ax-common-ui-lib 1.0.0-qa.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-app-common-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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWdncmVnYXRlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vc3JjL2F4LWFwcC1jb21tb24tbGliL3NyYy9saWIvZW5saWdodGVuLWxpYi9yZXBvcnQvdGFidWxhci1yZXBvcnQvYWdncmVnYXRlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sT0FBTyxTQUFTO0lBTWxCLFlBQVksU0FBcUI7UUFDN0IsSUFBSSxDQUFDLE9BQU8sR0FBRSxTQUFTLElBQUksU0FBUyxDQUFDLE9BQU8sSUFBSSxLQUFLLENBQUM7UUFDdEQsSUFBSSxDQUFDLE9BQU8sR0FBRSxTQUFTLElBQUksU0FBUyxDQUFDLE9BQU8sSUFBSSxLQUFLLENBQUM7UUFDdEQsSUFBSSxDQUFDLE9BQU8sR0FBRSxTQUFTLElBQUksU0FBUyxDQUFDLE9BQU8sSUFBSSxLQUFLLENBQUM7UUFDdEQsSUFBSSxDQUFDLE9BQU8sR0FBRSxTQUFTLElBQUksU0FBUyxDQUFDLE9BQU8sSUFBSSxLQUFLLENBQUM7UUFDdEQsSUFBSSxDQUFDLGVBQWUsR0FBRSxTQUFTLElBQUksU0FBUyxDQUFDLGVBQWUsSUFBSSxLQUFLLENBQUM7SUFDMUUsQ0FBQztDQUNKIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGNsYXNzIEFnZ3JlZ2F0ZSB7XG5zaG93U3VtOiBib29sZWFuO1xuc2hvd01heDogYm9vbGVhbjtcbnNob3dNaW46IGJvb2xlYW47XG5zaG93QXZnOiBib29sZWFuO1xuc2hvd1VuaXF1ZUNvdW50OiBib29sZWFuO1xuICAgIGNvbnN0cnVjdG9yKGFnZ3JlZ2F0ZT86IEFnZ3JlZ2F0ZSl7XG4gICAgICAgIHRoaXMuc2hvd1N1bT0gYWdncmVnYXRlICYmIGFnZ3JlZ2F0ZS5zaG93U3VtIHx8IGZhbHNlO1xuICAgICAgICB0aGlzLnNob3dNYXg9IGFnZ3JlZ2F0ZSAmJiBhZ2dyZWdhdGUuc2hvd01heCB8fCBmYWxzZTtcbiAgICAgICAgdGhpcy5zaG93TWluPSBhZ2dyZWdhdGUgJiYgYWdncmVnYXRlLnNob3dNaW4gfHwgZmFsc2U7XG4gICAgICAgIHRoaXMuc2hvd0F2Zz0gYWdncmVnYXRlICYmIGFnZ3JlZ2F0ZS5zaG93QXZnIHx8IGZhbHNlO1xuICAgICAgICB0aGlzLnNob3dVbmlxdWVDb3VudD0gYWdncmVnYXRlICYmIGFnZ3JlZ2F0ZS5zaG93VW5pcXVlQ291bnQgfHwgZmFsc2U7XG4gICAgfVxufVxuIl19

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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXhvLXBlcmNlbnRhZ2UucGlwZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3NyYy9heC1hcHAtY29tbW9uLWxpYi9zcmMvbGliL2VubGlnaHRlbi1saWIvcmVwb3J0L3RhYnVsYXItcmVwb3J0L2F4by1wZXJjZW50YWdlLnBpcGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLElBQUksRUFBaUIsTUFBTSxlQUFlLENBQUM7O0FBS3BELE1BQU0sT0FBTyxpQkFBaUI7SUFFNUIsU0FBUyxDQUFDLE9BQWUsRUFBRSxNQUFjLEVBQUUsSUFBWTtRQUNyRCxJQUFHLElBQUksS0FBRyxRQUFRLEVBQUM7WUFDakIsSUFBSSxLQUFLLEdBQUcsQ0FBQyxDQUFDO1lBQ2QsS0FBSSxNQUFNLElBQUksSUFBSSxNQUFNLEVBQUM7Z0JBQ3ZCLEtBQUssSUFBSSxNQUFNLENBQUMsSUFBSSxDQUFDLENBQUM7YUFDdkI7WUFDRCxNQUFNLFVBQVUsR0FBQyxDQUFDLFVBQVUsQ0FBQyxDQUFDLE9BQU8sR0FBQyxHQUFHLEdBQUMsS0FBSyxDQUFDLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQztZQUM5RCxPQUFPLENBQUMsVUFBVSxHQUFDLEdBQUcsQ0FBQyxDQUFDO1NBQ3pCO2FBQ0ksSUFBRyxJQUFJLEtBQUcsUUFBUSxFQUFDO1lBQ3RCLE9BQU0sQ0FBQyxPQUFPLEdBQUMsR0FBRyxDQUFDLENBQUM7U0FDckI7SUFDSCxDQUFDOztrRkFkVSxpQkFBaUI7dUZBQWpCLGlCQUFpQjt1RkFBakIsaUJBQWlCO2NBSDdCLElBQUk7ZUFBQztnQkFDSixJQUFJLEVBQUUsZUFBZTthQUN0QiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFBpcGUsIFBpcGVUcmFuc2Zvcm0gfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuQFBpcGUoe1xuICBuYW1lOiAnYXhvUGVyY2VudGFnZSdcbn0pXG5leHBvcnQgY2xhc3MgQXhvUGVyY2VudGFnZVBpcGUgaW1wbGVtZW50cyBQaXBlVHJhbnNmb3JtIHtcblxuICB0cmFuc2Zvcm0oX251bWJlcjogbnVtYmVyLCBzZXJpZXM6IHN0cmluZywgdHlwZTogc3RyaW5nKTogc3RyaW5nIHtcbiAgICBpZih0eXBlPT09J2RldGFpbCcpe1xuICAgICAgbGV0IHRvdGFsID0gMDtcbiAgICAgIGZvcihjb25zdCBkYXRhIG9mIHNlcmllcyl7XG4gICAgICAgIHRvdGFsICs9IE51bWJlcihkYXRhKTtcbiAgICAgIH1cbiAgICAgIGNvbnN0IHBlcmNlbnRhZ2U9KHBhcnNlRmxvYXQoKF9udW1iZXIqMTAwL3RvdGFsKS50b0ZpeGVkKDQpKSk7XG4gICAgICByZXR1cm4gKHBlcmNlbnRhZ2UrJyUnKTtcbiAgICB9XG4gICAgZWxzZSBpZih0eXBlPT09J2NvbHVtbicpe1xuICAgICAgcmV0dXJuKF9udW1iZXIrJyUnKTtcbiAgICB9XG4gIH1cblxufVxuIl19

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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29sdW1uLXN0eWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vc3JjL2F4LWFwcC1jb21tb24tbGliL3NyYy9saWIvZW5saWdodGVuLWxpYi9yZXBvcnQvdGFidWxhci1yZXBvcnQvY29sdW1uLXN0eWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sT0FBTyxXQUFXO0lBR3BCLFlBQVksV0FBeUI7UUFDakMsSUFBSSxDQUFDLFFBQVEsR0FBQyxXQUFXLElBQUksV0FBVyxDQUFDLFFBQVEsSUFBSSxTQUFTLENBQUM7UUFDL0QsSUFBSSxDQUFDLFNBQVMsR0FBQyxXQUFXLElBQUksV0FBVyxDQUFDLFNBQVMsSUFBSSxTQUFTLENBQUM7SUFDckUsQ0FBQztDQUNKIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGNsYXNzIENvbHVtblN0eWxle1xuICAgIG9kZENvbG9yOiBzdHJpbmc7XG4gICAgZXZlbkNvbG9yOiBzdHJpbmc7XG4gICAgY29uc3RydWN0b3IoY29sdW1uU3R5bGU/OiBDb2x1bW5TdHlsZSl7XG4gICAgICAgIHRoaXMub2RkQ29sb3I9Y29sdW1uU3R5bGUgJiYgY29sdW1uU3R5bGUub2RkQ29sb3IgfHwgJyNGRkZGRkYnO1xuICAgICAgICB0aGlzLmV2ZW5Db2xvcj1jb2x1bW5TdHlsZSAmJiBjb2x1bW5TdHlsZS5ldmVuQ29sb3IgfHwgJyNGRkZGRkYnO1xuICAgIH1cbn1cbiJdfQ==

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

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

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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3JkZXJieS10eXBlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vc3JjL2F4LWFwcC1jb21tb24tbGliL3NyYy9saWIvZW5saWdodGVuLWxpYi9yZXBvcnQvdGFidWxhci1yZXBvcnQvb3JkZXJieS10eXBlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sQ0FBTixJQUFZLFdBSVg7QUFKRCxXQUFZLFdBQVc7SUFDbkIsdURBQVcsQ0FBQTtJQUNYLHlEQUFZLENBQUE7SUFDWiw2Q0FBTSxDQUFBO0FBQ1YsQ0FBQyxFQUpXLFdBQVcsS0FBWCxXQUFXLFFBSXRCIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGVudW0gT3JkZXJCeVR5cGV7XG4gICAgYXNjZW5kaW5nPTEsXG4gICAgZGVzY2VuZGluZz0yLFxuICAgIG5vbmU9M1xufVxuIl19

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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicm93LXN0eWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vc3JjL2F4LWFwcC1jb21tb24tbGliL3NyYy9saWIvZW5saWdodGVuLWxpYi9yZXBvcnQvdGFidWxhci1yZXBvcnQvcm93LXN0eWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sT0FBTyxRQUFRO0lBR2pCLFlBQVksUUFBbUI7UUFDM0IsSUFBSSxDQUFDLFFBQVEsR0FBQyxRQUFRLElBQUksUUFBUSxDQUFDLFFBQVEsSUFBSSxTQUFTLENBQUM7UUFDekQsSUFBSSxDQUFDLFNBQVMsR0FBQyxRQUFRLElBQUksUUFBUSxDQUFDLFNBQVMsSUFBSSxTQUFTLENBQUM7SUFDL0QsQ0FBQztDQUNKIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGNsYXNzIFJvd1N0eWxle1xuICAgIG9kZENvbG9yOiBzdHJpbmc7XG4gICAgZXZlbkNvbG9yOiBzdHJpbmc7XG4gICAgY29uc3RydWN0b3Iocm93U3R5bGU/OiBSb3dTdHlsZSl7XG4gICAgICAgIHRoaXMub2RkQ29sb3I9cm93U3R5bGUgJiYgcm93U3R5bGUub2RkQ29sb3IgfHwgJyNGRkZGRkYnO1xuICAgICAgICB0aGlzLmV2ZW5Db2xvcj1yb3dTdHlsZSAmJiByb3dTdHlsZS5ldmVuQ29sb3IgfHwgJyNGRkZGRkYnO1xuICAgIH1cbn1cbiJdfQ==

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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