@rsbuild/core 0.0.21 → 0.0.23

package/dist/cli/commands.js

@@ -23,7 +23,7 @@ __export(commands_exports, {
 module.exports = __toCommonJS(commands_exports);
 var import_path = require("path");
 var import_shared = require("@rsbuild/shared");
-var import_commander = require("commander");
+var import_commander = require("../../compiled/commander");
 function setupProgram(rsbuild) {
   const pkgJson = (0, import_path.join)(__dirname, "../../package.json");
   const { version } = import_shared.fse.readJSONSync(pkgJson);

package/dist/cli/config.d.ts

@@ -1,8 +1,5 @@
-import type { RsbuildEntry, RsbuildPlugin, RsbuildConfig as BaseRsbuildConfig } from '@rsbuild/shared';
+import type { RsbuildPlugin, RsbuildConfig as BaseRsbuildConfig } from '@rsbuild/shared';
 export type RsbuildConfig = BaseRsbuildConfig & {
-  source?: {
-    entries?: RsbuildEntry;
-  };
   plugins?: RsbuildPlugin[];
   /**
    * @private only for testing
@@ -10,7 +7,4 @@ export type RsbuildConfig = BaseRsbuildConfig & {
   provider?: any;
 };
 export declare const defineConfig: (config: RsbuildConfig) => RsbuildConfig;
-export declare function loadConfig(): Promise<ReturnType<typeof defineConfig>>;
-export declare function getDefaultEntries(): {
-  index: string;
-};
+export declare function loadConfig(): Promise<ReturnType<typeof defineConfig>>;

package/dist/cli/config.js

@@ -29,14 +29,12 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var config_exports = {};
 __export(config_exports, {
   defineConfig: () => defineConfig,
-  getDefaultEntries: () => getDefaultEntries,
   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_restart = require("../server/restart");
 const defineConfig = (config) => config;
 const resolveConfigPath = () => {
@@ -84,24 +82,8 @@ async function loadConfig() {
   }
   return {};
 }
-function getDefaultEntries() {
-  const cwd = process.cwd();
-  const files = ["ts", "tsx", "js", "jsx"].map(
-    (ext) => (0, import_path.join)(cwd, `src/index.${ext}`)
-  );
-  const entryFile = (0, import_shared.findExists)(files);
-  if (entryFile) {
-    return {
-      index: entryFile
-    };
-  }
-  throw new Error(
-    "Could not find the entry file, please make sure that `src/index.(js|ts|tsx|jsx)` exists, or customize entry through the `source.entries` configuration."
-  );
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   defineConfig,
-  getDefaultEntries,
   loadConfig
 });

package/dist/cli/run.d.ts

@@ -1,4 +1,4 @@
-import { RsbuildPlugin } from '..';
+import { type RsbuildPlugin } from '..';
 type RunCliOptions = {
   isRestart?: boolean;
   defaultPlugins?: RsbuildPlugin[];

package/dist/cli/run.js

@@ -25,11 +25,9 @@ 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) {

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/createRsbuild.js

@@ -42,7 +42,6 @@ const getRspackProvider = async (rsbuildConfig) => {
 };
 const getCreateRsbuildDefaultOptions = () => ({
   cwd: process.cwd(),
-  entry: {},
   target: ["web"],
   configPath: 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 { RsbuildMode, RsbuildEntry, RsbuildTarget, RsbuildPlugin, Context, RsbuildInstance, CreateRsbuildOptions, InspectConfigOptions, OnExitFn, OnAfterBuildFn, OnAfterCreateCompilerFn, OnAfterStartDevServerFn, OnBeforeBuildFn, OnBeforeStartDevServerFn, OnBeforeCreateCompilerFn, OnDevCompileDoneFn, ModifyRsbuildConfigFn } from '@rsbuild/shared';
+export type { Rspack, RsbuildConfig, RsbuildPlugin, RsbuildPluginAPI } from './rspack-provider';
+export type { Context, RsbuildMode, RsbuildEntry, RsbuildTarget, RsbuildInstance, CreateRsbuildOptions, InspectConfigOptions, OnExitFn, OnAfterBuildFn, OnAfterCreateCompilerFn, OnAfterStartDevServerFn, OnBeforeBuildFn, OnBeforeStartDevServerFn, OnBeforeCreateCompilerFn, OnDevCompileDoneFn, ModifyRsbuildConfigFn } from '@rsbuild/shared';

package/dist/plugins/fileSize.js

@@ -35,7 +35,6 @@ module.exports = __toCommonJS(fileSize_exports);
 var import_path = __toESM(require("path"));
 var import_shared = require("@rsbuild/shared");
 var import_shared2 = require("@rsbuild/shared");
-var import_gzip_size = __toESM(require("gzip-size"));
 const filterAsset = (asset) => !/\.map$/.test(asset) && !/\.LICENSE\.txt$/.test(asset);
 const getAssetColor = (size) => {
   if (size > 300 * 1e3) {
@@ -63,10 +62,11 @@ const calcFileSize = (len) => {
   return `${val.toFixed(val < 1 ? 2 : 1)} kB`;
 };
 async function printFileSizes(stats, distPath) {
+  const { default: gzipSize } = await Promise.resolve().then(() => __toESM(require("@rsbuild/shared/gzip-size")));
   const formatAsset = (asset) => {
     const contents = import_shared.fse.readFileSync(import_path.default.join(distPath, asset.name));
     const size = contents.length;
-    const gzippedSize = import_gzip_size.default.sync(contents);
+    const gzippedSize = gzipSize.sync(contents);
     return {
       size,
       folder: import_path.default.join(import_path.default.basename(distPath), import_path.default.dirname(asset.name)),

package/dist/plugins/html.js

@@ -178,7 +178,7 @@ const pluginHtml = () => ({
         const htmlPaths = api.getHTMLPaths();
         const htmlInfoMap = {};
         await Promise.all(
-          entryNames.map(async (entryName, index) => {
+          entryNames.map(async (entryName) => {
             const entryValue = entries[entryName].values();
             const chunks = getChunks(entryName, entryValue);
             const inject = getInject(entryName, config);

package/dist/plugins/index.js

@@ -46,7 +46,6 @@ const plugins = {
   inlineChunk: () => Promise.resolve().then(() => __toESM(require("./inlineChunk"))).then((m) => m.pluginInlineChunk()),
   bundleAnalyzer: () => Promise.resolve().then(() => __toESM(require("./bundleAnalyzer"))).then((m) => m.pluginBundleAnalyzer()),
   asset: () => Promise.resolve().then(() => __toESM(require("./asset"))).then((m) => m.pluginAsset()),
-  rem: () => Promise.resolve().then(() => __toESM(require("./rem"))).then((m) => m.pluginRem()),
   wasm: () => Promise.resolve().then(() => __toESM(require("./wasm"))).then((m) => m.pluginWasm()),
   moment: () => Promise.resolve().then(() => __toESM(require("./moment"))).then((m) => m.pluginMoment()),
   nodeAddons: () => Promise.resolve().then(() => __toESM(require("./nodeAddons"))).then((m) => m.pluginNodeAddons()),

package/dist/plugins/startUrl.js

@@ -80,7 +80,7 @@ async function openBrowser(url) {
     }
   }
   try {
-    const { default: open } = await Promise.resolve().then(() => __toESM(require("open")));
+    const { default: open } = await Promise.resolve().then(() => __toESM(require("../../compiled/open")));
     await open(url);
     return true;
   } catch (err) {

package/dist/rspack-provider/core/createCompiler.d.ts

@@ -9,4 +9,4 @@ export declare function createCompiler({
   context: Context;
   rspackConfigs: RspackConfig[];
 }): Promise<import("@rspack/core").MultiCompiler>;
-export declare function startDevCompile(options: InitConfigsOptions, customCompiler?: RspackCompiler | RspackMultiCompiler): Promise<import("@rsbuild/shared").DevMiddleware>;
+export declare function createDevMiddleware(options: InitConfigsOptions, customCompiler?: RspackCompiler | RspackMultiCompiler): Promise<import("@rsbuild/shared").DevMiddleware>;

package/dist/rspack-provider/core/createCompiler.js

@@ -29,7 +29,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var createCompiler_exports = {};
 __export(createCompiler_exports, {
   createCompiler: () => createCompiler,
-  startDevCompile: () => startDevCompile
+  createDevMiddleware: () => createDevMiddleware
 });
 module.exports = __toCommonJS(createCompiler_exports);
 var import_shared = require("@rsbuild/shared");
@@ -82,7 +82,7 @@ async function createCompiler({
   (0, import_shared.debug)("create compiler done");
   return compiler;
 }
-async function startDevCompile(options, customCompiler) {
+async function createDevMiddleware(options, customCompiler) {
   let compiler;
   if (customCompiler) {
     compiler = customCompiler;
@@ -98,5 +98,5 @@ async function startDevCompile(options, customCompiler) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   createCompiler,
-  startDevCompile
+  createDevMiddleware
 });

package/dist/rspack-provider/core/createContext.js

@@ -29,8 +29,9 @@ async function createContext(options, userRsbuildConfig) {
   const rsbuildConfig = (0, import_defaults.withDefaultConfig)(userRsbuildConfig);
   const context = (0, import_shared.createContextByConfig)(
     options,
-    rsbuildConfig.output,
-    "rspack"
+    "rspack",
+    rsbuildConfig.source,
+    rsbuildConfig.output
   );
   const tsconfigPath = (0, import_path.join)(context.rootPath, import_shared.TS_CONFIG_FILE);
   return {

package/dist/rspack-provider/core/rspackConfig.js

@@ -53,7 +53,7 @@ async function modifyRspackConfig(context, rspackConfig, utils) {
 }
 async function getConfigUtils(config, chainUtils) {
   const { merge } = await Promise.resolve().then(() => __toESM(require("@rsbuild/shared/webpack-merge")));
-  const { default: rspack } = await Promise.resolve().then(() => __toESM(require("@rspack/core")));
+  const rspack = await Promise.resolve().then(() => __toESM(require("@rspack/core")));
   return {
     ...chainUtils,
     rspack,

package/dist/rspack-provider/index.d.ts

@@ -1,5 +1,5 @@
 export { getRspackVersion } from './shared/rspackVersion';
 export { rspackProvider } from './provider';
 export type { RspackProvider } from './provider';
-export type { RsbuildConfig, NormalizedConfig, RsbuildPluginAPI } from './types';
+export type { RsbuildConfig, NormalizedConfig, RsbuildPlugin, RsbuildPluginAPI } from './types';
 export type { Rspack, RspackConfig } from '@rsbuild/shared';

package/dist/rspack-provider/plugins/css.js

@@ -90,11 +90,7 @@ async function applyBaseCSSRule({
     rule.use(CHAIN_ID.USE.CSS).loader((0, import_shared2.getCompiledPath)("css-loader")).options(cssLoaderOptions).end();
   } else {
     if (!isServer && !isWebWorker && enableCSSModuleTS) {
-      const { cssModules, disableCssModuleExtension } = config.output;
-      const cssModulesAuto = (0, import_shared.getCssModulesAutoRule)(
-        cssModules,
-        disableCssModuleExtension
-      );
+      const { cssModules } = config.output;
       rule.use(CHAIN_ID.USE.CSS_MODULES_TS).loader(
         import_path.default.resolve(
           __dirname,
@@ -103,7 +99,7 @@ async function applyBaseCSSRule({
       ).options({
         modules: {
           exportLocalsConvention: cssModules.exportLocalsConvention,
-          auto: cssModulesAuto
+          auto: cssModules.auto
         }
       }).end();
     }
@@ -129,10 +125,7 @@ const applyCSSModuleRule = (rules, ruleTest, config) => {
   if (ruleIndex === -1) {
     return;
   }
-  const cssModulesAuto = (0, import_shared.getCssModulesAutoRule)(
-    config.output.cssModules,
-    config.output.disableCssModuleExtension
-  );
+  const cssModulesAuto = config.output.cssModules.auto;
   if (!cssModulesAuto) {
     return;
   }