hys-ui 0.1.1 → 0.2.0

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 | 'min' | (() => boolean | 'min');
+    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>;
 };

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/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>;
+};