@backstage/cli 0.35.4 → 0.35.5-next.0

package/dist/modules/new/lib/execution/PortableTemplater.cjs.js

@@ -13,8 +13,7 @@ var Lockfile = require('../../../../lib/versioning/Lockfile.cjs.js');
 require('minimatch');
 require('@manypkg/get-packages');
 require('@backstage/errors');
-require('@backstage/cli-common');
-var paths = require('../../../../lib/paths.cjs.js');
+var cliCommon = require('@backstage/cli-common');
 var version = require('../../../../lib/version.cjs.js');
 var yarnPlugin = require('../../../../lib/yarnPlugin.cjs.js');
 
@@ -44,7 +43,7 @@ class PortableTemplater {
   static async create(options = {}) {
     let lockfile;
     try {
-      lockfile = await Lockfile.Lockfile.load(paths.paths.resolveTargetRoot("yarn.lock"));
+      lockfile = await Lockfile.Lockfile.load(cliCommon.targetPaths.resolveRoot("yarn.lock"));
     } catch {
     }
     const hasYarnPlugin = await yarnPlugin.getHasYarnPlugin();

package/dist/modules/new/lib/execution/installNewPackage.cjs.js

@@ -3,7 +3,7 @@
 var fs = require('fs-extra');
 var upperFirst = require('lodash/upperFirst');
 var camelCase = require('lodash/camelCase');
-var paths = require('../../../../lib/paths.cjs.js');
+var cliCommon = require('@backstage/cli-common');
 var tasks = require('../tasks.cjs.js');
 
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
@@ -44,7 +44,7 @@ async function installNewPackage(input) {
   }
 }
 async function addDependency(input, path) {
-  const pkgJsonPath = paths.paths.resolveTargetRoot(path);
+  const pkgJsonPath = cliCommon.targetPaths.resolveRoot(path);
   const pkgJson = await fs__default.default.readJson(pkgJsonPath).catch((error) => {
     if (error.code === "ENOENT") {
       return void 0;
@@ -71,7 +71,7 @@ async function tryAddFrontendLegacy(input) {
       "add-frontend-legacy can only be used for frontend plugins"
     );
   }
-  const appDefinitionPath = paths.paths.resolveTargetRoot("packages/app/src/App.tsx");
+  const appDefinitionPath = cliCommon.targetPaths.resolveRoot("packages/app/src/App.tsx");
   if (!await fs__default.default.pathExists(appDefinitionPath)) {
     return;
   }
@@ -101,7 +101,7 @@ async function tryAddFrontendLegacy(input) {
   });
 }
 async function tryAddBackend(input) {
-  const backendIndexPath = paths.paths.resolveTargetRoot(
+  const backendIndexPath = cliCommon.targetPaths.resolveRoot(
     "packages/backend/src/index.ts"
   );
   if (!await fs__default.default.pathExists(backendIndexPath)) {

package/dist/modules/new/lib/execution/writeTemplateContents.cjs.js

@@ -2,7 +2,6 @@
 
 var fs = require('fs-extra');
 var path = require('node:path');
-var paths = require('../../../../lib/paths.cjs.js');
 var errors = require('@backstage/errors');
 var cliNode = require('@backstage/cli-node');
 var PortableTemplater = require('./PortableTemplater.cjs.js');
@@ -13,7 +12,7 @@ function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'defau
 var fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
 
 async function writeTemplateContents(template, input) {
-  const targetDir = paths.paths.resolveTargetRoot(input.packagePath);
+  const targetDir = cliCommon.targetPaths.resolveRoot(input.packagePath);
   if (await fs__default.default.pathExists(targetDir)) {
     throw new errors.InputError(`Package '${input.packagePath}' already exists`);
   }

package/dist/modules/new/lib/preparation/collectPortableTemplateInput.cjs.js

@@ -2,7 +2,7 @@
 
 var inquirer = require('inquirer');
 var codeowners = require('../codeowners/codeowners.cjs.js');
-var paths = require('../../../../lib/paths.cjs.js');
+var cliCommon = require('@backstage/cli-common');
 var resolvePackageParams = require('./resolvePackageParams.cjs.js');
 
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
@@ -11,7 +11,7 @@ var inquirer__default = /*#__PURE__*/_interopDefaultCompat(inquirer);
 
 async function collectPortableTemplateInput(options) {
   const { config, template, prefilledParams } = options;
-  const codeOwnersFilePath = await codeowners.getCodeownersFilePath(paths.paths.targetRoot);
+  const codeOwnersFilePath = await codeowners.getCodeownersFilePath(cliCommon.targetPaths.rootDir);
   const prompts = getPromptsForRole(template.role);
   if (codeOwnersFilePath) {
     prompts.push(ownerPrompt());

package/dist/modules/new/lib/preparation/loadPortableTemplate.cjs.js

@@ -5,7 +5,7 @@ var fs = require('fs-extra');
 var recursiveReaddir = require('recursive-readdir');
 var path = require('node:path');
 var yaml = require('yaml');
-var paths = require('../../../../lib/paths.cjs.js');
+var cliCommon = require('@backstage/cli-common');
 var types = require('../types.cjs.js');
 var errors = require('@backstage/errors');
 var v3 = require('zod-validation-error/v3');
@@ -25,7 +25,7 @@ async function loadPortableTemplate(pointer) {
   if (pointer.target.match(/https?:\/\//)) {
     throw new Error("Remote templates are not supported yet");
   }
-  const templateContent = await fs__default.default.readFile(paths.paths.resolveTargetRoot(pointer.target), "utf-8").catch((error) => {
+  const templateContent = await fs__default.default.readFile(cliCommon.targetPaths.resolveRoot(pointer.target), "utf-8").catch((error) => {
     throw new errors.ForwardedError(
       `Failed to load template definition from '${pointer.target}'`,
       error

package/dist/modules/new/lib/preparation/loadPortableTemplateConfig.cjs.js

@@ -2,7 +2,7 @@
 
 var fs = require('fs-extra');
 var path = require('node:path');
-var paths = require('../../../../lib/paths.cjs.js');
+var cliCommon = require('@backstage/cli-common');
 var defaultTemplates = require('../defaultTemplates.cjs.js');
 var types = require('../types.cjs.js');
 var yaml = require('yaml');
@@ -48,7 +48,7 @@ function computePackageNamePluginInfix(packageNamePrefix, namePluginInfix) {
 }
 async function loadPortableTemplateConfig(options = {}) {
   const { overrides = {} } = options;
-  const pkgPath = options.packagePath ?? paths.paths.resolveTargetRoot("package.json");
+  const pkgPath = options.packagePath ?? cliCommon.targetPaths.resolveRoot("package.json");
   const pkgJson = await fs__default.default.readJson(pkgPath);
   const parsed = pkgJsonWithNewConfigSchema.safeParse(pkgJson);
   if (!parsed.success) {

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");

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

@@ -6,7 +6,6 @@ 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');
 
@@ -19,7 +18,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 +99,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");
@@ -211,7 +210,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");

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

@@ -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,104 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+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 (options) => {
+  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,141 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+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 (options) => {
+  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,59 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var yargs = require('yargs');
+var factory = require('../../wiring/factory.cjs.js');
+var lazy = require('../../lib/lazy.cjs.js');
+var messageFilePath = require('./lib/messageFilePath.cjs.js');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var yargs__default = /*#__PURE__*/_interopDefaultCompat(yargs);
+
+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: async ({ args }) => {
+        const argv = await yargs__default.default().options({
+          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"
+          }
+        }).help().parse(args);
+        await lazy.lazy(() => import('./commands/export.cjs.js'), "default")(argv);
+      }
+    });
+    reg.addCommand({
+      path: ["translations", "import"],
+      description: "Generate translation resource wiring from translated JSON files",
+      execute: async ({ args }) => {
+        const argv = await yargs__default.default().options({
+          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"
+          }
+        }).help().parse(args);
+        await lazy.lazy(() => import('./commands/import.cjs.js'), "default")(argv);
+      }
+    });
+  }
+});
+
+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