@react-querybuilder/core 8.9.0 → 8.9.2

package/dist/parseSpEL.mjs

@@ -0,0 +1,273 @@
+import { joinWith } from "./arrayUtils-BF1P8iHS.mjs";
+import { isRuleGroup } from "./isRuleGroup-CnhYpLOM.mjs";
+import "./optGroupUtils-Duv-M8rf.mjs";
+import { fieldIsValidUtil, getFieldsArray, prepareRuleGroup } from "./prepareQueryObjects-CS6Wmhmf.mjs";
+import { SpelExpressionEvaluator } from "spel2js";
+
+//#region src/utils/parseSpEL/utils.ts
+const isSpELPropertyNode = (expr) => {
+	return expr.getType() === "property" || expr.getType() === "variable";
+};
+const isSpELCompoundNode = (expr) => {
+	return expr.getType() === "compound" && expr.getChildren().every((c) => isSpELPropertyNode(c));
+};
+const isSpELListNode = (expr) => {
+	return expr.getType() === "list";
+};
+const isSpELOpAnd = (expr) => expr.type === "op-and";
+const isSpELOpOr = (expr) => expr.type === "op-or";
+const isSpELOpMatches = (expr) => expr.type === "matches" && (isSpELIdentifier(expr.children[0]) && isSpELStringLiteral(expr.children[1]) || isSpELIdentifier(expr.children[1]) && isSpELStringLiteral(expr.children[0]) || isSpELIdentifier(expr.children[0]) && isSpELIdentifier(expr.children[1]));
+const isSpELIdentifier = (expr) => expr.type === "property" || expr.type === "variable" || expr.type === "compound";
+const isSpELStringLiteral = (expr) => expr.type === "string";
+const isSpELNumericLiteral = (expr) => expr.type === "number";
+const isSpELBooleanLiteral = (expr) => expr.type === "boolean";
+const isSpELNullLiteral = (expr) => expr.type === "null";
+const isSpELRelationOp = (expr) => expr.type === "op-eq" || expr.type === "op-ne" || expr.type === "op-gt" || expr.type === "op-ge" || expr.type === "op-lt" || expr.type === "op-le";
+const isSpELPrimitive = (expr) => isSpELNumericLiteral(expr) || isSpELStringLiteral(expr) || isSpELBooleanLiteral(expr) || isSpELNullLiteral(expr);
+const isSpELBetweenValues = (expr) => expr.type === "between" && isSpELIdentifier(expr.children[0]) && expr.children[1].type === "list" && expr.children[1].children.length >= 2 && expr.children[1].children.every((c) => isSpELPrimitive(c));
+const isSpELBetweenFields = (expr) => expr.type === "between" && isSpELIdentifier(expr.children[0]) && expr.children[1].type === "list" && expr.children[1].children.length >= 2 && expr.children[1].children.every((c) => isSpELIdentifier(c));
+const processCompiledExpression = (ce) => {
+	const type = ce.getType();
+	const identifier = isSpELCompoundNode(ce) ? ce.getChildren().map((p) => isSpELPropertyNode(p) ? p.getRaw() : "").join(".") : isSpELPropertyNode(ce) ? ce.getRaw() : null;
+	const children = type === "compound" ? [] : (isSpELListNode(ce) ? ce.getRaw : ce.getChildren)().map((c) => processCompiledExpression(c));
+	const startPosition = ce.getStartPosition();
+	const endPosition = ce.getEndPosition();
+	const value = ce.getValue.length === 0 ? ce.getValue() : "N/A";
+	return {
+		type: type === "compound" && !identifier ? "invalid" : type,
+		children,
+		startPosition,
+		endPosition,
+		value,
+		identifier
+	};
+};
+const normalizeOperator = (opType, flip) => {
+	if (flip) {
+		if (opType === "op-lt") return ">";
+		if (opType === "op-le") return ">=";
+		if (opType === "op-gt") return "<";
+		if (opType === "op-ge") return "<=";
+	}
+	return {
+		"op-eq": "=",
+		"op-ge": ">=",
+		"op-gt": ">",
+		"op-le": "<=",
+		"op-lt": "<",
+		"op-ne": "!="
+	}[opType];
+};
+const generateFlatAndOrList = (expr) => {
+	const combinator = expr.type.slice(3);
+	const [left, right] = expr.children;
+	if (left.type === "op-and" || left.type === "op-or") return [
+		...generateFlatAndOrList(left),
+		combinator,
+		right
+	];
+	return [
+		left,
+		combinator,
+		right
+	];
+};
+const generateMixedAndOrList = (expr) => {
+	const arr = generateFlatAndOrList(expr);
+	const returnArray = [];
+	let startIndex = 0;
+	for (let i = 0; i < arr.length; i += 2) if (arr[i + 1] === "and") {
+		startIndex = i;
+		let j = 1;
+		while (arr[startIndex + j] === "and") {
+			i += 2;
+			j += 2;
+		}
+		const tempAndArray = arr.slice(startIndex, i + 1);
+		returnArray.push(tempAndArray);
+		i -= 2;
+	} else if (arr[i + 1] === "or") if (i === 0 || i === arr.length - 3) {
+		if (i === 0 || arr[i - 1] === "or") returnArray.push(arr[i]);
+		returnArray.push(arr[i + 1]);
+		if (i === arr.length - 3) returnArray.push(arr[i + 2]);
+	} else if (arr[i - 1] === "and") returnArray.push(arr[i + 1]);
+	else returnArray.push(arr[i], arr[i + 1]);
+	if (returnArray.length === 1 && Array.isArray(returnArray[0])) return returnArray[0];
+	return returnArray;
+};
+
+//#endregion
+//#region src/utils/parseSpEL/parseSpEL.ts
+function parseSpEL(spel, options = {}) {
+	const { fields, independentCombinators, listsAsArrays } = options;
+	const ic = !!independentCombinators;
+	const fieldsFlat = getFieldsArray(fields);
+	const fieldIsValid = (fieldName, operator, subordinateFieldName) => fieldIsValidUtil({
+		fieldName,
+		fieldsFlat,
+		operator,
+		subordinateFieldName,
+		getValueSources: options?.getValueSources
+	});
+	const emptyQuery = {
+		rules: [],
+		...ic ? {} : { combinator: "and" }
+	};
+	const parseProcessedSpEL = (expr, processOpts = {}) => {
+		const { forwardNegation: _forwardedNegation, groupOnlyIfNecessary: _g } = processOpts;
+		if (expr.type === "op-not") {
+			const negatedExpr = parseProcessedSpEL(expr.children[0]);
+			// istanbul ignore else
+			if (negatedExpr) {
+				if (!isRuleGroup(negatedExpr) && (negatedExpr.operator === "contains" || negatedExpr.operator === "beginsWith" || negatedExpr.operator === "endsWith")) return {
+					...negatedExpr,
+					operator: `doesNot${negatedExpr.operator[0].toUpperCase()}${negatedExpr.operator.slice(1).replace("s", "")}`
+				};
+				return ic ? {
+					rules: [negatedExpr],
+					not: true
+				} : {
+					combinator: "and",
+					rules: [negatedExpr],
+					not: true
+				};
+			}
+		} else if (isSpELOpAnd(expr) || isSpELOpOr(expr)) {
+			if (ic) {
+				const rules$1 = generateFlatAndOrList(expr).map((v) => {
+					if (typeof v === "string") return v;
+					return parseProcessedSpEL(v);
+				});
+				if (!rules$1.every(Boolean)) return null;
+				return { rules: rules$1 };
+			}
+			const andOrList = generateMixedAndOrList(expr);
+			const combinator = andOrList[1];
+			const rules = andOrList.filter((v) => Array.isArray(v) || !!v && typeof v !== "string" && "type" in v).map((v) => Array.isArray(v) ? v.filter((vf) => !!v && typeof vf !== "string" && "type" in vf) : v).map((exp) => {
+				if (Array.isArray(exp)) return {
+					combinator: "and",
+					rules: exp.map((e) => parseProcessedSpEL(e)).filter(Boolean)
+				};
+				return parseProcessedSpEL(exp);
+			}).filter(Boolean);
+			// istanbul ignore else
+			if (rules.length > 0) return {
+				combinator,
+				rules
+			};
+		} else if (isSpELOpMatches(expr)) {
+			const [left, right] = expr.children;
+			let field = "";
+			let regex = "";
+			let valueSource = void 0;
+			if (isSpELIdentifier(left)) {
+				field = left.identifier;
+				if (isSpELIdentifier(right)) {
+					regex = right.identifier;
+					valueSource = "field";
+				} else if (isSpELPrimitive(right)) regex = right.value;
+			} else if (isSpELIdentifier(right) && isSpELPrimitive(left)) {
+				field = right.identifier;
+				regex = left.value;
+			}
+			if (/^(?!\^).*?(?<!\$)$/.test(regex)) {
+				// istanbul ignore else
+				if (fieldIsValid(field, "contains")) return {
+					field,
+					operator: "contains",
+					value: regex,
+					...valueSource ? { valueSource } : {}
+				};
+			} else if (/^\^.*?(?<!\$)$/.test(regex)) {
+				// istanbul ignore else
+				if (fieldIsValid(field, "beginsWith")) return {
+					field,
+					operator: "beginsWith",
+					value: regex.replace(/^\^/, "")
+				};
+			} else if (/^(?!\^).*?\$$/.test(regex)) {
+				// istanbul ignore else
+				if (fieldIsValid(field, "endsWith")) return {
+					field,
+					operator: "endsWith",
+					value: regex.replace(/\$$/, "")
+				};
+			}
+		} else if (isSpELBetweenValues(expr) || isSpELBetweenFields(expr)) {
+			let values = [null, null];
+			let valueSource = void 0;
+			const [{ identifier: field }, { children: [left, right] }] = expr.children;
+			if (isSpELBetweenValues(expr)) values = [left.value, right.value];
+			else {
+				values = [left.identifier, right.identifier];
+				valueSource = "field";
+			}
+			// istanbul ignore else
+			if (field && values.every((v) => fieldIsValid(field, "between", valueSource === "field" ? v : void 0))) {
+				const valueArray = values[0] < values[1] || valueSource === "field" ? values : [values[1], values[0]];
+				const value = listsAsArrays ? valueArray : joinWith(valueArray, ",");
+				return valueSource ? {
+					field,
+					operator: "between",
+					value,
+					valueSource
+				} : {
+					field,
+					operator: "between",
+					value
+				};
+			}
+		} else if (isSpELRelationOp(expr)) {
+			let field = null;
+			let value = void 0;
+			let valueSource = void 0;
+			let flip = false;
+			const [left, right] = expr.children;
+			if (isSpELIdentifier(left)) {
+				field = left.identifier;
+				if (isSpELIdentifier(right)) {
+					value = right.identifier;
+					valueSource = "field";
+				} else if (isSpELPrimitive(right)) value = right.value;
+			} else if (isSpELIdentifier(right) && isSpELPrimitive(left)) {
+				flip = true;
+				field = right.identifier;
+				value = left.value;
+			}
+			let operator = normalizeOperator(expr.type, flip);
+			if (value === null && (operator === "=" || operator === "!=")) operator = operator === "=" ? "null" : "notNull";
+			if (field && fieldIsValid(field, operator, valueSource === "field" ? value : void 0) && value !== void 0) return valueSource ? {
+				field,
+				operator,
+				value,
+				valueSource
+			} : {
+				field,
+				operator,
+				value
+			};
+		}
+		return null;
+	};
+	const prepare = options.generateIDs ? prepareRuleGroup : (g) => g;
+	let compiledSpEL;
+	try {
+		compiledSpEL = SpelExpressionEvaluator.compile(spel)._compiledExpression;
+	} catch {
+		return prepare(emptyQuery);
+	}
+	const processedSpEL = processCompiledExpression(compiledSpEL);
+	const result = parseProcessedSpEL(processedSpEL);
+	if (result) {
+		if (isRuleGroup(result)) return prepare(result);
+		return prepare({
+			rules: [result],
+			...ic ? {} : { combinator: "and" }
+		});
+	}
+	return prepare(emptyQuery);
+}
+
+//#endregion
+export { parseSpEL };
+//# sourceMappingURL=parseSpEL.mjs.map

package/dist/parseSpEL.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseSpEL.mjs","names":["returnArray: (\n    | DefaultCombinatorName\n    | SpELProcessedExpression\n    | ('and' | SpELProcessedExpression)[]\n  )[]","emptyQuery: DefaultRuleGroupTypeAny","rules","field: string","regex: string","valueSource: ValueSource | undefined","values: [any, any]","field: string | null","value: any","compiledSpEL: SpELExpressionNode"],"sources":["../src/utils/parseSpEL/utils.ts","../src/utils/parseSpEL/parseSpEL.ts"],"sourcesContent":["import type { DefaultCombinatorName, DefaultOperatorName } from '../../types';\nimport type {\n  SpELBaseNode,\n  SpELBetweenFields,\n  SpELBetweenValues,\n  SpELBooleanLiteral,\n  SpELCompoundNode,\n  SpELExpressionNode,\n  SpELIdentifier,\n  SpELListNode,\n  SpELNodeType,\n  SpELNullLiteral,\n  SpELNumericLiteral,\n  SpELOpAnd,\n  SpELOpMatches,\n  SpELOpOr,\n  SpELPrimitive,\n  SpELProcessedExpression,\n  SpELPropertyNode,\n  SpELRelOpType,\n  SpELRelation as SpELRelationOp,\n  SpELStringLiteral,\n} from './types';\n\nexport const isSpELPropertyNode = (expr: SpELBaseNode<SpELNodeType>): expr is SpELPropertyNode => {\n  return expr.getType() === 'property' || expr.getType() === 'variable';\n};\nexport const isSpELCompoundNode = (expr: SpELBaseNode<SpELNodeType>): expr is SpELCompoundNode => {\n  return expr.getType() === 'compound' && expr.getChildren().every(c => isSpELPropertyNode(c));\n};\nexport const isSpELListNode = (expr: SpELBaseNode<SpELNodeType>): expr is SpELListNode => {\n  return expr.getType() === 'list';\n};\n\nexport const isSpELOpAnd = (expr: SpELProcessedExpression): expr is SpELOpAnd =>\n  expr.type === 'op-and';\nexport const isSpELOpOr = (expr: SpELProcessedExpression): expr is SpELOpOr =>\n  expr.type === 'op-or';\nexport const isSpELOpMatches = (expr: SpELProcessedExpression): expr is SpELOpMatches =>\n  expr.type === 'matches' &&\n  ((isSpELIdentifier(expr.children[0]) && isSpELStringLiteral(expr.children[1])) ||\n    (isSpELIdentifier(expr.children[1]) && isSpELStringLiteral(expr.children[0])) ||\n    (isSpELIdentifier(expr.children[0]) && isSpELIdentifier(expr.children[1])));\nexport const isSpELIdentifier = (expr: SpELProcessedExpression): expr is SpELIdentifier =>\n  expr.type === 'property' || expr.type === 'variable' || expr.type === 'compound';\nexport const isSpELStringLiteral = (expr: SpELProcessedExpression): expr is SpELStringLiteral =>\n  expr.type === 'string';\nexport const isSpELNumericLiteral = (expr: SpELProcessedExpression): expr is SpELNumericLiteral =>\n  expr.type === 'number';\nexport const isSpELBooleanLiteral = (expr: SpELProcessedExpression): expr is SpELBooleanLiteral =>\n  expr.type === 'boolean';\nexport const isSpELNullLiteral = (expr: SpELProcessedExpression): expr is SpELNullLiteral =>\n  expr.type === 'null';\nexport const isSpELRelationOp = (expr: SpELProcessedExpression): expr is SpELRelationOp =>\n  expr.type === 'op-eq' ||\n  expr.type === 'op-ne' ||\n  expr.type === 'op-gt' ||\n  expr.type === 'op-ge' ||\n  expr.type === 'op-lt' ||\n  expr.type === 'op-le';\nexport const isSpELPrimitive = (expr: SpELProcessedExpression): expr is SpELPrimitive =>\n  isSpELNumericLiteral(expr) ||\n  isSpELStringLiteral(expr) ||\n  isSpELBooleanLiteral(expr) ||\n  isSpELNullLiteral(expr);\nexport const isSpELBetweenValues = (expr: SpELProcessedExpression): expr is SpELBetweenValues =>\n  expr.type === 'between' &&\n  isSpELIdentifier(expr.children[0]) &&\n  expr.children[1].type === 'list' &&\n  expr.children[1].children.length >= 2 &&\n  expr.children[1].children.every(c => isSpELPrimitive(c));\nexport const isSpELBetweenFields = (expr: SpELProcessedExpression): expr is SpELBetweenFields =>\n  expr.type === 'between' &&\n  isSpELIdentifier(expr.children[0]) &&\n  expr.children[1].type === 'list' &&\n  expr.children[1].children.length >= 2 &&\n  expr.children[1].children.every(c => isSpELIdentifier(c));\n\nexport const processCompiledExpression = (\n  ce: SpELPropertyNode | SpELExpressionNode\n): SpELProcessedExpression => {\n  const type = ce.getType();\n  const identifier = isSpELCompoundNode(ce)\n    ? ce\n        .getChildren()\n        .map(p => (isSpELPropertyNode(p) ? p.getRaw() : /* istanbul ignore next */ ''))\n        .join('.')\n    : isSpELPropertyNode(ce)\n      ? ce.getRaw()\n      : null;\n  const children =\n    type === 'compound'\n      ? []\n      : (isSpELListNode(ce) ? ce.getRaw : ce.getChildren)().map(c => processCompiledExpression(c));\n  const startPosition = ce.getStartPosition();\n  const endPosition = ce.getEndPosition();\n  const value = ce.getValue.length === 0 ? ce.getValue() : 'N/A';\n\n  return {\n    type: type === 'compound' && !identifier ? 'invalid' : type,\n    children,\n    startPosition,\n    endPosition,\n    value,\n    identifier,\n  };\n};\n\nexport const normalizeOperator = (opType: SpELRelOpType, flip?: boolean): DefaultOperatorName => {\n  if (flip) {\n    if (opType === 'op-lt') return '>';\n    if (opType === 'op-le') return '>=';\n    if (opType === 'op-gt') return '<';\n    if (opType === 'op-ge') return '<=';\n  }\n  return (\n    {\n      'op-eq': '=',\n      'op-ge': '>=',\n      'op-gt': '>',\n      'op-le': '<=',\n      'op-lt': '<',\n      'op-ne': '!=',\n    } as const\n  )[opType];\n};\n\nexport const generateFlatAndOrList = (\n  expr: SpELProcessedExpression\n): (DefaultCombinatorName | SpELProcessedExpression)[] => {\n  const combinator = expr.type.slice(3) as DefaultCombinatorName;\n  const [left, right] = expr.children;\n  if (left.type === 'op-and' || left.type === 'op-or') {\n    return [...generateFlatAndOrList(left), combinator, right];\n  }\n  return [left, combinator, right];\n};\n\nexport const generateMixedAndOrList = (\n  expr: SpELOpAnd | SpELOpOr\n): (DefaultCombinatorName | SpELProcessedExpression | ('and' | SpELProcessedExpression)[])[] => {\n  const arr = generateFlatAndOrList(expr);\n  const returnArray: (\n    | DefaultCombinatorName\n    | SpELProcessedExpression\n    | ('and' | SpELProcessedExpression)[]\n  )[] = [];\n  let startIndex = 0;\n  for (let i = 0; i < arr.length; i += 2) {\n    if (arr[i + 1] === 'and') {\n      startIndex = i;\n      let j = 1;\n      while (arr[startIndex + j] === 'and') {\n        i += 2;\n        j += 2;\n      }\n      const tempAndArray = arr.slice(startIndex, i + 1) as ('and' | SpELProcessedExpression)[];\n      returnArray.push(tempAndArray);\n      i -= 2;\n    } else if (arr[i + 1] === 'or') {\n      if (i === 0 || i === arr.length - 3) {\n        if (i === 0 || arr[i - 1] === 'or') {\n          returnArray.push(arr[i]);\n        }\n        returnArray.push(arr[i + 1]);\n        if (i === arr.length - 3) {\n          returnArray.push(arr[i + 2]);\n        }\n      } else {\n        if (arr[i - 1] === 'and') {\n          returnArray.push(arr[i + 1]);\n        } else {\n          returnArray.push(arr[i], arr[i + 1]);\n        }\n      }\n    }\n  }\n  if (returnArray.length === 1 && Array.isArray(returnArray[0])) {\n    // If length is 1, then the only element is an AND array so just return that\n    return returnArray[0];\n  }\n  return returnArray;\n};\n","import { SpelExpressionEvaluator } from 'spel2js';\nimport type {\n  DefaultCombinatorName,\n  DefaultOperatorName,\n  DefaultRuleGroupArray,\n  DefaultRuleGroupICArray,\n  DefaultRuleGroupType,\n  DefaultRuleGroupTypeAny,\n  DefaultRuleGroupTypeIC,\n  DefaultRuleType,\n  Except,\n  ValueSource,\n} from '../../types';\nimport type { ParserCommonOptions } from '../../types/import';\nimport { joinWith } from '../arrayUtils';\nimport { isRuleGroup } from '../isRuleGroup';\nimport { fieldIsValidUtil, getFieldsArray } from '../parserUtils';\nimport { prepareRuleGroup } from '../prepareQueryObjects';\nimport type { SpELExpressionNode, SpELProcessedExpression } from './types';\nimport {\n  generateFlatAndOrList,\n  generateMixedAndOrList,\n  isSpELBetweenFields,\n  isSpELBetweenValues,\n  isSpELIdentifier,\n  isSpELOpAnd,\n  isSpELOpMatches,\n  isSpELOpOr,\n  isSpELPrimitive,\n  isSpELRelationOp,\n  normalizeOperator,\n  processCompiledExpression,\n} from './utils';\n\n/**\n * Options object for {@link parseSpEL!parseSpEL}.\n */\nexport interface ParseSpELOptions extends ParserCommonOptions {}\n\n/**\n * Converts a SpEL string expression into a query suitable for the\n * {@link index!QueryBuilder QueryBuilder} component's `query` or `defaultQuery` props\n * ({@link index!DefaultRuleGroupType DefaultRuleGroupType}).\n */\nfunction parseSpEL(spel: string): DefaultRuleGroupType;\n/**\n * Converts a SpEL string expression into a query suitable for the\n * {@link index!QueryBuilder QueryBuilder} component's `query` or `defaultQuery` props\n * ({@link index!DefaultRuleGroupType DefaultRuleGroupType}).\n */\nfunction parseSpEL(\n  spel: string,\n  options: Except<ParseSpELOptions, 'independentCombinators'> & {\n    independentCombinators?: false;\n  }\n): DefaultRuleGroupType;\n/**\n * Converts a SpEL string expression into a query suitable for the\n * {@link index!QueryBuilder QueryBuilder} component's `query` or `defaultQuery` props\n * ({@link index!DefaultRuleGroupTypeIC DefaultRuleGroupTypeIC}).\n */\nfunction parseSpEL(\n  spel: string,\n  options: Except<ParseSpELOptions, 'independentCombinators'> & {\n    independentCombinators: true;\n  }\n): DefaultRuleGroupTypeIC;\nfunction parseSpEL(spel: string, options: ParseSpELOptions = {}): DefaultRuleGroupTypeAny {\n  const { fields, independentCombinators, listsAsArrays } = options;\n  const ic = !!independentCombinators;\n  const fieldsFlat = getFieldsArray(fields);\n\n  const fieldIsValid = (\n    fieldName: string,\n    operator: DefaultOperatorName,\n    subordinateFieldName?: string\n  ) =>\n    fieldIsValidUtil({\n      fieldName,\n      fieldsFlat,\n      operator,\n      subordinateFieldName,\n      getValueSources: options?.getValueSources,\n    });\n\n  const emptyQuery: DefaultRuleGroupTypeAny = {\n    rules: [],\n    ...(ic ? {} : { combinator: 'and' }),\n  };\n\n  const parseProcessedSpEL = (\n    expr: SpELProcessedExpression,\n    processOpts: {\n      groupOnlyIfNecessary?: boolean;\n      forwardNegation?: boolean;\n    } = {}\n  ): DefaultRuleType | DefaultRuleGroupTypeAny | null => {\n    const { forwardNegation: _forwardedNegation, groupOnlyIfNecessary: _g } = processOpts;\n    if (expr.type === 'op-not') {\n      const negatedExpr = parseProcessedSpEL(expr.children[0]);\n      // istanbul ignore else\n      if (negatedExpr) {\n        if (\n          !isRuleGroup(negatedExpr) &&\n          (negatedExpr.operator === 'contains' ||\n            negatedExpr.operator === 'beginsWith' ||\n            negatedExpr.operator === 'endsWith')\n        ) {\n          return {\n            ...negatedExpr,\n            operator: `doesNot${negatedExpr.operator[0].toUpperCase()}${negatedExpr.operator\n              .slice(1)\n              .replace('s', '')}` as DefaultOperatorName,\n          };\n        }\n        return ic\n          ? ({ rules: [negatedExpr], not: true } as DefaultRuleGroupTypeIC)\n          : ({\n              combinator: 'and',\n              rules: [negatedExpr],\n              not: true,\n            } as DefaultRuleGroupType);\n      }\n    } else if (isSpELOpAnd(expr) || isSpELOpOr(expr)) {\n      if (ic) {\n        const andOrList = generateFlatAndOrList(expr);\n        const rules = andOrList.map(v => {\n          if (typeof v === 'string') {\n            return v;\n          }\n          return parseProcessedSpEL(v);\n        });\n        // Bail out completely if any rules in the list were invalid\n        // so as not to return an incorrect and/or sequence\n        if (!rules.every(Boolean)) {\n          return null;\n        }\n        return {\n          rules: rules as DefaultRuleGroupICArray,\n        };\n      }\n      const andOrList = generateMixedAndOrList(expr);\n      const combinator = andOrList[1] as DefaultCombinatorName;\n      const filteredList = andOrList\n        .filter(v => Array.isArray(v) || (!!v && typeof v !== 'string' && 'type' in v))\n        .map(v =>\n          Array.isArray(v) ? v.filter(vf => !!v && typeof vf !== 'string' && 'type' in vf) : v\n        ) as (SpELProcessedExpression | SpELProcessedExpression[])[];\n      const rules = filteredList\n        .map((exp): DefaultRuleGroupType | DefaultRuleType | null => {\n          if (Array.isArray(exp)) {\n            return {\n              combinator: 'and',\n              rules: exp.map(e => parseProcessedSpEL(e)).filter(Boolean) as DefaultRuleGroupArray,\n            };\n          }\n          return parseProcessedSpEL(exp) as DefaultRuleType | DefaultRuleGroupType | null;\n        })\n        .filter(Boolean) as DefaultRuleGroupArray;\n      // istanbul ignore else\n      if (rules.length > 0) {\n        return { combinator, rules };\n      }\n    } else if (isSpELOpMatches(expr)) {\n      const [left, right] = expr.children;\n      let field: string = '';\n      let regex: string = '';\n      let valueSource: ValueSource | undefined = undefined;\n      if (isSpELIdentifier(left)) {\n        field = left.identifier;\n        if (isSpELIdentifier(right)) {\n          regex = right.identifier;\n          valueSource = 'field';\n        } else {\n          // istanbul ignore else\n          if (isSpELPrimitive(right)) {\n            regex = right.value;\n          }\n        }\n      } else {\n        // istanbul ignore else\n        if (isSpELIdentifier(right) && isSpELPrimitive(left)) {\n          field = right.identifier;\n          regex = left.value;\n        }\n      }\n\n      if (/^(?!\\^).*?(?<!\\$)$/.test(regex)) {\n        // istanbul ignore else\n        if (fieldIsValid(field, 'contains')) {\n          return {\n            field,\n            operator: 'contains',\n            value: regex,\n            ...(valueSource ? { valueSource } : {}),\n          };\n        }\n      } else {\n        if (/^\\^.*?(?<!\\$)$/.test(regex)) {\n          // istanbul ignore else\n          if (fieldIsValid(field, 'beginsWith')) {\n            return {\n              field,\n              operator: 'beginsWith',\n              value: regex.replace(/^\\^/, ''),\n            };\n          }\n        } else {\n          // istanbul ignore else\n          if (/^(?!\\^).*?\\$$/.test(regex)) {\n            // istanbul ignore else\n            if (fieldIsValid(field, 'endsWith')) {\n              return {\n                field,\n                operator: 'endsWith',\n                value: regex.replace(/\\$$/, ''),\n              };\n            }\n          }\n        }\n      }\n    } else if (isSpELBetweenValues(expr) || isSpELBetweenFields(expr)) {\n      // oxlint-disable-next-line typescript/no-explicit-any\n      let values: [any, any] = [null, null];\n      let valueSource: ValueSource | undefined = undefined;\n      const [\n        { identifier: field },\n        {\n          children: [left, right],\n        },\n      ] = expr.children;\n\n      if (isSpELBetweenValues(expr)) {\n        values = [left.value, right.value];\n      } else {\n        values = [left.identifier, right.identifier];\n        valueSource = 'field';\n      }\n      // istanbul ignore else\n      if (\n        field &&\n        values.every(v => fieldIsValid(field, 'between', valueSource === 'field' ? v : undefined))\n      ) {\n        const valueArray =\n          values[0] < values[1] || valueSource === 'field' ? values : [values[1], values[0]];\n        const value = listsAsArrays ? valueArray : joinWith(valueArray, ',');\n        return valueSource\n          ? { field, operator: 'between', value, valueSource }\n          : { field, operator: 'between', value };\n      }\n    } else if (isSpELRelationOp(expr)) {\n      let field: string | null = null;\n      // oxlint-disable-next-line typescript/no-explicit-any\n      let value: any = undefined;\n      let valueSource: ValueSource | undefined = undefined;\n      let flip = false;\n      const [left, right] = expr.children;\n\n      if (isSpELIdentifier(left)) {\n        field = left.identifier;\n        if (isSpELIdentifier(right)) {\n          value = right.identifier;\n          valueSource = 'field';\n        } else if (isSpELPrimitive(right)) {\n          value = right.value;\n        }\n      } else {\n        // istanbul ignore else\n        if (isSpELIdentifier(right) && isSpELPrimitive(left)) {\n          flip = true;\n          field = right.identifier;\n          value = left.value;\n        }\n      }\n      let operator = normalizeOperator(expr.type, flip);\n      if (value === null && (operator === '=' || operator === '!=')) {\n        operator = operator === '=' ? 'null' : 'notNull';\n      }\n      if (\n        field &&\n        fieldIsValid(field, operator, valueSource === 'field' ? value : undefined) &&\n        value !== undefined\n      ) {\n        return valueSource ? { field, operator, value, valueSource } : { field, operator, value };\n      }\n    }\n    return null;\n  };\n\n  const prepare = options.generateIDs ? prepareRuleGroup : <T>(g: T) => g;\n\n  let compiledSpEL: SpELExpressionNode;\n  try {\n    compiledSpEL = SpelExpressionEvaluator.compile(spel)._compiledExpression;\n  } catch {\n    return prepare(emptyQuery);\n  }\n\n  const processedSpEL = processCompiledExpression(compiledSpEL);\n\n  const result = parseProcessedSpEL(processedSpEL);\n  if (result) {\n    if (isRuleGroup(result)) {\n      return prepare(result);\n    }\n    return prepare({ rules: [result], ...(ic ? {} : { combinator: 'and' }) });\n  }\n\n  return prepare(emptyQuery);\n}\n\nexport { parseSpEL };\n"],"mappings":"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"}

package/dist/prepareQueryObjects-CS6Wmhmf.mjs

@@ -0,0 +1,154 @@
+import { isRuleGroup, lc } from "./isRuleGroup-CnhYpLOM.mjs";
+import { isFlexibleOptionArray, isFlexibleOptionGroupArray, toFlatOptionArray, toFullOption, toFullOptionList } from "./optGroupUtils-Duv-M8rf.mjs";
+import { produce } from "immer";
+
+//#region src/utils/filterFieldsByComparator.ts
+const filterByComparator = (field, operator, fieldToCompare) => {
+	const fullField = toFullOption(field);
+	const fullFieldToCompare = toFullOption(fieldToCompare);
+	if (fullField.value === fullFieldToCompare.value) return false;
+	if (typeof fullField.comparator === "string") return fullField[fullField.comparator] === fullFieldToCompare[fullField.comparator];
+	return fullField.comparator?.(fullFieldToCompare, operator) ?? false;
+};
+/**
+* For a given {@link FullField}, returns the `fields` list filtered for
+* other fields that match by `comparator`. Only fields *other than the
+* one in question* will ever be included, even if `comparator` is `null`
+* or `undefined`. If `comparator` is a string, fields with the same value
+* for that property will be included. If `comparator` is a function, each
+* field will be passed to the function along with the `operator` and fields
+* for which the function returns `true` will be included.
+*
+* @group Option Lists
+*/
+const filterFieldsByComparator = (field, fields, operator) => {
+	if (!field.comparator) {
+		const filterOutSameField = (f) => (f.value ?? f.name) !== (field.value ?? field.name);
+		if (isFlexibleOptionGroupArray(fields)) return fields.map((og) => ({
+			...og,
+			options: og.options.filter((v) => filterOutSameField(v))
+		}));
+		return fields.filter((v) => filterOutSameField(v));
+	}
+	if (isFlexibleOptionGroupArray(fields)) return fields.map((og) => ({
+		...og,
+		options: og.options.filter((f) => filterByComparator(field, operator, f))
+	})).filter((og) => og.options.length > 0);
+	return fields.filter((f) => filterByComparator(field, operator, f));
+};
+
+//#endregion
+//#region src/utils/getValueSourcesUtil.ts
+const defaultValueSourcesArray = [{
+	name: "value",
+	value: "value",
+	label: "value"
+}];
+const dummyFD = {
+	name: "name",
+	value: "name",
+	valueSources: null,
+	label: "label"
+};
+/**
+* Utility function to get the value sources array for the given
+* field and operator. If the field definition does not define a
+* `valueSources` property, the `getValueSources` prop is used.
+* Returns `[FullOption<"value">]` by default.
+*/
+const getValueSourcesUtil = (fieldData, operator, getValueSources) => {
+	const fd = fieldData ? toFullOption(fieldData) : dummyFD;
+	let valueSourcesNEW = fd.valueSources ?? false;
+	if (typeof valueSourcesNEW === "function") valueSourcesNEW = valueSourcesNEW(operator);
+	if (!valueSourcesNEW && getValueSources) valueSourcesNEW = getValueSources(fd.value, operator, { fieldData: fd });
+	if (!valueSourcesNEW) return defaultValueSourcesArray;
+	if (isFlexibleOptionArray(valueSourcesNEW)) return toFullOptionList(valueSourcesNEW);
+	return valueSourcesNEW.map((vs) => defaultValueSourcesArray.find((dmm) => dmm.value === lc(vs)) ?? {
+		name: vs,
+		value: vs,
+		label: vs
+	});
+};
+
+//#endregion
+//#region src/utils/parserUtils.ts
+const getFieldsArray = (fields) => {
+	const fieldsArray = fields ? Array.isArray(fields) ? fields : Object.keys(fields).map((fld) => ({
+		...fields[fld],
+		name: fld
+	})).sort((a, b) => a.label.localeCompare(b.label)) : [];
+	return toFlatOptionArray(fieldsArray);
+};
+function fieldIsValidUtil(params) {
+	const { fieldsFlat, fieldName, operator, subordinateFieldName, getValueSources } = params;
+	const vsIncludes = (vs) => {
+		const vss = getValueSourcesUtil(primaryField, operator, getValueSources);
+		return isFlexibleOptionArray(vss) && vss.some((vso) => vso.value === vs || vso.name === vs);
+	};
+	if (fieldsFlat.length === 0) return true;
+	let valid = false;
+	const primaryField = toFullOption(fieldsFlat.find((ff) => ff.name === fieldName));
+	if (primaryField) {
+		valid = !(!subordinateFieldName && operator !== "notNull" && operator !== "null" && !vsIncludes("value"));
+		if (valid && !!subordinateFieldName) if (vsIncludes("field") && fieldName !== subordinateFieldName) {
+			if (!filterFieldsByComparator(primaryField, fieldsFlat, operator).some((vsf) => vsf.name === subordinateFieldName)) valid = false;
+		} else valid = false;
+	}
+	return valid;
+}
+
+//#endregion
+//#region src/utils/generateID.ts
+const cryptoModule = globalThis.crypto;
+/**
+* Default `id` generator. Generates a valid v4 UUID. Uses `crypto.randomUUID()`
+* when available, otherwise uses an alternate method based on `getRandomValues`.
+* The returned string is guaranteed to match this regex:
+* ```
+* /^[0-9A-F]{8}-[0-9A-F]{4}-4[0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$/i
+* ```
+* @returns Valid v4 UUID
+*/
+// istanbul ignore next
+let generateID = () => "00-0-4-2-000".replaceAll(/[^-]/g, (s) => ((Math.random() + Math.trunc(s)) * 65536 >> Number.parseInt(s)).toString(16).padStart(4, "0"));
+// istanbul ignore else
+if (cryptoModule) {
+	// istanbul ignore else
+	if (typeof cryptoModule.randomUUID === "function") generateID = () => cryptoModule.randomUUID();
+	else if (typeof cryptoModule.getRandomValues === "function") {
+		const position19vals = "89ab";
+		const container = new Uint32Array(32);
+		generateID = () => {
+			cryptoModule.getRandomValues(container);
+			let id = (container[0] % 16).toString(16);
+			for (let i = 1; i < 32; i++) {
+				if (i === 12) id = `${id}4`;
+				else if (i === 16) id = `${id}${position19vals[container[17] % 4]}`;
+				else id = `${id}${(container[i] % 16).toString(16)}`;
+				if (i === 7 || i === 11 || i === 15 || i === 19) id = `${id}-`;
+			}
+			return id;
+		};
+	}
+}
+
+//#endregion
+//#region src/utils/prepareQueryObjects.ts
+/**
+* Ensures that a rule is valid by adding an `id` property if it does not already exist.
+*/
+const prepareRule = (rule, { idGenerator = generateID } = {}) => produce(rule, (draft) => {
+	if (!draft.id) draft.id = idGenerator();
+});
+/**
+* Ensures that a rule group is valid by recursively adding an `id` property to the group itself
+* and all its rules and subgroups where one does not already exist.
+*/
+const prepareRuleGroup = (queryObject, { idGenerator = generateID } = {}) => produce(queryObject, (draft) => {
+	if (!draft.id) draft.id = idGenerator();
+	draft.rules = draft.rules.map((r) => typeof r === "string" ? r : isRuleGroup(r) ? prepareRuleGroup(r, { idGenerator }) : prepareRule(r, { idGenerator }));
+});
+
+//#endregion
+export { fieldIsValidUtil, getFieldsArray, prepareRuleGroup };
+//# sourceMappingURL=prepareQueryObjects-CS6Wmhmf.mjs.map

package/dist/prepareQueryObjects-CS6Wmhmf.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"prepareQueryObjects-CS6Wmhmf.mjs","names":["defaultValueSourcesArray: ValueSourceFullOptions","valueSourcesNEW:\n    | false\n    | ValueSources\n    | ValueSourceFlexibleOptions\n    | ((operator: string) => ValueSources | ValueSourceFlexibleOptions)"],"sources":["../src/utils/filterFieldsByComparator.ts","../src/utils/getValueSourcesUtil.ts","../src/utils/parserUtils.ts","../src/utils/generateID.ts","../src/utils/prepareQueryObjects.ts"],"sourcesContent":["import type { FullField, OptionList, WithUnknownIndex } from '../types';\nimport { isFlexibleOptionGroupArray, toFullOption } from './optGroupUtils';\n\nconst filterByComparator = (field: FullField, operator: string, fieldToCompare: FullField) => {\n  const fullField = toFullOption(field);\n  const fullFieldToCompare = toFullOption(fieldToCompare);\n  if (fullField.value === fullFieldToCompare.value) {\n    return false;\n  }\n  if (typeof fullField.comparator === 'string') {\n    return fullField[fullField.comparator] === fullFieldToCompare[fullField.comparator];\n  }\n  return fullField.comparator?.(fullFieldToCompare, operator) ?? /* istanbul ignore next */ false;\n};\n\n/**\n * For a given {@link FullField}, returns the `fields` list filtered for\n * other fields that match by `comparator`. Only fields *other than the\n * one in question* will ever be included, even if `comparator` is `null`\n * or `undefined`. If `comparator` is a string, fields with the same value\n * for that property will be included. If `comparator` is a function, each\n * field will be passed to the function along with the `operator` and fields\n * for which the function returns `true` will be included.\n *\n * @group Option Lists\n */\nexport const filterFieldsByComparator = (\n  /** The field in question. */\n  field: FullField,\n  /** The full {@link FullField} list to be filtered. */\n  fields: OptionList<FullField>,\n  operator: string\n):\n  | FullField[]\n  | {\n      options: WithUnknownIndex<FullField>[];\n      label: string;\n    }[] => {\n  if (!field.comparator) {\n    const filterOutSameField = (f: FullField) =>\n      (f.value ?? /* istanbul ignore next */ f.name) !==\n      (field.value ?? /* istanbul ignore next */ field.name);\n    if (isFlexibleOptionGroupArray(fields)) {\n      return fields.map(og => ({\n        ...og,\n        options: og.options.filter(v => filterOutSameField(v)),\n      }));\n    }\n    return fields.filter(v => filterOutSameField(v));\n  }\n\n  if (isFlexibleOptionGroupArray(fields)) {\n    return fields\n      .map(og => ({\n        ...og,\n        options: og.options.filter(f => filterByComparator(field, operator, f)),\n      }))\n      .filter(og => og.options.length > 0);\n  }\n\n  return fields.filter(f => filterByComparator(field, operator, f));\n};\n","import type {\n  FullField,\n  GetOptionIdentifierType,\n  ValueSourceFlexibleOptions,\n  ValueSourceFullOptions,\n  ValueSources,\n} from '../types';\nimport { lc } from './misc';\nimport { isFlexibleOptionArray, toFullOption, toFullOptionList } from './optGroupUtils';\n\nconst defaultValueSourcesArray: ValueSourceFullOptions = [\n  { name: 'value', value: 'value', label: 'value' },\n];\n\nconst dummyFD = {\n  name: 'name',\n  value: 'name',\n  valueSources: null,\n  label: 'label',\n};\n\n/**\n * Utility function to get the value sources array for the given\n * field and operator. If the field definition does not define a\n * `valueSources` property, the `getValueSources` prop is used.\n * Returns `[FullOption<\"value\">]` by default.\n */\nexport const getValueSourcesUtil = <F extends FullField, O extends string>(\n  fieldData: F,\n  operator: string,\n  getValueSources?: (\n    field: GetOptionIdentifierType<F>,\n    operator: O,\n    misc: { fieldData: F }\n  ) => ValueSources | ValueSourceFlexibleOptions\n): ValueSourceFullOptions => {\n  // TypeScript doesn't allow it directly, but in practice\n  // `fieldData` can end up being undefined or null. The nullish\n  // coalescing assignment below avoids errors like\n  // \"TypeError: Cannot read properties of undefined (reading 'name')\"\n  const fd = fieldData ? toFullOption(fieldData) : dummyFD;\n\n  let valueSourcesNEW:\n    | false\n    | ValueSources\n    | ValueSourceFlexibleOptions\n    | ((operator: string) => ValueSources | ValueSourceFlexibleOptions) = fd.valueSources ?? false;\n\n  if (typeof valueSourcesNEW === 'function') {\n    valueSourcesNEW = valueSourcesNEW(operator as O);\n  }\n\n  if (!valueSourcesNEW && getValueSources) {\n    valueSourcesNEW = getValueSources(fd.value as GetOptionIdentifierType<F>, operator as O, {\n      fieldData: fd as F,\n    });\n  }\n\n  if (!valueSourcesNEW) {\n    return defaultValueSourcesArray;\n  }\n\n  if (isFlexibleOptionArray(valueSourcesNEW)) {\n    return toFullOptionList(valueSourcesNEW as ValueSourceFullOptions) as ValueSourceFullOptions;\n  }\n\n  return valueSourcesNEW.map(\n    vs =>\n      defaultValueSourcesArray.find(dmm => dmm.value === lc(vs)) ?? {\n        name: vs,\n        value: vs,\n        label: vs,\n      }\n  ) as ValueSourceFullOptions;\n};\n","import type {\n  DefaultOperatorName,\n  FullField,\n  FullOption,\n  OptionList,\n  ValueSource,\n  ValueSourceFlexibleOptions,\n  ValueSources,\n} from '../types';\nimport { filterFieldsByComparator } from './filterFieldsByComparator';\nimport { getValueSourcesUtil } from './getValueSourcesUtil';\nimport { isFlexibleOptionArray, toFlatOptionArray, toFullOption } from './optGroupUtils';\n\nexport const getFieldsArray = (\n  fields?: OptionList<FullField> | Record<string, FullField>\n): FullOption[] => {\n  const fieldsArray = fields\n    ? Array.isArray(fields)\n      ? fields\n      : Object.keys(fields)\n          .map(fld => ({ ...fields[fld], name: fld }))\n          .sort((a, b) => a.label.localeCompare(b.label))\n    : [];\n  return toFlatOptionArray(fieldsArray);\n};\n\nexport function fieldIsValidUtil(params: {\n  fieldsFlat: FullField[];\n  getValueSources?: (field: string, operator: string) => ValueSources | ValueSourceFlexibleOptions;\n  fieldName: string;\n  operator: DefaultOperatorName;\n  subordinateFieldName?: string;\n}): boolean {\n  const { fieldsFlat, fieldName, operator, subordinateFieldName, getValueSources } = params;\n\n  const vsIncludes = (vs: ValueSource) => {\n    const vss = getValueSourcesUtil(primaryField, operator, getValueSources);\n    return isFlexibleOptionArray(vss) && vss.some(vso => vso.value === vs || vso.name === vs);\n  };\n\n  // If fields option was an empty array or undefined, then all identifiers\n  // are considered valid.\n  if (fieldsFlat.length === 0) return true;\n\n  let valid = false;\n\n  const primaryField = toFullOption(fieldsFlat.find(ff => ff.name === fieldName)!);\n  if (primaryField) {\n    valid = !(\n      !subordinateFieldName &&\n      operator !== 'notNull' &&\n      operator !== 'null' &&\n      !vsIncludes('value')\n    );\n\n    if (valid && !!subordinateFieldName) {\n      if (vsIncludes('field') && fieldName !== subordinateFieldName) {\n        const validSubordinateFields = filterFieldsByComparator(\n          primaryField,\n          fieldsFlat,\n          operator\n        ) as FullField[];\n        if (!validSubordinateFields.some(vsf => vsf.name === subordinateFieldName)) {\n          valid = false;\n        }\n      } else {\n        valid = false;\n      }\n    }\n  }\n\n  return valid;\n}\n","// import type { UUID } from 'node:crypto';\ntype UUID = `${string}-${string}-${string}-${string}-${string}`;\n\nconst cryptoModule = globalThis.crypto;\n\n/**\n * Default `id` generator. Generates a valid v4 UUID. Uses `crypto.randomUUID()`\n * when available, otherwise uses an alternate method based on `getRandomValues`.\n * The returned string is guaranteed to match this regex:\n * ```\n * /^[0-9A-F]{8}-[0-9A-F]{4}-4[0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$/i\n * ```\n * @returns Valid v4 UUID\n */\n// Default implementation adapted from https://stackoverflow.com/a/68141099/217579\n// istanbul ignore next\nexport let generateID = (): UUID =>\n  '00-0-4-2-000'.replaceAll(/[^-]/g, s =>\n    (((Math.random() + Math.trunc(s as unknown as number)) * 0x1_00_00) >> Number.parseInt(s))\n      .toString(16)\n      .padStart(4, '0')\n  ) as UUID;\n\n// Improve on the default implementation by using the crypto package if it's available\n// istanbul ignore else\nif (cryptoModule) {\n  // istanbul ignore else\n  if (typeof cryptoModule.randomUUID === 'function') {\n    generateID = () => cryptoModule.randomUUID();\n  } else if (typeof cryptoModule.getRandomValues === 'function') {\n    // `randomUUID` is much simpler and faster, but it's only guaranteed to be\n    // available in secure contexts (server-side, https, etc.). `generateID`\n    // doesn't really need to be cryptographically secure, it only needs a\n    // fairly low chance of collisions. We fall back to the always-available\n    // `getRandomValues` here (while still generating a valid v4 UUID) when\n    // `randomUUID` is not available.\n    const position19vals = '89ab';\n    const container = new Uint32Array(32);\n\n    generateID = () => {\n      cryptoModule.getRandomValues(container);\n      let id = (container[0] % 16).toString(16);\n      for (let i = 1; i < 32; i++) {\n        if (i === 12) {\n          id = `${id}${'4'}`;\n        } else if (i === 16) {\n          id = `${id}${position19vals[container[17] % 4]}`;\n        } else {\n          id = `${id}${(container[i] % 16).toString(16)}`;\n        }\n\n        if (i === 7 || i === 11 || i === 15 || i === 19) {\n          id = `${id}${'-'}`;\n        }\n      }\n      return id as UUID;\n    };\n  }\n}\n","import { produce } from 'immer';\nimport type {\n  RuleGroupArray,\n  RuleGroupICArray,\n  RuleGroupType,\n  RuleGroupTypeAny,\n  RuleGroupTypeIC,\n  RuleType,\n} from '../types';\nimport { generateID } from './generateID';\nimport { isRuleGroup } from './isRuleGroup';\n\n/**\n * Options for {@link prepareRule}/{@link prepareRuleGroup}.\n */\nexport interface PreparerOptions {\n  idGenerator?: () => string;\n}\n\n/**\n * Ensures that a rule is valid by adding an `id` property if it does not already exist.\n */\nexport const prepareRule = (\n  rule: RuleType,\n  { idGenerator = generateID }: PreparerOptions = {}\n): RuleType =>\n  produce(rule, draft => {\n    if (!draft.id) {\n      draft.id = idGenerator();\n    }\n  });\n\n/**\n * Ensures that a rule group is valid by recursively adding an `id` property to the group itself\n * and all its rules and subgroups where one does not already exist.\n */\nexport const prepareRuleGroup = <RG extends RuleGroupTypeAny>(\n  queryObject: RG,\n  { idGenerator = generateID }: PreparerOptions = {}\n): RG =>\n  produce(queryObject, draft => {\n    if (!draft.id) {\n      draft.id = idGenerator();\n    }\n    draft.rules = draft.rules.map(r =>\n      typeof r === 'string'\n        ? r\n        : isRuleGroup(r)\n          ? prepareRuleGroup(r, { idGenerator })\n          : prepareRule(r, { idGenerator })\n    ) as RuleGroupArray | RuleGroupICArray;\n  });\n\n/**\n * Ensures that a rule or group is valid. See {@link prepareRule} and {@link prepareRuleGroup}.\n */\nexport const prepareRuleOrGroup = <RG extends RuleGroupTypeAny>(\n  rg: RG | RuleType,\n  { idGenerator = generateID }: PreparerOptions = {}\n): RuleGroupType | RuleGroupTypeIC | RuleType =>\n  isRuleGroup(rg) ? prepareRuleGroup(rg, { idGenerator }) : prepareRule(rg, { idGenerator });\n"],"mappings":"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"}

package/dist/react-querybuilder_core.d.mts

@@ -3378,6 +3378,11 @@ declare const nullFreeArray: <T>(arr: T[]) => arr is Exclude<T, null>[];
 type ClassDictionary = Record<string, any>;
 type ClassValue = ClassArray | ClassDictionary | string | number | bigint | null | boolean | undefined;
 type ClassArray = ClassValue[];
+/**
+* Vendored/adapted version of the `clsx` package.
+*
+* **NOTE:** Prefer the official package from npm outside the context of React Query Builder.
+*/
 declare function clsx(...args: ClassValue[]): string;
 //#endregion
 //#region src/utils/convertQuery.d.ts
@@ -4155,17 +4160,21 @@ declare const getValueSourcesUtil: <F extends FullField, O extends string>(field
 //#endregion
 //#region src/utils/isRuleGroup.d.ts
 /**
+* Determines if an object is a {@link RuleType} (only checks for a `field` property).
+*/
+declare const isRuleType: (s: unknown) => s is RuleType;
+/**
 * Determines if an object is a {@link RuleGroupType} or {@link RuleGroupTypeIC}.
 */
-declare const isRuleGroup: (rg: any) => rg is RuleGroupTypeAny;
+declare const isRuleGroup: (rg: unknown) => rg is RuleGroupTypeAny;
 /**
 * Determines if an object is a {@link RuleGroupType}.
 */
-declare const isRuleGroupType: (rg: any) => rg is RuleGroupType;
+declare const isRuleGroupType: (rg: unknown) => rg is RuleGroupType;
 /**
 * Determines if an object is a {@link RuleGroupTypeIC}.
 */
-declare const isRuleGroupTypeIC: (rg: any) => rg is RuleGroupTypeIC;
+declare const isRuleGroupTypeIC: (rg: unknown) => rg is RuleGroupTypeIC;
 //#endregion
 //#region src/utils/isRuleOrGroupValid.d.ts
 /**
@@ -4202,7 +4211,7 @@ declare const isPojo: (obj: any) => obj is Record<string, any>;
 /**
 * Simple helper to determine whether a value is null, undefined, or an empty string.
 */
-declare const nullOrUndefinedOrEmpty: (value: any) => value is null | undefined | "";
+declare const nullOrUndefinedOrEmpty: (value: unknown) => value is null | undefined | "";
 //#endregion
 //#region src/utils/objectUtils.d.ts
 /**
@@ -4659,15 +4668,17 @@ interface RegenerateIdOptions {
 /**
 * Generates a new `id` property for a rule.
 */
-declare const regenerateID: (rule: RuleType, {
+declare const regenerateID: <R extends RuleType>(rule: R, {
   idGenerator
-}?: RegenerateIdOptions) => RuleType;
+}?: RegenerateIdOptions) => SetRequired<R, "id">;
 /**
-* Recursively generates new `id` properties for a group and all its rules and subgroups.
+* Recursively generates new `id` properties for a rule group and all its rules and subgroups.
 */
-declare const regenerateIDs: (ruleOrGroup: RuleGroupType | RuleGroupTypeIC, {
+declare const regenerateIDs: <RG>(subject: RG, {
   idGenerator
-}?: RegenerateIdOptions) => RuleGroupType | RuleGroupTypeIC;
+}?: RegenerateIdOptions) => RG & {
+  id: string;
+};
 //#endregion
 //#region src/utils/transformQuery.d.ts
 /**
@@ -4782,5 +4793,5 @@ declare function transformQuery(query: RuleGroupType, options?: TransformQueryOp
 */
 declare function transformQuery(query: RuleGroupTypeIC, options?: TransformQueryOptions<RuleGroupTypeIC>): any;
 //#endregion
-export { AccessibleDescriptionGenerator, ActionElementEventHandler, AddOptions, And, Arity, BaseFullOption, BaseOption, BaseOptionMap, Classname, Classnames, Combinator, CombinatorByValue, CommonRuleAndGroupProperties, CommonRuleSubComponentProps, ConstituentWordOrder, ConstituentWordOrderString, DefaultCombinator, DefaultCombinatorExtended, DefaultCombinatorName, DefaultCombinatorNameExtended, DefaultCombinators, DefaultCombinatorsExtended, DefaultMatchModes, DefaultOperator, DefaultOperatorName, DefaultOperators, DefaultRuleGroupArray, DefaultRuleGroupICArray, DefaultRuleGroupType, DefaultRuleGroupTypeAny, DefaultRuleGroupTypeIC, DefaultRuleOrGroupArray, DefaultRuleType, DndDropTargetType, DragCollection, DraggedItem, DropCollection, DropEffect, DropResult, Except, ExportFormat, ExportObjectFormats, ExportOperatorMap, Field, FieldByValue, FindPathReturnType, Finite, FlexibleOption, FlexibleOptionGroup, FlexibleOptionList, FlexibleOptionListProp, Float, FormatQueryFinalOptions, FormatQueryOptions, FormatQueryValidateRule, FullCombinator, FullField, FullOperator, FullOption, FullOptionList, FullOptionMap, FullOptionRecord, GenericizeRuleGroupType, GetOptionIdentifierType, GetOptionType, GetRuleGroupType, GetRuleTypeFromGroupWithFieldAndOperator, GreaterThan, GreaterThanOrEqual, GroupOptions, GroupVariantCondition, IfAny$1 as IfAny, IfNever$1 as IfNever, InputType, InsertOptions, Integer, IsAny, IsBooleanLiteral, IsEqual, IsFloat, IsInteger, IsLiteral, IsNegative, IsNever, IsNumericLiteral, IsStringLiteral, IsSymbolLiteral, type JsonLogicAll, type JsonLogicAnd, type JsonLogicDoubleNegation, type JsonLogicEqual, type JsonLogicGreaterThan, type JsonLogicGreaterThanOrEqual, type JsonLogicInArray, type JsonLogicInString, type JsonLogicLessThan, type JsonLogicLessThanOrEqual, type JsonLogicNegation, type JsonLogicNone, type JsonLogicNotEqual, type JsonLogicOr, type JsonLogicReservedOperations, type JsonLogicRulesLogic, type JsonLogicSome, type JsonLogicStrictEqual, type JsonLogicStrictNotEqual, type JsonLogicVar, KeysOfUnion, LessThan, LogType, MatchConfig, MatchMode, MatchModeOptions, Merge, MoveOptions, NLTranslationKey, NLTranslations, NameLabelPair, Negative, NegativeFloat, NegativeInfinity, NegativeInteger, NonNegative, NonNegativeInteger, Numeric, OmitIndexSignature, Operator, OperatorByValue, Option, OptionGroup, OptionList, OptionalKeysOf, Or, OverrideProperties, ParameterizedNamedSQL, ParameterizedSQL, ParseNumberMethod, ParseNumberOptions, ParseNumbersPropConfig, Path, PickIndexSignature, PositiveInfinity, PreparerOptions, Primitive, QueryActions, QueryValidator, RQBJsonLogic, RQBJsonLogicEndsWith, RQBJsonLogicStartsWith, RQBJsonLogicVar, RegenerateIdOptions, RemoveNullability, RequireAtLeastOne, RequiredKeysOf, RuleGroupArray, RuleGroupICArray, RuleGroupProcessor, RuleGroupType, RuleGroupTypeAny, RuleGroupTypeIC, RuleOrGroupArray, RuleProcessor, RuleType, RuleValidator, SQLPreset, SetNonNullable, SetOptional, SetRequired, Simplify, StringUnionToFlexibleOptionArray, StringUnionToFullOptionArray, TestID, ToFlexibleOption, ToFullOption, TransformQueryOptions, Trim, UnionToIntersection, UnknownArray, UpdateOptions, UpdateableProperties, ValidationMap, ValidationResult, ValueChangeEventHandler, ValueEditorType, ValueOption, ValueProcessor, ValueProcessorByRule, ValueProcessorLegacy, ValueProcessorOptions, ValueSource, ValueSourceFlexibleOptions, ValueSourceFullOptions, ValueSources, WithRequired, WithUnknownIndex, Writable, Zero, add, bigIntJsonParseReviver, bigIntJsonStringifyReplacer, celCombinatorMap, clsx, convertFromIC, convertQuery, convertToIC, defaultCELValueProcessor, defaultCombinatorLabelMap, defaultCombinators, defaultCombinatorsExtended, defaultControlClassnames, defaultExportOperatorMap, defaultJoinChar, defaultMatchModes, defaultMongoDBValueProcessor, defaultNLTranslations, defaultOperatorLabelMap, defaultOperatorNegationMap, defaultOperatorProcessorNL, defaultOperatorProcessorSQL, defaultOperators, defaultPlaceholderFieldGroupLabel, defaultPlaceholderFieldLabel, defaultPlaceholderFieldName, defaultPlaceholderLabel, defaultPlaceholderName, defaultPlaceholderOperatorGroupLabel, defaultPlaceholderOperatorLabel, defaultPlaceholderOperatorName, defaultPlaceholderValueGroupLabel, defaultPlaceholderValueLabel, defaultPlaceholderValueName, defaultRuleGroupProcessorCEL, defaultRuleGroupProcessorDrizzle, defaultRuleGroupProcessorElasticSearch, defaultRuleGroupProcessorJSONata, defaultRuleGroupProcessorJsonLogic, defaultRuleGroupProcessorLDAP, defaultRuleGroupProcessorMongoDB, defaultRuleGroupProcessorMongoDBQuery, defaultRuleGroupProcessorNL, defaultRuleGroupProcessorParameterized, defaultRuleGroupProcessorPrisma, defaultRuleGroupProcessorSQL, defaultRuleGroupProcessorSequelize, defaultRuleGroupProcessorSpEL, defaultRuleProcessorCEL, defaultRuleProcessorDrizzle, defaultRuleProcessorElasticSearch, defaultRuleProcessorJSONata, defaultRuleProcessorJsonLogic, defaultRuleProcessorLDAP, defaultRuleProcessorMongoDB, defaultRuleProcessorMongoDBQuery, defaultRuleProcessorNL, defaultRuleProcessorParameterized, defaultRuleProcessorPrisma, defaultRuleProcessorSQL, defaultRuleProcessorSequelize, defaultRuleProcessorSpEL, defaultSpELValueProcessor, defaultValidator, defaultValueProcessor, defaultValueProcessorByRule, defaultValueProcessorCELByRule, defaultValueProcessorMongoDBByRule, defaultValueProcessorNL, defaultValueProcessorSpELByRule, filterFieldsByComparator, findID, findPath, formatQuery, formatQueryOptionPresets, generateAccessibleDescription, generateID, getCommonAncestorPath, getFirstOption, getMatchModesUtil, getNLTranslataion, getOption, getParentPath, getParseNumberMethod, getPathOfID, getQuoteFieldNamesWithArray, getQuotedFieldName, getValidationClassNames, getValueSourcesUtil, group, groupInvalidReasons, insert, isAncestor, isFlexibleOptionArray, isFlexibleOptionGroupArray, isFullOptionArray, isFullOptionGroupArray, isOptionGroupArray, isPojo, isRuleGroup, isRuleGroupType, isRuleGroupTypeIC, isRuleOrGroupValid, isValidValue, isValidationResult, isValueProcessorLegacy, joinWith, jsonLogicAdditionalOperators, lc, mapSQLOperator, mergeClassnames, mongoDbFallback, mongoOperators, move, normalizeConstituentWordOrder, nullFreeArray, nullOrUndefinedOrEmpty, numericRegex, numerifyValues, objectEntries, objectKeys, parseNumber, pathIsDisabled, pathsAreEqual, prepareRule, prepareRuleGroup, prepareRuleOrGroup, prismaFallback, prismaOperators, processMatchMode, regenerateID, regenerateIDs, remove, rootPath, shouldRenderAsNumber, splitBy, sqlDialectPresets, standardClassnames, toArray, toFlatOptionArray, toFullOption, toFullOptionList, toFullOptionMap, transformQuery, trimIfString, uniqByIdentifier, uniqByName, uniqOptGroups, uniqOptList, update };
+export { AccessibleDescriptionGenerator, ActionElementEventHandler, AddOptions, And, Arity, BaseFullOption, BaseOption, BaseOptionMap, Classname, Classnames, Combinator, CombinatorByValue, CommonRuleAndGroupProperties, CommonRuleSubComponentProps, ConstituentWordOrder, ConstituentWordOrderString, DefaultCombinator, DefaultCombinatorExtended, DefaultCombinatorName, DefaultCombinatorNameExtended, DefaultCombinators, DefaultCombinatorsExtended, DefaultMatchModes, DefaultOperator, DefaultOperatorName, DefaultOperators, DefaultRuleGroupArray, DefaultRuleGroupICArray, DefaultRuleGroupType, DefaultRuleGroupTypeAny, DefaultRuleGroupTypeIC, DefaultRuleOrGroupArray, DefaultRuleType, DndDropTargetType, DragCollection, DraggedItem, DropCollection, DropEffect, DropResult, Except, ExportFormat, ExportObjectFormats, ExportOperatorMap, Field, FieldByValue, FindPathReturnType, Finite, FlexibleOption, FlexibleOptionGroup, FlexibleOptionList, FlexibleOptionListProp, Float, FormatQueryFinalOptions, FormatQueryOptions, FormatQueryValidateRule, FullCombinator, FullField, FullOperator, FullOption, FullOptionList, FullOptionMap, FullOptionRecord, GenericizeRuleGroupType, GetOptionIdentifierType, GetOptionType, GetRuleGroupType, GetRuleTypeFromGroupWithFieldAndOperator, GreaterThan, GreaterThanOrEqual, GroupOptions, GroupVariantCondition, IfAny$1 as IfAny, IfNever$1 as IfNever, InputType, InsertOptions, Integer, IsAny, IsBooleanLiteral, IsEqual, IsFloat, IsInteger, IsLiteral, IsNegative, IsNever, IsNumericLiteral, IsStringLiteral, IsSymbolLiteral, type JsonLogicAll, type JsonLogicAnd, type JsonLogicDoubleNegation, type JsonLogicEqual, type JsonLogicGreaterThan, type JsonLogicGreaterThanOrEqual, type JsonLogicInArray, type JsonLogicInString, type JsonLogicLessThan, type JsonLogicLessThanOrEqual, type JsonLogicNegation, type JsonLogicNone, type JsonLogicNotEqual, type JsonLogicOr, type JsonLogicReservedOperations, type JsonLogicRulesLogic, type JsonLogicSome, type JsonLogicStrictEqual, type JsonLogicStrictNotEqual, type JsonLogicVar, KeysOfUnion, LessThan, LogType, MatchConfig, MatchMode, MatchModeOptions, Merge, MoveOptions, NLTranslationKey, NLTranslations, NameLabelPair, Negative, NegativeFloat, NegativeInfinity, NegativeInteger, NonNegative, NonNegativeInteger, Numeric, OmitIndexSignature, Operator, OperatorByValue, Option, OptionGroup, OptionList, OptionalKeysOf, Or, OverrideProperties, ParameterizedNamedSQL, ParameterizedSQL, ParseNumberMethod, ParseNumberOptions, ParseNumbersPropConfig, Path, PickIndexSignature, PositiveInfinity, PreparerOptions, Primitive, QueryActions, QueryValidator, RQBJsonLogic, RQBJsonLogicEndsWith, RQBJsonLogicStartsWith, RQBJsonLogicVar, RegenerateIdOptions, RemoveNullability, RequireAtLeastOne, RequiredKeysOf, RuleGroupArray, RuleGroupICArray, RuleGroupProcessor, RuleGroupType, RuleGroupTypeAny, RuleGroupTypeIC, RuleOrGroupArray, RuleProcessor, RuleType, RuleValidator, SQLPreset, SetNonNullable, SetOptional, SetRequired, Simplify, StringUnionToFlexibleOptionArray, StringUnionToFullOptionArray, TestID, ToFlexibleOption, ToFullOption, TransformQueryOptions, Trim, UnionToIntersection, UnknownArray, UpdateOptions, UpdateableProperties, ValidationMap, ValidationResult, ValueChangeEventHandler, ValueEditorType, ValueOption, ValueProcessor, ValueProcessorByRule, ValueProcessorLegacy, ValueProcessorOptions, ValueSource, ValueSourceFlexibleOptions, ValueSourceFullOptions, ValueSources, WithRequired, WithUnknownIndex, Writable, Zero, add, bigIntJsonParseReviver, bigIntJsonStringifyReplacer, celCombinatorMap, clsx, convertFromIC, convertQuery, convertToIC, defaultCELValueProcessor, defaultCombinatorLabelMap, defaultCombinators, defaultCombinatorsExtended, defaultControlClassnames, defaultExportOperatorMap, defaultJoinChar, defaultMatchModes, defaultMongoDBValueProcessor, defaultNLTranslations, defaultOperatorLabelMap, defaultOperatorNegationMap, defaultOperatorProcessorNL, defaultOperatorProcessorSQL, defaultOperators, defaultPlaceholderFieldGroupLabel, defaultPlaceholderFieldLabel, defaultPlaceholderFieldName, defaultPlaceholderLabel, defaultPlaceholderName, defaultPlaceholderOperatorGroupLabel, defaultPlaceholderOperatorLabel, defaultPlaceholderOperatorName, defaultPlaceholderValueGroupLabel, defaultPlaceholderValueLabel, defaultPlaceholderValueName, defaultRuleGroupProcessorCEL, defaultRuleGroupProcessorDrizzle, defaultRuleGroupProcessorElasticSearch, defaultRuleGroupProcessorJSONata, defaultRuleGroupProcessorJsonLogic, defaultRuleGroupProcessorLDAP, defaultRuleGroupProcessorMongoDB, defaultRuleGroupProcessorMongoDBQuery, defaultRuleGroupProcessorNL, defaultRuleGroupProcessorParameterized, defaultRuleGroupProcessorPrisma, defaultRuleGroupProcessorSQL, defaultRuleGroupProcessorSequelize, defaultRuleGroupProcessorSpEL, defaultRuleProcessorCEL, defaultRuleProcessorDrizzle, defaultRuleProcessorElasticSearch, defaultRuleProcessorJSONata, defaultRuleProcessorJsonLogic, defaultRuleProcessorLDAP, defaultRuleProcessorMongoDB, defaultRuleProcessorMongoDBQuery, defaultRuleProcessorNL, defaultRuleProcessorParameterized, defaultRuleProcessorPrisma, defaultRuleProcessorSQL, defaultRuleProcessorSequelize, defaultRuleProcessorSpEL, defaultSpELValueProcessor, defaultValidator, defaultValueProcessor, defaultValueProcessorByRule, defaultValueProcessorCELByRule, defaultValueProcessorMongoDBByRule, defaultValueProcessorNL, defaultValueProcessorSpELByRule, filterFieldsByComparator, findID, findPath, formatQuery, formatQueryOptionPresets, generateAccessibleDescription, generateID, getCommonAncestorPath, getFirstOption, getMatchModesUtil, getNLTranslataion, getOption, getParentPath, getParseNumberMethod, getPathOfID, getQuoteFieldNamesWithArray, getQuotedFieldName, getValidationClassNames, getValueSourcesUtil, group, groupInvalidReasons, insert, isAncestor, isFlexibleOptionArray, isFlexibleOptionGroupArray, isFullOptionArray, isFullOptionGroupArray, isOptionGroupArray, isPojo, isRuleGroup, isRuleGroupType, isRuleGroupTypeIC, isRuleOrGroupValid, isRuleType, isValidValue, isValidationResult, isValueProcessorLegacy, joinWith, jsonLogicAdditionalOperators, lc, mapSQLOperator, mergeClassnames, mongoDbFallback, mongoOperators, move, normalizeConstituentWordOrder, nullFreeArray, nullOrUndefinedOrEmpty, numericRegex, numerifyValues, objectEntries, objectKeys, parseNumber, pathIsDisabled, pathsAreEqual, prepareRule, prepareRuleGroup, prepareRuleOrGroup, prismaFallback, prismaOperators, processMatchMode, regenerateID, regenerateIDs, remove, rootPath, shouldRenderAsNumber, splitBy, sqlDialectPresets, standardClassnames, toArray, toFlatOptionArray, toFullOption, toFullOptionList, toFullOptionMap, transformQuery, trimIfString, uniqByIdentifier, uniqByName, uniqOptGroups, uniqOptList, update };
 //# sourceMappingURL=react-querybuilder_core.d.mts.map