@backstage/cli 0.36.0-next.2 → 0.36.0

package/dist/modules/build/lib/packager/createDistWorkspace.cjs.js

@@ -1,235 +0,0 @@
-'use strict';
-
-var chalk = require('chalk');
-var fs = require('fs-extra');
-var path = require('node:path');
-var os = require('node:os');
-var tar = require('tar');
-var partition = require('lodash/partition');
-var cliCommon = require('@backstage/cli-common');
-var _package = require('../../../../packages/cli/package.json.cjs.js');
-var packager = require('../builder/packager.cjs.js');
-var types = require('../builder/types.cjs.js');
-var productionPack = require('./productionPack.cjs.js');
-var cliNode = require('@backstage/cli-node');
-var typeDistProject = require('../typeDistProject.cjs.js');
-
-function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
-
-function _interopNamespaceCompat(e) {
-  if (e && typeof e === 'object' && 'default' in e) return e;
-  var n = Object.create(null);
-  if (e) {
-    Object.keys(e).forEach(function (k) {
-      if (k !== 'default') {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () { return e[k]; }
-        });
-      }
-    });
-  }
-  n.default = e;
-  return Object.freeze(n);
-}
-
-var chalk__default = /*#__PURE__*/_interopDefaultCompat(chalk);
-var fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
-var tar__namespace = /*#__PURE__*/_interopNamespaceCompat(tar);
-var partition__default = /*#__PURE__*/_interopDefaultCompat(partition);
-
-const UNSAFE_PACKAGES = [
-  ...Object.keys(_package.dependencies),
-  ...Object.keys(_package.devDependencies)
-];
-function prefixLogFunc(prefix, out) {
-  return (data) => {
-    for (const line of data.toString("utf8").split(/\r?\n/)) {
-      process[out].write(`${prefix} ${line}
-`);
-    }
-  };
-}
-async function createDistWorkspace(packageNames, options = {}) {
-  const targetDir = options.targetDir ?? await fs__default.default.mkdtemp(path.resolve(os.tmpdir(), "dist-workspace"));
-  const packages = await cliNode.PackageGraph.listTargetPackages();
-  const packageGraph = cliNode.PackageGraph.fromPackages(packages);
-  const targetNames = packageGraph.collectPackageNames(packageNames, (node) => {
-    if (node.packageJson.bundled) {
-      return void 0;
-    }
-    return node.publishedLocalDependencies.keys();
-  });
-  const targets = Array.from(targetNames).map((name) => packageGraph.get(name));
-  if (options.buildDependencies) {
-    const exclude = options.buildExcludes ?? [];
-    const configPaths = options.configPaths ?? [];
-    const toBuild = new Set(
-      targets.map((_) => _.name).filter((name) => !exclude.includes(name))
-    );
-    const standardBuilds = new Array();
-    const customBuild = new Array();
-    for (const pkg of packages) {
-      if (!toBuild.has(pkg.packageJson.name)) {
-        continue;
-      }
-      const role = pkg.packageJson.backstage?.role;
-      if (!role) {
-        console.warn(
-          `Building ${pkg.packageJson.name} separately because it has no role`
-        );
-        customBuild.push({ dir: pkg.dir, name: pkg.packageJson.name });
-        continue;
-      }
-      const buildScript = pkg.packageJson.scripts?.build;
-      if (!buildScript) {
-        customBuild.push({ dir: pkg.dir, name: pkg.packageJson.name });
-        continue;
-      }
-      if (!buildScript.startsWith("backstage-cli package build")) {
-        console.warn(
-          `Building ${pkg.packageJson.name} separately because it has a custom build script, '${buildScript}'`
-        );
-        customBuild.push({ dir: pkg.dir, name: pkg.packageJson.name });
-        continue;
-      }
-      if (cliNode.PackageRoles.getRoleInfo(role).output.includes("bundle")) {
-        console.warn(
-          `Building ${pkg.packageJson.name} separately because it is a bundled package`
-        );
-        const args = buildScript.includes("--config") ? [] : configPaths.map((p) => ["--config", p]).flat();
-        customBuild.push({ dir: pkg.dir, name: pkg.packageJson.name, args });
-        continue;
-      }
-      const outputs = packager.getOutputsForRole(role);
-      outputs.delete(types.Output.types);
-      if (outputs.size > 0) {
-        standardBuilds.push({
-          targetDir: pkg.dir,
-          packageJson: pkg.packageJson,
-          outputs,
-          logPrefix: `${chalk__default.default.cyan(
-            path.relative(cliCommon.targetPaths.rootDir, pkg.dir)
-          )}: `,
-          minify: options.minify,
-          workspacePackages: packages
-        });
-      }
-    }
-    await packager.buildPackages(standardBuilds);
-    if (customBuild.length > 0) {
-      await cliNode.runConcurrentTasks({
-        items: customBuild,
-        worker: async ({ name, dir, args }) => {
-          await cliCommon.run(["yarn", "run", "build", ...args || []], {
-            cwd: dir,
-            onStdout: prefixLogFunc(`${name}: `, "stdout"),
-            onStderr: prefixLogFunc(`${name}: `, "stderr")
-          }).waitForExit();
-        }
-      });
-    }
-  }
-  await moveToDistWorkspace(
-    targetDir,
-    targets,
-    Boolean(options.alwaysPack),
-    Boolean(options.enableFeatureDetection)
-  );
-  const files = options.files ?? ["yarn.lock", "package.json"];
-  for (const file of files) {
-    const src = typeof file === "string" ? file : file.src;
-    const dest = typeof file === "string" ? file : file.dest;
-    await fs__default.default.copy(cliCommon.targetPaths.resolveRoot(src), path.resolve(targetDir, dest));
-  }
-  if (options.skeleton) {
-    const skeletonFiles = targets.map((target) => {
-      const dir = path.relative(cliCommon.targetPaths.rootDir, target.dir);
-      return path.join(dir, "package.json");
-    }).sort();
-    await tar__namespace.create(
-      {
-        file: path.resolve(targetDir, options.skeleton),
-        cwd: targetDir,
-        portable: true,
-        noMtime: true,
-        gzip: options.skeleton.endsWith(".gz")
-      },
-      skeletonFiles
-    );
-  }
-  return targetDir;
-}
-const FAST_PACK_SCRIPTS = [
-  void 0,
-  "backstage-cli prepack",
-  "backstage-cli package prepack"
-];
-async function moveToDistWorkspace(workspaceDir, localPackages, alwaysPack, enableFeatureDetection) {
-  const [fastPackPackages, slowPackPackages] = partition__default.default(
-    localPackages,
-    (pkg) => !alwaysPack && FAST_PACK_SCRIPTS.includes(pkg.packageJson.scripts?.prepack)
-  );
-  const featureDetectionProject = fastPackPackages.length > 0 && enableFeatureDetection ? await typeDistProject.createTypeDistProject() : void 0;
-  await Promise.all(
-    fastPackPackages.map(async (target) => {
-      console.log(`Moving ${target.name} into dist workspace`);
-      const outputDir = path.relative(cliCommon.targetPaths.rootDir, target.dir);
-      const absoluteOutputPath = path.resolve(workspaceDir, outputDir);
-      await productionPack.productionPack({
-        packageDir: target.dir,
-        targetDir: absoluteOutputPath,
-        featureDetectionProject
-      });
-    })
-  );
-  async function pack(target, archive) {
-    console.log(`Repacking ${target.name} into dist workspace`);
-    const archivePath = path.resolve(workspaceDir, archive);
-    await cliCommon.run(["yarn", "pack", "--filename", archivePath], {
-      cwd: target.dir
-    }).waitForExit();
-    const outputDir = path.relative(cliCommon.targetPaths.rootDir, target.dir);
-    const absoluteOutputPath = path.resolve(workspaceDir, outputDir);
-    await fs__default.default.ensureDir(absoluteOutputPath);
-    await tar__namespace.extract({
-      file: archivePath,
-      cwd: absoluteOutputPath,
-      strip: 1
-    });
-    await fs__default.default.remove(archivePath);
-    if (target.packageJson.bundled) {
-      const pkgJson = await fs__default.default.readJson(
-        path.resolve(absoluteOutputPath, "package.json")
-      );
-      delete pkgJson.dependencies;
-      delete pkgJson.devDependencies;
-      delete pkgJson.peerDependencies;
-      delete pkgJson.optionalDependencies;
-      await fs__default.default.writeJson(
-        path.resolve(absoluteOutputPath, "package.json"),
-        pkgJson,
-        {
-          spaces: 2
-        }
-      );
-    }
-  }
-  const [unsafePackages, safePackages] = partition__default.default(
-    slowPackPackages,
-    (p) => UNSAFE_PACKAGES.includes(p.name)
-  );
-  for (const target of unsafePackages) {
-    await pack(target, `temp-package.tgz`);
-  }
-  await cliNode.runConcurrentTasks({
-    items: safePackages.map((target, index) => ({ target, index })),
-    worker: async ({ target, index }) => {
-      await pack(target, `temp-package-${index}.tgz`);
-    }
-  });
-}
-
-exports.createDistWorkspace = createDistWorkspace;
-//# sourceMappingURL=createDistWorkspace.cjs.js.map

package/dist/modules/build/lib/packager/productionPack.cjs.js

@@ -1,160 +0,0 @@
-'use strict';
-
-var fs = require('fs-extra');
-var npmPackList = require('npm-packlist');
-var path = require('node:path');
-var entryPoints = require('../entryPoints.cjs.js');
-var typeDistProject = require('../typeDistProject.cjs.js');
-
-function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
-
-var fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
-var npmPackList__default = /*#__PURE__*/_interopDefaultCompat(npmPackList);
-
-const PKG_PATH = "package.json";
-const PKG_BACKUP_PATH = "package.json-prepack";
-const SKIPPED_KEYS = ["access", "registry", "tag"];
-const SCRIPT_EXTS = [".js", ".jsx", ".ts", ".tsx"];
-async function productionPack(options) {
-  const { packageDir, targetDir } = options;
-  const pkgPath = path.resolve(packageDir, PKG_PATH);
-  const pkgContent = await fs__default.default.readFile(pkgPath, "utf8");
-  const pkg = JSON.parse(pkgContent);
-  if (!targetDir) {
-    await fs__default.default.writeFile(PKG_BACKUP_PATH, pkgContent);
-  }
-  await rewriteEntryPoints(pkg, packageDir, options.featureDetectionProject);
-  const publishConfig = pkg.publishConfig ?? {};
-  for (const key of Object.keys(publishConfig)) {
-    if (!SKIPPED_KEYS.includes(key)) {
-      pkg[key] = publishConfig[key];
-    }
-  }
-  if (pkg.bundled) {
-    delete pkg.dependencies;
-    delete pkg.devDependencies;
-    delete pkg.peerDependencies;
-    delete pkg.optionalDependencies;
-  }
-  if (targetDir) {
-    const filePaths = await npmPackList__default.default({
-      path: packageDir,
-      // This makes sure we use the updated package.json when listing files
-      packageJsonCache: /* @__PURE__ */ new Map([
-        [path.resolve(packageDir, PKG_PATH), pkg]
-      ])
-      // Seems like this parameter type is wrong,
-    });
-    await fs__default.default.ensureDir(targetDir);
-    for (const filePath of filePaths.sort()) {
-      const target = path.resolve(targetDir, filePath);
-      if (filePath === PKG_PATH) {
-        await fs__default.default.writeJson(target, pkg, { encoding: "utf8", spaces: 2 });
-      } else {
-        await fs__default.default.copy(path.resolve(packageDir, filePath), target);
-      }
-    }
-  } else {
-    await fs__default.default.writeJson(pkgPath, pkg, { encoding: "utf8", spaces: 2 });
-  }
-}
-async function revertProductionPack(packageDir) {
-  try {
-    await fs__default.default.move(PKG_BACKUP_PATH, PKG_PATH, { overwrite: true });
-    const pkg = await fs__default.default.readJson(PKG_PATH);
-    const entryPoints$1 = entryPoints.readEntryPoints(pkg);
-    for (const entryPoint of entryPoints$1) {
-      if (entryPoint.mount !== "." && SCRIPT_EXTS.includes(entryPoint.ext)) {
-        await fs__default.default.remove(path.resolve(packageDir, entryPoint.name));
-      }
-    }
-  } catch (error) {
-    console.warn(
-      `Failed to restore package.json, ${error}. Your package will be fine but you may have ended up with some garbage in the repo.`
-    );
-  }
-}
-const EXPORT_MAP = {
-  import: ".esm.js",
-  require: ".cjs.js",
-  types: ".d.ts"
-};
-async function rewriteEntryPoints(pkg, packageDir, featureDetectionProject) {
-  const distPath = path.resolve(packageDir, "dist");
-  if (!await fs__default.default.pathExists(distPath)) {
-    return void 0;
-  }
-  const distFiles = await fs__default.default.readdir(distPath);
-  const outputExports = {};
-  const entryPoints$1 = entryPoints.readEntryPoints(pkg);
-  if (pkg.typesVersions) {
-    pkg.typesVersions = void 0;
-  }
-  for (const entryPoint of entryPoints$1) {
-    if (!SCRIPT_EXTS.includes(entryPoint.ext)) {
-      outputExports[entryPoint.mount] = entryPoint.path.replace(
-        /^(\.\/)?src\//,
-        "./dist/"
-      );
-      continue;
-    }
-    let exp = {};
-    for (const [key, ext] of Object.entries(EXPORT_MAP)) {
-      const name = `${entryPoint.name}${ext}`;
-      if (distFiles.includes(name)) {
-        exp[key] = `./${path.posix.join(`dist`, name)}`;
-      }
-    }
-    if (exp.types) {
-      if (!pkg.typesVersions) {
-        pkg.typesVersions = { "*": {} };
-      }
-      if (entryPoint.name !== "index") {
-        pkg.typesVersions["*"][entryPoint.name] = [
-          `dist/${entryPoint.name}.d.ts`
-        ];
-      }
-    }
-    exp.default = exp.require ?? exp.import;
-    if (exp.types && featureDetectionProject) {
-      const defaultFeatureType = pkg.backstage?.role && typeDistProject.getEntryPointDefaultFeatureType(
-        pkg.backstage?.role,
-        packageDir,
-        featureDetectionProject,
-        exp.types
-      );
-      if (defaultFeatureType) {
-        exp = { backstage: defaultFeatureType, ...exp };
-        pkg.backstage = pkg.backstage ?? {};
-        pkg.backstage.features = pkg.backstage.features ?? {};
-        pkg.backstage.features[entryPoint.mount] = defaultFeatureType;
-      }
-    }
-    if (entryPoint.mount === ".") {
-      if (exp.default) {
-        pkg.main = exp.default;
-      }
-      if (exp.import) {
-        pkg.module = exp.import;
-      }
-      if (exp.types) {
-        pkg.types = exp.types;
-      }
-    }
-    if (Object.keys(exp).length > 0) {
-      outputExports[entryPoint.mount] = exp;
-    }
-  }
-  if (pkg.typesVersions?.["*"]) {
-    pkg.typesVersions["*"]["package.json"] = ["package.json"];
-  }
-  if (pkg.exports) {
-    pkg.exports = outputExports;
-    pkg.exports["./package.json"] = "./package.json";
-  }
-  return void 0;
-}
-
-exports.productionPack = productionPack;
-exports.revertProductionPack = revertProductionPack;
-//# sourceMappingURL=productionPack.cjs.js.map

package/dist/modules/build/lib/publishing.cjs.js

@@ -1,40 +0,0 @@
-'use strict';
-
-function publishPreflightCheck(pkg) {
-  const { name, backstage } = pkg.packageJson;
-  if (!backstage || !name) {
-    return;
-  }
-  const { role } = backstage;
-  if (role === "backend-plugin" || role === "backend-plugin-module" || role === "frontend-plugin") {
-    if (!backstage.pluginId) {
-      throw new Error(
-        `Plugin package ${name} is missing a backstage.pluginId, please run 'backstage-cli repo fix --publish'`
-      );
-    }
-  }
-  if (role === "backend-plugin" || role === "frontend-plugin") {
-    if (!backstage.pluginPackages) {
-      throw new Error(
-        `Plugin package ${name} is missing a backstage.pluginPackages, please run 'backstage-cli repo fix --publish'`
-      );
-    }
-  }
-  if (backstage.pluginId && (role === "common-library" || role === "node-library" || role === "web-library")) {
-    if (!backstage.pluginPackages) {
-      throw new Error(
-        `Plugin library package ${name} is missing a backstage.pluginPackages, please run 'backstage-cli repo fix --publish'`
-      );
-    }
-  }
-  if (role === "backend-plugin-module" || role === "frontend-plugin-module") {
-    if (backstage.pluginId && !backstage.pluginPackage) {
-      throw new Error(
-        `Plugin module package ${name} is missing a backstage.pluginPackage, please run 'backstage-cli repo fix --publish'`
-      );
-    }
-  }
-}
-
-exports.publishPreflightCheck = publishPreflightCheck;
-//# sourceMappingURL=publishing.cjs.js.map

package/dist/modules/build/lib/role.cjs.js

@@ -1,24 +0,0 @@
-'use strict';
-
-var fs = require('fs-extra');
-var cliCommon = require('@backstage/cli-common');
-var cliNode = require('@backstage/cli-node');
-
-function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
-
-var fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
-
-async function findRoleFromCommand(opts) {
-  if (opts.role) {
-    return cliNode.PackageRoles.getRoleInfo(opts.role).role;
-  }
-  const pkg = await fs__default.default.readJson(cliCommon.targetPaths.resolve("package.json"));
-  const info = cliNode.PackageRoles.getRoleFromPackage(pkg);
-  if (!info) {
-    throw new Error(`Target package must have 'backstage.role' set`);
-  }
-  return info;
-}
-
-exports.findRoleFromCommand = findRoleFromCommand;
-//# sourceMappingURL=role.cjs.js.map

package/dist/modules/build/lib/runner/runBackend.cjs.js

@@ -1,136 +0,0 @@
-'use strict';
-
-var chokidar = require('chokidar');
-var ctrlcWindows = require('ctrlc-windows');
-var IpcServer = require('../ipc/IpcServer.cjs.js');
-var ServerDataStore = require('../ipc/ServerDataStore.cjs.js');
-var debounce = require('lodash/debounce');
-var node_url = require('node:url');
-var path = require('node:path');
-var cliCommon = require('@backstage/cli-common');
-var spawn = require('cross-spawn');
-
-function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
-
-var debounce__default = /*#__PURE__*/_interopDefaultCompat(debounce);
-var spawn__default = /*#__PURE__*/_interopDefaultCompat(spawn);
-
-const loaderArgs = [
-  "--enable-source-maps",
-  "--require",
-  require.resolve("@backstage/cli/config/nodeTransform.cjs")
-  // TODO: Support modules, although there's currently no way to load them since import() is transpiled tp require()
-];
-async function runBackend(options) {
-  const envEnv = process.env;
-  if (!envEnv.NODE_ENV) {
-    envEnv.NODE_ENV = "development";
-  }
-  const server = new IpcServer.IpcServer();
-  ServerDataStore.ServerDataStore.bind(server);
-  let exiting = false;
-  let firstStart = true;
-  let child;
-  let watcher = void 0;
-  let shutdownPromise = void 0;
-  const watchedPaths = /* @__PURE__ */ new Set();
-  const restart = debounce__default.default(async () => {
-    if (firstStart) {
-      firstStart = false;
-    } else {
-      console.log();
-      console.log("Change detected, restarting the development server...");
-      console.log();
-    }
-    if (shutdownPromise) {
-      return;
-    }
-    if (child && !child.killed && child.exitCode === null) {
-      shutdownPromise = new Promise((resolve) => child.once("exit", resolve));
-      if (process.platform === "win32" && child.pid) {
-        ctrlcWindows.ctrlc(child.pid);
-      } else {
-        child.kill();
-      }
-      await shutdownPromise;
-      shutdownPromise = void 0;
-    }
-    if (exiting) {
-      return;
-    }
-    const optionArgs = new Array();
-    if (options.inspectEnabled) {
-      const inspect = typeof options.inspectEnabled === "string" ? `--inspect=${options.inspectEnabled}` : "--inspect";
-      optionArgs.push(inspect);
-    } else if (options.inspectBrkEnabled) {
-      const inspect = typeof options.inspectBrkEnabled === "string" ? `--inspect-brk=${options.inspectBrkEnabled}` : "--inspect-brk";
-      optionArgs.push(inspect);
-    }
-    if (options.require) {
-      const requires = [options.require].flat();
-      for (const r of requires) {
-        optionArgs.push(`--require=${r}`);
-      }
-    }
-    if (!envEnv.NODE_OPTIONS?.includes("--node-snapshot")) {
-      optionArgs.push("--no-node-snapshot");
-    }
-    const userArgs = process.argv.slice(["node", "backstage-cli", "package", "start"].length).filter((arg) => !optionArgs.includes(arg));
-    child = spawn__default.default(
-      process.execPath,
-      [...loaderArgs, ...optionArgs, options.entry, ...userArgs],
-      {
-        stdio: ["ignore", "inherit", "inherit", "ipc"],
-        cwd: options.targetDir,
-        env: {
-          ...process.env,
-          BACKSTAGE_CLI_LINKED_WORKSPACE: options.linkedWorkspace,
-          BACKSTAGE_CLI_CHANNEL: "1",
-          ESBK_TSCONFIG_PATH: cliCommon.targetPaths.resolveRoot("tsconfig.json")
-        },
-        serialization: "advanced"
-      }
-    );
-    server.addChild(child);
-    child.on("message", (data) => {
-      if (!watcher) {
-        return;
-      }
-      if (typeof data === "object" && data?.type === "watch") {
-        let path$1 = data.path;
-        if (path$1.startsWith("file:")) {
-          path$1 = node_url.fileURLToPath(path$1);
-        }
-        if (path.isAbsolute(path$1) && !watchedPaths.has(path$1)) {
-          watchedPaths.add(path$1);
-          watcher.add(path$1);
-        }
-      }
-    });
-  }, 100);
-  restart();
-  watcher = chokidar.watch(["./package.json"], {
-    cwd: process.cwd(),
-    ignoreInitial: true,
-    ignorePermissionErrors: true
-  }).on("all", restart);
-  process.stdin.on("data", restart);
-  const exitPromise = new Promise((resolveExitPromise) => {
-    async function handleSignal(signal) {
-      exiting = true;
-      if (child && child.exitCode === null) {
-        await new Promise((resolve) => {
-          child.on("close", resolve);
-          child.kill(signal);
-        });
-      }
-      resolveExitPromise();
-    }
-    process.once("SIGINT", handleSignal);
-    process.once("SIGTERM", handleSignal);
-  });
-  return () => exitPromise;
-}
-
-exports.runBackend = runBackend;
-//# sourceMappingURL=runBackend.cjs.js.map

package/dist/modules/build/lib/typeDistProject.cjs.js

@@ -1,89 +0,0 @@
-'use strict';
-
-var cliNode = require('@backstage/cli-node');
-var path = require('node:path');
-var tsMorph = require('ts-morph');
-var cliCommon = require('@backstage/cli-common');
-
-const createTypeDistProject = async () => {
-  return new tsMorph.Project({
-    tsConfigFilePath: cliCommon.targetPaths.resolveRoot("tsconfig.json"),
-    skipAddingFilesFromTsConfig: true
-  });
-};
-const targetPackageRoles = [
-  "backend-plugin",
-  "backend-plugin-module",
-  "frontend-plugin",
-  "frontend-plugin-module",
-  "web-library",
-  "node-library"
-];
-const getEntryPointDefaultFeatureType = (role, packageDir, project, entryPoint) => {
-  if (isTargetPackageRole(role)) {
-    const distPath = path.resolve(packageDir, entryPoint);
-    try {
-      const defaultFeatureType = getSourceFileDefaultFeatureType(
-        project.addSourceFileAtPath(distPath)
-      );
-      if (defaultFeatureType) {
-        return defaultFeatureType;
-      }
-    } catch (error) {
-      console.error(
-        `Failed to extract default feature type from ${distPath}, ${error}. Your package will publish fine but it may be missing metadata about its default feature.`
-      );
-    }
-  }
-  return null;
-};
-function getSourceFileDefaultFeatureType(sourceFile) {
-  for (const exportSymbol of sourceFile.getExportSymbols()) {
-    const declaration = exportSymbol.getDeclarations()[0];
-    const exportName = declaration.getSymbol()?.getName();
-    if (exportName !== "default") {
-      continue;
-    }
-    let exportType;
-    if (declaration) {
-      if (declaration.isKind(tsMorph.SyntaxKind.ExportAssignment)) {
-        exportType = declaration.getExpression().getType();
-      } else if (declaration.isKind(tsMorph.SyntaxKind.ExportSpecifier)) {
-        if (!declaration.isTypeOnly()) {
-          exportType = declaration.getType();
-        }
-      } else if (declaration.isKind(tsMorph.SyntaxKind.VariableDeclaration)) {
-        exportType = declaration.getType();
-      }
-    }
-    if (exportName && exportType) {
-      const $$type = getBackstagePackageFeature$$TypeFromType(exportType);
-      if ($$type) {
-        return $$type;
-      }
-    }
-  }
-  return null;
-}
-function getBackstagePackageFeature$$TypeFromType(type) {
-  const exportType = type.getTargetType() ?? type;
-  for (const property of exportType.getProperties()) {
-    if (property.getName() === "$$type") {
-      const $$type = property.getValueDeclaration()?.getText().match(/(\$\$type: '(?<type>.+)')/)?.groups?.type;
-      if ($$type && isTargetFeatureType($$type)) {
-        return $$type;
-      }
-    }
-  }
-  return null;
-}
-function isTargetPackageRole(role) {
-  return !!role && targetPackageRoles.includes(role);
-}
-function isTargetFeatureType(type) {
-  return !!type && cliNode.packageFeatureType.includes(type);
-}
-
-exports.createTypeDistProject = createTypeDistProject;
-exports.getEntryPointDefaultFeatureType = getEntryPointDefaultFeatureType;
-//# sourceMappingURL=typeDistProject.cjs.js.map

package/dist/modules/build/lib/urls.cjs.js

@@ -1,13 +0,0 @@
-'use strict';
-
-function isValidUrl(url) {
-  try {
-    new URL(url);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-exports.isValidUrl = isValidUrl;
-//# sourceMappingURL=urls.cjs.js.map