@annalib/anna-core 20.3.0 → 20.3.2

package/esm2022/lib/anna-core-shared-lib/services/anna-generic-table.service.mjs

@@ -0,0 +1,149 @@
+import { Injectable } from "@angular/core";
+import { ActivatedRoute, Router } from "@angular/router";
+import { cloneDeep } from "lodash-es";
+import { Subject } from "rxjs";
+import { AnnaFilterService } from "./anna-filter.service";
+import { AnnaSortService } from "./anna-sort.service";
+import * as i0 from "@angular/core";
+import * as i1 from "./anna-filter.service";
+import * as i2 from "@angular/router";
+import * as i3 from "./anna-sort.service";
+export class AnnaGtHelperService {
+    constructor(annaFilterService, router, route, annaSortService) {
+        this.annaFilterService = annaFilterService;
+        this.router = router;
+        this.route = route;
+        this.annaSortService = annaSortService;
+        this.virtualScrollSubject = new Subject();
+    }
+    calculateNumberOfSkeletonColumnsForTable(tableHeaders) {
+        const numberOfSkeletonColumns = [];
+        let headersInEachColumn = 0;
+        tableHeaders.forEach((column) => {
+            if (column.visible) {
+                headersInEachColumn = 0;
+                column.headerInfo.forEach(() => {
+                    headersInEachColumn += 1;
+                });
+                numberOfSkeletonColumns.push(Array(headersInEachColumn).fill(0));
+            }
+        });
+        return numberOfSkeletonColumns;
+    }
+    initColumnFilterAndSorting() {
+        this.annaFilterService.tooltipSelectedMap = new Map();
+        this.annaFilterService.selectedRadio = null;
+        this.annaFilterService.appliedFiltersArray = [];
+        this.annaFilterService.initialValueMap = new Map();
+        this.annaSortService.columnSortState = new Map();
+        this.annaSortService.noSortingAppliedData = [];
+    }
+    enableOrDisableClearAllBtn() {
+        const isFilterApplied = this.annaFilterService.appliedFiltersArray.length > 0;
+        const isSortApplied = this.isSortingAppliedToTable();
+        return !(isFilterApplied || isSortApplied);
+    }
+    updateFiltersInURL() {
+        const latestQueryParams = this.prepareQueryParamsOnFilter();
+        if (Object.keys(latestQueryParams).length > 0) {
+            this.router.navigate([], {
+                queryParams: { filters: JSON.stringify(latestQueryParams) },
+                relativeTo: this.route.parent,
+                queryParamsHandling: "merge",
+            });
+        }
+        else {
+            this.router.navigate([], {
+                relativeTo: this.route.parent,
+            });
+        }
+    }
+    prepareQueryParamsOnFilter() {
+        const query = {};
+        if (this.annaFilterService.appliedFiltersArray.length > 0) {
+            query.appliedFilters = this.annaFilterService.appliedFiltersArray;
+            query.selectedFilterData = JSON.stringify(Array.from(this.annaFilterService.tooltipSelectedMap));
+        }
+        if (this.checkIfSortingIsApplied()) {
+            query.sortState = JSON.stringify(Array.from(this.annaSortService.columnSortState));
+        }
+        return query;
+    }
+    checkIfSortingIsApplied() {
+        let isSortingApplied = false;
+        this.annaSortService.columnSortState.forEach((value, key) => {
+            if (value === "ASC" || value === "DESC") {
+                isSortingApplied = true;
+            }
+        });
+        return isSortingApplied;
+    }
+    initTableFilters(clonedTableData) {
+        this.annaFilterService.tooltipSelectedMap = new Map();
+        this.annaFilterService.selectedRadio = null;
+        this.annaFilterService.appliedFiltersArray = [];
+        this.annaSortService.columnSortState = new Map();
+        this.annaSortService.noSortingAppliedData = cloneDeep(clonedTableData);
+        this.annaFilterService.updateStateOfAllTheKeys(this.annaSortService.columnSortState);
+    }
+    initFilters() {
+        this.annaFilterService.tooltipSelectedMap = new Map();
+        this.annaFilterService.appliedFiltersArray = [];
+    }
+    setDataAsPerPersistingFilter(isPersistingFilter, clonedTable, filters) {
+        let usersTable;
+        if (isPersistingFilter) {
+            usersTable = this.annaFilterService.filterData(clonedTable, "");
+            this.annaSortService.noSortingAppliedData = cloneDeep(usersTable);
+        }
+        else {
+            usersTable = clonedTable;
+            this.annaSortService.noSortingAppliedData = cloneDeep(usersTable);
+        }
+        if (filters?.sortState) {
+            this.annaSortService.columnSortState = new Map(JSON.parse(filters.sortState));
+            usersTable = this.callSort(usersTable);
+        }
+        this.annaFilterService.updateStateOfAllTheKeys(this.annaSortService.columnSortState);
+        return usersTable;
+    }
+    callSort(usersTable) {
+        let sortedUsersTableData = usersTable;
+        this.annaSortService.columnSortState.forEach((value, key) => {
+            if (value === "ASC") {
+                sortedUsersTableData = this.annaSortService.sortDataForComponentOtherThanLurAndCsrPage(true, usersTable, key);
+            }
+            else if (value === "DESC") {
+                sortedUsersTableData = this.annaSortService.sortDataForComponentOtherThanLurAndCsrPage(false, usersTable, key);
+            }
+        });
+        return sortedUsersTableData;
+    }
+    isSortingAppliedToTable() {
+        let isSortingApplied = false;
+        this.annaSortService.columnSortState.forEach((value, key) => {
+            if (value === "ASC" || value === "DESC") {
+                isSortingApplied = true;
+            }
+        });
+        return isSortingApplied;
+    }
+    updateQueryParamsFilter(key, value, operation, queryParamObj) {
+        if (operation === "ADD") {
+            queryParamObj[key] = value;
+        }
+        else if (operation === "DELETE") {
+            delete queryParamObj[key];
+        }
+        return queryParamObj;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AnnaGtHelperService, deps: [{ token: i1.AnnaFilterService }, { token: i2.Router }, { token: i2.ActivatedRoute }, { token: i3.AnnaSortService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AnnaGtHelperService, providedIn: "root" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AnnaGtHelperService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root",
+                }]
+        }], ctorParameters: function () { return [{ type: i1.AnnaFilterService }, { type: i2.Router }, { type: i2.ActivatedRoute }, { type: i3.AnnaSortService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"anna-generic-table.service.js","sourceRoot":"","sources":["../../../../../../projects/anna-core/src/lib/anna-core-shared-lib/services/anna-generic-table.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from \"@angular/core\";\r\nimport { ActivatedRoute, Router } from \"@angular/router\";\r\nimport { cloneDeep } from \"lodash-es\";\r\nimport { Subject } from \"rxjs\";\r\n\r\nimport { AnnaFilterService } from \"./anna-filter.service\";\r\nimport { AnnaSortService } from \"./anna-sort.service\";\r\n\r\n@Injectable({\r\n    providedIn: \"root\",\r\n})\r\nexport class AnnaGtHelperService {\r\n    virtualScrollSubject = new Subject();\r\n    constructor(\r\n        private annaFilterService: AnnaFilterService,\r\n        private router: Router,\r\n        private route: ActivatedRoute,\r\n        private annaSortService: AnnaSortService,\r\n    ) {}\r\n\r\n    calculateNumberOfSkeletonColumnsForTable(tableHeaders: any[]): number[][] {\r\n        const numberOfSkeletonColumns: any[][] = [];\r\n        let headersInEachColumn = 0;\r\n        tableHeaders.forEach((column) => {\r\n            if (column.visible) {\r\n                headersInEachColumn = 0;\r\n                column.headerInfo.forEach(() => {\r\n                    headersInEachColumn += 1;\r\n                });\r\n                numberOfSkeletonColumns.push(Array(headersInEachColumn).fill(0));\r\n            }\r\n        });\r\n        return numberOfSkeletonColumns;\r\n    }\r\n\r\n    initColumnFilterAndSorting() {\r\n        this.annaFilterService.tooltipSelectedMap = new Map();\r\n        this.annaFilterService.selectedRadio = null;\r\n        this.annaFilterService.appliedFiltersArray = [];\r\n        this.annaFilterService.initialValueMap = new Map();\r\n        this.annaSortService.columnSortState = new Map();\r\n        this.annaSortService.noSortingAppliedData = [];\r\n    }\r\n\r\n    enableOrDisableClearAllBtn(): boolean {\r\n        const isFilterApplied = this.annaFilterService.appliedFiltersArray.length > 0;\r\n        const isSortApplied = this.isSortingAppliedToTable();\r\n\r\n        return !(isFilterApplied || isSortApplied);\r\n    }\r\n\r\n    updateFiltersInURL() {\r\n        const latestQueryParams = this.prepareQueryParamsOnFilter();\r\n\r\n        if (Object.keys(latestQueryParams).length > 0) {\r\n            this.router.navigate([], {\r\n                queryParams: { filters: JSON.stringify(latestQueryParams) },\r\n                relativeTo: this.route.parent,\r\n                queryParamsHandling: \"merge\",\r\n            });\r\n        } else {\r\n            this.router.navigate([], {\r\n                relativeTo: this.route.parent,\r\n            });\r\n        }\r\n    }\r\n\r\n    prepareQueryParamsOnFilter() {\r\n        const query: any = {};\r\n\r\n        if (this.annaFilterService.appliedFiltersArray.length > 0) {\r\n            query.appliedFilters = this.annaFilterService.appliedFiltersArray;\r\n            query.selectedFilterData = JSON.stringify(Array.from(this.annaFilterService.tooltipSelectedMap));\r\n        }\r\n\r\n        if (this.checkIfSortingIsApplied()) {\r\n            query.sortState = JSON.stringify(Array.from(this.annaSortService.columnSortState));\r\n        }\r\n\r\n        return query;\r\n    }\r\n\r\n    checkIfSortingIsApplied() {\r\n        let isSortingApplied = false;\r\n        this.annaSortService.columnSortState.forEach((value, key) => {\r\n            if (value === \"ASC\" || value === \"DESC\") {\r\n                isSortingApplied = true;\r\n            }\r\n        });\r\n\r\n        return isSortingApplied;\r\n    }\r\n\r\n    initTableFilters(clonedTableData: any) {\r\n        this.annaFilterService.tooltipSelectedMap = new Map();\r\n        this.annaFilterService.selectedRadio = null;\r\n        this.annaFilterService.appliedFiltersArray = [];\r\n\r\n        this.annaSortService.columnSortState = new Map();\r\n\r\n        this.annaSortService.noSortingAppliedData = cloneDeep(clonedTableData);\r\n        this.annaFilterService.updateStateOfAllTheKeys(this.annaSortService.columnSortState);\r\n    }\r\n\r\n    initFilters() {\r\n        this.annaFilterService.tooltipSelectedMap = new Map();\r\n        this.annaFilterService.appliedFiltersArray = [];\r\n    }\r\n\r\n    setDataAsPerPersistingFilter(isPersistingFilter: boolean, clonedTable: any, filters: any): any {\r\n        let usersTable;\r\n        if (isPersistingFilter) {\r\n            usersTable = this.annaFilterService.filterData(clonedTable, \"\");\r\n            this.annaSortService.noSortingAppliedData = cloneDeep(usersTable);\r\n        } else {\r\n            usersTable = clonedTable;\r\n            this.annaSortService.noSortingAppliedData = cloneDeep(usersTable);\r\n        }\r\n\r\n        if (filters?.sortState) {\r\n            this.annaSortService.columnSortState = new Map(JSON.parse(filters.sortState));\r\n            usersTable = this.callSort(usersTable);\r\n        }\r\n\r\n        this.annaFilterService.updateStateOfAllTheKeys(this.annaSortService.columnSortState);\r\n\r\n        return usersTable;\r\n    }\r\n\r\n    callSort(usersTable: any): any {\r\n        let sortedUsersTableData = usersTable;\r\n        this.annaSortService.columnSortState.forEach((value, key) => {\r\n            if (value === \"ASC\") {\r\n                sortedUsersTableData = this.annaSortService.sortDataForComponentOtherThanLurAndCsrPage(\r\n                    true,\r\n                    usersTable,\r\n                    key,\r\n                );\r\n            } else if (value === \"DESC\") {\r\n                sortedUsersTableData = this.annaSortService.sortDataForComponentOtherThanLurAndCsrPage(\r\n                    false,\r\n                    usersTable,\r\n                    key,\r\n                );\r\n            }\r\n        });\r\n\r\n        return sortedUsersTableData;\r\n    }\r\n\r\n    isSortingAppliedToTable() {\r\n        let isSortingApplied = false;\r\n\r\n        this.annaSortService.columnSortState.forEach((value, key) => {\r\n            if (value === \"ASC\" || value === \"DESC\") {\r\n                isSortingApplied = true;\r\n            }\r\n        });\r\n\r\n        return isSortingApplied;\r\n    }\r\n\r\n    updateQueryParamsFilter(key: string, value: any, operation: \"ADD\" | \"DELETE\", queryParamObj: any) {\r\n        if (operation === \"ADD\") {\r\n            queryParamObj[key] = value;\r\n        } else if (operation === \"DELETE\") {\r\n            delete queryParamObj[key];\r\n        }\r\n        return queryParamObj;\r\n    }\r\n}\r\n"]}

package/esm2022/lib/anna-core-shared-lib/services/anna-global-config.service.mjs

@@ -0,0 +1,135 @@
+import { Injectable } from "@angular/core";
+import * as i0 from "@angular/core";
+export class AnnaGlobalConfigService {
+    /*
+     Initializing all default settings
+    */
+    constructor() {
+        this.defaultAngular2MultiSelectSettings = {
+            text: "Select option",
+            selectAllText: "Select All",
+            unSelectAllText: "UnSelect All",
+            badgeShowLimit: 1,
+            singleSelection: false,
+            classes: "filter-dropdowns",
+            enableSearchFilter: true,
+            enableCheckAll: true,
+            autoPosition: false,
+            disabled: false,
+            position: "bottom",
+            lazyLoading: false,
+            showCheckbox: true,
+            maxHeight: 300,
+            enableFilterSelectAll: true,
+        };
+        this.defaultNgxAsideSettings = {
+            title: '"Filters"',
+            cancelButtonTitle: '"Cancel"',
+            submitButtonTitle: '"Apply"',
+            closeOnEscape: false,
+            showOverlay: false,
+            showDefaultFooter: false,
+            showDefaultHeader: false,
+        };
+        this.defaultNgbDatePickerSettings = {
+            autoClose: false,
+            placeholder: "mm-dd-yyyy",
+            displayMonths: 1,
+            firstDayOfWeek: 1,
+            showWeekNumbers: false,
+            readonly: true,
+        };
+        this.defaultNgSelectSettings = {
+            allowClear: false,
+            placeholder: "Select",
+        };
+        this.defaultNgxInfiniteScrollSettings = {
+            infiniteScrollDistance: 1,
+            infiniteScrollUpDistance: 2,
+            infiniteScrollThrottle: 300,
+            scrollWindow: false,
+        };
+        this.defaultNgxSkeletonLoaderSettings = {
+            numberOfSkeletonRows: Array(6).fill(0),
+        };
+        this.defaultRadioButtonsComponentConfig = {
+            heading: "Select Option",
+            radioButtons: [
+                {
+                    value: "Yes",
+                    isDisabled: false,
+                    label: "Yes",
+                    class: "",
+                },
+                {
+                    value: "No",
+                    isDisabled: false,
+                    label: "No",
+                    class: "",
+                },
+            ],
+        };
+        this.defaultConfirmationPopupConfig = {
+            showCancelButton: true,
+            title: "Are you sure ?",
+            showConfirmButton: true,
+            cancelButtonLabel: "No",
+            confirmButtonLabel: "Yes",
+            showCloseIcon: true,
+            backdrop: "static",
+            windowClass: "",
+            size: "sm",
+            keyboard: false,
+        };
+        this.defaultWeekCalendarConfig = {
+            firstDayOfWeek: 1,
+            showWeekNumbers: true,
+            dateFormatToDisplay: "d MMM y",
+            dateFormatForRequest: "y-MM-dd",
+            maxWeeksToShowWithRemainingCount: 2,
+            numberOfMonthsToEnableInPast: 1,
+            selectMultipleWeeks: false,
+            customClass: "",
+            emitMultipleWeekObjects: true,
+            maxWeeksToSelect: 0,
+            showAsDropdown: true,
+            selectCurrentWeek: true,
+        };
+        this.defaultGtHeaderConfig = {
+            iconColumn: false,
+            checkboxColumn: false,
+            lastColumnKeys: [],
+        };
+        this.defaultGtGeneralConfig = {
+            component: "",
+            totalRow: false,
+            isHeaderChecked: false,
+            disableHeaderCheckbox: false,
+            verticalScrollOffsetForFilterTooltip: 0,
+            isGrouped: false,
+            showAllColumnFilter: true,
+            bufferSize: 20,
+            page: "",
+        };
+        this.defaultSingleSelectConfig = {
+            showSearchBar: false,
+            placeholder: "Select",
+            classes: "",
+            position: "BOTTOM",
+            maxHeightOfList: 200,
+        };
+        this.defaultMultiSelectConfig = {
+            ...this.defaultSingleSelectConfig,
+            ...{ showErrorWhenNoOptionSelected: true },
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AnnaGlobalConfigService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AnnaGlobalConfigService, providedIn: "root" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AnnaGlobalConfigService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root",
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"anna-global-config.service.js","sourceRoot":"","sources":["../../../../../../projects/anna-core/src/lib/anna-core-shared-lib/services/anna-global-config.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from \"@angular/core\";\r\n\r\nimport {\r\n    IAngular2MultiSelectSettings,\r\n    IConfirmationPopupConfig,\r\n    ICustomMultiSelect,\r\n    ICustomSingleSelect,\r\n    INgbDatePickerSettings,\r\n    INgSelectSettings,\r\n    INgxAsideSettings,\r\n    INgxInfiniteScrollSettings,\r\n    INgxSkeletonLoaderSettings,\r\n    IRadioButtonComponentConfig,\r\n    IWeekCalendar,\r\n} from \"../models/anna-global-dropdown-config.model\";\r\nimport { IGtGeneralConfig, IGtHeaderConfig } from \"../models/anna-non-editable-gt-models\";\r\n\r\n@Injectable({\r\n    providedIn: \"root\",\r\n})\r\nexport class AnnaGlobalConfigService {\r\n    readonly defaultAngular2MultiSelectSettings: IAngular2MultiSelectSettings;\r\n    readonly defaultNgxAsideSettings: INgxAsideSettings;\r\n    readonly defaultNgbDatePickerSettings: INgbDatePickerSettings;\r\n    readonly defaultNgSelectSettings: INgSelectSettings;\r\n    readonly defaultNgxInfiniteScrollSettings: INgxInfiniteScrollSettings;\r\n    readonly defaultNgxSkeletonLoaderSettings: INgxSkeletonLoaderSettings;\r\n    readonly defaultRadioButtonsComponentConfig: IRadioButtonComponentConfig;\r\n    readonly defaultConfirmationPopupConfig: IConfirmationPopupConfig;\r\n    readonly defaultWeekCalendarConfig: IWeekCalendar;\r\n    readonly defaultGtHeaderConfig: IGtHeaderConfig;\r\n    readonly defaultGtGeneralConfig: IGtGeneralConfig;\r\n    readonly defaultSingleSelectConfig: ICustomSingleSelect;\r\n    readonly defaultMultiSelectConfig: ICustomMultiSelect;\r\n\r\n    /*\r\n     Initializing all default settings\r\n    */\r\n    constructor() {\r\n        this.defaultAngular2MultiSelectSettings = {\r\n            text: \"Select option\",\r\n            selectAllText: \"Select All\",\r\n            unSelectAllText: \"UnSelect All\",\r\n            badgeShowLimit: 1,\r\n            singleSelection: false,\r\n            classes: \"filter-dropdowns\",\r\n            enableSearchFilter: true,\r\n            enableCheckAll: true,\r\n            autoPosition: false,\r\n            disabled: false,\r\n            position: \"bottom\",\r\n            lazyLoading: false,\r\n            showCheckbox: true,\r\n            maxHeight: 300,\r\n            enableFilterSelectAll: true,\r\n        };\r\n\r\n        this.defaultNgxAsideSettings = {\r\n            title: '\"Filters\"',\r\n            cancelButtonTitle: '\"Cancel\"',\r\n            submitButtonTitle: '\"Apply\"',\r\n            closeOnEscape: false,\r\n            showOverlay: false,\r\n            showDefaultFooter: false,\r\n            showDefaultHeader: false,\r\n        };\r\n\r\n        this.defaultNgbDatePickerSettings = {\r\n            autoClose: false,\r\n            placeholder: \"mm-dd-yyyy\",\r\n            displayMonths: 1,\r\n            firstDayOfWeek: 1,\r\n            showWeekNumbers: false,\r\n            readonly: true,\r\n        };\r\n\r\n        this.defaultNgSelectSettings = {\r\n            allowClear: false,\r\n            placeholder: \"Select\",\r\n        };\r\n\r\n        this.defaultNgxInfiniteScrollSettings = {\r\n            infiniteScrollDistance: 1,\r\n            infiniteScrollUpDistance: 2,\r\n            infiniteScrollThrottle: 300,\r\n            scrollWindow: false,\r\n        };\r\n\r\n        this.defaultNgxSkeletonLoaderSettings = {\r\n            numberOfSkeletonRows: Array(6).fill(0),\r\n        };\r\n\r\n        this.defaultRadioButtonsComponentConfig = {\r\n            heading: \"Select Option\",\r\n            radioButtons: [\r\n                {\r\n                    value: \"Yes\",\r\n                    isDisabled: false,\r\n                    label: \"Yes\",\r\n                    class: \"\",\r\n                },\r\n                {\r\n                    value: \"No\",\r\n                    isDisabled: false,\r\n                    label: \"No\",\r\n                    class: \"\",\r\n                },\r\n            ],\r\n        };\r\n\r\n        this.defaultConfirmationPopupConfig = {\r\n            showCancelButton: true,\r\n            title: \"Are you sure ?\",\r\n            showConfirmButton: true,\r\n            cancelButtonLabel: \"No\",\r\n            confirmButtonLabel: \"Yes\",\r\n            showCloseIcon: true,\r\n            backdrop: \"static\",\r\n            windowClass: \"\",\r\n            size: \"sm\",\r\n            keyboard: false,\r\n        };\r\n\r\n        this.defaultWeekCalendarConfig = {\r\n            firstDayOfWeek: 1,\r\n            showWeekNumbers: true,\r\n            dateFormatToDisplay: \"d MMM y\",\r\n            dateFormatForRequest: \"y-MM-dd\",\r\n            maxWeeksToShowWithRemainingCount: 2,\r\n            numberOfMonthsToEnableInPast: 1,\r\n            selectMultipleWeeks: false,\r\n            customClass: \"\",\r\n            emitMultipleWeekObjects: true,\r\n            maxWeeksToSelect: 0,\r\n            showAsDropdown: true,\r\n            selectCurrentWeek: true,\r\n        };\r\n\r\n        this.defaultGtHeaderConfig = {\r\n            iconColumn: false,\r\n            checkboxColumn: false,\r\n            lastColumnKeys: [],\r\n        };\r\n\r\n        this.defaultGtGeneralConfig = {\r\n            component: \"\",\r\n            totalRow: false,\r\n            isHeaderChecked: false,\r\n            disableHeaderCheckbox: false,\r\n            verticalScrollOffsetForFilterTooltip: 0,\r\n            isGrouped: false,\r\n            showAllColumnFilter: true,\r\n            bufferSize: 20,\r\n            page: \"\",\r\n        };\r\n\r\n        this.defaultSingleSelectConfig = {\r\n            showSearchBar: false,\r\n            placeholder: \"Select\",\r\n            classes: \"\",\r\n            position: \"BOTTOM\",\r\n            maxHeightOfList: 200,\r\n        };\r\n\r\n        this.defaultMultiSelectConfig = {\r\n            ...this.defaultSingleSelectConfig,\r\n            ...{ showErrorWhenNoOptionSelected: true },\r\n        };\r\n    }\r\n}\r\n"]}

package/esm2022/lib/anna-core-shared-lib/services/anna-number-format.service.mjs

@@ -0,0 +1,59 @@
+import { Injectable } from "@angular/core";
+import * as i0 from "@angular/core";
+export class AnnaNumberFormatService {
+    static GetRoundedValueWithUnits(inputValue, digitsToRoundDecimalPoint = 2) {
+        const result = AnnaNumberFormatService.GetValueInUnits(Math.abs(inputValue));
+        let value = result[0];
+        const unit = result[1];
+        value = +(+value).toFixed(digitsToRoundDecimalPoint);
+        if (inputValue < 0) {
+            value *= -1;
+        }
+        return value.toString() + unit;
+        //   return (Math.Round(value, digitsToRoundDecimalPoint, MidpointRounding.AwayFromZero) + unit);
+    }
+    static GetRoundedImpressionsWithUnits(inputValue, digitsToRoundDecimalPoint = 0) {
+        const result = this.GetValueInUnits(Math.abs(inputValue));
+        let value = result[0];
+        const unit = result[1];
+        value = +value;
+        if (inputValue < 0) {
+            value *= -1;
+        }
+        let digitToRoundOff = digitsToRoundDecimalPoint;
+        if (digitsToRoundDecimalPoint === 0 && (unit === "M" || unit === "B" || unit === "K")) {
+            digitToRoundOff = 2;
+        }
+        return Number.isInteger(value) ? value.toString() + unit : value.toFixed(digitToRoundOff) + unit;
+        // return (Math.round(value, digitsToRoundDecimalPoint, MidpointRounding.AwayFromZero) + unit);
+    }
+    static GetValueInUnits(inputValue) {
+        let unit = "";
+        let updatedInputValue = inputValue;
+        const thousand = 1000;
+        const million = 1000000;
+        const billion = 1000000000;
+        if (inputValue >= thousand && inputValue < million) {
+            updatedInputValue = inputValue / thousand;
+            unit = "K";
+        }
+        else if (inputValue >= million && inputValue < billion) {
+            updatedInputValue = inputValue / million;
+            unit = "M";
+        }
+        else if (inputValue >= billion) {
+            updatedInputValue = inputValue / billion;
+            unit = "B";
+        }
+        return [updatedInputValue, unit];
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AnnaNumberFormatService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AnnaNumberFormatService, providedIn: "root" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AnnaNumberFormatService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root",
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/anna-core-shared-lib/services/anna-persisting-filter.service.mjs

@@ -0,0 +1,64 @@
+import { Injectable } from "@angular/core";
+import hash from "object-hash";
+import * as i0 from "@angular/core";
+export class AnnaPersistingFilterService {
+    storeKeyValueInLocalStorage(val, isFilterKey = true) {
+        let filterOrdering;
+        if (!localStorage.getItem("filterOrdering")) {
+            filterOrdering = [];
+        }
+        else {
+            filterOrdering = JSON.parse(localStorage.getItem("filterOrdering"));
+        }
+        const filterOrderingSet = new Set(filterOrdering);
+        let hashCode = null;
+        let key = null;
+        try {
+            hashCode = hash(val);
+            key = isFilterKey ? `filter_${hashCode}` : hashCode;
+            localStorage.setItem(key, JSON.stringify(val));
+            if (isFilterKey) {
+                if (filterOrderingSet.has(key)) {
+                    filterOrderingSet.delete(key);
+                }
+                filterOrderingSet.add(key);
+                localStorage.setItem("filterOrdering", JSON.stringify(Array.from(filterOrderingSet)));
+            }
+        }
+        catch (e) {
+            const halfArrayLength = filterOrdering.length / 2;
+            for (let i = 0; i < halfArrayLength; i++) {
+                localStorage.removeItem(filterOrdering[i]);
+            }
+            filterOrdering.splice(0, filterOrdering.length / 2);
+            hashCode = hash(val);
+            key = isFilterKey ? `filter_${hashCode}` : hashCode;
+            localStorage.setItem(key, JSON.stringify(val));
+            if (isFilterKey) {
+                if (filterOrderingSet.has(key)) {
+                    filterOrderingSet.delete(key);
+                }
+                filterOrderingSet.add(key);
+                localStorage.setItem("filterOrdering", JSON.stringify(Array.from(filterOrderingSet)));
+            }
+        }
+        return key;
+    }
+    getActualQueryParams(key) {
+        return localStorage.getItem(key);
+    }
+    convertObjToQueryString(paramsObject) {
+        return Object.keys(paramsObject)
+            .map((key) => `${encodeURIComponent(key)}=${encodeURIComponent(paramsObject[key])}`)
+            .join("&");
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AnnaPersistingFilterService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AnnaPersistingFilterService, providedIn: "root" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AnnaPersistingFilterService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root",
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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