hys-ui 0.2.0 → 0.4.0

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

@@ -0,0 +1,14 @@
+interface DragSettings {
+    vertical: boolean;
+    direction: 1 | -1;
+    available: number;
+    initial: number;
+    constrain: (value: number) => number;
+}
+export declare function useSplitPaneDrag(update: (value: number) => void, ended: (value: number, cancelled: boolean, notify: boolean) => void): {
+    start: (event: PointerEvent, settings: DragSettings) => boolean;
+    cancel: (event: PointerEvent) => void;
+    finish: (cancelled: boolean, notify?: boolean) => void;
+    active: () => boolean;
+};
+export {};

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

@@ -0,0 +1,4 @@
+import { type Ref } from "vue";
+import type { HysSplitPaneSizes } from "../components/HysSplitPane/HysSplitPane.vue";
+export declare function readStoredPaneSizes(value: unknown): HysSplitPaneSizes | undefined;
+export declare function useSplitPaneStorage<T>(key: () => string | undefined, state: Ref<T | undefined>, decode: (value: unknown) => T | undefined): void;

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

@@ -1,4 +1,4 @@
-import { type HysTableProps, type HysTableKey, type HysTableColumn, type HysTableSort, type HysTableFilters, type HysTableFilterValue, type HysTableQuery, type TableNode } from "./table";
+import { type HysTableProps, type HysTableKey, type HysTableColumn, type HysTableSort, type HysTableFilters, type HysTableFilterValue, type HysTableQuery, type HysTableRowSelectionOptions, 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>;
@@ -16,6 +16,7 @@ export declare function useTable<T extends object>(props: HysTableProps<T>, colu
     eligible: (node: TableNode<T>) => boolean;
     allSelected: import("vue").ComputedRef<boolean>;
     someSelected: import("vue").ComputedRef<boolean>;
+    selectionPage: import("vue").ComputedRef<TableNode<T>[]>;
     sorts: import("vue").ComputedRef<HysTableSort[]>;
     filters: import("vue").ComputedRef<HysTableFilters>;
     processed: import("vue").ComputedRef<{
@@ -26,7 +27,8 @@ export declare function useTable<T extends object>(props: HysTableProps<T>, colu
     display: import("vue").ComputedRef<TableNode<T>[]>;
     page: import("vue").ComputedRef<number>;
     pageSize: import("vue").ComputedRef<number>;
-    total: import("vue").ComputedRef<number>;
+    pageCount: import("vue").ComputedRef<number>;
+    paginationTotal: import("vue").ComputedRef<number | undefined>;
     pagination: import("vue").ComputedRef<import("./table").HysTablePagination>;
     currentKey: import("vue").ComputedRef<HysTableKey | null>;
     currentRow: import("vue").ComputedRef<T | undefined>;
@@ -40,16 +42,18 @@ export declare function useTable<T extends object>(props: HysTableProps<T>, colu
     }>>;
     loadErrors: import("vue").ShallowRef<Map<string, unknown>, Map<string, unknown>>;
     canExpand: (node: TableNode<T>) => boolean;
+    nextSortOrder: (column: HysTableColumn<T>, direction?: "asc" | "desc") => import("./table").HysTableDirection | null;
     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>;
+    toggleRowSelection: (value: T | HysTableKey, checked?: boolean, options?: boolean | HysTableRowSelectionOptions) => Promise<boolean>;
     toggleAllSelection: (checked?: boolean) => Promise<boolean>;
     invertSelection: () => Promise<boolean>;
     clearSelection: () => Promise<boolean>;
+    selectPage: (keys: readonly HysTableKey[], nodes?: TableNode<T>[]) => Promise<boolean>;
     getSelectionRows: () => T[];
     getHalfSelectionRows: () => T[];
     setCurrentRow: (value?: T | HysTableKey | null) => Promise<boolean>;

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

@@ -0,0 +1,22 @@
+import { type Ref } from "vue";
+import type { HysTableStickyOptions } from "./table";
+export declare function useTableSticky(viewport: Ref<HTMLElement | undefined>, header: Readonly<Ref<HTMLTableSectionElement | undefined>>, options: () => boolean | HysTableStickyOptions | undefined): {
+    headerTop: Ref<number, number>;
+    bar: import("vue").ShallowRef<{
+        top: number;
+        left: number;
+        width: number;
+        contentWidth: number;
+        direction: "ltr" | "rtl";
+    } | undefined, {
+        top: number;
+        left: number;
+        width: number;
+        contentWidth: number;
+        direction: "ltr" | "rtl";
+    } | undefined>;
+    scrollbar: Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    syncScrollbar: () => void;
+    scrollViewport: (event: Event) => void;
+    scrollbarHeight: number;
+};

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

@@ -0,0 +1,33 @@
+import { type Ref } from "vue";
+import type { HysTourAppearance, HysTourTarget } from "./tour";
+export declare function useTourLayout(shown: Readonly<Ref<boolean>>, panel: Readonly<Ref<HTMLElement | undefined>>, settings: Readonly<Ref<HysTourAppearance>>, targetInput: Readonly<Ref<HysTourTarget | undefined>>): {
+    view: import("vue").ShallowRef<{
+        width: number;
+        height: number;
+    }, {
+        width: number;
+        height: number;
+    }>;
+    bounds: import("vue").ShallowRef<DOMRect | undefined, DOMRect | undefined>;
+    card: import("vue").ShallowRef<{
+        width: number;
+        height: number;
+        x: number;
+        y: number;
+        placement: import("./useFloating").Placement;
+    } | undefined, {
+        width: number;
+        height: number;
+        x: number;
+        y: number;
+        placement: import("./useFloating").Placement;
+    } | undefined>;
+    arrow: import("vue").ShallowRef<{
+        x: number;
+        y: number;
+    } | undefined, {
+        x: number;
+        y: number;
+    } | undefined>;
+    path: import("vue").ComputedRef<string>;
+};

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

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

@@ -0,0 +1,126 @@
+import type { CSSProperties, HTMLAttributes, VNodeChild } from "vue";
+export type HysVirtualTableKey = string | number;
+export type HysVirtualTableAlign = "start" | "center" | "end" | "nearest";
+export interface HysVirtualTableSort {
+    key: string;
+    direction: "asc" | "desc";
+}
+export interface HysVirtualTableCell<T extends object = Record<string, unknown>> {
+    row: T;
+    column: HysVirtualTableColumn<T>;
+    value: unknown;
+    rowIndex: number;
+    columnIndex: number;
+}
+export interface HysVirtualTableColumn<T extends object = any> {
+    key: string;
+    label: string;
+    width?: number;
+    minWidth?: number;
+    maxWidth?: number;
+    dataIndex?: string | readonly (string | number)[];
+    valueGetter?: (row: T, index: number) => unknown;
+    formatter?: (context: HysVirtualTableCell<T>) => VNodeChild;
+    fixed?: boolean | "left" | "right";
+    hidden?: boolean;
+    align?: "left" | "center" | "right";
+    headerAlign?: "left" | "center" | "right";
+    sortable?: boolean | "custom";
+    sorter?: (a: T, b: T) => number;
+    className?: string;
+    headerClassName?: string;
+}
+export interface HysVirtualTableRange {
+    start: number;
+    end: number;
+    visibleStart: number;
+    visibleEnd: number;
+    columnKeys: string[];
+}
+export interface HysVirtualTableScroll {
+    scrollTop: number;
+    scrollLeft: number;
+    direction: "up" | "down" | "left" | "right" | null;
+}
+export interface HysVirtualTableProps<T extends object> {
+    rows: readonly T[];
+    columns: readonly HysVirtualTableColumn<T>[];
+    rowKey?: string | ((row: T, index: number) => HysVirtualTableKey);
+    rowHeight?: number;
+    height?: number | string;
+    width?: number | string;
+    headerHeight?: number;
+    showHeader?: boolean;
+    fit?: boolean;
+    overscan?: number;
+    virtualColumns?: boolean;
+    columnOverscan?: number;
+    loading?: boolean;
+    loadingMode?: "replace" | "overlay";
+    loadingText?: string;
+    emptyText?: string;
+    disabled?: boolean;
+    fixedRows?: readonly T[];
+    striped?: boolean;
+    bordered?: boolean;
+    sortState?: HysVirtualTableSort | null;
+    defaultSort?: HysVirtualTableSort | null;
+    selectable?: boolean | ((row: T, index: number) => boolean);
+    selectedRowKeys?: readonly HysVirtualTableKey[];
+    defaultSelectedRowKeys?: readonly HysVirtualTableKey[];
+    selectionType?: "checkbox" | "radio";
+    selectionWidth?: number;
+    reserveSelection?: boolean;
+    selectOnClick?: boolean;
+    currentRowKey?: HysVirtualTableKey | null;
+    defaultCurrentRowKey?: HysVirtualTableKey | null;
+    highlightCurrentRow?: boolean;
+    keyboard?: boolean;
+    endReachedThreshold?: number;
+    ariaLabel?: string;
+    rowClassName?: string | ((row: T, index: number) => string);
+    rowStyle?: CSSProperties | ((row: T, index: number) => CSSProperties);
+    cellClassName?: string | ((context: HysVirtualTableCell<T>) => string);
+    cellStyle?: CSSProperties | ((context: HysVirtualTableCell<T>) => CSSProperties);
+    customRow?: (row: T, index: number) => HTMLAttributes;
+    customCell?: (context: HysVirtualTableCell<T>) => HTMLAttributes;
+    customHeaderCell?: (column: HysVirtualTableColumn<T>, index: number) => HTMLAttributes;
+}
+export interface HysVirtualTableInstance<T extends object = Record<string, unknown>> {
+    readonly element: HTMLElement | undefined;
+    readonly viewport: HTMLElement | undefined;
+    readonly scrollTop: number;
+    readonly scrollLeft: number;
+    readonly range: HysVirtualTableRange;
+    readonly selectedRowKeys: HysVirtualTableKey[];
+    readonly sortState: HysVirtualTableSort | null;
+    scrollTo(options: {
+        top?: number;
+        left?: number;
+        behavior?: ScrollBehavior;
+    }): void;
+    scrollToRow(index: number, align?: HysVirtualTableAlign): void;
+    scrollToKey(key: HysVirtualTableKey, align?: HysVirtualTableAlign): boolean;
+    scrollToColumn(key: string, align?: HysVirtualTableAlign): boolean;
+    focusCell(index: number, key?: string): Promise<boolean>;
+    setSort(sort: HysVirtualTableSort | null): Promise<boolean>;
+    clearSelection(): Promise<boolean>;
+    toggleRowSelection(key: HysVirtualTableKey, selected?: boolean): Promise<boolean>;
+    selectAll(selected?: boolean): Promise<boolean>;
+    setCurrentRow(key: HysVirtualTableKey | null): Promise<boolean>;
+    getRow(index: number): T | undefined;
+    remeasure(): void;
+}
+export declare const virtualFinite: (value: unknown, fallback: number, min?: number, max?: number) => number;
+export declare const virtualKey: (key: unknown) => key is HysVirtualTableKey;
+export declare const virtualToken: (key: HysVirtualTableKey) => string;
+export declare function virtualValue<T extends object>(row: T, column: HysVirtualTableColumn<T>, index: number): unknown;
+export interface VirtualEntry<T extends object> {
+    row: T;
+    key: HysVirtualTableKey;
+    token: string;
+    sourceIndex: number;
+    valid: boolean;
+}
+export declare function virtualEntries<T extends object>(rows: readonly T[], rowKey: HysVirtualTableProps<T>["rowKey"]): VirtualEntry<T>[];
+export declare function virtualAligned(start: number, size: number, scroll: number, extent: number, align: HysVirtualTableAlign): number;

package/dist/types/config.d.ts

@@ -4,6 +4,7 @@ export type HysMotion = 'full' | 'subtle' | 'off';
 export interface HysConfig {
     theme?: MaybeRefOrGetter<HysTheme>;
     motion?: MaybeRefOrGetter<HysMotion>;
+    buttonAutoInsertSpace?: MaybeRefOrGetter<boolean>;
 }
 /** Call in a component setup. Reactive options are inherited by children and teleported panels. */
 export declare function provideHysConfig(config: HysConfig): void;