@react-querybuilder/core 8.20.1 → 8.21.0

package/dist/react-querybuilder_core.mjs

@@ -322,6 +322,50 @@ const defaultOperatorNegationMap = {
 	null: "notNull"
 };
 /**
+* Relational/comparison operators (`=`, `!=`, `<`, `>`, `<=`, `>=`).
+*
+* @group Defaults
+*/
+const relationalOperators = /* @__PURE__ */ new Set([
+	"=",
+	"!=",
+	"<",
+	">",
+	"<=",
+	">="
+]);
+/**
+* Substring/text-matching operators (`contains`, `beginsWith`, `endsWith`, and negations).
+*
+* @group Defaults
+*/
+const substringOperators = /* @__PURE__ */ new Set([
+	"contains",
+	"beginsWith",
+	"endsWith",
+	"doesNotContain",
+	"doesNotBeginWith",
+	"doesNotEndWith"
+]);
+/**
+* Null-check operators (`null`, `notNull`).
+*
+* @group Defaults
+*/
+const nullOperators = /* @__PURE__ */ new Set(["null", "notNull"]);
+/**
+* List-membership operators (`in`, `notIn`).
+*
+* @group Defaults
+*/
+const inOperators = /* @__PURE__ */ new Set(["in", "notIn"]);
+/**
+* Range operators (`between`, `notBetween`).
+*
+* @group Defaults
+*/
+const betweenOperators = /* @__PURE__ */ new Set(["between", "notBetween"]);
+/**
 * Default combinator list.
 *
 * @group Defaults
@@ -1175,6 +1219,51 @@ const mapSQLOperator = (rqbOperator) => {
 	}
 };
 /**
+* Returns a preset-aware SQL string-concatenation function. Emits `CONCAT(a, b, ...)` when
+* `concatOperator` is `"CONCAT"` (case-insensitive), otherwise joins with the infix operator
+* (e.g. `a || b`, `a + b`).
+*
+* @group Export
+*/
+const getSQLConcat = (concatOperator = "||") => (...values) => concatOperator.toUpperCase() === "CONCAT" ? `CONCAT(${values.join(", ")})` : values.join(` ${concatOperator} `);
+/**
+* Returns the `[prefix, suffix]` `LIKE` wildcards for a string-match operator (e.g. `contains`
+* → `['%', '%']`, `beginsWith` → `['', '%']`, `endsWith` → `['%', '']`). Unknown operators
+* yield `['', '']`.
+*
+* @group Export
+*/
+const getLikeWildcards = (operatorLC) => {
+	switch (operatorLC) {
+		case "contains":
+		case "doesnotcontain": return ["%", "%"];
+		case "beginswith":
+		case "doesnotbeginwith": return ["", "%"];
+		case "endswith":
+		case "doesnotendwith": return ["%", ""];
+		default: return ["", ""];
+	}
+};
+/**
+* Wraps an already-serialized SQL fragment (a quoted field name or an expression) with the
+* `LIKE` wildcards for the given (lowercase) string-match operator, concatenating the literal
+* `%` markers via the preset-aware {@link getSQLConcat}. Returns the fragment untouched for
+* operators without wildcards.
+*
+* @group Export
+*/
+const wrapLikeFragment = (fragment, operatorLC, { concatOperator = "||", quoteValuesWith, wrapValueWith = ["", ""] } = {}) => {
+	const [pre, post] = getLikeWildcards(operatorLC);
+	const quoteChar = quoteValuesWith || `'`;
+	const quote = (p) => `${wrapValueWith[0]}${quoteChar}${p}${quoteChar}${wrapValueWith[1]}`;
+	const parts = [
+		pre && quote(pre),
+		fragment,
+		post && quote(post)
+	].filter(Boolean);
+	return parts.length > 1 ? getSQLConcat(concatOperator)(...parts) : fragment;
+};
+/**
 * Maps a (lowercase) {@link DefaultOperatorName} to a MongoDB operator.
 *
 * @group Export
@@ -1338,6 +1427,27 @@ const normalizeConstituentWordOrder = (input) => {
 	return result;
 };
 /**
+* Prefixes a named-parameter value with the given `paramPrefix` unless the value already
+* begins with it. Used by {@link formatQuery} to render rules whose `valueSource` is
+* `"parameter"` (e.g. `"p1"` with prefix `":"` → `":p1"`; `":p1"` → `":p1"`).
+*
+* @group Export
+*/
+const withParamPrefix = (value, paramPrefix = ":") => {
+	const v = `${value ?? ""}`;
+	return paramPrefix && v.startsWith(paramPrefix) ? v : `${paramPrefix}${v}`;
+};
+/**
+* Strips a leading `paramPrefix` from a named-parameter value if present. Inverse of
+* {@link withParamPrefix}; used to normalize parameter names for validation/lookup.
+*
+* @group Export
+*/
+const stripParamPrefix = (value, paramPrefix = ":") => {
+	const v = `${value ?? ""}`;
+	return paramPrefix && v.startsWith(paramPrefix) ? v.slice(paramPrefix.length) : v;
+};
+/**
 * Default translations used by {@link formatQuery} for "natural_language" format.
 *
 * @group Export
@@ -1470,7 +1580,7 @@ const escapeDoubleQuotes$1 = (v, escapeQuotes) => typeof v !== "string" || !esca
 const defaultRuleProcessorCEL = (rule, opts = {}) => {
 	const { escapeQuotes, parseNumbers, preserveValueOrder } = opts;
 	const { field, operator, value, valueSource } = rule;
-	const valueIsField = valueSource === "field";
+	const valueIsField = valueSource === "field" || valueSource === "parameter";
 	const operatorTL = lc(operator === "=" ? "==" : operator);
 	const useBareValue = typeof value === "number" || typeof value === "boolean" || typeof value === "bigint" || shouldRenderAsNumber(value, parseNumbers);
 	const matchEval = processMatchMode(rule);
@@ -1791,7 +1901,7 @@ const escapeSingleQuotes$2 = (v, escapeQuotes) => typeof v !== "string" || !esca
 const defaultRuleProcessorSpEL = (rule, opts = {}) => {
 	const { field, operator, value, valueSource } = rule;
 	const { escapeQuotes, parseNumbers, preserveValueOrder } = opts;
-	const valueIsField = valueSource === "field";
+	const valueIsField = valueSource === "field" || valueSource === "parameter";
 	const operatorTL = lc(operator === "=" ? "==" : operator);
 	const useBareValue = typeof value === "number" || typeof value === "boolean" || typeof value === "bigint" || shouldRenderAsNumber(value, parseNumbers);
 	const matchEval = processMatchMode(rule);
@@ -1825,11 +1935,20 @@ const defaultRuleProcessorSpEL = (rule, opts = {}) => {
 		case ">":
 		case ">=": return `${field} ${operatorTL} ${valueIsField || useBareValue ? trimIfString(value) : `'${escapeSingleQuotes$2(value, escapeQuotes)}'`}`;
 		case "contains":
-		case "doesnotcontain": return wrapInNegation(`${field} matches ${valueIsField || useBareValue ? trimIfString(value) : `'${escapeSingleQuotes$2(value, escapeQuotes)}'`}`, shouldNegate$1(operatorTL));
+		case "doesnotcontain": {
+			const valueTL = valueIsField ? `'.*'.concat(${trimIfString(value)}).concat('.*')` : `'.*${escapeSingleQuotes$2(value, escapeQuotes)}.*'`;
+			return wrapInNegation(`${field} matches ${valueTL}`, shouldNegate$1(operatorTL));
+		}
 		case "beginswith":
-		case "doesnotbeginwith": return wrapInNegation(`${field} matches ${valueIsField ? `'^'.concat(${trimIfString(value)})` : `'${typeof value === "string" && !value.startsWith("^") || useBareValue ? "^" : ""}${escapeSingleQuotes$2(value, escapeQuotes)}'`}`, shouldNegate$1(operatorTL));
+		case "doesnotbeginwith": {
+			const valueTL = valueIsField ? `'^'.concat(${trimIfString(value)}).concat('.*')` : `'${typeof value === "string" && !value.startsWith("^") || useBareValue ? "^" : ""}${escapeSingleQuotes$2(value, escapeQuotes)}.*'`;
+			return wrapInNegation(`${field} matches ${valueTL}`, shouldNegate$1(operatorTL));
+		}
 		case "endswith":
-		case "doesnotendwith": return wrapInNegation(`${field} matches ${valueIsField ? `${trimIfString(value)}.concat('$')` : `'${escapeSingleQuotes$2(value, escapeQuotes)}${typeof value === "string" && !value.endsWith("$") || useBareValue ? "$" : ""}'`}`, shouldNegate$1(operatorTL));
+		case "doesnotendwith": {
+			const valueTL = valueIsField ? `'.*'.concat(${trimIfString(value)}).concat('$')` : `'.*${escapeSingleQuotes$2(value, escapeQuotes)}${typeof value === "string" && !value.endsWith("$") || useBareValue ? "$" : ""}'`;
+			return wrapInNegation(`${field} matches ${valueTL}`, shouldNegate$1(operatorTL));
+		}
 		case "null": return `${field} == null`;
 		case "notnull": return `${field} != null`;
 		case "in":
@@ -1867,7 +1986,35 @@ const escapeStringValueQuotes$1 = (v, quoteChar, escapeQuotes) => escapeQuotes &
 *
 * @group Export
 */
-const defaultValueProcessorByRule = ({ operator, value, valueSource }, { escapeQuotes, parseNumbers, preserveValueOrder, quoteFieldNamesWith, quoteValuesWith, concatOperator = "||", fieldIdentifierSeparator, wrapValueWith = ["", ""], translations } = {}) => {
+const defaultValueProcessorByRule = ({ operator, value, valueSource }, { escapeQuotes, parseNumbers, preserveValueOrder, quoteFieldNamesWith, quoteValuesWith, concatOperator = "||", fieldIdentifierSeparator, paramPrefix, wrapValueWith = ["", ""], translations } = {}) => {
+	if (valueSource === "parameter") {
+		const operatorLowerCase = lc(operator);
+		if (operatorLowerCase === "between" || operatorLowerCase === "notbetween") {
+			const valueAsArray = toArray(value, { retainEmptyStrings: true });
+			if (valueAsArray.length < 2 || !isValidValue(valueAsArray[0]) || !isValidValue(valueAsArray[1])) return "";
+			const [first, second] = valueAsArray;
+			return [withParamPrefix(first, paramPrefix), withParamPrefix(second, paramPrefix)].join(` ${translations?.betweenAnd ?? translations?.and ?? "and"} `);
+		}
+		if (operatorLowerCase === "in" || operatorLowerCase === "notin") {
+			const valueAsArray = toArray(value);
+			if (valueAsArray.length === 0) return "";
+			return `(${valueAsArray.map((v) => withParamPrefix(v, paramPrefix)).join(", ")})`;
+		}
+		const paramRef = withParamPrefix(value, paramPrefix);
+		switch (operatorLowerCase) {
+			case "contains":
+			case "doesnotcontain":
+			case "beginswith":
+			case "doesnotbeginwith":
+			case "endswith":
+			case "doesnotendwith": return wrapLikeFragment(paramRef, operatorLowerCase, {
+				concatOperator,
+				quoteValuesWith,
+				wrapValueWith
+			});
+		}
+		return paramRef;
+	}
 	const valueIsField = valueSource === "field";
 	const operatorLowerCase = lc(operator);
 	const quoteChar = quoteValuesWith || "'";
@@ -1878,7 +2025,11 @@ const defaultValueProcessorByRule = ({ operator, value, valueSource }, { escapeQ
 		quoteFieldNamesWith,
 		fieldIdentifierSeparator
 	});
-	const concat = (...values) => concatOperator.toUpperCase() === "CONCAT" ? `CONCAT(${values.join(", ")})` : values.join(` ${concatOperator} `);
+	const likeOpts = {
+		concatOperator,
+		quoteValuesWith,
+		wrapValueWith
+	};
 	switch (operatorLowerCase) {
 		case "null":
 		case "notnull": return "";
@@ -1905,11 +2056,11 @@ const defaultValueProcessorByRule = ({ operator, value, valueSource }, { escapeQ
 			return (valueIsField ? valsOneAndTwoOnly.map((v) => wrapFieldName(v)) : valsOneAndTwoOnly.every((v) => shouldRenderAsNumber(v, parseNumbers)) ? valsOneAndTwoOnly.map((v) => parseNumber(v, { parseNumbers: "strict" })) : valsOneAndTwoOnly.map((v) => wrapAndEscape(v))).join(` ${translations?.betweenAnd ?? translations?.and ?? "and"} `);
 		}
 		case "contains":
-		case "doesnotcontain": return valueIsField ? concat(quoteValue("%"), wrapFieldName(value), quoteValue("%")) : quoteValue(`%${escapeValue(value)}%`);
+		case "doesnotcontain": return valueIsField ? wrapLikeFragment(wrapFieldName(value), operatorLowerCase, likeOpts) : quoteValue(`%${escapeValue(value)}%`);
 		case "beginswith":
-		case "doesnotbeginwith": return valueIsField ? concat(wrapFieldName(value), quoteValue("%")) : quoteValue(`${escapeValue(value)}%`);
+		case "doesnotbeginwith": return valueIsField ? wrapLikeFragment(wrapFieldName(value), operatorLowerCase, likeOpts) : quoteValue(`${escapeValue(value)}%`);
 		case "endswith":
-		case "doesnotendwith": return valueIsField ? concat(quoteValue("%"), wrapFieldName(value)) : quoteValue(`%${escapeValue(value)}`);
+		case "doesnotendwith": return valueIsField ? wrapLikeFragment(wrapFieldName(value), operatorLowerCase, likeOpts) : quoteValue(`%${escapeValue(value)}`);
 	}
 	if (typeof value === "boolean") return value ? "TRUE" : "FALSE";
 	return valueIsField ? wrapFieldName(value) : shouldRenderAsNumber(value, parseNumbers) ? `${trimIfString(value)}` : `${wrapAndEscape(value)}`;
@@ -2657,7 +2808,7 @@ const defaultRuleGroupProcessorTanStackDB = (ruleGroup, options) => (refs) => {
 };
 //#endregion
 //#region src/utils/formatQuery/defaultRuleGroupProcessorDiagnostics.ts
-const numericInputTypes = new Set([
+const numericInputTypes = /* @__PURE__ */ new Set([
 	"number",
 	"range",
 	"bigint"
@@ -3481,7 +3632,10 @@ const defaultRuleProcessorJsonLogic = (rule, options = {}) => {
 		case "null":
 		case "notnull": return { [`${operatorLC === "notnull" ? "!" : "="}=`]: [fieldObject, null] };
 		case "in":
-		case "notin": return negateIfNotOp(operatorLC, { in: [fieldObject, toArray(value).map((v) => fieldOrNumberRenderer(v))] });
+		case "notin": {
+			const valueAsArray = toArray(value).map((v) => fieldOrNumberRenderer(v));
+			return negateIfNotOp(operatorLC, { in: [fieldObject, valueAsArray] });
+		}
 		case "between":
 		case "notbetween": {
 			const valueAsArray = toArray(value);
@@ -3512,11 +3666,20 @@ const defaultRuleProcessorJsonLogic = (rule, options = {}) => {
 			return false;
 		}
 		case "contains":
-		case "doesnotcontain": return negateIfNotOp(operatorLC, { in: [fieldOrNumberRenderer(value), fieldObject] });
+		case "doesnotcontain": {
+			const jsonRule = { in: [fieldOrNumberRenderer(value), fieldObject] };
+			return negateIfNotOp(operatorLC, jsonRule);
+		}
 		case "beginswith":
-		case "doesnotbeginwith": return negateIfNotOp(operatorLC, { startsWith: [fieldObject, fieldOrNumberRenderer(value)] });
+		case "doesnotbeginwith": {
+			const jsonRule = { startsWith: [fieldObject, fieldOrNumberRenderer(value)] };
+			return negateIfNotOp(operatorLC, jsonRule);
+		}
 		case "endswith":
-		case "doesnotendwith": return negateIfNotOp(operatorLC, { endsWith: [fieldObject, fieldOrNumberRenderer(value)] });
+		case "doesnotendwith": {
+			const jsonRule = { endsWith: [fieldObject, fieldOrNumberRenderer(value)] };
+			return negateIfNotOp(operatorLC, jsonRule);
+		}
 	}
 	return false;
 };
@@ -3550,7 +3713,10 @@ const defaultRuleProcessorLDAP = (rule, options = {}) => {
 		case "null":
 		case "notnull": return negateIf(`(${field}=*)`, operatorLC === "notnull");
 		case "in":
-		case "notin": return negateIf(`(|${toArray(value).map((val) => `(${field}=${ldapEscape(val)})`).join("")})`, operatorLC === "notin");
+		case "notin": {
+			const valueAsArray = toArray(value);
+			return negateIf(`(|${valueAsArray.map((val) => `(${field}=${ldapEscape(val)})`).join("")})`, operatorLC === "notin");
+		}
 		case "between":
 		case "notbetween": {
 			const valueAsArray = toArray(value);
@@ -3861,7 +4027,22 @@ const defaultRuleProcessorParameterized = (rule, opts, meta) => {
 	const [qPre, qPost] = quoteFieldNamesWith;
 	if ((sqlOperatorLowerCase === "in" || sqlOperatorLowerCase === "not in" || sqlOperatorLowerCase === "between" || sqlOperatorLowerCase === "not between") && !value) return finalize("");
 	else if (sqlOperatorLowerCase === "is null" || sqlOperatorLowerCase === "is not null") return finalize(`${qPre}${rule.field}${qPost} ${sqlOperator}`);
-	else if (rule.valueSource === "field") return finalize(`${qPre}${rule.field}${qPost} ${sqlOperator} ${value}`.trim());
+	else if (rule.valueSource === "parameter") {
+		const registerParam = (v) => {
+			const ref = withParamPrefix(v, paramPrefix);
+			if (!parameterized) paramsNamed[paramsKeepPrefix ? ref : stripParamPrefix(v, paramPrefix)] = null;
+			return ref;
+		};
+		if (sqlOperatorLowerCase === "between" || sqlOperatorLowerCase === "not between") {
+			const [first, second] = toArray(rule.value, { retainEmptyStrings: true }).slice(0, 2);
+			return finalize(`${qPre}${rule.field}${qPost} ${sqlOperator} ${registerParam(first)} and ${registerParam(second)}`.trim());
+		}
+		if (sqlOperatorLowerCase === "in" || sqlOperatorLowerCase === "not in") {
+			const splitValue = toArray(rule.value);
+			return finalize(`${qPre}${rule.field}${qPost} ${sqlOperator} (${splitValue.map((v) => registerParam(v)).join(", ")})`);
+		}
+		return finalize(`${qPre}${rule.field}${qPost} ${sqlOperator} ${wrapLikeFragment(registerParam(rule.value), lc(rule.operator), { concatOperator })}`.trim());
+	} else if (rule.valueSource === "field") return finalize(`${qPre}${rule.field}${qPost} ${sqlOperator} ${value}`.trim());
 	else if (sqlOperatorLowerCase === "in" || sqlOperatorLowerCase === "not in") {
 		const splitValue = toArray(rule.value);
 		if (parameterized) {
@@ -4053,7 +4234,9 @@ const defaultRuleProcessorSPARQL = (rule, opts = {}) => {
 		if (typeof v === "bigint") return String(v);
 		if (valueIsField) return sparqlVar(trimIfString(v));
 		if (typeof v === "number" || shouldRenderAsNumber(v, parseNumbers)) return trimIfString(v);
+		/* v8 ignore start -- @preserve */
 		const s = typeof v === "string" ? v : JSON.stringify(v) ?? "";
+		/* v8 ignore stop -- @preserve */
 		if (s.startsWith("?") || s.startsWith("<") || s.includes(":")) return s;
 		return `"${escapeDoubleQuotes(s, escapeQuotes)}"`;
 	};
@@ -4297,7 +4480,7 @@ const defaultFormatQueryOptions = {
 	translations: {},
 	operatorMap: {}
 };
-const valueProcessorCanActAsRuleProcessor = new Set([
+const valueProcessorCanActAsRuleProcessor = /* @__PURE__ */ new Set([
 	"cel",
 	"drizzle",
 	"elasticsearch",
@@ -4311,7 +4494,7 @@ const valueProcessorCanActAsRuleProcessor = new Set([
 	"spel",
 	"tanstack_db"
 ]);
-const sqlFormats = new Set([
+const sqlFormats = /* @__PURE__ */ new Set([
 	"sql",
 	"parameterized",
 	"parameterized_named",
@@ -4376,6 +4559,10 @@ function formatQuery(ruleGroup, optionParam = {}) {
 				if (typeof field.validator === "function") fieldValidator = field.validator;
 			}
 		}
+		if (rule.valueSource === "parameter" && typeof optObj.getParameters === "function") {
+			const fieldData = getOption(fields, rule.field);
+			if (!new Set(toFlatOptionArray(toFullOptionList(optObj.getParameters(rule.field, rule.operator, { fieldData }))).map((p) => stripParamPrefix(p.value, optObj.paramPrefix))).has(stripParamPrefix(rule.value, optObj.paramPrefix))) validationResult = false;
+		}
 		return [validationResult, fieldValidator];
 	};
 	const finalOptions = {
@@ -4592,7 +4779,7 @@ if (cryptoModule) {
 	if (typeof cryptoModule.randomUUID === "function") generateID = () => cryptoModule.randomUUID();
 	else if (typeof cryptoModule.getRandomValues === "function") {
 		const position19vals = "89ab";
-		const container = new Uint32Array(32);
+		const container = /* @__PURE__ */ new Uint32Array(32);
 		generateID = () => {
 			cryptoModule.getRandomValues(container);
 			let id = (container[0] % 16).toString(16);
@@ -4634,6 +4821,45 @@ const getMatchModesUtil = (fieldData, getMatchModes) => {
 	}) ?? [];
 };
 //#endregion
+//#region src/utils/getRuleDefaultValue.ts
+const getFirstOptionsFrom = (opts, r, listsAsArrays) => {
+	const firstOption = getFirstOption(opts);
+	if (r.operator === "between" || r.operator === "notBetween") {
+		const valueAsArray = [firstOption, firstOption];
+		return listsAsArrays ? valueAsArray : joinWith(valueAsArray.map((v) => v ?? ""), ",");
+	}
+	return firstOption;
+};
+/**
+* Computes the default `value` for a rule given its `field`/`operator`/`valueSource`, mirroring
+* the precedence the {@link react-querybuilder!QueryBuilder QueryBuilder} applies: a field's
+* `defaultValue`, then a `getDefaultValue` override, then a value derived from the field/operator's
+* value list and editor type (first option for `select`/`radio`, `false` for `checkbox`, paired for
+* `between`/`notBetween`), or a comparator-valid field when `valueSource` is `'field'`. Falls back
+* to `''`.
+*
+* @group Option Lists
+*/
+const getRuleDefaultValue = (rule, options) => {
+	const { fieldData, fields, getValueEditorType, getValues, getDefaultValue, getParameters, listsAsArrays } = options;
+	if (fieldData?.defaultValue !== void 0 && fieldData.defaultValue !== null) return fieldData.defaultValue;
+	else if (getDefaultValue) return getDefaultValue(rule, { fieldData });
+	let value = "";
+	const values = getValues(rule.field, rule.operator, { fieldData });
+	if (rule.valueSource === "field") {
+		const filteredFields = filterFieldsByComparator(fieldData, fields, rule.operator);
+		value = filteredFields.length > 0 ? getFirstOptionsFrom(filteredFields, rule, listsAsArrays) : "";
+	} else if (rule.valueSource === "parameter") {
+		const parameters = getParameters ? getParameters(rule.field, rule.operator, { fieldData }) : null;
+		value = parameters && parameters.length > 0 ? getFirstOption(parameters) : "";
+	} else if (values.length > 0) {
+		const editorType = getValueEditorType(rule.field, rule.operator, { fieldData });
+		if (editorType === "multiselect") value = listsAsArrays ? [] : "";
+		else if (editorType === "select" || editorType === "radio") value = getFirstOptionsFrom(values, rule, listsAsArrays);
+	} else if (getValueEditorType(rule.field, rule.operator, { fieldData }) === "checkbox") value = false;
+	return value;
+};
+//#endregion
 //#region src/utils/getValidationClassNames.ts
 /**
 * Gets the standard classname for valid or invalid components
@@ -4884,21 +5110,81 @@ const addInPlace = (query, ruleOrGroup, parentPathOrID, options = {}) => {
 	return query;
 };
 /**
-* Updates a property of a rule or group within a query without mutating the original query.
+* Relative order in which properties are applied during a multi-property update.
+* Lower ranks apply first; `value` applies last so an explicitly-provided value
+* is never clobbered by a reset triggered by a `field`/`operator`/`valueSource`
+* change. Unranked properties default to `3` (between `valueSource` and `value`).
+*/
+const updatePropRank = {
+	field: 0,
+	operator: 1,
+	valueSource: 2,
+	value: 4
+};
+/** Stable-sorts `[prop, value]` entries by {@link updatePropRank}. */
+const orderUpdateEntries = (entries) => entries.sort((x, y) => (updatePropRank[x[0]] ?? 3) - (updatePropRank[y[0]] ?? 3));
+/**
+* Normalizes the variadic {@link update}/{@link updateInPlace} arguments (single
+* prop+value, parallel arrays, or property map) into a canonically-ordered list
+* of `[prop, value]` entries plus the target path/ID and options.
+*/
+const normalizeUpdateArgs = (a, b, c, d) => {
+	if (typeof a === "string") return {
+		entries: [[a, b]],
+		pathOrID: c,
+		options: d ?? {}
+	};
+	if (Array.isArray(a)) {
+		const values = b;
+		return {
+			entries: orderUpdateEntries(a.map((prop, i) => [prop, values[i]])),
+			pathOrID: c,
+			options: d ?? {}
+		};
+	}
+	return {
+		entries: orderUpdateEntries(Object.entries(a)),
+		pathOrID: b,
+		options: c ?? {}
+	};
+};
+/**
+* Applies one or more property updates to a query in place. Shared by
+* {@link update} and {@link updateInPlace}.
+*/
+const applyUpdatesInPlace = (query, a, b, c, d) => {
+	const { entries, pathOrID, options } = normalizeUpdateArgs(a, b, c, d);
+	for (const [prop, value] of entries) updateInPlaceSingle(query, prop, value, pathOrID, options);
+	return query;
+};
+/**
+* Updates one or more properties of a rule or group within a query without
+* mutating the original query. Properties may be supplied individually
+* (`prop`, `value`), as parallel arrays (`props`, `values`), or as a
+* property-to-value map. For multi-property updates, `field`, `operator`, and
+* `valueSource` are applied before `value`, so an explicit `value` is never
+* reset by a change to one of those properties.
 *
-* @returns A new query with the rule or group property updated.
+* @returns A new query with the rule or group properties updated.
 *
 * @group Query Tools
 */
-const update = (query, prop, value, pathOrID, options = {}) => produce(query, (q) => updateInPlace(q, prop, value, pathOrID, options));
+const update = ((query, a, b, c, d) => produce(query, (q) => {
+	applyUpdatesInPlace(q, a, b, c, d);
+}));
 /**
-* Updates a property of a rule or group within a query in place.
+* Updates one or more properties of a rule or group within a query in place.
+* See {@link update} for the supported argument forms and ordering semantics.
 *
-* @returns The query (mutated in place) with the rule or group property updated.
+* @returns The query (mutated in place) with the rule or group properties updated.
 *
 * @group Query Tools
 */
-const updateInPlace = (query, prop, value, pathOrID, options = {}) => {
+const updateInPlace = ((query, a, b, c, d) => applyUpdatesInPlace(query, a, b, c, d));
+/**
+* Updates a single property of a rule or group within a query in place.
+*/
+const updateInPlaceSingle = (query, prop, value, pathOrID, options = {}) => {
 	const { resetOnFieldChange: _resetOnFieldChange = true, resetOnOperatorChange = false, getRuleDefaultOperator = () => "=", getValueSources = () => ["value"], getRuleDefaultValue = () => "", getMatchModes = () => [] } = options;
 	let resetOnFieldChange = _resetOnFieldChange;
 	const path = Array.isArray(pathOrID) ? pathOrID : getPathOfID(pathOrID, query);
@@ -5145,6 +5431,6 @@ const groupInPlace = (query, sourcePathOrID, targetPathOrID, options = {}) => {
 	return query;
 };
 //#endregion
-export { LogType, TestID, add, addInPlace, bigIntJsonParseReviver, bigIntJsonStringifyReplacer, celCombinatorMap, clsx, convertFromIC, convertQuery, convertToIC, cypherCombinatorMap, 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, defaultRuleGroupProcessorCypher, defaultRuleGroupProcessorDiagnostics, defaultRuleGroupProcessorDrizzle, defaultRuleGroupProcessorElasticSearch, defaultRuleGroupProcessorGremlin, defaultRuleGroupProcessorJSONata, defaultRuleGroupProcessorJsonLogic, defaultRuleGroupProcessorLDAP, defaultRuleGroupProcessorMongoDB, defaultRuleGroupProcessorMongoDBQuery, defaultRuleGroupProcessorNL, defaultRuleGroupProcessorParameterized, defaultRuleGroupProcessorPrisma, defaultRuleGroupProcessorSPARQL, defaultRuleGroupProcessorSQL, defaultRuleGroupProcessorSequelize, defaultRuleGroupProcessorSpEL, defaultRuleGroupProcessorTanStackDB, defaultRuleProcessorCEL, defaultRuleProcessorCypher, defaultRuleProcessorDrizzle, defaultRuleProcessorElasticSearch, defaultRuleProcessorGremlin, defaultRuleProcessorJSONata, defaultRuleProcessorJsonLogic, defaultRuleProcessorLDAP, defaultRuleProcessorMongoDB, defaultRuleProcessorMongoDBQuery, defaultRuleProcessorNL, defaultRuleProcessorParameterized, defaultRuleProcessorPrisma, defaultRuleProcessorSPARQL, defaultRuleProcessorSQL, defaultRuleProcessorSequelize, defaultRuleProcessorSpEL, defaultRuleProcessorTanStackDB, defaultSpELValueProcessor, defaultTranslations, 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, groupInPlace, groupInvalidReasons, insert, insertInPlace, isAncestor, isFlexibleOptionArray, isFlexibleOptionGroupArray, isFullOptionArray, isFullOptionGroupArray, isOptionGroupArray, isPojo, isRuleGroup, isRuleGroupType, isRuleGroupTypeIC, isRuleOrGroupValid, isRuleType, isUnsafeKey, isValidValue, isValidationResult, isValueProcessorLegacy, joinWith, jsonLogicAdditionalOperators, lc, mapSQLOperator, mergeAnyTranslation, mergeAnyTranslations, mergeClassnames, mongoDbFallback, mongoOperators, move, moveInPlace, normalizeConstituentWordOrder, nullFreeArray, nullOrUndefinedOrEmpty, numericRegex, numerifyValues, objectEntries, objectKeys, parseNumber, pathIsDisabled, pathsAreEqual, preferAnyProp, preferFlagProps, preferProp, prepareOptionList, prepareRule, prepareRuleGroup, prepareRuleOrGroup, prismaFallback, prismaOperators, processMatchMode, queryBuilderFlagDefaults, regenerateID, regenerateIDs, remove, removeInPlace, rootPath, shouldRenderAsNumber, sparqlVar, splitBy, sqlDialectPresets, standardClassnames, toArray, toFlatOptionArray, toFullOption, toFullOptionList, toFullOptionMap, transformQuery, trimIfString, uniqByIdentifier, uniqByName, uniqOptGroups, uniqOptList, update, updateInPlace, uuidV4regex };
+export { LogType, TestID, add, addInPlace, betweenOperators, bigIntJsonParseReviver, bigIntJsonStringifyReplacer, celCombinatorMap, clsx, convertFromIC, convertQuery, convertToIC, cypherCombinatorMap, 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, defaultRuleGroupProcessorCypher, defaultRuleGroupProcessorDiagnostics, defaultRuleGroupProcessorDrizzle, defaultRuleGroupProcessorElasticSearch, defaultRuleGroupProcessorGremlin, defaultRuleGroupProcessorJSONata, defaultRuleGroupProcessorJsonLogic, defaultRuleGroupProcessorLDAP, defaultRuleGroupProcessorMongoDB, defaultRuleGroupProcessorMongoDBQuery, defaultRuleGroupProcessorNL, defaultRuleGroupProcessorParameterized, defaultRuleGroupProcessorPrisma, defaultRuleGroupProcessorSPARQL, defaultRuleGroupProcessorSQL, defaultRuleGroupProcessorSequelize, defaultRuleGroupProcessorSpEL, defaultRuleGroupProcessorTanStackDB, defaultRuleProcessorCEL, defaultRuleProcessorCypher, defaultRuleProcessorDrizzle, defaultRuleProcessorElasticSearch, defaultRuleProcessorGremlin, defaultRuleProcessorJSONata, defaultRuleProcessorJsonLogic, defaultRuleProcessorLDAP, defaultRuleProcessorMongoDB, defaultRuleProcessorMongoDBQuery, defaultRuleProcessorNL, defaultRuleProcessorParameterized, defaultRuleProcessorPrisma, defaultRuleProcessorSPARQL, defaultRuleProcessorSQL, defaultRuleProcessorSequelize, defaultRuleProcessorSpEL, defaultRuleProcessorTanStackDB, defaultSpELValueProcessor, defaultTranslations, defaultValidator, defaultValueProcessor, defaultValueProcessorByRule, defaultValueProcessorCELByRule, defaultValueProcessorMongoDBByRule, defaultValueProcessorNL, defaultValueProcessorSpELByRule, filterFieldsByComparator, findID, findPath, formatQuery, formatQueryOptionPresets, generateAccessibleDescription, generateID, getCommonAncestorPath, getFirstOption, getLikeWildcards, getMatchModesUtil, getNLTranslataion, getOption, getParentPath, getParseNumberMethod, getPathOfID, getQuoteFieldNamesWithArray, getQuotedFieldName, getRuleDefaultValue, getSQLConcat, getValidationClassNames, getValueSourcesUtil, group, groupInPlace, groupInvalidReasons, inOperators, insert, insertInPlace, isAncestor, isFlexibleOptionArray, isFlexibleOptionGroupArray, isFullOptionArray, isFullOptionGroupArray, isOptionGroupArray, isPojo, isRuleGroup, isRuleGroupType, isRuleGroupTypeIC, isRuleOrGroupValid, isRuleType, isUnsafeKey, isValidValue, isValidationResult, isValueProcessorLegacy, joinWith, jsonLogicAdditionalOperators, lc, mapSQLOperator, mergeAnyTranslation, mergeAnyTranslations, mergeClassnames, mongoDbFallback, mongoOperators, move, moveInPlace, normalizeConstituentWordOrder, nullFreeArray, nullOperators, nullOrUndefinedOrEmpty, numericRegex, numerifyValues, objectEntries, objectKeys, parseNumber, pathIsDisabled, pathsAreEqual, preferAnyProp, preferFlagProps, preferProp, prepareOptionList, prepareRule, prepareRuleGroup, prepareRuleOrGroup, prismaFallback, prismaOperators, processMatchMode, queryBuilderFlagDefaults, regenerateID, regenerateIDs, relationalOperators, remove, removeInPlace, rootPath, shouldRenderAsNumber, sparqlVar, splitBy, sqlDialectPresets, standardClassnames, stripParamPrefix, substringOperators, toArray, toFlatOptionArray, toFullOption, toFullOptionList, toFullOptionMap, transformQuery, trimIfString, uniqByIdentifier, uniqByName, uniqOptGroups, uniqOptList, update, updateInPlace, uuidV4regex, withParamPrefix, wrapLikeFragment };
 
 //# sourceMappingURL=react-querybuilder_core.mjs.map