@modern-js/app-tools 2.57.2-alpha.0 → 2.58.1-alpha.0

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

@@ -5,7 +5,7 @@ const devCommand = async (program, api) => {
   const runner = api.useHookRunners();
   const devToolMetas = await runner.registerDev();
   const devProgram = program.command("dev").alias("start").usage("[options]").description(i18n.t(localeKeys.command.dev.describe)).option("-c --config <config>", i18n.t(localeKeys.command.shared.config)).option("-e --entry [entry...]", i18n.t(localeKeys.command.dev.entry)).option("--analyze", i18n.t(localeKeys.command.shared.analyze)).option("--api-only", i18n.t(localeKeys.command.dev.apiOnly)).option("--web-only", i18n.t(localeKeys.command.dev.webOnly)).action(async (options) => {
-    const { dev } = await import("./dev.js");
+    const { dev } = await import("./dev");
     await dev(api, options);
   });
   for (const meta of devToolMetas) {
@@ -28,7 +28,7 @@ const buildCommand = async (program, api) => {
   const runner = api.useHookRunners();
   const platformBuilders = await runner.registerBuildPlatform();
   const buildProgram = program.command("build").usage("[options]").description(i18n.t(localeKeys.command.build.describe)).option("-c --config <config>", i18n.t(localeKeys.command.shared.config)).option("--analyze", i18n.t(localeKeys.command.shared.analyze)).action(async (options) => {
-    const { build } = await import("./build.js");
+    const { build } = await import("./build");
     await build(api, options);
   });
   for (const platformBuilder of platformBuilders) {
@@ -47,17 +47,17 @@ const buildCommand = async (program, api) => {
 };
 const serverCommand = (program, api) => {
   program.command("serve").usage("[options]").description(i18n.t(localeKeys.command.serve.describe)).option("--api-only", i18n.t(localeKeys.command.dev.apiOnly)).option("-c --config <config>", i18n.t(localeKeys.command.shared.config)).action(async () => {
-    const { start } = await import("./serve.js");
+    const { start } = await import("./serve");
     await start(api);
   });
 };
 const deployCommand = (program, api) => {
   program.command("deploy").usage("[options]").option("-c --config <config>", i18n.t(localeKeys.command.shared.config)).option("-s --skip-build", i18n.t(localeKeys.command.shared.skipBuild)).description(i18n.t(localeKeys.command.deploy.describe)).action(async (options) => {
     if (!options.skipBuild) {
-      const { build } = await import("./build.js");
+      const { build } = await import("./build");
       await build(api);
     }
-    const { deploy } = await import("./deploy.js");
+    const { deploy } = await import("./deploy");
     await deploy(api, options);
     process.exit(0);
   });
@@ -71,8 +71,8 @@ const newCommand = (program, locale) => {
   });
 };
 const inspectCommand = (program, api) => {
-  program.command("inspect").description("inspect the internal configs").option(`--env <env>`, i18n.t(localeKeys.command.inspect.env), "development").option("--output <output>", i18n.t(localeKeys.command.inspect.output), "/").option("--verbose", i18n.t(localeKeys.command.inspect.verbose)).option("-c --config <config>", i18n.t(localeKeys.command.shared.config)).action(async (options) => {
-    const { inspect } = await import("./inspect.js");
+  program.command("inspect").description("inspect the internal configs").option(`--env <env>`, i18n.t(localeKeys.command.inspect.env), "development").option("--output <output>", i18n.t(localeKeys.command.inspect.output), "./").option("--verbose", i18n.t(localeKeys.command.inspect.verbose)).option("-c --config <config>", i18n.t(localeKeys.command.shared.config)).action(async (options) => {
+    const { inspect } = await import("./inspect");
     inspect(api, options);
   });
 };

package/dist/esm-node/index.js

@@ -1,6 +1,6 @@
 import path from "path";
 import { lintPlugin } from "@modern-js/plugin-lint";
-import { cleanRequireCache, emptyDir, getCommand, getArgv, fs, NESTED_ROUTE_SPEC_FILE } from "@modern-js/utils";
+import { cleanRequireCache, emptyDir, getCommand, getArgv } from "@modern-js/utils";
 import { getLocaleLanguage } from "@modern-js/plugin-i18n/language-detector";
 import initializePlugin from "./plugins/initialize";
 import analyzePlugin from "./plugins/analyze";
@@ -47,7 +47,6 @@ const appTools = (options = {
       ...appContext,
       toolsType: "app-tools"
     });
-    const nestedRoutes = {};
     const locale = getLocaleLanguage();
     i18n.changeLanguage({
       locale
@@ -112,21 +111,6 @@ const appTools = (options = {
         cleanRequireCache([
           require.resolve("./plugins/analyze")
         ]);
-      },
-      async modifyFileSystemRoutes({ entrypoint, routes }) {
-        nestedRoutes[entrypoint.entryName] = routes;
-        return {
-          entrypoint,
-          routes
-        };
-      },
-      async beforeGenerateRoutes({ entrypoint, code }) {
-        const { distDirectory } = api.useAppContext();
-        await fs.outputJSON(path.resolve(distDirectory, NESTED_ROUTE_SPEC_FILE), nestedRoutes);
-        return {
-          entrypoint,
-          code
-        };
       }
     };
   }

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

@@ -7,7 +7,6 @@ import { getSelectedEntries } from "../../utils/getSelectedEntries";
 import { initialNormalizedConfig } from "../../config";
 import { createBuilderGenerator } from "../../builder";
 import { checkIsBuildCommands } from "./utils";
-import { compatibleRequire } from "@modern-js/utils";
 const debug = createDebugger("plugin-analyze");
 var analyze_default = ({ bundler }) => ({
   name: "@modern-js/plugin-analyze",
@@ -45,9 +44,9 @@ var analyze_default = ({ bundler }) => ({
           return;
         }
         const [{ getBundleEntry }, { getServerRoutes }, { getHtmlTemplate }] = await Promise.all([
-          compatibleRequire(path.join(__dirname, "./getBundleEntry.js")),
-          compatibleRequire(path.join(__dirname, "./getServerRoutes.js")),
-          compatibleRequire(path.join(__dirname, "./getHtmlTemplate.js"))
+          import("./getBundleEntry"),
+          import("./getServerRoutes"),
+          import("./getHtmlTemplate")
         ]);
         const { entrypoints } = await hookRunners.modifyEntrypoints({
           entrypoints: await getBundleEntry(hookRunners, appContext, resolvedConfig)
@@ -100,7 +99,10 @@ var analyze_default = ({ bundler }) => ({
             normalizedConfig,
             appContext
           });
-          builder.onBeforeBuild(async ({ bundlerConfigs }) => {
+          builder.onBeforeBuild(async ({ bundlerConfigs, isFirstCompile }) => {
+            if (!isFirstCompile) {
+              return;
+            }
             const hookRunners2 = api.useHookRunners();
             await generateRoutes(appContext);
             await hookRunners2.beforeBuild({

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

@@ -2,12 +2,28 @@ 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 } from "./utils";
-const handleDependencies = async ({ appDir, serverRootDir, includeEntries, traceFiles = defaultTraceFiles, entryFilter, modifyPackageJson, copyWholePackage }) => {
+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, cacheOptions = {
+  cacheDir: ".modern-js/deploy",
+  fileCache: true,
+  analysisCache: true
+}, traceOptions }) => {
   const base = "/";
+  const startTime = Date.now();
   const entryFiles = await findEntryFiles(serverRootDir, entryFilter);
-  const fileTrace = await traceFiles(entryFiles.concat(includeEntries), serverRootDir, base);
+  const fileTrace = await traceFiles({
+    entryFiles: entryFiles.concat(includeEntries),
+    serverRootDir,
+    cacheOptions: {
+      ...cacheOptions,
+      cacheDir: path.resolve(appDir, cacheOptions.cacheDir)
+    },
+    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]) => {
@@ -15,7 +31,7 @@ const handleDependencies = async ({ appDir, serverRootDir, includeEntries, trace
       return;
     }
     const filePath = await resolveTracedPath(base, _path);
-    if (filePath.startsWith(serverRootDir) || filePath.startsWith(appDir) && !filePath.startsWith(currentProjectModules)) {
+    if (isSubPath(serverRootDir, filePath) || isSubPath(appDir, filePath) && !isSubPath(currentProjectModules, filePath)) {
       return;
     }
     if (!await isFile(filePath)) {
@@ -38,7 +54,7 @@ const handleDependencies = async ({ appDir, serverRootDir, includeEntries, trace
       const packageJsonPath = match ? path.join(match[0], "package.json") : await pkgUp({
         cwd: path.dirname(filePath)
       });
-      if (packageJsonPath) {
+      if (packageJsonPath && isSubPath(dependencySearchRoot, packageJsonPath)) {
         const packageJson = await fse.readJSON(packageJsonPath);
         pkgPath = baseDir = path.dirname(packageJsonPath);
         subpath = path.relative(baseDir, filePath);
@@ -55,7 +71,7 @@ const handleDependencies = async ({ appDir, serverRootDir, includeEntries, trace
       path: filePath,
       parents,
       isDirectDep: parents.some((parent) => {
-        return parent.startsWith(appDir) && !parent.startsWith(currentProjectModules);
+        return isSubPath(appDir, parent) && !isSubPath(currentProjectModules, parent);
       }),
       subpath,
       pkgName,
@@ -187,7 +203,10 @@ const handleDependencies = async ({ appDir, serverRootDir, includeEntries, trace
   };
   const finalPkgJson = (modifyPackageJson === null || modifyPackageJson === void 0 ? void 0 : modifyPackageJson(newPkgJson)) || newPkgJson;
   await fse.writeJSON(outputPkgPath, finalPkgJson);
+  const endTime = Date.now();
+  console.log("handleDependencies cost:", endTime - startTime);
 };
 export {
-  handleDependencies
+  handleDependencies,
+  nodeFileTrace
 };

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

@@ -98,17 +98,97 @@ const findPackageParents = (pkg, version, tracedFiles) => {
   ];
   return parentPkgs.filter((parentPkg) => parentPkg);
 };
-const traceFiles = async (entryFiles, serverRootDir, base = "/") => {
-  return await nodeFileTrace(entryFiles, {
+async function serializeMap(map) {
+  const resolvedMap = /* @__PURE__ */ new Map();
+  await Promise.all(Array.from(map.entries()).map(async ([key, value]) => {
+    resolvedMap.set(key, value instanceof Promise ? await Promise.resolve(value) : value);
+  }));
+  return JSON.stringify(resolvedMap, (key, value) => {
+    if (value instanceof Map) {
+      return {
+        dataType: "Map",
+        value: Array.from(value.entries())
+      };
+    }
+    if (value instanceof Set) {
+      return {
+        dataType: "Set",
+        value: Array.from(value)
+      };
+    }
+    return value;
+  });
+}
+function deserializeMap(serializedData) {
+  return JSON.parse(serializedData, (key, value) => {
+    if (value && value.dataType === "Map") {
+      return new Map(value.value);
+    }
+    if (value && value.dataType === "Set") {
+      return new Set(value.value);
+    }
+    return value;
+  });
+}
+const traceFiles = async ({ entryFiles, serverRootDir, base = "/", cacheOptions, traceOptions }) => {
+  const { cacheDir, fileCache: enableFileCache, analysisCache: enableAnalysisCache } = cacheOptions;
+  const analysisCacheFile = path.join(cacheDir, "analysis-cache.json");
+  const fileCacheFile = path.join(cacheDir, "file-cache.json");
+  const cache = /* @__PURE__ */ Object.create(null);
+  if (enableAnalysisCache && await fse.pathExists(analysisCacheFile)) {
+    const analysisCache2 = (await fse.readFile(analysisCacheFile)).toString();
+    cache.analysisCache = deserializeMap(analysisCache2);
+  }
+  if (enableFileCache && await fse.pathExists(fileCacheFile)) {
+    const fileCache2 = (await fse.readFile(fileCacheFile)).toString();
+    cache.fileCache = deserializeMap(fileCache2);
+  }
+  const res = await nodeFileTrace(entryFiles, {
     base,
-    processCwd: serverRootDir
+    processCwd: serverRootDir,
+    cache,
+    ...traceOptions
   });
+  const { analysisCache, fileCache } = cache;
+  if (analysisCache || fileCache) {
+    await fse.ensureDir(cacheDir);
+    if (analysisCache) {
+      const newAnalysisCache = new Map(analysisCache);
+      for (const key of newAnalysisCache.keys()) {
+        if (!key.includes("node_modules/")) {
+          newAnalysisCache.delete(key);
+        }
+      }
+      fse.writeFile(analysisCacheFile, await serializeMap(newAnalysisCache));
+    }
+    if (fileCache) {
+      const newFileCache = new Map(fileCache);
+      for (const key of newFileCache.keys()) {
+        if (!key.includes("node_modules/")) {
+          newFileCache.delete(key);
+        }
+      }
+      console.time("111");
+      fse.writeFile(fileCacheFile, await serializeMap(newFileCache));
+      console.timeEnd("111");
+    }
+  }
+  console.log("ffffffff", __filename);
+  return res;
 };
 const resolveTracedPath = async (base, p) => fse.realpath(path.resolve(base, p));
+const isSubPath = (parentPath, childPath) => {
+  if (!parentPath || !childPath) {
+    return false;
+  }
+  const relative = path.relative(parentPath, childPath);
+  return relative && !relative.startsWith("..");
+};
 export {
   findEntryFiles,
   findPackageParents,
   isFile,
+  isSubPath,
   linkPackage,
   readDirRecursive,
   resolveTracedPath,

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

@@ -1,6 +1,7 @@
 import * as path from "path";
 import { bundle } from "@modern-js/node-bundle-require";
 import { fs, getServerConfig, ensureAbsolutePath, OUTPUT_CONFIG_FILE, CONFIG_FILE_EXTENSIONS } 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);
@@ -33,32 +34,16 @@ const buildServerConfig = async ({ appDirectory, distDirectory, configFile, opti
     });
   }
 };
-const safeReplacer = () => {
-  const cache = [];
-  const keyCache = [];
-  return function(key, value) {
-    if (typeof value === "object" && value !== null) {
-      const index = cache.indexOf(value);
-      if (index !== -1) {
-        return `[Circular ${keyCache[index]}]`;
-      }
-      cache.push(value);
-      keyCache.push(key || "root");
-    }
-    return value;
-  };
-};
 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));
-  await fs.writeJSON(outputPath, resolvedConfig, {
-    spaces: 2,
-    replacer: safeReplacer()
+  const output = stringify(resolvedConfig);
+  await fs.writeFile(outputPath, output, {
+    encoding: "utf-8"
   });
 };
 export {
   buildServerConfig,
   defineServerConfig,
-  emitResolvedConfig,
-  safeReplacer
+  emitResolvedConfig
 };

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

@@ -15,7 +15,7 @@ const createServer = async (options) => {
   if (server) {
     server.close();
   }
-  server = await createDevServer(options, applyPlugins);
+  server = (await createDevServer(options, applyPlugins)).server;
   return server;
 };
 export {

package/dist/types/builder/index.d.ts

@@ -1 +1 @@
-export declare function createBuilderGenerator(bundler: 'webpack' | 'rspack'): Promise<typeof import("./builder-rspack/index.js").createRspackBuilderForModern>;
+export declare function createBuilderGenerator(bundler: 'webpack' | 'rspack'): Promise<typeof import("./builder-rspack").createRspackBuilderForModern>;

package/dist/types/plugins/deploy/dependencies/index.d.ts

@@ -1,20 +1,22 @@
 import type { PackageJson } from 'pkg-types';
 import type { NodeFileTraceOptions } from '@vercel/nft';
-import { traceFiles as defaultTraceFiles } from './utils';
+import { traceFiles as defaultTraceFiles, CacheOptions } from './utils';
 export type { NodeFileTraceOptions } from '@vercel/nft';
 export { nodeFileTrace } from '@vercel/nft';
-export declare const handleDependencies: ({ appDir, serverRootDir, includeEntries, traceFiles, entryFilter, modifyPackageJson, copyWholePackage, traceOptions, }: {
+export declare const handleDependencies: ({ appDir, serverRootDir, includeEntries, traceFiles, entryFilter, modifyPackageJson, copyWholePackage, cacheOptions, traceOptions, }: {
     appDir: string;
     serverRootDir: string;
     includeEntries: string[];
-    traceFiles?: (({ entryFiles, serverRootDir, base, traceOptions, }: {
+    traceFiles?: (({ entryFiles, serverRootDir, base, cacheOptions, traceOptions, }: {
         entryFiles: string[];
         serverRootDir: string;
         base?: string | undefined;
+        cacheOptions: CacheOptions;
         traceOptions?: NodeFileTraceOptions | undefined;
     }) => Promise<import("@vercel/nft").NodeFileTraceResult>) | undefined;
     entryFilter?: ((filePath: string) => boolean) | undefined;
     modifyPackageJson?: ((pkgJson: PackageJson) => PackageJson) | undefined;
     copyWholePackage?: ((pkgName: string) => boolean) | undefined;
+    cacheOptions?: CacheOptions | undefined;
     traceOptions?: NodeFileTraceOptions | undefined;
 }) => Promise<void>;

package/dist/types/plugins/deploy/dependencies/utils.d.ts

@@ -33,10 +33,16 @@ export declare const readDirRecursive: (dir: string, options?: ReadDirOptions) =
 export declare const isFile: (file: string) => Promise<boolean>;
 export declare const findEntryFiles: (rootDir: string, entryFilter?: ((filePath: string) => boolean) | undefined) => Promise<string[]>;
 export declare const findPackageParents: (pkg: TracedPackage, version: string, tracedFiles: Record<string, TracedFile>) => string[];
-export declare const traceFiles: ({ entryFiles, serverRootDir, base, traceOptions, }: {
+export interface CacheOptions {
+    fileCache: boolean;
+    analysisCache: boolean;
+    cacheDir: string;
+}
+export declare const traceFiles: ({ entryFiles, serverRootDir, base, cacheOptions, traceOptions, }: {
     entryFiles: string[];
     serverRootDir: string;
     base?: string | undefined;
+    cacheOptions: CacheOptions;
     traceOptions?: NodeFileTraceOptions | undefined;
 }) => Promise<import("@vercel/nft").NodeFileTraceResult>;
 export declare const resolveTracedPath: (base: string, p: string) => Promise<string>;

package/dist/types/plugins/deploy/platforms/netlifyEntry.d.ts

@@ -0,0 +1,2 @@
+declare function _default(request: any, context: any): Promise<any>;
+export default _default;

package/dist/types/plugins/deploy/platforms/vercelEntry.d.ts

@@ -0,0 +1,2 @@
+declare function _exports(req: any, res: any): Promise<any>;
+export = _exports;

package/dist/types/utils/config.d.ts

@@ -9,9 +9,4 @@ export declare const buildServerConfig: ({ appDirectory, distDirectory, configFi
     options?: Parameters<typeof bundle>[1];
     watch?: boolean | undefined;
 }) => Promise<void>;
-/**
- *
- * 处理循环引用的 replacer
- */
-export declare const safeReplacer: () => (key: string, value: unknown) => unknown;
 export declare const emitResolvedConfig: (appDirectory: string, resolvedConfig: AppNormalizedConfig<'shared'>) => Promise<void>;

package/package.json

@@ -15,7 +15,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "2.57.2-alpha.0",
+  "version": "2.58.1-alpha.0",
   "jsnext:source": "./src/index.ts",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/cjs/index.js",
@@ -77,43 +77,45 @@
     "@babel/parser": "^7.22.15",
     "@babel/traverse": "^7.23.2",
     "@babel/types": "^7.24.7",
-    "@rsbuild/plugin-node-polyfill": "1.0.3",
-    "@rsbuild/core": "1.0.1-beta.9",
+    "@rsbuild/core": "1.0.1-beta.10",
+    "@rsbuild/plugin-node-polyfill": "1.0.4",
     "@swc/helpers": "0.5.3",
+    "@ungap/structured-clone": "^1.2.0",
     "@vercel/nft": "^0.26.4",
     "es-module-lexer": "^1.1.0",
     "esbuild": "0.17.19",
     "esbuild-register": "^3.5.0",
+    "flatted": "^3.2.9",
     "mlly": "^1.6.1",
     "pkg-types": "^1.1.0",
     "std-env": "^3.7.0",
-    "@modern-js/core": "2.57.1",
-    "@modern-js/node-bundle-require": "2.57.1",
-    "@modern-js/plugin-data-loader": "2.57.1",
-    "@modern-js/plugin-i18n": "2.57.1",
-    "@modern-js/plugin": "2.57.1",
-    "@modern-js/rsbuild-plugin-esbuild": "2.57.1",
-    "@modern-js/server": "2.57.1",
-    "@modern-js/plugin-lint": "2.57.1",
-    "@modern-js/server-core": "2.57.1",
-    "@modern-js/server-utils": "2.57.1",
-    "@modern-js/types": "2.57.1",
-    "@modern-js/utils": "2.57.1",
-    "@modern-js/prod-server": "2.57.1",
-    "@modern-js/uni-builder": "2.57.1"
+    "@modern-js/core": "2.58.0",
+    "@modern-js/node-bundle-require": "2.58.0",
+    "@modern-js/plugin": "2.58.0",
+    "@modern-js/plugin-i18n": "2.58.0",
+    "@modern-js/plugin-lint": "2.58.0",
+    "@modern-js/server-core": "2.58.0",
+    "@modern-js/rsbuild-plugin-esbuild": "2.58.0",
+    "@modern-js/types": "2.58.0",
+    "@modern-js/server": "2.58.0",
+    "@modern-js/utils": "2.58.0",
+    "@modern-js/uni-builder": "2.58.0",
+    "@modern-js/prod-server": "2.58.0",
+    "@modern-js/server-utils": "2.58.0",
+    "@modern-js/plugin-data-loader": "2.58.0"
   },
   "devDependencies": {
-    "@rsbuild/plugin-swc": "1.0.1-beta.9",
+    "@rsbuild/plugin-swc": "1.0.1-beta.10",
     "@types/babel__traverse": "7.18.5",
     "@types/jest": "^29",
-    "@types/node": "^16",
+    "@types/node": "^14",
     "jest": "^29",
     "ts-node": "^10.9.1",
     "tsconfig-paths": "^4.2.0",
     "typescript": "^5",
     "webpack": "^5.93.0",
-    "@scripts/jest-config": "2.57.1",
-    "@scripts/build": "2.57.1"
+    "@scripts/build": "2.58.0",
+    "@scripts/jest-config": "2.58.0"
   },
   "sideEffects": false,
   "publishConfig": {

package/dist/cjs/esm/esbuild-loader.mjs

@@ -1,20 +0,0 @@
-import { pathToFileURL } from 'url';
-import { createMatchPath } from './utils.mjs';
-
-let matchPath;
-export async function initialize({ appDir, alias, tsconfigPath }) {
-  matchPath = createMatchPath({
-    alias,
-    appDir,
-    tsconfigPath,
-  });
-}
-
-export function resolve(specifier, context, defaultResolve) {
-  const match = matchPath(specifier);
-  return match
-    ? defaultResolve(pathToFileURL(match).href, context)
-    : defaultResolve(specifier, context);
-}
-
-export { load } from 'esbuild-register/loader';

package/dist/cjs/esm/register-esm.mjs

@@ -1,65 +0,0 @@
-import path from 'node:path';
-import { fs, readTsConfigByFile } from '@modern-js/utils';
-
-const checkDep = async dep => {
-  try {
-    await import(dep);
-    return true;
-  } catch (error) {
-    return false;
-  }
-};
-
-export const registerEsm = async ({ appDir, distDir, alias }) => {
-  const nodeVersion = process.versions.node;
-  const versionArr = nodeVersion.split('.').map(Number);
-  if (versionArr[0] < 18 || (versionArr[0] === 18 && versionArr[1] < 19)) {
-    throw new Error(
-      `The node version of the esm project must be greater than 18.19.0, current version is ${nodeVersion}`,
-    );
-  }
-  const hasTsNode = await checkDep('ts-node');
-  const TS_CONFIG_FILENAME = `tsconfig.json`;
-  const tsconfigPath = path.resolve(appDir, TS_CONFIG_FILENAME);
-  const hasTsconfig = await fs.pathExists(tsconfigPath);
-  const { register } = await import('node:module');
-  if (hasTsNode && hasTsconfig) {
-    // These can be overridden by ts-node options in tsconfig.json
-    process.env.TS_NODE_TRANSPILE_ONLY = true;
-    process.env.TS_NODE_PROJECT = tsconfigPath;
-    process.env.TS_NODE_SCOPE = true;
-    process.env.TS_NODE_FILES = true;
-    process.env.TS_NODE_IGNORE = `(?:^|/)node_modules/,(?:^|/)${path.relative(
-      appDir,
-      distDir,
-    )}/`;
-    register('./ts-node-loader.mjs', import.meta.url, {
-      data: {
-        appDir,
-        distDir,
-        alias,
-        tsconfigPath,
-      },
-    });
-  } else {
-    process.env.MODERN_NODE_LOADER = 'esbuild';
-    let tsConfig = {};
-    if (hasTsconfig) {
-      tsConfig = readTsConfigByFile(tsconfigPath);
-    }
-    const esbuildRegister = await import('esbuild-register/dist/node');
-    esbuildRegister.register({
-      tsconfigRaw: hasTsconfig ? tsConfig : undefined,
-      hookIgnoreNodeModules: true,
-      hookMatcher: fileName => !fileName.startsWith(distDir),
-    });
-    register('./esbuild-loader.mjs', import.meta.url, {
-      data: {
-        appDir,
-        distDir,
-        alias,
-        tsconfigPath,
-      },
-    });
-  }
-};

package/dist/cjs/esm/ts-node-loader.mjs

@@ -1,21 +0,0 @@
-import { pathToFileURL } from 'url';
-import { resolve as tsNodeResolve } from 'ts-node/esm';
-import { createMatchPath } from './utils.mjs';
-
-let matchPath;
-export async function initialize({ appDir, alias, tsconfigPath }) {
-  matchPath = createMatchPath({
-    alias,
-    appDir,
-    tsconfigPath,
-  });
-}
-
-export function resolve(specifier, context, defaultResolve) {
-  const match = matchPath(specifier);
-  return match
-    ? tsNodeResolve(pathToFileURL(match).href, context, defaultResolve)
-    : tsNodeResolve(specifier, context, defaultResolve);
-}
-
-export { transformSource, load } from 'ts-node/esm';

package/dist/cjs/esm/utils.mjs

@@ -1,43 +0,0 @@
-import path from 'path';
-import { createRequire } from 'module';
-import tsConfigPaths from '@modern-js/utils/tsconfig-paths';
-import { getAliasConfig } from '@modern-js/utils';
-
-const require = createRequire(import.meta.url);
-export function createMatchPath({ alias, appDir, tsconfigPath }) {
-  const aliasConfig = getAliasConfig(alias, {
-    appDirectory: appDir,
-    tsconfigPath,
-  });
-
-  const { paths = {}, absoluteBaseUrl = './' } = aliasConfig;
-
-  const tsPaths = Object.keys(paths).reduce((o, key) => {
-    let tsPath = paths[key];
-    // Do some special handling for Modern.js's internal alias, we can drop it in the next version
-    if (
-      typeof tsPath === 'string' &&
-      key.startsWith('@') &&
-      tsPath.startsWith('@')
-    ) {
-      try {
-        tsPath = require.resolve(tsPath, {
-          paths: [appDir],
-        });
-      } catch {}
-    }
-
-    if (typeof tsPath === 'string' && path.isAbsolute(tsPath)) {
-      tsPath = path.relative(absoluteBaseUrl, tsPath);
-    }
-    if (typeof tsPath === 'string') {
-      tsPath = [tsPath];
-    }
-    return {
-      ...o,
-      [`${key}`]: tsPath,
-    };
-  }, {});
-
-  return tsConfigPaths.createMatchPath(absoluteBaseUrl, tsPaths);
-}

package/dist/cjs/plugins/deploy/platforms/netlify-entry.js

@@ -1,3 +0,0 @@
-"use strict";
-const { handler } = require("./netlify-handler");
-module.exports.default = handler;

package/dist/cjs/plugins/deploy/platforms/netlify-entry.mjs

@@ -1 +0,0 @@
-export { handler as default } from './netlify-handler.cjs';