@modern-js/app-tools 3.0.5 → 3.1.1

package/dist/esm/plugins/deploy/utils/generator.mjs

@@ -0,0 +1,48 @@
+import node_path from "node:path";
+import { ROUTE_SPEC_FILE, SERVER_DIR, getMeta } from "@modern-js/utils";
+import { merge } from "@modern-js/utils/lodash";
+import { normalizePath } from "./index.mjs";
+const serverAppContextTemplate = (appContext)=>{
+    const { appDirectory, sharedDirectory, apiDirectory, lambdaDirectory, metaName, bffRuntimeFramework } = appContext;
+    const getRelativePathTemplate = (targetDirectory)=>`path.join(__dirname, ${JSON.stringify(normalizePath(node_path.relative(appDirectory, targetDirectory)))})`;
+    return {
+        sharedDirectory: getRelativePathTemplate(sharedDirectory),
+        apiDirectory: getRelativePathTemplate(apiDirectory),
+        lambdaDirectory: getRelativePathTemplate(lambdaDirectory),
+        metaName,
+        bffRuntimeFramework: bffRuntimeFramework || 'hono'
+    };
+};
+const genPluginImportsCode = (plugins, isESM = false)=>plugins.map(([name, options], index)=>{
+        const im = isESM ? `import * as plugin_${index}_ns from '${name}'` : `const plugin_${index}_ns = require('${name}')`;
+        return `${im};const plugin_${index} = plugin_${index}_ns.default || plugin_${index}_ns`;
+    }).join(';\n');
+const getPluginsCode = (plugins)=>`[${plugins.map(([, options], index)=>`plugin_${index}(${options ? JSON.stringify(options) : ''})`).join(',')}]`;
+const getServerConfigPath = (meta)=>`"${normalizePath(node_path.join(SERVER_DIR, `${meta}.server`))}"`;
+const generateHandler = async ({ template, appContext, config, serverConfig: modifyServerConfig, genAppContextTemplate = serverAppContextTemplate, genPluginImports = genPluginImportsCode, isESM })=>{
+    const { serverPlugins, metaName } = appContext;
+    const plugins = serverPlugins.map((plugin)=>[
+            plugin.name,
+            plugin.options
+        ]);
+    const serverConfig = merge({
+        bff: {
+            prefix: config?.bff?.prefix
+        },
+        output: {
+            distPath: {
+                root: '.'
+            }
+        }
+    }, modifyServerConfig || {});
+    const meta = getMeta(metaName);
+    const pluginImportCode = genPluginImports(plugins || [], Boolean(isESM));
+    const dynamicProdOptions = {
+        config: serverConfig
+    };
+    const serverConfigPath = getServerConfigPath(meta);
+    const pluginsCode = getPluginsCode(plugins);
+    const serverAppContext = genAppContextTemplate(appContext);
+    return template.replace('p_genPluginImportsCode', pluginImportCode).replace('p_ROUTE_SPEC_FILE', `"${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);
+};
+export { genPluginImportsCode, generateHandler, getPluginsCode, getServerConfigPath, serverAppContextTemplate };

package/dist/esm/plugins/deploy/utils/index.mjs

@@ -0,0 +1,40 @@
+import { pathToFileURL } from "node:url";
+import path from "path";
+import { ROUTE_SPEC_FILE, SERVER_DIR, fs, getMeta } from "@modern-js/utils";
+const normalizePath = (filePath)=>filePath.replace(/\\/g, '/');
+const getProjectUsage = (appDirectory, distDirectory, metaName)=>{
+    const routeJSON = path.join(distDirectory, ROUTE_SPEC_FILE);
+    const { routes } = fs.readJSONSync(routeJSON);
+    let useSSR = false;
+    let useAPI = false;
+    routes.forEach((route)=>{
+        if (route.isSSR) useSSR = true;
+        if (route.isApi) useAPI = true;
+    });
+    const meta = getMeta(metaName);
+    const serverConfigPath = path.resolve(appDirectory, SERVER_DIR, `${meta}.server`);
+    const isServerConfigExists = [
+        '.ts',
+        '.js'
+    ].some((ex)=>fs.existsSync(`${serverConfigPath}${ex}`));
+    return {
+        useSSR,
+        useAPI,
+        useWebServer: isServerConfigExists
+    };
+};
+const getTemplatePath = (file)=>path.join(__dirname, '../platforms/templates', file);
+const readTemplate = async (file)=>(await fs.readFile(getTemplatePath(file))).toString();
+const resolveESMDependency = async (entry)=>{
+    const conditions = new Set([
+        'node',
+        'import',
+        'module',
+        'default'
+    ]);
+    try {
+        const { moduleResolve } = await import("import-meta-resolve");
+        return normalizePath(moduleResolve(entry, pathToFileURL(`${__dirname}/`), conditions, false).pathname.replace(/^\/(\w)\:/, '$1:'));
+    } catch (err) {}
+};
+export { getProjectUsage, getTemplatePath, normalizePath, readTemplate, resolveESMDependency };

package/dist/esm/plugins/initialize/index.mjs

@@ -56,4 +56,4 @@ async function getServerPort(config) {
     if (isDev() && isDevCommand()) return getPort(Number(process.env.PORT) || prodPort);
     return prodPort;
 }
-export { initialize as default };
+export default initialize;

package/dist/esm/plugins/serverBuild.mjs

@@ -43,4 +43,4 @@ const serverBuild = ()=>({
             });
         }
     });
-export { serverBuild as default };
+export default serverBuild;

package/dist/esm/plugins/serverRuntime.mjs

@@ -12,4 +12,4 @@ const serverRuntime = ()=>({
                 }));
         }
     });
-export { serverRuntime as default };
+export default serverRuntime;

package/dist/esm/utils/loadPlugins.mjs

@@ -1,5 +1,5 @@
+import { loadServerPlugins } from "@modern-js/prod-server";
 import { compatibleRequire, createDebugger, dynamicImport, getInternalPlugins, tryResolve } from "@modern-js/utils";
-import * as __rspack_external__modern_js_prod_server_057184e2 from "@modern-js/prod-server";
 const debug = createDebugger('load-plugins');
 async function getServerPlugins(api, metaName = 'modern-js') {
     const hooks = api.getHooks();
@@ -12,9 +12,9 @@ async function getServerPlugins(api, metaName = 'modern-js') {
     });
     return filtedPlugins;
 }
-async function loadServerPlugins(api, appDirectory, metaName) {
+async function loadPlugins_loadServerPlugins(api, appDirectory, metaName) {
     const plugins = await getServerPlugins(api, metaName);
-    const instances = await (0, __rspack_external__modern_js_prod_server_057184e2.loadServerPlugins)(plugins, appDirectory);
+    const instances = await loadServerPlugins(plugins, appDirectory);
     return instances;
 }
 const resolveCliPlugin = async (p, appDirectory)=>{
@@ -42,4 +42,4 @@ const loadInternalPlugins = async (appDirectory, internalPlugins)=>{
     }));
     return loadedPlugins;
 };
-export { getServerPlugins, loadInternalPlugins, loadServerPlugins };
+export { getServerPlugins, loadInternalPlugins, loadPlugins_loadServerPlugins as loadServerPlugins };

package/dist/esm/utils/register.mjs

@@ -1,18 +1,10 @@
-import { fs, getAliasConfig, loadFromProject, readTsConfigByFile, tryResolve } from "@modern-js/utils";
-import * as __rspack_external_node_path_c5b9b54f from "node:path";
-const checkDepExist = (dep, appDir)=>{
-    try {
-        tryResolve(dep, appDir, process.cwd());
-        return true;
-    } catch  {
-        return false;
-    }
-};
+import node_path from "node:path";
+import { fs, getAliasConfig, isDepExists, loadFromProject, readTsConfigByFile } from "@modern-js/utils";
 const setupTsRuntime = async (appDir, distDir, alias)=>{
     const TS_CONFIG_FILENAME = "tsconfig.json";
-    const tsconfigPath = __rspack_external_node_path_c5b9b54f["default"].resolve(appDir, TS_CONFIG_FILENAME);
+    const tsconfigPath = node_path.resolve(appDir, TS_CONFIG_FILENAME);
     const isTsProject = await fs.pathExists(tsconfigPath);
-    const hasTsNode = checkDepExist('ts-node', appDir);
+    const hasTsNode = isDepExists(appDir, 'ts-node');
     if (!isTsProject || !hasTsNode) return;
     const aliasConfig = getAliasConfig(alias, {
         appDirectory: appDir,
@@ -29,7 +21,7 @@ const setupTsRuntime = async (appDir, distDir, alias)=>{
                 ]
             });
         } catch  {}
-        if ('string' == typeof tsPath && __rspack_external_node_path_c5b9b54f["default"].isAbsolute(tsPath)) tsPath = __rspack_external_node_path_c5b9b54f["default"].relative(absoluteBaseUrl, tsPath);
+        if ('string' == typeof tsPath && node_path.isAbsolute(tsPath)) tsPath = node_path.relative(absoluteBaseUrl, tsPath);
         if ('string' == typeof tsPath) tsPath = [
             tsPath
         ];
@@ -48,7 +40,7 @@ const setupTsRuntime = async (appDir, distDir, alias)=>{
         transpileOnly: true,
         ignore: [
             '(?:^|/)node_modules/',
-            `(?:^|/)${__rspack_external_node_path_c5b9b54f["default"].relative(appDir, distDir)}/`
+            `(?:^|/)${node_path.relative(appDir, distDir)}/`
         ],
         ...tsNodeOptions
     });

package/dist/esm-node/builder/generator/createCopyPattern.mjs

@@ -8,7 +8,7 @@ const info = (file)=>({
 function createPublicPattern(appContext, config, chain) {
     const { publicDir } = createCopyInfo(appContext, config);
     return {
-        info,
+        info: info,
         from: '**/*',
         to: 'public',
         context: publicDir,

package/dist/esm-node/builder/index.mjs

@@ -1,8 +1,8 @@
 import "node:module";
-import { parseRspackConfig } from "@modern-js/builder";
-import { builderPluginAdapterBasic, builderPluginAdapterHooks } from "./shared/builderPlugins/index.mjs";
 async function createBuilderGenerator() {
     const { createRspackBuilderForModern } = await import("./builder-rspack/index.mjs");
     return createRspackBuilderForModern;
 }
-export { builderPluginAdapterBasic, builderPluginAdapterHooks, createBuilderGenerator, parseRspackConfig };
+export { parseRspackConfig } from "@modern-js/builder";
+export { builderPluginAdapterBasic, builderPluginAdapterHooks } from "./shared/builderPlugins/index.mjs";
+export { createBuilderGenerator };

package/dist/esm-node/builder/shared/builderPlugins/adapterBasic.mjs

@@ -1,8 +1,8 @@
 import "node:module";
 import { fileURLToPath as __rspack_fileURLToPath } from "node:url";
 import { dirname as __rspack_dirname } from "node:path";
+import node_path from "node:path";
 import { SERVICE_WORKER_ENVIRONMENT_NAME } from "@modern-js/builder";
-import * as __rspack_external_node_path_c5b9b54f from "node:path";
 var adapterBasic_dirname = __rspack_dirname(__rspack_fileURLToPath(import.meta.url));
 const builderPluginAdapterBasic = (options)=>({
         name: 'builder-plugin-adapter-modern-basic',
@@ -14,7 +14,7 @@ const builderPluginAdapterBasic = (options)=>({
                     const bareServerModuleReg = /\.(server|node)\.[tj]sx?$/;
                     const depExt = 'mjs';
                     chain.module.rule(CHAIN_ID.RULE.JS).exclude.add(bareServerModuleReg);
-                    chain.module.rule('bare-server-module').test(bareServerModuleReg).use('server-module-loader').loader(__rspack_external_node_path_c5b9b54f["default"].join(adapterBasic_dirname, `../loaders/serverModuleLoader.${depExt}`));
+                    chain.module.rule('bare-server-module').test(bareServerModuleReg).use('server-module-loader').loader(node_path.join(adapterBasic_dirname, `../loaders/serverModuleLoader.${depExt}`));
                 }
                 const { appContext } = options;
                 const { metaName } = appContext;

package/dist/esm-node/builder/shared/builderPlugins/adapterSSR.mjs

@@ -4,7 +4,7 @@ import { resolve, sep } from "path";
 import { SERVICE_WORKER_ENVIRONMENT_NAME, isHtmlDisabled } from "@modern-js/builder";
 import { fs, isUseRsc, isUseSSRBundle } from "@modern-js/utils";
 import { mergeRsbuildConfig } from "@rsbuild/core";
-import { getServerCombinedModueFile } from "../../../plugins/analyze/utils.mjs";
+import { getServerCombinedModuleFile } from "../../../plugins/analyze/utils.mjs";
 import { HtmlAsyncChunkPlugin, RouterPlugin } from "../bundlerPlugins/index.mjs";
 const builderPluginAdapterSSR = (options)=>({
         name: 'builder-plugin-adapter-modern-ssr',
@@ -101,7 +101,7 @@ async function applySSRLoaderEntry(chain, optinos, isServer) {
     const { entrypoints } = appContext;
     await Promise.all(entrypoints.map(async (entrypoint)=>{
         const { entryName } = entrypoint;
-        const serverLoadersFile = getServerCombinedModueFile(internalDirectory, entryName);
+        const serverLoadersFile = getServerCombinedModuleFile(internalDirectory, entryName);
         if (isServer) try {
             await fs.access(serverLoadersFile, fs.constants.F_OK);
             chain.entry(`${entryName}-server-loaders`).add(serverLoadersFile);

package/dist/esm-node/builder/shared/loaders/serverModuleLoader.mjs

@@ -3,4 +3,4 @@ function loader() {
     return "module.exports = {}";
 }
 const serverModuleLoader = loader;
-export { serverModuleLoader as default };
+export default serverModuleLoader;

package/dist/esm-node/commands/build.mjs

@@ -1,9 +1,9 @@
 import "node:module";
+import node_path from "node:path";
 import { fs, logger } from "@modern-js/utils";
 import { loadServerPlugins } from "../utils/loadPlugins.mjs";
 import { setupTsRuntime } from "../utils/register.mjs";
 import { generateRoutes } from "../utils/routes.mjs";
-import * as __rspack_external_node_path_c5b9b54f from "node:path";
 async function copyEnvFiles(appDirectory, distDirectory) {
     try {
         const files = await fs.readdir(appDirectory);
@@ -11,8 +11,8 @@ async function copyEnvFiles(appDirectory, distDirectory) {
         const envFiles = files.filter((file)=>envFileRegex.test(file));
         if (0 === envFiles.length) return void logger.debug('No .env files found to copy');
         const copyPromises = envFiles.map(async (envFile)=>{
-            const sourcePath = __rspack_external_node_path_c5b9b54f["default"].resolve(appDirectory, envFile);
-            const targetPath = __rspack_external_node_path_c5b9b54f["default"].resolve(distDirectory, envFile);
+            const sourcePath = node_path.resolve(appDirectory, envFile);
+            const targetPath = node_path.resolve(distDirectory, envFile);
             try {
                 const stat = await fs.stat(sourcePath);
                 if (stat.isDirectory()) return;

package/dist/esm-node/commands/dev.mjs

@@ -1,4 +1,6 @@
 import "node:module";
+import node_path from "node:path";
+import { applyPlugins } from "@modern-js/prod-server";
 import { createDevServer } from "@modern-js/server";
 import { DEFAULT_DEV_HOST, SERVER_DIR, getMeta, logger } from "@modern-js/utils";
 import { setServer } from "../utils/createServer.mjs";
@@ -6,8 +8,6 @@ import { loadServerPlugins } from "../utils/loadPlugins.mjs";
 import { printInstructions } from "../utils/printInstructions.mjs";
 import { setupTsRuntime } from "../utils/register.mjs";
 import { generateRoutes } from "../utils/routes.mjs";
-import * as __rspack_external_node_path_c5b9b54f from "node:path";
-import * as __rspack_external__modern_js_prod_server_057184e2 from "@modern-js/prod-server";
 const dev = async (api, options, devServerOptions)=>{
     if (options.analyze) process.env.BUNDLE_ANALYZE = 'true';
     const normalizedConfig = api.getNormalizedConfig();
@@ -25,7 +25,7 @@ const dev = async (api, options, devServerOptions)=>{
     await setupTsRuntime(appContext.appDirectory, appContext.distDirectory, combinedAlias);
     const { appDirectory, port, apiOnly, metaName, serverRoutes } = appContext;
     const meta = getMeta(metaName);
-    const serverConfigPath = __rspack_external_node_path_c5b9b54f["default"].resolve(appDirectory, SERVER_DIR, `${meta}.server`);
+    const serverConfigPath = node_path.resolve(appDirectory, SERVER_DIR, `${meta}.server`);
     await hooks.onBeforeDev.call();
     if (!appContext.builder && !apiOnly) throw new Error('Expect the Builder to have been initialized, But the appContext.builder received `undefined`');
     await generateRoutes(appContext);
@@ -56,7 +56,7 @@ const dev = async (api, options, devServerOptions)=>{
         const { server } = await createDevServer({
             ...serverOptions,
             runCompile: false
-        }, devServerOptions?.applyPlugins || __rspack_external__modern_js_prod_server_057184e2.applyPlugins);
+        }, devServerOptions?.applyPlugins || applyPlugins);
         server.listen({
             port,
             host
@@ -68,7 +68,7 @@ const dev = async (api, options, devServerOptions)=>{
         const { server, afterListen } = await createDevServer({
             ...serverOptions,
             builder: appContext.builder
-        }, devServerOptions?.applyPlugins || __rspack_external__modern_js_prod_server_057184e2.applyPlugins);
+        }, devServerOptions?.applyPlugins || applyPlugins);
         server.listen({
             port,
             host

package/dist/esm-node/commands/serve.mjs

@@ -1,9 +1,9 @@
 import "node:module";
 import path from "path";
+import { createProdServer } from "@modern-js/prod-server";
 import { SERVER_DIR, getMeta, getTargetDir, isApiOnly, logger } from "@modern-js/utils";
 import { loadServerPlugins } from "../utils/loadPlugins.mjs";
 import { printInstructions } from "../utils/printInstructions.mjs";
-import * as __rspack_external__modern_js_prod_server_057184e2 from "@modern-js/prod-server";
 const serve = async (api, serverOptions)=>{
     const appContext = api.getAppContext();
     const userConfig = api.getNormalizedConfig();
@@ -17,7 +17,7 @@ const serve = async (api, serverOptions)=>{
     const meta = getMeta(metaName);
     const serverConfigPath = path.resolve(distDirectory, SERVER_DIR, `${meta}.server`);
     const pluginInstances = await loadServerPlugins(api, appDirectory, metaName);
-    const app = await (serverOptions?.launcher || __rspack_external__modern_js_prod_server_057184e2.createProdServer)({
+    const app = await (serverOptions?.launcher || createProdServer)({
         metaName,
         pwd: distDirectory,
         config: {

package/dist/esm-node/config/default.mjs

@@ -5,7 +5,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/esm-node/esm/register-esm.mjs

@@ -1,6 +1,6 @@
 import "node:module";
+import node_path from "node:path";
 import { fs } from "@modern-js/utils";
-import * as __rspack_external_node_path_c5b9b54f from "node:path";
 const checkDepExist = async (dep)=>{
     try {
         await import(dep);
@@ -11,7 +11,7 @@ const checkDepExist = async (dep)=>{
 };
 const registerModuleHooks = async ({ appDir, distDir, alias })=>{
     const TS_CONFIG_FILENAME = "tsconfig.json";
-    const tsconfigPath = __rspack_external_node_path_c5b9b54f["default"].resolve(appDir, TS_CONFIG_FILENAME);
+    const tsconfigPath = node_path.resolve(appDir, TS_CONFIG_FILENAME);
     const hasTsconfig = await fs.pathExists(tsconfigPath);
     const hasTsNode = await checkDepExist('ts-node');
     if (!hasTsconfig || !hasTsNode) return;
@@ -20,7 +20,7 @@ const registerModuleHooks = async ({ appDir, distDir, alias })=>{
     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/,(?:^|/)${__rspack_external_node_path_c5b9b54f["default"].relative(appDir, distDir)}/`;
+    process.env.TS_NODE_IGNORE = `(?:^|/)node_modules/,(?:^|/)${node_path.relative(appDir, distDir)}/`;
     register('./ts-node-loader.mjs', import.meta.url, {
         data: {
             appDir,

package/dist/esm-node/index.mjs

@@ -1,5 +1,7 @@
 import __rslib_shim_module__ from "node:module";
 const require = /*#__PURE__*/ __rslib_shim_module__.createRequire(/*#__PURE__*/ (()=>import.meta.url)());
+export * from "./defineConfig.mjs";
+export * from "./types/index.mjs";
 import path from "path";
 import { castArray } from "@modern-js/builder";
 import { getLocaleLanguage } from "@modern-js/i18n-utils/language-detector";
@@ -17,13 +19,6 @@ import serverRuntime from "./plugins/serverRuntime.mjs";
 import { generateWatchFiles } from "./utils/generateWatchFiles.mjs";
 import { initAppContext } from "./utils/initAppContext.mjs";
 import { restart } from "./utils/restart.mjs";
-import { defineConfig } from "./defineConfig.mjs";
-import { dev } from "./commands/dev.mjs";
-import { serve } from "./commands/serve.mjs";
-import { resolveModernRsbuildConfig } from "./rsbuild.mjs";
-import { mergeConfig } from "@modern-js/plugin/cli";
-export * from "./defineConfig.mjs";
-export * from "./types/index.mjs";
 const appTools = ()=>({
         name: '@modern-js/app-tools',
         usePlugins: [
@@ -122,4 +117,10 @@ const appTools = ()=>({
         }
     });
 const src = appTools;
-export { appTools, src as default, defineConfig, dev, generateWatchFiles, initAppContext, mergeConfig, resolveModernRsbuildConfig, serve };
+export { defineConfig } from "./defineConfig.mjs";
+export { dev } from "./commands/dev.mjs";
+export { serve } from "./commands/serve.mjs";
+export { resolveModernRsbuildConfig } from "./rsbuild.mjs";
+export { mergeConfig } from "@modern-js/plugin/cli";
+export default src;
+export { appTools, generateWatchFiles, initAppContext };

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

@@ -201,4 +201,4 @@ const analyze = ()=>({
             });
         }
     });
-export { analyze as default };
+export default analyze;

package/dist/esm-node/plugins/analyze/utils.mjs

@@ -30,7 +30,7 @@ const parseModule = async ({ source, filename })=>{
     }
     return await parse(content);
 };
-const getServerCombinedModueFile = (internalDirectory, entryName)=>path.join(internalDirectory, entryName, 'server-loader-combined.js');
+const getServerCombinedModuleFile = (internalDirectory, entryName)=>path.join(internalDirectory, entryName, 'server-loader-combined.js');
 const checkIsBuildCommands = ()=>{
     const buildCommands = [
         'dev',
@@ -53,4 +53,4 @@ const isSubDirOrEqual = (parent, child)=>{
     const isSubdir = relative && !relative.startsWith('..') && !path.isAbsolute(relative);
     return Boolean(isSubdir);
 };
-export { checkIsBuildCommands, checkIsServeCommand, getServerCombinedModueFile, isSubDirOrEqual, parseModule, replaceWithAlias, walkDirectory };
+export { checkIsBuildCommands, checkIsServeCommand, getServerCombinedModuleFile, isSubDirOrEqual, parseModule, replaceWithAlias, walkDirectory };

package/dist/esm-node/plugins/deploy/index.mjs

@@ -4,20 +4,25 @@ import { createGhPagesPreset } from "./platforms/gh-pages.mjs";
 import { createNetlifyPreset } from "./platforms/netlify.mjs";
 import { createNodePreset } from "./platforms/node.mjs";
 import { createVercelPreset } from "./platforms/vercel.mjs";
-import { getProjectUsage } from "./utils.mjs";
+import { getProjectUsage } from "./utils/index.mjs";
 const deployPresets = {
     node: createNodePreset,
     vercel: createVercelPreset,
     netlify: createNetlifyPreset,
     ghPages: createGhPagesPreset
 };
-async function getDeployPreset(appContext, modernConfig, deployTarget) {
+async function getDeployPreset(appContext, modernConfig, deployTarget, api) {
     const { appDirectory, distDirectory, metaName } = appContext;
     const { useSSR, useAPI, useWebServer } = 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',
@@ -28,7 +33,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();
@@ -36,4 +41,4 @@ const deploy = ()=>({
             });
         }
     });
-export { deploy as default };
+export default deploy;

package/dist/esm-node/plugins/deploy/platforms/gh-pages.mjs

@@ -24,7 +24,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 = path.join(appDirectory, '.output');

package/dist/esm-node/plugins/deploy/platforms/netlify.mjs

@@ -1,35 +1,28 @@
 import __rslib_shim_module__ from "node:module";
 const require = /*#__PURE__*/ __rslib_shim_module__.createRequire(/*#__PURE__*/ (()=>import.meta.url)());
-import { fileURLToPath as __rspack_fileURLToPath } from "node:url";
-import { dirname as __rspack_dirname } from "node:path";
-import { ROUTE_SPEC_FILE, SERVER_DIR, fs, getMeta, removeModuleSyncFromExports } from "@modern-js/utils";
+import node_path from "node:path";
+import { fs, removeModuleSyncFromExports } from "@modern-js/utils";
 import { nodeDepEmit } from "ndepe";
 import { isMainEntry } from "../../../utils/routes.mjs";
-import { genPluginImportsCode, getPluginsCode, serverAppContenxtTemplate } from "../utils.mjs";
-import * as __rspack_external_node_path_c5b9b54f from "node:path";
-var netlify_dirname = __rspack_dirname(__rspack_fileURLToPath(import.meta.url));
+import { readTemplate, resolveESMDependency } from "../utils/index.mjs";
+import { generateHandler } from "../utils/generator.mjs";
 async function cleanDistDirectory(dir) {
     try {
         const items = await fs.readdir(dir);
         for (const item of items){
-            const fullPath = __rspack_external_node_path_c5b9b54f["default"].join(dir, item);
+            const fullPath = node_path.join(dir, item);
             if ('static' !== item && '_redirects' !== item && 'html' !== item) await fs.remove(fullPath);
         }
     } catch (error) {
         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 = __rspack_external_node_path_c5b9b54f["default"].join(appDirectory, '.netlify');
-    const funcsDirectory = __rspack_external_node_path_c5b9b54f["default"].join(netlifyOutput, 'functions');
-    const entryFilePath = __rspack_external_node_path_c5b9b54f["default"].join(funcsDirectory, 'index.js');
-    const handlerFilePath = __rspack_external_node_path_c5b9b54f["default"].join(funcsDirectory, 'netlify-handler.cjs');
+    const netlifyOutput = node_path.join(appDirectory, '.netlify');
+    const funcsDirectory = node_path.join(netlifyOutput, 'functions');
+    const entryFilePath = node_path.join(funcsDirectory, 'index.js');
     return {
         async prepare () {
             await fs.remove(netlifyOutput);
@@ -56,49 +49,37 @@ const createNetlifyPreset = (appContext, modernConfig, needModernServer)=>{
                 await fs.ensureDir(funcsDirectory);
                 await fs.copy(distDirectory, funcsDirectory, {
                     filter: (src)=>{
-                        const distStaticDirectory = __rspack_external_node_path_c5b9b54f["default"].join(distDirectory, "static");
+                        const distStaticDirectory = node_path.join(distDirectory, "static");
                         return !src.includes(distStaticDirectory);
                     }
                 });
             }
-            const redirectFilePath = __rspack_external_node_path_c5b9b54f["default"].join(distDirectory, '_redirects');
+            const redirectFilePath = node_path.join(distDirectory, '_redirects');
             await fs.writeFile(redirectFilePath, redirectContent);
         },
         async genEntry () {
             if (!needModernServer) return;
-            const serverConfig = {
-                bff: {
-                    prefix: modernConfig?.bff?.prefix
-                },
-                output: {
-                    distPath: {
-                        root: '.'
-                    }
-                }
-            };
-            const meta = getMeta(metaName);
-            const pluginImportCode = genPluginImportsCode(plugins || []);
-            const dynamicProdOptions = {
-                config: serverConfig
-            };
-            const serverConfigPath = `path.join(__dirname, "${SERVER_DIR}", "${meta}.server")`;
-            const pluginsCode = getPluginsCode(plugins);
-            let handlerCode = (await fs.readFile(__rspack_external_node_path_c5b9b54f["default"].join(netlify_dirname, './netlify-handler.js'))).toString();
-            const serverAppContext = serverAppContenxtTemplate(appContext);
-            handlerCode = handlerCode.replace('p_genPluginImportsCode', pluginImportCode).replace('p_ROUTE_SPEC_FILE', `"${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 fs.writeFile(handlerFilePath, handlerCode);
-            if (isEsmProject) await fs.writeFile(entryFilePath, "export { handler as default } from './netlify-handler.cjs';\n");
-            else await fs.writeFile(entryFilePath, "const { handler } = require('./netlify-handler.cjs');\nexports.handler = handler;\n");
+            const template = await readTemplate(`netlify-entry.${isEsmProject ? 'mjs' : 'cjs'}`);
+            const code = await generateHandler({
+                template,
+                appContext,
+                config: modernConfig,
+                isESM: isEsmProject
+            });
+            await fs.writeFile(entryFilePath, code);
         },
         async end () {
             if ('development' !== process.env.NODE_ENV) await cleanDistDirectory(distDirectory);
             if (!needModernServer) return;
+            const entry = isEsmProject ? await resolveESMDependency('@modern-js/prod-server') : require.resolve('@modern-js/prod-server');
+            const netlifyEntry = isEsmProject ? await 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 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;