@sisense/sdk-pivot-query-client 2.17.0

package/dist/cjs/data-handling/DivergenceComparator.d.ts

@@ -0,0 +1,7 @@
+import { PivotTreeNode } from './types.js';
+export declare class DivergenceComparator {
+    divergence: number;
+    constructor(items?: Array<PivotTreeNode>, prevComparator?: DivergenceComparator);
+    getDivergence(): number;
+}
+export default DivergenceComparator;

package/dist/cjs/data-handling/DivergenceComparator.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DivergenceComparator = void 0;
+const index_js_1 = require("../tree-structure/utils/index.js");
+class DivergenceComparator {
+    constructor(items = [], prevComparator) {
+        this.divergence = 0;
+        const prevDivergence = prevComparator ? prevComparator.getDivergence() : 0;
+        const itemsLastLevel = index_js_1.treeNode.getLastLevelNodes(items);
+        this.divergence = (prevDivergence + itemsLastLevel.length) % 2;
+        for (let i = 0; i < itemsLastLevel.length; i += 1) {
+            itemsLastLevel[i].indexDivergence = (i + prevDivergence) % 2;
+        }
+    }
+    getDivergence() {
+        return this.divergence;
+    }
+}
+exports.DivergenceComparator = DivergenceComparator;
+exports.default = DivergenceComparator;

package/dist/cjs/data-handling/constants.d.ts

@@ -0,0 +1,44 @@
+export declare type Values<T extends {}> = T[keyof T];
+export declare const PanelType: {
+    ROWS: "rows";
+    COLUMNS: "columns";
+    MEASURES: "measures";
+    SCOPE: "scope";
+};
+export declare type ListOfPanelTypes = Values<typeof PanelType>;
+export declare const SortingDirection: {
+    ASC: "asc";
+    DESC: "desc";
+};
+export declare type ListOfSortingDirections = Values<typeof SortingDirection>;
+export declare const UserType: {
+    SUB_TOTAL: string;
+    GRAND_TOTAL: string;
+    MEASURE_TOP: string;
+    MEASURE_BOTTOM: string;
+    CORNER: string;
+};
+export declare const ColorFormatType: {
+    COLOR: string;
+    CONDITION: string;
+};
+export declare const JaqlDataType: {
+    DATETIME: "datetime";
+    TEXT: "text";
+    NUMERIC: "numeric";
+};
+export declare type ListOfJaqlDataTypes = Values<typeof JaqlDataType>;
+export declare const PluginsTypesFields: {
+    MEMBER: string;
+    VALUE: string;
+    SUB_TOTAL: string;
+    GRAND_TOTAL: string;
+};
+export declare const PluginsPanelFields: {
+    MEMBER: string;
+    INDEX: string;
+    TITLE: string;
+    NAME: string;
+    AGG: string;
+    DIM: string;
+};

package/dist/cjs/data-handling/constants.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginsPanelFields = exports.PluginsTypesFields = exports.JaqlDataType = exports.ColorFormatType = exports.UserType = exports.SortingDirection = exports.PanelType = void 0;
+exports.PanelType = {
+    ROWS: 'rows',
+    COLUMNS: 'columns',
+    MEASURES: 'measures',
+    SCOPE: 'scope',
+};
+exports.SortingDirection = {
+    ASC: 'asc',
+    DESC: 'desc',
+};
+exports.UserType = {
+    SUB_TOTAL: 'subTotal',
+    GRAND_TOTAL: 'grandTotal',
+    MEASURE_TOP: 'measureTop',
+    MEASURE_BOTTOM: 'measureBottom',
+    CORNER: 'corner',
+};
+exports.ColorFormatType = {
+    COLOR: 'color',
+    CONDITION: 'condition',
+};
+exports.JaqlDataType = {
+    DATETIME: 'datetime',
+    TEXT: 'text',
+    NUMERIC: 'numeric',
+};
+exports.PluginsTypesFields = {
+    MEMBER: 'member',
+    VALUE: 'value',
+    SUB_TOTAL: 'subtotal',
+    GRAND_TOTAL: 'grandtotal',
+};
+exports.PluginsPanelFields = {
+    MEMBER: 'member',
+    INDEX: 'index',
+    TITLE: 'title',
+    NAME: 'name',
+    AGG: 'agg',
+    DIM: 'dim',
+};

package/dist/cjs/data-handling/index.d.ts

@@ -0,0 +1,3 @@
+export { DataService } from './DataService.js';
+export { DivergenceComparator } from './DivergenceComparator.js';
+export * from './types.js';

package/dist/cjs/data-handling/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DivergenceComparator = exports.DataService = void 0;
+/* eslint-disable import/prefer-default-export */
+var DataService_js_1 = require("./DataService.js");
+Object.defineProperty(exports, "DataService", { enumerable: true, get: function () { return DataService_js_1.DataService; } });
+var DivergenceComparator_js_1 = require("./DivergenceComparator.js");
+Object.defineProperty(exports, "DivergenceComparator", { enumerable: true, get: function () { return DivergenceComparator_js_1.DivergenceComparator; } });
+__exportStar(require("./types.js"), exports);

package/dist/cjs/data-handling/types.d.ts

@@ -0,0 +1,104 @@
+import { JaqlPanel, JaqlRequest } from '../data-load/types.js';
+import { TreeNode, TreeServiceI } from '../tree-structure/types.js';
+import { Defer, InputStyles } from '../utils/types.js';
+import { GlobalStyles, Metadata, PluginConfig } from './utils/plugins/types.js';
+export declare type PivotTreeNode<ContentType = any> = TreeNode & {
+    content?: null | string | ContentType;
+    contentType?: string;
+    metadataType?: string;
+    userType?: string;
+    tableType?: string;
+    jaqlIndex?: number;
+    measureJaqlIndex?: number;
+    measurePath?: {
+        [key: string]: string;
+    };
+    parent?: PivotTreeNode<ContentType>;
+    master?: PivotTreeNode<ContentType>;
+    dir?: string | null;
+    databars?: boolean;
+    state?: {
+        isSelected?: boolean;
+        isDrilled?: boolean;
+    };
+    store?: {
+        domReadyDefer?: Defer;
+        [key: string]: any;
+    };
+};
+declare type CompileRangeArgs = {
+    minvalue?: number;
+    midvalue?: number;
+    maxvalue?: number;
+    min?: string;
+    max?: string;
+    minDef?: string;
+    maxDef?: string;
+    minGray?: string;
+    maxGray?: string;
+};
+export declare type PivotDataNode<ContentType = any, Style = InputStyles> = {
+    value: any;
+    content?: null | string | ContentType;
+    contentType?: string;
+    cf?: number;
+    style?: Style;
+    jaqlIndex?: number;
+    state?: {
+        isSelected?: boolean;
+        isDrilled?: boolean;
+    };
+    store?: {
+        domReadyDefer?: Defer;
+        compileRange?: (arg: CompileRangeArgs) => (value: number) => string;
+        compileRangeContext?: unknown;
+        compileRangeArgs?: CompileRangeArgs;
+        [key: string]: any;
+    };
+};
+export interface InitPageData {
+    rowsTreeService?: TreeServiceI;
+    columnsTreeService?: TreeServiceI;
+    cornerTreeService?: TreeServiceI;
+    isLastPage: boolean;
+    cellsMetadata?: Map<string, Metadata>;
+}
+export declare type AllDataInfo = {
+    loadedRowsCount: number;
+    totalItemsCount: number;
+    totalColumnsCount?: number;
+    totalRecordsCount?: number;
+    columnsCount?: number;
+    limitReached?: boolean;
+    dataBars?: Array<[string, string]>;
+    rangeMinMax?: Array<[string, string]>;
+};
+export interface DataServiceI {
+    on(eventName: string, callback: Function): void;
+    off(eventName: string, callback: Function): void;
+    emit(eventName: string, ...payload: Array<any>): void;
+    getSelectedPageData(selected: number, pageSize?: number): Promise<InitPageData>;
+    getIndexedPageData(from: number, to: number, lastPage?: boolean): Promise<InitPageData>;
+    loadAllData(): Promise<AllDataInfo>;
+    loadData(jaql?: JaqlRequest, options?: {
+        pageSize?: number;
+        isPaginated?: boolean;
+        metadata?: Array<JaqlPanel>;
+        cacheResult?: boolean;
+    }): Promise<InitPageData>;
+    getJaql(): JaqlRequest | undefined;
+    isSingleRowTree(): boolean;
+    preProcessTree(items: TreeNode | Array<TreeNode>, type: string, options?: {
+        level?: number;
+        measurePath?: {
+            [key: string]: string;
+        };
+    }): Array<PivotTreeNode>;
+    modifyTree(items: Array<PivotTreeNode>, type: string, originalData: TreeNode): Array<PivotTreeNode>;
+    postProcessTree(items: Array<PivotTreeNode>): void;
+    cancelLoading(): void;
+    destroy(): void;
+    setPluginHandlers(plugins: Array<PluginConfig>): void;
+    setGlobalStyles(styles: GlobalStyles): void;
+}
+export {};

package/dist/cjs/data-handling/types.js

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

package/dist/cjs/data-handling/utils/createPivotTreeNode.d.ts

@@ -0,0 +1,13 @@
+import { TreeNode } from '../../tree-structure/types.js';
+import { PivotTreeNode } from '../types.js';
+/**
+ * Converts TreeNode to PivotTreeNode
+ *
+ * @param {TreeNode} node - tree node
+ * @param {string} [type] - type of node to create, columns/rows
+ * @returns {PivotTreeNode} - converted node
+ *
+ * @private
+ */
+export declare const createPivotTreeNode: (node: TreeNode, type?: string) => PivotTreeNode;
+export default createPivotTreeNode;

package/dist/cjs/data-handling/utils/createPivotTreeNode.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPivotTreeNode = void 0;
+/**
+ * Converts TreeNode to PivotTreeNode
+ *
+ * @param {TreeNode} node - tree node
+ * @param {string} [type] - type of node to create, columns/rows
+ * @returns {PivotTreeNode} - converted node
+ *
+ * @private
+ */
+const createPivotTreeNode = (node, type) => {
+    const pivotNode = node;
+    if (type) {
+        pivotNode.metadataType = type;
+    }
+    return pivotNode;
+};
+exports.createPivotTreeNode = createPivotTreeNode;
+exports.default = exports.createPivotTreeNode;

package/dist/cjs/data-handling/utils/index.d.ts

@@ -0,0 +1,4 @@
+export { default as jaqlProcessor } from './jaqlProcessor.js';
+export { default as pivotTransforms } from './pivotTransforms.js';
+export { default as createPivotTreeNode } from './createPivotTreeNode.js';
+export { PluginService } from './plugins/PluginService.js';

package/dist/cjs/data-handling/utils/index.js

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginService = exports.createPivotTreeNode = exports.pivotTransforms = exports.jaqlProcessor = void 0;
+var jaqlProcessor_js_1 = require("./jaqlProcessor.js");
+Object.defineProperty(exports, "jaqlProcessor", { enumerable: true, get: function () { return __importDefault(jaqlProcessor_js_1).default; } });
+var pivotTransforms_js_1 = require("./pivotTransforms.js");
+Object.defineProperty(exports, "pivotTransforms", { enumerable: true, get: function () { return __importDefault(pivotTransforms_js_1).default; } });
+var createPivotTreeNode_js_1 = require("./createPivotTreeNode.js");
+Object.defineProperty(exports, "createPivotTreeNode", { enumerable: true, get: function () { return __importDefault(createPivotTreeNode_js_1).default; } });
+var PluginService_js_1 = require("./plugins/PluginService.js");
+Object.defineProperty(exports, "PluginService", { enumerable: true, get: function () { return PluginService_js_1.PluginService; } });

package/dist/cjs/data-handling/utils/jaqlProcessor.d.ts

@@ -0,0 +1,122 @@
+import { JaqlPanel, JaqlRequest, MeasurePath, SortDetails } from '../../data-load/types.js';
+import { ListOfJaqlDataTypes, ListOfSortingDirections } from '../constants.js';
+import { PivotTreeNode } from '../types.js';
+export declare type DataTypes = {
+    [key: string]: string;
+};
+export declare function getDataTypes(panels?: Array<JaqlPanel>): DataTypes;
+export declare function isMeasurePathEqual(_measurePathA?: MeasurePath | null, _measurePathB?: MeasurePath | null, dataTypes?: DataTypes): boolean;
+/**
+ * Get appropriate metadata panels (rows/columns/measures) from JAQL request object
+ *
+ * @param {JaqlRequest} jaql - jaql with metadata
+ * @param {string} type - panels type to receive
+ * @returns {Array<JaqlPanel>} - list of panels
+ */
+export declare const getMetadataPanels: (jaql?: JaqlRequest, type?: string) => Array<JaqlPanel>;
+/**
+ * Get appropriate metadata panel (rows/columns/measures) from JAQL request object by panel index
+ *
+ * @param {JaqlRequest} jaql - jaql with metadata
+ * @param {number} index - panel index
+ * @param {string} [type] - panels type to receive
+ * @returns {JaqlPanel} - jaql panels
+ */
+export declare const getMetadataPanelByIndex: (jaql?: JaqlRequest, index?: number, type?: string) => JaqlPanel | undefined;
+/**
+ * Get appropriate metadata panels (rows/columns/measures) in TreeNode structure from
+ * JAQL request object
+ *
+ * @param {JaqlRequest} jaql - jaql with metadata
+ * @param {string} [type=PanelType.ROWS] - panels type to receive
+ * @returns {PivotTreeNode} - metadata panels tree
+ */
+export declare const getMetadataTree: (jaql?: JaqlRequest, type?: string) => PivotTreeNode;
+/**
+ * Removes redundant sort details for single branch tree
+ * (As such pivot can be sorted only by one panel)
+ *
+ * @param {JaqlRequest} jaql - jaql request
+ * @returns {void}
+ */
+export declare const normalizeSingleBranchTreeSortDetails: (jaql: JaqlRequest) => void;
+/**
+ * Updates last applied flag on metadata item sort details
+ * (Required for proper apply single branch tree sorting)
+ *
+ * @param {JaqlRequest} jaql - jaql request
+ * @param {SortDetails} sortDetails - last updated sort details
+ * @returns {void}
+ */
+export declare const updateLastAppliedSortingFlag: (jaql: JaqlRequest, sortDetails: SortDetails) => void;
+/**
+ * method to handle new sorting metadata
+ *
+ * @param {SortDetails} sortDetails - node with sorting metadata
+ * @param {?JaqlRequest} jaql - jaql to process
+ * @param {object} [options] - additional options
+ * @param {Function} [options.formatter] - fields formatter for measurePath
+ * @param {boolean} [options.isSingleRowTree] - defines data structure
+ * @returns {JaqlRequest} - reload pivot after jaql formatting
+ */
+export declare const updatePanelsSortingMetadata: (sortDetails: SortDetails, jaql: JaqlRequest, options?: {
+    formatter?: Function;
+    isSingleRowTree?: boolean;
+}) => void;
+/**
+ * Set width for jaql panel item
+ *
+ * @param {JaqlRequest} jaql - jaql request object
+ * @param {number} jaqlIndex - jaql panel item index
+ * @param {number} width - jaql panel item width
+ * @returns {void}
+ */
+export declare const setResizeWidthToJaql: (jaql: JaqlRequest | undefined, jaqlIndex: number, width: number) => void;
+/**
+ * Get pairs 'jaqlIndex: value'  for jaql panel items
+ *
+ * @param {JaqlRequest} jaql - jaql request object
+ * @returns {object} - object, keys - jaqlIndex, value - width
+ * appropriate width
+ */
+export declare const getResizeWidthFromJaql: (jaql?: JaqlRequest) => {
+    [key: number]: number;
+};
+export declare const markSortedNode: (jaql: JaqlRequest | undefined, item: PivotTreeNode) => void;
+declare function handleComplexSortingSettingsUpdate(jaql: JaqlRequest, desiredSortingSettings: (SortingSettingsItem & {
+    indexInJaql: number;
+})[], possibleSortDetailsOfCurrentMeasure: SortDetails, options: {
+    formatter?: Function;
+    isSingleRowTree: boolean;
+}): void;
+export declare type SortingSettingsItem = {
+    title: string;
+    datatype: ListOfJaqlDataTypes;
+    selected: boolean;
+    direction: ListOfSortingDirections | null;
+    indexInJaql?: number;
+};
+declare function mapWidgetJaqlToComplexSortingSettings(jaql: JaqlRequest, possibleSortDetailsOfCurrentMeasure: SortDetails): Array<Omit<SortingSettingsItem, 'indexInJaql'>>;
+declare function mapWidgetJaqlToSimpleSortingSettings(metadataPanels: JaqlPanel[], possibleSortDetailsOfCurrentMeasure: SortDetails, dataTypes: DataTypes): SortingSettingsItem | undefined;
+declare const _default: {
+    isMeasurePathEqual: typeof isMeasurePathEqual;
+    getDataTypes: typeof getDataTypes;
+    updatePanelsSortingMetadata: (sortDetails: SortDetails, jaql: JaqlRequest, options?: {
+        formatter?: Function | undefined;
+        isSingleRowTree?: boolean | undefined;
+    } | undefined) => void;
+    getMetadataTree: (jaql?: JaqlRequest | undefined, type?: string) => PivotTreeNode<any>;
+    getMetadataPanels: (jaql?: JaqlRequest | undefined, type?: string | undefined) => JaqlPanel[];
+    getMetadataPanelByIndex: (jaql?: JaqlRequest | undefined, index?: number | undefined, type?: string | undefined) => JaqlPanel | undefined;
+    setResizeWidthToJaql: (jaql: JaqlRequest | undefined, jaqlIndex: number, width: number) => void;
+    getResizeWidthFromJaql: (jaql?: JaqlRequest | undefined) => {
+        [key: number]: number;
+    };
+    markSortedNode: (jaql: JaqlRequest | undefined, item: PivotTreeNode<any>) => void;
+    normalizeSingleBranchTreeSortDetails: (jaql: JaqlRequest) => void;
+    updateLastAppliedSortingFlag: (jaql: JaqlRequest, sortDetails: SortDetails) => void;
+    handleComplexSortingSettingsUpdate: typeof handleComplexSortingSettingsUpdate;
+    mapWidgetJaqlToSimpleSortingSettings: typeof mapWidgetJaqlToSimpleSortingSettings;
+    mapWidgetJaqlToComplexSortingSettings: typeof mapWidgetJaqlToComplexSortingSettings;
+};
+export default _default;