@sisense/sdk-pivot-query-client 2.17.0

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

@@ -0,0 +1,534 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCutNodesByChildCount = exports.clearNodeCache = exports.getNodesByChildCount = exports.getDeepLength = exports.getChildLength = exports.getLastLevelNodes = exports.iterateThroughTree = exports.deepMerge = exports.merge = exports.wrapInRootNode = exports.getLevel = exports.setLevel = exports.setChildren = exports.getChildren = exports.hasChildren = exports.create = exports.ROOT = void 0;
+const index_js_1 = require("../../utils/index.js");
+class ChunksList extends Array {
+    constructor(items) {
+        super(...items);
+        Object.setPrototypeOf(this, Object.create(ChunksList.prototype));
+        this.isHandled = false;
+    }
+}
+exports.ROOT = '$*$root$*$';
+function create(value, children, data, index) {
+    const res = { value };
+    if (children) {
+        res.children = children;
+    }
+    if (data) {
+        res.data = data;
+    }
+    if (typeof index !== 'undefined') {
+        res.index = index;
+    }
+    return res;
+}
+exports.create = create;
+/**
+ * Defines if node has child nodes or not
+ *
+ * @param {TreeNode} node - tree node object
+ * @returns {boolean} - true - has children, false - last child
+ */
+function hasChildren(node) {
+    return !!(node && node.children && node.children.length);
+}
+exports.hasChildren = hasChildren;
+/**
+ * Returns list of child nodes
+ *
+ * @param {TreeNode} node - tree node object
+ * @returns {Array<TreeNode>|Array} - list of child nodes or empty array
+ */
+function getChildren(node) {
+    return (node && node.children) || [];
+}
+exports.getChildren = getChildren;
+/**
+ * Set new list of child nodes
+ *
+ * @param {TreeNode} node - tree node object
+ * @param {Array<TreeNode>} list - new list of child nodes
+ * @returns {void}
+ */
+function setChildren(node, list) {
+    if (node && list && Array.isArray(list)) {
+        node.children = list;
+    }
+}
+exports.setChildren = setChildren;
+/**
+ * Set node deep level in tree hierarchy
+ *
+ * @param {TreeNode} node - tree node object
+ * @param {number} level - hierarchy level
+ * @returns {void}
+ */
+function setLevel(node, level) {
+    if (node) {
+        node.level = level;
+    }
+}
+exports.setLevel = setLevel;
+/**
+ * Returns node deep level in tree hierarchy
+ *
+ * @param {TreeNode} node - tree node object
+ * @returns {number} hierarchy level
+ */
+function getLevel(node) {
+    if (node && typeof node.level !== 'undefined') {
+        return node.level || 0;
+    }
+    return -1;
+}
+exports.getLevel = getLevel;
+function wrapInRootNode(data) {
+    if (!data) {
+        return undefined;
+    }
+    if (data && !Array.isArray(data) && data.value === exports.ROOT) {
+        return data;
+    }
+    const node = { value: exports.ROOT, children: [] };
+    if (Array.isArray(data)) {
+        node.children = data;
+    }
+    else {
+        (node.children || [])[0] = data;
+    }
+    return node;
+}
+exports.wrapInRootNode = wrapInRootNode;
+function findNode(rootNode, checkCb, level = 0) {
+    let res;
+    if (!rootNode || !checkCb) {
+        return res;
+    }
+    if (checkCb(rootNode, level)) {
+        res = rootNode;
+    }
+    if (hasChildren(rootNode)) {
+        const children = getChildren(rootNode);
+        const childCount = children.length;
+        for (let i = 0; i < childCount; i += 1) {
+            const childRes = findNode(children[i], checkCb, level + 1);
+            if (childRes) {
+                res = childRes;
+                break;
+            }
+        }
+    }
+    return res;
+}
+/**
+ * Merge two root trees into one
+ *
+ * @param {TreeNode} [firstNode] - first tree
+ * @param {TreeNode} [secondNode] - second tree
+ * @returns {TreeNode} - merged tree
+ */
+function merge(firstNode, secondNode) {
+    if (!firstNode && !secondNode) {
+        return undefined;
+    }
+    if (!firstNode && secondNode) {
+        return wrapInRootNode(secondNode);
+    }
+    if (firstNode && !secondNode) {
+        return wrapInRootNode(firstNode);
+    }
+    const firstRootNode = wrapInRootNode(firstNode);
+    const secondRootNode = wrapInRootNode(secondNode);
+    const firstChildrens = (firstRootNode && firstRootNode.children) || [];
+    const secondChildrens = (secondRootNode && secondRootNode.children) || [];
+    const children = firstChildrens.concat(secondChildrens);
+    return wrapInRootNode(children);
+}
+exports.merge = merge;
+const findLastCut = (node, level = 0) => {
+    if (!node || !node.isPart) {
+        return undefined;
+    }
+    node.level = level;
+    const childs = getChildren(node);
+    const lastChild = childs[childs.length - 1];
+    if (!lastChild) {
+        return node;
+    }
+    const childCut = findLastCut(lastChild, level + 1);
+    return childCut || node;
+};
+const findFirstCut = (node, lastCut, level = 0) => {
+    if (!node || !node.isPart) {
+        return undefined;
+    }
+    node.level = level;
+    if (node && lastCut && node.value === lastCut.value && node.level === lastCut.level) {
+        return node;
+    }
+    const childs = getChildren(node);
+    const firstChild = childs[0];
+    if (!firstChild) {
+        return node;
+    }
+    const childCut = findFirstCut(firstChild, lastCut, level + 1);
+    return childCut || node;
+};
+/**
+ * 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
+ */
+function deepMerge(targetTree, sourceTree) {
+    /**
+     * The node to which we plan to add children
+     *
+     * @type {?TreeNode}
+     */
+    let targetNode = findLastCut(targetTree);
+    /**
+     * The node from where we plan to copy the children
+     *
+     * @type {?TreeNode}
+     */
+    let sourceNode = findFirstCut(sourceTree, targetNode);
+    // This long logical expression
+    // needed for the flow type checker
+    // to infer non nullable type
+    // of a nested `.children` property
+    // and I can't move it out to a function
+    if (targetNode &&
+        targetNode.children &&
+        Array.isArray(targetNode.children) &&
+        sourceNode &&
+        sourceNode.children &&
+        Array.isArray(sourceNode.children) &&
+        sourceNode.children.length > 0) {
+        targetNode.children = targetNode.children.concat(sourceNode.children);
+        sourceNode.isHandled = true;
+    }
+    let hasReachedFirstCutNode = false;
+    targetNode = targetTree;
+    sourceNode = sourceTree;
+    // This long logical expression
+    // needed for the flow type checker
+    // to infer non nullable type
+    // of a nested `.children` property
+    // and I can't move it out to a function
+    while (targetNode &&
+        targetNode.children &&
+        Array.isArray(targetNode.children) &&
+        sourceNode &&
+        sourceNode.children &&
+        Array.isArray(sourceNode.children) &&
+        !sourceNode.isHandled) {
+        const preservedTargetChildren = targetNode.children;
+        targetNode = targetNode.children[targetNode.children.length - 1];
+        let i = 0;
+        if (sourceNode.children[0] && !hasReachedFirstCutNode) {
+            hasReachedFirstCutNode = !getChildren(sourceNode.children[0]).some((obj) => obj.isPart);
+            i = 1;
+        }
+        while (i < sourceNode.children.length) {
+            preservedTargetChildren.push(sourceNode.children[i]);
+            i += 1;
+        }
+        // eslint-disable-next-line prefer-destructuring
+        sourceNode = sourceNode.children[0];
+    }
+    return targetTree;
+}
+exports.deepMerge = deepMerge;
+function iterateThroughTree(nodes, callback, parent) {
+    if (!nodes || !callback) {
+        return;
+    }
+    nodes.forEach((node) => {
+        callback(node, parent);
+        if (hasChildren(node)) {
+            iterateThroughTree(getChildren(node), callback, node);
+        }
+    });
+}
+exports.iterateThroughTree = iterateThroughTree;
+function getLastLevelNodes(nodes, lastLevelNodes = [], level = 0, options = { maxLevel: 0 }) {
+    nodes.forEach((item) => {
+        if (options.maxLevel < level) {
+            options.maxLevel = level;
+        }
+        if (hasChildren(item)) {
+            getLastLevelNodes(getChildren(item), lastLevelNodes, level + 1, options);
+        }
+        else {
+            lastLevelNodes.push(item);
+        }
+    });
+    return lastLevelNodes;
+}
+exports.getLastLevelNodes = getLastLevelNodes;
+/**
+ * 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
+ */
+function getChildLength(item, options = {}) {
+    if (!options) {
+        // eslint-disable-next-line no-param-reassign
+        options = {};
+    }
+    if (typeof options.callCount !== 'number') {
+        options.callCount = 1;
+    }
+    else {
+        options.callCount += 1;
+    }
+    if (!item) {
+        return 0;
+    }
+    let clearCache = options.clearCache || false;
+    if (!Array.isArray(item) && item.value === exports.ROOT) {
+        // do not use cache from 'root' node
+        clearCache = true;
+    }
+    let count = 1;
+    let children = [];
+    if (Array.isArray(item)) {
+        count = 0;
+        children = item;
+    }
+    else if (item.children) {
+        children = getChildren(item);
+    }
+    if (children && children.length) {
+        if (!clearCache && !Array.isArray(item) && typeof item.childCount === 'number') {
+            // get cached value
+            count = item.childCount;
+        }
+        else {
+            count = 0;
+            // recalculate new value
+            children.forEach((child) => {
+                count += getChildLength(child, options);
+            });
+            if (!Array.isArray(item)) {
+                // cache value
+                item.childCount = count;
+            }
+        }
+    }
+    return count;
+}
+exports.getChildLength = getChildLength;
+/**
+ * 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
+ */
+function getDeepLength(item, options = {}) {
+    if (!options) {
+        // eslint-disable-next-line no-param-reassign
+        options = {};
+    }
+    if (typeof options.callCount !== 'number') {
+        options.callCount = 1;
+    }
+    else {
+        options.callCount += 1;
+    }
+    if (!item) {
+        return 0;
+    }
+    let clearCache = options.clearCache || false;
+    if (!Array.isArray(item) && item.value === exports.ROOT) {
+        // do not use cache from 'root' node
+        clearCache = true;
+    }
+    let count = 0;
+    let children = [];
+    if (item && !Array.isArray(item) && typeof item.value !== 'undefined') {
+        count = 1;
+    }
+    if (Array.isArray(item)) {
+        count = 0;
+        children = item;
+    }
+    else if (item.children) {
+        children = getChildren(item);
+    }
+    if (children && children.length) {
+        if (!clearCache && !Array.isArray(item) && typeof item.childDeep === 'number') {
+            // get cached value
+            count += item.childDeep;
+        }
+        else {
+            let maxCount = 0;
+            children.forEach((child) => {
+                const childCount = getDeepLength(child, options);
+                if (childCount > maxCount) {
+                    maxCount = childCount;
+                }
+            });
+            count += maxCount;
+            if (!Array.isArray(item)) {
+                // cache value
+                item.childDeep = maxCount;
+            }
+        }
+    }
+    return count;
+}
+exports.getDeepLength = getDeepLength;
+/**
+ * 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
+ */
+function getNodesByChildCount(rootNodes = [], from = 0, to) {
+    const nodes = [];
+    let index = 0;
+    let startIndex = -1;
+    let stopIndex = -1;
+    const count = rootNodes.length;
+    if (typeof from === 'number' && typeof to === 'number' && from > to) {
+        throw new Error('Wrong "getNodesByChildCount" diapason');
+    }
+    if (typeof from === 'number' && from < 0) {
+        throw new Error('Wrong "from" index for "getNodesByChildCount"');
+    }
+    for (let i = 0; i < count; i += 1) {
+        const rootNode = rootNodes[i];
+        const childCount = getChildLength(rootNode);
+        // start index
+        if (index + childCount > from) {
+            if (startIndex < 0) {
+                startIndex = index;
+            }
+            nodes.push(rootNode);
+            // stop index
+            if (typeof to === 'number' && index + childCount >= to) {
+                stopIndex = index + childCount;
+                break;
+            }
+        }
+        stopIndex = index + childCount;
+        index += childCount;
+    }
+    return {
+        nodes,
+        start: startIndex,
+        stop: stopIndex,
+    };
+}
+exports.getNodesByChildCount = getNodesByChildCount;
+/**
+ * Clear tree node internal cache
+ *
+ * @param {TreeNode} node - node to clear
+ * @returns {void}
+ */
+function clearNodeCache(node) {
+    if (node.isMapped !== undefined) {
+        node.isMapped = undefined;
+    }
+    if (node.minLevel !== undefined) {
+        node.minLevel = undefined;
+    }
+    if (node.childCount !== undefined) {
+        node.childCount = undefined;
+    }
+    if (node.childDeep !== undefined) {
+        node.childDeep = undefined;
+    }
+}
+exports.clearNodeCache = clearNodeCache;
+/**
+ * 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
+ */
+function getCutNodesByChildCount(rootNodes = [], from = 0, to, options) {
+    const { cloneFn = index_js_1.cloneObject } = options || {};
+    const result = [];
+    const { nodes, start, stop } = getNodesByChildCount(rootNodes, from, to);
+    const count = nodes.length;
+    let firstItem;
+    let lastItem;
+    let handleLast = true;
+    if (start < from) {
+        const firstOriginalItem = nodes[0] || {};
+        const newFrom = from - start;
+        let newTo;
+        if (count === 1 && typeof to === 'number') {
+            newTo = to - start;
+            handleLast = false;
+        }
+        firstItem = cloneFn(firstOriginalItem, true);
+        const firstItemChilds = getCutNodesByChildCount(getChildren(firstOriginalItem), newFrom, newTo, options);
+        setChildren(firstItem, firstItemChilds);
+    }
+    if (typeof to === 'number' && stop > to && handleLast) {
+        const lastOriginalItem = nodes[count - 1] || {};
+        const newFrom = 0;
+        const newTo = getChildLength(lastOriginalItem) - (stop - to);
+        lastItem = cloneFn(lastOriginalItem, true);
+        const lastItemChilds = getCutNodesByChildCount(getChildren(lastOriginalItem), newFrom, newTo, options);
+        setChildren(lastItem, lastItemChilds);
+    }
+    nodes.forEach((node, index) => {
+        if (firstItem && index === 0) {
+            result.push(firstItem);
+        }
+        else if (lastItem && index === count - 1) {
+            result.push(lastItem);
+        }
+        else {
+            const clonedNode = cloneFn(node);
+            result.push(clonedNode);
+        }
+    });
+    return result;
+}
+exports.getCutNodesByChildCount = getCutNodesByChildCount;
+exports.default = {
+    ROOT: exports.ROOT,
+    create,
+    hasChildren,
+    getChildren,
+    setChildren,
+    setLevel,
+    getLevel,
+    getLastLevelNodes,
+    iterateThroughTree,
+    wrapInRootNode,
+    findNode,
+    merge,
+    deepMerge,
+    getChildLength,
+    getDeepLength,
+    getNodesByChildCount,
+    getCutNodesByChildCount,
+    clearNodeCache,
+};

package/dist/cjs/utils/array.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Helper for finding first element index from array that meets check condition
+ *
+ * @param {Array<any>} arr - target array
+ * @param {Function} check - check function
+ * @param {number} [startFrom=0] - index from which to start search
+ * @returns {number} - found element index
+ */
+export declare function findIndex(arr: Array<any>, check: Function, startFrom?: number): number;
+declare const _default: {
+    findIndex: typeof findIndex;
+};
+export default _default;

package/dist/cjs/utils/array.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findIndex = void 0;
+/**
+ * Helper for finding first element index from array that meets check condition
+ *
+ * @param {Array<any>} arr - target array
+ * @param {Function} check - check function
+ * @param {number} [startFrom=0] - index from which to start search
+ * @returns {number} - found element index
+ */
+function findIndex(arr, check, startFrom = 0) {
+    for (let i = startFrom; i < arr.length; i += 1) {
+        const value = arr[i];
+        const isFound = !!check(value, i, arr);
+        if (isFound) {
+            return i;
+        }
+    }
+    return -1;
+}
+exports.findIndex = findIndex;
+exports.default = {
+    findIndex,
+};

package/dist/cjs/utils/cloneObject.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Makes deep clone of the object with ability exclude some properties or include only specific ones
+ * (includeKeys && excludeKeys) - simple key name comparison
+ * (include && exclude) - with parent hierarchy support, example:
+ * 'property1.deep_property2.deep_property3'
+ * or for array:
+ * 'arrayProperty.0' and 'arrayProperty.$.deep_property'
+ *
+ * @param {any} obj - object to clone
+ * @param {object} [options] - additional behaviour options
+ * @param {Array<string>} [options.include] - list of include properties keys
+ * @param {Array<string>} [options.includeKeys] - list of include properties keys
+ * @param {Array<string>} [options.exclude] - list of exclude properties keys
+ * @param {Array<string>} [options.excludeKeys] - list of exclude properties keys
+ * @param {boolean} [options.excludeEmpty] - defines if empty objects should be copied or not
+ * @param {Array<any>} [options.referenceClone] - defines types which clone by reference
+ * @returns {any} - cloned object
+ */
+export declare function cloneObject(obj: any, options?: {
+    include?: Array<string> | undefined;
+    includeKeys?: Array<string> | undefined;
+    exclude?: Array<string> | undefined;
+    excludeKeys?: Array<string> | undefined;
+    excludeEmpty?: boolean;
+    referenceClone?: Array<any>;
+}): any;
+export declare namespace cloneObject {
+    var REFERENCE_CLONE_TYPES: (ErrorConstructor | DateConstructor | RegExpConstructor | PromiseConstructor)[];
+}
+export default cloneObject;