hys-ui 0.2.0 → 0.3.0

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

@@ -1,27 +1,47 @@
-import { type Placement } from '../../composables/useFloating';
-type __VLS_Props = {
-    text?: string;
-    placement?: Placement;
-    disabled?: boolean;
-    showDelay?: number;
-    hideDelay?: number;
-};
-declare const __VLS_template: () => {
-    __VLS_Slots: {
-        default?: (props: {}) => any;
-    } & {
-        content?: (props: {}) => any;
-    };
-};
-type __VLS_Slots = ReturnType<typeof __VLS_template>['__VLS_Slots'];
-declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+import type { HysTooltipProps, HysTooltipSlots } from "../../composables/popupSurface";
+type __VLS_Slots = HysTooltipSlots;
+declare const __VLS_base: import("vue").DefineComponent<HysTooltipProps, {
+    element: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    referenceElement: import("vue").ComputedRef<HTMLElement | undefined>;
+    open: import("vue").Ref<boolean, boolean>;
+    placement: import("vue").Ref<import("../..").Placement, import("../..").Placement>;
+    show: () => Promise<boolean>;
+    hide: () => Promise<boolean>;
+    close: () => Promise<boolean>;
+    toggle: () => Promise<boolean>;
+    updatePosition: () => void;
+    focus: () => void | undefined;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (open: boolean) => any;
     visibleChange: (open: boolean) => any;
-}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    show: () => any;
+    hide: () => any;
+    "update:open": (open: boolean) => any;
+    opened: () => any;
+    closed: () => any;
+    openChange: (open: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<HysTooltipProps> & Readonly<{
+    "onUpdate:modelValue"?: ((open: boolean) => any) | undefined;
     onVisibleChange?: ((open: boolean) => any) | undefined;
+    onShow?: (() => any) | undefined;
+    onHide?: (() => any) | undefined;
+    "onUpdate:open"?: ((open: boolean) => any) | undefined;
+    onOpened?: (() => any) | undefined;
+    onClosed?: (() => any) | undefined;
+    onOpenChange?: ((open: boolean) => any) | undefined;
 }>, {
-    placement: Placement;
+    modelValue: boolean;
+    destroyOnHide: boolean;
+    effect: "dark" | "light";
+    placement: import("../..").Placement;
+    open: boolean;
+    appendTo: string | false | HTMLElement;
     showDelay: number;
     hideDelay: number;
+    autoAdjustOverflow: boolean;
+    enterable: boolean;
+    closeOnEscape: boolean;
+    closeOnOutside: 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/HysTour/HysTour.vue.d.ts

@@ -1,4 +1,5 @@
-type __VLS_Props = {
+import type { HysPopupMotionProps } from '../../motion/popup';
+type __VLS_Props = HysPopupMotionProps & {
     steps: {
         title: string;
         description: string;

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

@@ -10,8 +10,8 @@ declare const __VLS_export: <T extends object = HysTransferOption, K extends Hys
         "onUpdate:checkedKeys"?: ((keys: K[]) => any) | undefined;
         onPageSizeChange?: ((side: HysTransferSide, size: number) => any) | undefined;
         onPageChange?: ((side: HysTransferSide, page: number, pageSize: number) => any) | undefined;
-        onDragStart?: ((side: HysTransferSide, keys: K[], event: DragEvent) => any) | undefined;
         onDragEnd?: (() => any) | undefined;
+        onDragStart?: ((side: HysTransferSide, keys: K[], event: DragEvent) => any) | undefined;
         onCheckChange?: ((side: HysTransferSide, keys: K[]) => any) | undefined;
         onSelectChange?: ((left: K[], right: K[]) => any) | undefined;
         "onUpdate:searchValues"?: ((values: Record<HysTransferSide, string>) => any) | undefined;
@@ -45,7 +45,7 @@ declare const __VLS_export: <T extends object = HysTransferOption, K extends Hys
     }>) => void;
     attrs: any;
     slots: HysTransferSlots<T, K>;
-    emit: ((evt: "change", value: K[], direction: HysTransferSide, movedKeys: K[]) => void) & ((evt: "update:modelValue", value: K[]) => void) & ((evt: "search", side: HysTransferSide, value: string) => void) & ((evt: "blur", event: FocusEvent) => void) & ((evt: "focus", event: FocusEvent) => void) & ((evt: "scroll", side: HysTransferSide, event: Event) => void) & ((evt: "update:checkedKeys", keys: K[]) => void) & ((evt: "pageSizeChange", side: HysTransferSide, size: number) => void) & ((evt: "pageChange", side: HysTransferSide, page: number, pageSize: number) => void) & ((evt: "dragStart", side: HysTransferSide, keys: K[], event: DragEvent) => void) & ((evt: "dragEnd") => void) & ((evt: "checkChange", side: HysTransferSide, keys: K[]) => void) & ((evt: "selectChange", left: K[], right: K[]) => void) & ((evt: "update:searchValues", values: Record<HysTransferSide, string>) => void) & ((evt: "update:pages", pages: Record<HysTransferSide, number>) => void) & ((evt: "update:pageSizes", sizes: Record<HysTransferSide, number>) => void);
+    emit: ((evt: "change", value: K[], direction: HysTransferSide, movedKeys: K[]) => void) & ((evt: "update:modelValue", value: K[]) => void) & ((evt: "search", side: HysTransferSide, value: string) => void) & ((evt: "blur", event: FocusEvent) => void) & ((evt: "focus", event: FocusEvent) => void) & ((evt: "scroll", side: HysTransferSide, event: Event) => void) & ((evt: "update:checkedKeys", keys: K[]) => void) & ((evt: "pageSizeChange", side: HysTransferSide, size: number) => void) & ((evt: "pageChange", side: HysTransferSide, page: number, pageSize: number) => void) & ((evt: "dragEnd") => void) & ((evt: "dragStart", side: HysTransferSide, keys: K[], event: DragEvent) => void) & ((evt: "checkChange", side: HysTransferSide, keys: K[]) => void) & ((evt: "selectChange", left: K[], right: K[]) => void) & ((evt: "update:searchValues", values: Record<HysTransferSide, string>) => void) & ((evt: "update:pages", pages: Record<HysTransferSide, number>) => void) & ((evt: "update:pageSizes", sizes: Record<HysTransferSide, number>) => void);
 }>) => import("vue").VNode & {
     __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
 };

package/dist/types/components/HysTransfer/HysTransferPanel.vue.d.ts

@@ -22,8 +22,8 @@ declare const __VLS_export: <T extends object, K extends HysTransferKey>(__VLS_p
         itemHeight: number;
         overscan: number;
         virtual: boolean;
-        animated: boolean;
         draggable: boolean;
+        moveOnDoubleClick?: boolean;
         draggedKeys: readonly K[];
         dropTarget: boolean;
         words: HysTransferLocale;
@@ -42,9 +42,11 @@ declare const __VLS_export: <T extends object, K extends HysTransferKey>(__VLS_p
         onRemove?: ((key: K) => any) | undefined;
         onCheckAll?: ((checked: boolean) => any) | undefined;
         onPageSize?: ((size: number) => any) | undefined;
-        onDragStart?: ((event: DragEvent, key: K) => any) | undefined;
         onDragEnd?: (() => any) | undefined;
+        onDragStart?: ((event: DragEvent, key: K) => any) | undefined;
         onInvert?: (() => any) | undefined;
+        onRangeCheck?: ((keys: K[]) => any) | undefined;
+        onMoveItem?: ((key: K) => any) | undefined;
         onDragOver?: ((event: DragEvent) => any) | undefined;
         onDragLeave?: ((event: DragEvent) => any) | undefined;
     }> & (typeof globalThis extends {
@@ -92,7 +94,7 @@ declare const __VLS_export: <T extends object, K extends HysTransferKey>(__VLS_p
             info: HysTransferHeaderInfo;
         }) => any;
     };
-    emit: ((evt: "search", value: string) => void) & ((evt: "drop", event: DragEvent) => void) & ((evt: "scroll", event: Event) => void) & ((evt: "page", page: number) => void) & ((evt: "check", key: K, checked: boolean) => void) & ((evt: "remove", key: K) => void) & ((evt: "checkAll", checked: boolean) => void) & ((evt: "pageSize", size: number) => void) & ((evt: "dragStart", event: DragEvent, key: K) => void) & ((evt: "dragEnd") => void) & ((evt: "invert") => void) & ((evt: "dragOver", event: DragEvent) => void) & ((evt: "dragLeave", event: DragEvent) => void);
+    emit: ((evt: "search", value: string) => void) & ((evt: "drop", event: DragEvent) => void) & ((evt: "scroll", event: Event) => void) & ((evt: "page", page: number) => void) & ((evt: "check", key: K, checked: boolean) => void) & ((evt: "remove", key: K) => void) & ((evt: "checkAll", checked: boolean) => void) & ((evt: "pageSize", size: number) => void) & ((evt: "dragEnd") => void) & ((evt: "dragStart", event: DragEvent, key: K) => void) & ((evt: "invert") => void) & ((evt: "rangeCheck", keys: K[]) => void) & ((evt: "moveItem", key: K) => void) & ((evt: "dragOver", event: DragEvent) => void) & ((evt: "dragLeave", event: DragEvent) => void);
 }>) => import("vue").VNode & {
     __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
 };

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

@@ -15,9 +15,9 @@ declare const __VLS_export: <V extends HysTreeValue = string, N extends object =
             loadedKeys: HysTreeKey[];
         }) => any) | undefined;
         onScroll?: ((event: Event) => any) | undefined;
+        "onUpdate:checkedKeys"?: ((keys: HysTreeKey[]) => any) | undefined;
         "onUpdate:searchValue"?: ((query: string) => any) | undefined;
         onCheck?: ((keys: HysTreeKey[], info: HysTreeCheckInfo<N>) => any) | undefined;
-        "onUpdate:checkedKeys"?: ((keys: HysTreeKey[]) => any) | undefined;
         "onCheck-change"?: ((info: HysTreeCheckInfo<N>) => any) | undefined;
         "onSelection-change"?: ((info: HysTreeSelectInfo<N>) => any) | undefined;
         "onUpdate:expandedKeys"?: ((keys: HysTreeKey[]) => any) | undefined;
@@ -125,7 +125,7 @@ declare const __VLS_export: <V extends HysTreeValue = string, N extends object =
         node: N;
         children: readonly N[];
         loadedKeys: HysTreeKey[];
-    }) => void) & ((evt: "scroll", event: Event) => void) & ((evt: "update:searchValue", query: string) => void) & ((evt: "check", keys: HysTreeKey[], info: HysTreeCheckInfo<N>) => void) & ((evt: "update:checkedKeys", keys: HysTreeKey[]) => void) & ((evt: "check-change", info: HysTreeCheckInfo<N>) => void) & ((evt: "selection-change", info: HysTreeSelectInfo<N>) => void) & ((evt: "update:expandedKeys", keys: HysTreeKey[]) => void) & ((evt: "node-expand", node: N, info: {
+    }) => void) & ((evt: "scroll", event: Event) => void) & ((evt: "update:checkedKeys", keys: HysTreeKey[]) => void) & ((evt: "update:searchValue", query: string) => void) & ((evt: "check", keys: HysTreeKey[], info: HysTreeCheckInfo<N>) => void) & ((evt: "check-change", info: HysTreeCheckInfo<N>) => void) & ((evt: "selection-change", info: HysTreeSelectInfo<N>) => void) & ((evt: "update:expandedKeys", keys: HysTreeKey[]) => void) & ((evt: "node-expand", node: N, info: {
         key: HysTreeKey;
         expanded: boolean;
         expandedKeys: HysTreeKey[];

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

@@ -1,70 +1,58 @@
-export interface HysUploadFile {
-    uid: string;
-    name: string;
-    size: number;
-    raw: File;
-}
-type __VLS_Props = {
-    accept?: string;
-    multiple?: boolean;
-    disabled?: boolean;
-    limit?: number;
-    maxSize?: number;
-    drag?: boolean;
-    showFileList?: boolean;
-    beforeUpload?: (file: File) => boolean | void | Promise<boolean | void>;
+import { type HysUploadProps, type HysUploadFile, type HysUploadItem, type HysUploadSlots, type HysUploadChange, type HysUploadInvalid, type HysUploadError } from "../../composables/upload";
+export type { HysUploadFile } from "../../composables/upload";
+declare const __VLS_export: <T extends HysUploadItem = HysUploadFile>(__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<HysUploadProps<T> & {
+        onChange?: ((files: T[]) => any) | undefined;
+        "onUpdate:modelValue"?: ((files: T[]) => any) | undefined;
+        onProgress?: ((percentage: number, file: T) => any) | undefined;
+        onSelect?: ((files: File[]) => any) | undefined;
+        onSuccess?: ((response: unknown, file: T) => any) | undefined;
+        onAbort?: ((file: T, reason: string) => any) | undefined;
+        onDrop?: ((event: DragEvent) => any) | undefined;
+        onError?: ((message: string) => any) | undefined;
+        onInvalid?: ((info: HysUploadInvalid<T>) => any) | undefined;
+        onPaste?: ((event: ClipboardEvent) => any) | undefined;
+        onStart?: ((file: T) => any) | undefined;
+        onRemove?: ((file: T) => any) | undefined;
+        onPreview?: ((file: T) => any) | undefined;
+        onDownload?: ((file: T) => any) | undefined;
+        "onUpdate:fileList"?: ((files: T[]) => any) | undefined;
+        onFileChange?: ((change: HysUploadChange<T>) => any) | undefined;
+        onUploadError?: ((error: HysUploadError, file: T) => any) | undefined;
+        onExceed?: ((files: File[]) => any) | undefined;
+        onRemoveError?: ((error: Error, file: T) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: import("vue").ShallowUnwrapRef<{
+        element: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+        input: import("vue").Ref<HTMLInputElement | undefined, HTMLInputElement | undefined>;
+        files: import("vue").ComputedRef<T[]>;
+        busy: import("vue").Ref<boolean, boolean>;
+        uploading: import("vue").ComputedRef<number>;
+        queued: import("vue").ComputedRef<number>;
+        open: (event?: Event) => void;
+        focus: () => void;
+        addFiles: (inputFiles: readonly File[]) => Promise<T[]>;
+        getFiles: () => T[];
+        clearFiles: (statuses?: readonly import("../../index.js").HysUploadStatus[]) => Promise<boolean>;
+        remove: (file: string | T) => Promise<boolean>;
+        submit: (file?: T | string) => Promise<number>;
+        retry: (file: T | string) => Promise<boolean>;
+        abort: (file?: T | string) => number;
+        preview: (file: string | T) => Promise<boolean>;
+        download: (file: string | T) => Promise<boolean>;
+    }>) => void;
+    attrs: any;
+    slots: HysUploadSlots<T>;
+    emit: ((evt: "change", files: T[]) => void) & ((evt: "update:modelValue", files: T[]) => void) & ((evt: "progress", percentage: number, file: T) => void) & ((evt: "select", files: File[]) => void) & ((evt: "success", response: unknown, file: T) => void) & ((evt: "abort", file: T, reason: string) => void) & ((evt: "drop", event: DragEvent) => void) & ((evt: "error", message: string) => void) & ((evt: "invalid", info: HysUploadInvalid<T>) => void) & ((evt: "paste", event: ClipboardEvent) => void) & ((evt: "start", file: T) => void) & ((evt: "remove", file: T) => void) & ((evt: "preview", file: T) => void) & ((evt: "download", file: T) => void) & ((evt: "update:fileList", files: T[]) => void) & ((evt: "fileChange", change: HysUploadChange<T>) => void) & ((evt: "uploadError", error: HysUploadError, file: T) => void) & ((evt: "exceed", files: File[]) => void) & ((evt: "removeError", error: Error, file: T) => void);
+}>) => import("vue").VNode & {
+    __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
 };
-declare const __VLS_template: () => {
-    __VLS_Slots: {
-        default?: (props: {}) => any;
-    } & {
-        file?: (props: {
-            file: {
-                uid: string;
-                name: string;
-                size: number;
-                raw: {
-                    readonly lastModified: number;
-                    readonly name: string;
-                    readonly webkitRelativePath: string;
-                    readonly size: number;
-                    readonly type: string;
-                    arrayBuffer: () => Promise<ArrayBuffer>;
-                    bytes: () => Promise<Uint8Array<ArrayBuffer>>;
-                    slice: (start?: number, end?: number, contentType?: string) => Blob;
-                    stream: () => ReadableStream<Uint8Array<ArrayBuffer>>;
-                    text: () => Promise<string>;
-                };
-            };
-        }) => any;
-    };
-};
-type __VLS_Slots = ReturnType<typeof __VLS_template>['__VLS_Slots'];
-declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {
-    clearFiles: () => void;
-    open: () => void;
-}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    change: (files: HysUploadFile[]) => any;
-    select: (files: File[]) => any;
-    error: (message: string) => any;
-    remove: (file: HysUploadFile) => any;
-    exceed: (files: File[]) => any;
-}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
-    onChange?: ((files: HysUploadFile[]) => any) | undefined;
-    onSelect?: ((files: File[]) => any) | undefined;
-    onError?: ((message: string) => any) | undefined;
-    onRemove?: ((file: HysUploadFile) => any) | undefined;
-    onExceed?: ((files: File[]) => any) | undefined;
-}>, {
-    multiple: boolean;
-    drag: boolean;
-    showFileList: boolean;
-}, {}, {}, {}, 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/HysVirtualTable/HysVirtualTable.vue.d.ts

@@ -1,45 +1,76 @@
-type Row = {
-    id: string | number;
-    [key: string]: unknown;
-};
-type Column = {
-    key: string;
-    label: string;
-    width?: number;
-};
-type __VLS_Props = {
-    rows: Row[];
-    columns: Column[];
-    rowHeight?: number;
-    height?: number;
-    loading?: boolean;
-    emptyText?: string;
-    rowKey?: string;
-};
-declare const __VLS_template: () => {
-    __VLS_Slots: {
-        [x: string]: ((props: {
-            row: Row;
-            value: unknown;
+import { type HysVirtualTableProps, type HysVirtualTableColumn, type HysVirtualTableCell, type HysVirtualTableKey, type HysVirtualTableSort, type HysVirtualTableRange, type HysVirtualTableScroll, type HysVirtualTableAlign } from "../../composables/virtualTable";
+declare const __VLS_export: <T extends object = Record<string, unknown>>(__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<HysVirtualTableProps<T> & {
+        onScroll?: ((state: HysVirtualTableScroll) => any) | undefined;
+        onSelectionChange?: ((keys: HysVirtualTableKey[], rows: T[]) => any) | undefined;
+        onRowClick?: ((row: T, index: number, event: MouseEvent) => any) | undefined;
+        "onUpdate:selectedRowKeys"?: ((keys: HysVirtualTableKey[]) => any) | undefined;
+        onSortChange?: ((sort: HysVirtualTableSort | null) => any) | undefined;
+        "onUpdate:currentRowKey"?: ((key: HysVirtualTableKey | null) => any) | undefined;
+        onCurrentChange?: ((row: T | null, key: HysVirtualTableKey | null) => any) | undefined;
+        onRowDblclick?: ((row: T, index: number, event: MouseEvent) => any) | undefined;
+        onCellClick?: ((context: HysVirtualTableCell<T>, event: MouseEvent) => any) | undefined;
+        "onUpdate:sortState"?: ((sort: HysVirtualTableSort | null) => any) | undefined;
+        onRangeChange?: ((range: HysVirtualTableRange) => any) | undefined;
+        onEndReached?: ((info: {
+            distance: number;
+            total: number;
         }) => any) | undefined;
-    } & {
-        header?: (props: {
-            column: Column;
-        }) => any;
-    } & {
-        empty?: (props: {}) => any;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: import("vue").ShallowUnwrapRef<{
+        element: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+        viewport: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+        scrollTop: import("vue").Ref<number, number>;
+        scrollLeft: import("vue").Ref<number, number>;
+        range: import("vue").ComputedRef<HysVirtualTableRange>;
+        selectedRowKeys: import("vue").ComputedRef<HysVirtualTableKey[]>;
+        sortState: import("vue").ComputedRef<HysVirtualTableSort | null>;
+        scrollTo: (options: {
+            top?: number;
+            left?: number;
+            behavior?: ScrollBehavior;
+        }) => void;
+        scrollToRow: (index: number, align?: HysVirtualTableAlign) => void;
+        scrollToKey: (key: HysVirtualTableKey, align?: HysVirtualTableAlign) => boolean;
+        scrollToColumn: (key: string, align?: HysVirtualTableAlign) => boolean;
+        focusCell: (index: number, key?: string) => Promise<boolean>;
+        setSort: (value: HysVirtualTableSort | null) => Promise<boolean>;
+        clearSelection: () => Promise<boolean>;
+        toggleRowSelection: (key: HysVirtualTableKey, selected?: boolean) => Promise<boolean>;
+        selectAll: (selected?: boolean) => Promise<boolean>;
+        setCurrentRow: (key: HysVirtualTableKey | null) => Promise<boolean>;
+        getRow: (index: number) => T;
+        remeasure: () => void;
+    }>) => void;
+    attrs: any;
+    slots: {
+        [name: string]: ((props: any) => any) | undefined;
+        header?(props: {
+            column: HysVirtualTableColumn<T>;
+            columnIndex: number;
+        }): any;
+        cell?(props: HysVirtualTableCell<T>): any;
+        empty?(): any;
+        loading?(): any;
+        footer?(props: {
+            rows: readonly T[];
+            range: HysVirtualTableRange;
+            selectedRowKeys: HysVirtualTableKey[];
+        }): any;
     };
+    emit: ((evt: "scroll", state: HysVirtualTableScroll) => void) & ((evt: "selectionChange", keys: HysVirtualTableKey[], rows: T[]) => void) & ((evt: "rowClick", row: T, index: number, event: MouseEvent) => void) & ((evt: "update:selectedRowKeys", keys: HysVirtualTableKey[]) => void) & ((evt: "sortChange", sort: HysVirtualTableSort | null) => void) & ((evt: "update:currentRowKey", key: HysVirtualTableKey | null) => void) & ((evt: "currentChange", row: T | null, key: HysVirtualTableKey | null) => void) & ((evt: "rowDblclick", row: T, index: number, event: MouseEvent) => void) & ((evt: "cellClick", context: HysVirtualTableCell<T>, event: MouseEvent) => void) & ((evt: "update:sortState", sort: HysVirtualTableSort | null) => void) & ((evt: "rangeChange", range: HysVirtualTableRange) => void) & ((evt: "endReached", info: {
+        distance: number;
+        total: number;
+    }) => 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, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
-    height: number;
-    rowHeight: number;
-}, {}, {}, {}, 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/composables/autocomplete.d.ts

@@ -1,3 +1,4 @@
+import type { HysPopupTransition } from '../motion/popup';
 import type { Component, CSSProperties } from "vue";
 import type { Placement } from "./useFloating";
 import type { HysInputProps } from "./textInput";
@@ -23,6 +24,8 @@ export interface HysAutocompleteContext {
 export type HysAutocompleteCallback = (options: readonly HysAutocompleteDataOption[]) => void;
 export type HysAutocompleteFetch = (query: string, callback: HysAutocompleteCallback, context: HysAutocompleteContext) => void | readonly HysAutocompleteDataOption[] | Promise<void | readonly HysAutocompleteDataOption[]>;
 export interface HysAutocompleteProps {
+    popupTransition?: HysPopupTransition;
+    popupTransitionDuration?: number;
     modelValue?: string;
     defaultValue?: string;
     options?: readonly HysAutocompleteDataOption[];

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

@@ -1,3 +1,4 @@
+import type { HysPopupTransition } from '../motion/popup';
 import { type Component, type ComputedRef, type CSSProperties, type ImgHTMLAttributes, type InjectionKey } from "vue";
 import type { Placement } from "./useFloating";
 export type HysAvatarBreakpoint = "xs" | "sm" | "md" | "lg" | "xl" | "xxl";
@@ -46,6 +47,8 @@ export interface HysAvatarGroupInstance {
     close: () => void;
 }
 export interface HysAvatarGroupProps {
+    popupTransition?: HysPopupTransition;
+    popupTransitionDuration?: number;
     options?: readonly HysAvatarOption[];
     size?: HysAvatarSize;
     shape?: "circle" | "square";

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

@@ -1,3 +1,4 @@
+import type { HysPopupTransition } from '../motion/popup';
 import type { CSSProperties, VNodeChild } from "vue";
 import { type HysTreeKey } from "./tree";
 import type { Placement } from "./useFloating";
@@ -72,6 +73,8 @@ export interface HysCascaderLocale {
     limit: string;
 }
 export interface HysCascaderProps<N extends object = HysCascaderNode, V extends HysCascaderValue = HysCascaderValue> {
+    popupTransition?: HysPopupTransition;
+    popupTransitionDuration?: number;
     options: readonly N[];
     modelValue?: V;
     defaultValue?: V;

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

@@ -0,0 +1,97 @@
+import type { CSSProperties, VNodeChild } from "vue";
+import type { HysPopupMotionProps } from "../motion/popup";
+import type { Placement } from "./useFloating";
+export type HysColorFormat = "hex" | "rgb" | "hsl" | "hsv";
+export interface HysColor {
+    h: number;
+    s: number;
+    v: number;
+    a: number;
+}
+export interface HysColorPickerProps extends HysPopupMotionProps {
+    modelValue?: string;
+    defaultValue?: string;
+    disabled?: boolean;
+    readonly?: boolean;
+    size?: "sm" | "md" | "lg";
+    label?: string;
+    ariaLabel?: string;
+    presets?: readonly string[];
+    clearable?: boolean;
+    showAlpha?: boolean;
+    format?: HysColorFormat;
+    immediate?: boolean;
+    showInput?: boolean;
+    showText?: boolean;
+    showPresets?: boolean;
+    inline?: boolean;
+    open?: boolean;
+    defaultOpen?: boolean;
+    placement?: Placement;
+    appendTo?: string | HTMLElement | false;
+    popupClass?: string;
+    popupStyle?: CSSProperties;
+    popupWidth?: number | string;
+    showFooter?: boolean;
+    confirmText?: string;
+    cancelText?: string;
+    clearText?: string;
+    status?: "error" | "warning" | "success";
+    error?: string;
+    name?: string;
+    form?: string;
+    tabindex?: number;
+    autofocus?: boolean;
+    validateEvent?: boolean;
+    inputProps?: Record<string, unknown>;
+}
+export interface HysColorPickerContext {
+    value: string;
+    draft: string;
+    color: Readonly<HysColor>;
+    disabled: boolean;
+    readonly: boolean;
+    valid: boolean;
+    dirty: boolean;
+    setColor: (value: string) => Promise<boolean>;
+    confirm: () => Promise<boolean>;
+    cancel: () => void;
+    clear: () => Promise<boolean>;
+    show: () => Promise<boolean>;
+    hide: () => Promise<boolean>;
+}
+export interface HysColorPickerSlots {
+    trigger?: (context: HysColorPickerContext) => VNodeChild;
+    header?: (context: HysColorPickerContext) => VNodeChild;
+    footer?: (context: HysColorPickerContext) => VNodeChild;
+    preset?: (context: {
+        value: string;
+        color: string;
+        selected: boolean;
+        disabled: boolean;
+    }) => VNodeChild;
+}
+export interface HysColorPickerInstance {
+    readonly element: HTMLElement | undefined;
+    readonly input: HTMLInputElement | undefined;
+    readonly panel: HTMLElement | undefined;
+    readonly value: string;
+    readonly draft: string;
+    readonly color: Readonly<HysColor>;
+    readonly open: boolean;
+    focus: (options?: FocusOptions) => void;
+    blur: () => void;
+    show: () => Promise<boolean>;
+    hide: () => Promise<boolean>;
+    confirm: () => Promise<boolean>;
+    cancel: () => void;
+    clear: () => Promise<boolean>;
+    setColor: (value: string) => Promise<boolean>;
+}
+export declare const colorClamp: (value: number, min?: number, max?: number) => number;
+export declare function colorFromRgb(r: number, g: number, b: number, a?: number): HysColor;
+export declare function colorRgb(c: HysColor): readonly [number, number, number];
+export declare function parseColor(value: string | undefined): HysColor | undefined;
+export declare function formatColor(color: HysColor, format?: HysColorFormat, alpha?: boolean): string;
+export declare const colorCss: (color: HysColor) => string;
+export declare function sameColor(a: HysColor | undefined, b: HysColor | undefined): boolean;

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

@@ -0,0 +1,100 @@
+import type { HysPopupMotionProps } from "../motion/popup";
+export type HysDataGridKey = string | number;
+export type HysDataGridSort = {
+    key: string;
+    direction: "asc" | "desc";
+};
+export interface HysDataGridQuery {
+    page: number;
+    pageSize: number;
+    sort: HysDataGridSort[];
+    search: string;
+    filters: Record<string, string>;
+}
+export interface GridColumn<T extends object = Record<string, unknown>> {
+    key: string;
+    label: string;
+    field?: string | ((row: T) => unknown);
+    width?: number;
+    minWidth?: number;
+    maxWidth?: number;
+    sortable?: boolean;
+    sortMethod?: (a: T, b: T) => number;
+    filterable?: boolean;
+    filterMethod?: (value: string, row: T) => boolean;
+    hideable?: boolean;
+    resizable?: boolean;
+    reorderable?: boolean;
+    pinned?: "left" | "right";
+    align?: "left" | "center" | "right";
+    summary?: "sum" | "avg" | "min" | "max" | "count";
+    editable?: boolean;
+}
+export interface HysDataGridResult<T extends object> {
+    rows: readonly T[];
+    total: number;
+}
+export type HysDataGridLoader<T extends object> = (query: HysDataGridQuery, context: {
+    signal: AbortSignal;
+}) => Promise<HysDataGridResult<T>> | HysDataGridResult<T>;
+export interface HysDataGridProps<T extends object> extends HysPopupMotionProps {
+    columns: readonly GridColumn<T>[];
+    rows: readonly T[];
+    rowKey?: string | ((row: T, index: number) => HysDataGridKey);
+    page?: number;
+    pageSize?: number;
+    query?: HysDataGridQuery;
+    defaultQuery?: Partial<HysDataGridQuery>;
+    immediateQuery?: boolean;
+    serverMode?: boolean;
+    loadRows?: HysDataGridLoader<T>;
+    totalRows?: number;
+    storageKey?: string;
+    selectable?: boolean;
+    rowSelectable?: (row: T, index: number) => boolean;
+    selectedRowKeys?: readonly HysDataGridKey[];
+    defaultSelectedRowKeys?: readonly HysDataGridKey[];
+    reserveSelection?: boolean;
+    selectionType?: "checkbox" | "radio";
+    loading?: boolean;
+    emptyText?: string;
+    density?: "compact" | "normal" | "comfortable";
+    multiSort?: boolean;
+    stickyHeader?: boolean;
+    maxHeight?: number | string;
+    scrollToTopOnQuery?: boolean;
+    groupable?: boolean;
+    showSummary?: boolean;
+    summaryMethod?: (column: GridColumn<T>, rows: readonly T[]) => string | number;
+    treeMode?: boolean;
+    parentKey?: string;
+    editable?: boolean;
+}
+export interface HysDataGridInstance {
+    resetColumns(): void;
+    getQuery(): HysDataGridQuery;
+    setQuery(query: Partial<HysDataGridQuery>): void;
+    resetQuery(): void;
+    reload(): void;
+    getSelection(): HysDataGridKey[];
+    clearSelection(): void;
+    toggleRowSelection(key: HysDataGridKey, checked?: boolean): void;
+    scrollTo(options: ScrollToOptions): void;
+    scrollToRow(key: HysDataGridKey): boolean;
+}
+export type GridRow<T extends object> = {
+    row: T;
+    id: HysDataGridKey;
+    index: number;
+};
+export type GridTreeRow<T extends object> = GridRow<T> & {
+    depth: number;
+    hasChildren: boolean;
+};
+export declare const gridKey: (value: unknown) => value is HysDataGridKey;
+export declare const gridToken: (key: HysDataGridKey) => string;
+export declare const positiveInteger: (value: number | undefined, fallback: number) => number;
+export declare function gridField(row: object, path: string): unknown;
+export declare function gridValue<T extends object>(row: T, column: GridColumn<T>): unknown;
+export declare function gridRows<T extends object>(rows: readonly T[], rowKey: NonNullable<HysDataGridProps<T>["rowKey"]>, offset: number): GridRow<T>[];
+export declare function gridTree<T extends object>(rows: readonly GridRow<T>[], parentKey: string, expanded: ReadonlySet<HysDataGridKey>): GridTreeRow<T>[];