@react-querybuilder/core 8.13.0 → 8.14.1

package/dist/{basic-Cw014pDc.d.mts → basic-BXJVfD0P.d.ts}

@@ -11,25 +11,20 @@ import type {UnionToIntersection} from 'type-fest';
 type Union = {the(): void} | {great(arg: string): void} | {escape: boolean};
 
 type Intersection = UnionToIntersection<Union>;
-//=> {the(): void; great(arg: string): void; escape: boolean};
+//=> {the(): void} & {great(arg: string): void} & {escape: boolean}
 ```
 
 @category Type
 */
-type UnionToIntersection<Union> = (
-// `extends unknown` is always going to be the case and is used to convert the
+type UnionToIntersection<Union> = (// `extends unknown` is always going to be the case and is used to convert the
 // `Union` into a [distributive conditional
 // type](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html#distributive-conditional-types).
-Union extends unknown
-// The union type is used as the only argument to a function since the union
+Union extends unknown // The union type is used as the only argument to a function since the union
 // of function arguments is an intersection.
-? (distributedUnion: Union) => void
-// This won't happen.
-: never
-// Infer the `Intersection` type since TypeScript represents the positional
+? (distributedUnion: Union) => void // This won't happen.
+: never // Infer the `Intersection` type since TypeScript represents the positional
 // arguments of unions of functions as an intersection of the union.
-) extends ((mergedIntersection: infer Intersection) => void)
-// The `& Union` is to ensure result of `UnionToIntersection<A | B>` is always assignable to `A | B`
+) extends ((mergedIntersection: infer Intersection) => void) // The `& Union` is to ensure result of `UnionToIntersection<A | B>` is always assignable to `A | B`
 ? Intersection & Union : never;
 //#endregion
 //#region ../../node_modules/type-fest/source/keys-of-union.d.ts
@@ -70,8 +65,7 @@ type AllKeys = KeysOfUnion<Union>;
 
 @category Object
 */
-type KeysOfUnion<ObjectType> =
-// Hack to fix https://github.com/sindresorhus/type-fest/issues/1008
+type KeysOfUnion<ObjectType> = // Hack to fix https://github.com/sindresorhus/type-fest/issues/1008
 keyof UnionToIntersection<ObjectType extends unknown ? Record<keyof ObjectType, never> : never>;
 //#endregion
 //#region ../../node_modules/type-fest/source/is-any.d.ts
@@ -146,7 +140,7 @@ type T5 = IsOptionalKeyOf<User | Admin, 'surname'>;
 @category Type Guard
 @category Utilities
 */
-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;
+type IsOptionalKeyOf<Type extends object, Key extends keyof Type> = IsAny<Type | Key> extends true ? never : Key extends keyof Type ? Type extends Record<Key, Type[Key]> ? false : true : false;
 //#endregion
 //#region ../../node_modules/type-fest/source/optional-keys-of.d.ts
 /**
@@ -261,14 +255,14 @@ type IsTrue<T> = T extends true ? true : false;
 
 // When a distributive conditional is instantiated with `never`, the entire conditional results in `never`.
 type A = IsTrue<never>;
-//   ^? type A = never
+//=> never
 
 // If you don't want that behaviour, you can explicitly add an `IsNever` check before the distributive conditional.
 type IsTrueFixed<T> =
 	IsNever<T> extends true ? false : T extends true ? true : false;
 
 type B = IsTrueFixed<never>;
-//   ^? type B = false
+//=> false
 ```
 
 @category Type Guard
@@ -399,7 +393,6 @@ type C = IsArray<string>;
 type UnknownArray = readonly unknown[];
 //#endregion
 //#region ../../node_modules/type-fest/source/internal/array.d.ts
-
 /**
 Returns whether the given array `T` is readonly.
 */
@@ -517,7 +510,7 @@ const indexed: Record<string, unknown> = {}; // Allowed
 
 // @ts-expect-error
 const keyed: Record<'foo', unknown> = {}; // Error
-// => TS2739: Type '{}' is missing the following properties from type 'Record<"foo" | "bar", unknown>': foo, bar
+// TS2739: Type '{}' is missing the following properties from type 'Record<"foo" | "bar", unknown>': foo, bar
 ```
 
 Instead of causing a type error like the above, you can also use a [conditional type](https://www.typescriptlang.org/docs/handbook/2/conditional-types.html) to test whether a type is assignable to another:
@@ -526,12 +519,16 @@ Instead of causing a type error like the above, you can also use a [conditional
 type Indexed = {} extends Record<string, unknown>
 	? '✅ `{}` is assignable to `Record<string, unknown>`'
 	: '❌ `{}` is NOT assignable to `Record<string, unknown>`';
-// => '✅ `{}` is assignable to `Record<string, unknown>`'
+
+type IndexedResult = Indexed;
+//=> '✅ `{}` is assignable to `Record<string, unknown>`'
 
 type Keyed = {} extends Record<'foo' | 'bar', unknown>
 	? '✅ `{}` is assignable to `Record<\'foo\' | \'bar\', unknown>`'
 	: '❌ `{}` is NOT assignable to `Record<\'foo\' | \'bar\', unknown>`';
-// => "❌ `{}` is NOT assignable to `Record<'foo' | 'bar', unknown>`"
+
+type KeyedResult = Keyed;
+//=> '❌ `{}` is NOT assignable to `Record<\'foo\' | \'bar\', unknown>`'
 ```
 
 Using a [mapped type](https://www.typescriptlang.org/docs/handbook/2/mapped-types.html#further-exploration), you can then check for each `KeyType` of `ObjectType`...
@@ -579,7 +576,7 @@ type Example = {
 };
 
 type ExampleWithoutIndexSignatures = OmitIndexSignature<Example>;
-// => { foo: 'bar'; qux?: 'baz' | undefined; }
+//=> {foo: 'bar'; qux?: 'baz'}
 ```
 
 @see {@link PickIndexSignature}
@@ -637,11 +634,35 @@ type PickIndexSignature<ObjectType> = { [KeyType in keyof ObjectType as {} exten
 //#endregion
 //#region ../../node_modules/type-fest/source/merge.d.ts
 // Merges two objects without worrying about index signatures.
-type SimpleMerge<Destination, Source> = { [Key in keyof Destination as Key extends keyof Source ? never : Key]: Destination[Key] } & Source;
-
+type SimpleMerge<Destination, Source> = Simplify<{ [Key in keyof Destination as Key extends keyof Source ? never : Key]: Destination[Key] } & Source>;
 /**
 Merge two types into a new type. Keys of the second type overrides keys of the first type.
 
+This is different from the TypeScript `&` (intersection) operator. With `&`, conflicting property types are intersected, which often results in `never`. For example, `{a: string} & {a: number}` makes `a` become `string & number`, which resolves to `never`. With `Merge`, the second type's keys cleanly override the first, so `Merge<{a: string}, {a: number}>` gives `{a: number}` as expected. `Merge` also produces a flattened type (via `Simplify`), making it more readable in IDE tooltips compared to `A & B`.
+
+@example
+```
+import type {Merge} from 'type-fest';
+
+type Foo = {
+	a: string;
+	b: number;
+};
+
+type Bar = {
+	a: number; // Conflicts with Foo['a']
+	c: boolean;
+};
+
+// With `&`, `a` becomes `string & number` which is `never`. Not what you want.
+type WithIntersection = (Foo & Bar)['a'];
+//=> never
+
+// With `Merge`, `a` is cleanly overridden to `number`.
+type WithMerge = Merge<Foo, Bar>['a'];
+//=> number
+```
+
 @example
 ```
 import type {Merge} from 'type-fest';
@@ -661,7 +682,7 @@ type Bar = {
 };
 
 export type FooBar = Merge<Foo, Bar>;
-// => {
+//=> {
 // 	[x: string]: unknown;
 // 	[x: number]: number;
 // 	[x: symbol]: unknown;
@@ -671,9 +692,17 @@ export type FooBar = Merge<Foo, Bar>;
 // }
 ```
 
+Note: If you want a merge type that more accurately reflects the runtime behavior of object spread or `Object.assign`, refer to the {@link ObjectMerge} type.
+
+@see {@link ObjectMerge}
 @category Object
 */
-type Merge<Destination, Source> = Simplify<SimpleMerge<PickIndexSignature<Destination>, PickIndexSignature<Source>> & SimpleMerge<OmitIndexSignature<Destination>, OmitIndexSignature<Source>>>;
+type Merge<Destination, Source> = Destination extends unknown // For distributing `Destination`
+? Source extends unknown // For distributing `Source`
+? If<IsEqual<Destination, Source>, Destination, _Merge<Destination, Source>> : never // Should never happen
+: never;
+// Should never happen
+type _Merge<Destination, Source> = Simplify<SimpleMerge<PickIndexSignature<Destination>, PickIndexSignature<Source>> & SimpleMerge<OmitIndexSignature<Destination>, OmitIndexSignature<Source>>>;
 //#endregion
 //#region ../../node_modules/type-fest/source/internal/object.d.ts
 /**
@@ -796,7 +825,7 @@ type Filtered = Filter<'bar', 'foo'>;
 
 @see {Except}
 */
-type Filter<KeyType$1, ExcludeType> = IsEqual<KeyType$1, ExcludeType> extends true ? never : (KeyType$1 extends ExcludeType ? never : KeyType$1);
+type Filter<KeyType, ExcludeType> = IsEqual<KeyType, ExcludeType> extends true ? never : (KeyType extends ExcludeType ? never : KeyType);
 type ExceptOptions = {
   /**
   Disallow assigning non-specified properties.
@@ -808,7 +837,6 @@ type ExceptOptions = {
 type DefaultExceptOptions = {
   requireExactProps: false;
 };
-
 /**
 Create a type from an object type without certain keys.
 
@@ -832,14 +860,14 @@ type FooWithoutA = Except<Foo, 'a'>;
 
 // @ts-expect-error
 const fooWithoutA: FooWithoutA = {a: 1, b: '2'};
-//=> errors: 'a' does not exist in type '{ b: string; }'
+// errors: 'a' does not exist in type '{ b: string; }'
 
 type FooWithoutB = Except<Foo, 'b', {requireExactProps: true}>;
-//=> {a: number} & Partial<Record<"b", never>>
+//=> {a: number} & Partial<Record<'b', never>>
 
 // @ts-expect-error
 const fooWithoutB: FooWithoutB = {a: 1, b: '2'};
-//=> errors at 'b': Type 'string' is not assignable to type 'undefined'.
+// errors at 'b': Type 'string' is not assignable to type 'undefined'.
 
 // The `Omit` utility type doesn't work when omitting specific keys from objects containing index signatures.
 
@@ -854,12 +882,12 @@ type UserData = {
 
 // `Omit` clearly doesn't behave as expected in this case:
 type PostPayload = Omit<UserData, 'email'>;
-//=> { [x: string]: string; [x: number]: string; }
+//=> {[x: string]: string; [x: number]: string}
 
 // In situations like this, `Except` works better.
 // It simply removes the `email` key while preserving all the other keys.
 type PostPayloadFixed = Except<UserData, 'email'>;
-//=> { [x: string]: string; name: string; role: 'admin' | 'user'; }
+//=> {[x: string]: string; name: string; role: 'admin' | 'user'}
 ```
 
 @category Object
@@ -884,11 +912,7 @@ type Foo = {
 };
 
 type SomeRequired = SetRequired<Foo, 'b' | 'c'>;
-// type SomeRequired = {
-// 	a?: number;
-// 	b: string; // Was already required and still is.
-// 	c: boolean; // Is now required.
-// }
+//=> {a?: number; b: string; c: boolean}
 
 // Set specific indices in an array to be required.
 type ArrayExample = SetRequired<[number?, number?, number?], 0 | 1>;
@@ -898,23 +922,18 @@ type ArrayExample = SetRequired<[number?, number?, number?], 0 | 1>;
 @category Object
 */
 type SetRequired<BaseType, Keys extends keyof BaseType> = (BaseType extends ((...arguments_: never) => any) ? (...arguments_: Parameters<BaseType>) => ReturnType<BaseType> : unknown) & _SetRequired<BaseType, Keys>;
-type _SetRequired<BaseType, Keys extends keyof BaseType> = BaseType extends UnknownArray ? SetArrayRequired<BaseType, Keys> extends infer ResultantArray ? If<IsArrayReadonly<BaseType>, Readonly<ResultantArray>, ResultantArray> : never : Simplify<
-// Pick just the keys that are optional from the base type.
-Except<BaseType, Keys> &
-// Pick the keys that should be required from the base type and make them required.
+type _SetRequired<BaseType, Keys extends keyof BaseType> = BaseType extends UnknownArray ? SetArrayRequired<BaseType, Keys> extends infer ResultantArray ? If<IsArrayReadonly<BaseType>, Readonly<ResultantArray>, ResultantArray> : never : Simplify< // Pick just the keys that are optional from the base type.
+Except<BaseType, Keys> & // Pick the keys that should be required from the base type and make them required.
 Required<HomomorphicPick<BaseType, Keys>>>;
-
 /**
 Remove the optional modifier from the specified keys in an array.
 */
 type SetArrayRequired<TArray extends UnknownArray, Keys, Counter extends any[] = [], Accumulator extends UnknownArray = []> = TArray extends unknown // For distributing `TArray` when it's a union
-? keyof TArray & `${number}` extends never
-// Exit if `TArray` is empty (e.g., []), or
+? keyof TArray & `${number}` extends never // Exit if `TArray` is empty (e.g., []), or
 // `TArray` contains no non-rest elements preceding the rest element (e.g., `[...string[]]` or `[...string[], string]`).
 ? [...Accumulator, ...TArray] : TArray extends readonly [(infer First)?, ...infer Rest] ? '0' extends OptionalKeysOf<TArray> // If the first element of `TArray` is optional
 ? `${Counter['length']}` extends `${Keys & (string | number)}` // If the current index needs to be required
-? SetArrayRequired<Rest, Keys, [...Counter, any], [...Accumulator, First]>
-// If the current element is optional, but it doesn't need to be required,
+? SetArrayRequired<Rest, Keys, [...Counter, any], [...Accumulator, First]> // If the current element is optional, but it doesn't need to be required,
 // then we can exit early, since no further elements can now be made required.
 : [...Accumulator, ...TArray] : SetArrayRequired<Rest, Keys, [...Counter, any], [...Accumulator, TArray[0]]> : never // Should never happen, since `[(infer F)?, ...infer R]` is a top-type for arrays.
 : never; // Should never happen
@@ -963,7 +982,7 @@ type FlexibleOption<N extends string = string> = Simplify<WithUnknownIndex<Requi
 *
 * @group Option Lists
 */
-type ToFlexibleOption<Opt$1 extends BaseOption | string> = WithUnknownIndex<RequireAtLeastOne<Opt$1 extends string ? FlexibleOption<Opt$1> : Opt$1, "name" | "value">>;
+type ToFlexibleOption<Opt extends BaseOption | string> = WithUnknownIndex<RequireAtLeastOne<Opt extends string ? FlexibleOption<Opt> : Opt, "name" | "value">>;
 /**
 * A generic {@link Option} requiring both `name` _and_ `value` properties.
 * Props that extend {@link OptionList} accept {@link BaseOption}, but
@@ -991,38 +1010,38 @@ type BaseFullOption<N extends string = string> = Simplify<SetRequired<BaseOption
 *
 * @group Option Lists
 */
-type ToFullOption<Opt$1 extends BaseOption> = Opt$1 extends BaseFullOption ? Opt$1 : Opt$1 extends BaseOption<infer IdentifierType> ? WithUnknownIndex<Opt$1 & FullOption<IdentifierType>> : never;
+type ToFullOption<Opt extends BaseOption> = Opt extends BaseFullOption ? Opt : Opt extends BaseOption<infer IdentifierType> ? WithUnknownIndex<Opt & FullOption<IdentifierType>> : never;
 /**
 * A group of {@link Option}s, usually within an {@link OptionList}.
 *
 * @group Option Lists
 */
-interface OptionGroup<Opt$1 extends BaseOption = FlexibleOption> {
+interface OptionGroup<Opt extends BaseOption = FlexibleOption> {
   label: string;
-  options: WithUnknownIndex<Opt$1>[];
+  options: WithUnknownIndex<Opt>[];
 }
 /**
 * A group of {@link BaseOption}s, usually within a {@link FlexibleOptionList}.
 *
 * @group Option Lists
 */
-type FlexibleOptionGroup<Opt$1 extends BaseOption | string = BaseOption> = {
+type FlexibleOptionGroup<Opt extends BaseOption | string = BaseOption> = {
   label: string;
-  options: (Opt$1 extends BaseFullOption ? Opt$1 : ToFlexibleOption<Opt$1>)[];
+  options: (Opt extends BaseFullOption ? Opt : ToFlexibleOption<Opt>)[];
 };
 /**
 * Either an array of {@link Option}s or an array of {@link OptionGroup}s.
 *
 * @group Option Lists
 */
-type OptionList<Opt$1 extends Option = Option> = Opt$1[] | OptionGroup<Opt$1>[];
+type OptionList<Opt extends Option = Option> = Opt[] | OptionGroup<Opt>[];
 /**
 * An array of options or option groups, like {@link OptionList} but the option type
 * may use either `name` or `value` as the primary identifier.
 *
 * @group Option Lists
 */
-type FlexibleOptionList<Opt$1 extends BaseOption> = ToFlexibleOption<Opt$1>[] | FlexibleOptionGroup<ToFlexibleOption<Opt$1>>[];
+type FlexibleOptionList<Opt extends BaseOption> = ToFlexibleOption<Opt>[] | FlexibleOptionGroup<ToFlexibleOption<Opt>>[];
 /**
 * An array of options or option groups, like {@link OptionList}, but using
 * {@link FullOption} instead of {@link Option}. This means that every member is
@@ -1030,7 +1049,7 @@ type FlexibleOptionList<Opt$1 extends BaseOption> = ToFlexibleOption<Opt$1>[] |
 *
 * @group Option Lists
 */
-type FullOptionList<Opt$1 extends BaseOption> = Opt$1 extends BaseFullOption ? Opt$1[] | OptionGroup<Opt$1>[] : ToFullOption<Opt$1>[] | OptionGroup<ToFullOption<Opt$1>>[];
+type FullOptionList<Opt extends BaseOption> = Opt extends BaseFullOption ? Opt[] | OptionGroup<Opt>[] : ToFullOption<Opt>[] | OptionGroup<ToFullOption<Opt>>[];
 //#endregion
 //#region src/types/ruleGroups.d.ts
 /**
@@ -1051,10 +1070,10 @@ interface CommonRuleAndGroupProperties {
 * The main rule type. The `field`, `operator`, and `value` properties
 * can be narrowed with generics.
 */
-interface RuleType<F extends string = string, O extends string = string, V$1 = any, C extends string = string> extends CommonRuleAndGroupProperties {
+interface RuleType<F extends string = string, O extends string = string, V = any, C extends string = string> extends CommonRuleAndGroupProperties {
   field: F;
   operator: O;
-  value: V$1;
+  value: V;
   valueSource?: ValueSource;
   match?: MatchConfig;
   /**
@@ -1271,7 +1290,6 @@ type ParseNumberMethodName = "enhanced" | "native" | "strict";
 /**
 * Parsing algorithms used by {@link parseNumber}.
 */
-
 type ParseNumbersModerationLevel = "-limited" | "";
 /**
 * Options for the `parseNumbers` prop of {@link react-querybuilder!QueryBuilder QueryBuilder}.
@@ -1279,4 +1297,4 @@ type ParseNumbersModerationLevel = "-limited" | "";
 type ParseNumbersPropConfig = boolean | `${ParseNumberMethodName}${ParseNumbersModerationLevel}`;
 //#endregion
 export { Except as C, SetRequired as S, RuleGroupType as _, ValueSource as a, FullOptionList as b, RuleValidator as c, DefaultRuleGroupTypeIC as d, RuleGroupTypeAny as f, DefaultRuleGroupType as g, DefaultOperatorName as h, ParseNumbersPropConfig as i, ValidationMap as l, DefaultCombinatorName as m, FullOperator as n, ValueSources as o, RuleGroupTypeIC as p, InputType as r, QueryValidator as s, FullField as t, ValidationResult as u, RuleType as v, OptionList as x, FlexibleOptionList as y };
-//# sourceMappingURL=basic-Cw014pDc.d.mts.map
+//# sourceMappingURL=basic-BXJVfD0P.d.ts.map