@sisense/sdk-pivot-query-client 2.17.0

package/dist/data-handling/utils/plugins/PluginService.js

@@ -0,0 +1,379 @@
+import { PanelType, PluginsTypesFields } from '../../constants.js';
+import { getDimensionMetadata, getMeasureMetadata } from './getters.js';
+import { validate } from './validator.js';
+/**
+ * Removes not related styles from cell styles object,
+ * borders for example are not configured on cell level
+ *
+ * @param {object} style - removes border related styles from cell styles
+ * @returns {object} - clear styles
+ */
+const clearGlobal = (style) => {
+    const clone = {};
+    Object.keys(style).forEach((key) => {
+        // remove specific styles from cell
+        if (!key.startsWith('border') || key === 'borderColor') {
+            // @ts-ignore
+            clone[key] = style[key];
+        }
+    });
+    return clone;
+};
+const DEFAULT_CONTENT_TYPE = 'text';
+export class PluginService {
+    constructor(plugins, jaql, globalStyles) {
+        /**
+         * Handlers to apply for pivot cells
+         *
+         * @private
+         * */
+        this.plugins = [];
+        /**
+         * Cache columns metadata after handling column tree node
+         *
+         * @private
+         * */
+        this.columnsMetadata = [];
+        this.metadataCache = new Map();
+        this.plugins = plugins;
+        this.jaql = jaql;
+        this.globalStyles = globalStyles;
+        this.indexHelper = {
+            measuresLevel: this.getMeasuresLevel(),
+            columnStartFrom: 0,
+            rowStartFrom: 0,
+        };
+        if (this.globalStyles) {
+            this.globalStyles = clearGlobal(this.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) {
+        if (!this.jaql) {
+            throw new Error('No Jaql in Plugin service!');
+        }
+        return this.jaql.metadata.filter((el) => el.panel === jaqlPanel);
+    }
+    /**
+     * Calculate level of measures in column tree
+     *
+     * @returns {number} row level of measures in column tree
+     */
+    getMeasuresLevel() {
+        const columnPanels = this.getJaqlPanels(PanelType.COLUMNS);
+        const measurePanels = this.getJaqlPanels(PanelType.MEASURES);
+        return measurePanels.length > 1 ? columnPanels.length : 0;
+    }
+    /**
+     * Get count of row panels
+     *
+     * @returns {void}
+     */
+    getRowsColumnLength() {
+        const rowsPanels = this.getJaqlPanels(PanelType.ROWS);
+        return rowsPanels.length;
+    }
+    /**
+     * Get count of row panels
+     *
+     * @param {Array<string>} types - array of types from current cell
+     * @returns {void}
+     */
+    // eslint-disable-next-line class-methods-use-this
+    getTotalTypes(types) {
+        const totalTypes = types.filter((el) => el === PluginsTypesFields.SUB_TOTAL || el === PluginsTypesFields.GRAND_TOTAL);
+        // make array of unique types
+        if (totalTypes && totalTypes.length) {
+            return totalTypes.filter((value, index, self) => self.indexOf(value) === index);
+        }
+        return [];
+    }
+    /**
+     * Calculate measure index and get panel metadata
+     *
+     * @param {number} index - measure index in row
+     * @returns {MeasureMetadata} measure metadata
+     */
+    getMeasureMetaByIndex(index) {
+        const measurePanels = this.getJaqlPanels(PanelType.MEASURES);
+        if (measurePanels.length === 1) {
+            return getMeasureMetadata(measurePanels[0]);
+        }
+        const measureIndex = index % measurePanels.length;
+        return getMeasureMetadata(measurePanels[measureIndex]);
+    }
+    resetRowStartFrom() {
+        this.indexHelper.rowStartFrom = 1;
+    }
+    applyToColumns(columnTreeChildren) {
+        if (columnTreeChildren.length === 0) {
+            return;
+        }
+        if (this.indexHelper.columnStartFrom === 0) {
+            this.indexHelper.columnStartFrom = this.getRowsColumnLength();
+        }
+        this._applyToColumns(columnTreeChildren, { row: -1 });
+    }
+    /**
+     * 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}
+     */
+    _applyToColumns(columnTreeChildren, indexes) {
+        columnTreeChildren.forEach((item, index) => {
+            const { dimensionsMeta, type } = getDimensionMetadata(item, this.jaql);
+            type.push(PluginsTypesFields.MEMBER);
+            let rowIndex = indexes.row >= 0 ? indexes.row + 1 : 0;
+            if (rowIndex >= this.indexHelper.rowStartFrom) {
+                this.indexHelper.rowStartFrom = rowIndex + 1;
+            }
+            if (item.metadataType === PanelType.MEASURES) {
+                rowIndex = this.indexHelper.measuresLevel;
+            }
+            let colIndex = index === 0 ? 0 : 1;
+            colIndex += this.indexHelper.columnStartFrom;
+            const metadata = {
+                type,
+                rowIndex,
+                colIndex,
+                index: item.jaqlIndex,
+                columns: dimensionsMeta,
+            };
+            if (item.metadataType === PanelType.MEASURES) {
+                metadata.measure = this.getMeasureMetaByIndex(item.index || 0);
+            }
+            const cellItem = {
+                value: item.value || '',
+                content: item.content || '',
+                contentType: item.contentType || DEFAULT_CONTENT_TYPE,
+                style: item.style || {},
+                store: item.store || {},
+                state: item.state,
+            };
+            this.applyGlobal(cellItem);
+            this.apply(metadata, cellItem);
+            this.addToMetadata(metadata, cellItem, metadata.rowIndex, metadata.colIndex);
+            Object.assign(item, cellItem);
+            this.indexHelper.columnStartFrom = colIndex;
+            if (item.children) {
+                const parentIndex = {
+                    row: rowIndex,
+                    column: colIndex,
+                };
+                this._applyToColumns(item.children, parentIndex);
+            }
+            else {
+                this.columnsMetadata.push({ type, metadata: dimensionsMeta });
+            }
+            return true;
+        });
+    }
+    /**
+     * Apply plugins to corner tree headers
+     *
+     * @param {any} cornerTree - measure index in row
+     * @returns {void}
+     */
+    applyToHeaders(cornerTree) {
+        if (!cornerTree || !cornerTree.children || cornerTree.children.length === 0) {
+            return;
+        }
+        cornerTree.children.forEach((item) => {
+            const { dimensionsMeta } = getDimensionMetadata(item, this.jaql);
+            const metadata = {
+                type: [PluginsTypesFields.MEMBER],
+                rowIndex: 0,
+                colIndex: item.index || 0,
+                index: item.jaqlIndex,
+                rows: dimensionsMeta,
+            };
+            const cellItem = {
+                value: item.value,
+                content: item.content || '',
+                contentType: item.contentType || DEFAULT_CONTENT_TYPE,
+                style: item.style ? item.style : {},
+                store: item.store || {},
+                // eslint-disable-next-line max-lines
+                state: item.state,
+            };
+            this.applyGlobal(cellItem);
+            this.apply(metadata, cellItem);
+            this.addToMetadata(metadata, cellItem, metadata.rowIndex, metadata.colIndex);
+            Object.assign(item, cellItem);
+        });
+    }
+    applyToRows(rowTreeChildren) {
+        if (rowTreeChildren.length === 0) {
+            return;
+        }
+        const rows = this.getJaqlPanels(PanelType.ROWS);
+        const measures = this.getJaqlPanels(PanelType.MEASURES);
+        const columns = this.getJaqlPanels(PanelType.COLUMNS);
+        this.indexHelper.rowStartFrom = PluginService.getRowStartFromForPage(rows.length, measures.length, columns.length);
+        this._applyToRows(rowTreeChildren);
+    }
+    static getRowStartFromForPage(numberOfRows, numberOfMeasures, numberOfColumns) {
+        if (numberOfRows === 0 && numberOfColumns === 0) {
+            return 0;
+        }
+        const result = numberOfColumns + (numberOfMeasures === 0 ? 0 : 1);
+        if (result === 0) {
+            return 1;
+        }
+        return result;
+    }
+    /**
+     * Apply plugins to rows panels
+     *
+     * @param {Array<PivotTreeNode>} rowTreeChildren - measure index in row
+     * @returns {void}
+     */
+    _applyToRows(rowTreeChildren) {
+        rowTreeChildren.forEach((item, index) => {
+            const { dimensionsMeta, type } = getDimensionMetadata(item, this.jaql);
+            type.push(PluginsTypesFields.MEMBER);
+            const colIndex = item.level ? item.level : 0;
+            const rowIndex = index === 0 ? this.indexHelper.rowStartFrom : this.indexHelper.rowStartFrom + 1;
+            const metadata = {
+                type,
+                rowIndex,
+                colIndex,
+                index: item.jaqlIndex,
+                rows: dimensionsMeta,
+            };
+            const cellItem = {
+                value: item.value,
+                content: item.content || '',
+                contentType: item.contentType || DEFAULT_CONTENT_TYPE,
+                style: item.style || {},
+                store: item.store || {},
+                state: item.state,
+            };
+            this.applyGlobal(cellItem);
+            this.apply(metadata, cellItem);
+            this.addToMetadata(metadata, cellItem, metadata.rowIndex, metadata.colIndex);
+            this.indexHelper.rowStartFrom = rowIndex;
+            if (item.children) {
+                this._applyToRows(item.children);
+            }
+            else if (item.data && item.data.length) {
+                this.applyToValues(item.data, { type, metadata: dimensionsMeta }, { rowIndex, colIndex: this.getRowsColumnLength() });
+            }
+            Object.assign(item, cellItem);
+            return true;
+        });
+    }
+    /**
+     * 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}
+     */
+    // eslint-disable-next-line sonarjs/cognitive-complexity
+    applyToValues(values, rowData, indexes) {
+        if (!values.length) {
+            return;
+        }
+        values.forEach((item, index) => {
+            const type = [PluginsTypesFields.VALUE];
+            const colData = this.columnsMetadata[index];
+            if (!colData) {
+                return;
+            }
+            const totalTypes = this.getTotalTypes([...rowData.type, ...colData.type]);
+            const measureMetadata = this.getMeasureMetaByIndex(index);
+            const metadata = {
+                type: type.concat(totalTypes),
+                rows: rowData.metadata,
+                columns: colData.metadata,
+                measure: measureMetadata,
+                colIndex: index + indexes.colIndex,
+                rowIndex: indexes.rowIndex,
+                index: measureMetadata && measureMetadata.index ? measureMetadata.index : 0,
+            };
+            let cellItem = {
+                value: item,
+                content: item,
+                contentType: DEFAULT_CONTENT_TYPE,
+                style: {},
+                store: (item && item.store) || {},
+                state: (item && item.state) || undefined,
+            };
+            if (item !== null && item !== undefined && typeof item === 'object') {
+                cellItem = {
+                    value: item.value ? item.value : null,
+                    content: item.content || '',
+                    contentType: item.contentType || DEFAULT_CONTENT_TYPE,
+                    style: item.style || {},
+                    store: item.store || {},
+                    state: item.state,
+                };
+            }
+            this.applyGlobal(cellItem);
+            this.apply(metadata, cellItem);
+            this.addToMetadata(metadata, cellItem, metadata.rowIndex, metadata.colIndex);
+            values[index] = cellItem;
+        });
+    }
+    /**
+     * 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, cellItem, rowIndex, colIndex) {
+        const cacheMeta = Object.assign({ cellData: {
+                value: cellItem.value,
+                content: cellItem.content,
+            } }, metadata);
+        this.metadataCache.set(`${rowIndex}-${colIndex}`, cacheMeta);
+    }
+    /**
+     * Apply global config to cells
+     *
+     * @param {CellItem} item - cell item to update by plugin
+     * @returns {void}
+     */
+    applyGlobal(item) {
+        const { globalStyles } = this;
+        if (!globalStyles) {
+            return;
+        }
+        item.style = Object.assign(Object.assign({}, item.style), globalStyles);
+    }
+    /**
+     * Apply plugins to rows panels
+     *
+     * @param {Metadata} metadata - cell metadata
+     * @param {CellItem} item - cell item to update by plugin
+     * @returns {void}
+     */
+    apply(metadata, item) {
+        if (this.plugins && this.plugins.length) {
+            this.plugins.forEach((plugin) => {
+                const valid = validate(plugin.target, metadata);
+                if (valid) {
+                    const pluginHandler = plugin.handler;
+                    pluginHandler(metadata, item);
+                }
+            });
+        }
+    }
+}
+export default PluginService;

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

@@ -0,0 +1,23 @@
+import { JaqlPanel, JaqlRequest } from '../../../data-load/types.js';
+import { PivotTreeNode } from '../../types.js';
+import { MeasureMetadata } from './types.js';
+/**
+ * Collect and return rows or columns group metadata
+ *
+ * @param {PivotTreeNode} dimensionItem - PivotTreeNode item
+ * @param {JaqlRequest} jaql - jaql with metadata
+ * @param {Array} dimensionsMeta - array of child dimensions for group
+ * @param {Array} type - array of cell types
+ * @returns {{ dimensionsMeta: Array<any>, type: Array<string> }} of dimensions metadata
+ */
+export declare const getDimensionMetadata: (dimensionItem: PivotTreeNode, jaql?: JaqlRequest, dimensionsMeta?: Array<any>, type?: Array<string>) => {
+    dimensionsMeta: Array<any>;
+    type: Array<string>;
+};
+/**
+ * Copy and clean info about measure
+ *
+ * @param {JaqlPanel} measurePanel - current measure item
+ * @returns {MeasureMetadata} measure metadata
+ */
+export declare const getMeasureMetadata: (measurePanel?: JaqlPanel) => MeasureMetadata;

package/dist/data-handling/utils/plugins/getters.js

@@ -0,0 +1,65 @@
+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;
+};
+import { PanelType, UserType } from '../../constants.js';
+const getJaqlItemByIndex = (jaql, index) => jaql.metadata.find((el) => el.field && el.field.index === index);
+/**
+ * Collect and return rows or columns group metadata
+ *
+ * @param {PivotTreeNode} dimensionItem - PivotTreeNode item
+ * @param {JaqlRequest} jaql - jaql with metadata
+ * @param {Array} dimensionsMeta - array of child dimensions for group
+ * @param {Array} type - array of cell types
+ * @returns {{ dimensionsMeta: Array<any>, type: Array<string> }} of dimensions metadata
+ */
+export const getDimensionMetadata = (dimensionItem, jaql, dimensionsMeta = [], type = []) => {
+    if (!jaql || !dimensionItem || typeof dimensionItem.jaqlIndex === 'undefined') {
+        return { dimensionsMeta, type };
+    }
+    const dimension = getJaqlItemByIndex(jaql, dimensionItem.jaqlIndex);
+    if (dimension && dimension.jaql && dimensionItem.metadataType !== PanelType.MEASURES) {
+        dimensionsMeta.unshift({
+            title: dimension.jaql.title,
+            name: dimension.jaql.dim,
+            member: dimensionItem.value,
+            index: dimensionItem.jaqlIndex,
+        });
+    }
+    if (dimensionItem &&
+        dimensionItem.userType &&
+        (dimensionItem.userType === UserType.SUB_TOTAL ||
+            dimensionItem.userType === UserType.GRAND_TOTAL)) {
+        const itemType = dimensionItem.userType.toLowerCase();
+        type.push(itemType);
+    }
+    if (dimensionItem.parent && dimensionItem.parent.metadataType !== PanelType.MEASURES) {
+        return getDimensionMetadata(dimensionItem.parent, jaql, dimensionsMeta, type);
+    }
+    return { dimensionsMeta, type };
+};
+/**
+ * Copy and clean info about measure
+ *
+ * @param {JaqlPanel} measurePanel - current measure item
+ * @returns {MeasureMetadata} measure metadata
+ */
+export const getMeasureMetadata = (measurePanel) => {
+    let measureMetadata = {};
+    if (measurePanel) {
+        // eslint-disable-next-line no-unused-vars
+        const _a = measurePanel.jaql, { type, datatype, table, column } = _a, panelCopy = __rest(_a, ["type", "datatype", "table", "column"]);
+        measureMetadata = panelCopy;
+        if (measurePanel.field) {
+            measureMetadata.index = measurePanel.field.index;
+        }
+    }
+    return measureMetadata;
+};

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

@@ -0,0 +1,75 @@
+import { Defer, InputStyles, Styles } from '../../../utils/types.js';
+export declare type DimensionTarget = {
+    index?: Array<number | any>;
+    dim?: string;
+    name?: string;
+    member?: Array<string | any>;
+    members?: Array<string | any>;
+    title?: Array<string | any>;
+};
+export declare type ValueTarget = {
+    index?: Array<number | any>;
+    dim?: string;
+    name?: string;
+    agg?: string;
+    title?: Array<string | any>;
+};
+export declare type Target = {
+    type?: Array<string>;
+    rows?: Array<DimensionTarget>;
+    columns?: Array<DimensionTarget>;
+    values?: Array<ValueTarget>;
+    index?: Array<number>;
+};
+export declare type DimensionMetadata = {
+    title: string;
+    name: string;
+    member: string;
+    index: number;
+};
+export declare type MeasureMetadata = {
+    title?: string;
+    dim?: string;
+    agg?: string;
+    formula?: string;
+    context?: string;
+    index?: number;
+};
+export declare type Metadata = {
+    type: Array<string>;
+    rows?: Array<DimensionMetadata>;
+    columns?: Array<DimensionMetadata>;
+    measure?: MeasureMetadata;
+    index?: number;
+    colIndex: number;
+    rowIndex: number;
+    cellData?: {
+        value: any;
+        content: any;
+    };
+};
+export declare type DimensionOptions = {
+    fields: Array<string>;
+};
+export declare type MeasureOptions = {
+    fields: Array<string>;
+};
+export declare type CellItem = {
+    value: string | undefined;
+    content: string;
+    contentType: string;
+    style: InputStyles | undefined;
+    store?: {
+        domReadyDefer?: Defer;
+        [key: string]: any;
+    };
+    state?: {
+        isSelected?: boolean;
+        isDrilled?: boolean;
+    };
+};
+export declare type GlobalStyles = Styles;
+export declare type PluginConfig = {
+    target: Target;
+    handler: (metadata: Metadata, cellItem: CellItem) => void;
+};

package/dist/data-handling/utils/plugins/types.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,13 @@
+import { Metadata, Target } from './types.js';
+/**
+ * Collect and return rows or columns group metadata
+ *
+ * @param {Target} target - target rows
+ * @param {Metadata} metadata - array of rows in metadata
+ * @returns {boolean} validation result
+ */
+export declare const validate: (target: Target, metadata: Metadata) => boolean;
+declare const _default: {
+    validate: (target: Target, metadata: Metadata) => boolean;
+};
+export default _default;