@datum-cloud/datum-ui 0.8.0 → 0.9.0

package/dist/default-footer-DbpemJVl.mjs

@@ -0,0 +1,1037 @@
+import { t as cn } from "./cn-D2KYQ917.mjs";
+import { t as Button } from "./button-BllvE9Lm.mjs";
+import { t as Button$1 } from "./button-Rw1xI-k9.mjs";
+import { t as useBreakpoint } from "./use-breakpoint-DGcVmB3c.mjs";
+import { t as ResponsivePopover } from "./responsive-popover-D-t9bxSN.mjs";
+import { CalendarIcon, X } from "lucide-react";
+import { createContext, useCallback, useContext, useEffect, useMemo, useReducer, useRef } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { endOfDay, endOfMonth, endOfWeek, endOfYear, format, startOfDay, startOfMonth, startOfWeek, startOfYear, subDays, subHours, subMinutes } from "date-fns";
+import { formatInTimeZone, fromZonedTime, toZonedTime } from "date-fns-tz";
+//#region src/components/base/date-picker/use-date-constraints.ts
+function useDateConstraints({ minDate, maxDate, disablePast, disableFuture }) {
+	const today = useMemo(() => /* @__PURE__ */ new Date(), []);
+	const effectiveMinDate = useMemo(() => {
+		let min = minDate;
+		if (disablePast) {
+			const todayStart = startOfDay(today);
+			min = min ? min > todayStart ? min : todayStart : todayStart;
+		}
+		return min;
+	}, [
+		minDate,
+		disablePast,
+		today
+	]);
+	const effectiveMaxDate = useMemo(() => {
+		let max = maxDate;
+		if (disableFuture) {
+			const todayEnd = endOfDay(today);
+			max = max ? max < todayEnd ? max : todayEnd : todayEnd;
+		}
+		return max;
+	}, [
+		maxDate,
+		disableFuture,
+		today
+	]);
+	return {
+		effectiveMinDate,
+		effectiveMaxDate,
+		isDateDisabled: useCallback((date) => {
+			if (effectiveMinDate && date < effectiveMinDate) return true;
+			if (effectiveMaxDate && date > effectiveMaxDate) return true;
+			return false;
+		}, [effectiveMinDate, effectiveMaxDate])
+	};
+}
+//#endregion
+//#region src/components/features/picker/types.ts
+const RANGE_MODES = [
+	"date-range",
+	"time-range",
+	"datetime-range",
+	"date-range-time"
+];
+const TIME_BEARING_MODES = [
+	"time",
+	"time-range",
+	"datetime",
+	"datetime-range",
+	"date-range-time"
+];
+const DATE_BEARING_MODES = [
+	"date",
+	"date-range",
+	"datetime",
+	"datetime-range",
+	"date-range-time"
+];
+function isRangeMode(mode) {
+	return RANGE_MODES.includes(mode);
+}
+function isTimeBearingMode(mode) {
+	return TIME_BEARING_MODES.includes(mode);
+}
+function isDateBearingMode(mode) {
+	return DATE_BEARING_MODES.includes(mode);
+}
+const ALLOWED_STEPS = [
+	1,
+	5,
+	10,
+	15,
+	30,
+	60
+];
+//#endregion
+//#region src/components/features/picker/utils/timezone.ts
+/** Browser-detected IANA timezone, falling back to UTC if unavailable. */
+function getBrowserTimezone() {
+	try {
+		return Intl.DateTimeFormat().resolvedOptions().timeZone;
+	} catch {
+		return "UTC";
+	}
+}
+/**
+* UTC offset for a timezone in `±HH:MM` format.
+* Returns `+00:00` for UTC or any timezone the runtime cannot resolve.
+*/
+function getTimezoneOffset(timezone) {
+	try {
+		const offsetPart = new Intl.DateTimeFormat("en-US", {
+			timeZone: timezone,
+			timeZoneName: "shortOffset"
+		}).formatToParts(/* @__PURE__ */ new Date()).find((p) => p.type === "timeZoneName");
+		if (!offsetPart) return "+00:00";
+		const match = /GMT([+-])(\d+)(?::(\d+))?/.exec(offsetPart.value);
+		if (match) return `${match[1]}${match[2].padStart(2, "0")}:${match[3]?.padStart(2, "0") ?? "00"}`;
+		if (offsetPart.value === "GMT") return "+00:00";
+		return "+00:00";
+	} catch {
+		return "+00:00";
+	}
+}
+/**
+* Human-readable timezone label.
+* Example: `'Asia/Jakarta'` → `'Asia/Jakarta (UTC+07:00)'`.
+*/
+function formatTimezoneLabel(timezone) {
+	const offset = getTimezoneOffset(timezone);
+	return `${timezone.replace(/_/g, " ")} (UTC${offset})`;
+}
+/**
+* Convert a UTC ISO string to a Date object whose wall-clock components
+* (year/month/day/hours/minutes) reflect the value as seen in `timezone`.
+*
+* Use this to feed Calendar / time slot UI that reads `getHours()` etc.
+*
+* INVARIANT: `zonedDateToIso(isoToZonedDate(iso, tz), tz) === iso` for any
+* valid ISO and tz.
+*/
+function isoToZonedDate(iso, timezone) {
+	return toZonedTime(new Date(iso), timezone);
+}
+/**
+* Date-input variant of `isoToZonedDate`. Skips the ISO round-trip when the
+* caller already has a Date instance (e.g. preset `getRange(tz)` results).
+*/
+function dateToZoned(date, timezone) {
+	return toZonedTime(date, timezone);
+}
+/**
+* Inverse of `isoToZonedDate`. Treat the Date's wall-clock components
+* as `timezone`-local and convert back to a UTC ISO instant.
+*/
+function zonedDateToIso(date, timezone) {
+	return fromZonedTime(date, timezone).toISOString();
+}
+/**
+* Format a UTC ISO string in the given timezone using a date-fns format pattern.
+* Returns empty string if the input is not a valid date.
+*/
+function formatInTimezone(iso, timezone, pattern) {
+	try {
+		const d = new Date(iso);
+		if (Number.isNaN(d.getTime())) return "";
+		return formatInTimeZone(d, timezone, pattern);
+	} catch {
+		return "";
+	}
+}
+//#endregion
+//#region src/components/features/picker/components/context.ts
+const PickerContext = createContext(null);
+/** Throws when used outside `<Picker.Root>` — enforces compound-component discipline. */
+function usePickerContext() {
+	const ctx = useContext(PickerContext);
+	if (!ctx) throw new Error("Picker primitives must be rendered inside <Picker.Root>");
+	return ctx;
+}
+//#endregion
+//#region src/components/features/picker/components/content.tsx
+function PickerContent({ trigger, sheetTitle, sheetDescription, footer, align = "start", side = "bottom", modal, contentClassName, children }) {
+	const { state, actions, effectiveCommit, responsive, breakpoint } = usePickerContext();
+	const isMobileSheet = responsive && breakpoint === "mobile";
+	const desktopFooter = !isMobileSheet && effectiveCommit === "apply" ? footer : null;
+	const sheetFooter = isMobileSheet ? footer : void 0;
+	return /* @__PURE__ */ jsx(ResponsivePopover, {
+		open: state.open,
+		onOpenChange: (open) => open ? actions.open() : actions.close(),
+		trigger,
+		sheetTitle,
+		sheetDescription,
+		sheetFooter,
+		align,
+		side,
+		modal,
+		responsive,
+		contentClassName: cn("w-auto", contentClassName),
+		children: /* @__PURE__ */ jsxs("div", {
+			className: "flex flex-col",
+			children: [/* @__PURE__ */ jsx("div", {
+				className: "flex flex-col",
+				children
+			}), desktopFooter && /* @__PURE__ */ jsx("div", {
+				className: "border-t p-3",
+				children: desktopFooter
+			})]
+		})
+	});
+}
+PickerContent.displayName = "Picker.Content";
+//#endregion
+//#region src/components/features/picker/hooks/use-keyboard-shortcuts.ts
+/**
+* Bind preset keyboard shortcuts to a scoped root element (NOT document).
+*
+* Why root-scoped: binding on `document` causes presets to fire when the
+* user is typing in any input on the page — a well-known bug in the legacy
+* TimeRangePicker. Scoping to the picker's root element fixes it.
+*
+* Modifier keys (Ctrl, Meta, Alt) are ignored to avoid colliding with
+* browser/OS shortcuts.
+*/
+function useKeyboardShortcuts({ rootRef, presets, onSelect, enabled }) {
+	useEffect(() => {
+		if (!enabled) return;
+		const root = rootRef.current;
+		if (!root) return;
+		function handler(e) {
+			if (e.ctrlKey || e.metaKey || e.altKey) return;
+			const matched = presets.find((p) => p.shortcut && p.shortcut.toLowerCase() === e.key.toLowerCase());
+			if (matched) {
+				e.preventDefault();
+				onSelect(matched);
+			}
+		}
+		root.addEventListener("keydown", handler);
+		return () => root.removeEventListener("keydown", handler);
+	}, [
+		rootRef,
+		presets,
+		onSelect,
+		enabled
+	]);
+}
+//#endregion
+//#region src/components/features/picker/utils/commit.ts
+/**
+* Resolves the effective commit semantics for a picker.
+*
+* - Date + time combined modes (`datetime` / `datetime-range` /
+*   `date-range-time`) **always** commit on Apply, regardless of the
+*   caller-supplied override. Picking a date alone shouldn't publish a
+*   value with an unconfirmed 00:00 time — the user needs to set the
+*   time too, then explicitly Apply. The wrappers don't expose a
+*   `commit` prop for these modes; primitive consumers can still pass
+*   one through `Picker.Root` but it's silently overridden here.
+* - Range modes (`date-range`, `time-range`) default to `'apply'`.
+* - Everything else defaults to `'immediate'`.
+*/
+function resolveCommit(mode, commit) {
+	if (isDateBearingMode(mode) && isTimeBearingMode(mode)) return "apply";
+	return commit ?? (isRangeMode(mode) ? "apply" : "immediate");
+}
+//#endregion
+//#region src/components/features/picker/utils/format.ts
+/**
+* Format a Date as YYYY-MM-DD using local-time components.
+*
+* Note: this is the consumer-friendly format for date-only modes.
+* It does NOT round-trip through timezones; that's intentional —
+* a calendar day has no timezone.
+*/
+function dateToYYYYMMDD(d) {
+	return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`;
+}
+/**
+* Extract `"HH:mm"` from a Date using its wall-clock components.
+*
+* Caller is responsible for ensuring those components reflect the
+* intended timezone (typically via `dateToZoned` / `isoToZonedDate`
+* upstream). Pads single-digit hour/minute to two characters.
+*/
+function dateToHHmm(d) {
+	return `${String(d.getHours()).padStart(2, "0")}:${String(d.getMinutes()).padStart(2, "0")}`;
+}
+const TIME_REGEX = /^(\d{2}):(\d{2})$/;
+/**
+* Strict HH:mm validation. Rejects single-digit components,
+* out-of-range hours/minutes, and any non-numeric content.
+*/
+function isValidTimeString(s) {
+	const match = TIME_REGEX.exec(s);
+	if (!match) return false;
+	const h = Number(match[1]);
+	const m = Number(match[2]);
+	return h >= 0 && h <= 23 && m >= 0 && m <= 59;
+}
+/**
+* Parse a HH:mm string. Returns null for invalid input.
+*/
+function parseTimeString(s) {
+	if (!isValidTimeString(s)) return null;
+	const match = TIME_REGEX.exec(s);
+	return {
+		h: Number(match[1]),
+		m: Number(match[2])
+	};
+}
+/**
+* Format a HH:mm string for user display, respecting hour cycle.
+*
+* - `'24'`: returns the input as-is (`"14:30"`)
+* - `'12'`: returns `"2:30 PM"` style with AM/PM and no leading zero on hour
+*
+* Returns empty string for invalid input — callers should validate first.
+*/
+function formatTimeLabel(time, hourCycle) {
+	const parsed = parseTimeString(time);
+	if (!parsed) return "";
+	if (hourCycle === "24") return time;
+	const period = parsed.h >= 12 ? "PM" : "AM";
+	return `${parsed.h === 0 ? 12 : parsed.h > 12 ? parsed.h - 12 : parsed.h}:${String(parsed.m).padStart(2, "0")} ${period}`;
+}
+//#endregion
+//#region src/components/features/picker/hooks/use-picker-state.ts
+function reducer(state, action) {
+	switch (action.type) {
+		case "SET_SINGLE_DATE":
+		case "SET_SINGLE_TIME":
+		case "SET_SINGLE_DATETIME":
+		case "SET_RANGE":
+		case "SET_TIME_RANGE":
+		case "SET_DATETIME_RANGE": return {
+			...state,
+			pendingValue: action.payload,
+			selectedPresetKey: void 0
+		};
+		case "SELECT_PRESET": return {
+			...state,
+			pendingValue: action.payload.pendingValue,
+			selectedPresetKey: action.payload.key,
+			monthFrom: action.payload.monthFrom,
+			monthTo: action.payload.monthTo
+		};
+		case "SET_MONTH_FROM": return {
+			...state,
+			monthFrom: action.payload
+		};
+		case "SET_MONTH_TO": return {
+			...state,
+			monthTo: action.payload
+		};
+		case "OPEN": return {
+			...state,
+			open: true
+		};
+		case "CLOSE": return {
+			...state,
+			open: false
+		};
+		case "RESET_TO": return {
+			...state,
+			pendingValue: action.payload,
+			selectedPresetKey: void 0
+		};
+		case "CLEAR_PRESET": return {
+			...state,
+			selectedPresetKey: void 0
+		};
+		default: return state;
+	}
+}
+/**
+* Convert a preset's `{ from: Date, to: Date }` (real UTC instants) into the
+* value shape that the picker's `mode` actually emits.
+*
+* - `date-range`: pass through (Dates).
+* - `datetime-range` / `date-range-time`: `.toISOString()` — instants already match.
+* - `time-range`: extract wall-clock `HH:mm` in the active timezone.
+* - others (date / time / datetime): no preset value — return `null`.
+*/
+function presetValueForMode(mode, range, key, timezone) {
+	switch (mode) {
+		case "date-range": return {
+			from: range.from,
+			to: range.to,
+			preset: key
+		};
+		case "datetime-range":
+		case "date-range-time": return {
+			from: range.from.toISOString(),
+			to: range.to.toISOString(),
+			preset: key
+		};
+		case "time-range": return {
+			from: dateToHHmm(dateToZoned(range.from, timezone)),
+			to: dateToHHmm(dateToZoned(range.to, timezone)),
+			preset: key
+		};
+		default: return null;
+	}
+}
+function usePickerState({ mode, value, onChange, commit, timezone }) {
+	const effectiveCommit = resolveCommit(mode, commit);
+	const [state, dispatch] = useReducer(reducer, void 0, () => ({
+		pendingValue: value,
+		open: false,
+		selectedPresetKey: void 0,
+		monthFrom: void 0,
+		monthTo: void 0
+	}));
+	useEffect(() => {
+		dispatch({
+			type: "RESET_TO",
+			payload: value
+		});
+	}, [value]);
+	const onChangeRef = useRef(onChange);
+	const valueRef = useRef(value);
+	const pendingValueRef = useRef(state.pendingValue);
+	const effectiveCommitRef = useRef(effectiveCommit);
+	const modeRef = useRef(mode);
+	const timezoneRef = useRef(timezone);
+	useEffect(() => {
+		onChangeRef.current = onChange;
+		valueRef.current = value;
+		pendingValueRef.current = state.pendingValue;
+		effectiveCommitRef.current = effectiveCommit;
+		modeRef.current = mode;
+		timezoneRef.current = timezone;
+	});
+	const commitValue = useCallback((next) => {
+		onChangeRef.current(next);
+	}, []);
+	const actions = useMemo(() => {
+		const setSingleValue = (action) => {
+			dispatch(action);
+			if (effectiveCommitRef.current === "immediate") {
+				commitValue(action.payload);
+				dispatch({ type: "CLOSE" });
+			}
+		};
+		return {
+			setSingleDate: (d) => setSingleValue({
+				type: "SET_SINGLE_DATE",
+				payload: d
+			}),
+			setSingleTime: (t) => setSingleValue({
+				type: "SET_SINGLE_TIME",
+				payload: t
+			}),
+			setSingleDatetime: (iso) => setSingleValue({
+				type: "SET_SINGLE_DATETIME",
+				payload: iso
+			}),
+			setRange: (r) => {
+				dispatch({
+					type: "SET_RANGE",
+					payload: r
+				});
+				if (effectiveCommitRef.current === "immediate" && r !== null) {
+					commitValue(r);
+					dispatch({ type: "CLOSE" });
+				}
+			},
+			setTimeRange: (r) => {
+				dispatch({
+					type: "SET_TIME_RANGE",
+					payload: r
+				});
+				if (effectiveCommitRef.current === "immediate" && r !== null) {
+					commitValue(r);
+					dispatch({ type: "CLOSE" });
+				}
+			},
+			setDatetimeRange: (r) => {
+				dispatch({
+					type: "SET_DATETIME_RANGE",
+					payload: r
+				});
+				if (effectiveCommitRef.current === "immediate" && r !== null) {
+					commitValue(r);
+					dispatch({ type: "CLOSE" });
+				}
+			},
+			selectPreset: (range, key) => {
+				const pendingValue = presetValueForMode(modeRef.current, range, key, timezoneRef.current);
+				dispatch({
+					type: "SELECT_PRESET",
+					payload: {
+						pendingValue,
+						key,
+						monthFrom: range.from,
+						monthTo: range.to
+					}
+				});
+				commitValue(pendingValue);
+				dispatch({ type: "CLOSE" });
+			},
+			setMonthFrom: (d) => dispatch({
+				type: "SET_MONTH_FROM",
+				payload: d
+			}),
+			setMonthTo: (d) => dispatch({
+				type: "SET_MONTH_TO",
+				payload: d
+			}),
+			open: () => dispatch({ type: "OPEN" }),
+			close: () => dispatch({ type: "CLOSE" }),
+			apply: () => {
+				commitValue(pendingValueRef.current);
+				dispatch({ type: "CLOSE" });
+			},
+			reset: () => dispatch({
+				type: "RESET_TO",
+				payload: valueRef.current
+			}),
+			cancel: () => {
+				dispatch({
+					type: "RESET_TO",
+					payload: valueRef.current
+				});
+				dispatch({ type: "CLOSE" });
+			},
+			clear: () => {
+				dispatch({
+					type: "RESET_TO",
+					payload: null
+				});
+				commitValue(null);
+			}
+		};
+	}, [commitValue]);
+	return {
+		state: {
+			pendingValue: state.pendingValue,
+			open: state.open,
+			selectedPresetKey: state.selectedPresetKey,
+			monthFrom: state.monthFrom,
+			monthTo: state.monthTo
+		},
+		actions
+	};
+}
+//#endregion
+//#region src/components/features/picker/presets/defaults.ts
+function startOfDayInTz(d, tz) {
+	const zoned = toZonedTime(d, tz);
+	zoned.setHours(0, 0, 0, 0);
+	return fromZonedTime(zoned, tz);
+}
+function endOfDayInTz(d, tz) {
+	const zoned = toZonedTime(d, tz);
+	zoned.setHours(23, 59, 59, 999);
+	return fromZonedTime(zoned, tz);
+}
+/**
+* Date-bearing presets. Operate on calendar days; ignore time-of-day.
+*/
+const DATE_PRESETS = [
+	{
+		key: "today",
+		label: "Today",
+		shortcut: "D",
+		getRange: (tz) => ({
+			from: startOfDayInTz(/* @__PURE__ */ new Date(), tz),
+			to: endOfDayInTz(/* @__PURE__ */ new Date(), tz)
+		})
+	},
+	{
+		key: "yesterday",
+		label: "Yesterday",
+		shortcut: "Y",
+		getRange: (tz) => {
+			const y = subDays(/* @__PURE__ */ new Date(), 1);
+			return {
+				from: startOfDayInTz(y, tz),
+				to: endOfDayInTz(y, tz)
+			};
+		}
+	},
+	{
+		key: "this-week",
+		label: "This Week",
+		getRange: () => {
+			const now = /* @__PURE__ */ new Date();
+			return {
+				from: startOfWeek(now, { weekStartsOn: 1 }),
+				to: endOfWeek(now, { weekStartsOn: 1 })
+			};
+		}
+	},
+	{
+		key: "last-7-days",
+		label: "Last 7 Days",
+		shortcut: "W",
+		getRange: (tz) => ({
+			from: startOfDayInTz(subDays(/* @__PURE__ */ new Date(), 6), tz),
+			to: endOfDayInTz(/* @__PURE__ */ new Date(), tz)
+		})
+	},
+	{
+		key: "this-month",
+		label: "This Month",
+		getRange: () => {
+			const now = /* @__PURE__ */ new Date();
+			return {
+				from: startOfMonth(now),
+				to: endOfMonth(now)
+			};
+		}
+	},
+	{
+		key: "last-30-days",
+		label: "Last 30 Days",
+		shortcut: "M",
+		getRange: (tz) => ({
+			from: startOfDayInTz(subDays(/* @__PURE__ */ new Date(), 29), tz),
+			to: endOfDayInTz(/* @__PURE__ */ new Date(), tz)
+		})
+	},
+	{
+		key: "this-year",
+		label: "This Year",
+		getRange: () => {
+			const now = /* @__PURE__ */ new Date();
+			return {
+				from: startOfYear(now),
+				to: endOfYear(now)
+			};
+		}
+	}
+];
+/**
+* Datetime-bearing presets. Use "now" as the upper bound for past windows
+* (so the picker doesn't propose future timestamps).
+*/
+const DATETIME_PRESETS = [
+	{
+		key: "last-15m",
+		label: "Last 15 minutes",
+		shortcut: "1",
+		getRange: () => {
+			const now = /* @__PURE__ */ new Date();
+			return {
+				from: subMinutes(now, 15),
+				to: now
+			};
+		}
+	},
+	{
+		key: "last-1h",
+		label: "Last hour",
+		shortcut: "H",
+		getRange: () => {
+			const now = /* @__PURE__ */ new Date();
+			return {
+				from: subHours(now, 1),
+				to: now
+			};
+		}
+	},
+	{
+		key: "last-24h",
+		label: "Last 24 hours",
+		getRange: () => {
+			const now = /* @__PURE__ */ new Date();
+			return {
+				from: subHours(now, 24),
+				to: now
+			};
+		}
+	},
+	{
+		key: "today",
+		label: "Today",
+		shortcut: "D",
+		getRange: (tz) => ({
+			from: startOfDayInTz(/* @__PURE__ */ new Date(), tz),
+			to: /* @__PURE__ */ new Date()
+		})
+	},
+	{
+		key: "last-7-days",
+		label: "Last 7 days",
+		shortcut: "W",
+		getRange: () => {
+			const now = /* @__PURE__ */ new Date();
+			return {
+				from: subDays(now, 7),
+				to: now
+			};
+		}
+	},
+	{
+		key: "last-30-days",
+		label: "Last 30 days",
+		shortcut: "M",
+		getRange: () => {
+			const now = /* @__PURE__ */ new Date();
+			return {
+				from: subDays(now, 30),
+				to: now
+			};
+		}
+	}
+];
+const EMPTY = [];
+/**
+* Default preset set for a given mode. Time-only modes return empty —
+* presets rarely make sense for picking a wall-clock time.
+*/
+function getDefaultPresets(mode) {
+	switch (mode) {
+		case "date":
+		case "date-range": return DATE_PRESETS;
+		case "datetime":
+		case "datetime-range":
+		case "date-range-time": return DATETIME_PRESETS;
+		default: return EMPTY;
+	}
+}
+//#endregion
+//#region src/components/features/picker/hooks/use-presets.ts
+/**
+* Resolve the effective list of presets for a picker.
+*
+* Resolution order:
+*   1. If `custom` is provided, use it as-is (no exclusion, no constraint check).
+*   2. Otherwise: defaults for `mode`, minus `excludeKeys`, minus presets
+*      whose `getRange(timezone).from` or `.to` is rejected by `isDateDisabled`.
+*
+* Returns a memoized array; identity-stable when inputs haven't changed.
+*/
+function usePresets({ mode, timezone, custom, excludeKeys, isDateDisabled }) {
+	return useMemo(() => {
+		if (custom) return custom;
+		const base = getDefaultPresets(mode);
+		const excludeSet = new Set(excludeKeys ?? []);
+		return base.filter((preset) => {
+			if (excludeSet.has(preset.key)) return false;
+			const range = preset.getRange(timezone);
+			if (isDateDisabled(range.from)) return false;
+			if (isDateDisabled(range.to)) return false;
+			return true;
+		});
+	}, [
+		mode,
+		timezone,
+		custom,
+		excludeKeys,
+		isDateDisabled
+	]);
+}
+//#endregion
+//#region src/components/features/picker/components/root.tsx
+function detectHourCycle() {
+	try {
+		const opts = new Intl.DateTimeFormat(void 0, { hour: "numeric" }).resolvedOptions();
+		if (opts.hourCycle === "h23" || opts.hourCycle === "h24") return "24";
+		return "12";
+	} catch {
+		return "24";
+	}
+}
+function PickerRoot({ mode, value, onChange, commit, timezone: timezoneProp, step = 15, hourCycle: hourCycleProp, hideTimezone = false, responsive = true, presets: customPresets, excludePresets, minDate, maxDate, disablePast, disableFuture, children }) {
+	const rootRef = useRef(null);
+	const breakpoint = useBreakpoint();
+	const timezone = timezoneProp ?? getBrowserTimezone();
+	const hourCycle = hourCycleProp ?? detectHourCycle();
+	const { isDateDisabled } = useDateConstraints({
+		minDate,
+		maxDate,
+		disablePast,
+		disableFuture
+	});
+	const presets = usePresets({
+		mode,
+		timezone,
+		custom: customPresets,
+		excludeKeys: excludePresets,
+		isDateDisabled
+	});
+	const { state, actions } = usePickerState({
+		mode,
+		value,
+		onChange,
+		commit,
+		timezone
+	});
+	const effectiveCommit = resolveCommit(mode, commit);
+	useKeyboardShortcuts({
+		rootRef,
+		presets,
+		onSelect: useCallback((preset) => {
+			const range = preset.getRange(timezone);
+			actions.selectPreset(range, preset.key);
+		}, [timezone, actions]),
+		enabled: state.open
+	});
+	const ctx = useMemo(() => ({
+		mode,
+		timezone,
+		effectiveCommit,
+		hourCycle,
+		step,
+		hideTimezone,
+		responsive,
+		presets,
+		rootRef,
+		breakpoint,
+		state,
+		actions
+	}), [
+		mode,
+		timezone,
+		effectiveCommit,
+		hourCycle,
+		step,
+		hideTimezone,
+		responsive,
+		presets,
+		breakpoint,
+		state,
+		actions
+	]);
+	return /* @__PURE__ */ jsx(PickerContext.Provider, {
+		value: ctx,
+		children: /* @__PURE__ */ jsx("div", {
+			ref: rootRef,
+			children
+		})
+	});
+}
+PickerRoot.displayName = "Picker.Root";
+/**
+* Public namespace export. Subsequent tasks add Trigger, Content, etc.
+*/
+const Picker = { Root: PickerRoot };
+//#endregion
+//#region src/components/features/picker/components/trigger.tsx
+const DEFAULT_ICON = /* @__PURE__ */ jsx(CalendarIcon, { className: "text-muted-foreground size-4 shrink-0" });
+function PickerTrigger({ placeholder = "Pick a date", clearable = false, disabled = false, children, className, triggerClassName, id, icon, onClick, ...slotProps }) {
+	const { state, actions } = usePickerContext();
+	const hasValue = state.pendingValue !== null && state.pendingValue !== void 0;
+	const renderedIcon = icon === false ? null : icon ?? DEFAULT_ICON;
+	return /* @__PURE__ */ jsxs(Button$1, {
+		id,
+		type: "button",
+		variant: "outline",
+		role: "combobox",
+		"aria-label": placeholder,
+		"aria-expanded": state.open,
+		disabled,
+		onClick: (e) => {
+			onClick?.(e);
+			if (state.open) actions.close();
+			else actions.open();
+		},
+		className: cn("w-full justify-between gap-2 font-normal", triggerClassName, className),
+		...slotProps,
+		children: [/* @__PURE__ */ jsxs("span", {
+			className: "flex flex-1 items-center gap-2 truncate",
+			children: [renderedIcon, /* @__PURE__ */ jsx("span", {
+				className: cn("truncate", !hasValue && "text-muted-foreground"),
+				children: hasValue ? children ? children(state.pendingValue) : String(state.pendingValue) : placeholder
+			})]
+		}), clearable && hasValue && /* @__PURE__ */ jsx("button", {
+			type: "button",
+			"aria-label": "Clear",
+			onClick: (e) => {
+				e.stopPropagation();
+				actions.clear();
+			},
+			className: "text-muted-foreground hover:text-destructive shrink-0 rounded-sm p-0.5 transition-colors",
+			children: /* @__PURE__ */ jsx(X, { className: "size-3.5" })
+		})]
+	});
+}
+PickerTrigger.displayName = "Picker.Trigger";
+//#endregion
+//#region src/components/features/picker/utils/format-value.ts
+const DATE_OPTS = {
+	year: "numeric",
+	month: "short",
+	day: "2-digit"
+};
+function safeDate(input) {
+	if (input instanceof Date && !Number.isNaN(input.getTime())) return input;
+	return null;
+}
+function safeIso(input, timezone) {
+	if (typeof input !== "string") return null;
+	try {
+		const d = isoToZonedDate(input, timezone);
+		return Number.isNaN(d.getTime()) ? null : d;
+	} catch {
+		return null;
+	}
+}
+function formatDate(d, locale, dateFormat) {
+	if (dateFormat) return format(d, dateFormat);
+	return d.toLocaleDateString(locale, DATE_OPTS);
+}
+/** Renders `HH:mm` from a Date whose wall-clock fields are already in the target timezone. */
+function formatZonedTimeOfDay(d, hourCycle, timeFormat) {
+	if (timeFormat) return format(d, timeFormat);
+	return formatTimeLabel(dateToHHmm(d), hourCycle);
+}
+/**
+* Renders a `"HH:mm"` time-of-day string. Honors `timeFormat` (date-fns pattern)
+* by lifting the value into a Date and formatting; falls back to `formatTimeLabel`
+* (hourCycle-aware) otherwise.
+*/
+function formatTimeOfDayString(value, hourCycle, timeFormat) {
+	if (!timeFormat) return formatTimeLabel(value, hourCycle);
+	const parsed = parseTimeString(value);
+	if (!parsed) return "";
+	const d = /* @__PURE__ */ new Date();
+	d.setHours(parsed.h, parsed.m, 0, 0);
+	return format(d, timeFormat);
+}
+function isSameZonedDay(a, b) {
+	return a.getFullYear() === b.getFullYear() && a.getMonth() === b.getMonth() && a.getDate() === b.getDate();
+}
+/**
+* Renders a human-readable trigger label for any picker mode.
+* Returns the empty string when the value is null/undefined or unparseable.
+*/
+function formatPickerValue(value, mode, opts = {}) {
+	if (value === null || value === void 0) return "";
+	const timezone = opts.timezone ?? "UTC";
+	const hourCycle = opts.hourCycle ?? "24";
+	const locale = opts.locale;
+	const dateFormat = opts.dateFormat;
+	const timeFormat = opts.timeFormat;
+	if (mode === "date") {
+		const d = safeDate(value);
+		return d ? formatDate(d, locale, dateFormat) : "";
+	}
+	if (mode === "date-range") {
+		const v = value;
+		const from = safeDate(v?.from);
+		const to = safeDate(v?.to);
+		if (!from || !to) return "";
+		return `${formatDate(from, locale, dateFormat)} - ${formatDate(to, locale, dateFormat)}`;
+	}
+	if (mode === "time") return typeof value === "string" ? formatTimeOfDayString(value, hourCycle, timeFormat) : "";
+	if (mode === "time-range") {
+		const v = value;
+		if (typeof v?.from !== "string" || typeof v?.to !== "string") return "";
+		return `${formatTimeOfDayString(v.from, hourCycle, timeFormat)} - ${formatTimeOfDayString(v.to, hourCycle, timeFormat)}`;
+	}
+	if (mode === "datetime") {
+		const d = safeIso(value, timezone);
+		return d ? `${formatDate(d, locale, dateFormat)} ${formatZonedTimeOfDay(d, hourCycle, timeFormat)}` : "";
+	}
+	if (mode === "datetime-range") {
+		const v = value;
+		const from = safeIso(v?.from, timezone);
+		const to = safeIso(v?.to, timezone);
+		if (!from || !to) return "";
+		if (isSameZonedDay(from, to)) return `${formatDate(from, locale, dateFormat)} ${formatZonedTimeOfDay(from, hourCycle, timeFormat)} - ${formatZonedTimeOfDay(to, hourCycle, timeFormat)}`;
+		return `${formatDate(from, locale, dateFormat)} ${formatZonedTimeOfDay(from, hourCycle, timeFormat)} - ${formatDate(to, locale, dateFormat)} ${formatZonedTimeOfDay(to, hourCycle, timeFormat)}`;
+	}
+	if (mode === "date-range-time") {
+		const v = value;
+		const from = safeIso(v?.from, timezone);
+		const to = safeIso(v?.to, timezone);
+		if (!from || !to) return "";
+		return `${formatDate(from, locale, dateFormat)} - ${formatDate(to, locale, dateFormat)} (${formatZonedTimeOfDay(from, hourCycle, timeFormat)})`;
+	}
+	return "";
+}
+//#endregion
+//#region src/components/features/picker/components/footer.tsx
+function PickerFooter({ children, className }) {
+	return /* @__PURE__ */ jsx("div", {
+		className: cn("flex items-center justify-end gap-2", className),
+		children
+	});
+}
+PickerFooter.displayName = "Picker.Footer";
+function PickerApply({ children = "Apply" }) {
+	const { state, actions } = usePickerContext();
+	return /* @__PURE__ */ jsx(Button, {
+		type: "primary",
+		theme: "solid",
+		size: "xs",
+		disabled: state.pendingValue === null || state.pendingValue === void 0,
+		onClick: actions.apply,
+		children
+	});
+}
+PickerApply.displayName = "Picker.Apply";
+function PickerReset({ children = "Reset" }) {
+	const { actions } = usePickerContext();
+	return /* @__PURE__ */ jsx(Button, {
+		type: "quaternary",
+		theme: "outline",
+		size: "xs",
+		onClick: actions.reset,
+		children
+	});
+}
+PickerReset.displayName = "Picker.Reset";
+function PickerCancel({ children = "Cancel" }) {
+	const { actions } = usePickerContext();
+	return /* @__PURE__ */ jsx(Button, {
+		type: "quaternary",
+		theme: "borderless",
+		size: "xs",
+		onClick: actions.cancel,
+		children
+	});
+}
+PickerCancel.displayName = "Picker.Cancel";
+function PickerClear({ children = "Clear" }) {
+	const { actions } = usePickerContext();
+	return /* @__PURE__ */ jsx(Button, {
+		type: "primary",
+		theme: "borderless",
+		size: "xs",
+		onClick: actions.clear,
+		children
+	});
+}
+PickerClear.displayName = "Picker.Clear";
+//#endregion
+//#region src/components/features/picker/wrappers/internal/default-footer.tsx
+/**
+* The standard Cancel / Reset / Apply footer used by every wrapper.
+* `Picker.Content` decides whether to render it - desktop popover renders
+* it only when `commit === 'apply'`; mobile sheet always renders it.
+*/
+function DefaultFooter() {
+	return /* @__PURE__ */ jsxs(PickerFooter, { children: [
+		/* @__PURE__ */ jsx(PickerCancel, {}),
+		/* @__PURE__ */ jsx(PickerReset, {}),
+		/* @__PURE__ */ jsx(PickerApply, {})
+	] });
+}
+//#endregion
+export { zonedDateToIso as A, PickerContext as C, getBrowserTimezone as D, formatTimezoneLabel as E, isDateBearingMode as F, isRangeMode as I, isTimeBearingMode as L, DATE_BEARING_MODES as M, RANGE_MODES as N, getTimezoneOffset as O, TIME_BEARING_MODES as P, useDateConstraints as R, PickerContent as S, formatInTimezone as T, formatTimeLabel as _, PickerFooter as a, resolveCommit as b, PickerTrigger as c, DATETIME_PRESETS as d, DATE_PRESETS as f, dateToYYYYMMDD as g, dateToHHmm as h, PickerClear as i, ALLOWED_STEPS as j, isoToZonedDate as k, Picker as l, usePickerState as m, PickerApply as n, PickerReset as o, getDefaultPresets as p, PickerCancel as r, formatPickerValue as s, DefaultFooter as t, usePresets as u, isValidTimeString as v, usePickerContext as w, useKeyboardShortcuts as x, parseTimeString as y };