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

package/dist/esm/shared/parseCommonConfig.mjs

@@ -0,0 +1,172 @@
+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: { ...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
+    };
+}
+export { isLooseCssModules, parseCommonConfig };

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

@@ -0,0 +1,20 @@
+import path from "path";
+function rscClientBrowserFallbackPlugin() {
+    return {
+        name: 'builder:rsc-client-browser-fallback',
+        setup (api) {
+            let emptyModulePath;
+            try {
+                emptyModulePath = require.resolve('./rscEmptyModule');
+            } catch  {
+                emptyModulePath = path.resolve(__dirname, 'rscEmptyModule');
+            }
+            api.modifyRspackConfig((config)=>{
+                config.resolve ??= {};
+                config.resolve.fallback ??= {};
+                config.resolve.fallback['react-server-dom-webpack/client.browser'] = emptyModulePath;
+            });
+        }
+    };
+}
+export { rscClientBrowserFallbackPlugin };

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

@@ -0,0 +1,2 @@
+const rscEmptyModule = {};
+export { rscEmptyModule as default };

package/dist/esm/shared/utils.mjs

@@ -0,0 +1,53 @@
+import browserslist from "browserslist";
+const RUNTIME_CHUNK_NAME = 'builder-runtime';
+const RUNTIME_CHUNK_REGEX = new RegExp(`${RUNTIME_CHUNK_NAME}([.].+)?\\.js$`);
+const SERVICE_WORKER_ENVIRONMENT_NAME = 'workerSSR';
+const NODE_MODULES_REGEX = /[\\/]node_modules[\\/]/;
+const castArray = (arr)=>{
+    if (void 0 === arr) return [];
+    return Array.isArray(arr) ? arr : [
+        arr
+    ];
+};
+const browsersListCache = new Map();
+async function getBrowserslist(path) {
+    const env = process.env.NODE_ENV;
+    const cacheKey = `${path}${env}`;
+    if (browsersListCache.has(cacheKey)) return browsersListCache.get(cacheKey);
+    const result = browserslist.loadConfig({
+        path,
+        env
+    });
+    if (result) {
+        browsersListCache.set(cacheKey, result);
+        return result;
+    }
+    return null;
+}
+const isHtmlDisabled = (config, target)=>{
+    const { htmlPlugin } = config.tools;
+    return false === htmlPlugin || Array.isArray(htmlPlugin) && htmlPlugin.includes(false) || 'web' !== target;
+};
+const DEFAULT_WEB_BROWSERSLIST = [
+    'chrome >= 87',
+    'edge >= 88',
+    'firefox >= 78',
+    'safari >= 14'
+];
+const DEFAULT_BROWSERSLIST = {
+    web: DEFAULT_WEB_BROWSERSLIST,
+    node: [
+        'node >= 16'
+    ],
+    'web-worker': DEFAULT_WEB_BROWSERSLIST
+};
+async function getBrowserslistWithDefault(path, config, target) {
+    const { overrideBrowserslist: overrides } = config?.output || {};
+    if ('web' === target || 'web-worker' === target) {
+        if (overrides) return overrides;
+        const browserslistrc = await getBrowserslist(path);
+        if (browserslistrc) return browserslistrc;
+    }
+    return DEFAULT_BROWSERSLIST[target];
+}
+export { NODE_MODULES_REGEX, RUNTIME_CHUNK_NAME, RUNTIME_CHUNK_REGEX, SERVICE_WORKER_ENVIRONMENT_NAME, castArray, getBrowserslistWithDefault, isHtmlDisabled };

package/dist/esm-node/createBuilder.mjs

@@ -0,0 +1,61 @@
+import "node:module";
+/*#__PURE__*/ import.meta.url;
+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-node/index.mjs

@@ -0,0 +1,6 @@
+import "node:module";
+/*#__PURE__*/ import.meta.url;
+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-node/plugins/devtools.mjs

@@ -0,0 +1,15 @@
+import "node:module";
+/*#__PURE__*/ import.meta.url;
+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-node/plugins/emitRouteFile.mjs

@@ -0,0 +1,30 @@
+import "node:module";
+/*#__PURE__*/ import.meta.url;
+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-node/plugins/environmentDefaults.mjs

@@ -0,0 +1,68 @@
+import "node:module";
+/*#__PURE__*/ import.meta.url;
+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-node/plugins/globalVars.mjs

@@ -0,0 +1,23 @@
+import "node:module";
+/*#__PURE__*/ import.meta.url;
+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-node/plugins/htmlMinify.mjs

@@ -0,0 +1,83 @@
+import "node:module";
+/*#__PURE__*/ import.meta.url;
+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-node/plugins/manifest.mjs

@@ -0,0 +1,20 @@
+import "node:module";
+/*#__PURE__*/ import.meta.url;
+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-node/plugins/postcss.mjs

@@ -0,0 +1,83 @@
+import "node:module";
+/*#__PURE__*/ import.meta.url;
+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-node/plugins/runtimeChunk.mjs

@@ -0,0 +1,22 @@
+import "node:module";
+/*#__PURE__*/ import.meta.url;
+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 };