@modern-js/app-tools 2.69.4 → 3.0.0-alpha.0

package/dist/esm/builder/generator/getBuilderEnvironments.mjs

@@ -0,0 +1,56 @@
+import { SERVICE_WORKER_ENVIRONMENT_NAME } from "@modern-js/builder";
+import { isProd, isSSR, isServiceWorker, isUseRsc, isUseSSRBundle } from "@modern-js/utils";
+function getBuilderEnvironments(normalizedConfig, appContext, tempBuilderConfig) {
+    const entries = {};
+    const { entrypoints = [], checkedEntries } = appContext;
+    for (const { entryName, internalEntry, entry } of entrypoints){
+        if (checkedEntries && !checkedEntries.includes(entryName)) continue;
+        const finalEntry = internalEntry || entry;
+        if (entryName in entries) entries[entryName].push(finalEntry);
+        else entries[entryName] = [
+            finalEntry
+        ];
+    }
+    const serverEntries = {};
+    for(const entry in entries){
+        const v = entries[entry];
+        serverEntries[entry] = v.map((entry)=>entry.replace('index.jsx', 'index.server.jsx')).map((entry)=>entry.replace('bootstrap.jsx', 'bootstrap.server.jsx'));
+    }
+    const environments = {
+        web: {
+            output: {
+                target: 'web'
+            },
+            source: {
+                entry: entries
+            }
+        }
+    };
+    if (tempBuilderConfig.output?.copy) {
+        environments.web.output.copy = tempBuilderConfig.output.copy;
+        delete tempBuilderConfig.output.copy;
+    }
+    const useNodeTarget = isUseRsc(normalizedConfig) || (isProd() ? isUseSSRBundle(normalizedConfig) : isSSR(normalizedConfig));
+    if (useNodeTarget) environments.node = {
+        output: {
+            target: 'node'
+        },
+        source: {
+            entry: serverEntries
+        }
+    };
+    const useWorkerTarget = isServiceWorker(normalizedConfig);
+    if (useWorkerTarget) environments[SERVICE_WORKER_ENVIRONMENT_NAME] = {
+        output: {
+            target: 'web-worker'
+        },
+        source: {
+            entry: serverEntries
+        }
+    };
+    return {
+        environments,
+        builderConfig: tempBuilderConfig
+    };
+}
+export { getBuilderEnvironments };

package/dist/esm/builder/generator/index.mjs

@@ -0,0 +1,45 @@
+import { createBuilder } from "@modern-js/builder";
+import { mergeRsbuildConfig } from "@rsbuild/core";
+import { builderPluginAdapterBasic, builderPluginAdapterHooks, builderPluginAdapterHtml, builderPluginAdapterSSR } from "../shared/builderPlugins";
+import { builderPluginAdapterCopy } from "./adapterCopy";
+import { createBuilderProviderConfig } from "./createBuilderProviderConfig";
+import { getBuilderEnvironments } from "./getBuilderEnvironments";
+async function generateBuilder(options, bundlerType) {
+    const { normalizedConfig, appContext } = options;
+    const tempBuilderConfig = createBuilderProviderConfig(normalizedConfig, appContext);
+    const { environments, builderConfig } = getBuilderEnvironments(normalizedConfig, appContext, tempBuilderConfig);
+    if (builderConfig.environments) {
+        const mergedEnvironments = {
+            ...environments
+        };
+        for(const name in builderConfig.environments)if (environments[name]) mergedEnvironments[name] = mergeRsbuildConfig(environments[name], builderConfig.environments[name]);
+        else mergedEnvironments[name] = builderConfig.environments[name];
+        builderConfig.environments = mergedEnvironments;
+    } else builderConfig.environments = environments;
+    const builder = await createBuilder({
+        cwd: appContext.appDirectory,
+        rscClientRuntimePath: `@${appContext.metaName}/runtime/rsc/client`,
+        rscServerRuntimePath: `@${appContext.metaName}/runtime/rsc/server`,
+        internalDirectory: appContext.internalDirectory,
+        frameworkConfigPath: appContext.configFile || void 0,
+        bundlerType,
+        config: builderConfig
+    });
+    await applyBuilderPlugins(builder, options);
+    return builder;
+}
+async function applyBuilderPlugins(builder, options) {
+    builder.addPlugins([
+        builderPluginAdapterBasic(options),
+        builderPluginAdapterSSR(options),
+        builderPluginAdapterHtml(options),
+        builderPluginAdapterHooks(options)
+    ]);
+    builder.addPlugins([
+        builderPluginAdapterCopy(options)
+    ], {
+        environment: 'web'
+    });
+    const { normalizedConfig } = options;
+}
+export { generateBuilder };

package/dist/esm/builder/index.mjs

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

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

@@ -0,0 +1,78 @@
+import { SERVICE_WORKER_ENVIRONMENT_NAME } from "@modern-js/builder";
+const builderPluginAdapterBasic = (options)=>({
+        name: 'builder-plugin-adapter-modern-basic',
+        setup (api) {
+            api.modifyBundlerChain((chain, { target, CHAIN_ID, environment })=>{
+                const isServiceWorker = environment.name === SERVICE_WORKER_ENVIRONMENT_NAME;
+                if ('node' === target || isServiceWorker) applyNodeCompat(isServiceWorker, chain);
+                if ('web' === target) {
+                    const bareServerModuleReg = /\.(server|node)\.[tj]sx?$/;
+                    chain.module.rule(CHAIN_ID.RULE.JS).exclude.add(bareServerModuleReg);
+                    chain.module.rule('bare-server-module').test(bareServerModuleReg).use('server-module-loader').loader(require.resolve('../loaders/serverModuleLoader'));
+                }
+                const { appContext } = options;
+                const { metaName } = appContext;
+                chain.watchOptions({
+                    ignored: [
+                        `[\\\\/](?:node_modules(?![\\\\/]\\.${metaName})|.git)[\\\\/]`
+                    ]
+                });
+            });
+        }
+    });
+function applyNodeCompat(isServiceWorker, chain) {
+    const nodeExts = [
+        '.node.js',
+        '.node.jsx',
+        '.node.ts',
+        '.node.tsx',
+        '.node.mjs',
+        '.server.js',
+        '.server.jsx',
+        '.server.ts',
+        '.server.tsx',
+        '.server.mjs'
+    ];
+    const webWorkerExts = [
+        '.worker.js',
+        '.worker.jsx',
+        '.worker.ts',
+        '.worker.tsx'
+    ];
+    for (const ext of nodeExts)chain.resolve.extensions.prepend(ext);
+    if (isServiceWorker) for (const ext of webWorkerExts)chain.resolve.extensions.prepend(ext);
+    const extensionAlias = {
+        '.js': [
+            '.node.js',
+            '.server.js',
+            '.js'
+        ],
+        '.jsx': [
+            '.node.jsx',
+            '.server.jsx',
+            '.jsx'
+        ],
+        '.ts': [
+            '.node.ts',
+            '.server.ts',
+            '.ts'
+        ],
+        '.tsx': [
+            '.node.tsx',
+            '.server.tsx',
+            '.tsx'
+        ],
+        '.mjs': [
+            '.node.mjs',
+            '.server.mjs',
+            '.mjs'
+        ],
+        '.json': [
+            '.node.json',
+            '.server.json',
+            '.json'
+        ]
+    };
+    chain.resolve.extensionAlias.merge(extensionAlias);
+}
+export { builderPluginAdapterBasic };

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

@@ -0,0 +1,55 @@
+import { isHtmlDisabled } from "@modern-js/builder";
+import { removeTailSlash } from "@modern-js/utils";
+import { template } from "@modern-js/utils/lodash";
+import { BottomTemplatePlugin } from "../bundlerPlugins";
+const createVirtualModule = (content)=>`data:text/javascript;charset=utf-8,${encodeURIComponent(content)}`;
+const builderPluginAdapterHtml = (options)=>({
+        name: 'builder-plugin-adapter-modern-html',
+        setup (api) {
+            api.modifyBundlerChain(async (chain, { CHAIN_ID, target, HtmlPlugin: HtmlBundlerPlugin, environment })=>{
+                const builderConfig = environment.config;
+                if (!isHtmlDisabled(builderConfig, target)) {
+                    applyBottomHtmlPlugin({
+                        options,
+                        chain,
+                        CHAIN_ID,
+                        HtmlBundlerPlugin,
+                        htmlPaths: environment.htmlPaths
+                    });
+                    await injectAssetPrefix({
+                        chain
+                    });
+                }
+            });
+        }
+    });
+async function injectAssetPrefix({ chain }) {
+    const entries = chain.entryPoints.entries() || {};
+    const entryNames = Object.keys(entries);
+    const assetPrefix = removeTailSlash(chain.output.get('publicPath') || '');
+    const code = `window.__assetPrefix__ = '${assetPrefix}';`;
+    entryNames.forEach((entryName)=>{
+        entries[entryName].prepend(createVirtualModule(code));
+    });
+}
+function applyBottomHtmlPlugin({ chain, options, CHAIN_ID, HtmlBundlerPlugin, htmlPaths }) {
+    const { normalizedConfig: modernConfig, appContext } = options;
+    for (const entryName of Object.keys(htmlPaths)){
+        const baseTemplateParams = {
+            entryName,
+            title: modernConfig.html.title,
+            mountId: modernConfig.html.templateParameters
+        };
+        chain.plugin(`${CHAIN_ID.PLUGIN.HTML}-${entryName}`).tap((args)=>[
+                {
+                    ...args[0] || {},
+                    __internal__: true,
+                    bottomTemplate: appContext.htmlTemplates[`__${entryName}-bottom__`] && template(appContext.htmlTemplates[`__${entryName}-bottom__`])(baseTemplateParams)
+                }
+            ]);
+    }
+    chain.plugin('bottom-template').use(BottomTemplatePlugin, [
+        HtmlBundlerPlugin
+    ]);
+}
+export { builderPluginAdapterHtml };

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

@@ -0,0 +1,117 @@
+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";
+import { HtmlAsyncChunkPlugin, RouterPlugin } from "../bundlerPlugins";
+const builderPluginAdapterSSR = (options)=>({
+        name: 'builder-plugin-adapter-modern-ssr',
+        setup (api) {
+            const { normalizedConfig } = options;
+            api.modifyRsbuildConfig((config)=>mergeRsbuildConfig(config, {
+                    html: {
+                        inject: isStreamingSSR(normalizedConfig) ? 'head' : void 0
+                    },
+                    server: {
+                        compress: isStreamingSSR(normalizedConfig) || isUseRsc(normalizedConfig) ? false : void 0
+                    }
+                }));
+            api.modifyBundlerChain(async (chain, { target, isProd, HtmlPlugin: HtmlBundlerPlugin, isServer, environment })=>{
+                const builderConfig = environment.config;
+                const { normalizedConfig } = options;
+                applyRouterPlugin(chain, 'route-plugin', options, HtmlBundlerPlugin);
+                const isServiceWorker = environment.name === SERVICE_WORKER_ENVIRONMENT_NAME;
+                if ('node' === target || isServiceWorker) applyFilterEntriesBySSRConfig({
+                    isProd,
+                    chain,
+                    appNormalizedConfig: normalizedConfig
+                });
+                if (isUseSSRBundle(normalizedConfig) || isUseRsc(normalizedConfig)) {
+                    await applySSRLoaderEntry(chain, options, isServer);
+                    applySSRDataLoader(chain, options);
+                }
+                if (!isHtmlDisabled(builderConfig, target)) applyAsyncChunkHtmlPlugin({
+                    chain,
+                    modernConfig: options.normalizedConfig,
+                    HtmlBundlerPlugin
+                });
+            });
+        }
+    });
+const isStreamingSSR = (userConfig)=>{
+    const isStreaming = (ssr)=>{
+        if (!ssr) return false;
+        if ('boolean' == typeof ssr) return ssr;
+        return 'string' !== ssr.mode;
+    };
+    const { server } = userConfig;
+    if (isStreaming(server.ssr)) return true;
+    if (server?.ssrByEntries && 'object' == typeof server.ssrByEntries) {
+        for (const name of Object.keys(server.ssrByEntries))if (isStreaming(server.ssrByEntries[name])) return true;
+    }
+    return false;
+};
+function applyAsyncChunkHtmlPlugin({ chain, modernConfig, HtmlBundlerPlugin }) {
+    if (isStreamingSSR(modernConfig) || isUseRsc(modernConfig)) chain.plugin('html-async-chunk').use(HtmlAsyncChunkPlugin, [
+        HtmlBundlerPlugin
+    ]);
+}
+function applyRouterPlugin(chain, pluginName, options, HtmlBundlerPlugin) {
+    const { appContext, normalizedConfig } = options;
+    const { entrypoints } = appContext;
+    const existNestedRoutes = entrypoints.some((entrypoint)=>entrypoint.nestedRoutesEntry);
+    const workerSSR = Boolean(normalizedConfig.deploy.worker?.ssr);
+    const { enableInlineRouteManifests, disableInlineRouteManifests } = normalizedConfig.output;
+    const inlineRouteManifests = disableInlineRouteManifests ? !disableInlineRouteManifests : enableInlineRouteManifests;
+    if (existNestedRoutes || workerSSR) chain.plugin(pluginName).use(RouterPlugin, [
+        {
+            HtmlBundlerPlugin,
+            enableInlineRouteManifests: inlineRouteManifests,
+            staticJsDir: normalizedConfig.output?.distPath?.js,
+            disableFilenameHash: normalizedConfig.output?.filenameHash === false,
+            scriptLoading: normalizedConfig.html?.scriptLoading,
+            nonce: normalizedConfig.security?.nonce
+        }
+    ]);
+}
+function applyFilterEntriesBySSRConfig({ isProd, chain, appNormalizedConfig }) {
+    const { server: serverConfig, output: outputConfig } = appNormalizedConfig;
+    const entries = chain.entryPoints.entries();
+    if (isProd && (outputConfig?.ssg === true || 'function' == typeof outputConfig?.ssg)) return;
+    if (void 0 === entries) throw new Error('No entry found, one of src/routes/layout.tsx, src/App.tsx, src/index.tsx is required');
+    const entryNames = Object.keys(entries);
+    if (isProd && 1 === entryNames.length && outputConfig?.ssg) return;
+    const ssgEntries = [];
+    if (isProd && outputConfig?.ssgByEntries) {
+        const { ssgByEntries } = outputConfig;
+        entryNames.forEach((name)=>{
+            if (ssgByEntries[name]) ssgEntries.push(name);
+        });
+    }
+    const { ssr, ssrByEntries } = serverConfig || {};
+    entryNames.forEach((name)=>{
+        if (!serverConfig?.rsc && !ssgEntries.includes(name) && !name.includes('server-loaders') && (ssr && ssrByEntries?.[name] === false || !ssr && !ssrByEntries?.[name])) chain.entryPoints.delete(name);
+    });
+}
+async function applySSRLoaderEntry(chain, optinos, isServer) {
+    const { appContext } = optinos;
+    const { internalDirectory } = appContext;
+    const { entrypoints } = appContext;
+    await Promise.all(entrypoints.map(async (entrypoint)=>{
+        const { entryName } = entrypoint;
+        const serverLoadersFile = getServerCombinedModueFile(internalDirectory, entryName);
+        if (isServer) try {
+            await fs.access(serverLoadersFile, fs.constants.F_OK);
+            chain.entry(`${entryName}-server-loaders`).add(serverLoadersFile);
+        } catch (err) {}
+    }));
+}
+function applySSRDataLoader(chain, options) {
+    const { normalizedConfig, appContext } = options;
+    const { appDirectory } = appContext;
+    const { entriesDir = './src' } = normalizedConfig.source;
+    const absolutePath = resolve(appDirectory, entriesDir).split(sep).join('(\\\\|/)');
+    const reg = new RegExp(`${absolutePath}.*\\.(loader|data|data.client)\\.[t|j]sx?$`);
+    chain.module.rule('ssr-data-loader').test(reg).use('data-loader').loader(require.resolve('@modern-js/plugin-data-loader/loader')).end();
+}
+export { builderPluginAdapterSSR };

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

@@ -0,0 +1,17 @@
+const builderPluginAdapterHooks = (options)=>({
+        name: 'builder-plugin-support-modern-hooks',
+        setup (api) {
+            const _internalContext = options.appContext._internalContext;
+            const hooks = _internalContext.pluginAPI?.getHooks();
+            api.modifyBundlerChain(async (chain, utils)=>{
+                await hooks?.modifyBundlerChain.call(chain, utils);
+            });
+            api.modifyRsbuildConfig(async (config, utils)=>{
+                await hooks?.modifyRsbuildConfig.call(config, utils);
+            });
+            api.modifyRspackConfig(async (config, utils)=>{
+                await hooks?.modifyRspackConfig.call(config, utils);
+            });
+        }
+    });
+export { builderPluginAdapterHooks };

package/dist/esm/builder/shared/bundlerPlugins/HtmlAsyncChunkPlugin.mjs

@@ -0,0 +1,37 @@
+import { RUNTIME_CHUNK_REGEX } from "@modern-js/builder";
+class HtmlAsyncChunkPlugin {
+    apply(compiler) {
+        compiler.hooks.compilation.tap(this.name, (compilation)=>{
+            const hooks = this.htmlWebpackPlugin.getHooks(compilation);
+            hooks.alterAssetTagGroups.tap(this.name, (assets)=>{
+                const headTags = [];
+                const bodyTags = [];
+                const processScriptTag = (tag)=>{
+                    const { attributes } = tag;
+                    if (attributes && true === attributes.defer) {
+                        attributes.async = true;
+                        delete attributes.defer;
+                    }
+                    const src = attributes?.src;
+                    const isRuntimeChunk = src && RUNTIME_CHUNK_REGEX.test(src);
+                    return isRuntimeChunk ? bodyTags : headTags;
+                };
+                for (const tag of [
+                    ...assets.headTags,
+                    ...assets.bodyTags
+                ])if ("script" === tag.tagName) processScriptTag(tag).push(tag);
+                else (assets.headTags.includes(tag) ? headTags : bodyTags).push(tag);
+                return {
+                    ...assets,
+                    headTags,
+                    bodyTags
+                };
+            });
+        });
+    }
+    constructor(htmlWebpackPlugin){
+        this.name = 'HtmlAsyncChunkPlugin';
+        this.htmlWebpackPlugin = htmlWebpackPlugin;
+    }
+}
+export { HtmlAsyncChunkPlugin };

package/dist/esm/builder/shared/bundlerPlugins/HtmlBottomTemplate.mjs

@@ -0,0 +1,22 @@
+class BottomTemplatePlugin {
+    apply(compiler) {
+        compiler.hooks.compilation.tap(this.name, (compilation)=>{
+            this.htmlWebpackPlugin.getHooks(compilation).beforeEmit.tap(this.name, (data)=>{
+                if (!data.plugin.options?.__internal__) return data;
+                if (this.bottomTemplateReg.test(data.html)) {
+                    data.html = data.html.replace(this.bottomTemplateReg, '');
+                    const { bottomTemplate } = data.plugin.options;
+                    if (bottomTemplate) data.html = data.html.replace(this.bodyRegExp, (match)=>`\n${bottomTemplate}\n${match}`);
+                }
+                return data;
+            });
+        });
+    }
+    constructor(htmlWebpackPlugin){
+        this.bottomTemplateReg = /<!--<\?-\s*bottomTemplate\s*\?>-->/;
+        this.bodyRegExp = /(<\/\s*body\s*>)/i;
+        this.htmlWebpackPlugin = htmlWebpackPlugin;
+        this.name = 'bottom-template';
+    }
+}
+export { BottomTemplatePlugin };

package/dist/esm/builder/shared/bundlerPlugins/RouterPlugin.mjs

@@ -0,0 +1,157 @@
+import { createHash } from "crypto";
+import { ROUTE_MANIFEST_FILE } from "@modern-js/utils";
+import { merge, mergeWith } from "@modern-js/utils/lodash";
+import { ROUTE_MANIFEST } from "@modern-js/utils/universal/constants";
+const PLUGIN_NAME = 'ModernjsRoutePlugin';
+const generateContentHash = (content)=>createHash('md5').update(content).digest('hex').slice(0, 8);
+class RouterPlugin {
+    isTargetNodeOrWebWorker(target) {
+        if ('node' === target || Array.isArray(target) && target.includes('node')) return true;
+        if ('webworker' === target || Array.isArray(target) && target.includes('webworker')) return true;
+        return false;
+    }
+    getEntryChunks(compilation, chunks) {
+        const entrypointsArray = Array.from(compilation.entrypoints.entries());
+        const entryChunkIds = entrypointsArray.map((entrypoint)=>entrypoint[0]);
+        const entryChunks = [
+            ...chunks
+        ].filter((chunk)=>chunk.names?.some((name)=>entryChunkIds.includes(name)));
+        return entryChunks;
+    }
+    getEntryChunkFiles(entryChunks) {
+        return entryChunks.map((chunk)=>[
+                ...chunk.files || []
+            ].find((fname)=>fname.includes('.js')));
+    }
+    apply(compiler) {
+        const { target } = compiler.options;
+        if (this.isTargetNodeOrWebWorker(target)) return;
+        const { rspack } = compiler;
+        const { Compilation, sources } = rspack;
+        const { RawSource } = sources;
+        const normalizePath = (path)=>{
+            if (!path.endsWith('/')) return `${path}/`;
+            return path;
+        };
+        const chunksToHtmlName = new Map();
+        const ROUTE_MANIFEST_HOLDER = "route-manifest";
+        const placeholder = `<!--<?- ${ROUTE_MANIFEST_HOLDER} ?>-->`;
+        compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation)=>{
+            this.HtmlBundlerPlugin.getHooks(compilation).beforeEmit.tapAsync('RouterManifestPlugin', (data, callback)=>{
+                const { outputName } = data;
+                const { chunks } = data.plugin.options;
+                chunksToHtmlName.set(chunks, outputName);
+                data.html = data.html.replace("<\/script>", `</script>${placeholder}`);
+                callback(null, data);
+            });
+            compilation.hooks.processAssets.tapPromise({
+                name: PLUGIN_NAME,
+                stage: Compilation.PROCESS_ASSETS_STAGE_REPORT
+            }, async ()=>{
+                const stats = compilation.getStats().toJson({
+                    all: false,
+                    publicPath: true,
+                    assets: true,
+                    chunkGroups: true,
+                    chunks: true,
+                    ids: true
+                });
+                const { publicPath, chunks = [], namedChunkGroups } = stats;
+                const routeAssets = {};
+                if (!namedChunkGroups) return;
+                const prevManifestAsset = compilation.getAsset(ROUTE_MANIFEST_FILE);
+                const prevManifestStr = prevManifestAsset ? prevManifestAsset.source.source().toString() : JSON.stringify({
+                    routeAssets: {}
+                });
+                const prevManifest = JSON.parse(prevManifestStr);
+                const asyncEntryNames = [];
+                for (const [name, chunkGroup] of Object.entries(namedChunkGroups)){
+                    if (name.startsWith('async-')) asyncEntryNames.push(name);
+                    const assets = chunkGroup.assets.map((asset)=>{
+                        const filename = asset.name;
+                        return publicPath ? normalizePath(publicPath) + filename : filename;
+                    });
+                    const referenceCssAssets = assets.filter((asset)=>/\.css$/.test(asset));
+                    routeAssets[name] = {
+                        chunkIds: chunkGroup.chunks,
+                        assets,
+                        referenceCssAssets
+                    };
+                    if (prevManifest.routeAssets[name]) mergeWith(routeAssets[name], prevManifest.routeAssets[name], (obj, source)=>{
+                        if (Array.isArray(obj)) return obj.concat(source);
+                        return Object.assign(source, obj);
+                    });
+                }
+                if (asyncEntryNames.length > 0) for (const asyncEntryName of asyncEntryNames){
+                    const syncEntryName = asyncEntryName.replace('async-', '');
+                    const syncEntry = routeAssets[syncEntryName];
+                    const asyncEntry = routeAssets[asyncEntryName];
+                    merge(syncEntry, asyncEntry);
+                }
+                const manifest = {
+                    routeAssets
+                };
+                const entryNames = Array.from(compilation.entrypoints.keys());
+                let entryChunks = [];
+                entryChunks = this.getEntryChunks(compilation, chunks);
+                const entryChunkFiles = this.getEntryChunkFiles(entryChunks);
+                const entryChunkFileIds = entryChunks.map((chunk)=>chunk.id);
+                for(let i = 0; i < entryChunkFiles.length; i++){
+                    const entryName = entryNames[i];
+                    const file = entryChunkFiles[i];
+                    const chunkNames = entryChunks[i].names;
+                    const chunkId = entryChunkFileIds[i];
+                    const asset = compilation.assets[file];
+                    if (!asset || !chunkId) continue;
+                    let relatedAssets = {};
+                    if (entryChunkFiles.length > 1) Object.keys(routeAssets).forEach((routeId)=>{
+                        const segments = routeId.split('_');
+                        const chunkName = segments[0];
+                        if (chunkNames?.includes(chunkName)) relatedAssets[routeId] = routeAssets[routeId];
+                    });
+                    else relatedAssets = routeAssets;
+                    const manifest = {
+                        routeAssets: relatedAssets
+                    };
+                    const injectedContent = `
+            ;(function(){
+              window.${ROUTE_MANIFEST} = ${JSON.stringify(manifest, (k, v)=>{
+                        if (('assets' === k || 'referenceCssAssets' === k) && Array.isArray(v)) return v.map((item)=>item.replace(publicPath, ''));
+                        return v;
+                    })};
+            })();
+          `;
+                    let htmlName;
+                    for (const [chunks, name] of chunksToHtmlName.entries())if (Array.isArray(chunkNames) && Array.isArray(chunks) && chunkNames.every((value, index)=>value === chunks[index])) {
+                        htmlName = name;
+                        break;
+                    }
+                    const oldHtml = compilation.assets[htmlName];
+                    const { enableInlineRouteManifests, disableFilenameHash, staticJsDir, scriptLoading, nonce } = this;
+                    const nonceAttr = nonce ? `nonce="${nonce}"` : '';
+                    if (oldHtml) if (enableInlineRouteManifests) compilation.updateAsset(htmlName, new RawSource(oldHtml.source().toString().replace(placeholder, `<script ${nonceAttr}>${injectedContent}</script>`)), void 0);
+                    else {
+                        const scriptPath = `${staticJsDir}/${ROUTE_MANIFEST_HOLDER}-${entryName}${disableFilenameHash ? '.js' : `.${generateContentHash(injectedContent)}.js`}`;
+                        const scriptUrl = `${publicPath}${scriptPath}`;
+                        const scriptLoadingAttr = 'defer' === scriptLoading ? scriptLoading : 'module' === scriptLoading ? 'type="module"' : '';
+                        const script = `<script ${scriptLoadingAttr} ${nonceAttr} src="${scriptUrl}"></script>`;
+                        compilation.updateAsset(htmlName, new RawSource(oldHtml.source().toString().replace(placeholder, script)), void 0);
+                        compilation.emitAsset(scriptPath, new RawSource(injectedContent));
+                    }
+                }
+                if (prevManifestAsset) compilation.updateAsset(ROUTE_MANIFEST_FILE, new RawSource(JSON.stringify(manifest, null, 2)), void 0);
+                else compilation.emitAsset(ROUTE_MANIFEST_FILE, new RawSource(JSON.stringify(manifest, null, 2)));
+            });
+        });
+    }
+    constructor({ staticJsDir = 'static/js', HtmlBundlerPlugin, enableInlineRouteManifests, disableFilenameHash = false, scriptLoading = 'defer', nonce }){
+        this.name = 'RouterPlugin';
+        this.HtmlBundlerPlugin = HtmlBundlerPlugin;
+        this.enableInlineRouteManifests = enableInlineRouteManifests;
+        this.staticJsDir = staticJsDir;
+        this.disableFilenameHash = disableFilenameHash;
+        this.scriptLoading = scriptLoading;
+        this.nonce = nonce;
+    }
+}
+export { RouterPlugin };

package/dist/esm/builder/shared/createCopyInfo.mjs

@@ -0,0 +1,15 @@
+import path from "path";
+import { resolvePublicDirPaths } from "@modern-js/server-core";
+function createCopyInfo(appContext, config) {
+    const configDir = path.resolve(appContext.appDirectory, config.source.configDir || './config');
+    const uploadDir = path.posix.join(configDir.replace(/\\/g, '/'), 'upload');
+    const publicDir = path.posix.join(configDir.replace(/\\/g, '/'), 'public');
+    const customPublicDirPaths = resolvePublicDirPaths(config.server?.publicDir, appContext.appDirectory);
+    return {
+        configDir,
+        uploadDir,
+        publicDir,
+        customPublicDirs: customPublicDirPaths
+    };
+}
+export { createCopyInfo };

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

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