@react-querybuilder/core 8.12.0 → 8.14.0

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

@@ -26,34 +26,6 @@ type Intersection = UnionToIntersection<Union>;
 //=> {the(): void; great(arg: string): void; escape: boolean};
 ```
 
-A more applicable example which could make its way into your library code follows.
-
-@example
-```
-import type {UnionToIntersection} from 'type-fest';
-
-class CommandOne {
-	commands: {
-		a1: () => undefined,
-		b1: () => undefined,
-	}
-}
-
-class CommandTwo {
-	commands: {
-		a2: (argA: string) => undefined,
-		b2: (argB: string) => undefined,
-	}
-}
-
-const union = [new CommandOne(), new CommandTwo()].map(instance => instance.commands);
-type Union = typeof union;
-//=> {a1(): void; b1(): void} | {a2(argA: string): void; b2(argB: string): void}
-
-type Intersection = UnionToIntersection<Union>;
-//=> {a1(): void; b1(): void; a2(argA: string): void; b2(argB: string): void}
-```
-
 @category Type
 */
 type UnionToIntersection<Union> = (
@@ -129,8 +101,8 @@ import type {IsAny} from 'type-fest';
 const typedObject = {a: 1, b: 2} as const;
 const anyObject: any = {a: 1, b: 2};
 
-function get<O extends (IsAny<O> extends true ? {} : Record<string, number>), K extends keyof O = keyof O>(obj: O, key: K) {
-	return obj[key];
+function get<O extends (IsAny<O> extends true ? {} : Record<string, number>), K extends keyof O = keyof O>(object: O, key: K) {
+	return object[key];
 }
 
 const typedA = get(typedObject, 'a');
@@ -155,17 +127,17 @@ This is useful when writing utility types or schema validators that need to diff
 ```
 import type {IsOptionalKeyOf} from 'type-fest';
 
-interface User {
+type User = {
 	name: string;
 	surname: string;
 
 	luckyNumber?: number;
-}
+};
 
-interface Admin {
+type Admin = {
 	name: string;
 	surname?: string;
-}
+};
 
 type T1 = IsOptionalKeyOf<User, 'luckyNumber'>;
 //=> true
@@ -198,12 +170,12 @@ This is useful when you want to create a new type that contains different type v
 ```
 import type {OptionalKeysOf, Except} from 'type-fest';
 
-interface User {
+type User = {
 	name: string;
 	surname: string;
 
 	luckyNumber?: number;
-}
+};
 
 const REMOVE_FIELD = Symbol('remove field symbol');
 type UpdateOperation<Entity extends object> = Except<Partial<Entity>, OptionalKeysOf<Entity>> & {
@@ -211,12 +183,12 @@ type UpdateOperation<Entity extends object> = Except<Partial<Entity>, OptionalKe
 };
 
 const update1: UpdateOperation<User> = {
-	name: 'Alice'
+	name: 'Alice',
 };
 
 const update2: UpdateOperation<User> = {
 	name: 'Bob',
-	luckyNumber: REMOVE_FIELD
+	luckyNumber: REMOVE_FIELD,
 };
 ```
 
@@ -236,17 +208,23 @@ This is useful when you want to create a new type that contains different type v
 ```
 import type {RequiredKeysOf} from 'type-fest';
 
-declare function createValidation<Entity extends object, Key extends RequiredKeysOf<Entity> = RequiredKeysOf<Entity>>(field: Key, validator: (value: Entity[Key]) => boolean): ValidatorFn;
+declare function createValidation<
+	Entity extends object,
+	Key extends RequiredKeysOf<Entity> = RequiredKeysOf<Entity>,
+>(field: Key, validator: (value: Entity[Key]) => boolean): (entity: Entity) => boolean;
 
-interface User {
+type User = {
 	name: string;
 	surname: string;
-
 	luckyNumber?: number;
-}
+};
 
 const validator1 = createValidation<User>('name', value => value.length < 25);
 const validator2 = createValidation<User>('surname', value => value.length < 25);
+
+// @ts-expect-error
+const validator3 = createValidation<User>('luckyNumber', value => value > 0);
+// Error: Argument of type '"luckyNumber"' is not assignable to parameter of type '"name" | "surname"'.
 ```
 
 @category Utilities
@@ -268,29 +246,41 @@ Useful in type utilities, such as checking if something does not occur.
 ```
 import type {IsNever, And} from 'type-fest';
 
-// https://github.com/andnp/SimplyTyped/blob/master/src/types/strings.ts
-type AreStringsEqual<A extends string, B extends string> =
-	And<
-		IsNever<Exclude<A, B>> extends true ? true : false,
-		IsNever<Exclude<B, A>> extends true ? true : false
-	>;
-
-type EndIfEqual<I extends string, O extends string> =
-	AreStringsEqual<I, O> extends true
-		? never
-		: void;
-
-function endIfEqual<I extends string, O extends string>(input: I, output: O): EndIfEqual<I, O> {
-	if (input === output) {
-		process.exit(0);
-	}
-}
+type A = IsNever<never>;
+//=> true
 
-endIfEqual('abc', 'abc');
-//=> never
+type B = IsNever<any>;
+//=> false
+
+type C = IsNever<unknown>;
+//=> false
+
+type D = IsNever<never[]>;
+//=> false
+
+type E = IsNever<object>;
+//=> false
+
+type F = IsNever<string>;
+//=> false
+```
 
-endIfEqual('abc', '123');
-//=> void
+@example
+```
+import type {IsNever} from 'type-fest';
+
+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
+
+// 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
 ```
 
 @category Type Guard
@@ -311,7 +301,7 @@ Note:
 
 @example
 ```
-import {If} from 'type-fest';
+import type {If} from 'type-fest';
 
 type A = If<true, 'yes', 'no'>;
 //=> 'yes'
@@ -331,7 +321,7 @@ type E = If<never, 'yes', 'no'>;
 
 @example
 ```
-import {If, IsAny, IsNever} from 'type-fest';
+import type {If, IsAny, IsNever} from 'type-fest';
 
 type A = If<IsAny<unknown>, 'is any', 'not any'>;
 //=> 'not any'
@@ -342,7 +332,7 @@ type B = If<IsNever<never>, 'is never', 'not never'>;
 
 @example
 ```
-import {If, IsEqual} from 'type-fest';
+import type {If, IsEqual} from 'type-fest';
 
 type IfEqual<T, U, IfBranch, ElseBranch> = If<IsEqual<T, U>, IfBranch, ElseBranch>;
 
@@ -535,10 +525,11 @@ const literal = {foo: 123, bar: 'hello', baz: 456};
 const someType: SomeType = literal;
 const someInterface: SomeInterface = literal;
 
-function fn(object: Record<string, unknown>): void {}
+declare function fn(object: Record<string, unknown>): void;
 
 fn(literal); // Good: literal object type is sealed
 fn(someType); // Good: type is sealed
+// @ts-expect-error
 fn(someInterface); // Error: Index signature for type 'string' is missing in type 'someInterface'. Because `interface` can be re-opened
 fn(someInterface as Simplify<SomeInterface>); // Good: transform an `interface` into a `type`
 ```
@@ -576,9 +567,9 @@ type Includes<Value extends readonly any[], Item> =
 @category Type Guard
 @category Utilities
 */
-type IsEqual<A$1, B$1> = [A$1, B$1] extends [infer AA, infer BB] ? [AA] extends [never] ? [BB] extends [never] ? true : false : [BB] extends [never] ? false : _IsEqual<AA, BB> : false;
+type IsEqual<A, B> = [A] extends [B] ? [B] extends [A] ? _IsEqual<A, B> : false : false;
 // This version fails the `equalWrappedTupleIntersectionToBeNeverAndNeverExpanded` test in `test-d/is-equal.ts`.
-type _IsEqual<A$1, B$1> = (<G>() => G extends A$1 & G | G ? 1 : 2) extends (<G>() => G extends B$1 & G | G ? 1 : 2) ? true : false;
+type _IsEqual<A, B> = (<G>() => G extends A & G | G ? 1 : 2) extends (<G>() => G extends B & G | G ? 1 : 2) ? true : false;
 //#endregion
 //#region ../../node_modules/type-fest/source/omit-index-signature.d.ts
 /**
@@ -598,6 +589,7 @@ It relies on the fact that an empty object (`{}`) is assignable to an object wit
 ```
 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
 ```
@@ -611,16 +603,14 @@ type Indexed = {} extends Record<string, unknown>
 // => '✅ `{}` 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 assignable to `Record<\'foo\' | \'bar\', unknown>`'
+	: '❌ `{}` is NOT assignable to `Record<\'foo\' | \'bar\', unknown>`';
 // => "❌ `{}` 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`...
 
 ```
-import type {OmitIndexSignature} from 'type-fest';
-
 type OmitIndexSignature<ObjectType> = {
 	[KeyType in keyof ObjectType // Map each key of `ObjectType`...
 	]: ObjectType[KeyType]; // ...to its original value, i.e. `OmitIndexSignature<Foo> == Foo`.
@@ -630,14 +620,12 @@ type OmitIndexSignature<ObjectType> = {
 ...whether an empty object (`{}`) would be assignable to an object with that `KeyType` (`Record<KeyType, unknown>`)...
 
 ```
-import type {OmitIndexSignature} from 'type-fest';
-
 type OmitIndexSignature<ObjectType> = {
 	[KeyType in keyof ObjectType
-		// Is `{}` assignable to `Record<KeyType, unknown>`?
-		as {} extends Record<KeyType, unknown>
-			? ... // ✅ `{}` is assignable to `Record<KeyType, unknown>`
-			: ... // ❌ `{}` is NOT assignable to `Record<KeyType, unknown>`
+	// Is `{}` assignable to `Record<KeyType, unknown>`?
+	as {} extends Record<KeyType, unknown>
+		? never // ✅ `{}` is assignable to `Record<KeyType, unknown>`
+		: KeyType // ❌ `{}` is NOT assignable to `Record<KeyType, unknown>`
 	]: ObjectType[KeyType];
 };
 ```
@@ -648,21 +636,21 @@ If `{}` is assignable, it means that `KeyType` is an index signature and we want
 ```
 import type {OmitIndexSignature} from 'type-fest';
 
-interface Example {
+type Example = {
 	// These index signatures will be removed.
-	[x: string]: any
-	[x: number]: any
-	[x: symbol]: any
-	[x: `head-${string}`]: string
-	[x: `${string}-tail`]: string
-	[x: `head-${string}-tail`]: string
-	[x: `${bigint}`]: string
-	[x: `embedded-${number}`]: string
+	[x: string]: any;
+	[x: number]: any;
+	[x: symbol]: any;
+	[x: `head-${string}`]: string;
+	[x: `${string}-tail`]: string;
+	[x: `head-${string}-tail`]: string;
+	[x: `${bigint}`]: string;
+	[x: `embedded-${number}`]: string;
 
 	// These explicitly defined keys will remain.
 	foo: 'bar';
 	qux?: 'baz';
-}
+};
 
 type ExampleWithoutIndexSignatures = OmitIndexSignature<Example>;
 // => { foo: 'bar'; qux?: 'baz' | undefined; }
@@ -732,12 +720,12 @@ Merge two types into a new type. Keys of the second type overrides keys of the f
 ```
 import type {Merge} from 'type-fest';
 
-interface Foo {
+type Foo = {
 	[x: string]: unknown;
 	[x: number]: unknown;
 	foo: string;
 	bar: symbol;
-}
+};
 
 type Bar = {
 	[x: number]: number;
@@ -916,12 +904,14 @@ type Foo = {
 type FooWithoutA = Except<Foo, 'a'>;
 //=> {b: string}
 
+// @ts-expect-error
 const fooWithoutA: FooWithoutA = {a: 1, b: '2'};
 //=> errors: 'a' does not exist in type '{ b: string; }'
 
 type FooWithoutB = Except<Foo, 'b', {requireExactProps: true}>;
 //=> {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'.
 
@@ -938,12 +928,12 @@ type UserData = {
 
 // `Omit` clearly doesn't behave as expected in this case:
 type PostPayload = Omit<UserData, 'email'>;
-//=> type PostPayload = { [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 PostPayload = Except<UserData, 'email'>;
-//=> type PostPayload = { [x: string]: string; name: string; role: 'admin' | 'user'; }
+type PostPayloadFixed = Except<UserData, 'email'>;
+//=> { [x: string]: string; name: string; role: 'admin' | 'user'; }
 ```
 
 @category Object
@@ -967,13 +957,13 @@ type Responder = {
 
 const responder: RequireAtLeastOne<Responder, 'text' | 'json'> = {
 	json: () => '{"message": "ok"}',
-	secure: true
+	secure: true,
 };
 ```
 
 @category Object
 */
-type RequireAtLeastOne<ObjectType, KeysType extends keyof ObjectType = keyof ObjectType> = IfNotAnyOrNever<ObjectType, If<IsNever<KeysType>, never, _RequireAtLeastOne<ObjectType, If<IsAny<KeysType>, keyof ObjectType, KeysType>>>>;
+type RequireAtLeastOne$1<ObjectType, KeysType extends keyof ObjectType = keyof ObjectType> = IfNotAnyOrNever<ObjectType, If<IsNever<KeysType>, never, _RequireAtLeastOne<ObjectType, If<IsAny<KeysType>, keyof ObjectType, KeysType>>>>;
 type _RequireAtLeastOne<ObjectType, KeysType extends keyof ObjectType> = {
   // For each `Key` in `KeysType` make a mapped type:
 [Key in KeysType]-?: Required<Pick<ObjectType, Key>> &
@@ -1042,7 +1032,7 @@ type Foo = {
 	a: number;
 	b?: string;
 	c: boolean;
-}
+};
 
 type SomeOptional = SetOptional<Foo, 'b' | 'c'>;
 // type SomeOptional = {
@@ -1076,7 +1066,7 @@ type Foo = {
 	a?: number;
 	b: string;
 	c?: boolean;
-}
+};
 
 type SomeRequired = SetRequired<Foo, 'b' | 'c'>;
 // type SomeRequired = {
@@ -1115,7 +1105,7 @@ type SetArrayRequired<TArray extends UnknownArray, Keys, Counter extends any[] =
 : never; // Should never happen
 //#endregion
 //#region src/types/options.d.ts
-type RequireAtLeastOne$1<ObjectType, KeysType extends keyof ObjectType> = { [Key in KeysType]-?: Required<Pick<ObjectType, Key>> & Partial<Pick<ObjectType, Exclude<KeysType, Key>>> }[KeysType] & Except<ObjectType, KeysType>;
+type RequireAtLeastOne<ObjectType, KeysType extends keyof ObjectType> = { [Key in KeysType]-?: Required<Pick<ObjectType, Key>> & Partial<Pick<ObjectType, Exclude<KeysType, Key>>> }[KeysType] & Except<ObjectType, KeysType>;
 type StringUnionToFlexibleOptionArray<Op extends string> = Array<Op extends unknown ? FlexibleOption<Op> : never>;
 type StringUnionToFullOptionArray<Op extends string> = Array<Op extends unknown ? FullOption<Op> : never>;
 /**
@@ -1130,7 +1120,7 @@ type GetOptionType<OL extends FlexibleOptionList<FullOption>> = OL extends Flexi
 *
 * @group Option Lists
 */
-type GetOptionIdentifierType<Opt$1 extends BaseOption> = Opt$1 extends Option<infer NameType> | ValueOption<infer NameType> ? NameType : string;
+type GetOptionIdentifierType<Opt extends BaseOption> = Opt extends Option<infer NameType> | ValueOption<infer NameType> ? NameType : string;
 /**
 * Adds an `unknown` index property to an interface.
 */
@@ -1172,14 +1162,14 @@ type ValueOption<N extends string = string> = Simplify<WithUnknownIndex<SetRequi
 *
 * @group Option Lists
 */
-type FlexibleOption<N extends string = string> = Simplify<WithUnknownIndex<RequireAtLeastOne$1<BaseOption<N>, "name" | "value">>>;
+type FlexibleOption<N extends string = string> = Simplify<WithUnknownIndex<RequireAtLeastOne<BaseOption<N>, "name" | "value">>>;
 /**
 * Utility type to turn an {@link Option}, {@link ValueOption}, or {@link BaseOption}
 * into a {@link FlexibleOption}.
 *
 * @group Option Lists
 */
-type ToFlexibleOption<Opt$1 extends BaseOption | string> = WithUnknownIndex<RequireAtLeastOne$1<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
@@ -1207,7 +1197,7 @@ 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;
 /**
 * @deprecated Renamed to {@link Option}.
 *
@@ -1219,39 +1209,39 @@ type NameLabelPair<N extends string = string> = Option<N>;
 *
 * @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 the option type
 * may use either `name` or `value` as the primary identifier.
 *
 * @group Option Lists
 */
-type FlexibleOptionListProp<Opt$1 extends BaseOption> = (ToFlexibleOption<Opt$1> | GetOptionIdentifierType<Opt$1>)[] | FlexibleOptionGroup<ToFlexibleOption<Opt$1> | GetOptionIdentifierType<Opt$1>>[];
+type FlexibleOptionListProp<Opt extends BaseOption> = (ToFlexibleOption<Opt> | GetOptionIdentifierType<Opt>)[] | FlexibleOptionGroup<ToFlexibleOption<Opt> | GetOptionIdentifierType<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
@@ -1259,7 +1249,7 @@ type FlexibleOptionListProp<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>>[];
 /**
 * Map of option identifiers to their respective {@link Option}.
 *
@@ -1327,7 +1317,7 @@ type RuleGroupArray<RG extends RuleGroupType = RuleGroupType, R extends RuleType
 * All updateable properties of rules and groups (everything except
 * `id`, `path`, and `rules`).
 */
-type UpdateableProperties = Exclude<keyof (RuleType & RuleGroupType), "id" | "path" | "rules">;
+type UpdateableProperties = Exclude<keyof (RuleType & RuleGroupType), "id" | "path" | "rules"> | (string & {});
 /**
 * The type of the `rules` array in a {@link DefaultRuleGroupType}.
 */
@@ -3729,14 +3719,14 @@ declare const objectEntries: <Type extends Record<PropertyKey, unknown>>(value:
 *
 * @group Option Lists
 */
-declare function toFullOption<Opt$1 extends BaseOption>(opt: Opt$1 | string, baseProperties?: Record<string, unknown>, labelMap?: Record<string, unknown>): ToFullOption<Opt$1>;
+declare function toFullOption<Opt extends BaseOption>(opt: Opt | string, baseProperties?: Record<string, unknown>, labelMap?: Record<string, unknown>): ToFullOption<Opt>;
 /**
 * Converts an {@link OptionList} or {@link FlexibleOptionList} into a {@link FullOptionList}.
 * Lists of full options are left unchanged.
 *
 * @group Option Lists
 */
-declare function toFullOptionList<Opt$1 extends BaseOption>(optList: unknown[], baseProperties?: Record<string, unknown>, labelMap?: Record<string, unknown>): FullOptionList<Opt$1>;
+declare function toFullOptionList<Opt extends BaseOption>(optList: unknown[], baseProperties?: Record<string, unknown>, labelMap?: Record<string, unknown>): FullOptionList<Opt>;
 /**
 * Converts a {@link FlexibleOptionList} into a {@link FullOptionList}.
 * Lists of full options are left unchanged.
@@ -3762,7 +3752,7 @@ declare const uniqByName: <T extends {
 *
 * @group Option Lists
 */
-declare const uniqByIdentifier: <T extends RequireAtLeastOne<{
+declare const uniqByIdentifier: <T extends RequireAtLeastOne$1<{
   name: string;
   value: string;
 }, "name" | "value">>(originalArray: T[]) => T[];
@@ -3818,9 +3808,9 @@ declare function getOption<OptType extends Option>(arr: FlexibleOptionList<OptTy
 *
 * @group Option Lists
 */
-declare function getFirstOption<Opt$1 extends FullOption>(arr?: OptionGroup<Opt$1>[] | Opt$1[]): GetOptionIdentifierType<Opt$1> | null;
-declare function getFirstOption<Opt$1 extends ValueOption>(arr?: OptionGroup<Opt$1>[] | Opt$1[]): GetOptionIdentifierType<Opt$1> | null;
-declare function getFirstOption<Opt$1 extends Option>(arr?: OptionGroup<Opt$1>[] | Opt$1[]): GetOptionIdentifierType<Opt$1> | null;
+declare function getFirstOption<Opt extends FullOption>(arr?: OptionGroup<Opt>[] | Opt[]): GetOptionIdentifierType<Opt> | null;
+declare function getFirstOption<Opt extends ValueOption>(arr?: OptionGroup<Opt>[] | Opt[]): GetOptionIdentifierType<Opt> | null;
+declare function getFirstOption<Opt extends Option>(arr?: OptionGroup<Opt>[] | Opt[]): GetOptionIdentifierType<Opt> | null;
 /**
 * Flattens {@link FlexibleOptionGroup} arrays into {@link BaseOption} arrays.
 * If the array is already flat, it is returned as is.
@@ -3922,6 +3912,17 @@ declare const getCommonAncestorPath: (path1: Path, path2: Path) => Path;
 */
 declare const pathIsDisabled: (path: Path, query: RuleGroupTypeAny) => boolean;
 //#endregion
+//#region ../react-querybuilder/src/redux/getRqbStore.d.ts
+declare global {
+  var __RQB_DEVTOOLS__: boolean | undefined;
+}
+/**
+* Gets the singleton React Query Builder store instance.
+* DevTools are enabled if either:
+* - globalThis.__RQB_DEVTOOLS__ is truthy
+* - window.__RQB_DEVTOOLS__ is truthy
+*/
+//#endregion
 //#region src/utils/preferProp.d.ts
 /**
 * For given default, prop, and context values, return the first provided of prop,

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

@@ -750,7 +750,7 @@ const convertFromIC = (rg) => {
 */
 const convertToIC = (rg) => {
 	if (isRuleGroupTypeIC(rg)) return rg;
-	const { combinator,...queryWithoutCombinator } = rg;
+	const { combinator, ...queryWithoutCombinator } = rg;
 	const rules = [];
 	const { length } = rg.rules;
 	for (const [idx, r] of rg.rules.entries()) {
@@ -2585,7 +2585,30 @@ const defaultRuleProcessorElasticSearch = (rule, options = {}) => {
 	const { field, operator, value, valueSource } = rule;
 	const { parseNumbers, preserveValueOrder } = options;
 	const operatorLC = lc(operator);
-	if (processMatchMode(rule)) return false;
+	const matchEval = processMatchMode(rule);
+	if (matchEval === false) return false;
+	else if (matchEval) {
+		const { mode } = matchEval;
+		const subQuery = defaultRuleGroupProcessorElasticSearch(transformQuery(rule.value, { ruleProcessor: (r) => ({
+			...r,
+			field: r.field ? `${field}.${r.field}` : field
+		}) }), options);
+		if (Object.keys(subQuery).length === 0) return false;
+		switch (mode) {
+			case "some": return { nested: {
+				path: field,
+				query: subQuery
+			} };
+			case "none": return { bool: { must_not: { nested: {
+				path: field,
+				query: subQuery
+			} } } };
+			case "all":
+			case "atleast":
+			case "atmost":
+			case "exactly": return false;
+		}
+	}
 	if (valueSource === "field") {
 		if (toArray(value).some((v) => typeof v !== "string")) return false;
 		const fieldForScript = escapeSQ(field);
@@ -2959,7 +2982,8 @@ const defaultValueProcessorNL = (rule, opts = {}) => {
 			const valueAsArray = toArray(rule.value);
 			if (valueAsArray.length === 0) return "";
 			const valStringArray = valueAsArray.map((v) => valueIsField ? wrapFieldName(getOption(fields ?? [], v)?.label ?? v) : shouldRenderAsNumber(v, parseNumbers) ? `${trimIfString(v)}` : `${wrapAndEscape(v)}`);
-			return `${valStringArray.slice(0, -1).join(", ")}${valStringArray.length > 2 ? "," : ""} ${orTL} ${valStringArray.at(-1)}`;
+			if (valStringArray.length === 1) return valStringArray[0];
+			return `(${`${valStringArray.slice(0, -1).join(", ")}${valStringArray.length > 2 ? "," : ""} ${orTL} ${valStringArray.at(-1)}`})`;
 		}
 	}
 	if (typeof rule.value === "boolean") return rule.value ? trueTL : falseTL;
@@ -3004,17 +3028,22 @@ const defaultOperatorProcessorNL = (rule, opts = {}) => {
 	const { field, operator, valueSource = "value" } = rule;
 	// istanbul ignore next
 	const { getOperators = defaultGetOperators, operatorMap: operatorMapParam = defaultExportOperatorMap } = opts;
-	const mapOperatorMap = new Map(Object.entries(defaultExportOperatorMap));
-	for (const [key, value] of Object.entries(operatorMapParam)) mapOperatorMap.set(lc(key), value);
-	const operatorMap = Object.fromEntries(mapOperatorMap);
+	const mergedOperatorMap = new Map(Object.entries(defaultExportOperatorMap));
+	for (const [key, value] of Object.entries(operatorMapParam)) mergedOperatorMap.set(lc(key), value);
+	const operatorMap = Object.fromEntries(mergedOperatorMap);
+	const operatorLC = lc(operator);
+	var normalizedOperator = operator;
+	const hasSingleValue = toArray(rule.value).length === 1;
+	if (operatorLC === "in" && hasSingleValue) normalizedOperator = "=";
+	else if (operatorLC === "notin" && hasSingleValue) normalizedOperator = "!=";
 	const { value: operatorNL, label } = getOption(toFullOptionList(getOperators(field, { fieldData: opts.fieldData ?? {
 		name: field,
 		value: field,
 		label: field
-	} }) ?? []), operator) ?? {
-		name: operator,
-		value: operator,
-		label: operator
+	} }) ?? []), normalizedOperator) ?? {
+		name: normalizedOperator,
+		value: normalizedOperator,
+		label: normalizedOperator
 	};
 	const operatorTL = operatorMap[operatorNL] ?? operatorMap[lc(operatorNL)] ?? [label, label];
 	return typeof operatorTL === "string" ? operatorTL : operatorTL[valueSource === "field" ? 1 : 0];