@backstage/cli 0.36.0-next.1 → 0.36.0

package/dist/modules/new/lib/execution/installNewPackage.cjs.js

@@ -1,127 +0,0 @@
-'use strict';
-
-var fs = require('fs-extra');
-var upperFirst = require('lodash/upperFirst');
-var camelCase = require('lodash/camelCase');
-var cliCommon = require('@backstage/cli-common');
-var tasks = require('../tasks.cjs.js');
-
-function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
-
-var fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
-var upperFirst__default = /*#__PURE__*/_interopDefaultCompat(upperFirst);
-var camelCase__default = /*#__PURE__*/_interopDefaultCompat(camelCase);
-
-async function installNewPackage(input) {
-  switch (input.roleParams.role) {
-    case "web-library":
-    case "node-library":
-    case "common-library":
-    case "plugin-web-library":
-    case "plugin-node-library":
-    case "plugin-common-library":
-      return;
-    // No installation action needed for library packages
-    case "frontend-plugin":
-      await addDependency(input, "packages/app/package.json");
-      await tryAddFrontendLegacy(input);
-      return;
-    case "frontend-plugin-module":
-      await addDependency(input, "packages/app/package.json");
-      return;
-    case "backend-plugin":
-      await addDependency(input, "packages/backend/package.json");
-      await tryAddBackend(input);
-      return;
-    case "backend-plugin-module":
-      await addDependency(input, "packages/backend/package.json");
-      await tryAddBackend(input);
-      return;
-    default:
-      throw new Error(
-        `Unsupported role ${input.roleParams.role}`
-      );
-  }
-}
-async function addDependency(input, path) {
-  const pkgJsonPath = cliCommon.targetPaths.resolveRoot(path);
-  const pkgJson = await fs__default.default.readJson(pkgJsonPath).catch((error) => {
-    if (error.code === "ENOENT") {
-      return void 0;
-    }
-    throw error;
-  });
-  if (!pkgJson) {
-    return;
-  }
-  try {
-    pkgJson.dependencies = {
-      ...pkgJson.dependencies,
-      [input.packageName]: `workspace:^`
-    };
-    await fs__default.default.writeJson(path, pkgJson, { spaces: 2 });
-  } catch (error) {
-    throw new Error(`Failed to add package dependencies, ${error}`);
-  }
-}
-async function tryAddFrontendLegacy(input) {
-  const { roleParams } = input;
-  if (roleParams.role !== "frontend-plugin") {
-    throw new Error(
-      "add-frontend-legacy can only be used for frontend plugins"
-    );
-  }
-  const appDefinitionPath = cliCommon.targetPaths.resolveRoot("packages/app/src/App.tsx");
-  if (!await fs__default.default.pathExists(appDefinitionPath)) {
-    return;
-  }
-  await tasks.Task.forItem("app", "adding import", async () => {
-    const content = await fs__default.default.readFile(appDefinitionPath, "utf8");
-    const revLines = content.split("\n").reverse();
-    const lastImportIndex = revLines.findIndex(
-      (line) => line.match(/ from ("|').*("|')/)
-    );
-    const lastRouteIndex = revLines.findIndex(
-      (line) => line.match(/<\/FlatRoutes/)
-    );
-    if (lastImportIndex !== -1 && lastRouteIndex !== -1) {
-      const extensionName = upperFirst__default.default(`${camelCase__default.default(roleParams.pluginId)}Page`);
-      const importLine = `import { ${extensionName} } from '${input.packageName}';`;
-      if (!content.includes(importLine)) {
-        revLines.splice(lastImportIndex, 0, importLine);
-      }
-      const componentLine = `<Route path="/${roleParams.pluginId}" element={<${extensionName} />} />`;
-      if (!content.includes(componentLine)) {
-        const [indentation] = revLines[lastRouteIndex + 1].match(/^\s*/) ?? [];
-        revLines.splice(lastRouteIndex + 1, 0, indentation + componentLine);
-      }
-      const newContent = revLines.reverse().join("\n");
-      await fs__default.default.writeFile(appDefinitionPath, newContent, "utf8");
-    }
-  });
-}
-async function tryAddBackend(input) {
-  const backendIndexPath = cliCommon.targetPaths.resolveRoot(
-    "packages/backend/src/index.ts"
-  );
-  if (!await fs__default.default.pathExists(backendIndexPath)) {
-    return;
-  }
-  await tasks.Task.forItem("backend", `adding ${input.packageName}`, async () => {
-    const content = await fs__default.default.readFile(backendIndexPath, "utf8");
-    const lines = content.split("\n");
-    const backendAddLine = `backend.add(import('${input.packageName}'));`;
-    const backendStartIndex = lines.findIndex(
-      (line) => line.match(/backend.start/)
-    );
-    if (backendStartIndex !== -1) {
-      const [indentation] = lines[backendStartIndex].match(/^\s*/);
-      lines.splice(backendStartIndex, 0, `${indentation}${backendAddLine}`);
-      const newContent = lines.join("\n");
-      await fs__default.default.writeFile(backendIndexPath, newContent, "utf8");
-    }
-  });
-}
-
-exports.installNewPackage = installNewPackage;
-//# sourceMappingURL=installNewPackage.cjs.js.map

package/dist/modules/new/lib/execution/writeTemplateContents.cjs.js

@@ -1,116 +0,0 @@
-'use strict';
-
-var fs = require('fs-extra');
-var path = require('node:path');
-var errors = require('@backstage/errors');
-var cliNode = require('@backstage/cli-node');
-var PortableTemplater = require('./PortableTemplater.cjs.js');
-var cliCommon = require('@backstage/cli-common');
-
-function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
-
-var fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
-
-async function writeTemplateContents(template, input) {
-  const targetDir = cliCommon.targetPaths.resolveRoot(input.packagePath);
-  if (await fs__default.default.pathExists(targetDir)) {
-    throw new errors.InputError(`Package '${input.packagePath}' already exists`);
-  }
-  try {
-    const isMonoRepo = await cliNode.isMonoRepo();
-    const { role, ...roleValues } = input.roleParams;
-    const templater = await PortableTemplater.PortableTemplater.create({
-      values: {
-        ...roleValues,
-        packageName: input.packageName
-      },
-      templatedValues: template.values
-    });
-    if (!isMonoRepo) {
-      await fs__default.default.writeJson(
-        path.resolve(targetDir, "tsconfig.json"),
-        {
-          extends: "@backstage/cli/config/tsconfig.json",
-          include: ["src", "dev", "migrations"],
-          exclude: ["node_modules"],
-          compilerOptions: {
-            outDir: "dist-types",
-            rootDir: "."
-          }
-        },
-        { spaces: 2 }
-      );
-    }
-    for (const file of template.files) {
-      const destPath = path.resolve(targetDir, templater.template(file.path));
-      if (!cliCommon.isChildPath(targetDir, destPath)) {
-        throw new Error(
-          `Path ${destPath} is outside of target directory ${targetDir}`
-        );
-      }
-      await fs__default.default.ensureDir(path.dirname(destPath));
-      let content = file.syntax === "handlebars" ? templater.template(file.content) : file.content;
-      if (file.path === "package.json") {
-        try {
-          content = injectPackageJsonInput(input, content);
-        } catch (error) {
-          throw new errors.ForwardedError(
-            "Failed to transform templated package.json",
-            error
-          );
-        }
-      }
-      await fs__default.default.writeFile(destPath, content).catch((error) => {
-        throw new errors.ForwardedError(`Failed to copy file to ${destPath}`, error);
-      });
-    }
-    return { targetDir };
-  } catch (error) {
-    await fs__default.default.rm(targetDir, { recursive: true, force: true, maxRetries: 10 });
-    throw error;
-  }
-}
-function injectPackageJsonInput(input, content) {
-  const pkgJson = JSON.parse(content);
-  const toAdd = new Array();
-  if (pkgJson.version) {
-    pkgJson.version = input.version;
-  } else {
-    toAdd.push(["version", input.version]);
-  }
-  if (pkgJson.license) {
-    pkgJson.license = input.license;
-  } else {
-    toAdd.push(["license", input.license]);
-  }
-  if (input.private) {
-    if (pkgJson.private === false) {
-      pkgJson.private = true;
-    } else if (!pkgJson.private) {
-      toAdd.push(["private", true]);
-    }
-  } else {
-    delete pkgJson.private;
-  }
-  if (input.publishRegistry) {
-    if (pkgJson.publishConfig) {
-      pkgJson.publishConfig = {
-        ...pkgJson.publishConfig,
-        registry: input.publishRegistry
-      };
-    } else {
-      toAdd.push(["publishConfig", { registry: input.publishRegistry }]);
-    }
-  }
-  const entries = Object.entries(pkgJson);
-  const nameIndex = entries.findIndex(([name]) => name === "name");
-  if (nameIndex === -1) {
-    throw new Error("templated package.json does not contain a name field");
-  }
-  entries.splice(nameIndex + 1, 0, ...toAdd);
-  return JSON.stringify(Object.fromEntries(entries), null, 2);
-}
-
-exports.injectPackageJsonInput = injectPackageJsonInput;
-exports.writeTemplateContents = writeTemplateContents;
-//# sourceMappingURL=writeTemplateContents.cjs.js.map

package/dist/modules/new/lib/preparation/collectPortableTemplateInput.cjs.js

@@ -1,157 +0,0 @@
-'use strict';
-
-var inquirer = require('inquirer');
-var codeowners = require('../codeowners/codeowners.cjs.js');
-var cliCommon = require('@backstage/cli-common');
-var resolvePackageParams = require('./resolvePackageParams.cjs.js');
-
-function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
-
-var inquirer__default = /*#__PURE__*/_interopDefaultCompat(inquirer);
-
-async function collectPortableTemplateInput(options) {
-  const { config, template, prefilledParams } = options;
-  const codeOwnersFilePath = await codeowners.getCodeownersFilePath(cliCommon.targetPaths.rootDir);
-  const prompts = getPromptsForRole(template.role);
-  if (codeOwnersFilePath) {
-    prompts.push(ownerPrompt());
-  }
-  const deprecatedParams = {};
-  if (config.isUsingDefaultTemplates && prefilledParams.id) {
-    console.warn(
-      `DEPRECATION WARNING: The 'id' parameter is deprecated, use 'pluginId' instead`
-    );
-    deprecatedParams.pluginId = prefilledParams.id;
-  }
-  const parameters = {
-    ...template.values,
-    ...prefilledParams,
-    ...deprecatedParams
-  };
-  const needsAnswer = [];
-  const prefilledAnswers = {};
-  for (const prompt of prompts) {
-    if (prompt.name && parameters[prompt.name] !== void 0) {
-      prefilledAnswers[prompt.name] = parameters[prompt.name];
-    } else {
-      needsAnswer.push(prompt);
-    }
-  }
-  const promptAnswers = await inquirer__default.default.prompt(
-    needsAnswer
-  );
-  const answers = {
-    ...prefilledAnswers,
-    ...promptAnswers
-  };
-  const roleParams = {
-    role: template.role,
-    name: answers.name,
-    pluginId: answers.pluginId,
-    moduleId: answers.moduleId
-  };
-  const packageParams = resolvePackageParams.resolvePackageParams({
-    roleParams,
-    packagePrefix: config.packageNamePrefix,
-    pluginInfix: config.packageNamePluginInfix
-  });
-  return {
-    roleParams,
-    owner: answers.owner,
-    license: config.license,
-    version: config.version,
-    private: config.private,
-    publishRegistry: config.publishRegistry,
-    packageName: packageParams.packageName,
-    packagePath: packageParams.packagePath
-  };
-}
-function namePrompt() {
-  return {
-    type: "input",
-    name: "name",
-    message: "Enter the name of the package, without scope [required]",
-    validate: (value) => {
-      if (!value) {
-        return "Please enter the name of the package";
-      } else if (!/^[a-z0-9]+(-[a-z0-9]+)*$/.test(value)) {
-        return "Package names must be lowercase and contain only letters, digits, and dashes.";
-      }
-      return true;
-    }
-  };
-}
-function pluginIdPrompt() {
-  return {
-    type: "input",
-    name: "pluginId",
-    message: "Enter the ID of the plugin [required]",
-    validate: (value) => {
-      if (!value) {
-        return "Please enter the ID of the plugin";
-      } else if (!/^[a-z0-9]+(-[a-z0-9]+)*$/.test(value)) {
-        return "Plugin IDs must be lowercase and contain only letters, digits, and dashes.";
-      }
-      return true;
-    }
-  };
-}
-function moduleIdIdPrompt() {
-  return {
-    type: "input",
-    name: "moduleId",
-    message: "Enter the ID of the module [required]",
-    validate: (value) => {
-      if (!value) {
-        return "Please enter the ID of the module";
-      } else if (!/^[a-z0-9]+(-[a-z0-9]+)*$/.test(value)) {
-        return "Module IDs must be lowercase and contain only letters, digits, and dashes.";
-      }
-      return true;
-    }
-  };
-}
-function getPromptsForRole(role) {
-  switch (role) {
-    case "web-library":
-    case "node-library":
-    case "common-library":
-      return [namePrompt()];
-    case "plugin-web-library":
-    case "plugin-node-library":
-    case "plugin-common-library":
-    case "frontend-plugin":
-    case "backend-plugin":
-      return [pluginIdPrompt()];
-    case "frontend-plugin-module":
-    case "backend-plugin-module":
-      return [pluginIdPrompt(), moduleIdIdPrompt()];
-    default:
-      return [];
-  }
-}
-function ownerPrompt() {
-  return {
-    type: "input",
-    name: "owner",
-    message: "Enter an owner to add to CODEOWNERS [optional]",
-    validate: (value) => {
-      if (!value) {
-        return true;
-      }
-      const ownerIds = codeowners.parseOwnerIds(value);
-      if (!ownerIds) {
-        return "The owner must be a space separated list of team names (e.g. @org/team-name), usernames (e.g. @username), or the email addresses (e.g. user@example.com).";
-      }
-      return true;
-    }
-  };
-}
-
-exports.collectPortableTemplateInput = collectPortableTemplateInput;
-exports.getPromptsForRole = getPromptsForRole;
-exports.moduleIdIdPrompt = moduleIdIdPrompt;
-exports.namePrompt = namePrompt;
-exports.ownerPrompt = ownerPrompt;
-exports.pluginIdPrompt = pluginIdPrompt;
-//# sourceMappingURL=collectPortableTemplateInput.cjs.js.map

package/dist/modules/new/lib/preparation/loadPortableTemplate.cjs.js

@@ -1,81 +0,0 @@
-'use strict';
-
-var zod = require('zod');
-var fs = require('fs-extra');
-var recursiveReaddir = require('recursive-readdir');
-var path = require('node:path');
-var yaml = require('yaml');
-var cliCommon = require('@backstage/cli-common');
-var types = require('../types.cjs.js');
-var errors = require('@backstage/errors');
-var v3 = require('zod-validation-error/v3');
-
-function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
-
-var fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
-var recursiveReaddir__default = /*#__PURE__*/_interopDefaultCompat(recursiveReaddir);
-
-const templateDefinitionSchema = zod.z.object({
-  name: zod.z.string(),
-  role: zod.z.enum(types.TEMPLATE_ROLES),
-  description: zod.z.string().optional(),
-  values: zod.z.record(zod.z.string()).optional()
-}).strict();
-async function loadPortableTemplate(pointer) {
-  if (pointer.target.match(/https?:\/\//)) {
-    throw new Error("Remote templates are not supported yet");
-  }
-  const templateContent = await fs__default.default.readFile(cliCommon.targetPaths.resolveRoot(pointer.target), "utf-8").catch((error) => {
-    throw new errors.ForwardedError(
-      `Failed to load template definition from '${pointer.target}'`,
-      error
-    );
-  });
-  const rawTemplate = yaml.parse(templateContent);
-  const parsed = templateDefinitionSchema.safeParse(rawTemplate);
-  if (!parsed.success) {
-    throw new errors.ForwardedError(
-      `Invalid template definition at '${pointer.target}'`,
-      v3.fromZodError(parsed.error)
-    );
-  }
-  const { role, values = {} } = parsed.data;
-  const templatePath = path.resolve(path.dirname(pointer.target));
-  const filePaths = await recursiveReaddir__default.default(templatePath).catch((error) => {
-    throw new errors.ForwardedError(
-      `Failed to load template contents from '${templatePath}'`,
-      error
-    );
-  });
-  const loadedFiles = new Array();
-  for (const filePath of filePaths) {
-    const path$1 = path.relative(templatePath, filePath);
-    if (filePath === pointer.target) {
-      continue;
-    }
-    const content = await fs__default.default.readFile(filePath, "utf-8").catch((error) => {
-      throw new errors.ForwardedError(
-        `Failed to load file contents from '${path$1}'`,
-        error
-      );
-    });
-    if (path$1.endsWith(".hbs")) {
-      loadedFiles.push({
-        path: path$1.slice(0, -4),
-        content,
-        syntax: "handlebars"
-      });
-    } else {
-      loadedFiles.push({ path: path$1, content });
-    }
-  }
-  return {
-    name: pointer.name,
-    role,
-    files: loadedFiles,
-    values
-  };
-}
-
-exports.loadPortableTemplate = loadPortableTemplate;
-//# sourceMappingURL=loadPortableTemplate.cjs.js.map

package/dist/modules/new/lib/preparation/loadPortableTemplateConfig.cjs.js

@@ -1,132 +0,0 @@
-'use strict';
-
-var fs = require('fs-extra');
-var path = require('node:path');
-var cliCommon = require('@backstage/cli-common');
-var defaultTemplates = require('../defaultTemplates.cjs.js');
-var types = require('../types.cjs.js');
-var yaml = require('yaml');
-var zod = require('zod');
-var v3 = require('zod-validation-error/v3');
-var errors = require('@backstage/errors');
-
-function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
-
-var fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
-
-const defaults = {
-  license: "Apache-2.0",
-  version: "0.1.0",
-  private: true,
-  publishRegistry: void 0,
-  packageNamePrefix: "@internal/",
-  packageNamePluginInfix: "plugin-"
-};
-const newConfigSchema = zod.z.object({
-  templates: zod.z.array(zod.z.string()).optional(),
-  globals: zod.z.object({
-    license: zod.z.string().optional(),
-    version: zod.z.string().optional(),
-    private: zod.z.boolean().optional(),
-    publishRegistry: zod.z.string().optional(),
-    namePrefix: zod.z.string().optional(),
-    namePluginInfix: zod.z.string().optional()
-  }).optional()
-}).strict();
-const pkgJsonWithNewConfigSchema = zod.z.object({
-  backstage: zod.z.object({
-    cli: zod.z.object({
-      new: newConfigSchema.optional()
-    }).optional()
-  }).optional()
-});
-function computePackageNamePluginInfix(packageNamePrefix, namePluginInfix) {
-  const packageNamePluginInfix = namePluginInfix ?? (packageNamePrefix.includes("backstage") ? defaults.packageNamePluginInfix : "backstage-plugin-");
-  return {
-    packageNamePluginInfix
-  };
-}
-async function loadPortableTemplateConfig(options = {}) {
-  const { overrides = {} } = options;
-  const pkgPath = options.packagePath ?? cliCommon.targetPaths.resolveRoot("package.json");
-  const pkgJson = await fs__default.default.readJson(pkgPath);
-  const parsed = pkgJsonWithNewConfigSchema.safeParse(pkgJson);
-  if (!parsed.success) {
-    throw new errors.ForwardedError(
-      `Failed to load templating configuration from '${pkgPath}'`,
-      v3.fromZodError(parsed.error)
-    );
-  }
-  const config = parsed.data.backstage?.cli?.new;
-  const basePath = path.dirname(pkgPath);
-  const templatePointerEntries = await Promise.all(
-    (config?.templates ?? defaultTemplates.defaultTemplates).map(async (rawPointer) => {
-      try {
-        const templatePath = resolveLocalTemplatePath(rawPointer, basePath);
-        const pointer = await peekLocalTemplateDefinition(templatePath);
-        return { pointer, rawPointer };
-      } catch (error) {
-        throw new errors.ForwardedError(
-          `Failed to load template definition '${rawPointer}'`,
-          error
-        );
-      }
-    })
-  );
-  const templateNameConflicts = /* @__PURE__ */ new Map();
-  for (const { pointer, rawPointer } of templatePointerEntries) {
-    const conflict = templateNameConflicts.get(pointer.name);
-    if (conflict) {
-      throw new Error(
-        `Invalid template configuration, received conflicting template name '${pointer.name}' from '${conflict}' and '${rawPointer}'`
-      );
-    }
-    templateNameConflicts.set(pointer.name, rawPointer);
-  }
-  const packageNamePrefix = overrides.packageNamePrefix ?? config?.globals?.namePrefix ?? defaults.packageNamePrefix;
-  const { packageNamePluginInfix } = computePackageNamePluginInfix(
-    packageNamePrefix,
-    overrides.packageNamePluginInfix ?? config?.globals?.namePluginInfix
-  );
-  return {
-    isUsingDefaultTemplates: !config?.templates,
-    templatePointers: templatePointerEntries.map(({ pointer }) => pointer),
-    license: overrides.license ?? config?.globals?.license ?? defaults.license,
-    version: overrides.version ?? config?.globals?.version ?? defaults.version,
-    private: overrides.private ?? config?.globals?.private ?? defaults.private,
-    publishRegistry: overrides.publishRegistry ?? config?.globals?.publishRegistry ?? defaults.publishRegistry,
-    packageNamePrefix,
-    packageNamePluginInfix
-  };
-}
-function resolveLocalTemplatePath(pointer, basePath) {
-  if (path.isAbsolute(pointer)) {
-    throw new Error(`Template target may not be an absolute path`);
-  }
-  if (pointer.startsWith(".")) {
-    return path.resolve(basePath, pointer, types.TEMPLATE_FILE_NAME);
-  }
-  return require.resolve(`${pointer}/${types.TEMPLATE_FILE_NAME}`, {
-    paths: [basePath]
-  });
-}
-const partialTemplateDefinitionSchema = zod.z.object({
-  name: zod.z.string(),
-  description: zod.z.string().optional()
-});
-async function peekLocalTemplateDefinition(target) {
-  const content = await fs__default.default.readFile(target, "utf8");
-  const rawTemplate = yaml.parse(content);
-  const parsed = partialTemplateDefinitionSchema.safeParse(rawTemplate);
-  if (!parsed.success) {
-    throw v3.fromZodError(parsed.error);
-  }
-  return {
-    name: parsed.data.name,
-    description: parsed.data.description,
-    target
-  };
-}
-
-exports.loadPortableTemplateConfig = loadPortableTemplateConfig;
-//# sourceMappingURL=loadPortableTemplateConfig.cjs.js.map

package/dist/modules/new/lib/preparation/resolvePackageParams.cjs.js

@@ -1,40 +0,0 @@
-'use strict';
-
-var path = require('node:path');
-
-function resolvePackageParams(options) {
-  const baseName = getBaseNameForRole(options.roleParams);
-  const isPlugin = options.roleParams.role.includes("plugin");
-  const pluginInfix = isPlugin ? options.pluginInfix : "";
-  return {
-    packageName: `${options.packagePrefix}${pluginInfix}${baseName}`,
-    packagePath: path.join(isPlugin ? "plugins" : "packages", baseName)
-  };
-}
-function getBaseNameForRole(roleParams) {
-  switch (roleParams.role) {
-    case "web-library":
-    case "node-library":
-    case "common-library":
-      return roleParams.name;
-    case "plugin-web-library":
-      return `${roleParams.pluginId}-react`;
-    case "plugin-node-library":
-      return `${roleParams.pluginId}-node`;
-    case "plugin-common-library":
-      return `${roleParams.pluginId}-common`;
-    case "frontend-plugin":
-      return `${roleParams.pluginId}`;
-    case "frontend-plugin-module":
-      return `${roleParams.pluginId}-module-${roleParams.moduleId}`;
-    case "backend-plugin":
-      return `${roleParams.pluginId}-backend`;
-    case "backend-plugin-module":
-      return `${roleParams.pluginId}-backend-module-${roleParams.moduleId}`;
-    default:
-      throw new Error(`Unknown role ${roleParams.role}`);
-  }
-}
-
-exports.resolvePackageParams = resolvePackageParams;
-//# sourceMappingURL=resolvePackageParams.cjs.js.map

package/dist/modules/new/lib/preparation/selectTemplateInteractively.cjs.js

@@ -1,38 +0,0 @@
-'use strict';
-
-var inquirer = require('inquirer');
-
-function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
-
-var inquirer__default = /*#__PURE__*/_interopDefaultCompat(inquirer);
-
-async function selectTemplateInteractively(config, preselectedTemplateName) {
-  let selectedName = preselectedTemplateName;
-  if (config.isUsingDefaultTemplates && selectedName === "plugin") {
-    console.warn(
-      `DEPRECATION WARNING: The 'plugin' template is deprecated, use 'frontend-plugin' instead`
-    );
-    selectedName = "frontend-plugin";
-  }
-  if (!selectedName) {
-    const answers = await inquirer__default.default.prompt([
-      {
-        type: "list",
-        name: "name",
-        message: "What do you want to create?",
-        choices: config.templatePointers.map(
-          (t) => t.description ? { name: `${t.name} - ${t.description}`, value: t.name } : t.name
-        )
-      }
-    ]);
-    selectedName = answers.name;
-  }
-  const template = config.templatePointers.find((t) => t.name === selectedName);
-  if (!template) {
-    throw new Error(`Template '${selectedName}' not found`);
-  }
-  return template;
-}
-
-exports.selectTemplateInteractively = selectTemplateInteractively;
-//# sourceMappingURL=selectTemplateInteractively.cjs.js.map