@backstage/cli 0.36.0-next.2 → 0.36.0

package/dist/modules/build/lib/bundler/config.cjs.js

@@ -1,308 +0,0 @@
-'use strict';
-
-var path = require('node:path');
-var core = require('@rspack/core');
-var ESLintRspackPlugin = require('eslint-rspack-plugin');
-var tsCheckerRspackPlugin = require('ts-checker-rspack-plugin');
-var HtmlWebpackPlugin = require('html-webpack-plugin');
-var ModuleScopePlugin = require('react-dev-utils/ModuleScopePlugin');
-var rspack = require('@module-federation/enhanced/rspack');
-var fs = require('fs-extra');
-var optimization = require('./optimization.cjs.js');
-var pickBy = require('lodash/pickBy');
-var cliCommon = require('@backstage/cli-common');
-var transforms = require('./transforms.cjs.js');
-var version = require('../../../../wiring/version.cjs.js');
-var yn = require('yn');
-var hasReactDomClient = require('./hasReactDomClient.cjs.js');
-var linkWorkspaces = require('./linkWorkspaces.cjs.js');
-var ConfigInjectingHtmlWebpackPlugin = require('./ConfigInjectingHtmlWebpackPlugin.cjs.js');
-
-function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
-
-var ESLintRspackPlugin__default = /*#__PURE__*/_interopDefaultCompat(ESLintRspackPlugin);
-var HtmlWebpackPlugin__default = /*#__PURE__*/_interopDefaultCompat(HtmlWebpackPlugin);
-var ModuleScopePlugin__default = /*#__PURE__*/_interopDefaultCompat(ModuleScopePlugin);
-var fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
-var pickBy__default = /*#__PURE__*/_interopDefaultCompat(pickBy);
-var yn__default = /*#__PURE__*/_interopDefaultCompat(yn);
-
-function resolveBaseUrl(config, moduleFederationRemote) {
-  const baseUrl = config.getOptionalString("app.baseUrl");
-  const defaultBaseUrl = moduleFederationRemote ? `http://localhost:${process.env.PORT ?? "3000"}` : "http://localhost:3000";
-  try {
-    return new URL(baseUrl ?? "/", defaultBaseUrl);
-  } catch (error) {
-    throw new Error(`Invalid app.baseUrl, ${error}`);
-  }
-}
-function resolveEndpoint(config, moduleFederationRemote) {
-  const url = resolveBaseUrl(config, moduleFederationRemote);
-  return {
-    host: config.getOptionalString("app.listen.host") ?? url.hostname,
-    port: config.getOptionalNumber("app.listen.port") ?? Number(url.port) ?? (url.protocol === "https:" ? 443 : 80)
-  };
-}
-async function readBuildInfo() {
-  const timestamp = Date.now();
-  let commit;
-  try {
-    commit = await cliCommon.runOutput(["git", "rev-parse", "HEAD"]);
-  } catch (error) {
-  }
-  let gitVersion;
-  try {
-    gitVersion = await cliCommon.runOutput(["git", "describe", "--always"]);
-  } catch (error) {
-  }
-  if (commit === void 0 || gitVersion === void 0) {
-    console.info(
-      "NOTE: Did not compute git version or commit hash, could not execute the git command line utility"
-    );
-  }
-  const { version: packageVersion } = await fs__default.default.readJson(
-    cliCommon.targetPaths.resolve("package.json")
-  );
-  return {
-    cliVersion: version.version,
-    gitVersion: gitVersion ?? "unknown",
-    packageVersion,
-    timestamp,
-    commit: commit ?? "unknown"
-  };
-}
-async function createConfig(paths, options) {
-  const {
-    checksEnabled,
-    isDev,
-    frontendConfig,
-    moduleFederationRemote,
-    publicSubPath = "",
-    webpack
-  } = options;
-  const { plugins, loaders } = transforms.transforms(options);
-  const validBaseUrl = resolveBaseUrl(frontendConfig, moduleFederationRemote);
-  let publicPath = validBaseUrl.pathname.replace(/\/$/, "");
-  if (publicSubPath) {
-    publicPath = `${publicPath}${publicSubPath}`.replace("//", "/");
-  }
-  if (isDev) {
-    const { host, port } = resolveEndpoint(
-      options.frontendConfig,
-      options.moduleFederationRemote
-    );
-    const refreshOptions = {
-      overlay: {
-        sockProtocol: "ws",
-        sockHost: host,
-        sockPort: port
-      }
-    };
-    if (webpack) {
-      const ReactRefreshPlugin = require("@pmmmwh/react-refresh-webpack-plugin");
-      plugins.push(new ReactRefreshPlugin(refreshOptions));
-    } else {
-      const RspackReactRefreshPlugin = require("@rspack/plugin-react-refresh");
-      plugins.push(new RspackReactRefreshPlugin(refreshOptions));
-    }
-  }
-  if (checksEnabled) {
-    const TsCheckerPlugin = webpack ? require("fork-ts-checker-webpack-plugin") : tsCheckerRspackPlugin.TsCheckerRspackPlugin;
-    const ESLintPlugin = webpack ? require("eslint-webpack-plugin") : ESLintRspackPlugin__default.default;
-    plugins.push(
-      new TsCheckerPlugin({
-        typescript: { configFile: paths.targetTsConfig, memoryLimit: 8192 }
-      }),
-      new ESLintPlugin({
-        cache: false,
-        // Cache seems broken
-        context: paths.targetPath,
-        files: ["**/*.(ts|tsx|mts|cts|js|jsx|mjs|cjs)"]
-      })
-    );
-  }
-  const bundler = webpack ? webpack : core.rspack;
-  plugins.push(
-    new bundler.ProvidePlugin({
-      process: require.resolve("process/browser"),
-      Buffer: ["buffer", "Buffer"]
-    })
-  );
-  if (!options.moduleFederationRemote) {
-    const templateOptions = {
-      meta: {
-        "backstage-app-mode": options?.appMode ?? "public"
-      },
-      template: paths.targetHtml,
-      templateParameters: {
-        publicPath,
-        config: frontendConfig
-      }
-    };
-    if (webpack) {
-      plugins.push(new HtmlWebpackPlugin__default.default(templateOptions));
-    } else {
-      plugins.push(
-        new ConfigInjectingHtmlWebpackPlugin.ConfigInjectingHtmlWebpackPlugin(
-          templateOptions,
-          options.getFrontendAppConfigs
-        )
-      );
-    }
-    plugins.push(
-      new HtmlWebpackPlugin__default.default({
-        meta: {
-          "backstage-app-mode": options?.appMode ?? "public",
-          // This is added to be written in the later step, and finally read by the extra entry point
-          "backstage-public-path": "<%= publicPath %>/"
-        },
-        minify: false,
-        publicPath: "<%= publicPath %>",
-        filename: "index.html.tmpl",
-        template: `${require.resolve("raw-loader")}!${paths.targetHtml}`
-      })
-    );
-  }
-  if (options.moduleFederationRemote) {
-    const AdaptedModuleFederationPlugin = webpack ? require("@module-federation/enhanced/webpack").ModuleFederationPlugin : rspack.ModuleFederationPlugin;
-    const exposes = options.moduleFederationRemote.exposes ? Object.fromEntries(
-      Object.entries(options.moduleFederationRemote?.exposes).map(
-        ([k, v]) => [k, path.resolve(paths.targetPath, v)]
-      )
-    ) : {
-      ".": paths.targetEntry
-    };
-    plugins.push(
-      new AdaptedModuleFederationPlugin({
-        filename: "remoteEntry.js",
-        exposes,
-        name: options.moduleFederationRemote.name,
-        runtime: false,
-        shared: options.moduleFederationRemote.sharedDependencies
-      })
-    );
-  }
-  const buildInfo = await readBuildInfo();
-  plugins.push(
-    webpack ? new webpack.DefinePlugin({
-      "process.env.BUILD_INFO": JSON.stringify(buildInfo),
-      "process.env.APP_CONFIG": webpack.DefinePlugin.runtimeValue(
-        () => JSON.stringify(options.getFrontendAppConfigs()),
-        true
-      ),
-      // This allows for conditional imports of react-dom/client, since there's no way
-      // to check for presence of it in source code without module resolution errors.
-      "process.env.HAS_REACT_DOM_CLIENT": JSON.stringify(
-        hasReactDomClient.hasReactDomClient()
-      )
-    }) : new bundler.DefinePlugin({
-      "process.env.BUILD_INFO": JSON.stringify(buildInfo),
-      "process.env.APP_CONFIG": JSON.stringify([]),
-      // Inject via index.html instead
-      // This allows for conditional imports of react-dom/client, since there's no way
-      // to check for presence of it in source code without module resolution errors.
-      "process.env.HAS_REACT_DOM_CLIENT": JSON.stringify(
-        hasReactDomClient.hasReactDomClient()
-      )
-    })
-  );
-  if (options.linkedWorkspace) {
-    plugins.push(
-      ...await linkWorkspaces.createWorkspaceLinkingPlugins(
-        bundler,
-        options.linkedWorkspace
-      )
-    );
-  }
-  const reactRefreshFiles = webpack ? [
-    require.resolve(
-      "@pmmmwh/react-refresh-webpack-plugin/lib/runtime/RefreshUtils.js"
-    ),
-    require.resolve(
-      "@pmmmwh/react-refresh-webpack-plugin/overlay/index.js"
-    ),
-    require.resolve("react-refresh")
-  ] : [];
-  const mode = isDev ? "development" : "production";
-  const optimization$1 = optimization.optimization(options);
-  return {
-    mode,
-    profile: false,
-    ...isDev ? {
-      watchOptions: {
-        ignored: /node_modules\/(?!__backstage-autodetected-plugins__)/
-      }
-    } : {},
-    optimization: optimization$1,
-    bail: false,
-    performance: {
-      hints: false
-      // we check the gzip size instead
-    },
-    devtool: isDev ? "eval-cheap-module-source-map" : "source-map",
-    context: paths.targetPath,
-    entry: [
-      require.resolve("@backstage/cli/config/webpack-public-path"),
-      ...options.additionalEntryPoints ?? [],
-      paths.targetEntry
-    ],
-    resolve: {
-      extensions: [".ts", ".tsx", ".mjs", ".js", ".jsx", ".json", ".wasm"],
-      mainFields: ["browser", "module", "main"],
-      fallback: {
-        ...pickBy__default.default(require("node-stdlib-browser")),
-        module: false,
-        dgram: false,
-        dns: false,
-        fs: false,
-        http2: false,
-        net: false,
-        tls: false,
-        child_process: false,
-        /* new ignores */
-        path: false,
-        https: false,
-        http: false,
-        util: require.resolve("util/")
-      },
-      // FIXME: see also https://github.com/web-infra-dev/rspack/issues/3408
-      ...webpack && {
-        plugins: [
-          new ModuleScopePlugin__default.default(
-            [paths.targetSrc, paths.targetDev],
-            [paths.targetPackageJson, ...reactRefreshFiles]
-          )
-        ]
-      }
-    },
-    module: {
-      rules: loaders
-    },
-    output: {
-      uniqueName: options.moduleFederationRemote?.name,
-      path: paths.targetDist,
-      publicPath: options.moduleFederationRemote ? "auto" : `${publicPath}/`,
-      filename: isDev ? "[name].js" : "static/[name].[contenthash:8].js",
-      chunkFilename: isDev ? "[name].chunk.js" : "static/[name].[contenthash:8].chunk.js",
-      ...isDev ? {
-        devtoolModuleFilenameTemplate: (info) => `file:///${path.resolve(info.absoluteResourcePath).replace(
-          /\\/g,
-          "/"
-        )}`
-      } : {}
-    },
-    experiments: {
-      lazyCompilation: yn__default.default(process.env.EXPERIMENTAL_LAZY_COMPILATION),
-      ...!webpack && {
-        // We're still using `style-loader` for custom `insert` option
-        css: false
-      }
-    },
-    plugins
-  };
-}
-
-exports.createConfig = createConfig;
-exports.resolveBaseUrl = resolveBaseUrl;
-exports.resolveEndpoint = resolveEndpoint;
-//# sourceMappingURL=config.cjs.js.map

package/dist/modules/build/lib/bundler/hasReactDomClient.cjs.js

@@ -1,17 +0,0 @@
-'use strict';
-
-var cliCommon = require('@backstage/cli-common');
-
-function hasReactDomClient() {
-  try {
-    require.resolve("react-dom/client", {
-      paths: [cliCommon.targetPaths.dir]
-    });
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-exports.hasReactDomClient = hasReactDomClient;
-//# sourceMappingURL=hasReactDomClient.cjs.js.map

package/dist/modules/build/lib/bundler/linkWorkspaces.cjs.js

@@ -1,34 +0,0 @@
-'use strict';
-
-var path = require('node:path');
-var getPackages = require('@manypkg/get-packages');
-var cliCommon = require('@backstage/cli-common');
-
-async function createWorkspaceLinkingPlugins(bundler, workspace) {
-  const { packages: linkedPackages, root: linkedRoot } = await getPackages.getPackages(
-    workspace
-  );
-  const replacementRegex = new RegExp(
-    `^(?:${linkedPackages.map((pkg) => pkg.packageJson.name).join("|")})(?:/.*)?$`
-  );
-  return [
-    // Any imports of a package that is present in the linked workspace will
-    // be redirected to be resolved within the context of the linked workspace
-    new bundler.NormalModuleReplacementPlugin(replacementRegex, (resource) => {
-      resource.context = linkedRoot.dir;
-    }),
-    // react and react-dom are always resolved from the target directory
-    // Note: this often requires that the linked and target workspace use the same versions of React
-    new bundler.NormalModuleReplacementPlugin(
-      /^react(?:-router)?(?:-dom)?$/,
-      (resource) => {
-        if (!path.relative(linkedRoot.dir, resource.context).startsWith("..")) {
-          resource.context = cliCommon.targetPaths.dir;
-        }
-      }
-    )
-  ];
-}
-
-exports.createWorkspaceLinkingPlugins = createWorkspaceLinkingPlugins;
-//# sourceMappingURL=linkWorkspaces.cjs.js.map

package/dist/modules/build/lib/bundler/moduleFederation.cjs.js

@@ -1,135 +0,0 @@
-'use strict';
-
-var entryPoints = require('../entryPoints.cjs.js');
-var typeDistProject = require('../typeDistProject.cjs.js');
-var moduleFederationCommon = require('@backstage/module-federation-common');
-var path = require('node:path');
-var fs = require('fs-extra');
-var chokidar = require('chokidar');
-var PQueue = require('p-queue');
-
-function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
-
-var fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
-var chokidar__default = /*#__PURE__*/_interopDefaultCompat(chokidar);
-var PQueue__default = /*#__PURE__*/_interopDefaultCompat(PQueue);
-
-async function getModuleFederationRemoteOptions(packageJson, packageDir) {
-  let exposes;
-  const packageRole = packageJson.backstage?.role;
-  if (packageJson.exports && packageRole) {
-    const project = await typeDistProject.createTypeDistProject();
-    exposes = Object.fromEntries(
-      entryPoints.readEntryPoints(packageJson).filter((ep) => {
-        if (ep.mount === "./package.json") {
-          return false;
-        }
-        if (ep.mount === ".") {
-          return true;
-        }
-        return typeDistProject.getEntryPointDefaultFeatureType(
-          packageRole,
-          packageDir,
-          project,
-          ep.path
-        ) !== null;
-      }).map((ep) => [ep.mount, ep.path])
-    );
-  }
-  return {
-    // The default output mode requires the name to be a usable as a code
-    // symbol, there might be better options here but for now we need to
-    // sanitize the name.
-    name: packageJson.name.replaceAll("@", "").replaceAll("/", "__").replaceAll("-", "_"),
-    exposes,
-    sharedDependencies: moduleFederationCommon.defaultRemoteSharedDependencies()
-  };
-}
-function prepareRuntimeSharedDependenciesScript(hostSharedDependencies) {
-  const items = Object.entries(hostSharedDependencies).map(
-    ([name, sharedDep]) => {
-      if (!sharedDep.version) {
-        throw new Error(`Version is required for shared dependency '${name}'`);
-      }
-      return {
-        name,
-        version: sharedDep.version,
-        lib: name,
-        // Coverted into import below
-        shareConfig: {
-          singleton: sharedDep.singleton,
-          requiredVersion: sharedDep.requiredVersion,
-          eager: sharedDep.eager
-        }
-      };
-    }
-  );
-  return `window['${moduleFederationCommon.BACKSTAGE_RUNTIME_SHARED_DEPENDENCIES_GLOBAL}'] = ${JSON.stringify(
-    { items, version: "v1" },
-    null,
-    2
-  ).replace(
-    /"lib": ("[^"]+")/gm,
-    (_, name) => `"lib": () => import(${name})`
-  )};`;
-}
-const RUNTIME_SHARED_DEPENDENCIES_MODULE_NAME = "__backstage-module-federation-runtime-shared-dependencies__";
-const writeQueue = new PQueue__default.default({ concurrency: 1 });
-async function writeRuntimeSharedDependenciesModule(targetPath, runtimeSharedDependencies) {
-  const script = prepareRuntimeSharedDependenciesScript(
-    runtimeSharedDependencies
-  );
-  await writeQueue.add(async () => {
-    const path$1 = path.join(
-      targetPath,
-      "node_modules",
-      `${RUNTIME_SHARED_DEPENDENCIES_MODULE_NAME}.js`
-    );
-    await fs__default.default.ensureDir(path.dirname(path$1));
-    await fs__default.default.writeFile(path$1, script);
-  });
-}
-function resolveSharedDependencyVersions(targetPath, hostSharedDependencies) {
-  return Object.fromEntries(
-    Object.entries(hostSharedDependencies).filter(([_, sharedDep]) => sharedDep !== void 0).flatMap(([importPath, sharedDep]) => {
-      const moduleName = importPath.startsWith("@") ? importPath.split("/").slice(0, 2).join("/") : importPath.split("/")[0];
-      let version;
-      try {
-        const packagePath = require.resolve(`${moduleName}/package.json`, {
-          paths: [targetPath]
-        });
-        version = require(packagePath).version;
-      } catch (e) {
-        console.log(
-          `Skipping module federation shared dependency '${importPath}' because it could not be resolved.`
-        );
-        return [];
-      }
-      return [[importPath, { ...sharedDep, version }]];
-    })
-  );
-}
-async function createRuntimeSharedDependenciesEntryPoint(options) {
-  const { targetPath, watch } = options;
-  const doWriteSharedDependenciesModule = async () => {
-    const sharedDependencies = moduleFederationCommon.defaultHostSharedDependencies();
-    await writeRuntimeSharedDependenciesModule(
-      targetPath,
-      resolveSharedDependencyVersions(targetPath, sharedDependencies)
-    );
-  };
-  if (watch) {
-    const watcher = chokidar__default.default.watch(path.resolve(targetPath, "package.json"));
-    watcher.on("change", async () => {
-      await doWriteSharedDependenciesModule();
-      watch();
-    });
-  }
-  await doWriteSharedDependenciesModule();
-  return [RUNTIME_SHARED_DEPENDENCIES_MODULE_NAME];
-}
-
-exports.createRuntimeSharedDependenciesEntryPoint = createRuntimeSharedDependenciesEntryPoint;
-exports.getModuleFederationRemoteOptions = getModuleFederationRemoteOptions;
-exports.prepareRuntimeSharedDependenciesScript = prepareRuntimeSharedDependenciesScript;
-//# sourceMappingURL=moduleFederation.cjs.js.map

package/dist/modules/build/lib/bundler/optimization.cjs.js

@@ -1,68 +0,0 @@
-'use strict';
-
-var core = require('@rspack/core');
-
-const optimization = (options) => {
-  const { isDev, webpack } = options;
-  const MinifyPlugin = webpack ? require("esbuild-loader").EsbuildPlugin : core.SwcJsMinimizerRspackPlugin;
-  return {
-    minimize: !isDev,
-    minimizer: [
-      new MinifyPlugin({
-        target: "ES2023",
-        format: "iife",
-        exclude: "remoteEntry.js"
-      }),
-      // Avoid iife wrapping of module federation remote entry as it breaks the variable assignment
-      new MinifyPlugin({
-        target: "ES2023",
-        format: void 0,
-        include: "remoteEntry.js"
-      }),
-      webpack ? void 0 : new core.LightningCssMinimizerRspackPlugin()
-    ],
-    runtimeChunk: "single",
-    splitChunks: {
-      automaticNameDelimiter: "-",
-      cacheGroups: {
-        default: false,
-        // Put all vendor code needed for initial page load in individual files if they're big
-        // enough, if they're smaller they end up in the main
-        packages: {
-          chunks: "initial",
-          test(module) {
-            return Boolean(
-              module?.resource?.match(/[\\/]node_modules[\\/](.*?)([\\/]|$)/)
-            );
-          },
-          name(module) {
-            const packageName = module.resource.match(
-              /[\\/]node_modules[\\/](.*?)([\\/]|$)/
-            )[1];
-            return packageName.replace("@", "");
-          },
-          filename: isDev ? "module-[name].js" : "static/module-[name].[contenthash:8].js",
-          priority: 10,
-          minSize: 1e5,
-          minChunks: 1,
-          ...webpack && {
-            maxAsyncRequests: Infinity,
-            maxInitialRequests: Infinity
-          }
-        },
-        // filename is not included in type, but we need it
-        // Group together the smallest modules
-        vendor: {
-          chunks: "initial",
-          test: /[\\/]node_modules[\\/]/,
-          name: "vendor",
-          priority: 5,
-          enforce: true
-        }
-      }
-    }
-  };
-};
-
-exports.optimization = optimization;
-//# sourceMappingURL=optimization.cjs.js.map

package/dist/modules/build/lib/bundler/packageDetection.cjs.js

@@ -1,124 +0,0 @@
-'use strict';
-
-var config = require('@backstage/config');
-var chokidar = require('chokidar');
-var fs = require('fs-extra');
-var PQueue = require('p-queue');
-var path = require('node:path');
-var cliCommon = require('@backstage/cli-common');
-
-function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
-
-var chokidar__default = /*#__PURE__*/_interopDefaultCompat(chokidar);
-var fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
-var PQueue__default = /*#__PURE__*/_interopDefaultCompat(PQueue);
-
-const DETECTED_MODULES_MODULE_NAME = "__backstage-autodetected-plugins__";
-function readPackageDetectionConfig(config$1) {
-  const packages = config$1.getOptional("app.packages");
-  if (packages === void 0 || packages === null) {
-    return void 0;
-  }
-  if (typeof packages === "string") {
-    if (packages !== "all") {
-      throw new Error(
-        `Invalid app.packages mode, got '${packages}', expected 'all'`
-      );
-    }
-    return {};
-  }
-  if (typeof packages !== "object" || Array.isArray(packages)) {
-    throw new Error("Invalid config at 'app.packages', expected object");
-  }
-  const packagesConfig = new config.ConfigReader(packages, "app.packages");
-  return {
-    include: packagesConfig.getOptionalStringArray("include"),
-    exclude: packagesConfig.getOptionalStringArray("exclude")
-  };
-}
-async function detectPackages(targetPath, { include, exclude }) {
-  const pkg = await fs__default.default.readJson(
-    path.resolve(targetPath, "package.json")
-  );
-  return Object.keys(pkg.dependencies ?? {}).flatMap((depName) => {
-    if (exclude?.includes(depName)) {
-      return [];
-    }
-    if (include && !include.includes(depName)) {
-      return [];
-    }
-    try {
-      const depPackageJson = require(require.resolve(
-        `${depName}/package.json`,
-        { paths: [targetPath] }
-      ));
-      if (["frontend-plugin", "frontend-plugin-module"].includes(
-        depPackageJson.backstage?.role ?? ""
-      )) {
-        const exp = depPackageJson.exports;
-        if (exp && typeof exp === "object" && "./alpha" in exp) {
-          return [
-            { name: depName, import: depName },
-            { name: depName, export: "./alpha", import: `${depName}/alpha` }
-          ];
-        }
-        return [{ name: depName, import: depName }];
-      }
-    } catch {
-    }
-    return [];
-  });
-}
-const writeQueue = new PQueue__default.default({ concurrency: 1 });
-async function writeDetectedPackagesModule(targetPath, pkgs) {
-  const requirePackageScript = pkgs?.map(
-    (pkg) => `{ name: ${JSON.stringify(pkg.name)}, export: ${JSON.stringify(
-      pkg.export
-    )}, default: require('${pkg.import}').default }`
-  ).join(",");
-  await writeQueue.add(async () => {
-    const detectedModulesPath = path.join(
-      targetPath,
-      "node_modules",
-      `${DETECTED_MODULES_MODULE_NAME}.js`
-    );
-    await fs__default.default.ensureDir(path.dirname(detectedModulesPath));
-    await fs__default.default.writeFile(
-      detectedModulesPath,
-      `window['__@backstage/discovered__'] = { modules: [${requirePackageScript}] };`
-    );
-  });
-}
-async function createDetectedModulesEntryPoint(options) {
-  const { config, watch, targetPath } = options;
-  const detectionConfig = readPackageDetectionConfig(config);
-  if (!detectionConfig) {
-    return [];
-  }
-  const legacyDetectedModulesPath = path.join(
-    cliCommon.targetPaths.rootDir,
-    "node_modules",
-    `${DETECTED_MODULES_MODULE_NAME}.js`
-  );
-  if (await fs__default.default.pathExists(legacyDetectedModulesPath)) {
-    await fs__default.default.remove(legacyDetectedModulesPath);
-  }
-  if (watch) {
-    const watcher = chokidar__default.default.watch(path.resolve(targetPath, "package.json"));
-    watcher.on("change", async () => {
-      await writeDetectedPackagesModule(
-        targetPath,
-        await detectPackages(targetPath, detectionConfig)
-      );
-      watch();
-    });
-  }
-  await writeDetectedPackagesModule(
-    targetPath,
-    await detectPackages(targetPath, detectionConfig)
-  );
-  return [DETECTED_MODULES_MODULE_NAME];
-}
-
-exports.createDetectedModulesEntryPoint = createDetectedModulesEntryPoint;
-//# sourceMappingURL=packageDetection.cjs.js.map