hys-ui 0.1.1 → 0.3.0

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/useTagInput.d.ts

@@ -0,0 +1,66 @@
+import { type Ref } from "vue";
+import { type HysTagInputProps, type HysTagInputReason } from "./tagInput";
+export declare function useTagInput(props: HysTagInputProps, emit: (event: string, ...args: any[]) => void): {
+    attrs: import("vue").Attrs;
+    field: import("./formContext").HysFieldContext | undefined;
+    control: {
+        disabled: import("vue").ComputedRef<boolean>;
+        size: import("vue").ComputedRef<"sm" | "md" | "lg">;
+        label: import("vue").ComputedRef<string | undefined>;
+    };
+    element: Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    input: Ref<HTMLInputElement | undefined, HTMLInputElement | undefined>;
+    errorId: string;
+    draft: Ref<string, string>;
+    pending: Ref<boolean, boolean>;
+    composing: Ref<boolean, boolean>;
+    focused: Ref<boolean, boolean>;
+    values: import("vue").ComputedRef<string[]>;
+    status: import("vue").ComputedRef<import("./formContext").HysFormStatus | undefined>;
+    maximum: import("vue").ComputedRef<number>;
+    context: import("vue").ComputedRef<{
+        values: string[];
+        draft: string;
+        disabled: boolean;
+        readonly: boolean;
+        pending: boolean;
+        add: (value?: string | string[]) => Promise<boolean>;
+        clear: () => Promise<boolean>;
+    }>;
+    tags: import("vue").ComputedRef<{
+        value: string;
+        index: number;
+        key: string;
+    }[]>;
+    drag: Ref<{
+        index: number;
+        values: string[];
+    } | undefined, {
+        index: number;
+        values: string[];
+    } | undefined>;
+    drop: Ref<{
+        index: number;
+        after: boolean;
+    } | undefined, {
+        index: number;
+        after: boolean;
+    } | undefined>;
+    add: (value?: string | string[], reason?: HysTagInputReason) => Promise<boolean>;
+    remove: (index: number) => Promise<boolean>;
+    clear: () => Promise<boolean>;
+    move: (from: number, to: number) => Promise<boolean>;
+    focus: (options?: FocusOptions) => void;
+    nativeInput: (event: Event) => void;
+    compositionEnd: (event: CompositionEvent) => void;
+    pasted: (event: ClipboardEvent) => void;
+    key: (event: KeyboardEvent) => void;
+    tagKey: (event: KeyboardEvent, index: number) => Promise<void>;
+    focusIn: (event: FocusEvent) => void;
+    focusOut: (event: FocusEvent, extra?: HTMLElement) => void;
+    stopDrag: () => void;
+    dragStart: (event: DragEvent, index: number) => void;
+    dragOver: (event: DragEvent, index: number) => void;
+    dragDrop: (event: DragEvent) => Promise<void>;
+    setDraft: (value: string) => void;
+};

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/useTransferMotion.d.ts

@@ -0,0 +1,36 @@
+import { type Ref } from "vue";
+import { type HysTransferKey, type HysTransferSide } from "./transfer";
+interface Options {
+    animated?: boolean;
+    moveAnimation?: "flight" | "fade" | "none";
+    moveDuration?: number;
+    maxAnimatedItems?: number;
+    highlightOnArrival?: boolean;
+}
+type Box = {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+    right: number;
+    bottom: number;
+};
+interface Sample {
+    token: string;
+    label: string;
+    box: Box;
+}
+interface Snapshot {
+    generation: number;
+    direction: HysTransferSide;
+    count: number;
+    samples: Sample[];
+}
+/** Bounded visual feedback after an accepted move; never measures every data row. */
+export declare function useTransferMotion(root: Ref<HTMLElement | undefined>, options: Options): {
+    capture: (direction: HysTransferSide, keys: readonly HysTransferKey[]) => Snapshot | undefined;
+    play: (snapshot: Snapshot | undefined) => void;
+    stop: () => void;
+    cancelPlaying: () => void;
+};
+export {};

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/composables/useUpload.d.ts

@@ -0,0 +1,94 @@
+import { type Ref } from "vue";
+import { type HysUploadProps, type HysUploadItem, type HysUploadFileContext, type HysUploadSlotContext, type HysUploadStatus } from "./upload";
+export declare function useUpload<T extends HysUploadItem>(props: HysUploadProps<T>, emit: (name: string, ...args: any[]) => void): {
+    element: Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    zone: Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    input: Ref<HTMLInputElement | undefined, HTMLInputElement | undefined>;
+    active: Ref<boolean, boolean>;
+    available: import("vue").ComputedRef<boolean>;
+    disabled: import("vue").ComputedRef<boolean>;
+    size: import("vue").ComputedRef<"sm" | "md" | "lg">;
+    label: import("vue").ComputedRef<string | undefined>;
+    field: import("./formContext").HysFieldContext | undefined;
+    checking: Ref<boolean, boolean>;
+    dragging: Ref<boolean, boolean>;
+    lastError: Ref<string, string>;
+    words: import("vue").ComputedRef<{
+        choose: string;
+        drag: string;
+        checking: string;
+        localHint: string;
+        uploadHint: string;
+        files: string;
+        ready: string;
+        uploading: string;
+        success: string;
+        error: string;
+        queued: string;
+        removing: string;
+        submit: string;
+        abort: string;
+        retry: string;
+        clear: string;
+        remove: string;
+        preview: string;
+        download: string;
+        empty: string;
+    }>;
+    files: import("vue").ComputedRef<T[]>;
+    requests: {
+        configured: import("vue").ComputedRef<boolean>;
+        queue: import("vue").ShallowRef<string[], string[]>;
+        tasks: import("vue").ShallowRef<Map<string, {
+            uid: string;
+            raw: File;
+            controller: AbortController;
+            phase: "preparing" | "running" | "finishing";
+            stop?: (() => void) | undefined;
+            percentage: number;
+        }>, Map<string, {
+            uid: string;
+            raw: File;
+            controller: AbortController;
+            phase: "preparing" | "running" | "finishing";
+            stop?: (() => void) | undefined;
+            percentage: number;
+        }>>;
+        uploading: import("vue").ComputedRef<number>;
+        queued: import("vue").ComputedRef<number>;
+        activeKeys: import("vue").ComputedRef<Set<string>>;
+        queuedKeys: import("vue").ComputedRef<Set<string>>;
+        submit: (uid?: string) => Promise<number>;
+        retry: (uid: string) => Promise<boolean>;
+        abort: (uid?: string, reason?: string, reset?: boolean) => number;
+        cleanup: () => void;
+    };
+    removing: import("vue").ShallowRef<Set<string>, Set<string>>;
+    preview: import("vue").ShallowRef<{
+        file: T;
+        url: string;
+    } | undefined, {
+        file: T;
+        url: string;
+    } | undefined>;
+    closePreview: () => void;
+    context: (file: T) => HysUploadFileContext<T>;
+    scope: import("vue").ComputedRef<HysUploadSlotContext<T>>;
+    canPreview: (file: T) => boolean;
+    canDownload: (file: T) => boolean;
+    open: (event?: Event) => void;
+    click: (event: MouseEvent) => void;
+    keys: (event: KeyboardEvent) => void;
+    drop: (event: DragEvent) => void;
+    dragEnter: (event: DragEvent) => void;
+    dragOver: (event: DragEvent) => void;
+    dragLeave: () => void;
+    paste: (event: ClipboardEvent) => void;
+    blur: (event: FocusEvent) => void;
+    addFiles: (inputFiles: readonly File[]) => Promise<T[]>;
+    remove: (file: T | string) => Promise<boolean>;
+    clearFiles: (statuses?: readonly HysUploadStatus[]) => Promise<boolean>;
+    previewFile: (file: T | string) => Promise<boolean>;
+    download: (file: T | string) => Promise<boolean>;
+    focus: () => void;
+};

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

@@ -0,0 +1,14 @@
+import type { HysUploadProps, HysUploadItem, HysUploadChangeType } from "./upload";
+export declare function useUploadModel<T extends HysUploadItem>(props: HysUploadProps<T>, emit: (name: string, ...args: any[]) => void, live: () => boolean): {
+    files: import("vue").ComputedRef<T[]>;
+    controlled: import("vue").ComputedRef<boolean>;
+    commit: (change: (current: readonly T[]) => T[] | undefined, type: HysUploadChangeType, options?: {
+        force?: boolean;
+        allowInactive?: boolean;
+        guard?: () => boolean;
+        accepted?: () => void;
+    }) => Promise<boolean>;
+    cancel: () => void;
+    resetLocal: () => void;
+    interrupt: (keys: ReadonlySet<string>) => void;
+};

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

@@ -0,0 +1,38 @@
+import { type Ref } from "vue";
+import { type HysUploadItem, type HysUploadProps, type HysUploadChangeType } from "./upload";
+export declare function useUploadRequests<T extends HysUploadItem>(options: {
+    props: HysUploadProps<T>;
+    files: Readonly<Ref<readonly T[]>>;
+    available: Readonly<Ref<boolean>>;
+    live: () => boolean;
+    emit: (name: string, ...args: any[]) => void;
+    prepare: (file: T, signal: AbortSignal) => Promise<Blob | undefined>;
+    forget: (uid: string) => void;
+    patch: (changes: Map<string, Partial<T>>, type: HysUploadChangeType, guard?: (uid?: string) => boolean) => Promise<boolean>;
+}): {
+    configured: import("vue").ComputedRef<boolean>;
+    queue: import("vue").ShallowRef<string[], string[]>;
+    tasks: import("vue").ShallowRef<Map<string, {
+        uid: string;
+        raw: File;
+        controller: AbortController;
+        phase: "preparing" | "running" | "finishing";
+        stop?: () => void;
+        percentage: number;
+    }>, Map<string, {
+        uid: string;
+        raw: File;
+        controller: AbortController;
+        phase: "preparing" | "running" | "finishing";
+        stop?: () => void;
+        percentage: number;
+    }>>;
+    uploading: import("vue").ComputedRef<number>;
+    queued: import("vue").ComputedRef<number>;
+    activeKeys: import("vue").ComputedRef<Set<string>>;
+    queuedKeys: import("vue").ComputedRef<Set<string>>;
+    submit: (uid?: string) => Promise<number>;
+    retry: (uid: string) => Promise<boolean>;
+    abort: (uid?: string, reason?: string, reset?: boolean) => number;
+    cleanup: () => void;
+};

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

@@ -0,0 +1,51 @@
+import { type CSSProperties } from "vue";
+import { type HysVirtualTableAlign, type HysVirtualTableColumn, type HysVirtualTableProps, type HysVirtualTableRange, type HysVirtualTableScroll } from "./virtualTable";
+export interface VirtualColumn<T extends object> {
+    token: string;
+    column?: HysVirtualTableColumn<T>;
+    index: number;
+    width: number;
+    offset: number;
+    left?: number;
+    right?: number;
+    selection?: boolean;
+    gap?: boolean;
+}
+export declare function useVirtualTableLayout<T extends object>(props: HysVirtualTableProps<T>, count: () => number, lastKey: () => string | undefined, report: {
+    scroll: (state: HysVirtualTableScroll) => void;
+    range: (state: HysVirtualTableRange) => void;
+    end: (state: {
+        distance: number;
+        total: number;
+    }) => void;
+}): {
+    viewport: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    live: import("vue").Ref<boolean, boolean>;
+    rowHeight: import("vue").ComputedRef<number>;
+    headerHeight: import("vue").ComputedRef<number>;
+    topHeight: import("vue").ComputedRef<number>;
+    bodyHeight: import("vue").ComputedRef<number>;
+    rootStyle: import("vue").ComputedRef<{
+        width: string | undefined;
+    }>;
+    viewportStyle: import("vue").ComputedRef<{
+        height: string;
+    }>;
+    columns: import("vue").ComputedRef<VirtualColumn<T>[]>;
+    columnMap: import("vue").ComputedRef<Map<string, VirtualColumn<T>>>;
+    renderColumns: import("vue").ComputedRef<VirtualColumn<T>[]>;
+    contentWidth: import("vue").ComputedRef<number>;
+    scrollTop: import("vue").Ref<number, number>;
+    scrollLeft: import("vue").Ref<number, number>;
+    range: import("vue").ComputedRef<HysVirtualTableRange>;
+    scrollTo: (options: {
+        top?: number;
+        left?: number;
+        behavior?: ScrollBehavior;
+    }) => void;
+    scrollToRow: (index: number, align?: HysVirtualTableAlign) => void;
+    scrollToColumn: (key: string, align?: HysVirtualTableAlign) => boolean;
+    onScroll: () => void;
+    remeasure: () => void;
+};
+export declare function virtualColumnStyle<T extends object>(cell: VirtualColumn<T>): CSSProperties;