@react-querybuilder/core 8.9.2 → 8.10.0

package/dist/parseCEL.mjs

@@ -1,7 +1,7 @@
-import { defaultOperatorNegationMap, 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 { defaultOperatorNegationMap } from "./optGroupUtils-DrubUpx0.mjs";
+import { joinWith } from "./arrayUtils-C9sO4qLO.mjs";
+import { isRuleGroup } from "./isRuleGroup-CGe_rb2w.mjs";
+import { fieldIsValidUtil, getFieldsArray, prepareRuleGroup } from "./prepareQueryObjects-CJNpnGcJ.mjs";
 
 //#region src/utils/parseCEL/celParser.js
 var celParser = (function() {
@@ -2349,26 +2349,64 @@ const isCELExpressionGroup = (expr) => expr.type === "ExpressionGroup";
 const isCELConditionalAnd = (expr) => expr.type === "ConditionalAnd";
 const isCELConditionalOr = (expr) => expr.type === "ConditionalOr";
 const isCELStringLiteral = (expr) => expr.type === "StringLiteral";
-const isCELLiteral = (expr) => isCELNumericLiteral(expr) || isCELStringLiteral(expr) || expr.type === "BooleanLiteral" || expr.type === "NullLiteral" || expr.type === "BytesLiteral";
-const isCELNumericLiteral = (expr) => expr.type === "FloatLiteral" || expr.type === "IntegerLiteral" || expr.type === "UnsignedIntegerLiteral";
+const isCELLiteral = (expr) => isCELNumericLiteral(expr) || isCELStringLiteral(expr) || isCELBooleanLiteral(expr) || isCELNullLiteral(expr) || isCELBytesLiteral(expr);
+const isCELNumericLiteral = (expr) => isCELFloatLiteral(expr) || isCELIntegerLiteral(expr) || isCELUnsignedIntegerLiteral(expr);
 const isCELRelation = (expr) => expr.type === "Relation";
 const isCELList = (expr) => expr.type === "List";
 const isCELMap = (expr) => expr.type === "Map";
 const isCELIdentifier = (expr) => expr.type === "Identifier";
 const isCELNegation = (expr) => expr.type === "Negation";
 const isCELMember = (expr) => expr.type === "Member";
+// istanbul ignore next
+const isCELAddition = (expr) => expr.type === "Addition";
+const isCELBooleanLiteral = (expr) => expr.type === "BooleanLiteral";
+const isCELBytesLiteral = (expr) => expr.type === "BytesLiteral";
+// istanbul ignore next
+const isCELConditionalExpr = (expr) => expr.type === "ConditionalExpr";
+// istanbul ignore next
+const isCELDivision = (expr) => expr.type === "Division";
+// istanbul ignore next
+const isCELDynamicPropertyAccessor = (expr) => expr.type === "DynamicPropertyAccessor";
+// istanbul ignore next
+const isCELExpressionList = (expr) => expr.type === "ExpressionList";
+// istanbul ignore next
+const isCELFieldInit = (expr) => expr.type === "FieldInit";
+// istanbul ignore next
+const isCELFieldInits = (expr) => expr.type === "FieldInits";
+// istanbul ignore next
+const isCELFieldsObject = (expr) => expr.type === "FieldsObject";
+const isCELFloatLiteral = (expr) => expr.type === "FloatLiteral";
+// istanbul ignore next
+const isCELFunctionCall = (expr) => expr.type === "FunctionCall";
+const isCELIntegerLiteral = (expr) => expr.type === "IntegerLiteral";
+// istanbul ignore next
+const isCELMapInit = (expr) => expr.type === "MapInit";
+// istanbul ignore next
+const isCELMapInits = (expr) => expr.type === "MapInits";
+// istanbul ignore next
+const isCELModulo = (expr) => expr.type === "Modulo";
+// istanbul ignore next
+const isCELMultiplication = (expr) => expr.type === "Multiplication";
+// istanbul ignore next
+const isCELNegative = (expr) => expr.type === "Negative";
+const isCELNullLiteral = (expr) => expr.type === "NullLiteral";
+// istanbul ignore next
+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 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 getIdentifierFromChain = (expr) => {
+const getCELIdentifierFromChain = (expr) => {
 	if (isCELIdentifier(expr)) return expr.value;
-	return `${getIdentifierFromChain(expr.left)}.${expr.right.value}`;
+	return `${getCELIdentifierFromChain(expr.left)}.${expr.right.value}`;
 };
-const getIdentifierFromNegatedChain = (expr) => {
+const getCELIdentifierFromNegatedChain = (expr) => {
 	if (isCELNegatedIdentifier(expr)) return `${``.padStart(expr.negations, `!`)}${expr.value.value}`;
-	return `${getIdentifierFromNegatedChain(expr.left)}.${expr.right.value}`;
+	return `${getCELIdentifierFromNegatedChain(expr.left)}.${expr.right.value}`;
 };
 function evalCELLiteralValue(literal) {
 	switch (literal.type) {
@@ -2379,8 +2417,8 @@ function evalCELLiteralValue(literal) {
 		default: return literal.value;
 	}
 }
-const normalizeCombinator = (c) => c === "||" ? "or" : "and";
-const normalizeOperator = (op, flip) => {
+const celNormalizeCombinator = (c) => c === "||" ? "or" : "and";
+const celNormalizeOperator = (op, flip) => {
 	if (flip) {
 		if (op === "<") return ">";
 		if (op === "<=") return ">=";
@@ -2390,11 +2428,11 @@ const normalizeOperator = (op, flip) => {
 	if (op === "==") return "=";
 	return op;
 };
-const generateFlatAndOrList = (expr) => {
-	const combinator = normalizeCombinator(expr.type === "ConditionalAnd" ? "&&" : "||");
+const celGenerateFlatAndOrList = (expr) => {
+	const combinator = celNormalizeCombinator(expr.type === "ConditionalAnd" ? "&&" : "||");
 	const { left, right } = expr;
 	if (isCELConditionalAnd(left) || isCELConditionalOr(left)) return [
-		...generateFlatAndOrList(left),
+		...celGenerateFlatAndOrList(left),
 		combinator,
 		right
 	];
@@ -2404,8 +2442,8 @@ const generateFlatAndOrList = (expr) => {
 		right
 	];
 };
-const generateMixedAndOrList = (expr) => {
-	const arr = generateFlatAndOrList(expr);
+const celGenerateMixedAndOrList = (expr) => {
+	const arr = celGenerateFlatAndOrList(expr);
 	const returnArray = [];
 	let startIndex = 0;
 	for (let i = 0; i < arr.length; i += 2) if (arr[i + 1] === "and") {
@@ -2431,7 +2469,7 @@ const generateMixedAndOrList = (expr) => {
 //#endregion
 //#region src/utils/parseCEL/parseCEL.ts
 function parseCEL(cel, options = {}) {
-	const { fields, independentCombinators, listsAsArrays } = options;
+	const { fields, independentCombinators, listsAsArrays, customExpressionHandler } = options;
 	const ic = !!independentCombinators;
 	const fieldsFlat = getFieldsArray(fields);
 	const fieldIsValid = (fieldName, operator, subordinateFieldName) => fieldIsValidUtil({
@@ -2449,12 +2487,12 @@ function parseCEL(cel, options = {}) {
 		const { forwardNegation: forwardedNegation, groupOnlyIfNecessary } = processOpts;
 		/* istanbul ignore if */
 		if (isCELNegation(expr) || isCELNegatedLikeExpression(expr)) {
-			const negate = isCELNegation(expr) ? expr.negations % 2 === 1 : (getIdentifierFromNegatedChain(expr.left).match(/^!+/)?.[0].length ?? 0) % 2 === 1;
+			const negate = isCELNegation(expr) ? expr.negations % 2 === 1 : (getCELIdentifierFromNegatedChain(expr.left).match(/^!+/)?.[0].length ?? 0) % 2 === 1;
 			const negatedExpr = isCELNegation(expr) && isCELExpressionGroup(expr.value) && isCELLikeExpression(expr.value.value) ? processCELExpression(expr.value.value, { forwardNegation: negate }) : isCELNegatedLikeExpression(expr) ? processCELExpression({
 				...expr,
 				left: {
 					type: "Identifier",
-					value: getIdentifierFromNegatedChain(expr.left).replace(/^!+/, "")
+					value: getCELIdentifierFromNegatedChain(expr.left).replace(/^!+/, "")
 				}
 			}, { forwardNegation: negate }) : isCELNegation(expr) && isCELExpressionGroup(expr.value) && isCELRelation(expr.value.value) ? processCELExpression(expr.value.value, { forwardNegation: negate }) : processCELExpression(expr.value, {
 				groupOnlyIfNecessary: true,
@@ -2486,14 +2524,14 @@ function parseCEL(cel, options = {}) {
 			}
 		} else if (isCELConditionalAnd(expr) || isCELConditionalOr(expr)) {
 			if (ic) {
-				const rules$1 = generateFlatAndOrList(expr).map((v) => {
+				const rules$1 = celGenerateFlatAndOrList(expr).map((v) => {
 					if (typeof v === "string") return v;
 					return processCELExpression(v);
 				});
 				if (!rules$1.every(Boolean)) return null;
 				return { rules: rules$1 };
 			}
-			const andOrList = generateMixedAndOrList(expr);
+			const andOrList = celGenerateMixedAndOrList(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 {
@@ -2508,7 +2546,7 @@ function parseCEL(cel, options = {}) {
 				rules
 			};
 		} else if (isCELLikeExpression(expr)) {
-			const field = getIdentifierFromChain(expr.left);
+			const field = getCELIdentifierFromChain(expr.left);
 			const func = expr.right.value;
 			const operatorPre = func === "startsWith" ? "beginsWith" : func;
 			const operator = forwardedNegation ? `doesNot${operatorPre[0].toUpperCase()}${operatorPre.slice(1).replace("s", "")}` : operatorPre;
@@ -2532,29 +2570,29 @@ function parseCEL(cel, options = {}) {
 			let flip = false;
 			const { left, right } = expr;
 			if (isCELIdentifierOrChain(left)) {
-				field = getIdentifierFromChain(left);
+				field = getCELIdentifierFromChain(left);
 				if (isCELIdentifierOrChain(right)) {
-					value = getIdentifierFromChain(right);
+					value = getCELIdentifierFromChain(right);
 					valueSource = "field";
 				} else if (isCELLiteral(right)) value = evalCELLiteralValue(right);
 			} else if (isCELIdentifierOrChain(right) && isCELLiteral(left) && expr.operator !== "in") {
 				flip = true;
-				field = getIdentifierFromChain(right);
+				field = getCELIdentifierFromChain(right);
 				value = evalCELLiteralValue(left);
 			}
-			let operator = normalizeOperator(expr.operator, flip);
+			let operator = celNormalizeOperator(expr.operator, flip);
 			if (forwardedNegation) operator = defaultOperatorNegationMap[operator];
 			if (value === null && (operator === "=" || operator === "!=")) operator = operator === "=" ? "null" : "notNull";
 			else if ((operator === "in" || operator === "notIn") && isCELList(right)) {
 				if (right.value.value.every((v) => isCELLiteral(v))) value = right.value.value.map((v) => evalCELLiteralValue(v));
 				else if (right.value.value.every((v) => isCELIdentifierOrChain(v))) {
 					valueSource = "field";
-					value = right.value.value.map((id) => getIdentifierFromChain(id));
+					value = right.value.value.map((id) => getCELIdentifierFromChain(id));
 				}
 				if (value && !listsAsArrays) value = joinWith(value.map((v) => `${v}`), ",");
 			} else if ((operator === "in" || operator === "notIn") && isCELMap(right)) {
 				const keys = right.value.value.map((v) => v.left);
-				if (keys.every((k) => isCELLiteral(k) || isCELIdentifierOrChain(k))) value = keys.map((k) => isCELLiteral(k) ? evalCELLiteralValue(k) : getIdentifierFromChain(k));
+				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 ? {
@@ -2567,7 +2605,7 @@ function parseCEL(cel, options = {}) {
 				operator,
 				value
 			};
-		}
+		} else if (customExpressionHandler) return customExpressionHandler(expr);
 		return null;
 	};
 	const prepare = options.generateIDs ? prepareRuleGroup : (g) => g;
@@ -2589,5 +2627,5 @@ function parseCEL(cel, options = {}) {
 }
 
 //#endregion
-export { parseCEL };
+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 };
 //# sourceMappingURL=parseCEL.mjs.map