@ui-organized/vue 0.0.0-stage → 6.0.0

package/dist/components/ColorPicker/ColorPicker.types.d.ts

@@ -0,0 +1,60 @@
+export interface ColorPickerProps {
+    /** Accessible label rendered above the trigger. */
+    label?: string;
+    /** Helper text rendered below the trigger. Hidden when an error is shown. */
+    helperText?: string;
+    /**
+     * Error state. Pass a string to show an error message.
+     * Pass `true` to mark the field invalid without a message.
+     */
+    error?: string | boolean;
+    /**
+     * Controlled color as a CSS color string — `#2563eb`, `rgb(37 99 235)`,
+     * `hsl(221 83% 53%)`. Use `v-model` for two-way binding.
+     *
+     * Spelled `modelValue` rather than React's `value`: Ark Vue names the
+     * color-picker machine's controlled value for `v-model`, and this package
+     * follows Ark. The machine works in parsed `Color` objects; the conversion
+     * happens at this boundary.
+     */
+    modelValue?: string;
+    /** Initial color for the uncontrolled case. Defaults to '#000000'. */
+    defaultValue?: string;
+    /**
+     * The notation the color is held and printed in — the value string, the
+     * trigger's value text and the hidden form input. Defaults to 'rgba'.
+     *
+     * It also picks which notation the picker's fields open on. It does not pin
+     * them there: a reader can switch the fields to any notation without changing
+     * what this component hands back, which stays whatever this names.
+     */
+    format?: "rgba" | "hsla" | "hsba";
+    /** Preset swatches offered under the picker area. */
+    swatches?: string[];
+    /** Shows the eyedropper button, where the browser supports it. Defaults to true. */
+    showEyeDropper?: boolean;
+    /**
+     * Shows the notation select and its channel fields — HEX, RGB, HSL, OKLCH —
+     * under the sliders. Defaults to true. Turn it off for a picker meant to be
+     * driven by eye rather than by number.
+     */
+    showFormatInputs?: boolean;
+    /** Open state of the picker. Use `v-model:open` for two-way binding. */
+    open?: boolean;
+    /** Initial open state for the uncontrolled case. */
+    defaultOpen?: boolean;
+    /** Size variant. Defaults to 'md'. */
+    size?: "sm" | "md" | "lg";
+    /** Trigger treatment. `swatch-only` drops the value text. Defaults to 'default'. */
+    variant?: "default" | "swatch-only";
+    /** Marks the field required and shows the required indicator. */
+    required?: boolean;
+    /** Disables the control. */
+    disabled?: boolean;
+    /** Makes the color read-only while keeping the trigger focusable. */
+    readOnly?: boolean;
+    /** Form field name for the hidden input. */
+    name?: string;
+    /** DOM element to teleport the picker surface into. Defaults to `body`. */
+    container?: HTMLElement | null;
+}

package/dist/components/ColorPicker/ColorPicker.vue.d.ts

@@ -0,0 +1,27 @@
+import type { ColorPickerProps } from "./ColorPicker.types.js";
+import "@ui-organized/core/components/ColorPicker/ColorPicker.css";
+declare const _default: import("vue").DefineComponent<ColorPickerProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: string) => any;
+    valueChange: (value: string) => any;
+    openChange: (open: boolean) => any;
+    "update:open": (open: boolean) => any;
+    valueChangeEnd: (value: string) => any;
+}, string, import("vue").PublicProps, Readonly<ColorPickerProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+    onValueChange?: ((value: string) => any) | undefined;
+    onOpenChange?: ((open: boolean) => any) | undefined;
+    "onUpdate:open"?: ((open: boolean) => any) | undefined;
+    onValueChangeEnd?: ((value: string) => any) | undefined;
+}>, {
+    size: "sm" | "md" | "lg";
+    required: boolean;
+    disabled: boolean;
+    open: boolean;
+    readOnly: boolean;
+    defaultValue: string;
+    format: "rgba" | "hsla" | "hsba";
+    defaultOpen: boolean;
+    showEyeDropper: boolean;
+    showFormatInputs: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/ColorPicker/FormatInputs.vue.d.ts

@@ -0,0 +1,17 @@
+import { type ColorNotation } from "@ui-organized/core";
+import type { ColorLike } from "./channelFields.js";
+type __VLS_Props = {
+    format: ColorNotation;
+    color: ColorLike;
+    disabled?: boolean;
+    readOnly?: boolean;
+    container?: HTMLElement | null;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    commit: (next: import("@ark-ui/vue").Color) => any;
+    formatChange: (format: ColorNotation) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onCommit?: ((next: import("@ark-ui/vue").Color) => any) | undefined;
+    onFormatChange?: ((format: ColorNotation) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/ColorPicker/channelFields.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Reading and writing one field of the notation row.
+ *
+ * The half of a field that `COLOR_NOTATION_FIELDS` in `@ui-organized/core`
+ * cannot describe, because it needs a color object and the four libraries do
+ * not share one — the three Ark packages pass around `@zag-js/color-utils`
+ * `Color`s and Angular computes its own. Core names the channel, its space and
+ * its range; these two functions fetch and set it.
+ *
+ * Deliberately not Ark's `ChannelInput`: Ark writes a channel by converting the
+ * color to the *machine's* format first, so an HSL field would only work while
+ * the machine is in `hsla` — which would mean flipping the notation select had
+ * to reformat the machine, and the machine's format is what decides the value
+ * string, the hidden input's form value and whether the picker area is
+ * saturation×brightness or saturation×lightness. A display control must not
+ * move any of those, so the fields convert on their own. Reads and writes both
+ * go through `toFormat`, so every notation works from any machine format, and
+ * OKLCH — which the machine cannot represent at all — is one more entry in the
+ * same table.
+ */
+import { type Color } from "@ark-ui/vue";
+import { type ColorField, type Rgba } from "@ui-organized/core";
+/**
+ * The parsed color the machine holds. Named here rather than in the public
+ * types so `ColorPickerProps` keeps its string-only surface — a caller never
+ * handles one of these.
+ */
+export type ColorLike = Color;
+export declare function toRgba(color: ColorLike): Rgba;
+export declare function readField(field: ColorField, color: ColorLike): string;
+/**
+ * `null` rejects the edit, and the field falls back to the color it was
+ * showing rather than guessing at what was meant.
+ */
+export declare function writeField(field: ColorField, text: string, color: ColorLike): ColorLike | null;

package/dist/components/ColorPicker/index.d.ts

@@ -0,0 +1,3 @@
+export { default as ColorPicker } from "./ColorPicker.vue";
+export type { ColorPickerProps } from "./ColorPicker.types.js";
+export type { ColorPickerVariants } from "@ui-organized/core";

package/dist/components/Combobox/Combobox.types.d.ts

@@ -0,0 +1,45 @@
+import type { ControlSize } from "@ui-organized/core";
+export interface ComboboxOption {
+    value: string;
+    label: string;
+    disabled?: boolean;
+}
+export interface ComboboxProps {
+    /** Selectable options. The list filters against each option's `label`. */
+    options: ComboboxOption[];
+    /** Selected value. Use `v-model` for two-way binding. */
+    modelValue?: string;
+    /** Initial selected value for uncontrolled usage. */
+    defaultValue?: string;
+    /** Called with the selected option's value (empty string when cleared). */
+    onValueChange?: (value: string) => void;
+    /** Open state of the dropdown. */
+    open?: boolean;
+    /** Initial open state for uncontrolled usage. */
+    defaultOpen?: boolean;
+    /** Callback fired when the dropdown opens or closes. */
+    onOpenChange?: (open: boolean) => void;
+    /** Placeholder shown in the search input when nothing is selected. */
+    placeholder?: string;
+    /** Accessible label rendered above the control. */
+    label?: string;
+    /** Helper text rendered below the control. Hidden when an error is shown. */
+    helperText?: string;
+    /**
+     * Error state. Pass a string to show an error message.
+     * Pass `true` to mark the field invalid without a message.
+     */
+    error?: string | boolean;
+    /** Size variant. Defaults to 'md'. */
+    size?: ControlSize;
+    /** Whether the field should ignore user interaction. */
+    disabled?: boolean;
+    /** Name attribute for form submission. */
+    name?: string;
+    /** Whether a value is required for form submission. */
+    required?: boolean;
+    /** Message shown when no option matches the query. */
+    emptyMessage?: string;
+    /** DOM element to portal the dropdown into. Defaults to `document.body`. */
+    portalContainer?: HTMLElement | null;
+}

package/dist/components/Combobox/Combobox.vue.d.ts

@@ -0,0 +1,18 @@
+import type { ComboboxProps } from "./Combobox.types.js";
+import "@ui-organized/core/components/Combobox/Combobox.css";
+declare const _default: import("vue").DefineComponent<ComboboxProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: string) => any;
+    valueChange: (value: string) => any;
+    openChange: (open: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<ComboboxProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+    onValueChange?: ((value: string) => any) | undefined;
+    onOpenChange?: ((open: boolean) => any) | undefined;
+}>, {
+    required: boolean;
+    disabled: boolean;
+    open: boolean;
+    defaultOpen: boolean;
+    emptyMessage: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/Combobox/index.d.ts

@@ -0,0 +1,2 @@
+export { default as Combobox } from "./Combobox.vue";
+export type { ComboboxProps, ComboboxOption } from "./Combobox.types.js";

package/dist/components/ContextMenu/ContextMenu.types.d.ts

@@ -0,0 +1,38 @@
+import type { IconComponent, IconName } from "../Icon/Icon.types.js";
+export interface ContextMenuProps {
+    /** Open state. Use `v-model:open` for two-way binding. */
+    open?: boolean;
+    /** Initial open state for uncontrolled usage. */
+    defaultOpen?: boolean;
+}
+export interface ContextMenuContentProps {
+    /** Gap from the cursor, in px. Defaults to 4. */
+    sideOffset?: number;
+    /** Offset along the alignment axis, in px. */
+    alignOffset?: number;
+    /** DOM element to teleport into. Defaults to `body`. */
+    container?: HTMLElement | null;
+}
+export interface ContextMenuItemProps {
+    /** Stable value for the item. Generated when omitted. */
+    value?: string;
+    /** Icon rendered before the label. */
+    icon?: IconName | IconComponent;
+    /** Renders the item in the destructive color. */
+    destructive?: boolean;
+    /** Prevents selection while keeping the item visible. */
+    disabled?: boolean;
+}
+export interface ContextMenuCheckboxItemProps {
+    value?: string;
+    checked?: boolean;
+    disabled?: boolean;
+}
+export interface ContextMenuRadioItemProps {
+    value: string;
+    disabled?: boolean;
+}
+export interface ContextMenuRadioGroupProps {
+    /** Selected value. Use `v-model` for two-way binding. */
+    modelValue?: string;
+}

package/dist/components/ContextMenu/ContextMenu.vue.d.ts

@@ -0,0 +1,25 @@
+import type { ContextMenuProps } from "./ContextMenu.types.js";
+import "@ui-organized/core/components/ContextMenu/ContextMenu.css";
+import "@ui-organized/core/components/Checkbox/Checkbox.css";
+import "@ui-organized/core/components/Radio/Radio.css";
+declare var __VLS_10: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_10) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<ContextMenuProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    openChange: (open: boolean) => any;
+    "update:open": (open: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<ContextMenuProps> & Readonly<{
+    onOpenChange?: ((open: boolean) => any) | undefined;
+    "onUpdate:open"?: ((open: boolean) => any) | undefined;
+}>, {
+    open: boolean;
+    defaultOpen: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/ContextMenu/ContextMenuCheckboxItem.vue.d.ts

@@ -0,0 +1,22 @@
+import type { ContextMenuCheckboxItemProps } from "./ContextMenu.types.js";
+declare var __VLS_13: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_13) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<ContextMenuCheckboxItemProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:checked": (checked: boolean) => any;
+    checkedChange: (checked: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<ContextMenuCheckboxItemProps> & Readonly<{
+    "onUpdate:checked"?: ((checked: boolean) => any) | undefined;
+    onCheckedChange?: ((checked: boolean) => any) | undefined;
+}>, {
+    disabled: boolean;
+    checked: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/ContextMenu/ContextMenuContent.vue.d.ts

@@ -0,0 +1,15 @@
+import type { ContextMenuContentProps } from "./ContextMenu.types.js";
+declare var __VLS_14: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_14) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<ContextMenuContentProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ContextMenuContentProps> & Readonly<{}>, {
+    sideOffset: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/ContextMenu/ContextMenuGroup.vue.d.ts

@@ -0,0 +1,12 @@
+declare var __VLS_6: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_6) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/ContextMenu/ContextMenuGroupLabel.vue.d.ts

@@ -0,0 +1,12 @@
+declare var __VLS_6: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_6) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/ContextMenu/ContextMenuItem.vue.d.ts

@@ -0,0 +1,19 @@
+import type { ContextMenuItemProps } from "./ContextMenu.types.js";
+declare var __VLS_13: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_13) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<ContextMenuItemProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    select: () => any;
+}, string, import("vue").PublicProps, Readonly<ContextMenuItemProps> & Readonly<{
+    onSelect?: (() => any) | undefined;
+}>, {
+    disabled: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/ContextMenu/ContextMenuRadioGroup.vue.d.ts

@@ -0,0 +1,19 @@
+import type { ContextMenuRadioGroupProps } from "./ContextMenu.types.js";
+declare var __VLS_10: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_10) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<ContextMenuRadioGroupProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: string) => any;
+    valueChange: (value: string) => any;
+}, string, import("vue").PublicProps, Readonly<ContextMenuRadioGroupProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+    onValueChange?: ((value: string) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/ContextMenu/ContextMenuRadioItem.vue.d.ts

@@ -0,0 +1,15 @@
+import type { ContextMenuRadioItemProps } from "./ContextMenu.types.js";
+declare var __VLS_6: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_6) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<ContextMenuRadioItemProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ContextMenuRadioItemProps> & Readonly<{}>, {
+    disabled: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/ContextMenu/ContextMenuSeparator.vue.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/components/ContextMenu/ContextMenuTrigger.vue.d.ts

@@ -0,0 +1,12 @@
+declare var __VLS_6: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_6) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/ContextMenu/index.d.ts

@@ -0,0 +1,11 @@
+export { default as ContextMenu } from "./ContextMenu.vue";
+export { default as ContextMenuTrigger } from "./ContextMenuTrigger.vue";
+export { default as ContextMenuContent } from "./ContextMenuContent.vue";
+export { default as ContextMenuItem } from "./ContextMenuItem.vue";
+export { default as ContextMenuSeparator } from "./ContextMenuSeparator.vue";
+export { default as ContextMenuGroup } from "./ContextMenuGroup.vue";
+export { default as ContextMenuGroupLabel } from "./ContextMenuGroupLabel.vue";
+export { default as ContextMenuRadioGroup } from "./ContextMenuRadioGroup.vue";
+export { default as ContextMenuCheckboxItem } from "./ContextMenuCheckboxItem.vue";
+export { default as ContextMenuRadioItem } from "./ContextMenuRadioItem.vue";
+export type { ContextMenuProps, ContextMenuContentProps, ContextMenuItemProps, ContextMenuCheckboxItemProps, ContextMenuRadioItemProps, ContextMenuRadioGroupProps, } from "./ContextMenu.types.js";

package/dist/components/DateField/DateFieldBase.types.d.ts

@@ -0,0 +1,44 @@
+import type { ControlSize } from "@ui-organized/core";
+/** Props shared by the single date/time fields (DateInput, DateTimeInput). */
+export interface DateFieldProps {
+    /** Accessible label text rendered above the control. */
+    label?: string;
+    /** Helper text rendered below the control. Hidden when an error is shown. */
+    helperText?: string;
+    /**
+     * Error state. Pass a string to show an error message.
+     * Pass `true` to mark the field invalid without a message.
+     */
+    error?: string | boolean;
+    /** Size variant. Defaults to 'md'. */
+    size?: ControlSize;
+    /** Marks the control required and shows the required indicator. */
+    required?: boolean;
+    /** Disables the control and its picker button. */
+    disabled?: boolean;
+    /** The field's ISO value. Use `v-model` for two-way binding. */
+    modelValue?: string;
+    /** Initial ISO value for uncontrolled usage. */
+    defaultValue?: string;
+    /** Earliest selectable date, as an ISO string. */
+    min?: string;
+    /** Latest selectable date, as an ISO string. */
+    max?: string;
+    /**
+     * DOM element to teleport the calendar popover into. Defaults to `body`.
+     * Set this to a themed container when theme variables are scoped to a subtree
+     * (rather than `<html>`) so the popover inherits them instead of falling back
+     * to the document defaults.
+     */
+    portalContainer?: HTMLElement | null;
+}
+/**
+ * Internal props for the shared base — adds the native input type and the
+ * accessible label for the leading picker button.
+ */
+export interface DateFieldBaseProps extends DateFieldProps {
+    /** Native input type rendered on the field surface. */
+    type: "date" | "datetime-local";
+    /** Accessible label for the leading calendar button. */
+    pickerLabel: string;
+}

package/dist/components/DateField/DateFieldBase.vue.d.ts

@@ -0,0 +1,12 @@
+import type { DateFieldBaseProps } from "./DateFieldBase.types.js";
+import "@ui-organized/core/components/Input/Input.css";
+import "@ui-organized/core/components/Input/InputAffix.css";
+declare const _default: import("vue").DefineComponent<DateFieldBaseProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: string) => any;
+}, string, import("vue").PublicProps, Readonly<DateFieldBaseProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+}>, {
+    required: boolean;
+    disabled: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/DateField/DatePopover.types.d.ts

@@ -0,0 +1,10 @@
+export interface DatePopoverProps {
+    /** Optional container to teleport into (defaults to `body`). */
+    container?: HTMLElement | null;
+    /**
+     * Accessible name for the popup. Ark gives the content `role="dialog"`, and a
+     * dialog needs a name — the calendar inside is not one, it's the content.
+     * Pass the same phrase the trigger uses ("Choose date").
+     */
+    label: string;
+}

package/dist/components/DateField/DatePopover.vue.d.ts

@@ -0,0 +1,14 @@
+import type { DatePopoverProps } from "./DatePopover.types.js";
+import "@ui-organized/core/components/DateField/DatePopover.css";
+declare var __VLS_13: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_13) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<DatePopoverProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<DatePopoverProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/DateField/datePopoverPositioning.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Ark popover positioning that anchors the calendar to the *field* (or the
+ * start/end row) rather than to the small trigger button, and floats it below,
+ * left-aligned. Set on the controlled `Popover.Root` alongside `initialFocusEl`.
+ *
+ * The anchor arrives as an accessor rather than an element, because the element
+ * does not exist yet when the Root is initialised — reading it lazily inside
+ * `getAnchorRect` is what lets one object be built once and stay correct.
+ *
+ * React's version also merges the preview-container overrides from
+ * `useContainedPositioning()`. That context is a docs-site concern living in the
+ * React package's `preview/`, and has no counterpart here; the placement, gutter
+ * and strategy — the part that is the component's own behaviour — are identical.
+ */
+export interface DatePopoverPositioning {
+    placement: "bottom-start";
+    gutter: number;
+    strategy: "fixed";
+    getAnchorRect: () => {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    } | null;
+}
+export declare function datePopoverPositioning(anchor: () => HTMLElement | null): DatePopoverPositioning;

package/dist/components/DateField/openDatePicker.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Open the browser's native date/time picker for an input.
+ *
+ * `showPicker()` must run inside a user gesture and throws if it is unsupported
+ * or blocked — both cases are swallowed, so this stays a pure enhancement: the
+ * input remains fully typeable and the native on-focus picker keeps working.
+ */
+export declare function openDatePicker(input: HTMLInputElement | null): void;

package/dist/components/DateField/setNativeInputValue.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Set an input's value through the native value setter and dispatch an input
+ * event, so a consumer's `@input` (or `v-model`) fires whether the field is
+ * bound or not. Used when the calendar popover writes a date back to the field.
+ *
+ * The native setter is used rather than a plain `input.value = …` for the reason
+ * React needs it: a framework that owns the value may have installed its own
+ * `value` descriptor on the element, and writing through that descriptor is what
+ * it treats as "the value changed by itself" rather than "a user typed". Going
+ * through the prototype's setter writes the DOM value without telling the
+ * framework, leaving the dispatched event as the one and only notification.
+ */
+export declare function setNativeInputValue(input: HTMLInputElement | null, value: string): void;

package/dist/components/DateField/useCoarsePointer.d.ts

@@ -0,0 +1,14 @@
+import { type Ref } from "vue";
+/**
+ * Whether the primary input is a coarse pointer (touch).
+ *
+ * The date pickers show the DS-styled calendar popover on fine pointers
+ * (mouse/trackpad) but defer to the OS-native picker on touch devices, where the
+ * native wheel/calendar is the better experience. Starts `false` so SSR and the
+ * first paint render the desktop (popover) path, then corrects on mount — which
+ * is also what keeps this library's server-rendered markup identical to React's.
+ *
+ * The media query is created in `onMounted` rather than in setup: setup runs on
+ * the server too, where there is no `window` to ask.
+ */
+export declare function useCoarsePointer(): Ref<boolean>;

package/dist/components/DateInput/DateInput.types.d.ts

@@ -0,0 +1,41 @@
+import type { ControlSize } from "@ui-organized/core";
+/**
+ * Props for DateInput. `type` is fixed to `"date"`; every other native input
+ * attribute (`name`, `placeholder`, `autocomplete`, …) falls through `$attrs`
+ * onto the control.
+ *
+ * Written out rather than re-exporting the shared `DateFieldProps`, because a
+ * component's own prop list is what `defineProps<T>()` compiles into runtime
+ * declarations — and that list is the thing a consumer reads.
+ */
+export interface DateInputProps {
+    /** Accessible label text rendered above the control. */
+    label?: string;
+    /** Helper text rendered below the control. Hidden when an error is shown. */
+    helperText?: string;
+    /**
+     * Error state. Pass a string to show an error message.
+     * Pass `true` to mark the field invalid without a message.
+     */
+    error?: string | boolean;
+    /** Size variant. Defaults to 'md'. */
+    size?: ControlSize;
+    /** Marks the control required and shows the required indicator. */
+    required?: boolean;
+    /** Disables the control and its picker button. */
+    disabled?: boolean;
+    /** The field's ISO value (`YYYY-MM-DD`). Use `v-model` for two-way binding. */
+    modelValue?: string;
+    /** Initial ISO value for uncontrolled usage. */
+    defaultValue?: string;
+    /** Earliest selectable date (ISO `YYYY-MM-DD`). */
+    min?: string;
+    /** Latest selectable date (ISO `YYYY-MM-DD`). */
+    max?: string;
+    /**
+     * DOM element to teleport the calendar popover into. Defaults to `body`.
+     * Set this to a themed container when theme variables are scoped to a subtree
+     * so the popover inherits them instead of the document defaults.
+     */
+    portalContainer?: HTMLElement | null;
+}