@shuvi/toolpack 1.0.63 → 2.0.0-dev.6

package/lib/utils/tsCheckerRspackPlugin.d.ts

@@ -0,0 +1,4 @@
+import { TsCheckerRspackPlugin } from 'ts-checker-rspack-plugin';
+export { Issue } from 'ts-checker-rspack-plugin/lib/issue';
+export { createCodeFrameFormatter } from 'ts-checker-rspack-plugin/lib/formatter';
+export default TsCheckerRspackPlugin;

package/lib/utils/tsCheckerRspackPlugin.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCodeFrameFormatter = void 0;
+const ts_checker_rspack_plugin_1 = require("ts-checker-rspack-plugin");
+var formatter_1 = require("ts-checker-rspack-plugin/lib/formatter");
+Object.defineProperty(exports, "createCodeFrameFormatter", { enumerable: true, get: function () { return formatter_1.createCodeFrameFormatter; } });
+exports.default = ts_checker_rspack_plugin_1.TsCheckerRspackPlugin;

package/lib/webpack/config/base.rspack.d.ts

@@ -0,0 +1,35 @@
+import RspackChain from 'rspack-chain';
+import { CompilerOptions } from '../loaders/shuvi-swc-loader';
+type TsCompilerOptions = import('typescript').CompilerOptions;
+export interface BaseOptions {
+    dev: boolean;
+    name: string;
+    projectRoot: string;
+    outputDir: string;
+    cacheDir: string;
+    include: (string | RegExp)[];
+    jsConfig?: {
+        useTypeScript: boolean;
+        typeScriptPath?: string;
+        compilerOptions: TsCompilerOptions;
+        resolvedBaseUrl: string;
+    };
+    target?: string;
+    publicPath?: string;
+    env?: {
+        [x: string]: string | undefined;
+    };
+    lightningCss?: boolean;
+    compiler?: CompilerOptions;
+    analyze?: boolean;
+}
+/**
+ * @unsupported Rspack does not support TerserPlugin or CssMinimizerPlugin directly.
+ */
+export { RspackChain };
+export declare function getDefineEnv(env: {
+    [x: string]: string | undefined;
+}): {
+    [x: string]: string;
+};
+export declare function baseRspackChain({ dev, outputDir, lightningCss, compiler, projectRoot, include, jsConfig, name, publicPath, env, cacheDir, analyze }: BaseOptions): RspackChain;

package/lib/webpack/config/base.rspack.js

@@ -0,0 +1,329 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RspackChain = void 0;
+exports.getDefineEnv = getDefineEnv;
+exports.baseRspackChain = baseRspackChain;
+const rspack_chain_1 = __importDefault(require("rspack-chain"));
+exports.RspackChain = rspack_chain_1.default;
+const webpack_bundle_analyzer_1 = require("webpack-bundle-analyzer");
+/**
+ * @unsupported Rspack does not support TerserPlugin or CssMinimizerPlugin directly.
+ * TODO: Use Rspack's built-in minification or custom plugin when available.
+ */
+// import TerserPlugin from 'terser-webpack-plugin';
+// import CssMinimizerPlugin from 'css-minimizer-webpack-plugin';
+const rspack = __importStar(require("@rspack/core"));
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const constants_1 = require("@shuvi/shared/constants");
+const fix_watching_plugin_1 = __importDefault(require("../plugins/fix-watching-plugin"));
+const resolveLocalLoader = (name) => path.join(__dirname, `../loaders/${name}`);
+function getDefineEnv(env) {
+    return Object.assign(Object.assign({}, Object.keys(process.env).reduce((prev, key) => {
+        if (key.startsWith(constants_1.PUBLIC_ENV_PREFIX)) {
+            prev[`process.env.${key}`] = JSON.stringify(process.env[key]);
+        }
+        return prev;
+    }, {})), Object.keys(env).reduce((acc, key) => {
+        if (/^(?:NODE_.+)|^(?:__.+)$/i.test(key)) {
+            throw new Error(`The key "${key}" under "env" is not allowed.`);
+        }
+        return Object.assign(Object.assign({}, acc), { [`process.env.${key}`]: JSON.stringify(env[key]) });
+    }, {}));
+}
+/** remove 'shuvi/' of the target name */
+const getSimplifiedTargetName = (targetName) => targetName.replace(/^shuvi\//, '');
+function baseRspackChain({ dev, outputDir, lightningCss, compiler, projectRoot, include, jsConfig, name, publicPath = '/', env = {}, cacheDir, analyze }) {
+    const config = new rspack_chain_1.default();
+    config.mode(dev ? 'development' : 'production');
+    config.bail(!dev);
+    config.performance.hints(false);
+    config.context(projectRoot);
+    config.devtool(dev ? 'eval' : false);
+    config.output.path(outputDir);
+    config.output.merge({
+        publicPath,
+        filename: `${dev ? '[name]' : '[name].[contenthash:8]'}.js`,
+        // This saves chunks with the name given via `import()`
+        chunkFilename: `static/chunks/${dev ? '[name]' : '[name].[contenthash:8]'}.js`,
+        hotUpdateChunkFilename: 'static/webpack/[id].[fullhash].hot-update.js',
+        hotUpdateMainFilename: 'static/webpack/[runtime].[fullhash].hot-update.json',
+        strictModuleExceptionHandling: true,
+        // crossOriginLoading: crossOrigin,
+        webassemblyModuleFilename: 'static/wasm/[modulehash:8].wasm',
+        hashFunction: 'xxhash64',
+        hashDigestLength: 16
+    });
+    config.optimization.merge({
+        emitOnErrors: !dev,
+        /**
+         * The following options are not currently supported by Rspack:
+         *
+         * - checkWasmTypes: Ensures WebAssembly modules have correct types. Rspack does not expose this option (see https://github.com/web-infra-dev/rspack/issues/ for updates).
+         * - nodeEnv: Allows overriding process.env.NODE_ENV for modules. Rspack sets this automatically based on mode and does not allow manual override.
+         * - realContentHash: Ensures content hash is based on the real content. Rspack does not expose this option; its hashing is internal and may differ from Webpack.
+         *
+         * @todo If Rspack exposes these options in the future, restore them for full parity.
+         */
+        // checkWasmTypes: false,
+        // nodeEnv: false,
+        runtimeChunk: undefined,
+        minimize: !dev
+        // realContentHash: false
+    });
+    if (dev) {
+        config.optimization.usedExports(false);
+    }
+    else {
+        /**
+         * @todo Rspack does not support TerserPlugin or CssMinimizerPlugin directly.
+         *
+         * - TerserPlugin: Used in Webpack for advanced JS minification. Rspack has built-in minification, but does not allow custom minimizer plugins yet.
+         * - CssMinimizerPlugin: Used for CSS minification. Rspack's CSS minification is built-in and not pluggable as of now.
+         *
+         * Migration advice: Monitor Rspack's plugin API and minimizer support. If/when Rspack allows custom minimizers, these can be restored for advanced/custom minification needs.
+         * See: https://rspack.dev/guide/plugin.html and https://github.com/web-infra-dev/rspack/issues/ for updates.
+         */
+        // config.optimization.minimizer('terser').use(TerserPlugin, [ ... ]);
+        // config.optimization.minimizer('cssMinimizer').use(CssMinimizerPlugin, [ ... ]);
+        if (analyze) {
+            const targetName = getSimplifiedTargetName(name);
+            config
+                .plugin('private/bundle-analyzer-plugin')
+                .use(webpack_bundle_analyzer_1.BundleAnalyzerPlugin, [
+                {
+                    logLevel: 'warn',
+                    openAnalyzer: false,
+                    analyzerMode: 'static',
+                    reportFilename: `../analyze/${targetName}.html`,
+                    generateStatsFile: true,
+                    statsFilename: `../analyze/${targetName}-stats.json`
+                }
+            ]);
+        }
+    }
+    // Support for NODE_PATH
+    const nodePathList = (process.env.NODE_PATH || '')
+        .split(process.platform === 'win32' ? ';' : ':')
+        .filter(p => !!p);
+    config.resolve.merge({
+        modules: [
+            'node_modules',
+            ...nodePathList // Support for NODE_PATH environment variable
+        ]
+    });
+    config.resolve.alias.set('@swc/helpers', path.dirname(require.resolve(`@swc/helpers/package.json`)));
+    config.resolveLoader.merge({
+        alias: [
+            'lightningcss-loader',
+            'shuvi-swc-loader',
+            'empty-loader',
+            'route-component-loader'
+        ].reduce((alias, loader) => {
+            alias[`@shuvi/${loader}`] = resolveLocalLoader(loader);
+            return alias;
+        }, {})
+    });
+    /**
+     * @unsupported Rspack does not support strictExportPresence.
+     * - Unrecognized key(s) in object: 'strictExportPresence' at "module"
+     */
+    // config.module.set('strictExportPresence', true);
+    const mainRule = config.module.rule('main');
+    // TODO: FIXME: await babel/babel-loader to update to fix this.
+    // x-ref: https://github.com/webpack/webpack/issues/11467
+    config.module
+        .rule('webpackPatch')
+        .test(/\.m?js/)
+        .resolve.set('fullySpecified', false);
+    config.module
+        .rule('private/shuvi-runtime')
+        .test(/\.shuvi[/\\]app[/\\]runtime[/\\]index\.(js|ts)/)
+        .set('sideEffects', false);
+    mainRule
+        .oneOf('js')
+        .test(/\.(tsx|ts|js|cjs|mjs|jsx)$/)
+        .include.merge([...include])
+        .end()
+        .use('shuvi-swc-loader')
+        /**
+         * @todo use builtin:swc-loader instead of shuvi-swc-loader
+         */
+        .loader('@shuvi/shuvi-swc-loader')
+        .options({
+        isServer: false,
+        compiler,
+        supportedBrowsers: false,
+        swcCacheDir: path.join(cacheDir, 'swc')
+    });
+    mainRule
+        .oneOf('media')
+        .exclude.merge([/\.(tsx|ts|js|cjs|mjs|jsx)$/, /\.html$/, /\.json$/])
+        .end()
+        // @ts-ignore
+        .type('asset/resource')
+        .set('generator', {
+        filename: (pathData) => {
+            // Check if a string is a base64 data URI
+            if (pathData.filename && isValidBase64DataURL(pathData.filename)) {
+                // Handle base64 string case, [name] is empty
+                return `static/media/base64.[hash:8][ext]`;
+            }
+            else {
+                return `static/media/[name].[hash:8][ext]`;
+            }
+        }
+    });
+    // .use('file-loader')
+    // .loader(require.resolve('file-loader'))
+    // .options({
+    //   name: 'static/media/[name].[hash:8].[ext]'
+    // });
+    config.plugin('private/ignore-plugin').use(rspack.IgnorePlugin, [
+        {
+            resourceRegExp: /^\.\/locale$/,
+            contextRegExp: /moment$/
+        }
+    ]);
+    config.plugin('private/define').use(rspack.DefinePlugin, [
+        Object.assign({ 
+            // internal field to identify the plugin config
+            __SHUVI_DEFINE_ENV: 'true' }, getDefineEnv(env))
+    ]);
+    config.plugin('define').use(rspack.DefinePlugin, [
+        {
+            'process.env.NODE_ENV': JSON.stringify(dev ? 'development' : 'production')
+        }
+    ]);
+    // const getCacheConfig = () => {
+    //   const projectHash = crypto
+    //     .createHash('md5')
+    //     .update(projectRoot)
+    //     .digest('hex');
+    //   const stringifiedEnvs = Object.entries({
+    //     ...getDefineEnv(env)
+    //   }).reduce((prev: string, [key, value]) => {
+    //     return `${prev}|${key}=${value}`;
+    //   }, '');
+    //   const PACKAGE_JSON = path.resolve(__dirname, '../../../package.json');
+    //   const SHUVI_VERSION = require(PACKAGE_JSON).version;
+    //   return {
+    //     cacheDirectory: path.join(cacheDir, 'webpack', projectHash),
+    //     type: 'filesystem',
+    //     name: `${name.replace(/\//, '-')}-${config.get('mode')}`,
+    //     version: `${SHUVI_VERSION}|${stringifiedEnvs}`
+    //   };
+    // };
+    /**
+     * @unsupported Rspack only supports `cache: boolean`. Object cache config is not supported.
+     * See: https://rspack.dev/config/cache
+     */
+    // config.cache(
+    //   typeof process.env.SHUVI_DEV_DISABLE_CACHE !== 'undefined'
+    //     ? false
+    //     : getCacheConfig()
+    // );
+    config.cache(typeof process.env.SHUVI_DEV_DISABLE_CACHE !== 'undefined' ? false : true);
+    const tsConfigPath = path.join(projectRoot, 'tsconfig.json');
+    const jsConfigPath = path.join(projectRoot, 'jsconfig.json');
+    if (jsConfig === null || jsConfig === void 0 ? void 0 : jsConfig.useTypeScript) {
+        if (fs.existsSync(tsConfigPath)) {
+            config.resolve.tsConfig(tsConfigPath);
+        }
+    }
+    else if (fs.existsSync(jsConfigPath)) {
+        config.resolve.tsConfig(jsConfigPath);
+    }
+    if (dev) {
+        // For rspack-dev-middleware usage
+        config.watchOptions({
+            aggregateTimeout: 5,
+            ignored: ['**/.git/**']
+        });
+        config.set('infrastructureLogging', {
+            level: 'none'
+        });
+        config.plugin('private/fix-watching-plugin').use(fix_watching_plugin_1.default);
+    }
+    else {
+        // class PrintModuleIdsPlugin {
+        //   apply(compiler: rspack.Compiler) {
+        //     compiler.hooks.compilation.tap('PrintModuleIdsPlugin', (compilation) => {
+        //       compilation.hooks.processAssets.tap(
+        //         {
+        //           name: 'PrintModuleIdsPlugin',
+        //           // PROCESS_ASSETS_STAGE_ADDITIONS 是比較晚的階段，ID 通常已分配完成
+        //           stage: rspack.Compilation.PROCESS_ASSETS_STAGE_ADDITIONS
+        //         },
+        //         () => {
+        //           for (const module of compilation.modules) {
+        //             const id = compilation.chunkGraph.getModuleId(module);
+        //             if (id != null) {
+        //               console.log('module id:', id, 'request:', (module as any).rawRequest || (module as any).userRequest);
+        //             } else {
+        //               console.log('module id: <null>', 'request:', (module as any).rawRequest || (module as any).userRequest);
+        //             }
+        //           }
+        //         }
+        //       );
+        //     });
+        //   }
+        // }
+        // config.plugin('private/print-module-ids-plugin').use(PrintModuleIdsPlugin);
+        /**
+         * enable deterministic module ids
+         * this is equivalent to webpack's HashedModuleIdsPlugin
+         */
+        config.optimization.merge({
+            moduleIds: 'deterministic' // equivalent to webpack's HashedModuleIdsPlugin
+        });
+    }
+    return config;
+}
+function isValidBase64DataURL(input) {
+    // Check if input starts with the data URI scheme
+    if (!input.startsWith('data:')) {
+        return false;
+    }
+    // Split the data URI into metadata and data parts
+    const parts = input.split(',');
+    if (parts.length !== 2) {
+        return false;
+    }
+    const metadata = parts[0];
+    const data = parts[1];
+    // Check if the metadata contains 'base64'
+    if (!metadata.includes('base64')) {
+        return false;
+    }
+    // Regular expression to validate Base64 string
+    const base64Regex = /^[A-Za-z0-9+/]+[=]{0,2}$/;
+    // Validate Base64 data
+    return base64Regex.test(data);
+}

package/lib/webpack/config/browser.rspack.d.ts

@@ -0,0 +1,3 @@
+import { BaseOptions } from './base.rspack';
+import RspackChain from 'rspack-chain';
+export declare function createBrowserRspackChain(options: BaseOptions): RspackChain;

package/lib/webpack/config/browser.rspack.js

@@ -0,0 +1,228 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBrowserRspackChain = createBrowserRspackChain;
+const crypto = __importStar(require("crypto"));
+const rspack = __importStar(require("@rspack/core"));
+const path = __importStar(require("path"));
+const resolve_1 = require("@shuvi/utils/resolve");
+const base_rspack_1 = require("./base.rspack");
+const style_rspack_1 = require("./parts/style.rspack");
+const helpers_rspack_1 = require("./parts/helpers.rspack");
+const ts_checker_rspack_plugin_1 = require("ts-checker-rspack-plugin");
+const BIG_LIBRARY_THRESHOLD = 160000; // byte
+const SHUVI_PKGS_REGEX = /[\\/]node_modules[\\/](@shuvi|doura)[\\/]/;
+const FRAMEWORK_REACT_MODULES = [
+    {
+        test: /[/\\]node_modules[/\\]react[/\\]/
+    },
+    {
+        test: /[/\\]node_modules[/\\]react-dom[/\\]/
+    },
+    {
+        test: /[/\\]node_modules[/\\]scheduler[/\\]/,
+        issuers: [/[/\\]node_modules[/\\]react-dom[/\\]/]
+    }
+];
+function createBrowserRspackChain(options) {
+    const { projectRoot: projectRoot, cacheDir: cacheDir, jsConfig, dev, publicPath } = options;
+    const chain = (0, base_rspack_1.baseRspackChain)(options);
+    const useTypeScript = !!(jsConfig === null || jsConfig === void 0 ? void 0 : jsConfig.useTypeScript);
+    chain.target('web');
+    chain.devtool(dev ? 'cheap-module-source-map' : false);
+    chain.resolve.extensions.merge([
+        '.ts',
+        '.tsx',
+        '.mjs',
+        '.js',
+        '.jsx',
+        '.json',
+        '.wasm'
+    ]);
+    if (useTypeScript) {
+        chain
+            .plugin('private/ts-checker-rspack-plugin')
+            .use(ts_checker_rspack_plugin_1.TsCheckerRspackPlugin, [
+            {
+                typescript: {
+                    configFile: path.join(projectRoot, 'tsconfig.json'),
+                    mode: 'write-references',
+                    typescriptPath: jsConfig.typeScriptPath,
+                    diagnosticOptions: {
+                        syntactic: true
+                    },
+                    configOverwrite: {
+                        compilerOptions: {
+                            incremental: true,
+                            tsBuildInfoFile: path.resolve(cacheDir, 'tsbuildinfo')
+                        }
+                    }
+                },
+                async: dev,
+                logger: {
+                    log: message => console.log(message),
+                    error: message => console.error(message)
+                },
+                formatter: 'codeframe'
+            }
+        ]);
+    }
+    if (dev) {
+        chain.plugin('private/hmr-plugin').use(rspack.HotModuleReplacementPlugin);
+        // disable splitChunks at dev mode to prevent preload error
+        chain.optimization.splitChunks(false);
+    }
+    else {
+        const getDefaultChunkName = (_module, chunks) => {
+            return crypto
+                .createHash('sha1')
+                .update(chunks.reduce((acc, chunk) => {
+                return acc + chunk.name;
+            }, ''))
+                .digest('hex')
+                .substring(0, 8);
+        };
+        chain.optimization.splitChunks({
+            chunks: helpers_rspack_1.splitChunksFilter,
+            cacheGroups: {
+                default: Object.assign({ name: getDefaultChunkName, filename: (0, helpers_rspack_1.commonChunkFilename)({ dev: false }) }, helpers_rspack_1.defaultCacheGroups.default),
+                defaultVendors: Object.assign({ name: getDefaultChunkName, filename: (0, helpers_rspack_1.commonChunkFilename)({ dev: false }) }, helpers_rspack_1.defaultCacheGroups.defaultVendors),
+                framework: {
+                    chunks: 'all',
+                    name: 'framework',
+                    filename: (0, helpers_rspack_1.commonChunkFilename)({ dev: false }),
+                    test(module, { moduleGraph }) {
+                        const resource = module.nameForCondition();
+                        if (!resource) {
+                            return false;
+                        }
+                        if (SHUVI_PKGS_REGEX.test(resource)) {
+                            return true;
+                        }
+                        return FRAMEWORK_REACT_MODULES.some(frameworkModule => {
+                            if (!frameworkModule.test.test(resource)) {
+                                return false;
+                            }
+                            // Check issuer to ignore nested copies of framework libraries so they're
+                            // bundled with their issuer.
+                            // https://github.com/zeit/next.js/pull/9012
+                            if (frameworkModule.issuers) {
+                                for (const issuerTest of frameworkModule.issuers) {
+                                    // fix:  DeprecationWarning: Module.issuer: Use new ModuleGraph API
+                                    const issuer = moduleGraph.getIssuer(module);
+                                    const issuerResource = issuer
+                                        ? issuer.nameForCondition()
+                                        : null;
+                                    if (!issuerResource || !issuerTest.test(issuerResource)) {
+                                        return false;
+                                    }
+                                }
+                            }
+                            return true;
+                        });
+                    },
+                    // test: /(?<!node_modules.*)[\\/]node_modules[\\/](react|react-dom|@shuvi[\\/]router|@shuvi[\\/]router-react|scheduler|prop-types|use-sync-external-store|history)[\\/]/,
+                    priority: 40,
+                    // Don't let webpack eliminate this chunk (prevents this chunk from
+                    // becoming a part of the commons chunk)
+                    enforce: true
+                },
+                lib: {
+                    test(module) {
+                        return (module.size() > BIG_LIBRARY_THRESHOLD &&
+                            helpers_rspack_1.NODE_MODULES_REGEXP.test(module.nameForCondition() || ''));
+                    },
+                    /**
+                     * @unsupported Rspack does not support libIdent directly.
+                     */
+                    // name(module: {
+                    //   type: string;
+                    //   libIdent?: Function;
+                    //   updateHash: (hash: crypto.Hash) => void;
+                    // }): string {
+                    //   const hash = crypto.createHash('sha1');
+                    //   if (module.type === `css/mini-extract`) {
+                    //     module.updateHash(hash);
+                    //   } else {
+                    //     if (!module.libIdent) {
+                    //       throw new Error(
+                    //         `Encountered unknown module type: ${module.type}. Please open an issue.`
+                    //       );
+                    //     }
+                    //     hash.update(module.libIdent({ context: options.projectRoot }));
+                    //   }
+                    //   return hash.digest('hex').substring(0, 8);
+                    // },
+                    name: 'lib',
+                    filename: (0, helpers_rspack_1.commonChunkFilename)({ dev: false }),
+                    priority: 30,
+                    minChunks: 1,
+                    reuseExistingChunk: true
+                }
+            },
+            maxInitialRequests: 25,
+            minSize: 20000
+        });
+    }
+    // node polyfills
+    chain.resolve.fallback.merge({
+        buffer: (0, resolve_1.resolve)('buffer', {
+            includeCoreModules: false
+        }),
+        crypto: require.resolve('crypto-browserify'),
+        path: require.resolve('path-browserify'),
+        stream: require.resolve('stream-browserify'),
+        vm: require.resolve('vm-browserify')
+    });
+    chain.plugin('node-buffer-polyfill').use(rspack.ProvidePlugin, [
+        {
+            Buffer: ['buffer', 'Buffer']
+        }
+    ]);
+    chain.plugin('node-process-polyfill').use(rspack.ProvidePlugin, [
+        {
+            process: ['process']
+        }
+    ]);
+    chain.plugin('define').tap((args) => {
+        const [options = {}] = args;
+        return [
+            Object.assign(Object.assign({}, options), { __BROWSER__: true, 
+                /**
+                 * swc.optimizer can't handle `typeof window` correctly for dependencies
+                 */
+                'typeof window': JSON.stringify('object'), 
+                // prevent errof of destructing process.env
+                'process.env': JSON.stringify('{}') })
+        ];
+    });
+    return (0, style_rspack_1.withStyle)(chain, {
+        extractCss: !dev,
+        publicPath,
+        lightningCss: options.lightningCss,
+        filename: 'static/css/[contenthash:8].css',
+        chunkFilename: 'static/css/[contenthash:8].chunk.css'
+    });
+}

package/lib/webpack/config/{browser.d.ts → browser.webpack.d.ts}

@@ -1,2 +1,2 @@
-import { WebpackChain, BaseOptions } from './base';
+import { WebpackChain, BaseOptions } from './base.webpack';
 export declare function createBrowserWebpackChain(options: BaseOptions): WebpackChain;