@rsbuild/webpack 1.1.0 → 1.1.2

package/dist/index.js

@@ -7,61 +7,7 @@ import * as __WEBPACK_EXTERNAL_MODULE_webpack_lib_MultiStats_js__ from "webpack/
 import * as __WEBPACK_EXTERNAL_MODULE_node_path__ from "node:path";
 import * as __WEBPACK_EXTERNAL_MODULE_reduce_configs__ from "reduce-configs";
 import * as __WEBPACK_EXTERNAL_MODULE_node_fs__ from "node:fs";
-var __webpack_modules__ = {
-    "./src/shared.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
-        __webpack_require__.d(__webpack_exports__, {
-            A9: function() {
-                return initRsbuildConfig;
-            },
-            AS: function() {
-                return prettyTime;
-            },
-            DO: function() {
-                return stringifyConfig;
-            },
-            EB: function() {
-                return modifyBundlerChain;
-            },
-            Oo: function() {
-                return registerBuildHook;
-            },
-            PD: function() {
-                return getRsbuildInspectConfig;
-            },
-            PZ: function() {
-                return createDevServer;
-            },
-            SM: function() {
-                return outputInspectConfigFiles;
-            },
-            XQ: function() {
-                return castArray;
-            },
-            g5: function() {
-                return getStatsOptions;
-            },
-            iL: function() {
-                return chainToConfig;
-            },
-            px: function() {
-                return getChainUtils;
-            },
-            v1: function() {
-                return formatStats;
-            },
-            xn: function() {
-                return registerDevHook;
-            }
-        });
-        /* ESM import */ var _rsbuild_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("@rsbuild/core");
-        const { getChainUtils, initRsbuildConfig, createDevServer, formatStats, getStatsOptions, stringifyConfig, outputInspectConfigFiles, getRsbuildInspectConfig, chainToConfig, modifyBundlerChain, registerDevHook, registerBuildHook, prettyTime } = _rsbuild_core__WEBPACK_IMPORTED_MODULE_0__.__internalHelper;
-        const castArray = (arr)=>{
-            if (void 0 === arr) return [];
-            return Array.isArray(arr) ? arr : [
-                arr
-            ];
-        };
-    },
+var installedChunks, installChunk, __webpack_modules__ = {
     "@rsbuild/core": function(module) {
         module.exports = __WEBPACK_EXTERNAL_MODULE__rsbuild_core__;
     },
@@ -77,166 +23,87 @@ var __webpack_modules__ = {
     webpack: function(module) {
         module.exports = __WEBPACK_EXTERNAL_MODULE_webpack__;
     }
-};
-/************************************************************************/ // The module cache
-var __webpack_module_cache__ = {};
-// The require function
+}, __webpack_module_cache__ = {};
 function __webpack_require__(moduleId) {
-    // Check if module is in cache
     var cachedModule = __webpack_module_cache__[moduleId];
     if (void 0 !== cachedModule) return cachedModule.exports;
-    // Create a new module (and put it into the cache)
     var module = __webpack_module_cache__[moduleId] = {
         id: moduleId,
-        loaded: false,
+        loaded: !1,
         exports: {}
     };
-    // Execute the module function
-    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
-    // Flag the module as loaded
-    module.loaded = true;
-    // Return the exports of the module
-    return module.exports;
+    return __webpack_modules__[moduleId](module, module.exports, __webpack_require__), module.loaded = !0, module.exports;
 }
-// expose the modules object (__webpack_modules__)
-__webpack_require__.m = __webpack_modules__;
-/************************************************************************/ // webpack/runtime/compat_get_default_export
-(()=>{
-    // getDefaultExport function for compatibility with non-ESM modules
-    __webpack_require__.n = function(module) {
-        var getter = module && module.__esModule ? function() {
-            return module['default'];
-        } : function() {
-            return module;
-        };
-        __webpack_require__.d(getter, {
-            a: getter
-        });
-        return getter;
-    };
-})();
-// webpack/runtime/define_property_getters
-(()=>{
-    __webpack_require__.d = function(exports, definition) {
-        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) Object.defineProperty(exports, key, {
-            enumerable: true,
-            get: definition[key]
-        });
-    };
-})();
-// webpack/runtime/ensure_chunk
-(()=>{
-    __webpack_require__.f = {};
-    // This file contains only the entry chunk.
-    // The chunk loading function for additional chunks
-    __webpack_require__.e = function(chunkId) {
-        return Promise.all(Object.keys(__webpack_require__.f).reduce(function(promises, key) {
-            __webpack_require__.f[key](chunkId, promises);
-            return promises;
-        }, []));
-    };
-})();
-// webpack/runtime/get javascript chunk filename
-(()=>{
-    // This function allow to reference chunks
-    __webpack_require__.u = function(chunkId) {
-        // return url for filenames not based on template
-        // return url for filenames based on template
-        return "" + chunkId + ".js";
-    };
-})();
-// webpack/runtime/has_own_property
-(()=>{
-    __webpack_require__.o = function(obj, prop) {
-        return Object.prototype.hasOwnProperty.call(obj, prop);
-    };
-})();
-// webpack/runtime/node_module_decorator
-(()=>{
-    __webpack_require__.nmd = function(module) {
-        module.paths = [];
-        if (!module.children) module.children = [];
+__webpack_require__.m = __webpack_modules__, __webpack_require__.n = function(module) {
+    var getter = module && module.__esModule ? function() {
+        return module.default;
+    } : function() {
         return module;
     };
-})();
-// webpack/runtime/module_chunk_loading
-(()=>{
-    // object to store loaded and loading chunks
-    // undefined = chunk not loaded, null = chunk preloaded/prefetched
-    // [resolve, reject, Promise] = chunk loading, 0 = chunk loaded
-    var installedChunks = {
-        980: 0
-    };
-    var installChunk = function(data) {
-        var ids = data.ids;
-        var modules = data.modules;
-        var runtime = data.runtime;
-        // add "modules" to the modules object,
-        // then flag all "ids" as loaded and fire callback
-        var moduleId, chunkId, i = 0;
-        for(moduleId in modules)if (__webpack_require__.o(modules, moduleId)) __webpack_require__.m[moduleId] = modules[moduleId];
-        if (runtime) runtime(__webpack_require__);
-        for(; i < ids.length; i++){
-            chunkId = ids[i];
-            if (__webpack_require__.o(installedChunks, chunkId) && installedChunks[chunkId]) installedChunks[chunkId][0]();
-            installedChunks[ids[i]] = 0;
-        }
-    };
-    __webpack_require__.f.j = function(chunkId, promises) {
-        // import() chunk loading for javascript
-        var installedChunkData = __webpack_require__.o(installedChunks, chunkId) ? installedChunks[chunkId] : void 0;
-        if (0 !== installedChunkData) {
-            // a Promise means "currently loading".
-            if (installedChunkData) promises.push(installedChunkData[1]);
-            else {
-                // setup Promise in chunk cache
-                var promise = import("./" + __webpack_require__.u(chunkId)).then(installChunk, function(e) {
-                    if (0 !== installedChunks[chunkId]) installedChunks[chunkId] = void 0;
-                    throw e;
-                });
-                var promise = Promise.race([
-                    promise,
-                    new Promise(function(resolve) {
-                        installedChunkData = installedChunks[chunkId] = [
-                            resolve
-                        ];
-                    })
-                ]);
-                promises.push(installedChunkData[1] = promise);
-            }
+    return __webpack_require__.d(getter, {
+        a: getter
+    }), getter;
+}, __webpack_require__.d = function(exports, definition) {
+    for(var key in definition)__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key) && Object.defineProperty(exports, key, {
+        enumerable: !0,
+        get: definition[key]
+    });
+}, __webpack_require__.f = {}, __webpack_require__.e = function(chunkId) {
+    return Promise.all(Object.keys(__webpack_require__.f).reduce(function(promises, key) {
+        return __webpack_require__.f[key](chunkId, promises), promises;
+    }, []));
+}, __webpack_require__.u = function(chunkId) {
+    return "" + chunkId + ".js";
+}, __webpack_require__.o = function(obj, prop) {
+    return Object.prototype.hasOwnProperty.call(obj, prop);
+}, __webpack_require__.nmd = function(module) {
+    return module.paths = [], !module.children && (module.children = []), module;
+}, installedChunks = {
+    980: 0
+}, installChunk = function(data) {
+    var ids = data.ids, modules = data.modules, runtime = data.runtime, moduleId, chunkId, i = 0;
+    for(moduleId in modules)__webpack_require__.o(modules, moduleId) && (__webpack_require__.m[moduleId] = modules[moduleId]);
+    for(runtime && runtime(__webpack_require__); i < ids.length; i++)chunkId = ids[i], __webpack_require__.o(installedChunks, chunkId) && installedChunks[chunkId] && installedChunks[chunkId][0](), installedChunks[ids[i]] = 0;
+}, __webpack_require__.f.j = function(chunkId, promises) {
+    var installedChunkData = __webpack_require__.o(installedChunks, chunkId) ? installedChunks[chunkId] : void 0;
+    if (0 !== installedChunkData) {
+        if (installedChunkData) promises.push(installedChunkData[1]);
+        else {
+            var promise = import("./" + __webpack_require__.u(chunkId)).then(installChunk, function(e) {
+                throw 0 !== installedChunks[chunkId] && (installedChunks[chunkId] = void 0), e;
+            }), promise = Promise.race([
+                promise,
+                new Promise(function(resolve) {
+                    installedChunkData = installedChunks[chunkId] = [
+                        resolve
+                    ];
+                })
+            ]);
+            promises.push(installedChunkData[1] = promise);
         }
-    };
-})();
-// EXTERNAL MODULE: external "@rsbuild/core"
-var core_ = __webpack_require__("@rsbuild/core");
-// EXTERNAL MODULE: ./src/shared.ts
-var shared = __webpack_require__("./src/shared.ts");
-const getInspectOutputPath = (context, inspectOptions)=>{
-    if (inspectOptions.outputPath) {
-        if ((0, __WEBPACK_EXTERNAL_MODULE_node_path__.isAbsolute)(inspectOptions.outputPath)) return inspectOptions.outputPath;
-        return (0, __WEBPACK_EXTERNAL_MODULE_node_path__.join)(context.distPath, inspectOptions.outputPath);
     }
+};
+var core_ = __webpack_require__("@rsbuild/core");
+let getInspectOutputPath = (context, inspectOptions)=>{
+    if (inspectOptions.outputPath) return (0, __WEBPACK_EXTERNAL_MODULE_node_path__.isAbsolute)(inspectOptions.outputPath) ? inspectOptions.outputPath : (0, __WEBPACK_EXTERNAL_MODULE_node_path__.join)(context.distPath, inspectOptions.outputPath);
     return (0, __WEBPACK_EXTERNAL_MODULE_node_path__.join)(context.distPath, '.rsbuild');
 };
-async function inspectConfig({ context, pluginManager, rsbuildOptions, bundlerConfigs, inspectOptions = {} }) {
-    if (inspectOptions.mode) process.env.NODE_ENV = inspectOptions.mode;
-    else if (!process.env.NODE_ENV) process.env.NODE_ENV = 'development';
-    const webpackConfigs = bundlerConfigs || (await initConfigs({
+async function inspectConfig({ helpers, context, pluginManager, rsbuildOptions, bundlerConfigs, inspectOptions = {} }) {
+    inspectOptions.mode ? process.env.NODE_ENV = inspectOptions.mode : !process.env.NODE_ENV && (process.env.NODE_ENV = 'development');
+    let webpackConfigs = bundlerConfigs || (await initConfigs({
         context,
         pluginManager,
-        rsbuildOptions
-    })).webpackConfigs;
-    const rawBundlerConfigs = webpackConfigs.map((config, index)=>({
+        rsbuildOptions,
+        helpers
+    })).webpackConfigs, rawBundlerConfigs = webpackConfigs.map((config, index)=>({
             name: config.name || String(index),
-            content: (0, shared /* stringifyConfig */ .DO)(config, inspectOptions.verbose)
-        }));
-    const { rsbuildConfig, rawRsbuildConfig, environmentConfigs, rawEnvironmentConfigs } = (0, shared /* getRsbuildInspectConfig */ .PD)({
+            content: helpers.stringifyConfig(config, inspectOptions.verbose)
+        })), { rsbuildConfig, rawRsbuildConfig, environmentConfigs, rawEnvironmentConfigs } = helpers.getRsbuildInspectConfig({
         normalizedConfig: context.normalizedConfig,
         inspectOptions,
         pluginManager
-    });
-    const outputPath = getInspectOutputPath(context, inspectOptions);
-    if (inspectOptions.writeToDisk) await (0, shared /* outputInspectConfigFiles */ .SM)({
+    }), outputPath = getInspectOutputPath(context, inspectOptions);
+    return inspectOptions.writeToDisk && await helpers.outputInspectConfigFiles({
         rawBundlerConfigs,
         rawEnvironmentConfigs,
         inspectOptions: {
@@ -244,8 +111,7 @@ async function inspectConfig({ context, pluginManager, rsbuildOptions, bundlerCo
             outputPath
         },
         configType: 'webpack'
-    });
-    return {
+    }), {
         rsbuildConfig: rawRsbuildConfig,
         environmentConfigs: rawEnvironmentConfigs.map((r)=>r.content),
         bundlerConfigs: rawBundlerConfigs.map((r)=>r.content),
@@ -256,19 +122,21 @@ async function inspectConfig({ context, pluginManager, rsbuildOptions, bundlerCo
         }
     };
 }
+let castArray = (arr)=>void 0 === arr ? [] : Array.isArray(arr) ? arr : [
+        arr
+    ];
 async function modifyWebpackChain(context, utils, chain) {
     var _utils_environment_config_tools;
     core_.logger.debug('modify webpack chain');
-    const [modifiedChain] = await context.hooks.modifyWebpackChain.callInEnvironment({
+    let [modifiedChain] = await context.hooks.modifyWebpackChain.callInEnvironment({
         environment: utils.environment.name,
         args: [
             chain,
             utils
         ]
     });
-    if (null === (_utils_environment_config_tools = utils.environment.config.tools) || void 0 === _utils_environment_config_tools ? void 0 : _utils_environment_config_tools.webpackChain) for (const item of (0, shared /* castArray */ .XQ)(utils.environment.config.tools.webpackChain))item(modifiedChain, utils);
-    core_.logger.debug('modify webpack chain done');
-    return modifiedChain;
+    if (null === (_utils_environment_config_tools = utils.environment.config.tools) || void 0 === _utils_environment_config_tools ? void 0 : _utils_environment_config_tools.webpackChain) for (let item of castArray(utils.environment.config.tools.webpackChain))item(modifiedChain, utils);
+    return core_.logger.debug('modify webpack chain done'), modifiedChain;
 }
 async function modifyWebpackConfig(context, webpackConfig, utils) {
     var _utils_environment_config_tools;
@@ -280,34 +148,28 @@ async function modifyWebpackConfig(context, webpackConfig, utils) {
             utils
         ]
     });
-    if (null === (_utils_environment_config_tools = utils.environment.config.tools) || void 0 === _utils_environment_config_tools ? void 0 : _utils_environment_config_tools.webpack) modifiedConfig = (0, __WEBPACK_EXTERNAL_MODULE_reduce_configs__.reduceConfigsWithContext)({
+    return (null === (_utils_environment_config_tools = utils.environment.config.tools) || void 0 === _utils_environment_config_tools ? void 0 : _utils_environment_config_tools.webpack) && (modifiedConfig = (0, __WEBPACK_EXTERNAL_MODULE_reduce_configs__.reduceConfigsWithContext)({
         initial: modifiedConfig,
         config: utils.environment.config.tools.webpack,
         ctx: utils,
         mergeFn: utils.mergeConfig
-    });
-    core_.logger.debug('modify webpack config done');
-    return modifiedConfig;
+    })), core_.logger.debug('modify webpack config done'), modifiedConfig;
 }
-async function getChainUtils(target, environment) {
-    const { default: webpack } = await import("webpack");
-    const nameMap = {
-        web: 'client',
-        node: 'server',
-        'web-worker': 'web-worker'
-    };
+async function getChainUtils(target, environment, helpers) {
+    let { default: webpack } = await import("webpack");
     return {
-        ...(0, shared /* getChainUtils */ .px)(target, environment),
-        name: nameMap[target] || '',
+        ...helpers.getChainUtils(target, environment),
+        name: ({
+            web: 'client',
+            node: 'server',
+            'web-worker': 'web-worker'
+        })[target] || '',
         webpack,
-        HtmlWebpackPlugin: core_.__internalHelper.getHTMLPlugin()
+        HtmlWebpackPlugin: helpers.getHTMLPlugin()
     };
 }
-async function generateWebpackConfig({ target, context, environment }) {
-    const chainUtils = await getChainUtils(target, context.environments[environment]);
-    const { default: webpack } = await import("webpack");
-    const { BannerPlugin, DefinePlugin, IgnorePlugin, ProvidePlugin, HotModuleReplacementPlugin } = webpack;
-    const bundlerChain = await (0, shared /* modifyBundlerChain */ .EB)(context, {
+async function generateWebpackConfig({ target, context, environment, helpers }) {
+    let chainUtils = await getChainUtils(target, context.environments[environment], helpers), { default: webpack } = await import("webpack"), { BannerPlugin, DefinePlugin, IgnorePlugin, ProvidePlugin, HotModuleReplacementPlugin } = webpack, bundlerChain = await helpers.modifyBundlerChain(context, {
         ...chainUtils,
         bundler: {
             BannerPlugin,
@@ -316,43 +178,36 @@ async function generateWebpackConfig({ target, context, environment }) {
             ProvidePlugin,
             HotModuleReplacementPlugin
         }
-    });
-    const chain = await modifyWebpackChain(context, chainUtils, bundlerChain);
-    let webpackConfig = (0, shared /* chainToConfig */ .iL)(chain);
-    const configUtils = await core_.__internalHelper.getConfigUtils(webpackConfig, chainUtils);
-    webpackConfig = await modifyWebpackConfig(context, webpackConfig, configUtils);
-    return webpackConfig;
+    }), chain = await modifyWebpackChain(context, chainUtils, bundlerChain), webpackConfig = helpers.chainToConfig(chain), configUtils = await helpers.getConfigUtils(webpackConfig, chainUtils);
+    return webpackConfig = await modifyWebpackConfig(context, webpackConfig, configUtils);
 }
-async function initConfigs({ context, pluginManager, rsbuildOptions }) {
-    const normalizedConfig = await (0, shared /* initRsbuildConfig */ .A9)({
+async function initConfigs({ context, pluginManager, rsbuildOptions, helpers }) {
+    let normalizedConfig = await helpers.initRsbuildConfig({
         context,
         pluginManager
-    });
-    const webpackConfigs = await Promise.all(Object.entries(normalizedConfig.environments).map(([environment, config])=>generateWebpackConfig({
+    }), webpackConfigs = await Promise.all(Object.entries(normalizedConfig.environments).map(([environment, config])=>generateWebpackConfig({
             target: config.output.target,
             context,
-            environment
+            environment,
+            helpers
         })));
-    // write Rsbuild config and webpack config to disk in debug mode
     if ('verbose' === core_.logger.level) {
-        const inspect = ()=>{
-            const inspectOptions = {
-                verbose: true,
-                writeToDisk: true
-            };
+        let inspect = ()=>{
             inspectConfig({
                 context,
                 pluginManager,
-                inspectOptions,
+                inspectOptions: {
+                    verbose: !0,
+                    writeToDisk: !0
+                },
                 rsbuildOptions,
-                bundlerConfigs: webpackConfigs
+                bundlerConfigs: webpackConfigs,
+                helpers
             });
         };
-        // run inspect later to avoid cleaned by cleanOutput plugin
         context.hooks.onBeforeBuild.tap(({ isFirstCompile })=>{
-            if (isFirstCompile) inspect();
-        });
-        context.hooks.onAfterStartDevServer.tap(inspect);
+            isFirstCompile && inspect();
+        }), context.hooks.onAfterStartDevServer.tap(inspect);
     }
     return {
         webpackConfigs
@@ -361,86 +216,65 @@ async function initConfigs({ context, pluginManager, rsbuildOptions }) {
 async function createCompiler_createCompiler(options) {
     var _context_normalizedConfig;
     core_.logger.debug('create compiler');
-    const { context } = options;
-    const { webpackConfigs } = await initConfigs(options);
+    let { helpers, context } = options, { webpackConfigs } = await initConfigs(options);
     await context.hooks.onBeforeCreateCompiler.call({
         bundlerConfigs: webpackConfigs,
         environments: context.environments
     });
-    const { default: webpack } = await import("webpack");
-    const compiler = 1 === webpackConfigs.length ? webpack(webpackConfigs[0]) : webpack(webpackConfigs);
-    const done = (stats)=>{
-        const statsOptions = (0, shared /* getStatsOptions */ .g5)(compiler);
-        const statsJson = stats.toJson({
-            children: true,
+    let { default: webpack } = await import("webpack"), compiler = webpack(1 === webpackConfigs.length ? webpackConfigs[0] : webpackConfigs), done = (stats)=>{
+        let statsOptions = helpers.getStatsOptions(compiler), statsJson = stats.toJson({
+            children: !0,
             ...'string' == typeof statsOptions ? {
                 preset: statsOptions
             } : {
                 preset: 'errors-warnings'
             },
             ...'object' == typeof statsOptions ? statsOptions : {}
-        });
-        const { message, level } = (0, shared /* formatStats */ .v1)(statsJson, stats.hasErrors());
-        if ('error' === level) core_.logger.error(message);
-        if ('warning' === level) core_.logger.warn(message);
+        }), { message, level } = helpers.formatStats(statsJson, stats.hasErrors());
+        'error' === level && core_.logger.error(message), 'warning' === level && core_.logger.warn(message);
     };
-    compiler.hooks.done.tap('rsbuild:done', (stats)=>{
+    return compiler.hooks.done.tap('rsbuild:done', (stats)=>{
         done(stats);
-    });
-    if ((null === (_context_normalizedConfig = context.normalizedConfig) || void 0 === _context_normalizedConfig ? void 0 : _context_normalizedConfig.mode) === 'development') (0, shared /* registerDevHook */ .xn)({
+    }), (null === (_context_normalizedConfig = context.normalizedConfig) || void 0 === _context_normalizedConfig ? void 0 : _context_normalizedConfig.mode) === 'development' && helpers.registerDevHook({
         compiler,
         context,
         bundlerConfigs: webpackConfigs,
-        MultiStatsCtor: __WEBPACK_EXTERNAL_MODULE_webpack_lib_MultiStats_js__["default"]
-    });
-    await context.hooks.onAfterCreateCompiler.call({
+        MultiStatsCtor: __WEBPACK_EXTERNAL_MODULE_webpack_lib_MultiStats_js__.default
+    }), await context.hooks.onAfterCreateCompiler.call({
         compiler,
         environments: context.environments
-    });
-    core_.logger.debug('create compiler done');
-    return {
+    }), core_.logger.debug('create compiler done'), {
         compiler,
         webpackConfigs
     };
 }
-const build = async (initOptions, { watch, compiler: customCompiler } = {})=>{
-    const { context } = initOptions;
-    let compiler;
-    let bundlerConfigs;
+let build = async (initOptions, { watch, compiler: customCompiler } = {})=>{
+    let compiler, bundlerConfigs;
+    let { helpers, context } = initOptions;
     if (customCompiler) compiler = customCompiler;
     else {
-        const result = await createCompiler_createCompiler(initOptions);
-        compiler = result.compiler;
-        bundlerConfigs = result.webpackConfigs;
+        let result = await createCompiler_createCompiler(initOptions);
+        compiler = result.compiler, bundlerConfigs = result.webpackConfigs;
     }
-    (0, shared /* registerBuildHook */ .Oo)({
+    if (helpers.registerBuildHook({
         context,
         bundlerConfigs: bundlerConfigs,
         compiler,
-        isWatch: Boolean(watch),
-        MultiStatsCtor: __WEBPACK_EXTERNAL_MODULE_webpack_lib_MultiStats_js__["default"]
-    });
-    if (watch) {
-        const watching = compiler.watch({}, (err)=>{
-            if (err) core_.logger.error(err);
-        });
-        return {
-            close: ()=>new Promise((resolve)=>{
-                    watching.close(()=>{
-                        resolve();
-                    });
-                })
-        };
-    }
-    const { stats } = await new Promise((resolve, reject)=>{
+        isWatch: !!watch,
+        MultiStatsCtor: __WEBPACK_EXTERNAL_MODULE_webpack_lib_MultiStats_js__.default
+    }), watch) return compiler.watch({}, (err)=>{
+        err && core_.logger.error(err);
+    }), {
+        close: ()=>new Promise((resolve)=>{
+                compiler.close(()=>{
+                    resolve();
+                });
+            })
+    };
+    let { stats } = await new Promise((resolve, reject)=>{
         compiler.run((err, stats)=>{
-            if (err) reject(err);
-            else if (null == stats ? void 0 : stats.hasErrors()) reject(new Error('Webpack build failed!'));
-            else // When using run or watch, call close and wait for it to finish before calling run or watch again.
-            // Concurrent compilations will corrupt the output files.
-            compiler.close((closeErr)=>{
-                closeErr && core_.logger.error(closeErr);
-                resolve({
+            err ? reject(err) : (null == stats ? void 0 : stats.hasErrors()) ? reject(Error('Webpack build failed!')) : compiler.close((closeErr)=>{
+                closeErr && core_.logger.error(closeErr), resolve({
                     stats
                 });
             });
@@ -448,157 +282,134 @@ const build = async (initOptions, { watch, compiler: customCompiler } = {})=>{
     });
     return {
         stats,
-        // This close method is a noop in non-watch mode
-        // In watch mode, it's defined above to stop watching
-        close: async ()=>{}
+        close: ()=>new Promise((resolve)=>{
+                compiler.close(()=>{
+                    resolve();
+                });
+            })
     };
 };
 async function applyTsConfigPathsPlugin({ chain, CHAIN_ID, mainFields, extensions, configFile }) {
-    const { TsconfigPathsPlugin } = await import("tsconfig-paths-webpack-plugin");
+    let { TsconfigPathsPlugin } = await import("tsconfig-paths-webpack-plugin");
     chain.resolve.plugin(CHAIN_ID.RESOLVE_PLUGIN.TS_CONFIG_PATHS).use(TsconfigPathsPlugin, [
         {
             configFile,
             extensions,
-            // https://github.com/dividab/tsconfig-paths-webpack-plugin/pull/106
             mainFields: mainFields
         }
     ]);
 }
-function isWebTarget(target) {
-    const targets = (0, shared /* castArray */ .XQ)(target);
-    return targets.includes('web') || target.includes('web-worker');
-}
-const getMainFields = (chain, target)=>{
-    const mainFields = chain.resolve.mainFields.values();
+let getMainFields = (chain, target)=>{
+    var target1;
+    let mainFields = chain.resolve.mainFields.values();
     if (mainFields.length) return mainFields;
-    if (isWebTarget(target)) return [
+    return castArray(target1 = target).includes('web') || target1.includes('web-worker') ? [
         'browser',
         'module',
         'main'
-    ];
-    return [
+    ] : [
         'module',
         'main'
     ];
-};
-/**
- * Handling differences between Webpack and Rspack
- */ const pluginAdaptor = ()=>({
+}, pluginAdaptor = (helpers)=>({
         name: 'rsbuild-webpack:adaptor',
         setup (api) {
             api.modifyBundlerChain(async (chain, { CHAIN_ID, environment, target })=>{
-                const { config, tsconfigPath } = environment;
-                if (tsconfigPath && 'prefer-tsconfig' === config.source.aliasStrategy) await applyTsConfigPathsPlugin({
+                let { config, tsconfigPath } = environment;
+                tsconfigPath && 'prefer-tsconfig' === config.source.aliasStrategy && await applyTsConfigPathsPlugin({
                     chain,
                     CHAIN_ID,
                     configFile: tsconfigPath,
                     mainFields: getMainFields(chain, target),
                     extensions: chain.resolve.extensions.values()
                 });
-                // enable progress bar for webpack by default
-                const progress = config.dev.progressBar ?? true;
+                let progress = config.dev.progressBar ?? !0;
                 if (progress) {
-                    const { ProgressPlugin } = await Promise.all(/* import() */ [
+                    let { ProgressPlugin } = await Promise.all([
                         __webpack_require__.e("997"),
                         __webpack_require__.e("238")
                     ]).then(__webpack_require__.bind(__webpack_require__, "./src/progress/ProgressPlugin.ts"));
                     chain.plugin(CHAIN_ID.PLUGIN.PROGRESS).use(ProgressPlugin, [
                         {
                             id: environment.name,
-                            ...true === progress ? {} : progress
+                            prettyTime: helpers.prettyTime,
+                            ...!0 === progress ? {} : progress
                         }
                     ]);
                 }
-                const { copy } = config.output;
+                let { copy } = config.output;
                 if (copy) {
-                    const { default: CopyPlugin } = await import("copy-webpack-plugin");
-                    const options = Array.isArray(copy) ? {
+                    let { default: CopyPlugin } = await import("copy-webpack-plugin"), options = Array.isArray(copy) ? {
                         patterns: copy
                     } : copy;
                     chain.plugin(CHAIN_ID.PLUGIN.COPY).use(CopyPlugin, [
-                        // @ts-expect-error to type mismatch
                         options
                     ]);
                 }
-            });
-            api.modifyWebpackConfig(async (config)=>{
-                var _config_plugins;
-                const copyPlugin = null === (_config_plugins = config.plugins) || void 0 === _config_plugins ? void 0 : _config_plugins.find((item)=>(null == item ? void 0 : item.constructor.name) === 'CopyPlugin');
-                if (copyPlugin) {
-                    // If the pattern.context directory not exists, we should remove CopyPlugin.
-                    // Otherwise the CopyPlugin will cause the webpack to re-compile.
-                    const isContextNotExists = copyPlugin.patterns.every((pattern)=>'string' != typeof pattern && pattern.context && !__WEBPACK_EXTERNAL_MODULE_node_fs__["default"].existsSync(pattern.context));
-                    if (isContextNotExists) {
-                        var _config_plugins1;
-                        config.plugins = null === (_config_plugins1 = config.plugins) || void 0 === _config_plugins1 ? void 0 : _config_plugins1.filter((item)=>(null == item ? void 0 : item.constructor.name) !== 'CopyPlugin');
-                    }
-                }
+            }), api.modifyWebpackConfig(async (config)=>{
+                var _config_plugins, _config_plugins1;
+                let copyPlugin = null === (_config_plugins = config.plugins) || void 0 === _config_plugins ? void 0 : _config_plugins.find((item)=>(null == item ? void 0 : item.constructor.name) === 'CopyPlugin');
+                copyPlugin && copyPlugin.patterns.every((pattern)=>'string' != typeof pattern && pattern.context && !__WEBPACK_EXTERNAL_MODULE_node_fs__.default.existsSync(pattern.context)) && (config.plugins = null === (_config_plugins1 = config.plugins) || void 0 === _config_plugins1 ? void 0 : _config_plugins1.filter((item)=>(null == item ? void 0 : item.constructor.name) !== 'CopyPlugin'));
             });
         }
-    });
-const webpackProvider = async ({ context, pluginManager, rsbuildOptions, setCssExtractPlugin })=>{
-    const { default: cssExtractPlugin } = await import("mini-css-extract-plugin");
-    setCssExtractPlugin(cssExtractPlugin);
-    const createCompiler = async ()=>{
-        const result = await createCompiler_createCompiler({
+    }), webpackProvider = async ({ context, pluginManager, rsbuildOptions, helpers })=>{
+    let { default: cssExtractPlugin } = await import("mini-css-extract-plugin");
+    helpers.setCssExtractPlugin(cssExtractPlugin);
+    let createCompiler = async ()=>(await createCompiler_createCompiler({
             context,
             pluginManager,
-            rsbuildOptions
-        });
-        return result.compiler;
-    };
-    pluginManager.addPlugins([
-        pluginAdaptor()
-    ]);
-    return {
+            rsbuildOptions,
+            helpers
+        })).compiler;
+    return pluginManager.addPlugins([
+        pluginAdaptor(helpers)
+    ]), {
         bundler: 'webpack',
         createCompiler,
         async initConfigs () {
-            const { webpackConfigs } = await initConfigs({
+            let { webpackConfigs } = await initConfigs({
                 context,
                 pluginManager,
-                rsbuildOptions
+                rsbuildOptions,
+                helpers
             });
             return webpackConfigs;
         },
         async createDevServer (options) {
-            const config = await (0, shared /* initRsbuildConfig */ .A9)({
+            let config = await helpers.initRsbuildConfig({
                 context,
                 pluginManager
             });
-            return (0, shared /* createDevServer */ .PZ)({
+            return helpers.createDevServer({
                 context,
                 pluginManager,
                 rsbuildOptions
             }, createCompiler, config, options);
         },
         async startDevServer (options) {
-            const config = await (0, shared /* initRsbuildConfig */ .A9)({
+            let config = await helpers.initRsbuildConfig({
                 context,
                 pluginManager
             });
-            const server = await (0, shared /* createDevServer */ .PZ)({
+            return (await helpers.createDevServer({
                 context,
                 pluginManager,
                 rsbuildOptions
-            }, createCompiler, config, options);
-            return server.listen();
+            }, createCompiler, config, options)).listen();
         },
-        async build (options) {
-            return build({
+        build: async (options)=>build({
                 context,
                 pluginManager,
-                rsbuildOptions
-            }, options);
-        },
-        async inspectConfig (inspectOptions) {
-            return await inspectConfig({
+                rsbuildOptions,
+                helpers
+            }, options),
+        inspectConfig: async (inspectOptions)=>await inspectConfig({
                 context,
                 pluginManager,
                 rsbuildOptions,
-                inspectOptions
-            });
-        }
+                inspectOptions,
+                helpers
+            })
     };
 };
 export { webpackProvider };