@sisense/sdk-pivot-query-client 2.17.0

package/dist/cjs/tree-structure/AbstractTreeService.d.ts

@@ -0,0 +1,308 @@
+import { CloneFn } from '../utils/types.js';
+import { TreeCellMapI, TreeNode, TreeNodeMetadata, TreeServiceI } from './types.js';
+declare type TreeCellMapCache = {
+    [key: string]: TreeCellMapI;
+};
+declare type TreeNodeMetadataCache = {
+    [key: string]: TreeNodeMetadata;
+};
+declare type FillMapState = {
+    parentRowIndex: number;
+    parentColIndex: number;
+    prevChildren: number;
+    parentKey: string;
+};
+/**
+ * AbstractTreeService required as parent class to solve circular dependencies
+ * TreeService converts tree structure into grid structure, also it keeps inner grid structure
+ * to update cache system (via setCellCache) and receive merged cells (via updateMainCellMargins)
+ */
+export declare class AbstractTreeService implements TreeServiceI {
+    tree?: TreeNode;
+    hasGrandTotals: boolean;
+    /**
+     * Defines if tree will be converted to vertical or horizontal grid
+     *
+     *
+     * @private
+     */
+    isVertical: boolean;
+    deep?: number;
+    /**
+     * Cache tree nodes by deep levels
+     *
+     *
+     * @private
+     */
+    columns: Array<Array<TreeNode>>;
+    /**
+     * Cache last levels tree nodes
+     *
+     *
+     * @private
+     */
+    lastLevel: Array<any>;
+    /**
+     * Mapping object between tree<>grid
+     *
+     *
+     * @private
+     */
+    map: TreeCellMapCache;
+    /**
+     * Metadata cache object
+     *
+     *
+     * @private
+     */
+    metadataCache: TreeNodeMetadataCache;
+    /**
+     * Keep value node if it only one
+     *
+     *
+     * @private
+     */
+    valueNode?: TreeNode;
+    /**
+     * Final 2D array
+     *
+     *
+     * @private
+     */
+    grid?: Array<Array<any>>;
+    constructor(tree?: TreeNode, isVertical?: boolean, deep?: number);
+    destroy(): void;
+    getMainCellWidth(rowIndex: number, columnIndex: number, columnWidth: Function, borderWidth: number, options?: {
+        offsetTop?: number;
+        columnsOffset?: number;
+    }): number;
+    /**
+     * Adds additional tree node to current state
+     *
+     * @param {TreeNode} tree - new treeNode
+     * @returns {void}
+     */
+    extend(tree?: TreeNode): void;
+    /**
+     * Returns grid (2d list) of tree structure
+     *
+     * @returns {Array<Array<TreeNode | string>>} - 2d list
+     */
+    getGrid(): Array<Array<TreeNode | string>>;
+    /**
+     * Returns part of current grid according to "from" - "to" position
+     *
+     * @param {number} from - start rows index for partial grid
+     * @param {number} to - stop rows index for partial grid
+     * @returns {Array<Array<TreeNode | string>>} - partial grid
+     */
+    getPartialGrid(from: number, to: number): Array<Array<TreeNode | string>>;
+    /**
+     * Returns part of current tree with possible cut nodes according to "from" - "to" position
+     *
+     * @param {number} from - start rows index for partial grid
+     * @param {number} [to] - stop rows index for partial grid
+     * @param {object} [options] - additional options
+     * @param {Function} [options.cloneFn] - replace default clone function with specific one
+     * @returns {Array<TreeNode>} - partial tree
+     */
+    getPartialTree(from: number, to?: number, options?: {
+        cloneFn?: CloneFn;
+    }): Array<TreeNode>;
+    /**
+     * Returns TreeNode item if exist for appropriate coordinates (rowIndex, columnIndex)
+     *
+     * @param {number} rowIndex - row index
+     * @param {number} columnIndex - column index
+     * @returns {TreeNode|undefined} - TreeNode item
+     */
+    getTreeNode(rowIndex: number, columnIndex: number): TreeNode | undefined;
+    /**
+     * Defines if cell with (rowIndex, columnIndex) coordinate is children cell or main one
+     *
+     * @param {number} rowIndex - row index of the cell
+     * @param {number} columnIndex - column index of the cell
+     * @returns {boolean} - true - if children, false if main one
+     */
+    isChildren(rowIndex: number, columnIndex: number): boolean;
+    /**
+     * Defines if cell with (rowIndex, columnIndex) coordinate has children column/row cells or not
+     *
+     * @param {number} rowIndex - row index of the cell
+     * @param {number} columnIndex - column index of the cell
+     * @returns {boolean} - true - has children column/row cells, false - does not have
+     */
+    hasChildren(rowIndex: number, columnIndex: number): boolean;
+    /**
+     * Updates merge object for the cell if it has children cells
+     *
+     * @param {number} rowIndex - cell row index
+     * @param {number} columnIndex - cell column index
+     * @returns {object} - new merge object
+     */
+    getMainCellSpans(rowIndex: number, columnIndex: number): {
+        colSpan?: number;
+        rowSpan?: number;
+    };
+    /**
+     * Align start index in case of long merged cell
+     *
+     * @param {number} startIndex - initial start index
+     * @param {boolean} isVertical - defines if it is vertical grid or not
+     * @returns {number} - new start index
+     */
+    alignStartIndex(startIndex: number, isVertical?: boolean): number;
+    /**
+     * Align stop index in case of long merged cell
+     *
+     * @param {number} stopIndex - initial stop index
+     * @param {boolean} isVertical - defines if it is vertical grid or not
+     * @returns {number} - new stop index
+     */
+    alignStopIndex(stopIndex: number, isVertical?: boolean): number;
+    /**
+     * Returns number of last children for the tree
+     *
+     * @param {Array<TreeNode> | TreeNode} item - tree node or list of nodes
+     * @param {{ callCount: number, clearCache: boolean }} options - options for state
+     * @returns {number} - count of last children
+     */
+    getTreeChildLength(item?: TreeNode[] | TreeNode | undefined, options?: {
+        callCount?: number;
+        clearCache?: boolean;
+    }): number;
+    /**
+     * Returns deep level of the tree
+     *
+     * @param {Array<TreeNode> | TreeNode} item - tree node or list of nodes
+     * @param {{ callCount: number, clearCache: boolean }} options - options for inner state
+     * @returns {number} - count of last children
+     */
+    getTreeDeepsLength(item?: TreeNode[] | TreeNode | undefined, options?: {
+        callCount?: number;
+        clearCache?: boolean;
+    }): number;
+    /**
+     * Returns array of last tree nodes
+     *
+     * @returns {Array<TreeNode>} - list of tree nodes
+     */
+    getLastLevelNodes(): Array<TreeNode>;
+    /**
+     * Extract 2D array of data base on columnsTreeService
+     *
+     * @param {TreeServiceI} columnsTreeService - tree service according to which align the data
+     * @returns {Array<Array<any>>} - 2D array of data
+     */
+    extractData(columnsTreeService?: TreeServiceI): Array<Array<any>>;
+    /**
+     * Returns cell meta information
+     *
+     * @param {number} rowIndex - cell row index
+     * @param {number} columnIndex - cell column index
+     * @param {{ to: number }} [options] - additional configuration options
+     * @returns {{levels: Array<string>, siblings: Array<string>}} - meta information
+     */
+    getMetadata(rowIndex: number, columnIndex: number, options?: {
+        from: number;
+        to: number;
+    }): TreeNodeMetadata | undefined;
+    /**
+     * Sets value node when it's single
+     *
+     * @param {TreeNode} valueNode - values measure node
+     * @returns {void}
+     */
+    setValueNode(valueNode: TreeNode): void;
+    /**
+     * Fills cache object with nodes by appropriate deep level
+     *
+     * @param {Array<TreeNode>} list - list of nodes to cache
+     * @param {Array<Array<TreeNode>>} cache - cache object
+     * @param {{level: number }} options - internal recursive state
+     * @returns {Array<Array<TreeNode>>} - cache object
+     *
+     * @private
+     */
+    cacheLevels(list: Array<TreeNode>, cache?: Array<Array<TreeNode>>, options?: {
+        level: number;
+    }): TreeNode[][];
+    /**
+     * Fill horizontal grid map according to tree structure
+     *
+     * @param {Array<TreeNode>} children - list of tree nodes
+     * @param {number} rows - deep level rows
+     * @param {object} map - map object to fill
+     * @param {{parentColIndex: number, prevChildren: number}} initState - state object for
+     * recursive calls
+     * @returns {object} - map object
+     *
+     * @private
+     */
+    fillMap(children: Array<TreeNode>, rows: number, map?: TreeCellMapCache, initState?: FillMapState): TreeCellMapCache;
+    /**
+     * Fill vertical grid map according to tree structure
+     *
+     * @param {Array<TreeNode>} children - list of tree nodes
+     * @param {number} cols - deep level columns
+     * @param {TreeCellMapCache} map - map object to fill
+     * @param {FillMapState} initState - state object for
+     * recursive calls
+     * @returns {object} - map object
+     *
+     * @private
+     */
+    fillMapVertical(children: Array<TreeNode>, cols: number, map?: TreeCellMapCache, initState?: FillMapState): TreeCellMapCache;
+    /**
+     * Fill child items in map according to main cell merged row and col
+     *
+     * @param {object} map - map object to fill
+     * @param {string} mainKey - main cell key in map
+     * @param {number} rowStart - main cell row index
+     * @param {number} colStart - main cell column index
+     * @param {number} row - merged rows count
+     * @param {number} col - merged columns count
+     * @returns {void}
+     *
+     * @private
+     */
+    fillChildMap(map: TreeCellMapCache, mainKey: string, rowStart: number, colStart: number, row: number, col: number): void;
+    /**
+     * Creates TreeCellMap instance
+     *
+     * @param {object} options - instance options
+     * @param {number} options.rowIndex - row index of cell map instance
+     * @param {number} options.colIndex - row index of cell map instance
+     * @param {TreeNode} [options.node] - TreeNode for main cell
+     * @param {string} [options.parent] - parent key for child item
+     * @returns {TreeCellMap} - TreeCellMap instance
+     *
+     * @private
+     */
+    createTreeCellMap({ rowIndex, colIndex, node, parent, }: {
+        rowIndex: number;
+        colIndex: number;
+        node?: TreeNode;
+        parent?: string;
+    }): TreeCellMapI;
+    /**
+     * Returns TreeCellMapI item by key string
+     *
+     * @param {string} key - map key string
+     * @returns {TreeCellMapI|undefined} - TreeCellMapI instance or undefined
+     *
+     * @private
+     */
+    getItemByKey(key: string): TreeCellMapI | undefined;
+    /**
+     * Returns TreeCellMapI item by (row, col) coordinate
+     *
+     * @param {number} row - cell row index
+     * @param {number} col - cell column index
+     * @returns {TreeCellMapI|undefined} - TreeCellMapI instance or undefined
+     *
+     * @private
+     */
+    getItem(row: number, col: number): TreeCellMapI | undefined;
+}
+export default AbstractTreeService;