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

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?.server) {
+                    compatConfig.environments ??= {};
+                    compatConfig.environments.server = {
+                        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 = [
+                        'client',
+                        'server',
+                        '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,115 @@
+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/plugins/rscConfig.mjs

@@ -0,0 +1,112 @@
+import path from "path";
+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(__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/plugins/rsdoctor.mjs

@@ -0,0 +1,30 @@
+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/plugins/runtimeChunk.mjs

@@ -0,0 +1,21 @@
+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/shared/devServer.mjs

@@ -0,0 +1,53 @@
+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/shared/getCssSupport.mjs

@@ -0,0 +1,77 @@
+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/shared/manifest.mjs

@@ -0,0 +1,12 @@
+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 };