@rsbuild/core 0.0.20 → 0.0.22

package/dist/cli/commands.js

@@ -22,11 +22,11 @@ __export(commands_exports, {
 });
 module.exports = __toCommonJS(commands_exports);
 var import_path = require("path");
-var import_fs_extra = require("@rsbuild/shared/fs-extra");
+var import_shared = require("@rsbuild/shared");
 var import_commander = require("commander");
 function setupProgram(rsbuild) {
   const pkgJson = (0, import_path.join)(__dirname, "../../package.json");
-  const { version } = import_fs_extra.fs.readJSONSync(pkgJson);
+  const { version } = import_shared.fse.readJSONSync(pkgJson);
   import_commander.program.name("rsbuild").usage("<command> [options]").version(version);
   import_commander.program.command("dev").option(`--open`, "open the page in browser on startup").description("starting the dev server").action(async (options) => {
     await rsbuild.startDevServer({

package/dist/cli/config.js

@@ -33,10 +33,11 @@ __export(config_exports, {
   loadConfig: () => loadConfig
 });
 module.exports = __toCommonJS(config_exports);
+var import_fs = __toESM(require("fs"));
 var import_jiti = __toESM(require("jiti"));
 var import_path = require("path");
 var import_shared = require("@rsbuild/shared");
-var import_fs_extra = require("@rsbuild/shared/fs-extra");
+var import_restart = require("../server/restart");
 const defineConfig = (config) => config;
 const resolveConfigPath = () => {
   const CONFIG_FILES = [
@@ -50,19 +51,35 @@ const resolveConfigPath = () => {
   const root = process.cwd();
   for (const file of CONFIG_FILES) {
     const configFile = (0, import_path.join)(root, file);
-    if (import_fs_extra.fs.existsSync(configFile)) {
+    if (import_fs.default.existsSync(configFile)) {
       return configFile;
     }
   }
   return null;
 };
+async function watchConfig(configFile) {
+  const chokidar = await Promise.resolve().then(() => __toESM(require("@rsbuild/shared/chokidar")));
+  const watcher = chokidar.watch(configFile, {});
+  const callback = async () => {
+    watcher.close();
+    await (0, import_restart.restartDevServer)({ filePath: configFile });
+  };
+  watcher.on("change", callback);
+  watcher.on("unlink", callback);
+}
 async function loadConfig() {
   const configFile = resolveConfigPath();
   if (configFile) {
     const loadConfig2 = (0, import_jiti.default)(__filename, {
       esmResolve: true,
+      // disable require cache to support restart CLI and read the new config
+      requireCache: false,
       interopDefault: true
     });
+    const command = process.argv[2];
+    if (command === "dev") {
+      watchConfig(configFile);
+    }
     return loadConfig2(configFile);
   }
   return {};

package/dist/cli/index.d.ts

@@ -1,6 +1,2 @@
-import { RsbuildPlugin } from '..';
 export { defineConfig } from './config';
-type RunCliOptions = {
-  defaultPlugins?: RsbuildPlugin[];
-};
-export declare function runCli(options?: RunCliOptions): Promise<void>;
+export { runCli } from './run';

package/dist/cli/index.js

@@ -18,30 +18,12 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var cli_exports = {};
 __export(cli_exports, {
-  defineConfig: () => import_config2.defineConfig,
-  runCli: () => runCli
+  defineConfig: () => import_config.defineConfig,
+  runCli: () => import_run.runCli
 });
 module.exports = __toCommonJS(cli_exports);
-var import__ = require("..");
-var import_commands = require("./commands");
 var import_config = require("./config");
-var import_config2 = require("./config");
-async function runCli(options = {}) {
-  var _a;
-  const config = await (0, import_config.loadConfig)();
-  const rsbuild = await (0, import__.createRsbuild)({
-    rsbuildConfig: config,
-    entry: ((_a = config.source) == null ? void 0 : _a.entries) || (0, import_config.getDefaultEntries)(),
-    provider: config.provider
-  });
-  if (options.defaultPlugins) {
-    rsbuild.addPlugins(options.defaultPlugins);
-  }
-  if (config.plugins) {
-    rsbuild.addPlugins(config.plugins);
-  }
-  (0, import_commands.setupProgram)(rsbuild);
-}
+var import_run = require("./run");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   defineConfig,

package/dist/cli/run.d.ts

@@ -0,0 +1,7 @@
+import { RsbuildPlugin } from '..';
+type RunCliOptions = {
+  isRestart?: boolean;
+  defaultPlugins?: RsbuildPlugin[];
+};
+export declare function runCli(options?: RunCliOptions): Promise<import("..").RsbuildInstance<any>>;
+export {};

package/dist/cli/run.js

@@ -0,0 +1,49 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var run_exports = {};
+__export(run_exports, {
+  runCli: () => runCli
+});
+module.exports = __toCommonJS(run_exports);
+var import__ = require("..");
+var import_commands = require("./commands");
+var import_config = require("./config");
+async function runCli(options = {}) {
+  var _a;
+  const config = await (0, import_config.loadConfig)();
+  const rsbuild = await (0, import__.createRsbuild)({
+    rsbuildConfig: config,
+    entry: ((_a = config.source) == null ? void 0 : _a.entries) || (0, import_config.getDefaultEntries)(),
+    provider: config.provider
+  });
+  if (options.defaultPlugins) {
+    rsbuild.addPlugins(options.defaultPlugins);
+  }
+  if (config.plugins) {
+    rsbuild.addPlugins(config.plugins);
+  }
+  if (!options.isRestart) {
+    (0, import_commands.setupProgram)(rsbuild);
+  }
+  return rsbuild;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  runCli
+});

package/dist/client/hmr.js

@@ -0,0 +1,418 @@
+"use strict";
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+var createSocketUrl = function createSocketUrl(resourceQuery) {
+    var searchParams = resourceQuery.substr(1).split("&");
+    var options = {};
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = searchParams[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var pair = _step.value;
+            var ary = pair.split("=");
+            options[ary[0]] = decodeURIComponent(ary[1]);
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    var currentLocation = self.location;
+    return getSocketUrl(options, currentLocation);
+};
+var formatURL = function formatURL(param) {
+    var port = param.port, protocol = param.protocol, hostname = param.hostname, pathname = param.pathname;
+    if (window.URL) {
+        var url = new URL("http://localhost");
+        url.port = port;
+        url.hostname = hostname;
+        url.protocol = protocol;
+        url.pathname = pathname;
+        return url.toString();
+    }
+    var colon = protocol.indexOf(":") === -1 ? ":" : "";
+    return "".concat(protocol).concat(colon, "//").concat(hostname, ":").concat(port).concat(pathname);
+};
+var getSocketUrl = function getSocketUrl(urlParts, location) {
+    var host = urlParts.host, port = urlParts.port, path = urlParts.path, protocol = urlParts.protocol;
+    return formatURL({
+        protocol: protocol || (location.protocol === "https:" ? "wss" : "ws"),
+        hostname: host || location.hostname,
+        port: port || location.port,
+        pathname: path || HMR_SOCK_PATH
+    });
+};
+var clearOutdatedErrors = function clearOutdatedErrors() {
+    if (typeof console !== "undefined" && typeof console.clear === "function") {
+        if (hasCompileErrors) {
+            console.clear();
+        }
+    }
+};
+var handleSuccess = function handleSuccess() {
+    clearOutdatedErrors();
+    var isHotUpdate = !isFirstCompilation;
+    isFirstCompilation = false;
+    hasCompileErrors = false;
+    if (isHotUpdate) {
+        tryApplyUpdates();
+    }
+};
+var handleWarnings = function handleWarnings(warnings) {
+    clearOutdatedErrors();
+    var isHotUpdate = !isFirstCompilation;
+    isFirstCompilation = false;
+    hasCompileErrors = false;
+    function printWarnings() {
+        var formatted = (0, import_format_stats.formatStatsMessages)({
+            warnings: warnings,
+            errors: []
+        });
+        if (typeof console !== "undefined" && typeof console.warn === "function") {
+            for(var i = 0; i < formatted.warnings.length; i++){
+                if (i === 5) {
+                    console.warn("There were more warnings in other files.\nYou can find a complete log in the terminal.");
+                    break;
+                }
+                console.warn(formatted.warnings[i]);
+            }
+        }
+    }
+    printWarnings();
+    if (isHotUpdate) {
+        tryApplyUpdates();
+    }
+};
+var handleErrors = function handleErrors(errors) {
+    clearOutdatedErrors();
+    isFirstCompilation = false;
+    hasCompileErrors = true;
+    var formatted = (0, import_format_stats.formatStatsMessages)({
+        errors: errors,
+        warnings: []
+    });
+    if (typeof console !== "undefined" && typeof console.error === "function") {
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            for(var _iterator = formatted.errors[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                var error = _step.value;
+                console.error(error);
+            }
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            } finally{
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
+            }
+        }
+    }
+};
+var handleAvailableHash = function handleAvailableHash(hash) {
+    mostRecentCompilationHash = hash;
+};
+var isUpdateAvailable = function isUpdateAvailable() {
+    return mostRecentCompilationHash !== __webpack_hash__;
+};
+var canApplyUpdates = function canApplyUpdates() {
+    return module.hot.status() === "idle";
+};
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = function(cb, mod) {
+    return function __require() {
+        return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = {
+            exports: {}
+        }).exports, mod), mod.exports;
+    };
+};
+var __copyProps = function(to, from, except, desc) {
+    if (from && typeof from === "object" || typeof from === "function") {
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            var _loop = function() {
+                var key = _step.value;
+                if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+                    get: function() {
+                        return from[key];
+                    },
+                    enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+                });
+            };
+            for(var _iterator = __getOwnPropNames(from)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true)_loop();
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            } finally{
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
+            }
+        }
+    }
+    return to;
+};
+var __toESM = function(mod, isNodeMode, target) {
+    return target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(// If the importer is in node compatibility mode or this is not an ESM
+    // file that has been converted to a CommonJS file using a Babel-
+    // compatible transform (i.e. "__esModule" has not been set), then set
+    // "default" to the CommonJS "module.exports" for node compatibility.
+    isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+        value: mod,
+        enumerable: true
+    }) : target, mod);
+};
+// ../shared/dist/formatStats.js
+var require_formatStats = __commonJS({
+    "../shared/dist/formatStats.js": function(exports2, module2) {
+        "use strict";
+        var isLikelyASyntaxError = function isLikelyASyntaxError(message) {
+            return message.includes(friendlySyntaxErrorLabel);
+        };
+        var formatMessage = function formatMessage(stats) {
+            var lines = [];
+            var message;
+            if (typeof stats === "object") {
+                var fileName = stats.moduleName ? "File: ".concat(stats.moduleName, "\n") : "";
+                var mainMessage = typeof stats.formatted === "string" ? stats.formatted : stats.message;
+                var details = stats.details ? "\nDetails: ".concat(stats.details, "\n") : "";
+                var stack = stats.stack ? "\n".concat(stats.stack) : "";
+                message = "".concat(fileName).concat(mainMessage).concat(details).concat(stack);
+            } else {
+                message = stats;
+            }
+            lines = message.split("\n");
+            lines = lines.map(function(line) {
+                var parsingError = /Line (\d+):(?:(\d+):)?\s*Parsing error: (.+)$/.exec(line);
+                if (!parsingError) {
+                    return line;
+                }
+                var _parsingError = _sliced_to_array(parsingError, 4), errorLine = _parsingError[1], errorColumn = _parsingError[2], errorMessage = _parsingError[3];
+                return "".concat(friendlySyntaxErrorLabel, " ").concat(errorMessage, " (").concat(errorLine, ":").concat(errorColumn, ")");
+            });
+            message = lines.join("\n");
+            message = message.replace(/SyntaxError\s+\((\d+):(\d+)\)\s*(.+?)\n/g, "".concat(friendlySyntaxErrorLabel, " $3 ($1:$2)\n"));
+            lines = message.split("\n");
+            if (lines.length > 2 && lines[1].trim() === "") {
+                lines.splice(1, 1);
+            }
+            lines[0] = lines[0].replace(/^(.*) \d+:\d+-\d+$/, "$1");
+            if (lines[1] && lines[1].indexOf("Module not found:") !== -1) {
+                lines[1] = lines[1].replace("Error: ", "");
+            }
+            lines = lines.filter(function(line, index, arr) {
+                return index === 0 || line.trim() !== "" || line.trim() !== arr[index - 1].trim();
+            });
+            message = lines.join("\n");
+            return message.trim();
+        };
+        var formatStatsMessages2 = function formatStatsMessages2(json) {
+            var _a, _b, _c;
+            var formattedErrors = (_a = json == null ? void 0 : json.errors) == null ? void 0 : _a.map(formatMessage);
+            var formattedWarnings = (_b = json == null ? void 0 : json.warnings) == null ? void 0 : _b.map(formatMessage);
+            var result = {
+                errors: formattedErrors || [],
+                warnings: formattedWarnings || [],
+                errorTips: []
+            };
+            if ((_c = result.errors) == null ? void 0 : _c.some(isLikelyASyntaxError)) {
+                result.errors = result.errors.filter(isLikelyASyntaxError);
+            }
+            if (result.errors.length > 1) {
+                result.errors.length = 1;
+            }
+            return result;
+        };
+        var __defProp2 = Object.defineProperty;
+        var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+        var __getOwnPropNames2 = Object.getOwnPropertyNames;
+        var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+        var __export = function(target, all) {
+            for(var name in all)__defProp2(target, name, {
+                get: all[name],
+                enumerable: true
+            });
+        };
+        var __copyProps2 = function(to, from, except, desc) {
+            if (from && typeof from === "object" || typeof from === "function") {
+                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                try {
+                    var _loop = function() {
+                        var key = _step.value;
+                        if (!__hasOwnProp2.call(to, key) && key !== except) __defProp2(to, key, {
+                            get: function() {
+                                return from[key];
+                            },
+                            enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable
+                        });
+                    };
+                    for(var _iterator = __getOwnPropNames2(from)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true)_loop();
+                } catch (err) {
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                            _iterator.return();
+                        }
+                    } finally{
+                        if (_didIteratorError) {
+                            throw _iteratorError;
+                        }
+                    }
+                }
+            }
+            return to;
+        };
+        var __toCommonJS = function(mod) {
+            return __copyProps2(__defProp2({}, "__esModule", {
+                value: true
+            }), mod);
+        };
+        var formatStats_exports = {};
+        __export(formatStats_exports, {
+            formatStatsMessages: function() {
+                return formatStatsMessages2;
+            }
+        });
+        module2.exports = __toCommonJS(formatStats_exports);
+        var friendlySyntaxErrorLabel = "SyntaxError:";
+    }
+});
+// src/client/hmr/index.ts
+var import_format_stats = __toESM(require_formatStats());
+// src/client/hmr/createSocketUrl.ts
+var HMR_SOCK_PATH = "/rsbuild-hmr";
+// src/client/hmr/index.ts
+var hadRuntimeError = false;
+var socketUrl = createSocketUrl(__resourceQuery);
+var connection = new WebSocket(socketUrl);
+connection.onopen = function() {
+    if (typeof console !== "undefined" && typeof console.info === "function") {
+        console.info("[HMR] connected.");
+    }
+};
+connection.onclose = function() {
+    if (typeof console !== "undefined" && typeof console.info === "function") {
+        console.info("[HMR] disconnected. Refresh the page if necessary.");
+    }
+};
+var isFirstCompilation = true;
+var mostRecentCompilationHash = null;
+var hasCompileErrors = false;
+connection.onmessage = function(e) {
+    var message = JSON.parse(e.data);
+    switch(message.type){
+        case "hash":
+            handleAvailableHash(message.data);
+            break;
+        case "still-ok":
+        case "ok":
+            handleSuccess();
+            break;
+        case "content-changed":
+            window.location.reload();
+            break;
+        case "warnings":
+            handleWarnings(message.data);
+            break;
+        case "errors":
+            handleErrors(message.data);
+            break;
+        default:
+    }
+};
+function tryApplyUpdates() {
+    if (!module.hot) {
+        window.location.reload();
+        return;
+    }
+    if (!isUpdateAvailable() || !canApplyUpdates()) {
+        return;
+    }
+    function handleApplyUpdates(err, updatedModules) {
+        var wantsForcedReload = err || !updatedModules || hadRuntimeError;
+        if (wantsForcedReload) {
+            window.location.reload();
+            return;
+        }
+        if (isUpdateAvailable()) {
+            tryApplyUpdates();
+        }
+    }
+    var result = module.hot.check(/* autoApply */ true, handleApplyUpdates);
+    if (result === null || result === void 0 ? void 0 : result.then) {
+        result.then(function(updatedModules) {
+            handleApplyUpdates(null, updatedModules);
+        }, function(err) {
+            handleApplyUpdates(err, null);
+        });
+    }
+}

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 export { createRsbuild, getCreateRsbuildDefaultOptions } from './createRsbuild';
 export { mergeRsbuildConfig } from '@rsbuild/shared';
 export { defineConfig } from './cli';
-export type { RsbuildPluginAPI, RsbuildConfig } from './rspack-provider';
+export type { RsbuildPluginAPI, RsbuildConfig, Rspack } from './rspack-provider';
 export type { RsbuildMode, RsbuildEntry, RsbuildTarget, RsbuildPlugin, Context, RsbuildInstance, CreateRsbuildOptions, InspectConfigOptions, OnExitFn, OnAfterBuildFn, OnAfterCreateCompilerFn, OnAfterStartDevServerFn, OnBeforeBuildFn, OnBeforeStartDevServerFn, OnBeforeCreateCompilerFn, OnDevCompileDoneFn, ModifyRsbuildConfigFn } from '@rsbuild/shared';

package/dist/plugins/cache.js

@@ -33,18 +33,18 @@ __export(cache_exports, {
 module.exports = __toCommonJS(cache_exports);
 var import_crypto = __toESM(require("crypto"));
 var import_path = require("path");
-var import_fs_extra = require("@rsbuild/shared/fs-extra");
 var import_shared = require("@rsbuild/shared");
+var import_shared2 = require("@rsbuild/shared");
 async function validateCache(cacheDirectory, buildDependencies) {
   const configFile = (0, import_path.join)(cacheDirectory, "buildDependencies.json");
-  if (await (0, import_shared.isFileExists)(configFile)) {
-    const prevBuildDependencies = await import_fs_extra.fs.readJSON(configFile);
+  if (await (0, import_shared2.isFileExists)(configFile)) {
+    const prevBuildDependencies = await import_shared.fse.readJSON(configFile);
     if (JSON.stringify(prevBuildDependencies) === JSON.stringify(buildDependencies)) {
       return;
     }
-    await import_fs_extra.fs.remove(cacheDirectory);
+    await import_shared.fse.remove(cacheDirectory);
   }
-  await import_fs_extra.fs.outputJSON(configFile, buildDependencies);
+  await import_shared.fse.outputJSON(configFile, buildDependencies);
 }
 function getDigestHash(digest) {
   const fsHash = import_crypto.default.createHash("md5");
@@ -61,7 +61,7 @@ async function getBuildDependencies(context) {
   const rootPackageJson = (0, import_path.join)(context.rootPath, "package.json");
   const browserslistConfig = (0, import_path.join)(context.rootPath, ".browserslistrc");
   const buildDependencies = {};
-  if (await (0, import_shared.isFileExists)(rootPackageJson)) {
+  if (await (0, import_shared2.isFileExists)(rootPackageJson)) {
     buildDependencies.packageJson = [rootPackageJson];
   }
   if (context.configPath) {
@@ -70,14 +70,14 @@ async function getBuildDependencies(context) {
   if (context.tsconfigPath) {
     buildDependencies.tsconfig = [context.tsconfigPath];
   }
-  if (await (0, import_shared.isFileExists)(browserslistConfig)) {
+  if (await (0, import_shared2.isFileExists)(browserslistConfig)) {
     buildDependencies.browserslistrc = [browserslistConfig];
   }
   const tailwindExts = ["ts", "js", "cjs", "mjs"];
   const configs = tailwindExts.map(
     (ext) => (0, import_path.join)(context.rootPath, `tailwind.config.${ext}`)
   );
-  const tailwindConfig = (0, import_shared.findExists)(configs);
+  const tailwindConfig = (0, import_shared2.findExists)(configs);
   if (tailwindConfig) {
     buildDependencies.tailwindcss = [tailwindConfig];
   }

package/dist/plugins/cleanOutput.js

@@ -21,10 +21,10 @@ __export(cleanOutput_exports, {
   pluginCleanOutput: () => pluginCleanOutput
 });
 module.exports = __toCommonJS(cleanOutput_exports);
-var import_fs_extra = require("@rsbuild/shared/fs-extra");
+var import_shared = require("@rsbuild/shared");
 const emptyDir = async (dir) => {
-  if (await import_fs_extra.fs.pathExists(dir)) {
-    await import_fs_extra.fs.emptyDir(dir);
+  if (await import_shared.fse.pathExists(dir)) {
+    await import_shared.fse.emptyDir(dir);
   }
 };
 const pluginCleanOutput = () => ({