@sisense/sdk-pivot-query-client 2.17.0

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

@@ -0,0 +1,8 @@
+import { AbstractTreeService } from './AbstractTreeService.js';
+/**
+ * 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 TreeService extends AbstractTreeService {
+}
+export default TreeService;

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

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TreeService = void 0;
+const AbstractTreeService_js_1 = require("./AbstractTreeService.js");
+/**
+ * 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)
+ */
+class TreeService extends AbstractTreeService_js_1.AbstractTreeService {
+}
+exports.TreeService = TreeService;
+exports.default = TreeService;

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

@@ -0,0 +1,6 @@
+export declare const Position: {
+    FIRST: string;
+    LAST: string;
+    EVEN: string;
+    ODD: string;
+};

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

@@ -0,0 +1,10 @@
+"use strict";
+/* eslint-disable import/prefer-default-export */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Position = void 0;
+exports.Position = {
+    FIRST: 'first',
+    LAST: 'last',
+    EVEN: 'even',
+    ODD: 'odd',
+};

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

@@ -0,0 +1,5 @@
+export { TreeCellMap } from './TreeCellMap.js';
+export { TreeService } from './TreeService.js';
+export { HeaderTreeService } from './HeaderTreeService.js';
+export { type TreeServiceI } from './types.js';
+export { type TreeNode } from './types.js';

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

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HeaderTreeService = exports.TreeService = exports.TreeCellMap = void 0;
+/* eslint-disable import/prefer-default-export */
+var TreeCellMap_js_1 = require("./TreeCellMap.js");
+Object.defineProperty(exports, "TreeCellMap", { enumerable: true, get: function () { return TreeCellMap_js_1.TreeCellMap; } });
+var TreeService_js_1 = require("./TreeService.js");
+Object.defineProperty(exports, "TreeService", { enumerable: true, get: function () { return TreeService_js_1.TreeService; } });
+var HeaderTreeService_js_1 = require("./HeaderTreeService.js");
+Object.defineProperty(exports, "HeaderTreeService", { enumerable: true, get: function () { return HeaderTreeService_js_1.HeaderTreeService; } });

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

@@ -0,0 +1,93 @@
+import { CloneFn, InputStyles } from '../utils/types.js';
+export declare type TreeNode = {
+    value?: string;
+    content?: string;
+    style?: InputStyles;
+    cf?: number;
+    children?: Array<TreeNode>;
+    data?: Array<any>;
+    index?: number;
+    indexDivergence?: number;
+    size?: number;
+    isPart?: boolean;
+    maxChilds?: number;
+    level?: number;
+    minLevel?: number;
+    isMapped?: boolean;
+    childCount?: number;
+    childDeep?: number;
+    store?: {
+        [key: string]: any;
+    };
+    isHandled?: boolean;
+};
+export declare type ColumnsCount = {
+    totalColumnsCount: number;
+    columnsCount: number;
+};
+export declare type HeaderTreeNode = TreeNode & {
+    totalColumnsCount?: number;
+    columnsCount?: number;
+};
+export declare type TreeNodeMetadata = {
+    levels: Array<string>;
+    siblings: Array<string>;
+    root?: TreeNodeMetadata;
+    parent?: TreeNodeMetadata;
+    valueNode?: TreeNode;
+    nextNode?: any;
+};
+export interface TreeServiceI {
+    hasGrandTotals: boolean;
+    getGrid(): Array<Array<TreeNode | string>>;
+    getTreeNode(rowIndex: number, columnIndex: number): TreeNode | undefined;
+    isChildren(rowIndex: number, columnIndex: number): boolean;
+    hasChildren(rowIndex: number, columnIndex: number): boolean;
+    getMainCellSpans(rowIndex: number, columnIndex: number): {
+        colSpan?: number;
+        rowSpan?: number;
+    };
+    alignStartIndex(startIndex: number, isVertical?: boolean): number;
+    alignStopIndex(stopIndex: number, isVertical?: boolean): number;
+    getTreeChildLength(item?: Array<TreeNode> | TreeNode): number;
+    getTreeDeepsLength(item?: Array<TreeNode> | TreeNode): number;
+    getLastLevelNodes(): Array<TreeNode>;
+    extractData(columnsTreeService?: TreeServiceI): Array<Array<any>>;
+    setValueNode(valueNode: TreeNode): void;
+    getMetadata(rowIndex: number, columnIndex: number, options?: {
+        from: number;
+        to: number;
+    }): TreeNodeMetadata | undefined;
+    extend(tree?: TreeNode): void;
+    getPartialTree(from: number, to?: number, options?: {
+        cloneFn?: CloneFn;
+    }): Array<TreeNode>;
+    getPartialGrid(from: number, to: number): Array<Array<TreeNode | string>>;
+    getMainCellWidth(rowIndex: number, columnIndex: number, columnWidth: Function, borderWidth: number, options?: {
+        offsetTop?: number;
+        columnsOffset?: number;
+    }): number;
+    destroy(): void;
+}
+export interface TreeCellMapI {
+    rowIndex: number;
+    colIndex: number;
+    node?: TreeNode;
+    parent?: string;
+    isChild(): boolean;
+    hasChildren(): boolean;
+    hasColCell(): boolean;
+    addColCell(cell: TreeCellMapI): void;
+    getColCell(): Array<TreeCellMapI>;
+    hasRowCell(): boolean;
+    addRowCell(cell: TreeCellMapI): void;
+    getRowCell(): Array<TreeCellMapI>;
+    getStopRowIndex(): number;
+    getStopColIndex(): number;
+    setIndexInParent(indexInParent: number, siblingCount: number): void;
+    getIndexInParent(): {
+        indexInParent: number;
+        siblingCount: number;
+    };
+    getParenPosition(): Array<number> | undefined;
+}

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/tree-structure/utils/index.d.ts

@@ -0,0 +1 @@
+export { default as treeNode, ROOT as default } from './treeNode.js';

package/dist/cjs/tree-structure/utils/index.js

@@ -0,0 +1,9 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = exports.treeNode = void 0;
+var treeNode_js_1 = require("./treeNode.js");
+Object.defineProperty(exports, "treeNode", { enumerable: true, get: function () { return __importDefault(treeNode_js_1).default; } });
+Object.defineProperty(exports, "default", { enumerable: true, get: function () { return treeNode_js_1.ROOT; } });

package/dist/cjs/tree-structure/utils/treeNode.d.ts

@@ -0,0 +1,147 @@
+import { CloneFn } from '../../utils/types.js';
+import { TreeNode } from '../types.js';
+export declare const ROOT = "$*$root$*$";
+export declare function create(value?: string, children?: Array<TreeNode>, data?: Array<any>, index?: number): TreeNode;
+/**
+ * Defines if node has child nodes or not
+ *
+ * @param {TreeNode} node - tree node object
+ * @returns {boolean} - true - has children, false - last child
+ */
+export declare function hasChildren(node?: TreeNode): boolean;
+/**
+ * Returns list of child nodes
+ *
+ * @param {TreeNode} node - tree node object
+ * @returns {Array<TreeNode>|Array} - list of child nodes or empty array
+ */
+export declare function getChildren(node?: TreeNode): Array<TreeNode>;
+/**
+ * Set new list of child nodes
+ *
+ * @param {TreeNode} node - tree node object
+ * @param {Array<TreeNode>} list - new list of child nodes
+ * @returns {void}
+ */
+export declare function setChildren(node?: TreeNode, list?: Array<TreeNode>): void;
+/**
+ * Set node deep level in tree hierarchy
+ *
+ * @param {TreeNode} node - tree node object
+ * @param {number} level - hierarchy level
+ * @returns {void}
+ */
+export declare function setLevel(node: TreeNode | undefined, level: number): void;
+/**
+ * Returns node deep level in tree hierarchy
+ *
+ * @param {TreeNode} node - tree node object
+ * @returns {number} hierarchy level
+ */
+export declare function getLevel(node?: TreeNode): number;
+export declare function wrapInRootNode(data?: TreeNode | Array<TreeNode>): TreeNode | undefined;
+declare function findNode(rootNode?: TreeNode, checkCb?: Function, level?: number): TreeNode | undefined;
+/**
+ * Merge two root trees into one
+ *
+ * @param {TreeNode} [firstNode] - first tree
+ * @param {TreeNode} [secondNode] - second tree
+ * @returns {TreeNode} - merged tree
+ */
+export declare function merge(firstNode?: TreeNode, secondNode?: TreeNode): TreeNode | undefined;
+/**
+ * Merging two partial pivot trees into one (mutate first argument).
+ *
+ * @param {TreeNode} targetTree - main part of pivot table model (looks like 'tree' data structure)
+ * @param {TreeNode} sourceTree - part of pivot table model (looks like 'tree' data structure) which
+ *  we want merge in main part
+ * @returns {TreeNode} - merged tree
+ */
+export declare function deepMerge(targetTree?: TreeNode, sourceTree?: TreeNode): TreeNode | undefined;
+export declare function iterateThroughTree(nodes?: Array<TreeNode>, callback?: (item: Record<string, any>, parent?: Record<string, any>) => void, parent?: Record<string, any>): void;
+export declare function getLastLevelNodes(nodes: Array<TreeNode>, lastLevelNodes?: Array<TreeNode>, level?: number, options?: {
+    maxLevel: number;
+}): Array<TreeNode>;
+/**
+ * Returns number of last children for the tree
+ *
+ * @param {Array<TreeNode> | TreeNode} item - tree node or list of nodes
+ * @param {object} options - additional options
+ * @param {number} options.callCount - inner state for recursive calls count
+ * @param {boolean} options.clearCache - define if use cached value or recalculate new one
+ * @returns {number} - count of last children
+ */
+export declare function getChildLength(item?: TreeNode[] | TreeNode, options?: {
+    callCount?: number;
+    clearCache?: boolean;
+}): number;
+/**
+ * Returns deep level of the tree
+ *
+ * @param {Array<TreeNode> | TreeNode} item - tree node or list of nodes
+ * @param {object} options - additional options
+ * @param {number} options.callCount - inner state for recursive calls count
+ * @param {boolean} options.clearCache - define if use cached value or recalculate new one
+ * @returns {number} - count of last children
+ */
+export declare function getDeepLength(item?: TreeNode[] | TreeNode, options?: {
+    callCount?: number;
+    clearCache?: boolean;
+}): number;
+/**
+ * Returns part of tree nodes list according to children indexes "from" - "to"
+ * return result is not strict, and start/stop in returns object show returned node position
+ *
+ * @param {Array<TreeNode>} rootNodes - list of nodes
+ * @param {number} [from=0] - start index to for partial tree
+ * @param {number} [to] - end index for partial tree
+ * @returns {{nodes: Array<TreeNode>, start: number, stop: number}} - partial tree nodes and
+ * start/stop indexes of it in scope of initial list
+ */
+export declare function getNodesByChildCount(rootNodes?: Array<TreeNode>, from?: number, to?: number): {
+    nodes: Array<TreeNode>;
+    start: number;
+    stop: number;
+};
+/**
+ * Clear tree node internal cache
+ *
+ * @param {TreeNode} node - node to clear
+ * @returns {void}
+ */
+export declare function clearNodeCache(node: TreeNode): void;
+/**
+ * Returns cut cloned part of tree nodes list according to children indexes "from" - "to"
+ *
+ * @param {Array<TreeNode>} rootNodes - list of nodes
+ * @param {number} [from=0] - start index to for cut tree
+ * @param {number} [to] - end index for cut tree
+ * @param {object} [options] - additional options
+ * @param {Array<string>} [options.cloneIncludeKeys] - clone node include keys
+ * @param {Array<string>} [options.cloneExcludeKeys] - clone node exclude keys
+ * @returns {Array<TreeNode>} - cut cloned list of nodes
+ */
+export declare function getCutNodesByChildCount(rootNodes?: Array<TreeNode>, from?: number, to?: number, options?: {
+    cloneFn?: CloneFn;
+}): Array<TreeNode>;
+declare const _default: {
+    ROOT: string;
+    create: typeof create;
+    hasChildren: typeof hasChildren;
+    getChildren: typeof getChildren;
+    setChildren: typeof setChildren;
+    setLevel: typeof setLevel;
+    getLevel: typeof getLevel;
+    getLastLevelNodes: typeof getLastLevelNodes;
+    iterateThroughTree: typeof iterateThroughTree;
+    wrapInRootNode: typeof wrapInRootNode;
+    findNode: typeof findNode;
+    merge: typeof merge;
+    deepMerge: typeof deepMerge;
+    getChildLength: typeof getChildLength;
+    getDeepLength: typeof getDeepLength;
+    getNodesByChildCount: typeof getNodesByChildCount;
+    getCutNodesByChildCount: typeof getCutNodesByChildCount;
+    clearNodeCache: typeof clearNodeCache;
+};
+export default _default;