hys-ui 0.1.0 → 0.2.0

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

@@ -0,0 +1,83 @@
+import { type ComputedRef, type Ref } from "vue";
+import type { HysGanttDependencyChange, HysGanttDependencyInvalid, HysGanttDependencyMove, HysGanttDependencyReason, HysGanttScrollOptions } from "./gantt";
+type Id = string | number;
+interface Task {
+    id: Id;
+    title: string;
+    disabled?: boolean;
+    dependencies?: Id[];
+}
+interface Position {
+    x: number;
+    y: number;
+    w: number;
+    index: number;
+}
+interface Draft {
+    sourceId: Id;
+    previousTargetId?: Id;
+    targetId?: Id;
+    mode: "pointer" | "keyboard";
+    point: {
+        x: number;
+        y: number;
+    };
+    reason: HysGanttDependencyReason | null;
+}
+interface Context<T extends Task> {
+    items: () => readonly T[];
+    rows: () => readonly T[];
+    enabled: ComputedRef<boolean>;
+    live: () => boolean;
+    root: Ref<HTMLElement | undefined>;
+    viewport: Ref<HTMLElement | null>;
+    grid: Ref<HTMLElement | null>;
+    labelWidth: () => number;
+    rowHeight: () => number;
+    position: (id: Id) => Position | undefined;
+    locate: (id: Id, options?: HysGanttScrollOptions) => Promise<boolean>;
+    cancelTask: () => void;
+    update: (items: T[], info: HysGanttDependencyChange | HysGanttDependencyMove) => boolean;
+    change: (item: T) => void;
+    added: (info: HysGanttDependencyChange, item: T) => void;
+    removed: (info: HysGanttDependencyChange, item: T) => void;
+    moved: (info: HysGanttDependencyMove, item: T, previousItem: T) => void;
+    invalid: (info: HysGanttDependencyInvalid) => void;
+}
+export declare function ganttDependencyPath(from: {
+    x: number;
+    y: number;
+    w: number;
+}, to: {
+    x: number;
+    y: number;
+}, rowHeight?: number): string;
+export declare function ganttDependencyPickPath(from: {
+    x: number;
+    y: number;
+    w: number;
+}, to: {
+    x: number;
+    y: number;
+}, rowHeight?: number): string;
+export declare function useGanttDependencies<T extends Task>(ctx: Context<T>): {
+    draft: import("vue").ShallowRef<Draft | undefined, Draft | undefined>;
+    selected: ComputedRef<HysGanttDependencyChange | undefined>;
+    message: Ref<string, string>;
+    path: ComputedRef<string>;
+    add: (sourceId: Id, targetId: Id) => Promise<boolean>;
+    remove: (sourceId: Id, targetId: Id) => Promise<boolean>;
+    moveTarget: (sourceId: Id, previousTargetId: Id, targetId: Id) => Promise<boolean>;
+    cancel: (clearMessage?: boolean) => void;
+    beginPointer: (event: PointerEvent, source: Id, previousTargetId?: Id) => void;
+    move: (event: PointerEvent) => void;
+    end: (event: PointerEvent) => void;
+    lost: (event: PointerEvent) => void;
+    clickSource: (event: MouseEvent, id: Id, previousTargetId?: Id) => void;
+    beginKeyboard: (source: Id, previousTargetId?: Id) => void;
+    key: (event: KeyboardEvent) => void;
+    selectEdge: (event: Event, sourceId: Id, targetId: Id) => void;
+    clearSelected: () => void;
+    submit: (targetId?: Id) => Promise<boolean>;
+};
+export {};

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

@@ -0,0 +1,42 @@
+import type { HysGanttHistoryEntry, HysGanttHistoryInvalid, HysGanttHistoryState } from "./gantt";
+type Id = string | number;
+type Field = "start" | "end" | "dependencies";
+export interface GanttHistoryTask {
+    id: Id;
+    start: string;
+    end: string;
+    dependencies?: Id[];
+    disabled?: boolean;
+}
+interface Snapshot {
+    id: Id;
+    start: string;
+    end: string;
+    dependencies?: Id[];
+}
+export declare function useGanttHistory<T extends GanttHistoryTask>(ctx: {
+    items: () => readonly T[];
+    enabled: () => boolean;
+    limit: () => number;
+    live: () => boolean;
+    allowed: (item: T, fields: Field[], next: Partial<Snapshot>) => boolean;
+    send: (items: T[]) => void;
+    change: (item: T) => void;
+    beforeReplay: () => void;
+    external: () => void;
+    state: (state: HysGanttHistoryState) => void;
+    replay: (action: "undo" | "redo", entry: HysGanttHistoryEntry) => void;
+    invalid: (info: HysGanttHistoryInvalid) => void;
+}): {
+    capture: (items: T[], info: Omit<HysGanttHistoryEntry, "taskIds">) => boolean;
+    clear: () => void;
+    undo: () => Promise<boolean>;
+    redo: () => Promise<boolean>;
+    state: import("vue").ComputedRef<HysGanttHistoryState>;
+    canUndo: import("vue").ComputedRef<boolean>;
+    canRedo: import("vue").ComputedRef<boolean>;
+    pending: import("vue").Ref<boolean, boolean>;
+    enabled: import("vue").ComputedRef<boolean>;
+    message: import("vue").Ref<string, string>;
+};
+export {};

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

@@ -0,0 +1,23 @@
+import { type Ref } from "vue";
+export declare function useGanttLabelResize(options: {
+    width: () => number;
+    min: () => number;
+    max: () => number;
+    enabled: () => boolean;
+    available: Ref<number>;
+    live: () => boolean;
+    start: () => void;
+    update: (width: number) => void;
+    commit: (width: number) => void;
+}): {
+    width: import("vue").ComputedRef<number>;
+    minimum: import("vue").ComputedRef<number>;
+    maximum: import("vue").ComputedRef<number>;
+    resizing: Ref<boolean, boolean>;
+    down: (event: PointerEvent) => void;
+    move: (event: PointerEvent) => void;
+    up: (event: PointerEvent) => void;
+    cancel: () => void;
+    key: (event: KeyboardEvent) => void;
+    reset: () => void;
+};

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

@@ -0,0 +1,50 @@
+import { type VNodeChild } from 'vue';
+import type { HysToastPosition, HysToastType } from '../components/HysToast/HysToast.vue';
+import { type HysConfig } from '../config';
+export interface HysToastOptions {
+    id?: string;
+    message?: string;
+    content?: VNodeChild | (() => VNodeChild);
+    type?: HysToastType;
+    duration?: number;
+    closable?: boolean;
+    position?: HysToastPosition;
+    offset?: number;
+    zIndex?: number;
+    showIcon?: boolean;
+    icon?: VNodeChild | (() => VNodeChild);
+    plain?: boolean;
+    pauseOnHover?: boolean;
+    closeOnEscape?: boolean;
+    grouping?: boolean;
+    onClose?: () => void;
+    onAfterClose?: () => void;
+}
+export interface HysToastConfig extends Omit<HysToastOptions, 'id' | 'message' | 'content' | 'icon' | 'onClose' | 'onAfterClose'> {
+    maxCount?: number;
+    appendTo?: string | HTMLElement | ShadowRoot;
+}
+export interface HysToastHandle {
+    readonly id: string;
+    readonly closed: Promise<void>;
+    close(): void;
+    update(value: string | Omit<Partial<HysToastOptions>, 'id'>): void;
+}
+export interface HysToastApi {
+    show(value: string | HysToastOptions): HysToastHandle;
+    success(value: string | Omit<HysToastOptions, 'type'>): HysToastHandle;
+    info(value: string | Omit<HysToastOptions, 'type'>): HysToastHandle;
+    warning(value: string | Omit<HysToastOptions, 'type'>): HysToastHandle;
+    error(value: string | Omit<HysToastOptions, 'type'>): HysToastHandle;
+    loading(value: string | Omit<HysToastOptions, 'type'>): HysToastHandle;
+    closeAll(): void;
+}
+export interface HysToastServiceConfig extends HysToastConfig, HysConfig {
+}
+export interface HysToastService extends HysToastApi {
+    dispose(): void;
+}
+/** Call during setup. Messages inherit the owner's theme and are removed when its scope leaves. */
+export declare function useHysToast(config?: HysToastConfig): HysToastApi;
+/** Create a shared service for callers outside setup; dispose it when the owning application ends. */
+export declare function createHysToast(config?: HysToastServiceConfig): HysToastService;

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

@@ -0,0 +1,60 @@
+import { type HysTableProps, type HysTableKey, type HysTableColumn, type HysTableSort, type HysTableFilters, type HysTableFilterValue, type HysTableQuery, type TableNode } from "./table";
+export declare function useTable<T extends object>(props: HysTableProps<T>, columns: () => readonly HysTableColumn<T>[], hasExpand: () => boolean, emit: (name: string, ...args: any[]) => void): {
+    live: import("vue").Ref<boolean, boolean>;
+    busy: import("vue").ComputedRef<boolean>;
+    graph: import("vue").ComputedRef<{
+        roots: TableNode<T>[];
+        all: TableNode<T>[];
+        map: Map<string, TableNode<T>>;
+    }>;
+    rowId: (row: T) => HysTableKey;
+    selectedKeys: import("vue").ComputedRef<HysTableKey[]>;
+    selectedSet: import("vue").ComputedRef<Set<string>>;
+    expandedKeys: import("vue").ComputedRef<HysTableKey[]>;
+    expandedSet: import("vue").ComputedRef<Set<string>>;
+    halfSet: import("vue").ComputedRef<Set<string>>;
+    eligible: (node: TableNode<T>) => boolean;
+    allSelected: import("vue").ComputedRef<boolean>;
+    someSelected: import("vue").ComputedRef<boolean>;
+    sorts: import("vue").ComputedRef<HysTableSort[]>;
+    filters: import("vue").ComputedRef<HysTableFilters>;
+    processed: import("vue").ComputedRef<{
+        roots: TableNode<T>[];
+        children: Map<string, TableNode<T>[]>;
+    }>;
+    filteredRows: import("vue").ComputedRef<T[]>;
+    display: import("vue").ComputedRef<TableNode<T>[]>;
+    page: import("vue").ComputedRef<number>;
+    pageSize: import("vue").ComputedRef<number>;
+    total: import("vue").ComputedRef<number>;
+    pagination: import("vue").ComputedRef<import("./table").HysTablePagination>;
+    currentKey: import("vue").ComputedRef<HysTableKey | null>;
+    currentRow: import("vue").ComputedRef<T | undefined>;
+    query: import("vue").ComputedRef<HysTableQuery<T>>;
+    pending: import("vue").ShallowRef<Map<string, {
+        row: T;
+        controller: AbortController;
+    }>, Map<string, {
+        row: T;
+        controller: AbortController;
+    }>>;
+    loadErrors: import("vue").ShallowRef<Map<string, unknown>, Map<string, unknown>>;
+    canExpand: (node: TableNode<T>) => boolean;
+    toggleSort: (column: HysTableColumn<T>, direction?: "asc" | "desc") => void;
+    setSort: (value: HysTableSort | readonly HysTableSort[] | null) => void;
+    setFilter: (key: string, values: readonly HysTableFilterValue[]) => void;
+    clearFilter: (keys?: readonly string[]) => void;
+    requestPage: (n: number, action?: "page" | "pageSize") => void;
+    changeSize: (n: number) => void;
+    toggleRowSelection: (value: T | HysTableKey, checked?: boolean, range?: boolean) => Promise<boolean>;
+    toggleAllSelection: (checked?: boolean) => Promise<boolean>;
+    invertSelection: () => Promise<boolean>;
+    clearSelection: () => Promise<boolean>;
+    getSelectionRows: () => T[];
+    getHalfSelectionRows: () => T[];
+    setCurrentRow: (value?: T | HysTableKey | null) => Promise<boolean>;
+    toggleRowExpansion: (value: T | HysTableKey, expanded?: boolean) => Promise<boolean>;
+    loadRow: (value: T | HysTableKey, force?: boolean) => Promise<boolean>;
+    updateKeyChildren: (value: T | HysTableKey, children: readonly T[]) => Promise<boolean>;
+    find: (value: T | HysTableKey) => TableNode<T> | undefined;
+};

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

@@ -0,0 +1,3 @@
+import { type Ref } from "vue";
+import type { HysInputProps } from "./textInput";
+export declare function useTextareaSize(input: Ref<HTMLInputElement | HTMLTextAreaElement | undefined>, props: HysInputProps, size: Ref<string>, value: Ref<string>): () => Promise<void>;

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

@@ -0,0 +1,58 @@
+import { type ComputedRef } from "vue";
+import { type HysTransferProps, type HysTransferKey, type HysTransferSide } from "./transfer";
+export declare function useTransfer<T extends object, K extends HysTransferKey>(props: HysTransferProps<T, K>, disabled: ComputedRef<boolean>, emit: (name: string, ...args: any[]) => void, validate: () => void): {
+    live: import("vue").Ref<boolean, boolean>;
+    busy: ComputedRef<boolean>;
+    pending: import("vue").Ref<boolean, boolean>;
+    data: ComputedRef<{
+        rows: import("./transfer").HysTransferRecord<T, K>[];
+        map: Map<K, import("./transfer").HysTransferRecord<T, K>>;
+    }>;
+    keys: ComputedRef<K[]>;
+    targetSet: ComputedRef<Set<K>>;
+    checked: ComputedRef<K[]>;
+    checkedSet: ComputedRef<Set<K>>;
+    words: ComputedRef<import("./transfer").HysTransferLocale>;
+    all: ComputedRef<{
+        left: import("./transfer").HysTransferRecord<T, K>[];
+        right: import("./transfer").HysTransferRecord<T, K>[];
+    }>;
+    filtered: ComputedRef<{
+        left: import("./transfer").HysTransferRecord<T, K>[];
+        right: import("./transfer").HysTransferRecord<T, K>[];
+    }>;
+    visible: ComputedRef<{
+        left: import("./transfer").HysTransferRecord<T, K>[];
+        right: import("./transfer").HysTransferRecord<T, K>[];
+    }>;
+    searchValues: ComputedRef<{
+        left: string;
+        right: string;
+    }>;
+    pageSizes: ComputedRef<{
+        left: number;
+        right: number;
+    }>;
+    pages: ComputedRef<{
+        left: number;
+        right: number;
+    }>;
+    pageCounts: ComputedRef<{
+        left: number;
+        right: number;
+    }>;
+    pagination: ComputedRef<import("./transfer").HysTransferPagination>;
+    announcement: import("vue").Ref<string, string>;
+    getCheckedKeys: (side?: HysTransferSide) => K[];
+    setCheckedKeys: (next: readonly K[]) => Promise<boolean>;
+    check: (key: K, value?: boolean) => Promise<boolean>;
+    checkAll: (side: HysTransferSide, value?: boolean, scope?: "page" | "filtered" | "all") => Promise<boolean>;
+    invertSelection: (side: HysTransferSide, scope?: "page" | "filtered" | "all") => Promise<boolean>;
+    clearChecked: (side?: HysTransferSide) => Promise<boolean>;
+    move: (direction: HysTransferSide, requested?: readonly K[]) => Promise<boolean>;
+    setPage: (side: HysTransferSide, value: number) => void;
+    setPageSize: (side: HysTransferSide, value: number) => void;
+    setSearch: (side: HysTransferSide, value: string) => void;
+    clearSearch: (side?: HysTransferSide) => void;
+    selectionScope: (side: HysTransferSide, scope?: "page" | "filtered" | "all") => import("./transfer").HysTransferRecord<T, K>[];
+};

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

@@ -0,0 +1,77 @@
+import { type ComputedRef } from "vue";
+import { type HysTreeProps, type HysTreeKey, type HysTreeRecord, type HysTreeCheckInfo } from "./tree";
+export declare function useTree<N extends object>(props: HysTreeProps<N>, disabled: ComputedRef<boolean>, emit: (name: string, ...args: any[]) => void, validate: () => void, options?: {
+    loadActive?: ComputedRef<boolean>;
+}): {
+    live: import("vue").Ref<boolean, boolean>;
+    busy: ComputedRef<boolean>;
+    index: ComputedRef<{
+        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;
+    }>;
+    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<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 | N) => N | undefined;
+    getNodeInfo: (key: HysTreeKey | N) => HysTreeRecord<N> | undefined;
+    getCheckedKeys: (leafOnly?: boolean) => HysTreeKey[];
+    getCheckedNodes: (leafOnly?: boolean, includeHalf?: boolean) => N[];
+    getHalfCheckedKeys: () => HysTreeKey[];
+    checkInfo: (node?: N, on?: boolean, event?: Event) => HysTreeCheckInfo<N>;
+    setCheckedKeys: (keys: readonly HysTreeKey[], leafOnly?: boolean) => Promise<boolean>;
+    setChecked: (key: HysTreeKey | N, on: boolean, deep?: boolean, event?: Event) => Promise<boolean>;
+    selectNode: (row: HysTreeRecord<N>, event?: Event) => Promise<boolean>;
+    setSelectedKeys: (keys: readonly HysTreeKey[], node?: N | null, event?: Event) => Promise<boolean>;
+    setCurrentKey: (key: HysTreeKey | null, expandParents?: boolean) => Promise<boolean>;
+    getCurrentKey: () => HysTreeKey;
+    getCurrentNode: () => 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: N, parent?: HysTreeKey | N) => Promise<boolean>;
+    remove: (key: HysTreeKey | N) => Promise<boolean>;
+    insertBefore: (node: N, key: HysTreeKey | N) => Promise<boolean>;
+    insertAfter: (node: N, key: HysTreeKey | N) => Promise<boolean>;
+    updateKeyChildren: (key: HysTreeKey, children: readonly N[]) => Promise<boolean>;
+};

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

@@ -0,0 +1,117 @@
+import { type ComputedRef } from "vue";
+import { type HysTreeKey, type HysTreeRecord } from "./tree";
+import { type HysTreeSelectProps, type HysTreeSelectValue, type HysTreeSelectItem, type HysTreeSelectChange } from "./treeSelect";
+export declare const treeSelectValueKeys: (value: HysTreeSelectValue | undefined) => HysTreeKey[];
+export declare function useTreeSelect<N extends object>(props: HysTreeSelectProps<N>, disabled: ComputedRef<boolean>, active: ComputedRef<boolean>, emit: (name: string, ...args: any[]) => void, validate: () => void): {
+    tree: {
+        live: import("vue").Ref<boolean, boolean>;
+        busy: ComputedRef<boolean>;
+        index: ComputedRef<{
+            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;
+        }>;
+        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<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 | N) => N | undefined;
+        getNodeInfo: (key: HysTreeKey | N) => HysTreeRecord<N> | undefined;
+        getCheckedKeys: (leafOnly?: boolean) => HysTreeKey[];
+        getCheckedNodes: (leafOnly?: boolean, includeHalf?: boolean) => N[];
+        getHalfCheckedKeys: () => HysTreeKey[];
+        checkInfo: (node?: N | undefined, on?: boolean, event?: Event) => import("./tree").HysTreeCheckInfo<N>;
+        setCheckedKeys: (keys: readonly HysTreeKey[], leafOnly?: boolean) => Promise<boolean>;
+        setChecked: (key: HysTreeKey | N, on: boolean, deep?: boolean, event?: Event) => Promise<boolean>;
+        selectNode: (row: HysTreeRecord<N>, event?: Event) => Promise<boolean>;
+        setSelectedKeys: (keys: readonly HysTreeKey[], node?: N | null, event?: Event) => Promise<boolean>;
+        setCurrentKey: (key: HysTreeKey | null, expandParents?: boolean) => Promise<boolean>;
+        getCurrentKey: () => HysTreeKey;
+        getCurrentNode: () => 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: N, parent?: HysTreeKey | N | undefined) => Promise<boolean>;
+        remove: (key: HysTreeKey | N) => Promise<boolean>;
+        insertBefore: (node: N, key: HysTreeKey | N) => Promise<boolean>;
+        insertAfter: (node: N, key: HysTreeKey | N) => Promise<boolean>;
+        updateKeyChildren: (key: HysTreeKey, children: readonly N[]) => Promise<boolean>;
+    };
+    live: import("vue").Ref<boolean, boolean>;
+    current: ComputedRef<HysTreeSelectValue>;
+    values: ComputedRef<HysTreeKey[]>;
+    multiple: ComputedRef<boolean>;
+    query: ComputedRef<string>;
+    items: ComputedRef<HysTreeSelectItem<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: N) => N;
+    keyOf: (node: N) => HysTreeKey;
+    item: (key: HysTreeKey) => HysTreeSelectItem<N>;
+    pick: (row: HysTreeRecord<N>, event?: Event) => Promise<boolean>;
+    filter: (text: string) => void;
+    clear: () => Promise<boolean>;
+    removeTag: (key: HysTreeKey) => Promise<boolean>;
+    request: (keys: readonly HysTreeKey[], reason: HysTreeSelectChange<N>["reason"], node?: N, event?: Event, provided?: HysTreeSelectValue, halfKeys?: HysTreeKey[]) => Promise<boolean>;
+    project: (keys: readonly HysTreeKey[]) => HysTreeKey[];
+    retrySearch: () => Promise<void>;
+    setValue: (value: HysTreeSelectValue) => Promise<boolean>;
+};
+export type HysTreeSelectStore<N extends object> = ReturnType<typeof useTreeSelect<N>>;

package/dist/types/index.d.ts

@@ -1,21 +1,26 @@
 import './styles/index.css';
 export { default as HysAccordion } from './components/HysAccordion/HysAccordion.vue';
+export type { HysAccordionKey } from './components/HysAccordion/HysAccordion.vue';
+export type { HysAccordionItem } from './components/HysAccordion/HysAccordion.vue';
 export { default as HysAlert } from './components/HysAlert/HysAlert.vue';
 export { default as HysAnimatedNumber } from './components/HysAnimatedNumber/HysAnimatedNumber.vue';
+export { default as HysAutocomplete } from './components/HysAutocomplete/HysAutocomplete.vue';
 export { default as HysAvatar } from './components/HysAvatar/HysAvatar.vue';
+export { default as HysAvatarGroup } from './components/HysAvatarGroup/HysAvatarGroup.vue';
 export { default as HysBadge } from './components/HysBadge/HysBadge.vue';
 export { default as HysBreadcrumb } from './components/HysBreadcrumb/HysBreadcrumb.vue';
+export type { HysBreadcrumbItem } from './components/HysBreadcrumb/HysBreadcrumb.vue';
 export { default as HysButton } from './components/HysButton/HysButton.vue';
 export type { HysButtonVariant } from './components/HysButton/HysButton.vue';
 export type { HysButtonProps } from './components/HysButton/HysButton.vue';
 export { default as HysCalendar } from './components/HysCalendar/HysCalendar.vue';
-export type { CalendarEvent } from './components/HysCalendar/HysCalendar.vue';
 export { default as HysCalendarNavigation } from './components/HysCalendarNavigation/HysCalendarNavigation.vue';
 export { default as HysCard } from './components/HysCard/HysCard.vue';
+export type { HysCardTab } from './components/HysCard/HysCard.vue';
 export { default as HysCascader } from './components/HysCascader/HysCascader.vue';
-export type { HysCascaderNode } from './components/HysCascader/HysCascader.vue';
 export { default as HysChart } from './components/HysChart/HysChart.vue';
 export { default as HysCheckbox } from './components/HysCheckbox/HysCheckbox.vue';
+export { default as HysCheckboxGroup } from './components/HysCheckboxGroup/HysCheckboxGroup.vue';
 export { default as HysColorPicker } from './components/HysColorPicker/HysColorPicker.vue';
 export { default as HysColorTokenEditor } from './components/HysColorTokenEditor/HysColorTokenEditor.vue';
 export { default as HysCommandPalette } from './components/HysCommandPalette/HysCommandPalette.vue';
@@ -52,39 +57,65 @@ export { default as HysPagination } from './components/HysPagination/HysPaginati
 export { default as HysPermissionMatrix } from './components/HysPermissionMatrix/HysPermissionMatrix.vue';
 export { default as HysPopover } from './components/HysPopover/HysPopover.vue';
 export { default as HysProgress } from './components/HysProgress/HysProgress.vue';
+export { default as HysRadio } from './components/HysRadio/HysRadio.vue';
 export { default as HysRadioGroup } from './components/HysRadioGroup/HysRadioGroup.vue';
+export type { HysRadioOption } from './components/HysRadioGroup/HysRadioGroup.vue';
 export { default as HysRating } from './components/HysRating/HysRating.vue';
 export { default as HysResizablePanel } from './components/HysResizablePanel/HysResizablePanel.vue';
 export { default as HysRichTextEditor } from './components/HysRichTextEditor/HysRichTextEditor.vue';
 export { default as HysSearch } from './components/HysSearch/HysSearch.vue';
 export { default as HysSegmented } from './components/HysSegmented/HysSegmented.vue';
 export { default as HysSelect } from './components/HysSelect/HysSelect.vue';
-export type { HysSelectOption } from './components/HysSelect/HysSelect.vue';
 export { default as HysShortcutHelp } from './components/HysShortcutHelp/HysShortcutHelp.vue';
 export { default as HysSkeleton } from './components/HysSkeleton/HysSkeleton.vue';
+export type { HysSkeletonVariant } from './components/HysSkeleton/HysSkeleton.vue';
 export { default as HysSlider } from './components/HysSlider/HysSlider.vue';
 export { default as HysSortableList } from './components/HysSortableList/HysSortableList.vue';
 export { default as HysSplitPane } from './components/HysSplitPane/HysSplitPane.vue';
 export { default as HysSteps } from './components/HysSteps/HysSteps.vue';
+export type { HysStepStatus } from './components/HysSteps/HysSteps.vue';
+export type { HysStepItem } from './components/HysSteps/HysSteps.vue';
 export { default as HysSwitch } from './components/HysSwitch/HysSwitch.vue';
 export { default as HysTable } from './components/HysTable/HysTable.vue';
-export type { HysTableColumn } from './components/HysTable/HysTable.vue';
 export { default as HysTabs } from './components/HysTabs/HysTabs.vue';
+export type { HysTabValue } from './components/HysTabs/HysTabs.vue';
+export type { HysTabItem } from './components/HysTabs/HysTabs.vue';
 export { default as HysTagInput } from './components/HysTagInput/HysTagInput.vue';
 export { default as HysTextarea } from './components/HysTextarea/HysTextarea.vue';
 export { default as HysTimeline } from './components/HysTimeline/HysTimeline.vue';
 export { default as HysToast } from './components/HysToast/HysToast.vue';
+export type { HysToastType } from './components/HysToast/HysToast.vue';
+export type { HysToastPosition } from './components/HysToast/HysToast.vue';
 export { default as HysTooltip } from './components/HysTooltip/HysTooltip.vue';
 export { default as HysTour } from './components/HysTour/HysTour.vue';
 export { default as HysTransfer } from './components/HysTransfer/HysTransfer.vue';
 export { default as HysTree } from './components/HysTree/HysTree.vue';
-export type { TreeNode } from './components/HysTree/HysTree.vue';
 export { default as HysTreeSelect } from './components/HysTreeSelect/HysTreeSelect.vue';
-export type { HysTreeSelectNode } from './components/HysTreeSelect/HysTreeSelect.vue';
 export { default as HysUpload } from './components/HysUpload/HysUpload.vue';
 export type { HysUploadFile } from './components/HysUpload/HysUpload.vue';
 export { default as HysVirtualTable } from './components/HysVirtualTable/HysVirtualTable.vue';
 export { provideHysConfig } from './config';
 export type { HysConfig, HysTheme, HysMotion } from './config';
 export type { Placement } from './composables/useFloating';
-export type { HysFormRule } from './composables/formContext';
+export type { HysFormRule, HysFormRules, HysFormPath, HysFormPaths, HysFormTrigger, HysFormRuleType, HysFormStatus, HysFormMessages, HysFormField, HysFormFieldState, HysFormValidationResult, HysFormValidationContext, HysFormValidateCallback, HysFormFieldData } from './composables/formContext';
+export { useHysFormItemContext } from './composables/formContext';
+export type { HysFormCol, HysFormColSize, HysFormGridValue, HysFormBreakpoint } from './composables/formLayout';
+export type { HysSelectValue, HysSelectModelValue, HysSelectOption, HysSelectGroup, HysSelectDataOption, HysSelectFieldNames, HysSelectSearchContext, HysSelectInstance } from './composables/selectOptions';
+export type { HysNumberInputValue, HysNumberInputFormatInfo, HysNumberInputStepInfo, HysNumberInputInvalidInfo, HysNumberInputInstance } from './composables/numberInput';
+export type { HysInputProps, HysTextareaProps, HysInputFormatInfo, HysInputCountInfo, HysInputCountStrategy, HysInputInstance, HysTextareaInstance } from './composables/textInput';
+export { useHysToast, createHysToast } from './composables/useHysToast';
+export type { HysToastApi, HysToastOptions, HysToastConfig, HysToastHandle, HysToastServiceConfig, HysToastService } from './composables/useHysToast';
+export type { HysSliderValue, HysSliderStep, HysSliderMarks, HysSliderDragInfo, HysSliderInstance } from './composables/slider';
+export type { HysAvatarProps, HysAvatarSize, HysAvatarBreakpoint, HysAvatarFit, HysAvatarLoadInfo, HysAvatarOption, HysAvatarInstance, HysAvatarGroupProps, HysAvatarGroupInstance } from './composables/avatar';
+export type { HysAutocompleteProps, HysAutocompleteRow, HysAutocompleteOption, HysAutocompleteItem, HysAutocompleteGroup, HysAutocompleteDataOption, HysAutocompleteContext, HysAutocompleteCallback, HysAutocompleteFetch, HysAutocompleteInstance } from './composables/autocomplete';
+export type { HysChoiceValue, HysChoiceFieldNames, HysChoiceOption, HysChoiceDataOption, HysCheckboxChange, HysCheckboxReject, HysCheckboxInstance, HysCheckboxGroupInstance, HysRadioInstance, HysRadioGroupInstance, HysSwitchGuardContext, HysSwitchInstance } from './composables/choice';
+export type { HysRatingIcon, HysRatingLevels, HysRatingInstance } from './composables/rating';
+export type { HysSegmentedOption, HysSegmentedInstance } from './composables/segmented';
+export type { HysGanttScrollOptions, HysGanttInstance, HysGanttDependencyChange, HysGanttDependencyMove, HysGanttDependencyInvalid, HysGanttDependencyReason, HysGanttHistoryType, HysGanttHistoryEntry, HysGanttHistoryState, HysGanttHistoryInvalid, HysGanttConflictType, HysGanttConflict } from './composables/gantt';
+export type { CalendarEvent, HysCalendarValue, HysCalendarMode, HysCalendarTransition, HysCalendarAction, HysCalendarCell, HysCalendarMonthCell, HysCalendarSelectInfo, HysCalendarInstance } from './composables/calendar';
+export type { HysTableSelectionProps, HysTableSelectionColumn, HysTableFilterConfirmOptions, HysTableFilterResetOptions, HysTableScrollRowOptions, HysTableKey, HysTableDirection, HysTableFilterValue, HysTableFilters, HysTableSort, HysTableFilter, HysTableCellContext, HysTableColumn, HysTableElementAttrs, HysTablePaginationPosition, HysTablePagination, HysTableQuery, HysTableLoadContext, HysTableLocale, HysTableProps, HysTableInstance } from './composables/table';
+export type { HysTransferKey, HysTransferSide, HysTransferOption, HysTransferFieldNames, HysTransferPagination, HysTransferLocale, HysTransferHeaderInfo, HysTransferProps, HysTransferPanelContext, HysTransferInstance, HysTransferSlots } from './composables/transfer';
+export type { TreeNode, HysTreeKey, HysTreeValue, HysTreeNode, HysTreeFieldNames, HysTreeLoadContext, HysTreeLocale, HysTreeRecord, HysTreeCheckInfo, HysTreeSelectInfo, HysTreeDropPosition, HysTreeDropInfo, HysTreeNodeContext, HysTreeProps, HysTreeInstance } from './composables/tree';
+export type { HysTreeSelectNode, HysTreeSelectDataNode, HysTreeSelectLabelValue, HysTreeSelectValue, HysTreeSelectFieldNames, HysTreeSelectSimpleMode, HysTreeSelectStrategy, HysTreeSelectItem, HysTreeSelectChange, HysTreeSelectProps, HysTreeSelectInstance } from './composables/treeSelect';
+export type { HysCascaderKey, HysCascaderPath, HysCascaderValue, HysCascaderDataNode, HysCascaderNode, HysCascaderFieldNames, HysCascaderItem, HysCascaderOptionContext, HysCascaderLoadContext, HysCascaderChange, HysCascaderLocale, HysCascaderProps, HysCascaderInstance } from './composables/cascader';
+export type { HysDatePickerWeek, HysDateScalar, HysDatePickerValue, HysDateRangeValue, HysDatePickerType, HysDatePickerUnit, HysDatePickerView, HysDatePoint, HysDatePickerContext, HysDateDisabledTime, HysDateShortcut, HysDatePickerCell, HysDatePickerChange, HysDatePickerLocale, HysDatePickerProps, HysDateRangePickerProps, HysDatePickerInstance, HysDateRangePickerInstance, HysDatePickerSlots } from './composables/datePicker';