@annalib/anna-core 20.3.0 → 20.3.2

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

@@ -0,0 +1,176 @@
+// Angular import statements
+import { Injectable } from "@angular/core";
+import { cloneDeep } from "lodash-es";
+import { Subject } from "rxjs";
+import { AnnaDateTimeFormatService } from "./anna-date-time-format.service";
+import * as i0 from "@angular/core";
+import * as i1 from "./anna-date-time-format.service";
+// Third party import statements
+// User defined import statements
+export class AnnaSortService {
+    constructor(annaDateTimeFormatService) {
+        this.annaDateTimeFormatService = annaDateTimeFormatService;
+        this.updateSortTypeSubject = new Subject();
+        this.dateSet = new Set([
+            "endDate",
+            "startDate",
+            "end_date",
+            "start_date",
+            "flightStartDate",
+            "flightEndDate",
+            "date",
+            "GeneratedOn",
+        ]);
+    }
+    sortDataForComponentOtherThanLurAndCsrPage(isAsc, data, key) {
+        let param1;
+        let param2;
+        let dataToBeSorted = data;
+        if (this.dateSet.has(key)) {
+            dataToBeSorted.sort((a, b) => this.annaDateTimeFormatService.compareDate(a[key], b[key], isAsc));
+        }
+        else if (key === "AirDateAndTime" || key === "Date") {
+            dataToBeSorted.sort((a, b) => {
+                if (a[key] === "-") {
+                    return 1;
+                }
+                if (b[key] === "-") {
+                    return -1;
+                }
+                const first = this.annaDateTimeFormatService.formatDateAndHHMMATimeToStandardFormat(a[key]);
+                const second = this.annaDateTimeFormatService.formatDateAndHHMMATimeToStandardFormat(b[key]);
+                const compareDate = this.annaDateTimeFormatService.compareDate(first, second, isAsc);
+                return compareDate;
+            });
+        }
+        else if (key === "startEndTime" || key === "TimeBand") {
+            dataToBeSorted.sort((a, b) => {
+                if (isAsc) {
+                    param1 = a[key][1];
+                    param2 = b[key][1];
+                }
+                else {
+                    param1 = a[key][2];
+                    param2 = b[key][2];
+                }
+                const val = isAsc
+                    ? this.annaDateTimeFormatService.sortByTimeAscending(param1, param2)
+                    : this.annaDateTimeFormatService.sortByTimeDescending(param1, param2);
+                return val;
+            });
+        }
+        else {
+            const dataWithoutEmptyOrHyphenValues = dataToBeSorted.filter((n) => n[key] !== "-");
+            const rowsWithHyphenOrZeroValues = dataToBeSorted.filter((n) => n[key] === "-");
+            dataWithoutEmptyOrHyphenValues.sort((a, b) => {
+                param1 = a[key];
+                param2 = b[key];
+                if (param1 !== param2) {
+                    return this.annaDateTimeFormatService.compare(param1, param2, isAsc);
+                }
+                return 0;
+            });
+            dataToBeSorted = isAsc
+                ? [...rowsWithHyphenOrZeroValues, ...dataWithoutEmptyOrHyphenValues]
+                : [...dataWithoutEmptyOrHyphenValues, ...rowsWithHyphenOrZeroValues];
+        }
+        return dataToBeSorted;
+    }
+    sortEnterEditLurAndCsrPage(isAsc, data, key) {
+        let param1;
+        let param2;
+        if (key.includes("_")) {
+            const keys = key.split("_");
+            const weekNumber = keys[0];
+            let sortKey = keys[1];
+            if (keys.length > 2) {
+                sortKey = keys[2] === "true" ? "BookedAurIncludingNoChargeSpots" : "BookedAurExcludingNoChargeSpots";
+            }
+            data.sort((a, b) => {
+                const aInventoryCodeWeekWiseKey = Object.keys(a.WeekWiseInventoryCodeData).filter((invKey) => invKey.split("_")[1] === weekNumber);
+                const bInventoryCodeWeekWiseKey = Object.keys(b.WeekWiseInventoryCodeData).filter((invKey) => invKey.split("_")[1] === weekNumber);
+                param1 = null;
+                param2 = null;
+                if (aInventoryCodeWeekWiseKey.length > 0) {
+                    param1 = a.WeekWiseInventoryCodeData[aInventoryCodeWeekWiseKey[0]][sortKey][1];
+                }
+                if (bInventoryCodeWeekWiseKey.length > 0) {
+                    param2 = b.WeekWiseInventoryCodeData[bInventoryCodeWeekWiseKey[0]][sortKey][1];
+                }
+                if (param1 !== param2) {
+                    return this.annaDateTimeFormatService.compare(param1, param2, isAsc);
+                }
+                return 0;
+            });
+        }
+        else if (key === "TimeBand") {
+            data.sort((a, b) => {
+                if (isAsc) {
+                    param1 = a[key][1];
+                    param2 = b[key][1];
+                }
+                else {
+                    param1 = a[key][2];
+                    param2 = b[key][2];
+                }
+                const val = isAsc
+                    ? this.annaDateTimeFormatService.sortByTimeAscending(param1, param2)
+                    : this.annaDateTimeFormatService.sortByTimeDescending(param1, param2);
+                return val;
+            });
+        }
+        else {
+            data.sort((a, b) => {
+                param1 = a[key];
+                param2 = b[key];
+                if (param1 !== param2) {
+                    return this.annaDateTimeFormatService.compare(param1, param2, isAsc);
+                }
+                return 0;
+            });
+        }
+        return data;
+    }
+    checkIfSortingIsApplied(tableData, isLurAndCsrComponent) {
+        let sortedTableData = tableData;
+        this.columnSortState.forEach((value, key) => {
+            if (value === "ASC") {
+                sortedTableData = cloneDeep(isLurAndCsrComponent
+                    ? this.sortEnterEditLurAndCsrPage(true, tableData, key)
+                    : this.sortDataForComponentOtherThanLurAndCsrPage(true, tableData, key));
+            }
+            else if (value === "DESC") {
+                sortedTableData = cloneDeep(isLurAndCsrComponent
+                    ? this.sortEnterEditLurAndCsrPage(false, tableData, key)
+                    : this.sortDataForComponentOtherThanLurAndCsrPage(false, tableData, key));
+            }
+        });
+        return sortedTableData;
+    }
+    applySorting(key, tempSortOrder, tableData, isLurAndCsrComponent) {
+        let sortedTableData = tableData;
+        if (tempSortOrder === "ASC") {
+            sortedTableData = cloneDeep(isLurAndCsrComponent
+                ? this.sortEnterEditLurAndCsrPage(true, tableData, key)
+                : this.sortDataForComponentOtherThanLurAndCsrPage(true, tableData, key));
+        }
+        else if (tempSortOrder === "DESC") {
+            sortedTableData = cloneDeep(isLurAndCsrComponent
+                ? this.sortEnterEditLurAndCsrPage(false, tableData, key)
+                : this.sortDataForComponentOtherThanLurAndCsrPage(false, tableData, key));
+        }
+        else if (tempSortOrder === "DEFAULT") {
+            sortedTableData = cloneDeep(this.noSortingAppliedData);
+        }
+        return sortedTableData;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AnnaSortService, deps: [{ token: i1.AnnaDateTimeFormatService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AnnaSortService, providedIn: "root" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AnnaSortService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root",
+                }]
+        }], ctorParameters: function () { return [{ type: i1.AnnaDateTimeFormatService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"anna-sort.service.js","sourceRoot":"","sources":["../../../../../../projects/anna-core/src/lib/anna-core-shared-lib/services/anna-sort.service.ts"],"names":[],"mappings":"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","sourcesContent":["// Angular import statements\r\nimport { Injectable } from \"@angular/core\";\r\nimport { cloneDeep } from \"lodash-es\";\r\nimport { Subject } from \"rxjs\";\r\n\r\nimport { SortType } from \"../models/anna-sort.model\";\r\nimport { AnnaDateTimeFormatService } from \"./anna-date-time-format.service\";\r\n\r\n// Third party import statements\r\n\r\n// User defined import statements\r\n\r\n@Injectable({\r\n    providedIn: \"root\",\r\n})\r\nexport class AnnaSortService {\r\n    columnSortState: Map<string, SortType>;\r\n    noSortingAppliedData: any[];\r\n    updateSortTypeSubject: Subject<string> = new Subject();\r\n\r\n    dateSet = new Set([\r\n        \"endDate\",\r\n        \"startDate\",\r\n        \"end_date\",\r\n        \"start_date\",\r\n        \"flightStartDate\",\r\n        \"flightEndDate\",\r\n        \"date\",\r\n        \"GeneratedOn\",\r\n    ]);\r\n\r\n    constructor(private annaDateTimeFormatService: AnnaDateTimeFormatService) {}\r\n\r\n    sortDataForComponentOtherThanLurAndCsrPage(isAsc: boolean, data: any[], key: string) {\r\n        let param1: string | number;\r\n        let param2: string | number;\r\n\r\n        let dataToBeSorted = data;\r\n        if (this.dateSet.has(key)) {\r\n            dataToBeSorted.sort((a, b) => this.annaDateTimeFormatService.compareDate(a[key], b[key], isAsc));\r\n        } else if (key === \"AirDateAndTime\" || key === \"Date\") {\r\n            dataToBeSorted.sort((a, b) => {\r\n                if (a[key] === \"-\") {\r\n                    return 1;\r\n                }\r\n\r\n                if (b[key] === \"-\") {\r\n                    return -1;\r\n                }\r\n                const first = this.annaDateTimeFormatService.formatDateAndHHMMATimeToStandardFormat(a[key]);\r\n                const second = this.annaDateTimeFormatService.formatDateAndHHMMATimeToStandardFormat(b[key]);\r\n                const compareDate = this.annaDateTimeFormatService.compareDate(first, second, isAsc);\r\n                return compareDate;\r\n            });\r\n        } else if (key === \"startEndTime\" || key === \"TimeBand\") {\r\n            dataToBeSorted.sort((a, b) => {\r\n                if (isAsc) {\r\n                    param1 = a[key][1];\r\n                    param2 = b[key][1];\r\n                } else {\r\n                    param1 = a[key][2];\r\n                    param2 = b[key][2];\r\n                }\r\n                const val = isAsc\r\n                    ? this.annaDateTimeFormatService.sortByTimeAscending(param1, param2)\r\n                    : this.annaDateTimeFormatService.sortByTimeDescending(param1, param2);\r\n                return val;\r\n            });\r\n        } else {\r\n            const dataWithoutEmptyOrHyphenValues = dataToBeSorted.filter((n) => n[key] !== \"-\");\r\n            const rowsWithHyphenOrZeroValues = dataToBeSorted.filter((n) => n[key] === \"-\");\r\n\r\n            dataWithoutEmptyOrHyphenValues.sort((a, b) => {\r\n                param1 = a[key];\r\n                param2 = b[key];\r\n\r\n                if (param1 !== param2) {\r\n                    return this.annaDateTimeFormatService.compare(param1, param2, isAsc);\r\n                }\r\n\r\n                return 0;\r\n            });\r\n\r\n            dataToBeSorted = isAsc\r\n                ? [...rowsWithHyphenOrZeroValues, ...dataWithoutEmptyOrHyphenValues]\r\n                : [...dataWithoutEmptyOrHyphenValues, ...rowsWithHyphenOrZeroValues];\r\n        }\r\n\r\n        return dataToBeSorted;\r\n    }\r\n\r\n    sortEnterEditLurAndCsrPage(isAsc: boolean, data: any[], key: any) {\r\n        let param1: string | number;\r\n        let param2: string | number;\r\n\r\n        if (key.includes(\"_\")) {\r\n            const keys = key.split(\"_\");\r\n            const weekNumber = keys[0];\r\n            let sortKey = keys[1];\r\n\r\n            if (keys.length > 2) {\r\n                sortKey = keys[2] === \"true\" ? \"BookedAurIncludingNoChargeSpots\" : \"BookedAurExcludingNoChargeSpots\";\r\n            }\r\n\r\n            data.sort((a, b) => {\r\n                const aInventoryCodeWeekWiseKey = Object.keys(a.WeekWiseInventoryCodeData).filter(\r\n                    (invKey) => invKey.split(\"_\")[1] === weekNumber,\r\n                );\r\n                const bInventoryCodeWeekWiseKey = Object.keys(b.WeekWiseInventoryCodeData).filter(\r\n                    (invKey) => invKey.split(\"_\")[1] === weekNumber,\r\n                );\r\n\r\n                param1 = null;\r\n                param2 = null;\r\n                if (aInventoryCodeWeekWiseKey.length > 0) {\r\n                    param1 = a.WeekWiseInventoryCodeData[aInventoryCodeWeekWiseKey[0]][sortKey][1];\r\n                }\r\n\r\n                if (bInventoryCodeWeekWiseKey.length > 0) {\r\n                    param2 = b.WeekWiseInventoryCodeData[bInventoryCodeWeekWiseKey[0]][sortKey][1];\r\n                }\r\n\r\n                if (param1 !== param2) {\r\n                    return this.annaDateTimeFormatService.compare(param1, param2, isAsc);\r\n                }\r\n\r\n                return 0;\r\n            });\r\n        } else if (key === \"TimeBand\") {\r\n            data.sort((a, b) => {\r\n                if (isAsc) {\r\n                    param1 = a[key][1];\r\n                    param2 = b[key][1];\r\n                } else {\r\n                    param1 = a[key][2];\r\n                    param2 = b[key][2];\r\n                }\r\n                const val = isAsc\r\n                    ? this.annaDateTimeFormatService.sortByTimeAscending(param1, param2)\r\n                    : this.annaDateTimeFormatService.sortByTimeDescending(param1, param2);\r\n                return val;\r\n            });\r\n        } else {\r\n            data.sort((a, b) => {\r\n                param1 = a[key];\r\n                param2 = b[key];\r\n\r\n                if (param1 !== param2) {\r\n                    return this.annaDateTimeFormatService.compare(param1, param2, isAsc);\r\n                }\r\n\r\n                return 0;\r\n            });\r\n        }\r\n\r\n        return data;\r\n    }\r\n\r\n    checkIfSortingIsApplied(tableData: any[], isLurAndCsrComponent: boolean) {\r\n        let sortedTableData = tableData;\r\n        this.columnSortState.forEach((value, key) => {\r\n            if (value === \"ASC\") {\r\n                sortedTableData = cloneDeep(\r\n                    isLurAndCsrComponent\r\n                        ? this.sortEnterEditLurAndCsrPage(true, tableData, key)\r\n                        : this.sortDataForComponentOtherThanLurAndCsrPage(true, tableData, key),\r\n                );\r\n            } else if (value === \"DESC\") {\r\n                sortedTableData = cloneDeep(\r\n                    isLurAndCsrComponent\r\n                        ? this.sortEnterEditLurAndCsrPage(false, tableData, key)\r\n                        : this.sortDataForComponentOtherThanLurAndCsrPage(false, tableData, key),\r\n                );\r\n            }\r\n        });\r\n\r\n        return sortedTableData;\r\n    }\r\n\r\n    applySorting(key: string, tempSortOrder: SortType, tableData: any[], isLurAndCsrComponent: boolean) {\r\n        let sortedTableData = tableData;\r\n        if (tempSortOrder === \"ASC\") {\r\n            sortedTableData = cloneDeep(\r\n                isLurAndCsrComponent\r\n                    ? this.sortEnterEditLurAndCsrPage(true, tableData, key)\r\n                    : this.sortDataForComponentOtherThanLurAndCsrPage(true, tableData, key),\r\n            );\r\n        } else if (tempSortOrder === \"DESC\") {\r\n            sortedTableData = cloneDeep(\r\n                isLurAndCsrComponent\r\n                    ? this.sortEnterEditLurAndCsrPage(false, tableData, key)\r\n                    : this.sortDataForComponentOtherThanLurAndCsrPage(false, tableData, key),\r\n            );\r\n        } else if (tempSortOrder === \"DEFAULT\") {\r\n            sortedTableData = cloneDeep(this.noSortingAppliedData);\r\n        }\r\n\r\n        return sortedTableData;\r\n    }\r\n}\r\n"]}

package/esm2022/lib/anna-core.module.mjs

@@ -0,0 +1,222 @@
+/* eslint-disable max-len */
+import { ScrollingModule } from "@angular/cdk/scrolling";
+import { CommonModule } from "@angular/common";
+import { NgModule } from "@angular/core";
+import { FormsModule } from "@angular/forms";
+import { MatButtonToggleModule } from "@angular/material/button-toggle";
+import { MatRadioModule } from "@angular/material/radio";
+import { MatTableModule } from "@angular/material/table";
+import { NgxSliderModule } from "@angular-slider/ngx-slider";
+import { NgbModule } from "@ng-bootstrap/ng-bootstrap";
+import { NgCircleProgressModule } from "ng-circle-progress";
+import { NgxSkeletonLoaderModule } from "ngx-skeleton-loader";
+import { AnnaBuyerApprovalIconTemplateComponent } from "./anna-core-shared-lib/components/anna-buyer-approval-icon-template/anna-buyer-approval-icon-template.component";
+import { AnnaDeletedOrderIconTemplateComponent } from "./anna-core-shared-lib/components/anna-deleted-order-icon-template/anna-deleted-order-icon-template.component";
+import { AnnaEstIconTemplateComponent } from "./anna-core-shared-lib/components/anna-est-icon-template/anna-est-icon-template.component";
+import { AnnaIconColumnComponent } from "./anna-core-shared-lib/components/anna-icon-column/anna-icon-column.component";
+import { AnnaLiveIconTemplateComponent } from "./anna-core-shared-lib/components/anna-live-icon-template/anna-live-icon-template.component";
+import { AnnaNoDataComponent } from "./anna-core-shared-lib/components/anna-no-data/anna-no-data.component";
+import { AnnaNotifyIconTemplateComponent } from "./anna-core-shared-lib/components/anna-notify-icon-template/anna-notify-icon-template.component";
+import { AnnaPayForPerformanceIconTemplateComponent } from "./anna-core-shared-lib/components/anna-pay-for-performance-icon-template/anna-pay-for-performance-icon-template.component";
+import { AnnaRejectedIconTemplateComponent } from "./anna-core-shared-lib/components/anna-rejected-icon-template/anna-rejected-icon-template.component";
+import { DigitOnlyDirective } from "./anna-core-shared-lib/directives/digits-only/digits-only.directive";
+import { FixedRowsPopupTableDirective } from "./anna-core-shared-lib/directives/fixed-rows-popup-table/fixed-rows-popup-table.directive";
+import { ShowEllipsisTextOnHoverDirective } from "./anna-core-shared-lib/directives/show-ellipsis-text/show-ellipsis-text.directive";
+import { AnnaConvertArrayToCommaSeperatedValue } from "./anna-core-shared-lib/pipes/annaConvertArrayToCommaSeperatedValue.pipe";
+import { AnnaConvertZeroOrNullOrUndefinedPipe } from "./anna-core-shared-lib/pipes/annaConvertZeroOrNullOrUndefined.pipe";
+import { AnnaDateFormatterPipe } from "./anna-core-shared-lib/pipes/annaDateFormatter.pipe";
+import { AnnaFilterSearchedTextPipe } from "./anna-core-shared-lib/pipes/annaFilterSearchedText.pipe";
+import { AnnaReplaceCharPipe } from "./anna-core-shared-lib/pipes/annaReplaceChar.pipe";
+import { AnnaTypeofDataPipe } from "./anna-core-shared-lib/pipes/annaTypeOfData.pipe";
+import { AnnaCalendarFilterComponent } from "./anna-dropdown-lib/components/anna-calendar-filter/anna-calendar-filter.component";
+import { AnnaWeekCalendarComponent } from "./anna-dropdown-lib/components/anna-week-calendar-filter/anna-week-calendar-filter.component";
+import { AnnaColumnCheckboxFilterComponent } from "./anna-generic-table-lib/components/anna-column-filters/anna-column-checkbox-filter/anna-column-checkbox-filter.component";
+import { AnnaColumnDateRangeFilterComponent } from "./anna-generic-table-lib/components/anna-column-filters/anna-column-date-range-filter/anna-column-date-range-filter.component";
+import { AnnaColumnSliderFilterComponent } from "./anna-generic-table-lib/components/anna-column-filters/anna-column-slider-filter/anna-column-slider-filter.component";
+import { AnnaColumnTimeFilterComponent } from "./anna-generic-table-lib/components/anna-column-filters/anna-column-time-filter/anna-column-time-filter.component";
+import { AnnaNonEditableGenericTableComponent } from "./anna-generic-table-lib/components/anna-non-editable-generic-table/anna-non-editable-generic-table.component";
+import { AnnaSortComponent } from "./anna-generic-table-lib/components/anna-sort/anna-sort.component";
+import { AnnaTableVirtualScrollViewportComponent } from "./anna-generic-table-lib/components/anna-table-virtual-scroll-viewport/anna-table-virtual-scroll-viewport.component";
+import { AnnaFixedRowSizeTableVirtualScrollStrategyDirective } from "./anna-generic-table-lib/directives/anna-fixed-row-size-table-virtual-scroll-strategy";
+import { AnnaVirtualTableDirective } from "./anna-generic-table-lib/directives/anna-virtual-table";
+import * as i0 from "@angular/core";
+import * as i1 from "ng-circle-progress";
+export class AnnaCoreModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AnnaCoreModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.2.12", ngImport: i0, type: AnnaCoreModule, imports: [CommonModule,
+            NgbModule,
+            FormsModule,
+            MatRadioModule,
+            MatButtonToggleModule,
+            MatTableModule,
+            NgxSliderModule,
+            NgxSkeletonLoaderModule,
+            ScrollingModule, i1.NgCircleProgressModule, AnnaNoDataComponent,
+            AnnaFilterSearchedTextPipe,
+            AnnaConvertZeroOrNullOrUndefinedPipe,
+            AnnaTypeofDataPipe,
+            AnnaFilterSearchedTextPipe,
+            AnnaReplaceCharPipe,
+            AnnaBuyerApprovalIconTemplateComponent,
+            AnnaLiveIconTemplateComponent,
+            AnnaNotifyIconTemplateComponent,
+            AnnaPayForPerformanceIconTemplateComponent,
+            AnnaRejectedIconTemplateComponent,
+            ShowEllipsisTextOnHoverDirective,
+            AnnaIconColumnComponent,
+            AnnaWeekCalendarComponent,
+            AnnaCalendarFilterComponent,
+            AnnaSortComponent,
+            AnnaVirtualTableDirective,
+            AnnaNonEditableGenericTableComponent,
+            AnnaTableVirtualScrollViewportComponent,
+            AnnaFixedRowSizeTableVirtualScrollStrategyDirective,
+            DigitOnlyDirective,
+            AnnaColumnDateRangeFilterComponent,
+            AnnaColumnTimeFilterComponent,
+            AnnaColumnCheckboxFilterComponent,
+            AnnaDeletedOrderIconTemplateComponent,
+            AnnaColumnSliderFilterComponent,
+            AnnaDateFormatterPipe,
+            AnnaConvertArrayToCommaSeperatedValue,
+            FixedRowsPopupTableDirective,
+            AnnaEstIconTemplateComponent], exports: [AnnaNoDataComponent,
+            AnnaFilterSearchedTextPipe,
+            AnnaConvertZeroOrNullOrUndefinedPipe,
+            AnnaTypeofDataPipe,
+            AnnaReplaceCharPipe,
+            AnnaFilterSearchedTextPipe,
+            AnnaBuyerApprovalIconTemplateComponent,
+            AnnaLiveIconTemplateComponent,
+            AnnaNotifyIconTemplateComponent,
+            AnnaPayForPerformanceIconTemplateComponent,
+            AnnaRejectedIconTemplateComponent,
+            ShowEllipsisTextOnHoverDirective,
+            AnnaIconColumnComponent,
+            AnnaWeekCalendarComponent,
+            AnnaCalendarFilterComponent,
+            AnnaSortComponent,
+            AnnaVirtualTableDirective,
+            AnnaNonEditableGenericTableComponent,
+            AnnaTableVirtualScrollViewportComponent,
+            AnnaColumnDateRangeFilterComponent,
+            AnnaColumnTimeFilterComponent,
+            AnnaColumnCheckboxFilterComponent,
+            AnnaFixedRowSizeTableVirtualScrollStrategyDirective,
+            DigitOnlyDirective,
+            AnnaDeletedOrderIconTemplateComponent,
+            AnnaColumnSliderFilterComponent,
+            AnnaDateFormatterPipe,
+            AnnaConvertArrayToCommaSeperatedValue,
+            FixedRowsPopupTableDirective] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AnnaCoreModule, imports: [CommonModule,
+            NgbModule,
+            FormsModule,
+            MatRadioModule,
+            MatButtonToggleModule,
+            MatTableModule,
+            NgxSliderModule,
+            NgxSkeletonLoaderModule,
+            ScrollingModule,
+            NgCircleProgressModule.forRoot({
+                radius: 100,
+                outerStrokeWidth: 16,
+                innerStrokeWidth: 8,
+                outerStrokeColor: "#78C000",
+                innerStrokeColor: "#C7E596",
+                animationDuration: 300,
+            }),
+            AnnaWeekCalendarComponent,
+            AnnaCalendarFilterComponent,
+            AnnaNonEditableGenericTableComponent,
+            AnnaColumnDateRangeFilterComponent,
+            AnnaColumnTimeFilterComponent,
+            AnnaColumnCheckboxFilterComponent,
+            AnnaColumnSliderFilterComponent] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AnnaCoreModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        CommonModule,
+                        NgbModule,
+                        FormsModule,
+                        MatRadioModule,
+                        MatButtonToggleModule,
+                        MatTableModule,
+                        NgxSliderModule,
+                        NgxSkeletonLoaderModule,
+                        ScrollingModule,
+                        NgCircleProgressModule.forRoot({
+                            radius: 100,
+                            outerStrokeWidth: 16,
+                            innerStrokeWidth: 8,
+                            outerStrokeColor: "#78C000",
+                            innerStrokeColor: "#C7E596",
+                            animationDuration: 300,
+                        }),
+                        AnnaNoDataComponent,
+                        AnnaFilterSearchedTextPipe,
+                        AnnaConvertZeroOrNullOrUndefinedPipe,
+                        AnnaTypeofDataPipe,
+                        AnnaFilterSearchedTextPipe,
+                        AnnaReplaceCharPipe,
+                        AnnaBuyerApprovalIconTemplateComponent,
+                        AnnaLiveIconTemplateComponent,
+                        AnnaNotifyIconTemplateComponent,
+                        AnnaPayForPerformanceIconTemplateComponent,
+                        AnnaRejectedIconTemplateComponent,
+                        ShowEllipsisTextOnHoverDirective,
+                        AnnaIconColumnComponent,
+                        AnnaWeekCalendarComponent,
+                        AnnaCalendarFilterComponent,
+                        AnnaSortComponent,
+                        AnnaVirtualTableDirective,
+                        AnnaNonEditableGenericTableComponent,
+                        AnnaTableVirtualScrollViewportComponent,
+                        AnnaFixedRowSizeTableVirtualScrollStrategyDirective,
+                        DigitOnlyDirective,
+                        AnnaColumnDateRangeFilterComponent,
+                        AnnaColumnTimeFilterComponent,
+                        AnnaColumnCheckboxFilterComponent,
+                        AnnaDeletedOrderIconTemplateComponent,
+                        AnnaColumnSliderFilterComponent,
+                        AnnaDateFormatterPipe,
+                        AnnaConvertArrayToCommaSeperatedValue,
+                        FixedRowsPopupTableDirective,
+                        AnnaEstIconTemplateComponent,
+                    ],
+                    exports: [
+                        AnnaNoDataComponent,
+                        AnnaFilterSearchedTextPipe,
+                        AnnaConvertZeroOrNullOrUndefinedPipe,
+                        AnnaTypeofDataPipe,
+                        AnnaReplaceCharPipe,
+                        AnnaFilterSearchedTextPipe,
+                        AnnaBuyerApprovalIconTemplateComponent,
+                        AnnaLiveIconTemplateComponent,
+                        AnnaNotifyIconTemplateComponent,
+                        AnnaPayForPerformanceIconTemplateComponent,
+                        AnnaRejectedIconTemplateComponent,
+                        ShowEllipsisTextOnHoverDirective,
+                        AnnaIconColumnComponent,
+                        AnnaWeekCalendarComponent,
+                        AnnaCalendarFilterComponent,
+                        AnnaSortComponent,
+                        AnnaVirtualTableDirective,
+                        AnnaNonEditableGenericTableComponent,
+                        AnnaTableVirtualScrollViewportComponent,
+                        AnnaColumnDateRangeFilterComponent,
+                        AnnaColumnTimeFilterComponent,
+                        AnnaColumnCheckboxFilterComponent,
+                        AnnaFixedRowSizeTableVirtualScrollStrategyDirective,
+                        DigitOnlyDirective,
+                        AnnaDeletedOrderIconTemplateComponent,
+                        AnnaColumnSliderFilterComponent,
+                        AnnaDateFormatterPipe,
+                        AnnaConvertArrayToCommaSeperatedValue,
+                        FixedRowsPopupTableDirective,
+                    ],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"anna-core.module.js","sourceRoot":"","sources":["../../../../projects/anna-core/src/lib/anna-core.module.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable max-len */\r\nimport { ScrollingModule } from \"@angular/cdk/scrolling\";\r\nimport { CommonModule } from \"@angular/common\";\r\nimport { NgModule } from \"@angular/core\";\r\nimport { FormsModule } from \"@angular/forms\";\r\nimport { MatButtonToggleModule } from \"@angular/material/button-toggle\";\r\nimport { MatRadioModule } from \"@angular/material/radio\";\r\nimport { MatTableModule } from \"@angular/material/table\";\r\nimport { NgxSliderModule } from \"@angular-slider/ngx-slider\";\r\nimport { NgbModule } from \"@ng-bootstrap/ng-bootstrap\";\r\nimport { NgCircleProgressModule } from \"ng-circle-progress\";\r\nimport { NgxSkeletonLoaderModule } from \"ngx-skeleton-loader\";\r\n\r\nimport { AnnaBuyerApprovalIconTemplateComponent } from \"./anna-core-shared-lib/components/anna-buyer-approval-icon-template/anna-buyer-approval-icon-template.component\";\r\nimport { AnnaDeletedOrderIconTemplateComponent } from \"./anna-core-shared-lib/components/anna-deleted-order-icon-template/anna-deleted-order-icon-template.component\";\r\nimport { AnnaEstIconTemplateComponent } from \"./anna-core-shared-lib/components/anna-est-icon-template/anna-est-icon-template.component\";\r\nimport { AnnaIconColumnComponent } from \"./anna-core-shared-lib/components/anna-icon-column/anna-icon-column.component\";\r\nimport { AnnaLiveIconTemplateComponent } from \"./anna-core-shared-lib/components/anna-live-icon-template/anna-live-icon-template.component\";\r\nimport { AnnaNoDataComponent } from \"./anna-core-shared-lib/components/anna-no-data/anna-no-data.component\";\r\nimport { AnnaNotifyIconTemplateComponent } from \"./anna-core-shared-lib/components/anna-notify-icon-template/anna-notify-icon-template.component\";\r\nimport { AnnaPayForPerformanceIconTemplateComponent } from \"./anna-core-shared-lib/components/anna-pay-for-performance-icon-template/anna-pay-for-performance-icon-template.component\";\r\nimport { AnnaRejectedIconTemplateComponent } from \"./anna-core-shared-lib/components/anna-rejected-icon-template/anna-rejected-icon-template.component\";\r\nimport { DigitOnlyDirective } from \"./anna-core-shared-lib/directives/digits-only/digits-only.directive\";\r\nimport { FixedRowsPopupTableDirective } from \"./anna-core-shared-lib/directives/fixed-rows-popup-table/fixed-rows-popup-table.directive\";\r\nimport { ShowEllipsisTextOnHoverDirective } from \"./anna-core-shared-lib/directives/show-ellipsis-text/show-ellipsis-text.directive\";\r\nimport { AnnaConvertArrayToCommaSeperatedValue } from \"./anna-core-shared-lib/pipes/annaConvertArrayToCommaSeperatedValue.pipe\";\r\nimport { AnnaConvertZeroOrNullOrUndefinedPipe } from \"./anna-core-shared-lib/pipes/annaConvertZeroOrNullOrUndefined.pipe\";\r\nimport { AnnaDateFormatterPipe } from \"./anna-core-shared-lib/pipes/annaDateFormatter.pipe\";\r\nimport { AnnaFilterSearchedTextPipe } from \"./anna-core-shared-lib/pipes/annaFilterSearchedText.pipe\";\r\nimport { AnnaReplaceCharPipe } from \"./anna-core-shared-lib/pipes/annaReplaceChar.pipe\";\r\nimport { AnnaTypeofDataPipe } from \"./anna-core-shared-lib/pipes/annaTypeOfData.pipe\";\r\nimport { AnnaCalendarFilterComponent } from \"./anna-dropdown-lib/components/anna-calendar-filter/anna-calendar-filter.component\";\r\nimport { AnnaWeekCalendarComponent } from \"./anna-dropdown-lib/components/anna-week-calendar-filter/anna-week-calendar-filter.component\";\r\nimport { AnnaColumnCheckboxFilterComponent } from \"./anna-generic-table-lib/components/anna-column-filters/anna-column-checkbox-filter/anna-column-checkbox-filter.component\";\r\nimport { AnnaColumnDateRangeFilterComponent } from \"./anna-generic-table-lib/components/anna-column-filters/anna-column-date-range-filter/anna-column-date-range-filter.component\";\r\nimport { AnnaColumnSliderFilterComponent } from \"./anna-generic-table-lib/components/anna-column-filters/anna-column-slider-filter/anna-column-slider-filter.component\";\r\nimport { AnnaColumnTimeFilterComponent } from \"./anna-generic-table-lib/components/anna-column-filters/anna-column-time-filter/anna-column-time-filter.component\";\r\nimport { AnnaNonEditableGenericTableComponent } from \"./anna-generic-table-lib/components/anna-non-editable-generic-table/anna-non-editable-generic-table.component\";\r\nimport { AnnaSortComponent } from \"./anna-generic-table-lib/components/anna-sort/anna-sort.component\";\r\nimport { AnnaTableVirtualScrollViewportComponent } from \"./anna-generic-table-lib/components/anna-table-virtual-scroll-viewport/anna-table-virtual-scroll-viewport.component\";\r\nimport { AnnaFixedRowSizeTableVirtualScrollStrategyDirective } from \"./anna-generic-table-lib/directives/anna-fixed-row-size-table-virtual-scroll-strategy\";\r\nimport { AnnaVirtualTableDirective } from \"./anna-generic-table-lib/directives/anna-virtual-table\";\r\n\r\n@NgModule({\r\n    imports: [\r\n        CommonModule,\r\n        NgbModule,\r\n        FormsModule,\r\n        MatRadioModule,\r\n        MatButtonToggleModule,\r\n        MatTableModule,\r\n        NgxSliderModule,\r\n        NgxSkeletonLoaderModule,\r\n        ScrollingModule,\r\n        NgCircleProgressModule.forRoot({\r\n            radius: 100,\r\n            outerStrokeWidth: 16,\r\n            innerStrokeWidth: 8,\r\n            outerStrokeColor: \"#78C000\",\r\n            innerStrokeColor: \"#C7E596\",\r\n            animationDuration: 300,\r\n        }),\r\n        AnnaNoDataComponent,\r\n        AnnaFilterSearchedTextPipe,\r\n        AnnaConvertZeroOrNullOrUndefinedPipe,\r\n        AnnaTypeofDataPipe,\r\n        AnnaFilterSearchedTextPipe,\r\n        AnnaReplaceCharPipe,\r\n        AnnaBuyerApprovalIconTemplateComponent,\r\n        AnnaLiveIconTemplateComponent,\r\n        AnnaNotifyIconTemplateComponent,\r\n        AnnaPayForPerformanceIconTemplateComponent,\r\n        AnnaRejectedIconTemplateComponent,\r\n        ShowEllipsisTextOnHoverDirective,\r\n        AnnaIconColumnComponent,\r\n        AnnaWeekCalendarComponent,\r\n        AnnaCalendarFilterComponent,\r\n        AnnaSortComponent,\r\n        AnnaVirtualTableDirective,\r\n        AnnaNonEditableGenericTableComponent,\r\n        AnnaTableVirtualScrollViewportComponent,\r\n        AnnaFixedRowSizeTableVirtualScrollStrategyDirective,\r\n        DigitOnlyDirective,\r\n        AnnaColumnDateRangeFilterComponent,\r\n        AnnaColumnTimeFilterComponent,\r\n        AnnaColumnCheckboxFilterComponent,\r\n        AnnaDeletedOrderIconTemplateComponent,\r\n        AnnaColumnSliderFilterComponent,\r\n        AnnaDateFormatterPipe,\r\n        AnnaConvertArrayToCommaSeperatedValue,\r\n        FixedRowsPopupTableDirective,\r\n        AnnaEstIconTemplateComponent,\r\n    ],\r\n    exports: [\r\n        AnnaNoDataComponent,\r\n        AnnaFilterSearchedTextPipe,\r\n        AnnaConvertZeroOrNullOrUndefinedPipe,\r\n        AnnaTypeofDataPipe,\r\n        AnnaReplaceCharPipe,\r\n        AnnaFilterSearchedTextPipe,\r\n        AnnaBuyerApprovalIconTemplateComponent,\r\n        AnnaLiveIconTemplateComponent,\r\n        AnnaNotifyIconTemplateComponent,\r\n        AnnaPayForPerformanceIconTemplateComponent,\r\n        AnnaRejectedIconTemplateComponent,\r\n        ShowEllipsisTextOnHoverDirective,\r\n        AnnaIconColumnComponent,\r\n        AnnaWeekCalendarComponent,\r\n        AnnaCalendarFilterComponent,\r\n        AnnaSortComponent,\r\n        AnnaVirtualTableDirective,\r\n        AnnaNonEditableGenericTableComponent,\r\n        AnnaTableVirtualScrollViewportComponent,\r\n        AnnaColumnDateRangeFilterComponent,\r\n        AnnaColumnTimeFilterComponent,\r\n        AnnaColumnCheckboxFilterComponent,\r\n        AnnaFixedRowSizeTableVirtualScrollStrategyDirective,\r\n        DigitOnlyDirective,\r\n        AnnaDeletedOrderIconTemplateComponent,\r\n        AnnaColumnSliderFilterComponent,\r\n        AnnaDateFormatterPipe,\r\n        AnnaConvertArrayToCommaSeperatedValue,\r\n        FixedRowsPopupTableDirective,\r\n    ],\r\n})\r\nexport class AnnaCoreModule {}\r\n"]}