@backstage/cli 0.28.0-next.1 → 0.28.0-next.2

package/dist/cjs/new-CEnFhTT-.cjs.js

@@ -1,1043 +0,0 @@
-'use strict';
-
-var os = require('os');
-var fs = require('fs-extra');
-var path = require('path');
-var chalk = require('chalk');
-var inquirer = require('inquirer');
-var camelCase = require('lodash/camelCase');
-var upperFirst = require('lodash/upperFirst');
-var index = require('./index-b1ouG3q6.cjs.js');
-var handlebars = require('handlebars');
-var ora = require('ora');
-var util = require('util');
-var recursive = require('recursive-readdir');
-var child_process = require('child_process');
-var errors = require('@backstage/errors');
-var yarn = require('./yarn-6FNAgNBK.cjs.js');
-require('minimatch');
-require('@manypkg/get-packages');
-require('./run-CpZGNJQr.cjs.js');
-var partition = require('lodash/partition');
-var cliNode = require('@backstage/cli-node');
-require('commander');
-require('semver');
-require('@backstage/cli-common');
-require('@yarnpkg/parsers');
-require('@yarnpkg/lockfile');
-
-function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
-
-var os__default = /*#__PURE__*/_interopDefaultCompat(os);
-var fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
-var path__default = /*#__PURE__*/_interopDefaultCompat(path);
-var chalk__default = /*#__PURE__*/_interopDefaultCompat(chalk);
-var inquirer__default = /*#__PURE__*/_interopDefaultCompat(inquirer);
-var camelCase__default = /*#__PURE__*/_interopDefaultCompat(camelCase);
-var upperFirst__default = /*#__PURE__*/_interopDefaultCompat(upperFirst);
-var handlebars__default = /*#__PURE__*/_interopDefaultCompat(handlebars);
-var ora__default = /*#__PURE__*/_interopDefaultCompat(ora);
-var recursive__default = /*#__PURE__*/_interopDefaultCompat(recursive);
-var partition__default = /*#__PURE__*/_interopDefaultCompat(partition);
-
-const TEAM_ID_RE = /^@[-\w]+\/[-\w]+$/;
-const USER_ID_RE = /^@[-\w]+$/;
-const EMAIL_RE = /^[^@]+@[-.\w]+\.[-\w]+$/i;
-const DEFAULT_OWNER = "@backstage/maintainers";
-async function getCodeownersFilePath(rootDir) {
-  const possiblePaths = [
-    path__default.default.join(rootDir, ".github", "CODEOWNERS"),
-    path__default.default.join(rootDir, ".gitlab", "CODEOWNERS"),
-    path__default.default.join(rootDir, "docs", "CODEOWNERS"),
-    path__default.default.join(rootDir, "CODEOWNERS")
-  ];
-  for (const p of possiblePaths) {
-    if (await fs__default.default.pathExists(p)) {
-      return p;
-    }
-  }
-  return void 0;
-}
-function isValidSingleOwnerId(id) {
-  if (!id || typeof id !== "string") {
-    return false;
-  }
-  return TEAM_ID_RE.test(id) || USER_ID_RE.test(id) || EMAIL_RE.test(id);
-}
-function parseOwnerIds(spaceSeparatedOwnerIds) {
-  if (!spaceSeparatedOwnerIds || typeof spaceSeparatedOwnerIds !== "string") {
-    return void 0;
-  }
-  const ids = spaceSeparatedOwnerIds.split(" ").filter(Boolean);
-  if (!ids.every(isValidSingleOwnerId)) {
-    return void 0;
-  }
-  return ids;
-}
-async function addCodeownersEntry(ownedPath, ownerStr, codeownersFilePath) {
-  const ownerIds = parseOwnerIds(ownerStr);
-  if (!ownerIds || ownerIds.length === 0) {
-    return false;
-  }
-  let filePath = codeownersFilePath;
-  if (!filePath) {
-    filePath = await getCodeownersFilePath(index.paths.targetRoot);
-    if (!filePath) {
-      return false;
-    }
-  }
-  const allLines = (await fs__default.default.readFile(filePath, "utf8")).split("\n");
-  const commentLines = [];
-  for (const line of allLines) {
-    if (line[0] !== "#") {
-      break;
-    }
-    commentLines.push(line);
-  }
-  const oldDeclarationEntries = allLines.filter((line) => line[0] !== "#").map((line) => line.split(/\s+/).filter(Boolean)).filter((tokens) => tokens.length >= 2).map((tokens) => ({
-    ownedPath: tokens[0],
-    ownerIds: tokens.slice(1)
-  }));
-  const newDeclarationEntries = oldDeclarationEntries.filter((entry) => entry.ownedPath !== "*").concat([{ ownedPath, ownerIds }]).sort((l1, l2) => l1.ownedPath.localeCompare(l2.ownedPath));
-  newDeclarationEntries.unshift({
-    ownedPath: "*",
-    ownerIds: [DEFAULT_OWNER]
-  });
-  const longestOwnedPath = newDeclarationEntries.reduce(
-    (length, entry) => Math.max(length, entry.ownedPath.length),
-    0
-  );
-  const newDeclarationLines = newDeclarationEntries.map((entry) => {
-    const entryPath = entry.ownedPath + " ".repeat(longestOwnedPath - entry.ownedPath.length);
-    return [entryPath, ...entry.ownerIds].join(" ");
-  });
-  const newLines = [...commentLines, "", ...newDeclarationLines, ""];
-  await fs__default.default.writeFile(filePath, newLines.join("\n"), "utf8");
-  return true;
-}
-
-function createFactory(config) {
-  return config;
-}
-
-const exec = util.promisify(child_process.exec);
-const TASK_NAME_MAX_LENGTH = 14;
-class Task {
-  static log(name = "") {
-    process.stderr.write(`${chalk__default.default.green(name)}
-`);
-  }
-  static error(message = "") {
-    process.stderr.write(`
-${chalk__default.default.red(message)}
-
-`);
-  }
-  static section(name) {
-    const title = chalk__default.default.green(`${name}:`);
-    process.stderr.write(`
- ${title}
-`);
-  }
-  static exit(code = 0) {
-    process.exit(code);
-  }
-  static async forItem(task, item, taskFunc) {
-    const paddedTask = chalk__default.default.green(task.padEnd(TASK_NAME_MAX_LENGTH));
-    const spinner = ora__default.default({
-      prefixText: chalk__default.default.green(`  ${paddedTask}${chalk__default.default.cyan(item)}`),
-      spinner: "arc",
-      color: "green"
-    }).start();
-    try {
-      const result = await taskFunc();
-      spinner.succeed();
-      return result;
-    } catch (error) {
-      spinner.fail();
-      throw error;
-    }
-  }
-  static async forCommand(command, options) {
-    try {
-      await Task.forItem("executing", command, async () => {
-        await exec(command, { cwd: options?.cwd });
-      });
-    } catch (error) {
-      errors.assertError(error);
-      if (error.stderr) {
-        process.stderr.write(error.stderr);
-      }
-      if (error.stdout) {
-        process.stdout.write(error.stdout);
-      }
-      if (options?.optional) {
-        Task.error(`Warning: Failed to execute command ${chalk__default.default.cyan(command)}`);
-      } else {
-        throw new Error(
-          `Failed to execute command '${chalk__default.default.cyan(command)}', ${error}`
-        );
-      }
-    }
-  }
-}
-async function templatingTask(templateDir, destinationDir, context, versionProvider, isMonoRepo) {
-  const files = await recursive__default.default(templateDir).catch((error) => {
-    throw new Error(`Failed to read template directory: ${error.message}`);
-  });
-  for (const file of files) {
-    const destinationFile = file.replace(templateDir, destinationDir);
-    await fs__default.default.ensureDir(path.dirname(destinationFile));
-    if (file.endsWith(".hbs")) {
-      await Task.forItem("templating", path.basename(file), async () => {
-        const destination = destinationFile.replace(/\.hbs$/, "");
-        const template = await fs__default.default.readFile(file);
-        const compiled = handlebars__default.default.compile(template.toString(), {
-          strict: true
-        });
-        const contents = compiled(
-          { name: path.basename(destination), ...context },
-          {
-            helpers: {
-              versionQuery(name, versionHint) {
-                return versionProvider(
-                  name,
-                  typeof versionHint === "string" ? versionHint : void 0
-                );
-              }
-            }
-          }
-        );
-        await fs__default.default.writeFile(destination, contents).catch((error) => {
-          throw new Error(
-            `Failed to create file: ${destination}: ${error.message}`
-          );
-        });
-      });
-    } else {
-      if (isMonoRepo && file.match("tsconfig.json")) {
-        continue;
-      }
-      await Task.forItem("copying", path.basename(file), async () => {
-        await fs__default.default.copyFile(file, destinationFile).catch((error) => {
-          const destination = destinationFile;
-          throw new Error(
-            `Failed to copy file to ${destination} : ${error.message}`
-          );
-        });
-      });
-    }
-  }
-}
-async function addPackageDependency(path, options) {
-  try {
-    const pkgJson = await fs__default.default.readJson(path);
-    const normalize = (obj) => {
-      if (Object.keys(obj).length === 0) {
-        return void 0;
-      }
-      return Object.fromEntries(
-        Object.keys(obj).sort().map((key) => [key, obj[key]])
-      );
-    };
-    pkgJson.dependencies = normalize({
-      ...pkgJson.dependencies,
-      ...options.dependencies
-    });
-    pkgJson.devDependencies = normalize({
-      ...pkgJson.devDependencies,
-      ...options.devDependencies
-    });
-    pkgJson.peerDependencies = normalize({
-      ...pkgJson.peerDependencies,
-      ...options.peerDependencies
-    });
-    await fs__default.default.writeJson(path, pkgJson, { spaces: 2 });
-  } catch (error) {
-    throw new Error(`Failed to add package dependencies, ${error}`);
-  }
-}
-async function addToBackend(name, options) {
-  if (await fs__default.default.pathExists(index.paths.resolveTargetRoot("packages/backend"))) {
-    await Task.forItem("backend", `adding ${options.type}`, async () => {
-      const backendFilePath = index.paths.resolveTargetRoot(
-        "packages/backend/src/index.ts"
-      );
-      if (!await fs__default.default.pathExists(backendFilePath)) {
-        return;
-      }
-      const content = await fs__default.default.readFile(backendFilePath, "utf8");
-      const lines = content.split("\n");
-      const backendAddLine = `backend.add(import('${name}'));`;
-      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(backendFilePath, newContent, "utf8");
-      }
-    });
-  }
-}
-
-function pluginIdPrompt() {
-  return {
-    type: "input",
-    name: "id",
-    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 ownerPrompt() {
-  return {
-    type: "input",
-    name: "owner",
-    message: "Enter an owner to add to CODEOWNERS [optional]",
-    when: (opts) => Boolean(opts.codeOwnersPath),
-    validate: (value) => {
-      if (!value) {
-        return true;
-      }
-      const ownerIds = 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;
-    }
-  };
-}
-
-async function executePluginPackageTemplate(ctx, options) {
-  const { targetDir } = options;
-  let lockfile;
-  try {
-    lockfile = await yarn.Lockfile.load(index.paths.resolveTargetRoot("yarn.lock"));
-  } catch {
-  }
-  Task.section("Checking Prerequisites");
-  const shortPluginDir = path.relative(index.paths.targetRoot, targetDir);
-  await Task.forItem("availability", shortPluginDir, async () => {
-    if (await fs__default.default.pathExists(targetDir)) {
-      throw new Error(
-        `A package with the same plugin ID already exists at ${chalk__default.default.cyan(
-          shortPluginDir
-        )}. Please try again with a different ID.`
-      );
-    }
-  });
-  const tempDir = await Task.forItem("creating", "temp dir", async () => {
-    return await ctx.createTemporaryDirectory("backstage-create");
-  });
-  Task.section("Executing Template");
-  await templatingTask(
-    index.paths.resolveOwn("templates", options.templateName),
-    tempDir,
-    options.values,
-    index.createPackageVersionProvider(lockfile),
-    ctx.isMonoRepo
-  );
-  const pkgJsonPath = path.resolve(tempDir, "package.json");
-  if (await fs__default.default.pathExists(pkgJsonPath)) {
-    const pkgJson = await fs__default.default.readJson(pkgJsonPath);
-    await fs__default.default.writeJson(pkgJsonPath, pkgJson, { spaces: 2 });
-  }
-  Task.section("Installing");
-  await Task.forItem("moving", shortPluginDir, async () => {
-    await fs__default.default.move(tempDir, targetDir).catch((error) => {
-      throw new Error(
-        `Failed to move package from ${tempDir} to ${targetDir}, ${error.message}`
-      );
-    });
-  });
-  ctx.markAsModified();
-}
-
-const resolvePackageName = (options) => {
-  const { baseName, scope, plugin } = options;
-  if (scope) {
-    if (plugin) {
-      const pluginName = scope.startsWith("backstage") ? "plugin" : "backstage-plugin";
-      return scope.includes("/") ? `@${scope}${pluginName}-${baseName}` : `@${scope}/${pluginName}-${baseName}`;
-    }
-    return scope.includes("/") ? `@${scope}${baseName}` : `@${scope}/${baseName}`;
-  }
-  return plugin ? `backstage-plugin-${baseName}` : baseName;
-};
-
-const frontendPlugin = createFactory({
-  name: "plugin",
-  description: "A new frontend plugin",
-  optionsDiscovery: async () => ({
-    codeOwnersPath: await getCodeownersFilePath(index.paths.targetRoot)
-  }),
-  optionsPrompts: [pluginIdPrompt(), ownerPrompt()],
-  async create(options, ctx) {
-    const { id } = options;
-    const name = resolvePackageName({
-      baseName: id,
-      scope: ctx.scope,
-      plugin: true
-    });
-    const extensionName = `${upperFirst__default.default(camelCase__default.default(id))}Page`;
-    Task.log();
-    Task.log(`Creating frontend plugin ${chalk__default.default.cyan(name)}`);
-    const targetDir = ctx.isMonoRepo ? index.paths.resolveTargetRoot("plugins", id) : index.paths.resolveTargetRoot(`backstage-plugin-${id}`);
-    await executePluginPackageTemplate(ctx, {
-      targetDir,
-      templateName: "default-plugin",
-      values: {
-        id,
-        name,
-        extensionName,
-        pluginVar: `${camelCase__default.default(id)}Plugin`,
-        pluginVersion: ctx.defaultVersion,
-        privatePackage: ctx.private,
-        npmRegistry: ctx.npmRegistry,
-        license: ctx.license
-      }
-    });
-    if (await fs__default.default.pathExists(index.paths.resolveTargetRoot("packages/app"))) {
-      await Task.forItem("app", "adding dependency", async () => {
-        await addPackageDependency(
-          index.paths.resolveTargetRoot("packages/app/package.json"),
-          {
-            dependencies: {
-              [name]: `^${ctx.defaultVersion}`
-            }
-          }
-        );
-      });
-      await Task.forItem("app", "adding import", async () => {
-        const pluginsFilePath = index.paths.resolveTargetRoot(
-          "packages/app/src/App.tsx"
-        );
-        if (!await fs__default.default.pathExists(pluginsFilePath)) {
-          return;
-        }
-        const content = await fs__default.default.readFile(pluginsFilePath, "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 importLine = `import { ${extensionName} } from '${name}';`;
-          if (!content.includes(importLine)) {
-            revLines.splice(lastImportIndex, 0, importLine);
-          }
-          const componentLine = `<Route path="/${id}" 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(pluginsFilePath, newContent, "utf8");
-        }
-      });
-    }
-    if (options.owner) {
-      await addCodeownersEntry(`/plugins/${id}`, options.owner);
-    }
-    await Task.forCommand("yarn install", { cwd: targetDir, optional: true });
-    await Task.forCommand("yarn lint --fix", {
-      cwd: targetDir,
-      optional: true
-    });
-  }
-});
-
-const backendPlugin = createFactory({
-  name: "backend-plugin",
-  description: "A new backend plugin",
-  optionsDiscovery: async () => ({
-    codeOwnersPath: await getCodeownersFilePath(index.paths.targetRoot)
-  }),
-  optionsPrompts: [pluginIdPrompt(), ownerPrompt()],
-  async create(options, ctx) {
-    const { id } = options;
-    const pluginId = `${id}-backend`;
-    const name = resolvePackageName({
-      baseName: pluginId,
-      scope: ctx.scope,
-      plugin: true
-    });
-    Task.log();
-    Task.log(`Creating backend plugin ${chalk__default.default.cyan(name)}`);
-    const targetDir = ctx.isMonoRepo ? index.paths.resolveTargetRoot("plugins", pluginId) : index.paths.resolveTargetRoot(`backstage-plugin-${pluginId}`);
-    await executePluginPackageTemplate(ctx, {
-      targetDir,
-      templateName: "default-backend-plugin",
-      values: {
-        id,
-        name,
-        pluginVar: `${camelCase__default.default(id)}Plugin`,
-        pluginVersion: ctx.defaultVersion,
-        privatePackage: ctx.private,
-        npmRegistry: ctx.npmRegistry,
-        license: ctx.license
-      }
-    });
-    if (await fs__default.default.pathExists(index.paths.resolveTargetRoot("packages/backend"))) {
-      await Task.forItem("backend", "adding dependency", async () => {
-        await addPackageDependency(
-          index.paths.resolveTargetRoot("packages/backend/package.json"),
-          {
-            dependencies: {
-              [name]: `^${ctx.defaultVersion}`
-            }
-          }
-        );
-      });
-    }
-    await addToBackend(name, {
-      type: "plugin"
-    });
-    if (options.owner) {
-      await addCodeownersEntry(`/plugins/${id}`, options.owner);
-    }
-    await Task.forCommand("yarn install", { cwd: targetDir, optional: true });
-    await Task.forCommand("yarn lint --fix", {
-      cwd: targetDir,
-      optional: true
-    });
-  }
-});
-
-const backendModule = createFactory({
-  name: "backend-module",
-  description: "A new backend module that extends an existing backend plugin with additional features",
-  optionsDiscovery: async () => ({
-    codeOwnersPath: await getCodeownersFilePath(index.paths.targetRoot)
-  }),
-  optionsPrompts: [pluginIdPrompt(), moduleIdIdPrompt(), ownerPrompt()],
-  async create(options, ctx) {
-    const { id: pluginId, moduleId } = options;
-    const dirName = `${pluginId}-backend-module-${moduleId}`;
-    const name = resolvePackageName({
-      baseName: dirName,
-      scope: ctx.scope,
-      plugin: true
-    });
-    Task.log();
-    Task.log(`Creating backend module ${chalk__default.default.cyan(name)}`);
-    const targetDir = ctx.isMonoRepo ? index.paths.resolveTargetRoot("plugins", dirName) : index.paths.resolveTargetRoot(`backstage-plugin-${dirName}`);
-    const moduleCamelCase = camelCase__default.default(moduleId);
-    const modulePascalCase = moduleCamelCase[0].toUpperCase() + moduleCamelCase.slice(1);
-    const moduleVar = `${camelCase__default.default(pluginId)}Module${modulePascalCase}`;
-    await executePluginPackageTemplate(ctx, {
-      targetDir,
-      templateName: "default-backend-module",
-      values: {
-        pluginId,
-        moduleId,
-        name,
-        moduleVar,
-        packageVersion: ctx.defaultVersion,
-        privatePackage: ctx.private,
-        npmRegistry: ctx.npmRegistry,
-        license: ctx.license
-      }
-    });
-    if (await fs__default.default.pathExists(index.paths.resolveTargetRoot("packages/backend"))) {
-      await Task.forItem("backend", "adding dependency", async () => {
-        await addPackageDependency(
-          index.paths.resolveTargetRoot("packages/backend/package.json"),
-          {
-            dependencies: {
-              [name]: `^${ctx.defaultVersion}`
-            }
-          }
-        );
-      });
-    }
-    await addToBackend(name, {
-      type: "module"
-    });
-    if (options.owner) {
-      await addCodeownersEntry(`/plugins/${dirName}`, options.owner);
-    }
-    await Task.forCommand("yarn install", { cwd: targetDir, optional: true });
-    await Task.forCommand("yarn lint --fix", {
-      cwd: targetDir,
-      optional: true
-    });
-  }
-});
-
-const nodeLibraryPackage = createFactory({
-  name: "node-library",
-  description: "A new node-library package, exporting shared functionality for backend plugins and modules",
-  optionsDiscovery: async () => ({
-    codeOwnersPath: await getCodeownersFilePath(index.paths.targetRoot)
-  }),
-  optionsPrompts: [pluginIdPrompt(), ownerPrompt()],
-  async create(options, ctx) {
-    const { id } = options;
-    const name = resolvePackageName({
-      baseName: id,
-      scope: ctx.scope,
-      plugin: false
-    });
-    Task.log();
-    Task.log(`Creating node-library package ${chalk__default.default.cyan(name)}`);
-    const targetDir = ctx.isMonoRepo ? index.paths.resolveTargetRoot("packages", id) : index.paths.resolveTargetRoot(`${id}`);
-    await executePluginPackageTemplate(ctx, {
-      targetDir,
-      templateName: "node-library-package",
-      values: {
-        id,
-        name,
-        pluginVersion: ctx.defaultVersion,
-        privatePackage: ctx.private,
-        npmRegistry: ctx.npmRegistry,
-        license: ctx.license
-      }
-    });
-    if (options.owner) {
-      await addCodeownersEntry(`/packages/${id}`, options.owner);
-    }
-    await Task.forCommand("yarn install", { cwd: targetDir, optional: true });
-    await Task.forCommand("yarn lint --fix", {
-      cwd: targetDir,
-      optional: true
-    });
-  }
-});
-
-const webLibraryPackage = createFactory({
-  name: "web-library",
-  description: "A new web-library package, exporting shared functionality for frontend plugins",
-  optionsDiscovery: async () => ({
-    codeOwnersPath: await getCodeownersFilePath(index.paths.targetRoot)
-  }),
-  optionsPrompts: [pluginIdPrompt(), ownerPrompt()],
-  async create(options, ctx) {
-    const { id } = options;
-    const name = resolvePackageName({
-      baseName: id,
-      scope: ctx.scope,
-      plugin: false
-    });
-    Task.log();
-    Task.log(`Creating web-library package ${chalk__default.default.cyan(name)}`);
-    const targetDir = ctx.isMonoRepo ? index.paths.resolveTargetRoot("packages", id) : index.paths.resolveTargetRoot(`${id}`);
-    await executePluginPackageTemplate(ctx, {
-      targetDir,
-      templateName: "web-library-package",
-      values: {
-        id,
-        name,
-        pluginVersion: ctx.defaultVersion,
-        privatePackage: ctx.private,
-        npmRegistry: ctx.npmRegistry,
-        license: ctx.license
-      }
-    });
-    if (options.owner) {
-      await addCodeownersEntry(`/packages/${id}`, options.owner);
-    }
-    await Task.forCommand("yarn install", { cwd: targetDir, optional: true });
-    await Task.forCommand("yarn lint --fix", {
-      cwd: targetDir,
-      optional: true
-    });
-  }
-});
-
-const pluginCommon = createFactory({
-  name: "plugin-common",
-  description: "A new isomorphic common plugin package",
-  optionsDiscovery: async () => ({
-    codeOwnersPath: await getCodeownersFilePath(index.paths.targetRoot)
-  }),
-  optionsPrompts: [pluginIdPrompt(), ownerPrompt()],
-  async create(options, ctx) {
-    const { id } = options;
-    const suffix = `${id}-common`;
-    const name = resolvePackageName({
-      baseName: suffix,
-      scope: ctx.scope,
-      plugin: true
-    });
-    Task.log();
-    Task.log(`Creating common plugin package ${chalk__default.default.cyan(name)}`);
-    const targetDir = ctx.isMonoRepo ? index.paths.resolveTargetRoot("plugins", suffix) : index.paths.resolveTargetRoot(`backstage-plugin-${suffix}`);
-    await executePluginPackageTemplate(ctx, {
-      targetDir,
-      templateName: "default-common-plugin-package",
-      values: {
-        id,
-        name,
-        privatePackage: ctx.private,
-        npmRegistry: ctx.npmRegistry,
-        pluginVersion: ctx.defaultVersion,
-        license: ctx.license
-      }
-    });
-    if (options.owner) {
-      await addCodeownersEntry(`/plugins/${suffix}`, options.owner);
-    }
-    await Task.forCommand("yarn install", { cwd: targetDir, optional: true });
-    await Task.forCommand("yarn lint --fix", {
-      cwd: targetDir,
-      optional: true
-    });
-  }
-});
-
-const pluginNode = createFactory({
-  name: "plugin-node",
-  description: "A new Node.js library plugin package",
-  optionsDiscovery: async () => ({
-    codeOwnersPath: await getCodeownersFilePath(index.paths.targetRoot)
-  }),
-  optionsPrompts: [pluginIdPrompt(), ownerPrompt()],
-  async create(options, ctx) {
-    const { id } = options;
-    const suffix = `${id}-node`;
-    const name = resolvePackageName({
-      baseName: suffix,
-      scope: ctx.scope,
-      plugin: true
-    });
-    Task.log();
-    Task.log(`Creating Node.js plugin library ${chalk__default.default.cyan(name)}`);
-    const targetDir = ctx.isMonoRepo ? index.paths.resolveTargetRoot("plugins", suffix) : index.paths.resolveTargetRoot(`backstage-plugin-${suffix}`);
-    await executePluginPackageTemplate(ctx, {
-      targetDir,
-      templateName: "default-node-plugin-package",
-      values: {
-        id,
-        name,
-        privatePackage: ctx.private,
-        npmRegistry: ctx.npmRegistry,
-        pluginVersion: ctx.defaultVersion,
-        license: ctx.license
-      }
-    });
-    if (options.owner) {
-      await addCodeownersEntry(`/plugins/${suffix}`, options.owner);
-    }
-    await Task.forCommand("yarn install", { cwd: targetDir, optional: true });
-    await Task.forCommand("yarn lint --fix", {
-      cwd: targetDir,
-      optional: true
-    });
-  }
-});
-
-const pluginWeb = createFactory({
-  name: "plugin-react",
-  description: "A new web library plugin package",
-  optionsDiscovery: async () => ({
-    codeOwnersPath: await getCodeownersFilePath(index.paths.targetRoot)
-  }),
-  optionsPrompts: [pluginIdPrompt(), ownerPrompt()],
-  async create(options, ctx) {
-    const { id } = options;
-    const suffix = `${id}-react`;
-    const name = resolvePackageName({
-      baseName: suffix,
-      scope: ctx.scope,
-      plugin: true
-    });
-    Task.log();
-    Task.log(`Creating web plugin library ${chalk__default.default.cyan(name)}`);
-    const targetDir = ctx.isMonoRepo ? index.paths.resolveTargetRoot("plugins", suffix) : index.paths.resolveTargetRoot(`backstage-plugin-${suffix}`);
-    await executePluginPackageTemplate(ctx, {
-      targetDir,
-      templateName: "default-react-plugin-package",
-      values: {
-        id,
-        name,
-        privatePackage: ctx.private,
-        npmRegistry: ctx.npmRegistry,
-        pluginVersion: ctx.defaultVersion,
-        license: ctx.license
-      }
-    });
-    if (options.owner) {
-      await addCodeownersEntry(`/plugins/${suffix}`, options.owner);
-    }
-    await Task.forCommand("yarn install", { cwd: targetDir, optional: true });
-    await Task.forCommand("yarn lint --fix", {
-      cwd: targetDir,
-      optional: true
-    });
-  }
-});
-
-const scaffolderModule = createFactory({
-  name: "scaffolder-module",
-  description: "An module exporting custom actions for @backstage/plugin-scaffolder-backend",
-  optionsDiscovery: async () => ({
-    codeOwnersPath: await getCodeownersFilePath(index.paths.targetRoot)
-  }),
-  optionsPrompts: [
-    {
-      type: "input",
-      name: "id",
-      message: "Enter the name of the module [required]",
-      validate: (value) => {
-        if (!value) {
-          return "Please enter the name of the module";
-        } else if (!/^[a-z0-9]+(-[a-z0-9]+)*$/.test(value)) {
-          return "Module names must be lowercase and contain only letters, digits, and dashes.";
-        }
-        return true;
-      }
-    },
-    ownerPrompt()
-  ],
-  async create(options, ctx) {
-    const { id } = options;
-    const slug = `scaffolder-backend-module-${id}`;
-    const name = resolvePackageName({
-      baseName: slug,
-      scope: ctx.scope,
-      plugin: true
-    });
-    Task.log();
-    Task.log(`Creating module ${chalk__default.default.cyan(name)}`);
-    const targetDir = ctx.isMonoRepo ? index.paths.resolveTargetRoot("plugins", slug) : index.paths.resolveTargetRoot(`backstage-plugin-${slug}`);
-    await executePluginPackageTemplate(ctx, {
-      targetDir,
-      templateName: "scaffolder-module",
-      values: {
-        id,
-        name,
-        privatePackage: ctx.private,
-        npmRegistry: ctx.npmRegistry,
-        pluginVersion: ctx.defaultVersion,
-        license: ctx.license
-      }
-    });
-    if (await fs__default.default.pathExists(index.paths.resolveTargetRoot("packages/backend"))) {
-      await Task.forItem("backend", "adding dependency", async () => {
-        await addPackageDependency(
-          index.paths.resolveTargetRoot("packages/backend/package.json"),
-          {
-            dependencies: {
-              [name]: `^${ctx.defaultVersion}`
-            }
-          }
-        );
-      });
-    }
-    await addToBackend(name, {
-      type: "module"
-    });
-    if (options.owner) {
-      await addCodeownersEntry(`/plugins/${slug}`, options.owner);
-    }
-    await Task.forCommand("yarn install", { cwd: targetDir, optional: true });
-    await Task.forCommand("yarn lint --fix", {
-      cwd: targetDir,
-      optional: true
-    });
-  }
-});
-
-var factories = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  backendModule: backendModule,
-  backendPlugin: backendPlugin,
-  frontendPlugin: frontendPlugin,
-  nodeLibraryPackage: nodeLibraryPackage,
-  pluginCommon: pluginCommon,
-  pluginNode: pluginNode,
-  pluginWeb: pluginWeb,
-  scaffolderModule: scaffolderModule,
-  webLibraryPackage: webLibraryPackage
-});
-
-function applyPromptMessageTransforms(prompt, transforms) {
-  return {
-    ...prompt,
-    message: prompt.message && (async (answers) => {
-      if (typeof prompt.message === "function") {
-        return transforms.message(await prompt.message(answers));
-      }
-      return transforms.message(await prompt.message);
-    }),
-    validate: prompt.validate && (async (...args) => {
-      const result = await prompt.validate(...args);
-      if (typeof result === "string") {
-        return transforms.error(result);
-      }
-      return result;
-    })
-  };
-}
-class FactoryRegistry {
-  static factoryMap = new Map(
-    Object.values(factories).map((factory) => [factory.name, factory])
-  );
-  static async interactiveSelect(preselected) {
-    let selected = preselected;
-    if (!selected) {
-      const answers = await inquirer__default.default.prompt([
-        {
-          type: "list",
-          name: "name",
-          message: "What do you want to create?",
-          choices: Array.from(this.factoryMap.values()).map((factory2) => ({
-            name: `${factory2.name} - ${factory2.description}`,
-            value: factory2.name
-          }))
-        }
-      ]);
-      selected = answers.name;
-    }
-    const factory = this.factoryMap.get(selected);
-    if (!factory) {
-      throw new Error(`Unknown selection '${selected}'`);
-    }
-    return factory;
-  }
-  static async populateOptions(factory, provided) {
-    let currentOptions = provided;
-    if (factory.optionsDiscovery) {
-      const discoveredOptions = await factory.optionsDiscovery();
-      currentOptions = {
-        ...currentOptions,
-        ...discoveredOptions
-      };
-    }
-    if (factory.optionsPrompts) {
-      const [hasAnswers, needsAnswers] = partition__default.default(
-        factory.optionsPrompts,
-        (option) => option.name in currentOptions
-      );
-      for (const option of hasAnswers) {
-        const value = provided[option.name];
-        if (option.validate) {
-          const result = option.validate(value);
-          if (result !== true) {
-            throw new Error(`Invalid option '${option.name}'. ${result}`);
-          }
-        }
-      }
-      currentOptions = await inquirer__default.default.prompt(
-        needsAnswers.map(
-          (option) => applyPromptMessageTransforms(option, {
-            message: chalk__default.default.blue,
-            error: chalk__default.default.red
-          })
-        ),
-        currentOptions
-      );
-    }
-    return currentOptions;
-  }
-}
-
-function parseOptions(optionStrings) {
-  const options = {};
-  for (const str of optionStrings) {
-    const [key] = str.split("=", 1);
-    const value = str.slice(key.length + 1);
-    if (!key || str[key.length] !== "=") {
-      throw new Error(
-        `Invalid option '${str}', must be of the format <key>=<value>`
-      );
-    }
-    options[key] = value;
-  }
-  return options;
-}
-var _new = async (opts) => {
-  const factory = await FactoryRegistry.interactiveSelect(opts.select);
-  const providedOptions = parseOptions(opts.option);
-  const options = await FactoryRegistry.populateOptions(
-    factory,
-    providedOptions
-  );
-  let defaultVersion = "0.1.0";
-  if (opts.baseVersion) {
-    defaultVersion = opts.baseVersion;
-  } else {
-    const lernaVersion = await fs__default.default.readJson(index.paths.resolveTargetRoot("lerna.json")).then((pkg) => pkg.version).catch(() => void 0);
-    if (lernaVersion) {
-      defaultVersion = lernaVersion;
-    }
-  }
-  const tempDirs = new Array();
-  async function createTemporaryDirectory(name) {
-    const dir = await fs__default.default.mkdtemp(path.join(os__default.default.tmpdir(), name));
-    tempDirs.push(dir);
-    return dir;
-  }
-  const license = opts.license ?? "Apache-2.0";
-  let modified = false;
-  try {
-    await factory.create(options, {
-      isMonoRepo: await cliNode.isMonoRepo(),
-      defaultVersion,
-      license,
-      scope: opts.scope?.replace(/^@/, ""),
-      npmRegistry: opts.npmRegistry,
-      private: Boolean(opts.private),
-      createTemporaryDirectory,
-      markAsModified() {
-        modified = true;
-      }
-    });
-    Task.log();
-    Task.log(`\u{1F389}  Successfully created ${factory.name}`);
-    Task.log();
-  } catch (error) {
-    errors.assertError(error);
-    Task.error(error.message);
-    if (modified) {
-      Task.log("It seems that something went wrong in the creation process \u{1F914}");
-      Task.log();
-      Task.log(
-        "We have left the changes that were made intact in case you want to"
-      );
-      Task.log(
-        "continue manually, but you can also revert the changes and try again."
-      );
-      Task.error(`\u{1F525}  Failed to create ${factory.name}!`);
-    }
-  } finally {
-    for (const dir of tempDirs) {
-      try {
-        await fs__default.default.remove(dir);
-      } catch (error) {
-        console.error(
-          `Failed to remove temporary directory '${dir}', ${error}`
-        );
-      }
-    }
-  }
-};
-
-exports.default = _new;
-//# sourceMappingURL=new-CEnFhTT-.cjs.js.map