hys-ui 0.1.0 → 0.2.0

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: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;
+        "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: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: {
+        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];
+}) & {};

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

@@ -0,0 +1,106 @@
+import type { Component, CSSProperties } from "vue";
+import type { Placement } from "./useFloating";
+import type { HysInputProps } from "./textInput";
+export interface HysAutocompleteOption {
+    value?: string;
+    label?: string;
+    disabled?: boolean;
+    [key: string]: unknown;
+}
+export type HysAutocompleteItem = string | HysAutocompleteOption;
+export interface HysAutocompleteGroup {
+    label: string;
+    options?: readonly HysAutocompleteDataOption[];
+    children?: readonly HysAutocompleteDataOption[];
+    disabled?: boolean;
+    key?: string | number;
+    type?: "group";
+}
+export type HysAutocompleteDataOption = HysAutocompleteItem | HysAutocompleteGroup;
+export interface HysAutocompleteContext {
+    signal: AbortSignal;
+}
+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 {
+    modelValue?: string;
+    defaultValue?: string;
+    options?: readonly HysAutocompleteDataOption[];
+    fetchSuggestions?: HysAutocompleteFetch | readonly HysAutocompleteDataOption[];
+    valueKey?: string;
+    labelKey?: string;
+    filterOption?: boolean | ((query: string, item: HysAutocompleteItem) => boolean);
+    caseSensitive?: boolean;
+    debounce?: number;
+    minQueryLength?: number;
+    triggerOnFocus?: boolean;
+    highlightFirst?: boolean;
+    loopNavigation?: boolean;
+    backfill?: boolean;
+    selectWhenUnmatched?: boolean;
+    selectOnTab?: boolean;
+    append?: boolean;
+    clearAfterSelect?: boolean;
+    blurAfterSelect?: boolean;
+    getShow?: (query: string) => boolean;
+    disabled?: boolean;
+    readonly?: boolean;
+    loading?: boolean;
+    hideLoading?: boolean;
+    clearable?: boolean;
+    clearIcon?: Component;
+    placeholder?: string;
+    label?: string;
+    ariaLabel?: string;
+    name?: string;
+    status?: "error" | "warning" | "success";
+    error?: string;
+    size?: "sm" | "md" | "lg";
+    bordered?: boolean;
+    autofocus?: boolean;
+    inputProps?: Omit<HysInputProps, "modelValue" | "defaultValue">;
+    open?: boolean;
+    defaultOpen?: boolean;
+    placement?: Placement;
+    popupMatchWidth?: boolean;
+    popupWidth?: number | string;
+    popupClass?: string;
+    popupStyle?: CSSProperties;
+    appendTo?: string | HTMLElement | false;
+    listHeight?: number;
+    emptyText?: string;
+    loadingText?: string;
+    errorText?: string;
+}
+export interface HysAutocompleteInstance {
+    input: HTMLInputElement | HTMLTextAreaElement | undefined;
+    isOpen: boolean;
+    loading: boolean;
+    highlightedIndex: number;
+    suggestions: readonly HysAutocompleteDataOption[];
+    focus: (options?: FocusOptions) => void;
+    blur: () => void;
+    open: () => Promise<void>;
+    close: () => void;
+    clear: () => void;
+    getData: () => Promise<void>;
+    retry: () => Promise<void>;
+    highlight: (index: number) => void;
+    select: (option: HysAutocompleteItem) => Promise<void>;
+}
+export interface HysAutocompleteRow {
+    key: string;
+    kind: "group" | "option";
+    label: string;
+    value: string;
+    disabled: boolean;
+    item: HysAutocompleteItem;
+    group?: HysAutocompleteGroup;
+}
+export declare function autocompleteValue(item: HysAutocompleteItem, key?: string, labelKey?: string): string;
+export declare function normalizeAutocomplete(data: readonly HysAutocompleteDataOption[], query: string, settings: {
+    valueKey: string;
+    labelKey: string;
+    filter: boolean | ((query: string, item: HysAutocompleteItem) => boolean);
+    caseSensitive: boolean;
+}): HysAutocompleteRow[];

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

@@ -0,0 +1,70 @@
+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";
+export type HysAvatarSize = number | "sm" | "md" | "lg" | "small" | "medium" | "default" | "large" | Partial<Record<HysAvatarBreakpoint, number>>;
+export type HysAvatarFit = "cover" | "contain" | "fill" | "none" | "scale-down";
+export interface HysAvatarProps {
+    name?: string;
+    src?: string;
+    srcset?: string;
+    srcSet?: string;
+    sizes?: string;
+    size?: HysAvatarSize;
+    shape?: "circle" | "square";
+    fit?: HysAvatarFit;
+    alt?: string;
+    icon?: Component;
+    gap?: number;
+    autoFit?: boolean;
+    color?: string;
+    textColor?: string;
+    bordered?: boolean;
+    radius?: number | string;
+    fallbackSrc?: string;
+    loadError?: (event: Event) => boolean | void;
+    draggable?: boolean;
+    crossOrigin?: "" | "anonymous" | "use-credentials";
+    lazy?: boolean;
+    imgProps?: ImgHTMLAttributes;
+}
+export interface HysAvatarLoadInfo {
+    src: string;
+    fallback: boolean;
+}
+export interface HysAvatarInstance {
+    element: HTMLElement | undefined;
+    image: HTMLImageElement | undefined;
+    loaded: boolean;
+    failed: boolean;
+    reload: () => void;
+}
+export interface HysAvatarOption extends HysAvatarProps {
+    key?: string | number;
+}
+export interface HysAvatarGroupInstance {
+    open: () => Promise<void>;
+    close: () => void;
+}
+export interface HysAvatarGroupProps {
+    options?: readonly HysAvatarOption[];
+    size?: HysAvatarSize;
+    shape?: "circle" | "square";
+    gap?: number;
+    maxCount?: number;
+    vertical?: boolean;
+    bordered?: boolean;
+    maxStyle?: CSSProperties;
+    maxClass?: string;
+    placement?: Placement;
+    trigger?: "hover" | "focus" | "click";
+    showOverflow?: boolean;
+    expandOnHover?: boolean;
+}
+export interface AvatarGroupContext {
+    size: ComputedRef<HysAvatarSize | undefined>;
+    shape: ComputedRef<"circle" | "square" | undefined>;
+    bordered: ComputedRef<boolean>;
+}
+export declare const avatarGroupKey: InjectionKey<AvatarGroupContext>;
+export declare function resolveAvatarSize(size: HysAvatarSize | undefined, viewport: number): number;
+export declare function useAvatarSize(size: ComputedRef<HysAvatarSize | undefined>): ComputedRef<number>;