@modern-js/builder 3.0.0-alpha.0 → 3.0.0-alpha.2

package/dist/esm/createBuilder.mjs

@@ -0,0 +1,59 @@
+import { createRsbuild } from "@rsbuild/core";
+import { rsbuildRscPlugin } from "./rsc/plugins/rsbuild-rsc-plugin.mjs";
+import { parseCommonConfig } from "./shared/parseCommonConfig.mjs";
+import { rscClientBrowserFallbackPlugin } from "./shared/rsc/rscClientBrowserFallback.mjs";
+async function parseConfig(builderConfig, options) {
+    builderConfig.performance ??= {};
+    builderConfig.performance.buildCache ??= true;
+    const { rsbuildConfig, rsbuildPlugins } = await parseCommonConfig(builderConfig, options);
+    const { sri } = builderConfig.security || {};
+    if (sri) if (true === sri) rsbuildConfig.security.sri = {
+        enable: 'auto'
+    };
+    else {
+        const algorithm = Array.isArray(sri.hashFuncNames) ? sri.hashFuncNames[0] : void 0;
+        rsbuildConfig.security.sri = {
+            enable: sri.enabled,
+            algorithm
+        };
+    }
+    if (false === Boolean(rsbuildConfig.tools.lightningcssLoader)) {
+        const { pluginPostcss } = await import("./plugins/postcss.mjs");
+        rsbuildPlugins.push(pluginPostcss({
+            autoprefixer: builderConfig.tools?.autoprefixer
+        }));
+    }
+    const enableRsc = builderConfig.server?.rsc ?? false;
+    if (enableRsc) {
+        const { rscClientRuntimePath, rscServerRuntimePath, internalDirectory } = options;
+        rsbuildPlugins.push(rsbuildRscPlugin({
+            appDir: options.cwd,
+            rscClientRuntimePath,
+            rscServerRuntimePath,
+            internalDirectory
+        }));
+    } else rsbuildPlugins.push(rscClientBrowserFallbackPlugin());
+    return {
+        rsbuildConfig,
+        rsbuildPlugins
+    };
+}
+async function createRspackBuilder(options) {
+    const { cwd = process.cwd(), config, ...rest } = options;
+    const { rsbuildConfig, rsbuildPlugins } = await parseConfig(config, {
+        ...rest,
+        cwd
+    });
+    rsbuildConfig.plugins = [
+        ...rsbuildPlugins,
+        ...rsbuildConfig.plugins || []
+    ];
+    const rsbuild = await createRsbuild({
+        cwd,
+        rsbuildConfig
+    });
+    return {
+        ...rsbuild
+    };
+}
+export { createRspackBuilder, parseConfig };

package/dist/esm/index.mjs

@@ -0,0 +1,4 @@
+import { createRspackBuilder, parseConfig } from "./createBuilder.mjs";
+import { logger } from "@rsbuild/core";
+import { RUNTIME_CHUNK_NAME, RUNTIME_CHUNK_REGEX, SERVICE_WORKER_ENVIRONMENT_NAME, castArray, isHtmlDisabled } from "./shared/utils.mjs";
+export { RUNTIME_CHUNK_NAME, RUNTIME_CHUNK_REGEX, SERVICE_WORKER_ENVIRONMENT_NAME, castArray, createRspackBuilder as createBuilder, isHtmlDisabled, logger, parseConfig as parseRspackConfig };

package/dist/esm/plugins/devtools.mjs

@@ -0,0 +1,13 @@
+const pluginDevtool = (options)=>({
+        name: 'builder:devtool',
+        setup (api) {
+            const devtoolJs = 'boolean' == typeof options.sourceMap || options.sourceMap?.js !== void 0;
+            if (devtoolJs) return;
+            api.modifyBundlerChain((chain, { isProd, isServer })=>{
+                const prodDevTool = isServer ? 'source-map' : 'hidden-source-map';
+                const devtool = isProd ? prodDevTool : 'cheap-module-source-map';
+                chain.devtool(devtool);
+            });
+        }
+    });
+export { pluginDevtool };

package/dist/esm/plugins/emitRouteFile.mjs

@@ -0,0 +1,28 @@
+import node_fs from "node:fs";
+import { join } from "node:path";
+async function isFileExists(file) {
+    return node_fs.promises.access(file, node_fs.constants.F_OK).then(()=>true).catch(()=>false);
+}
+const pluginEmitRouteFile = ()=>({
+        name: 'builder:emit-route-file',
+        setup (api) {
+            api.onBeforeStartDevServer(async ({ environments })=>{
+                const { fs, ROUTE_SPEC_FILE } = await import("@modern-js/utils");
+                const routeFilePath = join(api.context.distPath, ROUTE_SPEC_FILE);
+                const htmlPaths = Object.values(environments).reduce((prev, curr)=>({
+                        ...prev,
+                        ...curr.htmlPaths
+                    }), {});
+                const routesInfo = Object.entries(htmlPaths).map(([entryName, filename], index)=>({
+                        urlPath: 0 === index ? '/' : `/${entryName}`,
+                        entryName,
+                        entryPath: filename,
+                        isSPA: true
+                    }));
+                if (!await isFileExists(routeFilePath) && routesInfo.length) await fs.outputFile(routeFilePath, JSON.stringify({
+                    routes: routesInfo
+                }, null, 2));
+            });
+        }
+    });
+export { isFileExists, pluginEmitRouteFile };

package/dist/esm/plugins/environmentDefaults.mjs

@@ -0,0 +1,66 @@
+import { join } from "node:path";
+import { SERVICE_WORKER_ENVIRONMENT_NAME, getBrowserslistWithDefault } from "../shared/utils.mjs";
+const pluginEnvironmentDefaults = (distPath = {})=>({
+        name: 'builder:environment-defaults-plugin',
+        setup (api) {
+            api.modifyRsbuildConfig((config, { mergeRsbuildConfig })=>{
+                const compatConfig = {};
+                if (config.environments?.[SERVICE_WORKER_ENVIRONMENT_NAME]) {
+                    compatConfig.environments ??= {};
+                    compatConfig.environments[SERVICE_WORKER_ENVIRONMENT_NAME] = {
+                        output: {
+                            polyfill: 'off',
+                            distPath: {
+                                root: join(distPath.root || 'dist', distPath.worker || 'worker'),
+                                js: '',
+                                css: '',
+                                jsAsync: '',
+                                cssAsync: ''
+                            },
+                            filename: {
+                                js: '[name].js'
+                            }
+                        }
+                    };
+                }
+                if (config.environments?.node) {
+                    compatConfig.environments ??= {};
+                    compatConfig.environments.node = {
+                        output: {
+                            emitAssets: false,
+                            distPath: {
+                                root: join(distPath.root || 'dist', distPath.server || 'bundles'),
+                                js: '',
+                                css: '',
+                                jsAsync: '',
+                                cssAsync: ''
+                            }
+                        }
+                    };
+                }
+                return compatConfig.environments ? mergeRsbuildConfig(compatConfig, config) : config;
+            });
+            api.modifyRsbuildConfig({
+                handler: (config)=>{
+                    const environmentNameOrder = [
+                        'web',
+                        'node',
+                        'workerSSR'
+                    ];
+                    config.environments = Object.fromEntries(Object.entries(config.environments).sort((a1, a2)=>environmentNameOrder.includes(a1[0]) ? environmentNameOrder.indexOf(a1[0]) - environmentNameOrder.indexOf(a2[0]) : 1));
+                },
+                order: 'post'
+            });
+            api.modifyEnvironmentConfig(async (config, { name })=>{
+                config.output.overrideBrowserslist ??= await getBrowserslistWithDefault(api.context.rootPath, config, name === SERVICE_WORKER_ENVIRONMENT_NAME ? 'node' : config.output.target);
+            });
+            api.modifyBundlerChain(async (chain, { environment })=>{
+                const isServiceWorker = environment.name === SERVICE_WORKER_ENVIRONMENT_NAME;
+                if (isServiceWorker) chain.output.library({
+                    ...chain.output.get('library') || {},
+                    type: 'commonjs2'
+                });
+            });
+        }
+    });
+export { pluginEnvironmentDefaults };

package/dist/esm/plugins/globalVars.mjs

@@ -0,0 +1,21 @@
+import { applyOptionsChain } from "@modern-js/utils";
+const pluginGlobalVars = (options)=>({
+        name: 'builder:global-vars',
+        setup (api) {
+            api.modifyBundlerChain((chain, { env, target, bundler })=>{
+                if (!options) return;
+                const globalVars = applyOptionsChain({}, options, {
+                    env,
+                    target
+                });
+                const serializedVars = {};
+                Object.entries(globalVars).forEach(([key, value])=>{
+                    serializedVars[key] = JSON.stringify(value) ?? 'undefined';
+                });
+                chain.plugin('globalVars').use(bundler.DefinePlugin, [
+                    serializedVars
+                ]);
+            });
+        }
+    });
+export { pluginGlobalVars };

package/dist/esm/plugins/htmlMinify.mjs

@@ -0,0 +1,81 @@
+import { merge } from "ts-deepmerge";
+function applyRemoveConsole(options, config) {
+    const { removeConsole } = config.performance;
+    const compressOptions = 'boolean' == typeof options.compress ? {} : options.compress || {};
+    if (true === removeConsole) options.compress = {
+        ...compressOptions,
+        drop_console: true
+    };
+    else if (Array.isArray(removeConsole)) {
+        const pureFuncs = removeConsole.map((method)=>`console.${method}`);
+        options.compress = {
+            ...compressOptions,
+            pure_funcs: pureFuncs
+        };
+    }
+    return options;
+}
+function getTerserMinifyOptions(config) {
+    const options = {
+        mangle: {
+            safari10: true
+        },
+        format: {
+            ascii_only: 'ascii' === config.output.charset
+        }
+    };
+    if ('none' === config.output.legalComments) {
+        options.format ||= {};
+        options.format.comments = false;
+    }
+    const finalOptions = applyRemoveConsole(options, config);
+    return finalOptions;
+}
+function getMinifyOptions(config) {
+    const minifyJS = getTerserMinifyOptions(config);
+    return {
+        removeComments: false,
+        useShortDoctype: true,
+        keepClosingSlash: true,
+        collapseWhitespace: true,
+        removeRedundantAttributes: true,
+        removeScriptTypeAttributes: true,
+        removeStyleLinkTypeAttributes: true,
+        removeEmptyAttributes: true,
+        minifyJS,
+        minifyCSS: true,
+        minifyURLs: true
+    };
+}
+const pluginHtmlMinifierTerser = ()=>({
+        name: 'builder:plugin-html-minifier-terser',
+        setup (api) {
+            api.modifyBundlerChain(async (chain, { isProd, environment })=>{
+                const { output, tools: { htmlPlugin } } = environment.config;
+                const disableHtmlMinify = !isProd || false === output.minify || false === htmlPlugin;
+                const { minify } = await import("html-minifier-terser");
+                const pluginRecord = chain.plugins.entries();
+                const minifyOptions = getMinifyOptions(environment.config);
+                for (const id of Object.keys(pluginRecord)){
+                    if (!id.startsWith('html-')) continue;
+                    const values = pluginRecord[id].values();
+                    const isHtmlRspackPlugin = values.some((item)=>{
+                        const name = item?.name || item.constructor?.name;
+                        return 'HtmlRspackPlugin' === name;
+                    });
+                    if (isHtmlRspackPlugin && !disableHtmlMinify) {
+                        chain.plugin(id).tap((options)=>{
+                            if (!options.length) return options;
+                            const userMinifyOption = options[0].minify;
+                            if (false === userMinifyOption) return options;
+                            const minifyFn = (html)=>minify(html, userMinifyOption ? merge(minifyOptions, userMinifyOption) : minifyOptions);
+                            options[0].minify = minifyFn;
+                            return options;
+                        });
+                        continue;
+                    }
+                }
+            });
+        }
+    });
+export { pluginHtmlMinifierTerser };

package/dist/esm/plugins/manifest.mjs

@@ -0,0 +1,18 @@
+import { generateManifest } from "../shared/manifest.mjs";
+const pluginManifest = ()=>({
+        name: 'builder:manifest',
+        setup (api) {
+            api.modifyBundlerChain(async (chain, { target, CHAIN_ID })=>{
+                const { RspackManifestPlugin } = await import("rspack-manifest-plugin");
+                const publicPath = chain.output.get('publicPath');
+                chain.plugin(CHAIN_ID.PLUGIN.MANIFEST).use(RspackManifestPlugin, [
+                    {
+                        fileName: 'web' === target ? 'asset-manifest.json' : `asset-manifest-${target}.json`,
+                        publicPath,
+                        generate: generateManifest
+                    }
+                ]);
+            });
+        }
+    });
+export { pluginManifest };

package/dist/esm/plugins/postcss.mjs

@@ -0,0 +1,81 @@
+import { createRequire } from "node:module";
+import { pathToFileURL } from "node:url";
+import { applyOptionsChain, isProd } from "@modern-js/utils";
+import { getCssSupport } from "../shared/getCssSupport.mjs";
+const postcss_require = createRequire(import.meta.url);
+const importPostcssPlugin = (name)=>Promise.resolve(postcss_require(name));
+const userPostcssrcCache = new Map();
+const clonePostCSSConfig = (config)=>({
+        ...config,
+        plugins: config.plugins ? [
+            ...config.plugins
+        ] : void 0
+    });
+async function loadUserPostcssrc(root) {
+    const cached = userPostcssrcCache.get(root);
+    if (cached) return clonePostCSSConfig(await cached);
+    const compiledPath = postcss_require.resolve('../../compiled/postcss-load-config');
+    const { default: postcssrc } = await import(pathToFileURL(compiledPath).href);
+    const promise = postcssrc({}, root).catch((err)=>{
+        if (err.message?.includes('No PostCSS Config found')) return {};
+        throw err;
+    });
+    userPostcssrcCache.set(root, promise);
+    return promise.then((config)=>{
+        userPostcssrcCache.set(root, config);
+        return clonePostCSSConfig(config);
+    });
+}
+const pluginPostcss = (options = {})=>({
+        name: 'builder:postcss-plugins',
+        pre: [
+            'builder:environment-defaults-plugin'
+        ],
+        setup (api) {
+            const { autoprefixer } = options;
+            api.modifyEnvironmentConfig(async (config, { mergeEnvironmentConfig })=>{
+                if ('web' !== config.output.target) return config;
+                const cssSupport = getCssSupport(config.output.overrideBrowserslist);
+                const enableExtractCSS = !config.output?.injectStyles;
+                const enableCssMinify = !enableExtractCSS && isProd();
+                const cssnanoOptions = {
+                    preset: [
+                        'default',
+                        {
+                            mergeLonghand: false,
+                            normalizeUrl: false
+                        }
+                    ]
+                };
+                const plugins = await Promise.all([
+                    importPostcssPlugin('postcss-flexbugs-fixes'),
+                    !cssSupport.customProperties && importPostcssPlugin('postcss-custom-properties'),
+                    !cssSupport.initial && importPostcssPlugin('postcss-initial'),
+                    !cssSupport.pageBreak && importPostcssPlugin('postcss-page-break'),
+                    !cssSupport.fontVariant && importPostcssPlugin('postcss-font-variant'),
+                    !cssSupport.mediaMinmax && importPostcssPlugin('postcss-media-minmax'),
+                    importPostcssPlugin('postcss-nesting'),
+                    enableCssMinify && importPostcssPlugin('cssnano').then((cssnano)=>cssnano(cssnanoOptions)),
+                    importPostcssPlugin('autoprefixer').then((autoprefixerPlugin)=>autoprefixerPlugin(applyOptionsChain({
+                            flexbox: 'no-2009',
+                            overrideBrowserslist: config.output.overrideBrowserslist
+                        }, autoprefixer)))
+                ]).then((results)=>results.filter(Boolean));
+                const userOptions = await loadUserPostcssrc(api.context.rootPath);
+                return mergeEnvironmentConfig({
+                    tools: {
+                        postcss: {
+                            postcssOptions: {
+                                ...userOptions,
+                                plugins: [
+                                    ...userOptions.plugins || [],
+                                    ...plugins
+                                ]
+                            }
+                        }
+                    }
+                }, config);
+            });
+        }
+    });
+export { pluginPostcss };

package/dist/esm/plugins/runtimeChunk.mjs

@@ -0,0 +1,20 @@
+import { RUNTIME_CHUNK_NAME, RUNTIME_CHUNK_REGEX } from "../shared/utils.mjs";
+const pluginRuntimeChunk = (disableInlineRuntimeChunk)=>({
+        name: 'builder:runtime-chunk',
+        setup (api) {
+            api.modifyBundlerChain(async (chain, { target, environment })=>{
+                if ('web' !== target) return;
+                const { config } = environment;
+                const { chunkSplit } = config.performance;
+                if (chunkSplit?.strategy !== 'all-in-one' && false !== config.splitChunks) chain.optimization.runtimeChunk({
+                    name: RUNTIME_CHUNK_NAME
+                });
+            });
+            api.modifyRsbuildConfig((config)=>{
+                config.output ||= {};
+                if (disableInlineRuntimeChunk) return;
+                if (!config.output.inlineScripts) config.output.inlineScripts = RUNTIME_CHUNK_REGEX;
+            });
+        }
+    });
+export { pluginRuntimeChunk };

package/dist/esm/rsc/common.mjs

@@ -0,0 +1,87 @@
+import { logger } from "@modern-js/utils";
+import { parse } from "@swc/core";
+const rspackRscLayerName = "react-server";
+const MODERN_RSC_INFO = 'modernRscInfo';
+const sharedData = {
+    store: new Map(),
+    get (key) {
+        return this.store.get(key);
+    },
+    set (key, value) {
+        this.store.set(key, value);
+    },
+    clear () {
+        this.store.clear();
+    }
+};
+function setBuildInfo(mod, property) {
+    if (!mod.buildInfo) mod.buildInfo = {};
+    Object.assign(mod.buildInfo, property);
+}
+function setRscBuildInfo(mod, property) {
+    if (!mod.buildInfo) mod.buildInfo = {};
+    const rscBuildInfo = mod.buildInfo[MODERN_RSC_INFO] || {};
+    Object.assign(rscBuildInfo, property);
+    setBuildInfo(mod, {
+        [MODERN_RSC_INFO]: rscBuildInfo
+    });
+}
+function removeRscBuildInfo(mod) {
+    delete mod.buildInfo?.[MODERN_RSC_INFO];
+}
+function getRscBuildInfo(mod) {
+    return mod.buildInfo?.[MODERN_RSC_INFO];
+}
+function isCssModule(mod) {
+    if (!mod) return false;
+    return getRscBuildInfo(mod)?.isCssModule;
+}
+const parseSource = async (source)=>await parse(source, {
+        syntax: "typescript",
+        tsx: true,
+        dynamicImport: true
+    });
+const getExportNames = async (ast, collectFuncOnly = false)=>{
+    const exportNames = [];
+    ast.body.forEach((node)=>{
+        if ('ExportNamedDeclaration' === node.type) {
+            const namedExport = node;
+            namedExport.specifiers.forEach((specifier)=>{
+                if ('ExportSpecifier' === specifier.type) exportNames.push(specifier.exported?.value || specifier.orig.value);
+            });
+        }
+        if ('ExportDeclaration' === node.type) {
+            if ('VariableDeclaration' === node.declaration.type) node.declaration.declarations.forEach((decl)=>{
+                if ('Identifier' === decl.id.type) if (collectFuncOnly) {
+                    if (decl.init?.type === 'FunctionExpression' || decl.init?.type === 'ArrowFunctionExpression') exportNames.push(decl.id.value);
+                } else exportNames.push(decl.id.value);
+            });
+            if ('ClassDeclaration' === node.declaration.type || 'FunctionDeclaration' === node.declaration.type) {
+                if (node.declaration.identifier) exportNames.push(node.declaration.identifier.value);
+            }
+        }
+        if ('ExportDefaultExpression' === node.type || 'ExportDefaultDeclaration' === node.type) exportNames.push('default');
+    });
+    return exportNames;
+};
+const checkDirective = async (ast, directive)=>{
+    try {
+        for(let i = 0; i < ast.body.length; i++){
+            const node = ast.body[i];
+            if ('ExpressionStatement' !== node.type) break;
+            if ('StringLiteral' === node.expression.type && node.expression.value === directive) return true;
+        }
+    } catch (e) {
+        logger.error(e);
+    }
+    return false;
+};
+const isServerModule = async (ast)=>checkDirective(ast, 'use server');
+const isClientModule = async (ast)=>checkDirective(ast, 'use client');
+function findRootIssuer(modulegraph, module) {
+    const currentModule = module;
+    const issuer = modulegraph.getIssuer(currentModule);
+    if (!issuer) return currentModule;
+    return findRootIssuer(modulegraph, issuer);
+}
+export { MODERN_RSC_INFO, findRootIssuer, getExportNames, getRscBuildInfo, isClientModule, isCssModule, isServerModule, parseSource, removeRscBuildInfo, rspackRscLayerName, setBuildInfo, setRscBuildInfo, sharedData };

package/dist/esm/rsc/plugins/rsbuild-rsc-plugin.mjs

@@ -0,0 +1,124 @@
+import node_path from "node:path";
+import fs_extra from "@modern-js/utils/fs-extra";
+import { logger } from "@rsbuild/core";
+import { rspackRscLayerName } from "../common.mjs";
+import { RspackRscClientPlugin } from "./rspack-rsc-client-plugin.mjs";
+import { RscServerPlugin } from "./rspack-rsc-server-plugin.mjs";
+const CSS_RULE_NAMES = [
+    'less',
+    'css',
+    'scss',
+    'sass'
+];
+const createVirtualModule = (content)=>`data:text/javascript,${encodeURIComponent(content)}`;
+const checkReactVersionAtLeast19 = async (appDir)=>{
+    const packageJsonPath = node_path.resolve(appDir, 'package.json');
+    const packageJson = await fs_extra.readJSON(packageJsonPath);
+    if (!packageJson.dependencies) return false;
+    const { dependencies } = packageJson;
+    const reactVersion = dependencies.react;
+    const reactDomVersion = dependencies['react-dom'];
+    if (!reactVersion || !reactDomVersion) return false;
+    const cleanVersion = (version)=>version.replace(/[\^~]/g, '');
+    const reactVersionParts = cleanVersion(reactVersion).split('.');
+    const reactDomVersionParts = cleanVersion(reactDomVersion).split('.');
+    const reactMajor = parseInt(reactVersionParts[0], 10);
+    const reactDomMajor = parseInt(reactDomVersionParts[0], 10);
+    if (Number.isNaN(reactMajor) || Number.isNaN(reactDomMajor)) return false;
+    return reactMajor >= 19 && reactDomMajor >= 19;
+};
+const rsbuildRscPlugin = ({ appDir, rscClientRuntimePath, rscServerRuntimePath, internalDirectory })=>({
+        name: 'builder:rsc-rsbuild-plugin',
+        setup (api) {
+            api.modifyBundlerChain({
+                handler: async (chain, { isServer, CHAIN_ID, isWebWorker })=>{
+                    if (!await checkReactVersionAtLeast19(appDir)) {
+                        logger.error('Enable react server component, please make sure the react and react-dom versions are greater than or equal to 19.0.0');
+                        process.exit(1);
+                    }
+                    const entryPath2Name = new Map();
+                    for (const [name, entry] of Object.entries(chain.entryPoints.entries()))entry.values().forEach((value)=>{
+                        entryPath2Name.set(value, name);
+                    });
+                    const jsHandler = ()=>{
+                        const originalJsRule = chain.module.rules.get(CHAIN_ID.RULE.JS);
+                        if (!originalJsRule) throw new Error('Original JS rule not found when setup RSC plugin.');
+                        const originalJsMainRule = originalJsRule.oneOfs.get(CHAIN_ID.ONE_OF.JS_MAIN);
+                        if (!originalJsMainRule) throw new Error('Original JS main rule not found when setup RSC plugin.');
+                        const useBabel = originalJsMainRule.uses.has(CHAIN_ID.USE.BABEL);
+                        const jsLoader = useBabel ? CHAIN_ID.USE.BABEL : CHAIN_ID.USE.SWC;
+                        const jsLoaderOptions = originalJsMainRule.use(jsLoader).get('options');
+                        const jsLoaderPath = originalJsMainRule.use(jsLoader).get('loader');
+                        originalJsRule.oneOfs.delete(CHAIN_ID.ONE_OF.JS_MAIN);
+                        chain.module.rule(CHAIN_ID.RULE.JS).oneOf('rsc-server').issuerLayer(rspackRscLayerName).exclude.add(/universal[/\\]async_storage/).end().use('rsc-server-loader').loader(require.resolve('../rsc-server-loader')).options({
+                            entryPath2Name,
+                            appDir,
+                            runtimePath: rscServerRuntimePath,
+                            internalDirectory
+                        }).end().use(jsLoader).loader(jsLoaderPath).options(jsLoaderOptions).end().end().oneOf('rsc-ssr').exclude.add(/universal[/\\]async_storage/).end().use('rsc-ssr-loader').loader(require.resolve('../rsc-ssr-loader')).options({
+                            entryPath2Name,
+                            internalDirectory
+                        }).end().use(jsLoader).loader(jsLoaderPath).options(jsLoaderOptions).end().end();
+                    };
+                    const layerHandler = ()=>{
+                        const routesFileReg = new RegExp(`${internalDirectory.replace(/[/\\]/g, '[/\\\\]')}[/\\\\][^/\\\\]*[/\\\\]routes`);
+                        chain.module.rule('server-module').resource([
+                            /render[/\\].*[/\\]server[/\\]rsc/,
+                            /AppProxy/,
+                            routesFileReg
+                        ]).layer(rspackRscLayerName).end();
+                        chain.module.rule(rspackRscLayerName).issuerLayer(rspackRscLayerName).resolve.conditionNames.add(rspackRscLayerName).add('...');
+                        chain.module.rule('rsc-common').resource([
+                            /universal[/\\]async_storage/
+                        ]).layer('rsc-common');
+                    };
+                    const flightCssHandler = ()=>{
+                        CSS_RULE_NAMES.forEach((ruleName)=>{
+                            const rule = chain.module.rules.get(ruleName);
+                            if (rule) chain.module.rule(ruleName).use('custom-loader').before('ignore-css').loader(require.resolve('../rsc-css-loader'));
+                        });
+                    };
+                    const addServerRscPlugin = ()=>{
+                        const ServerPlugin = RscServerPlugin;
+                        chain.plugin('rsc-server-plugin').use(ServerPlugin, [
+                            {
+                                entryPath2Name
+                            }
+                        ]);
+                    };
+                    const addRscClientLoader = ()=>{
+                        chain.module.rule('js').use('rsc-client-loader').loader(require.resolve('../rsc-client-loader')).before('babel').options({
+                            callServerImport: rscClientRuntimePath,
+                            registerImport: rscClientRuntimePath
+                        }).end();
+                    };
+                    const addRscClientPlugin = ()=>{
+                        const ClientPlugin = RspackRscClientPlugin;
+                        chain.plugin('rsc-client-plugin').use(ClientPlugin);
+                    };
+                    if (isServer) {
+                        chain.name('server');
+                        layerHandler();
+                        flightCssHandler();
+                        jsHandler();
+                        addServerRscPlugin();
+                    } else if (!isWebWorker) {
+                        chain.name('client');
+                        chain.dependencies([
+                            'server'
+                        ]);
+                        const entries = chain.entryPoints.entries();
+                        for (const entryName of Object.keys(entries)){
+                            const entryPoint = chain.entry(entryName);
+                            const code = `window.__MODERN_JS_ENTRY_NAME="${entryName}";`;
+                            entryPoint.add(createVirtualModule(code));
+                        }
+                        addRscClientLoader();
+                        addRscClientPlugin();
+                    }
+                },
+                order: 'post'
+            });
+        }
+    });
+export { rsbuildRscPlugin };