@rsbuild/core 2.2.3 → 2.2.5

package/compiled/postcss-loader/index.js

@@ -1,15 +1,15 @@
 (() => {
   "use strict";
   var __webpack_modules__ = {
-    999: (module, __unused_webpack_exports, __nccwpck_require__) => {
-      module.exports = __nccwpck_require__(377)["default"];
+    61: (module, __unused_webpack_exports, __nccwpck_require__) => {
+      module.exports = __nccwpck_require__(23)["default"];
     },
-    377: (__unused_webpack_module, exports, __nccwpck_require__) => {
+    23: (__unused_webpack_module, exports, __nccwpck_require__) => {
       var __webpack_unused_export__;
       __webpack_unused_export__ = { value: true };
       exports["default"] = loader;
       var _nodePath = _interopRequireDefault(__nccwpck_require__(760));
-      var _utils = __nccwpck_require__(308);
+      var _utils = __nccwpck_require__(690);
       function _interopRequireDefault(e) {
         return e && e.__esModule ? e : { default: e };
       }
@@ -179,7 +179,7 @@
         callback(null, result.css, map, { ast });
       }
     },
-    308: (module, exports, __nccwpck_require__) => {
+    690: (module, exports, __nccwpck_require__) => {
       module = __nccwpck_require__.nmd(module);
       Object.defineProperty(exports, "__esModule", { value: true });
       exports.exec = exec;
@@ -716,6 +716,6 @@
   })();
   if (typeof __nccwpck_require__ !== "undefined")
     __nccwpck_require__.ab = __dirname + "/";
-  var __webpack_exports__ = __nccwpck_require__(999);
+  var __webpack_exports__ = __nccwpck_require__(61);
   module.exports = __webpack_exports__;
 })();

package/compiled/rspack-chain/package.json

@@ -1 +1 @@
-{"name":"rspack-chain","version":"2.2.0","license":"MIT","types":"types/index.d.ts","type":"module"}
+{"name":"rspack-chain","version":"2.3.2","license":"MIT","types":"types/index.d.ts","type":"module"}

package/compiled/rspack-chain/types/index.d.ts

@@ -12,6 +12,20 @@ interface PluginInstance {
 }
 
 declare namespace __Config {
+  // Allow loose object patches while preserving arrays and atomic values.
+  type MergeValue<Value> = Value extends
+    Function | readonly unknown[] | RegExp | Date
+    ? Value
+    : Value extends object
+      ? Value | Record<string, unknown>
+      : Value;
+
+  type MergeInput<OptionsType> = {
+    [Key in keyof OptionsType]?: MergeValue<OptionsType[Key]>;
+  } & Record<string, any>;
+
+  type NamedPatches = Record<string, Record<string, unknown>>;
+
   class Chained<Parent> {
     batch(handler: (chained: this) => void): this;
     end(): Parent;
@@ -36,7 +50,32 @@ declare namespace __Config {
     ): this;
   }
 
-  class ChainedMap<Parent> extends TypedChainedMap<Parent, any> {}
+  class ChainedMap<
+    Parent,
+    OptionsType = any,
+    MergeOverrides = unknown,
+  > extends TypedChainedMap<Parent, any> {
+    // Known keys share their read/write types; custom keys remain unrestricted.
+    get<Key extends PropertyKey>(
+      key: Key,
+    ): Key extends keyof OptionsType ? OptionsType[Key] | undefined : any;
+    set<Key extends PropertyKey>(
+      key: Key,
+      value: Key extends keyof OptionsType ? OptionsType[Key] | undefined : any,
+    ): this;
+    getOrCompute<Key extends PropertyKey>(
+      key: Key,
+      compute: Key extends keyof OptionsType
+        ? () => OptionsType[Key] | undefined
+        : () => any,
+    ): Key extends keyof OptionsType ? OptionsType[Key] | undefined : any;
+    // Apply chain-specific container types without loosening their shape.
+    merge(
+      obj: MergeInput<Omit<OptionsType, keyof MergeOverrides>> &
+        Partial<MergeOverrides>,
+      omit?: string[],
+    ): this;
+  }
   class TypedChainedSet<Parent, Value> extends Chained<Parent> {
     add(value: Value): this;
     prepend(value: Value): this;
@@ -55,8 +94,17 @@ declare namespace __Config {
   class ChainedSet<Parent> extends TypedChainedSet<Parent, any> {}
 }
 
-type RspackConfig = Required<Configuration>;
-export declare class RspackChain extends __Config.ChainedMap<void> {
+type RspackConfig = Configuration;
+export declare class RspackChain extends __Config.ChainedMap<
+  void,
+  Configuration,
+  {
+    entry?: Record<
+      string,
+      RspackChain.RspackEntryObject | RspackChain.RspackEntryObject[]
+    >;
+  }
+> {
   entryPoints: RspackChain.TypedChainedMap<
     RspackChain,
     { [key: string]: RspackChain.EntryPoint }
@@ -73,7 +121,7 @@ export declare class RspackChain extends __Config.ChainedMap<void> {
 
   context(value: RspackConfig['context']): this;
   mode(value: RspackConfig['mode']): this;
-  devtool(value: RspackChain.DevTool): this;
+  devtool(value: RspackChain.DevTool | undefined): this;
   target(value: RspackConfig['target']): this;
   watch(value: RspackConfig['watch']): this;
   watchOptions(value: RspackConfig['watchOptions']): this;
@@ -117,7 +165,11 @@ export declare namespace RspackChain {
     Parent,
     OptionsType
   > {}
-  class ChainedMap<Parent> extends __Config.TypedChainedMap<Parent, any> {}
+  class ChainedMap<
+    Parent,
+    OptionsType = any,
+    MergeOverrides = unknown,
+  > extends __Config.ChainedMap<Parent, OptionsType, MergeOverrides> {}
   class TypedChainedSet<Parent, Value> extends __Config.TypedChainedSet<
     Parent,
     Value
@@ -168,9 +220,13 @@ export declare namespace RspackChain {
 
   class EntryPoint extends TypedChainedSet<RspackChain, RspackEntryObject> {}
 
-  type RspackModule = Required<NonNullable<Configuration['module']>>;
+  type RspackModule = NonNullable<Configuration['module']>;
 
-  class Module extends ChainedMap<RspackChain> {
+  class Module extends ChainedMap<
+    RspackChain,
+    NonNullable<Configuration['module']>,
+    { rule?: __Config.NamedPatches; defaultRule?: __Config.NamedPatches }
+  > {
     defaultRules: TypedChainedMap<this, { [key: string]: Rule }>;
     rules: TypedChainedMap<this, { [key: string]: Rule }>;
     generator: ChainedMap<this>;
@@ -180,9 +236,12 @@ export declare namespace RspackChain {
     noParse(value: RspackModule['noParse']): this;
   }
 
-  type RspackOutput = Required<NonNullable<Configuration['output']>>;
+  type RspackOutput = NonNullable<Configuration['output']>;
 
-  class Output extends ChainedMap<RspackChain> {
+  class Output extends ChainedMap<
+    RspackChain,
+    NonNullable<Configuration['output']>
+  > {
     assetModuleFilename(value: RspackOutput['assetModuleFilename']): this;
     asyncChunks(value: RspackOutput['asyncChunks']): this;
     bundlerInfo(value: RspackOutput['bundlerInfo']): this;
@@ -252,16 +311,19 @@ export declare namespace RspackChain {
   >;
 
   type DevServerShorthandMethods<T> = {
-    [K in keyof RspackDevServer]-?: (value: RspackDevServer[K]) => T;
+    [K in keyof RspackDevServer]-?: (
+      value: RspackDevServer[K] | undefined,
+    ) => T;
   };
 
+  // rslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging
   class DevServer extends TypedChainedMap<RspackChain, RspackDevServer> {}
 
-  // rslint-disable-next-line @typescript-eslint/no-empty-object-type
+  // rslint-disable-next-line @typescript-eslint/no-empty-object-type, @typescript-eslint/no-unsafe-declaration-merging
   interface DevServer extends DevServerShorthandMethods<DevServer> {}
 
   type RspackPerformance = Exclude<
-    Required<NonNullable<Configuration['performance']>>,
+    NonNullable<Configuration['performance']>,
     false
   >;
   class Performance extends ChainedMap<RspackChain> {
@@ -301,14 +363,16 @@ export declare namespace RspackChain {
     modules: TypedChainedSet<this, RspackResolve['modules'][number]>;
     fallback: TypedChainedMap<this, RspackResolveAlias>;
     byDependency: TypedChainedMap<this, RspackResolve['byDependency']>;
-    enforceExtension(value: RspackResolve['enforceExtension']): this;
-    fullySpecified(value: RspackResolve['fullySpecified']): this;
-    pnp(value: RspackResolve['pnp']): this;
-    symlinks(value: RspackResolve['symlinks']): this;
-    preferRelative(value: RspackResolve['preferRelative']): this;
-    preferAbsolute(value: RspackResolve['preferAbsolute']): this;
-
-    tsConfig(value: RspackResolve['tsConfig']): this;
+    enforceExtension(
+      value: RspackResolve['enforceExtension'] | undefined,
+    ): this;
+    fullySpecified(value: RspackResolve['fullySpecified'] | undefined): this;
+    pnp(value: RspackResolve['pnp'] | undefined): this;
+    symlinks(value: RspackResolve['symlinks'] | undefined): this;
+    preferRelative(value: RspackResolve['preferRelative'] | undefined): this;
+    preferAbsolute(value: RspackResolve['preferAbsolute'] | undefined): this;
+
+    tsConfig(value: RspackResolve['tsConfig'] | undefined): this;
   }
   class RuleResolve<T = RspackChain> extends Resolve<T> {}
 
@@ -318,12 +382,23 @@ export declare namespace RspackChain {
     packageMains: ChainedSet<this>;
   }
 
-  type RspackRuleSet = Required<RuleSetRule>;
-
-  class Rule<T = Module> extends ChainedMap<T> implements Orderable {
+  type RspackRuleSet = RuleSetRule;
+
+  class Rule<T = Module>
+    extends ChainedMap<
+      T,
+      RuleSetRule,
+      {
+        use?: __Config.NamedPatches;
+        rules?: __Config.NamedPatches;
+        oneOf?: __Config.NamedPatches;
+      }
+    >
+    implements Orderable
+  {
     uses: TypedChainedMap<this, { [key: string]: Use }>;
-    include: TypedChainedSet<this, RspackRuleSet['include']>;
-    exclude: TypedChainedSet<this, RspackRuleSet['exclude']>;
+    include: TypedChainedSet<this, NonNullable<RspackRuleSet['include']>>;
+    exclude: TypedChainedSet<this, NonNullable<RspackRuleSet['exclude']>>;
     rules: TypedChainedMap<this, { [key: string]: Rule<Rule> }>;
     oneOfs: TypedChainedMap<this, { [key: string]: Rule<Rule> }>;
     resolve: RuleResolve<Rule<T>>;
@@ -348,7 +423,9 @@ export declare namespace RspackChain {
     test(value: RspackRuleSet['test']): this;
     type(value: RspackRuleSet['type']): this;
 
-    use(name: string): Use<this>;
+    use<Options extends LoaderOptions = LoaderOptions>(
+      name: string,
+    ): Use<this, Options>;
     rule(name: string): Rule<Rule>;
     oneOf(name: string): Rule<Rule>;
     pre(): this;
@@ -357,10 +434,11 @@ export declare namespace RspackChain {
     after(name: string): this;
   }
 
-  type RspackOptimization = Required<
-    NonNullable<Configuration['optimization']>
+  type RspackOptimization = NonNullable<Configuration['optimization']>;
+  type SplitChunksObject = Exclude<
+    RspackOptimization['splitChunks'],
+    false | undefined
   >;
-  type SplitChunksObject = Exclude<RspackOptimization['splitChunks'], false>;
   class Optimization extends ChainedMap<RspackChain> {
     minimizer(name: string): RspackChain.Plugin<this, PluginInstance>;
     minimizers: TypedChainedMap<this, RspackChain.Plugin<this, PluginInstance>>;
@@ -404,13 +482,19 @@ export declare namespace RspackChain {
     RuleSetLoaderWithOptions['parallel']
   >;
 
-  class Use<Parent = Rule> extends ChainedMap<Parent> implements Orderable {
-    ident(value: NonNullable<RuleSetLoaderWithOptions['ident']>): this;
-    loader(value: string): this;
-    options(value: LoaderOptions): this;
-    parallel(value: LoaderParallelOptions): this;
+  class Use<Parent = Rule, Options extends LoaderOptions = LoaderOptions>
+    extends ChainedMap<
+      Parent,
+      Omit<RuleSetLoaderWithOptions, 'options'> & { options?: Options }
+    >
+    implements Orderable
+  {
+    ident(value: RuleSetLoaderWithOptions['ident']): this;
+    loader(value: string | undefined): this;
+    options(value: Options | undefined): this;
+    parallel(value: LoaderParallelOptions | undefined): this;
 
-    tap(f: (options: LoaderOptions) => LoaderOptions): this;
+    tap(f: (options: Options) => Options): this;
 
     // Orderable
     before(name: string): this;
@@ -418,7 +502,7 @@ export declare namespace RspackChain {
   }
 
   // [inline-|hidden-|eval-][nosources-][cheap-[module-]]source-map[-debugids].
-  export type DevTool = RspackConfig['devtool'];
+  export type DevTool = NonNullable<RspackConfig['devtool']>;
 
   interface PluginClass<PluginType extends PluginInstance> {
     new (...opts: any[]): PluginType;