hys-ui 0.6.0 → 0.8.0

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

@@ -0,0 +1,31 @@
+import type { Ref } from "vue";
+import { type HysDatePickerContext, type HysDatePickerProps, type HysDatePickerUnit, type HysDatePoint } from "./datePicker";
+interface DatePickerRules {
+    props: HysDatePickerProps;
+    range: Readonly<Ref<boolean>>;
+    multiple: Readonly<Ref<boolean>>;
+    time: Readonly<Ref<boolean>>;
+    unit: Readonly<Ref<HysDatePickerUnit>>;
+    first: Readonly<Ref<number>>;
+    weekContains: Readonly<Ref<number>>;
+    selected: Readonly<Ref<readonly (HysDatePoint | null)[]>>;
+    draft: Readonly<Ref<readonly (HysDatePoint | null)[]>>;
+    stage: Readonly<Ref<"start" | "end">>;
+    minPoint: Readonly<Ref<HysDatePoint | undefined>>;
+    maxPoint: Readonly<Ref<HysDatePoint | undefined>>;
+}
+export declare function useDatePickerRules({ props, range, multiple, time, unit, first, weekContains, selected, draft, stage, minPoint, maxPoint, }: DatePickerRules): {
+    context: (day: number, endpoint: number, from?: HysDatePoint | null) => HysDatePickerContext;
+    locked: (endpoint: number) => boolean;
+    available: (day: number, endpoint?: number, rangeLimit?: boolean, from?: HysDatePoint | null) => boolean;
+    periodAvailable: (start: number, end: number, endpoint?: number, rangeLimit?: boolean, fromPoint?: HysDatePoint | null) => boolean;
+    timeDisabled: (point: HysDatePoint, endpoint: number, from?: HysDatePoint | null) => {
+        hours: number[];
+        minutes: (hour: number) => number[];
+        seconds: (hour: number, minute: number) => number[];
+    };
+    validTime: (point: HysDatePoint, endpoint: number, from?: HysDatePoint | null) => boolean;
+    valid: (list: readonly (HysDatePoint | null)[], enforceLocks?: boolean) => boolean;
+    samePoint: (a: HysDatePoint | null | undefined, b: HysDatePoint | null | undefined) => boolean;
+};
+export {};

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

@@ -0,0 +1,277 @@
+import type { HysPopupTransition } from "../motion/popup";
+import type { Component, 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" | "daterange" | "weekrange" | "monthrange" | "quarterrange" | "yearrange" | "datetimerange";
+export type HysDatePickerView = "date" | "month" | "quarter" | "year" | "decade" | "time";
+export type HysDatePickerUnit = "date" | "week" | "month" | "quarter" | "year";
+export type HysDateDisplayFormat = string | ((date: Date) => string);
+export type HysDatePanelValues = readonly [HysDateScalar, HysDateScalar];
+export type HysDateDefaultTime = string | Date;
+export interface HysDateTimeOptions {
+    defaultValue?: HysDateDefaultTime | readonly [HysDateDefaultTime, HysDateDefaultTime];
+    format?: string;
+    use12Hours?: boolean;
+    hourStep?: number;
+    minuteStep?: number;
+    secondStep?: number;
+    hideDisabledOptions?: boolean;
+}
+export interface HysDatePopupOptions {
+    strategy?: "fixed" | "absolute";
+    offset?: number;
+    padding?: number;
+    flip?: boolean;
+}
+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[];
+    disabledHours?: () => readonly number[];
+    disabledMinutes?: (hour: number) => readonly number[];
+    disabledSeconds?: (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;
+    range?: "start" | "end";
+    rangeStart?: boolean;
+    rangeEnd?: boolean;
+    row?: number;
+    column?: number;
+}
+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 HysDateCalendarChange {
+    range: "start" | "end";
+    dates: readonly (Date | null)[];
+    formatted: readonly string[];
+}
+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;
+    value?: V;
+    defaultValue?: V;
+    clearValue?: V;
+    emptyValues?: readonly HysDatePickerValue[];
+    valueOnClear?: V | (() => V);
+    type?: HysDatePickerType;
+    picker?: HysDatePickerUnit;
+    valueType?: "string" | "date" | "timestamp";
+    valueFormat?: string;
+    format?: HysDateDisplayFormat | readonly HysDateDisplayFormat[];
+    inputFormats?: readonly string[];
+    disabled?: boolean | readonly [boolean, boolean];
+    readonly?: boolean;
+    size?: "sm" | "md" | "lg";
+    status?: "error" | "warning" | "success";
+    bordered?: boolean;
+    placeholder?: string | readonly [string, string];
+    id?: string | readonly [string, 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;
+    disabledHours?: (range: "start" | "end", from: Date | null) => readonly number[];
+    disabledMinutes?: (hour: number, range: "start" | "end", from: Date | null) => readonly number[];
+    disabledSeconds?: (hour: number, minute: number, range: "start" | "end", from: Date | null) => readonly number[];
+    firstDayOfWeek?: number;
+    firstWeekContainsDate?: number;
+    weekNumberFormatter?: (week: HysDatePickerWeek) => string;
+    disabledWeek?: (week: HysDatePickerWeek) => boolean;
+    weekValidation?: "any" | "full";
+    locale?: string;
+    messages?: Partial<HysDatePickerLocale>;
+    showWeekNumbers?: boolean;
+    showWeekNumber?: boolean;
+    showAdjacentDays?: boolean;
+    defaultPickerValue?: HysDateScalar | HysDatePanelValues;
+    panelValue?: HysDateScalar;
+    panelValues?: HysDatePanelValues;
+    mode?: HysDatePickerView;
+    defaultMode?: HysDatePickerView;
+    shortcuts?: readonly HysDateShortcut[];
+    presets?: readonly HysDateShortcut[];
+    ranges?: Readonly<Record<string, HysDateShortcut["value"]>>;
+    shortcutPlacement?: "top" | "start";
+    clearable?: boolean;
+    allowClear?: boolean;
+    editable?: boolean;
+    inputReadonly?: boolean;
+    showOnFocus?: boolean;
+    automaticDropdown?: boolean;
+    showToday?: boolean;
+    showNow?: boolean;
+    showFooter?: boolean;
+    showConfirm?: boolean;
+    showTime?: boolean | HysDateTimeOptions;
+    defaultTime?: HysDateDefaultTime | readonly [HysDateDefaultTime, HysDateDefaultTime];
+    dateFormat?: string;
+    timeFormat?: string;
+    use12Hours?: boolean;
+    hideDisabledOptions?: boolean;
+    arrowControl?: boolean;
+    hourStep?: number;
+    minuteStep?: number;
+    secondStep?: number;
+    showSeconds?: boolean;
+    rangeSeparator?: string;
+    separator?: 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 | "topLeft" | "topRight" | "bottomLeft" | "bottomRight";
+    appendTo?: string | HTMLElement | false;
+    teleported?: boolean;
+    getPopupContainer?: (trigger: HTMLElement) => HTMLElement;
+    fallbackPlacements?: readonly Placement[];
+    popperOptions?: HysDatePopupOptions;
+    popupWidth?: number | string;
+    popupClass?: string;
+    popupClassName?: string;
+    popperClass?: string;
+    popupStyle?: CSSProperties;
+    popperStyle?: CSSProperties | string;
+    prefixIcon?: Component | string;
+    clearIcon?: Component | string;
+    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;
+    "extra-footer"?: (context: {
+        dates: readonly (Date | null)[];
+        view: HysDatePickerView;
+    }) => any;
+    "date-render"?: (cell: HysDatePickerCell) => any;
+    "month-cell-render"?: (cell: HysDatePickerCell) => 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>;

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

@@ -5,7 +5,7 @@ export declare function positionFloating(anchor: DOMRect, size: {
 }, viewport: {
     width: number;
     height: number;
-}, placement: Placement, gap: number, padding: number, flip: boolean): {
+}, placement: Placement, gap: number, padding: number, flip: boolean, fallbackPlacements?: readonly Placement[]): {
     width: number;
     height: number;
     x: number;

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

@@ -1,4 +1,4 @@
-import { type Ref } from "vue";
+export { useContainerWidth as useFormWidth } from "./useContainerWidth";
 export type HysFormBreakpoint = "xs" | "sm" | "md" | "lg" | "xl" | "xxl";
 export type HysFormGridValue = number | Partial<Record<HysFormBreakpoint, number>>;
 export interface HysFormColSize {
@@ -8,4 +8,3 @@ export interface HysFormColSize {
 export type HysFormCol = HysFormColSize & Partial<Record<HysFormBreakpoint, number | HysFormColSize>>;
 export declare function resolveFormGrid(value: HysFormGridValue | undefined, width: number, fallback?: number): number;
 export declare function resolveFormCol(value: HysFormCol | undefined, width: number): HysFormColSize | undefined;
-export declare function useFormWidth(element: Ref<HTMLElement | undefined>): import("vue").ComputedRef<number>;

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

@@ -0,0 +1,7 @@
+import { type CSSProperties, type Ref } from "vue";
+import type { HysPopupSurfaceProps } from "./popupSurface";
+export declare function popupMaximumWidth(props: HysPopupSurfaceProps, kind: "tooltip" | "popover"): string;
+export declare function usePopupSurfaceStyle(props: HysPopupSurfaceProps, kind: "tooltip" | "popover", floatingStyle: Readonly<Ref<CSSProperties>>): {
+    style: import("vue").ComputedRef<CSSProperties>;
+    contentStyle: import("vue").ComputedRef<CSSProperties>;
+};

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

@@ -181,11 +181,12 @@ export interface HysTablePagination {
     hideOnSinglePage?: boolean;
 }
 export interface HysTableQuery<T extends object = Record<string, unknown>> {
-    action: "sort" | "filter" | "page" | "pageSize";
+    action: "sort" | "filter" | "page" | "pageSize" | "search";
     page: number;
     pageSize: number;
     sorts: HysTableSort[];
     filters: HysTableFilters;
+    search?: string;
     currentData: T[];
 }
 export interface HysTableLoadContext {
@@ -290,6 +291,7 @@ export interface HysTableProps<T extends object> {
     selectionColumn?: HysTableSelectionColumn;
     getSelectionProps?: (row: T, index: number) => HysTableSelectionProps;
     highlightCurrentRow?: boolean;
+    keyboardNavigation?: boolean;
     currentRowKey?: HysTableKey | null;
     defaultCurrentRowKey?: HysTableKey;
     showIndex?: boolean;
@@ -303,6 +305,10 @@ export interface HysTableProps<T extends object> {
     showSorterTooltip?: boolean | HysTableOverflowTooltipOptions;
     filters?: HysTableFilters;
     defaultFilters?: HysTableFilters;
+    search?: string;
+    defaultSearch?: string;
+    searchColumns?: readonly string[];
+    searchMethod?: (search: string, row: T) => boolean;
     filterColumnKey?: string | null;
     filterPlacement?: Placement;
     appendFilterTo?: string | HTMLElement | false;
@@ -376,6 +382,9 @@ export interface HysTableInstance<T extends object = Record<string, unknown>> {
     setSort: (sort: HysTableSort | readonly HysTableSort[] | null) => void;
     clearFilter: (keys?: readonly string[]) => void;
     setFilter: (key: string, values: readonly HysTableFilterValue[]) => void;
+    setSearch: (search: string) => void;
+    clearSearch: () => void;
+    focusRow: (row: T | HysTableKey) => boolean;
     showFilter: (key: string) => Promise<boolean>;
     hideFilter: () => Promise<boolean>;
     setPage: (page: number) => void;

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

@@ -41,6 +41,8 @@ export declare function createToastQueue(config: HysToastConfig, host: {
         actions?: readonly import("./useHysToast").HysToastAction[] | undefined;
         closeOnEscape?: boolean | undefined;
         live?: "polite" | "assertive" | "off" | undefined;
+        coordinates?: import("./useHysToast").HysToastCoordinates | undefined;
+        glass?: boolean | undefined;
         swipe?: boolean | undefined;
         persistent?: boolean | undefined;
         closeOnClick?: boolean | undefined;
@@ -50,8 +52,6 @@ export declare function createToastQueue(config: HysToastConfig, host: {
         interactive?: boolean | undefined;
         offsetX?: number | undefined;
         offsetY?: number | undefined;
-        coordinates?: import("./useHysToast").HysToastCoordinates | undefined;
-        glass?: boolean | undefined;
         toastStyle?: import("vue").CSSProperties | undefined;
         progressStyle?: import("vue").CSSProperties | undefined;
         showProgress?: boolean | undefined;
@@ -93,6 +93,8 @@ export declare function createToastQueue(config: HysToastConfig, host: {
         actions?: readonly import("./useHysToast").HysToastAction[] | undefined;
         closeOnEscape?: boolean | undefined;
         live?: "polite" | "assertive" | "off" | undefined;
+        coordinates?: import("./useHysToast").HysToastCoordinates | undefined;
+        glass?: boolean | undefined;
         swipe?: boolean | undefined;
         persistent?: boolean | undefined;
         closeOnClick?: boolean | undefined;
@@ -102,8 +104,6 @@ export declare function createToastQueue(config: HysToastConfig, host: {
         interactive?: boolean | undefined;
         offsetX?: number | undefined;
         offsetY?: number | undefined;
-        coordinates?: import("./useHysToast").HysToastCoordinates | undefined;
-        glass?: boolean | undefined;
         toastStyle?: import("vue").CSSProperties | undefined;
         progressStyle?: import("vue").CSSProperties | undefined;
         showProgress?: boolean | undefined;

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

@@ -93,6 +93,8 @@ export declare function defaults(config: HysToastConfig): {
     actions?: readonly import("./useHysToast").HysToastAction[] | undefined;
     closeOnEscape?: boolean | undefined;
     live?: "polite" | "assertive" | "off" | undefined;
+    coordinates?: import("./useHysToast").HysToastCoordinates | undefined;
+    glass?: boolean | undefined;
     swipe?: boolean | undefined;
     persistent?: boolean | undefined;
     closeOnClick?: boolean | undefined;
@@ -102,8 +104,6 @@ export declare function defaults(config: HysToastConfig): {
     interactive?: boolean | undefined;
     offsetX?: number | undefined;
     offsetY?: number | undefined;
-    coordinates?: import("./useHysToast").HysToastCoordinates | undefined;
-    glass?: boolean | undefined;
     toastStyle?: import("vue").CSSProperties | undefined;
     progressStyle?: import("vue").CSSProperties | undefined;
     showProgress?: boolean | undefined;

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

@@ -38,13 +38,11 @@ export declare function useColorPicker(props: HysColorPickerProps, emit: (name:
     status: import("vue").ComputedRef<import("./formContext").HysFormStatus | undefined>;
     floating: {
         open: import("vue").Ref<boolean, boolean>;
-        style: import("vue").ComputedRef<{
-            zIndex: string;
-        }>;
+        style: import("vue").ComputedRef<Record<string, string>>;
         placement: import("vue").Ref<import("./useFloating").Placement, import("./useFloating").Placement>;
         update: () => void;
         show: (force?: boolean) => Promise<void>;
-        close: (restore?: boolean, force?: boolean) => void;
+        close: (restore?: boolean, force?: boolean, source?: "outside" | "escape" | "anchor") => void;
         toggle: () => void | Promise<void>;
         restoringFocus: import("vue").Ref<boolean, boolean>;
         schedule: () => void;

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

@@ -0,0 +1,2 @@
+import { type Ref } from "vue";
+export declare function useContainerWidth(element: Ref<HTMLElement | undefined>): import("vue").ComputedRef<number>;

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

@@ -38,13 +38,11 @@ export declare function useContextMenu<N extends object>(props: HysContextMenuPr
     childStyles: import("vue").ShallowRef<Record<number, CSSProperties>, Record<number, CSSProperties>>;
     floating: {
         open: Ref<boolean, boolean>;
-        style: import("vue").ComputedRef<{
-            zIndex: string;
-        }>;
+        style: import("vue").ComputedRef<Record<string, string>>;
         placement: Ref<import("./useFloating").Placement, import("./useFloating").Placement>;
         update: () => void;
         show: (force?: boolean) => Promise<void>;
-        close: (restore?: boolean, force?: boolean) => void;
+        close: (restore?: boolean, force?: boolean, source?: "outside" | "escape" | "anchor") => void;
         toggle: () => void | Promise<void>;
         restoringFocus: Ref<boolean, boolean>;
         schedule: () => void;

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

@@ -1,5 +1,5 @@
 import { type ComputedRef } from "vue";
-import { type HysDatePoint, type HysDatePickerProps, type HysDatePickerValue, type HysDatePickerView, type HysDatePickerChange } from "./datePicker";
+import { type HysDatePoint, type HysDatePickerProps, type HysDatePickerValue, type HysDatePickerChange } from "./datePicker";
 export declare function useDatePicker(props: HysDatePickerProps, range: ComputedRef<boolean>, blocked: ComputedRef<boolean>, emit: (name: string, ...args: any[]) => void, validate: () => void): {
     current: ComputedRef<HysDatePickerValue>;
     selected: ComputedRef<(HysDatePoint | null)[]>;
@@ -7,16 +7,16 @@ export declare function useDatePicker(props: HysDatePickerProps, range: Computed
     stage: import("vue").Ref<"end" | "start", "end" | "start">;
     preview: import("vue").Ref<number | undefined, number | undefined>;
     error: import("vue").Ref<string, string>;
-    view: ComputedRef<HysDatePickerView>;
-    rightView: import("vue").Ref<HysDatePickerView, HysDatePickerView>;
+    view: ComputedRef<import("./datePickerTypes").HysDatePickerView>;
+    rightView: import("vue").Ref<import("./datePickerTypes").HysDatePickerView, import("./datePickerTypes").HysDatePickerView>;
     panels: ComputedRef<number[]>;
     first: ComputedRef<number>;
     weekContains: ComputedRef<number>;
     time: ComputedRef<boolean>;
-    unit: ComputedRef<import("./datePicker").HysDatePickerUnit>;
+    unit: ComputedRef<import("./datePickerTypes").HysDatePickerUnit>;
     multiple: ComputedRef<boolean>;
     pattern: ComputedRef<string>;
-    displayPattern: ComputedRef<string>;
+    displayPattern: ComputedRef<import("./datePickerTypes").HysDateDisplayFormat>;
     words: ComputedRef<{
         today: string;
         now: string;
@@ -44,7 +44,7 @@ export declare function useDatePicker(props: HysDatePickerProps, range: Computed
         limit: string;
     }>;
     needsConfirm: ComputedRef<boolean>;
-    today: ComputedRef<HysDatePoint>;
+    today: import("vue").ShallowRef<HysDatePoint, HysDatePoint>;
     model: {
         current: ComputedRef<HysDatePickerValue>;
         commit: (value: HysDatePickerValue, update: (value: HysDatePickerValue) => void, change: (value: HysDatePickerValue) => void, notifyOnRequest?: boolean) => Promise<boolean>;
@@ -56,24 +56,33 @@ export declare function useDatePicker(props: HysDatePickerProps, range: Computed
     parse: (value: unknown) => HysDatePoint | undefined;
     boundary: (value: unknown) => HysDatePoint | undefined;
     points: (value?: HysDatePickerValue | undefined) => (HysDatePoint | null)[];
-    available: (day: number, endpoint?: number, rangeLimit?: boolean) => boolean;
-    periodAvailable: (start: number, end: number, endpoint?: number, rangeLimit?: boolean) => boolean;
-    validTime: (point: HysDatePoint, endpoint: number) => boolean;
+    available: (day: number, endpoint?: number, rangeLimit?: boolean, from?: HysDatePoint | null) => boolean;
+    periodAvailable: (start: number, end: number, endpoint?: number, rangeLimit?: boolean, fromPoint?: HysDatePoint | null) => boolean;
+    validTime: (point: HysDatePoint, endpoint: number, from?: HysDatePoint | null) => boolean;
     valid: (list: readonly (HysDatePoint | null)[], enforceLocks?: boolean) => boolean;
-    timeDisabled: (point: HysDatePoint, endpoint: number) => import("./datePicker").HysDateDisabledTime;
+    timeDisabled: (point: HysDatePoint, endpoint: number, from?: HysDatePoint | null) => {
+        hours: number[];
+        minutes: (hour: number) => number[];
+        seconds: (hour: number, minute: number) => number[];
+    };
     encode: (list: readonly (HysDatePoint | null)[]) => HysDatePickerValue;
     describe: (list?: (HysDatePoint | null)[]) => string[];
     empty: () => HysDatePickerValue;
     request: (value: HysDatePickerValue, source: HysDatePickerChange["source"], allowClear?: boolean) => Promise<boolean>;
     begin: () => void;
     setPanel: (day: number, index?: number) => boolean;
-    setMode: (mode: HysDatePickerView, index?: number) => boolean;
+    setMode: (mode: import("./datePickerTypes").HysDatePickerView, index?: number) => boolean;
     choose: (day: number) => Promise<boolean>;
     clear: () => Promise<boolean>;
     confirm: () => Promise<boolean>;
     setValue: (value: HysDatePickerValue) => Promise<boolean>;
     setTime: (index: number, second: number) => boolean;
+    editDraft: (index: number, text: string, format: string, part: "date" | "time") => boolean;
+    emitDraft: (endpoint: number) => void;
     input: (value: string, index?: number) => Promise<boolean>;
     pickShortcut: (index: number) => boolean;
+    shortcuts: ComputedRef<import("./datePickerTypes").HysDateShortcut[]>;
+    context: (day: number, endpoint: number, from?: HysDatePoint | null) => import("./datePickerTypes").HysDatePickerContext;
+    defaultSecond: (index: number) => number;
     locked: (endpoint: number) => boolean;
 };

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

@@ -21,23 +21,22 @@ export declare function useFloating(anchor: Readonly<Ref<FloatingAnchor | undefi
     matchWidth?: boolean | "min" | (() => boolean | "min");
     width?: () => number | string | undefined;
     maxWidth?: () => number | string | undefined;
-    requestOpen?: (open: boolean, restoreFocus?: boolean) => boolean | void;
+    requestOpen?: (open: boolean, restoreFocus?: boolean, source?: "outside" | "escape" | "anchor") => boolean | void;
     closeOnTab?: boolean;
     closeOnEscape?: boolean;
     closeOnOutside?: boolean;
     autoAdjustOverflow?: boolean;
+    fallbackPlacements?: readonly Placement[];
     strategy?: "fixed" | "absolute";
     zIndex?: () => number | undefined;
     onPosition?: (position: FloatingPosition) => void;
 }): {
     open: Ref<boolean, boolean>;
-    style: import("vue").ComputedRef<{
-        zIndex: string;
-    }>;
+    style: import("vue").ComputedRef<Record<string, string>>;
     placement: Ref<Placement, Placement>;
     update: () => void;
     show: (force?: boolean) => Promise<void>;
-    close: (restore?: boolean, force?: boolean) => void;
+    close: (restore?: boolean, force?: boolean, source?: "outside" | "escape" | "anchor") => void;
     toggle: () => void | Promise<void>;
     restoringFocus: Ref<boolean, boolean>;
     schedule: () => void;

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

@@ -0,0 +1 @@
+export declare function usePageVisibility(): Readonly<import("vue").Ref<boolean, boolean>>;

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

@@ -1,10 +1,16 @@
 import { type CSSProperties, type HTMLAttributes } from "vue";
 import type { HysPopupSurfaceContext, HysPopupSurfaceProps } from "./popupSurface";
-export declare function usePopupSurface(props: HysPopupSurfaceProps, kind: "tooltip" | "popover", emit: (name: string, ...args: any[]) => void): {
+import { type PopupCloseSource } from "./usePopupSurfaceInteractions";
+export declare function usePopupSurface(props: HysPopupSurfaceProps, kind: "tooltip" | "popover", emit: (name: string, ...args: any[]) => void, hooks?: {
+    allowClose?: (source: PopupCloseSource) => boolean;
+    onDismiss?: (source: PopupCloseSource) => void;
+    allowTabExit?: boolean;
+    shouldRestoreFocus?: () => boolean;
+}): {
     afterEnter: () => Promise<void>;
     afterLeave: () => Promise<void>;
     inactive: () => void;
-    request: (value: boolean, restore?: boolean) => Promise<boolean>;
+    request: (value: boolean, restore?: boolean, source?: PopupCloseSource, notifyDismiss?: boolean) => Promise<boolean>;
     show: () => Promise<boolean>;
     hide: () => Promise<boolean>;
     toggle: () => Promise<boolean>;
@@ -32,7 +38,7 @@ export declare function usePopupSurface(props: HysPopupSurfaceProps, kind: "tool
     placement: import("vue").Ref<import("./useFloating").Placement, import("./useFloating").Placement>;
     active: import("vue").ComputedRef<boolean>;
     mounted: import("vue").ComputedRef<boolean>;
-    teleportTo: import("vue").ComputedRef<Element>;
+    teleportTo: import("vue").ComputedRef<string | Element>;
     arrowStyle: import("vue").Ref<{
         [x: `--${string}`]: string | number | undefined;
         accentColor?: import("csstype").Property.AccentColor | undefined;

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

@@ -2,14 +2,16 @@ import { type Ref } from "vue";
 import type { HysPopupSurfaceProps } from "./popupSurface";
 import type { FloatingAnchor, useFloating } from "./useFloating";
 export declare const popupFocusControls = "button,a[href],input,select,textarea,[tabindex]:not([tabindex=\"-1\"]),[contenteditable=\"true\"]";
-export declare function usePopupSurfaceInteractions(props: HysPopupSurfaceProps, kind: "tooltip" | "popover", { available, anchor, actualReference, panel, floating, restoreReferenceFocus, request, }: {
+export type PopupCloseSource = "trigger" | "outside" | "escape" | "tab" | "anchor" | "auto" | "programmatic";
+export declare function usePopupSurfaceInteractions(props: HysPopupSurfaceProps, kind: "tooltip" | "popover", { available, anchor, actualReference, panel, floating, restoreReferenceFocus, request, allowTabExit, }: {
     available: Readonly<Ref<boolean>>;
     anchor: Readonly<Ref<FloatingAnchor | undefined>>;
     actualReference: Readonly<Ref<HTMLElement | undefined>>;
     panel: Readonly<Ref<HTMLElement | undefined>>;
     floating: Pick<ReturnType<typeof useFloating>, "open" | "isTop" | "restoringFocus">;
     restoreReferenceFocus: () => void;
-    request: (open: boolean) => Promise<boolean>;
+    request: (open: boolean, restore?: boolean, source?: PopupCloseSource) => Promise<boolean>;
+    allowTabExit?: boolean;
 }): {
     clearDelays: () => void;
     clearAuto: () => void;

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

@@ -5,10 +5,10 @@ interface DragSettings {
     initial: number;
     constrain: (value: number) => number;
 }
-export declare function useSplitPaneDrag(update: (value: number) => void, ended: (value: number, cancelled: boolean, notify: boolean) => void): {
+export declare function useSplitPaneDrag(update: (value: number) => void, ended: (value: number, cancelled: boolean, notify: boolean, byInput: boolean) => void): {
     start: (event: PointerEvent, settings: DragSettings) => boolean;
     cancel: (event: PointerEvent) => void;
-    finish: (cancelled: boolean, notify?: boolean) => void;
+    finish: (cancelled: boolean, notify?: boolean, byInput?: boolean) => void;
     active: () => boolean;
 };
 export {};

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

@@ -0,0 +1 @@
+export declare function useSvgInstanceId(suffix: string): import("vue").Ref<string, string>;