@bleedingdev/modern-js-app-tools 3.2.0-ultramodern.0

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

@@ -0,0 +1,7 @@
+import "node:module";
+import { generateBuilder } from "../generator/index.mjs";
+async function createRspackBuilderForModern(options) {
+    const builder = await generateBuilder(options, 'rspack');
+    return builder;
+}
+export { createRspackBuilderForModern };

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

@@ -0,0 +1,36 @@
+import "node:module";
+import path from "path";
+import { createCopyInfo } from "../shared/index.mjs";
+import { createPublicPattern } from "./createCopyPattern.mjs";
+const builderPluginAdapterCopy = (options)=>({
+        name: 'builder-plugin-adapter-copy',
+        setup (api) {
+            const { normalizedConfig: modernConfig, appContext } = options;
+            api.modifyBundlerChain((chain, { CHAIN_ID })=>{
+                if (chain.plugins.has(CHAIN_ID.PLUGIN.COPY)) {
+                    const defaultCopyPattern = createPublicPattern(appContext, modernConfig, chain);
+                    const { customPublicDirs } = createCopyInfo(appContext, modernConfig);
+                    const customCopyPatterns = customPublicDirs.map((customPublicDir)=>{
+                        const relativePath = path.relative(appContext.appDirectory, customPublicDir);
+                        const outputDir = relativePath || path.basename(customPublicDir);
+                        return {
+                            from: '**/*',
+                            to: outputDir,
+                            context: customPublicDir,
+                            noErrorOnMissing: true
+                        };
+                    });
+                    chain.plugin(CHAIN_ID.PLUGIN.COPY).tap((args)=>[
+                            {
+                                patterns: [
+                                    ...args[0]?.patterns || [],
+                                    defaultCopyPattern,
+                                    ...customCopyPatterns
+                                ]
+                            }
+                        ]);
+                }
+            });
+        }
+    });
+export { builderPluginAdapterCopy };

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

@@ -0,0 +1,67 @@
+import "node:module";
+import { DEFAULT_API_PREFIX } from "@modern-js/utils";
+import { createUploadPattern } from "./createCopyPattern.mjs";
+function modifyOutputConfig(config, appContext) {
+    const defaultCopyPattern = createUploadPattern(appContext, config);
+    const { copy } = config.output;
+    const copyOptions = Array.isArray(copy) ? copy : copy?.patterns;
+    const builderCopy = [
+        ...copyOptions || [],
+        defaultCopyPattern
+    ];
+    config.output = {
+        ...config.output,
+        copy: builderCopy
+    };
+}
+function createBuilderProviderConfig(resolveConfig, appContext) {
+    const htmlConfig = {
+        ...resolveConfig.html
+    };
+    if (!htmlConfig.template) htmlConfig.template = ({ entryName })=>appContext.htmlTemplates[entryName];
+    const serverConfig = {
+        ...resolveConfig.server
+    };
+    if (resolveConfig.dev?.server?.cors !== void 0) serverConfig.cors = resolveConfig.dev?.server?.cors;
+    const config = {
+        ...resolveConfig,
+        plugins: [],
+        resolve: {
+            ...resolveConfig.resolve
+        },
+        source: {
+            ...resolveConfig.source
+        },
+        dev: {
+            ...resolveConfig.dev,
+            port: appContext.port
+        },
+        server: serverConfig,
+        html: htmlConfig,
+        output: {
+            ...resolveConfig.output,
+            cleanDistPath: false
+        },
+        tools: {
+            ...resolveConfig.tools,
+            devServer: {
+                ...resolveConfig.tools?.devServer,
+                compress: {
+                    filter: (req)=>{
+                        const bffPrefix = resolveConfig.bff?.prefix || DEFAULT_API_PREFIX;
+                        const bffPrefixes = Array.isArray(bffPrefix) ? bffPrefix : [
+                            bffPrefix
+                        ];
+                        const url = req.url;
+                        if (bffPrefixes.some((prefix)=>url?.startsWith(prefix))) return false;
+                        return true;
+                    }
+                }
+            }
+        }
+    };
+    if (config.source?.enableAsyncEntry && config.source?.enableAsyncPreEntry) delete config.source.preEntry;
+    modifyOutputConfig(config, appContext);
+    return config;
+}
+export { createBuilderProviderConfig };

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

@@ -0,0 +1,31 @@
+import "node:module";
+import { removeTailSlash } from "@modern-js/utils";
+import { createCopyInfo } from "../shared/index.mjs";
+const minifiedJsRexExp = /\.min\.js/;
+const info = (file)=>({
+        minimized: minifiedJsRexExp.test(file.sourceFilename)
+    });
+function createPublicPattern(appContext, config, chain) {
+    const { publicDir } = createCopyInfo(appContext, config);
+    return {
+        info: info,
+        from: '**/*',
+        to: 'public',
+        context: publicDir,
+        noErrorOnMissing: true,
+        transform: (content, absoluteFrom)=>{
+            if (!/\.html?$/.test(absoluteFrom)) return content;
+            return content.toString('utf8').replace(/<%=\s*assetPrefix\s*%>/g, removeTailSlash(chain.output.get('publicPath')));
+        }
+    };
+}
+function createUploadPattern(appContext, config) {
+    const { uploadDir } = createCopyInfo(appContext, config);
+    return {
+        from: '**/*',
+        to: 'upload',
+        context: uploadDir,
+        noErrorOnMissing: true
+    };
+}
+export { createPublicPattern, createUploadPattern };

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

@@ -0,0 +1,57 @@
+import "node:module";
+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 = {
+        client: {
+            output: {
+                target: 'web'
+            },
+            source: {
+                entry: entries
+            }
+        }
+    };
+    if (tempBuilderConfig.output?.copy) {
+        environments.client.output.copy = tempBuilderConfig.output.copy;
+        delete tempBuilderConfig.output.copy;
+    }
+    const useNodeTarget = isUseRsc(normalizedConfig) || (isProd() ? isUseSSRBundle(normalizedConfig) : isSSR(normalizedConfig));
+    if (useNodeTarget) environments.server = {
+        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-node/builder/generator/index.mjs

@@ -0,0 +1,47 @@
+import "node:module";
+import { createBuilder } from "@modern-js/builder";
+import { mergeRsbuildConfig } from "@rsbuild/core";
+import { builderPluginAdapterBasic, builderPluginAdapterHooks, builderPluginAdapterHtml, builderPluginAdapterPrecompress, builderPluginAdapterSSR } from "../shared/builderPlugins/index.mjs";
+import { builderPluginAdapterCopy } from "./adapterCopy.mjs";
+import { createBuilderProviderConfig } from "./createBuilderProviderConfig.mjs";
+import { getBuilderEnvironments } from "./getBuilderEnvironments.mjs";
+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),
+        builderPluginAdapterPrecompress(options),
+        builderPluginAdapterHooks(options)
+    ]);
+    builder.addPlugins([
+        builderPluginAdapterCopy(options)
+    ], {
+        environment: 'client'
+    });
+    const { normalizedConfig } = options;
+}
+export { generateBuilder };

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

@@ -0,0 +1,8 @@
+import "node:module";
+async function createBuilderGenerator() {
+    const { createRspackBuilderForModern } = await import("./builder-rspack/index.mjs");
+    return createRspackBuilderForModern;
+}
+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

@@ -0,0 +1,93 @@
+import "node:module";
+import node_path from "node:path";
+import { SERVICE_WORKER_ENVIRONMENT_NAME } from "@modern-js/builder";
+import { fileURLToPath as __rspack_fileURLToPath } from "node:url";
+import { dirname as __rspack_dirname } from "node:path";
+var adapterBasic_dirname = __rspack_dirname(__rspack_fileURLToPath(import.meta.url));
+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?$/;
+                    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(node_path.join(adapterBasic_dirname, `../loaders/serverModuleLoader.${depExt}`));
+                }
+                const { appContext } = options;
+                const { metaName } = appContext;
+                chain.watchOptions({
+                    ignored: [
+                        `[\\\\/](?:node_modules(?![\\\\/]\\.${metaName})|.git)[\\\\/]`
+                    ]
+                });
+            });
+            api.modifyRspackConfig((config, { target, environment })=>{
+                const isServiceWorker = environment.name === SERVICE_WORKER_ENVIRONMENT_NAME;
+                if ('node' === target || isServiceWorker) {
+                    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'
+                        ]
+                    };
+                    config.resolve ??= {};
+                    config.resolve.extensionAlias = {
+                        ...config.resolve.extensionAlias,
+                        ...extensionAlias
+                    };
+                }
+            });
+        }
+    });
+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);
+}
+export { builderPluginAdapterBasic };

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

@@ -0,0 +1,56 @@
+import "node:module";
+import { isHtmlDisabled } from "@modern-js/builder";
+import { removeTailSlash } from "@modern-js/utils";
+import { template } from "@modern-js/utils/lodash";
+import { BottomTemplatePlugin } from "../bundlerPlugins/index.mjs";
+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-node/builder/shared/builderPlugins/adapterPrecompress.mjs

@@ -0,0 +1,69 @@
+import "node:module";
+import { constants } from "node:zlib";
+import compression_webpack_plugin from "compression-webpack-plugin";
+const DEFAULT_PRECOMPRESS_TEST = /\.(js|mjs|cjs|css|html|svg|json|map)$/i;
+const DEFAULT_PRECOMPRESS_THRESHOLD = 10240;
+const DEFAULT_PRECOMPRESS_MIN_RATIO = 0.8;
+const createDefaultGzipOptions = ()=>({
+        algorithm: 'gzip',
+        filename: '[path][base].gz',
+        test: DEFAULT_PRECOMPRESS_TEST,
+        threshold: DEFAULT_PRECOMPRESS_THRESHOLD,
+        minRatio: DEFAULT_PRECOMPRESS_MIN_RATIO,
+        compressionOptions: {
+            level: 6
+        }
+    });
+const createDefaultBrotliOptions = ()=>({
+        algorithm: 'brotliCompress',
+        filename: '[path][base].br',
+        test: DEFAULT_PRECOMPRESS_TEST,
+        threshold: DEFAULT_PRECOMPRESS_THRESHOLD,
+        minRatio: DEFAULT_PRECOMPRESS_MIN_RATIO,
+        compressionOptions: {
+            params: {
+                [constants.BROTLI_PARAM_QUALITY]: 9
+            }
+        }
+    });
+const mergeCompressionOptions = (base, next)=>{
+    const merged = {
+        ...base,
+        ...next
+    };
+    if (base.compressionOptions || next.compressionOptions) merged.compressionOptions = {
+        ...base.compressionOptions,
+        ...next.compressionOptions
+    };
+    return merged;
+};
+const resolveCodecOptions = (codecConfig, createDefaultOptions)=>{
+    if (false === codecConfig) return null;
+    if (void 0 === codecConfig || true === codecConfig) return createDefaultOptions();
+    return mergeCompressionOptions(createDefaultOptions(), codecConfig);
+};
+const resolvePrecompressConfig = (normalizedConfig)=>{
+    const precompress = normalizedConfig.output.precompress;
+    if (false === precompress || void 0 === precompress) return false;
+    if (true === precompress) return {};
+    return precompress;
+};
+const builderPluginAdapterPrecompress = (options)=>({
+        name: 'builder-plugin-adapter-modern-precompress',
+        setup (api) {
+            api.modifyBundlerChain((chain, { isProd, target })=>{
+                if (!isProd || 'web' !== target) return;
+                const precompressConfig = resolvePrecompressConfig(options.normalizedConfig);
+                if (false === precompressConfig) return;
+                const gzipOptions = resolveCodecOptions(precompressConfig.gzip, createDefaultGzipOptions);
+                if (gzipOptions) chain.plugin('modern-precompress-gzip').use(compression_webpack_plugin, [
+                    gzipOptions
+                ]);
+                const brotliOptions = resolveCodecOptions(precompressConfig.brotli, createDefaultBrotliOptions);
+                if (brotliOptions) chain.plugin('modern-precompress-brotli').use(compression_webpack_plugin, [
+                    brotliOptions
+                ]);
+            });
+        }
+    });
+export { builderPluginAdapterPrecompress };

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

@@ -0,0 +1,119 @@
+import __rslib_shim_module__ from "node:module";
+const require = /*#__PURE__*/ __rslib_shim_module__.createRequire(/*#__PURE__*/ (()=>import.meta.url)());
+import { SERVICE_WORKER_ENVIRONMENT_NAME, isHtmlDisabled } from "@modern-js/builder";
+import { fs, isUseRsc, isUseSSRBundle } from "@modern-js/utils";
+import { mergeRsbuildConfig } from "@rsbuild/core";
+import { getServerCombinedModuleFile } from "../../../plugins/analyze/utils.mjs";
+import { HtmlAsyncChunkPlugin, RouterPlugin } from "../bundlerPlugins/index.mjs";
+import * as __rspack_external_path from "path";
+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 = getServerCombinedModuleFile(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 = __rspack_external_path.resolve(appDirectory, entriesDir).split(__rspack_external_path.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-node/builder/shared/builderPlugins/builderHooks.mjs

@@ -0,0 +1,18 @@
+import "node:module";
+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-node/builder/shared/builderPlugins/index.mjs

@@ -0,0 +1,6 @@
+import "node:module";
+export * from "./adapterBasic.mjs";
+export * from "./adapterHtml.mjs";
+export * from "./adapterPrecompress.mjs";
+export * from "./adapterSSR.mjs";
+export * from "./builderHooks.mjs";

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

@@ -0,0 +1,38 @@
+import "node:module";
+import { RUNTIME_CHUNK_REGEX } from "@modern-js/builder";
+class HtmlAsyncChunkPlugin {
+    apply(compiler) {
+        compiler.hooks.compilation.tap(this.name, (compilation)=>{
+            const hooks = this.htmlPlugin.getCompilationHooks(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(htmlPlugin){
+        this.name = 'HtmlAsyncChunkPlugin';
+        this.htmlPlugin = htmlPlugin;
+    }
+}
+export { HtmlAsyncChunkPlugin };