@annalib/anna-core 2.2.0 → 2.3.0

package/src/lib/anna-core-shared-lib/services/anna-sort.service.d.ts

@@ -0,0 +1,16 @@
+import { Subject } from 'rxjs';
+import { SortType } from '../models/anna-sort.model';
+import { AnnaDateTimeFormatService } from './anna-date-time-format.service';
+import * as i0 from "@angular/core";
+export declare class AnnaSortService {
+    private annaDateTimeFormatService;
+    columnSortState: Map<string, SortType>;
+    noSortingAppliedData: any[];
+    updateSortTypeSubject: Subject<string>;
+    dateSet: Set<string>;
+    constructor(annaDateTimeFormatService: AnnaDateTimeFormatService);
+    sortDataForComponentOtherThanLurAndCsrPage(isAsc: boolean, data: any[], key: string): any[];
+    sortEnterEditLurAndCsrPage(isAsc: boolean, data: any[], key: any): any[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<AnnaSortService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AnnaSortService>;
+}

package/src/lib/anna-dropdown-lib/anna-dropdown-lib.module.d.ts

@@ -0,0 +1,11 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./components/anna-week-calendar-filter/anna-week-calendar-filter.component";
+import * as i2 from "./components/anna-calendar-filter/anna-calendar-filter.component";
+import * as i3 from "@angular/common";
+import * as i4 from "@ng-bootstrap/ng-bootstrap";
+import * as i5 from "@annalib/anna-core/src/lib/anna-core-shared-lib";
+export declare class AnnaDropdownLibModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AnnaDropdownLibModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AnnaDropdownLibModule, [typeof i1.AnnaWeekCalendarComponent, typeof i2.AnnaCalendarFilterComponent], [typeof i3.CommonModule, typeof i4.NgbModule, typeof i5.AnnaCoreSharedLibModule], [typeof i1.AnnaWeekCalendarComponent, typeof i2.AnnaCalendarFilterComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AnnaDropdownLibModule>;
+}

package/src/lib/anna-dropdown-lib/annalib-anna-core-src-lib-anna-dropdown-lib.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+/// <amd-module name="@annalib/anna-core/src/lib/anna-dropdown-lib" />
+export * from './public-api';

package/src/lib/anna-dropdown-lib/components/anna-calendar-filter/anna-calendar-filter.component.d.ts

@@ -0,0 +1,34 @@
+import { EventEmitter, OnChanges, OnInit, SimpleChanges } from "@angular/core";
+import { NgbDate, NgbDatepickerConfig } from "@ng-bootstrap/ng-bootstrap";
+import { AnnaDateTimeFormatService } from "@annalib/anna-core/src/lib/anna-core-shared-lib";
+import * as i0 from "@angular/core";
+export declare class AnnaCalendarFilterComponent implements OnInit, OnChanges {
+    private annaTimeService;
+    private datePickerConfig;
+    maxDate: any;
+    label: string;
+    minDate: any;
+    selectedDate: EventEmitter<any>;
+    selectedFromDate: any;
+    selectedToDate: any;
+    apply: EventEmitter<any>;
+    cancel: EventEmitter<any>;
+    fromDate: any;
+    toDate: any;
+    hoveredDate: any;
+    disableApplyBtn: boolean;
+    dateToBeShownInInput: string;
+    constructor(annaTimeService: AnnaDateTimeFormatService, datePickerConfig: NgbDatepickerConfig);
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnInit(): void;
+    onDateSelection(date: NgbDate): void;
+    isHovered(date: NgbDate): boolean;
+    isInside(date: NgbDate): boolean;
+    isRange(date: NgbDate): boolean;
+    cancelSelection(): void;
+    applySelection(): void;
+    disableCalendarApplyBtn(): void;
+    setInputText(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AnnaCalendarFilterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AnnaCalendarFilterComponent, "anna-core-calendar-filter-lib", never, { "maxDate": "maxDate"; "label": "label"; "minDate": "minDate"; "selectedFromDate": "selectedFromDate"; "selectedToDate": "selectedToDate"; }, { "selectedDate": "selectedDate"; "apply": "apply"; "cancel": "cancel"; }, never, never>;
+}

package/src/lib/anna-dropdown-lib/components/anna-week-calendar-filter/anna-week-calendar-filter.component.d.ts

@@ -0,0 +1,67 @@
+import { DatePipe } from "@angular/common";
+import { AfterViewInit, EventEmitter, OnChanges, OnInit, SimpleChanges } from "@angular/core";
+import { NgbCalendar, NgbDate, NgbDatepickerConfig, NgbDateStruct, NgbInputDatepicker } from "@ng-bootstrap/ng-bootstrap";
+import { WeekObject, IWeekCalendar, AnnaDateTimeFormatService, AnnaGlobalConfigService } from "@annalib/anna-core/src/lib/anna-core-shared-lib";
+import * as i0 from "@angular/core";
+export declare class AnnaWeekCalendarComponent implements OnInit, OnChanges, AfterViewInit {
+    private calendar;
+    private datePickerConfig;
+    private annaDateTimeFormatService;
+    private globalConfigService;
+    fromDate: NgbDate | null;
+    hoveredDate: NgbDate | null;
+    toDate: NgbDate | null;
+    today: NgbDate;
+    model: NgbDateStruct;
+    weekNumbers: string[];
+    pipe: DatePipe;
+    dateToDisplay: string;
+    weekObjects: WeekObject[];
+    multiSelectDropdownOpen: boolean;
+    datepicker: NgbInputDatepicker;
+    private formatter;
+    formattedStartDate: string;
+    formattedEndDate: string;
+    private calendarMap;
+    private flag1;
+    private flag2;
+    selectedFromDate: NgbDateStruct;
+    selectedEndDate: NgbDateStruct;
+    disabledDates: NgbDate[];
+    maxDate: any;
+    minDate: any;
+    disabledFunc: any;
+    state: any;
+    private _defaultValues;
+    config: IWeekCalendar;
+    applyWeekCalendarChanges: EventEmitter<any>;
+    calendarToggled: EventEmitter<any>;
+    ngOnChanges(changes: SimpleChanges): void;
+    constructor(calendar: NgbCalendar, datePickerConfig: NgbDatepickerConfig, annaDateTimeFormatService: AnnaDateTimeFormatService, globalConfigService: AnnaGlobalConfigService);
+    getWeekNumber(week: any, firstDayOfWeek: any): number;
+    ngAfterViewInit(): void;
+    ngOnInit(): void;
+    initializeWeekData(): void;
+    selectWeek(date: NgbDate): void;
+    weekNumberGenerator(): void;
+    selectedDates(dates: any): void;
+    formattedDates(): (fromDate: NgbDate, toDate: NgbDate) => this;
+    displayToUI(): void;
+    constructStartDate(date: Date): (constructDate: any) => any;
+    constructEndDate(date: Date): (constructDate: any) => any;
+    buildDate(date: Date): (number: number) => NgbDate | null;
+    isHovered(date: NgbDate): boolean | null;
+    isInside(date: NgbDate): boolean | null;
+    isRange(date: NgbDate): boolean | null;
+    previousWeek(): void;
+    nextWeek(): void;
+    setCalendarMap(): void;
+    applyChanges(): void;
+    isFocused(value: any): void;
+    isDropdownOpenedForCalendar(datepicker: NgbInputDatepicker): void;
+    revertDates(): void;
+    checkIfDateIsDisabled(date: any): boolean;
+    closeDatepicker(datepickerRef: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AnnaWeekCalendarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AnnaWeekCalendarComponent, "anna-core-week-calendar-filter-lib", never, { "selectedFromDate": "from-date"; "selectedEndDate": "to-date"; "disabledDates": "disabled-dates"; "maxDate": "maxDate"; "minDate": "minDate"; "config": "week-calendar-config"; }, { "applyWeekCalendarChanges": "apply"; "calendarToggled": "toggle-calendar"; }, never, never>;
+}

package/src/lib/anna-dropdown-lib/package.json

@@ -0,0 +1,10 @@
+{
+  "module": "../../../fesm2015/annalib-anna-core-src-lib-anna-dropdown-lib.mjs",
+  "es2020": "../../../fesm2020/annalib-anna-core-src-lib-anna-dropdown-lib.mjs",
+  "esm2020": "../../../esm2020/src/lib/anna-dropdown-lib/annalib-anna-core-src-lib-anna-dropdown-lib.mjs",
+  "fesm2020": "../../../fesm2020/annalib-anna-core-src-lib-anna-dropdown-lib.mjs",
+  "fesm2015": "../../../fesm2015/annalib-anna-core-src-lib-anna-dropdown-lib.mjs",
+  "typings": "annalib-anna-core-src-lib-anna-dropdown-lib.d.ts",
+  "sideEffects": false,
+  "name": "@annalib/anna-core/src/lib/anna-dropdown-lib"
+}

package/src/lib/anna-dropdown-lib/public-api.d.ts

@@ -0,0 +1,3 @@
+export * from "./anna-dropdown-lib.module";
+export * from "./components/anna-calendar-filter/anna-calendar-filter.component";
+export * from "./components/anna-week-calendar-filter/anna-week-calendar-filter.component";

package/src/lib/anna-generic-table-lib/anna-generic-table-lib.module.d.ts

@@ -0,0 +1,21 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./components/anna-non-editable-generic-table/anna-non-editable-generic-table.component";
+import * as i2 from "./components/anna-sort/anna-sort.component";
+import * as i3 from "./components/anna-table-virtual-scroll-viewport/anna-table-virtual-scroll-viewport.component";
+import * as i4 from "./directives/anna-fixed-row-size-table-virtual-scroll-strategy/anna-fixed-row-size-table-virtual-scroll-strategy.directive";
+import * as i5 from "./directives/anna-virtual-table/anna-virtual-table.directive";
+import * as i6 from "@angular/common";
+import * as i7 from "@ng-bootstrap/ng-bootstrap";
+import * as i8 from "@annalib/anna-core/src/lib/anna-dropdown-lib";
+import * as i9 from "@angular/material/button-toggle";
+import * as i10 from "@angular/forms";
+import * as i11 from "@angular-slider/ngx-slider";
+import * as i12 from "ngx-skeleton-loader";
+import * as i13 from "@angular/material/table";
+import * as i14 from "@angular/material/radio";
+import * as i15 from "@annalib/anna-core/src/lib/anna-core-shared-lib";
+export declare class AnnaGenericTableLibModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AnnaGenericTableLibModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AnnaGenericTableLibModule, [typeof i1.AnnaNonEditableGenericTableComponent, typeof i2.AnnaSortComponent, typeof i3.AnnaTableVirtualScrollViewportComponent, typeof i4.AnnaFixedRowSizeTableVirtualScrollStrategyDirective, typeof i5.AnnaVirtualTableDirective], [typeof i6.CommonModule, typeof i7.NgbModule, typeof i8.AnnaDropdownLibModule, typeof i9.MatButtonToggleModule, typeof i10.FormsModule, typeof i11.NgxSliderModule, typeof i12.NgxSkeletonLoaderModule, typeof i13.MatTableModule, typeof i14.MatRadioModule, typeof i15.AnnaCoreSharedLibModule], [typeof i1.AnnaNonEditableGenericTableComponent, typeof i2.AnnaSortComponent, typeof i3.AnnaTableVirtualScrollViewportComponent, typeof i4.AnnaFixedRowSizeTableVirtualScrollStrategyDirective, typeof i5.AnnaVirtualTableDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AnnaGenericTableLibModule>;
+}

package/src/lib/anna-generic-table-lib/annalib-anna-core-src-lib-anna-generic-table-lib.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+/// <amd-module name="@annalib/anna-core/src/lib/anna-generic-table-lib" />
+export * from './public-api';

package/src/lib/anna-generic-table-lib/components/anna-non-editable-generic-table/anna-non-editable-generic-table.component.d.ts

@@ -0,0 +1,244 @@
+import { OnInit, QueryList, EventEmitter, SimpleChanges, OnChanges, ChangeDetectorRef, ElementRef, AfterViewChecked } from '@angular/core';
+import moment from "moment";
+import { Options } from '@angular-slider/ngx-slider';
+import { AnnaSortComponent } from '../anna-sort/anna-sort.component';
+import { SellerGroupHierarchy, IWeekCalendar, TooltipModel, AnnaSortService, AnnaDateTimeFormatService, NgbDateType, AnnaFilterService, IGtGeneralConfig, IGtTableHeader, ITotalRowInfo, AnnaGenericTableService, SortType, IHeaderInfo, radioButtonModel, GtColumnIconEmittedData } from "@annalib/anna-core/src/lib/anna-core-shared-lib";
+import * as i0 from "@angular/core";
+export declare class AnnaNonEditableGenericTableComponent implements OnInit, OnChanges, AfterViewChecked {
+    private cdRef;
+    private annaSortService;
+    annaDateTimeFormatService: AnnaDateTimeFormatService;
+    annaFilterService: AnnaFilterService;
+    private annaGenericTableService;
+    showSkeletonLoading: boolean;
+    tableHeaders: IGtTableHeader[];
+    tableData: any[];
+    clonedTableData: any[];
+    numberOfSkeletonRows: number[];
+    numberOfSkeletonColumns: number[][];
+    gtGeneralConfig: IGtGeneralConfig;
+    totalRowInfo?: ITotalRowInfo[];
+    gtDimension: {
+        rowHeight: number;
+        tableHeight: string;
+        headerHeight: number;
+    };
+    tableClass: string;
+    maximumRowsWhichCanBeRenderedWithoutScroll: number;
+    includeBorderInTableHeight: boolean;
+    toggleCheckbox: EventEmitter<any>;
+    toggleRowCheckbox: EventEmitter<any>;
+    toggleHeaderCheckbox: EventEmitter<any>;
+    undoIconClicked: EventEmitter<any>;
+    filterAppliedToTable: EventEmitter<any>;
+    sortingAppliedToTable: EventEmitter<any>;
+    rowClicked: EventEmitter<any>;
+    radioButtonSelected: EventEmitter<any>;
+    columnFilterOpened: EventEmitter<any>;
+    columnFilterClosed: EventEmitter<any>;
+    gtIconClicked: EventEmitter<any>;
+    gtSVGIconClicked: EventEmitter<any>;
+    gtTextActionClicked: EventEmitter<any>;
+    gtViewDetailClicked: EventEmitter<any>;
+    tableDataWrapper: any[];
+    rowChecked: boolean;
+    isAllRowsChecked: boolean;
+    noDataWidth: string;
+    markedForCreditStatus: string;
+    markedForMGStatus: string;
+    toolTipdata: any;
+    tempTooltipData: any;
+    tooltipRadioTextMap: Map<any, any>;
+    filterTabObjects: any[];
+    tooltip: any;
+    clonedTooltipData: any;
+    clonedTooltipSelectedMapData: any;
+    searchBar: string;
+    disableClearAllBtn: boolean;
+    disableColumnClearAllBtn: boolean;
+    allSelected: number;
+    showAll: boolean;
+    disableCheckboxApply: boolean;
+    disableSliderApplyButton: boolean;
+    disableTimeApplyButton: boolean;
+    sliderMinValue: number;
+    sliderMaxValue: number;
+    options: Options;
+    sliderValue: {
+        min: number;
+        max: number;
+    };
+    sliderFilterTextBoxStep: string;
+    sliderEnteredMinValue: number;
+    sliderEnteredMaxValue: number;
+    calendarMinEnabledDate: NgbDateType;
+    calendarMaxEnabledDate: NgbDateType;
+    selectedMinDate: NgbDateType;
+    selectedMaxDate: NgbDateType;
+    multiWeekPickerConfig: IWeekCalendar;
+    selectedFromTime: any[];
+    selectedToTime: any[];
+    clonedSelectedFromTime: any;
+    clonedSelectedToTime: any;
+    disableTimeFilterApplyBtn: boolean;
+    tableColumns: string[];
+    totalRowColumns: string[];
+    showMultiTimeCheckbox: boolean;
+    showZeroTimeCheckbox: boolean;
+    showEnterTimeCheckbox: boolean;
+    multiTimeCheckboxChecked: boolean;
+    zeroTimeCheckboxChecked: boolean;
+    enterTimeCheckboxChecked: boolean;
+    bindValueFuncCalled: boolean;
+    hierarchyTooltip: {
+        open: () => void;
+        close: () => void;
+    };
+    sellerGroupHierarchy: SellerGroupHierarchy[];
+    showFilterTooltipTabs: boolean;
+    sortComponent: QueryList<AnnaSortComponent>;
+    isScrolledLeft: boolean;
+    rowBorderWidth: number;
+    showSortComponent: boolean;
+    showFilterComponent: boolean;
+    tempSortOrder: SortType;
+    tooltipOptions: TooltipModel[];
+    clonedTooltipOptions: TooltipModel[];
+    disableSelectAll: boolean;
+    disableClearAll: boolean;
+    searchItem: string;
+    disableCalendarApplyBtn: boolean;
+    calendarSelection: any;
+    showSliderMinValueError: boolean;
+    showSliderMaxValueError: boolean;
+    isMinTextBoxEmpty: boolean;
+    isMaxTextBoxEmpty: boolean;
+    selectedLabel: string;
+    startTimeHourErr: boolean;
+    startTimeMinErr: boolean;
+    endTimeHourErr: boolean;
+    endTimeMinErr: boolean;
+    sameTooltipClicked: boolean;
+    showNoDataToDisplay: boolean;
+    marginTop: string;
+    viewChildTableHeaders: QueryList<ElementRef>;
+    selectedCheckboxOptionsCount: number;
+    isFilterChanged: boolean;
+    isSortChanged: boolean;
+    isDifferenceLessThan25Percent: boolean;
+    incorrectSliderInput: boolean;
+    constructor(cdRef: ChangeDetectorRef, annaSortService: AnnaSortService, annaDateTimeFormatService: AnnaDateTimeFormatService, annaFilterService: AnnaFilterService, annaGenericTableService: AnnaGenericTableService);
+    ngAfterViewChecked(): void;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    trackByFn(index: number): number;
+    setTooltipRadioNames(): void;
+    generateTableDataWrapper(): void;
+    selectOrUnselectCheckbox(rowData: any, columnKeys: any, isCheckboxSelected: any): void;
+    selectUnselectAllRows(): void;
+    selectUnselectRow(rowData: any): void;
+    undoCreditedSpot(data: any): void;
+    undoMgSpot(data: any): void;
+    closeTooltip(): void;
+    isTooltipActive(header: any[]): boolean;
+    bindTheValueToToolTip(tooltip: any, header: IHeaderInfo): void;
+    checkIfUniqueValuePresentForTheHeader(header: IHeaderInfo, enabledHeaders: any[]): void;
+    openTooltip(tooltip: any, header: any, columnHeader: IHeaderInfo): void;
+    clearColumnFilter(): void;
+    populateTooltipDataBasedOnSelectedRadio(activeTab: radioButtonModel): void;
+    createFilterTooltipData(header: string): void;
+    disableActiveFilterClearButton(): void;
+    getSliderData(header: string): void;
+    createOptionsForSlider(header: string): void;
+    setSelectedRangeForSlider(header: string): void;
+    getCheckboxData(header: string): void;
+    createListForCheckboxFilter(header: string): TooltipModel[];
+    selectUnselectListCheckbox(tooltipOptions: TooltipModel[], header: string): void;
+    getCalendarData(): void;
+    createRangeForTheDateFilter(): moment.Moment[];
+    createStartEndDateRange(optionData: any[]): moment.Moment[];
+    selectRangeForTheDateFilter(minMaxDate: any[], parsingFormat: string): void;
+    getTimeFilterData(header: string): void;
+    setTimeFilterDataForComponentsOtherThanRatingsPage(header: string): void;
+    setTimeFilterDataForRatingPageComponent(header: string): void;
+    selectOrUnselectMultiTimeCheckbox(): void;
+    selectOrUnselectZeroTimeCheckbox(): void;
+    selectOrUnselectEnterTimeCheckbox(): void;
+    selectUnselectCheckbox(data: TooltipModel): void;
+    minValueChanged(val: string): void;
+    maxValueChanged(val: string): void;
+    showErrorForMinAndMaxValue(): void;
+    isValueInRange(val: number): boolean;
+    disableSliderApplyBtn(): void;
+    sliderValueChange(): void;
+    cancelSliderFilter(): void;
+    applyFilters(): void;
+    applyListFilters(): void;
+    applySortingOnFilteredData(): void;
+    emitData(): void;
+    applySorting(key: string): void;
+    revert(): void;
+    closeCheckboxFilter(): void;
+    applySliderFilter(): void;
+    applySliderFilterOnData(): void;
+    cancelInDateFilter(): void;
+    updateSortMap(): void;
+    applyDateFilter(): void;
+    applyDateFilterOnData(): void;
+    applyWeekFilter(event: any): void;
+    incrementHour(arr: any[]): void;
+    decrementHour(arr: any[]): void;
+    incrementMinute(arr: any[]): void;
+    decrementMinute(arr: any): void;
+    changeStartTimeHour(increment: boolean): void;
+    changeEndTimeHour(increment: boolean): void;
+    changeEndTimeMinute(increment: boolean): void;
+    changeStartTimeMinute(increment: boolean): void;
+    applyTimeFilters(): void;
+    applyTimeFilterOnData(): void;
+    closeTimeFilter(): void;
+    disableTimeFilterApplyButton(): void;
+    validateTimeFilterInput(): boolean;
+    sortedData(event: any): void;
+    checkIfSortingIsApplied(): void;
+    disableEnableEachColumnTooltipIcon(): void;
+    ngAfterViewInit(): void;
+    setMarginLeftForFilterIcon(): void;
+    dataRowClicked(rowData: any): void;
+    radioButtonClicked(data: any, action: string, isDisabled: boolean): void;
+    bindTheValueToSellerGroupTooltip(sellerGroupHierarchy: SellerGroupHierarchy[], tooltip: any): void;
+    iconClicked(rowData: any, iconClass: string): void;
+    svgIconClicked(data: GtColumnIconEmittedData): void;
+    textActionClicked(rowData: any, id: number): void;
+    viewDetailsClicked(rowData: any): void;
+    setColumnSortStateMap(): void;
+    storeSortTypeInTempVariable(event: SortType): void;
+    unCheckAllCheckbox(): void;
+    selectAllCheckbox(): void;
+    searchForTheItem(str: string): void;
+    boldString(str: string, find: string): string;
+    removeBoldElementFromString(originalString: string): string;
+    clearSearchedItem(): void;
+    calendarDateChanged(event: any): void;
+    disableCalendarApplyButton(): void;
+    setInitialValueMapForTimeFilter(key: string): void;
+    setInitialValueMapForRatingPageTimeFilter(key: string): void;
+    startTimeHourChange(val: string): void;
+    startTimeMinChange(val: string): void;
+    endTimeHourChange(val: string): void;
+    endTimeMinChange(val: string): void;
+    checkIfCheckboxTooltipIsFiltered(): boolean;
+    checkIfTimeTooltipIsFiltered(): boolean;
+    checkIfDateTooltipIsFiltered(): boolean;
+    setInitialValueMapForDateFilter(): void;
+    checkIfSliderTooltipIsFiltered(): boolean;
+    setInitialValueMapForSliderFilter(): void;
+    checkIfSortingChanged(): boolean;
+    disableApplyButtonOfSelectedFilter(): void;
+    disableCheckboxFilterApplyButton(): void;
+    trackByTooltipModelId(index: number, item: TooltipModel): number;
+    setActiveStateObject(): void;
+    setIsDifference(value: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AnnaNonEditableGenericTableComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AnnaNonEditableGenericTableComponent, "anna-core-non-editable-generic-table-lib", never, { "showSkeletonLoading": "showSkeletonLoading"; "tableHeaders": "tableHeaders"; "tableData": "tableData"; "clonedTableData": "clonedTableData"; "numberOfSkeletonRows": "numberOfSkeletonRows"; "numberOfSkeletonColumns": "numberOfSkeletonColumns"; "gtGeneralConfig": "gtGeneralConfig"; "totalRowInfo": "totalRowInfo"; "gtDimension": "gtDimension"; "tableClass": "tableClass"; "maximumRowsWhichCanBeRenderedWithoutScroll": "maximumRowsWhichCanBeRenderedWithoutScroll"; "includeBorderInTableHeight": "includeBorderInTableHeight"; }, { "toggleCheckbox": "toggleCheckbox"; "toggleRowCheckbox": "toggleRowCheckbox"; "toggleHeaderCheckbox": "toggleHeaderCheckbox"; "undoIconClicked": "undoIconClicked"; "filterAppliedToTable": "filterAppliedToTable"; "sortingAppliedToTable": "sortingAppliedToTable"; "rowClicked": "rowClicked"; "radioButtonSelected": "radioButtonSelected"; "columnFilterOpened": "columnFilterOpened"; "columnFilterClosed": "columnFilterClosed"; "gtIconClicked": "gtIconClicked"; "gtSVGIconClicked": "gtSVGIconClicked"; "gtTextActionClicked": "gtTextActionClicked"; "gtViewDetailClicked": "gtViewDetailClicked"; }, never, never>;
+}

package/src/lib/anna-generic-table-lib/components/anna-sort/anna-sort.component.d.ts

@@ -0,0 +1,16 @@
+import { EventEmitter, OnChanges, SimpleChanges } from '@angular/core';
+import { AnnaSortService, SortOption, SortType } from '@annalib/anna-core/src/lib/anna-core-shared-lib';
+import * as i0 from "@angular/core";
+export declare class AnnaSortComponent implements OnChanges {
+    private annaSortService;
+    sortObjectKey: string;
+    sortOptionClicked: EventEmitter<SortType>;
+    sortOptions: SortOption[];
+    constructor(annaSortService: AnnaSortService);
+    ngOnChanges(changes: SimpleChanges): void;
+    sortOptionChanged(index: number, sortType: SortType): void;
+    ngOnInit(): void;
+    setSortType(option: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AnnaSortComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AnnaSortComponent, "anna-core-sort-lib", never, { "sortObjectKey": "sortObjectKey"; }, { "sortOptionClicked": "sortOptionClicked"; }, never, never>;
+}

package/src/lib/anna-generic-table-lib/components/anna-table-virtual-scroll-viewport/anna-table-virtual-scroll-viewport.component.d.ts

@@ -0,0 +1,141 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { Directionality } from "@angular/cdk/bidi";
+import { ListRange } from "@angular/cdk/collections";
+import { ChangeDetectorRef, ElementRef, NgZone, OnDestroy, OnInit } from "@angular/core";
+import { Observable } from "rxjs";
+import { CdkScrollable, CdkVirtualScrollRepeater, VirtualScrollStrategy, ScrollDispatcher, ViewportRuler } from "@angular/cdk/scrolling";
+import { AnnaGenericTableService } from "@annalib/anna-core/src/lib/anna-core-shared-lib";
+import * as i0 from "@angular/core";
+/**
+ * A viewport that virtualizes its scrolling with the help of `CdkVirtualForOf`.
+ * Uses `top: #px` instead of `transform: translateY(#px)` like the cdk virtual scroll viewport does
+ * which avoids flickering of elements in the transformed container with `position: sticky`.
+ */
+export declare class AnnaTableVirtualScrollViewportComponent extends CdkScrollable implements OnInit, OnDestroy {
+    elementRef: ElementRef<HTMLElement>;
+    private _changeDetectorRef;
+    private _scrollStrategy;
+    private annaGtService;
+    /** Emits when the viewport is detached from a CdkVirtualForOf. */
+    private _detachedSubject;
+    /** Emits when the rendered range changes. */
+    private _renderedRangeSubject;
+    /** The direction the viewport scrolls. */
+    get orientation(): "horizontal" | "vertical";
+    set orientation(orientation: "horizontal" | "vertical");
+    private _orientation;
+    /** Emits when the index of the first element visible in the viewport changes. */
+    scrolledIndexChange: Observable<number>;
+    /** The element that wraps the rendered content. */
+    _contentWrapper: ElementRef<HTMLElement>;
+    /** A stream that emits whenever the rendered range changes. */
+    renderedRangeStream: Observable<ListRange>;
+    /**
+     * The total size of all content (in pixels), including content that is not currently rendered.
+     */
+    private _totalContentSize;
+    /** A string representing the `style.width` property value to be used for the spacer element. */
+    _totalContentWidth: string;
+    /** A string representing the `style.height` property value to be used for the spacer element. */
+    _totalContentHeight: string;
+    /**
+     * The CSS transform applied to the rendered subset of items so that they appear within the bounds
+     * of the visible viewport.
+     */
+    private _renderedContentTransform;
+    /** The currently rendered range of indices. */
+    private _renderedRange;
+    /** The length of the data bound to this viewport (in number of items). */
+    private _dataLength;
+    /** The size of the viewport (in pixels). */
+    private _viewportSize;
+    /** the currently attached CdkVirtualScrollRepeater. */
+    private _forOf;
+    /** The last rendered content offset that was set. */
+    private _renderedContentOffset;
+    /**
+     * Whether the last rendered content offset was to the end of the content (and therefore needs to
+     * be rewritten as an offset to the start of the content).
+     */
+    private _renderedContentOffsetNeedsRewrite;
+    /** Whether there is a pending change detection cycle. */
+    private _isChangeDetectionPending;
+    /** A list of functions to run after the next change detection cycle. */
+    private _runAfterChangeDetection;
+    /** Subscription to changes in the viewport size. */
+    private _viewportChanges;
+    constructor(elementRef: ElementRef<HTMLElement>, _changeDetectorRef: ChangeDetectorRef, ngZone: NgZone, _scrollStrategy: VirtualScrollStrategy, dir: Directionality, scrollDispatcher: ScrollDispatcher, viewportRuler: ViewportRuler, annaGtService: AnnaGenericTableService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    /** Attaches a `CdkVirtualScrollRepeater` to this viewport. */
+    attach(forOf: CdkVirtualScrollRepeater<any>): void;
+    /** Detaches the current `CdkVirtualForOf`. */
+    detach(): void;
+    /** Gets the length of the data bound to this viewport (in number of items). */
+    getDataLength(): number;
+    /** Gets the size of the viewport (in pixels). */
+    getViewportSize(): number;
+    /** Get the current rendered range of items. */
+    getRenderedRange(): ListRange;
+    /**
+     * Sets the total size of all content (in pixels), including content that is not currently
+     * rendered.
+     */
+    setTotalContentSize(size: number): void;
+    /** Sets the currently rendered range of indices. */
+    setRenderedRange(range: ListRange): void;
+    /**
+     * Gets the offset from the start of the viewport to the start of the rendered data (in pixels).
+     */
+    getOffsetToRenderedContentStart(): number | null;
+    /**
+     * Sets the offset from the start of the viewport to either the start or end of the rendered data
+     * (in pixels).
+     */
+    setRenderedContentOffset(offset: number): void;
+    /**
+     * Scrolls to the given offset from the start of the viewport. Please note that this is not always
+     * the same as setting `scrollTop` or `scrollLeft`. In a horizontal viewport with right-to-left
+     * direction, this would be the equivalent of setting a fictional `scrollRight` property.
+     * @param offset The offset to scroll to.
+     * @param behavior The ScrollBehavior to use when scrolling. Default is behavior is `auto`.
+     */
+    scrollToOffset(offset: number, behavior?: ScrollBehavior): void;
+    /**
+     * Scrolls to the offset for the given index.
+     * @param index The index of the element to scroll to.
+     * @param behavior The ScrollBehavior to use when scrolling. Default is behavior is `auto`.
+     */
+    scrollToIndex(index: number, behavior?: ScrollBehavior): void;
+    /**
+     * Gets the current scroll offset from the start of the viewport (in pixels).
+     * @param from The edge to measure the offset from. Defaults to 'top' in vertical mode and 'start'
+     *     in horizontal mode.
+     */
+    measureScrollOffset(from?: "top" | "left" | "right" | "bottom" | "start" | "end"): number;
+    /** Measure the combined size of all of the rendered items. */
+    measureRenderedContentSize(): number;
+    /**
+     * Measure the total combined size of the given range. Throws if the range includes items that are
+     * not rendered.
+     */
+    measureRangeSize(range: ListRange): number;
+    /** Update the viewport dimensions and re-render. */
+    checkViewportSize(): void;
+    /** Measure the viewport size. */
+    private _measureViewportSize;
+    /** Queue up change detection to run. */
+    private _markChangeDetectionNeeded;
+    /** Run change detection. */
+    private _doChangeDetection;
+    /** Calculates the `style.width` and `style.height` for the spacer element. */
+    private _calculateSpacerSize;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AnnaTableVirtualScrollViewportComponent, [null, null, null, { optional: true; }, { optional: true; }, null, null, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AnnaTableVirtualScrollViewportComponent, "anna-table-virtual-scroll-viewport", never, { "orientation": "orientation"; }, { "scrolledIndexChange": "scrolledIndexChange"; }, never, ["*"]>;
+}