ax-common-ui-lib 1.0.0-beta.0

package/esm2020/lib/drill-through/drill-through.module.mjs

@@ -0,0 +1,33 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { DrillThroughComponent } from './drill-through.component';
+import { MatIconModule } from '@angular/material/icon';
+import { EnlightenLibModule } from '../enlighten-lib/enlighten-lib.module';
+import * as i0 from "@angular/core";
+export class DrillThroughModule {
+}
+DrillThroughModule.ɵfac = function DrillThroughModule_Factory(t) { return new (t || DrillThroughModule)(); };
+DrillThroughModule.ɵmod = /*@__PURE__*/ i0.ɵɵdefineNgModule({ type: DrillThroughModule });
+DrillThroughModule.ɵinj = /*@__PURE__*/ i0.ɵɵdefineInjector({ imports: [[
+            CommonModule,
+            MatIconModule,
+            EnlightenLibModule
+        ]] });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(DrillThroughModule, [{
+        type: NgModule,
+        args: [{
+                declarations: [
+                    DrillThroughComponent
+                ],
+                imports: [
+                    CommonModule,
+                    MatIconModule,
+                    EnlightenLibModule
+                ],
+                exports: [DrillThroughComponent]
+            }]
+    }], null, null); })();
+(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(DrillThroughModule, { declarations: [DrillThroughComponent], imports: [CommonModule,
+        MatIconModule,
+        EnlightenLibModule], exports: [DrillThroughComponent] }); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZHJpbGwtdGhyb3VnaC5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvYXgtY29tbW9uLXVpLWxpYi9zcmMvbGliL2RyaWxsLXRocm91Z2gvZHJpbGwtdGhyb3VnaC5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUN6QyxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDL0MsT0FBTyxFQUFFLHFCQUFxQixFQUFFLE1BQU0sMkJBQTJCLENBQUM7QUFDbEUsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLHdCQUF3QixDQUFDO0FBQ3ZELE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxNQUFNLHVDQUF1QyxDQUFDOztBQWUzRSxNQUFNLE9BQU8sa0JBQWtCOztvRkFBbEIsa0JBQWtCO29FQUFsQixrQkFBa0I7d0VBUHBCO1lBQ1AsWUFBWTtZQUNaLGFBQWE7WUFDYixrQkFBa0I7U0FDbkI7dUZBR1Usa0JBQWtCO2NBWDlCLFFBQVE7ZUFBQztnQkFDUixZQUFZLEVBQUU7b0JBQ1oscUJBQXFCO2lCQUN0QjtnQkFDRCxPQUFPLEVBQUU7b0JBQ1AsWUFBWTtvQkFDWixhQUFhO29CQUNiLGtCQUFrQjtpQkFDbkI7Z0JBQ0QsT0FBTyxFQUFDLENBQUMscUJBQXFCLENBQUM7YUFDaEM7O3dGQUNZLGtCQUFrQixtQkFUM0IscUJBQXFCLGFBR3JCLFlBQVk7UUFDWixhQUFhO1FBQ2Isa0JBQWtCLGFBRVgscUJBQXFCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTmdNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IENvbW1vbk1vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbic7XG5pbXBvcnQgeyBEcmlsbFRocm91Z2hDb21wb25lbnQgfSBmcm9tICcuL2RyaWxsLXRocm91Z2guY29tcG9uZW50JztcbmltcG9ydCB7IE1hdEljb25Nb2R1bGUgfSBmcm9tICdAYW5ndWxhci9tYXRlcmlhbC9pY29uJztcbmltcG9ydCB7IEVubGlnaHRlbkxpYk1vZHVsZSB9IGZyb20gJy4uL2VubGlnaHRlbi1saWIvZW5saWdodGVuLWxpYi5tb2R1bGUnO1xuXG5cblxuQE5nTW9kdWxlKHtcbiAgZGVjbGFyYXRpb25zOiBbXG4gICAgRHJpbGxUaHJvdWdoQ29tcG9uZW50XG4gIF0sXG4gIGltcG9ydHM6IFtcbiAgICBDb21tb25Nb2R1bGUsXG4gICAgTWF0SWNvbk1vZHVsZSxcbiAgICBFbmxpZ2h0ZW5MaWJNb2R1bGVcbiAgXSxcbiAgZXhwb3J0czpbRHJpbGxUaHJvdWdoQ29tcG9uZW50XVxufSlcbmV4cG9ydCBjbGFzcyBEcmlsbFRocm91Z2hNb2R1bGUgeyB9XG4iXX0=

package/esm2020/lib/drill-through/drill-through.resolver.mjs

@@ -0,0 +1,80 @@
+import { HttpClient, HttpParams } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { Page } from '../enlighten-lib/report/graphical-report/page/page';
+import { DrillThroughService } from './drill-through.service';
+import { BreadCrumbsService } from '../bread-crumbs/bread-crumbs.service';
+import { ScreenType } from '../enlighten-lib/filters/condition-type';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "./drill-through.service";
+import * as i3 from "../bread-crumbs/bread-crumbs.service";
+export class DrillThroughResolver {
+    /**
+     * Constructor
+     */
+    constructor(_httpClient, _drillThroughService, _breadCrumbService) {
+        this._httpClient = _httpClient;
+        this._drillThroughService = _drillThroughService;
+        this._breadCrumbService = _breadCrumbService;
+        this._drillThroughService.restoreStates();
+    }
+    // -----------------------------------------------------------------------------------------------------
+    // @ Public methods
+    // -----------------------------------------------------------------------------------------------------
+    /**
+     * Use this resolver to resolve initial api for the module
+     *
+     * @param route
+     * @param state
+     */
+    resolve(route, state) {
+        const pageId = route.params.pageId;
+        return new Promise((resolve, reject) => {
+            Promise.all([
+                this.getPageData(pageId)
+            ]).then((response) => {
+                this._breadCrumbService.removeScreenBreadCrumbs(ScreenType.reportBuilder);
+                this._breadCrumbService.removeScreenBreadCrumbs(ScreenType.dashboardBuilder);
+                this._breadCrumbService.removeScreenBreadCrumbs(ScreenType.containerDashboard);
+                resolve(response);
+            }).catch((error) => {
+                reject(error);
+            });
+        });
+    }
+    /**
+     * Get page data by page id
+     *
+     * @param pageId
+     * @returns
+     */
+    getPageData(pageId) {
+        let httpParams = new HttpParams();
+        httpParams = httpParams.append('pageId', pageId.toString());
+        return new Promise((resolve, reject) => {
+            const currentState = this._drillThroughService.GetCurrentDrillThroughState();
+            if (currentState && currentState.isLoaded) {
+                const isPageExists = this._drillThroughService.checkLoadedPageExists(Number(pageId));
+                if (isPageExists) {
+                    this._drillThroughService.onPageChanged.emit('page_changed');
+                }
+                resolve(true);
+            }
+            else {
+                this._httpClient.get('drillthrough/getdrilledpage', { params: httpParams })
+                    .subscribe((response) => {
+                    this._drillThroughService.GetCurrentDrillThroughState().page = new Page(response);
+                    this._drillThroughService.GetCurrentDrillThroughState().isLoaded = true;
+                    this._drillThroughService.onPageChanged.emit('page_changed');
+                    resolve(response);
+                }, reject);
+            }
+        });
+    }
+}
+DrillThroughResolver.ɵfac = function DrillThroughResolver_Factory(t) { return new (t || DrillThroughResolver)(i0.ɵɵinject(i1.HttpClient), i0.ɵɵinject(i2.DrillThroughService), i0.ɵɵinject(i3.BreadCrumbsService)); };
+DrillThroughResolver.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: DrillThroughResolver, factory: DrillThroughResolver.ɵfac });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(DrillThroughResolver, [{
+        type: Injectable
+    }], function () { return [{ type: i1.HttpClient }, { type: i2.DrillThroughService }, { type: i3.BreadCrumbsService }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/drill-through/drill-through.service.mjs

@@ -0,0 +1,218 @@
+import { Injectable, EventEmitter } from '@angular/core';
+import { Page } from '../enlighten-lib/report/graphical-report/page/page';
+import { ScreenType } from '../enlighten-lib/filters/condition-type';
+import { BreadCrumbsService, BreadCrumb } from '../bread-crumbs/bread-crumbs.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../bread-crumbs/bread-crumbs.service";
+/**
+ * @class DrillPageState :- hold the state of drilled page
+ */
+export class DrillPageState {
+    constructor(page, filter) {
+        this.page = page;
+        this.filter = filter;
+        this.isLoaded = false;
+    }
+}
+export class ParentData {
+}
+export class DrillThroughService {
+    constructor(_breadCrumbService) {
+        this._breadCrumbService = _breadCrumbService;
+        /* Drilled page saved here. this array will help to going back to previous drill page  */
+        this._drillThroughStates = [];
+        this._drillThroughStatesRedo = [];
+        this._parentData = new ParentData();
+        this.onPageChanged = new EventEmitter();
+    }
+    /**
+     * This will save page and filter in array for preserving routing state.
+     *
+     * @param page
+     * @param filter
+     */
+    drillPage(page, filter) {
+        this._drillThroughStates.push(new DrillPageState(page, filter));
+    }
+    /**
+     * Remove preserved drill page from array on back button click
+     */
+    PageBack() {
+        const poppedState = this._drillThroughStates.pop();
+        this._drillThroughStatesRedo.push(poppedState);
+        if (!this._drillThroughStates.length) {
+            return null;
+        }
+        const currentState = this._drillThroughStates[this._drillThroughStates.length - 1];
+        this._breadCrumbService.changeCurrentBreadCrumb(currentState.page.id);
+        this._breadCrumbService.update();
+        return currentState;
+    }
+    PageNext() {
+        const drillPageState = this._drillThroughStatesRedo.pop();
+        if (drillPageState) {
+            this.drillPage(drillPageState.page, drillPageState.filter);
+        }
+        return drillPageState;
+    }
+    /**
+     *  This function return the current drill through state.
+     */
+    GetCurrentDrillThroughState() {
+        if (this._drillThroughStates.length < 1) {
+            return null;
+        }
+        return this._drillThroughStates[this._drillThroughStates.length - 1];
+    }
+    /**
+     * This function removes the pages from Drill Through States on change of bread crumbs state
+     */
+    changeDrillThroughStates(index) {
+        if (index < this._drillThroughStates.length) {
+            const states = this._drillThroughStates.splice(index).reverse();
+            states.forEach((state) => {
+                this._drillThroughStatesRedo.push(state);
+            });
+            const currentState = this.GetCurrentDrillThroughState();
+            const breadCrumbIndex = this._breadCrumbService.breadCrumbs.map(b => b.itemId).lastIndexOf(currentState.page.id);
+            this._breadCrumbService.changeCurrentBreadCrumb(breadCrumbIndex);
+            this._breadCrumbService.update();
+            return true;
+        }
+        return false;
+    }
+    /**
+     * check loaded page already exists if it is then change the drill through states accordingly
+     */
+    checkLoadedPageExists(pageId) {
+        const index = this._drillThroughStates.findIndex(d => d.page.id === pageId);
+        if (index != -1) {
+            this.changeDrillThroughStates(index + 1);
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Destroy drill through data
+     */
+    destroy() {
+        this._drillThroughStates = [];
+        this._drillThroughStatesRedo = [];
+        this._parentData = new ParentData();
+        this._breadCrumbService.removeScreenBreadCrumbs(ScreenType.drillThrough);
+        localStorage.removeItem('drill_states');
+        localStorage.removeItem('drill_redo_states');
+        localStorage.removeItem('paranet_data');
+    }
+    /**
+     * Save states in localstorage on reload
+     */
+    saveStates() {
+        localStorage.setItem('drill_states', JSON.stringify(this._drillThroughStates));
+        localStorage.setItem('drill_redo_states', JSON.stringify(this._drillThroughStatesRedo));
+        localStorage.setItem('paranet_data', JSON.stringify(this._parentData));
+    }
+    /**
+     * Set the parent data of the drill through
+     *
+     * @param id
+     * @param name
+     * @param url
+     */
+    setParentData(id, name, url) {
+        if (!this._parentData.id) {
+            this._parentData = new ParentData();
+            this._parentData.id = id;
+            this._parentData.name = name;
+            this._parentData.screenType = ScreenType.drillThrough;
+            this._parentData.url = url;
+        }
+    }
+    /**
+     * Get parent data of drill through
+     *
+     * @returns
+     */
+    getParentData() {
+        return this._parentData;
+    }
+    /**
+     * Restore states when reload of page finishes
+     */
+    restoreStates() {
+        const drillThroughStates = JSON.parse(localStorage.getItem('drill_states'));
+        const drillThroughStatesRedo = JSON.parse(localStorage.getItem('drill_states_redo'));
+        const parentData = JSON.parse(localStorage.getItem('paranet_data'));
+        if (drillThroughStates && drillThroughStates.length) {
+            this.setParentData(parentData.id, parentData.name, parentData.url);
+            this.setParentBreadCrumb();
+            this._drillThroughStates = drillThroughStates;
+            this._drillThroughStates.forEach((state) => {
+                state.page = new Page(state.page);
+                state.filter = state.filter;
+            });
+            if (drillThroughStatesRedo && drillThroughStatesRedo.length) {
+                this._drillThroughStatesRedo = drillThroughStatesRedo;
+            }
+            this._drillThroughStates.forEach((state, index) => {
+                if (index < this._drillThroughStates.length - 1) {
+                    this.setPageBreadCrumb(state.page);
+                }
+            });
+        }
+    }
+    /**
+     * Set drill thorugh parent bread crumb
+     */
+    setParentBreadCrumb() {
+        const breadCrumb = new BreadCrumb();
+        breadCrumb.itemId = this._parentData.id;
+        breadCrumb.title = this._parentData.name;
+        breadCrumb.url = this._parentData.url;
+        breadCrumb.screenType = ScreenType.drillThrough;
+        this._breadCrumbService.addBreadCrumb(breadCrumb);
+        this._breadCrumbService.update();
+    }
+    /**
+     * Set bread crumbs for all states/pages of drill through
+     */
+    setBreadCrumbs() {
+        this._breadCrumbService.removeScreenBreadCrumbs(ScreenType.drillThrough);
+        this.setParentBreadCrumb();
+        this._drillThroughStates.forEach((state, index) => {
+            this.setPageBreadCrumb(state.page);
+        });
+    }
+    /**
+     * Set page bread crumb
+     *
+     * @param page
+     */
+    setPageBreadCrumb(page) {
+        const breadCrumb = new BreadCrumb();
+        breadCrumb.itemId = page.id;
+        breadCrumb.title = page.name;
+        breadCrumb.url = this._parentData.url + '/drill-through/' + page.id;
+        breadCrumb.parentId = this._parentData.id;
+        breadCrumb.screenType = ScreenType.drillThrough;
+        this._breadCrumbService.addBreadCrumb(breadCrumb);
+        this._breadCrumbService.update();
+    }
+    /**
+     * returns true if there next page to show
+     *
+     * @returns boolean
+     */
+    hasNextPage() {
+        return (this._drillThroughStatesRedo.length > 0);
+    }
+}
+DrillThroughService.ɵfac = function DrillThroughService_Factory(t) { return new (t || DrillThroughService)(i0.ɵɵinject(i1.BreadCrumbsService)); };
+DrillThroughService.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: DrillThroughService, factory: DrillThroughService.ɵfac, providedIn: 'root' });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(DrillThroughService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root'
+            }]
+    }], function () { return [{ type: i1.BreadCrumbsService }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"drill-through.service.js","sourceRoot":"","sources":["../../../../../src/ax-common-ui-lib/src/lib/drill-through/drill-through.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, EventEmitter } from '@angular/core';\nimport { AxFilter } from '../enlighten-lib/filters/ax-filter';\nimport { Page } from '../enlighten-lib/report/graphical-report/page/page';\nimport { ScreenType } from '../enlighten-lib/filters/condition-type';\nimport { BreadCrumbsService, BreadCrumb } from '../bread-crumbs/bread-crumbs.service';\n\n/**\n * @class DrillPageState :- hold the state of drilled page\n */\nexport class DrillPageState\n{\n  page: Page;\n  filter: AxFilter;\n  isLoaded: boolean;\n  constructor(page: Page,filter: AxFilter){\n    this.page = page;\n    this.filter = filter;\n    this.isLoaded= false;\n  }\n}\n\nexport class ParentData {\n  name: string;\n  id: number;\n  screenType: number;\n  url: string;\n}\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class DrillThroughService {\n\n  onPageChanged: EventEmitter<string>;\n  /* Drilled page saved here. this array will help to going back to previous drill page  */\n  private _drillThroughStates: Array<DrillPageState> = [];\n  private _drillThroughStatesRedo: Array<DrillPageState> = [];\n  private _parentData: ParentData = new ParentData();\n\n  constructor(private _breadCrumbService: BreadCrumbsService) {\n    this.onPageChanged = new EventEmitter();\n  }\n  /**\n   * This will save page and filter in array for preserving routing state.\n   *\n   * @param page\n   * @param filter\n   */\n  public drillPage(page: Page,filter: AxFilter): void{\n    this._drillThroughStates.push(new DrillPageState(page,filter));\n  }\n\n  /**\n   * Remove preserved drill page from array on back button click\n   */\n  public PageBack(): DrillPageState{\n    const poppedState: DrillPageState = this._drillThroughStates.pop();\n    this._drillThroughStatesRedo.push(poppedState);\n    if(!this._drillThroughStates.length){\n      return null;\n    }\n    const currentState: DrillPageState = this._drillThroughStates[this._drillThroughStates.length-1];\n    this._breadCrumbService.changeCurrentBreadCrumb(currentState.page.id);\n    this._breadCrumbService.update();\n    return currentState;\n  }\n\n  public PageNext(): DrillPageState {\n    const drillPageState: DrillPageState = this._drillThroughStatesRedo.pop();\n    if(drillPageState)\n      {this.drillPage(drillPageState.page, drillPageState.filter);}\n    return drillPageState;\n  }\n\n/**\n *  This function return the current drill through state.\n */\n  public GetCurrentDrillThroughState(): DrillPageState{\n    if(this._drillThroughStates.length < 1){\n      return null;\n    }\n    return this._drillThroughStates[this._drillThroughStates.length-1];\n  }\n\n  /**\n   * This function removes the pages from Drill Through States on change of bread crumbs state\n   */\n  public changeDrillThroughStates(index: number): boolean{\n    if(index < this._drillThroughStates.length){\n      const states: Array<DrillPageState> = this._drillThroughStates.splice(index).reverse();\n      states.forEach((state) => {\n        this._drillThroughStatesRedo.push(state);\n      });\n      const currentState: DrillPageState = this.GetCurrentDrillThroughState();\n      const breadCrumbIndex = this._breadCrumbService.breadCrumbs.map(b => b.itemId).lastIndexOf(currentState.page.id);\n      this._breadCrumbService.changeCurrentBreadCrumb(breadCrumbIndex);\n      this._breadCrumbService.update();\n      return true;\n    }\n    return false;\n  }\n\n  /**\n   * check loaded page already exists if it is then change the drill through states accordingly\n   */\n  public checkLoadedPageExists(pageId: number): boolean {\n    const index: number = this._drillThroughStates.findIndex(d => d.page.id === pageId);\n    if(index != -1){\n      this.changeDrillThroughStates(index+1);\n      return true;\n    }\n    return false;\n  }\n\n  /**\n   * Destroy drill through data\n   */\n  public destroy(): void {\n    this._drillThroughStates = [];\n    this._drillThroughStatesRedo = [];\n    this._parentData = new ParentData();\n    this._breadCrumbService.removeScreenBreadCrumbs(ScreenType.drillThrough);\n    localStorage.removeItem('drill_states');\n    localStorage.removeItem('drill_redo_states');\n    localStorage.removeItem('paranet_data');\n  }\n\n  /**\n   * Save states in localstorage on reload\n   */\n  public saveStates(): void {\n    localStorage.setItem('drill_states', JSON.stringify(this._drillThroughStates));\n    localStorage.setItem('drill_redo_states', JSON.stringify(this._drillThroughStatesRedo));\n    localStorage.setItem('paranet_data', JSON.stringify(this._parentData));\n  }\n\n  /**\n   * Set the parent data of the drill through\n   *\n   * @param id\n   * @param name\n   * @param url\n   */\n  setParentData(id: number, name: string, url: string): void {\n    if(!this._parentData.id){\n      this._parentData = new ParentData();\n      this._parentData.id = id;\n      this._parentData.name = name;\n      this._parentData.screenType = ScreenType.drillThrough;\n      this._parentData.url = url;\n    }\n  }\n\n  /**\n   * Get parent data of drill through\n   *\n   * @returns\n   */\n  getParentData(): ParentData {\n    return this._parentData;\n  }\n\n  /**\n   * Restore states when reload of page finishes\n   */\n  public restoreStates(): void {\n    const drillThroughStates = JSON.parse(localStorage.getItem('drill_states'));\n    const drillThroughStatesRedo = JSON.parse(localStorage.getItem('drill_states_redo'));\n    const parentData = JSON.parse(localStorage.getItem('paranet_data')) as ParentData;\n    if(drillThroughStates && drillThroughStates.length){\n      this.setParentData(parentData.id, parentData.name, parentData.url);\n      this.setParentBreadCrumb();\n      this._drillThroughStates = drillThroughStates;\n      this._drillThroughStates.forEach((state) => {\n        state.page = new Page(state.page);\n        state.filter = state.filter as AxFilter;\n      });\n      if(drillThroughStatesRedo && drillThroughStatesRedo.length)\n        {this._drillThroughStatesRedo = drillThroughStatesRedo;}\n\n      this._drillThroughStates.forEach((state, index) => {\n        if(index < this._drillThroughStates.length-1){\n          this.setPageBreadCrumb(state.page);\n        }\n      });\n    }\n  }\n\n  /**\n   * Set drill thorugh parent bread crumb\n   */\n  setParentBreadCrumb(): void{\n    const breadCrumb = new BreadCrumb();\n    breadCrumb.itemId = this._parentData.id;\n    breadCrumb.title = this._parentData.name;\n    breadCrumb.url = this._parentData.url;\n    breadCrumb.screenType = ScreenType.drillThrough;\n    this._breadCrumbService.addBreadCrumb(breadCrumb);\n    this._breadCrumbService.update();\n  }\n\n  /**\n   * Set bread crumbs for all states/pages of drill through\n   */\n  setBreadCrumbs(): void{\n    this._breadCrumbService.removeScreenBreadCrumbs(ScreenType.drillThrough);\n    this.setParentBreadCrumb();\n    this._drillThroughStates.forEach((state, index) => {\n      this.setPageBreadCrumb(state.page);\n    });\n  }\n\n  /**\n   * Set page bread crumb\n   *\n   * @param page\n   */\n  setPageBreadCrumb(page: Page): void {\n    const breadCrumb = new BreadCrumb();\n    breadCrumb.itemId = page.id;\n    breadCrumb.title = page.name;\n    breadCrumb.url = this._parentData.url + '/drill-through/' + page.id;\n    breadCrumb.parentId = this._parentData.id;\n    breadCrumb.screenType = ScreenType.drillThrough;\n    this._breadCrumbService.addBreadCrumb(breadCrumb);\n    this._breadCrumbService.update();\n  }\n\n  /**\n   * returns true if there next page to show\n   *\n   * @returns boolean\n   */\n  hasNextPage(): boolean {\n    return (this._drillThroughStatesRedo.length > 0);\n  }\n}\n"]}

package/esm2020/lib/enlighten-lib/ax-expression/ax-exp-column.mjs

@@ -0,0 +1,37 @@
+import { Attribute } from '../data-model/attribute';
+import { AxExpressionValue } from './ax-expression-value';
+import { ExpressionValueSubType } from './exp-sub-type';
+export class AxExpColumn extends AxExpressionValue {
+    constructor(axExpColumn) {
+        super(axExpColumn);
+        this.subType = ExpressionValueSubType.column;
+        if (axExpColumn) {
+            this.axExpColumn(axExpColumn);
+        }
+        else {
+            this.newAxExpColumn();
+        }
+    }
+    /**
+     * Create Object of Ex-column by default value
+     */
+    newAxExpColumn() {
+        this.value = new Attribute();
+    }
+    /**
+     * Create Object of Ex-column existing  value
+     *
+     * @param axExpColumn
+     */
+    axExpColumn(axExpColumn) {
+        this.value = axExpColumn.value;
+    }
+    // To check filter is searchable.
+    searchable() {
+        if (this.value) {
+            return true;
+        }
+        return false;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXgtZXhwLWNvbHVtbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3NyYy9heC1jb21tb24tdWktbGliL3NyYy9saWIvZW5saWdodGVuLWxpYi9heC1leHByZXNzaW9uL2F4LWV4cC1jb2x1bW4udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFNBQVMsRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBQ3BELE9BQU8sRUFBRSxpQkFBaUIsRUFBRSxNQUFNLHVCQUF1QixDQUFDO0FBQzFELE9BQU8sRUFBRSxzQkFBc0IsRUFBRSxNQUFNLGdCQUFnQixDQUFDO0FBRXhELE1BQU0sT0FBTyxXQUFZLFNBQVEsaUJBQWlCO0lBRTlDLFlBQVksV0FBeUI7UUFDakMsS0FBSyxDQUFDLFdBQVcsQ0FBQyxDQUFDO1FBQ25CLElBQUksQ0FBQyxPQUFPLEdBQUcsc0JBQXNCLENBQUMsTUFBTSxDQUFDO1FBQzdDLElBQUcsV0FBVyxFQUFDO1lBQ1gsSUFBSSxDQUFDLFdBQVcsQ0FBQyxXQUFXLENBQUMsQ0FBQztTQUNqQzthQUFJO1lBQ0QsSUFBSSxDQUFDLGNBQWMsRUFBRSxDQUFDO1NBQ3pCO0lBQ0wsQ0FBQztJQUVEOztPQUVHO0lBQ0gsY0FBYztRQUNWLElBQUksQ0FBQyxLQUFLLEdBQUcsSUFBSSxTQUFTLEVBQUUsQ0FBQztJQUNqQyxDQUFDO0lBQ0Q7Ozs7T0FJRztJQUNILFdBQVcsQ0FBQyxXQUF5QjtRQUNqQyxJQUFJLENBQUMsS0FBSyxHQUFHLFdBQVcsQ0FBQyxLQUFLLENBQUM7SUFDbkMsQ0FBQztJQUVELGlDQUFpQztJQUNqQyxVQUFVO1FBQ04sSUFBRyxJQUFJLENBQUMsS0FBSyxFQUFDO1lBQ1YsT0FBTyxJQUFJLENBQUM7U0FDZjtRQUNELE9BQU8sS0FBSyxDQUFDO0lBQ2pCLENBQUM7Q0FDSiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEF0dHJpYnV0ZSB9IGZyb20gJy4uL2RhdGEtbW9kZWwvYXR0cmlidXRlJztcbmltcG9ydCB7IEF4RXhwcmVzc2lvblZhbHVlIH0gZnJvbSAnLi9heC1leHByZXNzaW9uLXZhbHVlJztcbmltcG9ydCB7IEV4cHJlc3Npb25WYWx1ZVN1YlR5cGUgfSBmcm9tICcuL2V4cC1zdWItdHlwZSc7XG5cbmV4cG9ydCBjbGFzcyBBeEV4cENvbHVtbiBleHRlbmRzIEF4RXhwcmVzc2lvblZhbHVlIHtcbiAgICB2YWx1ZTogQXR0cmlidXRlO1xuICAgIGNvbnN0cnVjdG9yKGF4RXhwQ29sdW1uPzogQXhFeHBDb2x1bW4pe1xuICAgICAgICBzdXBlcihheEV4cENvbHVtbik7XG4gICAgICAgIHRoaXMuc3ViVHlwZSA9IEV4cHJlc3Npb25WYWx1ZVN1YlR5cGUuY29sdW1uO1xuICAgICAgICBpZihheEV4cENvbHVtbil7XG4gICAgICAgICAgICB0aGlzLmF4RXhwQ29sdW1uKGF4RXhwQ29sdW1uKTtcbiAgICAgICAgfWVsc2V7XG4gICAgICAgICAgICB0aGlzLm5ld0F4RXhwQ29sdW1uKCk7XG4gICAgICAgIH1cbiAgICB9XG5cbiAgICAvKipcbiAgICAgKiBDcmVhdGUgT2JqZWN0IG9mIEV4LWNvbHVtbiBieSBkZWZhdWx0IHZhbHVlXG4gICAgICovXG4gICAgbmV3QXhFeHBDb2x1bW4oKTogdm9pZCB7XG4gICAgICAgIHRoaXMudmFsdWUgPSBuZXcgQXR0cmlidXRlKCk7XG4gICAgfVxuICAgIC8qKlxuICAgICAqIENyZWF0ZSBPYmplY3Qgb2YgRXgtY29sdW1uIGV4aXN0aW5nICB2YWx1ZVxuICAgICAqXG4gICAgICogQHBhcmFtIGF4RXhwQ29sdW1uXG4gICAgICovXG4gICAgYXhFeHBDb2x1bW4oYXhFeHBDb2x1bW4/OiBBeEV4cENvbHVtbik6IHZvaWQge1xuICAgICAgICB0aGlzLnZhbHVlID0gYXhFeHBDb2x1bW4udmFsdWU7XG4gICAgfVxuXG4gICAgLy8gVG8gY2hlY2sgZmlsdGVyIGlzIHNlYXJjaGFibGUuXG4gICAgc2VhcmNoYWJsZSgpOiBib29sZWFue1xuICAgICAgICBpZih0aGlzLnZhbHVlKXtcbiAgICAgICAgICAgIHJldHVybiB0cnVlO1xuICAgICAgICB9XG4gICAgICAgIHJldHVybiBmYWxzZTtcbiAgICB9XG59XG4iXX0=

package/esm2020/lib/enlighten-lib/ax-expression/ax-exp-date-list.mjs

@@ -0,0 +1,37 @@
+import { AxoUtils } from '../../axo-utils/axo-utils';
+import { AxExpressionValue } from './ax-expression-value';
+import { ExpressionValueSubType } from './exp-sub-type';
+export class AxExpDateList extends AxExpressionValue {
+    constructor(axExpDateList) {
+        super(axExpDateList);
+        this.subType = ExpressionValueSubType.dateList;
+        if (axExpDateList) {
+            this.axExpDateList(axExpDateList);
+        }
+        else {
+            this.newAxExpDateList();
+        }
+    }
+    /**
+     * pass by default value
+     */
+    newAxExpDateList() {
+        this.value = [];
+    }
+    /**
+     * Pass actual date value
+     *
+     * @param axExpDateList
+     */
+    axExpDateList(axExpDateList) {
+        this.value = AxoUtils.convertUTCDateToDateFromat(axExpDateList.value);
+    }
+    // To check filter is searchable.
+    searchable() {
+        if (this.value?.length) {
+            return true;
+        }
+        return false;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/enlighten-lib/ax-expression/ax-exp-date-range-value.mjs

@@ -0,0 +1,37 @@
+import { AxDateRange } from './ax-exp-date-range';
+import { AxExpressionValue } from './ax-expression-value';
+import { ExpressionValueSubType } from './exp-sub-type';
+export class AxExpDateRangeValue extends AxExpressionValue {
+    constructor(axExpDateRangeValue) {
+        super(axExpDateRangeValue);
+        this.subType = ExpressionValueSubType.dateRange;
+        if (axExpDateRangeValue) {
+            this.axExpDateRangeValue(axExpDateRangeValue);
+        }
+        else {
+            this.newAxExpDateRangeValue();
+        }
+    }
+    /**
+     * pass by default value
+     */
+    newAxExpDateRangeValue() {
+        this.value = new AxDateRange();
+    }
+    /**
+     * Pass actual Text value
+     *
+     * @param axExpDateRangeValue
+     */
+    axExpDateRangeValue(axExpDateRangeValue) {
+        this.value = new AxDateRange(axExpDateRangeValue.value);
+    }
+    // To check filter is searchable.
+    searchable() {
+        if (this.value) {
+            return this.value?.searchable();
+        }
+        return false;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/enlighten-lib/ax-expression/ax-exp-date-range.mjs

@@ -0,0 +1,34 @@
+export class AxDateRange {
+    constructor(axDateRange) {
+        if (axDateRange) {
+            this.axDateRange(axDateRange);
+        }
+        else {
+            this.newAxDateRange();
+        }
+    }
+    /**
+     * pass by default value
+     */
+    newAxDateRange() {
+        this.from = new Date();
+        this.to = new Date();
+    }
+    /**
+     * Pass actual date value
+     *
+     * @param axDateRange
+     */
+    axDateRange(axDateRange) {
+        this.from = axDateRange.from;
+        this.to = axDateRange.to;
+    }
+    // To check filter is searchable.
+    searchable() {
+        if (this.from && this.to) {
+            return true;
+        }
+        return false;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/enlighten-lib/ax-expression/ax-exp-date-time-list.mjs

@@ -0,0 +1,36 @@
+import { AxExpressionValue } from './ax-expression-value';
+import { ExpressionValueSubType } from './exp-sub-type';
+export class AxExpDateTimeList extends AxExpressionValue {
+    constructor(axExpDateList) {
+        super(axExpDateList);
+        this.subType = ExpressionValueSubType.dateTimeList;
+        if (axExpDateList) {
+            this.axExpDateList(axExpDateList);
+        }
+        else {
+            this.newAxExpDateList();
+        }
+    }
+    /**
+     * pass by default value
+     */
+    newAxExpDateList() {
+        this.value = [];
+    }
+    /**
+     * Pass actual date value
+     *
+     * @param axExpDateList
+     */
+    axExpDateList(axExpDateList) {
+        this.value = axExpDateList.value;
+    }
+    // To check filter is searchable.
+    searchable() {
+        if (this.value?.length) {
+            return true;
+        }
+        return false;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXgtZXhwLWRhdGUtdGltZS1saXN0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vc3JjL2F4LWNvbW1vbi11aS1saWIvc3JjL2xpYi9lbmxpZ2h0ZW4tbGliL2F4LWV4cHJlc3Npb24vYXgtZXhwLWRhdGUtdGltZS1saXN0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxpQkFBaUIsRUFBRSxNQUFNLHVCQUF1QixDQUFDO0FBQzFELE9BQU8sRUFBRSxzQkFBc0IsRUFBRSxNQUFNLGdCQUFnQixDQUFDO0FBRXhELE1BQU0sT0FBTyxpQkFBbUIsU0FBUSxpQkFBaUI7SUFFckQsWUFBWSxhQUFpQztRQUN6QyxLQUFLLENBQUMsYUFBYSxDQUFDLENBQUM7UUFDckIsSUFBSSxDQUFDLE9BQU8sR0FBRyxzQkFBc0IsQ0FBQyxZQUFZLENBQUM7UUFDbkQsSUFBRyxhQUFhLEVBQUM7WUFDYixJQUFJLENBQUMsYUFBYSxDQUFDLGFBQWEsQ0FBQyxDQUFDO1NBQ3JDO2FBQUk7WUFDRCxJQUFJLENBQUMsZ0JBQWdCLEVBQUUsQ0FBQztTQUMzQjtJQUNMLENBQUM7SUFFRDs7T0FFRztJQUNILGdCQUFnQjtRQUNaLElBQUksQ0FBQyxLQUFLLEdBQUcsRUFBRSxDQUFDO0lBQ3BCLENBQUM7SUFDRDs7OztPQUlHO0lBQ0gsYUFBYSxDQUFDLGFBQWlDO1FBQzNDLElBQUksQ0FBQyxLQUFLLEdBQUcsYUFBYSxDQUFDLEtBQUssQ0FBQztJQUNyQyxDQUFDO0lBQ0QsaUNBQWlDO0lBQ2pDLFVBQVU7UUFDTixJQUFHLElBQUksQ0FBQyxLQUFLLEVBQUUsTUFBTSxFQUFDO1lBQ2xCLE9BQU8sSUFBSSxDQUFDO1NBQ2Y7UUFDRCxPQUFPLEtBQUssQ0FBQztJQUNqQixDQUFDO0NBQ0oiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBBeEV4cHJlc3Npb25WYWx1ZSB9IGZyb20gJy4vYXgtZXhwcmVzc2lvbi12YWx1ZSc7XG5pbXBvcnQgeyBFeHByZXNzaW9uVmFsdWVTdWJUeXBlIH0gZnJvbSAnLi9leHAtc3ViLXR5cGUnO1xuXG5leHBvcnQgY2xhc3MgQXhFeHBEYXRlVGltZUxpc3QgIGV4dGVuZHMgQXhFeHByZXNzaW9uVmFsdWUge1xuICAgIHZhbHVlOiBBcnJheTxhbnk+O1xuICAgIGNvbnN0cnVjdG9yKGF4RXhwRGF0ZUxpc3Q/OiBBeEV4cERhdGVUaW1lTGlzdCl7XG4gICAgICAgIHN1cGVyKGF4RXhwRGF0ZUxpc3QpO1xuICAgICAgICB0aGlzLnN1YlR5cGUgPSBFeHByZXNzaW9uVmFsdWVTdWJUeXBlLmRhdGVUaW1lTGlzdDtcbiAgICAgICAgaWYoYXhFeHBEYXRlTGlzdCl7XG4gICAgICAgICAgICB0aGlzLmF4RXhwRGF0ZUxpc3QoYXhFeHBEYXRlTGlzdCk7XG4gICAgICAgIH1lbHNle1xuICAgICAgICAgICAgdGhpcy5uZXdBeEV4cERhdGVMaXN0KCk7XG4gICAgICAgIH1cbiAgICB9XG5cbiAgICAvKipcbiAgICAgKiBwYXNzIGJ5IGRlZmF1bHQgdmFsdWVcbiAgICAgKi9cbiAgICBuZXdBeEV4cERhdGVMaXN0KCk6IHZvaWQge1xuICAgICAgICB0aGlzLnZhbHVlID0gW107XG4gICAgfVxuICAgIC8qKlxuICAgICAqIFBhc3MgYWN0dWFsIGRhdGUgdmFsdWVcbiAgICAgKlxuICAgICAqIEBwYXJhbSBheEV4cERhdGVMaXN0XG4gICAgICovXG4gICAgYXhFeHBEYXRlTGlzdChheEV4cERhdGVMaXN0PzogQXhFeHBEYXRlVGltZUxpc3QpOiB2b2lkIHtcbiAgICAgICAgdGhpcy52YWx1ZSA9IGF4RXhwRGF0ZUxpc3QudmFsdWU7XG4gICAgfVxuICAgIC8vIFRvIGNoZWNrIGZpbHRlciBpcyBzZWFyY2hhYmxlLlxuICAgIHNlYXJjaGFibGUoKTogYm9vbGVhbntcbiAgICAgICAgaWYodGhpcy52YWx1ZT8ubGVuZ3RoKXtcbiAgICAgICAgICAgIHJldHVybiB0cnVlO1xuICAgICAgICB9XG4gICAgICAgIHJldHVybiBmYWxzZTtcbiAgICB9XG59XG4iXX0=

package/esm2020/lib/enlighten-lib/ax-expression/ax-exp-date-time-range-value.mjs

@@ -0,0 +1,37 @@
+import { AxExpDateTimeRange } from './ax-exp-date-time-range';
+import { AxExpressionValue } from './ax-expression-value';
+import { ExpressionValueSubType } from './exp-sub-type';
+export class AxExpDateTimeRangeValue extends AxExpressionValue {
+    constructor(axExpDateTimeRangeValue) {
+        super(axExpDateTimeRangeValue);
+        this.subType = ExpressionValueSubType.dateTimeRange;
+        if (axExpDateTimeRangeValue) {
+            this.axExpDateRangeValue(axExpDateTimeRangeValue);
+        }
+        else {
+            this.newAxExpDateRangeValue();
+        }
+    }
+    /**
+     * pass by default value
+     */
+    newAxExpDateRangeValue() {
+        this.value = new AxExpDateTimeRange();
+    }
+    /**
+     * Pass actual value
+     *
+     * @param axExpDateTimeRangeValue
+     */
+    axExpDateRangeValue(axExpDateTimeRangeValue) {
+        this.value = new AxExpDateTimeRange(axExpDateTimeRangeValue.value);
+    }
+    // To check filter is searchable.
+    searchable() {
+        if (this.value) {
+            return this.value.searchable();
+        }
+        return false;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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