@modern-js/app-tools 2.57.1-beta.2 → 2.57.2-alpha.0

package/dist/cjs/builder/builder-rspack/adapterCopy.js

@@ -73,10 +73,10 @@ const builderPluginAdpaterCopy = (options) => ({
       const filepaths = (await import_fs_extra.default.readdir(publicDir)).map((file) => import_path.default.resolve(publicDir, file));
       await Promise.all(filepaths.filter((file) => HTML_REGEXP.test(file)).map(async (file) => {
         const content = await import_fs_extra.default.readFile(file, "utf-8");
-        if (publicPath) {
+        if (publicPath && typeof publicPath === "string") {
           await import_fs_extra.default.writeFile(file, content.replace(/<%=\s*assetPrefix\s*%>/g, (0, import_utils.removeTailSlash)(publicPath)));
         } else {
-          import_utils.logger.warn("Expect get a string from `publicPath`, but receive `undefined`.");
+          import_utils.logger.warn(`Expect get a string from \`publicPath\`, but receive \`${typeof publicPath}\`.`);
           await import_fs_extra.default.writeFile(file, content.replace(/<%=\s*assetPrefix\s*%>/g, (0, import_utils.removeTailSlash)("/")));
         }
       }));

package/dist/cjs/builder/builder-webpack/index.js

@@ -38,7 +38,7 @@ async function createWebpackBuilderForModern(options) {
   const { normalizedConfig } = options;
   if (normalizedConfig.tools.esbuild) {
     const { esbuild: esbuildOptions } = normalizedConfig.tools;
-    const { pluginEsbuild } = await Promise.resolve().then(() => __toESM(require("@modern-js/rsbuild-plugin-esbuild")));
+    const { pluginEsbuild } = await import("@modern-js/rsbuild-plugin-esbuild");
     builder.addPlugins([
       pluginEsbuild(esbuildOptions)
     ]);

package/dist/cjs/builder/generator/index.js

@@ -50,7 +50,7 @@ async function generateBuilder(options, bundlerType) {
   return builder;
 }
 async function applyBuilderPlugins(builder, options) {
-  const { builderPluginAdapterBasic, builderPluginAdapterHtml, builderPluginAdapterSSR, builderPluginAdapterWorker } = await Promise.resolve().then(() => __toESM(require("../shared/builderPlugins")));
+  const { builderPluginAdapterBasic, builderPluginAdapterHtml, builderPluginAdapterSSR, builderPluginAdapterWorker } = await import("../shared/builderPlugins/index.js");
   builder.addPlugins([
     builderPluginAdapterBasic(),
     builderPluginAdapterSSR(options),
@@ -59,7 +59,7 @@ async function applyBuilderPlugins(builder, options) {
   ]);
   const { normalizedConfig } = options;
   if (!normalizedConfig.output.disableNodePolyfill) {
-    const { pluginNodePolyfill } = await Promise.resolve().then(() => __toESM(require("@rsbuild/plugin-node-polyfill")));
+    const { pluginNodePolyfill } = await import("@rsbuild/plugin-node-polyfill");
     builder.addPlugins([
       pluginNodePolyfill()
     ]);

package/dist/cjs/builder/index.js

@@ -33,10 +33,10 @@ __export(builder_exports, {
 module.exports = __toCommonJS(builder_exports);
 async function createBuilderGenerator(bundler) {
   if (bundler === "rspack") {
-    const { createRspackBuilderForModern } = await Promise.resolve().then(() => __toESM(require("./builder-rspack")));
+    const { createRspackBuilderForModern } = await import("./builder-rspack/index.js");
     return createRspackBuilderForModern;
   }
-  const { createWebpackBuilderForModern } = await Promise.resolve().then(() => __toESM(require("./builder-webpack")));
+  const { createWebpackBuilderForModern } = await import("./builder-webpack/index.js");
   return createWebpackBuilderForModern;
 }
 // Annotate the CommonJS export names for ESM import in node:

package/dist/cjs/commands/build.js

@@ -1,7 +1,9 @@
 "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)
@@ -15,6 +17,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   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 build_exports = {};
 __export(build_exports, {
@@ -36,6 +46,15 @@ const build = async (api, options) => {
   const appContext = api.useAppContext();
   const hookRunners = api.useHookRunners();
   await (0, import_loadPlugins.loadServerPlugins)(api, appContext.appDirectory, appContext.metaName);
+  if (appContext.moduleType && appContext.moduleType === "module") {
+    var _resolvedConfig_source1;
+    const { registerEsm } = await import("../esm/register-esm.mjs");
+    await registerEsm({
+      appDir: appContext.appDirectory,
+      distDir: appContext.distDirectory,
+      alias: (_resolvedConfig_source1 = resolvedConfig.source) === null || _resolvedConfig_source1 === void 0 ? void 0 : _resolvedConfig_source1.alias
+    });
+  }
   await (0, import_register.registerCompiler)(appContext.appDirectory, appContext.distDirectory, resolvedConfig === null || resolvedConfig === void 0 ? void 0 : (_resolvedConfig_source = resolvedConfig.source) === null || _resolvedConfig_source === void 0 ? void 0 : _resolvedConfig_source.alias);
   const { apiOnly } = appContext;
   if (apiOnly) {

package/dist/cjs/commands/dev.js

@@ -50,6 +50,15 @@ const dev = async (api, options, devServerOptions) => {
   let normalizedConfig = api.useResolvedConfigContext();
   const appContext = api.useAppContext();
   const hookRunners = api.useHookRunners();
+  if (appContext.moduleType && appContext.moduleType === "module") {
+    var _normalizedConfig_source1;
+    const { registerEsm } = await import("../esm/register-esm.mjs");
+    await registerEsm({
+      appDir: appContext.appDirectory,
+      distDir: appContext.distDirectory,
+      alias: (_normalizedConfig_source1 = normalizedConfig.source) === null || _normalizedConfig_source1 === void 0 ? void 0 : _normalizedConfig_source1.alias
+    });
+  }
   await (0, import_register.registerCompiler)(appContext.appDirectory, appContext.distDirectory, normalizedConfig === null || normalizedConfig === void 0 ? void 0 : (_normalizedConfig_source = normalizedConfig.source) === null || _normalizedConfig_source === void 0 ? void 0 : _normalizedConfig_source.alias);
   normalizedConfig = {
     ...normalizedConfig,

package/dist/cjs/commands/index.js

@@ -44,7 +44,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(import_locale.i18n.t(import_locale.localeKeys.command.dev.describe)).option("-c --config <config>", import_locale.i18n.t(import_locale.localeKeys.command.shared.config)).option("-e --entry [entry...]", import_locale.i18n.t(import_locale.localeKeys.command.dev.entry)).option("--analyze", import_locale.i18n.t(import_locale.localeKeys.command.shared.analyze)).option("--api-only", import_locale.i18n.t(import_locale.localeKeys.command.dev.apiOnly)).option("--web-only", import_locale.i18n.t(import_locale.localeKeys.command.dev.webOnly)).action(async (options) => {
-    const { dev } = await Promise.resolve().then(() => __toESM(require("./dev")));
+    const { dev } = await import("./dev.js");
     await dev(api, options);
   });
   for (const meta of devToolMetas) {
@@ -54,7 +54,7 @@ const devCommand = async (program, api) => {
     for (const subCmd of meta.subCommands) {
       devProgram.command(subCmd).action(async (options = {}) => {
         const { appDirectory } = api.useAppContext();
-        const { isTypescript } = await Promise.resolve().then(() => __toESM(require("@modern-js/utils")));
+        const { isTypescript } = await import("@modern-js/utils");
         await runner.beforeDevTask(meta);
         await meta.action(options, {
           isTsProject: isTypescript(appDirectory)
@@ -67,7 +67,7 @@ const buildCommand = async (program, api) => {
   const runner = api.useHookRunners();
   const platformBuilders = await runner.registerBuildPlatform();
   const buildProgram = program.command("build").usage("[options]").description(import_locale.i18n.t(import_locale.localeKeys.command.build.describe)).option("-c --config <config>", import_locale.i18n.t(import_locale.localeKeys.command.shared.config)).option("--analyze", import_locale.i18n.t(import_locale.localeKeys.command.shared.analyze)).action(async (options) => {
-    const { build } = await Promise.resolve().then(() => __toESM(require("./build")));
+    const { build } = await import("./build.js");
     await build(api, options);
   });
   for (const platformBuilder of platformBuilders) {
@@ -75,7 +75,7 @@ const buildCommand = async (program, api) => {
     for (const platform of platforms) {
       buildProgram.command(platform).action(async () => {
         const { appDirectory } = api.useAppContext();
-        const { isTypescript } = await Promise.resolve().then(() => __toESM(require("@modern-js/utils")));
+        const { isTypescript } = await import("@modern-js/utils");
         await runner.beforeBuildPlatform(platformBuilders);
         await platformBuilder.build(platform, {
           isTsProject: isTypescript(appDirectory)
@@ -86,17 +86,17 @@ const buildCommand = async (program, api) => {
 };
 const serverCommand = (program, api) => {
   program.command("serve").usage("[options]").description(import_locale.i18n.t(import_locale.localeKeys.command.serve.describe)).option("--api-only", import_locale.i18n.t(import_locale.localeKeys.command.dev.apiOnly)).option("-c --config <config>", import_locale.i18n.t(import_locale.localeKeys.command.shared.config)).action(async () => {
-    const { start } = await Promise.resolve().then(() => __toESM(require("./serve")));
+    const { start } = await import("./serve.js");
     await start(api);
   });
 };
 const deployCommand = (program, api) => {
   program.command("deploy").usage("[options]").option("-c --config <config>", import_locale.i18n.t(import_locale.localeKeys.command.shared.config)).option("-s --skip-build", import_locale.i18n.t(import_locale.localeKeys.command.shared.skipBuild)).description(import_locale.i18n.t(import_locale.localeKeys.command.deploy.describe)).action(async (options) => {
     if (!options.skipBuild) {
-      const { build } = await Promise.resolve().then(() => __toESM(require("./build")));
+      const { build } = await import("./build.js");
       await build(api);
     }
-    const { deploy } = await Promise.resolve().then(() => __toESM(require("./deploy")));
+    const { deploy } = await import("./deploy.js");
     await deploy(api, options);
     process.exit(0);
   });
@@ -110,8 +110,8 @@ const newCommand = (program, locale) => {
   });
 };
 const inspectCommand = (program, api) => {
-  program.command("inspect").description("inspect the internal configs").option(`--env <env>`, import_locale.i18n.t(import_locale.localeKeys.command.inspect.env), "development").option("--output <output>", import_locale.i18n.t(import_locale.localeKeys.command.inspect.output), "/").option("--verbose", import_locale.i18n.t(import_locale.localeKeys.command.inspect.verbose)).option("-c --config <config>", import_locale.i18n.t(import_locale.localeKeys.command.shared.config)).action(async (options) => {
-    const { inspect } = await Promise.resolve().then(() => __toESM(require("./inspect")));
+  program.command("inspect").description("inspect the internal configs").option(`--env <env>`, import_locale.i18n.t(import_locale.localeKeys.command.inspect.env), "development").option("--output <output>", import_locale.i18n.t(import_locale.localeKeys.command.inspect.output), "./").option("--verbose", import_locale.i18n.t(import_locale.localeKeys.command.inspect.verbose)).option("-c --config <config>", import_locale.i18n.t(import_locale.localeKeys.command.shared.config)).action(async (options) => {
+    const { inspect } = await import("./inspect.js");
     inspect(api, options);
   });
 };

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

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,65 @@
+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

@@ -0,0 +1,21 @@
+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

@@ -0,0 +1,43 @@
+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/index.js

@@ -139,7 +139,7 @@ const appTools = (options = {
       async fileChange(e) {
         const { filename, eventType, isPrivate } = e;
         if (!isPrivate && (eventType === "change" || eventType === "unlink")) {
-          const { closeServer } = await Promise.resolve().then(() => __toESM(require("./utils/createServer")));
+          const { closeServer } = await import("./utils/createServer");
           await closeServer();
           await (0, import_restart.restart)(api.useHookRunners(), filename);
         }

package/dist/cjs/plugins/analyze/index.js

@@ -77,9 +77,9 @@ var analyze_default = ({ bundler }) => ({
           return;
         }
         const [{ getBundleEntry }, { getServerRoutes }, { getHtmlTemplate }] = await Promise.all([
-          Promise.resolve().then(() => __toESM(require("./getBundleEntry"))),
-          Promise.resolve().then(() => __toESM(require("./getServerRoutes"))),
-          Promise.resolve().then(() => __toESM(require("./getHtmlTemplate")))
+          import("./getBundleEntry.js"),
+          import("./getServerRoutes.js"),
+          import("./getHtmlTemplate.js")
         ]);
         const { entrypoints } = await hookRunners.modifyEntrypoints({
           entrypoints: await getBundleEntry(hookRunners, appContext, resolvedConfig)
@@ -132,7 +132,10 @@ var analyze_default = ({ bundler }) => ({
             normalizedConfig,
             appContext
           });
-          builder.onBeforeBuild(async ({ bundlerConfigs }) => {
+          builder.onBeforeBuild(async ({ bundlerConfigs, isFirstCompile }) => {
+            if (!isFirstCompile) {
+              return;
+            }
             const hookRunners2 = api.useHookRunners();
             await (0, import_routes.generateRoutes)(appContext);
             await hookRunners2.beforeBuild({

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

@@ -56,7 +56,7 @@ const handleDependencies = async ({ appDir, serverRootDir, includeEntries, trace
       return;
     }
     const filePath = await (0, import_utils2.resolveTracedPath)(base, _path);
-    if (filePath.startsWith(serverRootDir) || filePath.startsWith(appDir) && !filePath.startsWith(currentProjectModules)) {
+    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)) {
@@ -79,7 +79,7 @@ const handleDependencies = async ({ appDir, serverRootDir, includeEntries, trace
       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 === null || packageJsonPath === void 0 ? void 0 : packageJsonPath.startsWith(dependencySearchRoot)) {
+      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);
@@ -96,7 +96,7 @@ const handleDependencies = async ({ appDir, serverRootDir, includeEntries, trace
       path: filePath,
       parents,
       isDirectDep: parents.some((parent) => {
-        return parent.startsWith(appDir) && !parent.startsWith(currentProjectModules);
+        return (0, import_utils2.isSubPath)(appDir, parent) && !(0, import_utils2.isSubPath)(currentProjectModules, parent);
       }),
       subpath,
       pkgName,
@@ -219,6 +219,7 @@ const handleDependencies = async ({ appDir, serverRootDir, includeEntries, trace
     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,

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

@@ -31,6 +31,7 @@ __export(utils_exports, {
   findEntryFiles: () => findEntryFiles,
   findPackageParents: () => findPackageParents,
   isFile: () => isFile,
+  isSubPath: () => isSubPath,
   linkPackage: () => linkPackage,
   readDirRecursive: () => readDirRecursive,
   resolveTracedPath: () => resolveTracedPath,
@@ -142,15 +143,34 @@ 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,

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

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

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

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

package/dist/cjs/plugins/deploy/platforms/{netlifyEntry.js → netlify-handler.js}

@@ -53,9 +53,11 @@ async function createHandler() {
   return requestHandler;
 }
 createHandler();
-module.exports.default = async (request, context) => {
-  if (!requestHandler) {
-    await createHandler();
+module.exports = {
+  handler: async (request, context) => {
+    if (!requestHandler) {
+      await createHandler();
+    }
+    return requestHandler(request, context);
   }
-  return requestHandler(request, context);
 };

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

@@ -50,11 +50,13 @@ async function cleanDistDirectory(dir) {
   }
 }
 const createNetlifyPreset = (appContext, modernConfig, needModernServer) => {
-  const { appDirectory, distDirectory, entrypoints, serverPlugins } = appContext;
+  const { appDirectory, distDirectory, entrypoints, serverPlugins, moduleType } = appContext;
+  const isEsmProject = moduleType === "module";
   const plugins = serverPlugins.map((plugin) => plugin.name);
   const netlifyOutput = import_node_path.default.join(appDirectory, ".netlify");
   const funcsDirectory = import_node_path.default.join(netlifyOutput, "functions");
   const entryFilePath = import_node_path.default.join(funcsDirectory, "index.js");
+  const handlerFilePath = import_node_path.default.join(funcsDirectory, "netlify-handler.cjs");
   return {
     async prepare() {
       await import_utils.fs.remove(netlifyOutput);
@@ -103,7 +105,9 @@ const createNetlifyPreset = (appContext, modernConfig, needModernServer) => {
           prefix: modernConfig === null || modernConfig === void 0 ? void 0 : (_modernConfig_bff = modernConfig.bff) === null || _modernConfig_bff === void 0 ? void 0 : _modernConfig_bff.prefix
         },
         output: {
-          path: "."
+          distPath: {
+            root: "."
+          }
         }
       };
       const pluginImportCode = (0, import_utils2.genPluginImportsCode)(plugins || []);
@@ -114,10 +118,15 @@ const createNetlifyPreset = (appContext, modernConfig, needModernServer) => {
       const pluginsCode = `[${plugins.map((plugin, index) => {
         return `plugin_${index}()`;
       }).join(",")}]`;
-      let entryCode = (await import_utils.fs.readFile(import_node_path.default.join(__dirname, "./netlifyEntry.js"))).toString();
+      let handlerCode = (await import_utils.fs.readFile(import_node_path.default.join(__dirname, "./netlify-handler.js"))).toString();
       const serverAppContext = (0, import_utils2.serverAppContenxtTemplate)(appContext);
-      entryCode = entryCode.replace("p_genPluginImportsCode", pluginImportCode).replace("p_ROUTE_SPEC_FILE", `"${import_utils.ROUTE_SPEC_FILE}"`).replace("p_dynamicProdOptions", JSON.stringify(dynamicProdOptions)).replace("p_plugins", pluginsCode).replace("p_sharedDirectory", serverAppContext.sharedDirectory).replace("p_apiDirectory", serverAppContext.apiDirectory).replace("p_lambdaDirectory", serverAppContext.lambdaDirectory);
-      await import_utils.fs.writeFile(entryFilePath, entryCode);
+      handlerCode = handlerCode.replace("handlerCode", pluginImportCode).replace("p_ROUTE_SPEC_FILE", `"${import_utils.ROUTE_SPEC_FILE}"`).replace("p_dynamicProdOptions", JSON.stringify(dynamicProdOptions)).replace("p_plugins", pluginsCode).replace("p_sharedDirectory", serverAppContext.sharedDirectory).replace("p_apiDirectory", serverAppContext.apiDirectory).replace("p_lambdaDirectory", serverAppContext.lambdaDirectory);
+      await import_utils.fs.writeFile(handlerFilePath, handlerCode);
+      if (isEsmProject) {
+        await import_utils.fs.copy(import_node_path.default.join(__dirname, "./netlify-entry.mjs"), entryFilePath);
+      } else {
+        await import_utils.fs.copy(import_node_path.default.join(__dirname, "./netlify-entry.js"), entryFilePath);
+      }
     },
     async end() {
       if (process.env.NODE_ENV !== "development") {

package/dist/cjs/plugins/deploy/platforms/node.js

@@ -36,7 +36,8 @@ var import_utils = require("@modern-js/utils");
 var import_utils2 = require("../utils");
 var import_dependencies = require("../dependencies");
 const createNodePreset = (appContext, config) => {
-  const { appDirectory, distDirectory, serverPlugins } = appContext;
+  const { appDirectory, distDirectory, serverPlugins, moduleType } = appContext;
+  const isEsmProject = moduleType === "module";
   const plugins = serverPlugins.map((plugin) => plugin.name);
   const outputDirectory = import_node_path.default.join(appDirectory, ".output");
   const staticDirectory = import_node_path.default.join(outputDirectory, "static");
@@ -58,7 +59,9 @@ const createNodePreset = (appContext, config) => {
           prefix: config === null || config === void 0 ? void 0 : (_config_bff = config.bff) === null || _config_bff === void 0 ? void 0 : _config_bff.prefix
         },
         output: {
-          path: "."
+          distPath: {
+            root: "."
+          }
         }
       };
       const pluginImportCode = (0, import_utils2.genPluginImportsCode)(plugins || []);
@@ -69,10 +72,16 @@ const createNodePreset = (appContext, config) => {
       const pluginsCode = `[${plugins.map((plugin, index) => {
         return `plugin_${index}()`;
       }).join(",")}]`;
-      let entryCode = (await import_utils.fs.readFile(import_node_path.default.join(__dirname, "./nodeEntry.js"))).toString();
+      let entryCode = (await import_utils.fs.readFile(import_node_path.default.join(__dirname, "./node-entry.js"))).toString();
       const serverAppContext = (0, import_utils2.serverAppContenxtTemplate)(appContext);
       entryCode = entryCode.replace("p_genPluginImportsCode", pluginImportCode).replace("p_ROUTE_SPEC_FILE", `"${import_utils.ROUTE_SPEC_FILE}"`).replace("p_dynamicProdOptions", JSON.stringify(dynamicProdOptions)).replace("p_plugins", pluginsCode).replace("p_sharedDirectory", serverAppContext.sharedDirectory).replace("p_apiDirectory", serverAppContext.apiDirectory).replace("p_lambdaDirectory", serverAppContext.lambdaDirectory);
-      await import_utils.fs.writeFile(entryFilePath, entryCode);
+      if (isEsmProject) {
+        const cjsEntryFilePath = import_node_path.default.join(outputDirectory, "index.cjs");
+        await import_utils.fs.writeFile(cjsEntryFilePath, entryCode);
+        await import_utils.fs.writeFile(entryFilePath, `import('./index.cjs');`);
+      } else {
+        await import_utils.fs.writeFile(entryFilePath, entryCode);
+      }
     },
     async end() {
       console.log("Static directory:", import_utils.chalk.blue(import_node_path.default.relative(appDirectory, staticDirectory)));

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

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

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

@@ -0,0 +1,3 @@
+import { handler } from './vercel-handler.cjs';
+
+export default handler;

package/dist/cjs/plugins/deploy/platforms/{vercelEntry.js → vercel-handler.js}

@@ -1,4 +1,26 @@
 "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 vercel_handler_exports = {};
+__export(vercel_handler_exports, {
+  handler: () => handler
+});
+module.exports = __toCommonJS(vercel_handler_exports);
 const fs = require("node:fs/promises");
 const path = require("node:path");
 const { createProdServer } = require("@modern-js/prod-server");
@@ -53,9 +75,13 @@ async function createHandler() {
   return requestHandler;
 }
 createHandler();
-module.exports = async (req, res) => {
+const handler = async (req, res) => {
   if (!requestHandler) {
     await createHandler();
   }
   return requestHandler(req, res);
 };
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  handler
+});