@modern-js/app-tools 3.0.4 → 3.1.0

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;

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

@@ -40,19 +40,15 @@ 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 createVercelPreset = (appContext, modernConfig, needModernServer)=>{
-    const { appDirectory, distDirectory, entrypoints, serverPlugins, moduleType, metaName } = appContext;
+const index_js_namespaceObject = require("../utils/index.js");
+const generator_js_namespaceObject = require("../utils/generator.js");
+const createVercelPreset = ({ appContext, modernConfig, needModernServer })=>{
+    const { appDirectory, distDirectory, entrypoints, moduleType } = appContext;
     const isEsmProject = 'module' === moduleType;
-    const plugins = serverPlugins.map((plugin)=>[
-            plugin.name,
-            plugin.options
-        ]);
     const vercelOutput = external_node_path_default().join(appDirectory, '.vercel');
     const outputDirectory = external_node_path_default().join(vercelOutput, 'output');
     const funcsDirectory = external_node_path_default().join(outputDirectory, 'functions', 'index.func');
     const entryFilePath = external_node_path_default().join(funcsDirectory, 'index.js');
-    const handlerFilePath = external_node_path_default().join(funcsDirectory, 'vercel-handler.cjs');
     return {
         async prepare () {
             await utils_namespaceObject.fs.remove(vercelOutput);
@@ -121,37 +117,24 @@ const createVercelPreset = (appContext, modernConfig, needModernServer)=>{
         },
         async genEntry () {
             if (!needModernServer) return;
-            const serverConfig = {
-                bff: {
-                    prefix: modernConfig?.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 || []);
-            const serverAppContext = (0, external_utils_js_namespaceObject.serverAppContenxtTemplate)(appContext);
-            let handlerCode = (await utils_namespaceObject.fs.readFile(external_node_path_default().join(__dirname, './vercel-handler.js'))).toString();
-            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_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.copy(external_node_path_default().join(__dirname, './vercel-entry.mjs'), entryFilePath);
-            else await utils_namespaceObject.fs.copy(external_node_path_default().join(__dirname, './vercel-entry.js'), entryFilePath);
+            const template = await (0, index_js_namespaceObject.readTemplate)(`vercel-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 (!needModernServer) return;
+            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: funcsDirectory,
                 includeEntries: [
-                    require.resolve('@modern-js/prod-server')
+                    entry
                 ],
                 copyWholePackage (pkgName) {
                     return '@modern-js/utils' === pkgName;

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

@@ -0,0 +1,18 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,103 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    serverAppContextTemplate: ()=>serverAppContextTemplate,
+    getPluginsCode: ()=>getPluginsCode,
+    genPluginImportsCode: ()=>genPluginImportsCode,
+    generateHandler: ()=>generateHandler,
+    getServerConfigPath: ()=>getServerConfigPath
+});
+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 lodash_namespaceObject = require("@modern-js/utils/lodash");
+const external_index_js_namespaceObject = require("./index.js");
+const serverAppContextTemplate = (appContext)=>{
+    const { appDirectory, sharedDirectory, apiDirectory, lambdaDirectory, metaName, bffRuntimeFramework } = appContext;
+    return {
+        sharedDirectory: `path.join(__dirname, "${(0, external_index_js_namespaceObject.normalizePath)(external_node_path_default().relative(appDirectory, sharedDirectory))}")`,
+        apiDirectory: `path.join(__dirname, "${(0, external_index_js_namespaceObject.normalizePath)(external_node_path_default().relative(appDirectory, apiDirectory))}")`,
+        lambdaDirectory: `path.join(__dirname, "${(0, external_index_js_namespaceObject.normalizePath)(external_node_path_default().relative(appDirectory, 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)=>`"${(0, external_index_js_namespaceObject.normalizePath)(external_node_path_default().join(utils_namespaceObject.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 = (0, lodash_namespaceObject.merge)({
+        bff: {
+            prefix: config?.bff?.prefix
+        },
+        output: {
+            distPath: {
+                root: '.'
+            }
+        }
+    }, modifyServerConfig || {});
+    const meta = (0, utils_namespaceObject.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', `"${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);
+};
+exports.genPluginImportsCode = __webpack_exports__.genPluginImportsCode;
+exports.generateHandler = __webpack_exports__.generateHandler;
+exports.getPluginsCode = __webpack_exports__.getPluginsCode;
+exports.getServerConfigPath = __webpack_exports__.getServerConfigPath;
+exports.serverAppContextTemplate = __webpack_exports__.serverAppContextTemplate;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "genPluginImportsCode",
+    "generateHandler",
+    "getPluginsCode",
+    "getServerConfigPath",
+    "serverAppContextTemplate"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/plugins/deploy/{utils.js → utils/index.js}

@@ -33,29 +33,17 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
+    getTemplatePath: ()=>getTemplatePath,
     getProjectUsage: ()=>getProjectUsage,
-    serverAppContenxtTemplate: ()=>serverAppContenxtTemplate,
-    getPluginsCode: ()=>getPluginsCode,
-    genPluginImportsCode: ()=>genPluginImportsCode
+    normalizePath: ()=>normalizePath,
+    readTemplate: ()=>readTemplate,
+    resolveESMDependency: ()=>resolveESMDependency
 });
+const external_node_url_namespaceObject = require("node:url");
 const external_path_namespaceObject = require("path");
 var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
 const utils_namespaceObject = require("@modern-js/utils");
-const serverAppContenxtTemplate = (appContext)=>{
-    const { appDirectory, sharedDirectory, apiDirectory, lambdaDirectory, metaName, bffRuntimeFramework } = appContext;
-    return {
-        sharedDirectory: `path.join(__dirname, "${external_path_default().relative(appDirectory, sharedDirectory)}")`,
-        apiDirectory: `path.join(__dirname, "${external_path_default().relative(appDirectory, apiDirectory)}")`,
-        lambdaDirectory: `path.join(__dirname, "${external_path_default().relative(appDirectory, lambdaDirectory)}")`,
-        metaName,
-        bffRuntimeFramework: bffRuntimeFramework || 'hono'
-    };
-};
-const genPluginImportsCode = (plugins)=>plugins.map(([name, options], index)=>`
-      let plugin_${index} = require('${name}')
-      plugin_${index} = plugin_${index}.default || plugin_${index}
-      `).join(';\n');
-const getPluginsCode = (plugins)=>`[${plugins.map(([, options], index)=>`plugin_${index}(${options ? JSON.stringify(options) : ''})`).join(',')}]`;
+const normalizePath = (filePath)=>filePath.replace(/\\/g, '/');
 const getProjectUsage = (appDirectory, distDirectory, metaName)=>{
     const routeJSON = external_path_default().join(distDirectory, utils_namespaceObject.ROUTE_SPEC_FILE);
     const { routes } = utils_namespaceObject.fs.readJSONSync(routeJSON);
@@ -77,15 +65,31 @@ const getProjectUsage = (appDirectory, distDirectory, metaName)=>{
         useWebServer: isServerConfigExists
     };
 };
-exports.genPluginImportsCode = __webpack_exports__.genPluginImportsCode;
-exports.getPluginsCode = __webpack_exports__.getPluginsCode;
+const getTemplatePath = (file)=>external_path_default().join(__dirname, '../platforms/templates', file);
+const readTemplate = async (file)=>(await utils_namespaceObject.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, (0, external_node_url_namespaceObject.pathToFileURL)(`${__dirname}/`), conditions, false).pathname.replace(/^\/(\w)\:/, '$1:'));
+    } catch (err) {}
+};
 exports.getProjectUsage = __webpack_exports__.getProjectUsage;
-exports.serverAppContenxtTemplate = __webpack_exports__.serverAppContenxtTemplate;
+exports.getTemplatePath = __webpack_exports__.getTemplatePath;
+exports.normalizePath = __webpack_exports__.normalizePath;
+exports.readTemplate = __webpack_exports__.readTemplate;
+exports.resolveESMDependency = __webpack_exports__.resolveESMDependency;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "genPluginImportsCode",
-    "getPluginsCode",
     "getProjectUsage",
-    "serverAppContenxtTemplate"
+    "getTemplatePath",
+    "normalizePath",
+    "readTemplate",
+    "resolveESMDependency"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true

package/dist/cjs/rsbuild.js

@@ -0,0 +1,74 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    resolveModernRsbuildConfig: ()=>resolveModernRsbuildConfig
+});
+const builder_namespaceObject = require("@modern-js/builder");
+const cli_namespaceObject = require("@modern-js/plugin/cli");
+const index_js_namespaceObject = require("./builder/shared/builderPlugins/index.js");
+const external_constants_js_namespaceObject = require("./constants.js");
+const getConfigFile_js_namespaceObject = require("./utils/getConfigFile.js");
+const MODERN_META_NAME = 'modern-js';
+async function resolveModernRsbuildConfig(options) {
+    const { cwd = process.cwd(), metaName = MODERN_META_NAME } = options;
+    const configFile = options.configPath || (0, getConfigFile_js_namespaceObject.getConfigFile)(void 0, cwd);
+    if (!configFile) throw new Error(`Cannot find config file in ${cwd}. Please make sure you have a ${external_constants_js_namespaceObject.DEFAULT_CONFIG_FILE} file in your project.`);
+    const { config: modernConfig, getAppContext } = await (0, cli_namespaceObject.createConfigOptions)({
+        command: options.command,
+        cwd,
+        configFile,
+        metaName,
+        modifyModernConfig: options.modifyModernConfig
+    });
+    const nonStandardConfig = {
+        ...modernConfig,
+        plugins: modernConfig.builderPlugins
+    };
+    const appContext = getAppContext();
+    const { rsbuildConfig, rsbuildPlugins } = await (0, builder_namespaceObject.parseRspackConfig)(nonStandardConfig, {
+        cwd
+    });
+    const adapterParams = {
+        appContext,
+        normalizedConfig: modernConfig
+    };
+    rsbuildConfig.plugins = [
+        ...rsbuildPlugins,
+        ...rsbuildConfig.plugins || [],
+        (0, index_js_namespaceObject.builderPluginAdapterBasic)(adapterParams),
+        (0, index_js_namespaceObject.builderPluginAdapterHooks)(adapterParams)
+    ];
+    return {
+        rsbuildConfig
+    };
+}
+exports.resolveModernRsbuildConfig = __webpack_exports__.resolveModernRsbuildConfig;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "resolveModernRsbuildConfig"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/utils/getConfigFile.js

@@ -39,7 +39,7 @@ const external_path_namespaceObject = require("path");
 var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
 const utils_namespaceObject = require("@modern-js/utils");
 const external_constants_js_namespaceObject = require("../constants.js");
-const getConfigFile = (configFile)=>(0, utils_namespaceObject.findExists)(utils_namespaceObject.CONFIG_FILE_EXTENSIONS.map((extension)=>external_path_default().resolve(process.cwd(), `${configFile || external_constants_js_namespaceObject.DEFAULT_CONFIG_FILE}${extension}`)));
+const getConfigFile = (configFile, cwd = process.cwd())=>(0, utils_namespaceObject.findExists)(utils_namespaceObject.CONFIG_FILE_EXTENSIONS.map((extension)=>external_path_default().resolve(cwd, `${configFile || external_constants_js_namespaceObject.DEFAULT_CONFIG_FILE}${extension}`)));
 exports.getConfigFile = __webpack_exports__.getConfigFile;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "getConfigFile"

package/dist/cjs/utils/register.js

@@ -38,19 +38,11 @@ __webpack_require__.d(__webpack_exports__, {
 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 checkDepExist = (dep, appDir)=>{
-    try {
-        (0, utils_namespaceObject.tryResolve)(dep, appDir, process.cwd());
-        return true;
-    } catch  {
-        return false;
-    }
-};
 const setupTsRuntime = async (appDir, distDir, alias)=>{
     const TS_CONFIG_FILENAME = "tsconfig.json";
     const tsconfigPath = external_node_path_default().resolve(appDir, TS_CONFIG_FILENAME);
     const isTsProject = await utils_namespaceObject.fs.pathExists(tsconfigPath);
-    const hasTsNode = checkDepExist('ts-node', appDir);
+    const hasTsNode = (0, utils_namespaceObject.isDepExists)(appDir, 'ts-node');
     if (!isTsProject || !hasTsNode) return;
     const aliasConfig = (0, utils_namespaceObject.getAliasConfig)(alias, {
         appDirectory: appDir,

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

@@ -1,5 +1,5 @@
+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";
 const builderPluginAdapterBasic = (options)=>({
         name: 'builder-plugin-adapter-modern-basic',
         setup (api) {
@@ -10,7 +10,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(__dirname, `../loaders/serverModuleLoader.${depExt}`));
+                    chain.module.rule('bare-server-module').test(bareServerModuleReg).use('server-module-loader').loader(node_path.join(__dirname, `../loaders/serverModuleLoader.${depExt}`));
                 }
                 const { appContext } = options;
                 const { metaName } = appContext;

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

@@ -2,7 +2,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',
@@ -99,7 +99,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/commands/build.mjs

@@ -1,8 +1,8 @@
+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);
@@ -10,8 +10,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/commands/dev.mjs

@@ -1,3 +1,5 @@
+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";
@@ -5,8 +7,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();
@@ -24,7 +24,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);
@@ -55,7 +55,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
@@ -67,7 +67,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/commands/serve.mjs

@@ -1,8 +1,8 @@
 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();
@@ -16,7 +16,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/config/default.mjs

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

@@ -1,5 +1,5 @@
+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);
@@ -10,7 +10,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;
@@ -19,7 +19,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/index.mjs

@@ -18,6 +18,7 @@ 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";
@@ -119,4 +120,4 @@ const appTools = ()=>({
         }
     });
 const src = appTools;
-export { appTools, src as default, defineConfig, dev, generateWatchFiles, initAppContext, mergeConfig, serve };
+export { appTools, src as default, defineConfig, dev, generateWatchFiles, initAppContext, mergeConfig, resolveModernRsbuildConfig, serve };

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

@@ -29,7 +29,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',
@@ -52,4 +52,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 };