@modern-js/app-tools 3.0.5 → 3.1.0

package/dist/cjs/builder/shared/builderPlugins/adapterSSR.js

@@ -127,7 +127,7 @@ async function applySSRLoaderEntry(chain, optinos, isServer) {
     const { entrypoints } = appContext;
     await Promise.all(entrypoints.map(async (entrypoint)=>{
         const { entryName } = entrypoint;
-        const serverLoadersFile = (0, utils_js_namespaceObject.getServerCombinedModueFile)(internalDirectory, entryName);
+        const serverLoadersFile = (0, utils_js_namespaceObject.getServerCombinedModuleFile)(internalDirectory, entryName);
         if (isServer) try {
             await utils_namespaceObject.fs.access(serverLoadersFile, utils_namespaceObject.fs.constants.F_OK);
             chain.entry(`${entryName}-server-loaders`).add(serverLoadersFile);

package/dist/cjs/config/default.js

@@ -32,7 +32,7 @@ function createDefaultConfig(appContext) {
     const dev = {
         cliShortcuts: {
             help: false,
-            custom: (shortcuts = [])=>shortcuts.filter(({ key })=>'r' !== key && 'u' !== key)
+            custom: (shortcuts = [])=>shortcuts.filter(({ key })=>'r' !== key && 'u' !== key && 'o' !== key)
         }
     };
     const output = {

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

@@ -33,13 +33,13 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
-    checkIsBuildCommands: ()=>checkIsBuildCommands,
-    checkIsServeCommand: ()=>checkIsServeCommand,
     parseModule: ()=>parseModule,
+    checkIsServeCommand: ()=>checkIsServeCommand,
     replaceWithAlias: ()=>replaceWithAlias,
+    getServerCombinedModuleFile: ()=>getServerCombinedModuleFile,
     walkDirectory: ()=>walkDirectory,
     isSubDirOrEqual: ()=>isSubDirOrEqual,
-    getServerCombinedModueFile: ()=>getServerCombinedModueFile
+    checkIsBuildCommands: ()=>checkIsBuildCommands
 });
 const external_fs_namespaceObject = require("fs");
 var external_fs_default = /*#__PURE__*/ __webpack_require__.n(external_fs_namespaceObject);
@@ -74,7 +74,7 @@ const parseModule = async ({ source, filename })=>{
     }
     return await (0, external_es_module_lexer_namespaceObject.parse)(content);
 };
-const getServerCombinedModueFile = (internalDirectory, entryName)=>external_path_default().join(internalDirectory, entryName, 'server-loader-combined.js');
+const getServerCombinedModuleFile = (internalDirectory, entryName)=>external_path_default().join(internalDirectory, entryName, 'server-loader-combined.js');
 const checkIsBuildCommands = ()=>{
     const buildCommands = [
         'dev',
@@ -99,7 +99,7 @@ const isSubDirOrEqual = (parent, child)=>{
 };
 exports.checkIsBuildCommands = __webpack_exports__.checkIsBuildCommands;
 exports.checkIsServeCommand = __webpack_exports__.checkIsServeCommand;
-exports.getServerCombinedModueFile = __webpack_exports__.getServerCombinedModueFile;
+exports.getServerCombinedModuleFile = __webpack_exports__.getServerCombinedModuleFile;
 exports.isSubDirOrEqual = __webpack_exports__.isSubDirOrEqual;
 exports.parseModule = __webpack_exports__.parseModule;
 exports.replaceWithAlias = __webpack_exports__.replaceWithAlias;
@@ -107,7 +107,7 @@ exports.walkDirectory = __webpack_exports__.walkDirectory;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "checkIsBuildCommands",
     "checkIsServeCommand",
-    "getServerCombinedModueFile",
+    "getServerCombinedModuleFile",
     "isSubDirOrEqual",
     "parseModule",
     "replaceWithAlias",

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

@@ -31,20 +31,25 @@ const gh_pages_js_namespaceObject = require("./platforms/gh-pages.js");
 const netlify_js_namespaceObject = require("./platforms/netlify.js");
 const node_js_namespaceObject = require("./platforms/node.js");
 const vercel_js_namespaceObject = require("./platforms/vercel.js");
-const external_utils_js_namespaceObject = require("./utils.js");
+const index_js_namespaceObject = require("./utils/index.js");
 const deployPresets = {
     node: node_js_namespaceObject.createNodePreset,
     vercel: vercel_js_namespaceObject.createVercelPreset,
     netlify: netlify_js_namespaceObject.createNetlifyPreset,
     ghPages: gh_pages_js_namespaceObject.createGhPagesPreset
 };
-async function getDeployPreset(appContext, modernConfig, deployTarget) {
+async function getDeployPreset(appContext, modernConfig, deployTarget, api) {
     const { appDirectory, distDirectory, metaName } = appContext;
-    const { useSSR, useAPI, useWebServer } = (0, external_utils_js_namespaceObject.getProjectUsage)(appDirectory, distDirectory, metaName);
+    const { useSSR, useAPI, useWebServer } = (0, index_js_namespaceObject.getProjectUsage)(appDirectory, distDirectory, metaName);
     const needModernServer = useSSR || useAPI || useWebServer;
     const createPreset = deployPresets[deployTarget];
     if (!createPreset) throw new Error(`Unknown deploy target: '${deployTarget}'. MODERNJS_DEPLOY should be 'node', 'vercel', or 'netlify'.`);
-    return createPreset(appContext, modernConfig, needModernServer);
+    return createPreset({
+        appContext,
+        modernConfig,
+        needModernServer,
+        api
+    });
 }
 const deploy = ()=>({
         name: '@modern-js/plugin-deploy',
@@ -55,7 +60,7 @@ const deploy = ()=>({
                 const { metaName } = appContext;
                 if ('modern-js' !== metaName && !process.env.MODERNJS_DEPLOY) return;
                 const modernConfig = api.getNormalizedConfig();
-                const deployPreset = await getDeployPreset(appContext, modernConfig, deployTarget);
+                const deployPreset = await getDeployPreset(appContext, modernConfig, deployTarget, api);
                 deployPreset?.prepare && await deployPreset?.prepare();
                 deployPreset?.writeOutput && await deployPreset?.writeOutput();
                 deployPreset?.genEntry && await deployPreset?.genEntry();

package/dist/cjs/plugins/deploy/platforms/gh-pages.js

@@ -61,7 +61,7 @@ async function reorganizeHtmlFiles(routes, baseDir, baseUrl = '/') {
     });
     await Promise.all(copyPromises);
 }
-const createGhPagesPreset = (appContext, modernConfig)=>{
+const createGhPagesPreset = ({ appContext, modernConfig })=>{
     const { serverRoutes, appDirectory, distDirectory } = appContext;
     const { server: { baseUrl } } = modernConfig;
     const outputDirectory = external_path_default().join(appDirectory, '.output');

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

@@ -40,7 +40,8 @@ var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_no
 const utils_namespaceObject = require("@modern-js/utils");
 const external_ndepe_namespaceObject = require("ndepe");
 const routes_js_namespaceObject = require("../../../utils/routes.js");
-const external_utils_js_namespaceObject = require("../utils.js");
+const index_js_namespaceObject = require("../utils/index.js");
+const generator_js_namespaceObject = require("../utils/generator.js");
 async function cleanDistDirectory(dir) {
     try {
         const items = await utils_namespaceObject.fs.readdir(dir);
@@ -52,17 +53,12 @@ async function cleanDistDirectory(dir) {
         console.error('Error cleaning directory:', error);
     }
 }
-const createNetlifyPreset = (appContext, modernConfig, needModernServer)=>{
-    const { appDirectory, distDirectory, entrypoints, serverPlugins, moduleType, metaName } = appContext;
+const createNetlifyPreset = ({ appContext, modernConfig, needModernServer })=>{
+    const { appDirectory, distDirectory, entrypoints, moduleType } = appContext;
     const isEsmProject = 'module' === moduleType;
-    const plugins = serverPlugins.map((plugin)=>[
-            plugin.name,
-            plugin.options
-        ]);
     const netlifyOutput = external_node_path_default().join(appDirectory, '.netlify');
     const funcsDirectory = external_node_path_default().join(netlifyOutput, 'functions');
     const entryFilePath = external_node_path_default().join(funcsDirectory, 'index.js');
-    const handlerFilePath = external_node_path_default().join(funcsDirectory, 'netlify-handler.cjs');
     return {
         async prepare () {
             await utils_namespaceObject.fs.remove(netlifyOutput);
@@ -99,39 +95,27 @@ const createNetlifyPreset = (appContext, modernConfig, needModernServer)=>{
         },
         async genEntry () {
             if (!needModernServer) return;
-            const serverConfig = {
-                bff: {
-                    prefix: modernConfig?.bff?.prefix
-                },
-                output: {
-                    distPath: {
-                        root: '.'
-                    }
-                }
-            };
-            const meta = (0, utils_namespaceObject.getMeta)(metaName);
-            const pluginImportCode = (0, external_utils_js_namespaceObject.genPluginImportsCode)(plugins || []);
-            const dynamicProdOptions = {
-                config: serverConfig
-            };
-            const serverConfigPath = `path.join(__dirname, "${utils_namespaceObject.SERVER_DIR}", "${meta}.server")`;
-            const pluginsCode = (0, external_utils_js_namespaceObject.getPluginsCode)(plugins);
-            let handlerCode = (await utils_namespaceObject.fs.readFile(external_node_path_default().join(__dirname, './netlify-handler.js'))).toString();
-            const serverAppContext = (0, external_utils_js_namespaceObject.serverAppContenxtTemplate)(appContext);
-            handlerCode = handlerCode.replace('p_genPluginImportsCode', pluginImportCode).replace('p_ROUTE_SPEC_FILE', `"${utils_namespaceObject.ROUTE_SPEC_FILE}"`).replace('p_dynamicProdOptions', JSON.stringify(dynamicProdOptions)).replace('p_plugins', pluginsCode).replace('p_bffRuntimeFramework', `"${serverAppContext.bffRuntimeFramework}"`).replace('p_serverDirectory', serverConfigPath).replace('p_sharedDirectory', serverAppContext.sharedDirectory).replace('p_apiDirectory', serverAppContext.apiDirectory).replace('p_lambdaDirectory', serverAppContext.lambdaDirectory);
-            await utils_namespaceObject.fs.writeFile(handlerFilePath, handlerCode);
-            if (isEsmProject) await utils_namespaceObject.fs.writeFile(entryFilePath, "export { handler as default } from './netlify-handler.cjs';\n");
-            else await utils_namespaceObject.fs.writeFile(entryFilePath, "const { handler } = require('./netlify-handler.cjs');\nexports.handler = handler;\n");
+            const template = await (0, index_js_namespaceObject.readTemplate)(`netlify-entry.${isEsmProject ? 'mjs' : 'cjs'}`);
+            const code = await (0, generator_js_namespaceObject.generateHandler)({
+                template,
+                appContext,
+                config: modernConfig,
+                isESM: isEsmProject
+            });
+            await utils_namespaceObject.fs.writeFile(entryFilePath, code);
         },
         async end () {
             if ('development' !== process.env.NODE_ENV) await cleanDistDirectory(distDirectory);
             if (!needModernServer) return;
+            const entry = isEsmProject ? await (0, index_js_namespaceObject.resolveESMDependency)('@modern-js/prod-server') : require.resolve('@modern-js/prod-server');
+            const netlifyEntry = isEsmProject ? await (0, index_js_namespaceObject.resolveESMDependency)('@modern-js/prod-server/netlify') : require.resolve('@modern-js/prod-server/netlify');
+            if (!entry || !netlifyEntry) throw new Error('Cannot find @modern-js/prod-server');
             await (0, external_ndepe_namespaceObject.nodeDepEmit)({
                 appDir: appDirectory,
                 sourceDir: funcsDirectory,
                 includeEntries: [
-                    require.resolve('@modern-js/prod-server'),
-                    require.resolve('@modern-js/prod-server/netlify')
+                    entry,
+                    netlifyEntry
                 ],
                 copyWholePackage (pkgName) {
                     return '@modern-js/utils' === pkgName;

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

@@ -39,14 +39,11 @@ const external_node_path_namespaceObject = require("node:path");
 var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
 const utils_namespaceObject = require("@modern-js/utils");
 const external_ndepe_namespaceObject = require("ndepe");
-const external_utils_js_namespaceObject = require("../utils.js");
-const createNodePreset = (appContext, config)=>{
-    const { appDirectory, distDirectory, serverPlugins, moduleType, metaName } = appContext;
+const index_js_namespaceObject = require("../utils/index.js");
+const generator_js_namespaceObject = require("../utils/generator.js");
+const createNodePreset = ({ appContext, modernConfig, api })=>{
+    const { appDirectory, distDirectory, moduleType } = appContext;
     const isEsmProject = 'module' === moduleType;
-    const plugins = serverPlugins.map((plugin)=>[
-            plugin.name,
-            plugin.options
-        ]);
     const outputDirectory = external_node_path_default().join(appDirectory, '.output');
     const staticDirectory = external_node_path_default().join(outputDirectory, 'static');
     const entryFilePath = external_node_path_default().join(outputDirectory, 'index.js');
@@ -58,44 +55,24 @@ const createNodePreset = (appContext, config)=>{
             await utils_namespaceObject.fs.copy(distDirectory, outputDirectory);
         },
         async genEntry () {
-            const serverConfig = {
-                server: {
-                    port: 8080
-                },
-                bff: {
-                    prefix: config?.bff?.prefix
-                },
-                output: {
-                    distPath: {
-                        root: '.'
-                    }
-                }
-            };
-            const pluginImportCode = (0, external_utils_js_namespaceObject.genPluginImportsCode)(plugins || []);
-            const dynamicProdOptions = {
-                config: serverConfig
-            };
-            const meta = (0, utils_namespaceObject.getMeta)(metaName);
-            const serverConfigPath = `path.join(__dirname, "${utils_namespaceObject.SERVER_DIR}", "${meta}.server")`;
-            const pluginsCode = (0, external_utils_js_namespaceObject.getPluginsCode)(plugins);
-            let entryCode = (await utils_namespaceObject.fs.readFile(external_node_path_default().join(__dirname, './node-entry.js'))).toString();
-            const serverAppContext = (0, external_utils_js_namespaceObject.serverAppContenxtTemplate)(appContext);
-            entryCode = entryCode.replace('p_genPluginImportsCode', pluginImportCode).replace('p_ROUTE_SPEC_FILE', `"${utils_namespaceObject.ROUTE_SPEC_FILE}"`).replace('p_dynamicProdOptions', JSON.stringify(dynamicProdOptions)).replace('p_plugins', pluginsCode).replace('p_serverDirectory', serverConfigPath).replace('p_sharedDirectory', serverAppContext.sharedDirectory).replace('p_apiDirectory', serverAppContext.apiDirectory).replace('p_bffRuntimeFramework', `"${serverAppContext.bffRuntimeFramework}"`).replace('p_lambdaDirectory', serverAppContext.lambdaDirectory);
-            if (isEsmProject) {
-                const cjsEntryFilePath = external_node_path_default().join(outputDirectory, 'index.cjs');
-                await utils_namespaceObject.fs.writeFile(cjsEntryFilePath, entryCode);
-                await utils_namespaceObject.fs.writeFile(entryFilePath, "import('./index.cjs');");
-            } else await utils_namespaceObject.fs.writeFile(entryFilePath, entryCode);
+            const template = await (0, index_js_namespaceObject.readTemplate)(`node-entry.${isEsmProject ? 'mjs' : 'cjs'}`);
+            const code = await (0, generator_js_namespaceObject.generateHandler)({
+                template,
+                appContext,
+                config: modernConfig,
+                isESM: isEsmProject
+            });
+            await utils_namespaceObject.fs.writeFile(entryFilePath, code);
         },
         async end () {
-            console.log('Static directory:', utils_namespaceObject.chalk.blue(external_node_path_default().relative(appDirectory, staticDirectory)));
-            console.log("You can preview this build by", utils_namespaceObject.chalk.blue("node .output/index"));
             const filter = (filePath)=>!filePath.startsWith(staticDirectory) && !filePath.endsWith('.map');
+            const entry = isEsmProject ? await (0, index_js_namespaceObject.resolveESMDependency)('@modern-js/prod-server') : require.resolve('@modern-js/prod-server');
+            if (!entry) throw new Error('Cannot find @modern-js/prod-server');
             await (0, external_ndepe_namespaceObject.nodeDepEmit)({
                 appDir: appDirectory,
                 sourceDir: outputDirectory,
                 includeEntries: [
-                    require.resolve('@modern-js/prod-server')
+                    entry
                 ],
                 copyWholePackage (pkgName) {
                     return '@modern-js/utils' === pkgName;
@@ -109,6 +86,8 @@ const createNodePreset = (appContext, config)=>{
                     };
                 }
             });
+            console.log('Static directory:', utils_namespaceObject.chalk.blue(external_node_path_default().relative(appDirectory, staticDirectory).replace(/\\/g, '/')));
+            console.log("You can preview this build by", utils_namespaceObject.chalk.blue('node .output/index'));
         }
     };
 };

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

@@ -0,0 +1,57 @@
+const fs = require('node:fs/promises');
+const path = require('node:path');
+const { createNetlifyFunction } = require('@modern-js/prod-server/netlify');
+p_genPluginImportsCode;
+if (!process.env.NODE_ENV) process.env.NODE_ENV = 'production';
+let requestHandler = null;
+let handlerCreationPromise = null;
+async function loadRoutes(routeFilepath) {
+    try {
+        await fs.access(routeFilepath);
+        const content = await fs.readFile(routeFilepath, 'utf-8');
+        const routeSpec = JSON.parse(content);
+        return routeSpec.routes || [];
+    } catch (error) {
+        console.warn('route.json not found or invalid, continuing with empty routes.');
+        return [];
+    }
+}
+async function initServer() {
+    const routeFilepath = path.join(__dirname, p_ROUTE_SPEC_FILE);
+    const routes = await loadRoutes(routeFilepath);
+    const dynamicProdOptions = p_dynamicProdOptions;
+    const prodServerOptions = {
+        pwd: __dirname,
+        routes,
+        disableCustomHook: true,
+        appContext: {
+            sharedDirectory: p_sharedDirectory,
+            apiDirectory: p_apiDirectory,
+            lambdaDirectory: p_lambdaDirectory,
+            bffRuntimeFramework: p_bffRuntimeFramework
+        },
+        plugins: p_plugins,
+        serverConfigPath: p_serverDirectory,
+        ...dynamicProdOptions
+    };
+    const requestHandler = await createNetlifyFunction(prodServerOptions);
+    return requestHandler;
+}
+async function createHandler() {
+    if (!handlerCreationPromise) handlerCreationPromise = (async ()=>{
+        try {
+            requestHandler = await initServer();
+        } catch (error) {
+            console.error('Error creating server:', error);
+            process.exit(1);
+        }
+    })();
+    await handlerCreationPromise;
+    return requestHandler;
+}
+createHandler();
+const handler = async (request, context)=>{
+    if (!requestHandler) await createHandler();
+    return requestHandler(request, context);
+};
+exports.handler = handler;

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

@@ -0,0 +1,59 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createNetlifyFunction } from '@modern-js/prod-server/netlify';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+p_genPluginImportsCode;
+if (!process.env.NODE_ENV) process.env.NODE_ENV = 'production';
+let requestHandler = null;
+let handlerCreationPromise = null;
+async function loadRoutes(routeFilepath) {
+    try {
+        await fs.access(routeFilepath);
+        const content = await fs.readFile(routeFilepath, 'utf-8');
+        const routeSpec = JSON.parse(content);
+        return routeSpec.routes || [];
+    } catch (error) {
+        console.warn('route.json not found or invalid, continuing with empty routes.');
+        return [];
+    }
+}
+async function initServer() {
+    const routeFilepath = path.join(__dirname, p_ROUTE_SPEC_FILE);
+    const routes = await loadRoutes(routeFilepath);
+    const dynamicProdOptions = p_dynamicProdOptions;
+    const prodServerOptions = {
+        pwd: __dirname,
+        routes,
+        disableCustomHook: true,
+        appContext: {
+            sharedDirectory: p_sharedDirectory,
+            apiDirectory: p_apiDirectory,
+            lambdaDirectory: p_lambdaDirectory,
+            bffRuntimeFramework: p_bffRuntimeFramework
+        },
+        plugins: p_plugins,
+        serverConfigPath: p_serverDirectory,
+        ...dynamicProdOptions
+    };
+    const requestHandler = await createNetlifyFunction(prodServerOptions);
+    return requestHandler;
+}
+async function createHandler() {
+    if (!handlerCreationPromise) handlerCreationPromise = (async ()=>{
+        try {
+            requestHandler = await initServer();
+        } catch (error) {
+            console.error('Error creating server:', error);
+            process.exit(1);
+        }
+    })();
+    await handlerCreationPromise;
+    return requestHandler;
+}
+createHandler();
+const handler = async (request, context)=>{
+    if (!requestHandler) await createHandler();
+    return requestHandler(request, context);
+};
+export default handler;

package/dist/cjs/plugins/deploy/platforms/templates/node-entry.cjs

@@ -0,0 +1,44 @@
+const fs = require('node:fs/promises');
+const path = require('node:path');
+const { createProdServer } = require('@modern-js/prod-server');
+p_genPluginImportsCode;
+if (!process.env.NODE_ENV) process.env.NODE_ENV = 'production';
+async function loadRoutes(routeFilepath) {
+    try {
+        await fs.access(routeFilepath);
+        const content = await fs.readFile(routeFilepath, 'utf-8');
+        const routeSpec = JSON.parse(content);
+        return routeSpec.routes || [];
+    } catch (error) {
+        console.warn('route.json not found or invalid, continuing with empty routes.');
+        return [];
+    }
+}
+async function main() {
+    const routeFilepath = path.join(__dirname, p_ROUTE_SPEC_FILE);
+    const routes = await loadRoutes(routeFilepath);
+    const dynamicProdOptions = p_dynamicProdOptions;
+    const prodServerOptions = {
+        pwd: __dirname,
+        routes,
+        disableCustomHook: true,
+        appContext: {
+            sharedDirectory: p_sharedDirectory,
+            apiDirectory: p_apiDirectory,
+            lambdaDirectory: p_lambdaDirectory,
+            bffRuntimeFramework: p_bffRuntimeFramework
+        },
+        plugins: p_plugins,
+        serverConfigPath: p_serverDirectory,
+        ...dynamicProdOptions
+    };
+    const app = await createProdServer(prodServerOptions);
+    const port = process.env.PORT || 8080;
+    app.listen({
+        host: '::',
+        port
+    }, ()=>{
+        console.log(`\x1b[32mServer is listening on http://[::]:${port}`, '\x1b[0m');
+    });
+}
+main();

package/dist/{esm/plugins/deploy/platforms → cjs/plugins/deploy/platforms/templates}/node-entry.mjs

@@ -1,30 +1,8 @@
-import * as __rspack_external__modern_js_prod_server_057184e2 from "@modern-js/prod-server";
-import * as __rspack_external_node_fs_promises_153e37e0 from "node:fs/promises";
-import * as __rspack_external_node_path_c5b9b54f from "node:path";
-var __webpack_modules__ = {
-    "@modern-js/prod-server" (module) {
-        module.exports = __rspack_external__modern_js_prod_server_057184e2;
-    },
-    "node:fs/promises" (module) {
-        module.exports = __rspack_external_node_fs_promises_153e37e0;
-    },
-    "node:path" (module) {
-        module.exports = __rspack_external_node_path_c5b9b54f;
-    }
-};
-var __webpack_module_cache__ = {};
-function __webpack_require__(moduleId) {
-    var cachedModule = __webpack_module_cache__[moduleId];
-    if (void 0 !== cachedModule) return cachedModule.exports;
-    var module = __webpack_module_cache__[moduleId] = {
-        exports: {}
-    };
-    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
-    return module.exports;
-}
-const fs = __webpack_require__("node:fs/promises");
-const path = __webpack_require__("node:path");
-const { createProdServer } = __webpack_require__("@modern-js/prod-server");
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createProdServer } from '@modern-js/prod-server';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
 p_genPluginImportsCode;
 if (!process.env.NODE_ENV) process.env.NODE_ENV = 'production';
 async function loadRoutes(routeFilepath) {

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

@@ -0,0 +1,56 @@
+const fs = require('node:fs/promises');
+const path = require('node:path');
+const { createProdServer } = require('@modern-js/prod-server');
+p_genPluginImportsCode;
+if (!process.env.NODE_ENV) process.env.NODE_ENV = 'production';
+let requestHandler = null;
+let handlerCreationPromise = null;
+async function loadRoutes(routeFilepath) {
+    try {
+        await fs.access(routeFilepath);
+        const content = await fs.readFile(routeFilepath, 'utf-8');
+        const routeSpec = JSON.parse(content);
+        return routeSpec.routes || [];
+    } catch (error) {
+        console.warn('route.json not found or invalid, continuing with empty routes.');
+        return [];
+    }
+}
+async function initServer() {
+    const routeFilepath = path.join(__dirname, p_ROUTE_SPEC_FILE);
+    const routes = await loadRoutes(routeFilepath);
+    const dynamicProdOptions = p_dynamicProdOptions;
+    const prodServerOptions = {
+        pwd: __dirname,
+        routes,
+        disableCustomHook: true,
+        appContext: {
+            sharedDirectory: p_sharedDirectory,
+            apiDirectory: p_apiDirectory,
+            lambdaDirectory: p_lambdaDirectory
+        },
+        plugins: p_plugins,
+        serverConfigPath: p_serverDirectory,
+        ...dynamicProdOptions
+    };
+    const app = await createProdServer(prodServerOptions);
+    return app.getRequestListener();
+}
+async function createHandler() {
+    if (!handlerCreationPromise) handlerCreationPromise = (async ()=>{
+        try {
+            requestHandler = await initServer();
+        } catch (error) {
+            console.error('Error creating server:', error);
+            process.exit(1);
+        }
+    })();
+    await handlerCreationPromise;
+    return requestHandler;
+}
+createHandler();
+const handler = async (req, res)=>{
+    if (!requestHandler) await createHandler();
+    return requestHandler(req, res);
+};
+module.exports = handler;

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

@@ -0,0 +1,58 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createProdServer } from '@modern-js/prod-server';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+p_genPluginImportsCode;
+if (!process.env.NODE_ENV) process.env.NODE_ENV = 'production';
+let requestHandler = null;
+let handlerCreationPromise = null;
+async function loadRoutes(routeFilepath) {
+    try {
+        await fs.access(routeFilepath);
+        const content = await fs.readFile(routeFilepath, 'utf-8');
+        const routeSpec = JSON.parse(content);
+        return routeSpec.routes || [];
+    } catch (error) {
+        console.warn('route.json not found or invalid, continuing with empty routes.');
+        return [];
+    }
+}
+async function initServer() {
+    const routeFilepath = path.join(__dirname, p_ROUTE_SPEC_FILE);
+    const routes = await loadRoutes(routeFilepath);
+    const dynamicProdOptions = p_dynamicProdOptions;
+    const prodServerOptions = {
+        pwd: __dirname,
+        routes,
+        disableCustomHook: true,
+        appContext: {
+            sharedDirectory: p_sharedDirectory,
+            apiDirectory: p_apiDirectory,
+            lambdaDirectory: p_lambdaDirectory
+        },
+        plugins: p_plugins,
+        serverConfigPath: p_serverDirectory,
+        ...dynamicProdOptions
+    };
+    const app = await createProdServer(prodServerOptions);
+    return app.getRequestListener();
+}
+async function createHandler() {
+    if (!handlerCreationPromise) handlerCreationPromise = (async ()=>{
+        try {
+            requestHandler = await initServer();
+        } catch (error) {
+            console.error('Error creating server:', error);
+            process.exit(1);
+        }
+    })();
+    await handlerCreationPromise;
+    return requestHandler;
+}
+createHandler();
+const handler = async (req, res)=>{
+    if (!requestHandler) await createHandler();
+    return requestHandler(req, res);
+};
+export default handler;