@backstage/cli 0.13.1-next.0 → 0.13.2

package/dist/cjs/packageRoles-a2eecabc.cjs.js

@@ -0,0 +1,158 @@
+'use strict';
+
+var zod = require('zod');
+var fs = require('fs-extra');
+var index = require('./index-4605496f.cjs.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
+
+const packageRoleInfos = [
+  {
+    role: "app",
+    platform: "web",
+    output: ["bundle"]
+  },
+  {
+    role: "backend",
+    platform: "node",
+    output: ["bundle"]
+  },
+  {
+    role: "cli",
+    platform: "node",
+    output: ["cjs"]
+  },
+  {
+    role: "web-library",
+    platform: "web",
+    output: ["types", "esm"]
+  },
+  {
+    role: "node-library",
+    platform: "node",
+    output: ["types", "cjs"]
+  },
+  {
+    role: "common-library",
+    platform: "common",
+    output: ["types", "esm", "cjs"]
+  },
+  {
+    role: "plugin-frontend",
+    platform: "web",
+    output: ["types", "esm"]
+  },
+  {
+    role: "plugin-frontend-module",
+    platform: "web",
+    output: ["types", "esm"]
+  },
+  {
+    role: "plugin-backend",
+    platform: "node",
+    output: ["types", "cjs"]
+  },
+  {
+    role: "plugin-backend-module",
+    platform: "node",
+    output: ["types", "cjs"]
+  }
+];
+function getRoleInfo(role) {
+  const roleInfo = packageRoleInfos.find((r) => r.role === role);
+  if (!roleInfo) {
+    throw new Error(`Unknown package role '${role}'`);
+  }
+  return roleInfo;
+}
+const readSchema = zod.z.object({
+  name: zod.z.string().optional(),
+  backstage: zod.z.object({
+    role: zod.z.string().optional()
+  }).optional()
+});
+function getRoleFromPackage(pkgJson) {
+  const pkg = readSchema.parse(pkgJson);
+  if (pkg.backstage) {
+    const { role } = pkg.backstage;
+    if (!role) {
+      throw new Error(`Package ${pkg.name} must specify a role in the "backstage" field`);
+    }
+    return getRoleInfo(role).role;
+  }
+  return void 0;
+}
+async function findRoleFromCommand(cmd) {
+  var _a;
+  if (cmd.role) {
+    return (_a = getRoleInfo(cmd.role)) == null ? void 0 : _a.role;
+  }
+  const pkg = await fs__default["default"].readJson(index.paths.resolveTarget("package.json"));
+  const info = getRoleFromPackage(pkg);
+  if (!info) {
+    throw new Error(`Target package must have 'backstage.role' set`);
+  }
+  return info;
+}
+const detectionSchema = zod.z.object({
+  name: zod.z.string().optional(),
+  scripts: zod.z.object({
+    start: zod.z.string().optional(),
+    build: zod.z.string().optional()
+  }).optional(),
+  publishConfig: zod.z.object({
+    main: zod.z.string().optional(),
+    types: zod.z.string().optional(),
+    module: zod.z.string().optional()
+  }).optional(),
+  main: zod.z.string().optional(),
+  types: zod.z.string().optional(),
+  module: zod.z.string().optional()
+});
+function detectRoleFromPackage(pkgJson) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o;
+  const pkg = detectionSchema.parse(pkgJson);
+  if ((_b = (_a = pkg.scripts) == null ? void 0 : _a.start) == null ? void 0 : _b.includes("app:serve")) {
+    return "app";
+  }
+  if ((_d = (_c = pkg.scripts) == null ? void 0 : _c.build) == null ? void 0 : _d.includes("backend:bundle")) {
+    return "backend";
+  }
+  if (((_e = pkg.name) == null ? void 0 : _e.includes("plugin-")) && ((_f = pkg.name) == null ? void 0 : _f.includes("-backend-module-"))) {
+    return "plugin-backend-module";
+  }
+  if (((_g = pkg.name) == null ? void 0 : _g.includes("plugin-")) && ((_h = pkg.name) == null ? void 0 : _h.includes("-module-"))) {
+    return "plugin-frontend-module";
+  }
+  if ((_j = (_i = pkg.scripts) == null ? void 0 : _i.start) == null ? void 0 : _j.includes("plugin:serve")) {
+    return "plugin-frontend";
+  }
+  if ((_l = (_k = pkg.scripts) == null ? void 0 : _k.start) == null ? void 0 : _l.includes("backend:dev")) {
+    return "plugin-backend";
+  }
+  const mainEntry = ((_m = pkg.publishConfig) == null ? void 0 : _m.main) || pkg.main;
+  const moduleEntry = ((_n = pkg.publishConfig) == null ? void 0 : _n.module) || pkg.module;
+  const typesEntry = ((_o = pkg.publishConfig) == null ? void 0 : _o.types) || pkg.types;
+  if (typesEntry) {
+    if (mainEntry && moduleEntry) {
+      return "common-library";
+    }
+    if (moduleEntry || (mainEntry == null ? void 0 : mainEntry.endsWith(".esm.js"))) {
+      return "web-library";
+    }
+    if (mainEntry) {
+      return "node-library";
+    }
+  } else if (mainEntry) {
+    return "cli";
+  }
+  return void 0;
+}
+
+exports.detectRoleFromPackage = detectRoleFromPackage;
+exports.findRoleFromCommand = findRoleFromCommand;
+exports.getRoleFromPackage = getRoleFromPackage;
+exports.getRoleInfo = getRoleInfo;
+//# sourceMappingURL=packageRoles-a2eecabc.cjs.js.map

package/dist/cjs/packageScripts-69fbc72e.cjs.js

@@ -0,0 +1,61 @@
+'use strict';
+
+var fs = require('fs-extra');
+var path = require('path');
+var PackageGraph = require('./PackageGraph-f7218931.cjs.js');
+var packageRoles = require('./packageRoles-a2eecabc.cjs.js');
+require('@manypkg/get-packages');
+require('./index-4605496f.cjs.js');
+require('commander');
+require('chalk');
+require('semver');
+require('@backstage/cli-common');
+require('@backstage/config/package.json');
+require('@backstage/errors');
+require('zod');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
+
+const noStartRoles = ["cli", "common-library"];
+async function command() {
+  const packages = await PackageGraph.PackageGraph.listTargetPackages();
+  await Promise.all(packages.map(async ({ dir, packageJson }) => {
+    const role = packageRoles.getRoleFromPackage(packageJson);
+    if (!role) {
+      return;
+    }
+    const roleInfo = packageRoles.getRoleInfo(role);
+    const hasStart = !noStartRoles.includes(role);
+    const isBundled = roleInfo.output.includes("bundle");
+    const expectedScripts = {
+      ...hasStart && { start: "backstage-cli script start" },
+      build: "backstage-cli script build",
+      lint: "backstage-cli script lint",
+      test: "backstage-cli script test",
+      clean: "backstage-cli script clean",
+      ...!isBundled && {
+        postpack: "backstage-cli script postpack",
+        prepack: "backstage-cli script prepack"
+      }
+    };
+    let changed = false;
+    const currentScripts = packageJson.scripts = packageJson.scripts || {};
+    for (const [name, value] of Object.entries(expectedScripts)) {
+      if (currentScripts[name] !== value) {
+        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-69fbc72e.cjs.js.map

package/dist/cjs/{packager-03db0c91.cjs.js → packager-57263112.cjs.js}

@@ -4,7 +4,7 @@ var fs = require('fs-extra');
 var rollup = require('rollup');
 var chalk = require('chalk');
 var path = require('path');
-var index = require('./index-621ba6c9.cjs.js');
+var index = require('./index-4605496f.cjs.js');
 var peerDepsExternal = require('rollup-plugin-peer-deps-external');
 var commonjs = require('@rollup/plugin-commonjs');
 var resolve = require('@rollup/plugin-node-resolve');
@@ -16,6 +16,9 @@ var json = require('@rollup/plugin-json');
 var yaml = require('@rollup/plugin-yaml');
 var rollupPluginutils = require('rollup-pluginutils');
 var svgrTemplate = require('./svgrTemplate-f19e974c.cjs.js');
+var worker_threads = require('worker_threads');
+var packageRoles = require('./packageRoles-a2eecabc.cjs.js');
+var parallel = require('./parallel-e73a4058.cjs.js');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
@@ -96,13 +99,26 @@ var Output = /* @__PURE__ */ ((Output2) => {
 })(Output || {});
 
 async function makeRollupConfigs(options) {
+  var _a;
   const configs = new Array();
+  const targetDir = (_a = options.targetDir) != null ? _a : index.paths.targetDir;
+  const onwarn = ({ code, message }) => {
+    if (code === "EMPTY_BUNDLE") {
+      return;
+    }
+    if (options.logPrefix) {
+      console.log(options.logPrefix + message);
+    } else {
+      console.log(message);
+    }
+  };
+  const distDir = path.resolve(targetDir, "dist");
   if (options.outputs.has(Output.cjs) || options.outputs.has(Output.esm)) {
     const output = new Array();
     const mainFields = ["module", "main"];
     if (options.outputs.has(Output.cjs)) {
       output.push({
-        dir: "dist",
+        dir: distDir,
         entryFileNames: "index.cjs.js",
         chunkFileNames: "cjs/[name]-[hash].cjs.js",
         format: "commonjs",
@@ -111,7 +127,7 @@ async function makeRollupConfigs(options) {
     }
     if (options.outputs.has(Output.esm)) {
       output.push({
-        dir: "dist",
+        dir: distDir,
         entryFileNames: "index.esm.js",
         chunkFileNames: "esm/[name]-[hash].esm.js",
         format: "module",
@@ -120,12 +136,14 @@ async function makeRollupConfigs(options) {
       mainFields.unshift("browser");
     }
     configs.push({
-      input: "src/index.ts",
+      input: path.resolve(targetDir, "src/index.ts"),
       output,
+      onwarn,
       preserveEntrySignatures: "strict",
       external: require("module").builtinModules,
       plugins: [
         peerDepsExternal__default["default"]({
+          packageJsonPath: path.resolve(targetDir, "package.json"),
           includeDependencies: true
         }),
         resolve__default["default"]({ mainFields }),
@@ -162,111 +180,167 @@ async function makeRollupConfigs(options) {
     });
   }
   if (options.outputs.has(Output.types) && !options.useApiExtractor) {
-    const typesInput = index.paths.resolveTargetRoot("dist-types", path.relative(index.paths.targetRoot, index.paths.targetDir), "src/index.d.ts");
+    const typesInput = index.paths.resolveTargetRoot("dist-types", path.relative(index.paths.targetRoot, targetDir), "src/index.d.ts");
     const declarationsExist = await fs__default["default"].pathExists(typesInput);
     if (!declarationsExist) {
-      const path$1 = path.relative(index.paths.targetDir, typesInput);
+      const path$1 = path.relative(targetDir, typesInput);
       throw new Error(`No declaration files found at ${path$1}, be sure to run ${chalk__default["default"].bgRed.white("yarn tsc")} to generate .d.ts files before packaging`);
     }
     configs.push({
       input: typesInput,
       output: {
-        file: "dist/index.d.ts",
+        file: path.resolve(distDir, "index.d.ts"),
         format: "es"
       },
+      onwarn,
       plugins: [dts__default["default"]()]
     });
   }
   return configs;
 }
 
-const ignoredMessages = /* @__PURE__ */ new Set(["tsdoc-undefined-tag", "ae-forgotten-export"]);
-let apiExtractor;
-function prepareApiExtractor() {
-  if (apiExtractor) {
-    return apiExtractor;
-  }
+function buildTypeDefinitionsWorker() {
   try {
-    apiExtractor = require("@microsoft/api-extractor");
+    require("@microsoft/api-extractor");
   } catch (error) {
     throw new Error("Failed to resolve @microsoft/api-extractor, it must best installed as a dependency of your project in order to use experimental type builds");
   }
+  const { dirname } = require("path");
+  const { workerData, parentPort } = require("worker_threads");
+  const { entryPoints, workerConfigs, typescriptCompilerFolder } = workerData;
+  const apiExtractor = require("@microsoft/api-extractor");
+  const { Extractor, ExtractorConfig, CompilerState } = apiExtractor;
   const {
     PackageJsonLookup
   } = require("@rushstack/node-core-library/lib/PackageJsonLookup");
   const old = PackageJsonLookup.prototype.tryGetPackageJsonFilePathFor;
-  PackageJsonLookup.prototype.tryGetPackageJsonFilePathFor = function tryGetPackageJsonFilePathForPatch(path$1) {
-    if (path$1.includes("@material-ui") && !path.dirname(path$1).endsWith("@material-ui")) {
+  PackageJsonLookup.prototype.tryGetPackageJsonFilePathFor = function tryGetPackageJsonFilePathForPatch(path) {
+    if (path.includes("@material-ui") && !dirname(path).endsWith("@material-ui")) {
       return void 0;
     }
-    return old.call(this, path$1);
+    return old.call(this, path);
   };
-  return apiExtractor;
-}
-async function buildTypeDefinitions() {
-  const { Extractor, ExtractorConfig } = prepareApiExtractor();
-  const distTypesPackageDir = index.paths.resolveTargetRoot("dist-types", path.relative(index.paths.targetRoot, index.paths.targetDir));
-  const entryPoint = path.resolve(distTypesPackageDir, "src/index.d.ts");
-  const declarationsExist = await fs__default["default"].pathExists(entryPoint);
-  if (!declarationsExist) {
-    const path$1 = path.relative(index.paths.targetDir, entryPoint);
-    throw new Error(`No declaration files found at ${path$1}, be sure to run ${chalk__default["default"].bgRed.white("yarn tsc")} to generate .d.ts files before packaging`);
+  let success = true;
+  let compilerState;
+  for (const { extractorOptions, targetTypesDir } of workerConfigs) {
+    const extractorConfig = ExtractorConfig.prepare(extractorOptions);
+    if (!compilerState) {
+      compilerState = CompilerState.create(extractorConfig, {
+        additionalEntryPoints: entryPoints
+      });
+    }
+    const extractorResult = Extractor.invoke(extractorConfig, {
+      compilerState,
+      localBuild: false,
+      typescriptCompilerFolder,
+      showVerboseMessages: false,
+      showDiagnostics: false,
+      messageCallback: (message) => {
+        message.handled = true;
+        parentPort.postMessage({ type: "message", message, targetTypesDir });
+      }
+    });
+    if (!extractorResult.succeeded) {
+      parentPort.postMessage({
+        type: "done",
+        error: new Error(`Type definition build completed with ${extractorResult.errorCount} errors and ${extractorResult.warningCount} warnings`)
+      });
+      success = false;
+      break;
+    }
   }
-  const extractorConfig = ExtractorConfig.prepare({
-    configObject: {
-      mainEntryPointFilePath: entryPoint,
-      bundledPackages: [],
-      compiler: {
-        skipLibCheck: true,
-        tsconfigFilePath: index.paths.resolveTargetRoot("tsconfig.json")
-      },
-      dtsRollup: {
-        enabled: true,
-        untrimmedFilePath: index.paths.resolveTarget("dist/index.alpha.d.ts"),
-        betaTrimmedFilePath: index.paths.resolveTarget("dist/index.beta.d.ts"),
-        publicTrimmedFilePath: index.paths.resolveTarget("dist/index.d.ts")
+  if (success) {
+    parentPort.postMessage({ type: "done" });
+  }
+}
+
+const ignoredMessages = /* @__PURE__ */ new Set(["tsdoc-undefined-tag", "ae-forgotten-export"]);
+async function buildTypeDefinitions(targetDirs = [index.paths.targetDir]) {
+  const packageDirs = targetDirs.map((dir) => path.relative(index.paths.targetRoot, dir));
+  const entryPoints = await Promise.all(packageDirs.map(async (dir) => {
+    const entryPoint = index.paths.resolveTargetRoot("dist-types", dir, "src/index.d.ts");
+    const declarationsExist = await fs__default["default"].pathExists(entryPoint);
+    if (!declarationsExist) {
+      throw new Error(`No declaration files found at ${entryPoint}, be sure to run ${chalk__default["default"].bgRed.white("yarn tsc")} to generate .d.ts files before packaging`);
+    }
+    return entryPoint;
+  }));
+  const workerConfigs = packageDirs.map((packageDir) => {
+    const targetDir = index.paths.resolveTargetRoot(packageDir);
+    const targetTypesDir = index.paths.resolveTargetRoot("dist-types", packageDir);
+    const extractorOptions = {
+      configObject: {
+        mainEntryPointFilePath: path.resolve(targetTypesDir, "src/index.d.ts"),
+        bundledPackages: [],
+        compiler: {
+          skipLibCheck: true,
+          tsconfigFilePath: index.paths.resolveTargetRoot("tsconfig.json")
+        },
+        dtsRollup: {
+          enabled: true,
+          untrimmedFilePath: path.resolve(targetDir, "dist/index.alpha.d.ts"),
+          betaTrimmedFilePath: path.resolve(targetDir, "dist/index.beta.d.ts"),
+          publicTrimmedFilePath: path.resolve(targetDir, "dist/index.d.ts")
+        },
+        newlineKind: "lf",
+        projectFolder: targetDir
       },
-      newlineKind: "lf",
-      projectFolder: index.paths.targetDir
-    },
-    configObjectFullPath: index.paths.targetDir,
-    packageJsonFullPath: index.paths.resolveTarget("package.json")
+      configObjectFullPath: targetDir,
+      packageJsonFullPath: path.resolve(targetDir, "package.json")
+    };
+    return { extractorOptions, targetTypesDir };
   });
   const typescriptDir = index.paths.resolveTargetRoot("node_modules/typescript");
   const hasTypescript = await fs__default["default"].pathExists(typescriptDir);
-  const extractorResult = Extractor.invoke(extractorConfig, {
-    typescriptCompilerFolder: hasTypescript ? typescriptDir : void 0,
-    localBuild: false,
-    showVerboseMessages: false,
-    showDiagnostics: false,
-    messageCallback(message) {
-      message.handled = true;
-      if (ignoredMessages.has(message.messageId)) {
-        return;
+  const typescriptCompilerFolder = hasTypescript ? typescriptDir : void 0;
+  const worker = new worker_threads.Worker(`(${buildTypeDefinitionsWorker})()`, {
+    eval: true,
+    workerData: {
+      entryPoints,
+      workerConfigs,
+      typescriptCompilerFolder
+    }
+  });
+  await new Promise((resolve, reject) => {
+    worker.once("error", reject);
+    worker.once("exit", (code) => {
+      if (code) {
+        reject(new Error(`Worker exited with code ${code}`));
       }
-      let text = `${message.text} (${message.messageId})`;
-      if (message.sourceFilePath) {
-        text += " at ";
-        text += path.relative(distTypesPackageDir, message.sourceFilePath);
-        if (message.sourceFileLine) {
-          text += `:${message.sourceFileLine}`;
-          if (message.sourceFileColumn) {
-            text += `:${message.sourceFileColumn}`;
+    });
+    worker.on("message", (data) => {
+      if (data.type === "done") {
+        if (data.error) {
+          reject(data.error);
+        } else {
+          resolve();
+        }
+      } else if (data.type === "message") {
+        const { message, targetTypesDir } = data;
+        if (ignoredMessages.has(message.messageId)) {
+          return;
+        }
+        let text = `${message.text} (${message.messageId})`;
+        if (message.sourceFilePath) {
+          text += " at ";
+          text += path.relative(targetTypesDir, message.sourceFilePath);
+          if (message.sourceFileLine) {
+            text += `:${message.sourceFileLine}`;
+            if (message.sourceFileColumn) {
+              text += `:${message.sourceFileColumn}`;
+            }
           }
         }
+        if (message.logLevel === "error") {
+          console.error(chalk__default["default"].red(`Error: ${text}`));
+        } else if (message.logLevel === "warning" || message.category === "Extractor") {
+          console.warn(`Warning: ${text}`);
+        } else {
+          console.log(text);
+        }
       }
-      if (message.logLevel === "error") {
-        console.error(chalk__default["default"].red(`Error: ${text}`));
-      } else if (message.logLevel === "warning" || message.category === "Extractor") {
-        console.warn(`Warning: ${text}`);
-      } else {
-        console.log(text);
-      }
-    }
+    });
   });
-  if (!extractorResult.succeeded) {
-    throw new Error(`Type definition build completed with ${extractorResult.errorCount} errors and ${extractorResult.warningCount} warnings`);
-  }
 }
 
 function formatErrorMessage(error) {
@@ -346,7 +420,40 @@ const buildPackage = async (options) => {
   }
   await Promise.all(buildTasks);
 };
+const buildPackages = async (options) => {
+  if (options.some((opt) => !opt.targetDir)) {
+    throw new Error("targetDir must be set for all build options");
+  }
+  const rollupConfigs = await Promise.all(options.map(makeRollupConfigs));
+  await Promise.all(options.map(({ targetDir }) => fs__default["default"].remove(path.resolve(targetDir, "dist"))));
+  const buildTasks = rollupConfigs.flat().map((opts) => () => rollupBuild(opts));
+  const typeDefinitionTargetDirs = options.filter(({ outputs, useApiExtractor }) => outputs.has(Output.types) && useApiExtractor).map((_) => _.targetDir);
+  if (typeDefinitionTargetDirs.length > 0) {
+    buildTasks.unshift(() => buildTypeDefinitions(typeDefinitionTargetDirs));
+  }
+  await parallel.runParallelWorkers({
+    items: buildTasks,
+    worker: async (task) => task()
+  });
+};
+function getOutputsForRole(role) {
+  const outputs = /* @__PURE__ */ new Set();
+  for (const output of packageRoles.getRoleInfo(role).output) {
+    if (output === "cjs") {
+      outputs.add(Output.cjs);
+    }
+    if (output === "esm") {
+      outputs.add(Output.esm);
+    }
+    if (output === "types") {
+      outputs.add(Output.types);
+    }
+  }
+  return outputs;
+}
 
 exports.Output = Output;
 exports.buildPackage = buildPackage;
-//# sourceMappingURL=packager-03db0c91.cjs.js.map
+exports.buildPackages = buildPackages;
+exports.getOutputsForRole = getOutputsForRole;
+//# sourceMappingURL=packager-57263112.cjs.js.map

package/dist/cjs/{packages-ea22fb5a.cjs.js → packages-ef539958.cjs.js}

@@ -2,8 +2,8 @@
 
 var minimatch = require('minimatch');
 var getPackages = require('@manypkg/get-packages');
-var run = require('./run-615f671f.cjs.js');
-var index = require('./index-621ba6c9.cjs.js');
+var run = require('./run-43a2e0bb.cjs.js');
+var index = require('./index-4605496f.cjs.js');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
@@ -50,4 +50,4 @@ async function mapDependencies(targetDir, pattern) {
 
 exports.fetchPackageInfo = fetchPackageInfo;
 exports.mapDependencies = mapDependencies;
-//# sourceMappingURL=packages-ea22fb5a.cjs.js.map
+//# sourceMappingURL=packages-ef539958.cjs.js.map

package/dist/cjs/parallel-e73a4058.cjs.js

@@ -0,0 +1,48 @@
+'use strict';
+
+const DEFAULT_PARALLELISM = 4;
+const PARALLEL_ENV_VAR = "BACKSTAGE_CLI_BUILD_PARALLEL";
+function parseParallelismOption(parallel) {
+  if (parallel === void 0 || parallel === null) {
+    return DEFAULT_PARALLELISM;
+  } else if (typeof parallel === "boolean") {
+    return parallel ? DEFAULT_PARALLELISM : 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);
+    }
+  }));
+}
+
+exports.getEnvironmentParallelism = getEnvironmentParallelism;
+exports.runParallelWorkers = runParallelWorkers;
+//# sourceMappingURL=parallel-e73a4058.cjs.js.map