@rsbuild/core 0.3.11 → 0.4.1

package/dist/cli/commands.js

@@ -56,7 +56,7 @@ async function init({
     if ((0, import_shared.isDev)()) {
       (0, import_restart.onBeforeRestartServer)(envs.cleanup);
     }
-    const { content: config, filePath: configFilePath } = await (0, import_config.loadConfigV2)({
+    const { content: config, filePath: configFilePath } = await (0, import_config.loadConfig)({
       cwd: root,
       path: commonOpts.config,
       envMode: commonOpts.envMode
@@ -112,7 +112,7 @@ const applyServerOptions = (command) => {
   command.option("-o --open [url]", "open the page in browser on startup").option("--port <port>", "specify a port number for server to listen").option("--host <host>", "specify the host that the server listens to");
 };
 function runCli() {
-  import_commander.program.name("rsbuild").usage("<command> [options]").version("0.3.11");
+  import_commander.program.name("rsbuild").usage("<command> [options]").version("0.4.1");
   const devCommand = import_commander.program.command("dev");
   const buildCommand = import_commander.program.command("build");
   const previewCommand = import_commander.program.command("preview");

package/dist/cli/config.d.ts

@@ -16,12 +16,7 @@ export declare function defineConfig(config: RsbuildConfigSyncFn): RsbuildConfig
 export declare function defineConfig(config: RsbuildConfigAsyncFn): RsbuildConfigAsyncFn;
 export declare function defineConfig(config: RsbuildConfigExport): RsbuildConfigExport;
 export declare function watchFiles(files: string[]): Promise<void>;
-export declare function loadConfigByPath(configFile: string, envMode?: string): Promise<RsbuildConfig>;
-export declare function loadConfig({ cwd, path, }: {
-    cwd: string;
-    path?: string;
-}): Promise<RsbuildConfig>;
-export declare function loadConfigV2({ cwd, path, envMode, }: {
+export declare function loadConfig({ cwd, path, envMode, }: {
     cwd: string;
     path?: string;
     envMode?: string;

package/dist/cli/config.js

@@ -30,8 +30,6 @@ var config_exports = {};
 __export(config_exports, {
   defineConfig: () => defineConfig,
   loadConfig: () => loadConfig,
-  loadConfigByPath: () => loadConfigByPath,
-  loadConfigV2: () => loadConfigV2,
   watchFiles: () => watchFiles
 });
 module.exports = __toCommonJS(config_exports);
@@ -90,7 +88,18 @@ async function watchFiles(files) {
   watcher.on("change", callback);
   watcher.on("unlink", callback);
 }
-async function loadConfigByPath(configFile, envMode) {
+async function loadConfig({
+  cwd,
+  path,
+  envMode
+}) {
+  const configFile = resolveConfigPath(cwd, path);
+  if (!configFile) {
+    return {
+      content: {},
+      filePath: configFile
+    };
+  }
   try {
     const { default: jiti } = await Promise.resolve().then(() => __toESM(require("@rsbuild/shared/jiti")));
     const loadConfig2 = jiti(__filename, {
@@ -111,7 +120,10 @@ async function loadConfigByPath(configFile, envMode) {
       if (result === void 0) {
         throw new Error("Rsbuild config function must return a config object.");
       }
-      return result;
+      return {
+        content: result,
+        filePath: configFile
+      };
     }
     if (!(0, import_shared.isObject)(configExport)) {
       throw new Error(
@@ -120,44 +132,18 @@ async function loadConfigByPath(configFile, envMode) {
         )}`
       );
     }
-    return configExport;
-  } catch (err) {
-    import_shared.logger.error(`Failed to load file: ${import_shared.color.dim(configFile)}`);
-    throw err;
-  }
-}
-async function loadConfig({
-  cwd,
-  path
-}) {
-  const configFile = resolveConfigPath(cwd, path);
-  if (!configFile) {
-    return {};
-  }
-  return loadConfigByPath(configFile);
-}
-async function loadConfigV2({
-  cwd,
-  path,
-  envMode
-}) {
-  const configFile = resolveConfigPath(cwd, path);
-  if (!configFile) {
     return {
-      content: {},
+      content: configExport,
       filePath: configFile
     };
+  } catch (err) {
+    import_shared.logger.error(`Failed to load file: ${import_shared.color.dim(configFile)}`);
+    throw err;
   }
-  return {
-    content: await loadConfigByPath(configFile, envMode),
-    filePath: configFile
-  };
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   defineConfig,
   loadConfig,
-  loadConfigByPath,
-  loadConfigV2,
   watchFiles
 });

package/dist/cli/prepare.js

@@ -34,7 +34,7 @@ function prepareCli() {
   if (!npm_execpath || npm_execpath.includes("npx-cli.js")) {
     console.log();
   }
-  import_rslog.logger.greet(`  ${`Rsbuild v${"0.3.11"}`}
+  import_rslog.logger.greet(`  ${`Rsbuild v${"0.4.1"}`}
 `);
 }
 // Annotate the CommonJS export names for ESM import in node:

package/dist/constants.d.ts

@@ -2,5 +2,4 @@ export declare const PLUGIN_SWC_NAME = "rsbuild:swc";
 export declare const PLUGIN_CSS_NAME = "rsbuild:css";
 export declare const PLUGIN_LESS_NAME = "rsbuild:less";
 export declare const PLUGIN_SASS_NAME = "rsbuild:sass";
-export declare const PLUGIN_BABEL_NAME = "rsbuild:babel";
 export declare const PLUGIN_STYLUS_NAME = "rsbuild:stylus";

package/dist/constants.js

@@ -18,7 +18,6 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var constants_exports = {};
 __export(constants_exports, {
-  PLUGIN_BABEL_NAME: () => PLUGIN_BABEL_NAME,
   PLUGIN_CSS_NAME: () => PLUGIN_CSS_NAME,
   PLUGIN_LESS_NAME: () => PLUGIN_LESS_NAME,
   PLUGIN_SASS_NAME: () => PLUGIN_SASS_NAME,
@@ -30,11 +29,9 @@ const PLUGIN_SWC_NAME = "rsbuild:swc";
 const PLUGIN_CSS_NAME = "rsbuild:css";
 const PLUGIN_LESS_NAME = "rsbuild:less";
 const PLUGIN_SASS_NAME = "rsbuild:sass";
-const PLUGIN_BABEL_NAME = "rsbuild:babel";
 const PLUGIN_STYLUS_NAME = "rsbuild:stylus";
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  PLUGIN_BABEL_NAME,
   PLUGIN_CSS_NAME,
   PLUGIN_LESS_NAME,
   PLUGIN_SASS_NAME,

package/dist/createRsbuild.js

@@ -33,6 +33,7 @@ __export(createRsbuild_exports, {
 module.exports = __toCommonJS(createRsbuild_exports);
 var import_shared = require("@rsbuild/shared");
 var import_plugins = require("./plugins");
+var import_pluginManager = require("./pluginManager");
 const getRspackProvider = async () => {
   const { rspackProvider } = await Promise.resolve().then(() => __toESM(require("./provider")));
   return rspackProvider;
@@ -45,7 +46,7 @@ async function createRsbuild(options) {
     rsbuildConfig,
     ...options
   };
-  const pluginStore = (0, import_shared.createPluginStore)();
+  const pluginManager = (0, import_pluginManager.createPluginManager)();
   const {
     build,
     preview,
@@ -59,14 +60,14 @@ async function createRsbuild(options) {
     applyDefaultPlugins
   } = await provider({
     plugins: import_plugins.plugins,
-    pluginStore,
+    pluginManager,
     rsbuildOptions
   });
   (0, import_shared.debug)("add default plugins");
-  await applyDefaultPlugins(pluginStore);
+  await applyDefaultPlugins(pluginManager);
   (0, import_shared.debug)("add default plugins done");
   const rsbuild = {
-    ...(0, import_shared.pick)(pluginStore, ["addPlugins", "removePlugins", "isPluginExists"]),
+    ...(0, import_shared.pick)(pluginManager, ["addPlugins", "removePlugins", "isPluginExists"]),
     ...(0, import_shared.pick)(pluginAPI, [
       "onBeforeBuild",
       "onBeforeCreateCompiler",
@@ -76,6 +77,7 @@ async function createRsbuild(options) {
       "onAfterCreateCompiler",
       "onAfterStartDevServer",
       "onAfterStartProdServer",
+      "onCloseDevServer",
       "onDevCompileDone",
       "onExit",
       "getHTMLPaths",

package/dist/index.d.ts

@@ -7,7 +7,7 @@ export { createRsbuild } from './createRsbuild';
 export { loadConfig, defineConfig } from './cli/config';
 export declare const version: any;
 export { logger, mergeRsbuildConfig } from '@rsbuild/shared';
-export { PLUGIN_SWC_NAME, PLUGIN_CSS_NAME, PLUGIN_SASS_NAME, PLUGIN_LESS_NAME, PLUGIN_BABEL_NAME, PLUGIN_STYLUS_NAME, } from './constants';
+export { PLUGIN_SWC_NAME, PLUGIN_CSS_NAME, PLUGIN_SASS_NAME, PLUGIN_LESS_NAME, PLUGIN_STYLUS_NAME, } from './constants';
 export type { Rspack } from './provider';
 export type { RsbuildConfig, DevConfig, HtmlConfig, ToolsConfig, SourceConfig, OutputConfig, SecurityConfig, PerformanceConfig, NormalizedConfig, NormalizedDevConfig, NormalizedHtmlConfig, NormalizedToolsConfig, NormalizedSourceConfig, NormalizedOutputConfig, NormalizedSecurityConfig, NormalizedPerformanceConfig, RsbuildPlugin, RsbuildPlugins, RsbuildPluginAPI, } from './types';
-export type { RsbuildMode, RsbuildEntry, RsbuildTarget, RsbuildContext, RsbuildInstance, CreateRsbuildOptions, InspectConfigOptions, OnExitFn, OnAfterBuildFn, OnAfterCreateCompilerFn, OnAfterStartDevServerFn, OnAfterStartProdServerFn, OnBeforeBuildFn, OnBeforeStartDevServerFn, OnBeforeStartProdServerFn, OnBeforeCreateCompilerFn, OnDevCompileDoneFn, ModifyRsbuildConfigFn, } from '@rsbuild/shared';
+export type { RsbuildMode, RsbuildEntry, RsbuildTarget, RsbuildContext, RsbuildInstance, CreateRsbuildOptions, InspectConfigOptions, OnExitFn, OnAfterBuildFn, OnAfterCreateCompilerFn, OnAfterStartDevServerFn, OnAfterStartProdServerFn, OnBeforeBuildFn, OnBeforeStartDevServerFn, OnBeforeStartProdServerFn, OnBeforeCreateCompilerFn, OnCloseDevServerFn, OnDevCompileDoneFn, ModifyRsbuildConfigFn, } from '@rsbuild/shared';

package/dist/index.js

@@ -18,7 +18,6 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var src_exports = {};
 __export(src_exports, {
-  PLUGIN_BABEL_NAME: () => import_constants.PLUGIN_BABEL_NAME,
   PLUGIN_CSS_NAME: () => import_constants.PLUGIN_CSS_NAME,
   PLUGIN_LESS_NAME: () => import_constants.PLUGIN_LESS_NAME,
   PLUGIN_SASS_NAME: () => import_constants.PLUGIN_SASS_NAME,
@@ -38,10 +37,9 @@ var import_createRsbuild = require("./createRsbuild");
 var import_config = require("./cli/config");
 var import_shared = require("@rsbuild/shared");
 var import_constants = require("./constants");
-const version = "0.3.11";
+const version = "0.4.1";
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  PLUGIN_BABEL_NAME,
   PLUGIN_CSS_NAME,
   PLUGIN_LESS_NAME,
   PLUGIN_SASS_NAME,

package/dist/pluginManager.d.ts

@@ -0,0 +1,7 @@
+import type { PluginManager, RsbuildPlugin, RsbuildPluginAPI } from '@rsbuild/shared';
+export declare function createPluginManager(): PluginManager;
+export declare const pluginDagSort: (plugins: RsbuildPlugin[]) => RsbuildPlugin[];
+export declare function initPlugins({ pluginAPI, pluginManager, }: {
+    pluginAPI?: RsbuildPluginAPI;
+    pluginManager: PluginManager;
+}): Promise<void>;

package/dist/pluginManager.js

@@ -0,0 +1,176 @@
+"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 pluginManager_exports = {};
+__export(pluginManager_exports, {
+  createPluginManager: () => createPluginManager,
+  initPlugins: () => initPlugins,
+  pluginDagSort: () => pluginDagSort
+});
+module.exports = __toCommonJS(pluginManager_exports);
+var import_shared = require("@rsbuild/shared");
+function validatePlugin(plugin) {
+  const type = typeof plugin;
+  if (type !== "object" || plugin === null) {
+    throw new Error(
+      `Expect Rsbuild plugin instance to be an object, but got ${type}.`
+    );
+  }
+  if ((0, import_shared.isFunction)(plugin.setup)) {
+    return;
+  }
+  if ((0, import_shared.isFunction)(plugin.apply)) {
+    const { name = "SomeWebpackPlugin" } = plugin.constructor || {};
+    const messages = [
+      `${import_shared.color.yellow(
+        name
+      )} looks like a Webpack or Rspack plugin, please use ${import_shared.color.yellow(
+        "`tools.rspack`"
+      )} to register it:`,
+      import_shared.color.green(`
+  // rsbuild.config.ts
+  export default {
+    tools: {
+      rspack: {
+        plugins: [new ${name}()]
+      }
+    }
+  };
+`)
+    ];
+    throw new Error(messages.join("\n"));
+  }
+  throw new Error(
+    `Expect Rsbuild plugin.setup to be a function, but got ${type}.`
+  );
+}
+function createPluginManager() {
+  let plugins = [];
+  const addPlugins = (newPlugins, options) => {
+    const { before } = options || {};
+    newPlugins.forEach((newPlugin) => {
+      if (!newPlugin) {
+        return;
+      }
+      validatePlugin(newPlugin);
+      if (plugins.find((item) => item.name === newPlugin.name)) {
+        import_shared.logger.warn(
+          `Rsbuild plugin "${newPlugin.name}" registered multiple times.`
+        );
+      } else if (before) {
+        const index = plugins.findIndex((item) => item.name === before);
+        if (index === -1) {
+          import_shared.logger.warn(`Plugin "${before}" does not exist.`);
+          plugins.push(newPlugin);
+        } else {
+          plugins.splice(index, 0, newPlugin);
+        }
+      } else {
+        plugins.push(newPlugin);
+      }
+    });
+  };
+  const removePlugins = (pluginNames) => {
+    plugins = plugins.filter((plugin) => !pluginNames.includes(plugin.name));
+  };
+  const isPluginExists = (pluginName) => Boolean(plugins.find((plugin) => plugin.name === pluginName));
+  return {
+    get plugins() {
+      return plugins;
+    },
+    addPlugins,
+    removePlugins,
+    isPluginExists
+  };
+}
+const pluginDagSort = (plugins) => {
+  let allLines = [];
+  function getPlugin(name) {
+    const target = plugins.find((item) => item.name === name);
+    if (!target) {
+      throw new Error(`plugin ${name} not existed`);
+    }
+    return target;
+  }
+  plugins.forEach((plugin) => {
+    plugin.pre?.forEach((pre) => {
+      if (pre && plugins.some((item) => item.name === pre)) {
+        allLines.push([pre, plugin.name]);
+      }
+    });
+    plugin.post?.forEach((post) => {
+      if (post && plugins.some((item) => item.name === post)) {
+        allLines.push([plugin.name, post]);
+      }
+    });
+  });
+  let zeroEndPoints = plugins.filter(
+    (item) => !allLines.find((l) => l[1] === item.name)
+  );
+  const sortedPoint = [];
+  while (zeroEndPoints.length) {
+    const zep = zeroEndPoints.shift();
+    sortedPoint.push(getPlugin(zep.name));
+    allLines = allLines.filter((l) => l[0] !== getPlugin(zep.name).name);
+    const restPoints = plugins.filter(
+      (item) => !sortedPoint.find((sp) => sp.name === item.name)
+    );
+    zeroEndPoints = restPoints.filter(
+      (item) => !allLines.find((l) => l[1] === item.name)
+    );
+  }
+  if (allLines.length) {
+    const restInRingPoints = {};
+    allLines.forEach((l) => {
+      restInRingPoints[l[0]] = true;
+      restInRingPoints[l[1]] = true;
+    });
+    throw new Error(
+      `plugins dependencies has loop: ${Object.keys(restInRingPoints).join(
+        ","
+      )}`
+    );
+  }
+  return sortedPoint;
+};
+async function initPlugins({
+  pluginAPI,
+  pluginManager
+}) {
+  (0, import_shared.debug)("init plugins");
+  const plugins = pluginDagSort(pluginManager.plugins);
+  const removedPlugins = plugins.reduce((ret, plugin) => {
+    if (plugin.remove) {
+      return ret.concat(plugin.remove);
+    }
+    return ret;
+  }, []);
+  for (const plugin of plugins) {
+    if (removedPlugins.includes(plugin.name)) {
+      continue;
+    }
+    await plugin.setup(pluginAPI);
+  }
+  (0, import_shared.debug)("init plugins done");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createPluginManager,
+  initPlugins,
+  pluginDagSort
+});

package/dist/plugins/index.js

@@ -53,7 +53,8 @@ const plugins = {
   preloadOrPrefetch: () => Promise.resolve().then(() => __toESM(require("./preloadOrPrefetch"))).then((m) => m.pluginPreloadOrPrefetch()),
   performance: () => Promise.resolve().then(() => __toESM(require("./performance"))).then((m) => m.pluginPerformance()),
   define: () => Promise.resolve().then(() => __toESM(require("./define"))).then((m) => m.pluginDefine()),
-  server: () => Promise.resolve().then(() => __toESM(require("./server"))).then((m) => m.pluginServer())
+  server: () => Promise.resolve().then(() => __toESM(require("./server"))).then((m) => m.pluginServer()),
+  moduleFederation: () => Promise.resolve().then(() => __toESM(require("./moduleFederation"))).then((m) => m.pluginModuleFederation())
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/plugins/moduleFederation.d.ts

@@ -0,0 +1,2 @@
+import type { RsbuildPlugin } from '../types';
+export declare function pluginModuleFederation(): RsbuildPlugin;

package/dist/plugins/moduleFederation.js

@@ -0,0 +1,123 @@
+"use strict";
+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 __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+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 __toESM = (mod, isNodeMode, target) => (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
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+var moduleFederation_exports = {};
+__export(moduleFederation_exports, {
+  pluginModuleFederation: () => pluginModuleFederation
+});
+module.exports = __toCommonJS(moduleFederation_exports);
+var import_shared = require("@rsbuild/shared");
+class PatchSplitChunksPlugin {
+  constructor(name) {
+    __publicField(this, "name");
+    this.name = name;
+  }
+  apply(compiler) {
+    const { splitChunks } = compiler.options.optimization;
+    if (!splitChunks) {
+      return;
+    }
+    const applyPatch = (cacheGroup) => {
+      if (typeof cacheGroup !== "object" || cacheGroup instanceof RegExp) {
+        return;
+      }
+      const { chunks } = cacheGroup;
+      if (!chunks) {
+        return;
+      }
+      if (typeof chunks === "function") {
+        const prevChunks = chunks;
+        cacheGroup.chunks = (chunk) => {
+          if (chunk.name && chunk.name === this.name) {
+            return false;
+          }
+          return prevChunks(chunk);
+        };
+        return;
+      }
+      if (chunks === "all") {
+        cacheGroup.chunks = (chunk) => {
+          if (chunk.name && chunk.name === this.name) {
+            return false;
+          }
+          return true;
+        };
+        return;
+      }
+      if (chunks === "initial") {
+        cacheGroup.chunks = (chunk) => {
+          if (chunk.name && chunk.name === this.name) {
+            return false;
+          }
+          return chunk.isOnlyInitial();
+        };
+        return;
+      }
+    };
+    applyPatch(splitChunks);
+    const { cacheGroups } = splitChunks;
+    if (!cacheGroups) {
+      return;
+    }
+    Object.keys(cacheGroups).forEach((cacheGroupKey) => {
+      applyPatch(cacheGroups[cacheGroupKey]);
+    });
+  }
+}
+function pluginModuleFederation() {
+  return {
+    name: "rsbuild:module-federation",
+    setup(api) {
+      api.modifyBundlerChain(async (chain, { CHAIN_ID, target }) => {
+        const config = api.getNormalizedConfig();
+        if (!config.moduleFederation?.options || target !== "web") {
+          return;
+        }
+        const { options } = config.moduleFederation;
+        const { rspack } = await Promise.resolve().then(() => __toESM(require("@rspack/core")));
+        chain.plugin(CHAIN_ID.PLUGIN.MODULE_FEDERATION).use(rspack.container.ModuleFederationPlugin, [options]);
+        if (options.name) {
+          chain.plugin("mf-patch-split-chunks").use(PatchSplitChunksPlugin, [options.name]);
+        }
+        const publicPath = chain.output.get("publicPath");
+        if (publicPath === import_shared.DEFAULT_ASSET_PREFIX) {
+          chain.output.set("publicPath", "auto");
+        }
+      });
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  pluginModuleFederation
+});

package/dist/provider/config.d.ts

@@ -1,4 +1,4 @@
-import { type RsbuildConfig, type NormalizedConfig } from '@rsbuild/shared';
+import type { RsbuildConfig, NormalizedConfig } from '@rsbuild/shared';
 export declare const withDefaultConfig: (rootPath: string, config: RsbuildConfig) => Promise<RsbuildConfig>;
 /** #__PURE__
  * 1. May used by multiple plugins.