onchain-uikit 3.9.4-alpha4 → 3.9.4-alpha40

package/lib/src/components/OnChainVTable/feature/history-edit.d.ts

@@ -0,0 +1,435 @@
+import { ListTable } from '../ListTable';
+import { CellAddress, TableEventHandlersEventArgumentMap } from '@visactor/vtable/es/ts-types';
+import { RecordResult, RecordType } from '../const';
+import { HistoryEditOptions, WholeRow } from './types';
+import { CellEditStyle } from './style';
+type TableModifyInfo = ReturnType<HistoryEdit<WholeRow>['getTableModifyInfo']>;
+type ModifyRecord = TableEventHandlersEventArgumentMap['change_cell_value'];
+type ModifyRecordKeys = keyof ModifyRecord;
+type ChangePositionInfo = TableEventHandlersEventArgumentMap['change_header_position'];
+declare enum ChangeMode {
+    Set = 0,
+    Drag = 1,
+    Update = 2
+}
+/**
+ * @description 单元格数据管理
+ * @date 2024-08-09 09:46:55
+ * @class BasicsCellModify
+ */
+export declare class BasicsCellModify<Row extends WholeRow> {
+    tableInstance: ListTable<Row>;
+    /** 这个数据和 history 是同一份数据 */
+    private readonly record;
+    private readonly original;
+    /** 数据状态是否为空 */
+    private empty;
+    /** 单元格数据是否复原 */
+    private initial;
+    /** 数据变化类型 */
+    changeMode: ChangeMode;
+    isModifyMark: boolean;
+    constructor(record: ModifyRecord, { tableInstance, changeMode, isModifyMark, }: {
+        tableInstance: ListTable<Row>;
+        isModifyMark: boolean;
+        changeMode?: ChangeMode;
+    });
+    /** 创建一个新的单元格数据 */
+    static createCellModifyRecord(param: Partial<ModifyRecord>): ModifyRecord;
+    /** 记录类型 */
+    get type(): RecordType;
+    /** 单元格修改信息 */
+    get modify(): Readonly<ModifyRecord>;
+    /** 是否为空记录 */
+    get isEmpty(): boolean;
+    /** 初始状态 */
+    get isInitial(): boolean;
+    get isInsertion(): boolean;
+    /** 全局使用的修改记录，避免调用重置单元格渲染，导致拿不到全局使用的修改记录 */
+    get globallyUnique(): Readonly<{
+        col: number;
+        row: number;
+        rawValue: string | number;
+        currentValue: string | number;
+        changedValue: string | number;
+    }>;
+    /** 替换记录 */
+    private replace;
+    /** 添加记录 */
+    set(record: ModifyRecord): void;
+    setModifyAttr<T extends ModifyRecordKeys>(key: T, value: ModifyRecord[T]): void;
+    getModifyAttr<T extends ModifyRecordKeys>(key: T): {
+        col: number;
+        row: number;
+        rawValue: string | number;
+        currentValue: string | number;
+        changedValue: string | number;
+    }[T];
+    /** 移除记录 */
+    remove(): void;
+    /** 保存修改 */
+    saveModify(): void;
+    /** 更新单元格渲染 */
+    updateCellRender(record: ModifyRecord): void;
+    /** 重置单元格渲染 */
+    resetCellRender(): void;
+    /** 撤回单元格修改*/
+    revocation(): void;
+    /** 销毁 */
+    destroy(): void;
+}
+type ModifyManageStorageType = 'row' | 'col';
+/**
+ * @description Table 数据修改管理
+ * @date 2024-08-09 09:47:16
+ * @class ModifyManage
+ */
+declare class ModifyManage<Row extends WholeRow> {
+    readonly tableInstance: ListTable<Row>;
+    readonly isModifyMark: boolean;
+    /** 单行 存储的 列 数据 */
+    readonly row: Map<number, Map<number, BasicsCellModify<Row>>>;
+    /** 单列 存储的 行 数据 */
+    readonly col: Map<number, Map<number, BasicsCellModify<Row>>>;
+    readonly dataBinding: {
+        row: Map<string, Map<number, BasicsCellModify<Row>>>;
+        col: Map<string, Map<number, BasicsCellModify<Row>>>;
+    };
+    readonly basicsCellRecords: Set<BasicsCellModify<Row>>;
+    constructor(tableInstance: ListTable<Row>, { isModifyMark }: {
+        isModifyMark: boolean;
+    });
+    set(param: ModifyRecord): this;
+    get(): [Row | null, BasicsCellModify<Row>[] | null][];
+    delete(param: {
+        type: ModifyManageStorageType;
+        count: number;
+    }): BasicsCellModify<Row>[];
+    save(): void;
+    /** 历史数据发生变化 */
+    historyRecordChange({ recover, update }: {
+        recover?: Set<ModifyRecord>;
+        update?: Set<ModifyRecord>;
+    }): void;
+    /** 单元格位置发生变化 */
+    positionChange(param: ChangePositionInfo): void;
+    /** 获取单元格修改 */
+    getModifiedRecord(): BasicsCellModify<Row>[];
+    /** 清除记录数据 */
+    clear(): void;
+    /** 重置单元格数据 */
+    resetCellRender(): void;
+    /** 销毁记录数据 */
+    destroy(): void;
+    private generateCellModifyRecord;
+    getTableSourceData({ type }: {
+        type: Parameters<ModifyManage<Row>['generateCellModifyRecord']>[0]['type'];
+    }): {
+        data: (string | null)[];
+        oppositeData: (string | null)[];
+    };
+    private getCachePath;
+    positionChangeSort({ type }: {
+        type: 'row' | 'col';
+    }): void;
+    /**
+     * 因为 VTable 样式绑定单元格行号或者列号，所以排序发生变化后，需要更新样式
+     * 旧的单元格有更新标记，排序后的新单元格没有更新标记时，需要为新单元格生成一个为 RecordType.Raw 的修改记录
+     */
+    private antitheticComplete;
+}
+declare class BasicsSpecialHistoryEdit<Row extends WholeRow> {
+    readonly historyEdit: HistoryEdit<Row>;
+    get tableInstance(): ListTable<Row>;
+    get modifyManage(): ModifyManage<Row>;
+    constructor(param: {
+        historyEdit: HistoryEdit<Row>;
+    });
+}
+interface InsertInfo {
+    row: number;
+    dataList: any[];
+}
+/**
+ * @description 管理动态添加（插入）数据
+ * @date 2024-08-09 09:47:40
+ * @class InsertRowRecord
+ * @implements {InsertInfo}
+ */
+declare class InsertRowRecord<Row extends WholeRow> extends BasicsSpecialHistoryEdit<Row> implements InsertInfo {
+    readonly row: number;
+    readonly dataList: Row[];
+    readonly copyDataMap: Map<Row, Row>;
+    /** 当前步骤管理的cell修改 (historyEdit.current) */
+    affiliationStack: Set<ModifyRecord> | null;
+    protected inserted: boolean;
+    /** 全部插入的单元格 */
+    readonly cellRecords: Set<{
+        col: number;
+        row: number;
+        rawValue: string | number;
+        currentValue: string | number;
+        changedValue: string | number;
+    }>;
+    /** [行数据, Array<单元格>] */
+    readonly rowRecordMap: Map<Row, Set<{
+        col: number;
+        row: number;
+        rawValue: string | number;
+        currentValue: string | number;
+        changedValue: string | number;
+    }>>;
+    /** 有生成 ChildInsertRowRecord 的单元格 */
+    readonly autonomyCells: Set<{
+        col: number;
+        row: number;
+        rawValue: string | number;
+        currentValue: string | number;
+        changedValue: string | number;
+    }>;
+    /** 插入数据，第一个的位置 */
+    get insertStartRow(): number;
+    get IsInserted(): boolean;
+    constructor(param: InsertInfo & {
+        historyEdit: HistoryEdit<Row>;
+        isInitialize?: boolean;
+    });
+    /** 最新的插入位置（序号会发生变化） */
+    getLatestRowNumber(rowData: any): any;
+    insert(): void;
+    /** 恢复插入行为 */
+    recover(): void;
+    /** 添加单元格数据 ()*/
+    recoverCellData(): void;
+    /** 移除插入行为 */
+    remove(): void;
+    /** 移除单元格数据 返回移除单元格行所在数据的索引 */
+    removeCellData(): number[];
+    /** 设置插入数据的状态 */
+    setInserted(value: boolean): void;
+    /** 批量恢复插入行为 */
+    static recovers<Row extends WholeRow>({ insertHistory, tableInstance, modifyManage, }: {
+        insertHistory: (InsertRowRecord<Row> | ChildInsertRowRecord<Row> | null)[];
+        modifyManage: ModifyManage<Row>;
+        tableInstance: ListTable<Row>;
+    }): void;
+    /** 批量移除插入行为 */
+    static removes<Row extends WholeRow>({ insertHistory, tableInstance, modifyManage, }: {
+        insertHistory: (InsertRowRecord<Row> | ChildInsertRowRecord<Row> | null)[];
+        modifyManage: ModifyManage<Row>;
+        tableInstance: ListTable<Row>;
+    }): void;
+    static group<T extends {
+        row: number;
+    }>(array: T[]): Generator<T[], void, unknown>;
+}
+declare class ChildInsertRowRecord<Row extends WholeRow> extends InsertRowRecord<Row> {
+    parent: InsertRowRecord<Row>;
+    constructor(param: InsertInfo & {
+        historyEdit: HistoryEdit<Row>;
+        parent: InsertRowRecord<Row>;
+        appointCellRecords?: {
+            row: number;
+            originalModifyRecord: Set<ModifyRecord>;
+        }[];
+    });
+    insert(): void;
+    /** 删除自我管理，表示可以被其他数据接管 */
+    deleteAutonomyCells(): void;
+    /** 添加自我管理，表示不可被其他数据接管 */
+    addAutonomyCells(): void;
+    /** 恢复插入行为 */
+    recover(): void;
+    /** 移除插入行为 */
+    remove(): void;
+}
+declare class DeleteRowRecord<Row extends WholeRow> extends BasicsSpecialHistoryEdit<Row> {
+    insertMap: Map<InsertRowRecord<Row>, {
+        deleteInfos: Record<number, Set<ModifyRecord>>;
+        deleteCellSize: number;
+    }>;
+    /** 实际需要执行删除的 插入对象 */
+    needDelete: InsertRowRecord<Row>[];
+    /** 额外删除的单元格 */
+    needDeleteStyleCells: ModifyRecord[];
+    deleted: boolean;
+    constructor(param: {
+        historyEdit: HistoryEdit<Row>;
+        rows: number[];
+        needDeleteStyleCells?: ModifyRecord[];
+    });
+    delete(): void;
+    /** 初始化插入实例集合 */
+    initializeExpurgated(): void;
+    /** 恢复删除行为 */
+    recover(): void;
+    /** 移除删除行为 */
+    remove(): void;
+}
+/**
+ * @description 直接删除行数
+ * @date 2024-08-13 17:04:17
+ * @class DeleteDirectRow
+ * @extends {DeleteRowRecord}
+ */
+declare class DirectDeleteRowRecord<Row extends WholeRow> extends DeleteRowRecord<Row> {
+    dataList: {
+        row: number;
+        data: Row;
+    }[];
+    readonly copyDataMap: Map<Row, Row>;
+    readonly deletedIndex: Map<Row, number>;
+    constructor(param: {
+        dataList: {
+            row: number;
+            data: Row;
+        }[];
+        historyEdit: HistoryEdit<Row>;
+    });
+    delete(): void;
+    /** 恢复删除行为 */
+    recover(): void;
+    /** 移除删除行为 */
+    remove(): void;
+}
+type SortChangeInfo = TableEventHandlersEventArgumentMap['change_header_position'];
+declare class SortedRowRecord<Row extends WholeRow> extends BasicsSpecialHistoryEdit<Row> implements SortChangeInfo {
+    readonly event: Event;
+    readonly source: CellAddress;
+    readonly target: CellAddress;
+    sorted: boolean;
+    constructor(param: {
+        historyEdit: HistoryEdit<Row>;
+    } & SortChangeInfo);
+    private updateCellContent;
+    /** 恢复排序行为 */
+    recover(): void;
+    /** 移除排序行为 */
+    remove(): void;
+    get isSortCol(): boolean;
+    get isSortRow(): boolean;
+    get isSortNoChange(): boolean;
+}
+interface OtherHistory<Row extends WholeRow> {
+    sortHistory: (null | SortedRowRecord<Row>)[];
+    insertHistory: (null | InsertRowRecord<Row>)[];
+    deleteHistory: (null | DeleteRowRecord<Row> | DirectDeleteRowRecord<Row>)[];
+}
+interface HistoryGather<Row extends WholeRow> extends OtherHistory<Row> {
+    history: Set<ModifyRecord>[];
+}
+type GatherStorage<Row extends WholeRow> = {
+    [P in keyof HistoryGather<Row>]?: HistoryGather<Row>[P][0];
+};
+/**
+ * @description 历史数据栈处理基础类
+ * @date 2024-08-09 09:48:52
+ * @class BasicsHistoryStack
+ */
+declare class BasicsHistoryStack<Row extends WholeRow> {
+    current: Set<ModifyRecord> | null;
+    readonly gather: Readonly<HistoryGather<Row>>;
+    get history(): Set<{
+        col: number;
+        row: number;
+        rawValue: string | number;
+        currentValue: string | number;
+        changedValue: string | number;
+    }>[];
+    getStorage(): GatherStorage<Row>;
+    forEach(fn: (key: keyof HistoryGather<Row>) => void): void;
+    /** 创建历史记录区块 */
+    createHistory(): void;
+    /** 创建历史数据失败 */
+    createHistoryError(lastHistoryItem: HistoryGather<Row>['history'][0] | null): void;
+    historyClear(): void;
+}
+/**
+ * @description 历史修改
+ * @date 2024-08-09 09:50:19
+ * @export
+ * @class HistoryEdit
+ * @extends {BasicsHistoryStack}
+ */
+export declare class HistoryEdit<Row extends WholeRow> extends BasicsHistoryStack<Row> {
+    static RecordResult: typeof RecordResult;
+    current: Set<ModifyRecord> | null;
+    readonly eventIds: number[];
+    readonly tableInstance: ListTable<Row>;
+    readonly cellEditStyle: CellEditStyle<Row>;
+    readonly options?: HistoryEditOptions;
+    /** 手动记录中 */
+    private manualRecording;
+    /** 自动记录 */
+    private autoRecording;
+    /** 自动记录结束后的结果 */
+    private autoRecordEnd;
+    /** 初始数据映射 */
+    private readonly originalRecords;
+    modifyManage: ModifyManage<Row>;
+    constructor({ tableInstance, options }: {
+        tableInstance: ListTable<Row>;
+        options?: HistoryEditOptions;
+    });
+    get isModifyMark(): boolean;
+    setRecords(records: typeof this.tableInstance.records): void;
+    /** 记录修改 */
+    recording(fn: (param: {
+        recordOperation: <T extends keyof OtherHistory<Row>>(key: T, value: OtherHistory<Row>[T][0]) => void;
+    }) => RecordResult | void, extra?: {
+        isUpdateStyles?: boolean;
+    }): void;
+    autoRecordChangeValue(args: ModifyRecord): void;
+    private switchHistory;
+    insertData({ row, dataList }: InsertInfo): void;
+    deleteData(param: {
+        row: number;
+        data: any;
+    }[]): void;
+    /** 前进 */
+    forward(): Set<{
+        col: number;
+        row: number;
+        rawValue: string | number;
+        currentValue: string | number;
+        changedValue: string | number;
+    }> | null;
+    /** 后退 */
+    backward(): Set<{
+        col: number;
+        row: number;
+        rawValue: string | number;
+        currentValue: string | number;
+        changedValue: string | number;
+    }> | null;
+    /** 取消 */
+    cancel(): void;
+    /** 保存 */
+    save(course: (saveData: TableModifyInfo) => Promise<this['tableInstance']['records'] | void>): Promise<void>;
+    /** 清除事件 */
+    clearEvents(): void;
+    /** 清除历史记录 */
+    clear(): void;
+    /** 获取修改的记录 */
+    private getModifiedRecord;
+    private modifyMarkAmend;
+    getTableModifyInfo(): {
+        updateRecords: {
+            recordIdx: number;
+            id: string;
+            data: Partial<Row>;
+        }[];
+        deleteRecords: string[];
+        createRecords: {
+            recordIdx: number;
+            id: string;
+            data: Partial<Row>;
+        }[];
+        sortedRecords: {
+            oldIndex: number;
+            index: number;
+        }[];
+    };
+    private updateTableStyle;
+}
+export { RecordType };

package/lib/src/components/OnChainVTable/feature/index.d.ts

@@ -0,0 +1,6 @@
+export { generateFillHandle } from './fill-handle';
+export { rightClickMenu } from './right-click-menu';
+export { VTableFeatureUtils } from './utils';
+export { generateTooltip } from './tooltip';
+export { HistoryEdit } from './history-edit';
+export { customMergeCell, getRowTree, getGroupOptions } from './customMergeCell';

package/lib/src/components/OnChainVTable/feature/right-click-menu.d.ts

@@ -0,0 +1,24 @@
+import { default as VTable } from '@visactor/vtable';
+import { DropDownMenuEventArgs } from '@visactor/vtable/es/ts-types';
+import { ListTable } from '../ListTable';
+import { WholeRow } from './types';
+interface GenerateDropDownMenuParams<Row extends WholeRow> {
+    tableInstance: ListTable<Row>;
+}
+declare function generateDropDownMenu<Row extends WholeRow>({ tableInstance }: {
+    tableInstance: ListTable<Row>;
+}): () => void;
+export declare const rightClickMenu: {
+    getCellMenu: (params?: VTable.TYPES.MenuListItem[] | ((field: string, row: number, col: number) => VTable.TYPES.MenuListItem[])) => (field: string, row: number, col: number) => VTable.TYPES.MenuListItem[];
+    builtEvent: {
+        copy?: (<Row extends WholeRow>(event: DropDownMenuEventArgs, { tableInstance }: GenerateDropDownMenuParams<Row>) => void) | undefined;
+        shear?: (<Row extends WholeRow>(event: DropDownMenuEventArgs, { tableInstance }: GenerateDropDownMenuParams<Row>) => void) | undefined;
+        paste?: (<Row extends WholeRow>(event: DropDownMenuEventArgs, { tableInstance }: GenerateDropDownMenuParams<Row>) => void) | undefined;
+        delete?: (<Row extends WholeRow>(event: DropDownMenuEventArgs, { tableInstance }: GenerateDropDownMenuParams<Row>) => void) | undefined;
+        insert_down?: (<Row extends WholeRow>(event: DropDownMenuEventArgs, { tableInstance }: GenerateDropDownMenuParams<Row>) => void) | undefined;
+        insert_down_empty?: (<Row extends WholeRow>(event: DropDownMenuEventArgs, { tableInstance }: GenerateDropDownMenuParams<Row>) => void) | undefined;
+        delete_row?: (<Row extends WholeRow>(event: DropDownMenuEventArgs, { tableInstance }: GenerateDropDownMenuParams<Row>) => void) | undefined;
+    };
+    generateDropDownMenu: typeof generateDropDownMenu;
+};
+export {};

package/lib/src/components/OnChainVTable/feature/style.d.ts

@@ -0,0 +1,17 @@
+import { CustomCellStyle, CustomCellStyleArrangement } from '@visactor/vtable/es/ts-types';
+import { ListTable } from '../ListTable';
+import { HistoryEditOptions, WholeRow } from './types';
+export declare class CellEditStyle<Row extends WholeRow> {
+    readonly tableInstance: ListTable<Row>;
+    customCellStyle: CustomCellStyle[];
+    customCellStyleArrangement: (CustomCellStyleArrangement & {
+        defaultStyle?: boolean;
+    })[];
+    styles: CustomCellStyle[];
+    constructor({ tableInstance, options }: {
+        tableInstance: ListTable<Row>;
+        options?: HistoryEditOptions;
+    });
+    updateCellStyles(arrangement: CustomCellStyleArrangement[]): void;
+    clearAllCellStyles(): void;
+}

package/lib/src/components/OnChainVTable/feature/tooltip.d.ts

@@ -0,0 +1,9 @@
+import { ListTable } from '../ListTable';
+import { OnChainVTableProps } from '../type';
+import { WholeRow } from './types';
+/** 关闭自定义提示弹窗 */
+export declare function closeCustomTooltip(): void;
+/**
+ * 生成填充事件
+ */
+export declare function generateTooltip<Row extends WholeRow>(tableInstance: ListTable<Row>, tooltip?: OnChainVTableProps<Row>['tooltip']): () => void;

package/lib/src/components/OnChainVTable/feature/types.d.ts

@@ -0,0 +1,34 @@
+import { default as VTable } from '@visactor/vtable';
+import { TooltipOptions } from '@visactor/vtable/es/ts-types/tooltip';
+import { Placement } from '../const';
+import { ColumnStyleOption } from '@visactor/vtable/es/ts-types';
+
+
+// ** tooltip.ts -------------------------------------------
+export type VTableTooltipOptions = Omit<TooltipOptions, 'content' | 'position' | 'referencePosition' | 'style'> & {
+  format?: (cellInfo: Omit<VTable.TYPES.MousePointerCellEvent, 'target'> & { targetText?: string }) => string;
+  template?: (cellInfo: Omit<VTable.TYPES.MousePointerCellEvent, 'target'> & { targetText?: string }) => React.ReactNode;
+  referencePosition?: {
+    placement?: Placement;
+  };
+  style?: {
+    bgColor?: string;
+    fontSize?: number;
+    fontFamily?: string;
+    color?: string;
+    padding?: number[];
+    maxWidth?: number;
+    maxHeight?: number;
+  };
+};
+
+// ** history-edit.ts -------------------------------------------
+export interface HistoryEditOptions {
+  modifyMark?: boolean;
+  modifyMarkStyle?: {
+    delete?: ColumnStyleOption;
+    update?: ColumnStyleOption;
+  };
+}
+
+export type WholeRow = Record<string, any> & { __type?: 'title' | 'button' | 'empty' };

package/lib/src/components/OnChainVTable/feature/utils.d.ts

@@ -0,0 +1,141 @@
+import { default as VTable } from '@visactor/vtable';
+import { ListTable } from '../ListTable';
+import { BaseTableAPI } from '@visactor/vtable/es/ts-types/base-table';
+import { CellAddress, TableEventHandlersEventArgumentMap } from '@visactor/vtable/es/ts-types';
+import { RecordType, RightClickMenuKey } from '../const';
+import { WholeRow } from './types';
+export declare class VTableFeatureUtils {
+    static isValid(value: any): boolean;
+    /** 获取选中表格的值 */
+    static getSelectedCellValue<Row extends WholeRow>({ tableInstance, selectCells, filter, }: {
+        tableInstance: ListTable<Row>;
+        filter?: (cellInfo: VTable.TYPES.CellInfo) => boolean;
+        selectCells?: VTable.TYPES.CellInfo[][];
+    }): any[][];
+    /** 将选中单元格的值设置为空 */
+    static deleteSelectRange<Row extends WholeRow>({ selectCells, tableInstance, }: {
+        tableInstance: ListTable<Row>;
+        selectCells?: VTable.TYPES.CellInfo[][];
+    }): VTable.TYPES.CellInfo[][];
+    /** 判断单元格col,row是否在选中范围中 */
+    static cellIsSelectRange<Row extends WholeRow>({ tableInstance, row, col, selectCells, }: {
+        selectCells?: VTable.TYPES.CellInfo[][];
+        tableInstance: ListTable<Row>;
+        col: number;
+        row: number;
+    }): boolean;
+    /** 合并菜单配置项 */
+    static mergeMenu(...menusCollection: (VTable.TYPES.MenuListItem[] | undefined)[]): VTable.TYPES.MenuListItem[];
+    /** 删除默认菜单 */
+    static deleteDefaultMenu(keys?: RightClickMenuKey[]): VTable.TYPES.MenuListItem[];
+    /** 获取 padding */
+    static getPadding({ tableApi, row, col, defaultPadding, }: {
+        tableApi: BaseTableAPI;
+        row: number;
+        col: number;
+        defaultPadding?: number[];
+    }): number | number[] | undefined;
+    static getAmendModifyMarkValue({ newValue, oldValue, hasModifyMark, }: {
+        hasModifyMark?: boolean;
+        newValue: any;
+        oldValue: any;
+    }): any;
+    /**
+     * @description 无感知更新数据，不会触发 HistoryEdit 捕获
+     * @document 示例如下：
+     * ```ts
+     * modified.map((record) => {
+     *  insensitiveChangeValue(record)
+     *  this.tableInstance.scenegraph.updateCellContent(record.col, record.row)
+     * })
+     * this.tableInstance.scenegraph.renderSceneGraph();
+     * ```
+     */
+    static insensitiveChangeValue<Row extends WholeRow>({ tableInstance, col, row, value, renderColl, }: {
+        tableInstance: ListTable<Row>;
+        col: number;
+        row: number;
+        value: any;
+        renderColl?: boolean;
+    }): void;
+    /**
+     * @description 自动更新单元格宽高
+     */
+    static autoUpdateCellWidthHeight<Row extends WholeRow>({ tableInstance, col, row, }: {
+        tableInstance: ListTable<Row>;
+        col: number;
+        row: number;
+    }): void;
+    /** 获取修改记录类型 */
+    static getModifyRecordType(param: TableEventHandlersEventArgumentMap['change_cell_value']): RecordType;
+    static getCellModify<Row extends WholeRow>(param: {
+        tableInstance: ListTable<Row>;
+    } & CellAddress): import('./history-edit').BasicsCellModify<Row> | undefined;
+    static isEmptyValue(value: any): any;
+    static getRowRecordIdx<Row extends WholeRow>(param: {
+        tableInstance: ListTable<Row>;
+        row: number;
+    }): {
+        hasHeader: boolean;
+        recordIdx: number;
+    };
+    static getColumnIdx<Row extends WholeRow>(param: {
+        tableInstance: ListTable<Row>;
+        col: number;
+    }): {
+        hasNumberColumn: boolean;
+        columnIdx: number;
+    };
+    static getCellAddressByIndex<Row extends WholeRow>(param: {
+        tableInstance: ListTable<Row>;
+        colIdx: number;
+        rowIdx: number;
+    }): {
+        hasHeader: boolean;
+        hasNumberColumn: boolean;
+        col: number;
+        row: number;
+    };
+    /** 获取冻结的 column rowData 及其所占用的空间 */
+    static getFrozenLayout<Row extends WholeRow>(param: {
+        tableInstance: ListTable<Row>;
+    }): {
+        leftFixedColumn: (VTable.TYPES.ColumnDefine | null)[];
+        rightFixedColumn: VTable.TYPES.ColumnsDefine;
+        topFixedRow: (Row | null)[];
+        bottomFixedRow: Row[];
+        top: any;
+        left: any;
+        right: any;
+        bottom: any;
+    };
+    /** 获取表格布局（cover: 覆盖边框 | inside：不覆盖边框） */
+    static getFixCellLayout<Row extends WholeRow>({ type, tableInstance, col, row, rect, borderWidth, }: {
+        tableInstance: ListTable<Row>;
+        rect: {
+            top: number;
+            left: number;
+            width: number;
+            height: number;
+        };
+        type: 'cover' | 'inside';
+        borderWidth?: number;
+    } & CellAddress): {
+        top: number;
+        left: number;
+        width: number;
+        height: number;
+    };
+    static getMergeType<Row extends WholeRow>(record: Row): {
+        isEmpty: boolean;
+        isButton: boolean;
+        isTitle: boolean;
+    };
+    /** 是否是分组列表的合并行 */
+    static isGroupMergeCell<Row extends WholeRow>(param: {
+        tableInstance: ListTable<Row>;
+    } & CellAddress, callback?: (param: {
+        record?: Row;
+        isGroupMergeCell: boolean;
+    }) => void): boolean;
+}

package/lib/src/components/OnChainVTable/index.d.ts

@@ -0,0 +1,6 @@
+import { default as React } from 'react';
+import { OnChainVTableProps } from './type';
+import { WholeRow } from './feature/types';
+type ParametersOne<T extends (args: any) => any> = T extends (args: infer P) => any ? P : never;
+declare const OnChainVTable: <Row extends WholeRow>(props: ParametersOne<React.FC<OnChainVTableProps<Row>>>) => import("react/jsx-runtime").JSX.Element;
+export default OnChainVTable;