hys-ui 0.6.0 → 0.8.0

package/dist/types/components/HysTabs/useTabsDragGhost.d.ts

@@ -0,0 +1,22 @@
+import type { HysTabItem } from "./tabsTypes";
+interface Point {
+    x: number;
+    y: number;
+}
+export declare function useTabsDragGhost(): {
+    ghost: import("vue").ShallowRef<{
+        label: string;
+        width: number;
+        height: number;
+    } | undefined, {
+        label: string;
+        width: number;
+        height: number;
+    } | undefined>;
+    element: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    show: (item: HysTabItem, box: DOMRect, pointer: Point) => void;
+    move: (x: number, y: number) => void;
+    land: (commit: Promise<boolean> | undefined, target: () => HTMLElement | null | undefined, duration: number, easing: string) => Promise<void>;
+    clear: () => void;
+};
+export {};

package/dist/types/components/HysTabs/useTabsNav.d.ts

@@ -0,0 +1,20 @@
+import { type CSSProperties } from "vue";
+import type { HysTabItem, HysTabsProps, HysTabValue } from "./tabsTypes";
+export declare function useTabsNav(props: () => HysTabsProps, items: () => readonly HysTabItem[], active: () => HysTabValue, vertical: () => boolean, motion: () => boolean, switchTab: (step: number, source: "wheel") => void): {
+    nav: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    track: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    before: import("vue").Ref<boolean, boolean>;
+    after: import("vue").Ref<boolean, boolean>;
+    hasOverflow: import("vue").ComputedRef<boolean>;
+    overflowed: import("vue").ShallowRef<HysTabValue[], HysTabValue[]>;
+    indicator: import("vue").ShallowRef<CSSProperties, CSSProperties>;
+    setButton: (value: HysTabValue, element: HTMLButtonElement | null) => void;
+    button: (value: HysTabValue) => HTMLButtonElement | undefined;
+    rtl: () => boolean;
+    scroll: (direction: number) => void;
+    scrollTo: (value?: HysTabValue) => void;
+    scrollPixels: (distance: number, smooth?: boolean) => void;
+    focus: (value: HysTabValue) => void;
+    wheel: (event: WheelEvent) => void;
+    schedule: () => void;
+};

package/dist/types/components/HysTabs/useTabsOverlays.d.ts

@@ -0,0 +1,54 @@
+import { type Component } from "vue";
+import type { HysContextMenuInstance } from "../../composables/menu";
+import type { TabsEmit } from "./tabsTypes";
+export declare function useTabsOverlays(emit: TabsEmit): {
+    menu: import("vue").Ref<HysContextMenuInstance<import("../..").HysContextMenuItem> | undefined, HysContextMenuInstance<import("../..").HysContextMenuItem> | undefined>;
+    prompts: import("vue").Ref<import("vue").CreateComponentPublicInstanceWithMixins<Readonly<{}> & Readonly<{}>, {
+        confirm: (items: import("./tabsTypes").HysTabItem[], signal: AbortSignal) => Promise<boolean>;
+        rename: (item: import("./tabsTypes").HysTabItem) => Promise<string | boolean>;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {}, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<{}> & Readonly<{}>, {
+        confirm: (items: import("./tabsTypes").HysTabItem[], signal: AbortSignal) => Promise<boolean>;
+        rename: (item: import("./tabsTypes").HysTabItem) => Promise<string | boolean>;
+    }, {}, {}, {}, {}> | undefined, import("vue").CreateComponentPublicInstanceWithMixins<Readonly<{}> & Readonly<{}>, {
+        confirm: (items: import("./tabsTypes").HysTabItem[], signal: AbortSignal) => Promise<boolean>;
+        rename: (item: import("./tabsTypes").HysTabItem) => Promise<string | boolean>;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {}, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<{}> & Readonly<{}>, {
+        confirm: (items: import("./tabsTypes").HysTabItem[], signal: AbortSignal) => Promise<boolean>;
+        rename: (item: import("./tabsTypes").HysTabItem) => Promise<string | boolean>;
+    }, {}, {}, {}, {}> | undefined>;
+    menuComponent: import("vue").ShallowRef<Component | undefined, Component | undefined>;
+    promptComponent: import("vue").ShallowRef<Component | undefined, Component | undefined>;
+    showMenu: (point: {
+        x: number;
+        y: number;
+    }) => Promise<void>;
+    closeMenu: () => void;
+    prompt: () => Promise<import("vue").CreateComponentPublicInstanceWithMixins<Readonly<{}> & Readonly<{}>, {
+        confirm: (items: import("./tabsTypes").HysTabItem[], signal: AbortSignal) => Promise<boolean>;
+        rename: (item: import("./tabsTypes").HysTabItem) => Promise<string | boolean>;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {}, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<{}> & Readonly<{}>, {
+        confirm: (items: import("./tabsTypes").HysTabItem[], signal: AbortSignal) => Promise<boolean>;
+        rename: (item: import("./tabsTypes").HysTabItem) => Promise<string | boolean>;
+    }, {}, {}, {}, {}> | undefined>;
+};

package/dist/types/components/HysTabs/useTabsPanels.d.ts

@@ -0,0 +1,14 @@
+import type { HysTabContent, HysTabItem, HysTabValue, HysTabsProps, TabsEmit } from "./tabsTypes";
+interface Resource {
+    state: "loading" | "ready" | "error";
+    content?: HysTabContent;
+    error?: unknown;
+}
+export declare function useTabsPanels(props: () => HysTabsProps, items: () => readonly HysTabItem[], active: () => HysTabValue, emit: TabsEmit): {
+    loaded: import("vue").ShallowReactive<Map<HysTabValue, Resource>>;
+    versions: import("vue").Reactive<Map<HysTabValue, number>>;
+    render: (item: HysTabItem) => boolean;
+    preload: (value: HysTabValue) => Promise<boolean>;
+    reload: (value?: HysTabValue) => Promise<boolean>;
+};
+export {};

package/dist/types/components/HysTabs/useTabsPointer.d.ts

@@ -0,0 +1,30 @@
+import type { HysTabItem, HysTabsProps, HysTabValue } from "./tabsTypes";
+import type { useTabsNav } from "./useTabsNav";
+export declare function useTabsPointer(props: () => HysTabsProps, nav: ReturnType<typeof useTabsNav>, itemByToken: (token: string) => HysTabItem | undefined, canMove: (item: HysTabItem) => boolean, move: (value: HysTabValue, target: HysTabValue, after: boolean) => Promise<boolean>, isVertical: () => boolean, longpress: (item: HysTabItem, event: PointerEvent) => void, swipe: (step: number) => void, animated: () => boolean): {
+    dragging: import("vue").Ref<HysTabValue | undefined, HysTabValue | undefined>;
+    drop: import("vue").Ref<{
+        value: HysTabValue;
+        after: boolean;
+    } | undefined, {
+        value: HysTabValue;
+        after: boolean;
+    } | undefined>;
+    ghost: import("vue").ShallowRef<{
+        label: string;
+        width: number;
+        height: number;
+    } | undefined, {
+        label: string;
+        width: number;
+        height: number;
+    } | undefined>;
+    ghostElement: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    down: (event: PointerEvent) => void;
+    motion: (event: PointerEvent) => void;
+    finish: (event?: PointerEvent, cancelled?: boolean) => void;
+    cancel: (event: PointerEvent) => void;
+    clickCapture: (event: MouseEvent) => void;
+    swipeDown: (event: PointerEvent) => void;
+    swipeUp: (event: PointerEvent) => void;
+    cancelSwipe: () => void;
+};

package/dist/types/components/HysTabs/useTabsState.d.ts

@@ -0,0 +1,32 @@
+import type { HysTabCloseScope, HysTabItem, HysTabSource, HysTabsProps, HysTabValue, TabsEmit } from "./tabsTypes";
+type Options = () => HysTabsProps;
+export interface ClosedTab {
+    item: HysTabItem;
+    index: number;
+}
+export declare function useTabsState(props: Options, declared: () => readonly HysTabItem[], declarative: () => boolean, emit: TabsEmit, confirmDirty: (items: HysTabItem[], signal: AbortSignal) => Promise<boolean>): {
+    all: import("vue").ComputedRef<HysTabItem[]>;
+    visible: import("vue").ComputedRef<HysTabItem[]>;
+    byKey: import("vue").ComputedRef<Map<HysTabValue, HysTabItem>>;
+    enabled: import("vue").ComputedRef<HysTabItem[]>;
+    active: import("vue").ComputedRef<HysTabValue>;
+    current: import("vue").Ref<HysTabValue | undefined, HysTabValue | undefined>;
+    pending: import("vue").Ref<boolean, boolean>;
+    closing: import("vue").Reactive<Set<HysTabValue>>;
+    recent: import("vue").ShallowRef<HysTabValue[], HysTabValue[]>;
+    closed: import("vue").ShallowRef<ClosedTab[], ClosedTab[]>;
+    select: (value: HysTabValue, source?: HysTabSource) => Promise<boolean>;
+    add: (item?: HysTabItem) => Promise<boolean>;
+    write: (items: HysTabItem[]) => void;
+    canClose: (item: HysTabItem | undefined) => boolean;
+    canMove: (item: HysTabItem | undefined) => boolean;
+    canEdit: () => boolean;
+    rename: (value: HysTabValue, name: string) => Promise<boolean>;
+    pin: (value: HysTabValue, pinned?: boolean) => Promise<boolean>;
+    favorite: (value: HysTabValue, favorite?: boolean) => Promise<boolean>;
+    move: (value: HysTabValue, target: HysTabValue, after?: boolean) => Promise<boolean>;
+    restore: () => Promise<boolean>;
+    closeMany: (scope: HysTabCloseScope | readonly HysTabValue[], anchor?: HysTabValue) => Promise<HysTabValue[]>;
+    close: (value?: HysTabValue) => Promise<boolean>;
+};
+export {};

package/dist/types/components/HysTagInput/HysTagInput.vue.d.ts

@@ -25,8 +25,8 @@ declare const __VLS_base: import("vue").DefineComponent<HysTagInputProps, {
     invalid: (info: HysTagInputInvalid) => any;
     reject: (value: string) => any;
     remove: (value: string) => any;
-    acceptedChange: (values: string[]) => any;
     reorder: (from: number, to: number, values: string[]) => any;
+    acceptedChange: (values: string[]) => any;
 }, string, import("vue").PublicProps, Readonly<HysTagInputProps> & Readonly<{
     onChange?: ((values: string[]) => any) | undefined;
     "onUpdate:modelValue"?: ((values: string[]) => any) | undefined;
@@ -39,8 +39,8 @@ declare const __VLS_base: import("vue").DefineComponent<HysTagInputProps, {
     onInvalid?: ((info: HysTagInputInvalid) => any) | undefined;
     onReject?: ((value: string) => any) | undefined;
     onRemove?: ((value: string) => any) | undefined;
-    onAcceptedChange?: ((values: string[]) => any) | undefined;
     onReorder?: ((from: number, to: number, values: string[]) => any) | undefined;
+    onAcceptedChange?: ((values: string[]) => any) | undefined;
 }>, {
     modelValue: readonly string[];
     trim: boolean;

package/dist/types/components/HysToast/toastPresentation.d.ts

@@ -1,7 +1,7 @@
 import type { CSSProperties } from "vue";
 import type { HysToastLocale, HysToastPosition, HysToastPresentation } from "./toastTypes";
 export declare const toastLocale: HysToastLocale;
-export declare function normalizeToastPosition(position?: HysToastPosition): "center" | "top-right" | "top-left" | "bottom-right" | "bottom-left" | "top-center" | "bottom-center" | "custom";
+export declare function normalizeToastPosition(position?: HysToastPosition): "center" | "top-right" | "top-left" | "bottom-right" | "bottom-left" | "custom" | "top-center" | "bottom-center";
 export declare const finite: (value: number | undefined, fallback: number) => number;
 export declare const toastDuration: (options: HysToastPresentation) => number;
 export declare function toastPlacement(options: HysToastPresentation): CSSProperties;

package/dist/types/components/HysVirtualTable/HysVirtualTable.vue.d.ts

@@ -5,11 +5,11 @@ declare const __VLS_export: <T extends object = Record<string, unknown>>(__VLS_p
         onSelectionChange?: ((keys: HysVirtualTableKey[], rows: T[]) => any) | undefined;
         onRowClick?: ((row: T, index: number, event: MouseEvent) => any) | undefined;
         "onUpdate:selectedRowKeys"?: ((keys: HysVirtualTableKey[]) => any) | undefined;
-        onSortChange?: ((sort: HysVirtualTableSort | null) => any) | undefined;
         "onUpdate:currentRowKey"?: ((key: HysVirtualTableKey | null) => any) | undefined;
         onCurrentChange?: ((row: T | null, key: HysVirtualTableKey | null) => any) | undefined;
         onRowDblclick?: ((row: T, index: number, event: MouseEvent) => any) | undefined;
         onCellClick?: ((context: HysVirtualTableCell<T>, event: MouseEvent) => any) | undefined;
+        onSortChange?: ((sort: HysVirtualTableSort | null) => any) | undefined;
         "onUpdate:sortState"?: ((sort: HysVirtualTableSort | null) => any) | undefined;
         onRangeChange?: ((range: HysVirtualTableRange) => any) | undefined;
         onEndReached?: ((info: {
@@ -60,7 +60,7 @@ declare const __VLS_export: <T extends object = Record<string, unknown>>(__VLS_p
             selectedRowKeys: HysVirtualTableKey[];
         }): any;
     };
-    emit: ((evt: "scroll", state: HysVirtualTableScroll) => void) & ((evt: "selectionChange", keys: HysVirtualTableKey[], rows: T[]) => void) & ((evt: "rowClick", row: T, index: number, event: MouseEvent) => void) & ((evt: "update:selectedRowKeys", keys: HysVirtualTableKey[]) => void) & ((evt: "sortChange", sort: HysVirtualTableSort | null) => void) & ((evt: "update:currentRowKey", key: HysVirtualTableKey | null) => void) & ((evt: "currentChange", row: T | null, key: HysVirtualTableKey | null) => void) & ((evt: "rowDblclick", row: T, index: number, event: MouseEvent) => void) & ((evt: "cellClick", context: HysVirtualTableCell<T>, event: MouseEvent) => void) & ((evt: "update:sortState", sort: HysVirtualTableSort | null) => void) & ((evt: "rangeChange", range: HysVirtualTableRange) => void) & ((evt: "endReached", info: {
+    emit: ((evt: "scroll", state: HysVirtualTableScroll) => void) & ((evt: "selectionChange", keys: HysVirtualTableKey[], rows: T[]) => void) & ((evt: "rowClick", row: T, index: number, event: MouseEvent) => void) & ((evt: "update:selectedRowKeys", keys: HysVirtualTableKey[]) => void) & ((evt: "update:currentRowKey", key: HysVirtualTableKey | null) => void) & ((evt: "currentChange", row: T | null, key: HysVirtualTableKey | null) => void) & ((evt: "rowDblclick", row: T, index: number, event: MouseEvent) => void) & ((evt: "cellClick", context: HysVirtualTableCell<T>, event: MouseEvent) => void) & ((evt: "sortChange", sort: HysVirtualTableSort | null) => void) & ((evt: "update:sortState", sort: HysVirtualTableSort | null) => void) & ((evt: "rangeChange", range: HysVirtualTableRange) => void) & ((evt: "endReached", info: {
         distance: number;
         total: number;
     }) => void);

package/dist/types/composables/dataGrid.d.ts

@@ -1,4 +1,6 @@
 import type { HysPopupMotionProps } from "../motion/popup";
+import type { HysDataGridColumnLayout, HysDataGridColumnLayoutSnapshot } from "../components/HysDataGrid/gridColumnLayout";
+import type { HysDataGridCellContext, HysDataGridClass, HysDataGridContextMenu, HysDataGridHeaderContext, HysDataGridHeaderGroup, HysDataGridPin, HysDataGridRowContext, HysDataGridStyle } from "../components/HysDataGrid/gridPresentation";
 export type HysDataGridKey = string | number;
 export type HysDataGridSort = {
     key: string;
@@ -26,7 +28,11 @@ export interface GridColumn<T extends object = Record<string, unknown>> {
     resizable?: boolean;
     reorderable?: boolean;
     pinned?: "left" | "right";
+    pinnable?: boolean;
     align?: "left" | "center" | "right";
+    headerAlign?: "left" | "center" | "right";
+    headerWrap?: boolean;
+    group?: HysDataGridHeaderGroup;
     summary?: "sum" | "avg" | "min" | "max" | "count";
     editable?: boolean;
 }
@@ -64,14 +70,35 @@ export interface HysDataGridProps<T extends object> extends HysPopupMotionProps
     maxHeight?: number | string;
     scrollToTopOnQuery?: boolean;
     groupable?: boolean;
+    groupBy?: string;
+    defaultGroupBy?: string;
+    groupSummary?: boolean;
     showSummary?: boolean;
+    summaryScope?: "filtered" | "page" | "selected";
     summaryMethod?: (column: GridColumn<T>, rows: readonly T[]) => string | number;
     treeMode?: boolean;
     parentKey?: string;
     editable?: boolean;
+    keyboardNavigation?: boolean;
+    caption?: string;
+    striped?: boolean;
+    highlightCurrentRow?: boolean;
+    currentRowKey?: HysDataGridKey | null;
+    defaultCurrentRowKey?: HysDataGridKey;
+    rowClassName?: HysDataGridClass<HysDataGridRowContext<T>>;
+    rowStyle?: HysDataGridStyle<HysDataGridRowContext<T>>;
+    cellClassName?: HysDataGridClass<HysDataGridCellContext<T>>;
+    cellStyle?: HysDataGridStyle<HysDataGridCellContext<T>>;
+    headerClassName?: HysDataGridClass<HysDataGridHeaderContext<T>>;
+    headerStyle?: HysDataGridStyle<HysDataGridHeaderContext<T>>;
+    contextMenu?: HysDataGridContextMenu<T>;
 }
 export interface HysDataGridInstance {
     resetColumns(): void;
+    getColumnLayout(): HysDataGridColumnLayoutSnapshot;
+    applyColumnLayout(layout: HysDataGridColumnLayout): void;
+    setGroupBy(key: string): void;
+    setGroupsExpanded(expanded: boolean): void;
     getQuery(): HysDataGridQuery;
     setQuery(query: Partial<HysDataGridQuery>): void;
     resetQuery(): void;
@@ -81,6 +108,13 @@ export interface HysDataGridInstance {
     toggleRowSelection(key: HysDataGridKey, checked?: boolean): void;
     scrollTo(options: ScrollToOptions): void;
     scrollToRow(key: HysDataGridKey): boolean;
+    focusRow(key: HysDataGridKey): boolean;
+    getCurrentRowKey(): HysDataGridKey | null;
+    setCurrentRow(key: HysDataGridKey | null): void;
+    setColumnVisibility(key: string, visible: boolean): boolean;
+    pinColumn(key: string, side: HysDataGridPin | null): boolean;
+    resizeColumn(key: string, width: number): boolean;
+    resetColumnWidth(key: string): boolean;
 }
 export type GridRow<T extends object> = {
     row: T;

package/dist/types/composables/datePicker.d.ts

@@ -1,218 +1,16 @@
-import type { HysPopupTransition } from '../motion/popup';
-import type { CSSProperties } from "vue";
-import type { Placement } from "./useFloating";
-export type HysDateScalar = string | Date | number;
-export type HysDatePickerValue = HysDateScalar | readonly (HysDateScalar | null)[] | null;
-export type HysDateRangeValue = readonly [HysDateScalar | null, HysDateScalar | null] | null;
-export type HysDatePickerType = "date" | "dates" | "week" | "weeks" | "month" | "months" | "quarter" | "quarters" | "year" | "years" | "datetime";
-export type HysDatePickerView = "date" | "month" | "quarter" | "year";
-export type HysDatePickerUnit = "date" | "week" | "month" | "quarter" | "year";
-export interface HysDatePoint {
-    day: number;
-    second: number;
-}
-export interface HysDatePickerContext {
-    range: "start" | "end";
-    from: Date | null;
-    iso: string;
-}
-export interface HysDateDisabledTime {
-    hours?: readonly number[];
-    minutes?: (hour: number) => readonly number[];
-    seconds?: (hour: number, minute: number) => readonly number[];
-}
-export interface HysDateShortcut {
-    label: string;
-    value: HysDatePickerValue | (() => HysDatePickerValue);
-    disabled?: boolean;
-}
-export interface HysDatePickerCell {
-    date: Date;
-    iso: string;
-    value: number;
-    end: number;
-    text: string;
-    type: HysDatePickerView;
-    outside: boolean;
-    disabled: boolean;
-    selected: boolean;
-    inRange: boolean;
-    today: boolean;
-    week: number;
-    weekYear: number;
-    weekStart: string;
-    weekEnd: string;
-}
-export interface HysDatePickerWeek {
-    year: number;
-    week: number;
-    start: string;
-    end: string;
-    dates: readonly string[];
-}
-export interface HysDatePickerChange {
-    source: "date" | "time" | "input" | "shortcut" | "clear" | "confirm" | "api";
-    dates: readonly (Date | null)[];
-    formatted: readonly string[];
-    weeks?: readonly (HysDatePickerWeek | null)[];
-}
-export interface HysDatePickerLocale {
-    today: string;
-    now: string;
-    clear: string;
-    cancel: string;
-    close: string;
-    confirm: string;
-    start: string;
-    end: string;
-    chooseStart: string;
-    chooseEnd: string;
-    invalid: string;
-    week: string;
-    year: string;
-    month: string;
-    back: string;
-    prevMonth: string;
-    nextMonth: string;
-    prevYear: string;
-    nextYear: string;
-    hour: string;
-    minute: string;
-    second: string;
-    empty: string;
-    limit: string;
-}
-export interface HysDatePickerProps<V extends HysDatePickerValue = HysDatePickerValue> {
-    popupTransition?: HysPopupTransition;
-    popupTransitionDuration?: number;
-    modelValue?: V;
-    defaultValue?: V;
-    clearValue?: V;
-    type?: HysDatePickerType;
-    valueType?: "string" | "date" | "timestamp";
-    valueFormat?: string;
-    format?: string;
-    inputFormats?: readonly string[];
-    disabled?: boolean | readonly [boolean, boolean];
-    readonly?: boolean;
-    size?: "sm" | "md" | "lg";
-    status?: "error" | "warning" | "success";
-    bordered?: boolean;
-    placeholder?: string;
-    label?: string;
-    ariaLabel?: string;
-    name?: string | readonly [string, string];
-    form?: string;
-    autofocus?: boolean;
-    min?: HysDateScalar;
-    max?: HysDateScalar;
-    disabledDate?: (date: Date, context: HysDatePickerContext) => boolean;
-    disabledTime?: (date: Date, context: HysDatePickerContext) => HysDateDisabledTime;
-    firstDayOfWeek?: number;
-    firstWeekContainsDate?: number;
-    weekNumberFormatter?: (week: HysDatePickerWeek) => string;
-    disabledWeek?: (week: HysDatePickerWeek) => boolean;
-    weekValidation?: "any" | "full";
-    locale?: string;
-    messages?: Partial<HysDatePickerLocale>;
-    showWeekNumbers?: boolean;
-    showAdjacentDays?: boolean;
-    defaultPickerValue?: HysDateScalar;
-    panelValue?: HysDateScalar;
-    mode?: HysDatePickerView;
-    defaultMode?: HysDatePickerView;
-    shortcuts?: readonly HysDateShortcut[];
-    clearable?: boolean;
-    editable?: boolean;
-    inputReadonly?: boolean;
-    showOnFocus?: boolean;
-    showToday?: boolean;
-    showNow?: boolean;
-    showFooter?: boolean;
-    showConfirm?: boolean;
-    showTime?: boolean;
-    defaultTime?: string | readonly [string, string];
-    hourStep?: number;
-    minuteStep?: number;
-    secondStep?: number;
-    showSeconds?: boolean;
-    rangeSeparator?: string;
-    startPlaceholder?: string;
-    endPlaceholder?: string;
-    allowEmpty?: readonly [boolean, boolean];
-    singlePanel?: boolean;
-    unlinkPanels?: boolean;
-    minRangeDays?: number;
-    maxRangeDays?: number;
-    rangeValidation?: "endpoints" | "continuous";
-    maxDates?: number;
-    open?: boolean;
-    defaultOpen?: boolean;
-    inline?: boolean;
-    placement?: Placement;
-    appendTo?: string | HTMLElement | false;
-    popupWidth?: number | string;
-    popupClass?: string;
-    popupStyle?: CSSProperties;
-    validateEvent?: boolean;
-    cellClassName?: (cell: HysDatePickerCell) => string;
-}
-export interface HysDateRangePickerProps<V extends HysDatePickerValue = HysDateRangeValue> extends HysDatePickerProps<V> {
-}
-export interface HysDatePickerInstance<V extends HysDatePickerValue = HysDatePickerValue> {
-    readonly element: HTMLElement | undefined;
-    readonly open: boolean;
-    readonly value: V;
-    readonly draft: readonly (Date | null)[];
-    focus: () => void;
-    blur: () => void;
-    show: () => Promise<boolean>;
-    hide: (restoreFocus?: boolean) => void;
-    handleOpen: () => Promise<boolean>;
-    handleClose: () => void;
-    clear: () => Promise<boolean>;
-    setValue: (value: V) => Promise<boolean>;
-    confirm: () => Promise<boolean>;
-    cancel: () => void;
-    showMonth: (value: HysDateScalar) => Promise<boolean>;
-    setMode: (view: HysDatePickerView) => boolean;
-}
-export interface HysDatePickerSlots {
-    "week-number"?: (week: HysDatePickerWeek & {
-        selected: boolean;
-        disabled: boolean;
-    }) => any;
-    default?: (cell: HysDatePickerCell) => any;
-    cell?: (cell: HysDatePickerCell) => any;
-    prefix?: () => any;
-    suffix?: () => any;
-    "clear-icon"?: () => any;
-    "prev-month"?: () => any;
-    "next-month"?: () => any;
-    "prev-year"?: () => any;
-    "next-year"?: () => any;
-    header?: (context: {
-        dates: readonly (Date | null)[];
-        view: HysDatePickerView;
-    }) => any;
-    footer?: (context: {
-        dates: readonly (Date | null)[];
-        confirm: () => Promise<boolean>;
-        cancel: () => void;
-        clear: () => Promise<boolean>;
-    }) => any;
-    shortcut?: (context: {
-        shortcut: HysDateShortcut;
-        index: number;
-    }) => any;
-    "range-separator"?: () => any;
-}
-export type HysDateRangePickerInstance<V extends HysDatePickerValue = HysDateRangeValue> = HysDatePickerInstance<V>;
+import type { HysDatePickerLocale, HysDatePickerUnit, HysDatePickerValue, HysDatePickerWeek, HysDatePoint } from "./datePickerTypes";
+export type * from "./datePickerTypes";
 export declare const datePickerDefaults: {
     readonly open: undefined;
     readonly showConfirm: undefined;
     readonly type: "date";
     readonly clearable: false;
+    readonly allowClear: undefined;
+    readonly automaticDropdown: undefined;
+    readonly showWeekNumber: undefined;
+    readonly use12Hours: undefined;
+    readonly hideDisabledOptions: undefined;
+    readonly teleported: undefined;
     readonly editable: false;
     readonly bordered: true;
     readonly firstDayOfWeek: 1;
@@ -234,15 +32,17 @@ export declare const datePickerDefaults: {
 export declare const datePickerWords: HysDatePickerLocale;
 export declare const datePickerEnglish: HysDatePickerLocale;
 export declare const DATE_MIN: number, DATE_MAX: number;
-export declare const dateUnit: (type: string | undefined) => HysDatePickerUnit;
+export declare const dateRange: (type: string | undefined) => boolean;
+export declare function dateUnit(type: string | undefined): HysDatePickerUnit;
 export declare const dateMultiple: (type: string | undefined) => boolean;
 export declare function datePattern(type: string | undefined, time?: boolean): "YYYY-MM-DD" | "YYYY" | "YYYY-MM-DD HH:mm:ss" | "YYYY-MM" | "YYYY-[Q]Q";
 export declare function datePeriod(day: number, unit: HysDatePickerUnit, first?: number): [number, number];
 export declare function dateTimeString(second: number): string;
-export declare function dateTimeSeconds(value: string | undefined): number;
+export declare function dateTimeSeconds(value: string | Date | undefined): number;
 export declare function dateWeek(day: number, first?: number, contains?: number): HysDatePickerWeek;
-export declare function dateFormat(point: HysDatePoint, pattern: string, first?: number, contains?: number): string;
-export declare function datePoint(value: unknown, pattern?: string, first?: number, contains?: number): HysDatePoint | undefined;
+export declare function dateFormat(point: HysDatePoint, pattern: string, first?: number, contains?: number, locale?: string): string;
+export declare function datePoint(value: unknown, pattern?: string, first?: number, contains?: number, locale?: string): HysDatePoint | undefined;
+export declare function dateClockPoint(value: string, format: string): HysDatePoint | undefined;
 export declare function dateNative(point: HysDatePoint): Date;
 export declare function dateEqual(a: HysDatePickerValue | undefined, b: HysDatePickerValue | undefined): boolean;
 export declare function dateClone<V extends HysDatePickerValue>(value: V): V;

package/dist/types/composables/datePickerModel.d.ts

@@ -0,0 +1,63 @@
+import { type ComputedRef } from "vue";
+import { type HysDateDisplayFormat, type HysDatePickerProps, type HysDatePickerValue, type HysDatePoint } from "./datePicker";
+export declare function useDatePickerModel(props: HysDatePickerProps, range: ComputedRef<boolean>): {
+    time: ComputedRef<boolean>;
+    rangeDefaultTime: ComputedRef<boolean>;
+    unit: ComputedRef<import("./datePickerTypes").HysDatePickerUnit>;
+    multiple: ComputedRef<boolean>;
+    first: ComputedRef<number>;
+    weekContains: ComputedRef<number>;
+    pattern: ComputedRef<string>;
+    displayPattern: ComputedRef<HysDateDisplayFormat>;
+    words: ComputedRef<{
+        today: string;
+        now: string;
+        clear: string;
+        cancel: string;
+        close: string;
+        confirm: string;
+        start: string;
+        end: string;
+        chooseStart: string;
+        chooseEnd: string;
+        invalid: string;
+        week: string;
+        year: string;
+        month: string;
+        back: string;
+        prevMonth: string;
+        nextMonth: string;
+        prevYear: string;
+        nextYear: string;
+        hour: string;
+        minute: string;
+        second: string;
+        empty: string;
+        limit: string;
+    }>;
+    model: {
+        current: ComputedRef<HysDatePickerValue>;
+        commit: (value: HysDatePickerValue, update: (value: HysDatePickerValue) => void, change: (value: HysDatePickerValue) => void, notifyOnRequest?: boolean) => Promise<boolean>;
+        reset: () => void;
+        invalidate: () => void;
+        isLive: () => boolean;
+    };
+    current: ComputedRef<HysDatePickerValue>;
+    outputType: ComputedRef<"string" | "date" | "timestamp">;
+    parse: (value: unknown) => HysDatePoint | undefined;
+    boundary: (value: unknown) => HysDatePoint | undefined;
+    normalize: (point: HysDatePoint) => {
+        day: number;
+        second: number;
+    };
+    isEmpty: (value: HysDatePickerValue | undefined) => boolean;
+    points: (value?: HysDatePickerValue | undefined) => (HysDatePoint | null)[];
+    selected: ComputedRef<(HysDatePoint | null)[]>;
+    minPoint: ComputedRef<HysDatePoint | undefined>;
+    maxPoint: ComputedRef<HysDatePoint | undefined>;
+    encodePoint: (point: HysDatePoint) => string | number | Date;
+    encode: (list: readonly (HysDatePoint | null)[]) => HysDatePickerValue;
+    empty: () => HysDatePickerValue;
+    describe: (list?: (HysDatePoint | null)[]) => string[];
+    markClear: (value: HysDatePickerValue) => void;
+};

package/dist/types/composables/datePickerPanels.d.ts

@@ -0,0 +1,23 @@
+import { type Ref } from "vue";
+import { type HysDatePickerProps, type HysDatePickerUnit, type HysDatePickerView, type HysDatePoint } from "./datePicker";
+interface DatePickerPanels {
+    props: HysDatePickerProps;
+    unit: Readonly<Ref<HysDatePickerUnit>>;
+    range: Readonly<Ref<boolean>>;
+    time: Readonly<Ref<boolean>>;
+    selected: Readonly<Ref<readonly (HysDatePoint | null)[]>>;
+    minPoint: Readonly<Ref<HysDatePoint | undefined>>;
+    maxPoint: Readonly<Ref<HysDatePoint | undefined>>;
+    boundary: (value: unknown) => HysDatePoint | undefined;
+    encodePoint: (point: HysDatePoint) => string | number | Date;
+    emit: (name: string, ...args: any[]) => void;
+}
+export declare function useDatePickerPanels({ props, unit, range, time, selected, minPoint, maxPoint, boundary, encodePoint, emit, }: DatePickerPanels): {
+    currentView: import("vue").ComputedRef<HysDatePickerView>;
+    rightView: Ref<HysDatePickerView, HysDatePickerView>;
+    panels: import("vue").ComputedRef<number[]>;
+    resetPanels: (today: number) => void;
+    setPanel: (day: number, index?: number) => boolean;
+    setMode: (mode: HysDatePickerView, index?: number) => boolean;
+};
+export {};