@annalib/anna-core 33.0.1 → 33.1.0

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: "17.3.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: "17.3.12", ngImport: i0, type: AnnaGtHelperService, providedIn: "root" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AnnaGtHelperService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root",
+                }]
+        }], ctorParameters: () => [{ 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-generic-tooltip-html.services.mjs

@@ -0,0 +1,60 @@
+import { Injectable } from "@angular/core";
+import * as i0 from "@angular/core";
+export class GenericTooltipHtmlService {
+    static generateTableHTML(headers, rowData, tableHeading = "") {
+        const rowsToSkip = {}; // Track rows to skip by index for rowspan
+        // Start table HTML
+        let tableHTML = "";
+        tableHTML =
+            tableHeading === "" ? tableHTML : `<label class="generic-innerHtml-table-heading">${tableHeading}</label>`;
+        tableHTML += '<section class="generic-innerHtml-table-container"><table class="tooltip-table">';
+        // Generate header row
+        tableHTML += "<thead><tr>";
+        headers.forEach((header) => {
+            const colspan = header.colspan ? ` colspan="${header.colspan}"` : "";
+            const rowspan = header.rowspan ? ` rowspan="${header.rowspan}"` : "";
+            const width = header.width ? ` width="${header.width}"` : "";
+            tableHTML += `<th${colspan}${rowspan}${width}>${header.name}</th>`;
+        });
+        tableHTML += "</tr></thead>";
+        // Generate rows
+        tableHTML += "<tbody>";
+        rowData.forEach((row, rowIndex) => {
+            tableHTML += "<tr>";
+            headers.forEach((header, headerIndex) => {
+                // Check if the current column is part of a rowspan from previous row
+                if (rowsToSkip[rowIndex] && rowsToSkip[rowIndex].includes(headerIndex)) {
+                    // colIndex++;
+                    return; // Skip this column due to rowspan from a previous row
+                }
+                const cellData = row[header.key] || "";
+                const colspan = row[`${header.key}_colspan`] ? ` colspan="${row[`${header.key}_colspan`]}"` : "";
+                const rowspan = row[`${header.key}_rowspan`] ? ` rowspan="${row[`${header.key}_rowspan`]}"` : "";
+                // If rowspan is defined, mark future rows to skip this cell
+                if (row[`${header.key}_rowspan`]) {
+                    const rowsToSpan = row[`${header.key}_rowspan`];
+                    for (let i = 1; i < rowsToSpan; i++) {
+                        if (!rowsToSkip[rowIndex + i])
+                            rowsToSkip[rowIndex + i] = [];
+                        rowsToSkip[rowIndex + i].push(headerIndex); // Mark column to be skipped
+                    }
+                }
+                tableHTML += `<td${colspan}${rowspan}>${cellData}</td>`;
+            });
+            tableHTML += "</tr>";
+        });
+        tableHTML += "</tbody>";
+        // Close table
+        tableHTML += "</table></section>";
+        return tableHTML;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: GenericTooltipHtmlService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: GenericTooltipHtmlService, providedIn: "root" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: GenericTooltipHtmlService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root",
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,94 @@
+import { Injectable } from "@angular/core";
+import * as i0 from "@angular/core";
+export class AnnaGlobalConfigService {
+    /*
+     Initializing all default settings
+    */
+    constructor() {
+        this.defaultNgbDatePickerSettings = {
+            autoClose: false,
+            placeholder: "mm-dd-yyyy",
+            displayMonths: 1,
+            firstDayOfWeek: 1,
+            showWeekNumbers: false,
+            readonly: true,
+        };
+        this.defaultNgSelectSettings = {
+            allowClear: false,
+            placeholder: "Select",
+        };
+        this.defaultNgxSkeletonLoaderSettings = {
+            numberOfSkeletonRows: Array(6).fill(0),
+        };
+        this.defaultConfirmationPopupConfig = {
+            showCancelButton: true,
+            title: "Are you sure you want to save the changes?",
+            showConfirmButton: true,
+            cancelButtonLabel: "No",
+            confirmButtonLabel: "Yes",
+            showCloseIcon: true,
+            backdrop: "static",
+            windowClass: "",
+            size: "sm",
+            keyboard: false,
+        };
+        this.defaultUnsavedChangesConfirmationPopupConfig = {
+            showCancelButton: true,
+            title: "You have unsaved changes. All the changes will be lost if you switch. Do you want to continue?",
+            showConfirmButton: true,
+            cancelButtonLabel: "No",
+            confirmButtonLabel: "Yes",
+            showCloseIcon: false,
+            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.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",
+            minHeightOfList: 30,
+            maxHeightOfList: 180,
+        };
+        this.defaultMultiSelectConfig = {
+            ...this.defaultSingleSelectConfig,
+            ...{ showErrorWhenNoOptionSelected: true },
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AnnaGlobalConfigService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AnnaGlobalConfigService, providedIn: "root" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AnnaGlobalConfigService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root",
+                }]
+        }], ctorParameters: () => [] });
+//# 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":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;;AAgB3C,MAAM,OAAO,uBAAuB;IAWhC;;MAEE;IACF;QACI,IAAI,CAAC,4BAA4B,GAAG;YAChC,SAAS,EAAE,KAAK;YAChB,WAAW,EAAE,YAAY;YACzB,aAAa,EAAE,CAAC;YAChB,cAAc,EAAE,CAAC;YACjB,eAAe,EAAE,KAAK;YACtB,QAAQ,EAAE,IAAI;SACjB,CAAC;QAEF,IAAI,CAAC,uBAAuB,GAAG;YAC3B,UAAU,EAAE,KAAK;YACjB,WAAW,EAAE,QAAQ;SACxB,CAAC;QAEF,IAAI,CAAC,gCAAgC,GAAG;YACpC,oBAAoB,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC;SACzC,CAAC;QAEF,IAAI,CAAC,8BAA8B,GAAG;YAClC,gBAAgB,EAAE,IAAI;YACtB,KAAK,EAAE,4CAA4C;YACnD,iBAAiB,EAAE,IAAI;YACvB,iBAAiB,EAAE,IAAI;YACvB,kBAAkB,EAAE,KAAK;YACzB,aAAa,EAAE,IAAI;YACnB,QAAQ,EAAE,QAAQ;YAClB,WAAW,EAAE,EAAE;YACf,IAAI,EAAE,IAAI;YACV,QAAQ,EAAE,KAAK;SAClB,CAAC;QAEF,IAAI,CAAC,4CAA4C,GAAG;YAChD,gBAAgB,EAAE,IAAI;YACtB,KAAK,EAAE,gGAAgG;YACvG,iBAAiB,EAAE,IAAI;YACvB,iBAAiB,EAAE,IAAI;YACvB,kBAAkB,EAAE,KAAK;YACzB,aAAa,EAAE,KAAK;YACpB,QAAQ,EAAE,QAAQ;YAClB,WAAW,EAAE,EAAE;YACf,IAAI,EAAE,IAAI;YACV,QAAQ,EAAE,KAAK;SAClB,CAAC;QAEF,IAAI,CAAC,yBAAyB,GAAG;YAC7B,cAAc,EAAE,CAAC;YACjB,eAAe,EAAE,IAAI;YACrB,mBAAmB,EAAE,SAAS;YAC9B,oBAAoB,EAAE,SAAS;YAC/B,gCAAgC,EAAE,CAAC;YACnC,4BAA4B,EAAE,CAAC;YAC/B,mBAAmB,EAAE,KAAK;YAC1B,WAAW,EAAE,EAAE;YACf,uBAAuB,EAAE,IAAI;YAC7B,gBAAgB,EAAE,CAAC;YACnB,cAAc,EAAE,IAAI;YACpB,iBAAiB,EAAE,IAAI;SAC1B,CAAC;QAEF,IAAI,CAAC,sBAAsB,GAAG;YAC1B,SAAS,EAAE,EAAE;YACb,QAAQ,EAAE,KAAK;YACf,eAAe,EAAE,KAAK;YACtB,qBAAqB,EAAE,KAAK;YAC5B,oCAAoC,EAAE,CAAC;YACvC,SAAS,EAAE,KAAK;YAChB,mBAAmB,EAAE,IAAI;YACzB,UAAU,EAAE,EAAE;YACd,IAAI,EAAE,EAAE;SACX,CAAC;QAEF,IAAI,CAAC,yBAAyB,GAAG;YAC7B,aAAa,EAAE,KAAK;YACpB,WAAW,EAAE,QAAQ;YACrB,OAAO,EAAE,EAAE;YACX,QAAQ,EAAE,QAAQ;YAClB,eAAe,EAAE,EAAE;YACnB,eAAe,EAAE,GAAG;SACvB,CAAC;QAEF,IAAI,CAAC,wBAAwB,GAAG;YAC5B,GAAG,IAAI,CAAC,yBAAyB;YACjC,GAAG,EAAE,6BAA6B,EAAE,IAAI,EAAE;SAC7C,CAAC;IACN,CAAC;+GAnGQ,uBAAuB;mHAAvB,uBAAuB,cAFpB,MAAM;;4FAET,uBAAuB;kBAHnC,UAAU;mBAAC;oBACR,UAAU,EAAE,MAAM;iBACrB","sourcesContent":["import { Injectable } from \"@angular/core\";\r\n\r\nimport {\r\n    IConfirmationPopupConfig,\r\n    ICustomMultiSelect,\r\n    ICustomSingleSelect,\r\n    INgbDatePickerSettings,\r\n    INgSelectSettings,\r\n    INgxSkeletonLoaderSettings,\r\n    IWeekCalendar,\r\n} from \"../models/anna-global-dropdown-config.model\";\r\nimport { IGtGeneralConfig } 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 defaultNgbDatePickerSettings: INgbDatePickerSettings;\r\n    readonly defaultNgSelectSettings: INgSelectSettings;\r\n    readonly defaultNgxSkeletonLoaderSettings: INgxSkeletonLoaderSettings;\r\n    readonly defaultConfirmationPopupConfig: IConfirmationPopupConfig;\r\n    readonly defaultUnsavedChangesConfirmationPopupConfig: IConfirmationPopupConfig;\r\n    readonly defaultWeekCalendarConfig: IWeekCalendar;\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.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.defaultNgxSkeletonLoaderSettings = {\r\n            numberOfSkeletonRows: Array(6).fill(0),\r\n        };\r\n\r\n        this.defaultConfirmationPopupConfig = {\r\n            showCancelButton: true,\r\n            title: \"Are you sure you want to save the changes?\",\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.defaultUnsavedChangesConfirmationPopupConfig = {\r\n            showCancelButton: true,\r\n            title: \"You have unsaved changes. All the changes will be lost if you switch. Do you want to continue?\",\r\n            showConfirmButton: true,\r\n            cancelButtonLabel: \"No\",\r\n            confirmButtonLabel: \"Yes\",\r\n            showCloseIcon: false,\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.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            minHeightOfList: 30,\r\n            maxHeightOfList: 180,\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,80 @@
+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 GetRoundedValuesWithoutUnits(inputValue, digitsToRoundDecimalPoint = 2) {
+        let value = inputValue;
+        value = +(+value).toFixed(digitsToRoundDecimalPoint);
+        if (inputValue < 0) {
+            value *= -1;
+        }
+        return value.toLocaleString("en-IN");
+    }
+    static GetRoundedValueWithUnitsAndDollarSymbol(inputValue, digitsToRoundDecimalPoint = 2) {
+        if (inputValue === 0)
+            return "-";
+        const result = AnnaNumberFormatService.GetValueInUnits(Math.abs(inputValue));
+        let value = result[0];
+        const unit = result[1];
+        value = +(+value).toFixed(digitsToRoundDecimalPoint);
+        if (inputValue < 0) {
+            value *= -1;
+        }
+        const dollarSymbol = value < 0 ? "-$" : "$";
+        return dollarSymbol + value.toString() + 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: "17.3.12", ngImport: i0, type: AnnaNumberFormatService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AnnaNumberFormatService, providedIn: "root" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AnnaNumberFormatService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root",
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"anna-number-format.service.js","sourceRoot":"","sources":["../../../../../../projects/anna-core/src/lib/anna-core-shared-lib/services/anna-number-format.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from \"@angular/core\";\r\n\r\n@Injectable({\r\n    providedIn: \"root\",\r\n})\r\nexport class AnnaNumberFormatService {\r\n    public static GetRoundedValueWithUnits(inputValue: number, digitsToRoundDecimalPoint = 2) {\r\n        const result = AnnaNumberFormatService.GetValueInUnits(Math.abs(inputValue));\r\n        let value = result[0];\r\n        const unit = result[1];\r\n\r\n        value = +(+value).toFixed(digitsToRoundDecimalPoint);\r\n        if (inputValue < 0) {\r\n            value *= -1;\r\n        }\r\n        return value.toString() + unit;\r\n        //   return (Math.Round(value, digitsToRoundDecimalPoint, MidpointRounding.AwayFromZero) + unit);\r\n    }\r\n    public static GetRoundedValuesWithoutUnits(inputValue: number, digitsToRoundDecimalPoint = 2) {\r\n        let value = inputValue;\r\n        value = +(+value).toFixed(digitsToRoundDecimalPoint);\r\n        if (inputValue < 0) {\r\n            value *= -1;\r\n        }\r\n        return value.toLocaleString(\"en-IN\");\r\n    }\r\n\r\n    public static GetRoundedValueWithUnitsAndDollarSymbol(inputValue: number, digitsToRoundDecimalPoint = 2) {\r\n        if (inputValue === 0) return \"-\";\r\n        const result = AnnaNumberFormatService.GetValueInUnits(Math.abs(inputValue));\r\n        let value = result[0];\r\n        const unit = result[1];\r\n\r\n        value = +(+value).toFixed(digitsToRoundDecimalPoint);\r\n        if (inputValue < 0) {\r\n            value *= -1;\r\n        }\r\n        const dollarSymbol = value < 0 ? \"-$\" : \"$\";\r\n        return dollarSymbol + value.toString() + unit;\r\n    }\r\n\r\n    public static GetRoundedImpressionsWithUnits(inputValue: number, digitsToRoundDecimalPoint: number = 0) {\r\n        const result = this.GetValueInUnits(Math.abs(inputValue));\r\n        let value = result[0];\r\n        const unit = result[1];\r\n\r\n        value = +value;\r\n        if (inputValue < 0) {\r\n            value *= -1;\r\n        }\r\n\r\n        let digitToRoundOff = digitsToRoundDecimalPoint;\r\n        if (digitsToRoundDecimalPoint === 0 && (unit === \"M\" || unit === \"B\" || unit === \"K\")) {\r\n            digitToRoundOff = 2;\r\n        }\r\n        return Number.isInteger(value) ? value.toString() + unit : value.toFixed(digitToRoundOff) + unit;\r\n        // return (Math.round(value, digitsToRoundDecimalPoint, MidpointRounding.AwayFromZero) + unit);\r\n    }\r\n\r\n    public static GetValueInUnits(inputValue: number) {\r\n        let unit = \"\";\r\n        let updatedInputValue = inputValue;\r\n        const thousand = 1000;\r\n        const million = 1000000;\r\n        const billion = 1000000000;\r\n\r\n        if (inputValue >= thousand && inputValue < million) {\r\n            updatedInputValue = inputValue / thousand;\r\n            unit = \"K\";\r\n        } else if (inputValue >= million && inputValue < billion) {\r\n            updatedInputValue = inputValue / million;\r\n            unit = \"M\";\r\n        } else if (inputValue >= billion) {\r\n            updatedInputValue = inputValue / billion;\r\n            unit = \"B\";\r\n        }\r\n\r\n        return [updatedInputValue, unit];\r\n    }\r\n}\r\n"]}

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

@@ -0,0 +1,68 @@
+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);
+            // if (hashCode === "d909d7a911336eb2b8732b67d22cfb32c9603a7e") {
+            //     return;
+            //     // Added by Manisha, stationId with null was getting added
+            // }
+            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: "17.3.12", ngImport: i0, type: AnnaPersistingFilterService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AnnaPersistingFilterService, providedIn: "root" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AnnaPersistingFilterService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root",
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/anna-core-shared-lib/services/anna-regex-patterns.service.mjs

@@ -0,0 +1,20 @@
+import { Injectable } from "@angular/core";
+import * as i0 from "@angular/core";
+export class RegexPatternsService {
+    constructor() {
+        this.emailPattern = /\S+@\S+\.\S+/;
+        this.phonePattern = /^[(][0-9]{3}[)][0-9]{3}[-][0-9]{4}$/;
+        this.buyerNamePattern = /^[A-Za-z][A-Za-z .'-]{0,19}$/;
+        this.usernamePattern = /^\\S*$/;
+        this.namePattern = /^[A-Za-z][A-Za-z .'-]{0,49}$/;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: RegexPatternsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: RegexPatternsService, providedIn: "root" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: RegexPatternsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root",
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYW5uYS1yZWdleC1wYXR0ZXJucy5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvYW5uYS1jb3JlL3NyYy9saWIvYW5uYS1jb3JlLXNoYXJlZC1saWIvc2VydmljZXMvYW5uYS1yZWdleC1wYXR0ZXJucy5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7O0FBSzNDLE1BQU0sT0FBTyxvQkFBb0I7SUFIakM7UUFJb0IsaUJBQVksR0FBVyxjQUFjLENBQUM7UUFDdEMsaUJBQVksR0FBVyxxQ0FBcUMsQ0FBQztRQUM3RCxxQkFBZ0IsR0FBVyw4QkFBOEIsQ0FBQztRQUMxRCxvQkFBZSxHQUFXLFFBQVEsQ0FBQztRQUNuQyxnQkFBVyxHQUFXLDhCQUE4QixDQUFDO0tBQ3hFOytHQU5ZLG9CQUFvQjttSEFBcEIsb0JBQW9CLGNBRmpCLE1BQU07OzRGQUVULG9CQUFvQjtrQkFIaEMsVUFBVTttQkFBQztvQkFDUixVQUFVLEVBQUUsTUFBTTtpQkFDckIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSBcIkBhbmd1bGFyL2NvcmVcIjtcclxuXHJcbkBJbmplY3RhYmxlKHtcclxuICAgIHByb3ZpZGVkSW46IFwicm9vdFwiLFxyXG59KVxyXG5leHBvcnQgY2xhc3MgUmVnZXhQYXR0ZXJuc1NlcnZpY2Uge1xyXG4gICAgcHVibGljIHJlYWRvbmx5IGVtYWlsUGF0dGVybjogUmVnRXhwID0gL1xcUytAXFxTK1xcLlxcUysvO1xyXG4gICAgcHVibGljIHJlYWRvbmx5IHBob25lUGF0dGVybjogUmVnRXhwID0gL15bKF1bMC05XXszfVspXVswLTldezN9Wy1dWzAtOV17NH0kLztcclxuICAgIHB1YmxpYyByZWFkb25seSBidXllck5hbWVQYXR0ZXJuOiBSZWdFeHAgPSAvXltBLVphLXpdW0EtWmEteiAuJy1dezAsMTl9JC87XHJcbiAgICBwdWJsaWMgcmVhZG9ubHkgdXNlcm5hbWVQYXR0ZXJuOiBSZWdFeHAgPSAvXlxcXFxTKiQvO1xyXG4gICAgcHVibGljIHJlYWRvbmx5IG5hbWVQYXR0ZXJuOiBSZWdFeHAgPSAvXltBLVphLXpdW0EtWmEteiAuJy1dezAsNDl9JC87XHJcbn1cclxuIl19