@react-querybuilder/datetime 8.18.0 → 8.19.1

package/dist/cjs/getDatetimeRuleProcessorTanStackDB-CL79A1_x.js

@@ -0,0 +1,1208 @@
+let react_querybuilder = require("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 (0, react_querybuilder.defaultRuleProcessorCEL)(rule, opts);
+	const ts = (d) => `timestamp("${apiFns.toISOString(d)}")`;
+	const value = materializeRelativeValues(apiFns, rule.value, opts);
+	const operatorTL = (0, react_querybuilder.lc)(resolveDatetimeOperator(rule, opts).replace(/^=$/, "=="));
+	switch (operatorTL) {
+		case "<":
+		case "<=":
+		case "==":
+		case "!=":
+		case ">":
+		case ">=": return `${rule.field} ${operatorTL} ${ts(value)}`;
+	}
+	const valueAsDateArray = (0, react_querybuilder.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 (0, react_querybuilder.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 (0, react_querybuilder.defaultRuleProcessorCypher)(rule, opts);
+	const { field } = rule;
+	const operatorTL = (0, react_querybuilder.lc)(resolveDatetimeOperator(rule, opts));
+	if (operatorTL === "olderthanduration") return `datetime() - ${field} > duration('${rule.value}')`;
+	if (operatorTL === "withinduration") return `datetime() - ${field} <= duration('${rule.value}')`;
+	const valueAsDateArray = (0, react_querybuilder.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 (0, react_querybuilder.defaultRuleProcessorDrizzle)(rule, opts);
+	const { operator, value } = materializeForExport(apiFns, rule, opts, true);
+	return (0, react_querybuilder.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 (0, react_querybuilder.defaultRuleProcessorElasticSearch)(rule, opts);
+	const { operator, value } = materializeForExport(apiFns, rule, opts);
+	return (0, react_querybuilder.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 (0, react_querybuilder.defaultRuleProcessorGremlin)(rule, opts);
+	const { operator, value } = materializeForExport(apiFns, rule, opts);
+	return (0, react_querybuilder.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 (0, react_querybuilder.defaultRuleProcessorJSONata)(rule, opts);
+	const valueIsField = valueSource === "field";
+	const value = valueIsField ? rule.value : materializeRelativeValues(apiFns, rule.value, opts);
+	const fldToMs = (f) => `$toMillis(${(0, react_querybuilder.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 = (0, react_querybuilder.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 || (0, react_querybuilder.nullOrUndefinedOrEmpty)(valueAsArray[0]) || (0, react_querybuilder.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 (0, react_querybuilder.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 (0, react_querybuilder.defaultRuleProcessorLDAP)(rule, opts);
+	const { operator, value } = materializeForExport(apiFns, rule, opts);
+	return (0, react_querybuilder.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 (0, react_querybuilder.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]: { [react_querybuilder.mongoOperators[operator]]: apiFns.toDate(value) } };
+	}
+	const valueAsDateArray = (0, react_querybuilder.toArray)(value, { retainEmptyStrings: false }).map((v) => apiFns.toDate(v)).filter((dateVal) => apiFns.isValid(dateVal));
+	switch (operator) {
+		case "in":
+		case "notIn": return { [field]: { [react_querybuilder.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 (0, react_querybuilder.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 = (0, react_querybuilder.lc)(operator);
+	let finalValue = "";
+	// v8 ignore next
+	const { fieldData, quoteFieldNamesWith = ["", ""], fieldIdentifierSeparator = "", operatorProcessor = react_querybuilder.defaultOperatorProcessorNL, wordOrder = "SVO", context = {}, operatorMap = defaultDateTimeNLOperatorMap } = opts;
+	if (!processIsDateField(context.isDateField, rule, opts)) return (0, react_querybuilder.defaultRuleProcessorNL)(rule, opts);
+	if (rule.valueSource === "field") return (0, react_querybuilder.defaultRuleProcessorNL)(rule, {
+		...opts,
+		operatorMap: defaultDateTimeNLOperatorMap
+	});
+	if ((operatorLowerCase === "in" || operatorLowerCase === "notin" || operatorLowerCase === "between" || operatorLowerCase === "notbetween") && !rule.value) return "";
+	const valueAsDateArray = (0, react_querybuilder.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: (0, react_querybuilder.getQuotedFieldName)(fieldData?.label ?? rule.field, {
+			quoteFieldNamesWith,
+			fieldIdentifierSeparator
+		}),
+		V: operatorProcessor({
+			...rule,
+			operator
+		}, {
+			...opts,
+			operatorMap: {
+				...defaultDateTimeNLOperatorMap,
+				...operatorMap
+			}
+		}),
+		O: finalValue
+	};
+	return (0, react_querybuilder.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 (0, react_querybuilder.defaultRuleProcessorParameterized)(rule, opts, meta);
+	const { operator, value } = materializeForExport(apiFns, rule, opts);
+	return (0, react_querybuilder.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 (0, react_querybuilder.defaultRuleProcessorPrisma)(rule, opts);
+	const { operator, value } = materializeForExport(apiFns, rule, opts, true);
+	return (0, react_querybuilder.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 (0, react_querybuilder.defaultRuleProcessorSequelize)(rule, opts);
+	const { operator, value } = materializeForExport(apiFns, rule, opts, true);
+	return (0, react_querybuilder.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 (0, react_querybuilder.defaultRuleProcessorSPARQL)(rule, opts);
+	const { field: rawField, value } = rule;
+	const operator = resolveDatetimeOperator(rule, opts);
+	const field = (0, react_querybuilder.sparqlVar)(rawField);
+	const operatorTL = (0, react_querybuilder.lc)(operator);
+	if (operatorTL === "olderthanduration") return `NOW() - ${field} > "${value}"^^xsd:duration`;
+	if (operatorTL === "withinduration") return `NOW() - ${field} <= "${value}"^^xsd:duration`;
+	const valueAsDateArray = (0, react_querybuilder.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 (0, react_querybuilder.defaultRuleProcessorSpEL)(rule, opts);
+	const { operator, value } = materializeForExport(apiFns, rule, opts);
+	return (0, react_querybuilder.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 (0, react_querybuilder.defaultValueProcessorByRule)({
+		...rule,
+		value: toISOStringDateOnly(rule.value)
+	}, opts);
+	return (0, react_querybuilder.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 (0, react_querybuilder.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 (0, react_querybuilder.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 (0, react_querybuilder.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 (0, react_querybuilder.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 = (0, react_querybuilder.mapSQLOperator)(resolveDatetimeOperator(rule, opts));
+	const operatorLowerCase = (0, react_querybuilder.lc)(operator);
+	// v8 ignore next
+	const { quoteFieldNamesWith = ["", ""], fieldIdentifierSeparator = "", context = {} } = opts;
+	let finalValue = "";
+	if (rule.valueSource === "field" || !processIsDateField(context.isDateField, rule, opts)) return (0, react_querybuilder.defaultRuleProcessorSQL)(rule, opts);
+	const valueProcessor = presetToValueProcessorMap[opts.preset](apiFns);
+	const quotedField = (0, react_querybuilder.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 = (0, react_querybuilder.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 (0, react_querybuilder.defaultRuleProcessorTanStackDB)(rule, opts);
+	const { operator, value } = materializeForExport(apiFns, rule, opts, true);
+	return (0, react_querybuilder.defaultRuleProcessorTanStackDB)({
+		...rule,
+		operator,
+		value
+	}, opts);
+};
+//#endregion
+Object.defineProperty(exports, "datetimeValueProcessorNL", {
+	enumerable: true,
+	get: function() {
+		return datetimeValueProcessorNL;
+	}
+});
+Object.defineProperty(exports, "defaultDateTimeNLOperatorMap", {
+	enumerable: true,
+	get: function() {
+		return defaultDateTimeNLOperatorMap;
+	}
+});
+Object.defineProperty(exports, "getDatetimeJsonLogicOperations", {
+	enumerable: true,
+	get: function() {
+		return getDatetimeJsonLogicOperations;
+	}
+});
+Object.defineProperty(exports, "getDatetimeRuleProcessorCEL", {
+	enumerable: true,
+	get: function() {
+		return getDatetimeRuleProcessorCEL;
+	}
+});
+Object.defineProperty(exports, "getDatetimeRuleProcessorCypher", {
+	enumerable: true,
+	get: function() {
+		return getDatetimeRuleProcessorCypher;
+	}
+});
+Object.defineProperty(exports, "getDatetimeRuleProcessorDrizzle", {
+	enumerable: true,
+	get: function() {
+		return getDatetimeRuleProcessorDrizzle;
+	}
+});
+Object.defineProperty(exports, "getDatetimeRuleProcessorElasticSearch", {
+	enumerable: true,
+	get: function() {
+		return getDatetimeRuleProcessorElasticSearch;
+	}
+});
+Object.defineProperty(exports, "getDatetimeRuleProcessorGremlin", {
+	enumerable: true,
+	get: function() {
+		return getDatetimeRuleProcessorGremlin;
+	}
+});
+Object.defineProperty(exports, "getDatetimeRuleProcessorJSONata", {
+	enumerable: true,
+	get: function() {
+		return getDatetimeRuleProcessorJSONata;
+	}
+});
+Object.defineProperty(exports, "getDatetimeRuleProcessorLDAP", {
+	enumerable: true,
+	get: function() {
+		return getDatetimeRuleProcessorLDAP;
+	}
+});
+Object.defineProperty(exports, "getDatetimeRuleProcessorMongoDB", {
+	enumerable: true,
+	get: function() {
+		return getDatetimeRuleProcessorMongoDB;
+	}
+});
+Object.defineProperty(exports, "getDatetimeRuleProcessorMongoDBQuery", {
+	enumerable: true,
+	get: function() {
+		return getDatetimeRuleProcessorMongoDBQuery;
+	}
+});
+Object.defineProperty(exports, "getDatetimeRuleProcessorNL", {
+	enumerable: true,
+	get: function() {
+		return getDatetimeRuleProcessorNL;
+	}
+});
+Object.defineProperty(exports, "getDatetimeRuleProcessorParameterized", {
+	enumerable: true,
+	get: function() {
+		return getDatetimeRuleProcessorParameterized;
+	}
+});
+Object.defineProperty(exports, "getDatetimeRuleProcessorPrisma", {
+	enumerable: true,
+	get: function() {
+		return getDatetimeRuleProcessorPrisma;
+	}
+});
+Object.defineProperty(exports, "getDatetimeRuleProcessorSPARQL", {
+	enumerable: true,
+	get: function() {
+		return getDatetimeRuleProcessorSPARQL;
+	}
+});
+Object.defineProperty(exports, "getDatetimeRuleProcessorSQL", {
+	enumerable: true,
+	get: function() {
+		return getDatetimeRuleProcessorSQL;
+	}
+});
+Object.defineProperty(exports, "getDatetimeRuleProcessorSequelize", {
+	enumerable: true,
+	get: function() {
+		return getDatetimeRuleProcessorSequelize;
+	}
+});
+Object.defineProperty(exports, "getDatetimeRuleProcessorSpEL", {
+	enumerable: true,
+	get: function() {
+		return getDatetimeRuleProcessorSpEL;
+	}
+});
+Object.defineProperty(exports, "getDatetimeRuleProcessorTanStackDB", {
+	enumerable: true,
+	get: function() {
+		return getDatetimeRuleProcessorTanStackDB;
+	}
+});
+Object.defineProperty(exports, "getDatetimeValueProcessorANSI", {
+	enumerable: true,
+	get: function() {
+		return getDatetimeValueProcessorANSI;
+	}
+});
+Object.defineProperty(exports, "getDatetimeValueProcessorMSSQL", {
+	enumerable: true,
+	get: function() {
+		return getDatetimeValueProcessorMSSQL;
+	}
+});
+Object.defineProperty(exports, "getDatetimeValueProcessorMySQL", {
+	enumerable: true,
+	get: function() {
+		return getDatetimeValueProcessorMySQL;
+	}
+});
+Object.defineProperty(exports, "getDatetimeValueProcessorOracle", {
+	enumerable: true,
+	get: function() {
+		return getDatetimeValueProcessorOracle;
+	}
+});
+Object.defineProperty(exports, "getDatetimeValueProcessorPostgreSQL", {
+	enumerable: true,
+	get: function() {
+		return getDatetimeValueProcessorPostgreSQL;
+	}
+});
+Object.defineProperty(exports, "isDateOnlyDatatype", {
+	enumerable: true,
+	get: function() {
+		return isDateOnlyDatatype;
+	}
+});
+Object.defineProperty(exports, "isISOStringDateOnly", {
+	enumerable: true,
+	get: function() {
+		return isISOStringDateOnly;
+	}
+});
+Object.defineProperty(exports, "isRelativeDateTimeValue", {
+	enumerable: true,
+	get: function() {
+		return isRelativeDateTimeValue;
+	}
+});
+Object.defineProperty(exports, "processIsDateField", {
+	enumerable: true,
+	get: function() {
+		return processIsDateField;
+	}
+});
+Object.defineProperty(exports, "resolveDatetimeOperator", {
+	enumerable: true,
+	get: function() {
+		return resolveDatetimeOperator;
+	}
+});
+
+//# sourceMappingURL=getDatetimeRuleProcessorTanStackDB-CL79A1_x.js.map