@modern-js/app-tools 2.69.4 → 3.0.0-alpha.0

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

@@ -1,78 +0,0 @@
-import { ensureAbsolutePath, getPort, isDev, isDevCommand } from "@modern-js/utils";
-import { checkIsLegacyConfig, createDefaultConfig, createLegacyDefaultConfig, transformNormalizedConfig } from "../../config";
-var initialize_default = ({ bundler }) => ({
-  name: "@modern-js/plugin-initialize",
-  post: [
-    "@modern-js/plugin-ssr",
-    "@modern-js/plugin-document",
-    "@modern-js/plugin-state",
-    "@modern-js/plugin-router",
-    "@modern-js/plugin-router-v5",
-    "@modern-js/plugin-polyfill"
-  ],
-  setup(api) {
-    api.config(() => {
-      const appContext = api.getAppContext();
-      const userConfig = api.getConfig();
-      api.updateAppContext({
-        bundlerType: bundler
-      });
-      return checkIsLegacyConfig(userConfig) ? createLegacyDefaultConfig(appContext) : createDefaultConfig(appContext);
-    });
-    api.modifyResolvedConfig(async (resolved) => {
-      var _resolved_output_distPath;
-      let appContext = api.getAppContext();
-      const userConfig = api.getConfig();
-      const port = await getServerPort(resolved);
-      appContext = {
-        ...appContext,
-        port,
-        distDirectory: ensureAbsolutePath(appContext.appDirectory, ((_resolved_output_distPath = resolved.output.distPath) === null || _resolved_output_distPath === void 0 ? void 0 : _resolved_output_distPath.root) || "dist")
-      };
-      api.updateAppContext(appContext);
-      const normalizedConfig = checkIsLegacyConfig(resolved) ? transformNormalizedConfig(resolved) : resolved;
-      resolved._raw = userConfig;
-      resolved.server = {
-        ...normalizedConfig.server || {},
-        port
-      };
-      var _normalizedConfig_autoLoadPlugins;
-      resolved.autoLoadPlugins = (_normalizedConfig_autoLoadPlugins = normalizedConfig.autoLoadPlugins) !== null && _normalizedConfig_autoLoadPlugins !== void 0 ? _normalizedConfig_autoLoadPlugins : false;
-      stabilizeConfig(resolved, normalizedConfig, [
-        "source",
-        "bff",
-        "dev",
-        "html",
-        "output",
-        "tools",
-        "testing",
-        "plugins",
-        "builderPlugins",
-        "runtime",
-        "runtimeByEntries",
-        "deploy",
-        "performance"
-      ]);
-      if (bundler === "webpack") {
-        resolved.security = normalizedConfig.security || {};
-        resolved.experiments = normalizedConfig.experiments;
-      }
-      return resolved;
-    });
-  }
-});
-function stabilizeConfig(resolve, config, keys) {
-  keys.forEach((key) => {
-    resolve[key] = config[key] || {};
-  });
-}
-async function getServerPort(config) {
-  const prodPort = Number(process.env.PORT) || config.server.port || 8080;
-  if (isDev() && isDevCommand()) {
-    return getPort(Number(process.env.PORT) || config.dev.port || prodPort);
-  }
-  return prodPort;
-}
-export {
-  initialize_default as default
-};

package/dist/esm-node/plugins/serverBuild.js

@@ -1,56 +0,0 @@
-import fs from "fs";
-import path from "path";
-import { compile } from "@modern-js/server-utils";
-import { SERVER_DIR, SHARED_DIR, getMeta } from "@modern-js/utils";
-const TS_CONFIG_FILENAME = "tsconfig.json";
-function checkHasCache(appDir) {
-  const tsFilepath = path.resolve(appDir, SERVER_DIR, "cache.ts");
-  const jsfilepath = path.resolve(appDir, SERVER_DIR, "cache.js");
-  return fs.existsSync(tsFilepath) || fs.existsSync(jsfilepath);
-}
-function checkHasConfig(appDir, metaName = "modern-js") {
-  const meta = getMeta(metaName);
-  const tsFilepath = path.resolve(appDir, SERVER_DIR, `${meta}.server.ts`);
-  const jsfilepath = path.resolve(appDir, SERVER_DIR, `${meta}.server.js`);
-  return fs.existsSync(tsFilepath) || fs.existsSync(jsfilepath);
-}
-var serverBuild_default = () => ({
-  name: "@modern-js/server-build",
-  setup(api) {
-    api.onAfterBuild(async () => {
-      const { appDirectory, distDirectory, metaName } = api.getAppContext();
-      if (!checkHasCache(appDirectory) && !checkHasConfig(appDirectory, metaName)) {
-        return;
-      }
-      const modernConfig = api.getNormalizedConfig();
-      const distDir = path.resolve(distDirectory);
-      const serverDir = path.resolve(appDirectory, SERVER_DIR);
-      const sharedDir = path.resolve(appDirectory, SHARED_DIR);
-      const tsconfigPath = path.resolve(appDirectory, TS_CONFIG_FILENAME);
-      const sourceDirs = [];
-      if (fs.existsSync(serverDir)) {
-        sourceDirs.push(serverDir);
-        if (fs.existsSync(sharedDir)) {
-          sourceDirs.push(sharedDir);
-        }
-      }
-      const { server } = modernConfig;
-      const { alias } = modernConfig.source;
-      const { babel } = modernConfig.tools;
-      if (sourceDirs.length > 0) {
-        await compile(appDirectory, {
-          server,
-          alias,
-          babelConfig: babel
-        }, {
-          sourceDirs,
-          distDir,
-          tsconfigPath
-        });
-      }
-    });
-  }
-});
-export {
-  serverBuild_default as default
-};

package/dist/esm-node/plugins/serverRuntime.js

@@ -1,17 +0,0 @@
-var serverRuntime_default = () => ({
-  name: "@modern-js/plugin-server-runtime",
-  setup(api) {
-    api.config(() => ({
-      output: {
-        externals: [
-          {
-            "@modern-js/server-runtime": "@modern-js/server-runtime"
-          }
-        ]
-      }
-    }));
-  }
-});
-export {
-  serverRuntime_default as default
-};

package/dist/esm-node/run/index.js

@@ -1,104 +0,0 @@
-import path from "path";
-import { initAppDir } from "@modern-js/plugin-v2/cli";
-import { run as CLIPluginRun } from "@modern-js/plugin-v2/run";
-import { chalk, minimist } from "@modern-js/utils";
-import { handleSetupResult } from "../compat/hooks";
-import { PACKAGE_JSON_CONFIG_NAME, STATE_PLUGIN_NAME } from "../constants";
-import { getConfigFile } from "../utils/getConfigFile";
-import { getUserConfig } from "../utils/getUserConfig";
-import { loadInternalPlugins } from "../utils/loadPlugins";
-async function createRunOptions({ cwd, initialLog, metaName = "modern-js", version, internalPlugins, packageJsonConfig = PACKAGE_JSON_CONFIG_NAME, statePluginName = STATE_PLUGIN_NAME, configFile }) {
-  var _userConfig_runtime, _userConfig_runtime1, _userConfig_runtime_state, _userConfig_runtime2;
-  const nodeVersion = process.versions.node;
-  const versionArr = nodeVersion.split(".").map(Number);
-  if (versionArr[0] <= 16) {
-    console.warn(`
-  ${chalk.bgRed.white.bold(" ⚠️ CRITICAL NODE.JS VERSION ALERT ⚠️ ")}
-
-  ${chalk.red.bold("Node.js 16 End-of-Life Notice:")}
-  ${chalk.red("- Security updates and support have ended for Node.js 16")}
-
-  ${chalk.yellow("▸ Detected Runtime:")}  ${chalk.yellow.bold(`Node.js v${nodeVersion}`)}
-  ${chalk.green("▸ Required Minimum:")} ${chalk.green.bold("Node.js LTS (v18.x or higher)")}
-  ${chalk.green("▸ Recommended:")} ${chalk.green.bold("Node.js LTS (v22.x or higher)")}
-
-  ${chalk.cyan("Immediate Action Required:")}
-    ${chalk.gray("├──")} ${chalk.yellow("Recommended Upgrade")}
-       ${chalk.bold("nvm install 22 --lts && nvm use 22")}
-    ${chalk.gray("├──")} ${chalk.yellow("Manual Installation")}
-       ${chalk.underline("https://nodejs.org/download/release/lts-hydrogen/")}
-     ${chalk.gray("└──")} ${chalk.yellow("Environment Verification")}
-       ${chalk.bold("node -v && npm -v")}
-
-  ${chalk.hex("#AAAAAA").italic("[Security Advisory] Node.js 16 is no longer supported. Upgrade immediately for security and compatibility.")}
-      `);
-  }
-  const command = process.argv[2];
-  const cliParams = minimist(process.argv.slice(2));
-  const SUPPORT_CONFIG_PARAM_COMMANDS = [
-    "dev",
-    "build",
-    "deploy",
-    "start",
-    "serve",
-    "inspect",
-    "upgrade"
-  ];
-  let customConfigFile;
-  if (SUPPORT_CONFIG_PARAM_COMMANDS.includes(command)) {
-    customConfigFile = cliParams.config || cliParams.c;
-  }
-  if (command === "new") {
-    customConfigFile = cliParams["config-file"];
-  }
-  if (!process.env.NODE_ENV) {
-    if ([
-      "build",
-      "serve",
-      "deploy",
-      "analyze"
-    ].includes(command)) {
-      process.env.NODE_ENV = "production";
-    } else if (command === "test") {
-      process.env.NODE_ENV = "test";
-    } else {
-      process.env.NODE_ENV = "development";
-    }
-  }
-  const appDirectory = await initAppDir(cwd);
-  const finalConfigFile = customConfigFile || getConfigFile(configFile);
-  const userConfig = await getUserConfig(appDirectory, finalConfigFile, packageJsonConfig, metaName);
-  const plugins = await loadInternalPlugins(appDirectory, internalPlugins === null || internalPlugins === void 0 ? void 0 : internalPlugins.cli, internalPlugins === null || internalPlugins === void 0 ? void 0 : internalPlugins.autoLoad, userConfig.autoLoadPlugins);
-  if (!userConfig.autoLoadPlugins && userConfig.runtime && typeof userConfig.runtime !== "boolean" && (((_userConfig_runtime = userConfig.runtime) === null || _userConfig_runtime === void 0 ? void 0 : _userConfig_runtime.state) === true || typeof ((_userConfig_runtime1 = userConfig.runtime) === null || _userConfig_runtime1 === void 0 ? void 0 : _userConfig_runtime1.state) === "object" && !((_userConfig_runtime2 = userConfig.runtime) === null || _userConfig_runtime2 === void 0 ? void 0 : (_userConfig_runtime_state = _userConfig_runtime2.state) === null || _userConfig_runtime_state === void 0 ? void 0 : _userConfig_runtime_state.legacy))) {
-    if (!userConfig.plugins.find((plugin) => plugin.name === statePluginName)) {
-      console.warn(`${chalk.red("\n[Warning]")} We will no longer support built-in \`runtime.state\`. If you want to use Reduck, you must run ${chalk.yellow.bold(`\`pnpm add ${statePluginName}@${version}\``)} to install the state plugin dependency and manually register the plugin. After install state plugin, please add the following code to ${chalk.yellow.bold(`\`${path.basename(finalConfigFile)}\``)}:
-
-${chalk.yellow.bold(`import { statePlugin } from '${statePluginName}';
-
-export default defineConfig({
-  plugins: [
-    ...,
-    statePlugin(),
-  ],
-});
-        `)}`);
-    }
-  }
-  return {
-    cwd,
-    initialLog: initialLog || `Modern.js Framework v${version}`,
-    configFile: finalConfigFile,
-    metaName,
-    packageJsonConfig,
-    internalPlugins: plugins,
-    handleSetupResult
-  };
-}
-async function run(options) {
-  const runOptions = await createRunOptions(options);
-  await CLIPluginRun(runOptions);
-}
-export {
-  createRunOptions,
-  run
-};

package/dist/esm-node/types/index.js

@@ -1,3 +0,0 @@
-export * from "./hooks";
-export * from "./config";
-export * from "./legacyConfig";

package/dist/esm-node/utils/config.js

@@ -1,49 +0,0 @@
-import * as path from "path";
-import { bundle } from "@modern-js/node-bundle-require";
-import { fs, CONFIG_FILE_EXTENSIONS, OUTPUT_CONFIG_FILE, ensureAbsolutePath, getServerConfig } from "@modern-js/utils";
-import { stringify } from "flatted";
-const defineServerConfig = (config) => config;
-const buildServerConfig = async ({ appDirectory, distDirectory, configFile, options, watch }) => {
-  const configFilePath = await getServerConfig(appDirectory, configFile);
-  const getOutputFile = async (filepath) => path.resolve(distDirectory, `${filepath.replace(new RegExp(CONFIG_FILE_EXTENSIONS.join("|")), "")}.cjs`);
-  if (configFilePath) {
-    const configHelperFilePath = path.normalize(path.join(distDirectory, "./config-helper.js"));
-    const helperCode = `
-      export const defineConfig = (config) => config;
-    `;
-    await fs.ensureDir(distDirectory);
-    await fs.writeFile(configHelperFilePath, helperCode);
-    await bundle(configFilePath, {
-      ...options,
-      watch,
-      getOutputFile,
-      esbuildPlugins: [
-        {
-          name: "native-build-config",
-          setup(ctx) {
-            ctx.onResolve({
-              filter: /app-tools\/server/
-            }, () => {
-              return {
-                path: configHelperFilePath
-              };
-            });
-          }
-        }
-      ]
-    });
-  }
-};
-const emitResolvedConfig = async (appDirectory, resolvedConfig) => {
-  var _resolvedConfig_output_distPath;
-  const outputPath = ensureAbsolutePath(appDirectory, path.join(((_resolvedConfig_output_distPath = resolvedConfig.output.distPath) === null || _resolvedConfig_output_distPath === void 0 ? void 0 : _resolvedConfig_output_distPath.root) || "./dist", OUTPUT_CONFIG_FILE));
-  const output = stringify(resolvedConfig);
-  await fs.writeFile(outputPath, output, {
-    encoding: "utf-8"
-  });
-};
-export {
-  buildServerConfig,
-  defineServerConfig,
-  emitResolvedConfig
-};

package/dist/esm-node/utils/createServer.js

@@ -1,26 +0,0 @@
-import { applyPlugins } from "@modern-js/prod-server";
-import { createDevServer } from "@modern-js/server";
-let server = null;
-const getServer = () => server;
-const setServer = (newServer) => {
-  server = newServer;
-};
-const closeServer = async () => {
-  if (server) {
-    server.close();
-    server = null;
-  }
-};
-const createServer = async (options) => {
-  if (server) {
-    server.close();
-  }
-  server = (await createDevServer(options, applyPlugins)).server;
-  return server;
-};
-export {
-  closeServer,
-  createServer,
-  getServer,
-  setServer
-};

package/dist/esm-node/utils/env.js

@@ -1,16 +0,0 @@
-import { cutNameByHyphen } from "@modern-js/utils/universal";
-function getAutoInjectEnv(appContext) {
-  const { metaName } = appContext;
-  const prefix = `${cutNameByHyphen(metaName)}_`.toUpperCase();
-  const envReg = new RegExp(`^${prefix}`);
-  return Object.keys(process.env).reduce((prev, key) => {
-    const value = process.env[key];
-    if (envReg.test(key) && typeof value !== "undefined") {
-      prev[`process.env.${key}`] = value;
-    }
-    return prev;
-  }, {});
-}
-export {
-  getAutoInjectEnv
-};

package/dist/esm-node/utils/generateWatchFiles.js

@@ -1,30 +0,0 @@
-import path from "path";
-import { fs, getServerConfig } from "@modern-js/utils";
-import { PACKAGE_JSON_CONFIG_NAME } from "../constants";
-const getPackageConfig = (appDirectory, packageJsonConfig) => {
-  const json = JSON.parse(fs.readFileSync(path.resolve(appDirectory, "./package.json"), "utf8"));
-  return json[packageJsonConfig !== null && packageJsonConfig !== void 0 ? packageJsonConfig : PACKAGE_JSON_CONFIG_NAME];
-};
-const addServerConfigToDeps = async (dependencies, appDirectory, serverConfigFile) => {
-  const serverConfig = await getServerConfig(appDirectory, serverConfigFile);
-  if (serverConfig) {
-    dependencies.push(serverConfig);
-  }
-};
-async function generateWatchFiles(appContext, configDir) {
-  const { appDirectory, configFile } = appContext;
-  const configPath = path.join(appDirectory, configDir || "");
-  const dependencies = getPackageConfig(appContext.appDirectory, appContext.packageName) ? [
-    path.resolve(appDirectory, "./package.json")
-  ] : [];
-  await addServerConfigToDeps(dependencies, appContext.appDirectory, appContext.serverConfigFile);
-  return [
-    `${configPath}/html`,
-    configFile || "./config",
-    ...dependencies
-  ];
-}
-export {
-  addServerConfigToDeps,
-  generateWatchFiles
-};

package/dist/esm-node/utils/getConfigFile.js

@@ -1,7 +0,0 @@
-import path from "path";
-import { CONFIG_FILE_EXTENSIONS, findExists } from "@modern-js/utils";
-import { DEFAULT_CONFIG_FILE } from "../constants";
-const getConfigFile = (configFile) => findExists(CONFIG_FILE_EXTENSIONS.map((extension) => path.resolve(process.cwd(), `${configFile || DEFAULT_CONFIG_FILE}${extension}`)));
-export {
-  getConfigFile
-};

package/dist/esm-node/utils/getSelectedEntries.js

@@ -1,34 +0,0 @@
-import { chalk, inquirer } from "@modern-js/utils";
-import { i18n, localeKeys } from "../locale";
-const getSelectedEntries = async (entry, entrypoints) => {
-  const entryNames = entrypoints.map((e) => e.entryName);
-  if (!entry) {
-    return entryNames;
-  }
-  if (typeof entry === "boolean") {
-    const { selected } = await inquirer.prompt([
-      {
-        type: "checkbox",
-        name: "selected",
-        choices: entryNames,
-        message: i18n.t(localeKeys.command.dev.selectEntry),
-        validate(answer) {
-          if (answer.length < 1) {
-            return i18n.t(localeKeys.command.dev.requireEntry);
-          }
-          return true;
-        }
-      }
-    ]);
-    return selected;
-  }
-  entry.forEach((name) => {
-    if (!entryNames.includes(name)) {
-      throw new Error(`Can not found entry ${chalk.yellow(name)}, the entry should be one of ${chalk.yellow(entryNames.join(", "))}`);
-    }
-  });
-  return entry;
-};
-export {
-  getSelectedEntries
-};

package/dist/esm-node/utils/getUserConfig.js

@@ -1,10 +0,0 @@
-import { createLoadedConfig, loadEnv } from "@modern-js/plugin-v2/cli";
-async function getUserConfig(appDirectory, configFile, packageJsonConfig, metaName) {
-  const envName = metaName === "modern-js" ? "MODERN" : metaName;
-  loadEnv(appDirectory, process.env[`${envName.toUpperCase()}_ENV`]);
-  const loaded = await createLoadedConfig(appDirectory, configFile, packageJsonConfig);
-  return loaded.config || {};
-}
-export {
-  getUserConfig
-};

package/dist/esm-node/utils/initAppContext.js

@@ -1,29 +0,0 @@
-import path from "path";
-import { fs, address } from "@modern-js/utils";
-const initAppContext = ({ metaName, appDirectory, runtimeConfigFile, options, serverConfigFile, tempDir }) => {
-  const { apiDir = "api", sharedDir = "shared" } = options || {};
-  const pkgPath = path.resolve(appDirectory, "./package.json");
-  return {
-    runtimeConfigFile,
-    serverConfigFile,
-    ip: address.ip(),
-    port: 0,
-    moduleType: fs.existsSync(pkgPath) ? require(pkgPath).type || "commonjs" : "commonjs",
-    apiDirectory: path.resolve(appDirectory, apiDir),
-    lambdaDirectory: path.resolve(appDirectory, apiDir, "lambda"),
-    sharedDirectory: path.resolve(appDirectory, sharedDir),
-    serverPlugins: [],
-    internalDirectory: path.resolve(appDirectory, tempDir || `./node_modules/.${metaName}`),
-    htmlTemplates: {},
-    serverRoutes: [],
-    entrypoints: [],
-    checkedEntries: [],
-    apiOnly: false,
-    internalDirAlias: `@_${metaName.replace(/-/g, "_")}_internal`,
-    internalSrcAlias: `@_${metaName.replace(/-/g, "_")}_src`,
-    bffRuntimeFramework: "hono"
-  };
-};
-export {
-  initAppContext
-};

package/dist/esm-node/utils/loadPlugins.js

@@ -1,52 +0,0 @@
-import { loadServerPlugins as loadServerPluginInstances } from "@modern-js/prod-server";
-import { compatibleRequire, createDebugger, dynamicImport, getInternalPlugins, tryResolve } from "@modern-js/utils";
-const debug = createDebugger("load-plugins");
-async function getServerPlugins(api, metaName = "modern-js") {
-  const hooks = api.getHooks();
-  const { plugins } = await hooks._internalServerPlugins.call({
-    plugins: []
-  });
-  const filtedPlugins = plugins.filter((plugin) => plugin.name.includes(metaName));
-  api.updateAppContext({
-    serverPlugins: filtedPlugins
-  });
-  return filtedPlugins;
-}
-async function loadServerPlugins(api, appDirectory, metaName) {
-  const plugins = await getServerPlugins(api, metaName);
-  const instances = await loadServerPluginInstances(plugins, appDirectory);
-  return instances;
-}
-const resolveCliPlugin = async (p, appDirectory) => {
-  const pkg = typeof p === "string" ? p : p[0];
-  const pluginOptions = typeof p === "string" ? void 0 : p[1];
-  const path = tryResolve(pkg, appDirectory);
-  let module;
-  try {
-    module = await compatibleRequire(path);
-  } catch (e) {
-    ({ default: module } = await dynamicImport(path));
-  }
-  if (typeof module === "function") {
-    const result = module(pluginOptions);
-    return result;
-  }
-  return module;
-};
-const loadInternalPlugins = async (appDirectory, internalPlugins, autoLoad, autoLoadPlugins) => {
-  const plugins = [
-    ...autoLoadPlugins ? getInternalPlugins(appDirectory, internalPlugins) : [],
-    ...autoLoad ? getInternalPlugins(appDirectory, autoLoad) : []
-  ];
-  const loadedPlugins = await Promise.all(plugins.map((plugin) => {
-    const loadedPlugin = resolveCliPlugin(plugin, appDirectory);
-    debug(`resolve plugin %s: %s`, plugin, loadedPlugin);
-    return loadedPlugin;
-  }));
-  return loadedPlugins;
-};
-export {
-  getServerPlugins,
-  loadInternalPlugins,
-  loadServerPlugins
-};

package/dist/esm-node/utils/printInstructions.js

@@ -1,11 +0,0 @@
-import { logger, prettyInstructions } from "@modern-js/utils";
-const printInstructions = async (hooks, appContext, config) => {
-  const message = prettyInstructions(appContext, config);
-  const { instructions } = await hooks.onBeforePrintInstructions.call({
-    instructions: message
-  });
-  logger.log(instructions);
-};
-export {
-  printInstructions
-};

package/dist/esm-node/utils/register.js

@@ -1,94 +0,0 @@
-import path from "node:path";
-import { fs, getAliasConfig, loadFromProject, logger, readTsConfigByFile } from "@modern-js/utils";
-const registerEsbuild = async ({ isTsProject, tsConfig, distDir }) => {
-  const esbuildRegister = await import("esbuild-register/dist/node");
-  esbuildRegister.register({
-    tsconfigRaw: isTsProject ? tsConfig : void 0,
-    hookIgnoreNodeModules: true,
-    hookMatcher: (fileName) => !fileName.startsWith(distDir)
-  });
-};
-const registerCompiler = async (appDir, distDir, alias) => {
-  const TS_CONFIG_FILENAME = `tsconfig.json`;
-  const tsconfigPath = path.resolve(appDir, TS_CONFIG_FILENAME);
-  const isTsProject = await fs.pathExists(tsconfigPath);
-  const aliasConfig = getAliasConfig(alias, {
-    appDirectory: appDir,
-    tsconfigPath
-  });
-  const { paths = {}, absoluteBaseUrl = "./" } = aliasConfig;
-  const tsPaths = Object.keys(paths).reduce((o, key) => {
-    let tsPath = paths[key];
-    if (typeof tsPath === "string" && key.startsWith("@") && tsPath.startsWith("@")) {
-      try {
-        tsPath = require.resolve(tsPath, {
-          paths: [
-            process.cwd(),
-            ...module.paths
-          ]
-        });
-      } catch {
-      }
-    }
-    if (typeof tsPath === "string" && path.isAbsolute(tsPath)) {
-      tsPath = path.relative(absoluteBaseUrl, tsPath);
-    }
-    if (typeof tsPath === "string") {
-      tsPath = [
-        tsPath
-      ];
-    }
-    return {
-      ...o,
-      [`${key}`]: tsPath
-    };
-  }, {});
-  let tsConfig = {};
-  if (isTsProject) {
-    tsConfig = readTsConfigByFile(tsconfigPath);
-  }
-  const { MODERN_NODE_LOADER } = process.env;
-  if (MODERN_NODE_LOADER === "esbuild" || !isTsProject) {
-    await registerEsbuild({
-      isTsProject,
-      tsConfig,
-      distDir
-    });
-  } else {
-    try {
-      const tsNode = await loadFromProject("ts-node", appDir);
-      const tsNodeOptions = tsConfig["ts-node"];
-      tsNode.register({
-        project: tsconfigPath,
-        scope: true,
-        // for env.d.ts, https://www.npmjs.com/package/ts-node#missing-types
-        files: true,
-        transpileOnly: true,
-        ignore: [
-          "(?:^|/)node_modules/",
-          `(?:^|/)${path.relative(appDir, distDir)}/`
-        ],
-        ...tsNodeOptions
-      });
-    } catch (error) {
-      if (process.env.DEBUG) {
-        logger.error(error);
-      }
-      await registerEsbuild({
-        isTsProject,
-        tsConfig,
-        distDir
-      });
-    }
-  }
-  const tsConfigPaths = (await import("@modern-js/utils/tsconfig-paths")).default;
-  if (await fs.pathExists(appDir)) {
-    tsConfigPaths.register({
-      baseUrl: absoluteBaseUrl || "./",
-      paths: tsPaths
-    });
-  }
-};
-export {
-  registerCompiler
-};

package/dist/esm-node/utils/restart.js

@@ -1,23 +0,0 @@
-import { cli } from "@modern-js/plugin-v2/cli";
-import { chalk, clearConsole, getFullArgv, logger } from "@modern-js/utils";
-import { program } from "@modern-js/utils/commander";
-async function restart(hooks, filename) {
-  clearConsole();
-  logger.info(`Restart because ${chalk.yellow(filename)} is changed...
-`);
-  let hasGetError = false;
-  await hooks.onBeforeRestart.call();
-  try {
-    await cli.init(cli.getPrevInitOptions());
-  } catch (err) {
-    console.error(err);
-    hasGetError = true;
-  } finally {
-    if (!hasGetError) {
-      program.parse(getFullArgv());
-    }
-  }
-}
-export {
-  restart
-};

package/dist/esm-node/utils/routes.js

@@ -1,21 +0,0 @@
-import path from "path";
-import { fs, MAIN_ENTRY_NAME, ROUTE_SPEC_FILE } from "@modern-js/utils";
-const generateRoutes = async (appContext) => {
-  const { serverRoutes, distDirectory } = appContext;
-  const output = JSON.stringify({
-    routes: serverRoutes
-  }, null, 2);
-  await fs.outputFile(path.join(distDirectory, ROUTE_SPEC_FILE), output);
-};
-const getPathWithoutExt = (filename) => {
-  const extname = path.extname(filename);
-  return filename.slice(0, -extname.length);
-};
-const isMainEntry = (entryName, mainEntryName) => {
-  return entryName === (mainEntryName || MAIN_ENTRY_NAME);
-};
-export {
-  generateRoutes,
-  getPathWithoutExt,
-  isMainEntry
-};