@modern-js/app-tools 2.63.1 → 2.63.3

package/dist/cjs/plugins/deploy/dependencies/index.js

@@ -1,237 +0,0 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var dependencies_exports = {};
-__export(dependencies_exports, {
-  handleDependencies: () => handleDependencies,
-  nodeFileTrace: () => import_nft.nodeFileTrace
-});
-module.exports = __toCommonJS(dependencies_exports);
-var import_node_path = __toESM(require("node:path"));
-var import_utils = require("@modern-js/utils");
-var import_mlly = require("mlly");
-var import_pkg_types = require("pkg-types");
-var import_utils2 = require("./utils");
-var import_nft = require("@vercel/nft");
-const handleDependencies = async ({ appDir, serverRootDir, includeEntries, traceFiles = import_utils2.traceFiles, entryFilter, modifyPackageJson, copyWholePackage, traceOptions }) => {
-  const base = "/";
-  const entryFiles = await (0, import_utils2.findEntryFiles)(serverRootDir, entryFilter);
-  const fileTrace = await traceFiles({
-    entryFiles: entryFiles.concat(includeEntries),
-    serverRootDir,
-    base,
-    traceOptions
-  });
-  const currentProjectModules = import_node_path.default.join(appDir, "node_modules");
-  const dependencySearchRoot = import_node_path.default.resolve(appDir, "../../../../../../");
-  const tracedFiles = Object.fromEntries(await Promise.all([
-    ...fileTrace.reasons.entries()
-  ].map(async ([_path, reasons]) => {
-    if (reasons.ignored) {
-      return;
-    }
-    const filePath = await (0, import_utils2.resolveTracedPath)(base, _path);
-    if ((0, import_utils2.isSubPath)(serverRootDir, filePath) || (0, import_utils2.isSubPath)(appDir, filePath) && !(0, import_utils2.isSubPath)(currentProjectModules, filePath)) {
-      return;
-    }
-    if (!await (0, import_utils2.isFile)(filePath)) {
-      return;
-    }
-    let baseDir;
-    let pkgName;
-    let subpath;
-    let pkgPath;
-    if (filePath.includes("node_modules")) {
-      const parsed = (0, import_mlly.parseNodeModulePath)(filePath);
-      baseDir = parsed.dir;
-      pkgName = parsed.name;
-      subpath = parsed.subpath;
-      pkgPath = import_node_path.default.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 ? import_node_path.default.join(match[0], "package.json") : await (0, import_utils.pkgUp)({
-        cwd: import_node_path.default.dirname(filePath)
-      });
-      if (packageJsonPath && (0, import_utils2.isSubPath)(dependencySearchRoot, packageJsonPath)) {
-        const packageJson = await import_utils.fs.readJSON(packageJsonPath);
-        pkgPath = baseDir = import_node_path.default.dirname(packageJsonPath);
-        subpath = import_node_path.default.relative(baseDir, filePath);
-        pkgName = packageJson.name;
-      }
-    }
-    if (!baseDir) {
-      return;
-    }
-    const parents = await Promise.all([
-      ...reasons.parents
-    ].map((p) => (0, import_utils2.resolveTracedPath)(base, p)));
-    const tracedFile = {
-      path: filePath,
-      parents,
-      isDirectDep: parents.some((parent) => {
-        return (0, import_utils2.isSubPath)(appDir, parent) && !(0, import_utils2.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 (0, import_pkg_types.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 (0, import_utils2.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] = (0, import_utils2.findPackageParents)(tracedPackage, version, tracedFiles);
-    }
-  }
-  await Promise.all(singleVersionPackages.map((pkgName) => {
-    const pkg = tracedPackages[pkgName];
-    const version = Object.keys(pkg.versions)[0];
-    return (0, import_utils2.writePackage)({
-      pkg,
-      version,
-      projectDir: serverRootDir
-    });
-  }));
-  const projectPkgJson = await (0, import_pkg_types.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 import_utils.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 (0, import_utils2.writePackage)({
-        pkg,
-        version,
-        projectDir: serverRootDir,
-        _pkgPath: pkgDestPath
-      });
-      await (0, import_utils2.linkPackage)(pkgDestPath, `${pkgName}`, serverRootDir);
-      for (const parentPkg of parentPkgs) {
-        const parentPkgName = parentPkg.replace(/@[^@]+$/, "");
-        await (multiVersionPkgs[parentPkgName] ? (0, import_utils2.linkPackage)(pkgDestPath, `.modernjs/${parentPkg}/node_modules/${pkgName}`, serverRootDir) : (0, import_utils2.linkPackage)(pkgDestPath, `${parentPkgName}/node_modules/${pkgName}`, serverRootDir));
-      }
-    }
-  }
-  const outputPkgPath = import_node_path.default.join(serverRootDir, "package.json");
-  const newPkgJson = {
-    name: `${projectPkgJson.name || "modernjs-project"}-prod`,
-    version: projectPkgJson.version || "0.0.0",
-    private: true,
-    type: projectPkgJson.type || "commonjs",
-    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 import_utils.fs.writeJSON(outputPkgPath, finalPkgJson);
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  handleDependencies,
-  nodeFileTrace
-});

package/dist/cjs/plugins/deploy/dependencies/utils.js

@@ -1,179 +0,0 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var utils_exports = {};
-__export(utils_exports, {
-  findEntryFiles: () => findEntryFiles,
-  findPackageParents: () => findPackageParents,
-  isFile: () => isFile,
-  isSubPath: () => isSubPath,
-  linkPackage: () => linkPackage,
-  readDirRecursive: () => readDirRecursive,
-  resolveTracedPath: () => resolveTracedPath,
-  traceFiles: () => traceFiles,
-  writePackage: () => writePackage
-});
-module.exports = __toCommonJS(utils_exports);
-var import_node_os = __toESM(require("node:os"));
-var import_path = __toESM(require("path"));
-var import_utils = require("@modern-js/utils");
-var import_nft = require("@vercel/nft");
-var import_mlly = require("mlly");
-function applyPublicCondition(pkg) {
-  var _pkg_publishConfig;
-  if (pkg === null || pkg === void 0 ? void 0 : (_pkg_publishConfig = pkg.publishConfig) === null || _pkg_publishConfig === void 0 ? void 0 : _pkg_publishConfig.exports) {
-    var _pkg_publishConfig1;
-    pkg.exports = pkg === null || pkg === void 0 ? void 0 : (_pkg_publishConfig1 = pkg.publishConfig) === null || _pkg_publishConfig1 === void 0 ? void 0 : _pkg_publishConfig1.exports;
-  }
-}
-const writePackage = async (options) => {
-  const { pkg, version, projectDir, _pkgPath } = options;
-  const pkgPath = _pkgPath || pkg.name;
-  for (const src of pkg.versions[version].files) {
-    if (src.includes("node_modules")) {
-      const { subpath } = (0, import_mlly.parseNodeModulePath)(src);
-      const dest = import_path.default.join(projectDir, "node_modules", pkgPath, subpath);
-      const dirname = import_path.default.dirname(dest);
-      await import_utils.fs.ensureDir(dirname);
-      await import_utils.fs.copyFile(src, dest);
-    } else {
-      const subpath = import_path.default.relative(pkg.versions[version].path, src);
-      const dest = import_path.default.join(projectDir, "node_modules", pkgPath, subpath);
-      const dirname = import_path.default.dirname(dest);
-      await import_utils.fs.ensureDir(dirname);
-      await import_utils.fs.copyFile(src, dest);
-    }
-  }
-  const { pkgJSON } = pkg.versions[version];
-  applyPublicCondition(pkgJSON);
-  const packageJsonPath = import_path.default.join(projectDir, "node_modules", pkgPath, "package.json");
-  await import_utils.fs.ensureDir(import_path.default.dirname(packageJsonPath));
-  await import_utils.fs.writeFile(packageJsonPath, JSON.stringify(pkgJSON, null, 2));
-};
-const isWindows = import_node_os.default.platform() === "win32";
-const linkPackage = async (from, to, projectRootDir) => {
-  const src = import_path.default.join(projectRootDir, "node_modules", from);
-  const dest = import_path.default.join(projectRootDir, "node_modules", to);
-  const dstStat = await import_utils.fs.lstat(dest).catch(() => null);
-  const exists = dstStat === null || dstStat === void 0 ? void 0 : dstStat.isSymbolicLink();
-  if (exists) {
-    return;
-  }
-  await import_utils.fs.mkdir(import_path.default.dirname(dest), {
-    recursive: true
-  });
-  await import_utils.fs.symlink(import_path.default.relative(import_path.default.dirname(dest), src), dest, isWindows ? "junction" : "dir").catch((error) => {
-    console.error("Cannot link", from, "to", to, error);
-  });
-};
-const readDirRecursive = async (dir, options = {}) => {
-  const { filter } = options;
-  const files = await import_utils.fs.readdir(dir, {
-    withFileTypes: true
-  });
-  const filesAndDirs = await Promise.all(files.map(async (file) => {
-    const resolvedPath = import_path.default.resolve(dir, file.name);
-    if (file.isDirectory()) {
-      return readDirRecursive(resolvedPath, options);
-    } else {
-      return filter && !filter(resolvedPath) ? [] : resolvedPath;
-    }
-  }));
-  return filesAndDirs.flat();
-};
-const isFile = async (file) => {
-  try {
-    const stat = await import_utils.fs.stat(file);
-    return stat.isFile();
-  } catch (error) {
-    if (error.code === "ENOENT") {
-      return false;
-    }
-    throw error;
-  }
-};
-const findEntryFiles = async (rootDir, entryFilter) => {
-  const files = await readDirRecursive(rootDir, {
-    filter: entryFilter
-  });
-  return files.filter((file) => file.endsWith(".mjs") || file.endsWith(".cjs") || file.endsWith(".js"));
-};
-const findPackageParents = (pkg, version, tracedFiles) => {
-  const versionFiles = pkg.versions[version].files.map((path2) => tracedFiles[path2]);
-  const parentPkgs = [
-    ...new Set(versionFiles.flatMap((file) => (
-      // Because it supports copyWholePackage configuration, not all files exist.
-      file === null || file === void 0 ? void 0 : file.parents.map((parentPath) => {
-        const parentFile = tracedFiles[parentPath];
-        if (!parentFile || parentFile.pkgName === pkg.name) {
-          return null;
-        }
-        return `${parentFile.pkgName}@${parentFile.pkgVersion}`;
-      }).filter(Boolean)
-    )))
-  ];
-  return parentPkgs.filter((parentPkg) => parentPkg);
-};
-const traceFiles = async ({ entryFiles, serverRootDir, base = "/", traceOptions }) => {
-  return await (0, import_nft.nodeFileTrace)(entryFiles, {
-    base,
-    processCwd: serverRootDir,
-    resolve: async (id, parent, job, isCjs) => {
-      if (id.startsWith("@modern-js/prod-server")) {
-        return require.resolve(id, {
-          paths: [
-            require.resolve("@modern-js/app-tools")
-          ]
-        });
-      } else {
-        return (0, import_nft.resolve)(id, parent, job, isCjs);
-      }
-    },
-    ...traceOptions
-  });
-};
-const resolveTracedPath = async (base, p) => import_utils.fs.realpath(import_path.default.resolve(base, p));
-const isSubPath = (parentPath, childPath) => {
-  if (!parentPath || !childPath) {
-    return false;
-  }
-  const relative = import_path.default.relative(parentPath, childPath);
-  return relative && !relative.startsWith("..");
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  findEntryFiles,
-  findPackageParents,
-  isFile,
-  isSubPath,
-  linkPackage,
-  readDirRecursive,
-  resolveTracedPath,
-  traceFiles,
-  writePackage
-});

package/dist/cjs/plugins/deploy/exports.js

@@ -1,28 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var exports_exports = {};
-__export(exports_exports, {
-  handleDependencies: () => import_dependencies.handleDependencies
-});
-module.exports = __toCommonJS(exports_exports);
-var import_dependencies = require("./dependencies");
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  handleDependencies
-});

package/dist/esm/hooks.js

@@ -1,36 +0,0 @@
-import { createAsyncWaterfall, createAsyncWorkflow, createParallelWorkflow } from "@modern-js/plugin";
-var hooks = {
-  _internalRuntimePlugins: createAsyncWaterfall(),
-  modifyFileSystemRoutes: createAsyncWaterfall(),
-  modifyServerRoutes: createAsyncWaterfall(),
-  /** add entry point info to entrypoints array */
-  modifyEntrypoints: createAsyncWaterfall(),
-  /** add entry type */
-  checkEntryPoint: createAsyncWaterfall(),
-  generateEntryCode: createAsyncWorkflow(),
-  htmlPartials: createAsyncWaterfall(),
-  beforeGenerateRoutes: createAsyncWaterfall(),
-  _internalServerPlugins: createAsyncWaterfall(),
-  beforeDev: createAsyncWorkflow(),
-  afterDev: createAsyncWorkflow(),
-  beforeCreateCompiler: createAsyncWorkflow(),
-  afterCreateCompiler: createAsyncWorkflow(),
-  beforePrintInstructions: createAsyncWaterfall(),
-  beforeBuild: createAsyncWorkflow(),
-  afterBuild: createAsyncWorkflow(),
-  beforeDeploy: createAsyncWorkflow(),
-  deploy: createAsyncWorkflow(),
-  afterDeploy: createAsyncWorkflow(),
-  beforeRestart: createAsyncWorkflow(),
-  /**
-  * @deprecated
-  */
-  registerDev: createParallelWorkflow(),
-  /**
-  * @deprecated
-  */
-  registerBuildPlatform: createParallelWorkflow()
-};
-export {
-  hooks
-};

package/dist/esm/new/index.js

@@ -1,55 +0,0 @@
-import { createAsyncHook } from "@modern-js/plugin-v2";
-import { appTools as oldAppTools } from "../old";
-import { compatPlugin } from "./compat";
-import { DEFAULT_RUNTIME_CONFIG_FILE, DEFAULT_SERVER_CONFIG_FILE } from "./constants";
-import { initAppContext } from "./context";
-export * from "../defineConfig";
-var appTools = function() {
-  var options = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {
-    // default webpack to be compatible with original projects
-    bundler: "webpack"
-  };
-  return {
-    name: "@modern-js/app-tools",
-    usePlugins: [
-      compatPlugin(),
-      oldAppTools(options)
-    ],
-    post: [
-      "@modern-js/app-tools-old"
-    ],
-    registryHooks: {
-      onBeforeConfig: createAsyncHook(),
-      onAfterPrepare: createAsyncHook(),
-      deploy: createAsyncHook(),
-      _internalRuntimePlugins: createAsyncHook(),
-      _internalServerPlugins: createAsyncHook(),
-      checkEntryPoint: createAsyncHook(),
-      modifyEntrypoints: createAsyncHook(),
-      modifyFileSystemRoutes: createAsyncHook(),
-      modifyServerRoutes: createAsyncHook(),
-      generateEntryCode: createAsyncHook(),
-      onBeforeGenerateRoutes: createAsyncHook(),
-      onBeforePrintInstructions: createAsyncHook(),
-      registerDev: createAsyncHook(),
-      registerBuildPlatform: createAsyncHook(),
-      addRuntimeExports: createAsyncHook()
-    },
-    setup: function(api) {
-      var _userConfig_output;
-      var context = api.getAppContext();
-      var userConfig = api.getConfig();
-      api.updateAppContext(initAppContext({
-        appDirectory: context.appDirectory,
-        options: {},
-        serverConfigFile: DEFAULT_SERVER_CONFIG_FILE,
-        runtimeConfigFile: DEFAULT_RUNTIME_CONFIG_FILE,
-        tempDir: (_userConfig_output = userConfig.output) === null || _userConfig_output === void 0 ? void 0 : _userConfig_output.tempDir
-      }));
-    }
-  };
-};
-export {
-  appTools,
-  initAppContext
-};

package/dist/esm/new/loadPlugins.js

@@ -1,94 +0,0 @@
-import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
-import { _ as _to_consumable_array } from "@swc/helpers/_/_to_consumable_array";
-import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
-import { compatibleRequire, createDebugger, dynamicImport, getInternalPlugins, tryResolve } from "@modern-js/utils";
-var debug = createDebugger("load-plugins");
-var resolveCliPlugin = function() {
-  var _ref = _async_to_generator(function(p, appDirectory) {
-    var pkg, pluginOptions, path, module, e, ref, result;
-    return _ts_generator(this, function(_state) {
-      switch (_state.label) {
-        case 0:
-          pkg = typeof p === "string" ? p : p[0];
-          pluginOptions = typeof p === "string" ? void 0 : p[1];
-          path = tryResolve(pkg, appDirectory);
-          _state.label = 1;
-        case 1:
-          _state.trys.push([
-            1,
-            3,
-            ,
-            5
-          ]);
-          return [
-            4,
-            compatibleRequire(path)
-          ];
-        case 2:
-          module = _state.sent();
-          return [
-            3,
-            5
-          ];
-        case 3:
-          e = _state.sent();
-          return [
-            4,
-            dynamicImport(path)
-          ];
-        case 4:
-          ref = _state.sent(), module = ref.default, ref;
-          return [
-            3,
-            5
-          ];
-        case 5:
-          if (typeof module === "function") {
-            result = module(pluginOptions);
-            return [
-              2,
-              result
-            ];
-          }
-          return [
-            2,
-            module
-          ];
-      }
-    });
-  });
-  return function resolveCliPlugin2(p, appDirectory) {
-    return _ref.apply(this, arguments);
-  };
-}();
-var loadInternalPlugins = function() {
-  var _ref = _async_to_generator(function(appDirectory, internalPlugins, autoLoad, autoLoadPlugins) {
-    var plugins, loadedPlugins;
-    return _ts_generator(this, function(_state) {
-      switch (_state.label) {
-        case 0:
-          plugins = _to_consumable_array(autoLoadPlugins ? getInternalPlugins(appDirectory, internalPlugins) : []).concat(_to_consumable_array(autoLoad ? getInternalPlugins(appDirectory, autoLoad) : []));
-          return [
-            4,
-            Promise.all(plugins.map(function(plugin) {
-              var loadedPlugin = resolveCliPlugin(plugin, appDirectory);
-              debug("resolve plugin %s: %s", plugin, loadedPlugin);
-              return loadedPlugin;
-            }))
-          ];
-        case 1:
-          loadedPlugins = _state.sent();
-          return [
-            2,
-            loadedPlugins
-          ];
-      }
-    });
-  });
-  return function loadInternalPlugins2(appDirectory, internalPlugins, autoLoad, autoLoadPlugins) {
-    return _ref.apply(this, arguments);
-  };
-}();
-export {
-  loadInternalPlugins
-};