@sisense/sdk-pivot-query-client 2.17.0

package/dist/data-handling/DataService.d.ts

@@ -0,0 +1,672 @@
+/// <reference types="node" resolution-mode="require"/>
+import EventEmitter from 'events';
+import { DataLoadServiceI, JaqlPanel, JaqlRequest } from '../data-load/types.js';
+import { TreeService } from '../tree-structure/index.js';
+import { HeaderTreeNode, TreeNode, TreeServiceI } from '../tree-structure/types.js';
+import { DivergenceComparator } from './DivergenceComparator.js';
+import { AllDataInfo, DataServiceI, InitPageData, PivotTreeNode } from './types.js';
+import { PluginService } from './utils/index.js';
+import { GlobalStyles, PluginConfig } from './utils/plugins/types.js';
+export declare type NodesChunk = {
+    list: Array<TreeNode>;
+    size: number;
+    ready: boolean;
+    handled: boolean;
+};
+export declare const DEFAULT_PAGE_SIZE = 100;
+export declare const EVENT_DATA_LOAD = "dataLoad";
+export declare const EVENT_DATA_CHUNK_LOADED = "dataChunkLoaded";
+export declare const EVENT_DATABAR_CHUNK_LOADED = "dataBarChunkLoaded";
+export declare const EVENT_RANGEMINMAX_CHUNK_LOADED = "rangeMinMaxChunkLoaded";
+export declare const EVENT_GRAND_CHUNK_LOADED = "grandChunkLoaded";
+export declare const EVENT_DATA_FINISH_CHUNK_LOADED = "dataFinishChunkLoaded";
+export declare const EVENT_FINISH_CHUNK_LOADED = "finishChunkLoaded";
+export declare const EVENT_PROGRESS_ERROR = "progressError";
+export declare const EVENT_HEADER_CELL_FORMAT = "headerCellFormat";
+export declare const EVENT_DATA_CELL_FORMAT = "dataCellFormat";
+export declare const EVENT_TOTAL_ROWS_COUNT = "totalRowsCountLoaded";
+export declare const EVENT_TOTAL_COLUMNS_COUNT = "totalColumnsCountLoaded";
+export declare const NODES_CHUNK_SIZE_MAX = 1000;
+export declare const THROTTLE_TIME_MS = 0;
+declare type Options = {
+    throttle: Function;
+    throttleTime: number;
+    PluginService: typeof PluginService;
+    skipInternalColorFormatting: boolean;
+    subtotalsForSingleRow: boolean;
+};
+export declare type DataServiceOptions = Partial<Options>;
+export declare class DataService implements DataServiceI {
+    /**
+     *
+     *
+     * @private
+     * EventEmitter instance
+     */
+    events: EventEmitter;
+    /**
+     *
+     *
+     * @private
+     *
+     * DataLoadServiceI instance
+     */
+    loadService: DataLoadServiceI;
+    /**
+     *
+     *
+     * @private
+     *
+     * configuration options object
+     */
+    options: Options;
+    /**
+     *
+     *
+     * @private
+     *
+     * loaded data chunks group
+     */
+    tempDataChunks: Array<NodesChunk>;
+    /**
+     *
+     * @private
+     *
+     * last not handled data chunks group index
+     */
+    lastNotHandledChunkIndex: number;
+    /**
+     *
+     * @private
+     *
+     * last ready but not handled data chunks group index
+     */
+    lastReadyNotHandledChunkIndex: number;
+    /**
+     *
+     * @private
+     *
+     * Current rows nodes
+     */
+    rowsGrand?: PivotTreeNode;
+    /**
+     *
+      @private */
+    rowsTreeService?: TreeServiceI;
+    /**
+     *
+      @private */
+    columnsTreeService?: TreeServiceI;
+    /**
+     *
+      @private */
+    cornerTreeService?: TreeServiceI;
+    /**
+      @private */
+    pageSize: number;
+    /**
+     *
+      @private */
+    isPaginated: boolean;
+    /**
+     *
+     * @private
+     *
+     * number of loaded pages
+     */
+    loadedPagesCount: number;
+    /**
+     *
+     * @private
+     *
+     * state for "loadData" method
+     */
+    isLoadInProgress: boolean;
+    /**
+     *
+      @private */
+    loadPromiseResolve?: Function;
+    /**
+     *
+      @private */
+    loadPromiseReject?: Function;
+    /**
+     *
+      @private */
+    loadPromiseCache?: InitPageData;
+    /**
+     *
+      @private */
+    loadAllPromise?: Promise<any>;
+    /**
+     *
+      @private */
+    loadAllPromiseResolve?: Function;
+    /**
+     *
+      @private */
+    loadAllPromiseReject?: Function;
+    /**
+     *
+     * @private
+     *
+     * defines if all data is loaded
+     */
+    isWholeDataLoaded: boolean;
+    /**
+     *
+     * @private
+     *
+     * defines that data finish event is happened
+     */
+    hasDataFinishEvent: boolean;
+    /**
+     *
+     * @private
+     *
+     * defines that data handler in progress
+     */
+    isDataHandlerThrottled: boolean;
+    /**
+     *
+     * @private
+     *
+     * throttled data handler
+     */
+    onDataHandlerThrottle: (data?: any) => void;
+    /**
+     *
+     * @private
+     *
+     * jaql request pure metadata
+     */
+    metadata: Array<JaqlPanel>;
+    dataBars: Array<[string, string]> | undefined;
+    rangeMinMax: Array<[string, string]> | undefined;
+    /**
+     *
+     * @private
+     *
+     * service for items indexation divergence
+     */
+    divergenceComparator: DivergenceComparator;
+    /**
+     *
+     * @private
+     *
+     * service to apply customers plugins
+     */
+    pluginService?: PluginService;
+    /**
+     *
+      @private */
+    rawJaql?: JaqlRequest;
+    /**
+     *
+     * @private
+     *
+     * triggered events data storage
+     */
+    triggeredEventsData: {
+        [key: string]: any;
+    };
+    /**
+     *
+     * @private
+     *
+     * plugins handlers
+     */
+    callPlugins: Array<PluginConfig>;
+    /**
+     *
+     * @private
+     *
+     * plugins global styles
+     */
+    globalStyles?: GlobalStyles;
+    /**
+     *
+     * @private
+     *
+     * actual data columns count
+     */
+    columnsCount?: number;
+    /**
+     *
+     * @private
+     *
+     * total data columns count
+     */
+    totalColumnsCount?: number;
+    /**
+     *
+     * @private
+     *
+     * actual data rows count
+     */
+    rowsCount?: number;
+    /**
+     *
+     * @private
+     *
+     * total data rows count
+     */
+    totalRowsCount?: number;
+    /**
+     *
+     * @private
+     *
+     * total CVS records count
+     */
+    totalRecordsCount?: number;
+    /**
+     *
+     * @private
+     *
+     * is rows limit reached
+     */
+    limitReached?: boolean;
+    constructor(loadService: DataLoadServiceI, events?: EventEmitter, options?: Partial<Options>);
+    destroy(): void;
+    /**
+     * Subscribe to event notification
+     *
+     * @param {string} eventName - event name to subscribe
+     * @param {Function} callback - event handler
+     * @returns {void}
+     */
+    on(eventName: string, callback: (...args: any[]) => void): void;
+    /**
+     * Emits event with payload
+     *
+     * @param {string} eventName - event name to emit
+     * @param {Array<any>} payload - event payload
+     * @returns {void}
+     */
+    emit(eventName: string, ...payload: Array<any>): void;
+    /**
+     * Unsubscribe from event notification
+     *
+     * @param {string} eventName - event name to unsubscribe from
+     * @param {Function} callback - event handler
+     * @returns {void}
+     */
+    off(eventName: string, callback: (...args: any[]) => void): void;
+    /**
+     * Initialize start data loading
+     *
+     * @param {JaqlRequest} [jaql] - JAQL request object
+     * @param {object} [options] - additional options
+     * @param {number} [options.pageSize=100] - page size to wait
+     * @param {boolean} [options.isPaginated=false] - defines which type of treeService to return,
+     * partial or paginated
+     * @param {Array<JaqlPanel>} [options.metadata] - jaql's metadata
+     * @param {boolean} [options.cacheResult=false] - cache result for next call or not
+     * @returns {Promise<any>} - promise with initial data to render
+     */
+    loadData(jaql?: JaqlRequest, options?: {
+        pageSize?: number;
+        isPaginated?: boolean;
+        metadata?: Array<JaqlPanel>;
+        cacheResult?: boolean;
+    }): Promise<InitPageData>;
+    /**
+     * Sets Promise that resolves after all data loaded
+     *
+     * @returns {Promise<{ loadedRowsCount: number, totalItemsCount: number }>} - promise with
+     * loaded items count
+     */
+    loadAllData(): Promise<AllDataInfo>;
+    /**
+     * public method for selecting page and setting new page size
+     *
+     * @param {number} selected - page number
+     * @param {number} pageSize - set page size (optional)
+     * @returns {Promise<{rowsTreeService, columnsTreeService, cornerTreeService, isLastPage}>}
+     * - returns private method's call with panel's treeServices
+     */
+    getSelectedPageData(selected: number, pageSize?: number): Promise<InitPageData>;
+    /**
+     * public method for selecting page by indexes
+     *
+     * @param {number} from - first row's index
+     * @param {number} to - last row's index
+     * @param {boolean} lastPage - append grandTotals
+     * @returns {Promise<{rowsTreeService, columnsTreeService, cornerTreeService, isLastPage}>}
+     * - returns private method's call with panel's treeServices
+     */
+    getIndexedPageData(from: number, to: number, lastPage?: boolean): Promise<InitPageData>;
+    /**
+     * Returns current jaql request object
+     *
+     * @returns {JaqlRequest} - jaql request object
+     */
+    getJaql(): JaqlRequest;
+    /**
+     * Defines data structure
+     *
+     * @returns {boolean} - true - single branch tree
+     */
+    isSingleRowTree(): boolean;
+    /**
+     * Set cell process handlers
+     *
+     * @param {Array<PluginConfig>} handlers - object with target and handler
+     * @returns {void}
+     */
+    setPluginHandlers(handlers: Array<PluginConfig>): void;
+    /**
+     * Set global styles for all cells
+     *
+     * @param {GlobalStyles} [styles] - object with target and handler
+     * @returns {void}
+     */
+    setGlobalStyles(styles?: GlobalStyles): void;
+    /**
+     * Returns current raw jaql request object
+     *
+     * @returns {JaqlRequest} - composition of required jaql fields
+     * @private
+     */
+    getRawJaql(): JaqlRequest;
+    /**
+     * Returns current jaql request metadata array
+     *
+     * @returns {Array<JaqlPanel>} - jaql request metadata
+     * @private
+     */
+    getMetadata(): Array<JaqlPanel>;
+    /**
+     * Pre-process initial tree structure
+     *
+     * @param {Array<TreeNode>} items - items to normalize
+     * @param {string} type - items types to normalize
+     * @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
+     */
+    preProcessTree(items: TreeNode | Array<TreeNode>, type: string, options?: {
+        level?: number;
+        measurePath?: {
+            [key: string]: string;
+        };
+    }): Array<PivotTreeNode>;
+    /**
+     * Post-process final tree structure with formatting event
+     *
+     * @param {PivotTreeNode} items - list of PivotTreeNode items
+     * @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
+     * @returns {void}
+     */
+    postProcessTree(items: Array<PivotTreeNode>, options?: {
+        skipFormatEvent?: boolean;
+        onlyFormatEvents?: boolean;
+        iterateFn?: Function;
+    }): void;
+    /**
+     * Post-process data list with formatting event
+     *
+     * @param {PivotTreeNode} items - list of PivotTreeNode rows items
+     * @param {object} [options] - additional options
+     * @param {boolean} [options.skipFormatEvent] - process data list but skip format event trigger
+     * @param {boolean} [options.onlyFormatEvents] - process data list with format event
+     * trigger only
+     * @returns {void}
+     */
+    postProcessData(items: Array<PivotTreeNode>, options?: {
+        skipFormatEvent?: boolean;
+        onlyFormatEvents?: boolean;
+    }): void;
+    /**
+     * 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 {TreeNode} originalData - initial data object
+     * @returns {PivotTreeNode | Array<PivotTreeNode>} - normalized list of items
+     */
+    modifyTree(items: Array<PivotTreeNode>, type: string, originalData?: TreeNode): Array<PivotTreeNode>;
+    /**
+     * method calculates divergence by prev indexes
+     *
+     * @param {Array<PivotTreeNode>} items - data to modify divergence and apply
+     * @returns {void}
+     * @private
+     */
+    applyIndexDivergence(items: Array<PivotTreeNode>): void;
+    /**
+     * method creates plugin service instance for pivot
+     *
+     * @param {JaqlRequest} jaql - data to modify divergence and apply
+     * @returns {void}
+     * @private
+     */
+    initPluginService(jaql: JaqlRequest): void;
+    /**
+     * Cancel current loading process
+     *
+     * @returns {void}
+     */
+    cancelLoading(): void;
+    /**
+     * Returns final page size, excluding grand totals rows for example
+     *
+     * @returns {number} - page size
+     * @private
+     */
+    getPageSize(): number;
+    /**
+     *
+     * Send result for "loadData" function after promise resolve
+     *
+     * @param {number} loadedCount - count of already loaded rows
+     * @returns {{
+     *     rowsTreeService: TreeServiceI,
+     *     columnsTreeService: TreeServiceI,
+     *     corner: TreeNode,
+     *     values: TreeNode,
+     *     cellsMetadata: Map<string, Metadata>
+     * }} - object with initial data
+     * @private
+     */
+    sendInitPage(loadedCount: number): InitPageData;
+    /**
+     * Sets Page Size and returns Tree Services
+     *
+     * @param {number} selected - page number -- STARTING FROM 0
+     * @param {number} [newPageSize] - set new pageSize
+     * @returns {{
+     *     rowsTreeService: null,
+     *     columnsTreeService: TreeServiceI,
+     *     cornerTreeService: TreeServiceI,
+     *     isLastPage: boolean
+     * }} - returns panel's treeServices
+     * @private
+     */
+    sendPaginatedPage(selected: number, newPageSize?: number): InitPageData;
+    /**
+     * Returns partial tree by indexes
+     *
+     * @param {number} paramFrom - start index
+     * @param {number} paramTo - stop index
+     * @param {boolean} lastPage - append grandTotals
+     * @returns {{
+     *     rowsTreeService: TreeServiceI,
+     *     columnsTreeService: TreeServiceI,
+     *     cornerTreeService: TreeServiceI,
+     *     isLastPage: boolean
+     * }} - returns panel's treeServices
+     * @private
+     */
+    sendPartialPage(paramFrom: number, paramTo: number, lastPage: boolean): InitPageData;
+    /**
+     *
+     * Get current state of tree (not recommended to use before 'loadData')
+     *
+     * @returns {number} loadedCount - current loaded count of children
+     * @private
+     */
+    getLoadedElementsCount(): number;
+    /**
+     * Returns total amount items count handled on back-end side
+     *
+     * @deprecated
+     * @returns {number} - items count
+     * @private
+     */
+    getTotalItemsCount(): number;
+    /**
+     * Getter for pivot table loaded columns number
+     *
+     * @deprecated
+     * @returns {number} loadedCount - current loaded pivot table columns count
+     * @private
+     */
+    getLoadedColumnsCount(): number;
+    /**
+     * Attach events to load service
+     * This is a key function implementing the Observer pattern
+     * DataService acts as Observer and subscribes its handlers to various
+     * data loading events emitted by the load service.
+     *
+     *
+     * @returns {void}
+     * @private
+     */
+    attachEvent(): void;
+    /**
+     * Dettach events from load service
+     *
+     * @returns {void}
+     * @private
+     */
+    detachEvent(): void;
+    /**
+     * Handler for pivot metadata received event
+     *
+     * @returns {void}
+     */
+    onMetadataHandler: () => void;
+    onHeadersHandler: (data: HeaderTreeNode) => void;
+    onDataHandler: (data: TreeNode | Array<TreeNode>) => void;
+    onGrandHandler: (data: TreeNode) => void;
+    onFinishHandler: () => void;
+    onTotalRowsHandler: (data: any) => void;
+    onDataBarsHandler: (chunk: any) => void;
+    onRangeMinMaxHandler: (chunk: any) => void;
+    onDataFinishHandler: ({ rowsCount }?: {
+        rowsCount?: number | undefined;
+    }) => void;
+    onErrorHandler: (data: any) => void;
+    /**
+     * Check for enough data loaded and resolve promise of "loadData" function
+     *
+     * @returns {void}
+     * @private
+     */
+    checkLoadPromise(): void;
+    /**
+     * @returns {void}
+     * @private
+     */
+    clearLoadAllPromise(): void;
+    /**
+     * @returns {void}
+     * @private
+     */
+    clearLoadPromise(): void;
+    /**
+     * Mark finish request
+     *
+     * @returns {void}
+     * @private
+     */
+    finishRequest(): void;
+    /**
+     * Clear internal cache in case new JAQL request send
+     *
+     * @returns {void}
+     * @private
+     */
+    clearCache(): void;
+    static getEmptyPage(): InitPageData;
+    static fillDataChunks(list: Array<NodesChunk>, node: TreeNode, firstMaxSize?: number, maxSize?: number): void;
+    static cloneTreeNode<T>(obj: T, skipChildren?: boolean): T;
+    /**
+     * @typedef {Function} buildColumnsTreeService
+     * @param {HeaderTreeNode} originalColumnsTree
+     * @returns {BuildColumnsTreeServiceResult}
+     */
+    /**
+     * @typedef {object} BuildColumnsTreeServiceResult
+     * @property {TreeNode|undefined} columnsTree
+     * @property {TreeService|undefined} columnsTreeService
+     * @property {number} columnsCount
+     * @property {number} totalColumnsCount
+     */
+    /**
+     * Creates builder function for building columns tree service
+     *
+     * @param {object} handlers - build handlers
+     * @param {Function} handlers.getJaql - jaql getter
+     * @param {Function} [handlers.getRawJaql] - raw jaql getter
+     * @param {PluginService} [handlers.pluginService] - plugin service
+     * @param {Function} [handlers.applyIndexDivergence] - helper for calculation indexes divergence
+     * @param {object} [events] - build event emitters
+     * @param {Function} events.emitHeaderCellFormatEvent - emits EVENT_HEADER_CELL_FORMAT event
+     * @returns {buildColumnsTreeService} - build function
+     */
+    static createColumnsTreeServiceBuilder(handlers: {
+        getJaql: () => JaqlRequest;
+        getRawJaql?: () => JaqlRequest;
+        pluginService?: PluginService;
+        applyIndexDivergence?: (items: Array<PivotTreeNode>) => void;
+    }, events?: {
+        emitHeaderCellFormatEvent: (item: PivotTreeNode, panel: JaqlPanel | undefined, jaql: JaqlRequest) => void;
+    }): (originalColumnsTree: HeaderTreeNode) => {
+        columnsTree: TreeNode | undefined;
+        columnsTreeService: TreeService | undefined;
+        columnsCount: number;
+        totalColumnsCount: number;
+    };
+    /**
+     * @typedef {Function} buildCornerTreeService
+     * @param {HeaderTreeNode} originalColumnsTree
+     * @returns {BuildCornerTreeServiceResult}
+     */
+    /**
+     * @typedef {object} BuildCornerTreeServiceResult
+     * @property {TreeNode|undefined} columnsTree
+     * @property {TreeService|undefined} columnsTreeService
+     * @property {number} columnsCount
+     * @property {number} totalColumnsCount
+     */
+    /**
+     * Creates builder function for building corners tree service
+     *
+     * @param {object} handlers - build handlers
+     * @param {Function} handlers.getJaql - jaql getter
+     * @param {Function} [handlers.getRawJaql] - raw jaql getter
+     * @param {PluginService} [handlers.pluginService] - plugin service
+     * @param {TreeServiceI} [handlers.columnsTreeService] - column tree service
+     * @param {object} [events] - build event emitters
+     * @param {Function} events.emitHeaderCellFormatEvent - emits EVENT_HEADER_CELL_FORMAT event
+     * @returns {buildCornerTreeService} - build function
+     */
+    static createCornerTreeServiceBuilder(handlers: {
+        getJaql: () => JaqlRequest;
+        getRawJaql?: () => JaqlRequest;
+        pluginService?: PluginService;
+        columnsTreeService?: TreeServiceI;
+    }, events?: {
+        emitHeaderCellFormatEvent: (item: PivotTreeNode, panel: JaqlPanel | undefined, jaql: JaqlRequest) => void;
+    }): () => {
+        cornerTree: TreeNode | undefined;
+        cornerTreeService: TreeService | undefined;
+    };
+}
+export default DataService;