@modern-js/app-tools 2.58.1 → 2.58.2

package/dist/esm-node/plugins/analyze/getServerRoutes.js

@@ -1,132 +0,0 @@
-import path from "path";
-import fs from "fs";
-import { urlJoin, isPlainObject, removeLeadingSlash, getEntryOptions, SERVER_BUNDLE_DIRECTORY, removeTailSlash, SERVER_WORKER_BUNDLE_DIRECTORY } from "@modern-js/utils";
-import { isMainEntry } from "../../utils/routes";
-import { walkDirectory } from "./utils";
-const applyBaseUrl = (baseUrl, routes) => {
-  if (baseUrl) {
-    if (Array.isArray(baseUrl)) {
-      return baseUrl.reduce((previous, current) => [
-        ...previous,
-        ...applyBaseUrl(current, routes)
-      ], []);
-    } else {
-      return routes.map((route) => {
-        const urlPath = urlJoin(baseUrl, route.urlPath);
-        return {
-          ...route,
-          urlPath: urlPath === "/" ? urlPath : removeTailSlash(urlPath)
-        };
-      });
-    }
-  }
-  return routes;
-};
-const applyRouteOptions = (original, routeOptions) => {
-  const { route, disableSpa } = routeOptions;
-  original.isSPA = !disableSpa;
-  !original.isSPA && (original.entryPath = path.dirname(original.entryPath));
-  let routes;
-  if (route) {
-    if (Array.isArray(route)) {
-      routes = route.map((url) => {
-        if (isPlainObject(url)) {
-          const { path: urlPath, ...other } = url;
-          return {
-            ...original,
-            ...other,
-            urlPath
-          };
-        } else {
-          return {
-            ...original,
-            urlPath: url
-          };
-        }
-      });
-    } else if (isPlainObject(route)) {
-      const { path: urlPath, ...other } = route;
-      routes = [
-        {
-          ...original,
-          ...other,
-          urlPath
-        }
-      ];
-    } else {
-      routes = [
-        {
-          ...original,
-          urlPath: route
-        }
-      ];
-    }
-  } else {
-    routes = [
-      original
-    ];
-  }
-  return routes;
-};
-const collectHtmlRoutes = (entrypoints, appContext, config) => {
-  var _deploy_worker;
-  const { source: { mainEntryName }, html: { disableHtmlFolder }, output: { distPath: { html: htmlPath } = {} }, server: { baseUrl, routes, ssr, ssrByEntries }, deploy } = config;
-  const { packageName } = appContext;
-  const workerSSR = deploy === null || deploy === void 0 ? void 0 : (_deploy_worker = deploy.worker) === null || _deploy_worker === void 0 ? void 0 : _deploy_worker.ssr;
-  let htmlRoutes = entrypoints.reduce((previous, { entryName }) => {
-    const isMain = isMainEntry(entryName, mainEntryName);
-    const entryOptions = getEntryOptions(entryName, isMain, ssr, ssrByEntries, packageName);
-    const isSSR = Boolean(entryOptions);
-    const isWorker = Boolean(workerSSR);
-    const isStream = typeof entryOptions === "object" && (entryOptions.mode === "stream" || Boolean(entryOptions.preload));
-    const { resHeaders } = (routes === null || routes === void 0 ? void 0 : routes[entryName]) || {};
-    let route = {
-      urlPath: `/${isMain ? "" : entryName}`,
-      entryName,
-      entryPath: removeLeadingSlash(path.posix.normalize(`${htmlPath}/${entryName}${disableHtmlFolder ? ".html" : "/index.html"}`)),
-      isSPA: true,
-      isStream,
-      isSSR,
-      responseHeaders: resHeaders,
-      worker: isWorker ? `${SERVER_WORKER_BUNDLE_DIRECTORY}/${entryName}.js` : void 0,
-      bundle: isSSR ? `${SERVER_BUNDLE_DIRECTORY}/${entryName}.js` : void 0
-    };
-    if (routes === null || routes === void 0 ? void 0 : routes.hasOwnProperty(entryName)) {
-      const routeOptions = isPlainObject(routes[entryName]) ? routes[entryName] : {
-        route: routes[entryName]
-      };
-      route = applyRouteOptions(route, routeOptions);
-    }
-    return Array.isArray(route) ? [
-      ...previous,
-      ...route
-    ] : [
-      ...previous,
-      route
-    ];
-  }, []);
-  htmlRoutes = applyBaseUrl(baseUrl, htmlRoutes);
-  return htmlRoutes;
-};
-const collectStaticRoutes = (appContext, config) => {
-  const { appDirectory } = appContext;
-  const { source: { configDir }, server: { publicRoutes = {} } } = config;
-  const publicFolder = path.resolve(appDirectory, configDir || "", "public");
-  return fs.existsSync(publicFolder) ? walkDirectory(publicFolder).map((filePath) => {
-    const urlPath = `${urlJoin(toPosix(filePath).slice(toPosix(publicFolder).length))}`;
-    return {
-      urlPath: publicRoutes[removeLeadingSlash(urlPath)] || urlPath,
-      isSPA: true,
-      isSSR: false,
-      entryPath: toPosix(path.relative(path.resolve(appDirectory, configDir || ""), filePath))
-    };
-  }) : [];
-};
-const getServerRoutes = (entrypoints, { appContext, config }) => [
-  ...collectHtmlRoutes(entrypoints, appContext, config),
-  ...collectStaticRoutes(appContext, config)
-];
-const toPosix = (pathStr) => pathStr.split(path.sep).join(path.posix.sep);
-export {
-  getServerRoutes
-};

package/dist/esm-node/plugins/analyze/index.js

@@ -1,166 +0,0 @@
-import * as path from "path";
-import { createDebugger, fs, isApiOnly, minimist, isDevCommand, getArgv } from "@modern-js/utils";
-import { printInstructions } from "../../utils/printInstructions";
-import { generateRoutes } from "../../utils/routes";
-import { emitResolvedConfig } from "../../utils/config";
-import { getSelectedEntries } from "../../utils/getSelectedEntries";
-import { initialNormalizedConfig } from "../../config";
-import { createBuilderGenerator } from "../../builder";
-import { checkIsBuildCommands } from "./utils";
-const debug = createDebugger("plugin-analyze");
-var analyze_default = ({ bundler }) => ({
-  name: "@modern-js/plugin-analyze",
-  post: [
-    "@modern-js/runtime"
-  ],
-  setup: (api) => {
-    let pagesDir = [];
-    let nestedRouteEntries = [];
-    return {
-      async prepare() {
-        var _resolvedConfig_source;
-        let appContext = api.useAppContext();
-        const resolvedConfig = api.useResolvedConfigContext();
-        const hookRunners = api.useHookRunners();
-        try {
-          if (checkIsBuildCommands()) {
-            fs.emptydirSync(appContext.internalDirectory);
-          }
-        } catch {
-        }
-        const apiOnly = await isApiOnly(appContext.appDirectory, (_resolvedConfig_source = resolvedConfig.source) === null || _resolvedConfig_source === void 0 ? void 0 : _resolvedConfig_source.entriesDir, appContext.apiDirectory);
-        await hookRunners.addRuntimeExports();
-        if (apiOnly) {
-          const { routes: routes2 } = await hookRunners.modifyServerRoutes({
-            routes: []
-          });
-          debug(`server routes: %o`, routes2);
-          appContext = {
-            ...api.useAppContext(),
-            apiOnly,
-            serverRoutes: routes2
-          };
-          api.setAppContext(appContext);
-          return;
-        }
-        const [{ getBundleEntry }, { getServerRoutes }, { getHtmlTemplate }] = await Promise.all([
-          import("./getBundleEntry"),
-          import("./getServerRoutes"),
-          import("./getHtmlTemplate")
-        ]);
-        const { entrypoints } = await hookRunners.modifyEntrypoints({
-          entrypoints: await getBundleEntry(hookRunners, appContext, resolvedConfig)
-        });
-        debug(`entrypoints: %o`, entrypoints);
-        const initialRoutes = getServerRoutes(entrypoints, {
-          appContext,
-          config: resolvedConfig
-        });
-        const { routes } = await hookRunners.modifyServerRoutes({
-          routes: initialRoutes
-        });
-        debug(`server routes: %o`, routes);
-        appContext = {
-          ...api.useAppContext(),
-          entrypoints,
-          serverRoutes: routes
-        };
-        api.setAppContext(appContext);
-        nestedRouteEntries = entrypoints.map((point) => point.nestedRoutesEntry).filter(Boolean);
-        pagesDir = entrypoints.map((point) => point.entry).filter((entry) => entry && !path.extname(entry)).concat(nestedRouteEntries);
-        const htmlTemplates = await getHtmlTemplate(entrypoints, api, {
-          appContext,
-          config: resolvedConfig
-        });
-        debug(`html templates: %o`, htmlTemplates);
-        await hookRunners.addDefineTypes();
-        debug(`add Define Types`);
-        let checkedEntries = entrypoints.map((point) => point.entryName);
-        if (isDevCommand()) {
-          const { entry } = minimist(getArgv());
-          checkedEntries = await getSelectedEntries(typeof entry === "string" ? entry.split(",") : entry, entrypoints);
-        }
-        appContext = {
-          ...api.useAppContext(),
-          entrypoints,
-          checkedEntries,
-          apiOnly,
-          serverRoutes: routes,
-          htmlTemplates
-        };
-        api.setAppContext(appContext);
-        if (checkIsBuildCommands()) {
-          await hookRunners.generateEntryCode({
-            entrypoints
-          });
-          const normalizedConfig = api.useResolvedConfigContext();
-          const createBuilderForModern = await createBuilderGenerator(bundler);
-          const builder = await createBuilderForModern({
-            normalizedConfig,
-            appContext
-          });
-          builder.onBeforeBuild(async ({ bundlerConfigs, isFirstCompile }) => {
-            if (!isFirstCompile) {
-              return;
-            }
-            const hookRunners2 = api.useHookRunners();
-            await generateRoutes(appContext);
-            await hookRunners2.beforeBuild({
-              bundlerConfigs
-            });
-          });
-          builder.onAfterBuild(async ({ stats }) => {
-            const hookRunners2 = api.useHookRunners();
-            await hookRunners2.afterBuild({
-              stats
-            });
-            await emitResolvedConfig(appContext.appDirectory, normalizedConfig);
-          });
-          builder.onDevCompileDone(async ({ isFirstCompile }) => {
-            const hookRunners2 = api.useHookRunners();
-            hookRunners2.afterDev({
-              isFirstCompile
-            });
-            if (isFirstCompile) {
-              printInstructions(hookRunners2, appContext, normalizedConfig);
-            }
-          });
-          builder.onBeforeCreateCompiler(async ({ bundlerConfigs }) => {
-            const hookRunners2 = api.useHookRunners();
-            await hookRunners2.beforeCreateCompiler({
-              bundlerConfigs
-            });
-          });
-          builder.onAfterCreateCompiler(async ({ compiler }) => {
-            const hookRunners2 = api.useHookRunners();
-            await hookRunners2.afterCreateCompiler({
-              compiler
-            });
-          });
-          builder.addPlugins(resolvedConfig.builderPlugins);
-          appContext = {
-            ...api.useAppContext(),
-            builder
-          };
-          api.setAppContext(appContext);
-        }
-      },
-      watchFiles() {
-        return {
-          files: pagesDir,
-          isPrivate: true
-        };
-      },
-      resolvedConfig({ resolved }) {
-        const appContext = api.useAppContext();
-        const config = initialNormalizedConfig(resolved, appContext, bundler);
-        return {
-          resolved: config
-        };
-      }
-    };
-  }
-});
-export {
-  analyze_default as default
-};

package/dist/esm-node/plugins/analyze/isDefaultExportFunction.js

@@ -1,47 +0,0 @@
-import fs from "fs";
-import { parse } from "@babel/parser";
-import traverse from "@babel/traverse";
-import * as t from "@babel/types";
-const isFunction = (node) => t.isFunctionDeclaration(node) || t.isFunctionExpression(node) || t.isArrowFunctionExpression(node);
-const isDefaultExportFunction = (file) => {
-  if (!file || !fs.existsSync(file)) {
-    return false;
-  }
-  const ast = parse(fs.readFileSync(file, "utf8"), {
-    sourceType: "unambiguous",
-    plugins: [
-      "jsx",
-      "typescript",
-      "classProperties",
-      "dynamicImport",
-      "exportDefaultFrom",
-      "exportNamespaceFrom",
-      "decorators-legacy",
-      "functionBind",
-      "classPrivateMethods",
-      [
-        "pipelineOperator",
-        {
-          proposal: "minimal"
-        }
-      ],
-      "optionalChaining",
-      "optionalCatchBinding",
-      "objectRestSpread",
-      "numericSeparator"
-    ]
-  });
-  let isExportFunction = false;
-  traverse(ast, {
-    ExportDefaultDeclaration: (path) => {
-      const { declaration } = path.node;
-      if (isFunction(declaration)) {
-        isExportFunction = true;
-      }
-    }
-  });
-  return isExportFunction;
-};
-export {
-  isDefaultExportFunction
-};

package/dist/esm-node/plugins/analyze/templates.js

@@ -1,24 +0,0 @@
-const html = (partials) => `
-<!DOCTYPE html>
-<html>
-<head>
-
-  ${partials.top.join("\n")}
-
-  ${partials.head.join("\n")}
-
-</head>
-
-<body>
-  <div id="<%= mountId %>"><!--<?- html ?>--></div>
-  ${partials.body.join("\n")}
-  <!--<?- chunksMap.js ?>-->
-  <!--<?- SSRDataScript ?>-->
-  <!--<?- bottomTemplate ?>-->
-</body>
-
-</html>
-`;
-export {
-  html
-};

package/dist/esm-node/plugins/analyze/utils.js

@@ -1,68 +0,0 @@
-import fs from "fs";
-import path from "path";
-import { normalizeToPosixPath, getCommand, JS_EXTENSIONS } from "@modern-js/utils";
-import { transform } from "esbuild";
-import { parse } from "es-module-lexer";
-const walkDirectory = (dir) => fs.readdirSync(dir).reduce((previous, filename) => {
-  const filePath = path.join(dir, filename);
-  if (fs.statSync(filePath).isDirectory()) {
-    return [
-      ...previous,
-      ...walkDirectory(filePath)
-    ];
-  } else {
-    return [
-      ...previous,
-      filePath
-    ];
-  }
-}, []);
-const replaceWithAlias = (base, filePath, alias) => {
-  if (filePath.includes(base)) {
-    return normalizeToPosixPath(path.join(alias, path.relative(base, filePath)));
-  } else {
-    return filePath;
-  }
-};
-const parseModule = async ({ source, filename }) => {
-  let content = source;
-  if (JS_EXTENSIONS.some((ext) => filename.endsWith(ext))) {
-    const result = await transform(content, {
-      loader: path.extname(filename).slice(1),
-      format: "esm"
-    });
-    content = result.code;
-  }
-  return await parse(content);
-};
-const getServerCombinedModueFile = (internalDirectory, entryName) => {
-  return path.join(internalDirectory, entryName, "server-loader-combined.js");
-};
-const checkIsBuildCommands = () => {
-  const buildCommands = [
-    "dev",
-    "start",
-    "build",
-    "inspect",
-    "deploy",
-    "dev-worker"
-  ];
-  const command = getCommand();
-  return buildCommands.includes(command);
-};
-const isSubDirOrEqual = (parent, child) => {
-  if (parent === child) {
-    return true;
-  }
-  const relative = path.relative(parent, child);
-  const isSubdir = relative && !relative.startsWith("..") && !path.isAbsolute(relative);
-  return Boolean(isSubdir);
-};
-export {
-  checkIsBuildCommands,
-  getServerCombinedModueFile,
-  isSubDirOrEqual,
-  parseModule,
-  replaceWithAlias,
-  walkDirectory
-};

package/dist/esm-node/plugins/deploy/dependencies/index.js

@@ -1,201 +0,0 @@
-import path from "node:path";
-import { fs as fse, pkgUp, semver } from "@modern-js/utils";
-import { readPackageJSON } from "pkg-types";
-import { parseNodeModulePath } from "mlly";
-import { linkPackage, writePackage, isFile, findEntryFiles, traceFiles as defaultTraceFiles, findPackageParents, resolveTracedPath, readDirRecursive, isSubPath } from "./utils";
-import { nodeFileTrace } from "@vercel/nft";
-const handleDependencies = async ({ appDir, serverRootDir, includeEntries, traceFiles = defaultTraceFiles, entryFilter, modifyPackageJson, copyWholePackage, traceOptions }) => {
-  const base = "/";
-  const entryFiles = await findEntryFiles(serverRootDir, entryFilter);
-  const fileTrace = await traceFiles({
-    entryFiles: entryFiles.concat(includeEntries),
-    serverRootDir,
-    base,
-    traceOptions
-  });
-  const currentProjectModules = path.join(appDir, "node_modules");
-  const dependencySearchRoot = path.resolve(appDir, "../../../../../../");
-  const tracedFiles = Object.fromEntries(await Promise.all([
-    ...fileTrace.reasons.entries()
-  ].map(async ([_path, reasons]) => {
-    if (reasons.ignored) {
-      return;
-    }
-    const filePath = await resolveTracedPath(base, _path);
-    if (isSubPath(serverRootDir, filePath) || isSubPath(appDir, filePath) && !isSubPath(currentProjectModules, filePath)) {
-      return;
-    }
-    if (!await isFile(filePath)) {
-      return;
-    }
-    let baseDir;
-    let pkgName;
-    let subpath;
-    let pkgPath;
-    if (filePath.includes("node_modules")) {
-      const parsed = parseNodeModulePath(filePath);
-      baseDir = parsed.dir;
-      pkgName = parsed.name;
-      subpath = parsed.subpath;
-      pkgPath = path.join(baseDir, pkgName);
-    } else {
-      const MODERN_UTILS_PATH = "packages/toolkit/utils";
-      const MODERN_UTILS_PATH_REGEX = new RegExp(`(.*${MODERN_UTILS_PATH})`);
-      const match = filePath.match(MODERN_UTILS_PATH_REGEX);
-      const packageJsonPath = match ? path.join(match[0], "package.json") : await pkgUp({
-        cwd: path.dirname(filePath)
-      });
-      if (packageJsonPath && isSubPath(dependencySearchRoot, packageJsonPath)) {
-        const packageJson = await fse.readJSON(packageJsonPath);
-        pkgPath = baseDir = path.dirname(packageJsonPath);
-        subpath = path.relative(baseDir, filePath);
-        pkgName = packageJson.name;
-      }
-    }
-    if (!baseDir) {
-      return;
-    }
-    const parents = await Promise.all([
-      ...reasons.parents
-    ].map((p) => resolveTracedPath(base, p)));
-    const tracedFile = {
-      path: filePath,
-      parents,
-      isDirectDep: parents.some((parent) => {
-        return isSubPath(appDir, parent) && !isSubPath(currentProjectModules, parent);
-      }),
-      subpath,
-      pkgName,
-      pkgPath
-    };
-    return [
-      filePath,
-      tracedFile
-    ];
-  })).then((r) => r.filter(Boolean)));
-  const tracedPackages = {};
-  for (const tracedFile of Object.values(tracedFiles)) {
-    const { pkgName } = tracedFile;
-    let tracedPackage = tracedPackages[pkgName];
-    let pkgJSON = await readPackageJSON(tracedFile.pkgPath, {
-      cache: true
-    }).catch(() => {
-    });
-    if (!pkgJSON) {
-      pkgJSON = {
-        name: pkgName,
-        version: "0.0.0"
-      };
-    }
-    if (!tracedPackage) {
-      tracedPackage = {
-        name: pkgName,
-        versions: {}
-      };
-      tracedPackages[pkgName] = tracedPackage;
-    }
-    let tracedPackageVersion = tracedPackage.versions[pkgJSON.version];
-    if (!tracedPackageVersion) {
-      tracedPackageVersion = {
-        path: tracedFile.pkgPath,
-        files: [],
-        isDirectDep: false,
-        pkgJSON
-      };
-      if (tracedFile.isDirectDep) {
-        tracedPackageVersion.isDirectDep = tracedFile.isDirectDep;
-      }
-      tracedPackage.versions[pkgJSON.version] = tracedPackageVersion;
-    }
-    tracedFile.pkgName = pkgName;
-    tracedFile.pkgVersion = pkgJSON.version;
-    const shouldCopyWholePackage = copyWholePackage === null || copyWholePackage === void 0 ? void 0 : copyWholePackage(pkgName);
-    if (tracedFile.path.startsWith(tracedFile.pkgPath) && // Merged package files are based on the version, not on paths, to handle some boundary cases
-    tracedPackageVersion.pkgJSON.version === tracedFile.pkgVersion) {
-      if (shouldCopyWholePackage) {
-        const allFiles = await readDirRecursive(tracedFile.pkgPath);
-        tracedPackageVersion.files.push(...allFiles);
-      } else {
-        tracedPackageVersion.files.push(tracedFile.path);
-      }
-    }
-  }
-  const multiVersionPkgs = {};
-  const singleVersionPackages = [];
-  for (const tracedPackage of Object.values(tracedPackages)) {
-    const versions = Object.keys(tracedPackage.versions);
-    if (versions.length === 1) {
-      singleVersionPackages.push(tracedPackage.name);
-      continue;
-    }
-    multiVersionPkgs[tracedPackage.name] = {};
-    for (const version of versions) {
-      multiVersionPkgs[tracedPackage.name][version] = findPackageParents(tracedPackage, version, tracedFiles);
-    }
-  }
-  await Promise.all(singleVersionPackages.map((pkgName) => {
-    const pkg = tracedPackages[pkgName];
-    const version = Object.keys(pkg.versions)[0];
-    return writePackage({
-      pkg,
-      version,
-      projectDir: serverRootDir
-    });
-  }));
-  const projectPkgJson = await readPackageJSON(serverRootDir).catch(() => ({}));
-  for (const [pkgName, pkgVersions] of Object.entries(multiVersionPkgs)) {
-    const versionEntires = Object.entries(pkgVersions).sort(([v1, p1], [v2, p2]) => {
-      var _tracedPackages_pkgName_versions_v1, _tracedPackages_pkgName_versions, _tracedPackages_pkgName, _tracedPackages_pkgName_versions_v2, _tracedPackages_pkgName_versions1, _tracedPackages_pkgName1;
-      const shouldHoist1 = (_tracedPackages_pkgName = tracedPackages[pkgName]) === null || _tracedPackages_pkgName === void 0 ? void 0 : (_tracedPackages_pkgName_versions = _tracedPackages_pkgName.versions) === null || _tracedPackages_pkgName_versions === void 0 ? void 0 : (_tracedPackages_pkgName_versions_v1 = _tracedPackages_pkgName_versions[v1]) === null || _tracedPackages_pkgName_versions_v1 === void 0 ? void 0 : _tracedPackages_pkgName_versions_v1.isDirectDep;
-      const shouldHoist2 = (_tracedPackages_pkgName1 = tracedPackages[pkgName]) === null || _tracedPackages_pkgName1 === void 0 ? void 0 : (_tracedPackages_pkgName_versions1 = _tracedPackages_pkgName1.versions) === null || _tracedPackages_pkgName_versions1 === void 0 ? void 0 : (_tracedPackages_pkgName_versions_v2 = _tracedPackages_pkgName_versions1[v2]) === null || _tracedPackages_pkgName_versions_v2 === void 0 ? void 0 : _tracedPackages_pkgName_versions_v2.isDirectDep;
-      if (shouldHoist1 && !shouldHoist2) {
-        return -1;
-      }
-      if (!shouldHoist1 && shouldHoist2) {
-        return 1;
-      }
-      if (p1.length === 0) {
-        return -1;
-      }
-      if (p2.length === 0) {
-        return 1;
-      }
-      return semver.lt(v1, v2, {
-        loose: true
-      }) ? 1 : -1;
-    });
-    for (const [version, parentPkgs] of versionEntires) {
-      const pkg = tracedPackages[pkgName];
-      const pkgDestPath = `.modernjs/${pkgName}@${version}/node_modules/${pkgName}`;
-      await writePackage({
-        pkg,
-        version,
-        projectDir: serverRootDir,
-        _pkgPath: pkgDestPath
-      });
-      await linkPackage(pkgDestPath, `${pkgName}`, serverRootDir);
-      for (const parentPkg of parentPkgs) {
-        const parentPkgName = parentPkg.replace(/@[^@]+$/, "");
-        await (multiVersionPkgs[parentPkgName] ? linkPackage(pkgDestPath, `.modernjs/${parentPkg}/node_modules/${pkgName}`, serverRootDir) : linkPackage(pkgDestPath, `${parentPkgName}/node_modules/${pkgName}`, serverRootDir));
-      }
-    }
-  }
-  const outputPkgPath = path.join(serverRootDir, "package.json");
-  const newPkgJson = {
-    name: `${projectPkgJson.name || "modernjs-project"}-prod`,
-    version: projectPkgJson.version || "0.0.0",
-    private: true,
-    dependencies: Object.fromEntries([
-      ...Object.values(tracedPackages).map((pkg) => [
-        pkg.name,
-        Object.keys(pkg.versions)[0]
-      ])
-    ].sort(([a], [b]) => a.localeCompare(b)))
-  };
-  const finalPkgJson = (modifyPackageJson === null || modifyPackageJson === void 0 ? void 0 : modifyPackageJson(newPkgJson)) || newPkgJson;
-  await fse.writeJSON(outputPkgPath, finalPkgJson);
-};
-export {
-  handleDependencies,
-  nodeFileTrace
-};