hys-ui 0.5.0 → 0.6.0

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

@@ -106,6 +106,7 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {
     virtual: boolean;
     overscan: number;
     editable: boolean;
+    history: boolean;
     labelWidth: number;
     rowHeight: number;
     labelResizable: boolean;
@@ -114,7 +115,6 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {
     fitContainer: boolean;
     dependencyEditable: boolean;
     showDependencies: boolean;
-    history: boolean;
     historyLimit: number;
     historyKeyboard: boolean;
     showHistoryControls: boolean;

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

@@ -92,6 +92,7 @@ declare const __VLS_base: import("vue").DefineComponent<HysModalProps, {
     cancelText: string;
     fullscreen: boolean;
     closeOnEscape: boolean;
+    dragThreshold: number;
     initialFocus: import("../../index.js").HysModalInitialFocus;
     closeOnMask: boolean;
     showClose: boolean;
@@ -113,7 +114,6 @@ declare const __VLS_base: import("vue").DefineComponent<HysModalProps, {
     centered: boolean;
     dragHandlePosition: "left" | "right" | "center" | "both";
     dragMode: "preview" | "live";
-    dragThreshold: number;
     dragEffect: import("../../index.js").HysModalDragEffect;
     keepHandleVisible: boolean;
     resetPositionOnClose: boolean;

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

@@ -1,29 +1,52 @@
-type Item = {
-    id: string;
-    label: string;
-};
-type __VLS_Props = {
-    modelValue: Item[];
-    disabled?: boolean;
-};
-declare const __VLS_template: () => {
-    __VLS_Slots: {
-        item?: (props: {
-            item: Item;
-        }) => any;
+import { type VNodeChild } from "vue";
+import type { HysSortChange, HysSortDrag, HysSortFeedback, HysSortItem, HysSortKey, HysSortMoveOptions, HysSortPreview, HysSortRow, HysSortableListProps } from "./sortableList";
+declare const __VLS_export: <T extends object = HysSortItem>(__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<(Omit<HysSortableListProps<T>, "showHandle"> & {
+        showHandle?: boolean;
+    }) & {
+        onChange?: ((change: HysSortChange<T>) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: T[]) => any) | undefined;
+        onStart?: ((drag: HysSortDrag<T>) => any) | undefined;
+        onCancel?: ((feedback: HysSortFeedback<T>) => any) | undefined;
+        onInvalid?: ((feedback: HysSortFeedback<T>) => any) | undefined;
+        "onUpdate:selectedKeys"?: ((keys: HysSortKey[]) => any) | undefined;
+        onConflict?: ((feedback: HysSortFeedback<T>) => any) | undefined;
+        onPreview?: ((preview: HysSortPreview<T> | null) => any) | undefined;
+        "onSave-error"?: ((feedback: HysSortFeedback<T>) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: import("vue").ShallowUnwrapRef<{
+        move: (keys: HysSortKey | readonly HysSortKey[], options: HysSortMoveOptions) => Promise<boolean>;
+        select: (keys: readonly HysSortKey[]) => void;
+        scrollTo: (key: HysSortKey) => Promise<boolean>;
+        focus: (key: HysSortKey) => Promise<boolean>;
+        undo: () => Promise<boolean>;
+        redo: () => Promise<boolean>;
+        reset: () => Promise<boolean>;
+        cancel: () => void;
+    }>) => void;
+    attrs: any;
+    slots: {
+        item?: (row: HysSortRow<T>) => VNodeChild;
+        handle?: (row: HysSortRow<T>) => VNodeChild;
+        preview?: (context: {
+            drag: HysSortDrag<T>;
+            allowed: boolean;
+        }) => VNodeChild;
+        placeholder?: (row: HysSortRow<T>) => VNodeChild;
+        empty?: () => VNodeChild;
+        header?: () => VNodeChild;
+        cells?: (row: HysSortRow<T>) => VNodeChild;
     };
+    emit: ((evt: "change", change: HysSortChange<T>) => void) & ((evt: "update:modelValue", value: T[]) => void) & ((evt: "start", drag: HysSortDrag<T>) => void) & ((evt: "cancel", feedback: HysSortFeedback<T>) => void) & ((evt: "invalid", feedback: HysSortFeedback<T>) => void) & ((evt: "update:selectedKeys", keys: HysSortKey[]) => void) & ((evt: "conflict", feedback: HysSortFeedback<T>) => void) & ((evt: "preview", preview: HysSortPreview<T> | null) => void) & ((evt: "save-error", feedback: HysSortFeedback<T>) => void);
+}>) => import("vue").VNode & {
+    __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
 };
-type __VLS_Slots = ReturnType<typeof __VLS_template>['__VLS_Slots'];
-declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    "update:modelValue": (value: Item[]) => any;
-}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
-    "onUpdate:modelValue"?: ((value: Item[]) => any) | undefined;
-}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
-declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;
 export default _default;
-type __VLS_WithSlots<T, S> = T & {
-    new (): {
-        $slots: S;
-    };
-};
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

package/dist/types/components/HysSortableList/SortableGhost/SortableGhost.vue.d.ts

@@ -0,0 +1,31 @@
+import type { StyleValue } from "vue";
+import type { SortGhost } from "./useSortGhost";
+declare const __VLS_export: <T extends object>(__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<{
+        track: SortGhost<T>;
+        appearance: Record<string, string>;
+        motion: boolean;
+        ghostClass?: string;
+        ghostStyle?: StyleValue;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+        default?: (props: {
+            drag: import("../sortableList").HysSortDrag<T>;
+            allowed: boolean;
+        }) => any;
+    };
+    emit: {};
+}>) => 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/types/components/HysSortableList/SortableGhost/useSortGhost.d.ts

@@ -0,0 +1,23 @@
+import { type Ref } from "vue";
+import type { SortPoint } from "../geometry";
+import type { HysSortDrag } from "../sortableList";
+export interface SortGhost<T extends object> {
+    drag: HysSortDrag<T>;
+    position: Ref<SortPoint>;
+    returning: Ref<boolean>;
+    landing: Ref<{
+        duration: number;
+        easing: string;
+    } | null>;
+    allowed: Ref<boolean>;
+    width: number;
+}
+export declare function useSortGhost<T extends object>(animate: () => boolean, timing: () => {
+    duration: number;
+    easing: string;
+}): {
+    ghost: import("vue").ShallowRef<SortGhost<T> | null, SortGhost<T> | null>;
+    show: (drag: HysSortDrag<T>, row: HTMLElement, point: SortPoint) => void;
+    clear: (rebound: boolean, row?: HTMLElement) => void;
+    release: (commit: (onLanding?: (row?: HTMLElement) => void) => Promise<boolean>, sourceRow: () => HTMLElement | undefined) => Promise<boolean>;
+};

package/dist/types/components/HysSortableList/geometry.d.ts

@@ -0,0 +1,35 @@
+import { type SortCandidate, type SortPort, type SortProposal } from "./model";
+import type { HysSortDrag, HysSortFeedback, HysSortableListProps, HysSortKey, HysSortPosition, HysSortScroll } from "./sortableList";
+export interface SortPoint {
+    x: number;
+    y: number;
+}
+export declare function wholeRowDrag(props: Pick<HysSortableListProps, "handle" | "showHandle">): boolean;
+export declare function hitsSelectableText(element: Element, x: number, y: number): boolean;
+export declare function dropMarkerFor<T extends object>(port: SortPort<T>, candidate: SortCandidate<T>, drag: HysSortDrag<T>, result?: SortProposal<T> | HysSortFeedback<T>): {
+    key?: HysSortKey;
+    position: HysSortPosition;
+};
+export interface SortHit<T extends object> {
+    element: Element | null;
+    rowKey?: string;
+    candidate?: SortCandidate<T>;
+    nearCenter?: boolean;
+    nearEdge?: boolean;
+}
+export declare function withinDragBounds<T extends object>(port: SortPort<T>, point: SortPoint, origin: SortPoint): {
+    point: {
+        x: number;
+        y: number;
+    };
+    inside: boolean;
+};
+export declare function gridColumns(element: HTMLElement | undefined): number;
+export declare function findSortHit<T extends object>(source: SortPort<T>, point: SortPoint): SortHit<T>;
+export declare function keepSortCandidate<T extends object>(source: SortPort<T>, current: SortCandidate<T> | undefined, hit?: SortHit<T>): boolean | undefined;
+export declare function candidateAt<T extends object>(source: SortPort<T>, port: SortPort<T>, index: number): SortCandidate<T>;
+export declare function relativeCandidate<T extends object>(port: SortPort<T>, key: HysSortKey, step: number): SortCandidate<T> | undefined;
+export declare function keyStep<T extends object>(port: SortPort<T>, key: string): number;
+export declare function sameCandidate<T extends object>(a?: SortCandidate<T>, b?: SortCandidate<T>): boolean;
+export declare const tokenOf: (key: HysSortKey) => string;
+export declare function autoScrollSort(element: Element | null, point: SortPoint, option: boolean | HysSortScroll | undefined): boolean;

package/dist/types/components/HysSortableList/model.d.ts

@@ -0,0 +1,61 @@
+import type { HysSortChange, HysSortDrag, HysSortFeedback, HysSortFixed, HysSortGroup, HysSortKey, HysSortOperation, HysSortPosition, HysSortPreview, HysSortProposal, HysSortReason, HysSortSource, HysSortableListProps } from "./sortableList";
+export interface SortIndex<T extends object> {
+    keys: Map<HysSortKey, number>;
+    fixed: {
+        key: HysSortKey;
+        index: number;
+        placement: HysSortFixed;
+    }[];
+    items: readonly T[];
+    valid: boolean;
+}
+export interface SortPort<T extends object> {
+    id: () => string;
+    props: HysSortableListProps<T>;
+    root: () => HTMLElement | undefined;
+    surface: () => HTMLElement | undefined;
+    data: () => SortIndex<T>;
+    key: (item: T) => HysSortKey;
+    label: (item: T) => string;
+    row: (key: HysSortKey) => HTMLElement | undefined;
+    apply: (items: T[]) => void;
+    focus: (key: HysSortKey) => Promise<boolean>;
+    scroll: (key: HysSortKey) => Promise<boolean>;
+    lock: (busy: boolean) => void;
+    start: (drag: HysSortDrag<T>) => void;
+    preview: (preview: HysSortPreview<T> | null) => void;
+    change: (change: HysSortChange<T>) => void;
+    reject: (feedback: HysSortFeedback<T>) => void;
+    announce: (message: string) => void;
+}
+export interface SortCandidate<T extends object> {
+    port: SortPort<T>;
+    index: number;
+    position: HysSortPosition;
+    anchor?: HysSortKey;
+    operation?: HysSortOperation;
+}
+export interface SortProposal<T extends object> {
+    source: SortPort<T>;
+    target: SortPort<T>;
+    proposal: HysSortProposal<T>;
+    changes: {
+        port: SortPort<T>;
+        previous: readonly T[];
+        next: T[];
+    }[];
+}
+export declare function registerSortPort<T extends object>(element: HTMLElement, port: SortPort<T>): () => void;
+export declare const sortPorts: <T extends object>() => SortPort<T>[];
+export declare function portAt<T extends object>(element: Element | null): SortPort<T> | undefined;
+export declare const groupOf: <T extends object>(port: SortPort<T>) => HysSortGroup<T> | undefined;
+export declare function linkedPorts<T extends object>(port: SortPort<T>): SortPort<T>[];
+export declare const keyToken: (key: HysSortKey) => string;
+export declare const layoutOf: (props: Pick<HysSortableListProps, "layout" | "listTag">) => import("./sortableList").HysSortLayout;
+export declare function buildSortIndex<T extends object>(items: readonly T[], keyOf: (item: T) => HysSortKey, fixed: HysSortableListProps<T>["fixed"]): SortIndex<T>;
+export declare function feedback<T extends object>(reason: HysSortReason, proposal?: HysSortProposal<T>, message?: string, error?: unknown): HysSortFeedback<T>;
+export declare function dragIssue<T extends object>(port: SortPort<T>, item: T, index: number): HysSortFeedback<T> | undefined;
+export declare function makeDrag<T extends object>(port: SortPort<T>, keys: readonly HysSortKey[], source: HysSortSource): HysSortDrag<T> | HysSortFeedback<T>;
+export declare function preserved<T extends object>(port: SortPort<T>, next: readonly T[]): boolean;
+export declare const sameItems: <T>(left: readonly T[], right: readonly T[]) => boolean;
+export declare function proposeSort<T extends object>(source: SortPort<T>, drag: HysSortDrag<T>, candidate: SortCandidate<T>, commit?: boolean): SortProposal<T> | HysSortFeedback<T>;

package/dist/types/components/HysSortableList/sortableList.d.ts

@@ -0,0 +1,151 @@
+import type { StyleValue } from "vue";
+export type HysSortKey = string | number;
+export interface HysSortItem {
+    id: HysSortKey;
+    label: string;
+}
+export type HysSortLayout = "vertical" | "horizontal" | "grid";
+export type HysSortMode = "insert" | "swap";
+export type HysSortOperation = "move" | "copy" | "clone";
+export type HysSortPosition = "before" | "after" | "inside";
+export type HysSortSource = "pointer" | "keyboard" | "button" | "api";
+export type HysSortFixed = boolean | "top" | "bottom";
+export type HysSortDecision = boolean | string | void;
+export type HysSortReason = "cancelled" | "outside" | "disabled" | "keys" | "group" | "capacity" | "fixed" | "cycle" | "noop" | "rule" | "conflict" | "save";
+export interface HysSortListInfo<T extends object> {
+    id: string;
+    group?: string;
+    items: readonly T[];
+}
+export interface HysSortDrag<T extends object> {
+    source: HysSortSource;
+    from: HysSortListInfo<T>;
+    items: readonly T[];
+    keys: readonly HysSortKey[];
+    indices: readonly number[];
+}
+export interface HysSortProposal<T extends object> extends HysSortDrag<T> {
+    to: HysSortListInfo<T>;
+    /** 原列表中的插入边界，0 表示首位，length 表示末尾。交换模式下为目标项索引。 */
+    index: number;
+    position: HysSortPosition;
+    targetItem?: T;
+    operation: HysSortOperation;
+    mode: HysSortMode;
+}
+export interface HysSortListChange<T extends object> {
+    id: string;
+    previous: readonly T[];
+    next: readonly T[];
+}
+export interface HysSortPreview<T extends object> {
+    proposal: HysSortProposal<T>;
+    lists: readonly HysSortListChange<T>[];
+}
+export interface HysSortChange<T extends object> {
+    action: "sort" | "undo" | "redo" | "reset" | "rollback";
+    proposal?: HysSortProposal<T>;
+    lists: readonly HysSortListChange<T>[];
+}
+export interface HysSortFeedback<T extends object> {
+    reason: HysSortReason;
+    message: string;
+    proposal?: HysSortProposal<T>;
+    error?: unknown;
+}
+export interface HysSortGroup<T extends object> {
+    name: string;
+    pull?: boolean | HysSortOperation | ((proposal: HysSortProposal<T>) => boolean | HysSortOperation);
+    put?: boolean | readonly string[] | ((proposal: HysSortProposal<T>) => HysSortDecision);
+}
+export interface HysSortScroll {
+    threshold?: number;
+    speed?: number;
+    axis?: "x" | "y" | "both";
+    window?: boolean;
+}
+export interface HysSortVirtual {
+    height?: number | string;
+    estimateSize?: number;
+    overscan?: number;
+    /** 网格每一行的列数。设置为函数可根据容器宽度调整。 */
+    columns?: number | ((width: number) => number);
+}
+export interface HysSortRow<T extends object> {
+    item: T;
+    key: HysSortKey;
+    index: number;
+    selected: boolean;
+    dragging: boolean;
+    disabled: boolean;
+    fixed: HysSortFixed;
+    toggle: (event?: MouseEvent) => void;
+    move: (offset: number) => Promise<boolean>;
+}
+export interface HysSortableListProps<T extends object = HysSortItem> {
+    /** 受控列表。每项必须有唯一、稳定的键。 */
+    modelValue?: readonly T[];
+    /** 非受控初始数据，也可通过 reset 恢复挂载时的顺序。 */
+    defaultItems?: readonly T[];
+    itemKey?: keyof T | ((item: T) => HysSortKey);
+    itemLabel?: keyof T | ((item: T) => string);
+    listId?: string;
+    ariaLabel?: string;
+    layout?: HysSortLayout;
+    mode?: HysSortMode;
+    disabled?: boolean;
+    itemDisabled?: readonly HysSortKey[] | ((item: T, index: number) => boolean);
+    fixed?: readonly HysSortKey[] | ((item: T, index: number) => HysSortFixed | undefined);
+    handle?: boolean | string;
+    showHandle?: boolean;
+    showButtons?: boolean;
+    keyboard?: boolean;
+    dragDelay?: number;
+    touchDelay?: number;
+    dragThreshold?: number;
+    axis?: "x" | "y" | "both";
+    bounds?: "list" | "viewport" | HTMLElement | (() => HTMLElement | null | undefined);
+    snap?: boolean;
+    livePreview?: boolean;
+    group?: string | HysSortGroup<T>;
+    maxItems?: number;
+    selectable?: boolean;
+    selectedKeys?: readonly HysSortKey[];
+    defaultSelectedKeys?: readonly HysSortKey[];
+    /** copy 浅拷贝、clone 深拷贝。自定义时应返回有新键的项目。 */
+    clone?: (item: T, proposal: HysSortProposal<T>) => T;
+    canDrag?: (item: T, index: number) => HysSortDecision;
+    canDrop?: (proposal: HysSortProposal<T>) => HysSortDecision;
+    resolveIndex?: (proposal: HysSortProposal<T>) => number;
+    beforeDrop?: (proposal: HysSortProposal<T>, signal: AbortSignal) => HysSortDecision | Promise<HysSortDecision>;
+    save?: (change: HysSortChange<T>, signal: AbortSignal) => void | boolean | Promise<void | boolean>;
+    history?: boolean | number;
+    storageKey?: string;
+    autoScroll?: boolean | HysSortScroll;
+    virtual?: boolean | HysSortVirtual;
+    listTag?: "div" | "ul" | "ol" | "table";
+    tableColumns?: number;
+    motion?: boolean;
+    animationDuration?: number;
+    animationEasing?: string;
+    moveClass?: string;
+    ghostClass?: string;
+    ghostStyle?: StyleValue;
+}
+export interface HysSortMoveOptions {
+    /** 目标 listId；省略时在当前列表内移动。 */
+    to?: string;
+    /** 使用目标当前模型的插入边界；交换模式下为项目索引。 */
+    index: number;
+    operation?: HysSortOperation;
+}
+export interface HysSortableListInstance {
+    move: (keys: HysSortKey | readonly HysSortKey[], options: HysSortMoveOptions) => Promise<boolean>;
+    undo: () => Promise<boolean>;
+    redo: () => Promise<boolean>;
+    reset: () => Promise<boolean>;
+    cancel: () => void;
+    select: (keys: readonly HysSortKey[]) => void;
+    scrollTo: (key: HysSortKey) => Promise<boolean>;
+    focus: (key: HysSortKey) => Promise<boolean>;
+}

package/dist/types/components/HysSortableList/transactions.d.ts

@@ -0,0 +1,10 @@
+import { type SortCandidate, type SortPort } from "./model";
+import type { HysSortDrag, HysSortKey } from "./sortableList";
+export declare const busySort: (port: object) => boolean;
+export declare const abortSort: (port: object) => void | undefined;
+export declare function discardSortHistory<T extends object>(port: SortPort<T>): void;
+export declare function restoreStoredSort<T extends object>(port: SortPort<T>): void;
+export declare function commitSort<T extends object>(source: SortPort<T>, drag: HysSortDrag<T>, candidate: SortCandidate<T>, onLanding?: (row?: HTMLElement) => void): Promise<boolean>;
+export declare function navigateHistory<T extends object>(port: SortPort<T>, action: "undo" | "redo"): Promise<boolean>;
+export declare function resetSort<T extends object>(port: SortPort<T>, initial: readonly T[]): Promise<boolean>;
+export declare function keysArray(keys: HysSortKey | readonly HysSortKey[]): readonly HysSortKey[];

package/dist/types/components/HysSortableList/useSortDrag.d.ts

@@ -0,0 +1,25 @@
+import { type SortCandidate, type SortPort, type SortProposal } from "./model";
+import type { HysSortDrag, HysSortFeedback, HysSortKey, HysSortReason, HysSortSource } from "./sortableList";
+interface ActiveSort<T extends object> {
+    source: SortPort<T>;
+    drag: HysSortDrag<T>;
+    candidate?: SortCandidate<T>;
+    result?: SortProposal<T> | HysSortFeedback<T>;
+}
+export declare function useSortDrag<T extends object>(port: SortPort<T>, pickedKeys: (key: HysSortKey) => readonly HysSortKey[], animate: () => boolean): {
+    own: import("vue").ComputedRef<ActiveSort<T> | null>;
+    over: import("vue").ComputedRef<ActiveSort<T> | null>;
+    ghost: import("vue").ShallowRef<import("./SortableGhost/useSortGhost").SortGhost<T> | null, import("./SortableGhost/useSortGhost").SortGhost<T> | null>;
+    anchorForDisplay: import("vue").ComputedRef<{
+        key?: HysSortKey;
+        position: import("./sortableList").HysSortPosition;
+    } | undefined>;
+    pointerDown: (event: PointerEvent, key: HysSortKey, rowDisabled: boolean) => void;
+    keyboard: (event: KeyboardEvent, key: HysSortKey, rowDisabled: boolean) => void;
+    move: (keys: readonly HysSortKey[], candidate: SortCandidate<T>, source: HysSortSource) => Promise<boolean>;
+    relative: (key: HysSortKey, step: number, source: HysSortSource) => Promise<boolean>;
+    cancel: (reason?: HysSortReason, rebound?: boolean) => void;
+    detach: () => void;
+    dataChanged: () => void;
+};
+export {};

package/dist/types/components/HysSortableList/useSortKeyboard.d.ts

@@ -0,0 +1,17 @@
+import { type SortCandidate, type SortPort, type SortProposal } from "./model";
+import type { HysSortDrag, HysSortFeedback, HysSortKey } from "./sortableList";
+export declare const sortInteractive = "button,input,select,textarea,a[href],label,[contenteditable=true],[role=button],[data-sort-ignore]";
+export declare function keyboardPreviewLabel<T extends object>(source: SortPort<T>, item: T, result?: SortProposal<T> | HysSortFeedback<T>): string;
+interface KeyboardSort<T extends object> {
+    current: () => {
+        drag: HysSortDrag<T>;
+        candidate?: SortCandidate<T>;
+    } | null;
+    begin: (key: HysSortKey) => void;
+    update: (candidate: SortCandidate<T>) => void;
+    finish: () => Promise<boolean>;
+    cancel: () => void;
+    relative: (key: HysSortKey, step: number) => Promise<boolean>;
+}
+export declare function useSortKeyboard<T extends object>(port: SortPort<T>, actions: KeyboardSort<T>): (event: KeyboardEvent, key: HysSortKey, rowDisabled: boolean) => void;
+export {};

package/dist/types/components/HysSortableList/useSortWindow.d.ts

@@ -0,0 +1,16 @@
+import { type Ref } from "vue";
+import type { HysSortableListProps, HysSortKey } from "./sortableList";
+export declare function useSortWindow<T extends object>(props: HysSortableListProps<T>, items: Ref<readonly T[]>, viewport: Ref<HTMLElement | null>, surface: Ref<HTMLElement | null>, keyOf: (item: T) => HysSortKey): {
+    visibleItems: import("vue").ComputedRef<T[]>;
+    range: import("vue").ComputedRef<{
+        start: number;
+        end: number;
+        before: number;
+        after: number;
+    }>;
+    horizontal: import("vue").ComputedRef<boolean>;
+    length: import("vue").ComputedRef<string | undefined>;
+    columns: import("vue").ComputedRef<number>;
+    reveal: (index: number) => Promise<void>;
+    syncPosition: () => void;
+};

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

@@ -1,61 +1,59 @@
-export type HysToastType = 'success' | 'error' | 'info' | 'warning' | 'loading';
-export type HysToastPosition = 'top-left' | 'top-center' | 'top-right' | 'bottom-left' | 'bottom-center' | 'bottom-right' | 'center' | 'top' | 'bottom';
-type __VLS_Props = {
-    message?: string;
-    type?: HysToastType;
-    duration?: number;
-    closable?: boolean;
-    position?: HysToastPosition;
-    offset?: number;
-    zIndex?: number;
-    showIcon?: boolean;
-    pauseOnHover?: boolean;
-    closeOnEscape?: boolean;
-    repeat?: number;
-    plain?: boolean;
-    teleport?: boolean;
-    appendTo?: string | HTMLElement;
+import type { HysToastActionContext, HysToastActionEvent, HysToastCloseContext, HysToastCloseReason, HysToastContext, HysToastPatch, HysToastProps } from "./toastTypes";
+export type { HysToastPosition, HysToastType } from "./toastTypes";
+type __VLS_Slots = {
+    default?: (context: HysToastActionContext) => unknown;
+    icon?: (context: HysToastActionContext) => unknown;
+    header?: (context: HysToastActionContext) => unknown;
+    footer?: (context: HysToastActionContext) => unknown;
+    action?: (context: HysToastActionContext) => unknown;
 };
-declare function pause(): void;
-declare function resume(): void;
-declare function restart(): void;
-declare function close(): void;
-declare const __VLS_template: () => {
-    __VLS_Slots: {
-        icon?: (props: {}) => any;
-    } & {
-        default?: (props: {}) => any;
-    } & {
-        action?: (props: {
-            close: typeof close;
-        }) => any;
-    };
-};
-type __VLS_Slots = ReturnType<typeof __VLS_template>['__VLS_Slots'];
-declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {
+declare function close(reason?: HysToastCloseReason, event?: Event, force?: boolean): Promise<boolean>;
+declare const __VLS_base: import("vue").DefineComponent<HysToastProps, {
     close: typeof close;
-    pause: typeof pause;
-    resume: typeof resume;
-    restart: typeof restart;
+    pause: () => void;
+    resume: () => void;
+    restart: () => void;
+    extend: (milliseconds: number) => void;
     element: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    snapshotClock: () => import("./useToastTimer").ToastClock;
+    restoreClock: (clock: import("./useToastTimer").ToastClock) => void;
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    close: () => any;
-    afterClose: () => any;
-}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
-    onClose?: (() => any) | undefined;
-    onAfterClose?: (() => any) | undefined;
+    click: (event: MouseEvent, context: HysToastContext) => any;
+    close: (context: HysToastCloseContext) => any;
+    afterClose: (context: HysToastCloseContext) => any;
+    action: (event: HysToastActionEvent) => any;
+    show: (context: HysToastContext) => any;
+    update: (patch: HysToastPatch) => any;
+    "update:open": (open: boolean) => any;
+    afterShow: (context: HysToastContext) => any;
+    stateChange: (state: "visible" | "closing" | "closed", context: HysToastContext) => any;
+}, string, import("vue").PublicProps, Readonly<HysToastProps> & Readonly<{
+    onClick?: ((event: MouseEvent, context: HysToastContext) => any) | undefined;
+    onClose?: ((context: HysToastCloseContext) => any) | undefined;
+    onAfterClose?: ((context: HysToastCloseContext) => any) | undefined;
+    onAction?: ((event: HysToastActionEvent) => any) | undefined;
+    onShow?: ((context: HysToastContext) => any) | undefined;
+    onUpdate?: ((patch: HysToastPatch) => any) | undefined;
+    "onUpdate:open"?: ((open: boolean) => any) | undefined;
+    onAfterShow?: ((context: HysToastContext) => any) | undefined;
+    onStateChange?: ((state: "visible" | "closing" | "closed", context: HysToastContext) => any) | undefined;
 }>, {
     repeat: number;
-    type: HysToastType;
+    type: import("./toastTypes").HysToastType;
     offset: number;
+    duration: number;
     closable: boolean;
     showIcon: boolean;
-    position: HysToastPosition;
+    position: import("./toastTypes").HysToastPosition;
+    open: boolean;
     message: string;
     zIndex: number;
-    appendTo: string | HTMLElement;
-    pauseOnHover: boolean;
+    appendTo: string | HTMLElement | ShadowRoot;
     teleport: boolean;
+    pauseOnHover: boolean;
+    pauseOnBlur: boolean;
+    interactive: boolean;
+    actionLayout: "footer" | "inline";
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;

package/dist/types/components/HysToast/ToastViewport/ToastViewport.vue.d.ts

@@ -0,0 +1,25 @@
+import { type PropType, type VNode } from "vue";
+import type { createToastQueue } from "../../../composables/toastQueue";
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    queue: {
+        type: PropType<ReturnType<typeof createToastQueue>>;
+        required: true;
+    };
+    skin: {
+        type: PropType<() => Record<string, string>>;
+        required: true;
+    };
+}>, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>[], {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    queue: {
+        type: PropType<ReturnType<typeof createToastQueue>>;
+        required: true;
+    };
+    skin: {
+        type: PropType<() => Record<string, string>>;
+        required: true;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/dist/types/components/HysToast/ToastViewport/useToastStackDisclosure.d.ts

@@ -0,0 +1,16 @@
+interface Disclosure {
+    pinned: boolean;
+    preview: boolean;
+    focused: boolean;
+    suppressHover: boolean;
+}
+export declare function useToastStackDisclosure(): {
+    stacks: import("vue").Reactive<Map<string, Disclosure>>;
+    enter: (key: string, event: PointerEvent) => void;
+    leave: (key: string) => void;
+    toggle: (key: string) => void;
+    focusIn: (key: string) => void;
+    focusOut: (key: string, event: FocusEvent) => void;
+    retain: (keys: Iterable<string>) => void;
+};
+export {};