ropav 0.1.6 → 0.1.8

package/dist/componentRef.js

@@ -0,0 +1,26 @@
+import { nextTick } from "vue";
+//#region src/utils/dom/componentRef.ts
+function asHTMLElement(value) {
+	if (value == null || typeof value !== "object") return null;
+	const ElementConstructor = ("ownerDocument" in value ? value.ownerDocument : null)?.defaultView?.HTMLElement;
+	if (ElementConstructor && value instanceof ElementConstructor) return value;
+	if (typeof HTMLElement !== "undefined" && value instanceof HTMLElement) return value;
+	return null;
+}
+function toHTMLElement(value, fallbackId) {
+	const directElement = asHTMLElement(value);
+	if (directElement) return directElement;
+	const vdomElement = asHTMLElement(value?.$el);
+	if (vdomElement) return vdomElement;
+	const vaporBlock = asHTMLElement(value?.block);
+	if (vaporBlock) return vaporBlock;
+	return fallbackId && typeof document !== "undefined" ? document.getElementById(fallbackId) : null;
+}
+function resolveHTMLElementRef(value, fallbackId, resolve) {
+	const element = toHTMLElement(value, fallbackId);
+	resolve(element);
+	if (element || !value) return;
+	nextTick(() => resolve(toHTMLElement(value, fallbackId)));
+}
+//#endregion
+export { toHTMLElement as n, resolveHTMLElementRef as t };

package/dist/components/accordion/accordionContext.d.ts

@@ -0,0 +1,3 @@
+import { InjectionKey } from 'vue';
+import { AccordionContext } from './types.js';
+export declare const accordionKey: InjectionKey<AccordionContext>;

package/dist/components/accordion/accordionModel.d.ts

@@ -0,0 +1,14 @@
+import { AccordionItemValue, AccordionModelValue } from './types.js';
+type AccordionValueTransition = {
+    changed: false;
+} | {
+    changed: true;
+    modelValue: AccordionModelValue;
+};
+interface AccordionValueTransitionOptions {
+    multiple: boolean;
+    collapsible: boolean;
+}
+export declare function readAccordionOpenValues(value: AccordionModelValue | undefined, multiple: boolean): AccordionItemValue[];
+export declare function transitionAccordionValue(currentValue: AccordionModelValue | undefined, itemValue: AccordionItemValue, open: boolean, options: AccordionValueTransitionOptions): AccordionValueTransition;
+export {};

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

@@ -1,5 +1,6 @@
 export { default as Accordion } from './accordion.js';
 export { default as AccordionItem } from './accordion-item.js';
-export { useAccordion, useAccordionItem } from './useAccordion.js';
+export { useAccordion } from './useAccordion.js';
+export { useAccordionItem } from './useAccordionItem.js';
 export { accordionItemParts, accordionParts } from './types.js';
 export type { AccordionItemPart, AccordionContentProps, AccordionContext, AccordionItemProps, AccordionItemRootProps, AccordionItemSlotProps, AccordionItemTriggerSlotProps, AccordionItemValue, AccordionModelValue, AccordionPart, AccordionProps, AccordionRootProps, AccordionState, AccordionTriggerProps, UseAccordionItemReturn, UseAccordionReturn, } from './types.js';

package/dist/components/accordion/index.js

@@ -1,2 +1,2 @@
-import { a as accordionItemParts, i as useAccordionItem, n as accordion_default, o as accordionParts, r as useAccordion, t as accordion_item_default } from "../../accordion.js";
+import { a as useAccordion, i as accordion_default, n as accordionParts, o as useAccordionItem, r as accordion_item_default, t as accordionItemParts } from "../../accordion.js";
 export { accordion_default as Accordion, accordion_item_default as AccordionItem, accordionItemParts, accordionParts, useAccordion, useAccordionItem };

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

@@ -1,4 +1,4 @@
-import { ComputedRef, HTMLAttributes, InjectionKey } from 'vue';
+import { ComputedRef, HTMLAttributes } from 'vue';
 import { StylesApiProps } from '../../styles-api.js';
 import { CollapseContentProps, CollapseContentRole, CollapseTriggerProps } from '../collapse/types.js';
 export type AccordionItemValue = string | number;
@@ -98,4 +98,3 @@ export interface UseAccordionItemReturn {
     close: () => void;
     toggle: () => void;
 }
-export declare const accordionKey: InjectionKey<AccordionContext>;

package/dist/components/accordion/useAccordion.d.ts

@@ -1,3 +1,3 @@
-import { AccordionItemProps, AccordionModelValue, AccordionProps, UseAccordionItemReturn, UseAccordionReturn } from './types.js';
+import { AccordionModelValue, AccordionProps, UseAccordionReturn } from './types.js';
 export declare function useAccordion(props: Readonly<AccordionProps>, emitUpdate: (value: AccordionModelValue) => void): UseAccordionReturn;
-export declare function useAccordionItem(props: Readonly<AccordionItemProps>): UseAccordionItemReturn;
+export { useAccordionItem } from './useAccordionItem.js';

package/dist/components/accordion/useAccordionItem.d.ts

@@ -0,0 +1,2 @@
+import { AccordionItemProps, UseAccordionItemReturn } from './types.js';
+export declare function useAccordionItem(props: Readonly<AccordionItemProps>): UseAccordionItemReturn;

package/dist/components/calendar/calendar.d.ts

@@ -0,0 +1,30 @@
+import { CalendarDaySlotProps, CalendarProps } from './types.js';
+declare const __VLS_export: (__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import('vue').PublicProps & __VLS_PrettifyLocal<CalendarProps & {
+        "onUpdate:modelValue"?: ((value: Date) => any) | undefined;
+        onChange?: ((value: Date) => any) | undefined;
+        "onUpdate:month"?: ((month: Date) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: import('vue').ShallowUnwrapRef<{
+        nativeElement: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+        focus(): void;
+    }>) => void;
+    attrs: any;
+    slots: {
+        day?(props: CalendarDaySlotProps): unknown;
+        'previous-icon'?(): unknown;
+        'next-icon'?(): unknown;
+    };
+    emit: ((evt: "update:modelValue", value: Date) => void) & ((evt: "change", value: Date) => void) & ((evt: "update:month", month: Date) => void);
+}>) => import('vue').VNode & {
+    __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

package/dist/components/calendar/calendarBehavior.d.ts

@@ -0,0 +1,49 @@
+import { DateAvailabilityOptions } from '../../utils/dateAvailability.js';
+import { CalendarDay, CalendarWeekday, CalendarWeekdayFormat } from './types.js';
+interface CalendarBehaviorOptions extends DateAvailabilityOptions {
+    month: Date;
+    selectedDate: Date | null;
+    today: Date;
+    firstDayOfWeek?: number;
+    weekdayFormat?: CalendarWeekdayFormat;
+    locale?: string;
+    monthFormat?: Intl.DateTimeFormatOptions;
+    fixedWeeks?: boolean;
+    hideOutsideDates?: boolean;
+    disabled?: boolean;
+}
+type CalendarBehaviorAction = {
+    type: 'resolve-focusable';
+    focusedDate: Date;
+} | {
+    type: 'align-month';
+    previousMonth: Date;
+    focusedDate: Date;
+} | {
+    type: 'navigate-month';
+    amount: number;
+    focusedDate: Date;
+} | {
+    type: 'move-focus';
+    date: Date;
+    key: string;
+    shiftKey?: boolean;
+};
+interface CalendarBehaviorTransition {
+    focusedDate: Date;
+    visibleMonth?: Date;
+}
+interface CalendarBehaviorView {
+    days: CalendarDay[];
+    weeks: CalendarDay[][];
+    weekdays: CalendarWeekday[];
+    monthLabel: string;
+    previousDisabled: boolean;
+    nextDisabled: boolean;
+}
+interface CalendarBehavior {
+    view: CalendarBehaviorView;
+    decide: (action: CalendarBehaviorAction) => CalendarBehaviorTransition | null;
+}
+export declare function createCalendarBehavior(options: CalendarBehaviorOptions): CalendarBehavior;
+export {};

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

@@ -0,0 +1,3 @@
+export { default as Calendar } from './calendar.js';
+export { calendarParts, calendarRadiuses, calendarSizes, calendarWeekdayFormats } from './types.js';
+export type { CalendarDay, CalendarDaySlotProps, CalendarDisabledDates, CalendarPart, CalendarProps, CalendarRadius, CalendarSize, CalendarWeekday, CalendarWeekdayFormat, } from './types.js';

package/dist/components/calendar/index.js

@@ -0,0 +1,3 @@
+import { t as calendar_default } from "../../calendar.js";
+import { i as calendarWeekdayFormats, n as calendarRadiuses, r as calendarSizes, t as calendarParts } from "../../calendar2.js";
+export { calendar_default as Calendar, calendarParts, calendarRadiuses, calendarSizes, calendarWeekdayFormats };

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

@@ -0,0 +1,53 @@
+import { StylesApiProps } from '../../styles-api.js';
+import { DisabledDateRule } from '../../utils/dateAvailability.js';
+export declare const calendarParts: readonly ["root", "header", "previousControl", "monthLabel", "nextControl", "weekdays", "weekday", "grid", "week", "dayCell", "day"];
+export declare const calendarSizes: readonly ["xs", "sm", "md", "lg", "xl"];
+export declare const calendarRadiuses: readonly ["none", "xs", "sm", "md", "lg", "xl", "full"];
+export declare const calendarWeekdayFormats: readonly ["narrow", "short", "long"];
+export type CalendarPart = (typeof calendarParts)[number];
+export type CalendarSize = (typeof calendarSizes)[number];
+export type CalendarRadius = (typeof calendarRadiuses)[number];
+export type CalendarWeekdayFormat = (typeof calendarWeekdayFormats)[number];
+export type CalendarDisabledDates = DisabledDateRule;
+export interface CalendarDay {
+    date: Date;
+    key: string;
+    label: number;
+    ariaLabel: string;
+    outside: boolean;
+    hidden: boolean;
+    selected: boolean;
+    today: boolean;
+    disabled: boolean;
+}
+export interface CalendarWeekday {
+    key: number;
+    label: string;
+    ariaLabel: string;
+}
+export interface CalendarDaySlotProps extends CalendarDay {
+    select: () => void;
+}
+export interface CalendarProps extends StylesApiProps<CalendarPart> {
+    id?: string;
+    modelValue?: Date | null;
+    defaultValue?: Date | null;
+    month?: Date;
+    defaultMonth?: Date;
+    locale?: string;
+    firstDayOfWeek?: number;
+    weekdayFormat?: CalendarWeekdayFormat;
+    monthFormat?: Intl.DateTimeFormatOptions;
+    min?: Date;
+    max?: Date;
+    disabledDates?: CalendarDisabledDates;
+    fixedWeeks?: boolean;
+    hideOutsideDates?: boolean;
+    disabled?: boolean;
+    readonly?: boolean;
+    size?: CalendarSize;
+    radius?: CalendarRadius;
+    ariaLabel?: string;
+    previousLabel?: string;
+    nextLabel?: string;
+}

package/dist/components/calendar/useCalendar.d.ts

@@ -0,0 +1,24 @@
+import { CalendarDay, CalendarProps } from './types.js';
+interface CalendarEmitters {
+    value: (value: Date) => void;
+    month: (month: Date) => void;
+    change: (value: Date) => void;
+}
+export declare function useCalendar(props: Readonly<CalendarProps>, emit: CalendarEmitters): {
+    rootRef: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+    selectedDate: import('vue').ComputedRef<Date | null>;
+    visibleMonth: import('vue').ComputedRef<Date>;
+    days: import('vue').ComputedRef<CalendarDay[]>;
+    weeks: import('vue').ComputedRef<CalendarDay[][]>;
+    weekdays: import('vue').ComputedRef<import('./types.js').CalendarWeekday[]>;
+    monthLabel: import('vue').ComputedRef<string>;
+    rootClass: import('vue').ComputedRef<string[]>;
+    previousDisabled: import('vue').ComputedRef<boolean>;
+    nextDisabled: import('vue').ComputedRef<boolean>;
+    focusableDate: import('vue').ComputedRef<Date | null>;
+    selectDate: (day: CalendarDay) => void;
+    navigateMonth: (amount: number) => void;
+    onDayKeydown: (event: KeyboardEvent, day: CalendarDay) => void;
+    onDayFocus: (day: CalendarDay) => void;
+};
+export {};

package/dist/components/checkbox/useCheckbox.d.ts

@@ -1,10 +1,9 @@
-import { CSSProperties } from 'vue';
 import { CheckboxProps } from './types.js';
 export declare function useCheckbox(props: Readonly<CheckboxProps>, emitUpdate: (value: boolean) => void, getValue?: () => boolean): {
     inputRef: import('vue').Ref<HTMLInputElement | null, HTMLInputElement | null>;
     control: import('../../internal/composables/useControlState.js').ControlState;
     rootClass: import('vue').ComputedRef<string[]>;
-    rootStyle: import('vue').ComputedRef<CSSProperties | undefined>;
+    rootStyle: import('vue').ComputedRef<Record<string, string> | undefined>;
     onChange: (e: Event) => void;
     focus: (options?: FocusOptions) => void;
 };

package/dist/components/color-picker/index.js

@@ -1,3 +1,3 @@
-import { t as color_picker_default } from "../../color-picker.js";
-import { n as colorPickerParts, r as colorPickerSizes, t as colorPickerFormats } from "../../color-picker2.js";
+import { n as colorPickerFormats, t as color_picker_default } from "../../color-picker.js";
+import { n as colorPickerSizes, t as colorPickerParts } from "../../color-picker2.js";
 export { color_picker_default as ColorPicker, colorPickerFormats, colorPickerParts, colorPickerSizes };

package/dist/components/color-picker/types.d.ts

@@ -1,10 +1,10 @@
 import { HTMLAttributes } from 'vue';
+import { colorPickerFormats, ColorPickerFormat } from '../../utils/colorPicker.js';
 import { StylesApiProps } from '../../styles-api.js';
+export { colorPickerFormats, type ColorPickerFormat };
 export declare const colorPickerParts: readonly ["root", "label", "control", "handle", "swatches", "swatch"];
 export type ColorPickerPart = (typeof colorPickerParts)[number];
-export declare const colorPickerFormats: readonly ["hex", "hexa", "rgb", "rgba", "hsl", "hsla"];
 export declare const colorPickerSizes: readonly ["xs", "sm", "md", "lg", "xl"];
-export type ColorPickerFormat = (typeof colorPickerFormats)[number];
 export type ColorPickerSize = (typeof colorPickerSizes)[number];
 export interface ColorPickerSelection {
     saturation: number;

package/dist/components/color-picker/useColorPickerDrag.d.ts

@@ -11,6 +11,6 @@ interface UseColorPickerDragOptions {
     updateFromPointer: (pointer: ColorPickerPointerCoordinates, rect: DOMRect) => void;
 }
 export declare function useColorPickerDrag({ target, focusTarget, readonly, isGeometryValid, updateFromPointer, }: UseColorPickerDragOptions): {
-    onPointerDown: (event: PointerEvent) => void;
+    onPointerDown: (event: PointerEvent) => boolean;
 };
 export {};

package/dist/components/color-picker/useColorPickerSaturation.d.ts

@@ -0,0 +1,22 @@
+import { ComponentElementRef } from '../../utils/dom/componentRef.js';
+import { ColorPickerSelection } from './types.js';
+type ColorPickerAxis = 'saturation' | 'value';
+interface UseColorPickerSaturationOptions {
+    modelValue: () => Readonly<ColorPickerSelection>;
+    hue: () => number;
+    readonly: () => boolean;
+    onChange: (selection: ColorPickerSelection) => void;
+}
+export declare function useColorPickerSaturation({ modelValue, hue, readonly, onChange, }: UseColorPickerSaturationOptions): {
+    setSaturationElement: (value: ComponentElementRef) => void;
+    setSaturationInput: (value: ComponentElementRef) => void;
+    selection: import('vue').ComputedRef<{
+        saturation: number;
+        value: number;
+    }>;
+    normalizedHue: import('vue').ComputedRef<number>;
+    onPointerDown: (event: PointerEvent) => boolean;
+    onAxisKeydown: (event: KeyboardEvent, axis: ColorPickerAxis) => void;
+    onAxisInput: (event: Event, axis: ColorPickerAxis) => void;
+};
+export {};

package/dist/components/color-picker/useColorPickerSlider.d.ts

@@ -0,0 +1,20 @@
+import { ComponentElementRef } from '../../utils/dom/componentRef.js';
+import { ColorPickerSliderVariant } from './types.js';
+interface UseColorPickerSliderOptions {
+    variant: () => ColorPickerSliderVariant;
+    value: () => number;
+    readonly: () => boolean;
+    onChange: (value: number) => void;
+}
+export declare function useColorPickerSlider({ variant, value, readonly, onChange, }: UseColorPickerSliderOptions): {
+    setSliderElement: (element: ComponentElementRef) => void;
+    sliderState: import('vue').ComputedRef<{
+        isHue: boolean;
+        max: number;
+        value: number;
+        outputValue: number;
+    }>;
+    onPointerDown: (event: PointerEvent) => boolean;
+    onKeydown: (event: KeyboardEvent) => void;
+};
+export {};

package/dist/components/color-picker/useColorPickerValue.d.ts

@@ -1,4 +1,4 @@
-import { ColorPickerHsvColor } from './color-picker-utils.js';
+import { ColorPickerHsvColor } from '../../utils/colorPicker.js';
 import { ColorPickerProps, ColorPickerSelection, ColorPickerValue } from './types.js';
 type ColorPickerValueProps = Readonly<Pick<ColorPickerProps, 'modelValue' | 'format' | 'readonly'>>;
 export declare function useColorPickerValue(props: ColorPickerValueProps, emitUpdate: (value: ColorPickerValue) => void): {

package/dist/components/combobox/combobox.d.ts

@@ -0,0 +1,29 @@
+import { ComboboxEmptySlotProps, ComboboxOptionSlotProps, ComboboxProps } from './types.js';
+declare const __VLS_export: (__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import('vue').PublicProps & __VLS_PrettifyLocal<ComboboxProps & {
+        onSearch?: ((searchValue: string) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: string | number | null) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: import('vue').ShallowUnwrapRef<{
+        nativeElement: import('vue').Ref<HTMLSelectElement | null, HTMLSelectElement | null>;
+        inputElement: import('vue').Ref<HTMLInputElement | null, HTMLInputElement | null>;
+        focus: () => void | undefined;
+    }>) => void;
+    attrs: any;
+    slots: {
+        option?(props: ComboboxOptionSlotProps): unknown;
+        empty?(props: ComboboxEmptySlotProps): unknown;
+    };
+    emit: ((evt: "search", searchValue: string) => void) & ((evt: "update:modelValue", value: string | number | null) => void);
+}>) => import('vue').VNode & {
+    __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

package/dist/components/combobox/comboboxModel.d.ts

@@ -0,0 +1,4 @@
+import { ComboboxOption } from './types.js';
+export type ComboboxValue = string | number | null;
+export declare function hasComboboxValue(value: ComboboxValue): value is string | number;
+export declare function getComboboxDisplayLabel(options: readonly ComboboxOption[] | undefined, value: ComboboxValue): string;

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

@@ -0,0 +1,3 @@
+export { default as Combobox } from './combobox.js';
+export { comboboxParts } from './types.js';
+export type { ComboboxEmptySlotProps, ComboboxFilter, ComboboxOption, ComboboxOptionSlotProps, ComboboxPart, ComboboxProps, ComboboxRadius, ComboboxSize, } from './types.js';

package/dist/components/combobox/index.js

@@ -0,0 +1,2 @@
+import { n as combobox_default, t as comboboxParts } from "../../combobox.js";
+export { combobox_default as Combobox, comboboxParts };

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

@@ -0,0 +1,43 @@
+import { InputHTMLAttributes } from 'vue';
+import { StylesApiProps } from '../../styles-api.js';
+export interface ComboboxOption {
+    label: string;
+    value: string | number;
+    disabled?: boolean;
+}
+export type ComboboxFilter = (option: ComboboxOption, searchValue: string) => boolean;
+export type ComboboxRadius = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+export type ComboboxSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+export interface ComboboxOptionSlotProps {
+    option: ComboboxOption;
+    selected: boolean;
+    highlighted: boolean;
+}
+export interface ComboboxEmptySlotProps {
+    searchValue: string;
+}
+export interface ComboboxProps extends StylesApiProps<ComboboxPart> {
+    id?: string;
+    name?: string;
+    form?: string;
+    modelValue?: string | number | null;
+    defaultValue?: string | number | null;
+    options?: ComboboxOption[];
+    filter?: ComboboxFilter | false;
+    size?: ComboboxSize;
+    radius?: ComboboxRadius;
+    placeholder?: string;
+    clearable?: boolean;
+    clearLabel?: string;
+    toggleLabel?: string;
+    disabled?: boolean;
+    required?: boolean;
+    invalid?: boolean;
+    ariaLabel?: string;
+    describedby?: string;
+    labelledby?: string;
+    inputAttrs?: InputHTMLAttributes;
+    validationMessage?: string;
+}
+export declare const comboboxParts: readonly ["root", "input", "indicator", "clear", "toggle", "content", "option", "empty"];
+export type ComboboxPart = (typeof comboboxParts)[number];

package/dist/components/combobox/useCombobox.d.ts

@@ -0,0 +1,45 @@
+import { CSSProperties, ComputedRef, Ref, SelectHTMLAttributes } from 'vue';
+import { ControlState } from '../../internal/composables/useControlState.js';
+import { FlatOptionState } from '../../internal/composables/useFlatOptionCollection.js';
+import { ComponentElementRef } from '../../utils/dom/componentRef.js';
+import { FloatingPlacement, FloatingSide } from '../floating/types.js';
+import { ComboboxValue } from './comboboxModel.js';
+import { ComboboxOption, ComboboxProps } from './types.js';
+export interface ComboboxControl {
+    templateRefs: {
+        root: Ref<HTMLElement | null>;
+        input: Ref<HTMLInputElement | null>;
+        native: Ref<HTMLSelectElement | null>;
+    };
+    nativeSelectAttrs: ComputedRef<SelectHTMLAttributes>;
+    isOpen: Ref<boolean>;
+    popupId: string;
+    listboxId: string;
+    control: ControlState;
+    visibleOptions: ComputedRef<ComboboxOption[]>;
+    renderedOptions: ComputedRef<readonly FlatOptionState<ComboboxOption>[]>;
+    activeDescendantId: ComputedRef<string | undefined>;
+    rootClass: ComputedRef<string[]>;
+    floatingStyle: Readonly<Ref<CSSProperties>>;
+    actualPlacement: Readonly<Ref<FloatingPlacement>>;
+    placementSide: ComputedRef<FloatingSide>;
+    searchValue: Ref<string>;
+    displayLabel: ComputedRef<string>;
+    canClear: ComputedRef<boolean>;
+    setDropdownElement: (elementRef: ComponentElementRef) => void;
+    toggle: () => void;
+    selectOption: (option: ComboboxOption) => void;
+    clearSelection: () => void;
+    onOptionMouseenter: (option: ComboboxOption) => void;
+    onFocusout: (event: FocusEvent) => void;
+    onInput: (event: Event) => void;
+    onInputFocus: () => void;
+    onInputClick: () => void;
+    onInputKeydown: (event: KeyboardEvent) => void;
+}
+interface ComboboxCallbacks {
+    valueChange: (value: ComboboxValue) => void;
+    search: (searchValue: string) => void;
+}
+export declare function useCombobox(props: Readonly<ComboboxProps>, callbacks: ComboboxCallbacks): ComboboxControl;
+export {};

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

@@ -0,0 +1,33 @@
+import { DatePickerDaySlotProps, DatePickerProps } from './types.js';
+declare const __VLS_export: (__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import('vue').PublicProps & __VLS_PrettifyLocal<DatePickerProps & {
+        "onUpdate:modelValue"?: ((value: Date | null) => any) | undefined;
+        "onUpdate:open"?: ((open: boolean) => any) | undefined;
+        onChange?: ((value: Date | null) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: import('vue').ShallowUnwrapRef<{
+        nativeElement: import('vue').ComputedRef<HTMLInputElement | null>;
+        focus: () => void | undefined;
+        open: () => void;
+    }>) => void;
+    attrs: any;
+    slots: {
+        day?(props: DatePickerDaySlotProps): unknown;
+        'clear-icon'?(): unknown;
+        'calendar-icon'?(): unknown;
+        'previous-icon'?(): unknown;
+        'next-icon'?(): unknown;
+    };
+    emit: ((evt: "update:modelValue", value: Date | null) => void) & ((evt: "update:open", open: boolean) => void) & ((evt: "change", value: Date | null) => void);
+}>) => import('vue').VNode & {
+    __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

package/dist/components/date-picker/datePickerModel.d.ts

@@ -0,0 +1,10 @@
+export declare const defaultDatePickerFormat: Intl.DateTimeFormatOptions;
+export declare function formatDatePickerValue(value: Date | null, locale?: string, format?: Intl.DateTimeFormatOptions): string;
+/**
+ * Parses ISO date keys or supported locale values produced by `formatDatePickerValue`.
+ *
+ * Locale parsing supports Gregorian, ISO 8601, and Buddhist date-only formats.
+ * Two-digit years resolve to the corresponding Gregorian year from 2000 through 2099.
+ */
+export declare function parseDatePickerValue(value: string, locale?: string, format?: Intl.DateTimeFormatOptions): Date | null;
+export declare function normalizeDatePickerValue(value: Date | null | undefined): Date | null;

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

@@ -0,0 +1,4 @@
+export { default as DatePicker } from './date-picker.js';
+export { datePickerParts } from './types.js';
+export type { DatePickerDaySlotProps, DatePickerFormat, DatePickerParse, DatePickerPart, DatePickerProps, } from './types.js';
+export { defaultDatePickerFormat, formatDatePickerValue, normalizeDatePickerValue, parseDatePickerValue, } from './datePickerModel.js';

package/dist/components/date-picker/index.js

@@ -0,0 +1,2 @@
+import { a as normalizeDatePickerValue, i as formatDatePickerValue, n as date_picker_default, o as parseDatePickerValue, r as defaultDatePickerFormat, t as datePickerParts } from "../../date-picker.js";
+export { date_picker_default as DatePicker, datePickerParts, defaultDatePickerFormat, formatDatePickerValue, normalizeDatePickerValue, parseDatePickerValue };

package/dist/components/date-picker/types.d.ts

@@ -0,0 +1,57 @@
+import { InputHTMLAttributes } from 'vue';
+import { StylesApiProps } from '../../styles-api.js';
+import { CalendarDaySlotProps, CalendarDisabledDates, CalendarRadius, CalendarSize, CalendarWeekdayFormat } from '../calendar/types.js';
+import { InputRadius, InputSize } from '../input/types.js';
+import { PopoverPlacement } from '../popover/types.js';
+export declare const datePickerParts: readonly ["root", "control", "input", "clear", "indicator", "content", "calendar", "calendarHeader", "calendarControl", "calendarMonthLabel", "calendarWeekdays", "calendarWeekday", "calendarGrid", "calendarWeek", "calendarDayCell", "calendarDay"];
+export type DatePickerPart = (typeof datePickerParts)[number];
+export type DatePickerFormat = (date: Date) => string;
+export type DatePickerParse = (value: string) => Date | null;
+export type DatePickerDaySlotProps = CalendarDaySlotProps;
+export interface DatePickerProps extends StylesApiProps<DatePickerPart> {
+    id?: string;
+    name?: string;
+    form?: string;
+    modelValue?: Date | null;
+    defaultValue?: Date | null;
+    defaultMonth?: Date;
+    open?: boolean;
+    locale?: string;
+    dateFormat?: Intl.DateTimeFormatOptions;
+    formatDate?: DatePickerFormat;
+    parseDate?: DatePickerParse;
+    firstDayOfWeek?: number;
+    weekdayFormat?: CalendarWeekdayFormat;
+    min?: Date;
+    max?: Date;
+    disabledDates?: CalendarDisabledDates;
+    fixedWeeks?: boolean;
+    hideOutsideDates?: boolean;
+    allowInput?: boolean;
+    clearable?: boolean;
+    closeOnSelect?: boolean;
+    disabled?: boolean;
+    readonly?: boolean;
+    required?: boolean;
+    invalid?: boolean;
+    valid?: boolean;
+    size?: InputSize;
+    radius?: InputRadius;
+    calendarSize?: CalendarSize;
+    calendarRadius?: CalendarRadius;
+    placeholder?: string;
+    ariaLabel?: string;
+    describedby?: string;
+    labelledby?: string;
+    inputAttrs?: InputHTMLAttributes;
+    validationMessage?: string;
+    invalidDateMessage?: string;
+    clearLabel?: string;
+    toggleLabel?: string;
+    calendarAriaLabel?: string;
+    previousLabel?: string;
+    nextLabel?: string;
+    placement?: PopoverPlacement;
+    keepMounted?: boolean;
+    popoverId?: string;
+}

package/dist/components/date-picker/useDatePicker.d.ts

@@ -0,0 +1,29 @@
+import { InputHTMLAttributes } from 'vue';
+import { DatePickerProps } from './types.js';
+interface DatePickerEmitters {
+    value: (value: Date | null) => void;
+    change: (value: Date | null) => void;
+    open: (open: boolean) => void;
+}
+interface DatePickerElements {
+    getInput: () => HTMLInputElement | null;
+    focusCalendar: () => void;
+}
+export declare function useDatePicker(props: Readonly<DatePickerProps>, emit: DatePickerEmitters, elements: DatePickerElements): {
+    control: import('../../internal/composables/useControlState.js').ControlState;
+    selectedDate: import('vue').ComputedRef<Date | null>;
+    inputValue: import('vue').ShallowRef<string, string>;
+    isInvalid: import('vue').ComputedRef<boolean>;
+    effectiveValidationMessage: import('vue').ComputedRef<string | undefined>;
+    rootClass: import('vue').ComputedRef<string[]>;
+    canClear: import('vue').ComputedRef<boolean>;
+    getInputTriggerAttrs: (slotProps: unknown) => InputHTMLAttributes;
+    onInputUpdate: (value: string) => void;
+    onCalendarKeydown: (event: KeyboardEvent) => void;
+    onFocusOut: (event: FocusEvent) => void;
+    clearFromControl: (event: MouseEvent) => void;
+    selectCalendarDate: (value: Date) => void;
+    openDatePicker: () => void;
+    onOpenUpdate: (open: boolean) => void;
+};
+export {};