@backstage/cli 0.28.0-next.1 → 0.28.0

package/dist/lib/new/factories/common/prompts.cjs.js

@@ -0,0 +1,57 @@
+'use strict';
+
+var codeowners = require('../../../codeowners/codeowners.cjs.js');
+
+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 = 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.moduleIdIdPrompt = moduleIdIdPrompt;
+exports.ownerPrompt = ownerPrompt;
+exports.pluginIdPrompt = pluginIdPrompt;
+//# sourceMappingURL=prompts.cjs.js.map

package/dist/lib/new/factories/common/tasks.cjs.js

@@ -0,0 +1,66 @@
+'use strict';
+
+var fs = require('fs-extra');
+var chalk = require('chalk');
+var path = require('path');
+var paths = require('../../../paths.cjs.js');
+var tasks = require('../../../tasks.cjs.js');
+var Lockfile = require('../../../versioning/Lockfile.cjs.js');
+require('minimatch');
+require('@manypkg/get-packages');
+require('../../../yarn.cjs.js');
+require('../../../run.cjs.js');
+var version = require('../../../version.cjs.js');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
+var chalk__default = /*#__PURE__*/_interopDefaultCompat(chalk);
+
+async function executePluginPackageTemplate(ctx, options) {
+  const { targetDir } = options;
+  let lockfile;
+  try {
+    lockfile = await Lockfile.Lockfile.load(paths.paths.resolveTargetRoot("yarn.lock"));
+  } catch {
+  }
+  tasks.Task.section("Checking Prerequisites");
+  const shortPluginDir = path.relative(paths.paths.targetRoot, targetDir);
+  await tasks.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 tasks.Task.forItem("creating", "temp dir", async () => {
+    return await ctx.createTemporaryDirectory("backstage-create");
+  });
+  tasks.Task.section("Executing Template");
+  await tasks.templatingTask(
+    paths.paths.resolveOwn("templates", options.templateName),
+    tempDir,
+    options.values,
+    version.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 });
+  }
+  tasks.Task.section("Installing");
+  await tasks.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();
+}
+
+exports.executePluginPackageTemplate = executePluginPackageTemplate;
+//# sourceMappingURL=tasks.cjs.js.map

package/dist/lib/new/factories/common/util.cjs.js

@@ -0,0 +1,16 @@
+'use strict';
+
+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;
+};
+
+exports.resolvePackageName = resolvePackageName;
+//# sourceMappingURL=util.cjs.js.map

package/dist/lib/new/factories/frontendPlugin.cjs.js

@@ -0,0 +1,107 @@
+'use strict';
+
+var fs = require('fs-extra');
+var chalk = require('chalk');
+var camelCase = require('lodash/camelCase');
+var upperFirst = require('lodash/upperFirst');
+var paths = require('../../paths.cjs.js');
+var codeowners = require('../../codeowners/codeowners.cjs.js');
+var types = require('../types.cjs.js');
+var tasks = require('../../tasks.cjs.js');
+var prompts = require('./common/prompts.cjs.js');
+var tasks$1 = require('./common/tasks.cjs.js');
+var util = require('./common/util.cjs.js');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
+var chalk__default = /*#__PURE__*/_interopDefaultCompat(chalk);
+var camelCase__default = /*#__PURE__*/_interopDefaultCompat(camelCase);
+var upperFirst__default = /*#__PURE__*/_interopDefaultCompat(upperFirst);
+
+const frontendPlugin = types.createFactory({
+  name: "plugin",
+  description: "A new frontend plugin",
+  optionsDiscovery: async () => ({
+    codeOwnersPath: await codeowners.getCodeownersFilePath(paths.paths.targetRoot)
+  }),
+  optionsPrompts: [prompts.pluginIdPrompt(), prompts.ownerPrompt()],
+  async create(options, ctx) {
+    const { id } = options;
+    const name = util.resolvePackageName({
+      baseName: id,
+      scope: ctx.scope,
+      plugin: true
+    });
+    const extensionName = `${upperFirst__default.default(camelCase__default.default(id))}Page`;
+    tasks.Task.log();
+    tasks.Task.log(`Creating frontend plugin ${chalk__default.default.cyan(name)}`);
+    const targetDir = ctx.isMonoRepo ? paths.paths.resolveTargetRoot("plugins", id) : paths.paths.resolveTargetRoot(`backstage-plugin-${id}`);
+    await tasks$1.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(paths.paths.resolveTargetRoot("packages/app"))) {
+      await tasks.Task.forItem("app", "adding dependency", async () => {
+        await tasks.addPackageDependency(
+          paths.paths.resolveTargetRoot("packages/app/package.json"),
+          {
+            dependencies: {
+              [name]: `^${ctx.defaultVersion}`
+            }
+          }
+        );
+      });
+      await tasks.Task.forItem("app", "adding import", async () => {
+        const pluginsFilePath = paths.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 codeowners.addCodeownersEntry(`/plugins/${id}`, options.owner);
+    }
+    await tasks.Task.forCommand("yarn install", { cwd: targetDir, optional: true });
+    await tasks.Task.forCommand("yarn lint --fix", {
+      cwd: targetDir,
+      optional: true
+    });
+  }
+});
+
+exports.frontendPlugin = frontendPlugin;
+//# sourceMappingURL=frontendPlugin.cjs.js.map

package/dist/lib/new/factories/index.cjs.js

@@ -0,0 +1,24 @@
+'use strict';
+
+var frontendPlugin = require('./frontendPlugin.cjs.js');
+var backendPlugin = require('./backendPlugin.cjs.js');
+var backendModule = require('./backendModule.cjs.js');
+var nodeLibraryPackage = require('./nodeLibraryPackage.cjs.js');
+var webLibraryPackage = require('./webLibraryPackage.cjs.js');
+var pluginCommon = require('./pluginCommon.cjs.js');
+var pluginNode = require('./pluginNode.cjs.js');
+var pluginWeb = require('./pluginWeb.cjs.js');
+var scaffolderModule = require('./scaffolderModule.cjs.js');
+
+
+
+exports.frontendPlugin = frontendPlugin.frontendPlugin;
+exports.backendPlugin = backendPlugin.backendPlugin;
+exports.backendModule = backendModule.backendModule;
+exports.nodeLibraryPackage = nodeLibraryPackage.nodeLibraryPackage;
+exports.webLibraryPackage = webLibraryPackage.webLibraryPackage;
+exports.pluginCommon = pluginCommon.pluginCommon;
+exports.pluginNode = pluginNode.pluginNode;
+exports.pluginWeb = pluginWeb.pluginWeb;
+exports.scaffolderModule = scaffolderModule.scaffolderModule;
+//# sourceMappingURL=index.cjs.js.map

package/dist/lib/new/factories/nodeLibraryPackage.cjs.js

@@ -0,0 +1,57 @@
+'use strict';
+
+var chalk = require('chalk');
+var paths = require('../../paths.cjs.js');
+var codeowners = require('../../codeowners/codeowners.cjs.js');
+var types = require('../types.cjs.js');
+var tasks = require('../../tasks.cjs.js');
+var prompts = require('./common/prompts.cjs.js');
+var tasks$1 = require('./common/tasks.cjs.js');
+var util = require('./common/util.cjs.js');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var chalk__default = /*#__PURE__*/_interopDefaultCompat(chalk);
+
+const nodeLibraryPackage = types.createFactory({
+  name: "node-library",
+  description: "A new node-library package, exporting shared functionality for backend plugins and modules",
+  optionsDiscovery: async () => ({
+    codeOwnersPath: await codeowners.getCodeownersFilePath(paths.paths.targetRoot)
+  }),
+  optionsPrompts: [prompts.pluginIdPrompt(), prompts.ownerPrompt()],
+  async create(options, ctx) {
+    const { id } = options;
+    const name = util.resolvePackageName({
+      baseName: id,
+      scope: ctx.scope,
+      plugin: false
+    });
+    tasks.Task.log();
+    tasks.Task.log(`Creating node-library package ${chalk__default.default.cyan(name)}`);
+    const targetDir = ctx.isMonoRepo ? paths.paths.resolveTargetRoot("packages", id) : paths.paths.resolveTargetRoot(`${id}`);
+    await tasks$1.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 codeowners.addCodeownersEntry(`/packages/${id}`, options.owner);
+    }
+    await tasks.Task.forCommand("yarn install", { cwd: targetDir, optional: true });
+    await tasks.Task.forCommand("yarn lint --fix", {
+      cwd: targetDir,
+      optional: true
+    });
+  }
+});
+
+exports.nodeLibraryPackage = nodeLibraryPackage;
+//# sourceMappingURL=nodeLibraryPackage.cjs.js.map

package/dist/lib/new/factories/pluginCommon.cjs.js

@@ -0,0 +1,58 @@
+'use strict';
+
+var chalk = require('chalk');
+var paths = require('../../paths.cjs.js');
+var codeowners = require('../../codeowners/codeowners.cjs.js');
+var types = require('../types.cjs.js');
+var tasks = require('../../tasks.cjs.js');
+var prompts = require('./common/prompts.cjs.js');
+var tasks$1 = require('./common/tasks.cjs.js');
+var util = require('./common/util.cjs.js');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var chalk__default = /*#__PURE__*/_interopDefaultCompat(chalk);
+
+const pluginCommon = types.createFactory({
+  name: "plugin-common",
+  description: "A new isomorphic common plugin package",
+  optionsDiscovery: async () => ({
+    codeOwnersPath: await codeowners.getCodeownersFilePath(paths.paths.targetRoot)
+  }),
+  optionsPrompts: [prompts.pluginIdPrompt(), prompts.ownerPrompt()],
+  async create(options, ctx) {
+    const { id } = options;
+    const suffix = `${id}-common`;
+    const name = util.resolvePackageName({
+      baseName: suffix,
+      scope: ctx.scope,
+      plugin: true
+    });
+    tasks.Task.log();
+    tasks.Task.log(`Creating common plugin package ${chalk__default.default.cyan(name)}`);
+    const targetDir = ctx.isMonoRepo ? paths.paths.resolveTargetRoot("plugins", suffix) : paths.paths.resolveTargetRoot(`backstage-plugin-${suffix}`);
+    await tasks$1.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 codeowners.addCodeownersEntry(`/plugins/${suffix}`, options.owner);
+    }
+    await tasks.Task.forCommand("yarn install", { cwd: targetDir, optional: true });
+    await tasks.Task.forCommand("yarn lint --fix", {
+      cwd: targetDir,
+      optional: true
+    });
+  }
+});
+
+exports.pluginCommon = pluginCommon;
+//# sourceMappingURL=pluginCommon.cjs.js.map

package/dist/lib/new/factories/pluginNode.cjs.js

@@ -0,0 +1,58 @@
+'use strict';
+
+var chalk = require('chalk');
+var paths = require('../../paths.cjs.js');
+var codeowners = require('../../codeowners/codeowners.cjs.js');
+var types = require('../types.cjs.js');
+var tasks = require('../../tasks.cjs.js');
+var prompts = require('./common/prompts.cjs.js');
+var tasks$1 = require('./common/tasks.cjs.js');
+var util = require('./common/util.cjs.js');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var chalk__default = /*#__PURE__*/_interopDefaultCompat(chalk);
+
+const pluginNode = types.createFactory({
+  name: "plugin-node",
+  description: "A new Node.js library plugin package",
+  optionsDiscovery: async () => ({
+    codeOwnersPath: await codeowners.getCodeownersFilePath(paths.paths.targetRoot)
+  }),
+  optionsPrompts: [prompts.pluginIdPrompt(), prompts.ownerPrompt()],
+  async create(options, ctx) {
+    const { id } = options;
+    const suffix = `${id}-node`;
+    const name = util.resolvePackageName({
+      baseName: suffix,
+      scope: ctx.scope,
+      plugin: true
+    });
+    tasks.Task.log();
+    tasks.Task.log(`Creating Node.js plugin library ${chalk__default.default.cyan(name)}`);
+    const targetDir = ctx.isMonoRepo ? paths.paths.resolveTargetRoot("plugins", suffix) : paths.paths.resolveTargetRoot(`backstage-plugin-${suffix}`);
+    await tasks$1.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 codeowners.addCodeownersEntry(`/plugins/${suffix}`, options.owner);
+    }
+    await tasks.Task.forCommand("yarn install", { cwd: targetDir, optional: true });
+    await tasks.Task.forCommand("yarn lint --fix", {
+      cwd: targetDir,
+      optional: true
+    });
+  }
+});
+
+exports.pluginNode = pluginNode;
+//# sourceMappingURL=pluginNode.cjs.js.map

package/dist/lib/new/factories/pluginWeb.cjs.js

@@ -0,0 +1,58 @@
+'use strict';
+
+var chalk = require('chalk');
+var paths = require('../../paths.cjs.js');
+var codeowners = require('../../codeowners/codeowners.cjs.js');
+var types = require('../types.cjs.js');
+var tasks = require('../../tasks.cjs.js');
+var prompts = require('./common/prompts.cjs.js');
+var tasks$1 = require('./common/tasks.cjs.js');
+var util = require('./common/util.cjs.js');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var chalk__default = /*#__PURE__*/_interopDefaultCompat(chalk);
+
+const pluginWeb = types.createFactory({
+  name: "plugin-react",
+  description: "A new web library plugin package",
+  optionsDiscovery: async () => ({
+    codeOwnersPath: await codeowners.getCodeownersFilePath(paths.paths.targetRoot)
+  }),
+  optionsPrompts: [prompts.pluginIdPrompt(), prompts.ownerPrompt()],
+  async create(options, ctx) {
+    const { id } = options;
+    const suffix = `${id}-react`;
+    const name = util.resolvePackageName({
+      baseName: suffix,
+      scope: ctx.scope,
+      plugin: true
+    });
+    tasks.Task.log();
+    tasks.Task.log(`Creating web plugin library ${chalk__default.default.cyan(name)}`);
+    const targetDir = ctx.isMonoRepo ? paths.paths.resolveTargetRoot("plugins", suffix) : paths.paths.resolveTargetRoot(`backstage-plugin-${suffix}`);
+    await tasks$1.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 codeowners.addCodeownersEntry(`/plugins/${suffix}`, options.owner);
+    }
+    await tasks.Task.forCommand("yarn install", { cwd: targetDir, optional: true });
+    await tasks.Task.forCommand("yarn lint --fix", {
+      cwd: targetDir,
+      optional: true
+    });
+  }
+});
+
+exports.pluginWeb = pluginWeb;
+//# sourceMappingURL=pluginWeb.cjs.js.map

package/dist/lib/new/factories/scaffolderModule.cjs.js

@@ -0,0 +1,90 @@
+'use strict';
+
+var fs = require('fs-extra');
+var chalk = require('chalk');
+var paths = require('../../paths.cjs.js');
+var codeowners = require('../../codeowners/codeowners.cjs.js');
+var types = require('../types.cjs.js');
+var tasks = require('../../tasks.cjs.js');
+var prompts = require('./common/prompts.cjs.js');
+var tasks$1 = require('./common/tasks.cjs.js');
+var util = require('./common/util.cjs.js');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
+var chalk__default = /*#__PURE__*/_interopDefaultCompat(chalk);
+
+const scaffolderModule = types.createFactory({
+  name: "scaffolder-module",
+  description: "An module exporting custom actions for @backstage/plugin-scaffolder-backend",
+  optionsDiscovery: async () => ({
+    codeOwnersPath: await codeowners.getCodeownersFilePath(paths.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;
+      }
+    },
+    prompts.ownerPrompt()
+  ],
+  async create(options, ctx) {
+    const { id } = options;
+    const slug = `scaffolder-backend-module-${id}`;
+    const name = util.resolvePackageName({
+      baseName: slug,
+      scope: ctx.scope,
+      plugin: true
+    });
+    tasks.Task.log();
+    tasks.Task.log(`Creating module ${chalk__default.default.cyan(name)}`);
+    const targetDir = ctx.isMonoRepo ? paths.paths.resolveTargetRoot("plugins", slug) : paths.paths.resolveTargetRoot(`backstage-plugin-${slug}`);
+    await tasks$1.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(paths.paths.resolveTargetRoot("packages/backend"))) {
+      await tasks.Task.forItem("backend", "adding dependency", async () => {
+        await tasks.addPackageDependency(
+          paths.paths.resolveTargetRoot("packages/backend/package.json"),
+          {
+            dependencies: {
+              [name]: `^${ctx.defaultVersion}`
+            }
+          }
+        );
+      });
+    }
+    await tasks.addToBackend(name, {
+      type: "module"
+    });
+    if (options.owner) {
+      await codeowners.addCodeownersEntry(`/plugins/${slug}`, options.owner);
+    }
+    await tasks.Task.forCommand("yarn install", { cwd: targetDir, optional: true });
+    await tasks.Task.forCommand("yarn lint --fix", {
+      cwd: targetDir,
+      optional: true
+    });
+  }
+});
+
+exports.scaffolderModule = scaffolderModule;
+//# sourceMappingURL=scaffolderModule.cjs.js.map

package/dist/lib/new/factories/webLibraryPackage.cjs.js

@@ -0,0 +1,57 @@
+'use strict';
+
+var chalk = require('chalk');
+var paths = require('../../paths.cjs.js');
+var codeowners = require('../../codeowners/codeowners.cjs.js');
+var types = require('../types.cjs.js');
+var tasks = require('../../tasks.cjs.js');
+var prompts = require('./common/prompts.cjs.js');
+var tasks$1 = require('./common/tasks.cjs.js');
+var util = require('./common/util.cjs.js');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var chalk__default = /*#__PURE__*/_interopDefaultCompat(chalk);
+
+const webLibraryPackage = types.createFactory({
+  name: "web-library",
+  description: "A new web-library package, exporting shared functionality for frontend plugins",
+  optionsDiscovery: async () => ({
+    codeOwnersPath: await codeowners.getCodeownersFilePath(paths.paths.targetRoot)
+  }),
+  optionsPrompts: [prompts.pluginIdPrompt(), prompts.ownerPrompt()],
+  async create(options, ctx) {
+    const { id } = options;
+    const name = util.resolvePackageName({
+      baseName: id,
+      scope: ctx.scope,
+      plugin: false
+    });
+    tasks.Task.log();
+    tasks.Task.log(`Creating web-library package ${chalk__default.default.cyan(name)}`);
+    const targetDir = ctx.isMonoRepo ? paths.paths.resolveTargetRoot("packages", id) : paths.paths.resolveTargetRoot(`${id}`);
+    await tasks$1.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 codeowners.addCodeownersEntry(`/packages/${id}`, options.owner);
+    }
+    await tasks.Task.forCommand("yarn install", { cwd: targetDir, optional: true });
+    await tasks.Task.forCommand("yarn lint --fix", {
+      cwd: targetDir,
+      optional: true
+    });
+  }
+});
+
+exports.webLibraryPackage = webLibraryPackage;
+//# sourceMappingURL=webLibraryPackage.cjs.js.map

package/dist/lib/new/types.cjs.js

@@ -0,0 +1,8 @@
+'use strict';
+
+function createFactory(config) {
+  return config;
+}
+
+exports.createFactory = createFactory;
+//# sourceMappingURL=types.cjs.js.map