@bleedingdev/modern-js-builder 3.2.0-ultramodern.0

package/dist/esm-node/plugins/postcss.mjs

@@ -0,0 +1,116 @@
+import "node:module";
+import { createRequire } from "node:module";
+import node_path from "node:path";
+import { pathToFileURL } from "node:url";
+import { applyOptionsChain, isProd } from "@modern-js/utils";
+import { logger } from "@rsbuild/core";
+import { getCssSupport } from "../shared/getCssSupport.mjs";
+const builderRequire = createRequire(import.meta.url);
+const createRootRequire = (rootPath)=>createRequire(pathToFileURL(node_path.join(rootPath, 'package.json')).href);
+const loadByResolver = (resolveWith, name)=>{
+    try {
+        return resolveWith(name);
+    } catch (error) {
+        const resolved = resolveWith.resolve(name);
+        return resolveWith(resolved);
+    }
+};
+const loadPostcssPlugin = (name, appRootPath)=>{
+    const resolvers = [
+        builderRequire,
+        createRootRequire(appRootPath),
+        createRootRequire(process.cwd())
+    ];
+    let firstError = null;
+    for (const resolveWith of resolvers)try {
+        return loadByResolver(resolveWith, name);
+    } catch (error) {
+        firstError ??= error;
+    }
+    throw firstError;
+};
+const importPostcssPlugin = (name, appRootPath)=>Promise.resolve(loadPostcssPlugin(name, appRootPath));
+const clonePostCSSConfig = (config)=>({
+        ...config,
+        plugins: config.plugins ? [
+            ...config.plugins
+        ] : void 0
+    });
+const postcssLoadConfig = builderRequire('postcss-load-config');
+const userPostcssrcCache = new Map();
+const loadUserPostcssrc = async (root)=>{
+    const cached = userPostcssrcCache.get(root);
+    if (cached) return clonePostCSSConfig(await cached);
+    const promise = postcssLoadConfig({}, 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', api.context.rootPath),
+                    !cssSupport.customProperties && importPostcssPlugin('postcss-custom-properties', api.context.rootPath),
+                    !cssSupport.initial && importPostcssPlugin('postcss-initial', api.context.rootPath),
+                    !cssSupport.pageBreak && importPostcssPlugin('postcss-page-break', api.context.rootPath),
+                    !cssSupport.fontVariant && importPostcssPlugin('postcss-font-variant', api.context.rootPath),
+                    !cssSupport.mediaMinmax && importPostcssPlugin('postcss-media-minmax', api.context.rootPath),
+                    importPostcssPlugin('postcss-nesting', api.context.rootPath),
+                    enableCssMinify && importPostcssPlugin('cssnano', api.context.rootPath).then((cssnano)=>cssnano(cssnanoOptions)),
+                    importPostcssPlugin('autoprefixer', api.context.rootPath).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: (opts)=>{
+                            if ('function' == typeof opts.postcssOptions) {
+                                logger.warn('unexpected function type postcssOptions, the default postcss plugins will not be applied.');
+                                return opts;
+                            }
+                            const existingOptions = opts.postcssOptions ?? {};
+                            const mergedOptions = {
+                                ...userOptions,
+                                ...existingOptions
+                            };
+                            const userPlugins = userOptions.plugins ?? [];
+                            const existingPlugins = existingOptions.plugins ?? [];
+                            mergedOptions.plugins = [
+                                ...userPlugins,
+                                ...existingPlugins,
+                                ...plugins
+                            ];
+                            opts.postcssOptions = mergedOptions;
+                        }
+                    }
+                }, config);
+            });
+        }
+    });
+export { pluginPostcss };

package/dist/esm-node/plugins/rscConfig.mjs

@@ -0,0 +1,117 @@
+import __rslib_shim_module__ from "node:module";
+const require = /*#__PURE__*/ __rslib_shim_module__.createRequire(/*#__PURE__*/ (()=>import.meta.url)());
+import path from "path";
+import { fileURLToPath as __rspack_fileURLToPath } from "node:url";
+import { dirname as __rspack_dirname } from "node:path";
+var rscConfig_dirname = __rspack_dirname(__rspack_fileURLToPath(import.meta.url));
+const ASYNC_STORAGE_PATTERN = /universal[/\\]async_storage/;
+const RSC_COMMON_LAYER = 'rsc-common';
+const ENTRY_NAME_VAR = '__MODERN_JS_ENTRY_NAME';
+const createVirtualModule = (content)=>`data:text/javascript,${encodeURIComponent(content)}`;
+const isAsyncStorageExclude = (exclude)=>{
+    if ('string' == typeof exclude) return ASYNC_STORAGE_PATTERN.test(exclude);
+    if (exclude instanceof RegExp) return exclude.test('universal/async_storage') || exclude.test('universal\\async_storage');
+    return false;
+};
+function pluginRscConfig() {
+    return {
+        name: 'builder:rsc-config',
+        setup (api) {
+            let layersCache = null;
+            const getLayers = async ()=>{
+                if (!layersCache) {
+                    const { Layers } = await import("rsbuild-plugin-rsc");
+                    layersCache = Layers;
+                }
+                return layersCache;
+            };
+            api.modifyBundlerChain({
+                handler: (chain, { isServer })=>{
+                    if (isServer) {
+                        const routeFilePattern = /[/\\]routes[/\\](?:.*[/\\])?(?:layout|page|\$)\.[tj]sx?$/;
+                        const appFilePattern = /[/\\]App\.[tj]sx?$/;
+                        const combinedPattern = new RegExp(`(${routeFilePattern.source}|${appFilePattern.source})`);
+                        let loaderPath;
+                        try {
+                            loaderPath = require.resolve('../shared/rsc/rsc-server-entry-loader');
+                        } catch  {
+                            loaderPath = path.resolve(rscConfig_dirname, '../shared/rsc/rsc-server-entry-loader');
+                        }
+                        chain.module.rule('rsc-server-entry').test(/\.(tsx?|jsx?)$/).resource(combinedPattern).exclude.add(/node_modules/).end().use('rsc-server-entry-loader').loader(loaderPath).end();
+                    }
+                },
+                order: 'pre'
+            });
+            api.modifyRspackConfig(async (config, utils)=>{
+                const isServer = 'node' === config.target || 'node' === utils.target || utils.environment?.name === 'server';
+                if (!isServer) return;
+                const Layers = await getLayers();
+                if (config.entry) {
+                    const entries = config.entry;
+                    const newEntries = {};
+                    for (const [entryName, entryValue] of Object.entries(entries))if ('string' == typeof entryValue) newEntries[entryName] = {
+                        import: entryValue,
+                        layer: Layers.ssr
+                    };
+                    else if (Array.isArray(entryValue)) newEntries[entryName] = {
+                        import: entryValue,
+                        layer: Layers.ssr
+                    };
+                    else if ('object' == typeof entryValue && null !== entryValue) newEntries[entryName] = {
+                        ...entryValue,
+                        layer: Layers.ssr
+                    };
+                    else newEntries[entryName] = entryValue;
+                    config.entry = newEntries;
+                }
+                if (config.module?.rules) {
+                    const rules = config.module.rules;
+                    for (const rule of rules)if (rule.layer === Layers.rsc) {
+                        if (rule.exclude) {
+                            if (!Array.isArray(rule.exclude)) rule.exclude = [
+                                rule.exclude
+                            ];
+                        } else rule.exclude = [];
+                        const hasExclude = rule.exclude.some(isAsyncStorageExclude);
+                        if (!hasExclude) rule.exclude.push(ASYNC_STORAGE_PATTERN);
+                    }
+                    if (!Array.isArray(config.module.rules)) config.module.rules = [];
+                    config.module.rules.push({
+                        resource: ASYNC_STORAGE_PATTERN,
+                        layer: RSC_COMMON_LAYER
+                    });
+                }
+            });
+            api.modifyBundlerChain((chain, { isServer, isWebWorker })=>{
+                if (!isServer && !isWebWorker) {
+                    const entries = chain.entryPoints.entries();
+                    if (entries && 'object' == typeof entries) for (const entryName of Object.keys(entries)){
+                        const entryPoint = chain.entry(entryName);
+                        const code = `window.${ENTRY_NAME_VAR}="${entryName}";`;
+                        entryPoint.add(createVirtualModule(code));
+                    }
+                }
+            });
+        }
+    };
+}
+async function getRscPlugins(enableRsc, internalDirectory) {
+    if (enableRsc) {
+        const routesFileReg = new RegExp(`${internalDirectory.replace(/[/\\]/g, '[/\\\\]')}[/\\\\][^/\\\\]*[/\\\\]routes`);
+        const { pluginRSC } = await import("rsbuild-plugin-rsc");
+        return [
+            pluginRSC({
+                layers: {
+                    rsc: [
+                        /render[/\\].*[/\\]server[/\\]rsc/,
+                        /AppProxy/,
+                        routesFileReg
+                    ]
+                }
+            }),
+            pluginRscConfig()
+        ];
+    }
+    return [];
+}
+export { getRscPlugins, pluginRscConfig };

package/dist/esm-node/plugins/rsdoctor.mjs

@@ -0,0 +1,31 @@
+import "node:module";
+const isRsdoctorEnabled = (config)=>{
+    if (void 0 === config) return false;
+    if ('boolean' == typeof config) return config;
+    if ('boolean' == typeof config?.enabled) return config.enabled;
+    return true;
+};
+const getRsdoctorPluginOptions = (config)=>{
+    if (config && 'object' == typeof config) return {
+        disableClientServer: config.disableClientServer ?? true
+    };
+    return {
+        disableClientServer: true
+    };
+};
+const pluginRsdoctor = (config)=>{
+    if (!isRsdoctorEnabled(config)) return null;
+    const pluginOptions = getRsdoctorPluginOptions(config);
+    return {
+        name: 'builder:rsdoctor',
+        setup (api) {
+            api.modifyBundlerChain(async (chain)=>{
+                const { RsdoctorRspackPlugin } = await import("@rsdoctor/rspack-plugin");
+                chain.plugin('rsdoctor').use(RsdoctorRspackPlugin, [
+                    pluginOptions
+                ]);
+            });
+        }
+    };
+};
+export { pluginRsdoctor };

package/dist/esm-node/plugins/runtimeChunk.mjs

@@ -0,0 +1,22 @@
+import "node:module";
+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;
+                const originalConfig = api.getRsbuildConfig('original');
+                if (originalConfig.output?.inlineScripts === void 0) config.output.inlineScripts = RUNTIME_CHUNK_REGEX;
+            });
+        }
+    });
+export { pluginRuntimeChunk };

package/dist/esm-node/shared/devServer.mjs

@@ -0,0 +1,54 @@
+import "node:module";
+import { applyOptionsChain, isProd } from "@modern-js/utils";
+import { merge } from "ts-deepmerge";
+const defaultDevConfig = {
+    writeToDisk: (file)=>!file.includes('.hot-update.'),
+    hmr: true,
+    liveReload: true,
+    progressBar: true,
+    client: {
+        path: '/webpack-hmr',
+        overlay: false,
+        port: '<port>'
+    }
+};
+const transformToRsbuildServerOptions = (dev, devServer, server)=>{
+    const { host = '0.0.0.0', https, startUrl, beforeStartUrl, server: devServerConfig, ...devConfig } = dev;
+    const port = process.env.PORT ? Number(process.env.PORT) : server?.port ?? 8080;
+    const rsbuildDev = merge(defaultDevConfig, devConfig);
+    delete rsbuildDev.setupMiddlewares;
+    const legacyServerConfig = applyOptionsChain({}, devServer, {}, merge);
+    const serverCofig = {
+        compress: devServerConfig?.compress ?? legacyServerConfig.compress,
+        headers: devServerConfig?.headers ?? legacyServerConfig.headers,
+        historyApiFallback: devServerConfig?.historyApiFallback ?? legacyServerConfig.historyApiFallback,
+        proxy: devServerConfig?.proxy ?? legacyServerConfig.proxy
+    };
+    const rsbuildServer = isProd() ? {
+        publicDir: false,
+        htmlFallback: false,
+        printUrls: false
+    } : {
+        publicDir: false,
+        htmlFallback: false,
+        printUrls: false,
+        compress: serverCofig.compress,
+        headers: serverCofig.headers,
+        historyApiFallback: serverCofig.historyApiFallback,
+        proxy: serverCofig.proxy,
+        host,
+        port,
+        https: https ? https : void 0,
+        middlewareMode: true,
+        cors: server?.cors
+    };
+    if (!isProd() && startUrl) rsbuildServer.open = beforeStartUrl ? {
+        target: true === startUrl ? '//localhost:<port>' : startUrl,
+        before: beforeStartUrl
+    } : startUrl;
+    return {
+        rsbuildDev,
+        rsbuildServer
+    };
+};
+export { transformToRsbuildServerOptions };

package/dist/esm-node/shared/getCssSupport.mjs

@@ -0,0 +1,78 @@
+import "node:module";
+import browserslist from "browserslist";
+const CSS_FEATURES_BROWSER = {
+    customProperties: {
+        and_chr: '49',
+        and_ff: '31',
+        android: '50',
+        chrome: '49',
+        edge: '15',
+        firefox: '31',
+        ios_saf: '9.3',
+        op_mob: '36',
+        opera: '36',
+        safari: '9.1',
+        samsung: '5.0'
+    },
+    initial: {
+        and_chr: '37',
+        and_ff: '27',
+        android: '37',
+        chrome: '37',
+        edge: '79',
+        firefox: '27',
+        ios_saf: '9.3',
+        op_mob: '24',
+        opera: '24',
+        safari: '9.1',
+        samsung: '3.0'
+    },
+    pageBreak: {
+        and_chr: '51',
+        and_ff: '92',
+        android: '51',
+        chrome: '51',
+        edge: '12',
+        firefox: '92',
+        ios_saf: '10',
+        op_mob: '37',
+        opera: '11.1',
+        safari: '10',
+        samsung: '5.0'
+    },
+    fontVariant: {
+        and_chr: '18',
+        and_ff: '34',
+        android: '4.4',
+        chrome: '1',
+        edge: '12',
+        firefox: '34',
+        ios_saf: '9.3',
+        op_mob: '12',
+        opera: '10',
+        safari: '9.1',
+        samsung: '1.0'
+    },
+    mediaMinmax: {
+        and_chr: '104',
+        and_ff: '109',
+        android: '104',
+        chrome: '104',
+        edge: '104',
+        firefox: '63',
+        opera: '91'
+    }
+};
+const getCssFeatureBrowsers = (feature)=>{
+    const featureBrowsers = CSS_FEATURES_BROWSER[feature];
+    return browserslist(Object.entries(featureBrowsers).map(([key, value])=>`${key} >= ${value}`));
+};
+const isFeatureSupported = (projectBrowsers, featureBrowsers)=>projectBrowsers.every((item)=>featureBrowsers.includes(item));
+function getCssSupport(projectBrowserslist) {
+    const projectBrowsers = browserslist(projectBrowserslist);
+    return Object.keys(CSS_FEATURES_BROWSER).reduce((acc, key)=>{
+        acc[key] = isFeatureSupported(projectBrowsers, getCssFeatureBrowsers(key));
+        return acc;
+    }, {});
+}
+export { getCssSupport };

package/dist/esm-node/shared/manifest.mjs

@@ -0,0 +1,13 @@
+import "node:module";
+const generateManifest = (seed, files, entries)=>{
+    const manifestFiles = files.reduce((manifest, file)=>{
+        manifest[file.name] = file.path;
+        return manifest;
+    }, seed);
+    const entrypointFiles = Object.keys(entries).reduce((previous, name)=>previous.concat(entries[name].filter((fileName)=>!fileName.endsWith('.map'))), []);
+    return {
+        files: manifestFiles,
+        entrypoints: entrypointFiles
+    };
+};
+export { generateManifest };

package/dist/esm-node/shared/parseCommonConfig.mjs

@@ -0,0 +1,174 @@
+import "node:module";
+import { mergeRsbuildConfig } from "@rsbuild/core";
+import { pluginCssMinimizer } from "@rsbuild/plugin-css-minimizer";
+import { pluginLess } from "@rsbuild/plugin-less";
+import { pluginReact } from "@rsbuild/plugin-react";
+import { pluginSass } from "@rsbuild/plugin-sass";
+import { pluginDevtool } from "../plugins/devtools.mjs";
+import { pluginEmitRouteFile } from "../plugins/emitRouteFile.mjs";
+import { pluginEnvironmentDefaults } from "../plugins/environmentDefaults.mjs";
+import { pluginGlobalVars } from "../plugins/globalVars.mjs";
+import { pluginHtmlMinifierTerser } from "../plugins/htmlMinify.mjs";
+import { pluginRuntimeChunk } from "../plugins/runtimeChunk.mjs";
+import { transformToRsbuildServerOptions } from "./devServer.mjs";
+import { NODE_MODULES_REGEX } from "./utils.mjs";
+const CSS_MODULES_REGEX = /\.modules?\.\w+$/i;
+const GLOBAL_CSS_REGEX = /\.global\.\w+$/;
+const isLooseCssModules = (path)=>{
+    if (NODE_MODULES_REGEX.test(path)) return CSS_MODULES_REGEX.test(path);
+    return !GLOBAL_CSS_REGEX.test(path);
+};
+function removeUndefinedKey(obj) {
+    Object.keys(obj).forEach((key)=>{
+        if (void 0 === obj[key]) delete obj[key];
+    });
+    return obj;
+}
+async function parseCommonConfig(builderConfig, options) {
+    const frameworkConfigPath = options?.frameworkConfigPath;
+    const { plugins: [...plugins] = [], splitChunks, performance: { rsdoctor: rsdoctorConfig, ...performanceConfig } = {}, output: { module = false, enableCssModuleTSDeclaration, disableCssModuleExtension, disableTsChecker, disableSvgr, svgDefaultExport, assetsRetry, enableAssetManifest, sourceMap, convertToRem, polyfill, dataUriLimit = 10000, distPath = {}, ...outputConfig } = {}, html: { outputStructure, appIcon, ...htmlConfig } = {}, source: { alias, globalVars, transformImport, ...sourceConfig } = {}, dev = {}, server = {}, security: { checkSyntax, sri, ...securityConfig } = {}, tools: { devServer, tsChecker, minifyCss, less, sass, htmlPlugin, autoprefixer, ...toolsConfig } = {}, environments = {}, resolve = {} } = builderConfig;
+    let combinedAlias;
+    if (alias || resolve.alias) combinedAlias = [].concat(alias ?? []).concat(resolve.alias ?? []);
+    const rsbuildConfig = {
+        plugins,
+        splitChunks,
+        output: {
+            polyfill: 'ua' === polyfill ? 'off' : polyfill,
+            dataUriLimit,
+            sourceMap,
+            module,
+            ...outputConfig
+        },
+        resolve: {
+            ...resolve,
+            alias: combinedAlias
+        },
+        source: sourceConfig,
+        performance: performanceConfig,
+        html: htmlConfig,
+        tools: toolsConfig,
+        security: securityConfig,
+        environments
+    };
+    rsbuildConfig.tools.htmlPlugin = htmlPlugin;
+    rsbuildConfig.tools.lightningcssLoader ??= false;
+    const { html = {}, output = {}, source = {} } = rsbuildConfig;
+    source.transformImport = false === transformImport ? ()=>[] : transformImport;
+    if (!source.decorators) source.decorators = {
+        version: 'legacy'
+    };
+    output.charset ??= 'ascii';
+    if ('boolean' != typeof output.sourceMap) {
+        output.sourceMap ||= {};
+        output.sourceMap.css ??= 'production' !== process.env.NODE_ENV;
+    }
+    const { server: _server, worker, ...rsbuildDistPath } = distPath;
+    output.distPath = rsbuildDistPath;
+    output.distPath.html ??= 'html';
+    output.polyfill ??= 'entry';
+    if (disableCssModuleExtension) {
+        output.cssModules ||= {};
+        output.cssModules.auto ??= isLooseCssModules;
+    }
+    const extraConfig = {};
+    extraConfig.html ||= {};
+    extraConfig.html.outputStructure = outputStructure ?? 'nested';
+    html.title ??= '';
+    html.appIcon = appIcon;
+    extraConfig.tools ??= {};
+    if (false !== htmlPlugin) extraConfig.tools.htmlPlugin = (config)=>{
+        if ('function' == typeof config.templateParameters) {
+            const originFn = config.templateParameters;
+            config.templateParameters = (...args)=>{
+                const res = originFn(...args);
+                return {
+                    title: config.title,
+                    meta: void 0,
+                    ...res
+                };
+            };
+        }
+    };
+    if (!dev.lazyCompilation) dev.lazyCompilation = false;
+    const { rsbuildDev, rsbuildServer } = transformToRsbuildServerOptions(dev || {}, devServer || {}, server || {});
+    rsbuildConfig.server = removeUndefinedKey(rsbuildServer);
+    rsbuildConfig.dev = removeUndefinedKey(rsbuildDev);
+    rsbuildConfig.html = html;
+    rsbuildConfig.output = output;
+    const rsbuildPlugins = [
+        pluginGlobalVars(globalVars),
+        pluginDevtool({
+            sourceMap
+        }),
+        pluginEmitRouteFile(),
+        pluginSass({
+            sassLoaderOptions: sass
+        }),
+        pluginLess({
+            lessLoaderOptions: less
+        }),
+        pluginEnvironmentDefaults(distPath),
+        pluginHtmlMinifierTerser()
+    ];
+    if (checkSyntax) {
+        const { pluginCheckSyntax } = await import("@rsbuild/plugin-check-syntax");
+        rsbuildPlugins.push(pluginCheckSyntax('boolean' == typeof checkSyntax ? {} : checkSyntax));
+    }
+    if (!disableTsChecker) {
+        const { pluginTypeCheck } = await import("@rsbuild/plugin-type-check");
+        rsbuildPlugins.push(pluginTypeCheck({
+            tsCheckerOptions: tsChecker
+        }));
+    }
+    if (convertToRem) {
+        const { pluginRem } = await import("@rsbuild/plugin-rem");
+        rsbuildPlugins.push(pluginRem('boolean' == typeof convertToRem ? {} : convertToRem));
+    }
+    if (enableCssModuleTSDeclaration) {
+        const { pluginTypedCSSModules } = await import("@rsbuild/plugin-typed-css-modules");
+        rsbuildPlugins.push(pluginTypedCSSModules());
+    }
+    rsbuildPlugins.push(pluginRuntimeChunk(builderConfig.output?.disableInlineRuntimeChunk));
+    const { sourceBuild } = builderConfig.experiments || {};
+    if (sourceBuild) {
+        const { pluginSourceBuild } = await import("@rsbuild/plugin-source-build");
+        rsbuildPlugins.push(pluginSourceBuild(true === sourceBuild ? {} : sourceBuild));
+    }
+    rsbuildPlugins.push(pluginReact());
+    if (!disableSvgr) {
+        const { pluginSvgr } = await import("@rsbuild/plugin-svgr");
+        rsbuildPlugins.push(pluginSvgr({
+            mixedImport: true,
+            svgrOptions: {
+                exportType: 'component' === svgDefaultExport ? 'default' : 'named'
+            }
+        }));
+    }
+    if (assetsRetry) {
+        const { pluginAssetsRetry } = await import("@rsbuild/plugin-assets-retry");
+        rsbuildPlugins.push(pluginAssetsRetry(assetsRetry));
+    }
+    if (frameworkConfigPath && false !== performanceConfig.buildCache) {
+        const buildCache = 'object' == typeof performanceConfig.buildCache ? performanceConfig.buildCache : {};
+        rsbuildConfig.performance.buildCache = {
+            ...buildCache,
+            buildDependencies: [
+                frameworkConfigPath,
+                ...buildCache.buildDependencies || []
+            ]
+        };
+    }
+    rsbuildPlugins.push(pluginCssMinimizer({
+        pluginOptions: minifyCss
+    }));
+    if (enableAssetManifest) {
+        const { pluginManifest } = await import("../plugins/manifest.mjs");
+        rsbuildPlugins.push(pluginManifest());
+    }
+    return {
+        rsbuildConfig: mergeRsbuildConfig(rsbuildConfig, extraConfig),
+        rsbuildPlugins,
+        rsdoctorConfig
+    };
+}
+export { isLooseCssModules, parseCommonConfig };

package/dist/esm-node/shared/rsc/rsc-server-entry-loader.mjs

@@ -0,0 +1,8 @@
+import "node:module";
+function rscServerEntryLoader(source) {
+    this.cacheable(true);
+    const hasServerEntryDirective = source.includes("'use server-entry'") || source.includes('"use server-entry"') || source.includes('`use server-entry`');
+    if (hasServerEntryDirective) return source;
+    return `'use server-entry';\n${source}`;
+}
+export default rscServerEntryLoader;

package/dist/esm-node/shared/rsc/rscClientBrowserFallback.mjs

@@ -0,0 +1,25 @@
+import __rslib_shim_module__ from "node:module";
+const require = /*#__PURE__*/ __rslib_shim_module__.createRequire(/*#__PURE__*/ (()=>import.meta.url)());
+import path from "path";
+import { fileURLToPath as __rspack_fileURLToPath } from "node:url";
+import { dirname as __rspack_dirname } from "node:path";
+var rscClientBrowserFallback_dirname = __rspack_dirname(__rspack_fileURLToPath(import.meta.url));
+function rscClientBrowserFallbackPlugin() {
+    return {
+        name: 'builder:rsc-client-browser-fallback',
+        setup (api) {
+            let emptyModulePath;
+            try {
+                emptyModulePath = require.resolve('./rscEmptyModule');
+            } catch  {
+                emptyModulePath = path.resolve(rscClientBrowserFallback_dirname, 'rscEmptyModule');
+            }
+            api.modifyRspackConfig((config)=>{
+                config.resolve ??= {};
+                config.resolve.fallback ??= {};
+                config.resolve.fallback['react-server-dom-rspack/client.browser'] = emptyModulePath;
+            });
+        }
+    };
+}
+export { rscClientBrowserFallbackPlugin };

package/dist/esm-node/shared/rsc/rscEmptyModule.mjs

@@ -0,0 +1,3 @@
+import "node:module";
+const rscEmptyModule = {};
+export default rscEmptyModule;