@pantograph/pattern-vue 0.0.3 → 0.0.4

package/dist/components/DataTable/types/column.d.ts

@@ -0,0 +1,69 @@
+import { PopoverProps, SkeletonProps } from '@pantograph/vue';
+import { Column } from '@tanstack/vue-table';
+import { VNode } from 'vue';
+import { TableCustomCell, TableCustomCellReturn } from './cell';
+import { TableTitle } from './common';
+export interface TableGetFunctionsProps<T = any> {
+    index: number;
+    record: T;
+    parentId?: string;
+    depth: number;
+    id: {
+        cell: string;
+        column: string;
+    };
+    visibleColumnCount: number;
+    column: TableColumnBase<T> & TableColExtra;
+}
+export type TableCustomRender<T = any> = (data?: Partial<TableGetFunctionsProps<T>>) => VNode | undefined;
+export interface TableColExtra {
+    id: string;
+    bind: {
+        style: Record<string, any>;
+        fixed: boolean;
+        afterShadow: boolean;
+    };
+}
+export interface DataTableSlotProps {
+    visibleColumns: (TableColumn & TableColExtra)[];
+    visibleRows: object[];
+}
+export interface ColumnMenuItemTitles {
+    sortAsc?: string;
+    sortDesc?: string;
+    autoFitWidth?: string;
+    freezeUpToColumn?: string;
+    unfreezeAllColumn?: string;
+    filter?: string;
+    deleteFilter?: string;
+    wrapColumn?: string;
+}
+export interface TableColumnBase<T = any> extends Omit<TableCustomCellReturn, 'rowSpan'> {
+    dataIndex?: string;
+    render?: TableCustomRender<T>;
+    id: string;
+    responsive?: ('desktop' | 'tablet' | 'mobile')[];
+    sorter?: ((a: T, b: T) => number) | 'basic' | 'datetime' | 'textCaseSensitive' | 'text' | 'alphanumericCaseSensitive' | 'alphanumeric' | 'server';
+    hideColumnWrap?: boolean;
+    hideColumnFix?: boolean;
+    sortOrder?: 'asc' | 'desc';
+    multiSort?: number;
+    defaultSortOrder?: 'asc' | 'desc';
+    title?: TableTitle;
+    width?: number | string;
+    maxWidth?: number;
+    minWidth?: number;
+    skeletonProps?: SkeletonProps & Record<string, any>;
+    hasFilter?: boolean;
+    onFilter?: (reference: PopoverProps['reference'], placement: PopoverProps['placement']) => void;
+    onDeleteFilter?: (reference: PopoverProps['reference'], placement: PopoverProps['placement']) => void;
+    menuItemTitles?: ColumnMenuItemTitles;
+}
+export type TableColumn<T = any> = Omit<TableCustomCellReturn, 'rowSpan'> & TableColumnBase & {
+    customCell?: TableCustomCell<T>;
+} & {
+    [key: string]: unknown;
+};
+export type TableCol = Column<unknown> & {
+    columnDef: TableColumn;
+};

package/dist/components/DataTable/types/common.d.ts

@@ -0,0 +1,18 @@
+import { VNode } from 'vue';
+export type TableTitle = string | (() => VNode);
+export interface GetTableRowProps {
+    index?: number;
+    row?: object;
+    loading?: boolean;
+    header?: boolean;
+    footer?: boolean;
+    empty?: boolean;
+    lazyLoadObserver?: boolean;
+    zebra?: boolean;
+    checked?: boolean;
+    id?: string;
+    depth?: number;
+    parentId?: string;
+    first?: boolean;
+    last?: boolean;
+}

package/dist/components/DataTable/types/context.d.ts

@@ -0,0 +1,44 @@
+import { EmitType } from '@pantograph/utils-vue';
+import { Table } from '@tanstack/vue-table';
+import { ComputedRef, Ref } from 'vue';
+import { CellActions, ColActions, ColumnFixActions, ColumnOrderActions, ColumnSizeActions, ColumnWrapActions, FilterActions, RowActions, SelectionActions, SelectionState, SortActions, ColumnPopoverActions } from '../utils';
+import { ConfigProviderContext } from '@pantograph/vue';
+import { DataTableSlotProps, TableCol, TableColExtra, TableColumn } from './column';
+import { GetTableRowProps } from './common';
+import { DataTableEmits, DataTableProps, DataTableSlots } from './index';
+export interface InsertBetweenState {
+    tr: undefined | HTMLElement;
+    position: 'before' | 'after';
+}
+export interface DataTableContext extends Pick<ConfigProviderContext, 'getDragging' | 'setDragging'> {
+    props: DataTableProps;
+    emit: EmitType<DataTableEmits>;
+    slots: DataTableSlots;
+    table: Table<unknown>;
+    getRowProps: (params: GetTableRowProps) => Record<string, any>;
+    selectionId: string;
+    cell: CellActions;
+    selectState: SelectionState;
+    col: ColActions;
+    sort: SortActions;
+    getSlotProps: ComputedRef<DataTableSlotProps>;
+    getTableLayout: ComputedRef<DataTableProps['tableLayout']>;
+    tableSelect: SelectionActions;
+    colWrap: ColumnWrapActions;
+    filter: FilterActions;
+    size: ColumnSizeActions;
+    fix: ColumnFixActions;
+    colOrder: ColumnOrderActions;
+    colPopover: ColumnPopoverActions;
+    row: RowActions;
+    getColDefByExtra: (col: TableCol) => TableColExtra & TableColumn;
+    hasFooter: Ref<boolean>;
+    onScroll: (e: Event) => void;
+    insertBetweenState: Ref<InsertBetweenState>;
+    hideShadowHeader: Ref<boolean>;
+    hideShadowColumn: Ref<boolean>;
+    headerRowCount: Ref<number>;
+    tableRootRef: Ref<HTMLElement | undefined>;
+    tableHeaderRef: Ref<any | undefined>;
+    tableBodyRef: Ref<any | undefined>;
+}

package/dist/components/DataTable/types/index.d.ts

@@ -0,0 +1,139 @@
+import { MoveEvent, SortableEvent, SortableOptions } from '@pantograph/sortable';
+import { Direction, EmptyProps, ScrollContainerProps, TableSize, TrProps } from '@pantograph/vue';
+import { ClassValue } from 'clsx';
+import { DataTableSlotProps, TableColumn, TableGetFunctionsProps } from './column';
+import { GetTableRowProps } from './common';
+import { TableRowSelection, TableSelectProps } from './select';
+import { DataTableContext } from './context';
+import { DefineComponent } from '@pantograph/utils-vue';
+export interface DataTableProps {
+    minVisibleAreaOnFixColumns?: number | string;
+    dir?: Direction;
+    resizing?: {
+        mode?: 'onChange' | 'onEnd';
+        enable?: boolean;
+    };
+    columnOrdering?: boolean;
+    rowOrdering?: boolean | (Partial<Pick<SortableOptions, 'group'>> & {
+        disabled?: boolean;
+        getSelectedCount?: (row: object) => number | string;
+        includeSubRowsOnMultiDragBadgeCount?: boolean;
+        onStart?: (event: SortableEvent, row?: object) => void;
+        onMove?: (evt: MoveEvent, related?: object) => boolean | -1 | 1 | void;
+        onEnd?: (event: SortableEvent, row?: object) => void;
+        onChoose?: (event: SortableEvent, row?: object) => void;
+        getIsRowDragging?: (row: object) => boolean;
+    });
+    columnDefaultMinWidth?: number;
+    columns: TableColumn[];
+    columnOrder?: string[];
+    filteredColumns?: string[];
+    columnVisibility?: Record<string, boolean>;
+    rowLoading?: Record<string, boolean>;
+    expanded?: true | Record<string, boolean>;
+    childrenRowName?: string | ((row: Record<string, any>) => any);
+    rowLazyLoadKey?: string | ((row: any) => any);
+    childrenColumnName?: string | ((row: any) => any);
+    data: object[];
+    class?: ClassValue;
+    theadCls?: ClassValue;
+    tbodyCls?: ClassValue;
+    actionHoverCls?: ClassValue;
+    rootCls?: ClassValue;
+    rowSelection?: TableRowSelection;
+    rowKey: string | ((row: Record<string, any>, index: number) => string);
+    lazyLoading?: boolean;
+    loading?: boolean;
+    emptyProps?: EmptyProps;
+    scrollContainerProps?: ScrollContainerProps;
+    size?: TableSize;
+    batchActionsTitle?: string;
+    loadingRowCount?: number;
+    stickyHeader?: boolean;
+    paginateExpandedRows?: boolean;
+    stickyFooter?: boolean;
+    zebra?: boolean;
+    insertBetweenRows?: boolean;
+    scroll?: {
+        scrollToFirstRowOnChange?: boolean;
+        x?: string | number | 'max-content';
+        y?: string | number;
+    };
+    tableLayout?: 'auto' | 'fixed';
+    actionCol?: Omit<TableColumn, 'id' | 'wrap' | 'colSpan' | 'dataIndex' | 'sorter' | 'sortOrder' | 'multiSort' | 'defaultSortOrder'> & {
+        id?: string;
+    };
+    noHeader?: boolean;
+    rowProps?: TrProps | ((data: GetTableRowProps) => TrProps);
+    fixedColumn?: string;
+    overflowScroll?: boolean | 'scrollContainer' | string;
+    scrollCls?: ClassValue;
+    insertBetweenRowsCls?: ClassValue;
+    hideDataOnLoading?: boolean;
+    bordered?: boolean;
+    columnBordered?: boolean;
+    getScrollElement?: () => HTMLElement | undefined;
+    virtual?: boolean;
+    reCalculateVirtualRows?: number;
+    bodyProps?: Record<string, any>;
+}
+export interface DataTableSlots {
+    headerCell?: (props: Partial<Pick<TableGetFunctionsProps, 'column'>>) => never;
+    bodyCell?: (props: TableGetFunctionsProps) => never;
+    footer?: (props: DataTableSlotProps) => never;
+    footerCell?: (props: Pick<TableGetFunctionsProps, 'column'>) => never;
+    skeleton?: (props: Partial<Omit<TableGetFunctionsProps, 'record'>>) => never;
+    batchActions?: (props: Partial<TableSelectProps>) => never;
+    action?: (props: TableGetFunctionsProps) => never;
+    cellAction?: (props: TableGetFunctionsProps) => never;
+    hoverAction?: (props: TableGetFunctionsProps) => never;
+    emptyTitle?: (params?: object) => never;
+    emptyDescription?: (params?: object) => never;
+    emptyActions?: (params?: object) => never;
+    emptyImage?: (params?: object) => never;
+    extra?: (params?: object) => never;
+}
+export interface SortItem {
+    desc: boolean;
+    id: string;
+    multiple?: number;
+    sorter: Required<TableColumn['sorter']>;
+}
+export interface DataTableRowDropParams extends SortableEvent {
+    multiple?: boolean;
+    before?: unknown;
+    after?: unknown;
+    beforeIndex?: number;
+    afterIndex?: number;
+    draggedRow?: unknown;
+    draggedRows?: unknown[];
+}
+export interface DataTableEmits {
+    drop: [params: DataTableRowDropParams];
+    'update:filteredColumns': [value: string[]];
+    'update:columnVisibility': [value?: Record<string, boolean>];
+    'update:expanded': [value?: Record<string, boolean> | true];
+    expand: [id: string, value: boolean];
+    'update:columnOrder': [value: string[]];
+    resize: [value: Record<string, number | undefined>];
+    reorder: [value: string[]];
+    fetch: [getIsVisible: () => Promise<boolean>];
+    rowClick: [row: object, event: Event];
+    insertBetweenRows: [row: GetTableRowProps & {
+        position: 'before' | 'after';
+    }];
+    sort: [column: TableColumn, order: 'asc' | 'desc' | false, sorting: SortItem[]];
+    columnWrap: [wrapped: boolean, column: TableColumn];
+    'update:fixedColumn': [value?: string];
+    init: [value?: DataTableContext];
+}
+export * from './cell';
+export * from './column';
+export { type GetTableRowProps } from './common';
+export * from './select';
+export { type DataTableContext };
+declare module 'vue' {
+    interface GlobalComponents {
+        DataTable: DefineComponent<DataTableProps, DataTableSlots, DataTableEmits>;
+    }
+}

package/dist/components/DataTable/types/select.d.ts

@@ -0,0 +1,25 @@
+import { CheckboxProps } from '@pantograph/vue';
+import { MaybeRef } from 'vue';
+export interface TableSelectProps<T = any> {
+    selectedRowKeys: MaybeRef<string[]>;
+    selectedRows: MaybeRef<T[]>;
+}
+export type TableRowSelection<T = any> = {
+    disabled?: boolean;
+    checkStrictly?: boolean;
+    columnWidth?: string | number;
+    getCheckboxProps?: (record: T) => CheckboxProps;
+    preserveSelectedRowKeys?: boolean;
+    selectedRowKeys?: string[];
+    onChange?: (props: TableSelectProps<T>) => void;
+    onSelect?: (props: TableSelectProps<T> & {
+        selected: boolean;
+        record: T;
+    }) => void;
+    onSelectAll?: (props: TableSelectProps<T> & {
+        selected: boolean;
+    }) => void;
+    getSelectable?: (row: T, index: number) => boolean;
+    getOrderable?: (row: T, index: number) => boolean;
+    colSpan?: (row: T, index: number) => number;
+};

package/dist/components/DataTable/utils/index.d.ts

@@ -0,0 +1,14 @@
+export * from './useCell';
+export * from './useCol';
+export * from './useRow';
+export * from './useColumnWrap';
+export * from './useSelection';
+export * from './useSort';
+export * from './useFilter';
+export * from './useColumnSize';
+export * from './useColumnFixed';
+export * from './useColumnOrder';
+export * from './useColumnPopover';
+export * from './useRowOrder';
+export * from './useRowVirtualizer';
+export * from './useInsertBetween';

package/dist/components/DataTable/utils/useCell.d.ts

@@ -0,0 +1,23 @@
+import { TableColumn, TableGetFunctionsProps } from '../types';
+import { SkeletonProps } from '@pantograph/vue';
+import { VNode } from 'vue';
+import { Table } from '@tanstack/vue-table';
+interface RenderCellProps {
+    props: {
+        column: any;
+        row?: any;
+        table: Table<unknown>;
+    };
+    render?: object | never | string;
+    customRender?: object | never | string;
+}
+export interface CellActions {
+    getSkeletonProps: (column?: TableColumn) => SkeletonProps;
+    RenderCell: (data: RenderCellProps) => VNode;
+    getThProps: (data: any) => Record<string, any>;
+    getTdProps: (data: any) => Record<string, any>;
+    getCellParams: (data: any) => TableGetFunctionsProps;
+    isThVisible: (headerTrIndex: number, headerTrCount: number, id: string) => boolean;
+}
+export declare const useCell: ({ isColumnWrapped, getOutsideCol }: any) => CellActions;
+export {};

package/dist/components/DataTable/utils/useCol.d.ts

@@ -0,0 +1,35 @@
+import { DataTableEmits, DataTableProps, DataTableSlots, TableCol, TableColumn } from '../types';
+import { ComputedRef, Ref } from 'vue';
+import { Column } from '@tanstack/vue-table';
+import { EmitType } from '@pantograph/utils-vue';
+export interface ColActions {
+    cols: ComputedRef<any[]>;
+    colsSize: ComputedRef<Record<string, number | undefined>>;
+    autoFitWidth: Ref<string[]>;
+    columnOrder: Ref<string[]>;
+    columnOrderUpdating: Ref<boolean>;
+    actionId: ComputedRef<string>;
+    columnVisibility: Ref<Record<string, boolean>>;
+    setColumnVisibility: (params: {
+        id?: string;
+        value?: boolean;
+        bulkValue?: Record<string, boolean>;
+    }) => void;
+    getOutsideCol: (col: any) => TableColumn;
+    columnDefaults: {
+        size: number;
+        minSize: number;
+        maxSize: number;
+    };
+    setAutoFitWidth: (col: Column<unknown>, value: boolean) => void;
+    colRefs: Ref<Record<string, HTMLElement>>;
+    setColRef: (id: string, col: HTMLElement) => void;
+    getColRefSize: (col: TableCol) => number;
+}
+export declare const useCol: ({ props, emit, prefix, slots, getSelectionCol, }: {
+    props: DataTableProps;
+    emit: EmitType<DataTableEmits>;
+    slots: DataTableSlots;
+    prefix: string;
+    getSelectionCol: () => any;
+}) => ColActions;

package/dist/components/DataTable/utils/useColumnFixed.d.ts

@@ -0,0 +1,23 @@
+import { EmitType } from '@pantograph/utils-vue';
+import { Table } from '@tanstack/vue-table';
+import { ComputedRef, Ref } from 'vue';
+import { DataTableEmits, DataTableProps, TableCol } from '../types';
+export interface ColumnFixActions {
+    fixedColumn: Ref<undefined | TableCol>;
+    fixedCols: ComputedRef<TableCol[]>;
+    isColFixed: (column?: TableCol, returnUndefinedAsFalse?: boolean) => boolean | undefined;
+    fixUpToColumn: (column: TableCol) => void;
+    unfixAllColumns: () => void;
+    getBeforeFixedCols: (column: TableCol) => TableCol[];
+    getSortedCols: (columns?: TableCol[]) => TableCol[];
+}
+interface UseColumnFixedParams {
+    props: DataTableProps;
+    emit: EmitType<DataTableEmits>;
+    table: Table<unknown>;
+    getColRefSize: (col: TableCol) => number;
+    tableRootRef: Ref<HTMLElement | undefined>;
+    setColumnSizing: (columnSizing: Record<string, number>) => void;
+}
+export declare const useColumnFix: ({ props, emit, table, getColRefSize, tableRootRef, setColumnSizing, }: UseColumnFixedParams) => ColumnFixActions;
+export {};

package/dist/components/DataTable/utils/useColumnOrder.d.ts

@@ -0,0 +1,32 @@
+import { DataTableEmits, DataTableProps } from '../types';
+import { Table } from '@tanstack/vue-table';
+import { ComputedRef, Ref } from 'vue';
+import { SortableEvent } from '@pantograph/sortable';
+import { EmitType } from '@pantograph/utils-vue';
+/**
+ * Actions interface for managing column order operations
+ */
+export interface ColumnOrderActions {
+    updateColumnOrder: () => void;
+    updateColumnOrderFromDOM: (event: SortableEvent, depth: number) => void;
+}
+/**
+ * Hook for managing column ordering in data tables
+ *
+ * @param columnOrder - Reactive reference to current column order
+ * @param columnOrderUpdating - Flag to prevent update loops
+ * @param props - DataTable component props
+ * @param emit - DataTable component emits
+ * @param selectionId - ID of selection column
+ * @param actionId - ID of action column
+ * @param table - TanStack table instance
+ */
+export declare const useColumnOrder: ({ columnOrder, columnOrderUpdating, props, emit, selectionId, actionId, table, }: {
+    columnOrder: Ref<string[]>;
+    columnOrderUpdating: Ref<boolean>;
+    props: DataTableProps;
+    emit: EmitType<DataTableEmits>;
+    selectionId: string;
+    actionId: ComputedRef<string>;
+    table: Table<unknown>;
+}) => ColumnOrderActions;

package/dist/components/DataTable/utils/useColumnPopover.d.ts

@@ -0,0 +1,19 @@
+import { Ref } from 'vue';
+import { TableCol } from '../types';
+import { PopoverProps } from '@pantograph/vue';
+import { DebouncedFunction } from 'es-toolkit';
+type OpenState = 'open' | 'closed';
+export interface ColumnPopoverActions {
+    open: Ref<boolean>;
+    reference: Ref<PopoverProps['reference']>;
+    parentReference: Ref<PopoverProps['reference']>;
+    column: Ref<TableCol | undefined>;
+    getActionState: (_column: TableCol) => OpenState;
+    openHoverCard: (e: PointerEvent, _column: TableCol) => void;
+    debounceOpenHoverCard: DebouncedFunction<(e: PointerEvent, _column: TableCol) => void>;
+    closeHoverCard: () => void;
+    onPointerDown: (e: PointerEvent, _column: TableCol) => void;
+    debounceCloseHoverCard: DebouncedFunction<() => void>;
+}
+export declare const useColumnPopover: () => ColumnPopoverActions;
+export {};

package/dist/components/DataTable/utils/useColumnSize.d.ts

@@ -0,0 +1,14 @@
+import { TableCol } from '../types';
+import { Ref } from 'vue';
+import { ColActions } from './useCol';
+import { Table } from '@tanstack/vue-table';
+export interface ColumnSizeActions {
+    getColSizeStyle: (column: TableCol, isFixed?: boolean, getSortedCols?: (columns: TableCol[]) => TableCol[]) => Record<string, any>;
+    setColumnSizing: (columnSizing: Record<string, number>) => void;
+}
+export declare const useColumnSize: ({ hideShadowColumn, col, table, setColumnSizingLocallyReset, }: {
+    hideShadowColumn: Ref<boolean>;
+    col: ColActions;
+    table: Table<unknown>;
+    setColumnSizingLocallyReset: (value: boolean) => void;
+}) => ColumnSizeActions;

package/dist/components/DataTable/utils/useColumnWrap.d.ts

@@ -0,0 +1,7 @@
+import { DataTableProps, DataTableEmits, TableCol } from '../types';
+import { EmitType } from '@pantograph/utils-vue';
+export interface ColumnWrapActions {
+    isColumnWrapped: (id?: string) => boolean;
+    toggleWrap: (column: TableCol) => boolean;
+}
+export declare const useColumnWrap: (props: DataTableProps, emit: EmitType<DataTableEmits>, defaultWrappedIds: string[]) => ColumnWrapActions;

package/dist/components/DataTable/utils/useFilter.d.ts

@@ -0,0 +1,14 @@
+import { EmitType } from '@pantograph/utils-vue';
+import { PopoverProps } from '@pantograph/vue';
+import { Ref } from 'vue';
+import { DataTableEmits, DataTableProps, TableCol } from '../types';
+export interface FilterActions {
+    colFilter: (placement: PopoverProps['placement'], reference: PopoverProps['reference'], col: TableCol) => void;
+    deleteColFilter: (placement: PopoverProps['placement'], reference: PopoverProps['reference'], col: TableCol) => void;
+    filteredCols: Ref<string[]>;
+    isColumnFiltered: (id?: string) => boolean;
+}
+export declare const useFilter: ({ props, emit, }: {
+    props: DataTableProps;
+    emit: EmitType<DataTableEmits>;
+}) => FilterActions;

package/dist/components/DataTable/utils/useInsertBetween.d.ts

@@ -0,0 +1,5 @@
+import { DataTableContext } from '../types';
+export declare const useInsertBetween: (context: DataTableContext) => {
+    onPointermove: import('es-toolkit').ThrottledFunction<(e: PointerEvent) => void>;
+    onPointerleave: () => void;
+};

package/dist/components/DataTable/utils/useRow.d.ts

@@ -0,0 +1,9 @@
+import { DataTableProps } from '../types';
+import { Ref } from 'vue';
+import { ExpandedState } from '@tanstack/vue-table';
+export interface RowActions {
+    expanded: Ref<ExpandedState>;
+}
+export declare const useRow: ({ props }: {
+    props: DataTableProps;
+}) => RowActions;

package/dist/components/DataTable/utils/useRowOrder.d.ts

@@ -0,0 +1,114 @@
+import { Row } from '@tanstack/table-core';
+import { ComputedRef } from 'vue';
+import { DataTableContext } from '../types';
+interface RowSortableParams {
+    context: DataTableContext;
+    hasSubRows: ComputedRef<boolean>;
+    visibleFlattenRows: ComputedRef<Row<unknown>[]>;
+    getShouldCollapseParent: (row: Row<unknown>) => boolean | undefined;
+    getTableBindings: (_class?: string) => Record<string, any>;
+}
+export declare const useRowOrder: ({ context, hasSubRows: _hasSubRows, visibleFlattenRows, getShouldCollapseParent, getTableBindings, }: RowSortableParams) => {
+    id: ComputedRef<any>;
+    draggedRow: import('vue').Ref<{
+        _getAllCellsByColumnId: () => Record<string, import('@tanstack/table-core').Cell<unknown, unknown>>;
+        _uniqueValuesCache: Record<string, unknown>;
+        _valuesCache: Record<string, unknown>;
+        depth: number;
+        getAllCells: () => import('@tanstack/table-core').Cell<unknown, unknown>[];
+        getLeafRows: () => Row<unknown>[];
+        getParentRow: () => Row<unknown> | undefined;
+        getParentRows: () => Row<unknown>[];
+        getUniqueValues: <TValue>(columnId: string) => TValue[];
+        getValue: <TValue_1>(columnId: string) => TValue_1;
+        id: string;
+        index: number;
+        original: unknown;
+        originalSubRows?: unknown[] | undefined;
+        parentId?: string | undefined;
+        renderValue: <TValue_2>(columnId: string) => TValue_2;
+        subRows: any[];
+        _getAllVisibleCells: () => import('@tanstack/table-core').Cell<unknown, unknown>[];
+        getVisibleCells: () => import('@tanstack/table-core').Cell<unknown, unknown>[];
+        getCenterVisibleCells: () => import('@tanstack/table-core').Cell<unknown, unknown>[];
+        getLeftVisibleCells: () => import('@tanstack/table-core').Cell<unknown, unknown>[];
+        getRightVisibleCells: () => import('@tanstack/table-core').Cell<unknown, unknown>[];
+        getCanPin: () => boolean;
+        getIsPinned: () => import('@tanstack/table-core').RowPinningPosition;
+        getPinnedIndex: () => number;
+        pin: (position: import('@tanstack/table-core').RowPinningPosition, includeLeafRows?: boolean | undefined, includeParentRows?: boolean | undefined) => void;
+        columnFilters: Record<string, boolean>;
+        columnFiltersMeta: Record<string, import('@tanstack/table-core').FilterMeta>;
+        _groupingValuesCache: Record<string, any>;
+        getGroupingValue: (columnId: string) => unknown;
+        getIsGrouped: () => boolean;
+        groupingColumnId?: string | undefined;
+        groupingValue?: unknown;
+        getCanMultiSelect: () => boolean;
+        getCanSelect: () => boolean;
+        getCanSelectSubRows: () => boolean;
+        getIsAllSubRowsSelected: () => boolean;
+        getIsSelected: () => boolean;
+        getIsSomeSelected: () => boolean;
+        getToggleSelectedHandler: () => (event: unknown) => void;
+        toggleSelected: (value?: boolean | undefined, opts?: {
+            selectChildren?: boolean | undefined;
+        } | undefined) => void;
+        getCanExpand: () => boolean;
+        getIsAllParentsExpanded: () => boolean;
+        getIsExpanded: () => boolean;
+        getToggleExpandedHandler: () => () => void;
+        toggleExpanded: (expanded?: boolean | undefined) => void;
+    } | undefined, Row<unknown> | {
+        _getAllCellsByColumnId: () => Record<string, import('@tanstack/table-core').Cell<unknown, unknown>>;
+        _uniqueValuesCache: Record<string, unknown>;
+        _valuesCache: Record<string, unknown>;
+        depth: number;
+        getAllCells: () => import('@tanstack/table-core').Cell<unknown, unknown>[];
+        getLeafRows: () => Row<unknown>[];
+        getParentRow: () => Row<unknown> | undefined;
+        getParentRows: () => Row<unknown>[];
+        getUniqueValues: <TValue>(columnId: string) => TValue[];
+        getValue: <TValue_1>(columnId: string) => TValue_1;
+        id: string;
+        index: number;
+        original: unknown;
+        originalSubRows?: unknown[] | undefined;
+        parentId?: string | undefined;
+        renderValue: <TValue_2>(columnId: string) => TValue_2;
+        subRows: any[];
+        _getAllVisibleCells: () => import('@tanstack/table-core').Cell<unknown, unknown>[];
+        getVisibleCells: () => import('@tanstack/table-core').Cell<unknown, unknown>[];
+        getCenterVisibleCells: () => import('@tanstack/table-core').Cell<unknown, unknown>[];
+        getLeftVisibleCells: () => import('@tanstack/table-core').Cell<unknown, unknown>[];
+        getRightVisibleCells: () => import('@tanstack/table-core').Cell<unknown, unknown>[];
+        getCanPin: () => boolean;
+        getIsPinned: () => import('@tanstack/table-core').RowPinningPosition;
+        getPinnedIndex: () => number;
+        pin: (position: import('@tanstack/table-core').RowPinningPosition, includeLeafRows?: boolean | undefined, includeParentRows?: boolean | undefined) => void;
+        columnFilters: Record<string, boolean>;
+        columnFiltersMeta: Record<string, import('@tanstack/table-core').FilterMeta>;
+        _groupingValuesCache: Record<string, any>;
+        getGroupingValue: (columnId: string) => unknown;
+        getIsGrouped: () => boolean;
+        groupingColumnId?: string | undefined;
+        groupingValue?: unknown;
+        getCanMultiSelect: () => boolean;
+        getCanSelect: () => boolean;
+        getCanSelectSubRows: () => boolean;
+        getIsAllSubRowsSelected: () => boolean;
+        getIsSelected: () => boolean;
+        getIsSomeSelected: () => boolean;
+        getToggleSelectedHandler: () => (event: unknown) => void;
+        toggleSelected: (value?: boolean | undefined, opts?: {
+            selectChildren?: boolean | undefined;
+        } | undefined) => void;
+        getCanExpand: () => boolean;
+        getIsAllParentsExpanded: () => boolean;
+        getIsExpanded: () => boolean;
+        getToggleExpandedHandler: () => () => void;
+        toggleExpanded: (expanded?: boolean | undefined) => void;
+    } | undefined>;
+    isMultiDrag: ComputedRef<boolean>;
+};
+export {};

package/dist/components/DataTable/utils/useRowVirtualizer.d.ts

@@ -0,0 +1,12 @@
+import { ComputedRef, Ref } from 'vue';
+import { DataTableContext } from '../types';
+interface VirtualizerParams {
+    context: DataTableContext;
+    dataAndLoadingRows: ComputedRef<any[]>;
+    scrollRef: Ref<any>;
+}
+export declare const useRowVirtualizer: ({ context, dataAndLoadingRows, scrollRef, }: VirtualizerParams) => {
+    visibleItems: ComputedRef<any[]>;
+    trHeight: ComputedRef<string | number | undefined>;
+};
+export {};