hys-ui 0.4.0 → 0.6.0

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

@@ -31,14 +31,18 @@ declare const __VLS_template: () => {
 };
 type __VLS_Slots = ReturnType<typeof __VLS_template>['__VLS_Slots'];
 declare const __VLS_base: import("vue").DefineComponent<HysInputProps, {
+    element: import("vue").Ref<HTMLInputElement | HTMLTextAreaElement | undefined, HTMLInputElement | HTMLTextAreaElement | undefined>;
     input: import("vue").Ref<HTMLInputElement | HTMLTextAreaElement | undefined, HTMLInputElement | HTMLTextAreaElement | undefined>;
     textarea: import("vue").ComputedRef<HTMLTextAreaElement | undefined>;
     isComposing: import("vue").Ref<boolean, boolean>;
+    passwordVisible: import("vue").ComputedRef<boolean>;
+    textareaStyle: import("vue").ShallowRef<import("../..").HysTextareaStyle, import("../..").HysTextareaStyle>;
     focus: (options?: FocusOptions) => void;
     blur: () => void | undefined;
     select: () => void | undefined;
     clear: typeof clear;
     resize: () => Promise<void>;
+    resizeTextarea: () => Promise<void>;
     setSelectionRange: (start: number, end: number, direction?: "forward" | "backward" | "none") => void;
     scrollTo: (options: ScrollToOptions) => void | undefined;
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
@@ -46,11 +50,14 @@ declare const __VLS_base: import("vue").DefineComponent<HysInputProps, {
     "update:modelValue": (value: string) => any;
     clear: () => any;
     input: (value: string) => any;
+    keydown: (event: KeyboardEvent) => any;
     blur: (event: FocusEvent) => any;
     compositionend: (event: CompositionEvent) => any;
     compositionstart: (event: CompositionEvent) => any;
     compositionupdate: (event: CompositionEvent) => any;
     focus: (event: FocusEvent) => any;
+    mouseenter: (event: MouseEvent) => any;
+    mouseleave: (event: MouseEvent) => any;
     pressEnter: (event: KeyboardEvent) => any;
     "update:passwordVisible": (value: boolean) => any;
     passwordVisibleChange: (value: boolean) => any;
@@ -59,22 +66,27 @@ declare const __VLS_base: import("vue").DefineComponent<HysInputProps, {
     "onUpdate:modelValue"?: ((value: string) => any) | undefined;
     onClear?: (() => any) | undefined;
     onInput?: ((value: string) => any) | undefined;
+    onKeydown?: ((event: KeyboardEvent) => any) | undefined;
     onBlur?: ((event: FocusEvent) => any) | undefined;
     onCompositionend?: ((event: CompositionEvent) => any) | undefined;
     onCompositionstart?: ((event: CompositionEvent) => any) | undefined;
     onCompositionupdate?: ((event: CompositionEvent) => any) | undefined;
     onFocus?: ((event: FocusEvent) => any) | undefined;
+    onMouseenter?: ((event: MouseEvent) => any) | undefined;
+    onMouseleave?: ((event: MouseEvent) => any) | undefined;
     onPressEnter?: ((event: KeyboardEvent) => any) | undefined;
     "onUpdate:passwordVisible"?: ((value: boolean) => any) | undefined;
     onPasswordVisibleChange?: ((value: boolean) => any) | undefined;
 }>, {
     bordered: boolean;
     type: string;
-    resize: "none" | "both" | "horizontal" | "vertical";
+    resize: "none" | "horizontal" | "vertical" | "both";
     showPasswordOn: "click" | "mousedown";
     passwordVisible: boolean;
+    clearable: boolean;
     countPosition: "inside" | "outside";
     rows: number;
+    validateEvent: boolean;
 }, {}, {}, {}, 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/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/HysNumberInput/HysNumberInput.vue.d.ts

@@ -45,8 +45,8 @@ declare const __VLS_export: <T extends HysNumberInputValue = number | null>(__VL
         "onUpdate:modelValue"?: ((value: T) => any) | undefined;
         onClear?: (() => any) | undefined;
         onInput?: ((value: T | null) => any) | undefined;
-        onStep?: ((value: T, info: HysNumberInputStepInfo) => any) | undefined;
         onBlur?: ((event: FocusEvent) => any) | undefined;
+        onStep?: ((value: T, info: HysNumberInputStepInfo) => any) | undefined;
         onFocus?: ((event: FocusEvent) => any) | undefined;
         onInvalid?: ((info: HysNumberInputInvalidInfo) => any) | undefined;
         onPressEnter?: ((event: KeyboardEvent) => any) | undefined;
@@ -83,7 +83,7 @@ declare const __VLS_export: <T extends HysNumberInputValue = number | null>(__VL
     } & {
         append?: (props: {}) => any;
     };
-    emit: ((evt: "change", value: T) => void) & ((evt: "update:modelValue", value: T) => void) & ((evt: "clear") => void) & ((evt: "input", value: T | null) => void) & ((evt: "step", value: T, info: HysNumberInputStepInfo) => void) & ((evt: "blur", event: FocusEvent) => void) & ((evt: "focus", event: FocusEvent) => void) & ((evt: "invalid", info: HysNumberInputInvalidInfo) => void) & ((evt: "pressEnter", event: KeyboardEvent) => void);
+    emit: ((evt: "change", value: T) => void) & ((evt: "update:modelValue", value: T) => void) & ((evt: "clear") => void) & ((evt: "input", value: T | null) => void) & ((evt: "blur", event: FocusEvent) => void) & ((evt: "step", value: T, info: HysNumberInputStepInfo) => void) & ((evt: "focus", event: FocusEvent) => void) & ((evt: "invalid", info: HysNumberInputInvalidInfo) => void) & ((evt: "pressEnter", event: KeyboardEvent) => void);
 }>) => import("vue").VNode & {
     __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
 };

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

@@ -33,8 +33,8 @@ declare const __VLS_base: import("vue").DefineComponent<HysPopoverProps, {
     modelValue: boolean;
     destroyOnHide: boolean;
     effect: "dark" | "light";
-    placement: import("../..").Placement;
     open: boolean;
+    placement: import("../..").Placement;
     appendTo: string | false | HTMLElement;
     showDelay: number;
     hideDelay: number;

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

@@ -54,9 +54,9 @@ declare const __VLS_base: import("vue").DefineComponent<HysSearchProps, {
 }>, {
     trigger: "input" | "submit";
     placeholder: string;
+    delay: number;
     defaultValue: string;
     clearable: boolean;
-    delay: number;
     searchOnClear: boolean;
     searchLabel: string;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;

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

@@ -35,6 +35,8 @@ declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {},
     onVisibilityChange?: ((visible: boolean) => any) | undefined;
 }>, {
     title: boolean;
+    count: number;
+    delay: number;
     active: boolean;
     loading: boolean;
     loadingText: string;
@@ -43,8 +45,6 @@ declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {},
     avatarSize: number;
     avatarShape: "circle" | "square";
     titleWidth: string | number;
-    count: number;
-    delay: number;
     minDuration: number;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;

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/HysSteps/HysSteps.vue.d.ts

@@ -62,8 +62,8 @@ declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {},
 }>, {
     size: "sm" | "md";
     status: HysStepStatus;
-    responsive: boolean;
     current: number;
+    responsive: boolean;
     labelPlacement: "right" | "bottom";
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;

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

@@ -88,7 +88,7 @@ declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {
     destroyOnHide: boolean;
     type: "line" | "card" | "segment" | "border-card";
     animated: boolean;
-    activation: "auto" | "manual";
+    activation: "manual" | "auto";
     showScrollButtons: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;

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

@@ -47,8 +47,8 @@ declare const __VLS_base: import("vue").DefineComponent<HysTagInputProps, {
     max: number;
     placeholder: string;
     autocomplete: string;
-    caseSensitive: boolean;
     validateEvent: boolean;
+    caseSensitive: boolean;
     addOnBlur: boolean;
     tagTone: "primary" | "success" | "warning" | "danger" | "neutral";
     tagEffect: "dark" | "light" | "outline";