@backstage/cli 0.18.0 → 0.18.1

package/dist/cjs/packageScripts-6731503e.cjs.js

@@ -1,96 +0,0 @@
-'use strict';
-
-var fs = require('fs-extra');
-var path = require('path');
-var PackageGraph = require('./PackageGraph-1d7b086a.cjs.js');
-var packageRoles = require('./packageRoles-a310f84c.cjs.js');
-require('@manypkg/get-packages');
-require('./index-7e13cc9d.cjs.js');
-require('commander');
-require('chalk');
-require('semver');
-require('@backstage/cli-common');
-require('@backstage/errors');
-require('child_process');
-require('util');
-require('zod');
-
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
-
-const configArgPattern = /--config[=\s][^\s$]+/;
-const noStartRoles = ["cli", "common-library"];
-async function command() {
-  const packages = await PackageGraph.PackageGraph.listTargetPackages();
-  await Promise.all(packages.map(async ({ dir, packageJson }) => {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _i;
-    const role = packageRoles.getRoleFromPackage(packageJson);
-    if (!role) {
-      return;
-    }
-    const roleInfo = packageRoles.getRoleInfo(role);
-    const hasStart = !noStartRoles.includes(role);
-    const needsPack = !(roleInfo.output.includes("bundle") || role === "cli");
-    const scripts = (_a = packageJson.scripts) != null ? _a : {};
-    const startCmd = ["start"];
-    if ((_b = scripts.start) == null ? void 0 : _b.includes("--check")) {
-      startCmd.push("--check");
-    }
-    if ((_c = scripts.start) == null ? void 0 : _c.includes("--config")) {
-      startCmd.push(...(_d = scripts.start.match(configArgPattern)) != null ? _d : []);
-    }
-    const buildCmd = ["build"];
-    if ((_e = scripts.build) == null ? void 0 : _e.includes("--minify")) {
-      buildCmd.push("--minify");
-    }
-    if ((_f = scripts.build) == null ? void 0 : _f.includes("--experimental-type-build")) {
-      buildCmd.push("--experimental-type-build");
-    }
-    if ((_g = scripts.build) == null ? void 0 : _g.includes("--config")) {
-      buildCmd.push(...(_h = scripts.build.match(configArgPattern)) != null ? _h : []);
-    }
-    const testCmd = ["test"];
-    if ((_i = scripts.test) == null ? void 0 : _i.startsWith("backstage-cli test")) {
-      const args = scripts.test.slice("backstage-cli test".length).split(" ").filter(Boolean);
-      if (args.includes("--passWithNoTests")) {
-        args.splice(args.indexOf("--passWithNoTests"), 1);
-      }
-      testCmd.push(...args);
-    }
-    const expectedScripts = {
-      ...hasStart && {
-        start: `backstage-cli package ${startCmd.join(" ")}`
-      },
-      build: `backstage-cli package ${buildCmd.join(" ")}`,
-      lint: "backstage-cli package lint",
-      test: `backstage-cli package ${testCmd.join(" ")}`,
-      clean: "backstage-cli package clean",
-      ...needsPack && {
-        postpack: "backstage-cli package postpack",
-        prepack: "backstage-cli package prepack"
-      }
-    };
-    let changed = false;
-    const currentScripts = packageJson.scripts = packageJson.scripts || {};
-    for (const [name, value] of Object.entries(expectedScripts)) {
-      const currentScript = currentScripts[name];
-      const isMissing = !currentScript;
-      const isDifferent = currentScript !== value;
-      const isBackstageScript = currentScript == null ? void 0 : currentScript.includes("backstage-cli");
-      if (isMissing || isDifferent && isBackstageScript) {
-        changed = true;
-        currentScripts[name] = value;
-      }
-    }
-    if (changed) {
-      console.log(`Updating scripts for ${packageJson.name}`);
-      await fs__default["default"].writeJson(path.resolve(dir, "package.json"), packageJson, {
-        spaces: 2
-      });
-    }
-  }));
-}
-
-exports.command = command;
-//# sourceMappingURL=packageScripts-6731503e.cjs.js.map

package/dist/cjs/parallel-8286d3fa.cjs.js

@@ -1,171 +0,0 @@
-'use strict';
-
-var os = require('os');
-var worker_threads = require('worker_threads');
-
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-var os__default = /*#__PURE__*/_interopDefaultLegacy(os);
-
-const defaultParallelism = Math.ceil(os__default["default"].cpus().length / 2);
-const PARALLEL_ENV_VAR = "BACKSTAGE_CLI_BUILD_PARALLEL";
-function parseParallelismOption(parallel) {
-  if (parallel === void 0 || parallel === null) {
-    return defaultParallelism;
-  } else if (typeof parallel === "boolean") {
-    return parallel ? defaultParallelism : 1;
-  } else if (typeof parallel === "number" && Number.isInteger(parallel)) {
-    if (parallel < 1) {
-      return 1;
-    }
-    return parallel;
-  } else if (typeof parallel === "string") {
-    if (parallel === "true") {
-      return parseParallelismOption(true);
-    } else if (parallel === "false") {
-      return parseParallelismOption(false);
-    }
-    const parsed = Number(parallel);
-    if (Number.isInteger(parsed)) {
-      return parseParallelismOption(parsed);
-    }
-  }
-  throw Error(`Parallel option value '${parallel}' is not a boolean or integer`);
-}
-function getEnvironmentParallelism() {
-  return parseParallelismOption(process.env[PARALLEL_ENV_VAR]);
-}
-async function runParallelWorkers(options) {
-  const { parallelismFactor = 1, parallelismSetting, items, worker } = options;
-  const parallelism = parallelismSetting ? parseParallelismOption(parallelismSetting) : getEnvironmentParallelism();
-  const sharedIterator = items[Symbol.iterator]();
-  const sharedIterable = {
-    [Symbol.iterator]: () => sharedIterator
-  };
-  const workerCount = Math.max(Math.floor(parallelismFactor * parallelism), 1);
-  return Promise.all(Array(workerCount).fill(0).map(async () => {
-    for (const value of sharedIterable) {
-      await worker(value);
-    }
-  }));
-}
-async function runWorkerQueueThreads(options) {
-  const items = Array.from(options.items);
-  const {
-    workerFactory,
-    workerData,
-    threadCount = Math.min(getEnvironmentParallelism(), items.length)
-  } = options;
-  const iterator = items[Symbol.iterator]();
-  const results = new Array();
-  let itemIndex = 0;
-  await Promise.all(Array(threadCount).fill(0).map(async () => {
-    const thread = new worker_threads.Worker(`(${workerQueueThread})(${workerFactory})`, {
-      eval: true,
-      workerData
-    });
-    return new Promise((resolve, reject) => {
-      thread.on("message", (message) => {
-        if (message.type === "start" || message.type === "result") {
-          if (message.type === "result") {
-            results[message.index] = message.result;
-          }
-          const { value, done } = iterator.next();
-          if (done) {
-            thread.postMessage({ type: "done" });
-          } else {
-            thread.postMessage({
-              type: "item",
-              index: itemIndex,
-              item: value
-            });
-            itemIndex += 1;
-          }
-        } else if (message.type === "error") {
-          const error = new Error(message.error.message);
-          error.name = message.error.name;
-          error.stack = message.error.stack;
-          reject(error);
-        }
-      });
-      thread.on("error", reject);
-      thread.on("exit", (code) => {
-        if (code !== 0) {
-          reject(new Error(`Worker thread exited with code ${code}`));
-        } else {
-          resolve();
-        }
-      });
-    });
-  }));
-  return results;
-}
-function workerQueueThread(workerFuncFactory) {
-  const { parentPort, workerData } = require("worker_threads");
-  Promise.resolve().then(() => workerFuncFactory(workerData)).then((workerFunc) => {
-    parentPort.on("message", async (message) => {
-      if (message.type === "done") {
-        parentPort.close();
-        return;
-      }
-      if (message.type === "item") {
-        try {
-          const result = await workerFunc(message.item);
-          parentPort.postMessage({
-            type: "result",
-            index: message.index,
-            result
-          });
-        } catch (error) {
-          parentPort.postMessage({ type: "error", error });
-        }
-      }
-    });
-    parentPort.postMessage({ type: "start" });
-  }, (error) => parentPort.postMessage({ type: "error", error }));
-}
-async function runWorkerThreads(options) {
-  const { worker, workerData, threadCount = 1, onMessage } = options;
-  return Promise.all(Array(threadCount).fill(0).map(async () => {
-    const thread = new worker_threads.Worker(`(${workerThread})(${worker})`, {
-      eval: true,
-      workerData
-    });
-    return new Promise((resolve, reject) => {
-      thread.on("message", (message) => {
-        if (message.type === "result") {
-          resolve(message.result);
-        } else if (message.type === "error") {
-          reject(message.error);
-        } else if (message.type === "message") {
-          onMessage == null ? void 0 : onMessage(message.message);
-        }
-      });
-      thread.on("error", reject);
-      thread.on("exit", (code) => {
-        reject(new Error(`Unexpected worker thread exit with code ${code}`));
-      });
-    });
-  }));
-}
-function workerThread(workerFunc) {
-  const { parentPort, workerData } = require("worker_threads");
-  const sendMessage = (message) => {
-    parentPort.postMessage({ type: "message", message });
-  };
-  workerFunc(workerData, sendMessage).then((result) => {
-    parentPort.postMessage({
-      type: "result",
-      index: 0,
-      result
-    });
-  }, (error) => {
-    parentPort.postMessage({ type: "error", error });
-  });
-}
-
-exports.getEnvironmentParallelism = getEnvironmentParallelism;
-exports.runParallelWorkers = runParallelWorkers;
-exports.runWorkerQueueThreads = runWorkerQueueThreads;
-exports.runWorkerThreads = runWorkerThreads;
-//# sourceMappingURL=parallel-8286d3fa.cjs.js.map