hys-ui 0.1.1 → 0.3.0

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

@@ -0,0 +1,107 @@
+import { type CSSProperties, type VNodeChild } from "vue";
+import { type HysTransferKey, type HysTransferSide, type HysTransferRecord, type HysTransferPagination, type HysTransferLocale, type HysTransferHeaderInfo } from "../../composables/transfer";
+declare const __VLS_export: <T extends object, K extends HysTransferKey>(__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<{
+        side: HysTransferSide;
+        title: string;
+        id: string;
+        items: readonly HysTransferRecord<T, K>[];
+        total: number;
+        filtered: number;
+        checkedKeys: readonly K[];
+        busy: boolean;
+        loading?: boolean;
+        filterable: boolean;
+        query: string;
+        placeholder: string;
+        showSelectAll: boolean;
+        showInvert: boolean;
+        oneWay: boolean;
+        size: "sm" | "md" | "lg";
+        listHeight: number;
+        itemHeight: number;
+        overscan: number;
+        virtual: boolean;
+        draggable: boolean;
+        moveOnDoubleClick?: boolean;
+        draggedKeys: readonly K[];
+        dropTarget: boolean;
+        words: HysTransferLocale;
+        page: number;
+        pageSize: number;
+        pagination: HysTransferPagination | false;
+        listStyle?: CSSProperties;
+        format?: (info: HysTransferHeaderInfo) => string;
+        renderContent?: (option: T, side: HysTransferSide) => VNodeChild;
+    } & {
+        onSearch?: ((value: string) => any) | undefined;
+        onDrop?: ((event: DragEvent) => any) | undefined;
+        onScroll?: ((event: Event) => any) | undefined;
+        onPage?: ((page: number) => any) | undefined;
+        onCheck?: ((key: K, checked: boolean) => any) | undefined;
+        onRemove?: ((key: K) => any) | undefined;
+        onCheckAll?: ((checked: boolean) => any) | undefined;
+        onPageSize?: ((size: number) => 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 {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: import("vue").ShallowUnwrapRef<{
+        scrollTo: (options: {
+            key?: K;
+            top?: number;
+            behavior?: ScrollBehavior;
+        }) => Promise<void>;
+        focus: () => void;
+    }>) => void;
+    attrs: any;
+    slots: {
+        header?: (props: {
+            info: HysTransferHeaderInfo;
+            allChecked: boolean;
+            indeterminate: boolean;
+        }) => any;
+    } & {
+        panel?: (props: {}) => any;
+    } & {
+        option?: (props: {
+            option: T;
+            label: string;
+            checked: boolean;
+            disabled: boolean;
+        }) => any;
+    } & {
+        option?: (props: {
+            option: T;
+            label: string;
+            checked: boolean;
+            disabled: boolean;
+        }) => any;
+    } & {
+        empty?: (props: {
+            query: string;
+        }) => any;
+    } & {
+        loading?: (props: {}) => any;
+    } & {
+        footer?: (props: {
+            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: "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>>;
+};
+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/HysTree/HysTree.vue.d.ts

@@ -1,92 +1,159 @@
-export interface TreeNode {
-    id: string;
-    label: string;
-    children?: TreeNode[];
-    disabled?: boolean;
-    selectable?: boolean;
-    checkable?: boolean;
-    icon?: string;
-    hasChildren?: boolean;
-    loading?: boolean;
-}
-declare const __VLS_export: <T extends string | string[] = string>(__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<{
-        nodes: TreeNode[];
-        modelValue?: T;
-        checkedKeys?: string[];
-        expandedKeys?: string[];
-        multiple?: boolean;
-        checkable?: boolean;
-        searchable?: boolean;
-        disabled?: boolean;
-        defaultExpandAll?: boolean;
-        showLine?: boolean;
-        virtual?: boolean;
-        rowHeight?: number;
-        viewportHeight?: number;
-        draggable?: boolean;
-        contextMenu?: boolean;
-        checkStrictly?: boolean;
-        filterNode?: (query: string, node: TreeNode) => boolean;
-        loadChildren?: (node: TreeNode) => Promise<TreeNode[]>;
-    } & {
-        "onUpdate:modelValue"?: ((value: T) => any) | undefined;
-        onSelect?: ((node: TreeNode) => any) | undefined;
-        "onUpdate:checkedKeys"?: ((value: string[]) => any) | undefined;
-        "onUpdate:expandedKeys"?: ((value: string[]) => any) | undefined;
-        onCheck?: ((keys: string[]) => any) | undefined;
-        "onNode-drop"?: ((payload: {
-            dragId: string;
-            targetId: string;
-            position: "before" | "inside" | "after";
+import { type HysTreeProps, type HysTreeKey, type HysTreeValue, type TreeNode, type HysTreeRecord, type HysTreeCheckInfo, type HysTreeSelectInfo, type HysTreeDropInfo, type HysTreeNodeContext } from "../../composables/tree";
+export type { TreeNode } from "../../composables/tree";
+declare const __VLS_export: <V extends HysTreeValue = string, N extends object = TreeNode, K extends HysTreeKey = N extends {
+    id: infer I extends HysTreeKey;
+} ? I : HysTreeKey>(__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<HysTreeProps<N, V> & {
+        "onUpdate:modelValue"?: ((value: V) => any) | undefined;
+        onSearch?: ((query: string) => any) | undefined;
+        onSelect?: ((node: N, info: HysTreeSelectInfo<N>) => any) | undefined;
+        onBlur?: ((event: FocusEvent) => any) | undefined;
+        onFocus?: ((event: FocusEvent) => any) | undefined;
+        onLoad?: ((info: {
+            node: N;
+            children: readonly N[];
+            loadedKeys: HysTreeKey[];
         }) => any) | undefined;
-        "onNode-contextmenu"?: ((payload: {
-            node: TreeNode;
-            x: number;
-            y: number;
+        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;
+        "onCheck-change"?: ((info: HysTreeCheckInfo<N>) => any) | undefined;
+        "onSelection-change"?: ((info: HysTreeSelectInfo<N>) => any) | undefined;
+        "onUpdate:expandedKeys"?: ((keys: HysTreeKey[]) => any) | undefined;
+        "onNode-expand"?: ((node: N, info: {
+            key: HysTreeKey;
+            expanded: boolean;
+            expandedKeys: HysTreeKey[];
+        }) => any) | undefined;
+        "onNode-collapse"?: ((node: N, info: {
+            key: HysTreeKey;
+            expanded: boolean;
+            expandedKeys: HysTreeKey[];
+        }) => any) | undefined;
+        "onUpdate:nodes"?: ((nodes: readonly N[]) => any) | undefined;
+        "onData-change"?: ((info: {
+            nodes: readonly N[];
+            action: string;
+            key?: HysTreeKey;
         }) => any) | undefined;
-        "onLoad-error"?: ((payload: {
-            node: TreeNode;
+        "onUpdate:loadedKeys"?: ((keys: HysTreeKey[]) => any) | undefined;
+        "onChildren-loaded"?: ((info: {
+            node: N;
+            children: readonly N[];
+        }) => any) | undefined;
+        "onLoad-error"?: ((info: {
+            node: N;
             error: unknown;
         }) => any) | undefined;
-        "onChildren-loaded"?: ((payload: {
-            node: TreeNode;
-            children: TreeNode[];
+        "onNode-click"?: ((node: N, event: MouseEvent) => any) | undefined;
+        "onNode-drop"?: ((info: HysTreeDropInfo<N, K>) => any) | undefined;
+        "onNode-drag-start"?: ((info: {
+            node: N;
+            event: DragEvent;
+        }) => any) | undefined;
+        "onNode-drag-over"?: ((info: HysTreeDropInfo<N, K>) => any) | undefined;
+        "onNode-drag-end"?: ((info: {
+            node: N;
+            event?: Event;
+        }) => any) | undefined;
+        "onNode-contextmenu"?: ((info: {
+            node: N;
+            x: number;
+            y: number;
+            event: MouseEvent;
         }) => any) | undefined;
     }> & (typeof globalThis extends {
         __VLS_PROPS_FALLBACK: infer P;
     } ? P : {});
     expose: (exposed: import("vue").ShallowUnwrapRef<{
-        getNode: (id: string) => TreeNode | undefined;
-        getCheckedKeys: () => string[];
-        setCheckedKeys: (keys: string[]) => void;
-        filter: (value: string) => string;
-        expandAll: () => void;
-        collapseAll: () => void;
+        element: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+        getNode: (key: HysTreeKey | N) => N | undefined;
+        getNodeInfo: (key: HysTreeKey | N) => HysTreeRecord<N> | undefined;
+        getCheckedKeys: (leafOnly?: boolean) => HysTreeKey[];
+        getCheckedNodes: (leafOnly?: boolean, includeHalf?: boolean) => N[];
+        getHalfCheckedKeys: () => HysTreeKey[];
+        getHalfCheckedNodes: () => N[];
+        setCheckedKeys: (keys: readonly HysTreeKey[], leafOnly?: boolean) => Promise<boolean>;
+        setCheckedNodes: (nodes: readonly N[], leafOnly?: boolean) => Promise<boolean>;
+        setChecked: (key: HysTreeKey | N, on: boolean, deep?: boolean, event?: Event) => Promise<boolean>;
+        getCurrentKey: () => HysTreeKey;
+        getCurrentNode: () => N | null;
+        getSelectedKeys: () => HysTreeKey[];
+        setCurrentKey: (key: HysTreeKey | null, expandParents?: boolean) => Promise<boolean>;
+        setCurrentNode: (node: N | null, expandParents?: boolean) => Promise<boolean>;
+        setSelectedKeys: (keys: readonly HysTreeKey[], node?: N | null, event?: Event) => Promise<boolean>;
+        getExpandedKeys: () => HysTreeKey[];
+        setExpandedKeys: (keys: readonly HysTreeKey[]) => Promise<boolean>;
+        expandNode: (key: HysTreeKey, on?: boolean) => Promise<boolean>;
+        expandAll: () => Promise<boolean>;
+        collapseAll: () => Promise<boolean>;
+        filter: (q: string) => void;
+        reloadNode: (key: HysTreeKey) => Promise<boolean>;
+        updateKeyChildren: (key: HysTreeKey, children: readonly N[]) => Promise<boolean>;
+        append: (node: N, parent?: HysTreeKey | N | undefined) => Promise<boolean>;
+        insertBefore: (node: N, key: HysTreeKey | N) => Promise<boolean>;
+        insertAfter: (node: N, key: HysTreeKey | N) => Promise<boolean>;
+        remove: (key: HysTreeKey | N) => Promise<boolean>;
+        scrollTo: (options: {
+            key?: HysTreeKey;
+            top?: number;
+            align?: "top" | "bottom" | "auto";
+            offset?: number;
+            behavior?: ScrollBehavior;
+        }) => Promise<void>;
+        focus: (key?: HysTreeKey) => Promise<void>;
     }>) => void;
     attrs: any;
     slots: {
-        node?: (props: {
-            node: TreeNode;
-            depth: number;
-            expanded: boolean;
-            selected: boolean;
+        node?: (context: HysTreeNodeContext<N>) => any;
+        default?: (context: HysTreeNodeContext<N>) => any;
+        icon?: (context: HysTreeNodeContext<N>) => any;
+        switcher?: (context: HysTreeNodeContext<N>) => any;
+        actions?: (context: HysTreeNodeContext<N>) => any;
+        empty?: (context: {
+            query: string;
+        }) => any;
+        loading?: () => any;
+        contextmenu?: (context: {
+            node: N;
+            key: HysTreeKey;
+            close: () => void;
         }) => any;
     };
-    emit: ((evt: "update:modelValue", value: T) => void) & ((evt: "select", node: TreeNode) => void) & ((evt: "update:checkedKeys", value: string[]) => void) & ((evt: "update:expandedKeys", value: string[]) => void) & ((evt: "check", keys: string[]) => void) & ((evt: "node-drop", payload: {
-        dragId: string;
-        targetId: string;
-        position: "before" | "inside" | "after";
-    }) => void) & ((evt: "node-contextmenu", payload: {
-        node: TreeNode;
+    emit: ((evt: "update:modelValue", value: V) => void) & ((evt: "search", query: string) => void) & ((evt: "select", node: N, info: HysTreeSelectInfo<N>) => void) & ((evt: "blur", event: FocusEvent) => void) & ((evt: "focus", event: FocusEvent) => void) & ((evt: "load", info: {
+        node: N;
+        children: readonly N[];
+        loadedKeys: HysTreeKey[];
+    }) => 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[];
+    }) => void) & ((evt: "node-collapse", node: N, info: {
+        key: HysTreeKey;
+        expanded: boolean;
+        expandedKeys: HysTreeKey[];
+    }) => void) & ((evt: "update:nodes", nodes: readonly N[]) => void) & ((evt: "data-change", info: {
+        nodes: readonly N[];
+        action: string;
+        key?: HysTreeKey;
+    }) => void) & ((evt: "update:loadedKeys", keys: HysTreeKey[]) => void) & ((evt: "children-loaded", info: {
+        node: N;
+        children: readonly N[];
+    }) => void) & ((evt: "load-error", info: {
+        node: N;
+        error: unknown;
+    }) => void) & ((evt: "node-click", node: N, event: MouseEvent) => void) & ((evt: "node-drop", info: HysTreeDropInfo<N, K>) => void) & ((evt: "node-drag-start", info: {
+        node: N;
+        event: DragEvent;
+    }) => void) & ((evt: "node-drag-over", info: HysTreeDropInfo<N, K>) => void) & ((evt: "node-drag-end", info: {
+        node: N;
+        event?: Event;
+    }) => void) & ((evt: "node-contextmenu", info: {
+        node: N;
         x: number;
         y: number;
-    }) => void) & ((evt: "load-error", payload: {
-        node: TreeNode;
-        error: unknown;
-    }) => void) & ((evt: "children-loaded", payload: {
-        node: TreeNode;
-        children: TreeNode[];
+        event: MouseEvent;
     }) => void);
 }>) => import("vue").VNode & {
     __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;

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

@@ -1,34 +1,113 @@
-export interface HysTreeSelectNode {
-    label: string;
-    value: string;
-    children?: HysTreeSelectNode[];
-    disabled?: boolean;
-}
-declare const __VLS_export: <T extends string | string[] = string>(__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<{
-        modelValue: T;
-        nodes: HysTreeSelectNode[];
-        placeholder?: string;
-        disabled?: boolean;
-        multiple?: boolean;
-        clearable?: boolean;
-        searchable?: boolean;
-        leafOnly?: boolean;
-    } & {
-        "onUpdate:modelValue"?: ((value: T) => any) | undefined;
-        onChange?: ((value: T) => any) | undefined;
+import type { HysTreeKey, HysTreeCheckInfo, HysTreeNodeContext } from "../../composables/tree";
+import type { HysTreeSelectProps, HysTreeSelectValue, HysTreeSelectNode, HysTreeSelectItem, HysTreeSelectChange } from "../../composables/treeSelect";
+export type { HysTreeSelectNode } from "../../composables/treeSelect";
+declare const __VLS_export: <V extends HysTreeSelectValue = string, N extends object = HysTreeSelectNode>(__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<HysTreeSelectProps<N, V> & {
+        onChange?: ((value: V, info: HysTreeSelectChange<N>) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: V) => any) | undefined;
+        onSearch?: ((query: string) => any) | undefined;
         onClear?: (() => any) | undefined;
+        onSelect?: ((key: HysTreeKey, node: N, info: unknown) => any) | undefined;
+        onBlur?: ((event: FocusEvent) => any) | undefined;
+        onFocus?: ((event: FocusEvent) => any) | undefined;
+        onLoad?: ((info: {
+            node: N;
+            children: readonly N[];
+            loadedKeys: HysTreeKey[];
+        }) => any) | undefined;
+        onScroll?: ((event: Event) => any) | undefined;
+        "onUpdate:open"?: ((value: boolean) => any) | undefined;
+        "onUpdate:searchValue"?: ((value: string) => any) | undefined;
+        onDeselect?: ((key: HysTreeKey, node: N, info: unknown) => any) | undefined;
+        onLimit?: ((limit: number) => any) | undefined;
+        onCheck?: ((info: HysTreeCheckInfo<N>) => any) | undefined;
+        "onUpdate:expandedKeys"?: ((keys: HysTreeKey[]) => any) | undefined;
+        "onNode-expand"?: ((node: N, info: unknown) => any) | undefined;
+        "onNode-collapse"?: ((node: N, info: unknown) => any) | undefined;
+        "onUpdate:loadedKeys"?: ((keys: HysTreeKey[]) => any) | undefined;
+        "onChildren-loaded"?: ((info: {
+            node: N;
+            children: readonly N[];
+        }) => any) | undefined;
+        "onLoad-error"?: ((info: {
+            node: N;
+            error: unknown;
+        }) => any) | undefined;
+        "onValue-change"?: ((value: V, info: HysTreeSelectChange<N>) => any) | undefined;
+        "onRemove-tag"?: ((key: HysTreeKey, node: N | undefined) => any) | undefined;
+        "onSearch-complete"?: ((query: string) => any) | undefined;
+        "onSearch-error"?: ((error: unknown, query: string) => any) | undefined;
+        "onVisible-change"?: ((value: boolean) => any) | undefined;
     }> & (typeof globalThis extends {
         __VLS_PROPS_FALLBACK: infer P;
     } ? P : {});
-    expose: (exposed: {}) => void;
+    expose: (exposed: import("vue").ShallowUnwrapRef<{
+        element: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+        open: import("vue").Ref<boolean, boolean>;
+        focus: () => void;
+        blur: () => void;
+        show: () => Promise<boolean>;
+        hide: (restore?: boolean) => void;
+        clear: () => Promise<boolean>;
+        removeTag: (key: HysTreeKey) => Promise<boolean>;
+        setValue: (value: HysTreeSelectValue) => Promise<boolean>;
+        filter: (text: string) => void;
+        getSelectedKeys: () => HysTreeKey[];
+        getSelectedItems: () => HysTreeSelectItem<N>[];
+        getCheckedKeys: (leafOnly?: boolean) => HysTreeKey[];
+        getHalfCheckedKeys: () => HysTreeKey[];
+        getNode: (key: HysTreeKey) => N | undefined;
+        getExpandedKeys: () => HysTreeKey[];
+        setExpandedKeys: (keys: readonly HysTreeKey[]) => Promise<boolean>;
+        expandNode: (key: HysTreeKey, on?: boolean) => Promise<boolean>;
+        reloadNode: (key: HysTreeKey) => Promise<boolean>;
+        scrollTo: (options: {
+            key?: HysTreeKey;
+            top?: number;
+            align?: "top" | "bottom" | "auto";
+        }) => Promise<void>;
+    }>) => void;
     attrs: any;
     slots: {
-        option?: (props: {
-            node: HysTreeSelectNode;
+        option?: (scope: HysTreeNodeContext<N>) => any;
+        icon?: (scope: HysTreeNodeContext<N>) => any;
+        switcher?: (scope: HysTreeNodeContext<N>) => any;
+        tag?: (scope: {
+            item: HysTreeSelectItem<N>;
+            remove: () => Promise<boolean>;
+        }) => any;
+        "max-tag-placeholder"?: (scope: {
+            items: HysTreeSelectItem<N>[];
+            count: number;
+        }) => any;
+        prefix?: () => any;
+        suffix?: () => any;
+        header?: () => any;
+        footer?: (scope: {
+            items: HysTreeSelectItem<N>[];
+            clear: () => Promise<boolean>;
+            close: () => void;
+        }) => any;
+        empty?: (scope: {
+            query: string;
+        }) => any;
+        loading?: () => any;
+        error?: (scope: {
+            error: unknown;
+            retry: () => Promise<void>;
         }) => any;
     };
-    emit: ((evt: "update:modelValue", value: T) => void) & ((evt: "change", value: T) => void) & ((evt: "clear") => void);
+    emit: ((evt: "change", value: V, info: HysTreeSelectChange<N>) => void) & ((evt: "update:modelValue", value: V) => void) & ((evt: "search", query: string) => void) & ((evt: "clear") => void) & ((evt: "select", key: HysTreeKey, node: N, info: unknown) => void) & ((evt: "blur", event: FocusEvent) => void) & ((evt: "focus", event: FocusEvent) => void) & ((evt: "load", info: {
+        node: N;
+        children: readonly N[];
+        loadedKeys: HysTreeKey[];
+    }) => void) & ((evt: "scroll", event: Event) => void) & ((evt: "update:open", value: boolean) => void) & ((evt: "update:searchValue", value: string) => void) & ((evt: "deselect", key: HysTreeKey, node: N, info: unknown) => void) & ((evt: "limit", limit: number) => void) & ((evt: "check", info: HysTreeCheckInfo<N>) => void) & ((evt: "update:expandedKeys", keys: HysTreeKey[]) => void) & ((evt: "node-expand", node: N, info: unknown) => void) & ((evt: "node-collapse", node: N, info: unknown) => void) & ((evt: "update:loadedKeys", keys: HysTreeKey[]) => void) & ((evt: "children-loaded", info: {
+        node: N;
+        children: readonly N[];
+    }) => void) & ((evt: "load-error", info: {
+        node: N;
+        error: unknown;
+    }) => void) & ((evt: "value-change", value: V, info: HysTreeSelectChange<N>) => void) & ((evt: "remove-tag", key: HysTreeKey, node: N | undefined) => void) & ((evt: "search-complete", query: string) => void) & ((evt: "search-error", error: unknown, query: string) => void) & ((evt: "visible-change", value: boolean) => void);
 }>) => import("vue").VNode & {
     __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
 };

package/dist/types/components/HysTreeSelect/HysTreeSelectPanel.vue.d.ts

@@ -0,0 +1,56 @@
+import type { HysTreeSelectStore } from "../../composables/useTreeSelect";
+import type { HysTreeSelectNode } from "../../composables/treeSelect";
+import type { HysTreeKey, HysTreeNodeContext } from "../../composables/tree";
+declare const __VLS_export: <N extends object = HysTreeSelectNode>(__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<{
+        store: HysTreeSelectStore<N>;
+        size?: "sm" | "md" | "lg";
+        treeId: string;
+        checkable?: boolean;
+        checkStrictly?: boolean;
+        leafOnly?: boolean;
+        expandOnClickNode?: boolean;
+        showLine?: boolean;
+        showIcon?: boolean;
+        indent?: number;
+        listHeight?: number;
+        virtual?: boolean;
+        itemHeight?: number;
+        overscan?: number;
+    } & {
+        onScroll?: ((event: Event) => any) | undefined;
+        onChoose?: ((key: HysTreeKey) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: import("vue").ShallowUnwrapRef<{
+        focus: (key?: HysTreeKey) => Promise<void>;
+        scrollTo: (options: {
+            key?: HysTreeKey;
+            top?: number;
+            align?: "top" | "bottom" | "auto";
+        }) => Promise<void>;
+        searchKeys: (event: KeyboardEvent) => Promise<void>;
+        activeId: import("vue").ComputedRef<string | undefined>;
+        setActive: (key: HysTreeKey) => HysTreeKey;
+    }>) => void;
+    attrs: any;
+    slots: {
+        option?: (scope: HysTreeNodeContext<N>) => any;
+        icon?: (scope: HysTreeNodeContext<N>) => any;
+        switcher?: (scope: HysTreeNodeContext<N>) => any;
+        empty?: (scope: {
+            query: string;
+        }) => any;
+    };
+    emit: ((evt: "scroll", event: Event) => void) & ((evt: "choose", key: HysTreeKey) => void);
+}>) => 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];
+}) & {};