@react-querybuilder/core 8.11.1 → 8.12.0

package/dist/formatQuery.mjs

@@ -1,9 +1,7 @@
-import { d as defaultPlaceholderOperatorName, i as toFlatOptionArray, o as toFullOptionList, t as getOption, u as defaultPlaceholderFieldName } from "./optGroupUtils-VeZ3k7-1.mjs";
-import { i as trimIfString, n as splitBy, r as toArray, t as joinWith } from "./arrayUtils-A_OXU9W1.mjs";
-import { a as lc, i as isPojo, n as isRuleGroupType, o as nullOrUndefinedOrEmpty, r as isRuleGroupTypeIC, s as numericRegex, t as isRuleGroup } from "./isRuleGroup-CYcfPgbg.mjs";
-import { t as parseNumber } from "./parseNumber-CXdMVNFx.mjs";
-import { t as transformQuery } from "./transformQuery-DCCpjtyq.mjs";
-import { t as convertFromIC } from "./convertQuery-CqX3rPvj.mjs";
+import { E as parseNumber, M as defaultPlaceholderOperatorName, O as toArray, S as toFlatOptionArray, _ as shouldRenderAsNumber, a as getNLTranslataion, c as isValidValue, d as mapSQLOperator, f as mongoOperators, g as processMatchMode, h as prismaOperators, i as defaultNLTranslations, j as defaultPlaceholderFieldName, k as trimIfString, l as isValueProcessorLegacy, m as numerifyValues, n as bigIntJsonStringifyReplacer, o as getQuoteFieldNamesWithArray, p as normalizeConstituentWordOrder, r as celCombinatorMap, s as getQuotedFieldName, t as bigIntJsonParseReviver, u as jsonLogicAdditionalOperators, v as getParseNumberMethod, w as toFullOptionList, y as getOption } from "./utils-DxH23QtE.mjs";
+import { a as lc, i as isPojo, n as isRuleGroupType, o as nullOrUndefinedOrEmpty, r as isRuleGroupTypeIC, t as isRuleGroup } from "./isRuleGroup-BcfwGaIN.mjs";
+import { t as transformQuery } from "./transformQuery-Bq4iyYsE.mjs";
+import { t as convertFromIC } from "./convertQuery-Cj4t-LT4.mjs";
 import { produce } from "immer";
 
 //#region src/utils/isRuleOrGroupValid.ts
@@ -29,257 +27,6 @@ const isRuleOrGroupValid = (rg, validationResult, validator) => {
 	return true;
 };
 
-//#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;
-	}
-};
-/**
-* 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)
-};
-/**
-* Converts all `string`-type `value` properties of a query object into `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")) {
-			// istanbul 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.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;
-};
-/**
-* 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] ?? "" : Object.entries(translations).find(([keyToTest]) => translationMatchFilter(key, keyToTest, conditions))?.[1] ?? Object.entries(defaultNLTranslations).find(([keyToTest]) => translationMatchFilter(key, keyToTest, conditions))?.[1] ?? defaultNLTranslations[key] ?? "";
-const processMatchMode = (rule) => {
-	const { mode, threshold } = rule.match ?? {};
-	if (mode) {
-		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
-		};
-	}
-};
-/**
-* "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
 //#region src/utils/formatQuery/defaultRuleGroupProcessorCEL.ts
 /**