@unergy-dev/gandalf 0.0.0-stage → 0.6.0

package/dist/components/gandalf/kit/combobox/options.d.ts

@@ -0,0 +1,27 @@
+import { ComboboxOption, ComboboxOptionGroup, ComboboxOptions } from './types';
+/**
+ * Whether an entry is a group rather than an option.
+ *
+ * Groups are told apart by carrying `options`, so an option may not have a property by that name.
+ * The alternative — a `kind` discriminator — would have to be written on every option by hand,
+ * which is a tax on the common case to make the rare one tidier.
+ */
+export declare function isGroup(entry: ComboboxOption | ComboboxOptionGroup): entry is ComboboxOptionGroup;
+/**
+ * Reads either shape as groups, so the rest of the component only handles one.
+ *
+ * A flat list becomes a single unlabelled group. The first entry decides how the whole array is
+ * read: a mixed array is a caller mistake, and guessing per entry would hide it.
+ */
+export declare function toGroups(options: ComboboxOptions): ComboboxOptionGroup[];
+/** Every option, in order, with the grouping discarded. */
+export declare function flatten(options: ComboboxOptions): ComboboxOption[];
+/** The strings an option can be found by: what is shown, plus anything it was tagged with. */
+export declare function terms(option: ComboboxOption): string[];
+/**
+ * The default matcher: does this option answer this search?
+ *
+ * Folded on both sides, so `bogota` finds `Bogotá`. An empty search matches everything, which is
+ * what makes the list appear in full before anyone types.
+ */
+export declare function matches(option: ComboboxOption, search: string): boolean;

package/dist/components/gandalf/kit/combobox/options.js

@@ -0,0 +1,47 @@
+import { fold } from "./fold.js";
+// src/components/gandalf/kit/combobox/options.ts
+/**
+* Whether an entry is a group rather than an option.
+*
+* Groups are told apart by carrying `options`, so an option may not have a property by that name.
+* The alternative — a `kind` discriminator — would have to be written on every option by hand,
+* which is a tax on the common case to make the rare one tidier.
+*/
+function isGroup(entry) {
+	return entry !== null && typeof entry === "object" && "options" in entry;
+}
+/**
+* Reads either shape as groups, so the rest of the component only handles one.
+*
+* A flat list becomes a single unlabelled group. The first entry decides how the whole array is
+* read: a mixed array is a caller mistake, and guessing per entry would hide it.
+*/
+function toGroups(options) {
+	const first = options[0];
+	if (first === void 0) return [];
+	return isGroup(first) ? options : [{ options }];
+}
+/** Every option, in order, with the grouping discarded. */
+function flatten(options) {
+	return toGroups(options).flatMap((group) => group.options);
+}
+/** The strings an option can be found by: what is shown, plus anything it was tagged with. */
+function terms(option) {
+	return [
+		option.label,
+		option.description,
+		...option.keywords ?? []
+	].filter((term) => typeof term === "string" && term.length > 0);
+}
+/**
+* The default matcher: does this option answer this search?
+*
+* Folded on both sides, so `bogota` finds `Bogotá`. An empty search matches everything, which is
+* what makes the list appear in full before anyone types.
+*/
+function matches(option, search) {
+	const needle = fold(search.trim());
+	if (needle === "") return true;
+	return terms(option).some((term) => fold(term).includes(needle));
+}
+export { flatten, isGroup, matches, terms, toGroups };

package/dist/components/gandalf/kit/combobox/types.d.ts

@@ -0,0 +1,31 @@
+import { Option } from '../../base/types';
+/**
+ * An option, plus the two fields only a searchable list needs.
+ *
+ * Built on the shared `Option` rather than a generic `T`: `value` stays `string | number`, which
+ * is what Reka accepts as an item value and what every other Gandalf component already speaks.
+ * A generic value type would push a `by` comparator onto every caller to buy a case the platform
+ * does not have.
+ */
+export type ComboboxOption = Option & {
+    /** Second line under the label. Searched along with it. */
+    description?: string;
+    /** Extra terms that match this option without being shown — synonyms, codes, an old name. */
+    keywords?: string[];
+};
+/** A labelled run of options, rendered under a heading. */
+export type ComboboxOptionGroup = {
+    label?: string;
+    options: ComboboxOption[];
+};
+/**
+ * Either a flat list or a grouped one. Do not mix the two in a single array — the first entry
+ * decides how the whole array is read.
+ */
+export type ComboboxOptions = ComboboxOption[] | ComboboxOptionGroup[];
+/** The value of a single option. */
+export type ComboboxValue = Option['value'];
+/** What `v-model` carries: one value, or an array of them when `multiple` is set. */
+export type ComboboxModelValue = ComboboxValue | ComboboxValue[] | undefined;
+/** Keeps an option out of the list. Return `true` to keep it. */
+export type ComboboxFilter = (option: ComboboxOption, search: string) => boolean;

package/dist/components/gandalf/kit/date-picker/DatePicker.js

@@ -0,0 +1,4 @@
+import DatePicker_vue_vue_type_script_setup_true_lang_default from "./DatePicker.vue_vue_type_script_setup_true_lang.js";
+// src/components/gandalf/kit/date-picker/DatePicker.vue
+var DatePicker_default = DatePicker_vue_vue_type_script_setup_true_lang_default;
+export { DatePicker_default as default };

package/dist/components/gandalf/kit/date-picker/DatePicker.vue.d.ts

@@ -0,0 +1,114 @@
+import { HTMLAttributes } from 'vue';
+import { DatePickerDate, DatePickerMatcher, DatePickerModelValue, DatePickerPreset, DatePickerSelection, DatePickerType } from './types';
+type __VLS_Props = {
+    /** Whether the picker selects one day or a range. Decides the shape of everything else. */
+    type?: DatePickerType;
+    /** Shown on the trigger while nothing is selected. */
+    placeholder?: string;
+    /** Blocks the trigger and the calendar. */
+    disabled?: boolean;
+    /** Adds a clear control to the trigger once something is selected. */
+    clearable?: boolean;
+    /** Accessible label for the clear control. */
+    clearLabel?: string;
+    /** Shortcuts beside the calendar. The row knows which one is active. */
+    presets?: DatePickerPreset[];
+    /** Earliest date that can be picked. Everything before it is greyed out. */
+    min?: DatePickerDate;
+    /** Latest date that can be picked. Everything after it is greyed out. */
+    max?: DatePickerDate;
+    /** Keeps individual days out of reach — weekends, holidays. Return `true` to disable. */
+    isDateDisabled?: DatePickerMatcher;
+    /** Locale for the calendar's strings and the trigger label. */
+    locale?: string;
+    /** How the trigger prints the selection. Passed straight to `Intl.DateTimeFormat`. */
+    format?: Intl.DateTimeFormatOptions;
+    /** Whether a finished selection closes the popover. A half-picked range never closes it. */
+    closeOnSelect?: boolean;
+    /** Submits with a surrounding form, as a hidden input holding the ISO day. */
+    name?: string;
+    /** Field name for the end of a range. */
+    endName?: string;
+    /** Turns a picked day into the submitted string. */
+    serialize?: (value: Date) => string;
+    /** Put on the trigger, for a `<GLabel for>`. */
+    id?: string;
+    /** Which trigger edge the popover lines up with. */
+    align?: 'start' | 'center' | 'end';
+    /** Trigger height, as Figma's Input Field: `default` is md (40px), `sm` is 32px. */
+    size?: 'sm' | 'default';
+    /** Merged onto the trigger. */
+    class?: HTMLAttributes['class'];
+    /** Merged onto the popover content. */
+    contentClass?: HTMLAttributes['class'];
+};
+declare function close(): void;
+declare function clear(): void;
+type __VLS_ModelProps = {
+    modelValue?: DatePickerModelValue;
+    'open'?: boolean;
+    /**
+     * The month on screen — the calendar primitive's `placeholder`, renamed because `placeholder` is
+     * already the trigger's empty text everywhere else in Gandalf. Two props with one name, one a
+     * string and one a date, is a coin flip every caller loses once.
+     */
+    'month'?: DatePickerDate | undefined;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare var __VLS_15: {
+    value: DatePickerModelValue;
+    label: string;
+    empty: boolean;
+    open: boolean;
+    disabled: boolean;
+    clear: typeof clear;
+}, __VLS_66: {
+    value: DatePickerModelValue;
+    clear: typeof clear;
+    close: typeof close;
+};
+type __VLS_Slots = {} & {
+    trigger?: (props: typeof __VLS_15) => any;
+} & {
+    footer?: (props: typeof __VLS_66) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: DatePickerModelValue) => any;
+    "update:open": (value: boolean) => any;
+    change: (value: DatePickerSelection) => any;
+    "update:month": (value: DatePickerDate | undefined) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: DatePickerModelValue) => any) | undefined;
+    "onUpdate:open"?: ((value: boolean) => any) | undefined;
+    onChange?: ((value: DatePickerSelection) => any) | undefined;
+    "onUpdate:month"?: ((value: DatePickerDate | undefined) => any) | undefined;
+}>, {
+    disabled: boolean;
+    type: DatePickerType;
+    size: "default" | "sm";
+    placeholder: string;
+    class: string | false | Record<string, any> | import('vue').ClassValue[] | null;
+    id: string;
+    max: DatePickerDate;
+    min: DatePickerDate;
+    name: string;
+    format: Intl.DateTimeFormatOptions;
+    locale: string;
+    isDateDisabled: DatePickerMatcher;
+    align: "end" | "center" | "start";
+    contentClass: string | false | Record<string, any> | import('vue').ClassValue[] | null;
+    clearable: boolean;
+    clearLabel: string;
+    presets: DatePickerPreset[];
+    closeOnSelect: boolean;
+    endName: string;
+    serialize: (value: Date) => string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/gandalf/kit/date-picker/DatePicker.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,310 @@
+import { cn } from "../../../../lib/utils.js";
+import GButton_default from "../../base/button/GButton.js";
+import GCalendar_default from "../../base/calendar/GCalendar.js";
+import { gandalfFieldTriggerClass, gandalfFieldVariants } from "../../base/input/index.js";
+import GPopover_default from "../../base/popover/GPopover.js";
+import GPopoverTrigger_default from "../../base/popover/GPopoverTrigger.js";
+import GPopoverContent_default from "../../base/popover/GPopoverContent.js";
+import GRangeCalendar_default from "../../base/range-calendar/GRangeCalendar.js";
+import { formatDate, formatDateRange, isRange, toCalendarDate, toDateMatcher, toISODate, toNativeDate } from "./date.js";
+import { activePreset, resolvePreset } from "./presets.js";
+import { Fragment, computed, createBlock, createCommentVNode, createElementBlock, createElementVNode, createTextVNode, createVNode, defineComponent, mergeModels, mergeProps, normalizeClass, openBlock, renderList, renderSlot, toDisplayString, unref, useModel, withCtx, withModifiers } from "vue";
+import { CalendarIcon, X } from "lucide-vue-next";
+// src/components/gandalf/kit/date-picker/DatePicker.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1 = { class: "relative w-full" };
+var _hoisted_2 = ["id", "disabled"];
+var _hoisted_3 = ["name", "value"];
+var _hoisted_4 = ["name", "value"];
+var _hoisted_5 = { class: "flex flex-col sm:flex-row" };
+var _hoisted_6 = {
+	key: 0,
+	class: "border-border flex gap-1 overflow-x-auto border-b p-2 sm:w-40 sm:shrink-0 sm:flex-col sm:overflow-visible sm:border-e sm:border-b-0"
+};
+var _hoisted_7 = {
+	key: 0,
+	class: "border-border border-t p-2"
+};
+var DatePicker_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	inheritAttrs: false,
+	__name: "DatePicker",
+	props: /*@__PURE__*/ mergeModels({
+		type: { default: "single" },
+		placeholder: { default: "Select a date..." },
+		disabled: {
+			type: Boolean,
+			default: false
+		},
+		clearable: {
+			type: Boolean,
+			default: false
+		},
+		clearLabel: { default: "Clear date" },
+		presets: { default: void 0 },
+		min: { default: void 0 },
+		max: { default: void 0 },
+		isDateDisabled: {
+			type: Function,
+			default: void 0
+		},
+		locale: { default: "es-CO" },
+		format: { default: () => ({ dateStyle: "medium" }) },
+		closeOnSelect: {
+			type: Boolean,
+			default: true
+		},
+		name: { default: void 0 },
+		endName: { default: void 0 },
+		serialize: {
+			type: Function,
+			default: toISODate
+		},
+		id: { default: void 0 },
+		align: { default: "start" },
+		size: { default: "default" },
+		class: {
+			type: [
+				Boolean,
+				null,
+				String,
+				Object,
+				Array
+			],
+			default: void 0
+		},
+		contentClass: {
+			type: [
+				Boolean,
+				null,
+				String,
+				Object,
+				Array
+			],
+			default: void 0
+		}
+	}, {
+		"modelValue": { default: void 0 },
+		"modelModifiers": {},
+		"open": {
+			type: Boolean,
+			default: false
+		},
+		"openModifiers": {},
+		"month": { default: void 0 },
+		"monthModifiers": {}
+	}),
+	emits: /*@__PURE__*/ mergeModels(["change"], [
+		"update:modelValue",
+		"update:open",
+		"update:month"
+	]),
+	setup(__props, { emit: __emit }) {
+		const props = __props;
+		const emit = __emit;
+		const modelValue = useModel(__props, "modelValue");
+		const open = useModel(__props, "open");
+		/**
+		* The month on screen — the calendar primitive's `placeholder`, renamed because `placeholder` is
+		* already the trigger's empty text everywhere else in Gandalf. Two props with one name, one a
+		* string and one a date, is a coin flip every caller loses once.
+		*/
+		const month = useModel(__props, "month");
+		const isRangeType = computed(() => props.type === "range");
+		/** The selection as the calendar reads it. */
+		const single = computed(() => isRangeType.value ? void 0 : toCalendarDate(modelValue.value));
+		const range = computed(() => {
+			const value = modelValue.value;
+			const parts = isRange(value) ? value : {};
+			return {
+				start: toCalendarDate(parts.start),
+				end: toCalendarDate(parts.end)
+			};
+		});
+		/** The day the calendar opens on when nothing says otherwise. */
+		const anchor = computed(() => isRangeType.value ? range.value.start : single.value);
+		const monthOnScreen = computed(() => toCalendarDate(month.value) ?? anchor.value ?? toCalendarDate(/* @__PURE__ */ new Date()));
+		const presets = computed(() => props.presets ?? []);
+		const active = computed(() => activePreset(presets.value, modelValue.value));
+		const empty = computed(() => isRangeType.value ? range.value.start === void 0 : single.value === void 0);
+		const label = computed(() => {
+			if (active.value) return active.value.label;
+			if (isRangeType.value) return formatDateRange(asRange(modelValue.value), props.locale, props.format);
+			return formatDate(modelValue.value, props.locale, props.format);
+		});
+		const showClear = computed(() => props.clearable && !props.disabled && !empty.value);
+		/** The converted conveniences, merged over `$attrs` so a named prop wins over a raw calendar one. */
+		const calendarProps = computed(() => ({
+			...props.min !== void 0 ? { minValue: toCalendarDate(props.min) } : {},
+			...props.max !== void 0 ? { maxValue: toCalendarDate(props.max) } : {},
+			...props.isDateDisabled ? { isDateDisabled: toDateMatcher(props.isDateDisabled) } : {}
+		}));
+		const startName = computed(() => props.name);
+		const endFieldName = computed(() => props.endName ?? (props.name ? `${props.name}-end` : void 0));
+		function asRange(value) {
+			return isRange(value) ? value : void 0;
+		}
+		function serialized(value) {
+			const date = toNativeDate(toCalendarDate(value));
+			return date ? props.serialize(date) : "";
+		}
+		function commit(value) {
+			modelValue.value = value;
+			emit("change", value);
+		}
+		function close() {
+			open.value = false;
+		}
+		function handleSingle(next) {
+			commit(toNativeDate(next));
+			if (props.closeOnSelect && next) close();
+		}
+		/**
+		* A range is finished only when the second end lands. Until then the value is written through so
+		* the calendar and the trigger stay honest about the half state, but `change` stays quiet and the
+		* popover stays open — closing on the first click is the classic hand-rolled range picker bug.
+		*/
+		function handleRange(next) {
+			const value = {
+				start: toNativeDate(next?.start),
+				end: toNativeDate(next?.end)
+			};
+			const complete = value.start !== void 0 && value.end !== void 0;
+			const cleared = value.start === void 0 && value.end === void 0;
+			modelValue.value = value;
+			if (complete || cleared) emit("change", value);
+			if (props.closeOnSelect && complete) close();
+		}
+		function applyPreset(preset) {
+			const value = resolvePreset(preset);
+			if (isRangeType.value) {
+				const parts = asRange(value) ?? {};
+				commit({
+					start: toNativeDate(toCalendarDate(parts.start)),
+					end: toNativeDate(toCalendarDate(parts.end))
+				});
+			} else commit(toNativeDate(toCalendarDate(value)));
+			if (props.closeOnSelect) close();
+		}
+		function clear() {
+			commit(isRangeType.value ? {
+				start: void 0,
+				end: void 0
+			} : void 0);
+		}
+		function handleOpenChange(next) {
+			open.value = next;
+			if (!next) month.value = void 0;
+		}
+		function handleMonthChange(next) {
+			month.value = toNativeDate(next);
+		}
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(GPopover_default), {
+				open: open.value,
+				"onUpdate:open": handleOpenChange
+			}, {
+				default: withCtx(() => [createElementVNode("div", _hoisted_1, [
+					createVNode(unref(GPopoverTrigger_default), { "as-child": "" }, {
+						default: withCtx(() => [renderSlot(_ctx.$slots, "trigger", {
+							value: modelValue.value,
+							label: label.value,
+							empty: empty.value,
+							open: open.value,
+							disabled: __props.disabled,
+							clear
+						}, () => [createElementVNode("button", {
+							id: __props.id,
+							type: "button",
+							disabled: __props.disabled,
+							class: normalizeClass(unref(cn)(unref(gandalfFieldVariants)({ size: __props.size === "sm" ? "sm" : "md" }), unref(gandalfFieldTriggerClass), props.class))
+						}, [createElementVNode("span", { class: normalizeClass(unref(cn)("min-w-0 truncate text-start", empty.value && unref("text-base-foreground-extra-quiet"), showClear.value && "pe-7")) }, toDisplayString(label.value || __props.placeholder), 3), createVNode(unref(CalendarIcon), { class: "size-4 shrink-0 opacity-50" })], 10, _hoisted_2)])]),
+						_: 3
+					}),
+					showClear.value ? (openBlock(), createBlock(unref(GButton_default), {
+						key: 0,
+						type: "button",
+						variant: "ghost-primary",
+						size: "xs",
+						class: "absolute inset-y-0 inset-e-8 my-auto size-6",
+						"aria-label": __props.clearLabel,
+						onClick: withModifiers(clear, ["stop"])
+					}, {
+						default: withCtx(() => [createVNode(unref(X), { class: "size-4 opacity-50" })]),
+						_: 1
+					}, 8, ["aria-label"])) : createCommentVNode("", true),
+					__props.name ? (openBlock(), createElementBlock(Fragment, { key: 1 }, [createElementVNode("input", {
+						type: "hidden",
+						name: startName.value,
+						value: serialized(isRangeType.value ? asRange(modelValue.value)?.start : modelValue.value)
+					}, null, 8, _hoisted_3), isRangeType.value ? (openBlock(), createElementBlock("input", {
+						key: 0,
+						type: "hidden",
+						name: endFieldName.value,
+						value: serialized(asRange(modelValue.value)?.end)
+					}, null, 8, _hoisted_4)) : createCommentVNode("", true)], 64)) : createCommentVNode("", true)
+				]), createVNode(unref(GPopoverContent_default), {
+					align: __props.align,
+					class: normalizeClass(unref(cn)("w-auto p-0", __props.contentClass))
+				}, {
+					default: withCtx(() => [createElementVNode("div", _hoisted_5, [presets.value.length ? (openBlock(), createElementBlock("div", _hoisted_6, [(openBlock(true), createElementBlock(Fragment, null, renderList(presets.value, (preset) => {
+						return openBlock(), createBlock(unref(GButton_default), {
+							key: preset.label,
+							type: "button",
+							variant: "ghost-primary",
+							size: "sm",
+							disabled: __props.disabled,
+							"data-active": active.value === preset,
+							class: "data-[active=true]:bg-accent data-[active=true]:text-accent-foreground shrink-0 justify-start font-normal",
+							onClick: ($event) => applyPreset(preset)
+						}, {
+							default: withCtx(() => [createTextVNode(toDisplayString(preset.label), 1)]),
+							_: 2
+						}, 1032, [
+							"disabled",
+							"data-active",
+							"onClick"
+						]);
+					}), 128))])) : createCommentVNode("", true), isRangeType.value ? (openBlock(), createBlock(unref(GRangeCalendar_default), mergeProps({ key: 1 }, {
+						..._ctx.$attrs,
+						...calendarProps.value
+					}, {
+						"model-value": range.value,
+						placeholder: monthOnScreen.value,
+						locale: __props.locale,
+						disabled: __props.disabled,
+						"initial-focus": "",
+						"onUpdate:modelValue": handleRange,
+						"onUpdate:placeholder": handleMonthChange
+					}), null, 16, [
+						"model-value",
+						"placeholder",
+						"locale",
+						"disabled"
+					])) : (openBlock(), createBlock(unref(GCalendar_default), mergeProps({ key: 2 }, {
+						..._ctx.$attrs,
+						...calendarProps.value
+					}, {
+						"model-value": single.value,
+						placeholder: monthOnScreen.value,
+						locale: __props.locale,
+						disabled: __props.disabled,
+						"initial-focus": "",
+						"onUpdate:modelValue": handleSingle,
+						"onUpdate:placeholder": handleMonthChange
+					}), null, 16, [
+						"model-value",
+						"placeholder",
+						"locale",
+						"disabled"
+					]))]), _ctx.$slots.footer ? (openBlock(), createElementBlock("div", _hoisted_7, [renderSlot(_ctx.$slots, "footer", {
+						value: modelValue.value,
+						clear,
+						close
+					})])) : createCommentVNode("", true)]),
+					_: 3
+				}, 8, ["align", "class"])]),
+				_: 3
+			}, 8, ["open"]);
+		};
+	}
+});
+export { DatePicker_vue_vue_type_script_setup_true_lang_default as default };

package/dist/components/gandalf/kit/date-picker/date.d.ts

@@ -0,0 +1,44 @@
+import { DateValue } from '@internationalized/date';
+import { DatePickerDate, DatePickerMatcher, DatePickerRange } from './types';
+/** Whether a model value is a range rather than a single day. */
+export declare function isRange(value: unknown): value is DatePickerRange;
+/**
+ * Reads whatever the caller put in `v-model` as a calendar date — a day, with no time and no
+ * timezone, which is what a date on a form actually is.
+ *
+ * A string is parsed with `parseDate` rather than `new Date(value)`. The built-in parser reads a
+ * bare `'2026-09-03'` as UTC midnight, which in Bogotá (UTC-5) is the evening of the 2nd: the
+ * picker would highlight the day before the one the API sent. `parseDate` has no timezone at all.
+ *
+ * A `Date` is read through its local fields, because the day the user picked is the day they saw
+ * on their own screen, not the one the same instant lands on in UTC.
+ *
+ * Anything unparseable comes back as `undefined` — an invalid date is the same as no date here,
+ * and throwing would take a whole form down over one bad field.
+ */
+export declare function toCalendarDate(value: DatePickerDate | undefined | null): DateValue | undefined;
+/** A calendar date back as a native `Date`, at local midnight. */
+export declare function toNativeDate(value: DateValue): Date;
+export declare function toNativeDate(value: DateValue | undefined): Date | undefined;
+/**
+ * The `YYYY-MM-DD` form, for the wire.
+ *
+ * Built from the calendar fields rather than `toISOString()`, which converts to UTC before it
+ * reads the date off. In Bogotá (UTC-5) that is harmless for a value at local midnight, but a
+ * `Date` carrying an evening time reports tomorrow — `new Date()` after 7pm is exactly that — and
+ * east of Greenwich it is a day early even at midnight. The day someone picked should not depend
+ * on the hour they picked it.
+ */
+export declare function toISODate(value: DatePickerDate | undefined | null): string;
+/** How a picked day reads. Exported so a table can show the same string as the trigger. */
+export declare function formatDate(value: DatePickerDate | undefined | null, locale: string, options: Intl.DateTimeFormatOptions): string;
+/**
+ * How a picked range reads.
+ *
+ * `formatRange` rather than two `format` calls joined by a dash: it collapses whatever the two
+ * ends share, so a range inside one month reads `5–9 de enero de 2026` and not
+ * `5 de enero de 2026 – 9 de enero de 2026`, with the separator each locale actually uses.
+ */
+export declare function formatDateRange(range: DatePickerRange | undefined | null, locale: string, options: Intl.DateTimeFormatOptions): string;
+/** Lifts a matcher written in native `Date` terms into the one the calendar primitive expects. */
+export declare function toDateMatcher(matcher: DatePickerMatcher | undefined): ((date: DateValue) => boolean) | undefined;

package/dist/components/gandalf/kit/date-picker/date.js

@@ -0,0 +1,89 @@
+import { CalendarDate, getLocalTimeZone, parseDate } from "@internationalized/date";
+// src/components/gandalf/kit/date-picker/date.ts
+var ISO_DATE = /^\d{4}-\d{2}-\d{2}$/;
+/** Whether a model value is a range rather than a single day. */
+function isRange(value) {
+	return typeof value === "object" && value !== null && !(value instanceof Date) && ("start" in value || "end" in value);
+}
+/**
+* Reads whatever the caller put in `v-model` as a calendar date — a day, with no time and no
+* timezone, which is what a date on a form actually is.
+*
+* A string is parsed with `parseDate` rather than `new Date(value)`. The built-in parser reads a
+* bare `'2026-09-03'` as UTC midnight, which in Bogotá (UTC-5) is the evening of the 2nd: the
+* picker would highlight the day before the one the API sent. `parseDate` has no timezone at all.
+*
+* A `Date` is read through its local fields, because the day the user picked is the day they saw
+* on their own screen, not the one the same instant lands on in UTC.
+*
+* Anything unparseable comes back as `undefined` — an invalid date is the same as no date here,
+* and throwing would take a whole form down over one bad field.
+*/
+function toCalendarDate(value) {
+	if (value === void 0 || value === null) return void 0;
+	if (typeof value === "string") {
+		const day = value.slice(0, 10);
+		if (!ISO_DATE.test(day)) return void 0;
+		try {
+			return parseDate(day);
+		} catch {
+			return;
+		}
+	}
+	if (Number.isNaN(value.getTime())) return void 0;
+	return new CalendarDate(value.getFullYear(), value.getMonth() + 1, value.getDate());
+}
+function toNativeDate(value) {
+	return value?.toDate(getLocalTimeZone());
+}
+/**
+* The `YYYY-MM-DD` form, for the wire.
+*
+* Built from the calendar fields rather than `toISOString()`, which converts to UTC before it
+* reads the date off. In Bogotá (UTC-5) that is harmless for a value at local midnight, but a
+* `Date` carrying an evening time reports tomorrow — `new Date()` after 7pm is exactly that — and
+* east of Greenwich it is a day early even at midnight. The day someone picked should not depend
+* on the hour they picked it.
+*/
+function toISODate(value) {
+	const date = toCalendarDate(value);
+	if (!date) return "";
+	const month = String(date.month).padStart(2, "0");
+	const day = String(date.day).padStart(2, "0");
+	return `${String(date.year).padStart(4, "0")}-${month}-${day}`;
+}
+/**
+* A day as the instant `Intl` should be handed, which is local **noon**.
+*
+* Not midnight: midnight is the one hour a DST jump can delete. Where a timezone springs forward
+* at 00:00 — Santiago, Havana and Beirut all do — that day has no midnight, the conversion lands
+* on a neighbouring instant, and the trigger prints a day the user did not pick. No jump has ever
+* moved noon.
+*/
+function atNoon(value) {
+	return new Date(value.year, value.month - 1, value.day, 12);
+}
+/** How a picked day reads. Exported so a table can show the same string as the trigger. */
+function formatDate(value, locale, options) {
+	const date = toCalendarDate(value);
+	return date ? new Intl.DateTimeFormat(locale, options).format(atNoon(date)) : "";
+}
+/**
+* How a picked range reads.
+*
+* `formatRange` rather than two `format` calls joined by a dash: it collapses whatever the two
+* ends share, so a range inside one month reads `5–9 de enero de 2026` and not
+* `5 de enero de 2026 – 9 de enero de 2026`, with the separator each locale actually uses.
+*/
+function formatDateRange(range, locale, options) {
+	const start = toCalendarDate(range?.start);
+	const end = toCalendarDate(range?.end);
+	if (!start) return "";
+	if (!end) return formatDate(range?.start, locale, options);
+	return new Intl.DateTimeFormat(locale, options).formatRange(atNoon(start), atNoon(end));
+}
+/** Lifts a matcher written in native `Date` terms into the one the calendar primitive expects. */
+function toDateMatcher(matcher) {
+	return matcher ? (date) => matcher(toNativeDate(date)) : void 0;
+}
+export { formatDate, formatDateRange, isRange, toCalendarDate, toDateMatcher, toISODate, toNativeDate };

package/dist/components/gandalf/kit/date-picker/index.d.ts

@@ -0,0 +1,4 @@
+export { default as GKitDatePicker } from './DatePicker.vue';
+export { formatDate, formatDateRange, isRange, toCalendarDate, toDateMatcher, toISODate, toNativeDate, } from './date';
+export { activePreset, resolvePreset } from './presets';
+export type { DatePickerDate, DatePickerMatcher, DatePickerModelValue, DatePickerPreset, DatePickerRange, DatePickerSelection, DatePickerType, DatePickerWeekStart, } from './types';