@sisense/sdk-pivot-query-client 2.17.0

package/dist/cjs/utils/cloneObject.js

@@ -0,0 +1,225 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cloneObject = void 0;
+const REFERENCE_CLONE_TYPES = [Date, Error, RegExp, Promise];
+function isReferenceClone(obj, types = REFERENCE_CLONE_TYPES) {
+    return types.some((type) => obj instanceof type);
+}
+function hasMatchedItems(searchList, queryList = []) {
+    let res = false;
+    queryList.forEach((query) => {
+        if (searchList.includes(query)) {
+            res = true;
+        }
+    });
+    return res;
+}
+function getParentKeys(
+// eslint-disable-next-line @typescript-eslint/default-param-last
+parentKeys = [], key, isArray) {
+    const res = [];
+    if (isArray) {
+        parentKeys.forEach((parentKey) => {
+            res.push(`${parentKey}.$`);
+        });
+    }
+    if (parentKeys.length) {
+        parentKeys.forEach((parentKey) => {
+            res.push(`${parentKey}.${key}`);
+        });
+    }
+    else {
+        res.push(key);
+    }
+    return res;
+}
+function isObject(obj) {
+    return !(obj === null || typeof obj === 'undefined' || typeof obj !== 'object');
+}
+function isEmpty(value, excludeTypes) {
+    if (isObject(value) && value) {
+        if (Array.isArray(value)) {
+            return !value.length;
+        }
+        if (isReferenceClone(value, excludeTypes)) {
+            return false;
+        }
+        return !Object.keys(value).length;
+    }
+    if (value === undefined || value === null) {
+        return true;
+    }
+    return false;
+}
+function removeLastChildKey(key = '') {
+    const parts = key.split('.');
+    if (parts.length > 1) {
+        parts.pop();
+        return parts.join('.');
+    }
+    return parts[0];
+}
+function shouldBeIncluded(includeKeys, excludeKeys, keysWithParent) {
+    if (includeKeys.length) {
+        return hasMatchedItems(includeKeys, keysWithParent);
+    }
+    if (excludeKeys.length) {
+        return !hasMatchedItems(excludeKeys, keysWithParent);
+    }
+    return true;
+}
+function updateIncludeExcludeKeys(obj, include = [], exclude = [], parentKeys = [], includeKeys = {}, excludeKeys = {}, references = [], cachedResults = []) {
+    if (!isObject(obj)) {
+        return {
+            commonIncludeKeys: [],
+            commonExcludeKeys: [],
+        };
+    }
+    const index = references.indexOf(obj);
+    if (index !== -1) {
+        return cachedResults[index];
+    }
+    references.push(obj);
+    const keys = Object.keys(obj);
+    const isArray = Array.isArray(obj);
+    let commonIncludeKeys = [];
+    let commonExcludeKeys = [];
+    const childCommonIncludeKeys = [];
+    const childCommonExcludeKeys = [];
+    keys.forEach((key) => {
+        const value = obj[key];
+        const keysWithParent = getParentKeys(parentKeys, key, isArray);
+        const baseKeysWithParent = parentKeys[0] || '&';
+        includeKeys[baseKeysWithParent] = includeKeys[baseKeysWithParent] || [];
+        excludeKeys[baseKeysWithParent] = excludeKeys[baseKeysWithParent] || [];
+        keysWithParent.forEach((keyWithParent) => {
+            if ((include || []).includes(keyWithParent)) {
+                includeKeys[baseKeysWithParent].push(keyWithParent);
+                commonIncludeKeys.push(keyWithParent);
+            }
+            // push inserrt keys to parent in case property does not exist at all
+            (include || []).forEach((includeKey) => {
+                const includeKeyParent = removeLastChildKey(includeKey);
+                if (`${includeKeyParent}.$` === baseKeysWithParent ||
+                    includeKeyParent === baseKeysWithParent) {
+                    if (!includeKeys[baseKeysWithParent].includes(includeKey)) {
+                        includeKeys[baseKeysWithParent].push(includeKey);
+                    }
+                    if (!commonIncludeKeys.includes(includeKey)) {
+                        commonIncludeKeys.push(includeKey);
+                    }
+                }
+            });
+            if ((exclude || []).includes(keyWithParent)) {
+                excludeKeys[baseKeysWithParent].push(keyWithParent);
+                commonExcludeKeys.push(keyWithParent);
+            }
+        });
+        if (isObject(value)) {
+            updateIncludeExcludeKeys(value, include, exclude, keysWithParent, includeKeys, excludeKeys, references, cachedResults);
+        }
+    });
+    if (isObject(obj)) {
+        let baseArrayKeysWithParent = parentKeys[0] || '&';
+        if (Array.isArray(obj)) {
+            baseArrayKeysWithParent = `${baseArrayKeysWithParent}.$`;
+        }
+        includeKeys[baseArrayKeysWithParent] = (includeKeys[baseArrayKeysWithParent] || []).concat(childCommonIncludeKeys);
+        commonIncludeKeys = commonIncludeKeys.concat(childCommonIncludeKeys);
+        excludeKeys[baseArrayKeysWithParent] = (excludeKeys[baseArrayKeysWithParent] || []).concat(childCommonExcludeKeys);
+        commonExcludeKeys = commonIncludeKeys.concat(childCommonExcludeKeys);
+    }
+    cachedResults.push({
+        commonIncludeKeys,
+        commonExcludeKeys,
+    });
+    return {
+        commonIncludeKeys,
+        commonExcludeKeys,
+    };
+}
+function applyIncludeExclude(obj, options, references = new WeakMap()) {
+    const { includeKeys, includeKeysObj, excludeKeys, excludeKeysObj, parentKeys = [], excludeEmpty, referenceClone, } = options || {};
+    if (!isObject(obj) || isReferenceClone(obj, referenceClone)) {
+        return obj;
+    }
+    if (references.has(obj)) {
+        return references.get(obj);
+    }
+    const keys = Object.keys(obj);
+    const isArray = Array.isArray(obj);
+    const res = isArray ? [] : {};
+    references.set(obj, res);
+    const parentKey = parentKeys[0] || '&';
+    const curIncludeKeys = (includeKeysObj || {})[parentKey] || [];
+    const curExcludeKeys = (excludeKeysObj || {})[parentKey] || [];
+    keys.forEach((key) => {
+        const value = obj[key];
+        let keysWithParent = [];
+        let shouldBeAdded = true;
+        if (includeKeys || excludeKeys) {
+            shouldBeAdded = shouldBeIncluded(includeKeys || [], excludeKeys || [], [key]);
+        }
+        else if (includeKeysObj || excludeKeysObj) {
+            keysWithParent = getParentKeys(parentKeys, key, isArray);
+            shouldBeAdded = shouldBeIncluded(curIncludeKeys, curExcludeKeys, keysWithParent);
+        }
+        if (shouldBeAdded) {
+            const clonedValue = applyIncludeExclude(value, Object.assign(Object.assign({}, options), { parentKeys: keysWithParent }), references);
+            if (!excludeEmpty || !isEmpty(clonedValue, referenceClone)) {
+                if (isArray) {
+                    res.push(clonedValue);
+                }
+                else {
+                    res[key] = clonedValue;
+                }
+            }
+        }
+    });
+    return res;
+}
+/**
+ * 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
+ */
+function cloneObject(obj, options) {
+    const _a = options || {}, { include, exclude } = _a, restOptions = __rest(_a, ["include", "exclude"]);
+    let includeKeysObj;
+    let excludeKeysObj;
+    if (include || exclude) {
+        includeKeysObj = {};
+        excludeKeysObj = {};
+        updateIncludeExcludeKeys(obj, include, exclude, [], includeKeysObj, excludeKeysObj);
+    }
+    const applyOptions = Object.assign(Object.assign({}, restOptions), { includeKeysObj,
+        excludeKeysObj });
+    return applyIncludeExclude(obj, applyOptions);
+}
+exports.cloneObject = cloneObject;
+cloneObject.REFERENCE_CLONE_TYPES = REFERENCE_CLONE_TYPES;
+exports.default = cloneObject;

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

@@ -0,0 +1,3 @@
+export { cloneObject } from './cloneObject.js';
+export { findIndex } from './array.js';
+export { throttle } from './throttle.js';

package/dist/cjs/utils/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.throttle = exports.findIndex = exports.cloneObject = void 0;
+var cloneObject_js_1 = require("./cloneObject.js");
+Object.defineProperty(exports, "cloneObject", { enumerable: true, get: function () { return cloneObject_js_1.cloneObject; } });
+var array_js_1 = require("./array.js");
+Object.defineProperty(exports, "findIndex", { enumerable: true, get: function () { return array_js_1.findIndex; } });
+var throttle_js_1 = require("./throttle.js");
+Object.defineProperty(exports, "throttle", { enumerable: true, get: function () { return throttle_js_1.throttle; } });

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

@@ -0,0 +1,12 @@
+/**
+ * Prevent too frequent function calling in time limit
+ *
+ * @param {Function} func - function to execute
+ * @param {number} limit - time interval in which function should be called only once
+ * @returns {Function} - throttled function
+ */
+export declare const throttle: (func: Function, limit: number) => {
+    (...args: Array<any>): void;
+    cancel(): void;
+};
+export default throttle;

package/dist/cjs/utils/throttle.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.throttle = void 0;
+/**
+ * Prevent too frequent function calling in time limit
+ *
+ * @param {Function} func - function to execute
+ * @param {number} limit - time interval in which function should be called only once
+ * @returns {Function} - throttled function
+ */
+const throttle = (func, limit) => {
+    let inThrottle;
+    let activeTimerID;
+    let lastCallArgs = null;
+    const resultFn = (...args) => {
+        if (inThrottle) {
+            lastCallArgs = args;
+        }
+        else {
+            func(...args);
+            inThrottle = true;
+            lastCallArgs = null;
+            activeTimerID = setTimeout(() => {
+                inThrottle = false;
+                if (lastCallArgs) {
+                    func(...lastCallArgs);
+                    lastCallArgs = null;
+                }
+            }, limit);
+        }
+    };
+    resultFn.cancel = () => {
+        clearTimeout(activeTimerID);
+        inThrottle = false;
+    };
+    return resultFn;
+};
+exports.throttle = throttle;
+exports.default = exports.throttle;

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

@@ -0,0 +1,12 @@
+export declare type Defer = {
+    promise: Promise<any>;
+    resolve: Function;
+    reject: Function;
+};
+declare type CSSProperties = Record<string, string | number | null | undefined>;
+export declare type InputStyles<P = CSSProperties> = P & {
+    databarColor?: string;
+};
+export declare type Styles<P = CSSProperties> = P;
+export declare type CloneFn = <T>(obj: T, skipChildren?: boolean) => T;
+export {};

package/dist/cjs/utils/types.js

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