@sisense/sdk-pivot-query-client 2.17.0

package/dist/data-handling/utils/pivotTransforms.js

@@ -0,0 +1,335 @@
+import { treeNode } from '../../tree-structure/utils/index.js';
+import { ColorFormatType, PanelType, UserType } from '../constants.js';
+import createPivotTreeNode from './createPivotTreeNode.js';
+import * as jaqlProcessor from './jaqlProcessor.js';
+/**
+ * Helper for checking if tree has only one branch on all it's depth levels
+ *
+ * @param {TreeNode} root - tree root node
+ * @param {string} type - tree node type, rows | columns
+ * @returns {boolean} - boolean response
+ */
+function hasTreeMultipleBranches(root, type) {
+    if (!treeNode.hasChildren(root)) {
+        return false;
+    }
+    let forceTotals = false;
+    if (type === PanelType.COLUMNS && root && root.isPart) {
+        forceTotals = true;
+    }
+    const children = treeNode.getChildren(root);
+    if (children.length > 1 || forceTotals) {
+        return true;
+    }
+    const [singleChild] = children;
+    return hasTreeMultipleBranches(singleChild);
+}
+/**
+ * Helper for checking if node value is empty
+ *
+ * @param {*} value - node value
+ * @returns {boolean} - is empty flag
+ */
+function isEmptyValue(value) {
+    return value === null || value === undefined;
+}
+export const insertSubTotals = (items, originalData, type, jaql, // eslint-disable-line no-unused-vars
+subtotalsForSingleRow) => {
+    const result = [];
+    // eslint-disable-next-line sonarjs/cognitive-complexity
+    items.forEach((item) => {
+        // keep original item
+        result.push(item);
+        if (treeNode.hasChildren(item)) {
+            const newChildrenNodes = treeNode.getChildren(item);
+            const newChildren = insertSubTotals(newChildrenNodes, originalData, type, jaql, subtotalsForSingleRow);
+            treeNode.setChildren(item, newChildren);
+            // check if item has subtotal
+            let hasSubTotals = false;
+            if (subtotalsForSingleRow || hasTreeMultipleBranches(item, type)) {
+                if (type === PanelType.COLUMNS) {
+                    if (typeof item.index !== 'undefined' && item.index > -1) {
+                        hasSubTotals = true;
+                    }
+                }
+                else if (type === PanelType.ROWS) {
+                    if (typeof item.data !== 'undefined') {
+                        hasSubTotals = true;
+                    }
+                }
+            }
+            if (hasSubTotals) {
+                const { value, index, data, jaqlIndex, measurePath } = item;
+                let roughSubTotalItem;
+                if (type === PanelType.COLUMNS) {
+                    roughSubTotalItem = treeNode.create(value, undefined, undefined, index);
+                }
+                else if (type === PanelType.ROWS) {
+                    roughSubTotalItem = treeNode.create(value, undefined, data);
+                }
+                if (roughSubTotalItem) {
+                    const subTotalItem = createPivotTreeNode(roughSubTotalItem, type);
+                    subTotalItem.userType = UserType.SUB_TOTAL;
+                    subTotalItem.jaqlIndex = jaqlIndex;
+                    subTotalItem.measurePath = measurePath;
+                    subTotalItem.master = item;
+                    result.push(subTotalItem);
+                }
+            }
+        }
+    });
+    return result;
+};
+// eslint-disable-next-line no-unused-vars
+export const postProcessSubTotal = (item, jaql) => {
+    if (item.userType === UserType.SUB_TOTAL) {
+        if (item.master) {
+            item.measurePath = item.master.measurePath;
+        }
+    }
+};
+export const insertGrandTotals = (items, originalData, type, jaql) => {
+    const result = items;
+    if (type === PanelType.COLUMNS && originalData) {
+        const rootItem = createPivotTreeNode(originalData);
+        const hasGrandTotals = typeof rootItem.index === 'number';
+        if (hasGrandTotals) {
+            const valuesTree = jaqlProcessor.getMetadataTree(jaql, PanelType.MEASURES);
+            treeNode.getChildren(valuesTree).forEach((valueNode, i) => {
+                const roughGrandTotalItem = Object.assign(Object.assign({}, valueNode), { index: (rootItem.index || 0) + i });
+                const grandTotalItem = createPivotTreeNode(roughGrandTotalItem, type);
+                grandTotalItem.userType = UserType.GRAND_TOTAL;
+                // set measure jaqlIndex
+                grandTotalItem.measureJaqlIndex = grandTotalItem.jaqlIndex;
+                result.push(grandTotalItem);
+            });
+        }
+    }
+    return result;
+};
+// eslint-disable-next-line no-unused-vars
+export const postProcessGrandTotal = (item, jaql) => {
+    if (item.userType === UserType.GRAND_TOTAL) {
+        item.measurePath = undefined;
+        if (item.metadataType === PanelType.ROWS) {
+            item.parent = undefined;
+            item.jaqlIndex = 0;
+        }
+    }
+};
+export const insertMeasureNodes = (items, originalData, type, jaql) => {
+    let result = items;
+    if (type === PanelType.COLUMNS) {
+        const valuesTree = jaqlProcessor.getMetadataTree(jaql, PanelType.MEASURES);
+        const count = treeNode.getChildLength(valuesTree);
+        const columnsOptions = { maxLevel: 0 };
+        const columnsLastLevel = treeNode.getLastLevelNodes(result, [], 0, columnsOptions);
+        if (count > 1) {
+            // add values nodes at the last level
+            columnsLastLevel.forEach((lastNode) => {
+                if (lastNode.userType === UserType.GRAND_TOTAL) {
+                    return;
+                }
+                const lastChildren = treeNode.getChildren(valuesTree);
+                const lastFinalChildren = [];
+                for (let i = 0; i < lastChildren.length; i += 1) {
+                    if (typeof lastNode.maxChilds === 'number' && i >= lastNode.maxChilds) {
+                        // eslint-disable-next-line no-continue
+                        continue;
+                    }
+                    const roughMeasureItem = Object.assign(Object.assign({}, lastChildren[i]), { index: (lastNode.index || 0) + i, measurePath: lastNode.measurePath });
+                    const measureItem = createPivotTreeNode(roughMeasureItem, PanelType.MEASURES);
+                    measureItem.userType = UserType.MEASURE_BOTTOM;
+                    // set measure jaqlIndex
+                    measureItem.measureJaqlIndex = measureItem.jaqlIndex;
+                    lastFinalChildren.push(measureItem);
+                }
+                lastNode.minLevel = columnsOptions.maxLevel;
+                treeNode.setChildren(lastNode, lastFinalChildren);
+            });
+        }
+        else if (count === 1) {
+            // add value node at the first level
+            const valueNode = treeNode.getChildren(valuesTree)[0];
+            if (valueNode) {
+                const roughMeasureItem = Object.assign({}, valueNode);
+                const measureItem = createPivotTreeNode(roughMeasureItem, PanelType.MEASURES);
+                measureItem.userType = UserType.MEASURE_TOP;
+                treeNode.setChildren(measureItem, result);
+                result = [measureItem];
+                // set measure jaqlIndex
+                columnsLastLevel.forEach((lastNode) => {
+                    lastNode.measureJaqlIndex = valueNode.jaqlIndex;
+                });
+            }
+        }
+    }
+    return result;
+};
+export const postProcessMeasureNode = (item, jaql) => {
+    if (!treeNode.hasChildren(item) && typeof item.measureJaqlIndex !== 'undefined') {
+        jaqlProcessor.markSortedNode(jaql, item);
+    }
+};
+export const applyColorFormatting = (item, rowItem, columnItem, measurePanel) => {
+    let style = {};
+    if (rowItem.userType === UserType.SUB_TOTAL ||
+        rowItem.userType === UserType.GRAND_TOTAL ||
+        columnItem.userType === UserType.SUB_TOTAL ||
+        columnItem.userType === UserType.GRAND_TOTAL ||
+        (columnItem.parent && columnItem.parent.userType === UserType.SUB_TOTAL) ||
+        (columnItem.parent && columnItem.parent.userType === UserType.GRAND_TOTAL)) {
+        // ignore SUB_TOTAL & GRAND_TOTAL
+        return;
+    }
+    const colorFormat = (measurePanel && measurePanel.format && measurePanel.format.color) || null;
+    if (!colorFormat) {
+        return;
+    }
+    const { value, cf = -1 } = item;
+    if (colorFormat.type === ColorFormatType.COLOR) {
+        if (colorFormat.color && colorFormat.color !== 'transparent') {
+            style.backgroundColor = colorFormat.color;
+        }
+    }
+    if (colorFormat.type === ColorFormatType.CONDITION) {
+        if (colorFormat.conditions && colorFormat.conditions.length) {
+            for (let i = 0, c = colorFormat.conditions.length; i < c; i += 1) {
+                // handle empty value case
+                if (isEmptyValue(value)) {
+                    break;
+                }
+                // handle condition case
+                const conditions = colorFormat.conditions || [];
+                const { color } = conditions[i] || {};
+                if (color && cf === i) {
+                    style.backgroundColor = color;
+                    break;
+                }
+            }
+        }
+    }
+    if (Object.keys(style).length > 0) {
+        item.style = item.style || {};
+        Object.assign(item.style, style);
+    }
+    style = undefined;
+};
+/**
+ * Pre-process initial tree structure
+ *
+ * @param {Array<TreeNode>} items - items to normalize
+ * @param {string} type - items types to normalize
+ * @param {JaqlRequest} jaql - jaql request
+ * @param {object} options - additional options
+ * @param {number} [options.level=0] - tree level, for internal use only
+ * @param {object} [options.measurePath={}] - items types to normalize
+ * @returns {Array<PivotTreeNode>} - normalized list of items
+ */
+export const preProcessTree = (items, type, jaql, options) => {
+    const result = [];
+    const { level = 0, measurePath = {} } = options || {};
+    let finalItems;
+    if (Array.isArray(items)) {
+        finalItems = items;
+    }
+    else {
+        finalItems = treeNode.getChildren(items);
+    }
+    const panels = jaqlProcessor.getMetadataPanels(jaql, type);
+    const panel = panels[level];
+    const jaqlIndex = panel ? (panel.field || { index: Infinity }).index : undefined;
+    finalItems.forEach((item) => {
+        const pivotItem = createPivotTreeNode(item, type);
+        pivotItem.jaqlIndex = jaqlIndex;
+        if (typeof jaqlIndex !== 'undefined') {
+            pivotItem.measurePath = Object.assign(Object.assign({}, measurePath), { [jaqlIndex]: pivotItem.value });
+        }
+        // keep original item
+        result.push(pivotItem);
+        // check if item has children
+        if (treeNode.hasChildren(pivotItem)) {
+            const newChildrenNodes = treeNode.getChildren(pivotItem);
+            const childOptions = {
+                level: level + 1,
+                measurePath: pivotItem.measurePath,
+            };
+            const newChildren = preProcessTree(newChildrenNodes, type, jaql, childOptions);
+            treeNode.setChildren(pivotItem, newChildren);
+        }
+    });
+    return result;
+};
+/**
+ * Post-process final tree structure with formatting event
+ *
+ * @param {PivotTreeNode} items - list of PivotTreeNode items
+ * @param {JaqlRequest} jaql - jaql request
+ * @param {object} [options] - additional options
+ * @param {boolean} [options.skipFormatEvent] - process tree but skip format event trigger
+ * @param {boolean} [options.onlyFormatEvents] - process tree with format event trigger only
+ * @param {Function} [options.iterateFn] - iterate function to call for each tree node
+ * @param {Function} [options.emitFn] - transform event emit function to call for each tree node
+ * @returns {void}
+ */
+export const postProcessTree = (items, jaql, options) => {
+    const { skipFormatEvent = false, onlyFormatEvents = false, iterateFn, emitFn } = options || {};
+    items.forEach((item) => {
+        if (iterateFn) {
+            iterateFn(item);
+        }
+        if (skipFormatEvent || !onlyFormatEvents) {
+            postProcessSubTotal(item, jaql);
+            postProcessGrandTotal(item, jaql);
+            postProcessMeasureNode(item, jaql);
+        }
+        if (emitFn && (onlyFormatEvents || !skipFormatEvent)) {
+            const panel = jaqlProcessor.getMetadataPanelByIndex(jaql, item.jaqlIndex, item.metadataType || '');
+            emitFn(item, panel, jaql);
+        }
+        if (treeNode.hasChildren(item)) {
+            const itemChilds = treeNode.getChildren(item);
+            postProcessTree(itemChilds, jaql, options);
+        }
+    });
+};
+/**
+ * Modify tree structure for subtotals and grand totals and some customization
+ *
+ * @param {Array<PivotTreeNode>} items - base items to modify
+ * @param {string} type - items types to normalize
+ * @param {JaqlRequest} jaql - initial data object
+ * @param {object} [options] - modify options
+ * @param {TreeNode} [options.originalData] - initial data object
+ * @param {Function} [options.applyIndexDivergence] - helper for applying index divergence
+ * @returns {PivotTreeNode | Array<PivotTreeNode>} - normalized list of items
+ */
+const modifyTree = (items, type, jaql, options) => {
+    const { originalData, applyIndexDivergence, subtotalsForSingleRow } = options || {};
+    // items odd|even apply
+    if (applyIndexDivergence) {
+        applyIndexDivergence(items);
+    }
+    // insert subTotal
+    let modifiedItems = insertSubTotals(items, originalData, type, jaql, subtotalsForSingleRow);
+    // insert grandTotal
+    modifiedItems = insertGrandTotals(modifiedItems, originalData, type, jaql);
+    // measure nodes
+    modifiedItems = insertMeasureNodes(modifiedItems, originalData, type, jaql);
+    treeNode.iterateThroughTree(modifiedItems, (item, parent) => {
+        item.parent = parent;
+    });
+    return modifiedItems;
+};
+export default {
+    insertSubTotals,
+    postProcessSubTotal,
+    insertGrandTotals,
+    postProcessGrandTotal,
+    insertMeasureNodes,
+    postProcessMeasureNode,
+    applyColorFormatting,
+    preProcessTree,
+    modifyTree,
+    postProcessTree,
+};

package/dist/data-handling/utils/plugins/PluginService.d.ts

@@ -0,0 +1,135 @@
+import { JaqlRequest } from '../../../data-load/types.js';
+import { ListOfPanelTypes } from '../../constants.js';
+import { PivotTreeNode } from '../../types.js';
+import { CellItem, DimensionMetadata, GlobalStyles, MeasureMetadata, Metadata, PluginConfig } from './types.js';
+export declare class PluginService {
+    /**
+     * Handlers to apply for pivot cells
+     *
+     * @private
+     * */
+    plugins: Array<PluginConfig>;
+    /** @private global plugins config */
+    globalStyles?: GlobalStyles;
+    /** @private */
+    jaql: JaqlRequest;
+    /**
+     * Object to store indexes for data groups
+     */
+    private indexHelper;
+    /**
+     * Cache columns metadata after handling column tree node
+     *
+     * @private
+     * */
+    columnsMetadata: Array<{
+        metadata: Array<DimensionMetadata>;
+        type: Array<string>;
+    }>;
+    metadataCache: Map<string, Metadata>;
+    constructor(plugins: Array<any>, jaql: JaqlRequest, globalStyles?: GlobalStyles);
+    /**
+     * Get array of panels by type
+     *
+     * @param {ListOfPanelTypes} jaqlPanel - type of panels to return measures|columns|rows
+     * @returns {Array<any>} row level of measures in column tree
+     */
+    getJaqlPanels(jaqlPanel: ListOfPanelTypes): import("../../../data-load/types.js").JaqlPanel[];
+    /**
+     * Calculate level of measures in column tree
+     *
+     * @returns {number} row level of measures in column tree
+     */
+    getMeasuresLevel(): number;
+    /**
+     * Get count of row panels
+     *
+     * @returns {void}
+     */
+    getRowsColumnLength(): number;
+    /**
+     * Get count of row panels
+     *
+     * @param {Array<string>} types - array of types from current cell
+     * @returns {void}
+     */
+    getTotalTypes(types: Array<string>): Array<any>;
+    /**
+     * Calculate measure index and get panel metadata
+     *
+     * @param {number} index - measure index in row
+     * @returns {MeasureMetadata} measure metadata
+     */
+    getMeasureMetaByIndex(index: number): MeasureMetadata | undefined;
+    resetRowStartFrom(): void;
+    applyToColumns(columnTreeChildren: Array<PivotTreeNode>): void;
+    /**
+     * Apply plugins to columns values and cache metadata for measure handler
+     *
+     * @param {Array<any>} columnTreeChildren - measure index in row
+     * @param {object} indexes - measure index in row
+     * @returns {void}
+     */
+    private _applyToColumns;
+    /**
+     * Apply plugins to corner tree headers
+     *
+     * @param {any} cornerTree - measure index in row
+     * @returns {void}
+     */
+    applyToHeaders(cornerTree: PivotTreeNode): void;
+    applyToRows(rowTreeChildren: Array<PivotTreeNode>): void;
+    static getRowStartFromForPage(numberOfRows: number, numberOfMeasures: number, numberOfColumns: number): number;
+    /**
+     * Apply plugins to rows panels
+     *
+     * @param {Array<PivotTreeNode>} rowTreeChildren - measure index in row
+     * @returns {void}
+     */
+    private _applyToRows;
+    /**
+     * Apply plugins to value panels
+     *
+     * @param {Array<any>} values - measure index in row
+     * @param {object} rowData - row data
+     * @param {Array<string>} rowData.type - row types
+     * @param {Array<DimensionMetadata>} rowData.metadata - metadata of current row
+     * @param {object} indexes - parent indexes in tree
+     * @param {number} indexes.rowIndex - current row index
+     * @param {number} indexes.colIndex - colIndex of last row cell to calculate value cell index
+     * @returns {void}
+     */
+    applyToValues(values: Array<any>, rowData: {
+        type: Array<string>;
+        metadata: Array<DimensionMetadata>;
+    }, indexes: {
+        rowIndex: number;
+        colIndex: number;
+    }): void;
+    /**
+     * Add cell metadata to map for click/hover APIs
+     *
+     * @param {Metadata} metadata - cell metadata
+     * @param {CellItem} cellItem - cell content
+     * @param {number} rowIndex - cell row index
+     * @param {number} colIndex - cell column index
+     * @returns {void}
+     */
+    addToMetadata(metadata: Metadata, cellItem: CellItem, rowIndex: number, colIndex: number): void;
+    /**
+     * Apply global config to cells
+     *
+     * @param {CellItem} item - cell item to update by plugin
+     * @returns {void}
+     */
+    applyGlobal(item: CellItem): void;
+    /**
+     * Apply plugins to rows panels
+     *
+     * @param {Metadata} metadata - cell metadata
+     * @param {CellItem} item - cell item to update by plugin
+     * @returns {void}
+     */
+    apply(metadata: Metadata, item: CellItem): void;
+}
+export default PluginService;