@react-querybuilder/datetime 8.17.0 → 8.19.0

package/dist/cjs/react-querybuilder_datetime.cjs.development.js

@@ -1,6 +1,9 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_getDatetimeRuleProcessorSQL = require("./getDatetimeRuleProcessorSQL-CrA2ZrSe.js");
+const require_rqbDateTimeLibraryAPI_dayjs = require("./rqbDateTimeLibraryAPI.dayjs-CzLh_zi9.js");
+const require_getDatetimeRuleProcessorTanStackDB = require("./getDatetimeRuleProcessorTanStackDB-CL79A1_x.js");
 let react_querybuilder = require("react-querybuilder");
+let react = require("react");
+react = require_rqbDateTimeLibraryAPI_dayjs.__toESM(react);
 //#region src/datetimeRuleProcessorJsonLogic.ts
 const dateOperationMap = {
 	"!=": "dateNotOn",
@@ -24,26 +27,37 @@ const dateOperationMap = {
 */
 const datetimeRuleProcessorJsonLogic = (rule, options) => {
 	const opts = options ?? (	/* v8 ignore start -- @preserve */ {});
-	if (!require_getDatetimeRuleProcessorSQL.processIsDateField(opts.context?.isDateField, rule, opts)) return (0, react_querybuilder.defaultRuleProcessorJsonLogic)(rule, opts);
-	const { field, operator, value, valueSource } = rule;
+	if (!require_getDatetimeRuleProcessorTanStackDB.processIsDateField(opts.context?.isDateField, rule, opts)) return (0, react_querybuilder.defaultRuleProcessorJsonLogic)(rule, opts);
+	const { field, value, valueSource } = rule;
+	const operator = require_getDatetimeRuleProcessorTanStackDB.resolveDatetimeOperator(rule, opts);
 	const valueIsField = valueSource === "field";
 	const fieldObject = { var: field };
-	const maybeFieldRenderer = (v) => valueIsField ? { var: `${v}` } : v;
+	const dateOnly = require_getDatetimeRuleProcessorTanStackDB.isDateOnlyDatatype(opts?.fieldData?.datatype);
+	const renderValue = (v) => {
+		if (valueIsField) return { var: `${v}` };
+		if (require_getDatetimeRuleProcessorTanStackDB.isRelativeDateTimeValue(v)) return { dateRelative: [
+			v.anchor,
+			v.offset,
+			v.unit,
+			dateOnly
+		] };
+		return v;
+	};
 	switch (operator) {
 		case "<":
 		case "<=":
 		case "=":
 		case "!=":
 		case ">":
-		case ">=": return { [dateOperationMap[operator]]: [fieldObject, maybeFieldRenderer(value)] };
+		case ">=": return { [dateOperationMap[operator]]: [fieldObject, renderValue(value)] };
 		case "in":
 		case "notIn": {
-			const valueAsArray = (0, react_querybuilder.toArray)(value).map((v) => maybeFieldRenderer(v));
+			const valueAsArray = (Array.isArray(value) ? value : (0, react_querybuilder.toArray)(value)).map(renderValue);
 			return { [dateOperationMap[operator]]: [fieldObject, valueAsArray] };
 		}
 		case "between":
 		case "notBetween": {
-			const valueAsArray = (0, react_querybuilder.toArray)(value).map((v) => maybeFieldRenderer(v));
+			const valueAsArray = (Array.isArray(value) ? value : (0, react_querybuilder.toArray)(value)).map(renderValue);
 			if (valueAsArray.length < 2) return false;
 			return { [dateOperationMap[operator]]: [
 				valueAsArray[0],
@@ -55,77 +69,474 @@ const datetimeRuleProcessorJsonLogic = (rule, options) => {
 	return (0, react_querybuilder.defaultRuleProcessorJsonLogic)(rule, options);
 };
 //#endregion
-//#region src/getDatetimeRuleProcessorJSONata.ts
-const shouldNegate = (op) => /^(does)?not/i.test(op);
-const negate = (clause, neg) => neg ? `$not(${clause})` : `${clause}`;
+//#region src/InheritedValueEditorContext.ts
 /**
-* Generates a rule processor with date/time features for use by
-* {@link @react-querybuilder/core!formatQuery formatQuery} with the "jsonata" format.
+* Holds the value editor inherited from an outer (compat package) context provider,
+* captured _before_ {@link QueryBuilderDateTime} overrides it. Lets the date/time value
+* editor delegate non-date fields (and absolute date inputs) to the compat editor instead
+* of the bare default {@link react-querybuilder!ValueEditor ValueEditor}. `null` = none
+* inherited (fall back to default).
 */
-const getDatetimeRuleProcessorJSONata = (apiFns) => (rule, options) => {
-	const opts = options ?? (	/* v8 ignore start -- @preserve */ {});
-	const { context = {} } = opts;
-	// v8 ignore next
-	const { quoteFieldNamesWith = ["", ""], fieldIdentifierSeparator = "" } = opts;
-	const { field, operator, value, valueSource } = rule;
-	if (!require_getDatetimeRuleProcessorSQL.processIsDateField(context.isDateField, rule, opts)) return (0, react_querybuilder.defaultRuleProcessorJSONata)(rule, opts);
-	const valueIsField = valueSource === "field";
-	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 InheritedValueEditorContext = (0, react.createContext)(null);
+/** Inherited (compat) value editor, or `null` if none. See {@link InheritedValueEditorContext}. */
+const useInheritedValueEditor = () => (0, react.useContext)(InheritedValueEditorContext);
+//#endregion
+//#region src/relativeDateTimeConstants.ts
+/**
+* Class name applied to the absolute/relative mode toggle button. Package-local (not part
+* of the core `standardClassnames`) to avoid coupling core to this extension.
+*/
+const relativeDateTimeToggleClassName = "rule-value-dateTimeRelative-toggle";
+/** Default value applied when switching a rule to relative mode. */
+const defaultRelativeDateTimeValue = {
+	mode: "relative",
+	anchor: "now",
+	offset: 0,
+	unit: "day"
+};
+/** Default anchor (reference-point) options for the relative date/time editor. */
+const defaultRelativeDateTimeAnchors = [
+	{
+		name: "now",
+		value: "now",
+		label: "now"
+	},
+	{
+		name: "startOfDay",
+		value: "startOfDay",
+		label: "start of day"
+	},
+	{
+		name: "endOfDay",
+		value: "endOfDay",
+		label: "end of day"
+	},
+	{
+		name: "startOfWeek",
+		value: "startOfWeek",
+		label: "start of week"
+	},
+	{
+		name: "endOfWeek",
+		value: "endOfWeek",
+		label: "end of week"
+	},
+	{
+		name: "startOfMonth",
+		value: "startOfMonth",
+		label: "start of month"
+	},
+	{
+		name: "endOfMonth",
+		value: "endOfMonth",
+		label: "end of month"
+	},
+	{
+		name: "startOfYear",
+		value: "startOfYear",
+		label: "start of year"
+	},
+	{
+		name: "endOfYear",
+		value: "endOfYear",
+		label: "end of year"
 	}
-	const valueAsArray = (0, react_querybuilder.toArray)(rule.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(operator));
-			}
-			if (valueAsDateArray.length === 0) return "";
-			return negate(`${fldToMs(field)} in [${valueAsDateArray.map((val) => valToMs(val)).join(", ")}]`, shouldNegate(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);
+];
+/** Default unit options for the relative date/time editor. */
+const defaultRelativeDateTimeUnits = [
+	{
+		name: "minute",
+		value: "minute",
+		label: "minute(s)"
+	},
+	{
+		name: "hour",
+		value: "hour",
+		label: "hour(s)"
+	},
+	{
+		name: "day",
+		value: "day",
+		label: "day(s)"
+	},
+	{
+		name: "week",
+		value: "week",
+		label: "week(s)"
+	},
+	{
+		name: "month",
+		value: "month",
+		label: "month(s)"
+	},
+	{
+		name: "year",
+		value: "year",
+		label: "year(s)"
+	}
+];
+/** Default labels/content for the absolute/relative mode toggle. */
+const defaultRelativeDateTimeToggleLabels = {
+	label: "Toggle relative date/time",
+	absoluteTitle: "Absolute date/time (click for relative)",
+	relativeTitle: "Relative date/time (click for absolute)",
+	absoluteContent: "",
+	relativeContent: ""
+};
+//#endregion
+//#region src/relativeDateTimeModeControllers.tsx
+/**
+* Compact absolute/relative toggle rendered by {@link toggleModeController}. A
+* `role="switch"` button whose default glyph is supplied by CSS (keyed on
+* `aria-checked`); override via the `toggleLabels` config.
+*
+* @group Components
+*/
+const RelativeDateTimeModeToggle = ({ isRelative, setMode, disabled, className, labels }) => {
+	const onClick = react.useCallback(() => setMode(isRelative ? "absolute" : "relative"), [setMode, isRelative]);
+	return /* @__PURE__ */ react.createElement("button", {
+		type: "button",
+		role: "switch",
+		"aria-checked": isRelative,
+		"aria-label": labels.label,
+		title: isRelative ? labels.relativeTitle : labels.absoluteTitle,
+		disabled,
+		className: (0, react_querybuilder.clsx)(relativeDateTimeToggleClassName, className),
+		onClick
+	}, isRelative ? labels.relativeContent : labels.absoluteContent);
+};
+/**
+* Zero-config default {@link RelativeDateTimeModeController}: derives the mode from the
+* value shape and renders a compact toggle button to switch between absolute and
+* relative entry.
+*/
+const toggleModeController = {
+	isRelative: (props) => require_getDatetimeRuleProcessorTanStackDB.isRelativeDateTimeValue(props.value),
+	ModeControl: RelativeDateTimeModeToggle
+};
+/**
+* Builds an operator-driven {@link RelativeDateTimeModeController} that derives the mode
+* from the rule's operator. Pass the operator name(s) (or a predicate) that should put the
+* editor in relative mode. No toggle is rendered — the operator selector is the mode
+* affordance.
+*
+* NOTE: the chosen operators only signal _mode_; the rule's value remains a
+* {@link RelativeDateTimeValue}. For these operators to export correctly, map each one to a
+* real comparison operator via `context.relativeOperatorMap` when calling `formatQuery`
+* (e.g. `{ relativeEq: '=' }`). See the documentation.
+*/
+const createOperatorModeController = (relativeOperators) => ({ isRelative: (props) => typeof relativeOperators === "function" ? relativeOperators(props.operator) : relativeOperators.includes(props.operator) });
+/**
+* Appends the given `operators` to each field's `operators` list, so the operator-driven
+* controller (see {@link createOperatorModeController}) has an operator to switch into
+* relative mode. Fields without an explicit `operators` list fall back to the core
+* `defaultOperators`.
+*/
+const withRelativeOperators = (fields, operators) => fields.map((field) => ({
+	...field,
+	operators: [...field.operators ?? react_querybuilder.defaultOperators, ...operators]
+}));
+//#endregion
+//#region src/RelativeDateTimeConfigContext.tsx
+/**
+* Carries {@link RelativeDateTimeEditorConfig} to the {@link RelativeDateTimeValueEditor}.
+* Provided by {@link QueryBuilderDateTime}; defaults apply when no provider is present.
+*/
+const RelativeDateTimeConfigContext = (0, react.createContext)({});
+/** Reads the relative date/time editor config from context, merged with defaults. */
+const useRelativeDateTimeConfig = () => {
+	const config = (0, react.useContext)(RelativeDateTimeConfigContext);
+	return (0, react.useMemo)(() => ({
+		modeController: config.modeController ?? toggleModeController,
+		anchors: config.anchors ?? defaultRelativeDateTimeAnchors,
+		units: config.units ?? defaultRelativeDateTimeUnits,
+		toggleLabels: {
+			...defaultRelativeDateTimeToggleLabels,
+			...config.toggleLabels
+		},
+		dateTimeAPI: config.dateTimeAPI ?? require_rqbDateTimeLibraryAPI_dayjs.rqbDateTimeLibraryAPI
+	}), [config]);
+};
+//#endregion
+//#region src/RelativeDateTimeValueEditor.tsx
+const dummyPath = [];
+const dummyFieldData = {
+	name: "",
+	value: "",
+	label: ""
+};
+/** Splits a value into the from/to pair used by between/notBetween, object-safe. */
+const toBetweenArray = (value) => Array.isArray(value) ? value : require_getDatetimeRuleProcessorTanStackDB.isRelativeDateTimeValue(value) ? [value] : (0, react_querybuilder.toArray)(value);
+/**
+* Renders a single absolute-or-relative date/time value: a mode affordance (per the
+* controller) plus either an absolute date input or anchor + signed offset + unit
+* selectors. Reused once per slot so between/notBetween can mix bounds (e.g. an absolute
+* "from" and a relative "to").
+*/
+const RelativeDateTimeSingleValueEditor = ({ baseProps, value, onChange, absoluteOperator, config, SelectorComponent, valueListItemClassName, numericSchema }) => {
+	const { schema, disabled, title, testID } = baseProps;
+	const { modeController, anchors, units, toggleLabels } = config;
+	const NumericEditor = useInheritedValueEditor() ?? react_querybuilder.ValueEditor;
+	const isRelative = modeController.isRelative({
+		...baseProps,
+		value
+	});
+	const relValue = require_getDatetimeRuleProcessorTanStackDB.isRelativeDateTimeValue(value) ? value : defaultRelativeDateTimeValue;
+	const handleSetMode = (0, react.useCallback)((mode) => onChange(mode === "relative" ? defaultRelativeDateTimeValue : ""), [onChange]);
+	const handleChangeAnchor = (0, react.useCallback)((anchor) => onChange({
+		...relValue,
+		anchor
+	}), [onChange, relValue]);
+	const handleChangeOffset = (0, react.useCallback)((offset) => onChange({
+		...relValue,
+		offset: (0, react_querybuilder.parseNumber)(offset, { parseNumbers: true }) || 0
+	}), [onChange, relValue]);
+	const handleChangeUnit = (0, react.useCallback)((unit) => onChange({
+		...relValue,
+		unit
+	}), [onChange, relValue]);
+	const { ModeControl } = modeController;
+	return /* @__PURE__ */ react.createElement(react.Fragment, null, ModeControl && /* @__PURE__ */ react.createElement(ModeControl, {
+		isRelative,
+		setMode: handleSetMode,
+		schema,
+		disabled,
+		className: valueListItemClassName,
+		title,
+		testID,
+		labels: toggleLabels
+	}), isRelative ? /* @__PURE__ */ react.createElement(react.Fragment, null, /* @__PURE__ */ react.createElement(SelectorComponent, {
+		schema,
+		testID,
+		title,
+		className: valueListItemClassName,
+		handleOnChange: handleChangeAnchor,
+		disabled,
+		value: relValue.anchor,
+		options: anchors,
+		multiple: false,
+		listsAsArrays: false,
+		path: dummyPath,
+		level: 0
+	}), /* @__PURE__ */ react.createElement(NumericEditor, {
+		skipHook: true,
+		testID,
+		inputType: "number",
+		title,
+		className: valueListItemClassName,
+		disabled,
+		handleOnChange: handleChangeOffset,
+		field: "",
+		operator: "",
+		value: relValue.offset,
+		valueSource: "value",
+		fieldData: dummyFieldData,
+		schema: numericSchema,
+		path: dummyPath,
+		level: 0,
+		rule: {
+			field: "",
+			operator: "=",
+			value: relValue.offset
 		}
+	}), relValue.offset !== 0 && /* @__PURE__ */ react.createElement(SelectorComponent, {
+		schema,
+		testID,
+		title,
+		className: valueListItemClassName,
+		handleOnChange: handleChangeUnit,
+		disabled,
+		value: relValue.unit,
+		options: units,
+		multiple: false,
+		listsAsArrays: false,
+		path: dummyPath,
+		level: 0
+	})) : /* @__PURE__ */ react.createElement(DateTimeValueEditor, {
+		...baseProps,
+		operator: absoluteOperator,
+		value,
+		handleOnChange: onChange,
+		className: react_querybuilder.standardClassnames.value
+	}));
+};
+/**
+* Value editor with support for {@link RelativeDateTimeValue relative date/time values}
+* (e.g. "three months ago" or "the beginning of this year"). How the user switches
+* between absolute and relative modes is delegated to a pluggable
+* {@link RelativeDateTimeModeController} (default: a compact toggle), supplied via
+* {@link QueryBuilderDateTime}. In relative mode it renders anchor + signed offset + unit
+* selectors; the unit selector is hidden when the offset is `0`.
+*
+* For the `between`/`notBetween` operators it renders two independent value editors (each
+* with its own mode affordance) and stores the bounds as a two-element array, so the from
+* and to bounds can independently be absolute or relative.
+*
+* @group Components
+*/
+const RelativeDateTimeValueEditor = (props) => {
+	const { valueListItemClassName } = (0, react_querybuilder.useValueEditor)(props);
+	const { className, value, handleOnChange, schema, operator, separator } = props;
+	const { suppressStandardClassnames } = schema;
+	const SelectorComponent = props.selectorComponent ?? schema.controls.valueSelector;
+	const config = useRelativeDateTimeConfig();
+	const numericSchema = (0, react.useMemo)(() => ({
+		...schema,
+		parseNumbers: true
+	}), [schema]);
+	const outerClassname = (0, react.useMemo)(() => (0, react_querybuilder.clsx)(suppressStandardClassnames || react_querybuilder.standardClassnames.valueDateTimeRelative, className), [suppressStandardClassnames, className]);
+	const isBetween = operator === "between" || operator === "notBetween";
+	const valueAsArray = (0, react.useMemo)(() => toBetweenArray(value), [value]);
+	const handleChangeBound = (0, react.useCallback)((index) => (boundValue) => {
+		const next = [valueAsArray[0], valueAsArray[1]];
+		next[index] = boundValue;
+		handleOnChange(next);
+	}, [valueAsArray, handleOnChange]);
+	if (isBetween) return /* @__PURE__ */ react.createElement("span", { className: outerClassname }, /* @__PURE__ */ react.createElement(RelativeDateTimeSingleValueEditor, {
+		baseProps: props,
+		value: valueAsArray[0],
+		onChange: handleChangeBound(0),
+		absoluteOperator: "=",
+		config,
+		SelectorComponent,
+		valueListItemClassName,
+		numericSchema
+	}), separator, /* @__PURE__ */ react.createElement(RelativeDateTimeSingleValueEditor, {
+		baseProps: props,
+		value: valueAsArray[1],
+		onChange: handleChangeBound(1),
+		absoluteOperator: "=",
+		config,
+		SelectorComponent,
+		valueListItemClassName,
+		numericSchema
+	}));
+	return /* @__PURE__ */ react.createElement("span", { className: outerClassname }, /* @__PURE__ */ react.createElement(RelativeDateTimeSingleValueEditor, {
+		baseProps: props,
+		value,
+		onChange: handleOnChange,
+		absoluteOperator: operator,
+		config,
+		SelectorComponent,
+		valueListItemClassName,
+		numericSchema
+	}));
+};
+//#endregion
+//#region src/QueryBuilderDateTime.tsx
+/**
+* Whether a rule should use a date/time editor, based on either the coerced input
+* type (`date`/`datetime-local`) or a date-like `datatype` (`date`/`datetime`/`timestamp`).
+*/
+const isDateTimeEditor = (props, inputTypeCoerced) => props.type === "text" && (inputTypeCoerced === "date" || inputTypeCoerced === "datetime-local") || /^(?:date|datetime|timestamp)\b/i.test(props.fieldData?.datatype);
+const pad2 = (n) => `${n}`.padStart(2, "0");
+/**
+* Formats a `Date` into the local value expected by a native `date`/`datetime-local`
+* input (library-agnostic; the date library only handles parsing/validation).
+*/
+const formatDateInputValue = (d, withTime) => {
+	const datePart = `${d.getFullYear()}-${pad2(d.getMonth() + 1)}-${pad2(d.getDate())}`;
+	return withTime ? `${datePart}T${pad2(d.getHours())}:${pad2(d.getMinutes())}` : datePart;
+};
+const DateTimeValueEditor = (props) => {
+	const uVE = (0, react_querybuilder.useValueEditor)(props);
+	const InheritedEditor = useInheritedValueEditor();
+	const { dateTimeAPI } = useRelativeDateTimeConfig();
+	const fallback = (p) => InheritedEditor ? /* @__PURE__ */ react.createElement(InheritedEditor, p) : /* @__PURE__ */ react.createElement(react_querybuilder.ValueEditor, {
+		...p,
+		skipHook: true
+	});
+	if (!isDateTimeEditor(props, uVE.inputTypeCoerced)) return fallback(props);
+	if (dateTimeAPI.isValid(props.value)) {
+		const value = formatDateInputValue(dateTimeAPI.toDate(props.value), uVE.inputTypeCoerced !== "date");
+		return fallback({
+			...props,
+			value
+		});
 	}
-	return (0, react_querybuilder.defaultRuleProcessorJSONata)(rule, opts);
+	return fallback(props);
+};
+/**
+* Provider value editor: renders the relative-capable {@link RelativeDateTimeValueEditor}
+* for date/time fields and falls back to the inherited (compat) editor for everything else.
+*/
+const QueryBuilderDateTimeValueEditor = (props) => {
+	const uVE = (0, react_querybuilder.useValueEditor)(props);
+	const InheritedEditor = useInheritedValueEditor();
+	if (isDateTimeEditor(props, uVE.inputTypeCoerced)) return /* @__PURE__ */ react.createElement(RelativeDateTimeValueEditor, props);
+	return InheritedEditor ? /* @__PURE__ */ react.createElement(InheritedEditor, props) : /* @__PURE__ */ react.createElement(react_querybuilder.ValueEditor, {
+		...props,
+		skipHook: true
+	});
+};
+const QueryBuilderDateTimeContext = (0, react_querybuilder.getCompatContextProvider)({ controlElements: { valueEditor: QueryBuilderDateTimeValueEditor } });
+/**
+* Context provider enabling date/time features for a wrapped
+* {@link react-querybuilder!QueryBuilder QueryBuilder}: renders the relative-capable
+* {@link RelativeDateTimeValueEditor} for date/time fields, and accepts optional
+* {@link RelativeDateTimeEditorConfig} props (mode controller, anchor/unit options, and
+* toggle labels). With no props it provides the zero-config toggle experience.
+*
+* @group Components
+*/
+const QueryBuilderDateTime = ({ children, modeController, anchors, units, toggleLabels, dateTimeAPI }) => {
+	const config = (0, react.useMemo)(() => ({
+		modeController,
+		anchors,
+		units,
+		toggleLabels,
+		dateTimeAPI
+	}), [
+		modeController,
+		anchors,
+		units,
+		toggleLabels,
+		dateTimeAPI
+	]);
+	const inheritedValueEditor = (0, react.useContext)(react_querybuilder.QueryBuilderContext).controlElements?.valueEditor ?? null;
+	return /* @__PURE__ */ react.createElement(RelativeDateTimeConfigContext.Provider, { value: config }, /* @__PURE__ */ react.createElement(InheritedValueEditorContext.Provider, { value: inheritedValueEditor }, /* @__PURE__ */ react.createElement(QueryBuilderDateTimeContext, null, children)));
 };
 //#endregion
+exports.DateTimeValueEditor = DateTimeValueEditor;
+exports.QueryBuilderDateTime = QueryBuilderDateTime;
+exports.QueryBuilderDateTimeContext = QueryBuilderDateTimeContext;
+exports.RelativeDateTimeConfigContext = RelativeDateTimeConfigContext;
+exports.RelativeDateTimeModeToggle = RelativeDateTimeModeToggle;
+exports.RelativeDateTimeValueEditor = RelativeDateTimeValueEditor;
+exports.createOperatorModeController = createOperatorModeController;
 exports.datetimeRuleProcessorJsonLogic = datetimeRuleProcessorJsonLogic;
-exports.datetimeValueProcessorNL = require_getDatetimeRuleProcessorSQL.datetimeValueProcessorNL;
-exports.defaultDateTimeNLOperatorMap = require_getDatetimeRuleProcessorSQL.defaultDateTimeNLOperatorMap;
-exports.getDatetimeJsonLogicOperations = require_getDatetimeRuleProcessorSQL.getDatetimeJsonLogicOperations;
-exports.getDatetimeRuleProcessorCEL = require_getDatetimeRuleProcessorSQL.getDatetimeRuleProcessorCEL;
-exports.getDatetimeRuleProcessorCypher = require_getDatetimeRuleProcessorSQL.getDatetimeRuleProcessorCypher;
-exports.getDatetimeRuleProcessorJSONata = getDatetimeRuleProcessorJSONata;
-exports.getDatetimeRuleProcessorMongoDBQuery = require_getDatetimeRuleProcessorSQL.getDatetimeRuleProcessorMongoDBQuery;
-exports.getDatetimeRuleProcessorNL = require_getDatetimeRuleProcessorSQL.getDatetimeRuleProcessorNL;
-exports.getDatetimeRuleProcessorSPARQL = require_getDatetimeRuleProcessorSQL.getDatetimeRuleProcessorSPARQL;
-exports.getDatetimeRuleProcessorSQL = require_getDatetimeRuleProcessorSQL.getDatetimeRuleProcessorSQL;
-exports.getDatetimeValueProcessorANSI = require_getDatetimeRuleProcessorSQL.getDatetimeValueProcessorANSI;
-exports.getDatetimeValueProcessorMSSQL = require_getDatetimeRuleProcessorSQL.getDatetimeValueProcessorMSSQL;
-exports.getDatetimeValueProcessorMySQL = require_getDatetimeRuleProcessorSQL.getDatetimeValueProcessorMySQL;
-exports.getDatetimeValueProcessorOracle = require_getDatetimeRuleProcessorSQL.getDatetimeValueProcessorOracle;
-exports.getDatetimeValueProcessorPostgreSQL = require_getDatetimeRuleProcessorSQL.getDatetimeValueProcessorPostgreSQL;
+exports.datetimeValueProcessorNL = require_getDatetimeRuleProcessorTanStackDB.datetimeValueProcessorNL;
+exports.defaultDateTimeNLOperatorMap = require_getDatetimeRuleProcessorTanStackDB.defaultDateTimeNLOperatorMap;
+exports.defaultRelativeDateTimeAnchors = defaultRelativeDateTimeAnchors;
+exports.defaultRelativeDateTimeToggleLabels = defaultRelativeDateTimeToggleLabels;
+exports.defaultRelativeDateTimeUnits = defaultRelativeDateTimeUnits;
+exports.defaultRelativeDateTimeValue = defaultRelativeDateTimeValue;
+exports.getDatetimeJsonLogicOperations = require_getDatetimeRuleProcessorTanStackDB.getDatetimeJsonLogicOperations;
+exports.getDatetimeRuleProcessorCEL = require_getDatetimeRuleProcessorTanStackDB.getDatetimeRuleProcessorCEL;
+exports.getDatetimeRuleProcessorCypher = require_getDatetimeRuleProcessorTanStackDB.getDatetimeRuleProcessorCypher;
+exports.getDatetimeRuleProcessorDrizzle = require_getDatetimeRuleProcessorTanStackDB.getDatetimeRuleProcessorDrizzle;
+exports.getDatetimeRuleProcessorElasticSearch = require_getDatetimeRuleProcessorTanStackDB.getDatetimeRuleProcessorElasticSearch;
+exports.getDatetimeRuleProcessorGremlin = require_getDatetimeRuleProcessorTanStackDB.getDatetimeRuleProcessorGremlin;
+exports.getDatetimeRuleProcessorJSONata = require_getDatetimeRuleProcessorTanStackDB.getDatetimeRuleProcessorJSONata;
+exports.getDatetimeRuleProcessorLDAP = require_getDatetimeRuleProcessorTanStackDB.getDatetimeRuleProcessorLDAP;
+exports.getDatetimeRuleProcessorMongoDB = require_getDatetimeRuleProcessorTanStackDB.getDatetimeRuleProcessorMongoDB;
+exports.getDatetimeRuleProcessorMongoDBQuery = require_getDatetimeRuleProcessorTanStackDB.getDatetimeRuleProcessorMongoDBQuery;
+exports.getDatetimeRuleProcessorNL = require_getDatetimeRuleProcessorTanStackDB.getDatetimeRuleProcessorNL;
+exports.getDatetimeRuleProcessorParameterized = require_getDatetimeRuleProcessorTanStackDB.getDatetimeRuleProcessorParameterized;
+exports.getDatetimeRuleProcessorPrisma = require_getDatetimeRuleProcessorTanStackDB.getDatetimeRuleProcessorPrisma;
+exports.getDatetimeRuleProcessorSPARQL = require_getDatetimeRuleProcessorTanStackDB.getDatetimeRuleProcessorSPARQL;
+exports.getDatetimeRuleProcessorSQL = require_getDatetimeRuleProcessorTanStackDB.getDatetimeRuleProcessorSQL;
+exports.getDatetimeRuleProcessorSequelize = require_getDatetimeRuleProcessorTanStackDB.getDatetimeRuleProcessorSequelize;
+exports.getDatetimeRuleProcessorSpEL = require_getDatetimeRuleProcessorTanStackDB.getDatetimeRuleProcessorSpEL;
+exports.getDatetimeRuleProcessorTanStackDB = require_getDatetimeRuleProcessorTanStackDB.getDatetimeRuleProcessorTanStackDB;
+exports.getDatetimeValueProcessorANSI = require_getDatetimeRuleProcessorTanStackDB.getDatetimeValueProcessorANSI;
+exports.getDatetimeValueProcessorMSSQL = require_getDatetimeRuleProcessorTanStackDB.getDatetimeValueProcessorMSSQL;
+exports.getDatetimeValueProcessorMySQL = require_getDatetimeRuleProcessorTanStackDB.getDatetimeValueProcessorMySQL;
+exports.getDatetimeValueProcessorOracle = require_getDatetimeRuleProcessorTanStackDB.getDatetimeValueProcessorOracle;
+exports.getDatetimeValueProcessorPostgreSQL = require_getDatetimeRuleProcessorTanStackDB.getDatetimeValueProcessorPostgreSQL;
+exports.relativeDateTimeToggleClassName = relativeDateTimeToggleClassName;
+exports.toggleModeController = toggleModeController;
+exports.useRelativeDateTimeConfig = useRelativeDateTimeConfig;
+exports.withRelativeOperators = withRelativeOperators;
 
 //# sourceMappingURL=react-querybuilder_datetime.cjs.development.js.map