@coat/cli/build/util/gather-extended-templates.js

TODO: See #3

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.gatherExtendedTemplates = gatherExtendedTemplates;
var _path = _interopRequireDefault(require("path"));
var _resolveFrom = _interopRequireDefault(require("resolve-from"));
var _importFrom = _interopRequireDefault(require("import-from"));
var _chalk = _interopRequireDefault(require("chalk"));
var _groupBy = _interopRequireDefault(require("lodash/groupBy"));
var _getStrictCoatManifest = require("../util/get-strict-coat-manifest");
var _coatManifest = require("../validation/coat-manifest");
var _validationIssue = require("../validation/validation-issue");
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function getTemplates(cwd, context, templateEntry) {
  let template;
  let templateConfig;

  // extends entries can either be plain strings or
  // tuples in the form of:
  // [templateName, templateConfig]
  if (Array.isArray(templateEntry)) {
    [template, templateConfig] = templateEntry;
  } else {
    template = templateEntry;
    // Default config is an empty object
    templateConfig = {};
  }

  // Resolve the directory of the current template to
  // use it as the cwd for child templates.
  //
  // Especially in workspaces node_modules might be deduped
  // or child templates might live in the node_modules folder
  // of the template itself
  const templateDir = _path.default.dirname((0, _resolveFrom.default)(cwd, template));

  // Import the current template
  // TODO: See #15
  // Better error message when template can't be imported
  // with a hint to install node_modules
  const templateManifestRawModule = (0, _importFrom.default)(cwd, template);

  // Check whether the template exported its manifest or manifest function
  // as a default export or directly using module.exports
  let templateManifestRaw;
  if (typeof templateManifestRawModule === "object" && templateManifestRawModule !== null && "__esModule" in templateManifestRawModule && "default" in templateManifestRawModule) {
    templateManifestRaw = templateManifestRawModule.default;
  } else {
    templateManifestRaw = templateManifestRawModule;
  }
  let resolvedTemplate;
  if (typeof templateManifestRaw === "function") {
    resolvedTemplate = templateManifestRaw({
      coatContext: context,
      config: templateConfig
    });
  } else {
    resolvedTemplate = templateManifestRaw;
  }

  // Validate template
  const issues = [...(0, _coatManifest.validateCoatManifest)(resolvedTemplate, {
    isTemplate: true
  })];
  if (issues.length) {
    const {
      [_validationIssue.ValidationIssueType.Error]: errors = [],
      [_validationIssue.ValidationIssueType.Warning]: warnings = []
    } = (0, _groupBy.default)(issues, "type");
    const validationMessages = [(0, _chalk.default)`The extended template "{green ${template}}" has the following issue${issues.length > 1 ? "s" : ""}:`, ""];
    validationMessages.push(...warnings.map(warning => (0, _chalk.default)`{inverse.yellow.bold  WARNING } - ${warning.message}`));
    validationMessages.push(...errors.map(error => (0, _chalk.default)`{inverse.red.bold  ERROR } - ${error.message}`));
    validationMessages.push("");
    console.error(validationMessages.join("\n"));
    if (errors.length) {
      throw new Error(`Validation of template "${template}" threw ${errors.length > 1 ? "errors" : "an error"}.`);
    }
  }
  const resolvedTemplateStrict = (0, _getStrictCoatManifest.getStrictCoatManifest)(resolvedTemplate);
  return [...resolvedTemplateStrict.extends.map(childTemplate => getTemplates(templateDir, context, childTemplate)), resolvedTemplateStrict];
}

/**
 * Retrieves and imports all templates that are extended by a coat project.
 *
 * If a single child template is used by multiple templates, it will be not be
 * deduped in order to preserve any logic that depends on the child template being
 * available before the parent template is evaluated.
 *
 * @param context The context of the current coat project
 */
function gatherExtendedTemplates(context) {
  const results = context.coatManifest.extends.map(template => getTemplates(context.cwd, context, template));

  // TODO: Temporary error due to TypeScript regression bug in 4.7
  // See https://github.com/microsoft/TypeScript/issues/49280
  // @ts-expect-error Temporary error due to TypeScript regression bug in 4.7
  return results.flat(Infinity);
}