@backstage/cli 0.35.4 → 0.36.0-next.1

package/dist/{lib → modules/new/lib}/version.cjs.js

@@ -1,34 +1,31 @@
 'use strict';
 
-var fs = require('fs-extra');
 var semver = require('semver');
-var paths = require('./paths.cjs.js');
-var _package$k = require('../packages/backend-plugin-api/package.json.cjs.js');
-var _package$j = require('../packages/backend-test-utils/package.json.cjs.js');
-var _package$i = require('../packages/catalog-client/package.json.cjs.js');
-var _package$h = require('../packages/cli/package.json.cjs.js');
-var _package$g = require('../packages/config/package.json.cjs.js');
-var _package$f = require('../packages/core-app-api/package.json.cjs.js');
-var _package$e = require('../packages/core-components/package.json.cjs.js');
-var _package$d = require('../packages/core-plugin-api/package.json.cjs.js');
-var _package$c = require('../packages/dev-utils/package.json.cjs.js');
-var _package$b = require('../packages/errors/package.json.cjs.js');
-var _package$a = require('../packages/frontend-defaults/package.json.cjs.js');
-var _package$9 = require('../packages/frontend-plugin-api/package.json.cjs.js');
-var _package$8 = require('../packages/frontend-test-utils/package.json.cjs.js');
-var _package$7 = require('../packages/test-utils/package.json.cjs.js');
-var _package$4 = require('../plugins/scaffolder-node/package.json.cjs.js');
-var _package$3 = require('../plugins/scaffolder-node-test-utils/package.json.cjs.js');
-var _package$2 = require('../plugins/auth-backend/package.json.cjs.js');
-var _package$1 = require('../plugins/auth-backend-module-guest-provider/package.json.cjs.js');
-var _package = require('../plugins/catalog-node/package.json.cjs.js');
-var _package$6 = require('../packages/theme/package.json.cjs.js');
-var _package$5 = require('../packages/types/package.json.cjs.js');
-var _package$l = require('../packages/backend-defaults/package.json.cjs.js');
+var _package$k = require('../../../packages/backend-plugin-api/package.json.cjs.js');
+var _package$j = require('../../../packages/backend-test-utils/package.json.cjs.js');
+var _package$i = require('../../../packages/catalog-client/package.json.cjs.js');
+var _package$h = require('../../../packages/cli/package.json.cjs.js');
+var _package$g = require('../../../packages/config/package.json.cjs.js');
+var _package$f = require('../../../packages/core-app-api/package.json.cjs.js');
+var _package$e = require('../../../packages/core-components/package.json.cjs.js');
+var _package$d = require('../../../packages/core-plugin-api/package.json.cjs.js');
+var _package$c = require('../../../packages/dev-utils/package.json.cjs.js');
+var _package$b = require('../../../packages/errors/package.json.cjs.js');
+var _package$a = require('../../../packages/frontend-defaults/package.json.cjs.js');
+var _package$9 = require('../../../packages/frontend-plugin-api/package.json.cjs.js');
+var _package$8 = require('../../../packages/frontend-test-utils/package.json.cjs.js');
+var _package$7 = require('../../../packages/test-utils/package.json.cjs.js');
+var _package$4 = require('../../../plugins/scaffolder-node/package.json.cjs.js');
+var _package$3 = require('../../../plugins/scaffolder-node-test-utils/package.json.cjs.js');
+var _package$2 = require('../../../plugins/auth-backend/package.json.cjs.js');
+var _package$1 = require('../../../plugins/auth-backend-module-guest-provider/package.json.cjs.js');
+var _package = require('../../../plugins/catalog-node/package.json.cjs.js');
+var _package$6 = require('../../../packages/theme/package.json.cjs.js');
+var _package$5 = require('../../../packages/types/package.json.cjs.js');
+var _package$l = require('../../../packages/backend-defaults/package.json.cjs.js');
 
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
 
-var fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
 var semver__default = /*#__PURE__*/_interopDefaultCompat(semver);
 
 const packageVersions = {
@@ -55,12 +52,6 @@ const packageVersions = {
   "@backstage/plugin-auth-backend-module-guest-provider": _package$1.version,
   "@backstage/plugin-catalog-node": _package.version
 };
-function findVersion() {
-  const pkgContent = fs__default.default.readFileSync(paths.paths.resolveOwn("package.json"), "utf8");
-  return JSON.parse(pkgContent).version;
-}
-const version = findVersion();
-fs__default.default.pathExistsSync(paths.paths.resolveOwn("src"));
 function createPackageVersionProvider(lockfile, options) {
   return (name, versionHint) => {
     const packageVersion = packageVersions[name];
@@ -96,7 +87,5 @@ function createPackageVersionProvider(lockfile, options) {
 }
 
 exports.createPackageVersionProvider = createPackageVersionProvider;
-exports.findVersion = findVersion;
 exports.packageVersions = packageVersions;
-exports.version = version;
 //# sourceMappingURL=version.cjs.js.map

package/dist/modules/test/commands/package/test.cjs.js

@@ -2,7 +2,6 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var paths = require('../../../../lib/paths.cjs.js');
 var cliCommon = require('@backstage/cli-common');
 
 function includesAnyOf(hayStack, ...needles) {
@@ -21,7 +20,7 @@ var test = async (_opts, cmd) => {
   const allArgs = parent.args;
   const args = allArgs.slice(allArgs.indexOf("test") + 1);
   if (!includesAnyOf(args, "-c", "--config")) {
-    args.push("--config", paths.paths.resolveOwn("config/jest.js"));
+    args.push("--config", cliCommon.findOwnPaths(__dirname).resolve("config/jest.js"));
   }
   if (!includesAnyOf(args, "--no-passWithNoTests", "--passWithNoTests=false")) {
     args.push("--passWithNoTests");
@@ -46,9 +45,6 @@ var test = async (_opts, cmd) => {
   if (!process.env.NODE_OPTIONS?.includes("--node-snapshot")) {
     process.env.NODE_OPTIONS = `${process.env.NODE_OPTIONS ? `${process.env.NODE_OPTIONS} ` : ""}--no-node-snapshot`;
   }
-  if (args.includes("--help")) {
-    process.stdout._handle.setBlocking(true);
-  }
   try {
     require.resolve("jest");
   } catch {

package/dist/modules/test/commands/repo/test.cjs.js

@@ -6,9 +6,7 @@ var yargs = require('yargs');
 var jestCli = require('jest-cli');
 var path = require('node:path');
 var cliNode = require('@backstage/cli-node');
-var paths = require('../../../../lib/paths.cjs.js');
 var cliCommon = require('@backstage/cli-common');
-var SuccessCache = require('../../../../lib/cache/SuccessCache.cjs.js');
 
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
 
@@ -19,7 +17,7 @@ var yargs__default = /*#__PURE__*/_interopDefaultCompat(yargs);
 async function readPackageTreeHashes(graph) {
   const pkgs = Array.from(graph.values()).map((pkg) => ({
     ...pkg,
-    path: path.relative(paths.paths.targetRoot, pkg.dir)
+    path: path.relative(cliCommon.targetPaths.rootDir, pkg.dir)
   }));
   const output = await cliCommon.runOutput([
     "git",
@@ -100,7 +98,7 @@ async function command(opts, cmd) {
   const hasFlags = createFlagFinder(args);
   const { _: parsedArgs } = await yargs__default.default(args).options(jestCli.yargsOptions).argv;
   if (!hasFlags("-c", "--config")) {
-    args.push("--config", paths.paths.resolveOwn("config/jest.js"));
+    args.push("--config", cliCommon.findOwnPaths(__dirname).resolve("config/jest.js"));
   }
   if (!hasFlags("--passWithNoTests")) {
     args.push("--passWithNoTests");
@@ -185,7 +183,6 @@ async function command(opts, cmd) {
   if (args.includes("--jest-help")) {
     removeOptionArg(args, "--jest-help");
     args.push("--help");
-    process.stdout._handle.setBlocking(true);
   }
   if (opts.successCache) {
     removeOptionArg(args, "--successCache", 1);
@@ -202,7 +199,10 @@ async function command(opts, cmd) {
         `The --successCache flag can not be combined with the --shard flag`
       );
     }
-    const cache = new SuccessCache.SuccessCache("test", opts.successCacheDir);
+    const cache = cliNode.SuccessCache.create({
+      name: "test",
+      basePath: opts.successCacheDir
+    });
     const graph = await getPackageGraph();
     const projectHashes = /* @__PURE__ */ new Map();
     const outputSuccessCache = new Array();
@@ -211,7 +211,7 @@ async function command(opts, cmd) {
       async filterConfigs(projectConfigs, globalRootConfig) {
         const cacheEntries = await cache.read();
         const lockfile = await cliNode.Lockfile.load(
-          paths.paths.resolveTargetRoot("yarn.lock")
+          cliCommon.targetPaths.resolveRoot("yarn.lock")
         );
         const getPackageTreeHash = await readPackageTreeHashes(graph);
         const baseHash = crypto__default.default.createHash("sha1");
@@ -220,7 +220,7 @@ async function command(opts, cmd) {
         baseHash.update(process.version);
         baseHash.update("\0");
         baseHash.update(
-          SuccessCache.SuccessCache.trimPaths(JSON.stringify(globalRootConfig))
+          cliNode.SuccessCache.trimPaths(JSON.stringify(globalRootConfig))
         );
         const baseSha = baseHash.digest("hex");
         return projectConfigs.filter((project) => {
@@ -239,7 +239,7 @@ async function command(opts, cmd) {
             const depHash = getPackageTreeHash(depPkg.name);
             hash.update(`${depName}:${depHash}`);
           }
-          hash.update(SuccessCache.SuccessCache.trimPaths(JSON.stringify(project)));
+          hash.update(cliNode.SuccessCache.trimPaths(JSON.stringify(project)));
           hash.update(lockfile.getDependencyTreeHash(packageName));
           const sha = hash.digest("hex");
           projectHashes.set(packageName, sha);

package/dist/modules/test/index.cjs.js

@@ -4,7 +4,7 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var factory = require('../../wiring/factory.cjs.js');
 var commander = require('commander');
-var lazy = require('../../lib/lazy.cjs.js');
+var lazy = require('../../wiring/lazy.cjs.js');
 
 var index = factory.createCliPlugin({
   pluginId: "test",
@@ -15,6 +15,7 @@ var index = factory.createCliPlugin({
       execute: async ({ args }) => {
         const command = new commander.Command();
         command.allowUnknownOption(true);
+        command.allowExcessArguments(true);
         command.option(
           "--since <ref>",
           "Only test packages that changed since the specified ref"
@@ -38,7 +39,8 @@ var index = factory.createCliPlugin({
       execute: async ({ args }) => {
         const command = new commander.Command();
         command.allowUnknownOption(true);
-        command.helpOption(", --backstage-cli-help");
+        command.allowExcessArguments(true);
+        command.helpOption("--backstage-cli-help");
         command.action(
           lazy.lazy(() => import('./commands/package/test.cjs.js'), "default")
         );

package/dist/modules/translations/commands/export.cjs.js

@@ -0,0 +1,127 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var cleye = require('cleye');
+var cliCommon = require('@backstage/cli-common');
+var fs = require('fs-extra');
+var path = require('node:path');
+var discoverPackages = require('../lib/discoverPackages.cjs.js');
+var extractTranslations = require('../lib/extractTranslations.cjs.js');
+var messageFilePath = require('../lib/messageFilePath.cjs.js');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
+
+var _export = async ({ args, info }) => {
+  const {
+    flags: { output, pattern }
+  } = cleye.cli(
+    {
+      help: info,
+      flags: {
+        output: {
+          type: String,
+          default: "translations",
+          description: "Output directory for exported messages and manifest"
+        },
+        pattern: {
+          type: String,
+          default: messageFilePath.DEFAULT_MESSAGE_PATTERN,
+          description: "File path pattern for message files, with {id} and {lang} placeholders"
+        }
+      }
+    },
+    void 0,
+    args
+  );
+  const options = { output, pattern };
+  messageFilePath.validatePattern(options.pattern);
+  const targetPackageJson = await discoverPackages.readTargetPackage(
+    cliCommon.targetPaths.dir,
+    cliCommon.targetPaths.rootDir
+  );
+  const outputDir = path.resolve(cliCommon.targetPaths.dir, options.output);
+  const manifestPath = path.resolve(outputDir, "manifest.json");
+  const tsconfigPath = cliCommon.targetPaths.resolveRoot("tsconfig.json");
+  if (!await fs__default.default.pathExists(tsconfigPath)) {
+    throw new Error(
+      `No tsconfig.json found at ${tsconfigPath}. The translations export command requires a tsconfig.json in the repo root.`
+    );
+  }
+  console.log(
+    `Discovering frontend dependencies of ${targetPackageJson.name}...`
+  );
+  const packages = await discoverPackages.discoverFrontendPackages(
+    targetPackageJson,
+    cliCommon.targetPaths.dir
+  );
+  console.log(`Found ${packages.length} frontend packages to scan`);
+  console.log("Creating TypeScript project...");
+  const project = extractTranslations.createTranslationProject(tsconfigPath);
+  const allRefs = [];
+  for (const pkg of packages) {
+    for (const [exportPath, filePath] of pkg.entryPoints) {
+      try {
+        const sourceFile = project.addSourceFileAtPath(filePath);
+        const refs = extractTranslations.extractTranslationRefsFromSourceFile(
+          sourceFile,
+          pkg.name,
+          exportPath
+        );
+        allRefs.push(...refs);
+      } catch (error) {
+        console.warn(
+          `  Warning: failed to process ${pkg.name} (${exportPath}): ${error}`
+        );
+      }
+    }
+  }
+  if (allRefs.length === 0) {
+    console.log("No translation refs found.");
+    return;
+  }
+  console.log(`Found ${allRefs.length} translation ref(s):`);
+  for (const ref of allRefs) {
+    const messageCount = Object.keys(ref.messages).length;
+    console.log(`  ${ref.id} (${ref.packageName}, ${messageCount} messages)`);
+  }
+  for (const ref of allRefs) {
+    const relPath = messageFilePath.formatMessagePath(
+      options.pattern,
+      ref.id,
+      messageFilePath.DEFAULT_LANGUAGE
+    );
+    const filePath = path.resolve(outputDir, relPath);
+    await fs__default.default.ensureDir(path.dirname(filePath));
+    await fs__default.default.writeJson(filePath, ref.messages, { spaces: 2 });
+  }
+  const manifest = {};
+  for (const ref of allRefs) {
+    manifest[ref.id] = {
+      package: ref.packageName,
+      exportPath: ref.exportPath,
+      exportName: ref.exportName
+    };
+  }
+  await fs__default.default.writeJson(
+    manifestPath,
+    { pattern: options.pattern, refs: manifest },
+    { spaces: 2 }
+  );
+  const examplePath = messageFilePath.formatMessagePath(
+    options.pattern,
+    "<ref-id>",
+    messageFilePath.DEFAULT_LANGUAGE
+  );
+  console.log(
+    `
+Exported ${allRefs.length} translation ref(s) to ${options.output}/`
+  );
+  console.log(`  Messages: ${options.output}/${examplePath}`);
+  console.log(`  Manifest: ${options.output}/manifest.json`);
+};
+
+exports.default = _export;
+//# sourceMappingURL=export.cjs.js.map

package/dist/modules/translations/commands/import.cjs.js

@@ -0,0 +1,164 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var cleye = require('cleye');
+var cliCommon = require('@backstage/cli-common');
+var fs = require('fs-extra');
+var path = require('node:path');
+var discoverPackages = require('../lib/discoverPackages.cjs.js');
+var messageFilePath = require('../lib/messageFilePath.cjs.js');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
+
+var _import = async ({ args, info }) => {
+  const {
+    flags: { input, output }
+  } = cleye.cli(
+    {
+      help: info,
+      flags: {
+        input: {
+          type: String,
+          default: "translations",
+          description: "Input directory containing the manifest and translated message files"
+        },
+        output: {
+          type: String,
+          default: "src/translations/resources.ts",
+          description: "Output path for the generated wiring module"
+        }
+      }
+    },
+    void 0,
+    args
+  );
+  const options = { input, output };
+  await discoverPackages.readTargetPackage(cliCommon.targetPaths.dir, cliCommon.targetPaths.rootDir);
+  const inputDir = path.resolve(cliCommon.targetPaths.dir, options.input);
+  const manifestPath = path.resolve(inputDir, "manifest.json");
+  const outputPath = path.resolve(cliCommon.targetPaths.dir, options.output);
+  if (!await fs__default.default.pathExists(manifestPath)) {
+    throw new Error(
+      `No manifest.json found at ${manifestPath}. Run "backstage-cli translations export" first.`
+    );
+  }
+  const manifest = await fs__default.default.readJson(manifestPath);
+  if (!manifest.pattern) {
+    throw new Error(
+      'No pattern found in manifest.json. Re-run "backstage-cli translations export" to regenerate it.'
+    );
+  }
+  const pattern = manifest.pattern;
+  const parsePath = messageFilePath.createMessagePathParser(pattern);
+  const allFiles = (await collectJsonFiles(inputDir)).filter(
+    (f) => f !== "manifest.json"
+  );
+  const translationsByRef = /* @__PURE__ */ new Map();
+  let skipped = 0;
+  for (const relPath of allFiles) {
+    const parsed = parsePath(relPath);
+    if (!parsed) {
+      skipped++;
+      continue;
+    }
+    if (parsed.lang === messageFilePath.DEFAULT_LANGUAGE) {
+      continue;
+    }
+    if (!manifest.refs[parsed.id]) {
+      console.warn(
+        `  Warning: skipping ${relPath} - ref '${parsed.id}' not found in manifest`
+      );
+      continue;
+    }
+    const existing = translationsByRef.get(parsed.id) ?? [];
+    existing.push({ lang: parsed.lang, relPath });
+    translationsByRef.set(parsed.id, existing);
+  }
+  if (skipped > 0) {
+    console.warn(
+      `  Warning: ${skipped} file(s) did not match the pattern '${pattern}'`
+    );
+  }
+  if (translationsByRef.size === 0) {
+    console.log("No translated message files found.");
+    const example = messageFilePath.formatMessagePath(pattern, "<ref-id>", "sv");
+    console.log(
+      `Add translated files as ${example} in the translations directory.`
+    );
+    return;
+  }
+  const importLines = [];
+  const resourceLines = [];
+  importLines.push(
+    "import { createTranslationResource } from '@backstage/frontend-plugin-api';"
+  );
+  for (const [refId, entries] of [...translationsByRef.entries()].sort(
+    ([a], [b]) => a.localeCompare(b)
+  )) {
+    const refEntry = manifest.refs[refId];
+    const importPath = refEntry.exportPath === "." ? refEntry.package : `${refEntry.package}/${refEntry.exportPath.replace(/^\.\//, "")}`;
+    importLines.push(`import { ${refEntry.exportName} } from '${importPath}';`);
+    const translationEntries = entries.sort((a, b) => a.lang.localeCompare(b.lang)).map(({ lang, relPath }) => {
+      const jsonRelPath = path.relative(
+        path.resolve(outputPath, ".."),
+        path.resolve(inputDir, relPath)
+      ).split(path.sep).join("/");
+      return `    ${JSON.stringify(lang)}: () => import('./${jsonRelPath}'),`;
+    }).join("\n");
+    resourceLines.push(
+      [
+        `  createTranslationResource({`,
+        `    ref: ${refEntry.exportName},`,
+        `    translations: {`,
+        translationEntries,
+        `    },`,
+        `  }),`
+      ].join("\n")
+    );
+  }
+  const fileContent = [
+    "// This file is auto-generated by backstage-cli translations import",
+    "// Do not edit manually.",
+    "",
+    ...importLines,
+    "",
+    "export default [",
+    ...resourceLines,
+    "];",
+    ""
+  ].join("\n");
+  await fs__default.default.ensureDir(path.resolve(outputPath, ".."));
+  await fs__default.default.writeFile(outputPath, fileContent, "utf8");
+  const totalFiles = [...translationsByRef.values()].reduce(
+    (sum, e) => sum + e.length,
+    0
+  );
+  console.log(`Generated translation resources at ${options.output}`);
+  console.log(
+    `  ${translationsByRef.size} ref(s), ${totalFiles} translation file(s)`
+  );
+  console.log(
+    "\nImport this file in your app and pass the resources to your translation API setup."
+  );
+};
+async function collectJsonFiles(dir, prefix = "") {
+  const entries = await fs__default.default.readdir(dir, { withFileTypes: true });
+  const results = [];
+  for (const entry of entries) {
+    const relPath = prefix ? `${prefix}/${entry.name}` : entry.name;
+    if (entry.isDirectory()) {
+      results.push(
+        ...await collectJsonFiles(path.resolve(dir, entry.name), relPath)
+      );
+    } else if (entry.isFile() && entry.name.endsWith(".json")) {
+      results.push(relPath);
+    }
+  }
+  return results;
+}
+
+exports.default = _import;
+//# sourceMappingURL=import.cjs.js.map

package/dist/modules/translations/index.cjs.js

@@ -0,0 +1,24 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var factory = require('../../wiring/factory.cjs.js');
+
+var index = factory.createCliPlugin({
+  pluginId: "translations",
+  init: async (reg) => {
+    reg.addCommand({
+      path: ["translations", "export"],
+      description: "Export translation messages from an app and all of its frontend plugins to JSON files",
+      execute: { loader: () => import('./commands/export.cjs.js') }
+    });
+    reg.addCommand({
+      path: ["translations", "import"],
+      description: "Generate translation resource wiring from translated JSON files",
+      execute: { loader: () => import('./commands/import.cjs.js') }
+    });
+  }
+});
+
+exports.default = index;
+//# sourceMappingURL=index.cjs.js.map

package/dist/modules/translations/lib/discoverPackages.cjs.js

@@ -0,0 +1,121 @@
+'use strict';
+
+var cliNode = require('@backstage/cli-node');
+var path = require('node:path');
+var fs = require('fs-extra');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
+
+async function readTargetPackage(packageDir, repoRoot) {
+  const packageJsonPath = path.resolve(packageDir, "package.json");
+  if (!await fs__default.default.pathExists(packageJsonPath)) {
+    throw new Error(
+      "No package.json found in the current directory. The translations commands must be run from within a package directory."
+    );
+  }
+  if (path.resolve(packageDir) === path.resolve(repoRoot)) {
+    throw new Error(
+      "The translations commands must be run from within a package directory, not from the repository root. For example: cd packages/app && backstage-cli translations export"
+    );
+  }
+  return fs__default.default.readJson(packageJsonPath);
+}
+async function discoverFrontendPackages(targetPackageJson, targetDir) {
+  let workspaceByName;
+  try {
+    const workspacePackages = await cliNode.PackageGraph.listTargetPackages();
+    workspaceByName = new Map(
+      workspacePackages.map((p) => [p.packageJson.name, p])
+    );
+  } catch {
+    workspaceByName = /* @__PURE__ */ new Map();
+  }
+  const visited = /* @__PURE__ */ new Set();
+  const result = [];
+  async function visit(packageJson, pkgDir, includeDevDeps) {
+    const deps = {
+      ...packageJson.dependencies,
+      ...includeDevDeps ? packageJson.devDependencies ?? {} : {}
+    };
+    for (const depName of Object.keys(deps)) {
+      if (visited.has(depName)) {
+        continue;
+      }
+      visited.add(depName);
+      let depPkgJson;
+      let depDir;
+      let isWorkspace;
+      const workspacePkg = workspaceByName.get(depName);
+      if (workspacePkg) {
+        depPkgJson = workspacePkg.packageJson;
+        depDir = workspacePkg.dir;
+        isWorkspace = true;
+      } else {
+        try {
+          const pkgJsonPath = require.resolve(`${depName}/package.json`, {
+            paths: [pkgDir]
+          });
+          depPkgJson = await fs__default.default.readJson(pkgJsonPath);
+          depDir = path.dirname(pkgJsonPath);
+          isWorkspace = false;
+        } catch {
+          continue;
+        }
+      }
+      if (!depPkgJson.backstage) {
+        continue;
+      }
+      const role = depPkgJson.backstage?.role;
+      if (role && isFrontendRole(role)) {
+        const entryPoints = resolveEntryPoints(depPkgJson, depDir, isWorkspace);
+        if (entryPoints.size > 0) {
+          result.push({ name: depName, dir: depDir, entryPoints });
+        }
+      }
+      await visit(depPkgJson, depDir, false);
+    }
+  }
+  await visit(targetPackageJson, targetDir, true);
+  return result;
+}
+function resolveEntryPoints(packageJson, packageDir, isWorkspace) {
+  const entryPoints = /* @__PURE__ */ new Map();
+  const exports$1 = packageJson.exports;
+  if (exports$1) {
+    for (const [subpath, target] of Object.entries(exports$1)) {
+      if (subpath === "./package.json") {
+        continue;
+      }
+      let filePath;
+      if (typeof target === "string") {
+        filePath = target;
+      } else if (isWorkspace) {
+        filePath = target?.import ?? target?.types ?? target?.default;
+      } else {
+        filePath = target?.types ?? target?.import ?? target?.default;
+      }
+      if (typeof filePath === "string") {
+        entryPoints.set(subpath, path.resolve(packageDir, filePath));
+      }
+    }
+  } else {
+    const main = isWorkspace ? packageJson.main ?? packageJson.types : packageJson.types ?? packageJson.main;
+    if (main) {
+      entryPoints.set(".", path.resolve(packageDir, main));
+    }
+  }
+  return entryPoints;
+}
+function isFrontendRole(role) {
+  try {
+    return cliNode.PackageRoles.getRoleInfo(role).platform === "web";
+  } catch {
+    return false;
+  }
+}
+
+exports.discoverFrontendPackages = discoverFrontendPackages;
+exports.readTargetPackage = readTargetPackage;
+//# sourceMappingURL=discoverPackages.cjs.js.map