@react-querybuilder/datetime 8.17.0 → 8.19.0

package/dist/getDatetimeRuleProcessorTanStackDB-BcOC-o2A.mjs

@@ -0,0 +1,1029 @@
+import { defaultOperatorProcessorNL, defaultRuleProcessorCEL, defaultRuleProcessorCypher, defaultRuleProcessorDrizzle, defaultRuleProcessorElasticSearch, defaultRuleProcessorGremlin, defaultRuleProcessorJSONata, defaultRuleProcessorLDAP, defaultRuleProcessorMongoDBQuery, defaultRuleProcessorNL, defaultRuleProcessorParameterized, defaultRuleProcessorPrisma, defaultRuleProcessorSPARQL, defaultRuleProcessorSQL, defaultRuleProcessorSequelize, defaultRuleProcessorSpEL, defaultRuleProcessorTanStackDB, defaultValueProcessorByRule, getQuotedFieldName, lc, mapSQLOperator, mongoOperators, normalizeConstituentWordOrder, nullOrUndefinedOrEmpty, sparqlVar, toArray } from "react-querybuilder";
+//#region src/utils.ts
+const isISOStringDateOnly = (date) => typeof date === "string" && /^\d{4}-\d{2}-\d{2}$/.test(date);
+/**
+* Type guard for {@link RelativeDateTimeValue}. Relative values are stored as objects
+* (distinguishing them from the ISO 8601 strings used for absolute date/time values).
+*/
+const isRelativeDateTimeValue = (value) => typeof value === "object" && value !== null && value.mode === "relative" && typeof value.anchor === "string";
+const anchorRegExp = /^(start|end)Of(Day|Week|Month|Year)$/;
+/**
+* Resolves a {@link RelativeDateTimeValue} into a concrete `Date` using the given
+* date library API. The anchor is applied relative to `base` (defaulting to now),
+* then the signed offset is added.
+*/
+const resolveRelativeDateTime = (apiFns, value, base = /* @__PURE__ */ new Date()) => {
+	let result = base;
+	if (value.anchor !== "now") {
+		const match = anchorRegExp.exec(value.anchor);
+		// v8 ignore next -- guarded by the RelativeDateTimeAnchor type
+		if (match) {
+			const unit = match[2].toLowerCase();
+			result = match[1] === "start" ? apiFns.startOf(result, unit) : apiFns.endOf(result, unit);
+		}
+	}
+	if (value.offset) result = apiFns.add(result, value.offset, value.unit);
+	return result;
+};
+/**
+* Whether a `datatype` represents a date-only (no time component) type, e.g. `date`
+* but not `datetime`/`datetimeoffset`/`timestamp`. Used to choose the precision when
+* materializing a relative value to an ISO 8601 string.
+*/
+const isDateOnlyDatatype = (datatype) => /^date\b/i.test(datatype);
+/**
+* Replaces any {@link RelativeDateTimeValue} in `value` (or in each element, if `value`
+* is an array) with a concrete ISO 8601 string, resolved via
+* {@link resolveRelativeDateTime}. The "now" reference can be pinned with
+* `opts.context.relativeDateTimeBase` for deterministic output; precision (date-only vs
+* full) follows the field's `datatype`. Non-relative values pass through unchanged.
+*/
+const materializeRelativeValues = (apiFns, value, opts) => {
+	const base = opts?.context?.relativeDateTimeBase;
+	const dateOnly = isDateOnlyDatatype(opts?.fieldData?.datatype);
+	const conv = (v) => {
+		if (!isRelativeDateTimeValue(v)) return v;
+		const resolved = resolveRelativeDateTime(apiFns, v, base);
+		return dateOnly ? apiFns.toISOStringDateOnly(resolved) : apiFns.toISOString(resolved);
+	};
+	return Array.isArray(value) ? value.map(conv) : conv(value);
+};
+/**
+* Resolves a rule's operator for export, applying any `context.relativeOperatorMap`
+* entry. Operator-driven mode controllers (see `createOperatorModeController`) use
+* dedicated operator names to signal relative mode; this maps those names to the real
+* comparison operator at format time. Operators absent from the map pass through unchanged.
+*/
+const resolveDatetimeOperator = (...[rule, opts]) => (opts?.context?.relativeOperatorMap)?.[rule.operator] ?? rule.operator;
+/**
+* Prepares a date/time rule for delegation to a non-symbolic default rule processor
+* (e.g. "parameterized", "spel", "ldap", "gremlin", "prisma", "sequelize", "drizzle",
+* "tanstack_db"). Relative values are materialized to concrete dates (these formats have
+* no symbolic relative form), and `between`/`notBetween` operands are ordered
+* chronologically (defaults can't reorder non-numeric date operands). When `asDate` is
+* set, each valid value is converted to a `Date` (for object-based formats); otherwise
+* the materialized ISO 8601 strings are passed through. The resolved `operator` (after
+* any `relativeOperatorMap` mapping) is returned alongside the prepared `value`.
+*/
+const materializeForExport = (apiFns, rule, opts, asDate = false) => {
+	const operator = resolveDatetimeOperator(rule, opts);
+	const materialized = materializeRelativeValues(apiFns, rule.value, opts);
+	let prepared = materialized;
+	if (Array.isArray(materialized) && materialized.length >= 2) {
+		const opLC = operator.toLowerCase();
+		if (opLC === "between" || opLC === "notbetween") {
+			const first = apiFns.toDate(materialized[0]);
+			const second = apiFns.toDate(materialized[1]);
+			if (apiFns.isValid(first) && apiFns.isValid(second) && !apiFns.isBefore(first, second)) prepared = [
+				materialized[1],
+				materialized[0],
+				...materialized.slice(2)
+			];
+		}
+	}
+	if (!asDate) return {
+		operator,
+		value: prepared
+	};
+	const toDateVal = (v) => {
+		const d = apiFns.toDate(v);
+		return apiFns.isValid(d) ? d : v;
+	};
+	return {
+		operator,
+		value: Array.isArray(prepared) ? prepared.map(toDateVal) : toDateVal(prepared)
+	};
+};
+const defaultIsDateField = (...[rule, opts]) => rule.operator !== "contains" && rule.operator !== "beginsWith" && rule.operator !== "endsWith" && rule.operator !== "doesNotContain" && rule.operator !== "doesNotBeginWith" && rule.operator !== "doesNotEndWith" && rule.operator !== "null" && rule.operator !== "notNull" && /^(?:date|datetime|datetimeoffset|timestamp)\b/i.test(opts?.fieldData?.datatype);
+const processIsDateField = (isDateField, ...[rule, opts]) => {
+	if (typeof isDateField === "boolean") return isDateField;
+	if (typeof isDateField === "function") return isDateField(rule, opts);
+	if (Array.isArray(isDateField)) return isDateField.some((condition) => Object.entries(condition).every(([key, value]) => opts?.fieldData?.[key] === value));
+	if (typeof isDateField === "object") return Object.entries(isDateField).every(([key, value]) => opts?.fieldData?.[key] === value);
+	return defaultIsDateField(rule, opts);
+};
+//#endregion
+//#region src/getDatetimeJsonLogicOperations.ts
+/**
+* Custom operations for use with JsonLogic objects generated by
+* {@link datetimeRuleProcessorJsonLogic}.
+*/
+const getDatetimeJsonLogicOperations = (apiFns) => {
+	const { isAfter, isBefore, isSame } = apiFns;
+	return {
+		dateAfter: (a, b) => isAfter(a, b),
+		dateBefore: (a, b) => isBefore(a, b),
+		dateBetween: (a, b, c) => isSame(b, a) || isSame(b, c) || isAfter(b, a) && isBefore(b, c) || isAfter(b, c) && isBefore(b, a),
+		dateNotBetween: (a, b, c) => !isSame(b, a) && !isSame(b, c) && (isBefore(a, c) && (isBefore(b, a) || isAfter(b, c)) || isAfter(a, c) && (isBefore(b, c) || isAfter(b, a))),
+		dateIn: (a, b) => b.some((v) => isSame(a, v)),
+		dateNotIn: (a, b) => b.every((v) => !isSame(a, v)),
+		dateNotOn: (a, b) => !isSame(a, b),
+		dateOn: (a, b) => isSame(a, b),
+		dateOnOrAfter: (a, b) => isAfter(a, b) || isSame(a, b),
+		dateOnOrBefore: (a, b) => isBefore(a, b) || isSame(a, b),
+		dateRelative: (anchor, offset, unit, dateOnly) => {
+			const resolved = resolveRelativeDateTime(apiFns, {
+				mode: "relative",
+				anchor,
+				offset,
+				unit
+			});
+			return dateOnly ? apiFns.toISOStringDateOnly(resolved) : apiFns.toISOString(resolved);
+		}
+	};
+};
+//#endregion
+//#region src/getDatetimeRuleProcessorCEL.ts
+const shouldNegate$3 = (op) => /^(does)?not/i.test(op);
+/**
+* Generates a rule processor with date/time features for use by
+* {@link @react-querybuilder/core!formatQuery formatQuery} with the "cel" format.
+*/
+const getDatetimeRuleProcessorCEL = (apiFns) => (rule, options) => {
+	const opts = options ?? (	/* v8 ignore start -- @preserve */ {});
+	const { context = {} } = opts;
+	if (rule.valueSource === "field" || !processIsDateField(context.isDateField, rule, opts)) return defaultRuleProcessorCEL(rule, opts);
+	const ts = (d) => `timestamp("${apiFns.toISOString(d)}")`;
+	const value = materializeRelativeValues(apiFns, rule.value, opts);
+	const operatorTL = lc(resolveDatetimeOperator(rule, opts).replace(/^=$/, "=="));
+	switch (operatorTL) {
+		case "<":
+		case "<=":
+		case "==":
+		case "!=":
+		case ">":
+		case ">=": return `${rule.field} ${operatorTL} ${ts(value)}`;
+	}
+	const valueAsDateArray = toArray(value, { retainEmptyStrings: false }).map((v) => apiFns.toDate(v)).filter((dateVal) => apiFns.isValid(dateVal));
+	switch (operatorTL) {
+		case "in":
+		case "notin": {
+			if (valueAsDateArray.length === 0) return "";
+			const [prefix, suffix] = shouldNegate$3(operatorTL) ? ["!(", ")"] : ["", ""];
+			return `${prefix}${rule.field} in [${valueAsDateArray.map((val) => ts(val)).join(", ")}]${suffix}`;
+		}
+		case "between":
+		case "notbetween": {
+			if (valueAsDateArray.length < 2) return "";
+			const [first, second] = valueAsDateArray;
+			const [firstDate, secondDate] = apiFns.isBefore(first, second) ? [first, second] : [second, first];
+			return operatorTL === "between" ? `(${rule.field} >= ${ts(firstDate)} && ${rule.field} <= ${ts(secondDate)})` : `(${rule.field} < ${ts(firstDate)} || ${rule.field} > ${ts(secondDate)})`;
+		}
+	}
+	return defaultRuleProcessorCEL(rule, opts);
+};
+//#endregion
+//#region src/getDatetimeRuleProcessorCypher.ts
+const shouldNegate$2 = (op) => /^(does)?not/i.test(op);
+/**
+* Wraps a date string in the appropriate Cypher temporal constructor.
+* - Date-only strings (YYYY-MM-DD) become `date('...')`
+* - Full ISO strings become `datetime('...')`
+*/
+const cypherTemporal = (iso, dateOnly) => dateOnly ? `date('${iso}')` : `datetime('${iso}')`;
+/**
+* Generates a rule processor with date/time features for use by
+* {@link @react-querybuilder/core!formatQuery formatQuery} with the "cypher" or "gql" format.
+*
+* Supports:
+* - Standard comparison operators (`=`, `!=`, `<`, `>`, `<=`, `>=`)
+* - Range operators (between, notBetween, in, notIn)
+* - Duration math via custom operators: `olderThanDuration` and `withinDuration`
+*   (e.g., value `"P30D"` → `datetime() - field > duration('P30D')`)
+*/
+const getDatetimeRuleProcessorCypher = (apiFns) => (rule, options) => {
+	const opts = options ?? (	/* v8 ignore start -- @preserve */ {});
+	const { context = {} } = opts;
+	if (rule.valueSource === "field" || !processIsDateField(context.isDateField, rule, opts)) return defaultRuleProcessorCypher(rule, opts);
+	const { field } = rule;
+	const operatorTL = lc(resolveDatetimeOperator(rule, opts));
+	if (operatorTL === "olderthanduration") return `datetime() - ${field} > duration('${rule.value}')`;
+	if (operatorTL === "withinduration") return `datetime() - ${field} <= duration('${rule.value}')`;
+	const valueAsDateArray = toArray(materializeRelativeValues(apiFns, rule.value, opts), { retainEmptyStrings: false }).map((v) => [v, apiFns.toDate(v)]).filter(([, d]) => apiFns.isValid(d));
+	const fmtDate = (originalValue) => {
+		const dateOnly = isISOStringDateOnly(originalValue);
+		return cypherTemporal(dateOnly ? apiFns.toISOStringDateOnly(originalValue) : apiFns.toISOString(originalValue), dateOnly);
+	};
+	switch (operatorTL) {
+		case "in":
+		case "notin": {
+			if (valueAsDateArray.length === 0) return "";
+			const items = valueAsDateArray.map(([orig]) => fmtDate(orig));
+			return `${shouldNegate$2(operatorTL) ? "NOT " : ""}${field} IN [${items.join(", ")}]`;
+		}
+		case "between":
+		case "notbetween": {
+			if (valueAsDateArray.length < 2) return "";
+			const [first, second] = valueAsDateArray;
+			const [lo, hi] = apiFns.isBefore(first[1], second[1]) ? [first, second] : [second, first];
+			const expr = `${fmtDate(lo[0])} <= ${field} AND ${field} <= ${fmtDate(hi[0])}`;
+			return operatorTL === "notbetween" ? `NOT (${expr})` : expr;
+		}
+		default: {
+			if (valueAsDateArray.length === 0) return "";
+			const [orig] = valueAsDateArray[0];
+			return `${field} ${operatorTL === "<>" ? "<>" : operatorTL} ${fmtDate(orig)}`;
+		}
+	}
+};
+//#endregion
+//#region src/getDatetimeRuleProcessorDrizzle.ts
+/**
+* Generates a rule processor with date/time features for use by
+* {@link @react-querybuilder/core!formatQuery formatQuery} with the "drizzle" format.
+* Relative values are materialized and all date/time values are converted to `Date`
+* objects (Drizzle column operators compare against native `Date` values).
+*/
+const getDatetimeRuleProcessorDrizzle = (apiFns) => (rule, options) => {
+	const opts = options ?? (	/* v8 ignore start -- @preserve */ {});
+	const { context = {} } = opts;
+	if (rule.valueSource === "field" || !processIsDateField(context.isDateField, rule, opts)) return defaultRuleProcessorDrizzle(rule, opts);
+	const { operator, value } = materializeForExport(apiFns, rule, opts, true);
+	return defaultRuleProcessorDrizzle({
+		...rule,
+		operator,
+		value
+	}, opts);
+};
+//#endregion
+//#region src/getDatetimeRuleProcessorElasticSearch.ts
+/**
+* Generates a rule processor with date/time features for use by
+* {@link @react-querybuilder/core!formatQuery formatQuery} with the "elasticsearch" format.
+* Relative values are materialized to concrete ISO 8601 strings (ElasticSearch has no
+* symbolic relative form); absolute values pass through.
+*/
+const getDatetimeRuleProcessorElasticSearch = (apiFns) => (rule, options) => {
+	const opts = options ?? (	/* v8 ignore start -- @preserve */ {});
+	const { context = {} } = opts;
+	if (rule.valueSource === "field" || !processIsDateField(context.isDateField, rule, opts)) return defaultRuleProcessorElasticSearch(rule, opts);
+	const { operator, value } = materializeForExport(apiFns, rule, opts);
+	return defaultRuleProcessorElasticSearch({
+		...rule,
+		operator,
+		value
+	}, opts);
+};
+//#endregion
+//#region src/getDatetimeRuleProcessorGremlin.ts
+/**
+* Generates a rule processor with date/time features for use by
+* {@link @react-querybuilder/core!formatQuery formatQuery} with the "gremlin" format.
+* Relative values are materialized to concrete ISO 8601 strings (Gremlin has no symbolic
+* relative form); absolute values pass through.
+*/
+const getDatetimeRuleProcessorGremlin = (apiFns) => (rule, options) => {
+	const opts = options ?? (	/* v8 ignore start -- @preserve */ {});
+	const { context = {} } = opts;
+	if (rule.valueSource === "field" || !processIsDateField(context.isDateField, rule, opts)) return defaultRuleProcessorGremlin(rule, opts);
+	const { operator, value } = materializeForExport(apiFns, rule, opts);
+	return defaultRuleProcessorGremlin({
+		...rule,
+		operator,
+		value
+	}, opts);
+};
+//#endregion
+//#region src/getDatetimeRuleProcessorJSONata.ts
+const shouldNegate$1 = (op) => /^(does)?not/i.test(op);
+const negate = (clause, neg) => neg ? `$not(${clause})` : `${clause}`;
+/**
+* Generates a rule processor with date/time features for use by
+* {@link @react-querybuilder/core!formatQuery formatQuery} with the "jsonata" format.
+*/
+const getDatetimeRuleProcessorJSONata = (apiFns) => (rule, options) => {
+	const opts = options ?? (	/* v8 ignore start -- @preserve */ {});
+	const { context = {} } = opts;
+	// v8 ignore next
+	const { quoteFieldNamesWith = ["", ""], fieldIdentifierSeparator = "" } = opts;
+	const { field, valueSource } = rule;
+	const operator = resolveDatetimeOperator(rule, opts);
+	if (!processIsDateField(context.isDateField, rule, opts)) return defaultRuleProcessorJSONata(rule, opts);
+	const valueIsField = valueSource === "field";
+	const value = valueIsField ? rule.value : materializeRelativeValues(apiFns, rule.value, opts);
+	const fldToMs = (f) => `$toMillis(${getQuotedFieldName(f, {
+		quoteFieldNamesWith,
+		fieldIdentifierSeparator
+	})})`;
+	const valToMs = (v) => `$toMillis("${apiFns.toISOString(v)}")`;
+	switch (operator) {
+		case "<":
+		case "<=":
+		case "=":
+		case "!=":
+		case ">":
+		case ">=": return `${fldToMs(field)} ${operator} ${valueIsField ? fldToMs(value) : valToMs(value)}`;
+	}
+	const valueAsArray = toArray(value, { retainEmptyStrings: false });
+	const valueAsDateArray = valueAsArray.map((v) => apiFns.toDate(v)).filter((dateVal) => apiFns.isValid(dateVal));
+	switch (operator) {
+		case "in":
+		case "notIn":
+			if (valueIsField) {
+				if (valueAsArray.length === 0) return "";
+				return negate(`${fldToMs(field)} in [${valueAsArray.map((val) => fldToMs(val)).join(", ")}]`, shouldNegate$1(operator));
+			}
+			if (valueAsDateArray.length === 0) return "";
+			return negate(`${fldToMs(field)} in [${valueAsDateArray.map((val) => valToMs(val)).join(", ")}]`, shouldNegate$1(operator));
+		case "between":
+		case "notBetween": {
+			if (valueAsArray.length < 2 || nullOrUndefinedOrEmpty(valueAsArray[0]) || nullOrUndefinedOrEmpty(valueAsArray[1]) || !valueIsField && valueAsDateArray.length < 2) return "";
+			if (valueIsField) {
+				const [firstValue, secondValue] = valueAsArray;
+				const expression = `${fldToMs(field)} >= ${fldToMs(firstValue)} and ${fldToMs(field)} <= ${fldToMs(secondValue)}`;
+				return operator === "between" ? `(${expression})` : negate(expression, true);
+			}
+			const [first, second] = valueAsDateArray;
+			const [firstDate, secondDate] = apiFns.isBefore(first, second) ? [first, second] : [second, first];
+			const expression = `${fldToMs(field)} >= ${valToMs(firstDate)} and ${fldToMs(field)} <= ${valToMs(secondDate)}`;
+			return operator === "between" ? `(${expression})` : negate(expression, true);
+		}
+	}
+	return defaultRuleProcessorJSONata(rule, opts);
+};
+//#endregion
+//#region src/getDatetimeRuleProcessorLDAP.ts
+/**
+* Generates a rule processor with date/time features for use by
+* {@link @react-querybuilder/core!formatQuery formatQuery} with the "ldap" format.
+* Relative values are materialized to concrete ISO 8601 strings (LDAP has no symbolic
+* relative form); absolute values pass through.
+*/
+const getDatetimeRuleProcessorLDAP = (apiFns) => (rule, options) => {
+	const opts = options ?? (	/* v8 ignore start -- @preserve */ {});
+	const { context = {} } = opts;
+	if (rule.valueSource === "field" || !processIsDateField(context.isDateField, rule, opts)) return defaultRuleProcessorLDAP(rule, opts);
+	const { operator, value } = materializeForExport(apiFns, rule, opts);
+	return defaultRuleProcessorLDAP({
+		...rule,
+		operator,
+		value
+	}, opts);
+};
+//#endregion
+//#region src/getDatetimeRuleProcessorMongoDBQuery.ts
+/**
+* Generates a rule processor with date/time features for use by
+* {@link @react-querybuilder/core!formatQuery formatQuery} with the "mongodb_query" format.
+*/
+const getDatetimeRuleProcessorMongoDBQuery = (apiFns) => (rule, options) => {
+	const opts = options ?? (	/* v8 ignore start -- @preserve */ {});
+	const { field, valueSource } = rule;
+	const operator = resolveDatetimeOperator(rule, opts);
+	if (valueSource === "field" || !processIsDateField(opts.context?.isDateField, rule, opts)) return defaultRuleProcessorMongoDBQuery(rule, opts);
+	const value = materializeRelativeValues(apiFns, rule.value, opts);
+	if (operator === "=") return { [field]: apiFns.toDate(value) };
+	switch (operator) {
+		case "<":
+		case "<=":
+		case "!=":
+		case ">":
+		case ">=": return { [field]: { [mongoOperators[operator]]: apiFns.toDate(value) } };
+	}
+	const valueAsDateArray = toArray(value, { retainEmptyStrings: false }).map((v) => apiFns.toDate(v)).filter((dateVal) => apiFns.isValid(dateVal));
+	switch (operator) {
+		case "in":
+		case "notIn": return { [field]: { [mongoOperators[operator]]: valueAsDateArray } };
+		case "between":
+		case "notBetween": {
+			if (valueAsDateArray.length < 2) return "";
+			const [first, second] = valueAsDateArray;
+			const orderedArray = apiFns.isBefore(first, second) ? [first, second] : [second, first];
+			return operator === "between" ? { [field]: {
+				$gte: orderedArray[0],
+				$lte: orderedArray[1]
+			} } : { $or: [{ [field]: { $lt: orderedArray[0] } }, { [field]: { $gt: orderedArray[1] } }] };
+		}
+	}
+	return defaultRuleProcessorMongoDBQuery(rule, opts);
+};
+//#endregion
+//#region src/getDatetimeRuleProcessorMongoDB.ts
+/**
+* Generates a rule processor with date/time features for use by
+* {@link @react-querybuilder/core!formatQuery formatQuery} with the (deprecated) "mongodb"
+* format. Delegates to the "mongodb_query" date/time processor and serializes the result;
+* `Date` values serialize to ISO 8601 strings.
+*/
+const getDatetimeRuleProcessorMongoDB = (apiFns) => {
+	const mongoDBQueryProcessor = getDatetimeRuleProcessorMongoDBQuery(apiFns);
+	return (rule, options) => {
+		const queryObj = mongoDBQueryProcessor(rule, options);
+		return queryObj ? JSON.stringify(queryObj) : "";
+	};
+};
+//#endregion
+//#region src/getDatetimeRuleProcessorNL.ts
+const defaultDateTimeNLOperatorMap = {
+	"<": "is before",
+	">": "is after",
+	"<=": "is on or before",
+	">=": "is on or after",
+	in: ["is one of the dates", "is the same as a date in"],
+	notin: ["is not one of the dates", "is not the same as any date in"],
+	between: ["is between", "is between the dates in"],
+	notbetween: ["is not between", "is not between the dates in"]
+};
+/**
+* Generates a value processor with date/time features for use by
+* {@link @react-querybuilder/core!formatQuery formatQuery} with the "natural_language" format.
+*/
+const datetimeValueProcessorNL = (rule, opts) => {
+	if (isISOStringDateOnly(opts?.context?.originalValue)) return new Intl.DateTimeFormat(opts?.context?.locales, {
+		dateStyle: "full",
+		...opts?.context?.dateFormat
+	}).format(rule.value);
+	return new Intl.DateTimeFormat(opts?.context?.locales, {
+		dateStyle: "full",
+		timeStyle: "long",
+		...opts?.context?.dateTimeFormat
+	}).format(rule.value);
+};
+/**
+* Generates a rule processor with date/time features for use by {@link @react-querybuilder/core!formatQuery formatQuery} with
+* the "natural_language" format.
+*/
+const getDatetimeRuleProcessorNL = (apiFns) => (rule, options) => {
+	const opts = options ?? (	/* v8 ignore start -- @preserve */ {});
+	const operator = resolveDatetimeOperator(rule, opts);
+	const operatorLowerCase = lc(operator);
+	let finalValue = "";
+	// v8 ignore next
+	const { fieldData, quoteFieldNamesWith = ["", ""], fieldIdentifierSeparator = "", operatorProcessor = defaultOperatorProcessorNL, wordOrder = "SVO", context = {}, operatorMap = defaultDateTimeNLOperatorMap } = opts;
+	if (!processIsDateField(context.isDateField, rule, opts)) return defaultRuleProcessorNL(rule, opts);
+	if (rule.valueSource === "field") return defaultRuleProcessorNL(rule, {
+		...opts,
+		operatorMap: defaultDateTimeNLOperatorMap
+	});
+	if ((operatorLowerCase === "in" || operatorLowerCase === "notin" || operatorLowerCase === "between" || operatorLowerCase === "notbetween") && !rule.value) return "";
+	const valueAsDateArray = toArray(materializeRelativeValues(apiFns, rule.value, opts), { retainEmptyStrings: false }).map((v) => [v, apiFns.toDate(v)]).filter((v) => apiFns.isValid(v[1]));
+	switch (operatorLowerCase) {
+		case "in":
+		case "notin":
+			if (valueAsDateArray.length === 0) return "";
+			finalValue = `(${valueAsDateArray.map((value) => datetimeValueProcessorNL({
+				field: rule.field,
+				operator: "=",
+				value: value[1]
+			}, {
+				...opts,
+				context: {
+					...context,
+					originalValue: value[0]
+				}
+			})).join(", ")})`;
+			break;
+		case "between":
+		case "notbetween":
+			{
+				if (valueAsDateArray.length < 2) return "";
+				const [first, second] = valueAsDateArray;
+				finalValue = (apiFns.isBefore(first[1], second[1]) ? [first, second] : [second, first]).map(([originalValue, value]) => datetimeValueProcessorNL({
+					field: rule.field,
+					operator: "=",
+					value
+				}, {
+					...opts,
+					context: {
+						...context,
+						originalValue
+					}
+				})).join(` ${opts.translations?.and ?? "and"} `);
+			}
+			break;
+		default: {
+			const [originalValue, value] = valueAsDateArray[0] ?? ["", ""];
+			finalValue = originalValue ? datetimeValueProcessorNL({
+				field: rule.field,
+				operator: "=",
+				value
+			}, {
+				...opts,
+				context: {
+					...context,
+					originalValue
+				}
+			}) : "";
+		}
+	}
+	const wordOrderMap = {
+		S: getQuotedFieldName(fieldData?.label ?? rule.field, {
+			quoteFieldNamesWith,
+			fieldIdentifierSeparator
+		}),
+		V: operatorProcessor({
+			...rule,
+			operator
+		}, {
+			...opts,
+			operatorMap: {
+				...defaultDateTimeNLOperatorMap,
+				...operatorMap
+			}
+		}),
+		O: finalValue
+	};
+	return normalizeConstituentWordOrder(wordOrder).map((term) => `${wordOrderMap[term]}`).join(" ").trim();
+};
+//#endregion
+//#region src/getDatetimeRuleProcessorParameterized.ts
+/**
+* Generates a rule processor with date/time features for use by
+* {@link @react-querybuilder/core!formatQuery formatQuery} with the "parameterized" and
+* "parameterized_named" formats. Relative values are materialized to concrete ISO 8601
+* strings (these formats have no symbolic relative form); absolute values pass through.
+*/
+const getDatetimeRuleProcessorParameterized = (apiFns) => (rule, options, meta) => {
+	const opts = options ?? (	/* v8 ignore start -- @preserve */ {});
+	const { context = {} } = opts;
+	if (rule.valueSource === "field" || !processIsDateField(context.isDateField, rule, opts)) return defaultRuleProcessorParameterized(rule, opts, meta);
+	const { operator, value } = materializeForExport(apiFns, rule, opts);
+	return defaultRuleProcessorParameterized({
+		...rule,
+		operator,
+		value
+	}, opts, meta);
+};
+//#endregion
+//#region src/getDatetimeRuleProcessorPrisma.ts
+/**
+* Generates a rule processor with date/time features for use by
+* {@link @react-querybuilder/core!formatQuery formatQuery} with the "prisma" format.
+* Relative values are materialized and all date/time values are converted to `Date`
+* objects (Prisma's `where` clauses use native `Date` values for date columns).
+*/
+const getDatetimeRuleProcessorPrisma = (apiFns) => (rule, options) => {
+	const opts = options ?? (	/* v8 ignore start -- @preserve */ {});
+	const { context = {} } = opts;
+	if (rule.valueSource === "field" || !processIsDateField(context.isDateField, rule, opts)) return defaultRuleProcessorPrisma(rule, opts);
+	const { operator, value } = materializeForExport(apiFns, rule, opts, true);
+	return defaultRuleProcessorPrisma({
+		...rule,
+		operator,
+		value
+	}, opts);
+};
+//#endregion
+//#region src/getDatetimeRuleProcessorSequelize.ts
+/**
+* Generates a rule processor with date/time features for use by
+* {@link @react-querybuilder/core!formatQuery formatQuery} with the "sequelize" format.
+* Relative values are materialized and all date/time values are converted to `Date`
+* objects (Sequelize `where` clauses use native `Date` values for date columns).
+*/
+const getDatetimeRuleProcessorSequelize = (apiFns) => (rule, options) => {
+	const opts = options ?? (	/* v8 ignore start -- @preserve */ {});
+	const { context = {} } = opts;
+	if (rule.valueSource === "field" || !processIsDateField(context.isDateField, rule, opts)) return defaultRuleProcessorSequelize(rule, opts);
+	const { operator, value } = materializeForExport(apiFns, rule, opts, true);
+	return defaultRuleProcessorSequelize({
+		...rule,
+		operator,
+		value
+	}, opts);
+};
+//#endregion
+//#region src/getDatetimeRuleProcessorSPARQL.ts
+const shouldNegate = (op) => /^(does)?not/i.test(op);
+/**
+* Wraps a date string in the appropriate SPARQL typed literal.
+* - Date-only strings (YYYY-MM-DD) become `"..."^^xsd:date`
+* - Full ISO strings become `"..."^^xsd:dateTime`
+*/
+const sparqlTemporal = (iso, dateOnly) => dateOnly ? `"${iso}"^^xsd:date` : `"${iso}"^^xsd:dateTime`;
+/**
+* Generates a rule processor with date/time features for use by
+* {@link @react-querybuilder/core!formatQuery formatQuery} with the "sparql" format.
+*
+* Supports:
+* - Standard comparison operators (`=`, `!=`, `<`, `>`, `<=`, `>=`)
+* - Range operators (between, notBetween, in, notIn)
+* - Duration math via custom operators: `olderThanDuration` and `withinDuration`
+*   (e.g., value `"P30D"` → `NOW() - ?field > "P30D"^^xsd:duration`)
+*/
+const getDatetimeRuleProcessorSPARQL = (apiFns) => (rule, options) => {
+	const opts = options ?? (	/* v8 ignore start -- @preserve */ {});
+	const { context = {} } = opts;
+	if (rule.valueSource === "field" || !processIsDateField(context.isDateField, rule, opts)) return defaultRuleProcessorSPARQL(rule, opts);
+	const { field: rawField, value } = rule;
+	const operator = resolveDatetimeOperator(rule, opts);
+	const field = sparqlVar(rawField);
+	const operatorTL = lc(operator);
+	if (operatorTL === "olderthanduration") return `NOW() - ${field} > "${value}"^^xsd:duration`;
+	if (operatorTL === "withinduration") return `NOW() - ${field} <= "${value}"^^xsd:duration`;
+	const valueAsDateArray = toArray(materializeRelativeValues(apiFns, value, opts), { retainEmptyStrings: false }).map((v) => [v, apiFns.toDate(v)]).filter(([, d]) => apiFns.isValid(d));
+	const fmtDate = (originalValue) => {
+		const dateOnly = isISOStringDateOnly(originalValue);
+		return sparqlTemporal(dateOnly ? apiFns.toISOStringDateOnly(originalValue) : apiFns.toISOString(originalValue), dateOnly);
+	};
+	switch (operatorTL) {
+		case "in":
+		case "notin": {
+			if (valueAsDateArray.length === 0) return "";
+			const items = valueAsDateArray.map(([orig]) => fmtDate(orig));
+			return `${field} ${shouldNegate(operatorTL) ? "NOT " : ""}IN (${items.join(", ")})`;
+		}
+		case "between":
+		case "notbetween": {
+			if (valueAsDateArray.length < 2) return "";
+			const [first, second] = valueAsDateArray;
+			const [lo, hi] = apiFns.isBefore(first[1], second[1]) ? [first, second] : [second, first];
+			if (operatorTL === "notbetween") return `(${field} < ${fmtDate(lo[0])} || ${field} > ${fmtDate(hi[0])})`;
+			return `${field} >= ${fmtDate(lo[0])} && ${field} <= ${fmtDate(hi[0])}`;
+		}
+		default: {
+			if (valueAsDateArray.length === 0) return "";
+			const [orig] = valueAsDateArray[0];
+			return `${field} ${operatorTL === "<>" ? "!=" : operatorTL} ${fmtDate(orig)}`;
+		}
+	}
+};
+//#endregion
+//#region src/getDatetimeRuleProcessorSpEL.ts
+/**
+* Generates a rule processor with date/time features for use by
+* {@link @react-querybuilder/core!formatQuery formatQuery} with the "spel" format.
+* Relative values are materialized to concrete ISO 8601 strings (SpEL has no symbolic
+* relative form); absolute values pass through.
+*/
+const getDatetimeRuleProcessorSpEL = (apiFns) => (rule, options) => {
+	const opts = options ?? (	/* v8 ignore start -- @preserve */ {});
+	const { context = {} } = opts;
+	if (rule.valueSource === "field" || !processIsDateField(context.isDateField, rule, opts)) return defaultRuleProcessorSpEL(rule, opts);
+	const { operator, value } = materializeForExport(apiFns, rule, opts);
+	return defaultRuleProcessorSpEL({
+		...rule,
+		operator,
+		value
+	}, opts);
+};
+//#endregion
+//#region src/getRelativeDateTimeSQL.ts
+const parseAnchor = (anchor) => {
+	if (anchor === "now") return { bound: "now" };
+	const match = /^(start|end)Of(Day|Week|Month|Year)$/.exec(anchor);
+	return {
+		bound: match[1],
+		unit: match[2].toLowerCase()
+	};
+};
+const pluralUnit = (unit) => `${unit}s`;
+const pgBuild = (value, asDate) => {
+	const now = asDate ? "current_date" : "current_timestamp";
+	const { bound, unit } = parseAnchor(value.anchor);
+	let expr = now;
+	let modified = false;
+	if (bound === "start" && unit) {
+		expr = `date_trunc('${unit}', ${now})`;
+		modified = true;
+	} else if (bound === "end" && unit) {
+		expr = `date_trunc('${unit}', ${now}) + interval '1 ${unit}' - ${asDate ? `interval '1 day'` : `interval '1 microsecond'`}`;
+		modified = true;
+	}
+	if (value.offset) {
+		const op = value.offset < 0 ? "-" : "+";
+		expr = `${expr} ${op} interval '${Math.abs(value.offset)} ${pluralUnit(value.unit)}'`;
+		modified = true;
+	}
+	return asDate && modified ? `cast(${expr} as date)` : expr;
+};
+const mysqlTrunc = (now, bound, unit) => {
+	if (bound === "start") switch (unit) {
+		case "day": return `date(${now})`;
+		case "week": return `date_sub(date(${now}), interval dayofweek(${now}) - 1 day)`;
+		case "month": return `date_format(${now}, '%Y-%m-01')`;
+		case "year": return `date_format(${now}, '%Y-01-01')`;
+	}
+	switch (unit) {
+		case "day": return `date(${now})`;
+		case "week": return `date_add(date(${now}), interval 7 - dayofweek(${now}) day)`;
+		case "month": return `last_day(${now})`;
+	}
+	return `date_format(${now}, '%Y-12-31')`;
+};
+const mysqlBuild = (value, asDate) => {
+	const now = asDate ? "curdate()" : "now()";
+	const { bound, unit } = parseAnchor(value.anchor);
+	let expr = now;
+	if (bound !== "now" && unit) {
+		expr = mysqlTrunc(now, bound, unit);
+		if (bound === "end" && !asDate) expr = `date_sub(date_add(${expr}, interval 1 day), interval 1 microsecond)`;
+	}
+	if (value.offset) expr = `${value.offset < 0 ? "date_sub" : "date_add"}(${expr}, interval ${Math.abs(value.offset)} ${value.unit})`;
+	return expr;
+};
+const mssqlTrunc = (now, bound, unit, asDate) => {
+	const start = `dateadd(${unit}, datediff(${unit}, 0, ${now}), 0)`;
+	if (bound === "start") return start;
+	const nextStart = `dateadd(${unit}, datediff(${unit}, 0, ${now}) + 1, 0)`;
+	return asDate ? `dateadd(day, -1, ${nextStart})` : `dateadd(nanosecond, -100, cast(${nextStart} as datetime2))`;
+};
+const mssqlBuild = (value, asDate) => {
+	const now = asDate ? "cast(getdate() as date)" : "getdate()";
+	const { bound, unit } = parseAnchor(value.anchor);
+	let expr = now;
+	if (bound !== "now" && unit) expr = mssqlTrunc(now, bound, unit, asDate);
+	if (value.offset) expr = `dateadd(${value.unit}, ${value.offset}, ${expr})`;
+	return expr;
+};
+const oracleTruncFormat = {
+	day: "DDD",
+	week: "IW",
+	month: "MM",
+	year: "YYYY"
+};
+const oracleBuild = (value, asDate) => {
+	const now = asDate ? "trunc(sysdate)" : "systimestamp";
+	const { bound, unit } = parseAnchor(value.anchor);
+	let expr = now;
+	let endTimestampStepBack = false;
+	if (bound !== "now" && unit) {
+		const start = `trunc(${now}, '${oracleTruncFormat[unit]}')`;
+		if (bound === "start") expr = start;
+		else {
+			const next = unit === "month" || unit === "year" ? `add_months(${start}, ${unit === "month" ? 1 : 12})` : `${start} + interval '1' day${unit === "week" ? " * 7" : ""}`;
+			if (asDate) expr = `${next} - interval '1' second`;
+			else {
+				expr = next;
+				endTimestampStepBack = true;
+			}
+		}
+	}
+	if (value.offset) if (value.unit === "month" || value.unit === "year") expr = `add_months(${expr}, ${value.offset * (value.unit === "year" ? 12 : 1)})`;
+	else {
+		const days = {
+			day: 1,
+			week: 7
+		}[value.unit];
+		expr = days ? `${expr} ${value.offset < 0 ? "-" : "+"} ${Math.abs(value.offset) * days}` : `${expr} + numtodsinterval(${value.offset}, '${value.unit.toUpperCase()}')`;
+	}
+	if (endTimestampStepBack) expr = `cast(${expr} as timestamp) - numtodsinterval(0.000001, 'second')`;
+	return expr;
+};
+const sqliteStartModifier = {
+	day: `'start of day'`,
+	week: `'weekday 0', '-7 days'`,
+	month: `'start of month'`,
+	year: `'start of year'`
+};
+const sqliteBuild = (value, asDate) => {
+	const fn = asDate ? "date" : "datetime";
+	const args = [`'now'`];
+	const { bound, unit } = parseAnchor(value.anchor);
+	if (bound !== "now" && unit) if (bound === "start") args.push(sqliteStartModifier[unit]);
+	else switch (unit) {
+		case "day":
+			args.push(`'start of day'`, `'+1 day'`, asDate ? `'-1 day'` : `'-1 second'`);
+			break;
+		case "week":
+			args.push(`'weekday 0'`, asDate ? `'-1 day'` : `'-1 second'`);
+			break;
+		case "month":
+			args.push(`'start of month'`, `'+1 month'`, asDate ? `'-1 day'` : `'-1 second'`);
+			break;
+		case "year":
+			args.push(`'start of year'`, `'+1 year'`, asDate ? `'-1 day'` : `'-1 second'`);
+			break;
+	}
+	if (value.offset) {
+		const sign = value.offset < 0 ? "-" : "+";
+		args.push(`'${sign}${Math.abs(value.offset)} ${pluralUnit(value.unit)}'`);
+	}
+	return `${fn}(${args.join(", ")})`;
+};
+const presetToRelativeBuilderMap = {
+	ansi: pgBuild,
+	mssql: mssqlBuild,
+	mysql: mysqlBuild,
+	oracle: oracleBuild,
+	postgresql: pgBuild,
+	sqlite: sqliteBuild
+};
+/**
+* Determines whether the SQL expression for a relative date/time should be a
+* date (vs. a timestamp/datetime) based on the field's declared `datatype` and
+* the SQL dialect. Mirrors the per-dialect logic used for literal date values.
+*/
+const isDateGranularity = (preset, datatype) => {
+	const dt = datatype;
+	switch (preset) {
+		case "mssql": return !/^(?:small)?datetime/i.test(dt);
+		case "mysql": return !/^(?:datetime|timestamp)/i.test(dt);
+		case "oracle":
+		case "postgresql": return !/^timestamp/i.test(dt);
+		default: return !/^(?:datetime|timestamp)/i.test(dt);
+	}
+};
+/**
+* Builds a dialect-specific symbolic SQL expression for a {@link RelativeDateTimeValue}.
+*/
+const getRelativeDateTimeSQL = (value, preset, datatype) => presetToRelativeBuilderMap[preset](value, isDateGranularity(preset, datatype));
+//#endregion
+//#region src/getDatetimeRuleProcessorSQL.ts
+/**
+* Generates a value processor with date/time features for use by
+* {@link @react-querybuilder/core!formatQuery formatQuery} with the "sql" format and "ansi" preset.
+*/
+const getDatetimeValueProcessorANSI = ({ toISOStringDateOnly, toISOString }) => (rule, opts) => {
+	if (isISOStringDateOnly(opts?.context?.originalValue)) return defaultValueProcessorByRule({
+		...rule,
+		value: toISOStringDateOnly(rule.value)
+	}, opts);
+	return defaultValueProcessorByRule({
+		...rule,
+		value: toISOString(rule.value)
+	}, opts);
+};
+/**
+* Generates a value processor with date/time features for use by {@link @react-querybuilder/core!formatQuery formatQuery} with
+* the "sql" format and "mssql" preset.
+*/
+const getDatetimeValueProcessorMSSQL = ({ toISOStringDateOnly, toISOString }) => (rule, opts) => {
+	const datatype = /^(?:small)?datetime/i.test(opts?.fieldData?.datatype) ? "datetimeoffset" : "date";
+	const value = datatype === "datetimeoffset" ? toISOString(rule.value) : toISOStringDateOnly(rule.value);
+	return defaultValueProcessorByRule({
+		...rule,
+		value
+	}, {
+		...opts,
+		wrapValueWith: [`cast(`, ` as ${datatype})`]
+	});
+};
+/**
+* Generates a value processor with date/time features for use by {@link @react-querybuilder/core!formatQuery formatQuery} with
+* the "sql" format and "mysql" preset.
+*/
+const getDatetimeValueProcessorMySQL = ({ toISOStringDateOnly, toISOString }) => (rule, opts) => {
+	const datatype = /^(?:datetime|timestamp)/i.test(opts?.fieldData?.datatype) ? "datetime" : "date";
+	const value = datatype === "datetime" ? toISOString(rule.value) : toISOStringDateOnly(rule.value);
+	return defaultValueProcessorByRule({
+		...rule,
+		value
+	}, {
+		...opts,
+		wrapValueWith: [`cast(`, ` as ${datatype})`]
+	});
+};
+/**
+* Generates a value processor with date/time features for use by {@link @react-querybuilder/core!formatQuery formatQuery} with
+* the "sql" format and "oracle" preset.
+*/
+const getDatetimeValueProcessorOracle = ({ toISOStringDateOnly, toISOString }) => (rule, opts) => {
+	const datatype = /^timestamp/i.test(opts?.fieldData?.datatype) ? "timestamp" : "date";
+	const value = datatype === "timestamp" ? toISOString(rule.value).replaceAll("T", " ").replace("Z", " UTC") : toISOStringDateOnly(rule.value);
+	return defaultValueProcessorByRule({
+		...rule,
+		value
+	}, {
+		...opts,
+		wrapValueWith: [datatype, ``]
+	});
+};
+/**
+* Generates a value processor with date/time features for use by {@link @react-querybuilder/core!formatQuery formatQuery} with
+* the "sql" format and "postgresql" preset.
+*/
+const getDatetimeValueProcessorPostgreSQL = ({ toISOStringDateOnly, toISOString }) => (rule, opts) => {
+	const datatype = /^timestamp/i.test(opts?.fieldData?.datatype) ? "timestamp" : "date";
+	const value = datatype === "timestamp" ? toISOString(rule.value) : toISOStringDateOnly(rule.value);
+	return defaultValueProcessorByRule({
+		...rule,
+		value
+	}, {
+		...opts,
+		wrapValueWith: [datatype, ``]
+	});
+};
+const presetToValueProcessorMap = {
+	ansi: getDatetimeValueProcessorANSI,
+	mssql: getDatetimeValueProcessorMSSQL,
+	mysql: getDatetimeValueProcessorMySQL,
+	oracle: getDatetimeValueProcessorOracle,
+	postgresql: getDatetimeValueProcessorPostgreSQL,
+	sqlite: getDatetimeValueProcessorANSI
+};
+/**
+* Generates a rule processor with date/time features for use by {@link @react-querybuilder/core!formatQuery formatQuery} with
+* the "sql" format.
+*/
+const getDatetimeRuleProcessorSQL = (apiFns) => (rule, options) => {
+	const opts = options ?? (	/* v8 ignore start -- @preserve */ {});
+	const operator = mapSQLOperator(resolveDatetimeOperator(rule, opts));
+	const operatorLowerCase = lc(operator);
+	// v8 ignore next
+	const { quoteFieldNamesWith = ["", ""], fieldIdentifierSeparator = "", context = {} } = opts;
+	let finalValue = "";
+	if (rule.valueSource === "field" || !processIsDateField(context.isDateField, rule, opts)) return defaultRuleProcessorSQL(rule, opts);
+	const valueProcessor = presetToValueProcessorMap[opts.preset](apiFns);
+	const quotedField = getQuotedFieldName(rule.field, {
+		quoteFieldNamesWith,
+		fieldIdentifierSeparator
+	});
+	const ruleValue = context.materializeRelativeDateTime ? materializeRelativeValues(apiFns, rule.value, opts) : rule.value;
+	const rawValues = Array.isArray(ruleValue) ? ruleValue : [ruleValue];
+	if (rawValues.some(isRelativeDateTimeValue)) {
+		const exprFor = (v) => {
+			if (isRelativeDateTimeValue(v)) return getRelativeDateTimeSQL(v, opts.preset, opts.fieldData?.datatype);
+			const dateVal = apiFns.toDate(v);
+			if (!apiFns.isValid(dateVal)) return void 0;
+			return valueProcessor({
+				field: rule.field,
+				operator: "=",
+				value: dateVal
+			}, {
+				...opts,
+				context: { originalValue: v }
+			});
+		};
+		switch (operatorLowerCase) {
+			case "in":
+			case "not in": {
+				const exprs = rawValues.map(exprFor).filter((e) => e !== void 0);
+				// v8 ignore next -- a relative operand always yields an expression
+				if (exprs.length === 0) return "";
+				finalValue = `(${exprs.join(", ")})`;
+				break;
+			}
+			case "between":
+			case "not between": {
+				const first = exprFor(rawValues[0]);
+				const second = exprFor(rawValues[1]);
+				if (first === void 0 || second === void 0) return "";
+				finalValue = `${first} and ${second}`;
+				break;
+			}
+			default: {
+				const expr = exprFor(rawValues[0]);
+				// v8 ignore next -- a single relative operand always yields an expression
+				if (expr === void 0) return "";
+				finalValue = expr;
+			}
+		}
+		return `${quotedField} ${operator} ${finalValue}`.trim();
+	}
+	const valueAsDateArray = toArray(ruleValue, { retainEmptyStrings: false }).map((v) => [v, apiFns.toDate(v)]).filter((v) => apiFns.isValid(v[1]));
+	switch (operatorLowerCase) {
+		case "in":
+		case "not in":
+			if (valueAsDateArray.length === 0) return "";
+			finalValue = `(${valueAsDateArray.map((value) => valueProcessor({
+				field: rule.field,
+				operator: "=",
+				value: value[1]
+			}, {
+				...opts,
+				context: { originalValue: value[0] }
+			})).join(", ")})`;
+			break;
+		case "between":
+		case "not between":
+			{
+				if (valueAsDateArray.length < 2) return "";
+				const [first, second] = valueAsDateArray;
+				finalValue = (apiFns.isBefore(first[1], second[1]) ? [first, second] : [second, first]).map(([originalValue, value]) => valueProcessor({
+					field: rule.field,
+					operator: "=",
+					value
+				}, {
+					...opts,
+					context: { originalValue }
+				})).join(" and ");
+			}
+			break;
+		default: {
+			const [originalValue, value] = valueAsDateArray[0] ?? ["", ""];
+			finalValue = valueProcessor({
+				field: rule.field,
+				operator: "=",
+				value
+			}, {
+				...opts,
+				context: { originalValue }
+			});
+		}
+	}
+	return `${quotedField} ${operator} ${finalValue}`.trim();
+};
+//#endregion
+//#region src/getDatetimeRuleProcessorTanStackDB.ts
+/**
+* Generates a rule processor with date/time features for use by
+* {@link @react-querybuilder/core!formatQuery formatQuery} with the "tanstack_db" format.
+* Relative values are materialized and all date/time values are converted to `Date`
+* objects (TanStack DB collection filters compare against native `Date` values).
+*/
+const getDatetimeRuleProcessorTanStackDB = (apiFns) => (rule, options) => {
+	const opts = options ?? (	/* v8 ignore start -- @preserve */ {});
+	const { context = {} } = opts;
+	if (rule.valueSource === "field" || !processIsDateField(context.isDateField, rule, opts)) return defaultRuleProcessorTanStackDB(rule, opts);
+	const { operator, value } = materializeForExport(apiFns, rule, opts, true);
+	return defaultRuleProcessorTanStackDB({
+		...rule,
+		operator,
+		value
+	}, opts);
+};
+//#endregion
+export { resolveDatetimeOperator as A, getDatetimeRuleProcessorCypher as C, isISOStringDateOnly as D, isDateOnlyDatatype as E, isRelativeDateTimeValue as O, getDatetimeRuleProcessorDrizzle as S, getDatetimeJsonLogicOperations as T, getDatetimeRuleProcessorMongoDBQuery as _, getDatetimeValueProcessorMySQL as a, getDatetimeRuleProcessorGremlin as b, getDatetimeRuleProcessorSpEL as c, getDatetimeRuleProcessorPrisma as d, getDatetimeRuleProcessorParameterized as f, getDatetimeRuleProcessorMongoDB as g, getDatetimeRuleProcessorNL as h, getDatetimeValueProcessorMSSQL as i, processIsDateField as k, getDatetimeRuleProcessorSPARQL as l, defaultDateTimeNLOperatorMap as m, getDatetimeRuleProcessorSQL as n, getDatetimeValueProcessorOracle as o, datetimeValueProcessorNL as p, getDatetimeValueProcessorANSI as r, getDatetimeValueProcessorPostgreSQL as s, getDatetimeRuleProcessorTanStackDB as t, getDatetimeRuleProcessorSequelize as u, getDatetimeRuleProcessorLDAP as v, getDatetimeRuleProcessorCEL as w, getDatetimeRuleProcessorElasticSearch as x, getDatetimeRuleProcessorJSONata as y };
+
+//# sourceMappingURL=getDatetimeRuleProcessorTanStackDB-BcOC-o2A.mjs.map