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

package/dist/cjs/plugins/postcss.js

@@ -0,0 +1,118 @@
+"use strict";
+const __rslib_import_meta_url__ = /*#__PURE__*/ function() {
+    return "u" < typeof document ? new (require('url'.replace('', ''))).URL('file:' + __filename).href : document.currentScript && document.currentScript.src || new URL('main.js', document.baseURI).href;
+}();
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    pluginPostcss: ()=>pluginPostcss
+});
+const external_node_module_namespaceObject = require("node:module");
+const external_node_url_namespaceObject = require("node:url");
+const utils_namespaceObject = require("@modern-js/utils");
+const getCssSupport_js_namespaceObject = require("../shared/getCssSupport.js");
+const postcss_require = (0, external_node_module_namespaceObject.createRequire)(__rslib_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((0, external_node_url_namespaceObject.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 = (0, getCssSupport_js_namespaceObject.getCssSupport)(config.output.overrideBrowserslist);
+                const enableExtractCSS = !config.output?.injectStyles;
+                const enableCssMinify = !enableExtractCSS && (0, utils_namespaceObject.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((0, utils_namespaceObject.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);
+            });
+        }
+    });
+exports.pluginPostcss = __webpack_exports__.pluginPostcss;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "pluginPostcss"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/plugins/runtimeChunk.js

@@ -0,0 +1,54 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    pluginRuntimeChunk: ()=>pluginRuntimeChunk
+});
+const utils_js_namespaceObject = require("../shared/utils.js");
+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: utils_js_namespaceObject.RUNTIME_CHUNK_NAME
+                });
+            });
+            api.modifyRsbuildConfig((config)=>{
+                config.output ||= {};
+                if (disableInlineRuntimeChunk) return;
+                if (!config.output.inlineScripts) config.output.inlineScripts = utils_js_namespaceObject.RUNTIME_CHUNK_REGEX;
+            });
+        }
+    });
+exports.pluginRuntimeChunk = __webpack_exports__.pluginRuntimeChunk;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "pluginRuntimeChunk"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/rsc/common.js

@@ -0,0 +1,157 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    rspackRscLayerName: ()=>rspackRscLayerName,
+    getExportNames: ()=>getExportNames,
+    MODERN_RSC_INFO: ()=>MODERN_RSC_INFO,
+    isCssModule: ()=>isCssModule,
+    findRootIssuer: ()=>findRootIssuer,
+    getRscBuildInfo: ()=>getRscBuildInfo,
+    parseSource: ()=>parseSource,
+    sharedData: ()=>sharedData,
+    setBuildInfo: ()=>setBuildInfo,
+    isServerModule: ()=>isServerModule,
+    isClientModule: ()=>isClientModule,
+    removeRscBuildInfo: ()=>removeRscBuildInfo,
+    setRscBuildInfo: ()=>setRscBuildInfo
+});
+const utils_namespaceObject = require("@modern-js/utils");
+const core_namespaceObject = require("@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 (0, core_namespaceObject.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) {
+        utils_namespaceObject.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);
+}
+exports.MODERN_RSC_INFO = __webpack_exports__.MODERN_RSC_INFO;
+exports.findRootIssuer = __webpack_exports__.findRootIssuer;
+exports.getExportNames = __webpack_exports__.getExportNames;
+exports.getRscBuildInfo = __webpack_exports__.getRscBuildInfo;
+exports.isClientModule = __webpack_exports__.isClientModule;
+exports.isCssModule = __webpack_exports__.isCssModule;
+exports.isServerModule = __webpack_exports__.isServerModule;
+exports.parseSource = __webpack_exports__.parseSource;
+exports.removeRscBuildInfo = __webpack_exports__.removeRscBuildInfo;
+exports.rspackRscLayerName = __webpack_exports__.rspackRscLayerName;
+exports.setBuildInfo = __webpack_exports__.setBuildInfo;
+exports.setRscBuildInfo = __webpack_exports__.setRscBuildInfo;
+exports.sharedData = __webpack_exports__.sharedData;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "MODERN_RSC_INFO",
+    "findRootIssuer",
+    "getExportNames",
+    "getRscBuildInfo",
+    "isClientModule",
+    "isCssModule",
+    "isServerModule",
+    "parseSource",
+    "removeRscBuildInfo",
+    "rspackRscLayerName",
+    "setBuildInfo",
+    "setRscBuildInfo",
+    "sharedData"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/rsc/plugins/rsbuild-rsc-plugin.js

@@ -0,0 +1,169 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    rsbuildRscPlugin: ()=>rsbuildRscPlugin
+});
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const fs_extra_namespaceObject = require("@modern-js/utils/fs-extra");
+var fs_extra_default = /*#__PURE__*/ __webpack_require__.n(fs_extra_namespaceObject);
+const core_namespaceObject = require("@rsbuild/core");
+const external_common_js_namespaceObject = require("../common.js");
+const external_rspack_rsc_client_plugin_js_namespaceObject = require("./rspack-rsc-client-plugin.js");
+const external_rspack_rsc_server_plugin_js_namespaceObject = require("./rspack-rsc-server-plugin.js");
+const CSS_RULE_NAMES = [
+    'less',
+    'css',
+    'scss',
+    'sass'
+];
+const createVirtualModule = (content)=>`data:text/javascript,${encodeURIComponent(content)}`;
+const checkReactVersionAtLeast19 = async (appDir)=>{
+    const packageJsonPath = external_node_path_default().resolve(appDir, 'package.json');
+    const packageJson = await fs_extra_default().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)) {
+                        core_namespaceObject.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(external_common_js_namespaceObject.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(external_common_js_namespaceObject.rspackRscLayerName).end();
+                        chain.module.rule(external_common_js_namespaceObject.rspackRscLayerName).issuerLayer(external_common_js_namespaceObject.rspackRscLayerName).resolve.conditionNames.add(external_common_js_namespaceObject.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 = external_rspack_rsc_server_plugin_js_namespaceObject.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 = external_rspack_rsc_client_plugin_js_namespaceObject.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'
+            });
+        }
+    });
+exports.rsbuildRscPlugin = __webpack_exports__.rsbuildRscPlugin;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "rsbuildRscPlugin"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});