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

package/esm2020/lib/enlighten-lib/report/report-filter/report-filter.service.mjs

@@ -0,0 +1,246 @@
+import { Injectable } from '@angular/core';
+import { HttpClient, HttpParams } from '@angular/common/http';
+import { FilterCategory } from '../../filters/filter-category';
+import { AxFilter } from '../../filters/ax-filter';
+import { AxExpression } from '../../ax-expression/ax-expression';
+import { SearchNode } from '../../filters/search-node';
+import { ConditionType, FilterType, ScopeType } from '../../filters/condition-type';
+import { GridSterProperties } from '../../filters/gridster-properties';
+import { ExpressionValueType } from '../../ax-expression/exp-sub-type';
+import { ElementService } from '../element.service';
+import { WidgetType } from '../../../forms/page/common/widget-enums';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../element.service";
+export class ReportFilterService {
+    /**
+     * Constructor
+     */
+    constructor(_httpClient, _elementService) {
+        this._httpClient = _httpClient;
+        this._elementService = _elementService;
+    }
+    /**
+     * Get Category list by the app-version id
+     *
+     * @param appVersion
+     * @returns filter category array
+     */
+    getCategories(appVersion) {
+        return new Promise((resolve, reject) => {
+            let params = new HttpParams();
+            params = params.append('appVersionId', appVersion);
+            this._httpClient.get('filtercategories', { params: params })
+                .subscribe((response) => {
+                resolve(response);
+            }, reject);
+        });
+    }
+    /**
+     * Create filter category object mapping
+     *
+     * @param filterCategory
+     * @returns
+     */
+    createFilterCategoryObject(filterCategory) {
+        const filterCategoryArray = new Array();
+        if (filterCategory) {
+            filterCategory.forEach((category) => {
+                category.gridProperties = category.gridProperties ? category.gridProperties : new GridSterProperties();
+                filterCategoryArray.push(new FilterCategory(category));
+            });
+        }
+        return filterCategoryArray;
+    }
+    /**
+     * check filter category exists into filter
+     *
+     * @param categoryList
+     * @param categories
+     * @returns Filter category list
+     */
+    checkSelectedCategory(appCategories, reportCategories) {
+        appCategories.forEach((appCategory, key) => {
+            reportCategories.forEach((reportCategory, filterKey) => {
+                if (reportCategory.id === appCategory.id) {
+                    appCategory.gridProperties = reportCategory.gridProperties ? reportCategory.gridProperties : new GridSterProperties();
+                    appCategory.isSelected = true;
+                    if (reportCategory[filterKey]) {
+                        reportCategory[filterKey].isSelected = true;
+                    }
+                }
+            });
+        });
+        return appCategories;
+    }
+    /**
+     * Check the attributes are exists in filters
+     *
+     * @param dataModel
+     * @param filters
+     * @returns Data Model details
+     */
+    checkSelectedAttribute(dataModel, filters) {
+        if (dataModel) {
+            dataModel.entities.forEach((entity) => {
+                entity.columns.forEach((column) => {
+                    filters.forEach((filter, filterKey) => {
+                        const columnName = filters[filterKey].searchNodes[0].expression.field.name;
+                        const tableName = filters[filterKey].searchNodes[0].expression.field.tableName;
+                        const isTitleColumn = column.label == 'title';
+                        const isChoiceGuidColumn = column.name == 'col_guid' && column.widgetType == WidgetType.textBox;
+                        // check the existing  filter attribute with drop down of data model Attribute
+                        if (columnName === column.name && tableName === column.tableName && !isTitleColumn && !isChoiceGuidColumn) {
+                            column.isSelected = true;
+                            //   filters[filterKey].searchNodes[0].expression.field = column;
+                        }
+                    });
+                });
+            });
+            return dataModel;
+        }
+    }
+    /**
+     * Add new filter functionality
+     *
+     * @param appVersion
+     * @param event
+     * @param filters
+     * @returns  filter array
+     */
+    addFilter(appVersion, event, filters, scopeType, x) {
+        const field = event.option.value;
+        const expression = new AxExpression();
+        expression.field = field;
+        expression.valueType = ExpressionValueType.fixed;
+        const searchNode = new SearchNode();
+        searchNode.expression = expression;
+        searchNode.type = ConditionType.condition;
+        const axFilter = new AxFilter();
+        axFilter.type = FilterType.basic;
+        axFilter.scope = ScopeType.global;
+        axFilter.searchNodes.push(searchNode);
+        axFilter.appVersionId = appVersion;
+        axFilter.scope = scopeType;
+        axFilter.type = FilterType.basic;
+        axFilter.gridProperties.x = x;
+        if (event.option._selected) {
+            filters.push(axFilter);
+        }
+        else {
+            filters.forEach((filter, index) => {
+                if (filter.searchNodes[0].expression.field.name === field.name) {
+                    filters[index].isDeleted = true;
+                    filters[index].searchNodes[0].expression.value.isSearchable = false;
+                    this._elementService.refreshElementData();
+                }
+            });
+        }
+        return filters;
+    }
+    /**
+     * Add new filter functionality
+     *
+     * @param appVersion
+     * @param event
+     * @param filters
+     * @returns  filter array
+     */
+    createFilter(appVersion, attribute, scopeType, x) {
+        const field = attribute;
+        const expression = new AxExpression();
+        expression.field = field;
+        expression.valueType = ExpressionValueType.fixed;
+        const searchNode = new SearchNode();
+        searchNode.expression = expression;
+        searchNode.type = ConditionType.condition;
+        const axFilter = new AxFilter();
+        axFilter.type = FilterType.basic;
+        axFilter.scope = ScopeType.global;
+        axFilter.searchNodes.push(searchNode);
+        axFilter.appVersionId = appVersion;
+        axFilter.scope = scopeType;
+        axFilter.type = FilterType.basic;
+        axFilter.gridProperties.x = x;
+        return axFilter;
+    }
+    /**
+     * Delete Filter From Filter List
+     *
+     * @param attribute
+     * @param _filters
+     */
+    deleteFilter(attribute, _filters) {
+        _filters.forEach((filter, index) => {
+            if (filter.searchNodes[0].expression.field.name === attribute.name && filter.searchNodes[0].expression.field.tableName === attribute.tableName) {
+                _filters[index].isDeleted = true;
+                _filters[index].searchNodes[0].expression.value.isSearchable = false;
+                this._elementService.refreshElementData();
+            }
+        });
+    }
+    /**  REMOVE THIS CODE
+     * Add new filter category into report and element filter
+     *
+     * @param appVersion
+     * @param event
+     * @param categories
+     * @returns Filter category array
+     */
+    addFilterCategory(appVersion, event, categories, x) {
+        const categoryFilter = event.option.value;
+        categoryFilter.appVersionId = appVersion;
+        categoryFilter.gridProperties.x = x;
+        if (event.option._selected) {
+            categoryFilter.isDeleted = false;
+            const data = categories.find(category => category.id === categoryFilter.id);
+            if (data === undefined || categories.length === 0) {
+                categories.push(categoryFilter);
+            }
+        }
+        else {
+            categories.forEach((categoryField, index) => {
+                if (categoryField.id === categoryFilter.id) {
+                    categories[index].isDeleted = true;
+                    categories[index].isSearchable = false;
+                    this._elementService.refreshElementData();
+                }
+            });
+        }
+        return categories;
+    }
+    /**
+     * Create New Category Filter
+     *
+     * @param category
+     * @param appVersionId
+     * @param x
+     * @returns
+     */
+    createFilterCategory(category, appVersionId, x) {
+        category.appVersionId = appVersionId;
+        category.gridProperties.x = x;
+        category.isDeleted = false;
+        category.isVisible = true;
+        category.isDefault = false;
+        return category;
+    }
+    /**
+     * Delete Filter Category
+     */
+    deleteFilterCategory(deletedCategory, _categories) {
+        _categories.forEach((category, index) => {
+            if (category.id === deletedCategory.id) {
+                category.isDeleted = true;
+                category.isSearchable = false;
+                this._elementService.refreshElementData();
+            }
+        });
+    }
+}
+ReportFilterService.ɵfac = function ReportFilterService_Factory(t) { return new (t || ReportFilterService)(i0.ɵɵinject(i1.HttpClient), i0.ɵɵinject(i2.ElementService)); };
+ReportFilterService.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: ReportFilterService, factory: ReportFilterService.ɵfac });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ReportFilterService, [{
+        type: Injectable
+    }], function () { return [{ type: i1.HttpClient }, { type: i2.ElementService }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"report-filter.service.js","sourceRoot":"","sources":["../../../../../../../src/ax-common-ui-lib/src/lib/enlighten-lib/report/report-filter/report-filter.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Attribute } from '../../../enlighten-lib/data-model/attribute';\nimport { Injectable } from '@angular/core';\nimport { HttpClient, HttpParams } from '@angular/common/http';\nimport { FilterCategory } from '../../filters/filter-category';\nimport { DataModel } from '../../data-model/data-model';\nimport { AxFilter } from '../../filters/ax-filter';\nimport { AxExpression } from '../../ax-expression/ax-expression';\nimport { SearchNode } from '../../filters/search-node';\nimport { ConditionType, FilterType, ScopeType } from '../../filters/condition-type';\nimport { MatSelectChange } from '@angular/material/select';\nimport { GridSterProperties } from '../../filters/gridster-properties';\nimport { ExpressionValueType } from '../../ax-expression/exp-sub-type';\nimport { ElementService } from '../element.service';\nimport { IAxFilter } from '../../filters/iax-filter';\nimport { WidgetType } from '../../../forms/page/common/widget-enums';\nexport interface ICategory{\n    id: number;\n    name: string;\n    description?: string;\n    isSelected?: string;\n\n}\n\n@Injectable()\nexport class ReportFilterService {\n/**\n * Constructor\n */\n constructor(\n   private _httpClient: HttpClient,\n   private _elementService: ElementService,\n  ) { }\n\n /**\n  * Get Category list by the app-version id\n  *\n  * @param appVersion\n  * @returns filter category array\n  */\n  getCategories(appVersion: number): Promise<Array<FilterCategory>> {\n    return new Promise((resolve, reject) => {\n      let params = new HttpParams();\n      params = params.append('appVersionId', appVersion);\n      this._httpClient.get<[FilterCategory]>('filtercategories', {params: params})\n        .subscribe((response: any) => {\n          resolve(response);\n        }, reject);\n    });\n  }\n  /**\n   * Create filter category object mapping\n   *\n   * @param filterCategory\n   * @returns\n   */\n  createFilterCategoryObject(filterCategory: Array<FilterCategory>): Array<FilterCategory>{\n    const filterCategoryArray = new Array<FilterCategory>();\n    if(filterCategory){\n      filterCategory.forEach((category) => {\n        category.gridProperties = category.gridProperties ? category.gridProperties : new GridSterProperties();\n        filterCategoryArray.push(new FilterCategory(category));\n      });\n    }\n    return filterCategoryArray;\n  }\n\n  /**\n   * check filter category exists into filter\n   *\n   * @param categoryList\n   * @param categories\n   * @returns Filter category list\n   */\n  checkSelectedCategory(appCategories: Array<FilterCategory>,reportCategories: Array<IAxFilter>): Array<FilterCategory>{\n      appCategories.forEach((appCategory, key) => {\n        reportCategories.forEach((reportCategory, filterKey) => {\n          if(reportCategory.id === appCategory.id){\n            appCategory.gridProperties = reportCategory.gridProperties ? reportCategory.gridProperties : new GridSterProperties();\n            appCategory.isSelected = true;\n            if(reportCategory[filterKey]){\n              reportCategory[filterKey].isSelected = true;\n            }\n          }\n        });\n      });\n    return appCategories;\n  }\n\n  /**\n   * Check the attributes are exists in filters\n   *\n   * @param dataModel\n   * @param filters\n   * @returns Data Model details\n   */\n  checkSelectedAttribute(dataModel: DataModel, filters: Array<AxFilter>): DataModel{\n    if(dataModel){\n      dataModel.entities.forEach((entity) => {\n        entity.columns.forEach((column) => {\n          filters.forEach((filter, filterKey) => {\n            const columnName = filters[filterKey].searchNodes[0].expression.field.name;\n            const tableName = filters[filterKey].searchNodes[0].expression.field.tableName;\n            const isTitleColumn = column.label=='title';\n            const isChoiceGuidColumn = column.name=='col_guid' && column.widgetType == WidgetType.textBox;\n            // check the existing  filter attribute with drop down of data model Attribute\n            if(columnName === column.name && tableName === column.tableName && !isTitleColumn && !isChoiceGuidColumn){\n              column.isSelected = true;\n            //   filters[filterKey].searchNodes[0].expression.field = column;\n            }\n          });\n        });\n      });\n      return dataModel;\n    }\n  }\n\n  /**\n   * Add new filter functionality\n   *\n   * @param appVersion\n   * @param event\n   * @param filters\n   * @returns  filter array\n   */\n  addFilter(appVersion: number, event: MatSelectChange | any, filters: Array<AxFilter>, scopeType: number,x: number): Array<AxFilter>{\n    const field = event.option.value;\n    const expression = new AxExpression();\n    expression.field = field;\n    expression.valueType = ExpressionValueType.fixed;\n    const searchNode = new SearchNode();\n    searchNode.expression = expression;\n    searchNode.type = ConditionType.condition;\n    const axFilter = new AxFilter();\n    axFilter.type = FilterType.basic;\n    axFilter.scope = ScopeType.global;\n    axFilter.searchNodes.push(searchNode);\n    axFilter.appVersionId = appVersion;\n    axFilter.scope = scopeType;\n    axFilter.type = FilterType.basic;\n    axFilter.gridProperties.x = x;\n    if(event.option._selected){\n      filters.push(axFilter);\n    }else{\n      filters.forEach((filter, index) => {\n        if(filter.searchNodes[0].expression.field.name === field.name){\n          filters[index].isDeleted = true;\n          filters[index].searchNodes[0].expression.value.isSearchable = false;\n          this._elementService.refreshElementData();\n        }\n      });\n    }\n    return filters;\n  }\n  /**\n   * Add new filter functionality\n   *\n   * @param appVersion\n   * @param event\n   * @param filters\n   * @returns  filter array\n   */\n   createFilter(appVersion: number,attribute: Attribute, scopeType: number,x: number): AxFilter{\n    const field = attribute;\n    const expression = new AxExpression();\n    expression.field = field;\n    expression.valueType = ExpressionValueType.fixed;\n    const searchNode = new SearchNode();\n    searchNode.expression = expression;\n    searchNode.type = ConditionType.condition;\n    const axFilter = new AxFilter();\n    axFilter.type = FilterType.basic;\n    axFilter.scope = ScopeType.global;\n    axFilter.searchNodes.push(searchNode);\n    axFilter.appVersionId = appVersion;\n    axFilter.scope = scopeType;\n    axFilter.type = FilterType.basic;\n    axFilter.gridProperties.x = x;\n    return axFilter;\n  }\n\n  /**\n   * Delete Filter From Filter List\n   *\n   * @param attribute\n   * @param _filters\n   */\n  deleteFilter(attribute: Attribute,_filters: Array<AxFilter>): void{\n    _filters.forEach((filter, index) => {\n        if(filter.searchNodes[0].expression.field.name === attribute.name && filter.searchNodes[0].expression.field.tableName === attribute.tableName){\n          _filters[index].isDeleted = true;\n          _filters[index].searchNodes[0].expression.value.isSearchable = false;\n          this._elementService.refreshElementData();\n        }\n      });\n  }\n\n  /**  REMOVE THIS CODE\n   * Add new filter category into report and element filter\n   *\n   * @param appVersion\n   * @param event\n   * @param categories\n   * @returns Filter category array\n   */\n  addFilterCategory(appVersion: number, event: MatSelectChange | any, categories: Array<FilterCategory>, x: number): Array<FilterCategory>{\n    const categoryFilter = event.option.value;\n    categoryFilter.appVersionId = appVersion;\n    categoryFilter.gridProperties.x = x;\n    if(event.option._selected){\n      categoryFilter.isDeleted = false;\n      const data = categories.find(category => category.id === categoryFilter.id);\n      if(data === undefined || categories.length === 0){\n        categories.push(categoryFilter);\n      }\n    }else{\n      categories.forEach((categoryField, index) =>{\n        if(categoryField.id === categoryFilter.id){\n          categories[index].isDeleted = true;\n          categories[index].isSearchable = false;\n          this._elementService.refreshElementData();\n        }\n      });\n    }\n    return categories;\n  }\n\n  /**\n   * Create New Category Filter\n   *\n   * @param category\n   * @param appVersionId\n   * @param x\n   * @returns\n   */\n  createFilterCategory(category: FilterCategory,appVersionId: number,x: number): FilterCategory{\n    category.appVersionId = appVersionId;\n    category.gridProperties.x = x;\n    category.isDeleted = false;\n    category.isVisible = true;\n    category.isDefault = false;\n    return category;\n  }\n\n  /**\n   * Delete Filter Category\n   */\n  deleteFilterCategory(deletedCategory: FilterCategory,_categories: Array<FilterCategory>): void{\n    _categories.forEach((category, index) =>{\n        if(category.id === deletedCategory.id){\n          category.isDeleted = true;\n          category.isSearchable = false;\n          this._elementService.refreshElementData();\n        }\n    });\n  }\n}\n"]}

package/esm2020/lib/enlighten-lib/report/tabular-report/aggregate.mjs

@@ -0,0 +1,10 @@
+export class Aggregate {
+    constructor(aggregate) {
+        this.showSum = aggregate && aggregate.showSum || false;
+        this.showMax = aggregate && aggregate.showMax || false;
+        this.showMin = aggregate && aggregate.showMin || false;
+        this.showAvg = aggregate && aggregate.showAvg || false;
+        this.showUniqueCount = aggregate && aggregate.showUniqueCount || false;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWdncmVnYXRlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vc3JjL2F4LWNvbW1vbi11aS1saWIvc3JjL2xpYi9lbmxpZ2h0ZW4tbGliL3JlcG9ydC90YWJ1bGFyLXJlcG9ydC9hZ2dyZWdhdGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxPQUFPLFNBQVM7SUFNbEIsWUFBWSxTQUFxQjtRQUM3QixJQUFJLENBQUMsT0FBTyxHQUFFLFNBQVMsSUFBSSxTQUFTLENBQUMsT0FBTyxJQUFJLEtBQUssQ0FBQztRQUN0RCxJQUFJLENBQUMsT0FBTyxHQUFFLFNBQVMsSUFBSSxTQUFTLENBQUMsT0FBTyxJQUFJLEtBQUssQ0FBQztRQUN0RCxJQUFJLENBQUMsT0FBTyxHQUFFLFNBQVMsSUFBSSxTQUFTLENBQUMsT0FBTyxJQUFJLEtBQUssQ0FBQztRQUN0RCxJQUFJLENBQUMsT0FBTyxHQUFFLFNBQVMsSUFBSSxTQUFTLENBQUMsT0FBTyxJQUFJLEtBQUssQ0FBQztRQUN0RCxJQUFJLENBQUMsZUFBZSxHQUFFLFNBQVMsSUFBSSxTQUFTLENBQUMsZUFBZSxJQUFJLEtBQUssQ0FBQztJQUMxRSxDQUFDO0NBQ0oiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgY2xhc3MgQWdncmVnYXRlIHtcbnNob3dTdW06IGJvb2xlYW47XG5zaG93TWF4OiBib29sZWFuO1xuc2hvd01pbjogYm9vbGVhbjtcbnNob3dBdmc6IGJvb2xlYW47XG5zaG93VW5pcXVlQ291bnQ6IGJvb2xlYW47XG4gICAgY29uc3RydWN0b3IoYWdncmVnYXRlPzogQWdncmVnYXRlKXtcbiAgICAgICAgdGhpcy5zaG93U3VtPSBhZ2dyZWdhdGUgJiYgYWdncmVnYXRlLnNob3dTdW0gfHwgZmFsc2U7XG4gICAgICAgIHRoaXMuc2hvd01heD0gYWdncmVnYXRlICYmIGFnZ3JlZ2F0ZS5zaG93TWF4IHx8IGZhbHNlO1xuICAgICAgICB0aGlzLnNob3dNaW49IGFnZ3JlZ2F0ZSAmJiBhZ2dyZWdhdGUuc2hvd01pbiB8fCBmYWxzZTtcbiAgICAgICAgdGhpcy5zaG93QXZnPSBhZ2dyZWdhdGUgJiYgYWdncmVnYXRlLnNob3dBdmcgfHwgZmFsc2U7XG4gICAgICAgIHRoaXMuc2hvd1VuaXF1ZUNvdW50PSBhZ2dyZWdhdGUgJiYgYWdncmVnYXRlLnNob3dVbmlxdWVDb3VudCB8fCBmYWxzZTtcbiAgICB9XG59XG4iXX0=

package/esm2020/lib/enlighten-lib/report/tabular-report/axo-percentage.pipe.mjs

@@ -0,0 +1,26 @@
+import { Pipe } from '@angular/core';
+import * as i0 from "@angular/core";
+export class AxoPercentagePipe {
+    transform(_number, series, type) {
+        if (type === 'detail') {
+            let total = 0;
+            for (const data of series) {
+                total += Number(data);
+            }
+            const percentage = (parseFloat((_number * 100 / total).toFixed(4)));
+            return (percentage + '%');
+        }
+        else if (type === 'column') {
+            return (_number + '%');
+        }
+    }
+}
+AxoPercentagePipe.ɵfac = function AxoPercentagePipe_Factory(t) { return new (t || AxoPercentagePipe)(); };
+AxoPercentagePipe.ɵpipe = /*@__PURE__*/ i0.ɵɵdefinePipe({ name: "axoPercentage", type: AxoPercentagePipe, pure: true });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(AxoPercentagePipe, [{
+        type: Pipe,
+        args: [{
+                name: 'axoPercentage'
+            }]
+    }], null, null); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXhvLXBlcmNlbnRhZ2UucGlwZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3NyYy9heC1jb21tb24tdWktbGliL3NyYy9saWIvZW5saWdodGVuLWxpYi9yZXBvcnQvdGFidWxhci1yZXBvcnQvYXhvLXBlcmNlbnRhZ2UucGlwZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsSUFBSSxFQUFpQixNQUFNLGVBQWUsQ0FBQzs7QUFLcEQsTUFBTSxPQUFPLGlCQUFpQjtJQUU1QixTQUFTLENBQUMsT0FBZSxFQUFFLE1BQWMsRUFBRSxJQUFZO1FBQ3JELElBQUcsSUFBSSxLQUFHLFFBQVEsRUFBQztZQUNqQixJQUFJLEtBQUssR0FBRyxDQUFDLENBQUM7WUFDZCxLQUFJLE1BQU0sSUFBSSxJQUFJLE1BQU0sRUFBQztnQkFDdkIsS0FBSyxJQUFJLE1BQU0sQ0FBQyxJQUFJLENBQUMsQ0FBQzthQUN2QjtZQUNELE1BQU0sVUFBVSxHQUFDLENBQUMsVUFBVSxDQUFDLENBQUMsT0FBTyxHQUFDLEdBQUcsR0FBQyxLQUFLLENBQUMsQ0FBQyxPQUFPLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDO1lBQzlELE9BQU8sQ0FBQyxVQUFVLEdBQUMsR0FBRyxDQUFDLENBQUM7U0FDekI7YUFDSSxJQUFHLElBQUksS0FBRyxRQUFRLEVBQUM7WUFDdEIsT0FBTSxDQUFDLE9BQU8sR0FBQyxHQUFHLENBQUMsQ0FBQztTQUNyQjtJQUNILENBQUM7O2tGQWRVLGlCQUFpQjt1RkFBakIsaUJBQWlCO3VGQUFqQixpQkFBaUI7Y0FIN0IsSUFBSTtlQUFDO2dCQUNKLElBQUksRUFBRSxlQUFlO2FBQ3RCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgUGlwZSwgUGlwZVRyYW5zZm9ybSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5AUGlwZSh7XG4gIG5hbWU6ICdheG9QZXJjZW50YWdlJ1xufSlcbmV4cG9ydCBjbGFzcyBBeG9QZXJjZW50YWdlUGlwZSBpbXBsZW1lbnRzIFBpcGVUcmFuc2Zvcm0ge1xuXG4gIHRyYW5zZm9ybShfbnVtYmVyOiBudW1iZXIsIHNlcmllczogc3RyaW5nLCB0eXBlOiBzdHJpbmcpOiBzdHJpbmcge1xuICAgIGlmKHR5cGU9PT0nZGV0YWlsJyl7XG4gICAgICBsZXQgdG90YWwgPSAwO1xuICAgICAgZm9yKGNvbnN0IGRhdGEgb2Ygc2VyaWVzKXtcbiAgICAgICAgdG90YWwgKz0gTnVtYmVyKGRhdGEpO1xuICAgICAgfVxuICAgICAgY29uc3QgcGVyY2VudGFnZT0ocGFyc2VGbG9hdCgoX251bWJlcioxMDAvdG90YWwpLnRvRml4ZWQoNCkpKTtcbiAgICAgIHJldHVybiAocGVyY2VudGFnZSsnJScpO1xuICAgIH1cbiAgICBlbHNlIGlmKHR5cGU9PT0nY29sdW1uJyl7XG4gICAgICByZXR1cm4oX251bWJlcisnJScpO1xuICAgIH1cbiAgfVxuXG59XG4iXX0=

package/esm2020/lib/enlighten-lib/report/tabular-report/column-style.mjs

@@ -0,0 +1,7 @@
+export class ColumnStyle {
+    constructor(columnStyle) {
+        this.oddColor = columnStyle && columnStyle.oddColor || '#FFFFFF';
+        this.evenColor = columnStyle && columnStyle.evenColor || '#FFFFFF';
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29sdW1uLXN0eWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vc3JjL2F4LWNvbW1vbi11aS1saWIvc3JjL2xpYi9lbmxpZ2h0ZW4tbGliL3JlcG9ydC90YWJ1bGFyLXJlcG9ydC9jb2x1bW4tc3R5bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxPQUFPLFdBQVc7SUFHcEIsWUFBWSxXQUF5QjtRQUNqQyxJQUFJLENBQUMsUUFBUSxHQUFDLFdBQVcsSUFBSSxXQUFXLENBQUMsUUFBUSxJQUFJLFNBQVMsQ0FBQztRQUMvRCxJQUFJLENBQUMsU0FBUyxHQUFDLFdBQVcsSUFBSSxXQUFXLENBQUMsU0FBUyxJQUFJLFNBQVMsQ0FBQztJQUNyRSxDQUFDO0NBQ0oiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgY2xhc3MgQ29sdW1uU3R5bGV7XG4gICAgb2RkQ29sb3I6IHN0cmluZztcbiAgICBldmVuQ29sb3I6IHN0cmluZztcbiAgICBjb25zdHJ1Y3Rvcihjb2x1bW5TdHlsZT86IENvbHVtblN0eWxlKXtcbiAgICAgICAgdGhpcy5vZGRDb2xvcj1jb2x1bW5TdHlsZSAmJiBjb2x1bW5TdHlsZS5vZGRDb2xvciB8fCAnI0ZGRkZGRic7XG4gICAgICAgIHRoaXMuZXZlbkNvbG9yPWNvbHVtblN0eWxlICYmIGNvbHVtblN0eWxlLmV2ZW5Db2xvciB8fCAnI0ZGRkZGRic7XG4gICAgfVxufVxuIl19

package/esm2020/lib/enlighten-lib/report/tabular-report/itabular-report.component.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaXRhYnVsYXItcmVwb3J0LmNvbXBvbmVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3NyYy9heC1jb21tb24tdWktbGliL3NyYy9saWIvZW5saWdodGVuLWxpYi9yZXBvcnQvdGFidWxhci1yZXBvcnQvaXRhYnVsYXItcmVwb3J0LmNvbXBvbmVudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgVGFidWxhclJlcG9ydCB9IGZyb20gJy4vdGFidWxhci1yZXBvcnQnO1xuaW1wb3J0IHsgU2NyZWVuVHlwZSB9IGZyb20gJy4uLy4uLy4uL2VubGlnaHRlbi1saWIvZmlsdGVycy9jb25kaXRpb24tdHlwZSc7XG5pbXBvcnQgeyBBeEZpbHRlciB9IGZyb20gJy4uLy4uL2ZpbHRlcnMvYXgtZmlsdGVyJztcblxuZXhwb3J0IGludGVyZmFjZSBJVGFidWxhclJlcG9ydENvbXBvbmVudCB7XG4gIFx0aXNFZGl0YWJsZTogYm9vbGVhbjtcblx0dGFidWxhclJlcG9ydDogVGFidWxhclJlcG9ydDtcblx0aXNEaXJ0eTogYm9vbGVhbjtcblx0eDFJbWFnZU1lZGlhVXJsOiBzdHJpbmc7XG5cdGVsZW1lbnRHdWlkOiBzdHJpbmc7XG5cdHNjcmVlblR5cGU6IFNjcmVlblR5cGU7XG5cdGRyaWxsVGhyb3VnaFBhcmVudFR5cGU6IFNjcmVlblR5cGU7XG5cdGRyaWxsVGhyb3VnaEZpbHRlcklucHV0OiBBeEZpbHRlcjtcblx0dXNlckVtYWlsOiBzdHJpbmc7XG5cdHgxTWVkaWFVcmw6IHN0cmluZztcblx0YXBwVmVyc2lvbklkOm51bWJlcjtcbn1cbiJdfQ==

package/esm2020/lib/enlighten-lib/report/tabular-report/orderby-type.mjs

@@ -0,0 +1,7 @@
+export var OrderByType;
+(function (OrderByType) {
+    OrderByType[OrderByType["ascending"] = 1] = "ascending";
+    OrderByType[OrderByType["descending"] = 2] = "descending";
+    OrderByType[OrderByType["none"] = 3] = "none";
+})(OrderByType || (OrderByType = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3JkZXJieS10eXBlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vc3JjL2F4LWNvbW1vbi11aS1saWIvc3JjL2xpYi9lbmxpZ2h0ZW4tbGliL3JlcG9ydC90YWJ1bGFyLXJlcG9ydC9vcmRlcmJ5LXR5cGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxDQUFOLElBQVksV0FJWDtBQUpELFdBQVksV0FBVztJQUNuQix1REFBVyxDQUFBO0lBQ1gseURBQVksQ0FBQTtJQUNaLDZDQUFNLENBQUE7QUFDVixDQUFDLEVBSlcsV0FBVyxLQUFYLFdBQVcsUUFJdEIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgZW51bSBPcmRlckJ5VHlwZXtcbiAgICBhc2NlbmRpbmc9MSxcbiAgICBkZXNjZW5kaW5nPTIsXG4gICAgbm9uZT0zXG59XG4iXX0=

package/esm2020/lib/enlighten-lib/report/tabular-report/row-style.mjs

@@ -0,0 +1,7 @@
+export class RowStyle {
+    constructor(rowStyle) {
+        this.oddColor = rowStyle && rowStyle.oddColor || '#FFFFFF';
+        this.evenColor = rowStyle && rowStyle.evenColor || '#FFFFFF';
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicm93LXN0eWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vc3JjL2F4LWNvbW1vbi11aS1saWIvc3JjL2xpYi9lbmxpZ2h0ZW4tbGliL3JlcG9ydC90YWJ1bGFyLXJlcG9ydC9yb3ctc3R5bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxPQUFPLFFBQVE7SUFHakIsWUFBWSxRQUFtQjtRQUMzQixJQUFJLENBQUMsUUFBUSxHQUFDLFFBQVEsSUFBSSxRQUFRLENBQUMsUUFBUSxJQUFJLFNBQVMsQ0FBQztRQUN6RCxJQUFJLENBQUMsU0FBUyxHQUFDLFFBQVEsSUFBSSxRQUFRLENBQUMsU0FBUyxJQUFJLFNBQVMsQ0FBQztJQUMvRCxDQUFDO0NBQ0oiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgY2xhc3MgUm93U3R5bGV7XG4gICAgb2RkQ29sb3I6IHN0cmluZztcbiAgICBldmVuQ29sb3I6IHN0cmluZztcbiAgICBjb25zdHJ1Y3Rvcihyb3dTdHlsZT86IFJvd1N0eWxlKXtcbiAgICAgICAgdGhpcy5vZGRDb2xvcj1yb3dTdHlsZSAmJiByb3dTdHlsZS5vZGRDb2xvciB8fCAnI0ZGRkZGRic7XG4gICAgICAgIHRoaXMuZXZlbkNvbG9yPXJvd1N0eWxlICYmIHJvd1N0eWxlLmV2ZW5Db2xvciB8fCAnI0ZGRkZGRic7XG4gICAgfVxufVxuIl19

package/esm2020/lib/enlighten-lib/report/tabular-report/table-style.mjs

@@ -0,0 +1,47 @@
+import { Border } from '../graphical-report/chart/border';
+import { TextStyle } from '../graphical-report/chart/text-style';
+import { ColumnStyle } from './column-style';
+import { RowStyle } from './row-style';
+export class TableStyle {
+    constructor(tableStyle) {
+        if (tableStyle) {
+            this.tableStyle(tableStyle);
+        }
+        else {
+            this.newTableStyle();
+        }
+    }
+    //function to create new table style object
+    newTableStyle() {
+        this.border = new Border();
+        this.border.ManipulateObjectForTabular();
+        this.rowStyle = new RowStyle();
+        this.columnStyle = new ColumnStyle();
+        this.header = new TextStyle();
+        this.header.backgroundColor = '#F2F8FF';
+        this.body = new TextStyle();
+        this.body.backgroundColor = '#FFFFFF';
+        this.body.textSize = 12;
+        this.footer = new TextStyle();
+        this.footer.backgroundColor = '#DEEEFF';
+        this.subFooter = new TextStyle();
+        this.subFooter.backgroundColor = '#F5FAFF';
+        this.subHeader = new TextStyle();
+        this.subHeader.backgroundColor = '#F2F8FF';
+    }
+    /**function to create table style object with existing values
+    *
+    *@param TableStyle
+    */
+    tableStyle(tableStyle) {
+        this.border = new Border(tableStyle.border);
+        this.rowStyle = new RowStyle(tableStyle.rowStyle);
+        this.columnStyle = new ColumnStyle(tableStyle.columnStyle);
+        this.header = new TextStyle(tableStyle.header);
+        this.body = new TextStyle(tableStyle.body);
+        this.footer = new TextStyle(tableStyle.footer);
+        this.subFooter = new TextStyle(tableStyle.subFooter);
+        this.subHeader = new TextStyle(tableStyle.subHeader);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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