@sisense/sdk-pivot-query-client 2.17.0

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

@@ -0,0 +1,180 @@
+import { CloneFn } from '../utils/types.js';
+import { TreeNode, TreeNodeMetadata, TreeServiceI } from './types.js';
+export declare class HeaderTreeService implements TreeServiceI {
+    hasGrandTotals: boolean;
+    /**
+     * columns TreeService
+     *
+     *
+     * @private
+     */
+    columnsTreeService?: TreeServiceI;
+    /**
+     * corner TreeService
+     *
+     *
+     * @private
+     */
+    cornerTreeService?: TreeServiceI;
+    /**
+     * Final 2D array
+     *
+     *
+     * @private
+     */
+    grid?: Array<Array<any>>;
+    /**
+     * columns grid offset base on corner size
+     *
+     *
+     * @private
+     */
+    cornerOffset: number;
+    constructor(cornerTreeService?: TreeServiceI, columnsTreeService?: TreeServiceI);
+    /**
+     * Returns grid (2d list) of tree structure
+     *
+     * @returns {Array<Array<TreeNode | string>>} - 2d list
+     */
+    getGrid(): Array<Array<TreeNode | string>>;
+    /**
+     * 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;
+    getMainCellWidth(rowIndex: number, columnIndex: number, columnWidth: Function, borderWidth: number, options?: {
+        offsetTop?: number;
+        columnsOffset?: number;
+    }): number;
+    /**
+     * 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
+     * @returns {number} - count of last children
+     */
+    getTreeChildLength(item?: Array<TreeNode> | TreeNode): number;
+    /**
+     * Returns deep level of the tree
+     *
+     * @param {Array<TreeNode> | TreeNode} item - tree node or list of nodes
+     * @returns {number} - count of last children
+     */
+    getTreeDeepsLength(item?: Array<TreeNode> | TreeNode): number;
+    /**
+     * Sets value node when it's single
+     *
+     * @param {TreeNode} valueNode - values measure node
+     * @returns {void}
+     */
+    setValueNode(valueNode: TreeNode): void;
+    /**
+     * 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;
+    destroy(): void;
+    /**
+     * Returns array of last tree nodes
+     * Should not be called for header
+     *
+     * @returns {Array<TreeNode>} - list of tree nodes
+     * @deprecated
+     */
+    getLastLevelNodes(): Array<TreeNode>;
+    /**
+     * Extract 2D array of data base on columnsTreeService
+     * Should not be called for header
+     *
+     * @param {TreeServiceI} columnsTreeService - tree service according to which align the data
+     * @returns {Array<Array<any>>} - 2D array of data
+     * @deprecated
+     */
+    extractData(columnsTreeService?: TreeServiceI): Array<Array<any>>;
+    /**
+     * Adds additional tree node to current state
+     * Should not be called for header
+     *
+     * @param {TreeNode} tree - new treeNode
+     * @returns {void}
+     * @deprecated
+     */
+    extend(tree?: TreeNode): void;
+    /**
+     * Returns part of current tree with possible cut nodes according to "from" - "to" position
+     * Should not be called for header
+     *
+     * @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
+     * @deprecated
+     */
+    getPartialTree(from: number, to?: number, options?: {
+        cloneFn?: CloneFn;
+    }): Array<TreeNode>;
+    /**
+     * Returns part of current grid according to "from" - "to" position
+     * Should not be called for header
+     *
+     * @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
+     * @deprecated
+     */
+    getPartialGrid(from: number, to: number): Array<Array<TreeNode | string>>;
+}
+export default HeaderTreeService;

package/dist/cjs/tree-structure/HeaderTreeService.js

@@ -0,0 +1,280 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HeaderTreeService = void 0;
+class HeaderTreeService {
+    constructor(cornerTreeService, columnsTreeService) {
+        this.hasGrandTotals = false;
+        /**
+         * columns grid offset base on corner size
+         *
+         *
+         * @private
+         */
+        this.cornerOffset = 0;
+        this.cornerTreeService = cornerTreeService;
+        this.columnsTreeService = columnsTreeService;
+        this.cornerOffset = this.cornerTreeService ? this.cornerTreeService.getTreeChildLength() : 0;
+    }
+    /**
+     * Returns grid (2d list) of tree structure
+     *
+     * @returns {Array<Array<TreeNode | string>>} - 2d list
+     */
+    getGrid() {
+        if (this.grid) {
+            return this.grid;
+        }
+        const cornerGrid = this.cornerTreeService ? this.cornerTreeService.getGrid() : [];
+        const columnsGrid = this.columnsTreeService ? this.columnsTreeService.getGrid() : [];
+        this.grid = cornerGrid.map((cornerRow = [], index) => {
+            const columnsRow = columnsGrid[index] || [];
+            return cornerRow.concat(columnsRow);
+        });
+        return this.grid;
+    }
+    /**
+     * 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, columnIndex) {
+        if (columnIndex >= this.cornerOffset && this.columnsTreeService) {
+            return this.columnsTreeService.getTreeNode(rowIndex, columnIndex - this.cornerOffset);
+        }
+        return this.cornerTreeService
+            ? this.cornerTreeService.getTreeNode(rowIndex, columnIndex)
+            : 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, columnIndex) {
+        if (columnIndex >= this.cornerOffset && this.columnsTreeService) {
+            return this.columnsTreeService.isChildren(rowIndex, columnIndex - this.cornerOffset);
+        }
+        return this.cornerTreeService
+            ? this.cornerTreeService.isChildren(rowIndex, columnIndex)
+            : false;
+    }
+    /**
+     * 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, columnIndex) {
+        if (columnIndex >= this.cornerOffset && this.columnsTreeService) {
+            return this.columnsTreeService.hasChildren(rowIndex, columnIndex - this.cornerOffset);
+        }
+        return this.cornerTreeService
+            ? this.cornerTreeService.hasChildren(rowIndex, columnIndex)
+            : false;
+    }
+    getMainCellWidth(rowIndex, columnIndex, columnWidth, borderWidth, options = { offsetTop: -1, columnsOffset: 0 }) {
+        const columnsOffset = options.columnsOffset || this.cornerOffset;
+        if (columnIndex >= columnsOffset && this.columnsTreeService) {
+            return this.columnsTreeService.getMainCellWidth(rowIndex, columnIndex - columnsOffset, columnWidth, borderWidth, Object.assign(Object.assign({}, options), { columnsOffset }));
+        }
+        return this.cornerTreeService
+            ? this.cornerTreeService.getMainCellWidth(rowIndex, columnIndex, columnWidth, borderWidth, options)
+            : Number.NaN;
+    }
+    /**
+     * 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, columnIndex) {
+        if (columnIndex >= this.cornerOffset && this.columnsTreeService) {
+            return this.columnsTreeService.getMainCellSpans(rowIndex, columnIndex - this.cornerOffset);
+        }
+        return this.cornerTreeService
+            ? this.cornerTreeService.getMainCellSpans(rowIndex, columnIndex)
+            : {};
+    }
+    /**
+     * 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, isVertical) {
+        if (startIndex >= this.cornerOffset && this.columnsTreeService) {
+            return (this.cornerOffset +
+                this.columnsTreeService.alignStartIndex(startIndex - this.cornerOffset, isVertical));
+        }
+        return this.cornerTreeService
+            ? this.cornerTreeService.alignStartIndex(startIndex, isVertical)
+            : startIndex;
+    }
+    /**
+     * 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, isVertical) {
+        if (stopIndex >= this.cornerOffset && this.columnsTreeService) {
+            return (this.cornerOffset +
+                this.columnsTreeService.alignStopIndex(stopIndex - this.cornerOffset, isVertical));
+        }
+        return this.cornerTreeService
+            ? this.cornerTreeService.alignStopIndex(stopIndex, isVertical)
+            : stopIndex;
+    }
+    /**
+     * Returns number of last children for the tree
+     *
+     * @param {Array<TreeNode> | TreeNode} item - tree node or list of nodes
+     * @returns {number} - count of last children
+     */
+    getTreeChildLength(item) {
+        if (item) {
+            if (this.columnsTreeService) {
+                return this.columnsTreeService.getTreeChildLength(item);
+            }
+            return this.cornerTreeService ? this.cornerTreeService.getTreeChildLength(item) : 0;
+        }
+        const cornerLength = this.cornerTreeService ? this.cornerTreeService.getTreeChildLength() : 0;
+        const columnsLength = this.columnsTreeService
+            ? this.columnsTreeService.getTreeChildLength()
+            : 0;
+        return cornerLength + columnsLength;
+    }
+    /**
+     * Returns deep level of the tree
+     *
+     * @param {Array<TreeNode> | TreeNode} item - tree node or list of nodes
+     * @returns {number} - count of last children
+     */
+    getTreeDeepsLength(item) {
+        if (this.columnsTreeService) {
+            return this.columnsTreeService.getTreeDeepsLength(item);
+        }
+        return this.cornerTreeService ? this.cornerTreeService.getTreeDeepsLength(item) : 0;
+    }
+    /**
+     * Sets value node when it's single
+     *
+     * @param {TreeNode} valueNode - values measure node
+     * @returns {void}
+     */
+    setValueNode(valueNode) {
+        if (this.columnsTreeService) {
+            this.columnsTreeService.setValueNode(valueNode);
+        }
+    }
+    /**
+     * 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, columnIndex, options) {
+        if (columnIndex >= this.cornerOffset && this.columnsTreeService) {
+            return this.columnsTreeService.getMetadata(rowIndex, columnIndex - this.cornerOffset, options);
+            // eslint-disable-next-line max-lines
+        }
+        return this.cornerTreeService
+            ? this.cornerTreeService.getMetadata(rowIndex, columnIndex, options)
+            : undefined;
+    }
+    destroy() {
+        if (this.cornerTreeService) {
+            this.cornerTreeService.destroy();
+        }
+        if (this.columnsTreeService) {
+            this.columnsTreeService.destroy();
+        }
+        this.cornerTreeService = undefined;
+        this.columnsTreeService = undefined;
+    }
+    /**
+     * Returns array of last tree nodes
+     * Should not be called for header
+     *
+     * @returns {Array<TreeNode>} - list of tree nodes
+     * @deprecated
+     */
+    getLastLevelNodes() {
+        throw new Error(`"${this.constructor.name}.getLastLevelNodes" should not be called`);
+        // TODO review this
+        return this; // eslint-disable-line no-unreachable
+    }
+    /**
+     * Extract 2D array of data base on columnsTreeService
+     * Should not be called for header
+     *
+     * @param {TreeServiceI} columnsTreeService - tree service according to which align the data
+     * @returns {Array<Array<any>>} - 2D array of data
+     * @deprecated
+     */
+    extractData(columnsTreeService) {
+        throw new Error(`"${this.constructor.name}.extractData" should not be called`);
+        // TODO review this
+        return this || columnsTreeService; // eslint-disable-line no-unreachable
+    }
+    /**
+     * Adds additional tree node to current state
+     * Should not be called for header
+     *
+     * @param {TreeNode} tree - new treeNode
+     * @returns {void}
+     * @deprecated
+     */
+    extend(tree) {
+        throw new Error(`"${this.constructor.name}.extend" should not be called`);
+        // TODO review this
+        // return (this as unknown as void) || (tree as unknown as void); // eslint-disable-line no-unreachable
+    }
+    /**
+     * Returns part of current tree with possible cut nodes according to "from" - "to" position
+     * Should not be called for header
+     *
+     * @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
+     * @deprecated
+     */
+    getPartialTree(from, to, options) {
+        throw new Error(`"${this.constructor.name}.getPartialTree" should not be called`);
+        // TODO review this
+        return (this ||
+            from ||
+            to ||
+            options); // eslint-disable-line no-unreachable
+    }
+    /**
+     * Returns part of current grid according to "from" - "to" position
+     * Should not be called for header
+     *
+     * @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
+     * @deprecated
+     */
+    getPartialGrid(from, to) {
+        throw new Error(`"${this.constructor.name}.getPartialGrid" should not be called`);
+        // TODO review this
+        return (this ||
+            from ||
+            to); // eslint-disable-line no-unreachable
+    }
+}
+exports.HeaderTreeService = HeaderTreeService;
+exports.default = HeaderTreeService;

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

@@ -0,0 +1,104 @@
+import { TreeCellMapI, TreeNode } from './types.js';
+/**
+ * TreeCellMap keep mapping between grid cells and tree nodes
+ */
+export declare class TreeCellMap implements TreeCellMapI {
+    rowIndex: number;
+    colIndex: number;
+    node?: TreeNode;
+    parent?: string;
+    /**
+      @private */
+    childColCells: Array<TreeCellMapI>;
+    /**
+      @private */
+    childRowCells: Array<TreeCellMapI>;
+    /**
+      @private */
+    indexInParent: number;
+    /**
+      @private */
+    siblingCount: number;
+    constructor(rowIndex: number, colIndex: number, node?: TreeNode, parent?: string);
+    /**
+     * Defines if grid cell is child or main one
+     *
+     * @returns {boolean} - true - is children, false - main one
+     */
+    isChild(): boolean;
+    /**
+     * Defines if node has child row or column nodes or not
+     *
+     * @returns {boolean} - true - has children, false - does not have
+     */
+    hasChildren(): boolean;
+    /**
+     * Defines if node has child column nodes or not
+     *
+     * @returns {boolean} - true - has column children, false - does not have
+     */
+    hasColCell(): boolean;
+    /**
+     * Adds column children cell
+     *
+     * @param {TreeCellMapI} cell - column children
+     * @returns {void}
+     */
+    addColCell(cell: TreeCellMapI): void;
+    /**
+     * Returns list of column children
+     *
+     * @returns {Array<TreeCellMapI>} - list of column children
+     */
+    getColCell(): Array<TreeCellMapI>;
+    /**
+     * Defines if node has child row nodes or not
+     *
+     * @returns {boolean} - true - has row children, false - does not have
+     */
+    hasRowCell(): boolean;
+    /**
+     * Adds row children cell
+     *
+     * @param {TreeCellMapI} cell - row children
+     * @returns {void}
+     */
+    addRowCell(cell: TreeCellMapI): void;
+    /**
+     * Returns list of row children
+     *
+     * @returns {Array<TreeCellMapI>} - list of row children
+     */
+    getRowCell(): Array<TreeCellMapI>;
+    /**
+     * Returns row index of last merged cell
+     *
+     * @returns {number} - row index
+     */
+    getStopRowIndex(): number;
+    /**
+     * Returns column index of last merged cell
+     *
+     * @returns {number} - column index
+     */
+    getStopColIndex(): number;
+    /**
+     * Save index of node in parent child and total parent child count
+     *
+     * @param {number} indexInParent - index
+     * @param {number} siblingCount - child count
+     * @returns {void}
+     */
+    setIndexInParent(indexInParent: number, siblingCount: number): void;
+    /**
+     * Returns node index in parent and total parent child count
+     *
+     * @returns {{ indexInParent: number, siblingCount: number }} - index & count
+     */
+    getIndexInParent(): {
+        indexInParent: number;
+        siblingCount: number;
+    };
+    getParenPosition(): Array<number> | undefined;
+}
+export default TreeCellMap;

package/dist/cjs/tree-structure/TreeCellMap.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TreeCellMap = void 0;
+/**
+ * TreeCellMap keep mapping between grid cells and tree nodes
+ */
+class TreeCellMap {
+    constructor(rowIndex, colIndex, node, parent) {
+        /**
+          @private */
+        this.childColCells = [];
+        /**
+          @private */
+        this.childRowCells = [];
+        /**
+          @private */
+        this.indexInParent = -1;
+        /**
+          @private */
+        this.siblingCount = 0;
+        this.rowIndex = rowIndex;
+        this.colIndex = colIndex;
+        this.node = node;
+        this.parent = parent;
+    }
+    /**
+     * Defines if grid cell is child or main one
+     *
+     * @returns {boolean} - true - is children, false - main one
+     */
+    isChild() {
+        return !this.node;
+    }
+    /**
+     * Defines if node has child row or column nodes or not
+     *
+     * @returns {boolean} - true - has children, false - does not have
+     */
+    hasChildren() {
+        return !!(this.childColCells.length || this.childRowCells.length);
+    }
+    /**
+     * Defines if node has child column nodes or not
+     *
+     * @returns {boolean} - true - has column children, false - does not have
+     */
+    hasColCell() {
+        return this.childColCells.length > 0;
+    }
+    /**
+     * Adds column children cell
+     *
+     * @param {TreeCellMapI} cell - column children
+     * @returns {void}
+     */
+    addColCell(cell) {
+        this.childColCells.push(cell);
+    }
+    /**
+     * Returns list of column children
+     *
+     * @returns {Array<TreeCellMapI>} - list of column children
+     */
+    getColCell() {
+        return this.childColCells || [];
+    }
+    /**
+     * Defines if node has child row nodes or not
+     *
+     * @returns {boolean} - true - has row children, false - does not have
+     */
+    hasRowCell() {
+        return this.childRowCells.length > 0;
+    }
+    /**
+     * Adds row children cell
+     *
+     * @param {TreeCellMapI} cell - row children
+     * @returns {void}
+     */
+    addRowCell(cell) {
+        this.childRowCells.push(cell);
+    }
+    /**
+     * Returns list of row children
+     *
+     * @returns {Array<TreeCellMapI>} - list of row children
+     */
+    getRowCell() {
+        return this.childRowCells || [];
+    }
+    /**
+     * Returns row index of last merged cell
+     *
+     * @returns {number} - row index
+     */
+    getStopRowIndex() {
+        if (!this.hasRowCell()) {
+            return this.rowIndex;
+        }
+        return this.rowIndex + this.getRowCell().length;
+    }
+    /**
+     * Returns column index of last merged cell
+     *
+     * @returns {number} - column index
+     */
+    getStopColIndex() {
+        if (!this.hasColCell()) {
+            return this.colIndex;
+        }
+        return this.colIndex + this.getColCell().length;
+    }
+    /**
+     * Save index of node in parent child and total parent child count
+     *
+     * @param {number} indexInParent - index
+     * @param {number} siblingCount - child count
+     * @returns {void}
+     */
+    setIndexInParent(indexInParent, siblingCount) {
+        this.indexInParent = indexInParent;
+        this.siblingCount = siblingCount;
+    }
+    /**
+     * Returns node index in parent and total parent child count
+     *
+     * @returns {{ indexInParent: number, siblingCount: number }} - index & count
+     */
+    getIndexInParent() {
+        return {
+            indexInParent: this.indexInParent,
+            siblingCount: this.siblingCount,
+        };
+    }
+    getParenPosition() {
+        if (!this.parent) {
+            return undefined;
+        }
+        const res = (this.parent || '').match(/\d+/g) || [];
+        return [Number(res[0]), Number(res[1])];
+    }
+}
+exports.TreeCellMap = TreeCellMap;
+exports.default = TreeCellMap;