@react-querybuilder/core 8.9.0 → 8.9.2

package/dist/parseJsonLogic.d.mts

@@ -0,0 +1,36 @@
+import { DefaultRuleGroupType, DefaultRuleGroupTypeIC, Except, RuleGroupTypeAny, RuleType } from "./basic-BfD-7CN3.mjs";
+import { RQBJsonLogic } from "./export-r-V7bU31.mjs";
+import { ParserCommonOptions } from "./import-BwbbP4oU.mjs";
+
+//#region src/utils/parseJsonLogic/parseJsonLogic.d.ts
+/**
+* Options object for {@link parseJsonLogic}.
+*/
+interface ParseJsonLogicOptions extends ParserCommonOptions {
+  jsonLogicOperations?: Record<string, (value: any) => RuleType | RuleGroupTypeAny | false>;
+}
+/**
+* Converts a JsonLogic object into a query suitable for the
+* {@link index!QueryBuilder QueryBuilder} component's `query` or `defaultQuery` props
+* ({@link index!DefaultRuleGroupType DefaultRuleGroupType}).
+*/
+declare function parseJsonLogic(rqbJsonLogic: string | RQBJsonLogic): DefaultRuleGroupType;
+/**
+* Converts a JsonLogic object into a query suitable for the
+* {@link index!QueryBuilder QueryBuilder} component's `query` or `defaultQuery` props
+* ({@link index!DefaultRuleGroupType DefaultRuleGroupType}).
+*/
+declare function parseJsonLogic(rqbJsonLogic: string | RQBJsonLogic, options: Except<ParseJsonLogicOptions, "independentCombinators"> & {
+  independentCombinators?: false;
+}): DefaultRuleGroupType;
+/**
+* Converts a JsonLogic object into a query suitable for the
+* {@link index!QueryBuilder QueryBuilder} component's `query` or `defaultQuery` props
+* ({@link index!DefaultRuleGroupTypeIC DefaultRuleGroupTypeIC}).
+*/
+declare function parseJsonLogic(rqbJsonLogic: string | RQBJsonLogic, options: Except<ParseJsonLogicOptions, "independentCombinators"> & {
+  independentCombinators: true;
+}): DefaultRuleGroupTypeIC;
+//#endregion
+export { ParseJsonLogicOptions, parseJsonLogic };
+//# sourceMappingURL=parseJsonLogic.d.mts.map

package/dist/parseJsonLogic.mjs

@@ -0,0 +1,191 @@
+import { defaultOperatorNegationMap, joinWith } from "./arrayUtils-BF1P8iHS.mjs";
+import { isPojo, isRuleGroup, isRuleGroupType } from "./isRuleGroup-CnhYpLOM.mjs";
+import "./optGroupUtils-Duv-M8rf.mjs";
+import { convertToIC } from "./convertQuery-H7RhQiIc.mjs";
+import { fieldIsValidUtil, getFieldsArray, prepareRuleGroup } from "./prepareQueryObjects-CS6Wmhmf.mjs";
+import { objectKeys } from "./objectUtils-BtWdcZVG.mjs";
+
+//#region src/utils/parseJsonLogic/utils.ts
+const isJsonLogicVar = (logic) => isPojo(logic) && "var" in logic;
+const isRQBJsonLogicVar = (logic) => isJsonLogicVar(logic) && typeof logic.var === "string";
+const isJsonLogicEqual = (logic) => isPojo(logic) && "==" in logic;
+const isJsonLogicStrictEqual = (logic) => isPojo(logic) && "===" in logic;
+const isJsonLogicNotEqual = (logic) => isPojo(logic) && "!=" in logic;
+const isJsonLogicStrictNotEqual = (logic) => isPojo(logic) && "!==" in logic;
+const isJsonLogicNegation = (logic) => isPojo(logic) && "!" in logic;
+const isJsonLogicDoubleNegation = (logic) => isPojo(logic) && "!!" in logic;
+const isJsonLogicOr = (logic) => isPojo(logic) && "or" in logic;
+const isJsonLogicAnd = (logic) => isPojo(logic) && "and" in logic;
+const isJsonLogicGreaterThan = (logic) => isPojo(logic) && ">" in logic;
+const isJsonLogicGreaterThanOrEqual = (logic) => isPojo(logic) && ">=" in logic;
+const isJsonLogicLessThan = (logic) => isPojo(logic) && "<" in logic && logic["<"].length === 2;
+const isJsonLogicLessThanOrEqual = (logic) => isPojo(logic) && "<=" in logic && logic["<="].length === 2;
+const isJsonLogicInArray = (logic) => isPojo(logic) && "in" in logic && Array.isArray(logic.in[1]);
+const isJsonLogicInString = (logic) => isPojo(logic) && "in" in logic && !Array.isArray(logic.in[1]);
+const isJsonLogicAll = (logic) => isPojo(logic) && "all" in logic;
+const isJsonLogicNone = (logic) => isPojo(logic) && "none" in logic;
+const isJsonLogicSome = (logic) => isPojo(logic) && "some" in logic;
+const isJsonLogicBetweenExclusive = (logic) => isPojo(logic) && "<" in logic && Array.isArray(logic["<"]) && logic["<"].length === 3;
+const isJsonLogicBetweenInclusive = (logic) => isPojo(logic) && "<=" in logic && Array.isArray(logic["<="]) && logic["<="].length === 3;
+const isRQBJsonLogicStartsWith = (logic) => isPojo(logic) && "startsWith" in logic;
+const isRQBJsonLogicEndsWith = (logic) => isPojo(logic) && "endsWith" in logic;
+
+//#endregion
+//#region src/utils/parseJsonLogic/parseJsonLogic.ts
+const emptyRuleGroup = {
+	combinator: "and",
+	rules: []
+};
+function parseJsonLogic(rqbJsonLogic, options = {}) {
+	const fieldsFlat = getFieldsArray(options.fields);
+	const { getValueSources, listsAsArrays, jsonLogicOperations } = options;
+	const fieldIsValid = (fieldName, operator, subordinateFieldName) => fieldIsValidUtil({
+		fieldName,
+		fieldsFlat,
+		operator,
+		subordinateFieldName,
+		getValueSources
+	});
+	function processLogic(logic, outermost) {
+		if (outermost && !isPojo(logic)) return false;
+		const [key, keyValue] = Object.entries(logic || {})?.[0] ?? [];
+		if (jsonLogicOperations && objectKeys(jsonLogicOperations).includes(key)) {
+			const rule$1 = jsonLogicOperations[key](keyValue);
+			return rule$1 ? outermost && !isRuleGroup(rule$1) ? {
+				combinator: "and",
+				rules: [rule$1]
+			} : rule$1 : false;
+		}
+		if (isJsonLogicAnd(logic)) return {
+			combinator: "and",
+			rules: logic.and.map((l) => processLogic(l)).filter(Boolean)
+		};
+		else if (isJsonLogicOr(logic)) return {
+			combinator: "or",
+			rules: logic.or.map((l) => processLogic(l)).filter(Boolean)
+		};
+		else if (isJsonLogicNegation(logic)) {
+			const rule$1 = processLogic(logic["!"]);
+			if (rule$1) {
+				if (!isRuleGroupType(rule$1) && (rule$1.operator === "between" || rule$1.operator === "in" || rule$1.operator === "contains" || rule$1.operator === "beginsWith" || rule$1.operator === "endsWith")) {
+					const newRule = {
+						...rule$1,
+						operator: defaultOperatorNegationMap[rule$1.operator]
+					};
+					if (outermost) return {
+						combinator: "and",
+						rules: [newRule]
+					};
+					return newRule;
+				} else if (isJsonLogicBetweenExclusive(logic["!"]) || isRuleGroupType(rule$1)) return {
+					...rule$1,
+					not: true
+				};
+				return {
+					combinator: "and",
+					rules: [rule$1],
+					not: true
+				};
+			}
+			return false;
+		} else if (isJsonLogicDoubleNegation(logic)) return processLogic(logic["!!"]) || false;
+		let rule = false;
+		let field = "";
+		let operator = "=";
+		let value = "";
+		let valueSource = void 0;
+		if (isJsonLogicEqual(logic) || isJsonLogicStrictEqual(logic) || isJsonLogicNotEqual(logic) || isJsonLogicStrictNotEqual(logic) || isJsonLogicGreaterThan(logic) || isJsonLogicGreaterThanOrEqual(logic) || isJsonLogicLessThan(logic) || isJsonLogicLessThanOrEqual(logic) || isJsonLogicInString(logic) || isRQBJsonLogicStartsWith(logic) || isRQBJsonLogicEndsWith(logic)) {
+			const [first, second] = keyValue;
+			if (isRQBJsonLogicVar(first) && !isPojo(second)) {
+				field = first.var;
+				value = second;
+			} else if (!isPojo(first) && isRQBJsonLogicVar(second)) {
+				field = second.var;
+				value = first;
+			} else if (isRQBJsonLogicVar(first) && isRQBJsonLogicVar(second)) {
+				field = first.var;
+				value = second.var;
+				valueSource = "field";
+			} else return false;
+			if (isJsonLogicEqual(logic) || isJsonLogicStrictEqual(logic)) operator = value === null ? "null" : "=";
+			else if (isJsonLogicNotEqual(logic) || isJsonLogicStrictNotEqual(logic)) operator = value === null ? "notNull" : "!=";
+			else if (isJsonLogicInString(logic)) operator = "contains";
+			else if (isRQBJsonLogicStartsWith(logic)) operator = "beginsWith";
+			else if (isRQBJsonLogicEndsWith(logic)) operator = "endsWith";
+			else operator = key;
+			if (fieldIsValid(field, operator, valueSource === "field" ? value : void 0)) rule = {
+				field,
+				operator,
+				value,
+				valueSource
+			};
+		} else if (isJsonLogicAll(logic) && isRQBJsonLogicVar(logic["all"][0]) || isJsonLogicNone(logic) && isRQBJsonLogicVar(logic["none"][0]) || isJsonLogicSome(logic) && isRQBJsonLogicVar(logic["some"][0])) {
+			const match = { mode: isJsonLogicNone(logic) ? "none" : isJsonLogicSome(logic) ? "some" : "all" };
+			const [{ var: field$1 }, operation] = logic[match.mode];
+			const matcher = processLogic(operation);
+			if (!matcher) return false;
+			rule = {
+				field: field$1,
+				operator: "=",
+				match,
+				value: isRuleGroup(matcher) ? matcher : {
+					combinator: "and",
+					rules: [matcher]
+				}
+			};
+		} else if (isJsonLogicBetweenExclusive(logic) && isRQBJsonLogicVar(logic["<"][1])) {
+			field = logic["<"][1].var;
+			const values = [logic["<"][0], logic["<"][2]];
+			// istanbul ignore else
+			if (values.every((v) => isRQBJsonLogicVar(v)) || values.every((el) => typeof el === "string") || values.every((el) => typeof el === "number") || values.every((el) => typeof el === "boolean")) return processLogic({ and: [{ ">": [{ var: field }, values[0]] }, { "<": [{ var: field }, values[1]] }] }) || false;
+		} else if (isJsonLogicBetweenInclusive(logic) && isRQBJsonLogicVar(logic["<="][1])) {
+			field = logic["<="][1].var;
+			operator = "between";
+			const values = [logic["<="][0], logic["<="][2]];
+			if (logic["<="].every((v) => isRQBJsonLogicVar(v))) {
+				const vars = values;
+				valueSource = "field";
+				const fieldList = vars.map((el) => el.var).filter((sf) => fieldIsValid(field, operator, sf));
+				value = listsAsArrays ? fieldList : joinWith(fieldList, ",");
+			} else if (values.every((el) => typeof el === "string") || values.every((el) => typeof el === "number") || values.every((el) => typeof el === "boolean")) value = listsAsArrays ? values : joinWith(values.map((el) => `${el}`), ",");
+			if (fieldIsValid(field, operator) && value.length >= 2) rule = {
+				field,
+				operator,
+				value,
+				valueSource
+			};
+		} else if (isJsonLogicInArray(logic) && isRQBJsonLogicVar(keyValue[0])) {
+			field = keyValue[0].var;
+			operator = "in";
+			if (logic.in[1].every((v) => isRQBJsonLogicVar(v))) {
+				valueSource = "field";
+				const fieldList = logic.in[1].map((el) => el.var).filter((sf) => fieldIsValid(field, operator, sf));
+				value = listsAsArrays ? fieldList : joinWith(fieldList, ",");
+			} else if (logic.in[1].every((el) => typeof el === "string") || logic.in[1].every((el) => typeof el === "number") || logic.in[1].every((el) => typeof el === "boolean")) value = listsAsArrays ? logic.in[1] : joinWith(logic.in[1].map((el) => `${el}`), ",");
+			// istanbul ignore else
+			if (value.length > 0) rule = {
+				field,
+				operator,
+				value,
+				valueSource
+			};
+		}
+		return rule ? outermost ? {
+			combinator: "and",
+			rules: [rule]
+		} : rule : false;
+	}
+	const prepare = options.generateIDs ? prepareRuleGroup : (g) => g;
+	let logicRoot = rqbJsonLogic;
+	if (typeof rqbJsonLogic === "string") try {
+		logicRoot = JSON.parse(rqbJsonLogic);
+	} catch {
+		return prepare(emptyRuleGroup);
+	}
+	const finalQuery = processLogic(logicRoot, true) || emptyRuleGroup;
+	return prepare(options.independentCombinators ? convertToIC(finalQuery) : finalQuery);
+}
+
+//#endregion
+export { parseJsonLogic };
+//# sourceMappingURL=parseJsonLogic.mjs.map

package/dist/parseJsonLogic.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseJsonLogic.mjs","names":["emptyRuleGroup: DefaultRuleGroupType","rule","rule: DefaultRuleType | false","operator: DefaultOperatorName","value: any","valueSource: ValueSource | undefined","match: MatchConfig","field","finalQuery: DefaultRuleGroupType"],"sources":["../src/utils/parseJsonLogic/utils.ts","../src/utils/parseJsonLogic/parseJsonLogic.ts"],"sourcesContent":["import type {\n  JsonLogicAll,\n  JsonLogicAnd,\n  JsonLogicDoubleNegation,\n  JsonLogicEqual,\n  JsonLogicGreaterThan,\n  JsonLogicGreaterThanOrEqual,\n  JsonLogicInArray,\n  JsonLogicInString,\n  JsonLogicLessThan,\n  JsonLogicLessThanOrEqual,\n  JsonLogicNegation,\n  JsonLogicNone,\n  JsonLogicNotEqual,\n  JsonLogicOr,\n  JsonLogicSome,\n  JsonLogicStrictEqual,\n  JsonLogicStrictNotEqual,\n  JsonLogicVar,\n  RQBJsonLogicEndsWith,\n  RQBJsonLogicStartsWith,\n  RQBJsonLogicVar,\n} from '../../types';\nimport { isPojo } from '../misc';\nimport type { JsonLogicBetweenExclusive, JsonLogicBetweenInclusive } from './types';\n\n// Standard JsonLogic operations\nexport const isJsonLogicVar = (\n  logic: unknown\n): logic is JsonLogicVar<RQBJsonLogicStartsWith | RQBJsonLogicEndsWith> =>\n  isPojo(logic) && 'var' in logic;\nexport const isRQBJsonLogicVar = (logic: unknown): logic is RQBJsonLogicVar =>\n  isJsonLogicVar(logic) && typeof logic.var === 'string';\nexport const isJsonLogicEqual = (logic: unknown): logic is JsonLogicEqual =>\n  isPojo(logic) && '==' in logic;\nexport const isJsonLogicStrictEqual = (logic: unknown): logic is JsonLogicStrictEqual =>\n  isPojo(logic) && '===' in logic;\nexport const isJsonLogicNotEqual = (logic: unknown): logic is JsonLogicNotEqual =>\n  isPojo(logic) && '!=' in logic;\nexport const isJsonLogicStrictNotEqual = (logic: unknown): logic is JsonLogicStrictNotEqual =>\n  isPojo(logic) && '!==' in logic;\nexport const isJsonLogicNegation = (logic: unknown): logic is JsonLogicNegation =>\n  isPojo(logic) && '!' in logic;\nexport const isJsonLogicDoubleNegation = (logic: unknown): logic is JsonLogicDoubleNegation =>\n  isPojo(logic) && '!!' in logic;\nexport const isJsonLogicOr = (\n  logic: unknown\n): logic is JsonLogicOr<RQBJsonLogicStartsWith | RQBJsonLogicEndsWith> =>\n  isPojo(logic) && 'or' in logic;\nexport const isJsonLogicAnd = (\n  logic: unknown\n): logic is JsonLogicAnd<RQBJsonLogicStartsWith | RQBJsonLogicEndsWith> =>\n  isPojo(logic) && 'and' in logic;\nexport const isJsonLogicGreaterThan = (\n  logic: unknown\n): logic is JsonLogicGreaterThan<RQBJsonLogicStartsWith | RQBJsonLogicEndsWith> =>\n  isPojo(logic) && '>' in logic;\nexport const isJsonLogicGreaterThanOrEqual = (\n  logic: unknown\n): logic is JsonLogicGreaterThanOrEqual<RQBJsonLogicStartsWith | RQBJsonLogicEndsWith> =>\n  isPojo(logic) && '>=' in logic;\nexport const isJsonLogicLessThan = (\n  logic: unknown\n): logic is JsonLogicLessThan<RQBJsonLogicStartsWith | RQBJsonLogicEndsWith> =>\n  isPojo(logic) && '<' in logic && logic['<'].length === 2;\nexport const isJsonLogicLessThanOrEqual = (\n  logic: unknown\n): logic is JsonLogicLessThanOrEqual<RQBJsonLogicStartsWith | RQBJsonLogicEndsWith> =>\n  isPojo(logic) && '<=' in logic && logic['<='].length === 2;\nexport const isJsonLogicInArray = (\n  logic: unknown\n): logic is JsonLogicInArray<RQBJsonLogicStartsWith | RQBJsonLogicEndsWith> =>\n  isPojo(logic) && 'in' in logic && Array.isArray(logic.in[1]);\nexport const isJsonLogicInString = (\n  logic: unknown\n): logic is JsonLogicInString<RQBJsonLogicStartsWith | RQBJsonLogicEndsWith> =>\n  isPojo(logic) && 'in' in logic && !Array.isArray(logic.in[1]);\nexport const isJsonLogicAll = (\n  logic: unknown\n): logic is JsonLogicAll<RQBJsonLogicStartsWith | RQBJsonLogicEndsWith> =>\n  isPojo(logic) && 'all' in logic;\nexport const isJsonLogicNone = (\n  logic: unknown\n): logic is JsonLogicNone<RQBJsonLogicStartsWith | RQBJsonLogicEndsWith> =>\n  isPojo(logic) && 'none' in logic;\nexport const isJsonLogicSome = (\n  logic: unknown\n): logic is JsonLogicSome<RQBJsonLogicStartsWith | RQBJsonLogicEndsWith> =>\n  isPojo(logic) && 'some' in logic;\n\n// \"Between\" operations are special cases of '<' and '<='\nexport const isJsonLogicBetweenExclusive = (logic: unknown): logic is JsonLogicBetweenExclusive =>\n  isPojo(logic) && '<' in logic && Array.isArray(logic['<']) && logic['<'].length === 3;\nexport const isJsonLogicBetweenInclusive = (logic: unknown): logic is JsonLogicBetweenInclusive =>\n  isPojo(logic) && '<=' in logic && Array.isArray(logic['<=']) && logic['<='].length === 3;\n\n// RQB extensions\nexport const isRQBJsonLogicStartsWith = (logic: unknown): logic is RQBJsonLogicStartsWith =>\n  isPojo(logic) && 'startsWith' in logic;\nexport const isRQBJsonLogicEndsWith = (logic: unknown): logic is RQBJsonLogicEndsWith =>\n  isPojo(logic) && 'endsWith' in logic;\n\n// Type guards for unused JsonLogic operations\n\n// import type {\n//   JsonLogicCat,\n//   JsonLogicDifference,\n//   JsonLogicFilter,\n//   JsonLogicIf,\n//   JsonLogicLog,\n//   JsonLogicMap,\n//   JsonLogicMax,\n//   JsonLogicMerge,\n//   JsonLogicMin,\n//   JsonLogicMissing,\n//   JsonLogicMissingSome,\n//   JsonLogicProduct,\n//   JsonLogicQuotient,\n//   JsonLogicReduce,\n//   JsonLogicRemainder,\n//   JsonLogicSubstr,\n//   JsonLogicSum,\n// } from '../../types';\n//\n// export const isJsonLogicMissing = (\n//   logic: RQBJsonLogic\n// ): logic is JsonLogicMissing<RQBJsonLogicStartsWith | RQBJsonLogicEndsWith> =>\n//   isPojo(logic) && 'missing' in logic;\n// export const isJsonLogicMissingSome = (\n//   logic: RQBJsonLogic\n// ): logic is JsonLogicMissingSome<RQBJsonLogicStartsWith | RQBJsonLogicEndsWith> =>\n//   isPojo(logic) && 'missing_some' in logic;\n// export const isJsonLogicIf = (logic: RQBJsonLogic): logic is JsonLogicIf =>\n//   isPojo(logic) && 'if' in logic;\n// export const isJsonLogicMax = (\n//   logic: RQBJsonLogic\n// ): logic is JsonLogicMax<RQBJsonLogicStartsWith | RQBJsonLogicEndsWith> =>\n//   isPojo(logic) && 'max' in logic;\n// export const isJsonLogicMin = (\n//   logic: RQBJsonLogic\n// ): logic is JsonLogicMin<RQBJsonLogicStartsWith | RQBJsonLogicEndsWith> =>\n//   isPojo(logic) && 'min' in logic;\n// export const isJsonLogicSum = (\n//   logic: RQBJsonLogic\n// ): logic is JsonLogicSum<RQBJsonLogicStartsWith | RQBJsonLogicEndsWith> =>\n//   isPojo(logic) && '+' in logic;\n// export const isJsonLogicDifference = (\n//   logic: RQBJsonLogic\n// ): logic is JsonLogicDifference<RQBJsonLogicStartsWith | RQBJsonLogicEndsWith> =>\n//   isPojo(logic) && '-' in logic;\n// export const isJsonLogicProduct = (\n//   logic: RQBJsonLogic\n// ): logic is JsonLogicProduct<RQBJsonLogicStartsWith | RQBJsonLogicEndsWith> =>\n//   isPojo(logic) && '*' in logic;\n// export const isJsonLogicQuotient = (\n//   logic: RQBJsonLogic\n// ): logic is JsonLogicQuotient<RQBJsonLogicStartsWith | RQBJsonLogicEndsWith> =>\n//   isPojo(logic) && '/' in logic;\n// export const isJsonLogicRemainder = (\n//   logic: RQBJsonLogic\n// ): logic is JsonLogicRemainder<RQBJsonLogicStartsWith | RQBJsonLogicEndsWith> =>\n//   isPojo(logic) && '%' in logic;\n// export const isJsonLogicMap = (\n//   logic: RQBJsonLogic\n// ): logic is JsonLogicMap<RQBJsonLogicStartsWith | RQBJsonLogicEndsWith> =>\n//   isPojo(logic) && 'map' in logic;\n// export const isJsonLogicFilter = (\n//   logic: RQBJsonLogic\n// ): logic is JsonLogicFilter<RQBJsonLogicStartsWith | RQBJsonLogicEndsWith> =>\n//   isPojo(logic) && 'filter' in logic;\n// export const isJsonLogicReduce = (\n//   logic: RQBJsonLogic\n// ): logic is JsonLogicReduce<RQBJsonLogicStartsWith | RQBJsonLogicEndsWith> =>\n//   isPojo(logic) && 'reduce' in logic;\n// export const isJsonLogicMerge = (\n//   logic: RQBJsonLogic\n// ): logic is JsonLogicMerge<RQBJsonLogicStartsWith | RQBJsonLogicEndsWith> =>\n//   isPojo(logic) && 'merge' in logic;\n// export const isJsonLogicCat = (\n//   logic: RQBJsonLogic\n// ): logic is JsonLogicCat<RQBJsonLogicStartsWith | RQBJsonLogicEndsWith> =>\n//   isPojo(logic) && 'cat' in logic;\n// export const isJsonLogicSubstr = (\n//   logic: RQBJsonLogic\n// ): logic is JsonLogicSubstr<RQBJsonLogicStartsWith | RQBJsonLogicEndsWith> =>\n//   isPojo(logic) && 'substr' in logic;\n// export const isJsonLogicLog = (\n//   logic: RQBJsonLogic\n// ): logic is JsonLogicLog<RQBJsonLogicStartsWith | RQBJsonLogicEndsWith> =>\n//   isPojo(logic) && 'log' in logic;\n","import { defaultOperatorNegationMap } from '../../defaults';\nimport type {\n  DefaultOperatorName,\n  DefaultRuleGroupType,\n  DefaultRuleGroupTypeAny,\n  DefaultRuleGroupTypeIC,\n  DefaultRuleType,\n  Except,\n  MatchConfig,\n  RQBJsonLogic,\n  RQBJsonLogicVar,\n  RuleGroupTypeAny,\n  RuleType,\n  ValueSource,\n} from '../../types';\nimport type { ParserCommonOptions } from '../../types/import';\nimport { joinWith } from '../arrayUtils';\nimport { convertToIC } from '../convertQuery';\nimport { isRuleGroup, isRuleGroupType } from '../isRuleGroup';\nimport { isPojo } from '../misc';\nimport { objectKeys } from '../objectUtils';\nimport { fieldIsValidUtil, getFieldsArray } from '../parserUtils';\nimport { prepareRuleGroup } from '../prepareQueryObjects';\nimport {\n  isJsonLogicAll,\n  isJsonLogicAnd,\n  isJsonLogicBetweenExclusive,\n  isJsonLogicBetweenInclusive,\n  isJsonLogicDoubleNegation,\n  isJsonLogicEqual,\n  isJsonLogicGreaterThan,\n  isJsonLogicGreaterThanOrEqual,\n  isJsonLogicInArray,\n  isJsonLogicInString,\n  isJsonLogicLessThan,\n  isJsonLogicLessThanOrEqual,\n  isJsonLogicNegation,\n  isJsonLogicNone,\n  isJsonLogicNotEqual,\n  isJsonLogicOr,\n  isJsonLogicSome,\n  isJsonLogicStrictEqual,\n  isJsonLogicStrictNotEqual,\n  isRQBJsonLogicEndsWith,\n  isRQBJsonLogicStartsWith,\n  isRQBJsonLogicVar,\n} from './utils';\n\n/**\n * Options object for {@link parseJsonLogic}.\n */\nexport interface ParseJsonLogicOptions extends ParserCommonOptions {\n  // oxlint-disable-next-line typescript/no-explicit-any\n  jsonLogicOperations?: Record<string, (value: any) => RuleType | RuleGroupTypeAny | false>;\n}\n\nconst emptyRuleGroup: DefaultRuleGroupType = { combinator: 'and', rules: [] };\n\n/**\n * Converts a JsonLogic object into a query suitable for the\n * {@link index!QueryBuilder QueryBuilder} component's `query` or `defaultQuery` props\n * ({@link index!DefaultRuleGroupType DefaultRuleGroupType}).\n */\nfunction parseJsonLogic(rqbJsonLogic: string | RQBJsonLogic): DefaultRuleGroupType;\n/**\n * Converts a JsonLogic object into a query suitable for the\n * {@link index!QueryBuilder QueryBuilder} component's `query` or `defaultQuery` props\n * ({@link index!DefaultRuleGroupType DefaultRuleGroupType}).\n */\nfunction parseJsonLogic(\n  rqbJsonLogic: string | RQBJsonLogic,\n  options: Except<ParseJsonLogicOptions, 'independentCombinators'> & {\n    independentCombinators?: false;\n  }\n): DefaultRuleGroupType;\n/**\n * Converts a JsonLogic object into a query suitable for the\n * {@link index!QueryBuilder QueryBuilder} component's `query` or `defaultQuery` props\n * ({@link index!DefaultRuleGroupTypeIC DefaultRuleGroupTypeIC}).\n */\nfunction parseJsonLogic(\n  rqbJsonLogic: string | RQBJsonLogic,\n  options: Except<ParseJsonLogicOptions, 'independentCombinators'> & {\n    independentCombinators: true;\n  }\n): DefaultRuleGroupTypeIC;\nfunction parseJsonLogic(\n  rqbJsonLogic: string | RQBJsonLogic,\n  options: ParseJsonLogicOptions = {}\n): DefaultRuleGroupTypeAny {\n  const fieldsFlat = getFieldsArray(options.fields);\n  const { getValueSources, listsAsArrays, jsonLogicOperations } = options;\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,\n    });\n\n  // Overload 1: Always return a rule group or false for the outermost logic object\n  function processLogic(logic: RQBJsonLogic, outermost: true): DefaultRuleGroupType | false;\n  // Overload 2: If not the outermost object, return value could also be a rule\n  function processLogic(\n    logic: RQBJsonLogic,\n    outermost?: false\n  ): DefaultRuleGroupType | DefaultRuleType | false;\n  // Implementation\n  function processLogic(\n    logic: RQBJsonLogic,\n    outermost?: boolean\n  ): DefaultRuleGroupType | DefaultRuleType | false {\n    // Bail if the outermost logic is not a plain object\n    if (outermost && !isPojo(logic)) {\n      return false;\n    }\n    const [key, keyValue] = Object.entries(logic || {})?.[0] ?? [];\n\n    // Custom operations process logic\n    if (jsonLogicOperations && objectKeys(jsonLogicOperations).includes(key)) {\n      const rule = jsonLogicOperations[key](keyValue) as DefaultRuleType;\n      return rule\n        ? outermost && !isRuleGroup(rule)\n          ? { combinator: 'and', rules: [rule] }\n          : rule\n        : false;\n    }\n\n    // Rule groups\n    if (isJsonLogicAnd(logic)) {\n      return {\n        combinator: 'and',\n        rules: logic.and.map(l => processLogic(l)).filter(Boolean) as (\n          | DefaultRuleType\n          | DefaultRuleGroupType\n        )[],\n      };\n    } else if (isJsonLogicOr(logic)) {\n      return {\n        combinator: 'or',\n        rules: logic.or.map(l => processLogic(l)).filter(Boolean) as (\n          | DefaultRuleType\n          | DefaultRuleGroupType\n        )[],\n      };\n    } else if (isJsonLogicNegation(logic)) {\n      const rule = processLogic(logic['!']);\n      if (rule) {\n        if (\n          !isRuleGroupType(rule) &&\n          (rule.operator === 'between' ||\n            rule.operator === 'in' ||\n            rule.operator === 'contains' ||\n            rule.operator === 'beginsWith' ||\n            rule.operator === 'endsWith')\n        ) {\n          const newRule = { ...rule, operator: defaultOperatorNegationMap[rule.operator] };\n          if (outermost) {\n            return { combinator: 'and', rules: [newRule] };\n          }\n          return newRule;\n        } else if (isJsonLogicBetweenExclusive(logic['!']) || isRuleGroupType(rule)) {\n          return { ...rule, not: true };\n        }\n        return { combinator: 'and', rules: [rule], not: true };\n      }\n      return false;\n    } else if (isJsonLogicDoubleNegation(logic)) {\n      const rule = processLogic(logic['!!']);\n      return rule || false;\n    }\n\n    // All other keys represent rules\n    let rule: DefaultRuleType | false = false;\n    let field = '';\n    let operator: DefaultOperatorName = '=';\n    // oxlint-disable-next-line typescript/no-explicit-any\n    let value: any = '';\n    let valueSource: ValueSource | undefined = undefined;\n\n    if (\n      // Basic boolean operations\n      isJsonLogicEqual(logic) ||\n      isJsonLogicStrictEqual(logic) ||\n      isJsonLogicNotEqual(logic) ||\n      isJsonLogicStrictNotEqual(logic) ||\n      isJsonLogicGreaterThan(logic) ||\n      isJsonLogicGreaterThanOrEqual(logic) ||\n      isJsonLogicLessThan(logic) ||\n      isJsonLogicLessThanOrEqual(logic) ||\n      isJsonLogicInString(logic) ||\n      isRQBJsonLogicStartsWith(logic) ||\n      isRQBJsonLogicEndsWith(logic)\n    ) {\n      const [first, second] = keyValue;\n      if (isRQBJsonLogicVar(first) && !isPojo(second)) {\n        field = first.var;\n        value = second;\n      } else if (!isPojo(first) && isRQBJsonLogicVar(second)) {\n        field = second.var;\n        value = first;\n      } else if (isRQBJsonLogicVar(first) && isRQBJsonLogicVar(second)) {\n        field = first.var;\n        value = second.var;\n        valueSource = 'field';\n      } else {\n        return false;\n      }\n\n      // Translate operator if necessary\n      if (isJsonLogicEqual(logic) || isJsonLogicStrictEqual(logic)) {\n        operator = value === null ? 'null' : '=';\n      } else if (isJsonLogicNotEqual(logic) || isJsonLogicStrictNotEqual(logic)) {\n        operator = value === null ? 'notNull' : '!=';\n      } else if (isJsonLogicInString(logic)) {\n        operator = 'contains';\n      } else if (isRQBJsonLogicStartsWith(logic)) {\n        operator = 'beginsWith';\n      } else if (isRQBJsonLogicEndsWith(logic)) {\n        operator = 'endsWith';\n      } else {\n        operator = key as DefaultOperatorName;\n      }\n\n      if (fieldIsValid(field, operator, valueSource === 'field' ? value : undefined)) {\n        rule = { field, operator, value, valueSource };\n      }\n    } else if (\n      (isJsonLogicAll(logic) && isRQBJsonLogicVar(logic['all'][0])) ||\n      (isJsonLogicNone(logic) && isRQBJsonLogicVar(logic['none'][0])) ||\n      (isJsonLogicSome(logic) && isRQBJsonLogicVar(logic['some'][0]))\n    ) {\n      // The array coverage functions must have a field as their first element.\n      // Otherwise we'd be comparing values to values, which is not supported.\n      const match: MatchConfig = {\n        mode: isJsonLogicNone(logic) ? 'none' : isJsonLogicSome(logic) ? 'some' : 'all',\n      };\n\n      // oxlint-disable-next-line typescript/no-explicit-any\n      const [{ var: field }, operation] = (logic as any)[match.mode];\n      const matcher = processLogic(operation);\n\n      // TODO: Support operations that evaluate array member properties\n      if (!matcher) return false;\n\n      rule = {\n        field,\n        operator: '=',\n        match,\n        value: isRuleGroup(matcher) ? matcher : { combinator: 'and', rules: [matcher] },\n      };\n    } else if (isJsonLogicBetweenExclusive(logic) && isRQBJsonLogicVar(logic['<'][1])) {\n      field = logic['<'][1].var;\n      const values = [logic['<'][0], logic['<'][2]];\n      // istanbul ignore else\n      if (\n        values.every(v => isRQBJsonLogicVar(v)) ||\n        values.every(el => typeof el === 'string') ||\n        values.every(el => typeof el === 'number') ||\n        values.every(el => typeof el === 'boolean')\n      ) {\n        return (\n          processLogic({\n            and: [{ '>': [{ var: field }, values[0]] }, { '<': [{ var: field }, values[1]] }],\n          }) || /* istanbul ignore next */ false\n        );\n      }\n    } else if (isJsonLogicBetweenInclusive(logic) && isRQBJsonLogicVar(logic['<='][1])) {\n      field = logic['<='][1].var;\n      operator = 'between';\n      const values = [logic['<='][0], logic['<='][2]];\n      if (logic['<='].every(v => isRQBJsonLogicVar(v))) {\n        const vars = values as RQBJsonLogicVar[];\n        valueSource = 'field';\n        const fieldList = vars.map(el => el.var).filter(sf => fieldIsValid(field, operator, sf));\n        value = listsAsArrays ? fieldList : joinWith(fieldList, ',');\n      } else {\n        // istanbul ignore else\n        if (\n          values.every(el => typeof el === 'string') ||\n          values.every(el => typeof el === 'number') ||\n          values.every(el => typeof el === 'boolean')\n        ) {\n          value = listsAsArrays\n            ? values\n            : joinWith(\n                values.map(el => `${el}`),\n                ','\n              );\n        }\n      }\n\n      if (fieldIsValid(field, operator) && value.length >= 2) {\n        rule = { field, operator, value, valueSource };\n      }\n    } else if (isJsonLogicInArray(logic) && isRQBJsonLogicVar(keyValue[0])) {\n      field = keyValue[0].var;\n      operator = 'in';\n      if (logic.in[1].every(v => isRQBJsonLogicVar(v))) {\n        valueSource = 'field';\n        const fieldList = logic.in[1]\n          .map(el => el.var)\n          .filter(sf => fieldIsValid(field, operator, sf));\n        value = listsAsArrays ? fieldList : joinWith(fieldList, ',');\n      } else {\n        // istanbul ignore else\n        if (\n          logic.in[1].every(el => typeof el === 'string') ||\n          logic.in[1].every(el => typeof el === 'number') ||\n          logic.in[1].every(el => typeof el === 'boolean')\n        ) {\n          value = listsAsArrays\n            ? logic.in[1]\n            : joinWith(\n                logic.in[1].map(el => `${el}`),\n                ','\n              );\n        }\n      }\n\n      // istanbul ignore else\n      if (value.length > 0) {\n        rule = { field, operator, value, valueSource };\n      }\n    }\n\n    return rule ? (outermost ? { combinator: 'and', rules: [rule] } : rule) : false;\n  }\n\n  const prepare = options.generateIDs ? prepareRuleGroup : <T>(g: T) => g;\n\n  let logicRoot = rqbJsonLogic;\n  if (typeof rqbJsonLogic === 'string') {\n    try {\n      logicRoot = JSON.parse(rqbJsonLogic);\n    } catch {\n      return prepare(emptyRuleGroup);\n    }\n  }\n\n  const result = processLogic(logicRoot, true);\n  const finalQuery: DefaultRuleGroupType = result || emptyRuleGroup;\n  return prepare(\n    options.independentCombinators ? convertToIC<DefaultRuleGroupTypeIC>(finalQuery) : finalQuery\n  );\n}\n\nexport { parseJsonLogic };\n"],"mappings":"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"}

package/dist/parseMongoDB.d.mts

@@ -0,0 +1,79 @@
+import { DefaultRuleGroupType, DefaultRuleGroupTypeIC, Except, RuleGroupType, RuleType } from "./basic-BfD-7CN3.mjs";
+import { ParserCommonOptions } from "./import-BwbbP4oU.mjs";
+
+//#region src/utils/parseMongoDB/parseMongoDB.d.ts
+
+/**
+* Options object for {@link parseMongoDB}.
+*/
+interface ParseMongoDbOptions extends ParserCommonOptions {
+  /**
+  * When `true`, MongoDB rules in the form of `{ fieldName: { $not: { <...rule> } } }`
+  * will be parsed into a rule group with the `not` attribute set to `true`. By default
+  * (i.e., when this attribute is `false`), such "`$not`" rules will be parsed into a
+  * rule with a negated operator.
+  *
+  * For example, with `preventOperatorNegation` set to `true`, a MongoDB rule like this...
+  *
+  * ```ts
+  * { fieldName: { $not: { $eq: 1 } } }
+  * ```
+  *
+  * ...would yield a rule group like this:
+  *
+  * ```ts
+  * {
+  *   combinator: 'and',
+  *   not: true,
+  *   rules: [{ field: 'fieldName', operator: '=', value: 1 }]
+  * }
+  * ```
+  *
+  * By default, the same MongoDB rule would yield a rule like this:
+  *
+  * ```ts
+  * { field: 'fieldName', operator: '!=', value: 1 }
+  * //              negated operator ^
+  * ```
+  *
+  * @default false
+  */
+  preventOperatorNegation?: boolean;
+  /**
+  * Map of additional operators to their respective processing functions. Operators
+  * must begin with `"$"`. Processing functions should return either a {@link index!RuleType RuleType}
+  * or {@link index!RuleGroupType RuleGroupType}.
+  *
+  * (The functions should _not_ return {@link index!RuleGroupTypeIC RuleGroupTypeIC}, even if using independent
+  * combinators. If the `independentCombinators` option is `true`, `parseMongoDB`
+  * will convert the final query to {@link index!RuleGroupTypeIC RuleGroupTypeIC} before returning it.)
+  *
+  * @default {}
+  */
+  additionalOperators?: Record<`$${string}`, (field: string, operator: string, value: any, options: ParserCommonOptions) => RuleType | RuleGroupType>;
+}
+/**
+* Converts a MongoDB query object or parseable string into a query suitable
+* for the {@link index!QueryBuilder QueryBuilder} component's `query` or `defaultQuery` props
+* ({@link index!DefaultRuleGroupType DefaultRuleGroupType}).
+*/
+declare function parseMongoDB(mongoDbRules: string | Record<string, any>): DefaultRuleGroupType;
+/**
+* Converts a MongoDB query object or parseable string into a query suitable
+* for the {@link index!QueryBuilder QueryBuilder} component's `query` or `defaultQuery` props
+* ({@link index!DefaultRuleGroupType DefaultRuleGroupType}).
+*/
+declare function parseMongoDB(mongoDbRules: string | Record<string, any>, options: Except<ParseMongoDbOptions, "independentCombinators"> & {
+  independentCombinators?: false;
+}): DefaultRuleGroupType;
+/**
+* Converts a MongoDB query object or parseable string into a query suitable
+* for the {@link index!QueryBuilder QueryBuilder} component's `query` or `defaultQuery` props
+* ({@link index!DefaultRuleGroupTypeIC DefaultRuleGroupTypeIC}).
+*/
+declare function parseMongoDB(mongoDbRules: string | Record<string, any>, options: Except<ParseMongoDbOptions, "independentCombinators"> & {
+  independentCombinators: true;
+}): DefaultRuleGroupTypeIC;
+//#endregion
+export { ParseMongoDbOptions, parseMongoDB };
+//# sourceMappingURL=parseMongoDB.d.mts.map

package/dist/parseMongoDB.mjs

@@ -0,0 +1,267 @@
+import { defaultOperatorNegationMap, joinWith } from "./arrayUtils-BF1P8iHS.mjs";
+import { isPojo, isRuleGroupType } from "./isRuleGroup-CnhYpLOM.mjs";
+import "./optGroupUtils-Duv-M8rf.mjs";
+import { convertToIC } from "./convertQuery-H7RhQiIc.mjs";
+import { fieldIsValidUtil, getFieldsArray, prepareRuleGroup } from "./prepareQueryObjects-CS6Wmhmf.mjs";
+import { objectKeys } from "./objectUtils-BtWdcZVG.mjs";
+
+//#region src/utils/parseMongoDB/utils.ts
+const getRegExStr = (re) => typeof re === "string" ? re : re.source;
+const isPrimitive = (v) => typeof v === "string" || typeof v === "number" || typeof v === "boolean";
+const mongoDbToRqbOperatorMap = {
+	$eq: "=",
+	$ne: "!=",
+	$gt: ">",
+	$gte: ">=",
+	$lt: "<",
+	$lte: "<="
+};
+
+//#endregion
+//#region src/utils/parseMongoDB/parseMongoDB.ts
+const emptyRuleGroup = {
+	combinator: "and",
+	rules: []
+};
+function parseMongoDB(mongoDbRules, options = {}) {
+	const listsAsArrays = !!options.listsAsArrays;
+	const fieldsFlat = getFieldsArray(options.fields);
+	const getValueSources = options.getValueSources;
+	const additionalOperators = options.additionalOperators ?? {};
+	const preventOperatorNegation = !!options.preventOperatorNegation;
+	const { additionalOperators: _ao,...otherOptions } = options;
+	const fieldIsValid = (fieldName, operator, subordinateFieldName) => fieldIsValidUtil({
+		fieldName,
+		fieldsFlat,
+		operator,
+		subordinateFieldName,
+		getValueSources
+	});
+	function processMongoDbQueryBooleanOperator(field, mdbOperator, keyValue) {
+		let operator = "=";
+		let value = "";
+		// istanbul ignore else
+		if (mdbOperator === "$eq" || mdbOperator === "$ne" || mdbOperator === "$gt" || mdbOperator === "$gte" || mdbOperator === "$lt" || mdbOperator === "$lte") if (mdbOperator === "$ne" && keyValue === null) {
+			if (fieldIsValid(field, "notNull")) return {
+				field,
+				operator: "notNull",
+				value: null
+			};
+		} else {
+			operator = mongoDbToRqbOperatorMap[mdbOperator];
+			if (fieldIsValid(field, operator)) return {
+				field,
+				operator,
+				value: keyValue
+			};
+		}
+		else if (mdbOperator === "$regex" && /^[^$^]$|^[^^].*[^$]$/.test(getRegExStr(keyValue))) {
+			if (fieldIsValid(field, "contains")) return {
+				field,
+				operator: "contains",
+				value: getRegExStr(keyValue)
+			};
+		} else if (mdbOperator === "$regex" && /^\^.*[^$]/.test(getRegExStr(keyValue))) {
+			if (fieldIsValid(field, "beginsWith")) return {
+				field,
+				operator: "beginsWith",
+				value: getRegExStr(keyValue).replace(/^\^/, "")
+			};
+		} else if (mdbOperator === "$regex" && /[^^].*\$/.test(getRegExStr(keyValue))) {
+			if (fieldIsValid(field, "endsWith")) return {
+				field,
+				operator: "endsWith",
+				value: getRegExStr(keyValue).replace(/\$$/, "")
+			};
+		} else if (mdbOperator === "$in" && Array.isArray(keyValue)) {
+			if (fieldIsValid(field, "in")) {
+				value = listsAsArrays ? keyValue : joinWith(keyValue.map((v) => `${v}`), ",");
+				return {
+					field,
+					operator: "in",
+					value
+				};
+			}
+		} else if (mdbOperator === "$nin" && Array.isArray(keyValue) && fieldIsValid(field, "notIn")) {
+			value = listsAsArrays ? keyValue : joinWith(keyValue.map((v) => `${v}`), ",");
+			return {
+				field,
+				operator: "notIn",
+				value
+			};
+		}
+		return false;
+	}
+	function processMongoDbQueryObjectKey(key, keyValue) {
+		let field = "";
+		// istanbul ignore else
+		if (key === "$and") {
+			if (!Array.isArray(keyValue) || keyValue.length === 0 || !keyValue.every((v) => isPojo(v))) return false;
+			if (keyValue.length === 2 && keyValue.every((kv) => objectKeys(kv).length === 1)) {
+				const [rule1, rule2] = keyValue;
+				const [ruleKey1, ruleKey2] = keyValue.map((kv) => objectKeys(kv)[0]);
+				if (ruleKey1 === ruleKey2 && isPojo(rule1[ruleKey1]) && objectKeys(rule1[ruleKey1]).length === 1 && isPojo(rule2[ruleKey2]) && objectKeys(rule2[ruleKey2]).length === 1 && ("$gte" in rule1[ruleKey1] && "$lte" in rule2[ruleKey2] && rule2[ruleKey2].$lte >= rule1[ruleKey1].$gte || "$lte" in rule1[ruleKey1] && "$gte" in rule2[ruleKey2] && rule1[ruleKey1].$lte >= rule2[ruleKey2].$gte)) {
+					const [val1, val2] = [rule1[ruleKey1].$gte ?? rule1[ruleKey1].$lte, rule2[ruleKey2].$lte ?? rule2[ruleKey2].$gte];
+					let value = listsAsArrays ? [val1, val2] : joinWith([val1, val2], ",");
+					if (val1 > val2) value = listsAsArrays ? [val2, val1] : joinWith([val2, val1], ",");
+					return {
+						field: ruleKey1,
+						operator: "between",
+						value
+					};
+				}
+			}
+			const rules = keyValue.map((l) => processMongoDbQueryObject(l)).filter(Boolean);
+			return rules.length > 0 ? {
+				combinator: "and",
+				rules
+			} : false;
+		} else if (key === "$or") {
+			if (!Array.isArray(keyValue) || keyValue.length === 0 || !keyValue.every((v) => isPojo(v))) return false;
+			if (keyValue.length === 2 && keyValue.every((kv) => objectKeys(kv).length === 1)) {
+				const [rule1, rule2] = keyValue;
+				const [ruleKey1, ruleKey2] = keyValue.map((kv) => objectKeys(kv)[0]);
+				if (ruleKey1 === ruleKey2 && isPojo(rule1[ruleKey1]) && objectKeys(rule1[ruleKey1]).length === 1 && isPojo(rule2[ruleKey2]) && objectKeys(rule2[ruleKey2]).length === 1 && ("$gt" in rule1[ruleKey1] && "$lt" in rule2[ruleKey2] && rule1[ruleKey1].$gt >= rule2[ruleKey2].$lt || "$lt" in rule1[ruleKey1] && "$gt" in rule2[ruleKey2] && rule2[ruleKey2].$gt >= rule1[ruleKey1].$lt)) {
+					const [val1, val2] = [rule1[ruleKey1].$gt ?? rule1[ruleKey1].$lt, rule2[ruleKey2].$lt ?? rule2[ruleKey2].$gt];
+					let value = listsAsArrays ? [val1, val2] : `${val1},${val2}`;
+					if (val1 > val2) value = listsAsArrays ? [val2, val1] : `${val2},${val1}`;
+					return {
+						field: ruleKey1,
+						operator: "notBetween",
+						value
+					};
+				}
+			}
+			const rules = keyValue.map((l) => processMongoDbQueryObject(l)).filter(Boolean);
+			return rules.length > 0 ? {
+				combinator: "or",
+				rules
+			} : false;
+		} else if (key === "$not" && isPojo(keyValue)) {
+			const ruleOrGroup = processMongoDbQueryObject(keyValue);
+			if (ruleOrGroup) {
+				if (isRuleGroupType(ruleOrGroup)) return ruleOrGroup.not ? {
+					combinator: "and",
+					rules: [ruleOrGroup],
+					not: true
+				} : {
+					...ruleOrGroup,
+					not: true
+				};
+				return preventOperatorNegation ? {
+					combinator: "and",
+					rules: [ruleOrGroup],
+					not: true
+				} : {
+					...ruleOrGroup,
+					operator: defaultOperatorNegationMap[ruleOrGroup.operator]
+				};
+			}
+			return false;
+		} else if (key === "$expr") {
+			const op = objectKeys(keyValue)[0];
+			if (/^\$(eq|gte?|lte?|n?in)$/.test(op) && Array.isArray(keyValue[op]) && keyValue[op].length === 2 && typeof keyValue[op][0] === "string" && keyValue[op][0].startsWith("$")) {
+				field = keyValue[op][0].replace(/^\$/, "");
+				const val = keyValue[op][1];
+				if (typeof val === "string" && val.startsWith("$") || Array.isArray(val) && val.every((v) => typeof v === "string") && val.every((v) => v.startsWith("$"))) {
+					const valForProcessing = Array.isArray(val) ? val.map((v) => v.replace(/^\$/, "")) : val.replace(/^\$/, "");
+					const tempRule = processMongoDbQueryBooleanOperator(field, op, valForProcessing);
+					if (tempRule) {
+						if (typeof tempRule.value === "string" && !fieldIsValid(field, tempRule.operator, tempRule.value)) return false;
+						return {
+							...tempRule,
+							valueSource: "field"
+						};
+					}
+				}
+				return processMongoDbQueryBooleanOperator(field, op, keyValue[op][1]);
+			}
+		} else if (/^[^$]/.test(key)) {
+			field = key;
+			if (isPrimitive(keyValue)) {
+				if (fieldIsValid(field, "=")) return {
+					field,
+					operator: "=",
+					value: keyValue
+				};
+			} else if (keyValue === null) {
+				if (fieldIsValid(field, "null")) return {
+					field,
+					operator: "null",
+					value: keyValue
+				};
+			} else if (isPojo(keyValue)) {
+				let betweenRule = false;
+				let notRule = false;
+				const allOps = [
+					"eq",
+					"ne",
+					"gte?",
+					"lte?",
+					"n?in",
+					"regex",
+					"not",
+					...objectKeys(additionalOperators).map((o) => o.replace(/^\$/, ""))
+				];
+				const acceptedOpsRegExp = /* @__PURE__ */ new RegExp(`^\\$(${allOps.join("|")})$`);
+				const operators = objectKeys(keyValue).filter((o) => acceptedOpsRegExp.test(o)).sort();
+				if (operators.length === 0) return false;
+				if ("$not" in keyValue && isPojo(keyValue.$not)) {
+					const invertedNotRule = processMongoDbQueryObject({ [field]: keyValue.$not });
+					if (invertedNotRule) if (isRuleGroupType(invertedNotRule)) notRule = {
+						...invertedNotRule,
+						not: true
+					};
+					else notRule = preventOperatorNegation ? {
+						combinator: "and",
+						rules: [invertedNotRule],
+						not: true
+					} : {
+						...invertedNotRule,
+						operator: defaultOperatorNegationMap[invertedNotRule.operator]
+					};
+				}
+				if ("$gte" in keyValue && "$lte" in keyValue) betweenRule = {
+					field,
+					operator: "between",
+					value: listsAsArrays ? [keyValue.$gte, keyValue.$lte] : `${keyValue.$gte},${keyValue.$lte}`
+				};
+				const rules = operators.filter((op) => !(notRule && op === "$not")).filter((op) => !(betweenRule && (op === "$gte" || op === "$lte"))).map((op) => op in additionalOperators && typeof additionalOperators[op] === "function" ? additionalOperators[op](field, op, keyValue[op], otherOptions) : processMongoDbQueryBooleanOperator(field, op, keyValue[op])).filter(Boolean);
+				if (notRule) rules.unshift(notRule);
+				if (betweenRule) rules.unshift(betweenRule);
+				if (rules.length === 0) return false;
+				if (rules.length === 1) return rules[0];
+				return {
+					combinator: "and",
+					rules
+				};
+			}
+		}
+		return false;
+	}
+	function processMongoDbQueryObject(mongoDbQueryObject) {
+		const rules = objectKeys(mongoDbQueryObject).map((k) => processMongoDbQueryObjectKey(k, mongoDbQueryObject[k])).filter(Boolean);
+		return rules.length === 1 ? rules[0] : rules.length > 1 ? {
+			combinator: "and",
+			rules
+		} : false;
+	}
+	const prepare = options.generateIDs ? prepareRuleGroup : (g) => g;
+	let mongoDbPOJO = mongoDbRules;
+	if (typeof mongoDbRules === "string") try {
+		mongoDbPOJO = JSON.parse(mongoDbRules);
+	} catch {
+		return prepare(emptyRuleGroup);
+	}
+	if (!isPojo(mongoDbPOJO)) return prepare(emptyRuleGroup);
+	const result = processMongoDbQueryObject(mongoDbPOJO);
+	const finalQuery = result ? isRuleGroupType(result) ? result : {
+		combinator: "and",
+		rules: [result]
+	} : emptyRuleGroup;
+	return prepare(options.independentCombinators ? convertToIC(finalQuery) : finalQuery);
+}
+
+//#endregion
+export { parseMongoDB };
+//# sourceMappingURL=parseMongoDB.mjs.map