@backstage/cli 0.13.1-next.1 → 0.14.0

package/dist/cjs/{packager-89d7686b.cjs.js → packager-8f82846e.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-db3186f9.cjs.js');
+var index = require('./index-2b8588e8.cjs.js');
 var peerDepsExternal = require('rollup-plugin-peer-deps-external');
 var commonjs = require('@rollup/plugin-commonjs');
 var resolve = require('@rollup/plugin-node-resolve');
@@ -15,7 +15,9 @@ var dts = require('rollup-plugin-dts');
 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 svgrTemplate = require('./svgrTemplate-b7a4ee52.cjs.js');
+var parallel = require('./parallel-d8e5bcbf.cjs.js');
+var packageRoles = require('./packageRoles-f375a99e.cjs.js');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
@@ -96,13 +98,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 +126,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 +135,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,92 +179,128 @@ 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;
-  }
+async function buildTypeDefinitionsWorker(workerData, sendMessage) {
   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 { 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 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;
+        sendMessage({ message, targetTypesDir });
+      }
+    });
+    if (!extractorResult.succeeded) {
+      throw new Error(`Type definition build completed with ${extractorResult.errorCount} errors and ${extractorResult.warningCount} warnings`);
+    }
   }
-  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")
+}
+
+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;
+  const typescriptCompilerFolder = hasTypescript ? typescriptDir : void 0;
+  await parallel.runWorkerThreads({
+    threadCount: 1,
+    workerData: {
+      entryPoints,
+      workerConfigs,
+      typescriptCompilerFolder
+    },
+    worker: buildTypeDefinitionsWorker,
+    onMessage: ({
+      message,
+      targetTypesDir
+    }) => {
       if (ignoredMessages.has(message.messageId)) {
         return;
       }
       let text = `${message.text} (${message.messageId})`;
       if (message.sourceFilePath) {
         text += " at ";
-        text += path.relative(distTypesPackageDir, message.sourceFilePath);
+        text += path.relative(targetTypesDir, message.sourceFilePath);
         if (message.sourceFileLine) {
           text += `:${message.sourceFileLine}`;
           if (message.sourceFileColumn) {
@@ -264,9 +317,6 @@ async function buildTypeDefinitions() {
       }
     }
   });
-  if (!extractorResult.succeeded) {
-    throw new Error(`Type definition build completed with ${extractorResult.errorCount} errors and ${extractorResult.warningCount} warnings`);
-  }
 }
 
 function formatErrorMessage(error) {
@@ -346,7 +396,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-89d7686b.cjs.js.map
+exports.buildPackages = buildPackages;
+exports.getOutputsForRole = getOutputsForRole;
+//# sourceMappingURL=packager-8f82846e.cjs.js.map

package/dist/cjs/{packages-fd09251d.cjs.js → packages-572642d7.cjs.js}

@@ -2,8 +2,8 @@
 
 var minimatch = require('minimatch');
 var getPackages = require('@manypkg/get-packages');
-var run = require('./run-448b5912.cjs.js');
-var index = require('./index-db3186f9.cjs.js');
+var run = require('./run-d3528c59.cjs.js');
+var index = require('./index-2b8588e8.cjs.js');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
@@ -28,7 +28,8 @@ async function fetchPackageInfo(name) {
 }
 async function mapDependencies(targetDir, pattern) {
   var _a;
-  const { packages } = await getPackages.getPackages(targetDir);
+  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) => {
@@ -50,4 +51,4 @@ async function mapDependencies(targetDir, pattern) {
 
 exports.fetchPackageInfo = fetchPackageInfo;
 exports.mapDependencies = mapDependencies;
-//# sourceMappingURL=packages-fd09251d.cjs.js.map
+//# sourceMappingURL=packages-572642d7.cjs.js.map

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

@@ -0,0 +1,171 @@
+'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-d8e5bcbf.cjs.js.map

package/dist/cjs/{paths-f273ca03.cjs.js → paths-8e0b151d.cjs.js}

@@ -12,9 +12,9 @@ var nodeExternals = require('webpack-node-externals');
 var cliCommon = require('@backstage/cli-common');
 var getPackages = require('@manypkg/get-packages');
 var MiniCssExtractPlugin = require('mini-css-extract-plugin');
-var svgrTemplate = require('./svgrTemplate-f19e974c.cjs.js');
-var index = require('./index-db3186f9.cjs.js');
-var run = require('./run-448b5912.cjs.js');
+var svgrTemplate = require('./svgrTemplate-b7a4ee52.cjs.js');
+var index = require('./index-2b8588e8.cjs.js');
+var run = require('./run-d3528c59.cjs.js');
 var ESLintPlugin = require('eslint-webpack-plugin');
 var pickBy = require('lodash/pickBy');
 
@@ -38,7 +38,8 @@ const optimization = (options) => {
     minimize: !isDev,
     minimizer: [
       new ESBuildMinifyPlugin({
-        target: "es2019"
+        target: "es2019",
+        format: "iife"
       })
     ],
     runtimeChunk: "single",
@@ -262,7 +263,7 @@ async function createConfig(paths, options) {
   const validBaseUrl = new URL(baseUrl);
   if (checksEnabled) {
     plugins.push(new ForkTsCheckerWebpackPlugin__default["default"]({
-      typescript: { configFile: paths.targetTsConfig }
+      typescript: { configFile: paths.targetTsConfig, memoryLimit: 4096 }
     }), new ESLintPlugin__default["default"]({
       context: paths.targetPath,
       files: ["**", "!**/__tests__/**", "!**/?(*.)(spec|test).*"]
@@ -473,40 +474,40 @@ function nodeExternalsWithResolve(options) {
 }
 
 function resolveBundlingPaths(options) {
-  const { entry } = options;
+  const { entry, targetDir = index.paths.targetDir } = options;
   const resolveTargetModule = (pathString) => {
     for (const ext of ["mjs", "js", "ts", "tsx", "jsx"]) {
-      const filePath = index.paths.resolveTarget(`${pathString}.${ext}`);
+      const filePath = path.resolve(targetDir, `${pathString}.${ext}`);
       if (fs__default["default"].pathExistsSync(filePath)) {
         return filePath;
       }
     }
-    return index.paths.resolveTarget(`${pathString}.js`);
+    return path.resolve(targetDir, `${pathString}.js`);
   };
   let targetPublic = void 0;
-  let targetHtml = index.paths.resolveTarget("public/index.html");
+  let targetHtml = path.resolve(targetDir, "public/index.html");
   if (fs__default["default"].pathExistsSync(targetHtml)) {
-    targetPublic = index.paths.resolveTarget("public");
+    targetPublic = path.resolve(targetDir, "public");
   } else {
-    targetHtml = index.paths.resolveTarget(`${entry}.html`);
+    targetHtml = path.resolve(targetDir, `${entry}.html`);
     if (!fs__default["default"].pathExistsSync(targetHtml)) {
       targetHtml = index.paths.resolveOwn("templates/serve_index.html");
     }
   }
-  const targetRunFile = index.paths.resolveTarget("src/run.ts");
+  const targetRunFile = path.resolve(targetDir, "src/run.ts");
   const runFileExists = fs__default["default"].pathExistsSync(targetRunFile);
   return {
     targetHtml,
     targetPublic,
-    targetPath: index.paths.resolveTarget("."),
+    targetPath: path.resolve(targetDir, "."),
     targetRunFile: runFileExists ? targetRunFile : void 0,
-    targetDist: index.paths.resolveTarget("dist"),
-    targetAssets: index.paths.resolveTarget("assets"),
-    targetSrc: index.paths.resolveTarget("src"),
-    targetDev: index.paths.resolveTarget("dev"),
+    targetDist: path.resolve(targetDir, "dist"),
+    targetAssets: path.resolve(targetDir, "assets"),
+    targetSrc: path.resolve(targetDir, "src"),
+    targetDev: path.resolve(targetDir, "dev"),
     targetEntry: resolveTargetModule(entry),
     targetTsConfig: index.paths.resolveTargetRoot("tsconfig.json"),
-    targetPackageJson: index.paths.resolveTarget("package.json"),
+    targetPackageJson: path.resolve(targetDir, "package.json"),
     rootNodeModules: index.paths.resolveTargetRoot("node_modules"),
     root: index.paths.targetRoot
   };
@@ -516,4 +517,4 @@ exports.createBackendConfig = createBackendConfig;
 exports.createConfig = createConfig;
 exports.resolveBaseUrl = resolveBaseUrl;
 exports.resolveBundlingPaths = resolveBundlingPaths;
-//# sourceMappingURL=paths-f273ca03.cjs.js.map
+//# sourceMappingURL=paths-8e0b151d.cjs.js.map

package/dist/cjs/{print-bd48d728.cjs.js → print-b7e68297.cjs.js}

@@ -2,9 +2,9 @@
 
 var yaml = require('yaml');
 var config$1 = require('@backstage/config');
-var config = require('./config-08b1d0e3.cjs.js');
+var config = require('./config-147bac17.cjs.js');
 require('@backstage/config-loader');
-require('./index-db3186f9.cjs.js');
+require('./index-2b8588e8.cjs.js');
 require('commander');
 require('chalk');
 require('fs-extra');
@@ -13,7 +13,10 @@ require('@backstage/cli-common');
 require('@backstage/config/package.json');
 require('@backstage/errors');
 require('@manypkg/get-packages');
-require('./PackageGraph-7a0d3a83.cjs.js');
+require('./PackageGraph-d7b9d768.cjs.js');
+require('path');
+require('child_process');
+require('util');
 
 var print = async (cmd) => {
   const { schema, appConfigs } = await config.loadCliConfig({
@@ -59,4 +62,4 @@ function serializeConfigData(appConfigs, schema, visibility) {
 }
 
 exports["default"] = print;
-//# sourceMappingURL=print-bd48d728.cjs.js.map
+//# sourceMappingURL=print-b7e68297.cjs.js.map

package/dist/cjs/{run-448b5912.cjs.js → run-d3528c59.cjs.js}

@@ -1,7 +1,7 @@
 'use strict';
 
 var child_process = require('child_process');
-var index = require('./index-db3186f9.cjs.js');
+var index = require('./index-2b8588e8.cjs.js');
 var util = require('util');
 var errors = require('@backstage/errors');
 
@@ -78,4 +78,4 @@ async function waitForExit(child, name) {
 exports.run = run;
 exports.runCheck = runCheck;
 exports.runPlain = runPlain;
-//# sourceMappingURL=run-448b5912.cjs.js.map
+//# sourceMappingURL=run-d3528c59.cjs.js.map

package/dist/cjs/{schema-c5b2f512.cjs.js → schema-0d43bb71.cjs.js}

@@ -1,10 +1,10 @@
 'use strict';
 
 var yaml = require('yaml');
-var config = require('./config-08b1d0e3.cjs.js');
+var config = require('./config-147bac17.cjs.js');
 var configLoader = require('@backstage/config-loader');
 require('@backstage/config');
-require('./index-db3186f9.cjs.js');
+require('./index-2b8588e8.cjs.js');
 require('commander');
 require('chalk');
 require('fs-extra');
@@ -13,7 +13,10 @@ require('@backstage/cli-common');
 require('@backstage/config/package.json');
 require('@backstage/errors');
 require('@manypkg/get-packages');
-require('./PackageGraph-7a0d3a83.cjs.js');
+require('./PackageGraph-d7b9d768.cjs.js');
+require('path');
+require('child_process');
+require('util');
 
 var schema = async (cmd) => {
   const { schema } = await config.loadCliConfig({
@@ -34,4 +37,4 @@ var schema = async (cmd) => {
 };
 
 exports["default"] = schema;
-//# sourceMappingURL=schema-c5b2f512.cjs.js.map
+//# sourceMappingURL=schema-0d43bb71.cjs.js.map