@hi-ui/schema-editable-table 4.0.0-experimental.1

package/lib/types/hooks/use-props.d.ts

@@ -0,0 +1,109 @@
+import type { ReadonlyRefObject } from '@hi-ui/schema-hooks';
+import type { EditableSchemaTableProps } from '../table';
+import type { PropsRefType } from '../ctx';
+/** 标准化后的 props 类型 */
+export type NormalizedProps<T extends AnyObject> = ReturnType<typeof getNormalizedProps<T>>;
+export declare function getNormalizedProps<T extends AnyObject>(props: EditableSchemaTableProps<T>): {
+    subRowKey: string;
+    debug: {
+        debugAll?: boolean | undefined;
+        debugColumns?: boolean | undefined;
+        debugHeaders?: boolean | undefined;
+        debugCells?: boolean | undefined;
+        debugRows?: boolean | undefined;
+        debugTable?: boolean | undefined;
+    } | undefined;
+    sticky: import("..").TableStickyOpts | undefined;
+    virtualize: {
+        row: Partial<Omit<import("@tanstack/virtual-core").VirtualizerOptions<HTMLDivElement, HTMLDivElement>, "count" | "getScrollElement">> | undefined;
+        column: Partial<Omit<import("@tanstack/virtual-core").VirtualizerOptions<HTMLDivElement, HTMLDivElement>, "count" | "getScrollElement">> | undefined;
+    } | undefined;
+    rowSelection: {
+        enableIndicator: import("../features/row-selection/indicator").RowSelectionIndicatorOpts | undefined;
+        type?: "checkbox" | "radio";
+        onChange?: ((selected: {
+            keys: string[];
+            rows: T[];
+        }) => void) | undefined;
+        onCheckAllChange?: (ctx: {
+            checked: boolean;
+            indeterminate: boolean;
+        }) => void;
+        preserveSelectedRows?: boolean;
+        enableRowSelection?: ((rowData: T, ctx: {
+            row: import("@tanstack/table-core").Row<T>;
+        }) => boolean) | undefined;
+        enableSubRowSelection?: ((rowData: T, ctx: {
+            row: import("@tanstack/table-core").Row<T>;
+        }) => boolean) | undefined;
+        enableDynamicRowSelection?: boolean;
+        dftSelectedRowKeys?: (string | number)[];
+        enableClickSelect?: boolean;
+    } | undefined;
+    rowOperation: import("..").RowOperationOptsType<T> | undefined;
+    pagination: import("../features/pagination").PaginationProps | undefined;
+    filter: import("../features/filter").FilterOpts | undefined;
+    sorter: {
+        tooltip: {
+            text?: {
+                asc?: string;
+                desc?: string;
+                default?: string;
+            };
+        } | undefined;
+        remote?: boolean;
+        onChange?: (state: import("@tanstack/table-core").SortingState, ctx: import("../utils").OnChangeFnCtxType<import("@tanstack/table-core").SortingState>) => void;
+        enableMultiSort?: import("@tanstack/table-core").TableOptions<AnyObject>["enableMultiSort"];
+        maxMultiSortColCount?: import("@tanstack/table-core").TableOptions<AnyObject>["maxMultiSortColCount"];
+        sortUndefined?: import("@tanstack/table-core").SortingColumnDef<AnyObject>["sortUndefined"];
+    } | undefined;
+    grouping: {} | undefined;
+    expanding: {} | undefined;
+    fieldMap?: Partial<import("packages/schema/schema-fields/lib/types").ProFieldMapType>;
+    value?: T[] | undefined;
+    defaultValue?: T[] | undefined;
+    onChange?: ((val: T[]) => void) | undefined;
+    fields: import("@hi-ui/schema-core").FieldConfigType[];
+    asyncData?: import("..").AsyncDataOptsType<T> | undefined;
+    innerCtxRef?: import("react").RefObject<import("../table").TableCtxRefType<T>> | undefined;
+    onValuesChange?: ((changedValues: Record<number, Partial<T>>, allValues: T[]) => void) | undefined;
+    getRowStyle?: ((row: T, ctx: {
+        row: import("@tanstack/table-core").Row<T>;
+    }) => React.CSSProperties) | undefined;
+    defaultActive?: boolean;
+    showFooter?: boolean;
+    enableForceRerender?: boolean;
+    rowKey?: string;
+    readonly?: boolean;
+    headerAction?: import("../features/header-actions").HeaderActionOptsType;
+    bordered?: boolean;
+    bottom?: import("..").BottomRenderConfigType;
+    customCell?: import("../cell").CustomCellType<T> | undefined;
+    defaultColumn?: Partial<import("@tanstack/table-core").ColumnDef<T, unknown>> | undefined;
+    features?: import("@tanstack/table-core").TableOptions<TData>["_features"];
+    wrapperStyle?: React.CSSProperties;
+    on?: {
+        rowMounted?: import("../body").OnBodyRowMountedFn<T> | undefined;
+    } | undefined;
+    customEngineOpts?: Partial<import("@tanstack/table-core").TableOptions<T>> | undefined;
+};
+export declare function usePropsRef<T extends AnyObject>(props: EditableSchemaTableProps<T>): {
+    propsRef: PropsRefType<T>;
+    staticOptsRef: ReadonlyRefObject<{
+        enableAsyncData: boolean;
+        hasNestHeader: boolean;
+        enableRowSelection: boolean;
+        enableRowOperation: boolean;
+        enableRowEdit: boolean;
+        operationColWidth: number;
+        enablePagination: boolean;
+        enableHeaderActionHoverOnly: boolean;
+        enableFilter: boolean;
+        enableRemoteFilter: boolean;
+        enableSorter: boolean;
+        enableRemoteSorter: boolean;
+        enableRowExpanding: boolean;
+        enableRowGrouping: boolean;
+        isBottomEmpty: boolean;
+    }>;
+};

package/lib/types/hooks/use-table-columns.d.ts

@@ -0,0 +1,11 @@
+import type { ColumnDef } from '@tanstack/react-table';
+import type { FieldConfigType } from '@hi-ui/schema-core';
+import type { PropsRefType } from '../ctx';
+export declare function MapFieldConfigToColumnDef<TData extends AnyObject>(fields: FieldConfigType[], ctx: {
+    propsRef: PropsRefType<TData>;
+}): ColumnDef<TData>[];
+type UseTableColumnsCtxType<TData extends AnyObject> = {
+    propsRef: PropsRefType<TData>;
+};
+export declare function useTableColumns<TData extends AnyObject>(ctx: UseTableColumnsCtxType<TData>): ColumnDef<TData>[];
+export {};

package/lib/types/hooks/use-table-meta.d.ts

@@ -0,0 +1,15 @@
+import type { Table, TableMeta } from '@tanstack/react-table';
+import type { Subscription } from '@hi-ui/use-subscription';
+import type { EditableSchemaTableProps } from '../table';
+import type { InnerRefType } from '../ctx';
+type UseTableMetaCtxType<TData extends AnyObject = AnyObject> = {
+    fieldMap?: EditableSchemaTableProps<TData>['fieldMap'];
+    onValuesChange?: EditableSchemaTableProps<TData>['onValuesChange'];
+    innerRef: InnerRefType<TData>;
+};
+export declare const useTableMeta: <TData extends AnyObject = AnyObject>(tableValue: Subscription<TData[]>, ctx: UseTableMetaCtxType<TData>) => TableMeta<TData>;
+export declare function getCellOpFn<TData extends AnyObject = AnyObject>(table: Table<TData>): {
+    getCellValue: TableMeta<TData>["getCellValue"];
+    setCellValue: TableMeta<TData>["updateData"];
+};
+export {};

package/lib/types/hooks/use-update.d.ts

@@ -0,0 +1,11 @@
+import type { Subscription } from '@hi-ui/use-subscription';
+/**
+ * 监听表格数据变化，并触发重渲染
+ * @notice 仅在表格数据发生【全量变化】时触发重渲染
+ * @param tableValue 表格数据
+ * @returns 重渲染函数
+ */
+export declare function useTableUpdate<T>(tableValue: Subscription<T[]>): {
+    rerender: () => void;
+    forceRerenderFlag: string;
+};

package/lib/types/index.d.ts

@@ -0,0 +1,32 @@
+export { default as Body, type EditTableBodyProps } from './body';
+export { default as Header, type EditTableHeaderProps } from './header';
+export { default as Footer, type EditTableFooterProps } from './footer';
+export { default as Cell, FooterCell } from './cell';
+export { EditableSchemaTable, EditableSchemaTable as EditTable } from './table';
+export type { EditableSchemaTableProps, EditableSchemaTableProps as EditTableProps } from './table';
+export { useEditableSchemaTableCtx, useEditTableCtx } from './ctx';
+export type { TableCtxRefType } from './table';
+export type { EditableSchemaTableCtxType, EditableSchemaTableCtxType as EditTableCtxType, } from './ctx';
+export { TableContainer, useTableContainer } from './container';
+export { useRowVirtualizer, useColumnVirtualizer } from './container/hooks';
+export type { TableStickyOpts, VirtualizeConfig } from './container';
+export { BottomRender } from './container/bottom';
+export type { BottomRenderConfigType } from './container/bottom';
+export { validateHeaderCell } from './header/validate';
+export { useTableSetting } from './features/setting-bridge';
+export { useDataFetcher, defineDataFetcher } from './features/async-data';
+export { ColumnCollapsingAction } from './features/header-actions';
+export { TableRowController } from './features/row-controller';
+export type { GetDataSourceType, GetDataSourceBasicParamsType, GetDataSourceParamsType, GetDataSourceResType, AsyncDataOptsType, } from './features/async-data';
+export type { OpButtonConfigType, RowOperationOptsType } from './features/row-operation';
+export type { RowSelectionOptsType } from './features/row-selection';
+export type { TableRowControllerType } from './features/row-controller';
+export type { UseTableSettingProps } from './features/setting-bridge';
+export type { GetHeaderCellWrapperDynamicAttrsFnType } from './header';
+export type { GetBodyCellWrapperDynamicAttrsFnType } from './body/wrapper';
+export type { FieldCustomHeaderActionsFn, FieldCustomHeaderActionComponent, } from './features/header-actions/type';
+export type { OpButtonRenderCtx } from './features/row-operation/buttons';
+export type { BottomRenderCtxType } from './container/bottom';
+export { normalizeValueFromChange } from './cell/editing';
+export { clsPrefix } from './utils/cls';
+export { ProEditTable, type ProEditTableProps, type FormEditTableToolbarCtxType, } from './field-bridge';

package/lib/types/table.d.ts

@@ -0,0 +1,152 @@
+import React from 'react';
+import type { TableMeta, TableOptions } from '@tanstack/react-table';
+import type { StandardProps } from 'ahooks/es/useControllableValue';
+import type { FieldConfigType } from '@hi-ui/schema-core';
+import type { UseFieldMapOpts } from '@hi-ui/schema-fields';
+import type { BoolConfig } from '@hi-ui/schema-utils';
+import { type EditableSchemaTableCtxType, type InnerRefType } from './ctx';
+import { type GlobalStaticActionsType } from './hooks/use-global-actions';
+import { useGetFieldsValue, useGetGroupedValues } from './hooks/use-get-fields-value';
+import { type RowSelectionOptsType } from './features/row-selection';
+import { type PaginationProps } from './features/pagination';
+import { type FilterOpts } from './features/filter/use-opts';
+import { type SorterOpts } from './features/sorter/use-opts';
+import { type ExpandedOpts } from './features/row-expanding';
+import { type GroupingOpts } from './features/column-grouping';
+import type { CustomCellType } from './cell/index';
+import type { AsyncDataOptsType } from './features/async-data';
+import type { RowOperationOptsType } from './features/row-operation';
+import type { TableStickyOpts, VirtualizeConfig } from './container/index';
+import type { HeaderActionOptsType } from './features/header-actions';
+import type { BottomRenderConfigType } from './container/bottom';
+import type { EditTableBodyProps, OnBodyRowMountedFn } from './body';
+import './index.scss';
+/** 对外暴露的表格上下文类型 */
+export type TableCtxRefType<TData extends AnyObject = AnyObject> = Pick<EditableSchemaTableCtxType<TData>, 'table' | 'subscription' | 'rowActions'> & {
+    /** 触发内部重渲染 */
+    rerender: () => void;
+    /** 获取所有可编辑字段的值 */
+    getFieldsValue: ReturnType<typeof useGetFieldsValue<TData>>;
+    /** 获取分组后的所有可编辑字段的值和只读字段的值 */
+    getGroupedValues: ReturnType<typeof useGetGroupedValues<TData>>;
+    /** 滚动到顶部 */
+    scrollIntoView: (behavior?: ScrollBehavior) => void;
+    /** 获取异步数据源（仅获取数据） */
+    getDataSource: GlobalStaticActionsType<TData>['getDataSource'];
+    /** 更新异步数据源（获取数据并更新表格） */
+    updateDataSource: GlobalStaticActionsType<TData>['updateDataSource'];
+    /** 重置分页、筛选状态 */
+    resetDataSource: GlobalStaticActionsType<TData>['resetDataSource'];
+    /**
+     * 设置表格数据源
+     * - 本质是调用 subscription.setValue
+     * - 支持直接传入新值或者取值函数
+     * - 调用后将直接全量更新内部数据，并触发重渲染
+     * - 若有开启 enableForceRerender 还会触发强制重渲染
+     */
+    setDataSource: GlobalStaticActionsType<TData>['setDataSource'];
+    /**
+     * 获取单元格值
+     * - 本质是调用 table.options.meta.getCellValue
+     */
+    getCellValue: TableMeta<TData>['getCellValue'];
+    /**
+     * 设置单元格值
+     * - 本质是调用 table.options.meta.updateData
+     */
+    setCellValue: TableMeta<TData>['updateData'];
+    /**
+     * 设置行选择状态
+     * - 传入数组时，选中指定行
+     * - 传入 null 时，清空所有选中的行
+     * - 传入函数时，调用者可获取当前选中的rowKeys，并自行返回新的rowKeys
+     * - 传入函数时，返回 null 也可清空所有选中的行
+     */
+    setSelectedRowKeys: GlobalStaticActionsType<TData>['setSelectedRowKeys'];
+    /**
+     * 完整的内部上下文引用
+     * @desc 一般不应被外部读取，除非明确知道用途
+     */
+    innerRef: InnerRefType<TData>;
+};
+type TableDebugOpts<T extends AnyObject> = Pick<TableOptions<T>, 'debugAll' | 'debugColumns' | 'debugHeaders' | 'debugCells' | 'debugRows' | 'debugTable'>;
+export type EditableSchemaTableProps<TData extends AnyObject = AnyObject> = UseFieldMapOpts & Partial<StandardProps<TData[]>> & {
+    fields: FieldConfigType[];
+    asyncData?: AsyncDataOptsType<TData>;
+    innerCtxRef?: React.RefObject<TableCtxRefType<TData>>;
+    onValuesChange?: (changedValues: Record<number, Partial<TData>>, allValues: TData[]) => void;
+    getRowStyle?: EditTableBodyProps<TData>['getRowStyle'];
+    /** 是否默认激活全部可编辑单元格 */
+    defaultActive?: boolean;
+    /** 是否固定表头和表尾 */
+    sticky?: BoolConfig<TableStickyOpts>;
+    /** 虚拟化配置 */
+    virtualize?: BoolConfig<VirtualizeConfig>;
+    /** 是否展示表尾 */
+    showFooter?: boolean;
+    /** 调试配置 */
+    debug?: BoolConfig<TableDebugOpts<TData>>;
+    /**
+     * 是否开启强制重渲染
+     * - 通常用在存在复杂的表格行数据操作时
+     * - 启用后会在内部触发完全更新(即subscription.setValue)时，重新渲染整个表格
+     * - 原理是给表格顶层容器增加了 key 属性，从而触发整个表格的重新渲染
+     */
+    enableForceRerender?: boolean;
+    /**
+     * 行唯一标识
+     * @desc 会根据行数据，取出【rowKey】的值作为唯一标识
+     * @desc 用于行选择、行操作等功能，默认使用【数组索引】作为唯一标识
+     * @desc 会在行 DOM 上增加 data-id 属性
+     * @desc 仅做展示时可不传，开启【行选择】【分页】等依赖行唯一标识的功能时，则必须传入
+     */
+    rowKey?: string;
+    /**
+     * 子行在父行中的取值字段
+     * @desc 会从指定字段中取出【子行数据】
+     * @desc 用于树形表格，默认使用【children】作为子行取值字段
+     */
+    subRowKey?: string;
+    /** 行选择配置 */
+    rowSelection?: BoolConfig<RowSelectionOptsType<TData>>;
+    /** 行操作配置 */
+    rowOperation?: BoolConfig<RowOperationOptsType<TData>>;
+    /** 是否开启只读模式 */
+    readonly?: boolean;
+    /** 分页配置 */
+    pagination?: BoolConfig<PaginationProps>;
+    /** 表头操作配置 */
+    headerAction?: HeaderActionOptsType;
+    /** 筛选配置 */
+    filter?: BoolConfig<FilterOpts>;
+    /** 排序配置 */
+    sorter?: BoolConfig<SorterOpts>;
+    /** 行展开配置 */
+    expanding?: BoolConfig<ExpandedOpts>;
+    /** 列分组配置 */
+    grouping?: BoolConfig<GroupingOpts>;
+    /** 是否显示边框 */
+    bordered?: boolean;
+    /** 底部的渲染配置 */
+    bottom?: BottomRenderConfigType;
+    /**
+     * 自定义单元格渲染
+     * - 目前仅开放聚合单元格
+     */
+    customCell?: CustomCellType<TData>;
+    /** 自定义默认列配置 */
+    defaultColumn?: TableOptions<TData>['defaultColumn'];
+    /** 自定义表格功能 */
+    features?: TableOptions<TData>['_features'];
+    /** 自定义表格容器样式 */
+    wrapperStyle?: React.CSSProperties;
+    /** 内部事件的集中入口 */
+    on?: {
+        /** 行挂载后触发 */
+        rowMounted?: OnBodyRowMountedFn<TData>;
+    };
+    /** 自定义 react-table 引擎选项 */
+    customEngineOpts?: Partial<TableOptions<TData>>;
+};
+export declare function EditableSchemaTable<TData extends AnyObject>(props: EditableSchemaTableProps<TData>): JSX.Element;
+export {};

package/lib/types/utils/cls.d.ts

@@ -0,0 +1,4 @@
+export declare const clsPrefix = "editable-schema-table";
+export declare const cls: (...args: ((string | false | null | undefined) | {
+    [x: string]: boolean | null | undefined;
+})[]) => string;

package/lib/types/utils/fixed.d.ts

@@ -0,0 +1,11 @@
+import { Column } from '@tanstack/react-table';
+import type { EditableSchemaTableCtxType } from '../ctx';
+type FixedStyleResult = {
+    className?: string[];
+    style?: React.CSSProperties;
+};
+type GetFixedStyleOptsType = {
+    globalStaticRef: EditableSchemaTableCtxType['globalStaticRef'];
+};
+export declare function getFixedStyles<TData>(column: Column<TData>, opts: GetFixedStyleOptsType): FixedStyleResult;
+export {};

package/lib/types/utils/grouping.d.ts

@@ -0,0 +1,6 @@
+import type { Row, RowData } from '@tanstack/table-core';
+/**
+ * 检查值是否为空值（包括null、undefined、'null'、'undefined'和空字符串）
+ */
+export declare function isEmptyValue(value: unknown): boolean;
+export declare function getGroupedLeafRows<TData extends RowData>(rows: Row<TData>[]): Row<TData>[];

package/lib/types/utils/index.d.ts

@@ -0,0 +1,5 @@
+export * from './cls';
+export * from './fixed';
+export * from './grouping';
+export * from './meta';
+export * from './state-merge';

package/lib/types/utils/meta.d.ts

@@ -0,0 +1,8 @@
+import { Column } from '@tanstack/react-table';
+/**
+ * 获取列宽
+ * @deprecated 已废弃，列宽度状态同步逻辑不完善时的中间方案，目前已经不再使用
+ * @param column 列
+ * @returns 列宽
+ */
+export declare function getColWidth(column: Column<AnyType>): number;

package/lib/types/utils/state-merge.d.ts

@@ -0,0 +1,14 @@
+export type OnChangeFnCtxType<TState> = {
+    rawState: TState;
+};
+/**
+ * 确保状态字段完整性，为被清空的字段添加默认值
+ * @param state 变化前的状态
+ * @param newState 变化后的状态
+ * @param stateKey 要设置默认值的字段名
+ * @param defaultValue 字段被清空时的默认值
+ * @returns 处理后的状态
+ */
+export declare function ensureStateFields<TState extends {
+    id: string;
+}, TKey extends keyof TState, TValue extends TState[TKey]>(state: TState[], newState: TState[], stateKey: TKey, defaultValue: TValue | undefined): TState[];

package/package.json

@@ -0,0 +1,90 @@
+{
+  "name": "@hi-ui/schema-editable-table",
+  "version": "4.0.0-experimental.1",
+  "description": "A sub-package for @hi-ui/schema.",
+  "keywords": [],
+  "author": "HiUI <mi-hiui@xiaomi.com>",
+  "homepage": "https://github.com/XiaoMi/hiui/tree/master/packages/schema/schema-editable-table#readme",
+  "license": "MIT",
+  "directories": {
+    "lib": "lib",
+    "test": "__tests__"
+  },
+  "files": [
+    "lib",
+    "type.d.ts"
+  ],
+  "main": "lib/cjs/index.js",
+  "module": "lib/esm/index.js",
+  "types": "lib/types/index.d.ts",
+  "typings": "lib/types/index.d.ts",
+  "exports": {
+    ".": {
+      "require": "./lib/cjs/index.js",
+      "default": "./lib/esm/index.js"
+    },
+    "type": {
+      "types": "./type.d.ts"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/XiaoMi/hiui.git"
+  },
+  "scripts": {
+    "test": "jest",
+    "clean": "rimraf lib",
+    "prebuild": "yarn clean",
+    "build:esm": "hi-build ./src/index.ts --format esm -d ./lib/esm",
+    "build:cjs": "hi-build ./src/index.ts --format cjs -d ./lib/cjs",
+    "build:types": "tsc --emitDeclarationOnly --declaration --declarationDir lib/types",
+    "build": "concurrently yarn:build:*"
+  },
+  "bugs": {
+    "url": "https://github.com/XiaoMi/hiui/issues"
+  },
+  "dependencies": {
+    "@hi-ui/schema-action-trigger": ">=4.0.0-experimental.1",
+    "@hi-ui/schema-core": ">=4.0.0-experimental.1",
+    "@hi-ui/schema-fields": ">=4.0.0-experimental.1",
+    "@hi-ui/schema-form": ">=4.0.0-experimental.1",
+    "@hi-ui/schema-hooks": ">=4.0.0-experimental.1",
+    "@hi-ui/schema-utils": ">=4.0.0-experimental.1",
+    "@hi-ui/schema-table-extensions": ">=4.0.0-experimental.1",
+    "@hi-ui/use-subscription": ">=4.0.0-experimental.1",
+    "immer": "^11.1.3",
+    "lodash-es": "^4.17.23"
+  },
+  "peerDependencies": {
+    "@hi-ui/button": ">=5.0.0-experimental.0",
+    "@hi-ui/checkbox": ">=5.0.0-experimental.0",
+    "@hi-ui/classname": ">=5.0.0-experimental.0",
+    "@hi-ui/ellipsis-tooltip": ">=5.0.0-experimental.0",
+    "@hi-ui/icons": ">=5.0.0-experimental.0",
+    "@hi-ui/pagination": ">=5.0.0-experimental.0",
+    "@hi-ui/radio": ">=5.0.0-experimental.0",
+    "@hi-ui/schema-types": ">=4.0.0-experimental.1",
+    "@hi-ui/space": ">=5.0.0-experimental.0",
+    "@hi-ui/switch": ">=5.0.0-experimental.0",
+    "@hi-ui/tag": ">=5.0.0-experimental.0",
+    "@hi-ui/use-id": ">=5.0.0-experimental.0",
+    "@hi-ui/utility-types": ">=4.0.0-experimental.1",
+    "@tanstack/react-table": "^8.21.3",
+    "@tanstack/react-virtual": "^3.13.18",
+    "ahooks": "^3.9.6",
+    "react": ">=16.8.6"
+  },
+  "devDependencies": {
+    "@hi-ui/schema-types": ">=4.0.0-experimental.1",
+    "@hi-ui/utility-types": ">=4.0.0-experimental.1",
+    "@tanstack/react-table": "^8.21.3",
+    "@tanstack/react-virtual": "^3.13.18",
+    "react": "^17.0.2"
+  },
+  "volta": {
+    "node": "14.21.3"
+  }
+}

package/type.d.ts

@@ -0,0 +1,143 @@
+import type { RowData, Cell, RowSelectionState } from '@tanstack/react-table'
+import type { ProFieldMapType } from '@hi-ui/schema-fields'
+import type { SubscriptionType } from '@hi-ui/use-subscription'
+import type {
+  FieldConfigType,
+  FieldControlType,
+  FieldFilterConfigType,
+  FieldGroupingConfigType,
+  FieldPayloadType,
+  FieldSorterConfigType,
+} from '@hi-ui/schema-core'
+import type { InnerRefType } from './src/ctx'
+
+declare module '@tanstack/react-table' {
+  interface CoreInstance<TData extends RowData> {
+    $getInnerRef: () => InnerRefType<TData>
+    $getCell: (cellId: string) => Cell<TData, unknown> | null
+    /**
+     * 获取指定行的实时数据
+     * @desc 与 row.original 的区别在于，会返回内部订阅中的最新数据
+     */
+    $getRealtimeRowData: (rowId: string) => TData | undefined
+    /**
+     * 缓存选中行的原始数据
+     * - key 为行 id, value 为行数据
+     * - 仅在开启 preserveSelectedRows 时有效
+     * - 其余时间仅为一个空 Map
+     */
+    $selectedRowsCache: Map<string, TData>
+    /**
+     * 缓存当前选中状态
+     * - rows 为选中行的原始数据
+     * - keys 为选中行的 id
+     */
+    $rowSelectionCache: {
+      selectedRows: TData[]
+      selectedRowKeys: string[]
+      selectedRowEntries: [string, TData][]
+    }
+    /**
+     * 更新选中行原始数据的缓存
+     */
+    $updateSelectedRowsCache: (entries: [string, TData][]) => void
+    /**
+     * 获取选中行的原始数据
+     * - 会根据行选中状态，返回内部订阅中的最新数据
+     */
+    $getRowSelection: (state?: RowSelectionState) => {
+      selectedRows: TData[]
+      selectedRowKeys: string[]
+      selectedRowEntries: [string, TData][]
+    }
+  }
+
+  interface CoreRow<TData extends RowData> {
+    /**
+     * 获取指定列的聚合后的值
+     */
+    // 原因是内置的 getValue 在识别到指定列是分组列后
+    // 会直接返回列本身的值，而不是返回聚合后的值
+    $getAggregatedValue: <TValue>(columnId: string) => TValue | undefined
+    /**
+     * 获取指定行的实时数据
+     * @desc 与 row.original 的区别在于，会返回内部订阅中的最新数据
+     */
+    // 与表格实例的 getRealtimeRowData 效果一致
+    $getRealtimeRowData: () => TData
+  }
+
+  interface CoreCell {
+    /**
+     * 获取指定列的聚合后的值
+     */
+    // 与行的 getAggregateValue 效果一致
+    $getAggregatedValue: <TValue>() => TValue | undefined
+    /**
+     * 获取指定行的实时数据
+     * @desc 与 row.original 的区别在于，会返回内部订阅中的最新数据
+     */
+    // 与表格实例的 getRealtimeRowData 效果一致
+    $getRealtimeRowData: () => TData
+  }
+
+  interface TableMeta<TData extends RowData>
+    extends Pick<FieldControlType, 'editable' | 'readonly' | 'disabled'> {
+    /** 表格数据订阅 */
+    subscription: SubscriptionType<TData[]>
+    fieldMap?: Partial<ProFieldMapType>
+    updateData: (rowIndex: number, columnId: string, value: unknown) => void
+    getCellValue: (rowIndex: number, columnId: string) => unknown
+    innerRef: InnerRefType<TData>
+  }
+
+  interface ColumnMeta<TData extends RowData, TValue>
+    extends Pick<
+        FieldControlType,
+        | 'editable'
+        | 'readonly'
+        | 'disabled'
+        | 'simple'
+        | 'fixed'
+        | 'align'
+        | 'headerCell'
+        | 'bodyCell'
+        // 下面三个会被更下面的三处定义覆盖
+        | 'filter'
+        | 'sorter'
+        | 'grouping'
+      >,
+      Pick<FieldPayloadType, 'shouldUpdate'> {
+    field: FieldConfigType // 存储原始字段配置
+    filter?: FieldFilterConfigType
+    sorter?: FieldSorterConfigType
+    grouping?: FieldGroupingConfigType
+    _IGNORE_ME_?: (data: TData) => TValue // 防止泛型参数未被使用
+  }
+
+  interface ColumnDefBase<TData extends RowData, TValue = unknown> {
+    meta: ColumnMeta<TData, TValue>
+  }
+
+  interface PaginationState {
+    rowCount: number
+    /** 标记是否内部手动设置分页状态 */
+    $fromCustom?: boolean
+  }
+  interface PaginationInstance {
+    originalResetPagination: (defaultState?: boolean) => void
+  }
+
+  interface RowSelectionRow {
+    /** 切换行选择状态后，处理父行选中状态的逻辑 */
+    $afterToggleSelected: () => void
+  }
+
+  interface TableState {
+    /**
+     * 自定义的列折叠状态
+     * @desc 仅对存在子列的父列生效
+     */
+    customColumnCollapsing?: Record<string, boolean>
+  }
+}