@rsbuild/core 0.0.12 → 0.0.13

package/dist/cli/config.d.ts

@@ -1,17 +1,11 @@
-import type { RsbuildEntry, RsbuildPlugin, RsbuildProvider, SharedRsbuildConfig } from '@rsbuild/shared';
-import type { RsbuildConfig as RspackRsbuildConfig } from '../rspack-provider';
-export type RsbuildConfig<Config> = Config & {
+import type { RsbuildEntry, RsbuildPlugin, RsbuildConfig as BaseRsbuildConfig } from '@rsbuild/shared';
+export type RsbuildConfig = BaseRsbuildConfig & {
   source?: {
     entries?: RsbuildEntry;
   };
   plugins?: RsbuildPlugin[];
-  provider?: ({
-    rsbuildConfig
-  }: {
-    rsbuildConfig: Config;
-  }) => RsbuildProvider;
 };
-export declare const defineConfig: <T extends SharedRsbuildConfig = RspackRsbuildConfig>(config: RsbuildConfig<T>) => RsbuildConfig<T>;
+export declare const defineConfig: (config: RsbuildConfig) => RsbuildConfig;
 export declare function loadConfig(): Promise<ReturnType<typeof defineConfig>>;
 export declare function getDefaultEntries(): {
   index: string;

package/dist/cli/index.js

@@ -28,9 +28,8 @@ var import_config = require("./config");
 var import_config2 = require("./config");
 async function runCli(options = {}) {
   var _a;
-  const { provider, ...config } = await (0, import_config.loadConfig)();
+  const config = await (0, import_config.loadConfig)();
   const rsbuild = await (0, import__.createRsbuild)({
-    provider,
     rsbuildConfig: config,
     entry: ((_a = config.source) == null ? void 0 : _a.entries) || (0, import_config.getDefaultEntries)()
   });

package/dist/plugins/asset.d.ts

@@ -1,2 +1,3 @@
 import type { DefaultRsbuildPlugin } from '@rsbuild/shared';
-export declare const pluginAsset: (assetType: 'image' | 'media' | 'font', exts: string[]) => DefaultRsbuildPlugin;
+export declare function getRegExpForExts(exts: string[]): RegExp;
+export declare const pluginAsset: (assetType: 'image' | 'media' | 'font' | 'svg', exts: string[]) => DefaultRsbuildPlugin;

package/dist/plugins/asset.js

@@ -28,17 +28,25 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var asset_exports = {};
 __export(asset_exports, {
+  getRegExpForExts: () => getRegExpForExts,
   pluginAsset: () => pluginAsset
 });
 module.exports = __toCommonJS(asset_exports);
 var import_path = __toESM(require("path"));
 var import_shared = require("@rsbuild/shared");
+function getRegExpForExts(exts) {
+  const matcher = exts.map((ext) => ext.trim()).map((ext) => ext.startsWith(".") ? ext.slice(1) : ext).join("|");
+  return new RegExp(
+    exts.length === 1 ? `\\.${matcher}$` : `\\.(${matcher})$`,
+    "i"
+  );
+}
 const pluginAsset = (assetType, exts) => ({
   name: `plugin-${assetType}`,
   setup(api) {
     api.modifyBundlerChain((chain, { isProd }) => {
       const config = api.getNormalizedConfig();
-      const regExp = (0, import_shared.getRegExpForExts)(exts);
+      const regExp = getRegExpForExts(exts);
       const distDir = (0, import_shared.getDistPath)(config.output, assetType);
       const filename = (0, import_shared.getFilename)(config.output, assetType, isProd);
       const maxSize = config.output.dataUriLimit[assetType];
@@ -54,5 +62,6 @@ const pluginAsset = (assetType, exts) => ({
 });
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  getRegExpForExts,
   pluginAsset
 });

package/dist/plugins/entry.d.ts

@@ -1,2 +1,2 @@
-import { DefaultRsbuildPlugin } from '@rsbuild/shared';
+import { type DefaultRsbuildPlugin } from '@rsbuild/shared';
 export declare const pluginEntry: () => DefaultRsbuildPlugin;

package/dist/plugins/entry.js

@@ -1,9 +1,7 @@
 "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 __export = (target, all) => {
   for (var name in all)
@@ -17,21 +15,13 @@ var __copyProps = (to, from, except, desc) => {
   }
   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 entry_exports = {};
 __export(entry_exports, {
   pluginEntry: () => pluginEntry
 });
 module.exports = __toCommonJS(entry_exports);
-var import_lodash = __toESM(require("lodash"));
+var import_shared = require("@rsbuild/shared");
 const pluginEntry = () => ({
   name: "plugin-entry",
   setup(api) {
@@ -41,7 +31,7 @@ const pluginEntry = () => ({
       Object.keys(entry).forEach((entryName) => {
         const appendEntry = (file) => chain.entry(entryName).add(file);
         preEntry.forEach(appendEntry);
-        import_lodash.default.castArray(entry[entryName]).forEach(appendEntry);
+        (0, import_shared.castArray)(entry[entryName]).forEach(appendEntry);
       });
     });
   }

package/dist/plugins/html.d.ts

@@ -1,7 +1,7 @@
-import type { SharedHtmlConfig, DefaultRsbuildPlugin, SharedRsbuildPluginAPI, NormalizedSharedOutputConfig } from '@rsbuild/shared';
+import type { HtmlConfig, DefaultRsbuildPlugin, SharedRsbuildPluginAPI, NormalizedOutputConfig } from '@rsbuild/shared';
 export declare function getMetaTags(entryName: string, config: {
-  html: SharedHtmlConfig;
-  output: NormalizedSharedOutputConfig;
-}): Promise<string>;
+  html: HtmlConfig;
+  output: NormalizedOutputConfig;
+}): Promise<import("html-webpack-plugin").HtmlTagObject[]>;
 export declare const applyInjectTags: (api: SharedRsbuildPluginAPI) => void;
 export declare const pluginHtml: () => DefaultRsbuildPlugin;

package/dist/plugins/html.js

@@ -39,24 +39,19 @@ var import_fs_extra = require("@rsbuild/shared/fs-extra");
 var import_lodash = __toESM(require("lodash"));
 var import_generateMetaTags = require("../utils/generateMetaTags");
 async function getMetaTags(entryName, config) {
-  var _a;
   const { meta, metaByEntries } = config.html;
-  const metaOptions = {
-    ...meta != null ? meta : {},
-    ...(_a = metaByEntries == null ? void 0 : metaByEntries[entryName]) != null ? _a : {}
-  };
+  const metaOptions = {};
   if (config.output.charset === "utf8") {
     metaOptions.charset = { charset: "utf-8" };
   }
+  Object.assign(metaOptions, meta, metaByEntries == null ? void 0 : metaByEntries[entryName]);
   return (0, import_generateMetaTags.generateMetaTags)(metaOptions);
 }
 async function getTemplateParameters(entryName, config, assetPrefix) {
   const { mountId, templateParameters, templateParametersByEntries } = config.html;
-  const meta = await getMetaTags(entryName, config);
   const title = (0, import_shared.getTitle)(entryName, config);
   const templateParams = (templateParametersByEntries == null ? void 0 : templateParametersByEntries[entryName]) || templateParameters;
   const baseParameters = {
-    meta,
     title,
     mountId,
     entryName,
@@ -86,10 +81,10 @@ async function getChunks(entryName, entryValue) {
 const applyInjectTags = (api) => {
   api.modifyBundlerChain(async (chain, { HtmlPlugin, CHAIN_ID }) => {
     const config = api.getNormalizedConfig();
-    const tags = import_lodash.default.castArray(config.html.tags).filter(Boolean);
+    const tags = (0, import_shared.castArray)(config.html.tags).filter(Boolean);
     const tagsByEntries = import_lodash.default.mapValues(
       config.html.tagsByEntries,
-      (tags2) => import_lodash.default.castArray(tags2).filter(Boolean)
+      (tags2) => (0, import_shared.castArray)(tags2).filter(Boolean)
     );
     const shouldByEntries = import_lodash.default.some(tagsByEntries, "length");
     if (!tags.length && !shouldByEntries) {
@@ -132,6 +127,10 @@ const pluginHtml = () => ({
         const entryNames = Object.keys(entries);
         const htmlPaths = api.getHTMLPaths();
         const faviconUrls = [];
+        const metaPluginOptions = {
+          meta: [],
+          HtmlPlugin
+        };
         await Promise.all(
           entryNames.map(async (entryName, index) => {
             const entryValue = entries[entryName].values();
@@ -140,11 +139,18 @@ const pluginHtml = () => ({
             const favicon = (0, import_shared.getFavicon)(entryName, config);
             const filename = htmlPaths[entryName];
             const template = (0, import_shared.getTemplatePath)(entryName, config);
+            const metaTags = await getMetaTags(entryName, config);
             const templateParameters = await getTemplateParameters(
               entryName,
               config,
               assetPrefix
             );
+            if (metaTags.length) {
+              metaPluginOptions.meta.push({
+                tags: metaTags,
+                filename
+              });
+            }
             const pluginOptions = {
               chunks,
               inject,
@@ -181,6 +187,9 @@ const pluginHtml = () => ({
             chain.plugin(`${CHAIN_ID.PLUGIN.HTML}-${entryName}`).use(HtmlPlugin, [finalOptions]);
           })
         );
+        if (metaPluginOptions.meta.length) {
+          chain.plugin(CHAIN_ID.PLUGIN.HTML_META).use(import_shared.HtmlMetaPlugin, [metaPluginOptions]);
+        }
         if (config.security) {
           const { nonce } = config.security;
           if (nonce) {

package/dist/plugins/index.js

@@ -43,10 +43,10 @@ const plugins = {
   cache: () => Promise.resolve().then(() => __toESM(require("./cache"))).then((m) => m.pluginCache()),
   yaml: () => Promise.resolve().then(() => __toESM(require("./yaml"))).then((m) => m.pluginYaml()),
   toml: () => Promise.resolve().then(() => __toESM(require("./toml"))).then((m) => m.pluginToml()),
-  svg: () => Promise.resolve().then(() => __toESM(require("./svg"))).then((m) => m.pluginSvg()),
   splitChunks: () => Promise.resolve().then(() => __toESM(require("./splitChunks"))).then((m) => m.pluginSplitChunks()),
   inlineChunk: () => Promise.resolve().then(() => __toESM(require("./inlineChunk"))).then((m) => m.pluginInlineChunk()),
   bundleAnalyzer: () => Promise.resolve().then(() => __toESM(require("./bundleAnalyzer"))).then((m) => m.pluginBundleAnalyzer()),
+  svg: () => Promise.resolve().then(() => __toESM(require("./asset"))).then((m) => m.pluginAsset("svg", ["svg"])),
   font: () => Promise.resolve().then(() => __toESM(require("./asset"))).then((m) => m.pluginAsset("font", import_shared.FONT_EXTENSIONS)),
   image: () => Promise.resolve().then(() => __toESM(require("./asset"))).then((m) => m.pluginAsset("image", import_shared.IMAGE_EXTENSIONS)),
   media: () => Promise.resolve().then(() => __toESM(require("./asset"))).then((m) => m.pluginAsset("media", import_shared.MEDIA_EXTENSIONS)),

package/dist/plugins/startUrl.js

@@ -33,7 +33,6 @@ __export(startUrl_exports, {
   replacePlaceholder: () => replacePlaceholder
 });
 module.exports = __toCommonJS(startUrl_exports);
-var import_lodash = __toESM(require("lodash"));
 var import_path = require("path");
 var import_shared = require("@rsbuild/shared");
 var import_child_process = require("child_process");
@@ -74,10 +73,8 @@ async function openBrowser(url) {
       }
       return false;
     } catch (err) {
-      import_shared.logger.error(
-        "Failed to open start URL with apple script:",
-        JSON.stringify(err)
-      );
+      import_shared.logger.error("Failed to open start URL with apple script.");
+      import_shared.logger.error(err);
       return false;
     }
   }
@@ -86,7 +83,8 @@ async function openBrowser(url) {
     await open(url);
     return true;
   } catch (err) {
-    import_shared.logger.error("Failed to open start URL:", JSON.stringify(err));
+    import_shared.logger.error("Failed to open start URL.");
+    import_shared.logger.error(err);
     return false;
   }
 }
@@ -116,7 +114,7 @@ function pluginStartUrl() {
           urls.push(`${protocol}://localhost:${port}`);
         } else {
           urls.push(
-            ...import_lodash.default.castArray(startUrl).map(
+            ...(0, import_shared.castArray)(startUrl).map(
               (item) => replacePlaceholder(item, port)
             )
           );
@@ -130,7 +128,7 @@ function pluginStartUrl() {
           }
         };
         if (beforeStartUrl) {
-          Promise.all((0, import_shared.ensureArray)(beforeStartUrl).map((fn) => fn())).then(
+          Promise.all((0, import_shared.castArray)(beforeStartUrl).map((fn) => fn())).then(
             openUrls
           );
         } else {

package/dist/rspack-provider/config/defaults.js

@@ -26,10 +26,7 @@ var import_shared = require("@rsbuild/shared");
 const createDefaultConfig = () => ({
   dev: (0, import_shared.getDefaultDevConfig)(),
   html: (0, import_shared.getDefaultHtmlConfig)(),
-  source: {
-    ...(0, import_shared.getDefaultSourceConfig)(),
-    define: {}
-  },
+  source: (0, import_shared.getDefaultSourceConfig)(),
   output: (0, import_shared.getDefaultOutputConfig)(),
   tools: (0, import_shared.getDefaultToolsConfig)(),
   security: (0, import_shared.getDefaultSecurityConfig)(),

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

@@ -1,14 +1,13 @@
 import { InitConfigsOptions } from './initConfigs';
-import { BuildOptions, Stats, MultiStats } from '@rsbuild/shared';
-import type { Compiler, MultiCompiler } from '../types';
+import type { Stats, MultiStats, BuildOptions, RspackCompiler, RspackMultiCompiler } from '@rsbuild/shared';
 export type BuildExecuter = {
-  (compiler: Compiler): Promise<{
+  (compiler: RspackCompiler): Promise<{
     stats?: Stats;
   }>;
-  (compiler: MultiCompiler): Promise<{
+  (compiler: RspackMultiCompiler): Promise<{
     stats?: MultiStats;
   }>;
-  (compiler: Compiler | MultiCompiler): Promise<{
+  (compiler: RspackCompiler | RspackMultiCompiler): Promise<{
     stats?: Stats | MultiStats;
   }>;
 };

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

@@ -1,4 +1,5 @@
-import type { Context, RspackConfig } from '../types';
+import { type RspackConfig } from '@rsbuild/shared';
+import type { Context } from '../types';
 export declare function createCompiler({
   context,
   rspackConfigs

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

@@ -24,7 +24,6 @@ module.exports = __toCommonJS(createContext_exports);
 var import_path = require("path");
 var import_shared = require("@rsbuild/shared");
 var import_initHooks = require("./initHooks");
-var import_validate = require("../config/validate");
 var import_defaults = require("../config/defaults");
 async function createContext(options, userRsbuildConfig) {
   const rsbuildConfig = (0, import_defaults.withDefaultConfig)(userRsbuildConfig);
@@ -33,13 +32,10 @@ async function createContext(options, userRsbuildConfig) {
     rsbuildConfig.output,
     "rspack"
   );
-  const configValidatingTask = Promise.resolve();
-  await (0, import_validate.validateRsbuildConfig)(rsbuildConfig);
   const tsconfigPath = (0, import_path.join)(context.rootPath, import_shared.TS_CONFIG_FILE);
   return {
     ...context,
     hooks: (0, import_initHooks.initHooks)(),
-    configValidatingTask,
     config: { ...rsbuildConfig },
     originalConfig: userRsbuildConfig,
     tsconfigPath: await (0, import_shared.isFileExists)(tsconfigPath) ? tsconfigPath : void 0

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

@@ -10,5 +10,5 @@ export declare function initConfigs({
   pluginStore,
   rsbuildOptions
 }: InitConfigsOptions): Promise<{
-  rspackConfigs: import("../types").RspackConfig[];
+  rspackConfigs: import("@rsbuild/shared").RspackConfig[];
 }>;

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

@@ -39,14 +39,13 @@ async function initConfigs({
   pluginStore,
   rsbuildOptions
 }) {
-  await context.configValidatingTask;
   await (0, import_shared.initPlugins)({
     pluginAPI: context.pluginAPI,
     pluginStore
   });
   await modifyRsbuildConfig(context);
   context.normalizedConfig = (0, import_normalize.normalizeConfig)(context.config);
-  const targets = (0, import_shared.ensureArray)(rsbuildOptions.target);
+  const targets = (0, import_shared.castArray)(rsbuildOptions.target);
   const rspackConfigs = await Promise.all(
     targets.map((target) => (0, import_rspackConfig.generateRspackConfig)({ target, context }))
   );

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

@@ -1,5 +1,5 @@
-import { OnExitFn, OnAfterBuildFn, OnBeforeBuildFn, OnDevCompileDoneFn, ModifyRsbuildConfigFn, OnAfterStartDevServerFn, OnBeforeStartDevServerFn, OnAfterCreateCompilerFn, OnBeforeCreateCompilerFn, ModifyBundlerChainFn } from '@rsbuild/shared';
-import type { RspackConfig, RsbuildConfig, ModifyRspackConfigFn } from '../types';
+import { OnExitFn, OnAfterBuildFn, OnBeforeBuildFn, OnDevCompileDoneFn, ModifyRsbuildConfigFn, OnAfterStartDevServerFn, OnBeforeStartDevServerFn, OnAfterCreateCompilerFn, OnBeforeCreateCompilerFn, ModifyBundlerChainFn, type RspackConfig } from '@rsbuild/shared';
+import type { RsbuildConfig, ModifyRspackConfigFn } from '../types';
 export declare function initHooks(): {
   /** parameters are not bundler-related */
   onExitHook: import("@rsbuild/shared").AsyncHook<OnExitFn>;

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

@@ -1,6 +1,5 @@
-import { InitConfigsOptions } from './initConfigs';
-import { InspectConfigOptions } from '@rsbuild/shared';
-import type { RspackConfig } from '../types';
+import { type InitConfigsOptions } from './initConfigs';
+import { type RspackConfig, type InspectConfigOptions } from '@rsbuild/shared';
 export declare function inspectConfig({
   context,
   pluginStore,
@@ -14,7 +13,7 @@ export declare function inspectConfig({
   rsbuildConfig: string;
   bundlerConfigs: string[];
   origin: {
-    rsbuildConfig: Readonly<import("../types").RsbuildConfig>;
+    rsbuildConfig: Readonly<import("@rsbuild/shared").RsbuildConfig>;
     bundlerConfigs: RspackConfig[];
   };
 }>;

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

@@ -1,5 +1,5 @@
-import { type RsbuildTarget } from '@rsbuild/shared';
-import type { Context, RspackConfig } from '../types';
+import { type RspackConfig, type RsbuildTarget } from '@rsbuild/shared';
+import type { Context } from '../types';
 export declare function generateRspackConfig({
   target,
   context

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

@@ -32,7 +32,6 @@ __export(rspackConfig_exports, {
 });
 module.exports = __toCommonJS(rspackConfig_exports);
 var import_shared = require("@rsbuild/shared");
-var import_lodash = require("lodash");
 var import_shared2 = require("../shared");
 async function modifyRspackConfig(context, rspackConfig, utils) {
   var _a;
@@ -60,7 +59,7 @@ async function getConfigUtils(config, chainUtils) {
     rspack,
     mergeConfig: merge,
     addRules(rules) {
-      const ruleArr = (0, import_lodash.castArray)(rules);
+      const ruleArr = (0, import_shared.castArray)(rules);
       if (!config.module) {
         config.module = {};
       }
@@ -70,14 +69,14 @@ async function getConfigUtils(config, chainUtils) {
       config.module.rules.unshift(...ruleArr);
     },
     prependPlugins(plugins) {
-      const pluginArr = (0, import_lodash.castArray)(plugins);
+      const pluginArr = (0, import_shared.castArray)(plugins);
       if (!config.plugins) {
         config.plugins = [];
       }
       config.plugins.unshift(...pluginArr);
     },
     appendPlugins(plugins) {
-      const pluginArr = (0, import_lodash.castArray)(plugins);
+      const pluginArr = (0, import_shared.castArray)(plugins);
       if (!config.plugins) {
         config.plugins = [];
       }
@@ -92,7 +91,7 @@ async function getConfigUtils(config, chainUtils) {
 }
 async function getChainUtils(target) {
   const nodeEnv = process.env.NODE_ENV;
-  const { default: HtmlPlugin } = await Promise.resolve().then(() => __toESM(require("@rspack/plugin-html")));
+  const { default: HtmlPlugin } = await Promise.resolve().then(() => __toESM(require("html-webpack-plugin")));
   const { default: webpack } = await Promise.resolve().then(() => __toESM(require("webpack")));
   return {
     env: nodeEnv,

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

@@ -1,7 +1,6 @@
-import { StartDevServerOptions } from '@rsbuild/shared';
-import { InitConfigsOptions } from './initConfigs';
-import type { Compiler, MultiCompiler } from '../types';
+import { StartDevServerOptions, type RspackCompiler, type RspackMultiCompiler } from '@rsbuild/shared';
+import { type InitConfigsOptions } from './initConfigs';
 type ServerOptions = Exclude<StartDevServerOptions['serverOptions'], undefined>;
-export declare function createDevServer(options: InitConfigsOptions, port: number, serverOptions: ServerOptions, customCompiler?: Compiler | MultiCompiler): Promise<import("@modern-js/server").Server>;
+export declare function createDevServer(options: InitConfigsOptions, port: number, serverOptions: ServerOptions, customCompiler?: RspackCompiler | RspackMultiCompiler): Promise<import("@modern-js/server").Server>;
 export declare function startDevServer(options: InitConfigsOptions, startDevServerOptions?: StartDevServerOptions): Promise<import("@rsbuild/shared").StartServerResult>;
 export {};

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

@@ -34,8 +34,8 @@ __export(startDevServer_exports, {
 module.exports = __toCommonJS(startDevServer_exports);
 var import_shared = require("@rsbuild/shared");
 var import_createCompiler = require("./createCompiler");
-var import_initConfigs = require("./initConfigs");
 var import_devMiddleware = require("./devMiddleware");
+var import_initConfigs = require("./initConfigs");
 async function createDevServer(options, port, serverOptions, customCompiler) {
   const { Server } = await Promise.resolve().then(() => __toESM(require("@modern-js/server")));
   let compiler;

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

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

package/dist/rspack-provider/plugins/css.d.ts

@@ -1,5 +1,5 @@
-import { type BundlerChain, type Context, type ModifyBundlerChainUtils } from '@rsbuild/shared';
-import type { RsbuildPlugin, NormalizedConfig, RspackRule } from '../types';
+import { type BundlerChain, type Context, type RspackRule, type ModifyBundlerChainUtils } from '@rsbuild/shared';
+import type { RsbuildPlugin, NormalizedConfig } from '../types';
 export declare const enableNativeCss: (config: NormalizedConfig) => boolean;
 export declare function applyBaseCSSRule({
   rule,

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

@@ -34,8 +34,8 @@ __export(css_exports, {
   pluginCss: () => pluginCss
 });
 module.exports = __toCommonJS(css_exports);
-var import_shared = require("@rsbuild/shared");
 var import_path = __toESM(require("path"));
+var import_shared = require("@rsbuild/shared");
 var import_shared2 = require("../shared");
 const enableNativeCss = (config) => !config.output.disableCssExtract;
 async function applyBaseCSSRule({
@@ -185,7 +185,7 @@ const pluginCss = () => {
             (0, import_shared.setConfig)(rspackConfig, "experiments.css", false);
             return;
           }
-          let localIdentName = config.output.cssModules.localIdentName || config.output.cssModuleLocalIdentName || // Using shorter classname in production to reduce bundle size
+          let localIdentName = config.output.cssModules.localIdentName || // Using shorter classname in production to reduce bundle size
           (isProd ? "[local]-[hash:6]" : "[path][name]__[local]-[hash:6]");
           if (localIdentName.includes(":base64")) {
             import_shared.logger.warn(

package/dist/rspack-provider/plugins/minimize.d.ts

@@ -1,4 +1,5 @@
-import { BundlerChain } from '@rsbuild/shared';
+import { type BundlerChain } from '@rsbuild/shared';
 import type { RsbuildPlugin, NormalizedConfig } from '../types';
-export declare function applyJSMinimizer(chain: BundlerChain, config: NormalizedConfig): Promise<void>;
+export declare function applyJSMinimizer(chain: BundlerChain, config: NormalizedConfig): void;
+export declare function applyCSSMinimizer(chain: BundlerChain): void;
 export declare const pluginMinimize: () => RsbuildPlugin;

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

@@ -18,13 +18,14 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var minimize_exports = {};
 __export(minimize_exports, {
+  applyCSSMinimizer: () => applyCSSMinimizer,
   applyJSMinimizer: () => applyJSMinimizer,
   pluginMinimize: () => pluginMinimize
 });
 module.exports = __toCommonJS(minimize_exports);
 var import_shared = require("@rsbuild/shared");
 var import_core = require("@rspack/core");
-async function applyJSMinimizer(chain, config) {
+function applyJSMinimizer(chain, config) {
   const options = {};
   const { removeConsole } = config.performance;
   if (removeConsole === true) {
@@ -51,22 +52,26 @@ async function applyJSMinimizer(chain, config) {
   options.asciiOnly = config.output.charset === "ascii";
   chain.optimization.minimizer(import_shared.CHAIN_ID.MINIMIZER.JS).use(import_core.SwcJsMinimizerRspackPlugin, [options]).end();
 }
+function applyCSSMinimizer(chain) {
+  chain.optimization.minimizer(import_shared.CHAIN_ID.MINIMIZER.CSS).use(import_core.SwcCssMinimizerRspackPlugin, []).end();
+}
 const pluginMinimize = () => ({
   name: "plugin-minimize",
   setup(api) {
-    api.modifyBundlerChain(async (chain, { isProd }) => {
+    api.modifyBundlerChain((chain, { isProd }) => {
       const config = api.getNormalizedConfig();
       const isMinimize = isProd && !config.output.disableMinimize;
       chain.optimization.minimize(isMinimize);
       if (isMinimize) {
-        await applyJSMinimizer(chain, config);
-        await (0, import_shared.applyCSSMinimizer)(chain, config);
+        applyJSMinimizer(chain, config);
+        applyCSSMinimizer(chain);
       }
     });
   }
 });
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  applyCSSMinimizer,
   applyJSMinimizer,
   pluginMinimize
 });

package/dist/rspack-provider/plugins/swc.d.ts

@@ -1,5 +1,5 @@
-import { type RsbuildTarget } from '@rsbuild/shared';
-import type { RsbuildPlugin, NormalizedConfig, BuiltinSwcLoaderOptions } from '../types';
+import { type RsbuildTarget, type BuiltinSwcLoaderOptions } from '@rsbuild/shared';
+import type { RsbuildPlugin, NormalizedConfig } from '../types';
 export declare function getDefaultSwcConfig(config: NormalizedConfig, rootPath: string, target: RsbuildTarget): Promise<BuiltinSwcLoaderOptions>;
 /**
  * Provide some swc configs of rspack

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

@@ -1,6 +1,6 @@
-import { type RsbuildProvider } from '@rsbuild/shared';
-import type { Compiler, RspackConfig, RsbuildConfig, NormalizedConfig, MultiCompiler } from './types';
-export type RspackProvider = RsbuildProvider<RsbuildConfig, RspackConfig, NormalizedConfig, Compiler | MultiCompiler>;
+import { type RsbuildProvider, type RspackConfig, type RspackCompiler, type RspackMultiCompiler } from '@rsbuild/shared';
+import type { RsbuildConfig, NormalizedConfig } from './types';
+export type RspackProvider = RsbuildProvider<RsbuildConfig, RspackConfig, NormalizedConfig, RspackCompiler | RspackMultiCompiler>;
 export declare function rspackProvider({
   rsbuildConfig: originalRsbuildConfig
 }: {

package/dist/rspack-provider/rspackPlugin/removeCssSourcemapPlugin.d.ts

@@ -1,5 +1,5 @@
 import type { Compiler } from '@rspack/core';
-import type HtmlPlugin from '@rspack/plugin-html';
+import type HtmlPlugin from 'html-webpack-plugin';
 export declare class RemoveCssSourcemapPlugin {
   name: string;
   htmlPlugin: typeof HtmlPlugin;

package/dist/rspack-provider/shared/plugin.js

@@ -52,8 +52,6 @@ const applyDefaultPlugins = (plugins) => (0, import_shared.awaitableGetter)([
   plugins.wasm(),
   plugins.moment(),
   plugins.nodeAddons(),
-  // pug plugin should after html plugin
-  Promise.resolve().then(() => __toESM(require("../plugins/pug"))).then((m) => m.pluginPug()),
   plugins.define(),
   Promise.resolve().then(() => __toESM(require("../plugins/css"))).then((m) => m.pluginCss()),
   Promise.resolve().then(() => __toESM(require("../plugins/less"))).then((m) => m.pluginLess()),

package/dist/rspack-provider/types/context.d.ts

@@ -1,6 +1,5 @@
-import type { Context as BaseContext } from '@rsbuild/shared';
+import type { Context as BaseContext, RsbuildConfig, NormalizedConfig } from '@rsbuild/shared';
 import type { Hooks } from '../core/initHooks';
-import type { RsbuildConfig, NormalizedConfig } from './config';
 import type { RsbuildPluginAPI } from './plugin';
 /** The inner context. */
 export type Context = BaseContext & {
@@ -8,8 +7,6 @@ export type Context = BaseContext & {
   hooks: Readonly<Hooks>;
   /** Current Rsbuild config. */
   config: Readonly<RsbuildConfig>;
-  /** The async task to validate schema of config. */
-  configValidatingTask: Promise<void>;
   /** The original Rsbuild config passed from the createRsbuild method. */
   originalConfig: Readonly<RsbuildConfig>;
   /** The normalized Rsbuild config. */

package/dist/rspack-provider/types/hooks.d.ts

@@ -1,11 +1,3 @@
-import type { ModifyChainUtils } from '@rsbuild/shared';
-import type { RspackConfig, RspackRule, RspackPluginInstance } from './rspack';
-export type ModifyRspackConfigUtils = ModifyChainUtils & {
-  addRules: (rules: RspackRule | RspackRule[]) => void;
-  prependPlugins: (plugins: RspackPluginInstance | RspackPluginInstance[]) => void;
-  appendPlugins: (plugins: RspackPluginInstance | RspackPluginInstance[]) => void;
-  removePlugin: (pluginName: string) => void;
-  mergeConfig: typeof import('@rsbuild/shared/webpack-merge').merge;
-  rspack: typeof import('@rspack/core');
-};
+import type { ModifyRspackConfigUtils } from '@rsbuild/shared';
+import type { RspackConfig } from '@rsbuild/shared';
 export type ModifyRspackConfigFn = (config: RspackConfig, utils: ModifyRspackConfigUtils) => Promise<RspackConfig | void> | RspackConfig | void;