@react-querybuilder/core 8.9.1 → 8.9.2

package/dist/import-BwbbP4oU.d.mts

@@ -0,0 +1,28 @@
+import { FullField, OptionList, ValueSources } from "./basic-BfD-7CN3.mjs";
+
+//#region src/types/import.d.ts
+
+/**
+* Options common to all parsers.
+*/
+interface ParserCommonOptions {
+  fields?: OptionList<FullField> | Record<string, FullField>;
+  getValueSources?: (field: string, operator: string) => ValueSources;
+  listsAsArrays?: boolean;
+  /**
+  * When true, the generated query will use independent combinators ({@link RuleGroupTypeIC}).
+  */
+  independentCombinators?: boolean;
+  /**
+  * When true, a unique `id` will be generated for each rule and group in the query.
+  */
+  generateIDs?: boolean;
+  /**
+  * Generates a `bigint` value if the string represents a valid integer
+  * outside the safe boundaries of the `number` type.
+  */
+  bigIntOnOverflow?: boolean;
+}
+//#endregion
+export { ParserCommonOptions };
+//# sourceMappingURL=import-BwbbP4oU.d.mts.map

package/dist/isRuleGroup-CnhYpLOM.mjs

@@ -0,0 +1,40 @@
+import { numericRegex } from "numeric-quantity";
+
+//#region src/utils/misc.ts
+/**
+* Converts a value to lowercase if it's a string, otherwise returns the value as is.
+*/
+// istanbul ignore next
+const lc = (v) => typeof v === "string" ? v.toLowerCase() : v;
+/**
+* Regex matching numeric strings. Passes for positive/negative integers, decimals,
+* and E notation, with optional surrounding whitespace.
+*/
+const numericRegex$1 = new RegExp(numericRegex.source.replace(/^\^/, String.raw`^\s*`).replace(/\$$/, String.raw`\s*$`));
+/**
+* Determines if a variable is a plain old JavaScript object, aka POJO.
+*/
+const isPojo = (obj) => obj === null || typeof obj !== "object" ? false : Object.getPrototypeOf(obj) === Object.prototype;
+/**
+* Simple helper to determine whether a value is null, undefined, or an empty string.
+*/
+const nullOrUndefinedOrEmpty = (value) => value === null || value === void 0 || value === "";
+
+//#endregion
+//#region src/utils/isRuleGroup.ts
+/**
+* Determines if an object is a {@link RuleGroupType} or {@link RuleGroupTypeIC}.
+*/
+const isRuleGroup = (rg) => isPojo(rg) && Array.isArray(rg.rules);
+/**
+* Determines if an object is a {@link RuleGroupType}.
+*/
+const isRuleGroupType = (rg) => isRuleGroup(rg) && typeof rg.combinator === "string";
+/**
+* Determines if an object is a {@link RuleGroupTypeIC}.
+*/
+const isRuleGroupTypeIC = (rg) => isRuleGroup(rg) && rg.combinator === void 0;
+
+//#endregion
+export { isPojo, isRuleGroup, isRuleGroupType, isRuleGroupTypeIC, lc, nullOrUndefinedOrEmpty, numericRegex$1 as numericRegex };
+//# sourceMappingURL=isRuleGroup-CnhYpLOM.mjs.map

package/dist/isRuleGroup-CnhYpLOM.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"isRuleGroup-CnhYpLOM.mjs","names":["numericRegex: RegExp","numericQuantityRegex"],"sources":["../src/utils/misc.ts","../src/utils/isRuleGroup.ts"],"sourcesContent":["import { numericRegex as numericQuantityRegex } from 'numeric-quantity';\n\n/**\n * Converts a value to lowercase if it's a string, otherwise returns the value as is.\n */\n// istanbul ignore next\nexport const lc = <T>(v: T): T => (typeof v === 'string' ? (v.toLowerCase() as T) : v);\n\n/**\n * Regex matching numeric strings. Passes for positive/negative integers, decimals,\n * and E notation, with optional surrounding whitespace.\n */\nexport const numericRegex: RegExp = new RegExp(\n  numericQuantityRegex.source.replace(/^\\^/, String.raw`^\\s*`).replace(/\\$$/, String.raw`\\s*$`)\n);\n\n/**\n * Determines if a variable is a plain old JavaScript object, aka POJO.\n */\n// oxlint-disable-next-line typescript/no-explicit-any\nexport const isPojo = (obj: any): obj is Record<string, any> =>\n  obj === null || typeof obj !== 'object' ? false : Object.getPrototypeOf(obj) === Object.prototype;\n\n/**\n * Simple helper to determine whether a value is null, undefined, or an empty string.\n */\nexport const nullOrUndefinedOrEmpty = (value: unknown): value is null | undefined | '' =>\n  value === null || value === undefined || value === '';\n","import type { RuleGroupType, RuleGroupTypeAny, RuleGroupTypeIC, RuleType } from '../types';\nimport { isPojo } from './misc';\n\n/**\n * Determines if an object is a {@link RuleType} (only checks for a `field` property).\n */\nexport const isRuleType = (s: unknown): s is RuleType =>\n  isPojo(s) && 'field' in s && typeof s.field === 'string';\n\n/**\n * Determines if an object is a {@link RuleGroupType} or {@link RuleGroupTypeIC}.\n */\nexport const isRuleGroup = (rg: unknown): rg is RuleGroupTypeAny =>\n  isPojo(rg) && Array.isArray(rg.rules);\n\n/**\n * Determines if an object is a {@link RuleGroupType}.\n */\nexport const isRuleGroupType = (rg: unknown): rg is RuleGroupType =>\n  isRuleGroup(rg) && typeof rg.combinator === 'string';\n\n/**\n * Determines if an object is a {@link RuleGroupTypeIC}.\n */\nexport const isRuleGroupTypeIC = (rg: unknown): rg is RuleGroupTypeIC =>\n  isRuleGroup(rg) && rg.combinator === undefined;\n"],"mappings":";;;;;;;AAMA,MAAa,MAAS,MAAa,OAAO,MAAM,WAAY,EAAE,aAAa,GAAS;;;;;AAMpF,MAAaA,iBAAuB,IAAI,OACtCC,aAAqB,OAAO,QAAQ,OAAO,OAAO,GAAG,OAAO,CAAC,QAAQ,OAAO,OAAO,GAAG,OAAO,CAC9F;;;;AAMD,MAAa,UAAU,QACrB,QAAQ,QAAQ,OAAO,QAAQ,WAAW,QAAQ,OAAO,eAAe,IAAI,KAAK,OAAO;;;;AAK1F,MAAa,0BAA0B,UACrC,UAAU,QAAQ,UAAU,UAAa,UAAU;;;;;;;ACfrD,MAAa,eAAe,OAC1B,OAAO,GAAG,IAAI,MAAM,QAAQ,GAAG,MAAM;;;;AAKvC,MAAa,mBAAmB,OAC9B,YAAY,GAAG,IAAI,OAAO,GAAG,eAAe;;;;AAK9C,MAAa,qBAAqB,OAChC,YAAY,GAAG,IAAI,GAAG,eAAe"}

package/dist/isRuleGroup-DqAs2x4E.js.map

@@ -1 +1 @@
-{"version":3,"file":"isRuleGroup-DqAs2x4E.js","names":["numericRegex: RegExp","numericQuantityRegex"],"sources":["../src/utils/misc.ts","../src/utils/isRuleGroup.ts"],"sourcesContent":["import { numericRegex as numericQuantityRegex } from 'numeric-quantity';\n\n/**\n * Converts a value to lowercase if it's a string, otherwise returns the value as is.\n */\n// istanbul ignore next\nexport const lc = <T>(v: T): T => (typeof v === 'string' ? (v.toLowerCase() as T) : v);\n\n/**\n * Regex matching numeric strings. Passes for positive/negative integers, decimals,\n * and E notation, with optional surrounding whitespace.\n */\nexport const numericRegex: RegExp = new RegExp(\n  numericQuantityRegex.source.replace(/^\\^/, String.raw`^\\s*`).replace(/\\$$/, String.raw`\\s*$`)\n);\n\n/**\n * Determines if a variable is a plain old JavaScript object, aka POJO.\n */\n// oxlint-disable-next-line typescript/no-explicit-any\nexport const isPojo = (obj: any): obj is Record<string, any> =>\n  obj === null || typeof obj !== 'object' ? false : Object.getPrototypeOf(obj) === Object.prototype;\n\n/**\n * Simple helper to determine whether a value is null, undefined, or an empty string.\n */\n// oxlint-disable-next-line typescript/no-explicit-any\nexport const nullOrUndefinedOrEmpty = (value: any): value is null | undefined | '' =>\n  value === null || value === undefined || value === '';\n","import type { RuleGroupType, RuleGroupTypeAny, RuleGroupTypeIC } from '../types';\nimport { isPojo } from './misc';\n\n/**\n * Determines if an object is a {@link RuleGroupType} or {@link RuleGroupTypeIC}.\n */\n// oxlint-disable-next-line typescript/no-explicit-any\nexport const isRuleGroup = (rg: any): rg is RuleGroupTypeAny =>\n  isPojo(rg) && Array.isArray(rg.rules);\n\n/**\n * Determines if an object is a {@link RuleGroupType}.\n */\n// oxlint-disable-next-line typescript/no-explicit-any\nexport const isRuleGroupType = (rg: any): rg is RuleGroupType =>\n  isRuleGroup(rg) && typeof rg.combinator === 'string';\n\n/**\n * Determines if an object is a {@link RuleGroupTypeIC}.\n */\n// oxlint-disable-next-line typescript/no-explicit-any\nexport const isRuleGroupTypeIC = (rg: any): rg is RuleGroupTypeIC =>\n  isRuleGroup(rg) && rg.combinator === undefined;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAMA,MAAa,MAAS,MAAa,OAAO,MAAM,WAAY,EAAE,aAAa,GAAS;;;;;AAMpF,MAAaA,eAAuB,IAAI,OACtCC,8BAAqB,OAAO,QAAQ,OAAO,OAAO,GAAG,OAAO,CAAC,QAAQ,OAAO,OAAO,GAAG,OAAO,CAC9F;;;;AAMD,MAAa,UAAU,QACrB,QAAQ,QAAQ,OAAO,QAAQ,WAAW,QAAQ,OAAO,eAAe,IAAI,KAAK,OAAO;;;;AAM1F,MAAa,0BAA0B,UACrC,UAAU,QAAQ,UAAU,UAAa,UAAU;;;;;;;ACrBrD,MAAa,eAAe,OAC1B,OAAO,GAAG,IAAI,MAAM,QAAQ,GAAG,MAAM;;;;AAMvC,MAAa,mBAAmB,OAC9B,YAAY,GAAG,IAAI,OAAO,GAAG,eAAe;;;;AAM9C,MAAa,qBAAqB,OAChC,YAAY,GAAG,IAAI,GAAG,eAAe"}
+{"version":3,"file":"isRuleGroup-DqAs2x4E.js","names":["numericRegex: RegExp","numericQuantityRegex"],"sources":["../src/utils/misc.ts","../src/utils/isRuleGroup.ts"],"sourcesContent":["import { numericRegex as numericQuantityRegex } from 'numeric-quantity';\n\n/**\n * Converts a value to lowercase if it's a string, otherwise returns the value as is.\n */\n// istanbul ignore next\nexport const lc = <T>(v: T): T => (typeof v === 'string' ? (v.toLowerCase() as T) : v);\n\n/**\n * Regex matching numeric strings. Passes for positive/negative integers, decimals,\n * and E notation, with optional surrounding whitespace.\n */\nexport const numericRegex: RegExp = new RegExp(\n  numericQuantityRegex.source.replace(/^\\^/, String.raw`^\\s*`).replace(/\\$$/, String.raw`\\s*$`)\n);\n\n/**\n * Determines if a variable is a plain old JavaScript object, aka POJO.\n */\n// oxlint-disable-next-line typescript/no-explicit-any\nexport const isPojo = (obj: any): obj is Record<string, any> =>\n  obj === null || typeof obj !== 'object' ? false : Object.getPrototypeOf(obj) === Object.prototype;\n\n/**\n * Simple helper to determine whether a value is null, undefined, or an empty string.\n */\nexport const nullOrUndefinedOrEmpty = (value: unknown): value is null | undefined | '' =>\n  value === null || value === undefined || value === '';\n","import type { RuleGroupType, RuleGroupTypeAny, RuleGroupTypeIC, RuleType } from '../types';\nimport { isPojo } from './misc';\n\n/**\n * Determines if an object is a {@link RuleType} (only checks for a `field` property).\n */\nexport const isRuleType = (s: unknown): s is RuleType =>\n  isPojo(s) && 'field' in s && typeof s.field === 'string';\n\n/**\n * Determines if an object is a {@link RuleGroupType} or {@link RuleGroupTypeIC}.\n */\nexport const isRuleGroup = (rg: unknown): rg is RuleGroupTypeAny =>\n  isPojo(rg) && Array.isArray(rg.rules);\n\n/**\n * Determines if an object is a {@link RuleGroupType}.\n */\nexport const isRuleGroupType = (rg: unknown): rg is RuleGroupType =>\n  isRuleGroup(rg) && typeof rg.combinator === 'string';\n\n/**\n * Determines if an object is a {@link RuleGroupTypeIC}.\n */\nexport const isRuleGroupTypeIC = (rg: unknown): rg is RuleGroupTypeIC =>\n  isRuleGroup(rg) && rg.combinator === undefined;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAMA,MAAa,MAAS,MAAa,OAAO,MAAM,WAAY,EAAE,aAAa,GAAS;;;;;AAMpF,MAAaA,eAAuB,IAAI,OACtCC,8BAAqB,OAAO,QAAQ,OAAO,OAAO,GAAG,OAAO,CAAC,QAAQ,OAAO,OAAO,GAAG,OAAO,CAC9F;;;;AAMD,MAAa,UAAU,QACrB,QAAQ,QAAQ,OAAO,QAAQ,WAAW,QAAQ,OAAO,eAAe,IAAI,KAAK,OAAO;;;;AAK1F,MAAa,0BAA0B,UACrC,UAAU,QAAQ,UAAU,UAAa,UAAU;;;;;;;ACfrD,MAAa,eAAe,OAC1B,OAAO,GAAG,IAAI,MAAM,QAAQ,GAAG,MAAM;;;;AAKvC,MAAa,mBAAmB,OAC9B,YAAY,GAAG,IAAI,OAAO,GAAG,eAAe;;;;AAK9C,MAAa,qBAAqB,OAChC,YAAY,GAAG,IAAI,GAAG,eAAe"}

package/dist/objectUtils-BtWdcZVG.mjs

@@ -0,0 +1,11 @@
+//#region src/utils/objectUtils.ts
+/**
+* A strongly-typed version of `Object.keys()`.
+*
+* [Original source](https://github.com/sindresorhus/ts-extras/blob/44f57392c5f027268330771996c4fdf9260b22d6/source/object-keys.ts)
+*/
+const objectKeys = Object.keys;
+
+//#endregion
+export { objectKeys };
+//# sourceMappingURL=objectUtils-BtWdcZVG.mjs.map

package/dist/objectUtils-BtWdcZVG.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"objectUtils-BtWdcZVG.mjs","names":[],"sources":["../src/utils/objectUtils.ts"],"sourcesContent":["// All code in this file is adapted from:\n// npm: https://www.npmjs.com/package/ts-extras\n// src: https://github.com/sindresorhus/ts-extras\n\n/**\n * Original looked like this (not sure why template string is used):\n * ```\n * type ObjectKeys<T extends object> = `${Exclude<keyof T, symbol>}`;\n * ```\n */\ntype ObjectKeys<T extends object> = Exclude<keyof T, symbol>;\n\n/**\n * A strongly-typed version of `Object.keys()`.\n *\n * [Original source](https://github.com/sindresorhus/ts-extras/blob/44f57392c5f027268330771996c4fdf9260b22d6/source/object-keys.ts)\n */\nexport const objectKeys = Object.keys as <Type extends object>(\n  value: Type\n) => Array<ObjectKeys<Type>>;\n\n/**\n * A strongly-typed version of `Object.entries()`.\n *\n * [Original source](https://github.com/sindresorhus/ts-extras/blob/44f57392c5f027268330771996c4fdf9260b22d6/source/object-entries.ts)\n */\nexport const objectEntries = Object.entries as <Type extends Record<PropertyKey, unknown>>(\n  value: Type\n) => Array<[ObjectKeys<Type>, Type[ObjectKeys<Type>]]>;\n"],"mappings":";;;;;;AAiBA,MAAa,aAAa,OAAO"}

package/dist/optGroupUtils-Duv-M8rf.mjs

@@ -0,0 +1,102 @@
+import { isPojo } from "./isRuleGroup-CnhYpLOM.mjs";
+import { produce } from "immer";
+
+//#region src/utils/optGroupUtils.ts
+const isOptionWithName = (opt) => isPojo(opt) && "name" in opt && typeof opt.name === "string";
+const isOptionWithValue = (opt) => isPojo(opt) && "value" in opt && typeof opt.value === "string";
+/**
+* Converts an {@link Option} or {@link ValueOption} (i.e., {@link BaseOption})
+* into a {@link FullOption}. Full options are left unchanged.
+*
+* @group Option Lists
+*/
+function toFullOption(opt, baseProperties, labelMap) {
+	return produce((draft) => {
+		const idObj = {};
+		let needsUpdating = !!baseProperties;
+		if (typeof draft === "string") return {
+			...baseProperties,
+			name: draft,
+			value: draft,
+			label: labelMap?.[draft] ?? draft
+		};
+		if (isOptionWithName(draft) && !isOptionWithValue(draft)) {
+			idObj.value = draft.name;
+			needsUpdating = true;
+		} else if (!isOptionWithName(draft) && isOptionWithValue(draft)) {
+			idObj.name = draft.value;
+			needsUpdating = true;
+		}
+		if (needsUpdating) return Object.assign({}, baseProperties, draft, idObj);
+	})(opt);
+}
+/**
+* Converts an {@link OptionList} or {@link FlexibleOptionList} into a {@link FullOptionList}.
+* Lists of full options are left unchanged.
+*
+* @group Option Lists
+*/
+function toFullOptionList(optList, baseProperties, labelMap) {
+	if (!Array.isArray(optList)) return [];
+	return produce((draft) => {
+		if (isFlexibleOptionGroupArray(draft)) for (const optGroup of draft) for (const [idx, opt] of optGroup.options.entries()) optGroup.options[idx] = toFullOption(opt, baseProperties, labelMap);
+		else for (const [idx, opt] of draft.entries()) draft[idx] = toFullOption(opt, baseProperties, labelMap);
+	})(optList);
+}
+/**
+* Generates a new array of objects with duplicates removed based
+* on the identifying property (`value` or `name`)
+*
+* @group Option Lists
+*/
+const uniqByIdentifier = (originalArray) => {
+	const names = /* @__PURE__ */ new Set();
+	const newArray = [];
+	for (const el of originalArray) if (!names.has(el.value ?? el.name)) {
+		names.add(el.value ?? el.name);
+		newArray.push(el);
+	}
+	return originalArray.length === newArray.length ? originalArray : newArray;
+};
+/**
+* Determines if an {@link OptionList} is an {@link OptionGroup} array.
+*
+* @group Option Lists
+*/
+const isOptionGroupArray = (arr) => Array.isArray(arr) && arr.length > 0 && isPojo(arr[0]) && "options" in arr[0] && Array.isArray(arr[0].options);
+/**
+* Determines if an array is a flat array of {@link FlexibleOption}.
+*
+* @group Option Lists
+*/
+const isFlexibleOptionArray = (arr) => {
+	let isFOA = false;
+	if (Array.isArray(arr)) for (const o of arr) if (isOptionWithName(o) || isOptionWithValue(o)) isFOA = true;
+	else return false;
+	return isFOA;
+};
+/**
+* Determines if a {@link FlexibleOptionList} is a {@link FlexibleOptionGroup} array.
+*
+* @group Option Lists
+*/
+const isFlexibleOptionGroupArray = (arr, { allowEmpty = false } = {}) => {
+	let isFOGA = false;
+	if (Array.isArray(arr)) for (const og of arr) if (isPojo(og) && "options" in og && (isFlexibleOptionArray(og.options) || allowEmpty && Array.isArray(og.options) && og.options.length === 0)) isFOGA = true;
+	else return false;
+	return isFOGA;
+};
+function getOption(arr, name) {
+	return (isFlexibleOptionGroupArray(arr, { allowEmpty: true }) ? arr.flatMap((og) => og.options) : arr).find((op) => op.value === name || op.name === name);
+}
+/**
+* Flattens {@link FlexibleOptionGroup} arrays into {@link BaseOption} arrays.
+* If the array is already flat, it is returned as is.
+*
+* @group Option Lists
+*/
+const toFlatOptionArray = (arr) => uniqByIdentifier(isOptionGroupArray(arr) ? arr.flatMap((og) => og.options) : arr);
+
+//#endregion
+export { getOption, isFlexibleOptionArray, isFlexibleOptionGroupArray, toFlatOptionArray, toFullOption, toFullOptionList };
+//# sourceMappingURL=optGroupUtils-Duv-M8rf.mjs.map

package/dist/optGroupUtils-Duv-M8rf.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"optGroupUtils-Duv-M8rf.mjs","names":["idObj: { name?: string; value?: string }","newArray: T[]"],"sources":["../src/utils/optGroupUtils.ts"],"sourcesContent":["import type { Draft } from 'immer';\nimport { produce } from 'immer';\nimport type {\n  BaseOption,\n  BaseOptionMap,\n  FlexibleOption,\n  FlexibleOptionGroup,\n  FlexibleOptionList,\n  FullOption,\n  FullOptionList,\n  GetOptionIdentifierType,\n  Option,\n  OptionGroup,\n  RequireAtLeastOne,\n  ToFullOption,\n  ValueOption,\n  WithUnknownIndex,\n} from '../types';\nimport { isPojo } from './misc';\n\nconst isOptionWithName = (opt: BaseOption): opt is Option =>\n  isPojo(opt) && 'name' in opt && typeof opt.name === 'string';\nconst isOptionWithValue = (opt: BaseOption): opt is ValueOption =>\n  isPojo(opt) && 'value' in opt && typeof opt.value === 'string';\n\n/**\n * Converts an {@link Option} or {@link ValueOption} (i.e., {@link BaseOption})\n * into a {@link FullOption}. Full options are left unchanged.\n *\n * @group Option Lists\n */\nexport function toFullOption<Opt extends BaseOption>(\n  opt: Opt | string,\n  baseProperties?: Record<string, unknown>,\n  labelMap?: Record<string, unknown>\n): ToFullOption<Opt> {\n  const recipe: (o: Opt | string) => ToFullOption<Opt> = produce(draft => {\n    const idObj: { name?: string; value?: string } = {};\n    let needsUpdating = !!baseProperties;\n\n    if (typeof draft === 'string') {\n      return {\n        ...baseProperties,\n        name: draft,\n        value: draft,\n        label: labelMap?.[draft] ?? draft,\n      } as Draft<Opt>;\n    }\n\n    if (isOptionWithName(draft) && !isOptionWithValue(draft)) {\n      idObj.value = draft.name;\n      needsUpdating = true;\n    } else if (!isOptionWithName(draft) && isOptionWithValue(draft)) {\n      idObj.name = draft.value;\n      needsUpdating = true;\n    }\n\n    if (needsUpdating) {\n      return Object.assign({}, baseProperties, draft, idObj);\n    }\n  });\n  return recipe(opt);\n}\n\n/**\n * Converts an {@link OptionList} or {@link FlexibleOptionList} into a {@link FullOptionList}.\n * Lists of full options are left unchanged.\n *\n * @group Option Lists\n */\nexport function toFullOptionList<Opt extends BaseOption>(\n  optList: unknown[],\n  baseProperties?: Record<string, unknown>,\n  labelMap?: Record<string, unknown>\n): FullOptionList<Opt> {\n  if (!Array.isArray(optList)) {\n    return [] as unknown as FullOptionList<Opt>;\n  }\n\n  const recipe: (ol: FlexibleOptionList<Opt>) => FullOptionList<Opt> = produce(draft => {\n    if (isFlexibleOptionGroupArray(draft)) {\n      for (const optGroup of draft) {\n        for (const [idx, opt] of optGroup.options.entries())\n          optGroup.options[idx] = toFullOption(opt, baseProperties, labelMap);\n      }\n    } else {\n      for (const [idx, opt] of (draft as Opt[]).entries())\n        draft[idx] = toFullOption(opt, baseProperties, labelMap);\n    }\n  });\n\n  return recipe(optList as FlexibleOptionList<Opt>);\n}\n\n/**\n * Converts a {@link FlexibleOptionList} into a {@link FullOptionList}.\n * Lists of full options are left unchanged.\n *\n * @group Option Lists\n */\nexport function toFullOptionMap<OptMap extends BaseOptionMap>(\n  optMap: OptMap,\n  baseProperties?: Record<string, unknown>\n): OptMap extends BaseOptionMap<infer V, infer K> ? Partial<Record<K, ToFullOption<V>>> : never {\n  type FullOptMapType =\n    OptMap extends BaseOptionMap<infer VT, infer KT>\n      ? Partial<Record<KT, ToFullOption<VT>>>\n      : never;\n\n  return Object.fromEntries(\n    (Object.entries(optMap) as [string, FlexibleOption][]).map(([k, v]) => [\n      k,\n      toFullOption(v, baseProperties),\n    ])\n  ) as FullOptMapType;\n}\n\n/**\n * @deprecated Renamed to {@link uniqByIdentifier}.\n *\n * @group Option Lists\n */\nexport const uniqByName = <\n  T extends { name: string; value?: string } | { name?: string; value: string },\n>(\n  originalArray: T[]\n): T[] => uniqByIdentifier(originalArray);\n\n/**\n * Generates a new array of objects with duplicates removed based\n * on the identifying property (`value` or `name`)\n *\n * @group Option Lists\n */\nexport const uniqByIdentifier = <\n  T extends RequireAtLeastOne<{ name: string; value: string }, 'name' | 'value'>,\n>(\n  originalArray: T[]\n): T[] => {\n  const names = new Set<string>();\n  const newArray: T[] = [];\n  for (const el of originalArray) {\n    if (!names.has((el.value ?? el.name)!)) {\n      names.add((el.value ?? el.name)!);\n      newArray.push(el);\n    }\n  }\n  return originalArray.length === newArray.length ? originalArray : newArray;\n};\n\n/**\n * Determines if an {@link OptionList} is an {@link OptionGroup} array.\n *\n * @group Option Lists\n */\n// oxlint-disable-next-line typescript/no-explicit-any\nexport const isOptionGroupArray = (arr: any): arr is OptionGroup<BaseOption>[] =>\n  Array.isArray(arr) &&\n  arr.length > 0 &&\n  isPojo(arr[0]) &&\n  'options' in arr[0] &&\n  Array.isArray(arr[0].options);\n\n/**\n * Determines if an array is a flat array of {@link FlexibleOption}.\n *\n * @group Option Lists\n */\n// oxlint-disable-next-line typescript/no-explicit-any\nexport const isFlexibleOptionArray = (arr: any): arr is FlexibleOption[] => {\n  let isFOA = false;\n  if (Array.isArray(arr)) {\n    for (const o of arr) {\n      if (isOptionWithName(o) || isOptionWithValue(o)) {\n        isFOA = true;\n      } else {\n        return false;\n      }\n    }\n  }\n  return isFOA;\n};\n\n/**\n * Determines if an array is a flat array of {@link FullOption}.\n *\n * @group Option Lists\n */\n// oxlint-disable-next-line typescript/no-explicit-any\nexport const isFullOptionArray = (arr: any): arr is FullOption[] => {\n  let isFOA = false;\n  if (Array.isArray(arr)) {\n    for (const o of arr) {\n      if (isOptionWithName(o) && isOptionWithValue(o)) {\n        isFOA = true;\n      } else {\n        return false;\n      }\n    }\n  }\n  return isFOA;\n};\n\n/**\n * Determines if a {@link FlexibleOptionList} is a {@link FlexibleOptionGroup} array.\n *\n * @group Option Lists\n */\nexport const isFlexibleOptionGroupArray = (\n  // oxlint-disable-next-line typescript/no-explicit-any\n  arr: any,\n  { allowEmpty = false }: { allowEmpty?: boolean } = {}\n): arr is FlexibleOptionGroup[] => {\n  let isFOGA = false;\n  if (Array.isArray(arr)) {\n    for (const og of arr) {\n      if (\n        isPojo(og) &&\n        'options' in og &&\n        (isFlexibleOptionArray(og.options) ||\n          (allowEmpty && Array.isArray(og.options) && og.options.length === 0))\n      ) {\n        isFOGA = true;\n      } else {\n        return false;\n      }\n    }\n  }\n  return isFOGA;\n};\n\n/**\n * Determines if a {@link FlexibleOptionList} is a {@link OptionGroup} array of {@link FullOption}.\n *\n * @group Option Lists\n */\nexport const isFullOptionGroupArray = (\n  // oxlint-disable-next-line typescript/no-explicit-any\n  arr: any,\n  { allowEmpty = false }: { allowEmpty?: boolean } = {}\n): arr is OptionGroup<FullOption>[] => {\n  let isFOGA = false;\n  if (Array.isArray(arr)) {\n    for (const og of arr) {\n      if (\n        isPojo(og) &&\n        'options' in og &&\n        (isFullOptionArray(og.options) ||\n          (allowEmpty && Array.isArray(og.options) && og.options.length === 0))\n      ) {\n        isFOGA = true;\n      } else {\n        return false;\n      }\n    }\n  }\n  return isFOGA;\n};\n\n/**\n * Gets the option from an {@link OptionList} with the given `name`. Handles\n * {@link Option} arrays as well as {@link OptionGroup} arrays.\n *\n * @group Option Lists\n */\nexport function getOption<OptType extends FullOption>(\n  arr: FullOptionList<OptType>,\n  name: string\n): OptType | undefined;\nexport function getOption<OptType extends ValueOption>(\n  arr: FlexibleOptionList<OptType>,\n  name: string\n): OptType | undefined;\nexport function getOption<OptType extends Option>(\n  arr: FlexibleOptionList<OptType>,\n  name: string\n): OptType | undefined;\nexport function getOption<OptType extends BaseOption>(\n  arr: FlexibleOptionList<OptType>,\n  name: string\n): OptType | undefined {\n  const options = isFlexibleOptionGroupArray(arr, { allowEmpty: true })\n    ? arr.flatMap(og => og.options)\n    : arr;\n  return options.find(op => op.value === name || op.name === name) as OptType | undefined;\n}\n\n/**\n * Gets the first option from an {@link OptionList}.\n *\n * @group Option Lists\n */\nexport function getFirstOption<Opt extends FullOption>(\n  arr?: OptionGroup<Opt>[] | Opt[]\n): GetOptionIdentifierType<Opt> | null;\nexport function getFirstOption<Opt extends ValueOption>(\n  arr?: OptionGroup<Opt>[] | Opt[]\n): GetOptionIdentifierType<Opt> | null;\nexport function getFirstOption<Opt extends Option>(\n  arr?: OptionGroup<Opt>[] | Opt[]\n): GetOptionIdentifierType<Opt> | null;\nexport function getFirstOption<Opt extends BaseOption>(\n  arr?: FlexibleOptionGroup<Opt>[] | Opt[]\n): GetOptionIdentifierType<Opt> | null {\n  if (!Array.isArray(arr) || arr.length === 0) {\n    return null;\n  } else if (isFlexibleOptionGroupArray(arr, { allowEmpty: true })) {\n    for (const og of arr) {\n      if (og.options.length > 0) {\n        return (og.options[0].value ?? og.options[0].name) as GetOptionIdentifierType<Opt>;\n      }\n    }\n    // istanbul ignore next\n    return null;\n  }\n\n  return (arr[0].value ?? arr[0].name) as GetOptionIdentifierType<Opt>;\n}\n\n/**\n * Flattens {@link FlexibleOptionGroup} arrays into {@link BaseOption} arrays.\n * If the array is already flat, it is returned as is.\n *\n * @group Option Lists\n */\nexport const toFlatOptionArray = <T extends FullOption, OL extends FullOptionList<T>>(arr: OL) =>\n  uniqByIdentifier(isOptionGroupArray(arr) ? arr.flatMap(og => og.options) : arr) as T[];\n\n/**\n * Generates a new {@link OptionGroup} array with duplicates\n * removed based on the identifying property (`value` or `name`).\n *\n * @group Option Lists\n */\nexport const uniqOptGroups = <T extends BaseOption>(\n  originalArray: FlexibleOptionGroup<T>[]\n): OptionGroup<ToFullOption<T>>[] => {\n  type K = T extends BaseOption<infer KT> ? KT : never;\n  const labels = new Set<string>();\n  const names = new Set<K>();\n  const newArray: OptionGroup<ToFullOption<T>>[] = [];\n  for (const el of originalArray) {\n    if (!labels.has(el.label)) {\n      labels.add(el.label);\n      const optionsForThisGroup: WithUnknownIndex<ToFullOption<T>>[] = [];\n      for (const opt of el.options) {\n        if (!names.has((opt.value ?? opt.name) as K)) {\n          names.add((opt.value ?? opt.name) as K);\n          optionsForThisGroup.push(toFullOption(opt) as WithUnknownIndex<ToFullOption<T>>);\n        }\n      }\n      newArray.push({ ...el, options: optionsForThisGroup });\n    }\n  }\n  return newArray;\n};\n\n/**\n * Generates a new {@link Option} or {@link OptionGroup} array with duplicates\n * removed based on the identifier property (`value` or `name`).\n *\n * @group Option Lists\n */\nexport const uniqOptList = <T extends BaseOption>(\n  originalArray: FlexibleOptionList<T>\n): WithUnknownIndex<BaseOption & FullOption>[] | OptionGroup<ToFullOption<T>>[] => {\n  if (isFlexibleOptionGroupArray(originalArray)) {\n    return uniqOptGroups(originalArray) as OptionGroup<ToFullOption<T>>[];\n  }\n  return uniqByIdentifier((originalArray as BaseOption[]).map(o => toFullOption(o)));\n};\n"],"mappings":";;;;AAoBA,MAAM,oBAAoB,QACxB,OAAO,IAAI,IAAI,UAAU,OAAO,OAAO,IAAI,SAAS;AACtD,MAAM,qBAAqB,QACzB,OAAO,IAAI,IAAI,WAAW,OAAO,OAAO,IAAI,UAAU;;;;;;;AAQxD,SAAgB,aACd,KACA,gBACA,UACmB;AA0BnB,QAzBuD,SAAQ,UAAS;EACtE,MAAMA,QAA2C,EAAE;EACnD,IAAI,gBAAgB,CAAC,CAAC;AAEtB,MAAI,OAAO,UAAU,SACnB,QAAO;GACL,GAAG;GACH,MAAM;GACN,OAAO;GACP,OAAO,WAAW,UAAU;GAC7B;AAGH,MAAI,iBAAiB,MAAM,IAAI,CAAC,kBAAkB,MAAM,EAAE;AACxD,SAAM,QAAQ,MAAM;AACpB,mBAAgB;aACP,CAAC,iBAAiB,MAAM,IAAI,kBAAkB,MAAM,EAAE;AAC/D,SAAM,OAAO,MAAM;AACnB,mBAAgB;;AAGlB,MAAI,cACF,QAAO,OAAO,OAAO,EAAE,EAAE,gBAAgB,OAAO,MAAM;GAExD,CACY,IAAI;;;;;;;;AASpB,SAAgB,iBACd,SACA,gBACA,UACqB;AACrB,KAAI,CAAC,MAAM,QAAQ,QAAQ,CACzB,QAAO,EAAE;AAeX,QAZqE,SAAQ,UAAS;AACpF,MAAI,2BAA2B,MAAM,CACnC,MAAK,MAAM,YAAY,MACrB,MAAK,MAAM,CAAC,KAAK,QAAQ,SAAS,QAAQ,SAAS,CACjD,UAAS,QAAQ,OAAO,aAAa,KAAK,gBAAgB,SAAS;MAGvE,MAAK,MAAM,CAAC,KAAK,QAAS,MAAgB,SAAS,CACjD,OAAM,OAAO,aAAa,KAAK,gBAAgB,SAAS;GAE5D,CAEY,QAAmC;;;;;;;;AA2CnD,MAAa,oBAGX,kBACQ;CACR,MAAM,wBAAQ,IAAI,KAAa;CAC/B,MAAMC,WAAgB,EAAE;AACxB,MAAK,MAAM,MAAM,cACf,KAAI,CAAC,MAAM,IAAK,GAAG,SAAS,GAAG,KAAO,EAAE;AACtC,QAAM,IAAK,GAAG,SAAS,GAAG,KAAO;AACjC,WAAS,KAAK,GAAG;;AAGrB,QAAO,cAAc,WAAW,SAAS,SAAS,gBAAgB;;;;;;;AASpE,MAAa,sBAAsB,QACjC,MAAM,QAAQ,IAAI,IAClB,IAAI,SAAS,KACb,OAAO,IAAI,GAAG,IACd,aAAa,IAAI,MACjB,MAAM,QAAQ,IAAI,GAAG,QAAQ;;;;;;AAQ/B,MAAa,yBAAyB,QAAsC;CAC1E,IAAI,QAAQ;AACZ,KAAI,MAAM,QAAQ,IAAI,CACpB,MAAK,MAAM,KAAK,IACd,KAAI,iBAAiB,EAAE,IAAI,kBAAkB,EAAE,CAC7C,SAAQ;KAER,QAAO;AAIb,QAAO;;;;;;;AA4BT,MAAa,8BAEX,KACA,EAAE,aAAa,UAAoC,EAAE,KACpB;CACjC,IAAI,SAAS;AACb,KAAI,MAAM,QAAQ,IAAI,CACpB,MAAK,MAAM,MAAM,IACf,KACE,OAAO,GAAG,IACV,aAAa,OACZ,sBAAsB,GAAG,QAAQ,IAC/B,cAAc,MAAM,QAAQ,GAAG,QAAQ,IAAI,GAAG,QAAQ,WAAW,GAEpE,UAAS;KAET,QAAO;AAIb,QAAO;;AAiDT,SAAgB,UACd,KACA,MACqB;AAIrB,SAHgB,2BAA2B,KAAK,EAAE,YAAY,MAAM,CAAC,GACjE,IAAI,SAAQ,OAAM,GAAG,QAAQ,GAC7B,KACW,MAAK,OAAM,GAAG,UAAU,QAAQ,GAAG,SAAS,KAAK;;;;;;;;AAyClE,MAAa,qBAAyE,QACpF,iBAAiB,mBAAmB,IAAI,GAAG,IAAI,SAAQ,OAAM,GAAG,QAAQ,GAAG,IAAI"}

package/dist/parseCEL.d.mts

@@ -0,0 +1,34 @@
+import { DefaultRuleGroupType, DefaultRuleGroupTypeIC, Except } from "./basic-BfD-7CN3.mjs";
+import { ParserCommonOptions } from "./import-BwbbP4oU.mjs";
+
+//#region src/utils/parseCEL/parseCEL.d.ts
+
+/**
+* Options object for {@link parseCEL}.
+*/
+interface ParseCELOptions extends ParserCommonOptions {}
+/**
+* Converts a CEL string expression into a query suitable for the
+* {@link index!QueryBuilder QueryBuilder} component's `query` or `defaultQuery` props
+* ({@link index!DefaultRuleGroupType DefaultRuleGroupType}).
+*/
+declare function parseCEL(cel: string): DefaultRuleGroupType;
+/**
+* Converts a CEL string expression into a query suitable for the
+* {@link index!QueryBuilder QueryBuilder} component's `query` or `defaultQuery` props
+* ({@link index!DefaultRuleGroupType DefaultRuleGroupType}).
+*/
+declare function parseCEL(cel: string, options: Except<ParseCELOptions, "independentCombinators"> & {
+  independentCombinators?: false;
+}): DefaultRuleGroupType;
+/**
+* Converts a CEL string expression into a query suitable for the
+* {@link index!QueryBuilder QueryBuilder} component's `query` or `defaultQuery` props
+* ({@link index!DefaultRuleGroupTypeIC DefaultRuleGroupTypeIC}).
+*/
+declare function parseCEL(cel: string, options: Except<ParseCELOptions, "independentCombinators"> & {
+  independentCombinators: true;
+}): DefaultRuleGroupTypeIC;
+//#endregion
+export { ParseCELOptions, parseCEL };
+//# sourceMappingURL=parseCEL.d.mts.map