@are-visual/virtual-table 0.6.0 → 0.8.0

package/README.md

@@ -137,6 +137,168 @@ function App() {
 
 > 关于 `getOffsetTop` 的默认实现是否会造成额外重排/性能影响，还有待验证。若你实在担心，可以设置 getOffsetTop 以覆盖默认实现。
 
+#### useTableInstance
+
+一个提供编程式操作 VirtualTable 的 hook。
+
+> 版本要求：>=v0.8.0
+
+##### scrollToRow 滚动到指定行
+
+```tsx
+const instance = useTableInstance()
+
+const onScroll = () => {
+  // 通过索引值，滚动到第 10 行
+  instance.scrollToRow(10)
+}
+
+<VirtualTable instance={instance} />
+```
+
+> 注意：由于是虚拟列表，行高是不确定的，若 `estimatedRowHeight` 不准确，scrollToRow 则无法准确滚动到对应的行。
+
+##### scrollToColumn 滚动到指定列
+
+```tsx
+const instance = useTableInstance()
+
+const onScroll = () => {
+  // 通过 key，滚动到指定列
+  instance.scrollToColumn('columnKey')
+}
+
+<VirtualTable instance={instance} />
+```
+
+> 注意：由于是虚拟列表，列宽是不确定的，若 `estimatedColumnWidth` 不准确，scrollToColumn 则无法准确滚动到对应的列。
+
+##### scrollTo 手动滚动
+
+```tsx
+const instance = useTableInstance()
+
+const onScroll = () => {
+  // 使用像素值进行滚动，背后其实是对原生 DOM 节点的 scrollTo 进行的封装
+  instance.scrollTo({ top: 0, left: 0 })
+}
+
+<VirtualTable instance={instance} />
+```
+
+##### getScrollValueByRowIndex
+
+```tsx
+const instance = useTableInstance()
+
+const onScroll = () => {
+  // 通过索引值，滚动到第 10 行所对应的数值
+  console.log(instance.getScrollValueByRowIndex(10))
+}
+```
+
+##### getScrollValueByColumnKey
+
+```tsx
+const instance = useTableInstance()
+
+const onScroll = () => {
+  // 通过 key，获取滚动到指定列所对应的数值
+  console.log(instance.getScrollValueByColumnKey('columnKey'))
+}
+```
+
+##### getDOM
+
+有些时候，你不得不获取 DOM 节点来进行一些操作。
+
+```tsx
+const instance = useTableInstance()
+
+const doSomething = () => {
+  const { root, headerWrapper, bodyWrapper, bodyRoot, body } = instance.getDOM()
+}
+
+<VirtualTable instance={instance} />
+```
+
+##### getCurrentProps
+
+有些时候，你可能不太方便获取到传递给 VirtualTable 的 props，那么你可以通过 `instance.getCurrentProps` 获取。
+
+```tsx
+const instance = useTableInstance()
+
+const doSomething = () => {
+  console.log(instance.getCurrentProps().stickyHeader)
+}
+
+<VirtualTable stickyHeader={120} instance={instance} />
+```
+
+##### getRowVirtualizeState 获取行虚拟化用到的数据
+
+```tsx
+const { startIndex, endIndex, overscan, estimateSize } = instance.getRowVirtualizeState()
+```
+
+##### getRowHeightMap 获取所有的行高信息
+
+```ts
+const heightMap = instance.getRowHeightMap()
+
+heightMap.get(rowKey)
+```
+
+##### getColumnByKey 通过 columnKey 获取 column 定义
+
+```ts
+const column = instance.getColumnByKey(columnKey)
+```
+
+##### getColumnByIndex 通过索引获取 column 定义
+
+```ts
+const column = instance.getColumnByIndex(index)
+```
+
+##### getColumnKeyByIndex 通过索引获取 columnKey
+
+```ts
+const columnKey = instance.getColumnKeyByIndex(index)
+```
+
+##### getColumnWidths 获取所有的列宽
+
+所有的列宽通过 columnKey 进行记录（无序）。
+
+```ts
+const widths = instance.getColumnWidths()
+widths.get(columnKey)
+```
+
+##### getColumnWidthByKey 通过 columnKey 获取列宽
+
+```ts
+const width = instance.getColumnWidthByKey(columnKey)
+```
+
+##### getColumns 获取 middleware 处理过的 columns
+
+```ts
+const pipelineColumns = instance.getColumns()
+```
+
+##### getDataSource 获取 middleware 处理过的 dataSource
+
+```ts
+const pipelineDataSource = instance.getDataSource()
+```
+
+通过以上的函数，你可以很方便的获取一些 VirtualTable 内部的数据，但是这些函数不能在 render 阶段中直接调用，否则会抛出 `has not been implemented yet` 错误。因为这些函数都在 VirtualTable 内部渲染阶段初始化，它们初始化完成后便能使用。建议在事件处理函数中调用。
+
+你也许会发现有些函数能够在渲染阶段直接使用，但是并不能保证在未来的版本中均是如此。
+
 #### 插件
 
 `@are-visual/virtual-table` 提供一个 `useTablePipeline` hook 用于组合各种插件，为 Table 增加各式各样的功能。
@@ -251,6 +413,7 @@ const mergedPipeline = useTablePipeline({
 | bodyRef | tbody 元素 | RefObject\<HTMLTableSectionElement\> | |
 | getScroller | 获取滚动容器 | () => ScrollElement \| undefined |  |
 | getOffsetTop | 计算顶部偏移量 | () => number | |
+| instance | 与 useTableInstance 一致 | TableInstance | >=0.8.0 |
 
 ##### 插件返回值定义
 

package/index.d.ts

@@ -1,5 +1,5 @@
 import * as react from 'react';
-import { DetailedHTMLProps, HTMLAttributes, Key, ReactNode, TdHTMLAttributes, RefObject, ReactElement, CSSProperties, Ref, RefAttributes } from 'react';
+import { DetailedHTMLProps, HTMLAttributes, Key, ReactElement, CSSProperties, Ref, RefAttributes, ReactNode, TdHTMLAttributes, RefObject } from 'react';
 
 type ScrollElement = HTMLElement | Window;
 declare function getScrollParent(el: Element, root?: ScrollElement | null | undefined): ScrollElement;
@@ -10,6 +10,92 @@ declare function getScrollElement(el: unknown): Element;
 declare function getScrollTop(node: ScrollElement): number;
 declare function getRelativeOffsetTop(el: HTMLElement, ancestor: HTMLElement): number;
 
+type NativeProps$1 = DetailedHTMLProps<HTMLAttributes<HTMLTableRowElement>, HTMLTableRowElement>;
+interface OnRefCallbackArgs<T> {
+    node: HTMLTableRowElement | null;
+    rowKey: Key;
+    rowIndex: number;
+    rowData: T;
+}
+interface RowProps<T> extends Omit<NativeProps$1, 'children'> {
+    rowIndex: number;
+    rowKey: Key;
+    rowData: T;
+    columns: InnerColumnDescriptor<T>;
+    onRow?: OnRowType<T>;
+    renderRow?: MiddlewareRenderRow;
+    renderCell?: MiddlewareRenderCell;
+    onRefCallback?: (args: OnRefCallbackArgs<T>) => void;
+}
+declare const _default$3: <T>(props: RowProps<T>) => ReactElement;
+
+interface TableBodyProps<T> extends Omit<NecessaryProps<T>, 'columns'>, Pick<RowProps<T>, 'onRow' | 'renderRow' | 'renderCell'> {
+    className?: string;
+    style?: CSSProperties;
+    columns: InnerColumnDescriptor<T>;
+    bodyWrapperRef?: Ref<HTMLDivElement>;
+    bodyRootRef?: Ref<HTMLTableElement>;
+    bodyRef?: Ref<HTMLTableSectionElement>;
+    instance: TableInstance;
+    overscan: number;
+    estimateSize: number;
+    getOffsetTop: () => number;
+    getScroller: () => ScrollElement | undefined;
+    rowClassName?: (record: T, index: number) => string;
+    renderBodyWrapper?: MiddlewareRenderBodyWrapper;
+    renderBodyRoot?: MiddlewareRenderBodyRoot;
+    renderBody?: MiddlewareRenderBody;
+    renderBodyContent?: MiddlewareRenderBodyContent;
+}
+
+interface Hook<T> {
+    priority: number;
+    hook: Middleware<T>;
+}
+declare class TablePipeline<T> {
+    constructor();
+    hooks: Hook<T>[];
+    setHooks(value: Hook<T>[]): void;
+    use(options: MiddlewareContext<T>): MiddlewareResult<T>;
+    static defaultPipeline: TablePipeline<unknown>;
+}
+
+interface UseTablePipelineOptions<T = any> {
+    pipeline?: TablePipeline<T>;
+    use?: (Middleware<T> | Hook<T>)[];
+}
+
+declare function useTablePipeline<T = any>(options: UseTablePipelineOptions<T>): TablePipeline<T>;
+
+interface VirtualTableCoreProps<T> extends NecessaryProps<T>, Pick<TableBodyProps<T>, 'rowClassName' | 'onRow'> {
+    bodyRootRef?: Ref<HTMLTableElement>;
+    instance?: TableInstance;
+    className?: string;
+    style?: CSSProperties;
+    tableBodyClassName?: string;
+    tableBodyStyle?: CSSProperties;
+    /** 开启表头 sticky，设置为 true 则默认 top 为 0，为 number 则是偏移量 */
+    stickyHeader?: number | boolean;
+    /** 预计每列宽度，需要横向虚拟化时，设置它 */
+    estimatedColumnWidth?: number;
+    /** 预计每行高度 @default 46 */
+    estimatedRowHeight?: number;
+    /** 在头和尾额外渲染多少行 @default 5 */
+    overscanRows?: number;
+    /** 横向虚拟化时，在头和尾额外渲染多少列 @default 3 */
+    overscanColumns?: number;
+    /** 开启表头虚拟滚动 @default true */
+    virtualHeader?: boolean;
+    /**
+     * 缺失宽度设置时的默认值（与虚拟化无关）
+     * @default 100
+     */
+    defaultColumnWidth?: number;
+    pipeline?: TablePipeline<T>;
+    getOffsetTop?: () => number;
+}
+declare const _default$2: <T>(props: VirtualTableCoreProps<T> & RefAttributes<HTMLDivElement>) => ReactElement;
+
 type FixedType = 'left' | 'right';
 declare function isValidFixedLeft(fixed: unknown): fixed is "left";
 declare function isValidFixedRight(fixed: unknown): fixed is "right";
@@ -56,6 +142,48 @@ interface InnerColumnDescriptor<T> {
     descriptor: ColumnDescriptor<T>[];
     columns: ColumnType<T>[];
 }
+interface TableInstance<T = any> {
+    getCurrentProps: () => Readonly<VirtualTableCoreProps<T>>;
+    /** 获取所有 middleware 处理过的 columns */
+    getColumns: () => ColumnType<T>[];
+    /** 获取所有 middleware 处理过的 dataSource */
+    getDataSource: () => T[];
+    getDOM: () => {
+        root: HTMLDivElement | null;
+        headerWrapper: HTMLDivElement | null;
+        bodyWrapper: HTMLDivElement | null;
+        bodyRoot: HTMLTableElement | null;
+        body: HTMLTableSectionElement | null;
+    };
+    /** 获取行虚拟化用到的数据 */
+    getRowVirtualizeState: () => {
+        startIndex: number;
+        endIndex: number;
+        overscan: number;
+        estimateSize: number;
+    };
+    /** 获取所有的行高信息。Map<rowKey, Map<key, number>> */
+    getRowHeightMap: () => Map<Key, Map<Key, number>>;
+    /** 通过索引值，获取指定行所对应的滚动数值 */
+    getScrollValueByRowIndex: (index: number) => number;
+    /** 通过 columnKey，获取指定列所对应的滚动数值 */
+    getScrollValueByColumnKey: (columnKey: Key) => number;
+    /** 通过索引值，滚动到指定行 */
+    scrollToRow: (index: number) => void;
+    /** 通过 columnKey，滚动到指定列 */
+    scrollToColumn: (columnKey: Key) => void;
+    scrollTo: (options: ScrollToOptions) => void;
+    /** 通过 columnKey 获取 column 定义 */
+    getColumnByKey: (columnKey: Key) => ColumnType<T> | undefined;
+    /** 通过索引获取 column 定义 */
+    getColumnByIndex: (index: number) => ColumnType<T> | undefined;
+    /** 通过索引获取 columnKey */
+    getColumnKeyByIndex: (index: number) => Key | undefined;
+    /** 获取所有的列宽 */
+    getColumnWidths: () => Map<Key, number>;
+    /** 通过 columnKey 获取列宽 */
+    getColumnWidthByKey: (columnKey: Key) => number | undefined;
+}
 
 interface NecessaryProps<T> {
     dataSource: T[];
@@ -75,6 +203,7 @@ interface MiddlewareContext<T> extends Readonly<NecessaryProps<T>> {
     readonly bodyRef: RefObject<HTMLTableSectionElement>;
     readonly getScroller: () => ScrollElement | undefined;
     readonly getOffsetTop: () => number;
+    readonly instance: TableInstance;
     [key: string]: unknown;
 }
 interface MiddlewareResult<T> extends MiddlewareContext<T>, MiddlewareRenders {
@@ -86,6 +215,7 @@ type Middleware<T> = (context: MiddlewareContext<T>) => MiddlewareResult<T>;
 interface RenderOptions<T = any> {
     column: ColumnType<T>;
     columnWidths: Map<Key, number>;
+    rowKey: Key;
     rowIndex: number;
     startRowIndex: number;
     columns: ColumnType<T>[];
@@ -106,7 +236,7 @@ type MiddlewareRenderBodyWrapper<T = any> = (children: ReactNode, options: Prett
 type MiddlewareRenderBodyRoot<T = any> = (children: ReactNode, options: Prettify<Pick<RenderOptions<T>, 'columns' | 'columnDescriptor' | 'startRowIndex'>>) => ReactNode;
 type MiddlewareRenderBody<T = any> = (children: ReactNode, options: Prettify<Pick<RenderOptions<T>, 'columns' | 'columnDescriptor' | 'startRowIndex'>>) => ReactNode;
 type MiddlewareRenderBodyContent<T = any> = (children: ReactNode, options: Prettify<Pick<RenderOptions<T>, 'columns' | 'columnDescriptor' | 'startRowIndex'>>) => ReactNode;
-type MiddlewareRenderRow<T = any> = (children: ReactNode, options: Prettify<Pick<RenderOptions<T>, 'columns' | 'columnDescriptor' | 'rowIndex' | 'rowData'>>) => ReactNode;
+type MiddlewareRenderRow<T = any> = (children: ReactNode, options: Prettify<Pick<RenderOptions<T>, 'columns' | 'columnDescriptor' | 'rowKey' | 'rowIndex' | 'rowData'>>) => ReactNode;
 type MiddlewareRenderCell<T = any> = (children: ReactNode, options: Prettify<Pick<RenderOptions<T>, 'column'>>) => ReactNode;
 type MergedMiddlewareRender<T = any> = MiddlewareRender<T> | MiddlewareRenderRoot<T> | MiddlewareRenderContent<T> | MiddlewareRenderHeaderWrapper<T> | MiddlewareRenderHeaderRoot<T> | MiddlewareRenderHeader<T> | MiddlewareRenderHeaderRow<T> | MiddlewareRenderHeaderCell<T> | MiddlewareRenderBodyWrapper<T> | MiddlewareRenderBodyRoot<T> | MiddlewareRenderBody<T> | MiddlewareRenderBodyContent<T> | MiddlewareRenderRow<T> | MiddlewareRenderCell<T>;
 interface MiddlewareRenders {
@@ -179,20 +309,20 @@ interface MiddlewareRenders {
     renderCell?: MiddlewareRenderCell;
 }
 
-type NativeProps$1 = DetailedHTMLProps<HTMLAttributes<HTMLTableCellElement>, HTMLTableCellElement>;
-interface CellProps<T> extends Omit<NativeProps$1, 'children'> {
+type NativeProps = DetailedHTMLProps<HTMLAttributes<HTMLTableCellElement>, HTMLTableCellElement>;
+interface CellProps<T> extends Omit<NativeProps, 'children'> {
     column: ColumnType<T>;
     rowIndex: number;
     rowData: T;
     renderCell?: MiddlewareRenderCell;
 }
-declare const _default$3: <T>(props: CellProps<T>) => ReactElement;
+declare const _default$1: <T>(props: CellProps<T>) => ReactElement;
 
 interface ColgroupProps {
     columns: ColumnDescriptor[];
     onColumnSizesMeasure?: (columnSizes: Map<Key, number>) => void;
 }
-declare const _default$2: react.NamedExoticComponent<ColgroupProps>;
+declare const _default: react.NamedExoticComponent<ColgroupProps>;
 
 interface TableColumnsContextType {
     widthList: Map<Key, number>;
@@ -221,11 +351,11 @@ declare function useHorizontalScrollContext(): HorizontalScrollContextState;
 interface TableRowManagerContextType {
     getRowHeightList: () => number[];
     /**
-     * @param index rowIndex
+     * @param rowKey
      * @param key 唯一的 key，用于去重
      * @param height 行高
      */
-    updateRowHeight: (index: number, key: Key, height: number) => void;
+    setRowHeightByRowKey: (rowKey: Key, key: Key, height: number) => void;
 }
 declare function useTableRowManager(): TableRowManagerContextType;
 
@@ -239,6 +369,8 @@ interface StickyContextState {
 }
 declare function useTableSticky(): StickyContextState;
 
+declare const NormalRowHeightKey = "NormalRow";
+
 /**
  * 缓存数据（浅比较，如果是数组则对第一层进行浅比较）
  */
@@ -246,87 +378,13 @@ declare function useShallowMemo<T>(pickData: () => T): T;
 
 declare function useStableFn<T extends Function>(callback: T): T;
 
+declare function useTableInstance(instance?: TableInstance): TableInstance<any>;
+
 /**
  * 创建中间件，内部会浅比较 options，只有 options 改变才会返回新的函数。
  */
 declare function createMiddleware<T, Args extends any[]>(hook: (ctx: MiddlewareContext<T>, ...args: Args) => MiddlewareResult<T>): (...args: Args) => Middleware<T>;
 
-interface Hook<T> {
-    priority: number;
-    hook: Middleware<T>;
-}
-declare class TablePipeline<T> {
-    constructor();
-    hooks: Hook<T>[];
-    setHooks(value: Hook<T>[]): void;
-    use(options: MiddlewareContext<T>): MiddlewareResult<T>;
-    static defaultPipeline: TablePipeline<unknown>;
-}
-
-interface UseTablePipelineOptions<T = any> {
-    pipeline?: TablePipeline<T>;
-    use?: (Middleware<T> | Hook<T>)[];
-}
-
-declare function useTablePipeline<T = any>(options: UseTablePipelineOptions<T>): TablePipeline<T>;
-
-type NativeProps = DetailedHTMLProps<HTMLAttributes<HTMLTableRowElement>, HTMLTableRowElement>;
-interface RowProps<T> extends Omit<NativeProps, 'children'> {
-    rowIndex: number;
-    rowData: T;
-    columns: InnerColumnDescriptor<T>;
-    onRow?: OnRowType<T>;
-    renderRow?: MiddlewareRenderRow;
-    renderCell?: MiddlewareRenderCell;
-}
-declare const _default$1: <T>(props: RowProps<T>) => ReactElement;
-
-interface TableBodyProps<T> extends Omit<NecessaryProps<T>, 'columns'>, Pick<RowProps<T>, 'onRow' | 'renderRow' | 'renderCell'> {
-    className?: string;
-    style?: CSSProperties;
-    columns: InnerColumnDescriptor<T>;
-    bodyWrapperRef?: Ref<HTMLDivElement>;
-    bodyRootRef?: Ref<HTMLTableElement>;
-    bodyRef?: Ref<HTMLTableSectionElement>;
-    overscan: number;
-    estimateSize: number;
-    getOffsetTop: () => number;
-    getScroller: () => ScrollElement | undefined;
-    rowClassName?: (record: T, index: number) => string;
-    renderBodyWrapper?: MiddlewareRenderBodyWrapper;
-    renderBodyRoot?: MiddlewareRenderBodyRoot;
-    renderBody?: MiddlewareRenderBody;
-    renderBodyContent?: MiddlewareRenderBodyContent;
-}
-
-interface VirtualTableCoreProps<T> extends NecessaryProps<T>, Pick<TableBodyProps<T>, 'rowClassName' | 'onRow'> {
-    bodyRootRef?: Ref<HTMLTableElement>;
-    className?: string;
-    style?: CSSProperties;
-    tableBodyClassName?: string;
-    tableBodyStyle?: CSSProperties;
-    /** 开启表头 sticky，设置为 true 则默认 top 为 0，为 number 则是偏移量 */
-    stickyHeader?: number | boolean;
-    /** 预计每列宽度，需要横向虚拟化时，设置它 */
-    estimatedColumnWidth?: number;
-    /** 预计每行高度 @default 46 */
-    estimatedRowHeight?: number;
-    /** 在头和尾额外渲染多少行 @default 5 */
-    overscanRows?: number;
-    /** 横向虚拟化时，在头和尾额外渲染多少列 @default 3 */
-    overscanColumns?: number;
-    /** 开启表头虚拟滚动 @default true */
-    virtualHeader?: boolean;
-    /**
-     * 缺失宽度设置时的默认值（与虚拟化无关）
-     * @default 100
-     */
-    defaultColumnWidth?: number;
-    pipeline?: TablePipeline<T>;
-    getOffsetTop?: () => number;
-}
-declare const _default: <T>(props: VirtualTableCoreProps<T> & RefAttributes<HTMLDivElement>) => ReactElement;
-
 declare function getKey<T>(column: ColumnType<T>): Key;
 declare function getRowKey<T>(rowData: T, rowKey: NecessaryProps<T>['rowKey']): Key;
 
@@ -342,4 +400,5 @@ type PossibleRef<T> = Ref<T> | undefined;
 declare function mergeRefs<T>(...refs: PossibleRef<T>[]): (node: T | null) => void;
 declare function useMergedRef<T>(...refs: PossibleRef<T>[]): (node: T | null) => void;
 
-export { type AlignType, type AnyObject, _default$2 as Colgroup, type ColumnDescriptor, type ColumnExtra, type ColumnType, type ContainerSizeState, type FixedType, type HorizontalScrollContextState, type MergedMiddlewareRender, type Middleware, type MiddlewareContext, type MiddlewareRender, type MiddlewareRenderBody, type MiddlewareRenderBodyContent, type MiddlewareRenderBodyRoot, type MiddlewareRenderBodyWrapper, type MiddlewareRenderCell, type MiddlewareRenderContent, type MiddlewareRenderHeader, type MiddlewareRenderHeaderCell, type MiddlewareRenderHeaderRoot, type MiddlewareRenderHeaderRow, type MiddlewareRenderHeaderWrapper, type MiddlewareRenderRoot, type MiddlewareRenderRow, type MiddlewareRenders, type MiddlewareResult, type OnRowType, type PipelineRender, type PipelineRenderOptions, type ScrollElement, type StickyContextState, type TableColumnsContextType, TablePipeline, type TableRowManagerContextType, type UseTablePipelineOptions, _default as VirtualTable, _default$3 as VirtualTableCell, type CellProps as VirtualTableCellProps, type VirtualTableCoreProps as VirtualTableProps, _default$1 as VirtualTableRow, type RowProps as VirtualTableRowProps, createMiddleware, findLastIndex, getKey, getRelativeOffsetTop, getRowKey, getScrollElement, getScrollParent, getScrollTop, isDocument, isRoot, isValidFixed, isValidFixedLeft, isValidFixedRight, isWindow, mergeRefs, onResize, useColumnSizes, useContainerSize, useHorizontalScrollContext, useMergedRef, useShallowMemo, useStableFn, useTablePipeline, useTableRowManager, useTableSticky };
+export { _default as Colgroup, NormalRowHeightKey, TablePipeline, _default$2 as VirtualTable, _default$1 as VirtualTableCell, _default$3 as VirtualTableRow, createMiddleware, findLastIndex, getKey, getRelativeOffsetTop, getRowKey, getScrollElement, getScrollParent, getScrollTop, isDocument, isRoot, isValidFixed, isValidFixedLeft, isValidFixedRight, isWindow, mergeRefs, onResize, useColumnSizes, useContainerSize, useHorizontalScrollContext, useMergedRef, useShallowMemo, useStableFn, useTableInstance, useTablePipeline, useTableRowManager, useTableSticky };
+export type { AlignType, AnyObject, ColumnDescriptor, ColumnExtra, ColumnType, ContainerSizeState, FixedType, HorizontalScrollContextState, MergedMiddlewareRender, Middleware, MiddlewareContext, MiddlewareRender, MiddlewareRenderBody, MiddlewareRenderBodyContent, MiddlewareRenderBodyRoot, MiddlewareRenderBodyWrapper, MiddlewareRenderCell, MiddlewareRenderContent, MiddlewareRenderHeader, MiddlewareRenderHeaderCell, MiddlewareRenderHeaderRoot, MiddlewareRenderHeaderRow, MiddlewareRenderHeaderWrapper, MiddlewareRenderRoot, MiddlewareRenderRow, MiddlewareRenders, MiddlewareResult, OnRowType, PipelineRender, PipelineRenderOptions, ScrollElement, StickyContextState, TableColumnsContextType, TableInstance, TableRowManagerContextType, UseTablePipelineOptions, CellProps as VirtualTableCellProps, VirtualTableCoreProps as VirtualTableProps, RowProps as VirtualTableRowProps };