@react-querybuilder/core 8.11.1 → 8.12.0

package/dist/cjs/react-querybuilder_core.cjs.development.d.ts

@@ -143,7 +143,7 @@ const anyA = get(anyObject, 'a');
 @category Type Guard
 @category Utilities
 */
-type IsAny<T$1> = 0 extends 1 & NoInfer<T$1> ? true : false;
+type IsAny<T> = 0 extends 1 & NoInfer<T> ? true : false;
 //#endregion
 //#region ../../node_modules/type-fest/source/is-optional-key-of.d.ts
 /**
@@ -186,7 +186,7 @@ type T5 = IsOptionalKeyOf<User | Admin, 'surname'>;
 @category Type Guard
 @category Utilities
 */
-type IsOptionalKeyOf<Type$1 extends object, Key$1 extends keyof Type$1> = IsAny<Type$1 | Key$1> extends true ? never : Key$1 extends keyof Type$1 ? Type$1 extends Record<Key$1, Type$1[Key$1]> ? false : true : false;
+type IsOptionalKeyOf<Type extends object, Key$1 extends keyof Type> = IsAny<Type | Key$1> extends true ? never : Key$1 extends keyof Type ? Type extends Record<Key$1, Type[Key$1]> ? false : true : false;
 //#endregion
 //#region ../../node_modules/type-fest/source/optional-keys-of.d.ts
 /**
@@ -222,8 +222,8 @@ const update2: UpdateOperation<User> = {
 
 @category Utilities
 */
-type OptionalKeysOf<Type$1 extends object> = Type$1 extends unknown // For distributing `Type`
-? (keyof { [Key in keyof Type$1 as IsOptionalKeyOf<Type$1, Key> extends false ? never : Key]: never }) & keyof Type$1 // Intersect with `keyof Type` to ensure result of `OptionalKeysOf<Type>` is always assignable to `keyof Type`
+type OptionalKeysOf<Type extends object> = Type extends unknown // For distributing `Type`
+? (keyof { [Key in keyof Type as IsOptionalKeyOf<Type, Key> extends false ? never : Key]: never }) & keyof Type // Intersect with `keyof Type` to ensure result of `OptionalKeysOf<Type>` is always assignable to `keyof Type`
 : never;
 //#endregion
 //#region ../../node_modules/type-fest/source/required-keys-of.d.ts
@@ -251,8 +251,8 @@ const validator2 = createValidation<User>('surname', value => value.length < 25)
 
 @category Utilities
 */
-type RequiredKeysOf<Type$1 extends object> = Type$1 extends unknown // For distributing `Type`
-? Exclude<keyof Type$1, OptionalKeysOf<Type$1>> : never;
+type RequiredKeysOf<Type extends object> = Type extends unknown // For distributing `Type`
+? Exclude<keyof Type, OptionalKeysOf<Type>> : never;
 //#endregion
 //#region ../../node_modules/type-fest/source/is-never.d.ts
 /**
@@ -296,7 +296,7 @@ endIfEqual('abc', '123');
 @category Type Guard
 @category Utilities
 */
-type IsNever<T$1> = [T$1] extends [never] ? true : false;
+type IsNever<T> = [T] extends [never] ? true : false;
 //#endregion
 //#region ../../node_modules/type-fest/source/if.d.ts
 /**
@@ -353,10 +353,45 @@ type B = IfEqual<string, number, 'equal', 'not equal'>;
 //=> 'not equal'
 ```
 
+Note: Sometimes using the `If` type can make an implementation non–tail-recursive, which can impact performance. In such cases, it’s better to use a conditional directly. Refer to the following example:
+
+@example
+```
+import type {If, IsEqual, StringRepeat} from 'type-fest';
+
+type HundredZeroes = StringRepeat<'0', 100>;
+
+// The following implementation is not tail recursive
+type Includes<S extends string, Char extends string> =
+	S extends `${infer First}${infer Rest}`
+		? If<IsEqual<First, Char>,
+			'found',
+			Includes<Rest, Char>>
+		: 'not found';
+
+// Hence, instantiations with long strings will fail
+// @ts-expect-error
+type Fails = Includes<HundredZeroes, '1'>;
+//           ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+// Error: Type instantiation is excessively deep and possibly infinite.
+
+// However, if we use a simple conditional instead of `If`, the implementation becomes tail-recursive
+type IncludesWithoutIf<S extends string, Char extends string> =
+	S extends `${infer First}${infer Rest}`
+		? IsEqual<First, Char> extends true
+			? 'found'
+			: IncludesWithoutIf<Rest, Char>
+		: 'not found';
+
+// Now, instantiations with long strings will work
+type Works = IncludesWithoutIf<HundredZeroes, '1'>;
+//=> 'not found'
+```
+
 @category Type Guard
 @category Utilities
 */
-type If<Type$1 extends boolean, IfBranch, ElseBranch> = IsNever<Type$1> extends true ? ElseBranch : Type$1 extends true ? IfBranch : ElseBranch;
+type If<Type extends boolean, IfBranch, ElseBranch> = IsNever<Type> extends true ? ElseBranch : Type extends true ? IfBranch : ElseBranch;
 //#endregion
 //#region ../../node_modules/type-fest/source/unknown-array.d.ts
 /**
@@ -398,7 +433,7 @@ Needed to handle the case of a single call signature with properties.
 Multiple call signatures cannot currently be supported due to a TypeScript limitation.
 @see https://github.com/microsoft/TypeScript/issues/29732
 */
-type HasMultipleCallSignatures<T$1 extends (...arguments_: any[]) => unknown> = T$1 extends {
+type HasMultipleCallSignatures<T extends (...arguments_: any[]) => unknown> = T extends {
   (...arguments_: infer A): unknown;
   (...arguments_: infer B): unknown;
 } ? B extends A ? A extends B ? false : true : true : false;
@@ -419,14 +454,40 @@ type B = IfNotAnyOrNever<any, 'VALID', 'IS_ANY', 'IS_NEVER'>;
 type C = IfNotAnyOrNever<never, 'VALID', 'IS_ANY', 'IS_NEVER'>;
 //=> 'IS_NEVER'
 ```
+
+Note: Wrapping a tail-recursive type with `IfNotAnyOrNever` makes the implementation non-tail-recursive. To fix this, move the recursion into a helper type. Refer to the following example:
+
+@example
+```ts
+import type {StringRepeat} from 'type-fest';
+
+type NineHundredNinetyNineSpaces = StringRepeat<' ', 999>;
+
+// The following implementation is not tail recursive
+type TrimLeft<S extends string> = IfNotAnyOrNever<S, S extends ` ${infer R}` ? TrimLeft<R> : S>;
+
+// Hence, instantiations with long strings will fail
+// @ts-expect-error
+type T1 = TrimLeft<NineHundredNinetyNineSpaces>;
+//        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+// Error: Type instantiation is excessively deep and possibly infinite.
+
+// To fix this, move the recursion into a helper type
+type TrimLeftOptimised<S extends string> = IfNotAnyOrNever<S, _TrimLeftOptimised<S>>;
+
+type _TrimLeftOptimised<S extends string> = S extends ` ${infer R}` ? _TrimLeftOptimised<R> : S;
+
+type T2 = TrimLeftOptimised<NineHundredNinetyNineSpaces>;
+//=> ''
+```
 */
-type IfNotAnyOrNever<T$1, IfNotAnyOrNever$1, IfAny = any, IfNever = never> = If<IsAny<T$1>, IfAny, If<IsNever<T$1>, IfNever, IfNotAnyOrNever$1>>;
+type IfNotAnyOrNever<T, IfNotAnyOrNever$1, IfAny = any, IfNever = never> = If<IsAny<T>, IfAny, If<IsNever<T>, IfNever, IfNotAnyOrNever$1>>;
 //#endregion
 //#region ../../node_modules/type-fest/source/internal/array.d.ts
 /**
 Returns whether the given array `T` is readonly.
 */
-type IsArrayReadonly<T$1 extends UnknownArray> = If<IsNever<T$1>, false, T$1 extends unknown[] ? false : true>;
+type IsArrayReadonly<T extends UnknownArray> = If<IsNever<T>, false, T extends unknown[] ? false : true>;
 //#endregion
 //#region ../../node_modules/type-fest/source/simplify.d.ts
 /**
@@ -483,10 +544,10 @@ fn(someInterface as Simplify<SomeInterface>); // Good: transform an `interface`
 ```
 
 @link https://github.com/microsoft/TypeScript/issues/15300
-@see SimplifyDeep
+@see {@link SimplifyDeep}
 @category Object
 */
-type Simplify<T$1> = { [KeyType in keyof T$1]: T$1[KeyType] } & {};
+type Simplify<T> = { [KeyType in keyof T]: T[KeyType] } & {};
 //#endregion
 //#region ../../node_modules/type-fest/source/is-equal.d.ts
 /**
@@ -607,7 +668,7 @@ type ExampleWithoutIndexSignatures = OmitIndexSignature<Example>;
 // => { foo: 'bar'; qux?: 'baz' | undefined; }
 ```
 
-@see PickIndexSignature
+@see {@link PickIndexSignature}
 @category Object
 */
 type OmitIndexSignature<ObjectType> = { [KeyType in keyof ObjectType as {} extends Record<KeyType, unknown> ? never : KeyType]: ObjectType[KeyType] };
@@ -655,7 +716,7 @@ type ExampleIndexSignature = PickIndexSignature<Example>;
 // }
 ```
 
-@see OmitIndexSignature
+@see {@link OmitIndexSignature}
 @category Object
 */
 type PickIndexSignature<ObjectType> = { [KeyType in keyof ObjectType as {} extends Record<KeyType, unknown> ? KeyType : never]: ObjectType[KeyType] };
@@ -738,7 +799,7 @@ type Any = HomomorphicPick<{a: 1; b: 2} | {c: 3}, any>;
 type IndexSignature = HomomorphicPick<{[k: string]: unknown}, number>;
 //=> {}
 */
-type HomomorphicPick<T$1, Keys extends KeysOfUnion<T$1>> = { [P in keyof T$1 as Extract<P, Keys>]: T$1[P] };
+type HomomorphicPick<T, Keys extends KeysOfUnion<T>> = { [P in keyof T as Extract<P, Keys>]: T[P] };
 /**
 Merges user specified options with default options.
 
@@ -964,7 +1025,7 @@ Note that types containing overloaded functions are not made deeply required due
 @category Set
 @category Map
 */
-type RequiredDeep<T$1> = T$1 extends BuiltIns ? T$1 : T$1 extends Map<infer KeyType, infer ValueType> ? Map<RequiredDeep<KeyType>, RequiredDeep<ValueType>> : T$1 extends Set<infer ItemType> ? Set<RequiredDeep<ItemType>> : T$1 extends ReadonlyMap<infer KeyType, infer ValueType> ? ReadonlyMap<RequiredDeep<KeyType>, RequiredDeep<ValueType>> : T$1 extends ReadonlySet<infer ItemType> ? ReadonlySet<RequiredDeep<ItemType>> : T$1 extends WeakMap<infer KeyType, infer ValueType> ? WeakMap<RequiredDeep<KeyType>, RequiredDeep<ValueType>> : T$1 extends WeakSet<infer ItemType> ? WeakSet<RequiredDeep<ItemType>> : T$1 extends Promise<infer ValueType> ? Promise<RequiredDeep<ValueType>> : T$1 extends ((...arguments_: any[]) => unknown) ? IsNever<keyof T$1> extends true ? T$1 : HasMultipleCallSignatures<T$1> extends true ? T$1 : ((...arguments_: Parameters<T$1>) => ReturnType<T$1>) & RequiredObjectDeep<T$1> : T$1 extends object ? RequiredObjectDeep<T$1> : unknown;
+type RequiredDeep<T> = T extends BuiltIns ? T : T extends Map<infer KeyType, infer ValueType> ? Map<RequiredDeep<KeyType>, RequiredDeep<ValueType>> : T extends Set<infer ItemType> ? Set<RequiredDeep<ItemType>> : T extends ReadonlyMap<infer KeyType, infer ValueType> ? ReadonlyMap<RequiredDeep<KeyType>, RequiredDeep<ValueType>> : T extends ReadonlySet<infer ItemType> ? ReadonlySet<RequiredDeep<ItemType>> : T extends WeakMap<infer KeyType, infer ValueType> ? WeakMap<RequiredDeep<KeyType>, RequiredDeep<ValueType>> : T extends WeakSet<infer ItemType> ? WeakSet<RequiredDeep<ItemType>> : T extends Promise<infer ValueType> ? Promise<RequiredDeep<ValueType>> : T extends ((...arguments_: any[]) => unknown) ? IsNever<keyof T> extends true ? T : HasMultipleCallSignatures<T> extends true ? T : ((...arguments_: Parameters<T>) => ReturnType<T>) & RequiredObjectDeep<T> : T extends object ? RequiredObjectDeep<T> : unknown;
 type RequiredObjectDeep<ObjectType extends object> = { [KeyType in keyof ObjectType]-?: RequiredDeep<ObjectType[KeyType]> };
 //#endregion
 //#region ../../node_modules/type-fest/source/set-optional.d.ts
@@ -1062,7 +1123,7 @@ type StringUnionToFullOptionArray<Op extends string> = Array<Op extends unknown
 *
 * @group Option Lists
 */
-type GetOptionType<OL$1 extends FlexibleOptionList<FullOption>> = OL$1 extends FlexibleOptionList<infer Opt> ? Opt : never;
+type GetOptionType<OL extends FlexibleOptionList<FullOption>> = OL extends FlexibleOptionList<infer Opt> ? Opt : never;
 /**
 * Extracts the type of the identifying property from a {@link Option},
 * {@link ValueOption}, or {@link FullOption}.
@@ -1073,7 +1134,7 @@ type GetOptionIdentifierType<Opt$1 extends BaseOption> = Opt$1 extends Option<in
 /**
 * Adds an `unknown` index property to an interface.
 */
-type WithUnknownIndex<T$1> = T$1 & {
+type WithUnknownIndex<T> = T & {
   [key: string]: unknown;
 };
 /**
@@ -1238,9 +1299,9 @@ interface CommonRuleAndGroupProperties {
 * The main rule type. The `field`, `operator`, and `value` properties
 * can be narrowed with generics.
 */
-interface RuleType<F$1 extends string = string, O$1 extends string = string, V$1 = any, C extends string = string> extends CommonRuleAndGroupProperties {
-  field: F$1;
-  operator: O$1;
+interface RuleType<F extends string = string, O extends string = string, V$1 = any, C extends string = string> extends CommonRuleAndGroupProperties {
+  field: F;
+  operator: O;
   value: V$1;
   valueSource?: ValueSource;
   match?: MatchConfig;
@@ -1253,15 +1314,15 @@ interface RuleType<F$1 extends string = string, O$1 extends string = string, V$1
 * The main rule group type. This type is used for query definitions as well as
 * all sub-groups of queries.
 */
-interface RuleGroupType<R$1 extends RuleType = RuleType, C extends string = string> extends CommonRuleAndGroupProperties {
+interface RuleGroupType<R extends RuleType = RuleType, C extends string = string> extends CommonRuleAndGroupProperties {
   combinator: C;
-  rules: RuleGroupArray<RuleGroupType<R$1, C>, R$1>;
+  rules: RuleGroupArray<RuleGroupType<R, C>, R>;
   not?: boolean;
 }
 /**
 * The type of the `rules` array in a {@link RuleGroupType}.
 */
-type RuleGroupArray<RG$1 extends RuleGroupType = RuleGroupType, R$1 extends RuleType = RuleType> = (R$1 | RG$1)[];
+type RuleGroupArray<RG extends RuleGroupType = RuleGroupType, R extends RuleType = RuleType> = (R | RG)[];
 /**
 * All updateable properties of rules and groups (everything except
 * `id`, `path`, and `rules`).
@@ -1270,18 +1331,18 @@ type UpdateableProperties = Exclude<keyof (RuleType & RuleGroupType), "id" | "pa
 /**
 * The type of the `rules` array in a {@link DefaultRuleGroupType}.
 */
-type DefaultRuleGroupArray<F$1 extends string = string> = RuleGroupArray<DefaultRuleGroupType, DefaultRuleType<F$1>>;
+type DefaultRuleGroupArray<F extends string = string> = RuleGroupArray<DefaultRuleGroupType, DefaultRuleType<F>>;
 /**
 * {@link RuleGroupType} with the `combinator` property limited to
 * {@link DefaultCombinatorNameExtended} and `rules` limited to {@link DefaultRuleType}.
 */
-type DefaultRuleGroupType<F$1 extends string = string> = RuleGroupType<DefaultRuleType<F$1>, DefaultCombinatorNameExtended> & {
-  rules: DefaultRuleGroupArray<F$1>;
+type DefaultRuleGroupType<F extends string = string> = RuleGroupType<DefaultRuleType<F>, DefaultCombinatorNameExtended> & {
+  rules: DefaultRuleGroupArray<F>;
 };
 /**
 * {@link RuleType} with the `operator` property limited to {@link DefaultOperatorName}.
 */
-type DefaultRuleType<F$1 extends string = string> = RuleType<F$1, DefaultOperatorName>;
+type DefaultRuleType<F extends string = string> = RuleType<F, DefaultOperatorName>;
 /**
 * Default allowed values for the `combinator` property.
 *
@@ -1328,9 +1389,9 @@ type MappedTuple<Tuple extends Array<unknown>, Result extends Array<unknown> = [
 * The main rule group interface when using independent combinators. This type is used
 * for query definitions as well as all sub-groups of queries.
 */
-interface RuleGroupTypeIC<R$1 extends RuleType = RuleType, C extends string = string> extends Except<RuleGroupType<R$1, C>, "combinator" | "rules"> {
+interface RuleGroupTypeIC<R extends RuleType = RuleType, C extends string = string> extends Except<RuleGroupType<R, C>, "combinator" | "rules"> {
   combinator?: undefined;
-  rules: RuleGroupICArray<RuleGroupTypeIC<R$1, C>, R$1, C>;
+  rules: RuleGroupICArray<RuleGroupTypeIC<R, C>, R, C>;
   /**
   * Only used when adding a rule to a query that uses independent combinators
   */
@@ -1339,11 +1400,11 @@ interface RuleGroupTypeIC<R$1 extends RuleType = RuleType, C extends string = st
 /**
 * Shorthand for "either {@link RuleGroupType} or {@link RuleGroupTypeIC}".
 */
-type RuleGroupTypeAny<R$1 extends RuleType = RuleType, C extends string = string> = RuleGroupType<R$1, C> | RuleGroupTypeIC<R$1, C>;
+type RuleGroupTypeAny<R extends RuleType = RuleType, C extends string = string> = RuleGroupType<R, C> | RuleGroupTypeIC<R, C>;
 /**
 * The type of the `rules` array in a {@link RuleGroupTypeIC}.
 */
-type RuleGroupICArray<RG$1 extends RuleGroupTypeIC = RuleGroupTypeIC, R$1 extends RuleType = RuleType, C extends string = string> = [R$1 | RG$1] | [R$1 | RG$1, ...MappedTuple<[C, R$1 | RG$1]>] | ((R$1 | RG$1)[] & {
+type RuleGroupICArray<RG extends RuleGroupTypeIC = RuleGroupTypeIC, R extends RuleType = RuleType, C extends string = string> = [R | RG] | [R | RG, ...MappedTuple<[C, R | RG]>] | ((R | RG)[] & {
   length: 0;
 });
 /**
@@ -1353,27 +1414,27 @@ type RuleOrGroupArray = RuleGroupArray | RuleGroupICArray;
 /**
 * The type of the `rules` array in a {@link DefaultRuleGroupTypeIC}.
 */
-type DefaultRuleGroupICArray<F$1 extends string = string> = RuleGroupICArray<DefaultRuleGroupTypeIC<F$1>, DefaultRuleType<F$1>, DefaultCombinatorName>;
+type DefaultRuleGroupICArray<F extends string = string> = RuleGroupICArray<DefaultRuleGroupTypeIC<F>, DefaultRuleType<F>, DefaultCombinatorName>;
 /**
 * Shorthand for "either {@link DefaultRuleGroupArray} or {@link DefaultRuleGroupICArray}".
 */
-type DefaultRuleOrGroupArray<F$1 extends string = string> = DefaultRuleGroupArray<F$1> | DefaultRuleGroupICArray<F$1>;
+type DefaultRuleOrGroupArray<F extends string = string> = DefaultRuleGroupArray<F> | DefaultRuleGroupICArray<F>;
 /**
 * {@link RuleGroupTypeIC} with combinators limited to
 * {@link DefaultCombinatorName} and rules limited to {@link DefaultRuleType}.
 */
-interface DefaultRuleGroupTypeIC<F$1 extends string = string> extends RuleGroupTypeIC<DefaultRuleType<F$1>> {
-  rules: DefaultRuleGroupICArray<F$1>;
+interface DefaultRuleGroupTypeIC<F extends string = string> extends RuleGroupTypeIC<DefaultRuleType<F>> {
+  rules: DefaultRuleGroupICArray<F>;
 }
 /**
 * Shorthand for "either {@link DefaultRuleGroupType} or {@link DefaultRuleGroupTypeIC}".
 */
-type DefaultRuleGroupTypeAny<F$1 extends string = string> = DefaultRuleGroupType<F$1> | DefaultRuleGroupTypeIC<F$1>;
+type DefaultRuleGroupTypeAny<F extends string = string> = DefaultRuleGroupType<F> | DefaultRuleGroupTypeIC<F>;
 /**
 * Determines if a type extending {@link RuleGroupTypeAny} is actually
 * {@link RuleGroupType} or {@link RuleGroupTypeIC}.
 */
-type GetRuleGroupType<RG$1> = RG$1 extends {
+type GetRuleGroupType<RG> = RG extends {
   combinator: string;
 } ? RuleGroupType : RuleGroupTypeIC;
 /**
@@ -1384,11 +1445,11 @@ type GetRuleGroupType<RG$1> = RG$1 extends {
 * the rule type has its field and operator types narrowed to the
 * identifier types of the provided Field and Operator types.
 */
-type GetRuleTypeFromGroupWithFieldAndOperator<RG$1 extends RuleGroupTypeAny, F$1 extends BaseOption, O$1 extends BaseOption> = RG$1 extends RuleGroupType<infer RT> | RuleGroupTypeIC<infer RT> ? RT extends RuleType<infer RuleFieldName, infer RuleOperatorName, infer RuleValueName, infer RuleCombinatorName> ? RuleFieldName extends GetOptionIdentifierType<F$1> ? RuleOperatorName extends GetOptionIdentifierType<O$1> ? RuleType<RuleFieldName, RuleOperatorName, RuleValueName, RuleCombinatorName> : RuleType<RuleFieldName, GetOptionIdentifierType<O$1>, RuleValueName, RuleCombinatorName> : RuleOperatorName extends GetOptionIdentifierType<O$1> ? RuleType<GetOptionIdentifierType<F$1>, RuleOperatorName, RuleValueName, RuleCombinatorName> : RuleType<GetOptionIdentifierType<F$1>, GetOptionIdentifierType<O$1>, RuleValueName, RuleCombinatorName> : never : never;
+type GetRuleTypeFromGroupWithFieldAndOperator<RG extends RuleGroupTypeAny, F extends BaseOption, O extends BaseOption> = RG extends RuleGroupType<infer RT> | RuleGroupTypeIC<infer RT> ? RT extends RuleType<infer RuleFieldName, infer RuleOperatorName, infer RuleValueName, infer RuleCombinatorName> ? RuleFieldName extends GetOptionIdentifierType<F> ? RuleOperatorName extends GetOptionIdentifierType<O> ? RuleType<RuleFieldName, RuleOperatorName, RuleValueName, RuleCombinatorName> : RuleType<RuleFieldName, GetOptionIdentifierType<O>, RuleValueName, RuleCombinatorName> : RuleOperatorName extends GetOptionIdentifierType<O> ? RuleType<GetOptionIdentifierType<F>, RuleOperatorName, RuleValueName, RuleCombinatorName> : RuleType<GetOptionIdentifierType<F>, GetOptionIdentifierType<O>, RuleValueName, RuleCombinatorName> : never : never;
 /**
 * Converts a narrowed rule group type to its most generic form.
 */
-type GenericizeRuleGroupType<RG$1> = RG$1 extends RuleGroupType ? RuleGroupType : RuleGroupTypeIC;
+type GenericizeRuleGroupType<RG> = RG extends RuleGroupType ? RuleGroupType : RuleGroupTypeIC;
 //#endregion
 //#region src/types/validation.d.ts
 /**
@@ -1444,7 +1505,7 @@ type ToOptionArrays<Sources extends readonly string[]> = Sources extends unknown
   label: string;
 } } : never;
 type ToFlexibleOptionArrays<Sources extends readonly string[]> = Sources extends unknown ? { [K in keyof Sources]: FlexibleOption<Sources[K]> } : never;
-type WithOptionalClassName<T$1> = T$1 & {
+type WithOptionalClassName<T> = T & {
   className?: Classname;
 };
 /**
@@ -1528,11 +1589,11 @@ type FieldByValue<FieldName extends string = string, OperatorName extends string
 /**
 * Utility type to make one or more properties required.
 */
-type WithRequired<T$1, K$1 extends keyof T$1> = T$1 & { [P in K$1]-?: T$1[P] };
+type WithRequired<T, K$1 extends keyof T> = T & { [P in K$1]-?: T[P] };
 /**
 * Utility type to make all properties non-nullable.
 */
-type RemoveNullability<T$1 extends Record<string, unknown>> = { [k in keyof T$1]: NonNullable<T$1[k]> };
+type RemoveNullability<T extends Record<string, unknown>> = { [k in keyof T]: NonNullable<T[k]> };
 /**
 * Allowed values of the {@link FullOperator} property `arity`. A value of `"unary"` or
 * a number less than two will cause the default {@link react-querybuilder!ValueEditor ValueEditor} to render `null`.
@@ -2288,9 +2349,13 @@ interface Classnames {
   */
   branches: Classname;
   /**
-  * Classname(s) rules that render a subquery.
+  * Classname(s) applied to rules that render a subquery.
   */
   hasSubQuery: Classname;
+  /**
+  * Classname(s) applied to async components in their "loading" state.
+  */
+  loading: Classname;
 }
 /**
 * Placeholder strings for option lists.
@@ -2653,6 +2718,7 @@ declare const standardClassnames: {
   readonly branches: "queryBuilder-branches";
   readonly justified: "queryBuilder-justified";
   readonly hasSubQuery: "rule-hasSubQuery";
+  readonly loading: "queryBuilder-loading";
 };
 /**
 * Default classnames for each component.
@@ -3441,7 +3507,19 @@ type ProcessedMatchMode = {
   mode: "exactly";
   threshold: number;
 };
-declare const processMatchMode: (rule: RuleType) => void | false | ProcessedMatchMode;
+/**
+* Transforms
+* - `match: { mode: "atLeast", threshold: 1 }` to `match: { mode: "some" }`
+* - `match: { mode: "atMost", threshold: 0 }` to `match: { mode: "none" }`.
+*
+* Returns:
+* - Processed `{ mode, threshold }` object for valid subqueries
+* - `null` if match mode is not applicable for the rule
+* - `false` if match mode is valid, but either
+*   1. `threshold` is required and invalid, or
+*   2. `value` is not a valid rule group.
+*/
+declare const processMatchMode: (rule: RuleType) => null | false | ProcessedMatchMode;
 /**
 * "Replacer" method for JSON.stringify's second argument. Converts `bigint` values to
 * objects with a `$bigint` property having a value of a string representation of
@@ -3630,7 +3708,7 @@ declare const nullOrUndefinedOrEmpty: (value: unknown) => value is null | undefi
 * type ObjectKeys<T extends object> = `${Exclude<keyof T, symbol>}`;
 * ```
 */
-type ObjectKeys<T$1 extends object> = Exclude<keyof T$1, symbol>;
+type ObjectKeys<T extends object> = Exclude<keyof T, symbol>;
 /**
 * A strongly-typed version of `Object.keys()`.
 *
@@ -3764,14 +3842,14 @@ declare const uniqOptGroups: <T extends BaseOption>(originalArray: FlexibleOptio
 * @group Option Lists
 */
 declare const uniqOptList: <T extends BaseOption>(originalArray: FlexibleOptionList<T>) => WithUnknownIndex<BaseOption & FullOption>[] | OptionGroup<ToFullOption<T>>[];
-interface PreparedOptionList<O$1 extends FullOption> {
+interface PreparedOptionList<O extends FullOption> {
   defaultOption: FullOption;
-  optionList: O$1[] | OptionGroup<O$1>[];
+  optionList: FullOptionList<O>;
   optionsMap: Partial<FullOptionRecord<FullOption>>;
 }
-interface PrepareOptionListParams<O$1 extends FullOption> {
+interface PrepareOptionListParams<O extends FullOption> {
   placeholder?: Placeholder;
-  optionList?: FlexibleOptionListProp<O$1> | BaseOptionMap<O$1>;
+  optionList?: FlexibleOptionListProp<O> | BaseOptionMap<O>;
   baseOption?: Record<string, unknown>;
   labelMap?: Record<string, string>;
   autoSelectOption?: boolean;
@@ -4124,7 +4202,7 @@ declare const regenerateIDs: <RG>(subject: RG, {
 /**
 * Options object for {@link index!transformQuery transformQuery}.
 */
-interface TransformQueryOptions<RG$1 extends RuleGroupTypeAny = RuleGroupType> {
+interface TransformQueryOptions<RG extends RuleGroupTypeAny = RuleGroupType> {
   /**
   * When a rule is encountered in the hierarchy, it will be replaced
   * with the result of this function.
@@ -4138,7 +4216,7 @@ interface TransformQueryOptions<RG$1 extends RuleGroupTypeAny = RuleGroupType> {
   *
   * @defaultValue `rg => rg`
   */
-  ruleGroupProcessor?: (ruleGroup: RG$1) => Record<string, any>;
+  ruleGroupProcessor?: (ruleGroup: RG) => Record<string, any>;
   /**
   * For each rule and group in the query, any properties matching a key
   * in this object will be renamed to the corresponding value. To retain both

package/dist/cjs/react-querybuilder_core.cjs.development.js

@@ -1,30 +1,5 @@
-//#region rolldown:runtime
-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 __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-		key = keys[i];
-		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-			get: ((k) => from[k]).bind(null, key),
-			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-		});
-	}
-	return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-	value: mod,
-	enumerable: true
-}) : target, mod));
-
-//#endregion
 let immer = require("immer");
-immer = __toESM(immer);
 let numeric_quantity = require("numeric-quantity");
-numeric_quantity = __toESM(numeric_quantity);
 
 //#region src/defaults.ts
 /**
@@ -449,7 +424,8 @@ const standardClassnames = {
 	valueListItem: "rule-value-list-item",
 	branches: "queryBuilder-branches",
 	justified: "queryBuilder-justified",
-	hasSubQuery: "rule-hasSubQuery"
+	hasSubQuery: "rule-hasSubQuery",
+	loading: "queryBuilder-loading"
 };
 /**
 * Default classnames for each component.
@@ -496,7 +472,8 @@ const defaultControlClassnames = {
 	disabled: "",
 	valueListItem: "",
 	branches: "",
-	hasSubQuery: ""
+	hasSubQuery: "",
+	loading: ""
 };
 /**
 * Default reason codes for a group being invalid.
@@ -1028,7 +1005,7 @@ const prepareOptionList = (props) => {
 		label: placeholderLabel
 	};
 	const optionsProp = optionListPropOriginal ?? [defaultOption];
-	let optionList = [];
+	let optionList;
 	const opts = Array.isArray(optionsProp) ? toFullOptionList(optionsProp, baseOption, labelMap) : objectKeys(toFullOptionMap(optionsProp, baseOption)).map((opt) => ({
 		...optionsProp[opt],
 		name: opt,
@@ -1113,6 +1090,13 @@ const parseNumber = (val, { parseNumbers, bigIntOnOverflow } = {}) => {
 
 //#endregion
 //#region src/utils/transformQuery.ts
+/**
+* Recursively steps through a query object ({@link index!RuleGroupType RuleGroupType} or {@link index!RuleGroupTypeIC RuleGroupTypeIC}),
+* passing each {@link index!RuleType RuleType} object to a provided `ruleProcessor` function and returning a
+* new query object if there were any referential changes.
+*
+* @module transformQuery
+*/
 const remapProperties = (obj, propertyMap, deleteRemappedProperties) => (0, immer.produce)(obj, (draft) => {
 	for (const [k, v] of Object.entries(propertyMap)) if (v === false) delete draft[k];
 	else if (!!v && k !== v && k in draft) {
@@ -1389,18 +1373,29 @@ const translationMatchFilter = (key, keyToTest, conditions) => keyToTest.startsW
 * @group Export
 */
 const getNLTranslataion = (key, translations, conditions = []) => conditions.length === 0 ? translations[key] ?? defaultNLTranslations[key] ?? "" : Object.entries(translations).find(([keyToTest]) => translationMatchFilter(key, keyToTest, conditions))?.[1] ?? Object.entries(defaultNLTranslations).find(([keyToTest]) => translationMatchFilter(key, keyToTest, conditions))?.[1] ?? defaultNLTranslations[key] ?? "";
+/**
+* Transforms
+* - `match: { mode: "atLeast", threshold: 1 }` to `match: { mode: "some" }`
+* - `match: { mode: "atMost", threshold: 0 }` to `match: { mode: "none" }`.
+*
+* Returns:
+* - Processed `{ mode, threshold }` object for valid subqueries
+* - `null` if match mode is not applicable for the rule
+* - `false` if match mode is valid, but either
+*   1. `threshold` is required and invalid, or
+*   2. `value` is not a valid rule group.
+*/
 const processMatchMode = (rule) => {
 	const { mode, threshold } = rule.match ?? {};
-	if (mode) {
-		if (!isRuleGroup(rule.value)) return false;
-		const matchModeLC = lc(mode);
-		const matchModeCoerced = matchModeLC === "atleast" && threshold === 1 ? "some" : matchModeLC === "atmost" && threshold === 0 ? "none" : matchModeLC;
-		if ((matchModeCoerced === "atleast" || matchModeCoerced === "atmost" || matchModeCoerced === "exactly") && (typeof threshold !== "number" || threshold < 0)) return false;
-		return {
-			mode: matchModeCoerced,
-			threshold
-		};
-	}
+	if (!mode) return null;
+	if (!isRuleGroup(rule.value)) return false;
+	const matchModeLC = lc(mode);
+	const matchModeCoerced = matchModeLC === "atleast" && threshold === 1 ? "some" : matchModeLC === "atmost" && threshold === 0 ? "none" : matchModeLC;
+	if ((matchModeCoerced === "atleast" || matchModeCoerced === "atmost" || matchModeCoerced === "exactly") && (typeof threshold !== "number" || threshold < 0)) return false;
+	return {
+		mode: matchModeCoerced,
+		threshold
+	};
 };
 /**
 * "Replacer" method for JSON.stringify's second argument. Converts `bigint` values to
@@ -3902,7 +3897,8 @@ const mergeClassnames = (...args) => ({
 	matchMode: joinClassnamesByName("matchMode", args),
 	matchThreshold: joinClassnamesByName("matchThreshold", args),
 	branches: joinClassnamesByName("branches", args),
-	hasSubQuery: joinClassnamesByName("hasSubQuery", args)
+	hasSubQuery: joinClassnamesByName("hasSubQuery", args),
+	loading: joinClassnamesByName("loading", args)
 });
 
 //#endregion
@@ -3935,6 +3931,7 @@ const preferFlagProps = (props = {}, contextVals = {}, finalize) => objectEntrie
 */
 const prepareRule = (rule, { idGenerator = generateID } = {}) => (0, immer.produce)(rule, (draft) => {
 	if (!draft.id) draft.id = idGenerator();
+	if (processMatchMode(draft)) draft.value = prepareRuleGroup(draft.value, { idGenerator });
 });
 /**
 * Ensures that a rule group is valid by recursively adding an `id` property to the group itself