@react-querybuilder/core 8.22.5 → 8.23.1

package/dist/utils-4k-j5FBa.mjs

@@ -1,537 +0,0 @@
-import { a as lc, i as isPojo, s as numericRegex$1, t as isRuleGroup } from "./isRuleGroup-CqLThsbu.mjs";
-import { numericQuantity } from "numeric-quantity";
-//#region src/defaults.ts
-/**
-* Map of default operators to their respective opposite/negating operators.
-*
-* @group Defaults
-*/
-const defaultOperatorNegationMap = {
-	"=": "!=",
-	"!=": "=",
-	"<": ">=",
-	"<=": ">",
-	">": "<=",
-	">=": "<",
-	beginsWith: "doesNotBeginWith",
-	doesNotBeginWith: "beginsWith",
-	endsWith: "doesNotEndWith",
-	doesNotEndWith: "endsWith",
-	contains: "doesNotContain",
-	doesNotContain: "contains",
-	between: "notBetween",
-	notBetween: "between",
-	in: "notIn",
-	notIn: "in",
-	notNull: "null",
-	null: "notNull"
-};
-//#endregion
-//#region src/utils/arrayUtils.ts
-/**
-* Splits a string by a given character (see {@link defaultJoinChar}). Escaped characters
-* (characters preceded by a backslash) will not apply to the split, and the backslash will
-* be removed in the array element. Inverse of {@link joinWith}.
-*
-* @example
-* splitBy('this\\,\\,that,,the other,,,\\,')
-* // or
-* splitBy('this\\,\\,that,,the other,,,\\,', ',')
-* // would return
-* ['this,,that', '', 'the other', '', '', ',']
-*/
-const splitBy = (str, splitChar = ",") => typeof str === "string" ? str.split(`\\${splitChar}`).map((c) => c.split(splitChar)).reduce((prev, curr, idx) => {
-	if (idx === 0) return curr;
-	return [
-		...prev.slice(0, -1),
-		`${prev.at(-1)}${splitChar}${curr[0]}`,
-		...curr.slice(1)
-	];
-}, []) : [];
-/**
-* Joins an array of strings using the given character (see {@link defaultJoinChar}). When
-* the given character appears in an array element, a backslash will be added just before it
-* to distinguish it from the join character. Effectively the inverse of {@link splitBy}.
-*
-* TIP: The join character can actually be a string of any length. Only the first character
-* will be searched for in the array elements and preceded by a backslash.
-*
-* @example
-* joinWith(['this,,that', '', 'the other', '', '', ','], ', ')
-* // would return
-* 'this\\,\\,that, , the other, , , \\,'
-*/
-const joinWith = (strArr, joinChar = ",") => strArr.map((str) => `${str ?? ""}`.replaceAll(joinChar[0], `\\${joinChar[0]}`)).join(joinChar);
-/**
-* Trims the value if it is a string. Otherwise returns the value as is.
-*/
-const trimIfString = (val) => typeof val === "string" ? val.trim() : val;
-/**
-* Splits a string by comma then trims each element. Arrays are returned as is except
-* any string elements are trimmed.
-*/
-const toArray = (a, { retainEmptyStrings } = {}) => Array.isArray(a) ? a.map(trimIfString) : typeof a === "string" ? splitBy(a, ",").filter(retainEmptyStrings ? () => true : (s) => !/^\s*$/.test(s)).map((s) => s.trim()) : typeof a === "number" ? [a] : [];
-//#endregion
-//#region src/utils/parseNumber.ts
-/**
-* Converts a string to a number. Uses native `parseFloat` if `parseNumbers` is "native",
-* otherwise uses [`numeric-quantity`](https://jakeboone02.github.io/numeric-quantity/).
-* If that returns `NaN`, the string is returned unchanged. Numeric values are returned
-* as-is regardless of the `parseNumbers` option.
-*/
-const parseNumber = (val, { parseNumbers, bigIntOnOverflow } = {}) => {
-	if (!parseNumbers || typeof val === "bigint" || typeof val === "number") return val;
-	if (parseNumbers === "native") return Number.parseFloat(val);
-	const valAsNum = numericQuantity(val, {
-		allowTrailingInvalid: parseNumbers === "enhanced",
-		bigIntOnOverflow,
-		romanNumerals: false,
-		round: false
-	});
-	return typeof valAsNum === "bigint" || !Number.isNaN(valAsNum) ? valAsNum : val;
-};
-//#endregion
-//#region src/utils/optGroupUtils.ts
-const isOptionWithName = (opt) => isPojo(opt) && "name" in opt && typeof opt.name === "string";
-const isOptionWithValue = (opt) => isPojo(opt) && "value" in opt && typeof opt.value === "string";
-/**
-* Converts an {@link Option} or {@link ValueOption} (i.e., {@link BaseOption})
-* into a {@link FullOption}. Full options are left unchanged.
-*
-* @group Option Lists
-*/
-function toFullOption(opt, baseProperties, labelMap) {
-	if (typeof opt === "string") return {
-		...baseProperties,
-		name: opt,
-		value: opt,
-		label: labelMap?.[opt] ?? opt
-	};
-	const idObj = {};
-	let needsUpdating = !!baseProperties;
-	if (isOptionWithName(opt) && !isOptionWithValue(opt)) {
-		idObj.value = opt.name;
-		needsUpdating = true;
-	} else if (!isOptionWithName(opt) && isOptionWithValue(opt)) {
-		idObj.name = opt.value;
-		needsUpdating = true;
-	}
-	if (needsUpdating) return Object.assign({}, baseProperties, opt, idObj);
-	return opt;
-}
-/**
-* Converts an {@link OptionList} or {@link FlexibleOptionList} into a {@link FullOptionList}.
-* Lists of full options are left unchanged.
-*
-* @group Option Lists
-*/
-function toFullOptionList(optList, baseProperties, labelMap) {
-	if (!Array.isArray(optList)) return [];
-	const list = optList;
-	if (isFlexibleOptionGroupArray(list)) return list.map((optGroup) => ({
-		...optGroup,
-		options: optGroup.options.map((opt) => toFullOption(opt, baseProperties, labelMap))
-	}));
-	return list.map((opt) => toFullOption(opt, baseProperties, labelMap));
-}
-/**
-* Generates a new array of objects with duplicates removed based
-* on the identifying property (`value` or `name`)
-*
-* @group Option Lists
-*/
-const uniqByIdentifier = (originalArray) => {
-	const names = /* @__PURE__ */ new Set();
-	const newArray = [];
-	for (const el of originalArray) if (!names.has(el.value ?? el.name)) {
-		names.add(el.value ?? el.name);
-		newArray.push(el);
-	}
-	return originalArray.length === newArray.length ? originalArray : newArray;
-};
-/**
-* Determines if an {@link OptionList} is an {@link OptionGroup} array.
-*
-* @group Option Lists
-*/
-const isOptionGroupArray = (arr) => Array.isArray(arr) && arr.length > 0 && isPojo(arr[0]) && "options" in arr[0] && Array.isArray(arr[0].options);
-/**
-* Determines if an array is a flat array of {@link FlexibleOption}.
-*
-* @group Option Lists
-*/
-const isFlexibleOptionArray = (arr) => {
-	let isFOA = false;
-	if (Array.isArray(arr)) for (const o of arr) if (isOptionWithName(o) || isOptionWithValue(o)) isFOA = true;
-	else return false;
-	return isFOA;
-};
-/**
-* Determines if a {@link FlexibleOptionList} is a {@link FlexibleOptionGroup} array.
-*
-* @group Option Lists
-*/
-const isFlexibleOptionGroupArray = (arr, { allowEmpty = false } = {}) => {
-	let isFOGA = false;
-	if (Array.isArray(arr)) for (const og of arr) if (isPojo(og) && "options" in og && (isFlexibleOptionArray(og.options) || allowEmpty && Array.isArray(og.options) && og.options.length === 0)) isFOGA = true;
-	else return false;
-	return isFOGA;
-};
-function getOption(arr, name) {
-	return (isFlexibleOptionGroupArray(arr, { allowEmpty: true }) ? arr.flatMap((og) => og.options) : arr).find((op) => op.value === name || op.name === name);
-}
-/**
-* Flattens {@link FlexibleOptionGroup} arrays into {@link BaseOption} arrays.
-* If the array is already flat, it is returned as is.
-*
-* @group Option Lists
-*/
-const toFlatOptionArray = (arr) => uniqByIdentifier(isOptionGroupArray(arr) ? arr.flatMap((og) => og.options) : arr);
-//#endregion
-//#region src/utils/getParseNumberMethod.ts
-const getParseNumberMethod = ({ parseNumbers, inputType }) => {
-	if (typeof parseNumbers === "string") {
-		const [method, level] = parseNumbers.split("-");
-		if (level === "limited") return inputType === "number" ? method : false;
-		return method;
-	}
-	return parseNumbers ? "strict" : false;
-};
-//#endregion
-//#region src/utils/formatQuery/utils.ts
-/**
-* Maps a {@link DefaultOperatorName} to a SQL operator.
-*
-* @group Export
-*/
-const mapSQLOperator = (rqbOperator) => {
-	switch (lc(rqbOperator)) {
-		case "null": return "is null";
-		case "notnull": return "is not null";
-		case "notin": return "not in";
-		case "notbetween": return "not between";
-		case "contains":
-		case "beginswith":
-		case "endswith": return "like";
-		case "doesnotcontain":
-		case "doesnotbeginwith":
-		case "doesnotendwith": return "not like";
-		default: return 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
-*/
-const mongoOperators = {
-	"=": "$eq",
-	"!=": "$ne",
-	"<": "$lt",
-	"<=": "$lte",
-	">": "$gt",
-	">=": "$gte",
-	in: "$in",
-	notin: "$nin",
-	notIn: "$nin"
-};
-/**
-* Maps a (lowercase) {@link DefaultOperatorName} to a Prisma ORM operator.
-*
-* @group Export
-*/
-const prismaOperators = {
-	"=": "equals",
-	"!=": "not",
-	"<": "lt",
-	"<=": "lte",
-	">": "gt",
-	">=": "gte",
-	in: "in",
-	notin: "notIn"
-};
-/**
-* Maps a {@link DefaultCombinatorName} to a CEL combinator.
-*
-* @group Export
-*/
-const celCombinatorMap = {
-	and: "&&",
-	or: "||"
-};
-/**
-* Register these operators with `jsonLogic` before applying the result
-* of `formatQuery(query, 'jsonlogic')`.
-*
-* @example
-* ```
-* for (const [op, func] of Object.entries(jsonLogicAdditionalOperators)) {
-*   jsonLogic.add_operation(op, func);
-* }
-* jsonLogic.apply({ "startsWith": [{ "var": "firstName" }, "Stev"] }, data);
-* ```
-*
-* @group Export
-*/
-const jsonLogicAdditionalOperators = {
-	startsWith: (a, b) => typeof a === "string" && a.startsWith(b),
-	endsWith: (a, b) => typeof a === "string" && a.endsWith(b)
-};
-/**
-* Returns a new query object with all `string`-type `value` properties converted
-* to `number` where appropriate.
-*
-* Used by {@link formatQuery} for the `json*` formats when `parseNumbers` is `true`.
-*
-* @group Export
-*/
-const numerifyValues = (rg, options) => ({
-	...rg,
-	rules: rg.rules.map((r) => {
-		if (typeof r === "string") return r;
-		if (isRuleGroup(r)) return numerifyValues(r, options);
-		const fieldData = getOption(options.fields, r.field);
-		const parseNumbers = getParseNumberMethod({
-			parseNumbers: options.parseNumbers,
-			inputType: fieldData?.inputType
-		});
-		if (Array.isArray(r.value)) return {
-			...r,
-			value: r.value.map((v) => parseNumber(v, { parseNumbers }))
-		};
-		const valAsArray = toArray(r.value, { retainEmptyStrings: true }).map((v) => parseNumber(v, { parseNumbers }));
-		if (valAsArray.every((v) => typeof v === "number")) {
-			// v8 ignore else
-			if (valAsArray.length > 1) return {
-				...r,
-				value: valAsArray
-			};
-			else if (valAsArray.length === 1) return {
-				...r,
-				value: valAsArray[0]
-			};
-		}
-		return r;
-	})
-});
-/**
-* Determines whether a value is _anything_ except an empty `string` or `NaN`.
-*
-* @group Export
-*/
-const isValidValue = (value) => typeof value === "string" && value.length > 0 || typeof value === "number" && !Number.isNaN(value) || typeof value !== "string" && typeof value !== "number";
-/**
-* Determines whether {@link formatQuery} should render the given value as a number.
-* As long as `parseNumbers` is `true`, `number` and `bigint` values will return `true` and
-* `string` values will return `true` if they test positive against {@link numericRegex}.
-*
-* @group Export
-*/
-const shouldRenderAsNumber = (value, parseNumbers) => !!parseNumbers && (typeof value === "number" || typeof value === "bigint" || typeof value === "string" && numericRegex$1.test(value));
-/**
-* Used by {@link formatQuery} to determine whether the given value processor is a
-* "legacy" value processor by counting the number of arguments. Legacy value
-* processors take 3 arguments (not counting any arguments with default values), while
-* rule-based value processors take no more than 2 arguments.
-*
-* @group Export
-*/
-const isValueProcessorLegacy = (valueProcessor) => valueProcessor.length >= 3;
-/**
-* Converts the `quoteFieldNamesWith` option into an array of two strings.
-* If the option is a string, the array elements are both that string.
-*
-* @default
-* ['', '']
-*
-* @group Export
-*/
-const getQuoteFieldNamesWithArray = (quoteFieldNamesWith = ["", ""]) => Array.isArray(quoteFieldNamesWith) ? quoteFieldNamesWith : typeof quoteFieldNamesWith === "string" ? [quoteFieldNamesWith, quoteFieldNamesWith] : quoteFieldNamesWith ?? ["", ""];
-/**
-* Given a field name and relevant {@link ValueProcessorOptions}, returns the field name
-* wrapped in the configured quote character(s).
-*
-* @group Export
-*/
-const getQuotedFieldName = (fieldName, { quoteFieldNamesWith, fieldIdentifierSeparator }) => {
-	const [qPre, qPost] = getQuoteFieldNamesWithArray(quoteFieldNamesWith);
-	return typeof fieldIdentifierSeparator === "string" && fieldIdentifierSeparator.length > 0 ? joinWith(splitBy(fieldName, fieldIdentifierSeparator).map((part) => `${qPre}${part}${qPost}`), fieldIdentifierSeparator) : `${qPre}${fieldName}${qPost}`;
-};
-const defaultWordOrder = [
-	"S",
-	"V",
-	"O"
-];
-/**
-* Given a [Constituent word order](https://en.wikipedia.org/wiki/Word_order#Constituent_word_orders)
-* like "svo" or "sov", returns a permutation of `["S", "V", "O"]` based on the first occurrence of
-* each letter in the input string (case insensitive). This widens the valid input from abbreviations
-* like "svo" to more expressive strings like "subject-verb-object" or "sub ver obj". Any missing
-* letters are appended in the default order "SVO" (e.g., "object" would yield `["O", "S", "V"]`).
-*
-* @group Export
-*/
-const normalizeConstituentWordOrder = (input) => {
-	const result = [];
-	const letterSet = new Set(defaultWordOrder);
-	for (const char of input.toUpperCase()) if (letterSet.has(char)) {
-		result.push(char);
-		letterSet.delete(char);
-		if (letterSet.size === 0) break;
-	}
-	for (const letter of defaultWordOrder) if (letterSet.has(letter)) result.push(letter);
-	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
-*/
-const defaultNLTranslations = {
-	groupPrefix: "",
-	groupPrefix_not_xor: "either zero or more than one of",
-	groupPrefix_xor: "exactly one of",
-	groupSuffix: "is true",
-	groupSuffix_not: "is not true"
-};
-/**
-* Note: This function assumes `conditions.length > 0`
-*/
-const translationMatchFilter = (key, keyToTest, conditions) => keyToTest.startsWith(key) && conditions.every((c) => keyToTest.includes(`_${c}`) && keyToTest.match(/_/g)?.length === conditions.length);
-/**
-* Used by {@link formatQuery} to get a translation based on certain conditions
-* for the "natural_language" format.
-*
-* @group Export
-*/
-const getNLTranslataion = (key, translations, conditions = []) => conditions.length === 0 ? translations[key] ?? defaultNLTranslations[key] ?? 
-/* v8 ignore start -- @preserve */ "" : Object.entries(translations).find(([keyToTest]) => translationMatchFilter(key, keyToTest, conditions))?.[1] ?? Object.entries(defaultNLTranslations).find(([keyToTest]) => translationMatchFilter(key, keyToTest, conditions))?.[1] ?? defaultNLTranslations[key] ?? 
-/* v8 ignore next -- @preserve */ "";
-/**
-* Transforms
-* - `match: { mode: "atLeast", threshold: 1 }` to `match: { mode: "some" }`
-* - `match: { mode: "atMost", threshold: 0 }` to `match: { mode: "none" }`.
-*
-* Returns:
-* - Processed `{ mode, threshold }` object for valid subqueries
-* - `null` if match mode is not applicable for the rule
-* - `false` if match mode is valid, but either
-*   1. `threshold` is required and invalid, or
-*   2. `value` is not a valid rule group.
-*/
-const processMatchMode = (rule) => {
-	const { mode, threshold } = rule.match ?? {};
-	if (!mode) return null;
-	if (!isRuleGroup(rule.value)) return false;
-	const matchModeLC = lc(mode);
-	const matchModeCoerced = matchModeLC === "atleast" && threshold === 1 ? "some" : matchModeLC === "atmost" && threshold === 0 ? "none" : matchModeLC;
-	if ((matchModeCoerced === "atleast" || matchModeCoerced === "atmost" || matchModeCoerced === "exactly") && (typeof threshold !== "number" || threshold < 0)) return false;
-	return {
-		mode: matchModeCoerced,
-		threshold
-	};
-};
-/**
-* Base alias assigned to the element binding of a subquery generated for a rule's
-* {@link MatchMode `match` mode} (e.g. `unnest(field) as elem_alias`).
-*/
-const subqueryElementAliasBase = "elem_alias";
-/**
-* Returns the element alias for a subquery at the given nesting depth. Depth 0 (the common,
-* non-nested case) uses {@link subqueryElementAliasBase} unchanged; deeper levels are suffixed
-* with the depth, so a subquery nested within a subquery cannot shadow its parent's binding.
-*
-* Deterministic by depth rather than randomized, so output remains stable and snapshot-friendly.
-*
-* @group Export
-*/
-const getSubqueryElementAlias = (subqueryDepth = 0) => subqueryDepth > 0 ? `${subqueryElementAliasBase}_${subqueryDepth}` : subqueryElementAliasBase;
-/**
-* "Replacer" method for JSON.stringify's second argument. Converts `bigint` values to
-* objects with a `$bigint` property having a value of a string representation of
-* the actual `bigint`-type value.
-*
-* Inverse of {@link bigIntJsonParseReviver}.
-*
-* @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt#use_within_json
-*/
-const bigIntJsonStringifyReplacer = (_key, value) => typeof value === "bigint" ? { $bigint: value.toString() } : value;
-/**
-* "Reviver" method for JSON.parse's second argument. Converts objects having a single
-* `$bigint: string` property to an actual `bigint` value.
-*
-* Inverse of {@link bigIntJsonStringifyReplacer}.
-*
-* @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt#use_within_json
-*/
-const bigIntJsonParseReviver = (_key, value) => isPojo(value) && Object.keys(value).length === 1 && typeof value.$bigint === "string" ? BigInt(value.$bigint) : value;
-//#endregion
-export { toFullOption as A, withParamPrefix as C, isFlexibleOptionArray as D, getOption as E, trimIfString as F, defaultOperatorNegationMap as I, parseNumber as M, joinWith as N, isFlexibleOptionGroupArray as O, toArray as P, subqueryElementAliasBase as S, getParseNumberMethod as T, numerifyValues as _, getLikeWildcards as a, shouldRenderAsNumber as b, getQuotedFieldName as c, isValidValue as d, isValueProcessorLegacy as f, normalizeConstituentWordOrder as g, mongoOperators as h, defaultNLTranslations as i, toFullOptionList as j, toFlatOptionArray as k, getSQLConcat as l, mapSQLOperator as m, bigIntJsonStringifyReplacer as n, getNLTranslataion as o, jsonLogicAdditionalOperators as p, celCombinatorMap as r, getQuoteFieldNamesWithArray as s, bigIntJsonParseReviver as t, getSubqueryElementAlias as u, prismaOperators as v, wrapLikeFragment as w, stripParamPrefix as x, processMatchMode as y };
-
-//# sourceMappingURL=utils-4k-j5FBa.mjs.map