ag-grid-enterprise

import type { ITreeNode } from 'ag-grid-community'; import type { TreeRow } from './treeRow'; /** * We keep a secondary tree data structure based on TreeNode together with the RowNodes. * We associate a RowNode with a TreeNode, both storing the row in node.row and by storing the TreeNode in row.treeNode field. * We break the association when the row is removed or the TreeStrategy destroyed. * Consider that a TreeNode can contain more than one RowNode if there are duplicates keys in the same group, * in this case it means that the rows will have the same TreeNode. * * TreeStrategy uses a two stage approach both for first time creation and updates. * Multiple updates interact with the tree, and a commit stage commits all updates reducing expensive computations. * * Operations that do not affect the order will invalidate only the affected paths with node.invalidate(), * so that the commit operation will only update the affected paths without traversing the whole tree. * Consider that order of invalidated items is not deterministic, so the commit operation should be able to handle any order. * * During commit, the childrenAfterGroup and allLeafChildren arrays are rebuilt, and the updates are applied. * The empty filler nodes nodes are removed. * Before commit those arrays are NOT representing the truth, so they should not be used. */ export declare class TreeNode implements ITreeNode { /** The parent node of this node. Is null if destroyed or if is the root. */ parent: TreeNode | null; /** The key of this node. */ readonly key: string; /** The level of this node. Root has level -1 */ readonly level: number; /** Contains all the children by their key */ private children; /** * The head of the singly linked list of direct children nodes that are invalidated and need to be committed. * We use this so we can invalidate just the path and explore only the invalidated during commit. * Also, once a path is invalidated the next invalidation will not add the same node again and stop the recursion quickly. */ private invalidatedHead; /** * The next node in the linked list of parent.invalidatedHead. * - undefined: the node is not invalidated (not present in the parent linked list) * - null: this is the first and last node in the linked list * - TreeNode instance: is the next node in the linked list */ private invalidatedNext; /** The RowNode associated to this tree node */ row: TreeRow | null; /** We use this during commit to understand if the row changed. After commit, it will be the same as this.row. */ oldRow: TreeRow | null; /** * There may be duplicate rows if they have the same key. * This is NOT an edge case, temporarily duplicates may arise during transactions. * For example, think about swapping the paths of two nodes, they will have the same key for a short while. */ duplicateRows: Set<TreeRow> | null; /** We keep the row.childrenAfterGroup here, we just swap arrays when we assign rows */ childrenAfterGroup: TreeRow[]; /** * We keep the row.allLeafChildren here, we just swap arrays when we assign or swap the row to this node. * If this is null, we are borrowing the allLeafChildren array from one of the children, * in this case the row.allLeafChildren will be the same as one of the childrenAfterGroup[x].allLeafChildren, * to get the allLeafChildren if is null, do node.allLeafChildren ?? node.row.allLeafChildren. */ allLeafChildren: TreeRow[] | null; /** Indicates whether childrenAfterGroup might need to be recomputed and sorted. Reset during commit. */ childrenChanged: boolean; /** Indicates whether allLeafChildren should be recomputed. Reset to false during commit. */ leafChildrenChanged: boolean; /** This is set if the duplicate key warning was already raised for this node, to reduce the performance hit */ duplicateRowsWarned?: boolean; /** The ordering this node had in the previous commit. */ sourceIdx: number; constructor( /** The parent node of this node. Is null if destroyed or if is the root. */ parent: TreeNode | null, /** The key of this node. */ key: string, /** The level of this node. Root has level -1 */ level: number); /** Returns the number of children in this node */ get size(): number; isEmptyFillerNode(): boolean; /** Returns an iterator able to iterate all children in this node, in order of insertion */ enumChildren(): IterableIterator<TreeNode>; /** * Gets a node a key in the given parent. If the node does not exists, creates a filler node, with null row. * We cast to string just to be sure the user passed a string correctly and not a number or something else. * @param key - The key of the node to get. * @param append - If true, the node will be moved to the end of the children list. * @returns the node at the given key, or a new filler node inserted there if it does not exist. */ upsertKey(key: string | number): TreeNode; /** Same as upsertKey, but moves the node to the end no matter what. */ appendKey(key: string | number): TreeNode; /** Removes this node from the parent, and free memory. This node cannot be used after this. */ destroy(): void; /** * Sets the row for the TreeNode. * If the row is already set, it will be replaced with the new row, and the old row will be orphaned. * childrenAfterGroup and allLeafChildren will be reassigned. * @returns True if the row changed */ setRow(newRow: TreeRow | null): boolean; /** * Removes a row from the tree node. * If the row is the main row, it will be replaced with the first row in the duplicate rows, if any. * If the row is a duplicate row, it will be removed from the duplicate rows. * @param rowToRemove - The row to be removed. * @returns `true` if the row was successfully removed, `false` if the row was not found. */ removeRow(rowToRemove: TreeRow): boolean; /** * Adds a duplicate row to the tree node. * @param newRow - The new row to be added. * @returns A boolean indicating whether the row was successfully added. */ addDuplicateRow(newRow: TreeRow): boolean; /** * This is needed to be sure that the row is the duplicate row with the smallest sourceRowIndex, in O(n). * @returns this.row */ sortFirstDuplicateRow(): TreeRow | null; /** Pops the first duplicate row from the list of duplicates */ private popDuplicateRow; /** * Dequeues the next child invalidated node to be committed. Order is not deterministic. * @returns the next child node to be committed, or null if all children were already dequeued. */ dequeueInvalidated(): TreeNode | null; /** * Invalidates this node and all its parents until the root is reached. * Order of invalidated nodes is not deterministic. * The root itself cannot be invalidated, as it has no parents. * If a node is already invalidated, it will stop the recursion. */ invalidate(): void; /** Marks childrenChanged in the parent, so the childrenAfterGroup will be recomputed and invalidates the parent. */ invalidateOrder(): void; /** * When we receive rowNodeOrder not undefined, we need to update the rowPosition of the node, * to ensure it will be sorted in the right order in childrenAfterGroup. * This function makes sense to be called only in the post-order commit DFS * as it assumes children's childrenAfterGroup is already updated. * @returns the rowPosition the node should have. */ getNewSourceIdx(): number; /** * This is called in post order during commit to update the childrenAfterGroup array. * It uses the rowNodeOrder map to sort the children in the right order, if is passed. * It assumes all children childrenAfterGroup are up to date and rows all created. * * It replaces the array with _EmptyArray if there are no children, to reduce memory usage and GC pressure. * It does sort the children only if strictly needed, to avoid unnecessary work. * * If the order changes, also the order in the children map will be updated, * so the next call to enumChildren() will return the children in the right order. */ updateChildrenAfterGroup(treeData: boolean): boolean; /** This reorders the given array and rebuild the children map. */ private reorderChildrenList; /** * Rebuild the allLeafChildren rows array of a node. It uses childrenAfterGroup, we assume to be already updated. * This is called in post order during commit, after the childrenAfterGroup are updated with updateChildrenAfterGroup(). * It uses the childrenAfterGroup and allLeafChildren of all the children, we assume they are updated. */ updateAllLeafChildren(): void; }