@react-querybuilder/core 8.11.1 → 8.12.0

package/dist/parseCEL.mjs

@@ -1,7 +1,6 @@
-import { l as defaultOperatorNegationMap } from "./optGroupUtils-VeZ3k7-1.mjs";
-import { t as joinWith } from "./arrayUtils-A_OXU9W1.mjs";
-import { t as isRuleGroup } from "./isRuleGroup-CYcfPgbg.mjs";
-import { n as fieldIsValidUtil, r as getFieldsArray, t as prepareRuleGroup } from "./prepareQueryObjects-DPCC-iHp.mjs";
+import { A as defaultOperatorNegationMap, D as joinWith } from "./utils-DxH23QtE.mjs";
+import { t as isRuleGroup } from "./isRuleGroup-BcfwGaIN.mjs";
+import { n as fieldIsValidUtil, r as getFieldsArray, t as prepareRuleGroup } from "./prepareQueryObjects-BfnyRV5t.mjs";
 import { JisonParser } from "@ts-jison/parser";
 import { JisonLexer } from "@ts-jison/lexer";
 
@@ -2058,14 +2057,39 @@ const isCELProperty = (expr) => expr.type === "Property";
 // istanbul ignore next
 const isCELSubtraction = (expr) => expr.type === "Subtraction";
 const isCELUnsignedIntegerLiteral = (expr) => expr.type === "UnsignedIntegerLiteral";
-const isCELIdentifierOrChain = (expr) => isCELIdentifier(expr) || isCELMember(expr) && !!expr.left && !!expr.right && !expr.list && !expr.value && isCELIdentifierOrChain(expr.left) && isCELIdentifier(expr.right);
+const isCELIdentifierOrChain = (expr) => isCELIdentifier(expr) || isCELDynamicPropertyAccessor(expr) || isCELMember(expr) && !!expr.left && !!expr.right && !expr.list && !expr.value && isCELIdentifierOrChain(expr.left) && isCELIdentifier(expr.right);
 const isCELNegatedIdentifier = (expr) => isCELNegation(expr) && isCELIdentifier(expr.value);
 const isCELNegatedIdentifierOrChain = (expr) => isCELNegatedIdentifier(expr) || isCELMember(expr) && !!expr.left && !!expr.right && !expr.list && !expr.value && isCELIdentifierOrChain(expr.right) && isCELNegatedIdentifier(expr.left);
 const isCELLikeExpression = (expr) => isCELMember(expr) && !!expr.left && !!expr.right && !!expr.list && isCELIdentifierOrChain(expr.left) && isCELIdentifier(expr.right) && (expr.right.value === "contains" || expr.right.value === "startsWith" || expr.right.value === "endsWith") && expr.list.value.length === 1 && (isCELStringLiteral(expr.list.value[0]) || isCELIdentifier(expr.list.value[0]));
 const isCELNegatedLikeExpression = (expr) => isCELMember(expr) && !!expr.left && !!expr.right && !!expr.list && isCELNegatedIdentifierOrChain(expr.left) && isCELIdentifier(expr.right) && (expr.right.value === "contains" || expr.right.value === "startsWith" || expr.right.value === "endsWith") && expr.list.value.length === 1 && (isCELStringLiteral(expr.list.value[0]) || isCELIdentifier(expr.list.value[0]));
+const isCELSubqueryExpression = (expr) => isCELMember(expr) && !!expr.left && !!expr.right && !!expr.list && isCELIdentifierOrChain(expr.left) && isCELIdentifier(expr.right) && (expr.right.value === "all" || expr.right.value === "exists") && expr.list.value.length >= 2;
+const isCELNegatedSubqueryExpression = (expr) => isCELMember(expr) && !!expr.left && !!expr.right && !!expr.list && isCELNegatedIdentifierOrChain(expr.left) && isCELIdentifier(expr.right) && (expr.right.value === "all" || expr.right.value === "exists") && expr.list.value.length >= 2;
+const extractSubqueryComponents = (expr) => {
+	// istanbul ignore next
+	if (!isCELSubqueryExpression(expr)) return null;
+	const field = getCELIdentifierFromChain(expr.left);
+	const method = expr.right.value;
+	const [aliasExpr, conditionExpr] = expr.list.value;
+	return {
+		field,
+		method,
+		alias: isCELIdentifier(aliasExpr) ? aliasExpr.value : null,
+		condition: conditionExpr
+	};
+};
 const getCELIdentifierFromChain = (expr) => {
 	if (isCELIdentifier(expr)) return expr.value;
-	return `${getCELIdentifierFromChain(expr.left)}.${expr.right.value}`;
+	if (isCELDynamicPropertyAccessor(expr)) {
+		const leftField = getCELIdentifierFromChain(expr.left);
+		// istanbul ignore else
+		if (isCELStringLiteral(expr.right)) return `${leftField}["${evalCELLiteralValue(expr.right)}"]`;
+		// istanbul ignore next
+		return `${leftField}[${expr.right.type}]`;
+	}
+	// istanbul ignore else
+	if (expr.left && expr.right && isCELIdentifier(expr.right) && (isCELIdentifier(expr.left) || isCELMember(expr.left) || isCELDynamicPropertyAccessor(expr.left))) return `${getCELIdentifierFromChain(expr.left)}.${expr.right.value}`;
+	// istanbul ignore next
+	return expr.type;
 };
 const getCELIdentifierFromNegatedChain = (expr) => {
 	if (isCELNegatedIdentifier(expr)) return `${``.padStart(expr.negations, `!`)}${expr.value.value}`;
@@ -2128,6 +2152,102 @@ const celGenerateMixedAndOrList = (expr) => {
 	if (returnArray.length === 1 && Array.isArray(returnArray[0])) return returnArray[0];
 	return returnArray;
 };
+const isPrimitiveArrayUsage = (expr, alias) => {
+	// istanbul ignore next
+	if (!alias) return false;
+	if (isCELIdentifier(expr) && expr.value === alias) return true;
+	if (isCELLikeExpression(expr) && isCELIdentifier(expr.left) && expr.left.value === alias) return true;
+	if (isCELRelation(expr) || isCELConditionalAnd(expr) || isCELConditionalOr(expr)) return isPrimitiveArrayUsage(expr.left, alias) || isPrimitiveArrayUsage(expr.right, alias);
+	// istanbul ignore next
+	if (isCELExpressionGroup(expr) || isCELNegation(expr)) return isPrimitiveArrayUsage(expr.value, alias);
+	return false;
+};
+const transformAliasInExpressionInternal = (expr, alias, isPrimitive) => {
+	// istanbul ignore next
+	if (!alias) return expr;
+	if (isCELIdentifier(expr) && expr.value === alias) return {
+		type: "Identifier",
+		value: ""
+	};
+	if (isCELMember(expr) && expr.left && isCELIdentifier(expr.left) && expr.left.value === alias) {
+		if (expr.right && isCELIdentifier(expr.right) && !isPrimitive) {
+			if (expr.list) return {
+				type: "Member",
+				left: {
+					type: "Identifier",
+					value: ""
+				},
+				right: expr.right,
+				list: expr.list
+			};
+			return expr.right;
+		}
+	}
+	if (isCELLikeExpression(expr) && isCELIdentifier(expr.left) && expr.left.value === alias) return {
+		type: "Member",
+		left: {
+			type: "Identifier",
+			value: ""
+		},
+		right: expr.right,
+		list: expr.list
+	};
+	if (isCELNegatedLikeExpression(expr) && expr.left && isCELNegatedIdentifier(expr.left) && expr.left.value.value === alias) return {
+		type: "Member",
+		left: {
+			type: "Negation",
+			negations: expr.left.negations,
+			value: {
+				type: "Identifier",
+				value: ""
+			}
+		},
+		right: expr.right,
+		list: expr.list
+	};
+	if (isCELMember(expr) && expr.left && expr.right) {
+		const transformedLeft = transformAliasInExpressionInternal(expr.left, alias, isPrimitive);
+		// istanbul ignore else
+		if (transformedLeft !== expr.left) return {
+			type: "Member",
+			left: transformedLeft,
+			right: expr.right,
+			list: expr.list,
+			value: expr.value
+		};
+	}
+	if (isCELRelation(expr)) return {
+		type: "Relation",
+		left: transformAliasInExpressionInternal(expr.left, alias, isPrimitive),
+		right: transformAliasInExpressionInternal(expr.right, alias, isPrimitive),
+		operator: expr.operator
+	};
+	if (isCELConditionalAnd(expr)) return {
+		type: "ConditionalAnd",
+		left: transformAliasInExpressionInternal(expr.left, alias, isPrimitive),
+		right: transformAliasInExpressionInternal(expr.right, alias, isPrimitive)
+	};
+	if (isCELConditionalOr(expr)) return {
+		type: "ConditionalOr",
+		left: transformAliasInExpressionInternal(expr.left, alias, isPrimitive),
+		right: transformAliasInExpressionInternal(expr.right, alias, isPrimitive)
+	};
+	if (isCELExpressionGroup(expr)) return {
+		type: "ExpressionGroup",
+		value: transformAliasInExpressionInternal(expr.value, alias, isPrimitive)
+	};
+	if (isCELNegation(expr)) return {
+		type: "Negation",
+		negations: expr.negations,
+		value: transformAliasInExpressionInternal(expr.value, alias, isPrimitive)
+	};
+	return expr;
+};
+const transformAliasInExpression = (expr, alias) => {
+	// istanbul ignore next
+	if (!alias) return expr;
+	return transformAliasInExpressionInternal(expr, alias, isPrimitiveArrayUsage(expr, alias));
+};
 
 //#endregion
 //#region src/utils/parseCEL/parseCEL.ts
@@ -2226,6 +2346,52 @@ function parseCEL(cel, options = {}) {
 				operator,
 				value
 			};
+		} else if (isCELSubqueryExpression(expr)) {
+			const components = extractSubqueryComponents(expr);
+			// istanbul ignore else
+			if (components) {
+				const { field, method, alias, condition } = components;
+				const matchMode = method === "all" ? "all" : "some";
+				const subqueryValue = processCELExpression(transformAliasInExpression(condition, alias));
+				if (subqueryValue && fieldIsValid(field, "=")) {
+					const ruleGroupValue = isRuleGroup(subqueryValue) ? subqueryValue : ic ? { rules: [subqueryValue] } : {
+						combinator: "and",
+						rules: [subqueryValue]
+					};
+					return {
+						field,
+						operator: "=",
+						match: { mode: matchMode },
+						value: ruleGroupValue
+					};
+				}
+			}
+		} else if (isCELNegatedSubqueryExpression(expr)) {
+			const field = getCELIdentifierFromNegatedChain(expr.left).replace(/^!+/, "");
+			const method = expr.right.value;
+			const [aliasExpr, conditionExpr] = expr.list.value;
+			const subqueryValue = processCELExpression(transformAliasInExpression(conditionExpr, isCELIdentifier(aliasExpr) ? aliasExpr.value : null));
+			// istanbul ignore else
+			if (subqueryValue && fieldIsValid(field, "=")) {
+				const ruleGroupValue = isRuleGroup(subqueryValue) ? subqueryValue : ic ? { rules: [subqueryValue] } : {
+					combinator: "and",
+					rules: [subqueryValue]
+				};
+				const subqueryRule = {
+					field,
+					operator: "=",
+					match: { mode: method === "all" ? "all" : "some" },
+					value: ruleGroupValue
+				};
+				return ic ? {
+					not: true,
+					rules: [subqueryRule]
+				} : {
+					combinator: "and",
+					not: true,
+					rules: [subqueryRule]
+				};
+			}
 		} else if (isCELRelation(expr)) {
 			let field = null;
 			let value = void 0;
@@ -2258,7 +2424,7 @@ function parseCEL(cel, options = {}) {
 				if (keys.every((k) => isCELLiteral(k) || isCELIdentifierOrChain(k))) value = keys.map((k) => isCELLiteral(k) ? evalCELLiteralValue(k) : getCELIdentifierFromChain(k));
 				if (value && !listsAsArrays) value = joinWith(value.map((v) => `${v}`), ",");
 			}
-			if (field && fieldIsValid(field, operator, valueSource === "field" ? value : void 0) && value !== void 0) return valueSource ? {
+			if (field !== null && fieldIsValid(field, operator, valueSource === "field" ? value : void 0) && value !== void 0) return valueSource ? {
 				field,
 				operator,
 				value,
@@ -2291,5 +2457,5 @@ function parseCEL(cel, options = {}) {
 }
 
 //#endregion
-export { celGenerateFlatAndOrList, celGenerateMixedAndOrList, celNormalizeCombinator, celNormalizeOperator, evalCELLiteralValue, getCELIdentifierFromChain, getCELIdentifierFromNegatedChain, isCELAddition, isCELBooleanLiteral, isCELBytesLiteral, isCELConditionalAnd, isCELConditionalExpr, isCELConditionalOr, isCELDivision, isCELDynamicPropertyAccessor, isCELExpressionGroup, isCELExpressionList, isCELFieldInit, isCELFieldInits, isCELFieldsObject, isCELFloatLiteral, isCELFunctionCall, isCELIdentifier, isCELIdentifierOrChain, isCELIntegerLiteral, isCELLikeExpression, isCELList, isCELLiteral, isCELMap, isCELMapInit, isCELMapInits, isCELMember, isCELModulo, isCELMultiplication, isCELNegatedIdentifier, isCELNegatedIdentifierOrChain, isCELNegatedLikeExpression, isCELNegation, isCELNegative, isCELNullLiteral, isCELNumericLiteral, isCELProperty, isCELRelation, isCELStringLiteral, isCELSubtraction, isCELUnsignedIntegerLiteral, parseCEL };
+export { celGenerateFlatAndOrList, celGenerateMixedAndOrList, celNormalizeCombinator, celNormalizeOperator, evalCELLiteralValue, extractSubqueryComponents, getCELIdentifierFromChain, getCELIdentifierFromNegatedChain, isCELAddition, isCELBooleanLiteral, isCELBytesLiteral, isCELConditionalAnd, isCELConditionalExpr, isCELConditionalOr, isCELDivision, isCELDynamicPropertyAccessor, isCELExpressionGroup, isCELExpressionList, isCELFieldInit, isCELFieldInits, isCELFieldsObject, isCELFloatLiteral, isCELFunctionCall, isCELIdentifier, isCELIdentifierOrChain, isCELIntegerLiteral, isCELLikeExpression, isCELList, isCELLiteral, isCELMap, isCELMapInit, isCELMapInits, isCELMember, isCELModulo, isCELMultiplication, isCELNegatedIdentifier, isCELNegatedIdentifierOrChain, isCELNegatedLikeExpression, isCELNegatedSubqueryExpression, isCELNegation, isCELNegative, isCELNullLiteral, isCELNumericLiteral, isCELProperty, isCELRelation, isCELStringLiteral, isCELSubqueryExpression, isCELSubtraction, isCELUnsignedIntegerLiteral, parseCEL, transformAliasInExpression };
 //# sourceMappingURL=parseCEL.mjs.map