@backstage/cli 0.27.1 → 0.28.0-next.1

package/dist/cjs/install-BMA3RshT.cjs.js

@@ -1,268 +0,0 @@
-'use strict';
-
-var fs = require('fs-extra');
-require('@yarnpkg/parsers');
-require('@yarnpkg/lockfile');
-var packages = require('./packages-Cuogjl7j.cjs.js');
-var index = require('./index-DmUbBCFk.cjs.js');
-var chalk = require('chalk');
-var sortBy = require('lodash/sortBy');
-var groupBy = require('lodash/groupBy');
-var run = require('./run-CSt1n0F1.cjs.js');
-require('minimatch');
-require('@manypkg/get-packages');
-require('./yarn-Ukl9MOS0.cjs.js');
-require('@backstage/errors');
-require('child_process');
-require('util');
-require('commander');
-require('semver');
-require('@backstage/cli-common');
-
-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 sortBy__default = /*#__PURE__*/_interopDefaultCompat(sortBy);
-var groupBy__default = /*#__PURE__*/_interopDefaultCompat(groupBy);
-
-function createStepDefinition(config) {
-  return config;
-}
-
-class AppRouteStep {
-  constructor(data) {
-    this.data = data;
-  }
-  async run() {
-    const { path, element, packageName } = this.data;
-    const appTsxPath = index.paths.resolveTargetRoot("packages/app/src/App.tsx");
-    const contents = await fs__default.default.readFile(appTsxPath, "utf-8");
-    let failed = false;
-    const contentsWithRoute = contents.replace(
-      /(\s*)<\/FlatRoutes>/,
-      `$1  <Route path="${path}" element={${element}} />$1</FlatRoutes>`
-    );
-    if (contentsWithRoute === contents) {
-      failed = true;
-    }
-    const componentName = element.match(/[A-Za-z0-9]+/)?.[0];
-    if (!componentName) {
-      throw new Error(`Could not find component name in ${element}`);
-    }
-    const contentsWithImport = contentsWithRoute.replace(
-      /^import /m,
-      `import { ${componentName} } from '${packageName}';
-import `
-    );
-    if (contentsWithImport === contentsWithRoute) {
-      failed = true;
-    }
-    if (failed) {
-      console.log(
-        "Failed to automatically add a route to package/app/src/App.tsx"
-      );
-      console.log(`Action needed, add the following:`);
-      console.log(`1. import { ${componentName} } from '${packageName}';`);
-      console.log(`2. <Route path="${path}" element={${element}} />`);
-    } else {
-      await fs__default.default.writeFile(appTsxPath, contentsWithImport);
-    }
-  }
-}
-const appRoute = createStepDefinition({
-  type: "app-route",
-  deserialize(obj, pkg) {
-    const { path, element } = obj;
-    if (!path || typeof path !== "string") {
-      throw new Error("Invalid install step, 'path' must be a string");
-    }
-    if (!element || typeof element !== "string") {
-      throw new Error("Invalid install step, 'element' must be a string");
-    }
-    return new AppRouteStep({ path, element, packageName: pkg.name });
-  },
-  create(data) {
-    return new AppRouteStep(data);
-  }
-});
-
-class DependenciesStep {
-  constructor(data) {
-    this.data = data;
-  }
-  async run() {
-    const { dependencies: dependencies2 } = this.data;
-    const byTarget = groupBy__default.default(dependencies2, "target");
-    for (const [target, deps] of Object.entries(byTarget)) {
-      const pkgPath = index.paths.resolveTargetRoot(target, "package.json");
-      const pkgJson = await fs__default.default.readJson(pkgPath);
-      const depTypes = /* @__PURE__ */ new Set();
-      for (const dep of deps) {
-        depTypes.add(dep.type);
-        pkgJson[dep.type][dep.name] = dep.query;
-      }
-      for (const depType of depTypes) {
-        pkgJson[depType] = Object.fromEntries(
-          sortBy__default.default(Object.entries(pkgJson[depType]), ([key]) => key)
-        );
-      }
-      await fs__default.default.writeJson(pkgPath, pkgJson, { spaces: 2 });
-    }
-    console.log();
-    console.log(
-      `Running ${chalk__default.default.blue("yarn install")} to install new versions`
-    );
-    console.log();
-    await run.run("yarn", ["install"]);
-  }
-}
-const dependencies = createStepDefinition({
-  type: "dependencies",
-  deserialize() {
-    throw new Error("The dependency step may not be defined in JSON");
-  },
-  create(data) {
-    return new DependenciesStep(data);
-  }
-});
-
-class MessageStep {
-  constructor(data) {
-    this.data = data;
-  }
-  async run() {
-    console.log(this.data.message);
-  }
-}
-const message = createStepDefinition({
-  type: "message",
-  deserialize(obj) {
-    const { message: msg } = obj;
-    if (!msg || typeof msg !== "string" && !Array.isArray(msg)) {
-      throw new Error(
-        "Invalid install step, 'message' must be a string or array"
-      );
-    }
-    return new MessageStep({ message: [msg].flat().join("") });
-  },
-  create(data) {
-    return new MessageStep(data);
-  }
-});
-
-var stepDefinitionMap = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  appRoute: appRoute,
-  dependencies: dependencies,
-  message: message
-});
-
-const stepDefinitions = Object.values(stepDefinitionMap);
-async function fetchPluginPackage(id) {
-  const searchNames = [`@backstage/plugin-${id}`, `backstage-plugin-${id}`, id];
-  for (const name of searchNames) {
-    try {
-      const packageInfo = await packages.fetchPackageInfo(
-        name
-      );
-      return packageInfo;
-    } catch (error) {
-      if (error.name !== "NotFoundError") {
-        throw error;
-      }
-    }
-  }
-  throw new index.NotFoundError(
-    `No matching package found for '${id}', tried ${searchNames.join(", ")}`
-  );
-}
-class PluginInstaller {
-  constructor(steps) {
-    this.steps = steps;
-  }
-  static async resolveSteps(pkg, versionToInstall) {
-    const steps = [];
-    const dependencies$1 = [];
-    dependencies$1.push({
-      target: "packages/app",
-      type: "dependencies",
-      name: pkg.name,
-      query: versionToInstall || `^${pkg.version}`
-    });
-    steps.push({
-      type: "dependencies",
-      step: dependencies.create({ dependencies: dependencies$1 })
-    });
-    for (const step of pkg.experimentalInstallationRecipe?.steps ?? []) {
-      const { type } = step;
-      const definition = stepDefinitions.find((d) => d.type === type);
-      if (definition) {
-        steps.push({
-          type,
-          step: definition.deserialize(step, pkg)
-        });
-      } else {
-        throw new Error(`Unsupported step type: ${type}`);
-      }
-    }
-    return steps;
-  }
-  async run() {
-    for (const { type, step } of this.steps) {
-      console.log(`Running step ${type}`);
-      await step.run();
-    }
-  }
-}
-async function installPluginAndPeerPlugins(pkg) {
-  const pluginDeps = /* @__PURE__ */ new Map();
-  pluginDeps.set(pkg.name, { pkg });
-  await loadPeerPluginDeps(pkg, pluginDeps);
-  console.log(`Installing ${pkg.name} AND any peer plugin dependencies.`);
-  for (const [_pluginDepName, pluginDep] of pluginDeps.entries()) {
-    const { pkg: pluginDepPkg, versionToInstall } = pluginDep;
-    console.log(
-      `Installing plugin: ${pluginDepPkg.name}: ${versionToInstall || pluginDepPkg.version}`
-    );
-    const steps = await PluginInstaller.resolveSteps(
-      pluginDepPkg,
-      versionToInstall
-    );
-    const installer = new PluginInstaller(steps);
-    await installer.run();
-  }
-}
-async function loadPackageJson(plugin) {
-  if (plugin.endsWith("package.json")) {
-    return await fs__default.default.readJson(plugin);
-  }
-  return await fetchPluginPackage(plugin);
-}
-async function loadPeerPluginDeps(pkg, pluginMap) {
-  for (const [pluginId, pluginVersion] of Object.entries(
-    pkg.experimentalInstallationRecipe?.peerPluginDependencies ?? {}
-  )) {
-    const depPkg = await loadPackageJson(pluginId);
-    if (!pluginMap.get(depPkg.name)) {
-      pluginMap.set(depPkg.name, {
-        pkg: depPkg,
-        versionToInstall: pluginVersion
-      });
-      await loadPeerPluginDeps(depPkg, pluginMap);
-    }
-  }
-}
-var install = async (pluginId, cmd) => {
-  const from = pluginId || cmd?.from;
-  if (!from) {
-    throw new Error(
-      "Missing both <plugin-id> or a package.json file path in the --from flag."
-    );
-  }
-  const pkg = await loadPackageJson(from);
-  await installPluginAndPeerPlugins(pkg);
-};
-
-exports.default = install;
-//# sourceMappingURL=install-BMA3RshT.cjs.js.map

package/dist/cjs/lint-Dkx_fBkS.cjs.js

@@ -1,10 +0,0 @@
-'use strict';
-
-var lint = async () => {
-  throw new Error(
-    "This command has been removed, please consider alternatives such as `yarn dedupe` instead."
-  );
-};
-
-exports.default = lint;
-//# sourceMappingURL=lint-Dkx_fBkS.cjs.js.map

package/dist/cjs/packages-Cuogjl7j.cjs.js

@@ -1,75 +0,0 @@
-'use strict';
-
-var minimatch = require('minimatch');
-var getPackages = require('@manypkg/get-packages');
-var index = require('./index-DmUbBCFk.cjs.js');
-var yarn = require('./yarn-Ukl9MOS0.cjs.js');
-var run = require('./run-CSt1n0F1.cjs.js');
-
-const DEP_TYPES = [
-  "dependencies",
-  "devDependencies",
-  "peerDependencies",
-  "optionalDependencies"
-];
-async function fetchPackageInfo(name) {
-  const yarnVersion = await yarn.detectYarnVersion();
-  const cmd = yarnVersion === "classic" ? ["info"] : ["npm", "info"];
-  try {
-    const { stdout: output } = await run.execFile(
-      "yarn",
-      [...cmd, "--json", name],
-      { shell: true }
-    );
-    if (!output) {
-      throw new index.NotFoundError(
-        `No package information found for package ${name}`
-      );
-    }
-    if (yarnVersion === "berry") {
-      return JSON.parse(output);
-    }
-    const info = JSON.parse(output);
-    if (info.type !== "inspect") {
-      throw new Error(`Received unknown yarn info for ${name}, ${output}`);
-    }
-    return info.data;
-  } catch (error) {
-    if (yarnVersion === "classic") {
-      throw error;
-    }
-    if (error?.stdout.includes("Response Code: 404")) {
-      throw new index.NotFoundError(
-        `No package information found for package ${name}`
-      );
-    }
-    throw error;
-  }
-}
-async function mapDependencies(targetDir, pattern) {
-  const { packages, root } = await getPackages.getPackages(targetDir);
-  packages.push(root);
-  const dependencyMap = /* @__PURE__ */ new Map();
-  for (const pkg of packages) {
-    const deps = DEP_TYPES.flatMap(
-      (t) => Object.entries(pkg.packageJson[t] ?? {})
-    );
-    for (const [name, range] of deps) {
-      if (minimatch.minimatch(name, pattern)) {
-        dependencyMap.set(
-          name,
-          (dependencyMap.get(name) ?? []).concat({
-            range,
-            name: pkg.packageJson.name,
-            location: pkg.dir
-          })
-        );
-      }
-    }
-  }
-  return dependencyMap;
-}
-
-exports.fetchPackageInfo = fetchPackageInfo;
-exports.mapDependencies = mapDependencies;
-//# sourceMappingURL=packages-Cuogjl7j.cjs.js.map

package/dist/cjs/tasks-DtAiMv5G.cjs.js

@@ -1,188 +0,0 @@
-'use strict';
-
-var chalk = require('chalk');
-var fs = require('fs-extra');
-var handlebars = require('handlebars');
-var ora = require('ora');
-var util = require('util');
-var path = require('path');
-var recursive = require('recursive-readdir');
-var child_process = require('child_process');
-var errors = require('@backstage/errors');
-var index = require('./index-DmUbBCFk.cjs.js');
-
-function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
-
-var chalk__default = /*#__PURE__*/_interopDefaultCompat(chalk);
-var fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
-var handlebars__default = /*#__PURE__*/_interopDefaultCompat(handlebars);
-var ora__default = /*#__PURE__*/_interopDefaultCompat(ora);
-var recursive__default = /*#__PURE__*/_interopDefaultCompat(recursive);
-
-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");
-      }
-    });
-  }
-}
-
-exports.Task = Task;
-exports.addPackageDependency = addPackageDependency;
-exports.addToBackend = addToBackend;
-exports.templatingTask = templatingTask;
-//# sourceMappingURL=tasks-DtAiMv5G.cjs.js.map

package/dist/cjs/yarn-Ukl9MOS0.cjs.js

@@ -1,34 +0,0 @@
-'use strict';
-
-var errors = require('@backstage/errors');
-var child_process = require('child_process');
-var util = require('util');
-
-const execFile = util.promisify(child_process.execFile);
-const versions = /* @__PURE__ */ new Map();
-function detectYarnVersion(dir) {
-  const cwd = process.cwd();
-  if (versions.has(cwd)) {
-    return versions.get(cwd);
-  }
-  const promise = Promise.resolve().then(async () => {
-    try {
-      const { stdout } = await execFile("yarn", ["--version"], {
-        shell: true,
-        cwd
-      });
-      return stdout.trim().startsWith("1.") ? "classic" : "berry";
-    } catch (error) {
-      errors.assertError(error);
-      if ("stderr" in error) {
-        process.stderr.write(error.stderr);
-      }
-      throw new errors.ForwardedError("Failed to determine yarn version", error);
-    }
-  });
-  versions.set(cwd, promise);
-  return promise;
-}
-
-exports.detectYarnVersion = detectYarnVersion;
-//# sourceMappingURL=yarn-Ukl9MOS0.cjs.js.map