@react-querybuilder/antd 8.12.0 → 8.13.0

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

@@ -20,34 +20,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> = (
@@ -123,8 +95,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');
@@ -149,17 +121,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
@@ -192,12 +164,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>> & {
@@ -205,12 +177,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,
 };
 ```
 
@@ -230,17 +202,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
@@ -262,29 +240,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
@@ -305,7 +295,7 @@ Note:
 
 @example
 ```
-import {If} from 'type-fest';
+import type {If} from 'type-fest';
 
 type A = If<true, 'yes', 'no'>;
 //=> 'yes'
@@ -325,7 +315,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'
@@ -336,7 +326,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>;
 
@@ -466,10 +456,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`
 ```
@@ -507,7 +498,7 @@ type Includes<Value extends readonly any[], Item> =
 @category Type Guard
 @category Utilities
 */
-type IsEqual<A, B> = [A, B] 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, B> = (<G>() => G extends A & G | G ? 1 : 2) extends (<G>() => G extends B & G | G ? 1 : 2) ? true : false;
 //#endregion
@@ -529,6 +520,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
 ```
@@ -542,16 +534,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`.
@@ -561,14 +551,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];
 };
 ```
@@ -579,21 +567,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; }
@@ -663,12 +651,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;
@@ -847,12 +835,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'.
 
@@ -869,12 +859,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
@@ -896,7 +886,7 @@ type Foo = {
 	a?: number;
 	b: string;
 	c?: boolean;
-}
+};
 
 type SomeRequired = SetRequired<Foo, 'b' | 'c'>;
 // type SomeRequired = {
@@ -950,7 +940,7 @@ type Foo = {
 	a: number | null;
 	b: string | undefined;
 	c?: boolean | null;
-}
+};
 
 type SomeNonNullable = SetNonNullable<Foo, 'b' | 'c'>;
 // type SomeNonNullable = {
@@ -2744,6 +2734,17 @@ type QueryBuilderProps<RG extends RuleGroupTypeAny, F extends FullField, O exten
   context?: any;
 } : never;
 //#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/AntDActionElement.d.ts
 type RemoveDataIndexKeys<T$1> = { [K in keyof T$1 as `data-${string}` extends K ? never : K]: T$1[K] };
 /**

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

@@ -5,16 +5,18 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __commonJS = (cb, mod) => function() {
-	return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
+var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
 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
-		});
+	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;
 };
@@ -50,7 +52,7 @@ dayjs_plugin_weekday_js = __toESM(dayjs_plugin_weekday_js);
 /**
 * @group Components
 */
-const AntDActionElement = ({ className, handleOnClick, label, title, disabled, disabledTranslation, testID: _testID, level: _level, path: _path, context: _context, validation: _validation, ruleOrGroup: _ruleOrGroup, schema: _schema,...extraProps }) => /* @__PURE__ */ react.createElement(antd.Button, {
+const AntDActionElement = ({ className, handleOnClick, label, title, disabled, disabledTranslation, testID: _testID, level: _level, path: _path, context: _context, validation: _validation, ruleOrGroup: _ruleOrGroup, schema: _schema, ...extraProps }) => /* @__PURE__ */ react.createElement(antd.Button, {
 	type: "primary",
 	className,
 	title: disabledTranslation && disabled ? disabledTranslation.title : title,
@@ -64,7 +66,7 @@ const AntDActionElement = ({ className, handleOnClick, label, title, disabled, d
 /**
 * @group Components
 */
-const AntDDragHandle = (0, react.forwardRef)(({ className, title, testID: _testID, level: _level, path: _path, label: _label, disabled: _disabled, context: _context, validation: _validation, schema: _schema, ruleOrGroup: _ruleOrGroup,...extraProps }, dragRef) => /* @__PURE__ */ react.createElement(__ant_design_icons.HolderOutlined, {
+const AntDDragHandle = (0, react.forwardRef)(({ className, title, testID: _testID, level: _level, path: _path, label: _label, disabled: _disabled, context: _context, validation: _validation, schema: _schema, ruleOrGroup: _ruleOrGroup, ...extraProps }, dragRef) => /* @__PURE__ */ react.createElement(__ant_design_icons.HolderOutlined, {
 	className,
 	title,
 	...extraProps,
@@ -76,7 +78,7 @@ const AntDDragHandle = (0, react.forwardRef)(({ className, title, testID: _testI
 /**
 * @group Components
 */
-const AntDNotToggle = ({ className, handleOnChange, label, checked, title, disabled, path: _path, context: _context, validation: _validation, testID: _testID, schema: _schema, ruleGroup: _ruleGroup,...extraProps }) => /* @__PURE__ */ react.createElement(antd.Switch, {
+const AntDNotToggle = ({ className, handleOnChange, label, checked, title, disabled, path: _path, context: _context, validation: _validation, testID: _testID, schema: _schema, ruleGroup: _ruleGroup, ...extraProps }) => /* @__PURE__ */ react.createElement(antd.Switch, {
 	title,
 	className,
 	onChange: (v) => handleOnChange(v),
@@ -111,7 +113,7 @@ const AntDShiftActions = ({ shiftUp, shiftDown, shiftUpDisabled, shiftDownDisabl
 
 //#endregion
 //#region ../../node_modules/rc-util/lib/warning.js
-var require_warning = /* @__PURE__ */ __commonJS({ "../../node_modules/rc-util/lib/warning.js": ((exports) => {
+var require_warning = /* @__PURE__ */ __commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	exports.default = void 0;
 	exports.noteOnce = noteOnce$1;
@@ -174,11 +176,11 @@ var require_warning = /* @__PURE__ */ __commonJS({ "../../node_modules/rc-util/l
 	warningOnce.resetWarned = resetWarned;
 	warningOnce.noteOnce = noteOnce$1;
 	exports.default = warningOnce;
-}) });
+}));
 
 //#endregion
 //#region src/dayjs.ts
-var import_warning = /* @__PURE__ */ __toESM(require_warning());
+var import_warning = require_warning();
 dayjs.default.extend(dayjs_plugin_customParseFormat_js.default);
 dayjs.default.extend(dayjs_plugin_advancedFormat_js.default);
 dayjs.default.extend(dayjs_plugin_weekday_js.default);
@@ -281,7 +283,7 @@ const DatePicker = (0, antd_es_date_picker_generatePicker_index_js.default)(dayj
 * @group Components
 */
 const AntDValueEditor = (allProps) => {
-	const { fieldData, operator, value, handleOnChange, title, className, type, inputType, values = [], listsAsArrays, separator, valueSource: _vs, disabled, testID, selectorComponent: SelectorComponent = allProps.schema.controls.valueSelector, extraProps, parseNumbers: _parseNumbers,...propsForValueSelector } = allProps;
+	const { fieldData, operator, value, handleOnChange, title, className, type, inputType, values = [], listsAsArrays, separator, valueSource: _vs, disabled, testID, selectorComponent: SelectorComponent = allProps.schema.controls.valueSelector, extraProps, parseNumbers: _parseNumbers, ...propsForValueSelector } = allProps;
 	const { valueAsArray, multiValueHandler, bigIntValueHandler, valueListItemClassName, inputTypeCoerced } = (0, react_querybuilder.useValueEditor)(allProps);
 	if (operator === "null" || operator === "notNull") return null;
 	const placeHolderText = fieldData?.placeholder ?? "";
@@ -462,7 +464,7 @@ const AntDValueEditor = (allProps) => {
 /**
 * @group Components
 */
-const AntDValueSelector = ({ className, handleOnChange, options, value, title, disabled, multiple, listsAsArrays, testID: _testID, rule: _rule, ruleGroup: _ruleGroup, rules: _rules, level: _level, path: _path, context: _context, validation: _validation, operator: _operator, field: _field, fieldData: _fieldData, schema: _schema,...extraProps }) => {
+const AntDValueSelector = ({ className, handleOnChange, options, value, title, disabled, multiple, listsAsArrays, testID: _testID, rule: _rule, ruleGroup: _ruleGroup, rules: _rules, level: _level, path: _path, context: _context, validation: _validation, operator: _operator, field: _field, fieldData: _fieldData, schema: _schema, ...extraProps }) => {
 	const { onChange: onChangeNoArrays } = (0, react_querybuilder.useValueSelector)({
 		handleOnChange,
 		listsAsArrays: false,