@scvzerng/element-ui-ag-grid-vue2 0.0.8

package/dist/types/ag-grid-vue/main.d.ts

@@ -0,0 +1,2 @@
+import AgGridVue from './components/AgGridVue.vue';
+export { AgGridVue };

package/dist/types/clientSideRowModel/abstractClientSideNodeManager.d.ts

@@ -0,0 +1,50 @@
+import { BeanStub, RowNode, IClientSideNodeManager, ClientSideNodeManagerUpdateRowDataResult } from 'ag-grid-community';
+import type { GetRowIdFunc, RowDataTransaction, IChangedRowNodes, RefreshModelParams } from 'ag-grid-community';
+/**
+ * This is the type of any row in allLeafChildren and childrenAfterGroup of the ClientSideNodeManager rootNode.
+ * ClientSideNodeManager is allowed to update the sourceRowIndex property of the nodes.
+ */
+interface ClientSideNodeManagerRowNode<TData> extends RowNode<TData> {
+    sourceRowIndex: number;
+}
+/**
+ * This is the type of the root RowNode of the ClientSideNodeManager
+ * ClientSideNodeManager is allowed to update the allLeafChildren and childrenAfterGroup properties of the root node.
+ */
+interface ClientSideNodeManagerRootNode<TData> extends RowNode<TData> {
+    sibling: ClientSideNodeManagerRootNode<TData>;
+    allLeafChildren: ClientSideNodeManagerRowNode<TData>[] | null;
+    childrenAfterGroup: ClientSideNodeManagerRowNode<TData>[] | null;
+}
+export declare namespace AbstractClientSideNodeManager {
+    type RowNode<TData> = ClientSideNodeManagerRowNode<TData>;
+    type RootNode<TData> = ClientSideNodeManagerRootNode<TData>;
+}
+export declare abstract class AbstractClientSideNodeManager<TData = any> extends BeanStub implements IClientSideNodeManager<TData> {
+    private nextId;
+    protected allNodesMap: {
+        [id: string]: RowNode<TData>;
+    };
+    rootNode: AbstractClientSideNodeManager.RootNode<TData> | null;
+    getRowNode(id: string): RowNode | undefined;
+    extractRowData(): TData[] | null | undefined;
+    activate(rootNode: ClientSideNodeManagerRootNode<TData>): void;
+    deactivate(): void;
+    destroy(): void;
+    setNewRowData(rowData: TData[]): void;
+    private updateRootSiblingArrays;
+    protected loadNewRowData(rowData: TData[]): void;
+    setImmutableRowData(params: RefreshModelParams<TData>, rowData: TData[]): void;
+    /** Called when a node needs to be deleted */
+    protected rowNodeDeleted(node: RowNode<TData>): void;
+    updateRowData(rowDataTran: RowDataTransaction<TData>, changedRowNodes: IChangedRowNodes<TData>): ClientSideNodeManagerUpdateRowDataResult<TData>;
+    protected executeAdd(rowDataTran: RowDataTransaction, result: ClientSideNodeManagerUpdateRowDataResult<TData>): void;
+    protected executeRemove(getRowIdFunc: GetRowIdFunc<TData> | undefined, rowDataTran: RowDataTransaction, { changedRowNodes, rowNodeTransaction }: ClientSideNodeManagerUpdateRowDataResult<TData>, nodesToUnselect: RowNode<TData>[]): void;
+    protected executeUpdate(getRowIdFunc: GetRowIdFunc<TData> | undefined, rowDataTran: RowDataTransaction, { changedRowNodes, rowNodeTransaction }: ClientSideNodeManagerUpdateRowDataResult<TData>, nodesToUnselect: RowNode<TData>[]): void;
+    protected dispatchRowDataUpdateStartedEvent(rowData?: TData[] | null): void;
+    protected deselectNodes(nodesToUnselect: RowNode<TData>[]): void;
+    private sanitizeAddIndex;
+    protected createRowNode(data: TData, sourceRowIndex: number): RowNode<TData>;
+    protected lookupRowNode(getRowIdFunc: ((data: any) => string) | undefined, data: TData): RowNode<TData> | null;
+}
+export {};

package/dist/types/clientSideRowModel/changedRowNodes.d.ts

@@ -0,0 +1,12 @@
+import type { RowNode, IRowNode } from 'ag-grid-community';
+export declare class ChangedRowNodes<TData = any> {
+    readonly removals: Set<RowNode<TData>>;
+    readonly updates: Set<RowNode<TData>>;
+    readonly adds: Set<RowNode<TData>>;
+    /** Marks a row as removed. Order of operations is: remove, update, add */
+    remove(node: IRowNode<TData>): void;
+    /** Marks a row as updated. Order of operations is: remove, update, add */
+    update(node: IRowNode<TData>): void;
+    /** Marks a row as added. Order of operation is: remove, update, add */
+    add(node: IRowNode<TData>): void;
+}

package/dist/types/clientSideRowModel/clientSideNodeManager.d.ts

@@ -0,0 +1,5 @@
+import type { NamedBean } from 'ag-grid-community';
+import { AbstractClientSideNodeManager } from './abstractClientSideNodeManager';
+export declare class ClientSideNodeManager<TData> extends AbstractClientSideNodeManager<TData> implements NamedBean {
+    beanName: "csrmNodeSvc";
+}

package/dist/types/clientSideRowModel/clientSideRowModel.d.ts

@@ -0,0 +1,129 @@
+import { BeanStub, RowNode, IClientSideRowModel, RefreshModelParams, ChangedPath } from 'ag-grid-community';
+import type { NamedBean, BeanCollection, RowBounds, RowModelType, RowDataTransaction, RowNodeTransaction } from 'ag-grid-community';
+export declare class ClientSideRowModel extends BeanStub implements IClientSideRowModel, NamedBean {
+    beanName: "rowModel";
+    private colModel;
+    private valueCache?;
+    private filterStage?;
+    private sortStage?;
+    private flattenStage?;
+    private groupStage?;
+    private aggStage?;
+    private pivotStage?;
+    private filterAggStage?;
+    wireBeans(beans: BeanCollection): void;
+    rootNode: RowNode | null;
+    private rowsToDisplay;
+    private nodeManager;
+    private rowDataTransactionBatch;
+    /** Keep track if row data was updated. Important with suppressModelUpdateAfterUpdateTransaction and refreshModel api is called  */
+    private rowDataUpdatedPending;
+    private applyAsyncTransactionsTimeout;
+    /** Has the start method been called */
+    private started;
+    /**
+     * This is to prevent refresh model being called when it's already being called.
+     * E.g. the group stage can trigger initial state filter model to be applied. This fires onFilterChanged,
+     * which then triggers the listener here that calls refresh model again but at the filter stage
+     * (which is about to be run by the original call).
+     */
+    private isRefreshingModel;
+    private rowNodesCountReady;
+    private rowCountReady;
+    private orderedStages;
+    postConstruct(): void;
+    private getNewNodeManager;
+    private addPropertyListeners;
+    start(): void;
+    private setInitialData;
+    ensureRowHeightsValid(startPixel: number, endPixel: number, startLimitIndex: number, endLimitIndex: number): boolean;
+    private onPropChange;
+    private setRowTopAndRowIndex;
+    private clearRowTopAndRowIndex;
+    isLastRowIndexKnown(): boolean;
+    getRowCount(): number;
+    /**
+     * Returns the number of rows with level === 1
+     */
+    getTopLevelRowCount(): number;
+    /**
+     * Get the row display index by the top level index
+     * top level index is the index of rows with level === 1
+     */
+    getTopLevelRowDisplayedIndex(topLevelIndex: number): number;
+    /**
+     * The opposite of `getTopLevelRowDisplayedIndex`
+     */
+    getTopLevelIndexFromDisplayedIndex(displayedIndex: number): number;
+    getRowBounds(index: number): RowBounds | null;
+    onRowGroupOpened(): void;
+    private onFilterChanged;
+    private onSortChanged;
+    getType(): RowModelType;
+    private onValueChanged;
+    private createChangePath;
+    private isSuppressModelUpdateAfterUpdateTransaction;
+    refreshModel(params: RefreshModelParams): void;
+    isEmpty(): boolean;
+    isRowsToRender(): boolean;
+    getNodesInRangeForSelection(firstInRange: RowNode, lastInRange: RowNode): RowNode[];
+    getTopLevelNodes(): RowNode[] | null;
+    getRow(index: number): RowNode;
+    isRowPresent(rowNode: RowNode): boolean;
+    getRowIndexAtPixel(pixelToMatch: number): number;
+    private isRowInPixel;
+    forEachLeafNode(callback: (node: RowNode, index: number) => void): void;
+    forEachNode(callback: (node: RowNode, index: number) => void, includeFooterNodes?: boolean): void;
+    forEachDisplayedNode(callback: (rowNode: RowNode<any>, index: number) => void): void;
+    forEachNodeAfterFilter(callback: (node: RowNode, index: number) => void, includeFooterNodes?: boolean): void;
+    forEachNodeAfterFilterAndSort(callback: (node: RowNode, index: number) => void, includeFooterNodes?: boolean): void;
+    forEachPivotNode(callback: (node: RowNode, index: number) => void, includeFooterNodes?: boolean, afterSort?: boolean): void;
+    /**
+     * Iterate through each node and all of its children
+     * @param callback the function to execute for each node
+     * @param includeFooterNodes whether to also iterate over footer nodes
+     * @param nodes the nodes to start iterating over
+     * @param getChildren a function to determine the recursion strategy
+     * @param startIndex the index to start from
+     * @returns the index ended at
+     */
+    private depthFirstSearchRowNodes;
+    doAggregate(changedPath?: ChangedPath): void;
+    private doFilterAggregates;
+    private doSort;
+    private doRowGrouping;
+    private doFilter;
+    private doPivot;
+    getRowNode(id: string): RowNode | undefined;
+    batchUpdateRowData(rowDataTransaction: RowDataTransaction, callback?: (res: RowNodeTransaction) => void): void;
+    flushAsyncTransactions(): void;
+    private executeBatchUpdateRowData;
+    /**
+     * Used to apply transaction changes.
+     * Called by gridApi & rowDragFeature
+     */
+    updateRowData(rowDataTran: RowDataTransaction): RowNodeTransaction | null;
+    /**
+     * Common to:
+     * - executeBatchUpdateRowData (batch transactions)
+     * - updateRowData (single transaction)
+     * - setImmutableRowData (generated transaction)
+     *
+     * @param rowNodeTrans - the transactions to apply
+     * @param orderChanged - whether the order of the rows has changed, either via generated transaction or user provided addIndex
+     */
+    private commitTransactions;
+    private doRowsToDisplay;
+    onRowHeightChanged(): void;
+    resetRowHeights(): void;
+    private resetRowHeightsForAllRowNodes;
+    private onGridStylesChanges;
+    private onGridReady;
+    isRowDataLoaded(): boolean;
+    destroy(): void;
+    private onRowHeightChanged_debounced;
+    /**
+     * @deprecated v33.1
+     */
+    onRowHeightChangedDebounced(): void;
+}

package/dist/types/clientSideRowModel/clientSideRowModelApi.d.ts

@@ -0,0 +1,12 @@
+import type { BeanCollection, ClientSideRowModelStep, IRowNode, RowDataTransaction, RowNodeTransaction } from 'ag-grid-community';
+export declare function onGroupExpandedOrCollapsed(beans: BeanCollection): void;
+export declare function refreshClientSideRowModel(beans: BeanCollection, step?: ClientSideRowModelStep): void;
+export declare function isRowDataEmpty(beans: BeanCollection): boolean;
+export declare function forEachLeafNode<TData = any>(beans: BeanCollection, callback: (rowNode: IRowNode<TData>) => void): void;
+export declare function forEachNodeAfterFilter<TData = any>(beans: BeanCollection, callback: (rowNode: IRowNode<TData>, index: number) => void): void;
+export declare function forEachNodeAfterFilterAndSort<TData = any>(beans: BeanCollection, callback: (rowNode: IRowNode<TData>, index: number) => void): void;
+export declare function resetRowHeights(beans: BeanCollection): void;
+export declare function applyTransaction<TData = any>(beans: BeanCollection, rowDataTransaction: RowDataTransaction<TData>): RowNodeTransaction<TData> | null | undefined;
+export declare function applyTransactionAsync<TData = any>(beans: BeanCollection, rowDataTransaction: RowDataTransaction<TData>, callback?: (res: RowNodeTransaction<TData>) => void): void;
+export declare function flushAsyncTransactions(beans: BeanCollection): void;
+export declare function getBestCostNodeSelection<TData = any>(beans: BeanCollection): IRowNode<TData>[] | undefined;

package/dist/types/clientSideRowModel/clientSideRowModelModule.d.ts

@@ -0,0 +1,9 @@
+import type { _ClientSideRowModelGridApi, _ModuleWithApi, _ModuleWithoutApi } from 'ag-grid-community';
+/**
+ * @feature Client-Side Row Model
+ */
+export declare const ClientSideRowModelModule: _ModuleWithoutApi;
+/**
+ * @feature Client-Side Row Model
+ */
+export declare const ClientSideRowModelApiModule: _ModuleWithApi<_ClientSideRowModelGridApi<any>>;

package/dist/types/clientSideRowModel/filterStage.d.ts

@@ -0,0 +1,14 @@
+import type { NamedBean, BeanCollection, GridOptions, RowNode, IRowNodeStage, StageExecuteParams, ClientSideRowModelStage } from 'ag-grid-community';
+import { BeanStub } from 'ag-grid-community';
+export declare function updateRowNodeAfterFilter(rowNode: RowNode): void;
+export declare class FilterStage extends BeanStub implements IRowNodeStage, NamedBean {
+    beanName: "filterStage";
+    refreshProps: Set<keyof GridOptions<any>>;
+    step: ClientSideRowModelStage;
+    private filterManager?;
+    wireBeans(beans: BeanCollection): void;
+    execute(params: StageExecuteParams): void;
+    private filter;
+    private filterNodes;
+    private doingTreeDataFiltering;
+}

package/dist/types/clientSideRowModel/sortStage.d.ts

@@ -0,0 +1,10 @@
+import { BeanStub } from 'ag-grid-community';
+import type { NamedBean, GridOptions, RowNode, ClientSideRowModelStage, IRowNodeStage, StageExecuteParams } from 'ag-grid-community';
+export declare function updateRowNodeAfterSort(rowNode: RowNode): void;
+export declare class SortStage extends BeanStub implements NamedBean, IRowNodeStage {
+    beanName: "sortStage";
+    refreshProps: Set<keyof GridOptions<any>>;
+    step: ClientSideRowModelStage;
+    execute(params: StageExecuteParams): void;
+    private sort;
+}

package/dist/types/context-menu/index.d.ts

@@ -0,0 +1,8 @@
+import type { IMenuActionParams, MenuItemDef } from 'ag-grid-community';
+/**
+ * 显示上下文菜单
+ * @param event - 鼠标事件对象，用于获取菜单显示位置
+ * @param options - 菜单项定义数组，包含菜单项的配置信息
+ * @param agEvent - 菜单操作参数对象，传递给菜单项处理函数
+ */
+export declare const showContextMenu: (event: MouseEvent, options: MenuItemDef[], agEvent: IMenuActionParams) => void;

package/dist/types/helper/vModel.d.ts

@@ -0,0 +1,12 @@
+import { UnwrapNestedRefs } from "vue";
+/**
+ * vue2 翻译jsx片段时在非组件上下文中会生成this.$set 尝试设置属性导致报错 此时使用此方法绕过生成
+ * @param hostObject
+ * @param path
+ */
+export declare const vModel: <T>(hostObject: UnwrapNestedRefs<T>, path: string) => {
+    model: {
+        value: any;
+        callback: (newValue: any) => void;
+    };
+};

package/dist/types/index.d.ts

@@ -0,0 +1,25 @@
+import type { PluginObject } from 'vue';
+import type { ColDef, ColGroupDef, ICellRendererParams } from 'ag-grid-community';
+import type { RestrictedAgGridOptions } from './ag-grid/options/ag-grid-options';
+import 'ag-grid-community/styles/ag-grid.css';
+import 'ag-grid-community/styles/ag-theme-alpine.css';
+import "@scvzerng/vue2-context-menu/lib/vue2-context-menu.css";
+export * from './GridDataSource';
+export * from './tokens';
+export * from './utils/GridUtils';
+export { default as Grid } from './Grid.vue';
+export * from './renders';
+export * from "./helper/vModel";
+export * from "./search";
+export type Options<TData = any> = RestrictedAgGridOptions<TData>;
+export type Column<T = any> = ColDef<T> | ColGroupDef<T>;
+export type ContextMenuItem<TData> = {
+    name: string;
+    icon?: string;
+    subMenu?: ContextMenuItem<TData>[];
+    checked?: boolean;
+    disabled?: boolean;
+    action?: (params: ICellRendererParams<TData>) => void;
+};
+export type RowIdMapper<T> = (data: T) => string;
+export declare const VueGridPlugin: PluginObject<any>;

package/dist/types/model/row/ActualRow.d.ts

@@ -0,0 +1,77 @@
+import { CellValue } from './CellValue';
+import { Column, GridApi, IRowNode } from 'ag-grid-community';
+import { RowSpans } from './SpanInfo';
+import { ProjectionRow } from './ProjectionRow';
+import { GridRow } from './GridRow';
+import { EditableRow } from './EditableRow';
+import { RowIdMapper } from '../../index';
+import { GridDataCache } from '../../GridDataCache';
+/**
+ * 实际行
+ */
+export declare class ActualRow<T> implements GridRow<T> {
+    /**
+     *  唯一编号
+     */
+    id: string;
+    /**
+     * 数据
+     */
+    data: T;
+    /**
+     * 可以进行路径访问的单元格映射
+     */
+    pathCells: Map<string, CellValue | CellValue[]>;
+    /**
+     * 签名
+     */
+    signature: string;
+    /**
+     * 每行的最后一个单元格
+     */
+    leafCells: CellValue[];
+    /**
+     * 合并行信息
+     */
+    spanCache: RowSpans;
+    gridApi: GridApi<GridRow<T>>;
+    idMapper: RowIdMapper<T>;
+    dataCache: GridDataCache<T>;
+    /**
+     * 当前数据在列表中的索引
+     */
+    index?: number;
+    constructor(data: T, gridApi: GridApi<GridRow<T>>, idMapper: RowIdMapper<T>, dataCache: GridDataCache<T>, index?: number);
+    delete(): void;
+    redraw(): void;
+    getDataIndex(): number;
+    getRowSpans(): RowSpans;
+    getSignature(): string;
+    startEditing(redraw?: boolean): EditableRow<T>;
+    /**
+     * 设置数据当前在集合的位置
+     * 在设置表格数据时每次自行更新不可外部手动调用
+     * @param index
+     */
+    __setIndex(index: number): void;
+    /**
+     * 更新数据
+     * @param id
+     * @param data
+     */
+    update(id: string, data: T): void;
+    isTransient(): this is EditableRow<T>;
+    getId(): string;
+    isEditing(): this is EditableRow<T>;
+    getData(): T;
+    buildSpan(): void;
+    /**
+     * 把嵌套的数组结构扁平化以便表格渲染对应的行数
+     */
+    flat(): ProjectionRow<T>[];
+    private getLeafCells;
+    getCell(column: Column, nestingIndexes: number[]): CellValue | undefined;
+    getValue(column: Column, nestingIndexes: number[]): any;
+    setData(data: T): void;
+    match(rowNode: IRowNode<GridRow<T>>): boolean;
+}

package/dist/types/model/row/CellValue.d.ts

@@ -0,0 +1,37 @@
+import { Column } from 'ag-grid-community';
+export declare class CellValue {
+    id: string;
+    /**
+     *  值从哪个字段提取的
+     */
+    field: string;
+    /**
+     * 属性值
+     */
+    value: any;
+    index?: number;
+    /**
+     * 复杂标的值对象，只有在提取的值不是一个单元格可渲染的简单值时才会存在 否则应该为空
+     */
+    properties: Map<string, CellValue | CellValue[]>;
+    parent?: CellValue;
+    /**
+     * 合并单元格行数
+     */
+    spanRow: number;
+    path: string;
+    constructor(id: string, field: string, value: any, index?: number, parent?: CellValue);
+    getRoot(): CellValue | undefined;
+    pretreatmentValue(field: string, parent: CellValue, column: Column): CellValue | CellValue[];
+    /**
+     * 只要子路径包含数组元素就需要合并行
+     * @private
+     */
+    private isNeedSpan;
+    get(field: string): CellValue | CellValue[] | undefined;
+    calcSpan(): number;
+    private setRowSpan;
+    getPath(): string;
+    getReadPath(): string;
+    isArrayElement(): boolean;
+}

package/dist/types/model/row/EditableRow.d.ts

@@ -0,0 +1,52 @@
+import { ActualRow } from './ActualRow';
+import { UnwrapNestedRefs } from 'vue';
+import { GridRow } from './GridRow';
+import { Column, IRowNode } from 'ag-grid-community';
+import { RowIdMapper } from '../../index';
+import { ProjectionRow } from './ProjectionRow';
+import { RowSpans } from './SpanInfo';
+/**
+ * 可编辑行
+ */
+export declare class EditableRow<T = any> implements GridRow<T> {
+    private actualRow;
+    private draft?;
+    private transient;
+    private readonly idMapper;
+    constructor(actualRow: ActualRow<T>, idMapper: RowIdMapper<T>, transient?: boolean);
+    delete(): void;
+    redraw(): void;
+    getDataIndex(): number;
+    getSignature(): string;
+    getValue(column: Column, nestingIndexes: number[]): string | boolean | number;
+    getData(): T;
+    isTransient(): this is EditableRow<T>;
+    getCell(column: Column, nestingIndexes: number[]): import("./CellValue").CellValue | undefined;
+    __setIndex(index: number): void;
+    /**
+     * 结束编辑
+     */
+    stopEditing(redraw?: boolean): ActualRow<T>;
+    /**
+     * 编辑中
+     */
+    isEditing(): this is EditableRow<T>;
+    /**
+     * 获取编辑草稿信息
+     */
+    getDraft(): UnwrapNestedRefs<T> | undefined;
+    getId(): string;
+    flat(): ProjectionRow<T>[];
+    /**
+     * 持久化数据 让数据从瞬态转为持久态
+     *
+     *  不改变当前的编辑状态
+     *
+     * @param persistentCallback
+     */
+    persistent(persistentCallback: (row: T) => Promise<T>): Promise<this>;
+    getRowSpans(): RowSpans;
+    setData(data: T): void;
+    buildSpan(): void;
+    match(rowNode: IRowNode<GridRow<T>>): boolean;
+}

package/dist/types/model/row/GridRow.d.ts

@@ -0,0 +1,30 @@
+import { Column, IRowNode } from 'ag-grid-community';
+import { ActualRow } from './ActualRow';
+import { EditableRow } from './EditableRow';
+import { CellValue } from './CellValue';
+import { RowSpans } from './SpanInfo';
+export interface GridRow<T> {
+    getValue(column: Column, nestingIndexes?: number[]): string | boolean | number;
+    isEditing(): this is EditableRow<T>;
+    getData(): T;
+    getId(): string;
+    isTransient(): this is EditableRow<T>;
+    getCell(column: Column, nestingIndexes?: number[]): CellValue | undefined;
+    getSignature(): string;
+    getRowSpans(): RowSpans;
+    setData(data: T): void;
+    /**
+     *  构建行span信息
+     */
+    buildSpan(): void;
+    /**
+     * 是否匹配
+     * @param rowNode
+     */
+    match(rowNode: IRowNode<GridRow<T>>): boolean;
+    getDataIndex(): number;
+    redraw(): void;
+    delete(): void;
+}
+export declare const isGridRow: <T>(row: any) => row is GridRow<T>;
+export declare const isActualRow: <T extends object>(row: any) => row is ActualRow<T>;

package/dist/types/model/row/ProjectionRow.d.ts

@@ -0,0 +1,43 @@
+import { Column, IRowNode } from 'ag-grid-community';
+import { ActualRow } from './ActualRow';
+import { GridRow } from './GridRow';
+import { EditableRow } from './EditableRow';
+import { RowSpans } from './SpanInfo';
+/**
+ * 投影行
+ *
+ * 行合并时分裂的投影行
+ */
+export declare class ProjectionRow<T> implements GridRow<T> {
+    /**
+     * 引用数据
+     *
+     * 如果发现该行存在引用数据 说明该行为虚拟行无实际意义 需要取引用数据
+     */
+    actualRow: ActualRow<T> | EditableRow<T>;
+    /**
+     * 投影行ID
+     */
+    id: string;
+    constructor(id: string, actualRow: ActualRow<T> | EditableRow<T>);
+    delete(): void;
+    redraw(): void;
+    getDataIndex(): number;
+    getRowSpans(): RowSpans;
+    isEditing(): this is EditableRow<T>;
+    getValue(column: Column): string | boolean | number;
+    getRowSpan(column: Column): number;
+    getData(): T;
+    isColumnValueChanged(value: any, column: Column): boolean;
+    getNestingIndexes(): number[];
+    /**
+     * 获取该行节点的签名 当前面变化时所有可视单元格需要重新渲染
+     */
+    getSignature(): string;
+    getId(): string;
+    getCell(column: Column): import("./CellValue").CellValue | undefined;
+    isTransient(): this is EditableRow<T>;
+    setData(data: T): void;
+    buildSpan(): void;
+    match(rowNode: IRowNode<GridRow<T>>): boolean;
+}

package/dist/types/model/row/SpanInfo.d.ts

@@ -0,0 +1,25 @@
+import { Column } from 'ag-grid-community';
+import { CellValue } from './CellValue';
+/**
+ * 存储每行数据的行span信息
+ */
+export declare class RowSpans {
+    private cellSpanCache;
+    private static SPLITTER;
+    get(rowId: string, column: Column): number;
+    set(rowId: string, column: Column, span: number): void;
+    private getKey;
+    constructor(cells: CellValue[], columns: Column[]);
+    /**
+     * 递归计算每个叶子节点路径上的span信息
+     *
+     * 对于同属于一个父节点的节点只会在第一个节点时保存 其余节点全部忽略，
+     * 因为在展开行时对于ag-grid 只有在合并单元格的第一个单元格返回合并信息 剩余的单元格不能返回合并信息必须返回0所以只记录第一个节点的合并信息
+     * @param id 叶子节点单元格的ID 即展开行后的行ID
+     * @param cell 当前节点
+     * @param columns 列配置
+     * @private
+     */
+    private calcSpanInfo;
+    private processDeep;
+}

package/dist/types/render/CellHolder.d.ts

@@ -0,0 +1,15 @@
+import { CreateElement, RenderContext, VNode } from 'vue';
+import { ICellRendererParams } from 'ag-grid-community';
+declare const _default: {
+    functional: boolean;
+    props: {
+        params: {
+            type: ObjectConstructor;
+            required: boolean;
+        };
+    };
+    render(createElement: CreateElement, context: RenderContext<{
+        params: ICellRendererParams;
+    }>): VNode | VNode[];
+};
+export default _default;

package/dist/types/render/CellRenderer.vue.d.ts

@@ -0,0 +1,16 @@
+import { ICustomCellRendererParams } from './types/ICellRendererParamsExt';
+import { GridRow } from '../model/row/GridRow';
+type __VLS_Props = {
+    params: ICustomCellRendererParams<GridRow<any>, any>;
+};
+declare const _default: import("vue").DefineComponent<__VLS_TypePropsToOption<__VLS_Props>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToOption<__VLS_Props>>>, {}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};

package/dist/types/render/FooterCellRender.vue.d.ts

@@ -0,0 +1,15 @@
+import { ICellRendererParams } from 'ag-grid-community';
+type __VLS_Props = {
+    params: ICellRendererParams;
+};
+declare const _default: import("vue").DefineComponent<__VLS_TypePropsToOption<__VLS_Props>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToOption<__VLS_Props>>>, {}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};

package/dist/types/render/HeaderRenderer.vue.d.ts

@@ -0,0 +1,15 @@
+import type { IHeaderParams } from 'ag-grid-community';
+type __VLS_Props = {
+    params: IHeaderParams;
+};
+declare const _default: import("vue").DefineComponent<__VLS_TypePropsToOption<__VLS_Props>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToOption<__VLS_Props>>>, {}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};

package/dist/types/render/VNodeRender.d.ts

@@ -0,0 +1,11 @@
+import { CreateElement, RenderContext, VNode } from 'vue';
+import { ICustomCellRendererParams } from './types/ICellRendererParamsExt';
+declare const _default: {
+    functional: boolean;
+    name: string;
+    props: string[];
+    render(createElement: CreateElement, context: RenderContext<{
+        params: ICustomCellRendererParams<any, any>;
+    }>): VNode | VNode[];
+};
+export default _default;