hys-ui 0.1.0 → 0.2.0

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

@@ -0,0 +1,237 @@
+import type { CSSProperties, VNodeChild } from "vue";
+export type HysTreeKey = string | number;
+export type HysTreeValue = HysTreeKey | readonly HysTreeKey[] | null;
+export interface HysTreeNode<K extends HysTreeKey = HysTreeKey> {
+    id: K;
+    label: string;
+    children?: HysTreeNode<K>[];
+    disabled?: boolean;
+    disableCheckbox?: boolean;
+    selectable?: boolean;
+    checkable?: boolean;
+    icon?: string;
+    hasChildren?: boolean;
+    isLeaf?: boolean;
+    loading?: boolean;
+}
+/** Existing string-key node type remains available. */
+export type TreeNode = HysTreeNode<string>;
+export type HysTreeDropPosition = "before" | "inside" | "after";
+export interface HysTreeFieldNames {
+    id: string;
+    label: string;
+    children: string;
+    disabled: string;
+    disableCheckbox: string;
+    selectable: string;
+    checkable: string;
+    icon: string;
+    hasChildren: string;
+    isLeaf: string;
+}
+export interface HysTreeLoadContext {
+    signal: AbortSignal;
+    key: HysTreeKey;
+}
+export interface HysTreeLocale {
+    search: string;
+    empty: string;
+    noMatch: string;
+    loading: string;
+    retry: string;
+    loadError: string;
+    expand: string;
+    collapse: string;
+    check: string;
+    select: string;
+    clear: string;
+    close: string;
+    tree: string;
+}
+export interface HysTreeRecord<N extends object> {
+    key: HysTreeKey;
+    node: N;
+    label: string;
+    parent?: HysTreeKey;
+    children: HysTreeKey[];
+    depth: number;
+    index: number;
+    pos: number;
+    size: number;
+    disabled: boolean;
+    checkboxDisabled: boolean;
+    selectable: boolean;
+    checkable: boolean;
+    leaf: boolean;
+    hasChildren: boolean;
+    icon: unknown;
+}
+export interface HysTreeCheckInfo<N extends object> {
+    node?: N;
+    checked?: boolean;
+    checkedKeys: HysTreeKey[];
+    checkedNodes: N[];
+    halfCheckedKeys: HysTreeKey[];
+    halfCheckedNodes: N[];
+    event?: Event;
+}
+export interface HysTreeSelectInfo<N extends object> {
+    node: N | null;
+    selected: boolean;
+    selectedKeys: HysTreeKey[];
+    selectedNodes: N[];
+    event?: Event;
+}
+export interface HysTreeDropInfo<N extends object, K extends HysTreeKey = HysTreeKey> {
+    dragId: K;
+    targetId: K;
+    position: HysTreeDropPosition;
+    dragNode: N;
+    targetNode: N;
+    event: DragEvent;
+}
+export interface HysTreeNodeContext<N extends object> {
+    node: N;
+    key: HysTreeKey;
+    label: string;
+    depth: number;
+    expanded: boolean;
+    selected: boolean;
+    checked: boolean;
+    indeterminate: boolean;
+    disabled: boolean;
+    loading: boolean;
+    leaf: boolean;
+}
+export interface HysTreeProps<N extends object = TreeNode, V extends HysTreeValue = HysTreeValue> {
+    nodes: readonly N[];
+    modelValue?: V;
+    defaultValue?: V;
+    checkedKeys?: readonly HysTreeKey[];
+    defaultCheckedKeys?: readonly HysTreeKey[];
+    halfCheckedKeys?: readonly HysTreeKey[];
+    expandedKeys?: readonly HysTreeKey[];
+    defaultExpandedKeys?: readonly HysTreeKey[];
+    loadedKeys?: readonly HysTreeKey[];
+    multiple?: boolean;
+    selectable?: boolean;
+    checkable?: boolean;
+    searchable?: boolean;
+    disabled?: boolean;
+    inheritDisabled?: boolean;
+    loading?: boolean;
+    size?: "sm" | "md" | "lg";
+    defaultExpandAll?: boolean;
+    autoExpandParent?: boolean;
+    accordion?: boolean;
+    expandOnClickNode?: boolean;
+    expandOnDoubleClick?: boolean;
+    checkOnClickNode?: boolean;
+    checkOnClickLeaf?: boolean;
+    selectOnClickNode?: boolean;
+    allowDeselect?: boolean;
+    highlightCurrent?: boolean;
+    fieldNames?: Partial<HysTreeFieldNames>;
+    nodeKey?: string | ((node: N) => HysTreeKey);
+    showLine?: boolean;
+    showIcon?: boolean;
+    indent?: number;
+    blockNode?: boolean;
+    virtual?: boolean;
+    rowHeight?: number;
+    viewportHeight?: number;
+    overscan?: number;
+    draggable?: boolean;
+    dragExpandDelay?: number;
+    allowDrag?: (node: N) => boolean;
+    allowDrop?: (drag: N, target: N, position: HysTreeDropPosition) => boolean;
+    contextMenu?: boolean;
+    checkStrictly?: boolean;
+    searchValue?: string;
+    defaultSearchValue?: string;
+    searchPlaceholder?: string;
+    filterNode?: (query: string, node: N) => boolean;
+    filterMode?: "hide" | "highlight";
+    showMatchedChildren?: boolean;
+    emptyText?: string;
+    ariaLabel?: string;
+    locale?: Partial<HysTreeLocale>;
+    loadChildren?: (node: N, context: HysTreeLoadContext) => Promise<readonly N[]>;
+    renderContent?: (context: HysTreeNodeContext<N>) => VNodeChild;
+    nodeClass?: string | ((node: N) => string | undefined);
+    nodeStyle?: CSSProperties | ((node: N) => CSSProperties | undefined);
+    validateEvent?: boolean;
+}
+export interface HysTreeInstance<N extends object = TreeNode> {
+    readonly element: HTMLElement | undefined;
+    getNode: (key: HysTreeKey | N) => N | undefined;
+    getNodeInfo: (key: HysTreeKey | N) => HysTreeRecord<N> | undefined;
+    getCheckedKeys: (leafOnly?: boolean) => HysTreeKey[];
+    getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: 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, checked: boolean, deep?: boolean) => Promise<boolean>;
+    getCurrentKey: () => HysTreeKey | null;
+    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[]) => Promise<boolean>;
+    getExpandedKeys: () => HysTreeKey[];
+    setExpandedKeys: (keys: readonly HysTreeKey[]) => Promise<boolean>;
+    expandNode: (key: HysTreeKey, expanded?: boolean) => Promise<boolean>;
+    expandAll: () => Promise<boolean>;
+    collapseAll: () => Promise<boolean>;
+    filter: (value: string) => void;
+    reloadNode: (key: HysTreeKey) => Promise<boolean>;
+    updateKeyChildren: (key: HysTreeKey, children: readonly N[]) => Promise<boolean>;
+    append: (node: N, parent?: HysTreeKey | N) => Promise<boolean>;
+    insertBefore: (node: N, reference: HysTreeKey | N) => Promise<boolean>;
+    insertAfter: (node: N, reference: 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>;
+}
+export declare const treeLocale: HysTreeLocale;
+export declare const treeKey: (v: unknown) => v is HysTreeKey;
+export declare const treeKeys: (v: readonly HysTreeKey[]) => HysTreeKey[];
+export declare function treeField(value: unknown, path: string): unknown;
+export declare function treeAssign<N extends object>(node: N, path: string, value: unknown): N;
+export declare function treeFields<N extends object>(props: HysTreeProps<N>): {
+    id: string;
+    label: string;
+    children: string;
+    disabled: string;
+    disableCheckbox: string;
+    selectable: string;
+    checkable: string;
+    icon: string;
+    hasChildren: string;
+    isLeaf: string;
+};
+export declare function treeIndex<N extends object>(nodes: readonly N[], props: HysTreeProps<N>, asyncChildren?: Map<HysTreeKey, readonly N[]>): {
+    map: Map<HysTreeKey, HysTreeRecord<N>>;
+    rows: HysTreeRecord<N>[];
+    roots: HysTreeKey[];
+    fields: {
+        id: string;
+        label: string;
+        children: string;
+        disabled: string;
+        disableCheckbox: string;
+        selectable: string;
+        checkable: string;
+        icon: string;
+        hasChildren: string;
+        isLeaf: string;
+    };
+    invalid: boolean;
+};

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

@@ -0,0 +1,167 @@
+import type { CSSProperties, VNodeChild } from "vue";
+import { type HysTreeKey, type HysTreeFieldNames, type HysTreeLoadContext, type HysTreeLocale } from "./tree";
+import type { Placement } from "./useFloating";
+export interface HysTreeSelectDataNode<K extends HysTreeKey = HysTreeKey> {
+    value: K;
+    label: string;
+    children?: HysTreeSelectDataNode<K>[];
+    disabled?: boolean;
+    disableCheckbox?: boolean;
+    checkable?: boolean;
+    selectable?: boolean;
+    hasChildren?: boolean;
+    isLeaf?: boolean;
+}
+export type HysTreeSelectNode = HysTreeSelectDataNode<string>;
+export interface HysTreeSelectLabelValue {
+    value: HysTreeKey;
+    label?: VNodeChild;
+    disabled?: boolean;
+}
+export type HysTreeSelectValue = HysTreeKey | HysTreeSelectLabelValue | readonly (HysTreeKey | HysTreeSelectLabelValue)[] | null;
+export interface HysTreeSelectFieldNames extends Omit<HysTreeFieldNames, "id"> {
+    value: string;
+}
+export interface HysTreeSelectSimpleMode {
+    id?: string;
+    parentId?: string;
+    rootParentId?: HysTreeKey | null;
+}
+export type HysTreeSelectStrategy = "all" | "parent" | "child";
+export interface HysTreeSelectItem<N extends object = HysTreeSelectNode> {
+    value: HysTreeKey;
+    label: VNodeChild;
+    node?: N;
+    disabled: boolean;
+    missing: boolean;
+}
+export interface HysTreeSelectChange<N extends object = HysTreeSelectNode> {
+    reason: "select" | "check" | "remove" | "clear" | "api";
+    node?: N;
+    values: HysTreeKey[];
+    items: HysTreeSelectItem<N>[];
+    halfCheckedKeys: HysTreeKey[];
+    event?: Event;
+}
+export interface HysTreeSelectProps<N extends object = HysTreeSelectNode, V extends HysTreeSelectValue = HysTreeSelectValue> {
+    modelValue?: V;
+    defaultValue?: V;
+    nodes: readonly N[];
+    cacheData?: readonly N[];
+    fieldNames?: Partial<HysTreeSelectFieldNames>;
+    nodeKey?: string | ((node: N) => HysTreeKey);
+    simpleMode?: boolean | HysTreeSelectSimpleMode;
+    labelInValue?: boolean;
+    disabled?: boolean;
+    readonly?: boolean;
+    loading?: boolean;
+    size?: "sm" | "md" | "lg";
+    status?: "error" | "warning" | "success";
+    placeholder?: string;
+    ariaLabel?: string;
+    name?: string;
+    multiple?: boolean;
+    leafOnly?: boolean;
+    checkable?: boolean;
+    checkStrictly?: boolean;
+    showCheckedStrategy?: HysTreeSelectStrategy;
+    clearable?: boolean;
+    clearValue?: HysTreeKey | null;
+    removable?: boolean;
+    multipleLimit?: number;
+    maxTagCount?: number;
+    maxTagTextLength?: number;
+    searchable?: boolean;
+    searchValue?: string;
+    defaultSearchValue?: string;
+    searchPlaceholder?: string;
+    filterNode?: (query: string, node: N) => boolean;
+    filterMode?: "hide" | "highlight";
+    showMatchedChildren?: boolean;
+    retainSearch?: boolean;
+    clearSearchAfterSelect?: boolean;
+    remote?: boolean;
+    remoteMethod?: (query: string, context: {
+        signal: AbortSignal;
+    }) => void | readonly N[] | Promise<void | readonly N[]>;
+    debounce?: number;
+    expandedKeys?: readonly HysTreeKey[];
+    defaultExpandedKeys?: readonly HysTreeKey[];
+    defaultExpandAll?: boolean;
+    autoExpandParent?: boolean;
+    accordion?: boolean;
+    expandOnClickNode?: boolean;
+    expandSelected?: boolean;
+    loadedKeys?: readonly HysTreeKey[];
+    loadChildren?: (node: N, context: HysTreeLoadContext) => Promise<readonly N[]>;
+    showLine?: boolean;
+    showIcon?: boolean;
+    indent?: number;
+    open?: boolean;
+    defaultOpen?: boolean;
+    showOnFocus?: boolean;
+    popupMatchWidth?: boolean;
+    popupWidth?: number | string;
+    popupClass?: string;
+    popupStyle?: CSSProperties;
+    appendTo?: string | HTMLElement | false;
+    placement?: Placement;
+    listHeight?: number;
+    virtual?: boolean;
+    itemHeight?: number;
+    overscan?: number;
+    emptyText?: string;
+    noMatchText?: string;
+    loadingText?: string;
+    locale?: Partial<HysTreeLocale>;
+    validateEvent?: boolean;
+}
+export interface HysTreeSelectInstance<N extends object = HysTreeSelectNode> {
+    readonly element: HTMLElement | undefined;
+    readonly open: boolean;
+    focus: () => void;
+    blur: () => void;
+    show: () => Promise<boolean>;
+    hide: (restoreFocus?: boolean) => void;
+    clear: () => Promise<boolean>;
+    removeTag: (key: HysTreeKey) => Promise<boolean>;
+    setValue: (value: HysTreeSelectValue) => Promise<boolean>;
+    filter: (query: 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, expanded?: boolean) => Promise<boolean>;
+    reloadNode: (key: HysTreeKey) => Promise<boolean>;
+    scrollTo: (options: {
+        key?: HysTreeKey;
+        top?: number;
+        align?: "top" | "bottom" | "auto";
+    }) => Promise<void>;
+}
+export declare function treeSelectFields<N extends object>(props: HysTreeSelectProps<N>): Partial<HysTreeFieldNames>;
+export declare function treeSelectForest<N extends object>(nodes: readonly N[], props: HysTreeSelectProps<N>): {
+    nodes: readonly N[];
+    raw: Map<HysTreeKey, N>;
+};
+export declare const selectTreeIndex: <N extends object>(nodes: readonly N[], props: HysTreeSelectProps<N>) => {
+    map: Map<HysTreeKey, import("./tree").HysTreeRecord<N>>;
+    rows: import("./tree").HysTreeRecord<N>[];
+    roots: HysTreeKey[];
+    fields: {
+        id: string;
+        label: string;
+        children: string;
+        disabled: string;
+        disableCheckbox: string;
+        selectable: string;
+        checkable: string;
+        icon: string;
+        hasChildren: string;
+        isLeaf: string;
+    };
+    invalid: boolean;
+};

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

@@ -0,0 +1,162 @@
+import { type ComputedRef } from "vue";
+import { type HysTreeKey, type HysTreeRecord } from "./tree";
+import type { HysTreeSelectValue } from "./treeSelect";
+import { type CascaderEntry, type HysCascaderProps, type HysCascaderValue, type HysCascaderKey, type HysCascaderPath, type HysCascaderItem } from "./cascader";
+export declare function useCascader<N extends object>(props: HysCascaderProps<N>, disabled: ComputedRef<boolean>, active: ComputedRef<boolean>, emit: (name: string, ...args: any[]) => void, validate: () => void): {
+    engine: {
+        tree: {
+            live: import("vue").Ref<boolean, boolean>;
+            busy: ComputedRef<boolean>;
+            index: ComputedRef<{
+                map: Map<HysTreeKey, HysTreeRecord<CascaderEntry<N>>>;
+                rows: HysTreeRecord<CascaderEntry<N>>[];
+                roots: HysTreeKey[];
+                fields: {
+                    id: string;
+                    label: string;
+                    children: string;
+                    disabled: string;
+                    disableCheckbox: string;
+                    selectable: string;
+                    checkable: string;
+                    icon: string;
+                    hasChildren: string;
+                    isLeaf: string;
+                };
+                invalid: boolean;
+            }>;
+            words: ComputedRef<{
+                search: string;
+                empty: string;
+                noMatch: string;
+                loading: string;
+                retry: string;
+                loadError: string;
+                expand: string;
+                collapse: string;
+                check: string;
+                select: string;
+                clear: string;
+                close: string;
+                tree: string;
+            }>;
+            query: ComputedRef<string>;
+            expanded: ComputedRef<Set<HysTreeKey>>;
+            rawExpanded: ComputedRef<HysTreeKey[]>;
+            selected: ComputedRef<HysTreeKey[]>;
+            selection: ComputedRef<Set<HysTreeKey>>;
+            multiple: ComputedRef<boolean>;
+            visible: ComputedRef<HysTreeRecord<CascaderEntry<N>>[]>;
+            matches: ComputedRef<Set<HysTreeKey>>;
+            checked: ComputedRef<Set<HysTreeKey>>;
+            halfChecked: ComputedRef<Set<HysTreeKey>>;
+            loadingKeys: import("vue").ShallowRef<Set<HysTreeKey>, Set<HysTreeKey>>;
+            failures: import("vue").ShallowRef<Map<HysTreeKey, unknown>, Map<HysTreeKey, unknown>>;
+            ancestors: (key: HysTreeKey) => HysTreeKey[];
+            getNode: (key: HysTreeKey | CascaderEntry<N>) => CascaderEntry<N> | undefined;
+            getNodeInfo: (key: HysTreeKey | CascaderEntry<N>) => HysTreeRecord<CascaderEntry<N>> | undefined;
+            getCheckedKeys: (leafOnly?: boolean) => HysTreeKey[];
+            getCheckedNodes: (leafOnly?: boolean, includeHalf?: boolean) => CascaderEntry<N>[];
+            getHalfCheckedKeys: () => HysTreeKey[];
+            checkInfo: (node?: CascaderEntry<N> | undefined, on?: boolean, event?: Event) => import("./tree").HysTreeCheckInfo<CascaderEntry<N>>;
+            setCheckedKeys: (keys: readonly HysTreeKey[], leafOnly?: boolean) => Promise<boolean>;
+            setChecked: (key: HysTreeKey | CascaderEntry<N>, on: boolean, deep?: boolean, event?: Event) => Promise<boolean>;
+            selectNode: (row: HysTreeRecord<CascaderEntry<N>>, event?: Event) => Promise<boolean>;
+            setSelectedKeys: (keys: readonly HysTreeKey[], node?: CascaderEntry<N> | null, event?: Event) => Promise<boolean>;
+            setCurrentKey: (key: HysTreeKey | null, expandParents?: boolean) => Promise<boolean>;
+            getCurrentKey: () => HysTreeKey;
+            getCurrentNode: () => CascaderEntry<N> | null;
+            setExpandedKeys: (keys: readonly HysTreeKey[]) => Promise<boolean>;
+            expandNode: (key: HysTreeKey, on?: boolean) => Promise<boolean>;
+            filter: (q: string) => void;
+            reloadNode: (key: HysTreeKey) => Promise<boolean>;
+            load: (key: HysTreeKey, force?: boolean) => Promise<boolean>;
+            append: (node: CascaderEntry<N>, parent?: HysTreeKey | CascaderEntry<N> | undefined) => Promise<boolean>;
+            remove: (key: HysTreeKey | CascaderEntry<N>) => Promise<boolean>;
+            insertBefore: (node: CascaderEntry<N>, key: HysTreeKey | CascaderEntry<N>) => Promise<boolean>;
+            insertAfter: (node: CascaderEntry<N>, key: HysTreeKey | CascaderEntry<N>) => Promise<boolean>;
+            updateKeyChildren: (key: HysTreeKey, children: readonly CascaderEntry<N>[]) => Promise<boolean>;
+        };
+        live: import("vue").Ref<boolean, boolean>;
+        current: ComputedRef<HysTreeSelectValue>;
+        values: ComputedRef<HysTreeKey[]>;
+        multiple: ComputedRef<boolean>;
+        query: ComputedRef<string>;
+        items: ComputedRef<import("./treeSelect").HysTreeSelectItem<CascaderEntry<N>>[]>;
+        displayKeys: ComputedRef<HysTreeKey[]>;
+        busy: ComputedRef<boolean>;
+        blocked: ComputedRef<boolean>;
+        words: ComputedRef<{
+            search: string;
+            empty: string;
+            noMatch: string;
+            loading: string;
+            retry: string;
+            loadError: string;
+            expand: string;
+            collapse: string;
+            check: string;
+            select: string;
+            clear: string;
+            close: string;
+            tree: string;
+        }>;
+        remotePending: import("vue").Ref<boolean, boolean>;
+        remoteError: import("vue").ShallowRef<unknown, unknown>;
+        rawNode: (node: CascaderEntry<N>) => CascaderEntry<N>;
+        keyOf: (node: CascaderEntry<N>) => HysTreeKey;
+        item: (key: HysTreeKey) => import("./treeSelect").HysTreeSelectItem<CascaderEntry<N>>;
+        pick: (row: HysTreeRecord<CascaderEntry<N>>, event?: Event) => Promise<boolean>;
+        filter: (text: string) => void;
+        clear: () => Promise<boolean>;
+        removeTag: (key: HysTreeKey) => Promise<boolean>;
+        request: (keys: readonly HysTreeKey[], reason: "clear" | "select" | "check" | "remove" | "api", node?: CascaderEntry<N> | undefined, event?: Event, provided?: HysTreeSelectValue, halfKeys?: HysTreeKey[]) => Promise<boolean>;
+        project: (keys: readonly HysTreeKey[]) => HysTreeKey[];
+        retrySearch: () => Promise<void>;
+        setValue: (value: HysTreeSelectValue) => Promise<boolean>;
+    };
+    entries: ComputedRef<Map<string, CascaderEntry<N>>>;
+    current: ComputedRef<HysCascaderValue>;
+    multiple: ComputedRef<boolean>;
+    items: ComputedRef<HysCascaderItem<N>[]>;
+    columns: ComputedRef<CascaderEntry<N>[][]>;
+    browsing: ComputedRef<HysTreeKey[]>;
+    anyLevel: ComputedRef<boolean>;
+    blocked: ComputedRef<boolean>;
+    words: ComputedRef<{
+        search: string;
+        empty: string;
+        noMatch: string;
+        loading: string;
+        panel: string;
+        loadError: string;
+        retry: string;
+        clear: string;
+        close: string;
+        level: string;
+        expand: string;
+        remove: string;
+        more: string;
+        limit: string;
+    }>;
+    checking: import("vue").Ref<boolean, boolean>;
+    selectedPaths: ComputedRef<HysTreeKey[][]>;
+    modelKeys: ComputedRef<string[]>;
+    rootPending: import("vue").Ref<boolean, boolean>;
+    rootError: import("vue").ShallowRef<unknown, unknown>;
+    filterPending: import("vue").Ref<boolean, boolean>;
+    filterError: import("vue").ShallowRef<unknown, unknown>;
+    searchResults: ComputedRef<CascaderEntry<N>[]>;
+    item: (key: string) => HysCascaderItem<N>;
+    pick: (key: string, event?: Event, checked?: boolean) => Promise<boolean>;
+    expandPath: (path: HysCascaderPath) => Promise<boolean>;
+    removeTag: (value: HysCascaderPath | HysCascaderKey) => Promise<boolean>;
+    setValue: (value: HysCascaderValue) => Promise<boolean>;
+    clear: () => Promise<boolean>;
+    filter: (text: string) => void;
+    reloadRoot: (force?: boolean) => Promise<boolean>;
+    retrySearch: () => Promise<void>;
+    reloadNode: (path: HysCascaderPath) => Promise<boolean>;
+    getCheckedNodes: (leafOnly?: boolean) => N[];
+};
+export type HysCascaderStore<N extends object> = ReturnType<typeof useCascader<N>>;

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

@@ -0,0 +1,79 @@
+import { type ComputedRef } from "vue";
+import { type HysDatePoint, type HysDatePickerProps, type HysDatePickerValue, type HysDatePickerView, type HysDatePickerChange } from "./datePicker";
+export declare function useDatePicker(props: HysDatePickerProps, range: ComputedRef<boolean>, blocked: ComputedRef<boolean>, emit: (name: string, ...args: any[]) => void, validate: () => void): {
+    current: ComputedRef<HysDatePickerValue>;
+    selected: ComputedRef<(HysDatePoint | null)[]>;
+    draft: import("vue").ShallowRef<(HysDatePoint | null)[], (HysDatePoint | null)[]>;
+    stage: import("vue").Ref<"end" | "start", "end" | "start">;
+    preview: import("vue").Ref<number | undefined, number | undefined>;
+    error: import("vue").Ref<string, string>;
+    view: ComputedRef<HysDatePickerView>;
+    rightView: import("vue").Ref<HysDatePickerView, HysDatePickerView>;
+    panels: ComputedRef<number[]>;
+    first: ComputedRef<number>;
+    weekContains: ComputedRef<number>;
+    time: ComputedRef<boolean>;
+    unit: ComputedRef<import("./datePicker").HysDatePickerUnit>;
+    multiple: ComputedRef<boolean>;
+    pattern: ComputedRef<string>;
+    displayPattern: ComputedRef<string>;
+    words: ComputedRef<{
+        today: string;
+        now: string;
+        clear: string;
+        cancel: string;
+        close: string;
+        confirm: string;
+        start: string;
+        end: string;
+        chooseStart: string;
+        chooseEnd: string;
+        invalid: string;
+        week: string;
+        year: string;
+        month: string;
+        back: string;
+        prevMonth: string;
+        nextMonth: string;
+        prevYear: string;
+        nextYear: string;
+        hour: string;
+        minute: string;
+        second: string;
+        empty: string;
+        limit: string;
+    }>;
+    needsConfirm: ComputedRef<boolean>;
+    today: ComputedRef<HysDatePoint>;
+    model: {
+        current: ComputedRef<HysDatePickerValue>;
+        commit: (value: HysDatePickerValue, update: (value: HysDatePickerValue) => void, change: (value: HysDatePickerValue) => void, notifyOnRequest?: boolean) => Promise<boolean>;
+        reset: () => void;
+        invalidate: () => void;
+        isLive: () => boolean;
+    };
+    outputType: ComputedRef<"string" | "date" | "timestamp">;
+    parse: (value: unknown) => HysDatePoint | undefined;
+    boundary: (value: unknown) => HysDatePoint | undefined;
+    points: (value?: HysDatePickerValue | undefined) => (HysDatePoint | null)[];
+    available: (day: number, endpoint?: number, rangeLimit?: boolean) => boolean;
+    periodAvailable: (start: number, end: number, endpoint?: number, rangeLimit?: boolean) => boolean;
+    validTime: (point: HysDatePoint, endpoint: number) => boolean;
+    valid: (list: readonly (HysDatePoint | null)[], enforceLocks?: boolean) => boolean;
+    timeDisabled: (point: HysDatePoint, endpoint: number) => import("./datePicker").HysDateDisabledTime;
+    encode: (list: readonly (HysDatePoint | null)[]) => HysDatePickerValue;
+    describe: (list?: (HysDatePoint | null)[]) => string[];
+    empty: () => HysDatePickerValue;
+    request: (value: HysDatePickerValue, source: HysDatePickerChange["source"], allowClear?: boolean) => Promise<boolean>;
+    begin: () => void;
+    setPanel: (day: number, index?: number) => boolean;
+    setMode: (mode: HysDatePickerView, index?: number) => boolean;
+    choose: (day: number) => Promise<boolean>;
+    clear: () => Promise<boolean>;
+    confirm: () => Promise<boolean>;
+    setValue: (value: HysDatePickerValue) => Promise<boolean>;
+    setTime: (index: number, second: number) => boolean;
+    input: (value: string, index?: number) => Promise<boolean>;
+    pickShortcut: (index: number) => boolean;
+    locked: (endpoint: number) => boolean;
+};

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

@@ -1,5 +1,5 @@
-import { type Ref } from 'vue';
-export type Placement = 'bottom-start' | 'bottom-end' | 'top-start' | 'top-end' | 'right' | 'left';
+import { type Ref } from "vue";
+export type Placement = "bottom-start" | "bottom-end" | "top-start" | "top-end" | "right" | "left";
 export interface FloatingAnchor {
     getBoundingClientRect(): DOMRect;
     contains(node: Node | null): boolean;
@@ -10,14 +10,17 @@ export declare function useFloating(anchor: Readonly<Ref<FloatingAnchor | undefi
     placement?: Placement;
     gap?: number;
     padding?: number;
-    matchWidth?: boolean;
+    matchWidth?: boolean | "min" | (() => boolean | "min");
+    width?: () => number | string | undefined;
+    requestOpen?: (open: boolean, restoreFocus?: boolean) => boolean | void;
+    closeOnTab?: boolean;
 }): {
     open: Ref<boolean, boolean>;
     style: Ref<Record<string, string>, Record<string, string>>;
     placement: Ref<Placement, Placement>;
     update: () => void;
-    show: () => Promise<void>;
-    close: (restore?: boolean) => void;
+    show: (force?: boolean) => Promise<void>;
+    close: (restore?: boolean, force?: boolean) => void;
     toggle: () => void | Promise<void>;
     restoringFocus: Ref<boolean, boolean>;
 };