@react-querybuilder/datetime 8.17.0 → 8.19.0

package/dist/cjs/rqbDateTimeLibraryAPI.dayjs-CzLh_zi9.js

@@ -0,0 +1,63 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+const require_getDatetimeRuleProcessorTanStackDB = require("./getDatetimeRuleProcessorTanStackDB-CL79A1_x.js");
+let dayjs = require("dayjs");
+dayjs = __toESM(dayjs);
+//#region src/rqbDateTimeLibraryAPI.dayjs.ts
+/**
+* {@link RQBDateTimeLibraryAPI} for Day.js
+*/
+const rqbDateTimeLibraryAPI = {
+	format: (d, fmt) => (0, dayjs.default)(d).format(fmt),
+	isAfter: (a, b) => (0, dayjs.default)(a).isAfter(b),
+	isBefore: (a, b) => (0, dayjs.default)(a).isBefore(b),
+	isSame: (a, b) => (0, dayjs.default)(a).isSame(b, require_getDatetimeRuleProcessorTanStackDB.isISOStringDateOnly(a) || require_getDatetimeRuleProcessorTanStackDB.isISOStringDateOnly(b) ? "d" : "ms"),
+	isValid: (d) => (0, dayjs.default)(d).isValid(),
+	toDate: (d) => (0, dayjs.default)(d).toDate(),
+	toISOString: (d) => {
+		const dToDate = (0, dayjs.default)(d);
+		return dToDate.isValid() ? dToDate.toISOString() : "";
+	},
+	toISOStringDateOnly: (d) => {
+		const dToDate = (0, dayjs.default)(d);
+		return dToDate.isValid() ? dToDate.format("YYYY-MM-DD") : "";
+	},
+	startOf: (d, unit) => (0, dayjs.default)(d).startOf(unit).toDate(),
+	endOf: (d, unit) => (0, dayjs.default)(d).endOf(unit).toDate(),
+	add: (d, amount, unit) => (0, dayjs.default)(d).add(amount, unit).toDate()
+};
+//#endregion
+Object.defineProperty(exports, "__toESM", {
+	enumerable: true,
+	get: function() {
+		return __toESM;
+	}
+});
+Object.defineProperty(exports, "rqbDateTimeLibraryAPI", {
+	enumerable: true,
+	get: function() {
+		return rqbDateTimeLibraryAPI;
+	}
+});
+
+//# sourceMappingURL=rqbDateTimeLibraryAPI.dayjs-CzLh_zi9.js.map

package/dist/cjs/rqbDateTimeLibraryAPI.dayjs-CzLh_zi9.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rqbDateTimeLibraryAPI.dayjs-CzLh_zi9.js","names":["isISOStringDateOnly"],"sources":["../../src/rqbDateTimeLibraryAPI.dayjs.ts"],"sourcesContent":["import dayjs from 'dayjs';\nimport type { RQBDateTimeLibraryAPI } from './types';\nimport { isISOStringDateOnly } from './utils';\n\n/**\n * {@link RQBDateTimeLibraryAPI} for Day.js\n */\nexport const rqbDateTimeLibraryAPI: RQBDateTimeLibraryAPI = {\n  format: (d, fmt) => dayjs(d).format(fmt),\n  isAfter: (a, b) => dayjs(a).isAfter(b),\n  isBefore: (a, b) => dayjs(a).isBefore(b),\n  isSame: (a, b) =>\n    dayjs(a).isSame(b, isISOStringDateOnly(a) || isISOStringDateOnly(b) ? 'd' : 'ms'),\n  isValid: d => dayjs(d).isValid(),\n  toDate: d => dayjs(d).toDate(),\n  toISOString: d => {\n    const dToDate = dayjs(d);\n    return dToDate.isValid() ? dToDate.toISOString() : '';\n  },\n  toISOStringDateOnly: d => {\n    const dToDate = dayjs(d);\n    return dToDate.isValid() ? dToDate.format('YYYY-MM-DD') : '';\n  },\n  startOf: (d, unit) => dayjs(d).startOf(unit).toDate(),\n  endOf: (d, unit) => dayjs(d).endOf(unit).toDate(),\n  add: (d, amount, unit) => dayjs(d).add(amount, unit).toDate(),\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAOA,MAAa,wBAA+C;CAC1D,SAAS,GAAG,SAAA,GAAA,MAAA,QAAA,CAAc,CAAC,CAAC,CAAC,OAAO,GAAG;CACvC,UAAU,GAAG,OAAA,GAAA,MAAA,QAAA,CAAY,CAAC,CAAC,CAAC,QAAQ,CAAC;CACrC,WAAW,GAAG,OAAA,GAAA,MAAA,QAAA,CAAY,CAAC,CAAC,CAAC,SAAS,CAAC;CACvC,SAAS,GAAG,OAAA,GAAA,MAAA,QAAA,CACJ,CAAC,CAAC,CAAC,OAAO,GAAGA,2CAAAA,oBAAoB,CAAC,KAAKA,2CAAAA,oBAAoB,CAAC,IAAI,MAAM,IAAI;CAClF,UAAS,OAAA,GAAA,MAAA,QAAA,CAAW,CAAC,CAAC,CAAC,QAAQ;CAC/B,SAAQ,OAAA,GAAA,MAAA,QAAA,CAAW,CAAC,CAAC,CAAC,OAAO;CAC7B,cAAa,MAAK;EAChB,MAAM,WAAA,GAAA,MAAA,QAAA,CAAgB,CAAC;EACvB,OAAO,QAAQ,QAAQ,IAAI,QAAQ,YAAY,IAAI;CACrD;CACA,sBAAqB,MAAK;EACxB,MAAM,WAAA,GAAA,MAAA,QAAA,CAAgB,CAAC;EACvB,OAAO,QAAQ,QAAQ,IAAI,QAAQ,OAAO,YAAY,IAAI;CAC5D;CACA,UAAU,GAAG,UAAA,GAAA,MAAA,QAAA,CAAe,CAAC,CAAC,CAAC,QAAQ,IAAI,CAAC,CAAC,OAAO;CACpD,QAAQ,GAAG,UAAA,GAAA,MAAA,QAAA,CAAe,CAAC,CAAC,CAAC,MAAM,IAAI,CAAC,CAAC,OAAO;CAChD,MAAM,GAAG,QAAQ,UAAA,GAAA,MAAA,QAAA,CAAe,CAAC,CAAC,CAAC,IAAI,QAAQ,IAAI,CAAC,CAAC,OAAO;AAC9D"}

package/dist/cjs/types-XYMw0jFT.d.ts

@@ -0,0 +1,265 @@
+import { FullOption, RQBJsonLogic, RuleProcessor, ValueEditorProps } from "react-querybuilder";
+import { RulesLogic } from "json-logic-js";
+import { ComponentType, ReactNode } from "react";
+
+//#region src/types.d.ts
+interface RQBJsonLogicDateBetween {
+  dateBetween: [RQBJsonLogic, RQBJsonLogic, RQBJsonLogic];
+}
+interface RQBJsonLogicDateNotBetween {
+  dateNotBetween: [RQBJsonLogic, RQBJsonLogic, RQBJsonLogic];
+}
+interface RQBJsonLogicDateIn {
+  dateIn: [RQBJsonLogic, RQBJsonLogic[]];
+}
+interface RQBJsonLogicDateNotIn {
+  dateNotIn: [RQBJsonLogic, RQBJsonLogic[]];
+}
+interface RQBJsonLogicDateBefore {
+  dateBefore: [RQBJsonLogic, RQBJsonLogic, ...RQBJsonLogic[]];
+}
+interface RQBJsonLogicDateOnOrBefore {
+  dateOnOrBefore: [RQBJsonLogic, RQBJsonLogic, ...RQBJsonLogic[]];
+}
+interface RQBJsonLogicDateOn {
+  dateOn: [RQBJsonLogic, RQBJsonLogic, ...RQBJsonLogic[]];
+}
+interface RQBJsonLogicDateNotOn {
+  dateNotOn: [RQBJsonLogic, RQBJsonLogic, ...RQBJsonLogic[]];
+}
+interface RQBJsonLogicDateAfter {
+  dateAfter: [RQBJsonLogic, RQBJsonLogic, ...RQBJsonLogic[]];
+}
+interface RQBJsonLogicDateOnOrAfter {
+  dateOnOrAfter: [RQBJsonLogic, RQBJsonLogic, ...RQBJsonLogic[]];
+}
+interface RQBJsonLogicDateRelative {
+  dateRelative: [RelativeDateTimeAnchor, number, RelativeDateTimeUnit, boolean];
+}
+/**
+* JsonLogic rule object with additional operators generated by
+* {@link @react-querybuilder/core!formatQuery formatQuery} and accepted by
+* {@link @react-querybuilder/core!parseJsonLogic parseJsonLogic}.
+*/
+type RQBDateTimeJsonLogic = RQBJsonLogic | RulesLogic<RQBJsonLogicDateAfter | RQBJsonLogicDateBefore | RQBJsonLogicDateBetween | RQBJsonLogicDateIn | RQBJsonLogicDateNotBetween | RQBJsonLogicDateNotIn | RQBJsonLogicDateNotOn | RQBJsonLogicDateOn | RQBJsonLogicDateOnOrAfter | RQBJsonLogicDateOnOrBefore | RQBJsonLogicDateRelative>;
+type DateOrString = string | Date;
+/**
+* Unit of measure for a relative date/time offset.
+*/
+type RelativeDateTimeUnit = "minute" | "hour" | "day" | "week" | "month" | "year";
+/**
+* Unit of measure for truncating a date/time to the start or end of a period
+* (the subset of {@link RelativeDateTimeUnit} that represents a calendar period).
+*/
+type RelativeDateTimeTruncationUnit = "day" | "week" | "month" | "year";
+/**
+* Reference point (zero-offset) for a {@link RelativeDateTimeValue}. `'now'` is the
+* current date/time; the `startOf*`/`endOf*` anchors truncate to the start or end
+* of the corresponding calendar period.
+*/
+type RelativeDateTimeAnchor = "now" | "startOfDay" | "endOfDay" | "startOfWeek" | "endOfWeek" | "startOfMonth" | "endOfMonth" | "startOfYear" | "endOfYear";
+/**
+* Structured representation of a relative date/time value, e.g. "three months ago"
+* or "the beginning of this year". Stored as the `value` of a rule (in place of the
+* usual ISO 8601 string) and recognized by the date/time rule processors.
+*
+* The final date/time is computed as: apply the `anchor` to the current date/time,
+* then add `offset` units of `unit`. When `offset` is `0`, `unit` is irrelevant.
+*/
+interface RelativeDateTimeValue {
+  /** Discriminant identifying a relative (as opposed to absolute) value. */
+  mode: "relative";
+  /** Zero-offset reference point. */
+  anchor: RelativeDateTimeAnchor;
+  /** Signed offset from the anchor; negative = past, positive = future, 0 = exact anchor. */
+  offset: number;
+  /** Unit of the `offset`. */
+  unit: RelativeDateTimeUnit;
+}
+interface RQBDateTimeLibraryAPI {
+  /**
+  * Formats a date as a string.
+  */
+  format: (d: DateOrString, fmt: string) => string;
+  /**
+  * Formats a date as an ISO 8601 string, only including
+  * the year, month, and day ('YYYY-MM-DD').
+  */
+  toISOStringDateOnly: (d: DateOrString) => string;
+  /**
+  * Determines whether the first date is after the second date.
+  */
+  isAfter: (a: DateOrString, b: DateOrString) => boolean;
+  /**
+  * Determines whether the first date is before the second date.
+  */
+  isBefore: (a: DateOrString, b: DateOrString) => boolean;
+  /**
+  * Determines whether the first date is the same as the second date.
+  *
+  * If either the first date or the second date is a string in the
+  * format 'YYYY-MM-DD', then the dates will only be compared at
+  * the date level (no time component). Otherwise, they will be
+  * compared to the millisecond.
+  */
+  isSame: (a: DateOrString, b: DateOrString) => boolean;
+  /**
+  * Determines whether the date is either a valid `Date` object or an
+  * ISO 8601-formatted string representing a valid date.
+  */
+  isValid: (d: DateOrString) => boolean;
+  /**
+  * Converts a string to a `Date` object or returns a valid `Date` as is.
+  */
+  toDate: (d: DateOrString) => Date;
+  /**
+  * Converts a `Date` or ISO 8601-formatted string into a full ISO 8601 UTC
+  * string, in the format 'YYYY-MM-DDTHH:mm:ss.SSSZ' (the "T" and "Z" are
+  * static; other parts represent standard time units, increasing in precision
+  * from left to right).
+  */
+  toISOString: (d: DateOrString) => string;
+  /**
+  * Returns a new `Date` truncated to the start of the given period.
+  *
+  * Week start follows the date library's own default/locale (e.g. Luxon uses
+  * Monday per ISO 8601; Day.js and date-fns default to Sunday).
+  */
+  startOf: (d: DateOrString, unit: RelativeDateTimeTruncationUnit) => Date;
+  /**
+  * Returns a new `Date` advanced to the end of the given period (the last
+  * representable instant within it).
+  *
+  * Week start follows the date library's own default/locale (see {@link RQBDateTimeLibraryAPI.startOf}).
+  */
+  endOf: (d: DateOrString, unit: RelativeDateTimeTruncationUnit) => Date;
+  /**
+  * Returns a new `Date` offset from the input by `amount` units of `unit`
+  * (negative `amount` moves into the past).
+  */
+  add: (d: DateOrString, amount: number, unit: RelativeDateTimeUnit) => Date;
+}
+type FnDateDate = (a: DateOrString, b: DateOrString) => boolean;
+type FnDateArrayOfDates = (a: DateOrString, b: DateOrString[]) => boolean;
+type FnDateDateDate = (a: DateOrString, b: DateOrString, c: DateOrString) => boolean;
+type RQBJsonLogicDateTimeOperations = {
+  /** Determines if the first date is after the second date. */dateAfter: FnDateDate; /** Determines if the first date is before the second date. */
+  dateBefore: FnDateDate; /** Determines if the second date is between the first and third dates (inclusive). */
+  dateBetween: FnDateDateDate; /** Determines if the first date is one of the values in the array of dates. */
+  dateIn: FnDateArrayOfDates; /** Determines if the second date is not between the first and third dates. */
+  dateNotBetween: FnDateDateDate; /** Determines if the first date is not one of the values in the array of dates. */
+  dateNotIn: FnDateArrayOfDates; /** Determines if the first date is not the same as the second date. */
+  dateNotOn: FnDateDate; /** Determines if the first date is the same as the second date (at the level of least precision between the two). */
+  dateOn: FnDateDate; /** Determines if the first date is either the same as the second date or after it. */
+  dateOnOrAfter: FnDateDate; /** Determines if the first date is either the same as the second date or before it. */
+  dateOnOrBefore: FnDateDate;
+  /**
+  * Resolves a relative date/time descriptor (anchor, offset, unit, and date-only
+  * flag) to a concrete ISO 8601 string at evaluation time ("live" semantics).
+  */
+  dateRelative: (anchor: RelativeDateTimeAnchor, offset: number, unit: RelativeDateTimeUnit, dateOnly: boolean) => string;
+};
+/**
+* Customizable content/labels for the absolute/relative mode toggle rendered by
+* {@link toggleModeController}. The default glyphs come from CSS pseudo-elements, so
+* `absoluteContent`/`relativeContent` are only needed to override them (e.g. to render
+* an icon component or localized text).
+*/
+interface RelativeDateTimeToggleLabels {
+  /** Accessible label (`aria-label`) for the toggle button. */
+  label?: string;
+  /** Tooltip shown while in absolute mode (clicking switches to relative). */
+  absoluteTitle?: string;
+  /** Tooltip shown while in relative mode (clicking switches to absolute). */
+  relativeTitle?: string;
+  /** Custom content rendered while in absolute mode. Defaults to a CSS glyph. */
+  absoluteContent?: ReactNode;
+  /** Custom content rendered while in relative mode. Defaults to a CSS glyph. */
+  relativeContent?: ReactNode;
+}
+/**
+* Props passed to a {@link RelativeDateTimeModeController}'s `ModeControl` component —
+* the affordance (e.g. a toggle button) that switches a rule between absolute and
+* relative date/time entry.
+*/
+interface RelativeDateTimeModeControlProps {
+  /** Whether the rule is currently in relative mode. */
+  isRelative: boolean;
+  /** Switches the rule between absolute and relative mode. */
+  setMode: (mode: "absolute" | "relative") => void;
+  /** The value editor's schema (for theme-aware rendering). */
+  schema: ValueEditorProps["schema"];
+  /** Whether the control is disabled. */
+  disabled?: boolean;
+  /** Class name applied to the control. */
+  className?: string;
+  /** Title/tooltip from the value editor (fallback when labels omit titles). */
+  title?: string;
+  /** Test ID from the value editor. */
+  testID?: string;
+  /** Resolved toggle labels (merged with defaults). */
+  labels: Required<RelativeDateTimeToggleLabels>;
+}
+/**
+* A pluggable strategy that governs how a user switches between absolute and relative
+* date/time entry in the {@link RelativeDateTimeValueEditor}. The stored value shape is
+* unaffected — a controller only decides the current mode and (optionally) renders an
+* affordance to change it.
+*
+* Ships with {@link toggleModeController} (the zero-config default); build an
+* operator-driven controller with {@link createOperatorModeController}, or supply a custom
+* object to fully control the UX.
+*/
+interface RelativeDateTimeModeController {
+  /** Derives the current mode from the rule (its operator and/or value). */
+  isRelative: (props: ValueEditorProps) => boolean;
+  /**
+  * Optional affordance rendered inside the editor to switch modes. Omit it (as the
+  * operator-driven controller does) when the mode is selected elsewhere, e.g. via the
+  * operator selector.
+  */
+  ModeControl?: ComponentType<RelativeDateTimeModeControlProps>;
+}
+/**
+* Configuration for the {@link RelativeDateTimeValueEditor}, supplied as props to
+* {@link QueryBuilderDateTime} (or via the relative date/time config context). Every
+* field is optional; omitting all of them yields the zero-config toggle experience.
+*/
+interface RelativeDateTimeEditorConfig {
+  /** Strategy for switching between absolute and relative modes. Defaults to {@link toggleModeController}. */
+  modeController?: RelativeDateTimeModeController;
+  /** Anchor (reference-point) options. Defaults to {@link defaultRelativeDateTimeAnchors}. */
+  anchors?: FullOption<RelativeDateTimeAnchor>[];
+  /** Unit options. Defaults to {@link defaultRelativeDateTimeUnits}. */
+  units?: FullOption<RelativeDateTimeUnit>[];
+  /** Content/labels for the absolute/relative toggle. */
+  toggleLabels?: RelativeDateTimeToggleLabels;
+  /**
+  * Date/time library adapter used by the value editor to parse/validate the rule value
+  * for the native date input. Defaults to the Day.js adapter. Pass the adapter matching
+  * your chosen entry point (e.g. from `@react-querybuilder/datetime/luxon`) so the editor
+  * interprets values consistently with the rule processors.
+  */
+  dateTimeAPI?: RQBDateTimeLibraryAPI;
+}
+/**
+* Maps operator names that are used only to _signal_ relative mode (see
+* {@link createOperatorModeController}) to the real comparison operator that should be used
+* when exporting via `formatQuery`. Supplied through `context.relativeOperatorMap`. Operators
+* not present in the map are exported unchanged.
+*
+* @example
+* ```ts
+* formatQuery(query, {
+*   format: 'sql',
+*   ruleProcessor: datetimeRuleProcessorSQL,
+*   context: { relativeOperatorMap: { relativeEq: '=' } },
+* });
+* ```
+*/
+type RelativeOperatorMap = Record<string, string>;
+type IsDateFieldFunction = (...[rule, opts]: Parameters<RuleProcessor>) => boolean;
+type IsDateField = IsDateFieldFunction | Record<string, unknown> | Record<string, unknown>[] | boolean | undefined;
+//#endregion
+export { RelativeDateTimeUnit as C, RelativeDateTimeTruncationUnit as S, RelativeOperatorMap as T, RelativeDateTimeAnchor as _, RQBJsonLogicDateAfter as a, RelativeDateTimeModeController as b, RQBJsonLogicDateIn as c, RQBJsonLogicDateNotOn as d, RQBJsonLogicDateOn as f, RQBJsonLogicDateTimeOperations as g, RQBJsonLogicDateRelative as h, RQBDateTimeLibraryAPI as i, RQBJsonLogicDateNotBetween as l, RQBJsonLogicDateOnOrBefore as m, IsDateFieldFunction as n, RQBJsonLogicDateBefore as o, RQBJsonLogicDateOnOrAfter as p, RQBDateTimeJsonLogic as r, RQBJsonLogicDateBetween as s, IsDateField as t, RQBJsonLogicDateNotIn as u, RelativeDateTimeEditorConfig as v, RelativeDateTimeValue as w, RelativeDateTimeToggleLabels as x, RelativeDateTimeModeControlProps as y };
+//# sourceMappingURL=types-XYMw0jFT.d.ts.map

package/dist/datetime-layout.css

@@ -0,0 +1 @@
+:root{--rqbdt-spacing: 0.5rem}.rule-value-dateTimeRelative{display:inline-flex;flex-wrap:wrap;align-items:center;gap:var(--rqbdt-spacing)}.rule-value-dateTimeRelative-toggle{cursor:pointer}.rule-value-dateTimeRelative-toggle:empty::before{content:"📅"}.rule-value-dateTimeRelative-toggle[aria-checked=true]:empty::before{content:"🕒"}.rule-value-dateTimeRelative-toggle:disabled{cursor:not-allowed}/*# sourceMappingURL=datetime-layout.css.map */

package/dist/datetime-layout.css.map

@@ -0,0 +1 @@
+{"version":3,"sourceRoot":"","sources":["styles/_root.scss","styles/_layout.scss"],"names":[],"mappings":"CAEA,MACE,wBCEF,6BACE,oBACA,eACA,mBACA,yBAMF,oCACE,eAEA,kDACE,aAGF,qEACE,aAGF,6CACE","file":"datetime-layout.css"}

package/dist/datetime-layout.scss

@@ -0,0 +1,3 @@
+@forward './styles/variables';
+@forward './styles/root';
+@forward './styles/layout';

package/dist/datetime.css

@@ -0,0 +1 @@
+:root{--rqbdt-spacing: 0.5rem}.rule-value-dateTimeRelative{display:inline-flex;flex-wrap:wrap;align-items:center;gap:var(--rqbdt-spacing)}.rule-value-dateTimeRelative-toggle{cursor:pointer}.rule-value-dateTimeRelative-toggle:empty::before{content:"📅"}.rule-value-dateTimeRelative-toggle[aria-checked=true]:empty::before{content:"🕒"}.rule-value-dateTimeRelative-toggle:disabled{cursor:not-allowed}/*# sourceMappingURL=datetime.css.map */

package/dist/datetime.css.map

@@ -0,0 +1 @@
+{"version":3,"sourceRoot":"","sources":["styles/_root.scss","styles/_layout.scss"],"names":[],"mappings":"CAEA,MACE,wBCEF,6BACE,oBACA,eACA,mBACA,yBAMF,oCACE,eAEA,kDACE,aAGF,qEACE,aAGF,6CACE","file":"datetime.css"}

package/dist/datetime.scss

@@ -0,0 +1 @@
+@forward './datetime-layout';