@bcgov/nr-ngx-component-lib 0.0.56 → 0.0.57

package/components/icon/icon.component.d.ts

@@ -17,5 +17,7 @@ export declare class IconComponent extends NrclBase implements AfterContentInit
 }
 declare const ICON: {
     'clear-filters': string;
+    'user-clock': string;
+    roster: string;
 };
 export {};

package/components/list-attachments/list-attachments.component.d.ts

@@ -52,7 +52,7 @@ export declare class ListAttachmentsComponent extends RowListBase<{}, Attachment
         description: string;
     }[];
     ngOnChanges(changes: SimpleChanges): void;
-    get initialPageState(): RowListState<{}>;
+    getInitialPageState(): RowListState<{}>;
     fetchRowListPage(): Observable<any>;
     parseRows(res: any): AttachmentsTableRow[];
     onDownloadClick(item: AttachmentsTableRow): any;

package/components/list-event-history/list-event-history.component.d.ts

@@ -47,7 +47,7 @@ export declare class ListEventHistoryComponent extends RowListBase<{}, EventHist
     }[];
     fetchRowListPage(): Observable<any>;
     parseRows(res: any): EventHistoryTableRow[];
-    get initialPageState(): RowListState<{}>;
+    getInitialPageState(): RowListState<{}>;
     savePageState(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<ListEventHistoryComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<ListEventHistoryComponent, "nrcl-list-event-history", never, { "rowListProvider": { "alias": "rowListProvider"; "required": false; }; "canDelete": { "alias": "canDelete"; "required": false; }; "showPagination": { "alias": "showPagination"; "required": false; }; "isSupplier": { "alias": "isSupplier"; "required": false; }; "noRowsMessage": { "alias": "noRowsMessage"; "required": false; }; }, {}, never, never, false, never>;

package/components/list-select/list-select.component.d.ts

@@ -22,7 +22,7 @@ export declare class ListSelectComponent<T> extends RowListBase<{}, CodeDescript
     displayColumns: any[];
     ngOnChanges(changes: SimpleChanges): void;
     ngAfterContentInit(): void;
-    get initialPageState(): RowListState<{}>;
+    getInitialPageState(): RowListState<{}>;
     fetchRowListPage(): Observable<CodeDescription[]>;
     parseRows(res: any): CodeDescription[];
     parseTotalRowCount(res: any): number;

package/components/resource-schedule/resource-schedule.component.d.ts

@@ -0,0 +1,33 @@
+import { TemplateRef } from "@angular/core";
+import { MatMenuPanel } from "@angular/material/menu";
+import { ScheduleComponent, ScheduleProvider, ScheduleRow, ScheduleRowItem } from "../schedule/schedule.component";
+import * as i0 from "@angular/core";
+export declare class ResourceScheduleRowHeadingDirective {
+    template: TemplateRef<any>;
+    constructor(template: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResourceScheduleRowHeadingDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ResourceScheduleRowHeadingDirective, "[nrclResourceScheduleRowHeading]", never, {}, {}, never, never, false, never>;
+}
+export type ResourceScheduleItemTypes = 'rostered' | 'out-of-service' | 'available-duty-day' | 'available-standby-day' | 'available-off-day' | 'available-regular-day' | 'assigned-duty-day' | 'assigned-standby-day' | 'assigned-off-day' | 'assigned-regular-day';
+export type ResourceScheduleRowItem = ScheduleRowItem & {
+    name: ResourceScheduleItemTypes;
+    allocationType?: string;
+    shiftType?: string;
+    assignmentName?: string;
+};
+export type ResourceScheduleRow = ScheduleRow & {
+    items: (Promise<ResourceScheduleRowItem[]>);
+};
+export type ResourceSchedule = ResourceScheduleRow[];
+export declare class ResourceScheduleComponent {
+    provider?: ScheduleProvider;
+    startDate?: string;
+    weekStart: number;
+    dayCount?: number;
+    menu?: MatMenuPanel;
+    scheduleComponent?: ScheduleComponent;
+    headerTemplate: ResourceScheduleRowHeadingDirective;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResourceScheduleComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ResourceScheduleComponent, "nrcl-resource-schedule", never, { "provider": { "alias": "provider"; "required": false; }; "startDate": { "alias": "startDate"; "required": false; }; "weekStart": { "alias": "weekStart"; "required": false; }; "dayCount": { "alias": "dayCount"; "required": false; }; "menu": { "alias": "menu"; "required": false; }; }, {}, ["headerTemplate"], ["*"], false, never>;
+    static ngAcceptInputType_dayCount: unknown;
+}

package/components/schedule/schedule.component.d.ts

@@ -0,0 +1,83 @@
+import { OnChanges, QueryList, SimpleChanges, TemplateRef } from '@angular/core';
+import { MatMenuPanel } from '@angular/material/menu';
+import { Observable } from 'rxjs';
+import { PaginationState } from '../../directives/pagination.base';
+import { RowListBase } from '../../directives/row-list.base';
+import * as i0 from "@angular/core";
+export declare class ScheduleRowHeadingDirective {
+    template: TemplateRef<any>;
+    constructor(template: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScheduleRowHeadingDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ScheduleRowHeadingDirective, "[nrclScheduleRowHeading]", never, {}, {}, never, never, false, never>;
+}
+export declare class ScheduleItemDirective {
+    template: TemplateRef<any>;
+    name?: string;
+    constructor(template: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScheduleItemDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ScheduleItemDirective, "[nrclScheduleItem]", never, { "name": { "alias": "nrclScheduleItem"; "required": false; }; }, {}, never, never, false, never>;
+}
+export type ScheduleRowItem = {
+    id: string;
+    name: string;
+    icons?: () => string[];
+    tooltip?: () => string;
+    travel?: boolean;
+};
+export type ScheduleRow = {
+    id?: string;
+    heading: any;
+    items: Promise<ScheduleRowItem[]>;
+};
+export type Schedule = ScheduleRow[];
+type Day = {
+    dayName: string;
+    monthDay: number;
+    date: string;
+    isWeekend: boolean;
+    isToday: boolean;
+    isFirst: boolean;
+};
+type Week = {
+    start: string;
+    end: string;
+    span: number;
+};
+export type FetchScheduleParameters = {
+    pageNumber: number;
+    pageSize: number;
+    sortActive: string;
+    sortDirection: string;
+};
+export type FetchScheduleRowParameters = {
+    resourceId: string;
+};
+export interface ScheduleProvider {
+    fetchSchedule(x: FetchScheduleParameters): Observable<any>;
+    parseSchedule(res: any): Schedule;
+    getInitialPageState(): PaginationState<{}>;
+}
+export declare class ScheduleComponent extends RowListBase<{}, ScheduleRow> implements OnChanges {
+    provider?: ScheduleProvider;
+    startDate?: string;
+    weekStart: number;
+    dayCount?: number;
+    menu?: MatMenuPanel;
+    itemTemplates: QueryList<ScheduleItemDirective>;
+    headerTemplate: ScheduleRowHeadingDirective;
+    protected _days: Day[];
+    protected _weeks: Week[];
+    protected _templates: TemplateRef<any>[][];
+    ngOnChanges(changes: SimpleChanges): void;
+    ngAfterViewInit(): void;
+    fetchRowListPage(): Observable<any>;
+    parseRows(res: any): ScheduleRow[];
+    getInitialPageState(): PaginationState<{}>;
+    onSamePageFilterChange(ev: {}): void;
+    makeRows(schedule: Schedule): Schedule;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScheduleComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ScheduleComponent, "nrcl-schedule", never, { "provider": { "alias": "provider"; "required": false; }; "startDate": { "alias": "startDate"; "required": false; }; "weekStart": { "alias": "weekStart"; "required": false; }; "dayCount": { "alias": "dayCount"; "required": false; }; "menu": { "alias": "menu"; "required": false; }; }, {}, ["headerTemplate", "itemTemplates"], ["*"], false, never>;
+    static ngAcceptInputType_weekStart: unknown;
+    static ngAcceptInputType_dayCount: unknown;
+}
+export {};

package/components/tabs/tab/tab.component.d.ts

@@ -20,7 +20,7 @@ export declare class TabComponent extends NrclBase {
     label?: string;
     disabled: boolean;
     labelTemplate?: TabLabelDirective;
-    contentTemplate?: TabLabelDirective;
+    contentTemplate?: TabContentDirective;
     content: TemplateRef<any>;
     static ɵfac: i0.ɵɵFactoryDeclaration<TabComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<TabComponent, "nrcl-tab", never, { "name": { "alias": "name"; "required": false; }; "label": { "alias": "label"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, ["labelTemplate", "contentTemplate"], ["[nrclTabLabel]", "*"], false, never>;

package/directives/pagination.base.d.ts

@@ -0,0 +1,47 @@
+import { AfterViewInit, ChangeDetectorRef } from "@angular/core";
+import { Sort, SortDirection } from "@angular/material/sort";
+import { PageStateService } from "../services/page-state.service";
+import { NrclBase } from "./nrcl.base";
+import * as i0 from "@angular/core";
+export type PaginationConfig = {
+    pageSize: number;
+    pageNumber: number;
+    sortActive: string;
+    sortDirection: SortDirection;
+};
+export type PaginationState<F> = {
+    pageConfig: PaginationConfig;
+    filter: F;
+};
+export declare abstract class PaginationBase<F> extends NrclBase implements AfterViewInit {
+    pageStateService: PageStateService;
+    changeDetectorRef: ChangeDetectorRef;
+    protected _totalRowCount: number;
+    get totalRowCount(): number;
+    private _pageConfig;
+    get pageSize(): number;
+    get pageNumber(): number;
+    get sortActive(): string;
+    get sortDirection(): SortDirection;
+    private _filter?;
+    get filter(): F;
+    protected set filter(f: F);
+    ngAfterViewInit(): void;
+    clone(obj: any): any;
+    onFilterChange(ev: F): void;
+    onSortChange(ev: Sort): void;
+    onPageSizeChange(ev: number): void;
+    onPageNumberChange(ev: number): void;
+    get initialPageState(): PaginationState<F>;
+    abstract getInitialPageState(): PaginationState<F>;
+    loadPageState(): void;
+    savePageState(): void;
+    paginateState(id: string): {
+        id: string;
+        itemsPerPage: number;
+        currentPage: number;
+        totalItems: number;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<PaginationBase<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<PaginationBase<any>, never, never, {}, {}, never, never, false, never>;
+}

package/directives/row-list.base.d.ts

@@ -1,20 +1,10 @@
 import { AfterViewInit, ChangeDetectorRef, EventEmitter } from "@angular/core";
-import { Sort, SortDirection } from "@angular/material/sort";
 import { Observable } from "rxjs";
 import { PageStateService } from "../services/page-state.service";
-import { NrclBase } from "./nrcl.base";
+import { PaginationBase as PaginationBase, PaginationState } from "./pagination.base";
 import * as i0 from "@angular/core";
-export type RowListPageConfig = {
-    pageSize: number;
-    pageNumber: number;
-    sortActive: string;
-    sortDirection: SortDirection;
-};
-export type RowListState<F> = {
-    pageConfig: RowListPageConfig;
-    filter: F;
-};
-export declare abstract class RowListBase<F, R, L = any> extends NrclBase implements AfterViewInit {
+export type RowListState<F> = PaginationState<F>;
+export declare abstract class RowListBase<F, R, L = any> extends PaginationBase<F> implements AfterViewInit {
     pageStateService: PageStateService;
     changeDetectorRef: ChangeDetectorRef;
     isLoadingChange: EventEmitter<boolean>;
@@ -23,37 +13,16 @@ export declare abstract class RowListBase<F, R, L = any> extends NrclBase implem
     set isLoading(v: boolean);
     private _rows;
     get rows(): R[];
-    private _totalRowCount;
-    get totalRowCount(): number;
-    private _pageConfig;
-    get pageSize(): number;
-    get pageNumber(): number;
-    get sortActive(): string;
-    get sortDirection(): SortDirection;
-    private _filter?;
-    get filter(): F;
     private _loadRowListRequest?;
-    constructor();
     ngAfterViewInit(): void;
     refreshRowList(): Promise<void>;
+    loadRowList(): Promise<L>;
     abstract fetchRowListPage(): Observable<L>;
+    parseRowList(result: L): Promise<void>;
     abstract parseRows(res: L): R[];
     parseTotalRowCount(res: L): number;
     loadRowListPageFailed(error: any): void;
-    clone(obj: any): any;
-    onFilterChange(ev: F): void;
-    onSortChange(ev: Sort): void;
-    onPageSizeChange(ev: number): void;
     onPageNumberChange(ev: number): void;
-    abstract get initialPageState(): RowListState<F>;
-    loadPageState(): void;
-    savePageState(): void;
-    paginateState(id: string): {
-        id: string;
-        itemsPerPage: number;
-        currentPage: number;
-        totalItems: number;
-    };
     static ɵfac: i0.ɵɵFactoryDeclaration<RowListBase<any, any, any>, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<RowListBase<any, any, any>, never, never, {}, { "isLoadingChange": "isLoadingChange"; }, never, never, false, never>;
 }

package/esm2022/components/icon/icon.component.mjs

@@ -52,6 +52,17 @@ const ICON = {
                 </g>
             </g>
         </svg>
+    `,
+    'user-clock': `
+        <!-- Font Awesome Free 5.15.4 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license/free (Icons: CC BY 4.0, Fonts: SIL OFL 1.1, Code: MIT License) -->
+        <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 640 512">
+            <path d="M496 224c-79.6 0-144 64.4-144 144s64.4 144 144 144 144-64.4 144-144-64.4-144-144-144zm64 150.3c0 5.3-4.4 9.7-9.7 9.7h-60.6c-5.3 0-9.7-4.4-9.7-9.7v-76.6c0-5.3 4.4-9.7 9.7-9.7h12.6c5.3 0 9.7 4.4 9.7 9.7V352h38.3c5.3 0 9.7 4.4 9.7 9.7v12.6zM320 368c0-27.8 6.7-54.1 18.2-77.5-8-1.5-16.2-2.5-24.6-2.5h-16.7c-22.2 10.2-46.9 16-72.9 16s-50.6-5.8-72.9-16h-16.7C60.2 288 0 348.2 0 422.4V464c0 26.5 21.5 48 48 48h347.1c-45.3-31.9-75.1-84.5-75.1-144zm-96-112c70.7 0 128-57.3 128-128S294.7 0 224 0 96 57.3 96 128s57.3 128 128 128z" />
+        </svg>
+    `,
+    'roster': `
+        <svg xmlns="http://www.w3.org/2000/svg" viewBox="120 -840 720 720">
+            <path d="M120-180v-600q0-24.75 17.625-42.375T180-840h600q24.75 0 42.375 17.625T840-780v600q0 24.75-17.625 42.375T780-120H180q-24.75 0-42.375-17.625T120-180Zm60-440h600v-160H180v160Zm220 220h160v-160H400v160Zm0 220h160v-160H400v160ZM180-400h160v-160H180v160Zm440 0h160v-160H620v160ZM180-180h160v-160H180v160Zm440 0h160v-160H620v160Z" />
+        </svg>
     `
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/components/list-attachments/list-attachments.component.mjs

@@ -52,7 +52,7 @@ export class ListAttachmentsComponent extends RowListBase {
             ];
         }
     }
-    get initialPageState() {
+    getInitialPageState() {
         return {
             filter: {},
             pageConfig: {
@@ -108,4 +108,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImpo
             }], noRowsMessage: [{
                 type: Input
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"list-attachments.component.js","sourceRoot":"","sources":["../../../../../projects/nr-ngx-component-lib/src/components/list-attachments/list-attachments.component.ts","../../../../../projects/nr-ngx-component-lib/src/components/list-attachments/list-attachments.component.html"],"names":[],"mappings":"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","sourcesContent":["import { ChangeDetectionStrategy, Component, Input, OnChanges, SimpleChanges } from \"@angular/core\";\nimport { Observable } from \"rxjs\";\nimport { RowListBase, RowListState } from \"../../directives/row-list.base\";\nimport { DATE_FORMATS } from \"../../utils/date.util\";\n\nexport type AttachmentsTableRow = {\n    attachmentTypeDescription: string\n    orgUnit: string\n    fileName: string\n    fileExtension: string\n    uploadedBy: string\n    uploadedTimestamp: string\n    attachmentDescription: string\n    attachmentId: string \n    fileId: string\n    sourceObjectUniqueId: string,\n}\n\nexport type FetchAttachmentsParameters = { \n    pageNumber: number \n    pageRowCount: number \n    sortColumn: string \n    sortDirection: string\n}\n\nexport interface AttachmentRowListProvider<R,L=any> {\n    fetchAttachments( x: FetchAttachmentsParameters ): Observable<L>    \n    displayRowListPage( res: L ): AttachmentsTableRow[]\n    downloadItem( item: R ): any\n    deleteItem( item: R ): any\n}\n\n@Component({\n    selector: \"nrcl-list-attachments\",\n    templateUrl: \"./list-attachments.component.html\",\n    styleUrl: \"./list-attachments.component.scss\",\n    changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class ListAttachmentsComponent extends RowListBase<{},AttachmentsTableRow> implements OnChanges {\n    @Input() rowListProvider?: AttachmentRowListProvider<AttachmentsTableRow>\n    @Input() canDelete = true\n    @Input() canDownload = true\n    @Input() showOrgUnit = false\n    @Input() noRowsMessage = \"No attachments have been added.\"\n\n    DATE_FORMATS = DATE_FORMATS\n    columns: string[] = [] \n    sortColumns: { code: string; description: string; }[] = []\n\n    ngOnChanges(changes: SimpleChanges): void {\n        if ( changes.canDownload || changes.canDelete || changes.showOrgUnit ) {\n            this.columns = [ \n                'attachmentTypeCode',\n                ...(this.showOrgUnit ? ['orgUnit'] : []),\n                'fileName', \n                'fileExtension', \n                'uploadedBy', \n                'uploadedTimestamp', \n                'description',\n                ...( this.canDownload ? ['download'] : [] ),\n                ...( this.canDelete ? ['delete'] : [] )\n            ]\n        }\n        \n        if ( changes.showOrgUnit ) {\n            this.sortColumns = [\n                { code: 'attachmentTypeCode', description: 'Attachment Type' },\n                { code: 'fileName', description: 'File Name' },\n                { code: 'fileExtension', description: 'File Type' },\n                { code: 'uploadedBy', description: 'Uploaded By' },\n                { code: 'uploadedTimestamp', description: 'Uploaded Date' },\n                ...(this.showOrgUnit ? [{ code: 'orgUnit', description: 'Org Unit' }] : []),\n                { code: 'description', description: 'Description' }\n            ];\n        }\n    }\n\n    get initialPageState(): RowListState<{}> {\n        return {\n            filter: {},\n            pageConfig: {\n                pageSize: 10,\n                pageNumber: 1,\n                sortActive: 'uploadedTimestamp',\n                sortDirection: 'desc',\n            }\n        }\n    }\n\n    fetchRowListPage(): Observable<any> {\n        if ( !this.rowListProvider?.fetchAttachments ) throw Error( 'no provider for ListAttachmentsComponent.rowListProvider.fetchRowListPage' )\n\n        return this.rowListProvider.fetchAttachments({\n            pageNumber: this.pageNumber,\n            pageRowCount: this.pageSize,\n            sortColumn: this.sortActive,\n            sortDirection: this.sortDirection,\n        })\n    }\n\n    parseRows( res: any ): AttachmentsTableRow[] {\n        if ( !this.rowListProvider?.displayRowListPage ) throw Error( 'no provider for ListAttachmentsComponent.rowListProvider.displayRowListPage' )\n\n        return this.rowListProvider.displayRowListPage( res )\n    }\n    \n    onDownloadClick( item: AttachmentsTableRow ) {\n        if ( !this.rowListProvider?.downloadItem ) throw Error( 'no provider for ListAttachmentsComponent.rowListProvider.onDownloadClick' )\n\n        return this.rowListProvider.downloadItem( item )\n    }\n\n    onDeleteClick( item: AttachmentsTableRow ) {\n        if ( !this.rowListProvider?.deleteItem ) throw Error( 'no provider for ListAttachmentsComponent.rowListProvider.onDeleteClick.' )\n        \n        return this.rowListProvider.deleteItem( item )\n    }\n\n    savePageState(): void {\n        // state not saved\n    }\n}\n","<nrcl-device-view>\n    <ng-template desktop-view>\n        @if ( rows?.length > 0 ) {\n            <nrcl-row-list-desktop [showRowHover]=\"false\">\n                <mat-table\n                    [dataSource]=\"rows | paginate: paginateState( 'desktop-attachments' )\"\n                    matSort\n                    [matSortActive]=\"sortActive\"\n                    [matSortDirection]=\"sortDirection\"\n                    (matSortChange)=\"onSortChange( $event )\"\n                >\n                    <ng-container matColumnDef=\"attachmentTypeCode\">\n                        <mat-header-cell *matHeaderCellDef mat-sort-header>Attachment Type</mat-header-cell>\n                        <mat-cell *matCellDef=\"let item\">\n                            <nrcl-cell-content tooltip>{{ item.attachmentTypeDescription }}</nrcl-cell-content>\n                        </mat-cell>\n                    </ng-container>\n\n<!--                    Only show this column for prep sheet attachment section-->\n                    <ng-container matColumnDef=\"orgUnit\">\n                        <mat-header-cell *matHeaderCellDef mat-sort-header>Org Unit</mat-header-cell>\n                        <mat-cell *matCellDef=\"let item\">\n                            {{ item.orgUnit }}\n                        </mat-cell>\n                    </ng-container>\n\n                    <ng-container matColumnDef=\"fileName\">\n                        <mat-header-cell *matHeaderCellDef mat-sort-header>File Name</mat-header-cell>\n                        <mat-cell *matCellDef=\"let item\">\n                            <nrcl-button anchor tooltip\n                                [label]=\"item.fileName\"\n                                iconRight=\"download\"\n                                (click)=\"onDownloadClick( item )\"\n                            ></nrcl-button>\n                        </mat-cell>\n                    </ng-container>\n\n                    <ng-container matColumnDef=\"fileExtension\">\n                        <mat-header-cell *matHeaderCellDef mat-sort-header>File Type</mat-header-cell>\n                        <mat-cell *matCellDef=\"let item\">\n                            {{ item.fileExtension }}\n                        </mat-cell>\n                    </ng-container>\n\n                    <ng-container matColumnDef=\"uploadedBy\">\n                        <mat-header-cell *matHeaderCellDef mat-sort-header>Uploaded By</mat-header-cell>\n                        <mat-cell *matCellDef=\"let item\">\n                            {{ item.uploadedBy }}\n                        </mat-cell>\n                    </ng-container>\n\n                    <ng-container matColumnDef=\"uploadedTimestamp\">\n                        <mat-header-cell *matHeaderCellDef mat-sort-header>Uploaded Date</mat-header-cell>\n                        <mat-cell *matCellDef=\"let item\">\n                            {{ item.uploadedTimestamp }}\n                        </mat-cell>\n                    </ng-container>\n\n                    <ng-container matColumnDef=\"description\">\n                        <mat-header-cell *matHeaderCellDef mat-sort-header>Description</mat-header-cell>\n                        <mat-cell *matCellDef=\"let item\">\n                            {{ item.attachmentDescription }}\n                        </mat-cell>\n                    </ng-container>\n\n                    <ng-container matColumnDef=\"download\">\n                        <mat-header-cell *matHeaderCellDef>Down&shy;load</mat-header-cell>\n                        <mat-cell *matCellDef=\"let item\">\n                            <nrcl-button compact\n                                icon=\"download\"\n                                (click)=\"onDownloadClick( item )\"\n                            ></nrcl-button>\n                        </mat-cell>\n                    </ng-container>\n\n                    <ng-container matColumnDef=\"delete\">\n                        <mat-header-cell *matHeaderCellDef>Delete</mat-header-cell>\n                        <mat-cell *matCellDef=\"let item\">\n                            <nrcl-button compact\n                                icon=\"delete\"\n                                (click)=\"onDeleteClick( item )\"\n                            ></nrcl-button>\n                        </mat-cell>\n                    </ng-container>\n\n                    <mat-header-row *matHeaderRowDef=\"columns; sticky: true\"></mat-header-row>\n                    <mat-row *matRowDef=\"let item; columns: columns;\"></mat-row>\n                </mat-table>\n            </nrcl-row-list-desktop>\n\n            <nrcl-gap/>\n        }\n\n        <nrcl-row-list-pagination\n            paginationId=\"desktop-attachments\"\n            [pageSize]=\"pageSize\"\n            [pageNumber]=\"pageNumber\"\n            [rowCount]=\"totalRowCount\"\n            (pageNumberChange)=\"onPageNumberChange( $event )\"\n            (pageSizeChange)=\"onPageSizeChange( $event )\"\n            [noRowsMessage]=\"noRowsMessage\"\n        ></nrcl-row-list-pagination>\n    </ng-template>\n\n    <ng-template mobile-view>\n        <nrcl-gap/>\n\n        @if ( rows?.length > 0 ) {\n            <nrcl-row-list-sorting\n                [sortColumn]=\"sortActive\"\n                [sortColumnOptions]=\"sortColumns\"\n                [sortDirection]=\"sortDirection\"\n                (sortChange)=\"onSortChange($event)\">\n            </nrcl-row-list-sorting>\n\n            <nrcl-gap/>\n\n            <nrcl-row-list-mobile>\n                @for ( item of rows | paginate: paginateState( 'mobile-attachments' ); track item.attachmentId ) {\n                    <mat-card>\n                        <mat-card-content>\n                            <section full-width class=\"filename\">\n                                <mat-label>File Name</mat-label>\n                                <div class=\"value\">\n                                    <nrcl-button anchor\n                                        [label]=\"item.fileName\"\n                                        iconRight=\"download\"\n                                        (click)=\"onDownloadClick( item )\"\n                                    ></nrcl-button>\n                                </div>\n                            </section>\n\n                            <section>\n                                <mat-label>Attachment Type</mat-label>\n                                <div class=\"value\">{{ item.attachmentTypeDescription }}</div>\n                            </section>\n\n                            <section>\n                                <mat-label>File Type</mat-label>\n                                <div class=\"value\">{{ item.fileExtension }}</div>\n                            </section>\n\n                            <section>\n                                <mat-label>Uploaded By</mat-label>\n                                <div class=\"value\">{{ item.uploadedBy }}</div>\n                            </section>\n\n                            <section>\n                                <mat-label>Uploaded Date</mat-label>\n                                <div class=\"value\">{{ item.uploadedTimestamp }}</div>\n                            </section>\n\n                            @if ( showOrgUnit ) {\n                                <section full-width>\n                                    <mat-label>Org Unit</mat-label>\n                                    <div class=\"value\">{{ item.orgUnit }}</div>\n                                </section>\n                            }\n\n                            <section full-width>\n                                <mat-label>Description</mat-label>\n                                <div class=\"value\">{{ item.attachmentDescription }}</div>\n                            </section>\n                        </mat-card-content>\n\n                        <mat-card-footer>\n                            @if ( canDownload ) {\n                                <nrcl-button compact\n                                    label=\"Download\"\n                                    icon=\"download\"\n                                    (click)=\"onDownloadClick( item )\"\n                                ></nrcl-button>\n                            }\n\n                            @if ( canDelete ) {\n                                <nrcl-button compact\n                                    label=\"Delete\"\n                                    icon=\"delete\"\n                                    (click)=\"onDeleteClick( item )\"\n                                ></nrcl-button>\n                            }\n                        </mat-card-footer>\n                    </mat-card>\n                }\n            </nrcl-row-list-mobile>\n\n            <nrcl-gap/>\n        }\n\n        <nrcl-row-list-pagination\n            paginationId=\"mobile-attachments\"\n            [pageSize]=\"pageSize\"\n            [pageNumber]=\"pageNumber\"\n            [rowCount]=\"totalRowCount\"\n            (pageNumberChange)=\"onPageNumberChange( $event )\"\n            (pageSizeChange)=\"onPageSizeChange( $event )\"\n            [noRowsMessage]=\"noRowsMessage\"\n        ></nrcl-row-list-pagination>\n    </ng-template>\n</nrcl-device-view>\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"list-attachments.component.js","sourceRoot":"","sources":["../../../../../projects/nr-ngx-component-lib/src/components/list-attachments/list-attachments.component.ts","../../../../../projects/nr-ngx-component-lib/src/components/list-attachments/list-attachments.component.html"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,SAAS,EAAE,KAAK,EAA4B,MAAM,eAAe,CAAC;AAEpG,OAAO,EAAE,WAAW,EAAgB,MAAM,gCAAgC,CAAC;AAC3E,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;;;;;;;;;;;;;;;AAmCrD,MAAM,OAAO,wBAAyB,SAAQ,WAAmC;IANjF;;QAQa,cAAS,GAAG,IAAI,CAAA;QAChB,gBAAW,GAAG,IAAI,CAAA;QAClB,gBAAW,GAAG,KAAK,CAAA;QACnB,kBAAa,GAAG,iCAAiC,CAAA;QAE1D,iBAAY,GAAG,YAAY,CAAA;QAC3B,YAAO,GAAa,EAAE,CAAA;QACtB,gBAAW,GAA6C,EAAE,CAAA;KA0E7D;IAxEG,WAAW,CAAC,OAAsB;QAC9B,IAAK,OAAO,CAAC,WAAW,IAAI,OAAO,CAAC,SAAS,IAAI,OAAO,CAAC,WAAW,EAAG,CAAC;YACpE,IAAI,CAAC,OAAO,GAAG;gBACX,oBAAoB;gBACpB,GAAG,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;gBACxC,UAAU;gBACV,eAAe;gBACf,YAAY;gBACZ,mBAAmB;gBACnB,aAAa;gBACb,GAAG,CAAE,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,EAAE,CAAE;gBAC3C,GAAG,CAAE,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,EAAE,CAAE;aAC1C,CAAA;QACL,CAAC;QAED,IAAK,OAAO,CAAC,WAAW,EAAG,CAAC;YACxB,IAAI,CAAC,WAAW,GAAG;gBACf,EAAE,IAAI,EAAE,oBAAoB,EAAE,WAAW,EAAE,iBAAiB,EAAE;gBAC9D,EAAE,IAAI,EAAE,UAAU,EAAE,WAAW,EAAE,WAAW,EAAE;gBAC9C,EAAE,IAAI,EAAE,eAAe,EAAE,WAAW,EAAE,WAAW,EAAE;gBACnD,EAAE,IAAI,EAAE,YAAY,EAAE,WAAW,EAAE,aAAa,EAAE;gBAClD,EAAE,IAAI,EAAE,mBAAmB,EAAE,WAAW,EAAE,eAAe,EAAE;gBAC3D,GAAG,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,WAAW,EAAE,UAAU,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;gBAC3E,EAAE,IAAI,EAAE,aAAa,EAAE,WAAW,EAAE,aAAa,EAAE;aACtD,CAAC;QACN,CAAC;IACL,CAAC;IAED,mBAAmB;QACf,OAAO;YACH,MAAM,EAAE,EAAE;YACV,UAAU,EAAE;gBACR,QAAQ,EAAE,EAAE;gBACZ,UAAU,EAAE,CAAC;gBACb,UAAU,EAAE,mBAAmB;gBAC/B,aAAa,EAAE,MAAM;aACxB;SACJ,CAAA;IACL,CAAC;IAED,gBAAgB;QACZ,IAAK,CAAC,IAAI,CAAC,eAAe,EAAE,gBAAgB;YAAG,MAAM,KAAK,CAAE,2EAA2E,CAAE,CAAA;QAEzI,OAAO,IAAI,CAAC,eAAe,CAAC,gBAAgB,CAAC;YACzC,UAAU,EAAE,IAAI,CAAC,UAAU;YAC3B,YAAY,EAAE,IAAI,CAAC,QAAQ;YAC3B,UAAU,EAAE,IAAI,CAAC,UAAU;YAC3B,aAAa,EAAE,IAAI,CAAC,aAAa;SACpC,CAAC,CAAA;IACN,CAAC;IAED,SAAS,CAAE,GAAQ;QACf,IAAK,CAAC,IAAI,CAAC,eAAe,EAAE,kBAAkB;YAAG,MAAM,KAAK,CAAE,6EAA6E,CAAE,CAAA;QAE7I,OAAO,IAAI,CAAC,eAAe,CAAC,kBAAkB,CAAE,GAAG,CAAE,CAAA;IACzD,CAAC;IAED,eAAe,CAAE,IAAyB;QACtC,IAAK,CAAC,IAAI,CAAC,eAAe,EAAE,YAAY;YAAG,MAAM,KAAK,CAAE,0EAA0E,CAAE,CAAA;QAEpI,OAAO,IAAI,CAAC,eAAe,CAAC,YAAY,CAAE,IAAI,CAAE,CAAA;IACpD,CAAC;IAED,aAAa,CAAE,IAAyB;QACpC,IAAK,CAAC,IAAI,CAAC,eAAe,EAAE,UAAU;YAAG,MAAM,KAAK,CAAE,yEAAyE,CAAE,CAAA;QAEjI,OAAO,IAAI,CAAC,eAAe,CAAC,UAAU,CAAE,IAAI,CAAE,CAAA;IAClD,CAAC;IAED,aAAa;QACT,kBAAkB;IACtB,CAAC;+GAlFQ,wBAAwB;mGAAxB,wBAAwB,yQCtCrC,koSAwMA;;4FDlKa,wBAAwB;kBANpC,SAAS;+BACI,uBAAuB,mBAGhB,uBAAuB,CAAC,MAAM;8BAGtC,eAAe;sBAAvB,KAAK;gBACG,SAAS;sBAAjB,KAAK;gBACG,WAAW;sBAAnB,KAAK;gBACG,WAAW;sBAAnB,KAAK;gBACG,aAAa;sBAArB,KAAK","sourcesContent":["import { ChangeDetectionStrategy, Component, Input, OnChanges, SimpleChanges } from \"@angular/core\";\nimport { Observable } from \"rxjs\";\nimport { RowListBase, RowListState } from \"../../directives/row-list.base\";\nimport { DATE_FORMATS } from \"../../utils/date.util\";\n\nexport type AttachmentsTableRow = {\n    attachmentTypeDescription: string\n    orgUnit: string\n    fileName: string\n    fileExtension: string\n    uploadedBy: string\n    uploadedTimestamp: string\n    attachmentDescription: string\n    attachmentId: string \n    fileId: string\n    sourceObjectUniqueId: string,\n}\n\nexport type FetchAttachmentsParameters = { \n    pageNumber: number \n    pageRowCount: number \n    sortColumn: string \n    sortDirection: string\n}\n\nexport interface AttachmentRowListProvider<R,L=any> {\n    fetchAttachments( x: FetchAttachmentsParameters ): Observable<L>    \n    displayRowListPage( res: L ): AttachmentsTableRow[]\n    downloadItem( item: R ): any\n    deleteItem( item: R ): any\n}\n\n@Component({\n    selector: \"nrcl-list-attachments\",\n    templateUrl: \"./list-attachments.component.html\",\n    styleUrl: \"./list-attachments.component.scss\",\n    changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class ListAttachmentsComponent extends RowListBase<{},AttachmentsTableRow> implements OnChanges {\n    @Input() rowListProvider?: AttachmentRowListProvider<AttachmentsTableRow>\n    @Input() canDelete = true\n    @Input() canDownload = true\n    @Input() showOrgUnit = false\n    @Input() noRowsMessage = \"No attachments have been added.\"\n\n    DATE_FORMATS = DATE_FORMATS\n    columns: string[] = [] \n    sortColumns: { code: string; description: string; }[] = []\n\n    ngOnChanges(changes: SimpleChanges): void {\n        if ( changes.canDownload || changes.canDelete || changes.showOrgUnit ) {\n            this.columns = [ \n                'attachmentTypeCode',\n                ...(this.showOrgUnit ? ['orgUnit'] : []),\n                'fileName', \n                'fileExtension', \n                'uploadedBy', \n                'uploadedTimestamp', \n                'description',\n                ...( this.canDownload ? ['download'] : [] ),\n                ...( this.canDelete ? ['delete'] : [] )\n            ]\n        }\n        \n        if ( changes.showOrgUnit ) {\n            this.sortColumns = [\n                { code: 'attachmentTypeCode', description: 'Attachment Type' },\n                { code: 'fileName', description: 'File Name' },\n                { code: 'fileExtension', description: 'File Type' },\n                { code: 'uploadedBy', description: 'Uploaded By' },\n                { code: 'uploadedTimestamp', description: 'Uploaded Date' },\n                ...(this.showOrgUnit ? [{ code: 'orgUnit', description: 'Org Unit' }] : []),\n                { code: 'description', description: 'Description' }\n            ];\n        }\n    }\n\n    getInitialPageState(): RowListState<{}> {\n        return {\n            filter: {},\n            pageConfig: {\n                pageSize: 10,\n                pageNumber: 1,\n                sortActive: 'uploadedTimestamp',\n                sortDirection: 'desc',\n            }\n        }\n    }\n\n    fetchRowListPage(): Observable<any> {\n        if ( !this.rowListProvider?.fetchAttachments ) throw Error( 'no provider for ListAttachmentsComponent.rowListProvider.fetchRowListPage' )\n\n        return this.rowListProvider.fetchAttachments({\n            pageNumber: this.pageNumber,\n            pageRowCount: this.pageSize,\n            sortColumn: this.sortActive,\n            sortDirection: this.sortDirection,\n        })\n    }\n\n    parseRows( res: any ): AttachmentsTableRow[] {\n        if ( !this.rowListProvider?.displayRowListPage ) throw Error( 'no provider for ListAttachmentsComponent.rowListProvider.displayRowListPage' )\n\n        return this.rowListProvider.displayRowListPage( res )\n    }\n    \n    onDownloadClick( item: AttachmentsTableRow ) {\n        if ( !this.rowListProvider?.downloadItem ) throw Error( 'no provider for ListAttachmentsComponent.rowListProvider.onDownloadClick' )\n\n        return this.rowListProvider.downloadItem( item )\n    }\n\n    onDeleteClick( item: AttachmentsTableRow ) {\n        if ( !this.rowListProvider?.deleteItem ) throw Error( 'no provider for ListAttachmentsComponent.rowListProvider.onDeleteClick.' )\n        \n        return this.rowListProvider.deleteItem( item )\n    }\n\n    savePageState(): void {\n        // state not saved\n    }\n}\n","<nrcl-device-view>\n    <ng-template desktop-view>\n        @if ( rows?.length > 0 ) {\n            <nrcl-row-list-desktop [showRowHover]=\"false\">\n                <mat-table\n                    [dataSource]=\"rows | paginate: paginateState( 'desktop-attachments' )\"\n                    matSort\n                    [matSortActive]=\"sortActive\"\n                    [matSortDirection]=\"sortDirection\"\n                    (matSortChange)=\"onSortChange( $event )\"\n                >\n                    <ng-container matColumnDef=\"attachmentTypeCode\">\n                        <mat-header-cell *matHeaderCellDef mat-sort-header>Attachment Type</mat-header-cell>\n                        <mat-cell *matCellDef=\"let item\">\n                            <nrcl-cell-content tooltip>{{ item.attachmentTypeDescription }}</nrcl-cell-content>\n                        </mat-cell>\n                    </ng-container>\n\n<!--                    Only show this column for prep sheet attachment section-->\n                    <ng-container matColumnDef=\"orgUnit\">\n                        <mat-header-cell *matHeaderCellDef mat-sort-header>Org Unit</mat-header-cell>\n                        <mat-cell *matCellDef=\"let item\">\n                            {{ item.orgUnit }}\n                        </mat-cell>\n                    </ng-container>\n\n                    <ng-container matColumnDef=\"fileName\">\n                        <mat-header-cell *matHeaderCellDef mat-sort-header>File Name</mat-header-cell>\n                        <mat-cell *matCellDef=\"let item\">\n                            <nrcl-button anchor tooltip\n                                [label]=\"item.fileName\"\n                                iconRight=\"download\"\n                                (click)=\"onDownloadClick( item )\"\n                            ></nrcl-button>\n                        </mat-cell>\n                    </ng-container>\n\n                    <ng-container matColumnDef=\"fileExtension\">\n                        <mat-header-cell *matHeaderCellDef mat-sort-header>File Type</mat-header-cell>\n                        <mat-cell *matCellDef=\"let item\">\n                            {{ item.fileExtension }}\n                        </mat-cell>\n                    </ng-container>\n\n                    <ng-container matColumnDef=\"uploadedBy\">\n                        <mat-header-cell *matHeaderCellDef mat-sort-header>Uploaded By</mat-header-cell>\n                        <mat-cell *matCellDef=\"let item\">\n                            {{ item.uploadedBy }}\n                        </mat-cell>\n                    </ng-container>\n\n                    <ng-container matColumnDef=\"uploadedTimestamp\">\n                        <mat-header-cell *matHeaderCellDef mat-sort-header>Uploaded Date</mat-header-cell>\n                        <mat-cell *matCellDef=\"let item\">\n                            {{ item.uploadedTimestamp }}\n                        </mat-cell>\n                    </ng-container>\n\n                    <ng-container matColumnDef=\"description\">\n                        <mat-header-cell *matHeaderCellDef mat-sort-header>Description</mat-header-cell>\n                        <mat-cell *matCellDef=\"let item\">\n                            {{ item.attachmentDescription }}\n                        </mat-cell>\n                    </ng-container>\n\n                    <ng-container matColumnDef=\"download\">\n                        <mat-header-cell *matHeaderCellDef>Down&shy;load</mat-header-cell>\n                        <mat-cell *matCellDef=\"let item\">\n                            <nrcl-button compact\n                                icon=\"download\"\n                                (click)=\"onDownloadClick( item )\"\n                            ></nrcl-button>\n                        </mat-cell>\n                    </ng-container>\n\n                    <ng-container matColumnDef=\"delete\">\n                        <mat-header-cell *matHeaderCellDef>Delete</mat-header-cell>\n                        <mat-cell *matCellDef=\"let item\">\n                            <nrcl-button compact\n                                icon=\"delete\"\n                                (click)=\"onDeleteClick( item )\"\n                            ></nrcl-button>\n                        </mat-cell>\n                    </ng-container>\n\n                    <mat-header-row *matHeaderRowDef=\"columns; sticky: true\"></mat-header-row>\n                    <mat-row *matRowDef=\"let item; columns: columns;\"></mat-row>\n                </mat-table>\n            </nrcl-row-list-desktop>\n\n            <nrcl-gap/>\n        }\n\n        <nrcl-row-list-pagination\n            paginationId=\"desktop-attachments\"\n            [pageSize]=\"pageSize\"\n            [pageNumber]=\"pageNumber\"\n            [rowCount]=\"totalRowCount\"\n            (pageNumberChange)=\"onPageNumberChange( $event )\"\n            (pageSizeChange)=\"onPageSizeChange( $event )\"\n            [noRowsMessage]=\"noRowsMessage\"\n        ></nrcl-row-list-pagination>\n    </ng-template>\n\n    <ng-template mobile-view>\n        <nrcl-gap/>\n\n        @if ( rows?.length > 0 ) {\n            <nrcl-row-list-sorting\n                [sortColumn]=\"sortActive\"\n                [sortColumnOptions]=\"sortColumns\"\n                [sortDirection]=\"sortDirection\"\n                (sortChange)=\"onSortChange($event)\">\n            </nrcl-row-list-sorting>\n\n            <nrcl-gap/>\n\n            <nrcl-row-list-mobile>\n                @for ( item of rows | paginate: paginateState( 'mobile-attachments' ); track item.attachmentId ) {\n                    <mat-card>\n                        <mat-card-content>\n                            <section full-width class=\"filename\">\n                                <mat-label>File Name</mat-label>\n                                <div class=\"value\">\n                                    <nrcl-button anchor\n                                        [label]=\"item.fileName\"\n                                        iconRight=\"download\"\n                                        (click)=\"onDownloadClick( item )\"\n                                    ></nrcl-button>\n                                </div>\n                            </section>\n\n                            <section>\n                                <mat-label>Attachment Type</mat-label>\n                                <div class=\"value\">{{ item.attachmentTypeDescription }}</div>\n                            </section>\n\n                            <section>\n                                <mat-label>File Type</mat-label>\n                                <div class=\"value\">{{ item.fileExtension }}</div>\n                            </section>\n\n                            <section>\n                                <mat-label>Uploaded By</mat-label>\n                                <div class=\"value\">{{ item.uploadedBy }}</div>\n                            </section>\n\n                            <section>\n                                <mat-label>Uploaded Date</mat-label>\n                                <div class=\"value\">{{ item.uploadedTimestamp }}</div>\n                            </section>\n\n                            @if ( showOrgUnit ) {\n                                <section full-width>\n                                    <mat-label>Org Unit</mat-label>\n                                    <div class=\"value\">{{ item.orgUnit }}</div>\n                                </section>\n                            }\n\n                            <section full-width>\n                                <mat-label>Description</mat-label>\n                                <div class=\"value\">{{ item.attachmentDescription }}</div>\n                            </section>\n                        </mat-card-content>\n\n                        <mat-card-footer>\n                            @if ( canDownload ) {\n                                <nrcl-button compact\n                                    label=\"Download\"\n                                    icon=\"download\"\n                                    (click)=\"onDownloadClick( item )\"\n                                ></nrcl-button>\n                            }\n\n                            @if ( canDelete ) {\n                                <nrcl-button compact\n                                    label=\"Delete\"\n                                    icon=\"delete\"\n                                    (click)=\"onDeleteClick( item )\"\n                                ></nrcl-button>\n                            }\n                        </mat-card-footer>\n                    </mat-card>\n                }\n            </nrcl-row-list-mobile>\n\n            <nrcl-gap/>\n        }\n\n        <nrcl-row-list-pagination\n            paginationId=\"mobile-attachments\"\n            [pageSize]=\"pageSize\"\n            [pageNumber]=\"pageNumber\"\n            [rowCount]=\"totalRowCount\"\n            (pageNumberChange)=\"onPageNumberChange( $event )\"\n            (pageSizeChange)=\"onPageSizeChange( $event )\"\n            [noRowsMessage]=\"noRowsMessage\"\n        ></nrcl-row-list-pagination>\n    </ng-template>\n</nrcl-device-view>\n"]}

package/esm2022/components/list-event-history/list-event-history.component.mjs

@@ -46,7 +46,7 @@ export class ListEventHistoryComponent extends RowListBase {
             throw Error('no provider for ListEventHistoryComponent.rowListProvider.displayRowListPage');
         return this.rowListProvider.displayRowListPage(res);
     }
-    get initialPageState() {
+    getInitialPageState() {
         return {
             filter: {},
             pageConfig: {
@@ -77,4 +77,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImpo
             }], noRowsMessage: [{
                 type: Input
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"list-event-history.component.js","sourceRoot":"","sources":["../../../../../projects/nr-ngx-component-lib/src/components/list-event-history/list-event-history.component.ts","../../../../../projects/nr-ngx-component-lib/src/components/list-event-history/list-event-history.component.html"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAE1E,OAAO,EAAE,WAAW,EAAgB,MAAM,gCAAgC,CAAC;AAC3E,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;;;;;;;;;;;;;;AA8BrD,MAAM,OAAO,yBAA0B,SAAQ,WAAoC;IANnF;;QAQa,cAAS,GAAG,IAAI,CAAA;QAChB,mBAAc,GAAG,KAAK,CAAA;QACtB,eAAU,GAAY,KAAK,CAAA;QAC3B,kBAAa,GAAG,8BAA8B,CAAA;QAEvD,iBAAY,GAAG,YAAY,CAAA;QAC3B,YAAO,GAAG,CAAE,UAAU,EAAE,WAAW,EAAE,MAAM,EAAE,SAAS,EAAE,SAAS,CAAE,CAAA;QACnE,gBAAW,GAAG;YACV,EAAE,IAAI,EAAE,UAAU,EAAE,WAAW,EAAE,eAAe,EAAE;YAClD,EAAE,IAAI,EAAE,WAAW,EAAE,WAAW,EAAE,YAAY,EAAE;YAChD,EAAE,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE;YACrC,EAAE,IAAI,EAAE,SAAS,EAAE,WAAW,EAAE,SAAS,EAAE;SAC9C,CAAA;KAmCJ;IAjCG,gBAAgB;QACZ,IAAK,CAAC,IAAI,CAAC,eAAe,EAAE,iBAAiB;YAAG,MAAM,KAAK,CAAE,4EAA4E,CAAE,CAAA;QAE3I,OAAO,IAAI,CAAC,eAAe,CAAC,iBAAiB,CAAE;YAC3C,UAAU,EAAE,IAAI,CAAC,UAAU;YAC3B,UAAU,EAAE,IAAI,CAAC,UAAU;YAC3B,YAAY,EAAE,IAAI,CAAC,QAAQ;YAC3B,UAAU,EAAE,IAAI,CAAC,UAAU;YAC3B,aAAa,EAAE,IAAI,CAAC,aAAa;SACpC,CAAE,CAAA;IACP,CAAC;IAED,SAAS,CAAE,GAAQ;QACf,IAAK,CAAC,IAAI,CAAC,eAAe,EAAE,kBAAkB;YAAG,MAAM,KAAK,CAAE,8EAA8E,CAAE,CAAA;QAE9I,OAAO,IAAI,CAAC,eAAe,CAAC,kBAAkB,CAAE,GAAG,CAAE,CAAA;IACzD,CAAC;IAED,IAAI,gBAAgB;QAChB,OAAO;YACH,MAAM,EAAE,EAAE;YACV,UAAU,EAAE;gBACR,QAAQ,EAAE,EAAE;gBACZ,UAAU,EAAE,CAAC;gBACb,UAAU,EAAE,UAAU;gBACtB,aAAa,EAAE,MAAM;aACxB;SACJ,CAAA;IACL,CAAC;IAED,aAAa;QACT,kBAAkB;IACtB,CAAC;+GAhDQ,yBAAyB;mGAAzB,yBAAyB,0PCjCtC,oiLA8HA;;4FD7Fa,yBAAyB;kBANrC,SAAS;+BACI,yBAAyB,mBAGlB,uBAAuB,CAAC,MAAM;8BAGtC,eAAe;sBAAvB,KAAK;gBACG,SAAS;sBAAjB,KAAK;gBACG,cAAc;sBAAtB,KAAK;gBACG,UAAU;sBAAlB,KAAK;gBACG,aAAa;sBAArB,KAAK","sourcesContent":["import { ChangeDetectionStrategy, Component, Input } from \"@angular/core\";\nimport { Observable } from \"rxjs\";\nimport { RowListBase, RowListState } from \"../../directives/row-list.base\";\nimport { DATE_FORMATS } from \"../../utils/date.util\";\n\nexport type EventHistoryTableRow = {\n    eventTimestamp: string\n    createdByUserId: string\n    eventHistoryTypeDescription: string\n    sourceObjectNameDescription: string\n    comment: string\n    eventHistoryGuid: string\n}\n\nexport type FetchEventHistoryParameters = { \n    isSupplier: boolean \n    pageNumber: number \n    pageRowCount: number \n    sortColumn: string \n    sortDirection: string\n}\n\nexport interface EventHistoryRowListProvider<R,L=any> {\n    fetchEventHistory( x: FetchEventHistoryParameters ): Observable<L>    \n    displayRowListPage( res: L ): EventHistoryTableRow[]\n}\n\n@Component({\n    selector: \"nrcl-list-event-history\",\n    templateUrl: \"./list-event-history.component.html\",\n    styleUrl: \"./list-event-history.component.scss\",\n    changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class ListEventHistoryComponent extends RowListBase<{},EventHistoryTableRow> {\n    @Input() rowListProvider?: EventHistoryRowListProvider<EventHistoryTableRow>\n    @Input() canDelete = true\n    @Input() showPagination = false\n    @Input() isSupplier: boolean = false\n    @Input() noRowsMessage = \"No comments have been added.\"\n\n    DATE_FORMATS = DATE_FORMATS\n    columns = [ 'dateTime', 'changedBy', 'type', 'section', 'comment' ]\n    sortColumns = [\n        { code: 'dateTime', description: 'Date and Time' },\n        { code: 'changedBy', description: 'Changed By' },\n        { code: 'type', description: 'Type' },\n        { code: 'section', description: 'Section' },\n    ]\n\n    fetchRowListPage(): Observable<any> {\n        if ( !this.rowListProvider?.fetchEventHistory ) throw Error( 'no provider for ListEventHistoryComponent.rowListProvider.fetchRowListPage' )\n\n        return this.rowListProvider.fetchEventHistory( {\n            isSupplier: this.isSupplier,\n            pageNumber: this.pageNumber,\n            pageRowCount: this.pageSize,\n            sortColumn: this.sortActive,\n            sortDirection: this.sortDirection,\n        } )\n    }\n\n    parseRows( res: any ): EventHistoryTableRow[] {\n        if ( !this.rowListProvider?.displayRowListPage ) throw Error( 'no provider for ListEventHistoryComponent.rowListProvider.displayRowListPage' )\n\n        return this.rowListProvider.displayRowListPage( res )\n    }\n\n    get initialPageState(): RowListState<{}> {\n        return {\n            filter: {},\n            pageConfig: {\n                pageSize: 20,\n                pageNumber: 1,\n                sortActive: 'dateTime',\n                sortDirection: 'desc',\n            }\n        }\n    }\n\n    savePageState(): void {\n        // state not saved\n    }\n}\n","<nrcl-device-view>\n    <ng-template desktop-view>\n        @if ( rows?.length > 0 ) {\n            <nrcl-row-list-desktop [showRowHover]=\"false\">\n                <mat-table\n                    [dataSource]=\"rows | paginate: paginateState( 'desktop-event-history' )\"\n                    matSort\n                    [matSortActive]=\"sortActive\"\n                    [matSortDirection]=\"sortDirection\"\n                    (matSortChange)=\"onSortChange( $event )\">\n                >\n                    <ng-container matColumnDef=\"dateTime\">\n                        <mat-header-cell *matHeaderCellDef mat-sort-header>Date and Time</mat-header-cell>\n                        <mat-cell *matCellDef=\"let item\">\n                            <nrcl-cell-content tooltip>{{ item.eventTimestamp }}</nrcl-cell-content>\n                        </mat-cell>\n                    </ng-container>\n\n                    <ng-container matColumnDef=\"changedBy\">\n                        <mat-header-cell *matHeaderCellDef mat-sort-header>User ID</mat-header-cell>\n                        <mat-cell *matCellDef=\"let item\">\n                            <nrcl-cell-content tooltip>{{ item.createdByUserId }}</nrcl-cell-content>\n                        </mat-cell>\n                    </ng-container>\n\n                    <ng-container matColumnDef=\"type\">\n                        <mat-header-cell *matHeaderCellDef mat-sort-header>Type</mat-header-cell>\n                        <mat-cell *matCellDef=\"let item\">\n                            <nrcl-cell-content tooltip>{{ item.eventHistoryTypeDescription }}</nrcl-cell-content>\n                        </mat-cell>\n                    </ng-container>\n\n                    <ng-container matColumnDef=\"section\">\n                        <mat-header-cell *matHeaderCellDef mat-sort-header>Section</mat-header-cell>\n                        <mat-cell *matCellDef=\"let item\">\n                            <nrcl-cell-content tooltip>{{ item.sourceObjectNameDescription }}</nrcl-cell-content>\n                        </mat-cell>\n                    </ng-container>\n\n                    <ng-container matColumnDef=\"comment\">\n                        <mat-header-cell *matHeaderCellDef>Comment</mat-header-cell>\n                        <mat-cell *matCellDef=\"let item\">\n                            {{ item.comment }}\n                        </mat-cell>\n                    </ng-container>\n\n                    <mat-header-row *matHeaderRowDef=\"columns; sticky: true\"></mat-header-row>\n                    <mat-row *matRowDef=\"let item; columns: columns;\"></mat-row>\n                </mat-table>\n            </nrcl-row-list-desktop>\n\n            <nrcl-gap/>\n        }\n\n        <nrcl-row-list-pagination\n            paginationId=\"desktop-event-history\"\n            [pageSize]=\"pageSize\"\n            [pageNumber]=\"pageNumber\"\n            [rowCount]=\"totalRowCount\"\n            (pageNumberChange)=\"onPageNumberChange( $event )\"\n            (pageSizeChange)=\"onPageSizeChange( $event )\"\n            [noRowsMessage]=\"noRowsMessage\"\n        ></nrcl-row-list-pagination>\n    </ng-template>\n\n    <ng-template mobile-view>\n        @if ( rows?.length > 0 ) {\n            <nrcl-gap/>\n\n            <nrcl-row-list-sorting\n                [sortColumn]=\"sortActive\"\n                [sortColumnOptions]=\"sortColumns\"\n                [sortDirection]=\"sortDirection\"\n                (sortChange)=\"onSortChange($event)\">\n            </nrcl-row-list-sorting>\n\n            <nrcl-gap/>\n\n            <nrcl-row-list-mobile>\n                @for ( item of rows | paginate: paginateState( 'mobile-event-history' ); track item.eventHistoryGuid ) {\n                    <mat-card>\n                        <mat-card-title>\n                            <section title>\n                                <h2>{{ item.eventTimestamp }}</h2>\n                            </section>\n                        </mat-card-title>\n\n                        <mat-card-content>\n                            <section>\n                                <mat-label>User ID</mat-label>\n                                <div class=\"value\">{{ item.createdByUserId }}</div>\n                            </section>\n\n                            <section>\n                                <mat-label>Type</mat-label>\n                                <div class=\"value\">{{ item.eventHistoryTypeDescription }}</div>\n                            </section>\n\n                            <section full-width>\n                                <mat-label>Section</mat-label>\n                                <div class=\"value\">{{ item.sourceObjectNameDescription }}</div>\n                            </section>\n\n                            <section full-width>\n                                <mat-label>Comment</mat-label>\n                                <div class=\"value\">{{ item.comment }}</div>\n                            </section>\n                        </mat-card-content>\n                    </mat-card>\n                }\n            </nrcl-row-list-mobile>\n\n            <nrcl-gap/>\n        }\n\n        <nrcl-row-list-pagination\n            paginationId=\"mobile-event-history\"\n            [pageSize]=\"pageSize\"\n            [pageNumber]=\"pageNumber\"\n            [rowCount]=\"totalRowCount\"\n            (pageNumberChange)=\"onPageNumberChange( $event )\"\n            (pageSizeChange)=\"onPageSizeChange( $event )\"\n            [noRowsMessage]=\"noRowsMessage\"\n        ></nrcl-row-list-pagination>\n    </ng-template>\n</nrcl-device-view>\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"list-event-history.component.js","sourceRoot":"","sources":["../../../../../projects/nr-ngx-component-lib/src/components/list-event-history/list-event-history.component.ts","../../../../../projects/nr-ngx-component-lib/src/components/list-event-history/list-event-history.component.html"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAE1E,OAAO,EAAE,WAAW,EAAgB,MAAM,gCAAgC,CAAC;AAC3E,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;;;;;;;;;;;;;;AA8BrD,MAAM,OAAO,yBAA0B,SAAQ,WAAoC;IANnF;;QAQa,cAAS,GAAG,IAAI,CAAA;QAChB,mBAAc,GAAG,KAAK,CAAA;QACtB,eAAU,GAAY,KAAK,CAAA;QAC3B,kBAAa,GAAG,8BAA8B,CAAA;QAEvD,iBAAY,GAAG,YAAY,CAAA;QAC3B,YAAO,GAAG,CAAE,UAAU,EAAE,WAAW,EAAE,MAAM,EAAE,SAAS,EAAE,SAAS,CAAE,CAAA;QACnE,gBAAW,GAAG;YACV,EAAE,IAAI,EAAE,UAAU,EAAE,WAAW,EAAE,eAAe,EAAE;YAClD,EAAE,IAAI,EAAE,WAAW,EAAE,WAAW,EAAE,YAAY,EAAE;YAChD,EAAE,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE;YACrC,EAAE,IAAI,EAAE,SAAS,EAAE,WAAW,EAAE,SAAS,EAAE;SAC9C,CAAA;KAmCJ;IAjCG,gBAAgB;QACZ,IAAK,CAAC,IAAI,CAAC,eAAe,EAAE,iBAAiB;YAAG,MAAM,KAAK,CAAE,4EAA4E,CAAE,CAAA;QAE3I,OAAO,IAAI,CAAC,eAAe,CAAC,iBAAiB,CAAE;YAC3C,UAAU,EAAE,IAAI,CAAC,UAAU;YAC3B,UAAU,EAAE,IAAI,CAAC,UAAU;YAC3B,YAAY,EAAE,IAAI,CAAC,QAAQ;YAC3B,UAAU,EAAE,IAAI,CAAC,UAAU;YAC3B,aAAa,EAAE,IAAI,CAAC,aAAa;SACpC,CAAE,CAAA;IACP,CAAC;IAED,SAAS,CAAE,GAAQ;QACf,IAAK,CAAC,IAAI,CAAC,eAAe,EAAE,kBAAkB;YAAG,MAAM,KAAK,CAAE,8EAA8E,CAAE,CAAA;QAE9I,OAAO,IAAI,CAAC,eAAe,CAAC,kBAAkB,CAAE,GAAG,CAAE,CAAA;IACzD,CAAC;IAED,mBAAmB;QACf,OAAO;YACH,MAAM,EAAE,EAAE;YACV,UAAU,EAAE;gBACR,QAAQ,EAAE,EAAE;gBACZ,UAAU,EAAE,CAAC;gBACb,UAAU,EAAE,UAAU;gBACtB,aAAa,EAAE,MAAM;aACxB;SACJ,CAAA;IACL,CAAC;IAED,aAAa;QACT,kBAAkB;IACtB,CAAC;+GAhDQ,yBAAyB;mGAAzB,yBAAyB,0PCjCtC,oiLA8HA;;4FD7Fa,yBAAyB;kBANrC,SAAS;+BACI,yBAAyB,mBAGlB,uBAAuB,CAAC,MAAM;8BAGtC,eAAe;sBAAvB,KAAK;gBACG,SAAS;sBAAjB,KAAK;gBACG,cAAc;sBAAtB,KAAK;gBACG,UAAU;sBAAlB,KAAK;gBACG,aAAa;sBAArB,KAAK","sourcesContent":["import { ChangeDetectionStrategy, Component, Input } from \"@angular/core\";\nimport { Observable } from \"rxjs\";\nimport { RowListBase, RowListState } from \"../../directives/row-list.base\";\nimport { DATE_FORMATS } from \"../../utils/date.util\";\n\nexport type EventHistoryTableRow = {\n    eventTimestamp: string\n    createdByUserId: string\n    eventHistoryTypeDescription: string\n    sourceObjectNameDescription: string\n    comment: string\n    eventHistoryGuid: string\n}\n\nexport type FetchEventHistoryParameters = { \n    isSupplier: boolean \n    pageNumber: number \n    pageRowCount: number \n    sortColumn: string \n    sortDirection: string\n}\n\nexport interface EventHistoryRowListProvider<R,L=any> {\n    fetchEventHistory( x: FetchEventHistoryParameters ): Observable<L>    \n    displayRowListPage( res: L ): EventHistoryTableRow[]\n}\n\n@Component({\n    selector: \"nrcl-list-event-history\",\n    templateUrl: \"./list-event-history.component.html\",\n    styleUrl: \"./list-event-history.component.scss\",\n    changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class ListEventHistoryComponent extends RowListBase<{},EventHistoryTableRow> {\n    @Input() rowListProvider?: EventHistoryRowListProvider<EventHistoryTableRow>\n    @Input() canDelete = true\n    @Input() showPagination = false\n    @Input() isSupplier: boolean = false\n    @Input() noRowsMessage = \"No comments have been added.\"\n\n    DATE_FORMATS = DATE_FORMATS\n    columns = [ 'dateTime', 'changedBy', 'type', 'section', 'comment' ]\n    sortColumns = [\n        { code: 'dateTime', description: 'Date and Time' },\n        { code: 'changedBy', description: 'Changed By' },\n        { code: 'type', description: 'Type' },\n        { code: 'section', description: 'Section' },\n    ]\n\n    fetchRowListPage(): Observable<any> {\n        if ( !this.rowListProvider?.fetchEventHistory ) throw Error( 'no provider for ListEventHistoryComponent.rowListProvider.fetchRowListPage' )\n\n        return this.rowListProvider.fetchEventHistory( {\n            isSupplier: this.isSupplier,\n            pageNumber: this.pageNumber,\n            pageRowCount: this.pageSize,\n            sortColumn: this.sortActive,\n            sortDirection: this.sortDirection,\n        } )\n    }\n\n    parseRows( res: any ): EventHistoryTableRow[] {\n        if ( !this.rowListProvider?.displayRowListPage ) throw Error( 'no provider for ListEventHistoryComponent.rowListProvider.displayRowListPage' )\n\n        return this.rowListProvider.displayRowListPage( res )\n    }\n\n    getInitialPageState(): RowListState<{}> {\n        return {\n            filter: {},\n            pageConfig: {\n                pageSize: 20,\n                pageNumber: 1,\n                sortActive: 'dateTime',\n                sortDirection: 'desc',\n            }\n        }\n    }\n\n    savePageState(): void {\n        // state not saved\n    }\n}\n","<nrcl-device-view>\n    <ng-template desktop-view>\n        @if ( rows?.length > 0 ) {\n            <nrcl-row-list-desktop [showRowHover]=\"false\">\n                <mat-table\n                    [dataSource]=\"rows | paginate: paginateState( 'desktop-event-history' )\"\n                    matSort\n                    [matSortActive]=\"sortActive\"\n                    [matSortDirection]=\"sortDirection\"\n                    (matSortChange)=\"onSortChange( $event )\">\n                >\n                    <ng-container matColumnDef=\"dateTime\">\n                        <mat-header-cell *matHeaderCellDef mat-sort-header>Date and Time</mat-header-cell>\n                        <mat-cell *matCellDef=\"let item\">\n                            <nrcl-cell-content tooltip>{{ item.eventTimestamp }}</nrcl-cell-content>\n                        </mat-cell>\n                    </ng-container>\n\n                    <ng-container matColumnDef=\"changedBy\">\n                        <mat-header-cell *matHeaderCellDef mat-sort-header>User ID</mat-header-cell>\n                        <mat-cell *matCellDef=\"let item\">\n                            <nrcl-cell-content tooltip>{{ item.createdByUserId }}</nrcl-cell-content>\n                        </mat-cell>\n                    </ng-container>\n\n                    <ng-container matColumnDef=\"type\">\n                        <mat-header-cell *matHeaderCellDef mat-sort-header>Type</mat-header-cell>\n                        <mat-cell *matCellDef=\"let item\">\n                            <nrcl-cell-content tooltip>{{ item.eventHistoryTypeDescription }}</nrcl-cell-content>\n                        </mat-cell>\n                    </ng-container>\n\n                    <ng-container matColumnDef=\"section\">\n                        <mat-header-cell *matHeaderCellDef mat-sort-header>Section</mat-header-cell>\n                        <mat-cell *matCellDef=\"let item\">\n                            <nrcl-cell-content tooltip>{{ item.sourceObjectNameDescription }}</nrcl-cell-content>\n                        </mat-cell>\n                    </ng-container>\n\n                    <ng-container matColumnDef=\"comment\">\n                        <mat-header-cell *matHeaderCellDef>Comment</mat-header-cell>\n                        <mat-cell *matCellDef=\"let item\">\n                            {{ item.comment }}\n                        </mat-cell>\n                    </ng-container>\n\n                    <mat-header-row *matHeaderRowDef=\"columns; sticky: true\"></mat-header-row>\n                    <mat-row *matRowDef=\"let item; columns: columns;\"></mat-row>\n                </mat-table>\n            </nrcl-row-list-desktop>\n\n            <nrcl-gap/>\n        }\n\n        <nrcl-row-list-pagination\n            paginationId=\"desktop-event-history\"\n            [pageSize]=\"pageSize\"\n            [pageNumber]=\"pageNumber\"\n            [rowCount]=\"totalRowCount\"\n            (pageNumberChange)=\"onPageNumberChange( $event )\"\n            (pageSizeChange)=\"onPageSizeChange( $event )\"\n            [noRowsMessage]=\"noRowsMessage\"\n        ></nrcl-row-list-pagination>\n    </ng-template>\n\n    <ng-template mobile-view>\n        @if ( rows?.length > 0 ) {\n            <nrcl-gap/>\n\n            <nrcl-row-list-sorting\n                [sortColumn]=\"sortActive\"\n                [sortColumnOptions]=\"sortColumns\"\n                [sortDirection]=\"sortDirection\"\n                (sortChange)=\"onSortChange($event)\">\n            </nrcl-row-list-sorting>\n\n            <nrcl-gap/>\n\n            <nrcl-row-list-mobile>\n                @for ( item of rows | paginate: paginateState( 'mobile-event-history' ); track item.eventHistoryGuid ) {\n                    <mat-card>\n                        <mat-card-title>\n                            <section title>\n                                <h2>{{ item.eventTimestamp }}</h2>\n                            </section>\n                        </mat-card-title>\n\n                        <mat-card-content>\n                            <section>\n                                <mat-label>User ID</mat-label>\n                                <div class=\"value\">{{ item.createdByUserId }}</div>\n                            </section>\n\n                            <section>\n                                <mat-label>Type</mat-label>\n                                <div class=\"value\">{{ item.eventHistoryTypeDescription }}</div>\n                            </section>\n\n                            <section full-width>\n                                <mat-label>Section</mat-label>\n                                <div class=\"value\">{{ item.sourceObjectNameDescription }}</div>\n                            </section>\n\n                            <section full-width>\n                                <mat-label>Comment</mat-label>\n                                <div class=\"value\">{{ item.comment }}</div>\n                            </section>\n                        </mat-card-content>\n                    </mat-card>\n                }\n            </nrcl-row-list-mobile>\n\n            <nrcl-gap/>\n        }\n\n        <nrcl-row-list-pagination\n            paginationId=\"mobile-event-history\"\n            [pageSize]=\"pageSize\"\n            [pageNumber]=\"pageNumber\"\n            [rowCount]=\"totalRowCount\"\n            (pageNumberChange)=\"onPageNumberChange( $event )\"\n            (pageSizeChange)=\"onPageSizeChange( $event )\"\n            [noRowsMessage]=\"noRowsMessage\"\n        ></nrcl-row-list-pagination>\n    </ng-template>\n</nrcl-device-view>\n"]}

package/esm2022/components/list-select/list-select.component.mjs

@@ -33,7 +33,7 @@ export class ListSelectComponent extends RowListBase {
             this.displayColumns = this.displayColumnsProvider([...this.defaultDisplayColumns]);
         });
     }
-    get initialPageState() {
+    getInitialPageState() {
         return {
             filter: {},
             pageConfig: {
@@ -134,4 +134,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImpo
                 type: ContentChildren,
                 args: [MatColumnDef]
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"list-select.component.js","sourceRoot":"","sources":["../../../../../projects/nr-ngx-component-lib/src/components/list-select/list-select.component.ts","../../../../../projects/nr-ngx-component-lib/src/components/list-select/list-select.component.html"],"names":[],"mappings":"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","sourcesContent":["import { AfterContentInit, booleanAttribute, ChangeDetectionStrategy, Component, ContentChildren, EventEmitter, Input, OnChanges, Output, QueryList, SimpleChanges, ViewChild } from \"@angular/core\";\nimport { MatColumnDef, MatTable } from \"@angular/material/table\";\nimport { Observable, of } from \"rxjs\";\nimport { RowListBase, RowListState } from \"../../directives/row-list.base\";\nimport { CodeDescription } from \"../../utils/code-table.util\";\n\n@Component({\n    selector: \"nrcl-list-select\",\n    templateUrl: \"./list-select.component.html\",\n    styleUrl: \"./list-select.component.scss\",\n    changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class ListSelectComponent<T> extends RowListBase<{},CodeDescription> implements OnChanges, AfterContentInit {\n    @Input() options: CodeDescription[]\n    @Input() value: string[]\n    @Input() descriptionLabel = 'Description'\n    @Input( { transform: booleanAttribute } ) single \n    @Input() noRowsMessage = \"No items have been added.\"\n    @Input() displayColumnsProvider: ( cols: string[] ) => string[] = ( cols ) => cols\n    @Input() filterProvider: ( option: CodeDescription ) => boolean = () => true\n   \n    @Output() valueChange = new EventEmitter<string[]>();\n    @Output() filterClear = new EventEmitter<void>();\n    \n    @ViewChild( MatTable, {static: true} ) table!: MatTable<T>;\n    \n    @ContentChildren( MatColumnDef ) columnDefs!: QueryList<MatColumnDef>;\n    \n    searchText\n    searchRegexp: RegExp\n    defaultDisplayColumns = [ 'description', 'addRemove' ]\n    displayColumns = []\n\n    ngOnChanges( changes: SimpleChanges ): void {\n        if ( changes.options ) {\n            this.refreshRowList()\n        }\n    }\n\n    ngAfterContentInit(): void {\n        this.columnDefs.forEach(columnDef => this.table.addColumnDef(columnDef));\n\n        setTimeout( () => {\n            this.displayColumns = this.displayColumnsProvider( [ ...this.defaultDisplayColumns ] )\n        } )\n    }\n\n    get initialPageState(): RowListState<{}> {\n        return {\n            filter: {},\n            pageConfig: {\n                pageSize: 0,\n                pageNumber: 1,\n                sortActive: '',\n                sortDirection: 'desc',\n            }\n        }\n    }\n\n    fetchRowListPage(): Observable<CodeDescription[]> {\n        return of( this.options.filter( o => this.filterOption( o ) ) )\n    }\n    \n    parseRows( res: any ): CodeDescription[] {\n        return res\n    }\n\n    parseTotalRowCount( res: any ): number {\n        return res.length\n    }\n\n    isSelected( item: CodeDescription ) {\n        return this.value?.includes( item.code )\n    }\n\n    onRowClick( item: CodeDescription ) {       \n        if ( this.single ) {\n            if ( this.isSelected( item ) ) {\n                this.value = []\n            }\n            else {\n                this.value = [ item.code ]\n            }\n        }\n        else {\n            let val = this.value || []\n\n            if ( this.isSelected( item ) ) {\n                this.value = val.filter( c => c != item.code )\n            }\n            else {\n                this.value = val.concat( item.code )\n            }\n        }\n\n        this.valueChange.emit( this.value )\n    }    \n\n    onClearFilters() {\n        this.searchText = null\n        this.searchRegexp = null\n        this.filterClear.emit()\n        this.refreshRowList()\n    }\n\n    onSearchTextChange( ev ) {\n        this.searchText = ev\n\n        let t = this.searchText?.trim()\n        if ( t ) {\n            t = t.toLowerCase().replace( /\\s+/g, '.*' )\n            this.searchRegexp = new RegExp( t, 'i' ) \n        }\n        else {\n            this.searchRegexp = null\n        }\n\n        this.refreshRowList()\n    }\n\n    filterOption( option: CodeDescription ): boolean {\n        if ( this.searchRegexp && !this.searchRegexp.test( option.description ) ) return false\n\n        return this.filterProvider( option )\n    }\n\n    savePageState(): void {\n        // state not saved\n    }\n}\n","@if ( !single ) {\n    <div class=\"summary\">\n        <h3>{{ value?.length || '0' }} Selected</h3>\n    </div>\n}\n\n<nrcl-filters-panel (clearFilters)=\"onClearFilters()\">\n    <nrcl-filter-search\n        [(value)]=\"searchText\"\n        (valueChange)=\"onSearchTextChange( $event )\">\n    </nrcl-filter-search>\n\n    <ng-content select=\"[filter]\"></ng-content>\n</nrcl-filters-panel>\n\n<nrcl-row-list-desktop [class.empty]=\"rows?.length == 0\">\n    <mat-table [dataSource]=\"rows\" >\n        <ng-container matColumnDef=\"description\">\n            <mat-header-cell *matHeaderCellDef>{{ descriptionLabel }}</mat-header-cell>\n            <mat-cell *matCellDef=\"let item\">\n                <nrcl-cell-content>{{ item.description }}</nrcl-cell-content>\n            </mat-cell>\n        </ng-container>\n\n        <ng-container matColumnDef=\"addRemove\">\n            <mat-header-cell *matHeaderCellDef>Add Remove</mat-header-cell>\n            <mat-cell *matCellDef=\"let item\">\n                <nrcl-indicator-select [selected]=\"isSelected( item )\"></nrcl-indicator-select>\n            </mat-cell>\n        </ng-container>\n\n        <ng-content></ng-content>\n\n        <mat-header-row *matHeaderRowDef=\"displayColumns; sticky: true\"></mat-header-row>\n\n        <mat-row\n            *matRowDef=\"let item; columns: displayColumns\"\n            [class.selected]=\"isSelected( item )\"\n            (click)=\"onRowClick( item )\"\n            (keypress)=\"onRowClick( item )\"\n        ></mat-row>\n    </mat-table>\n</nrcl-row-list-desktop>\n\n@if ( totalRowCount == 0 ) {\n    <nrcl-row-list-pagination\n        paginationId=\"list-select\"\n        [pageSize]=\"pageSize\"\n        [pageNumber]=\"pageNumber\"\n        [rowCount]=\"totalRowCount\"\n        (pageNumberChange)=\"onPageNumberChange( $event )\"\n        (pageSizeChange)=\"onPageSizeChange( $event )\"\n        [noRowsMessage]=\"noRowsMessage\"\n    ></nrcl-row-list-pagination>\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"list-select.component.js","sourceRoot":"","sources":["../../../../../projects/nr-ngx-component-lib/src/components/list-select/list-select.component.ts","../../../../../projects/nr-ngx-component-lib/src/components/list-select/list-select.component.html"],"names":[],"mappings":"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","sourcesContent":["import { AfterContentInit, booleanAttribute, ChangeDetectionStrategy, Component, ContentChildren, EventEmitter, Input, OnChanges, Output, QueryList, SimpleChanges, ViewChild } from \"@angular/core\";\nimport { MatColumnDef, MatTable } from \"@angular/material/table\";\nimport { Observable, of } from \"rxjs\";\nimport { RowListBase, RowListState } from \"../../directives/row-list.base\";\nimport { CodeDescription } from \"../../utils/code-table.util\";\n\n@Component({\n    selector: \"nrcl-list-select\",\n    templateUrl: \"./list-select.component.html\",\n    styleUrl: \"./list-select.component.scss\",\n    changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class ListSelectComponent<T> extends RowListBase<{},CodeDescription> implements OnChanges, AfterContentInit {\n    @Input() options: CodeDescription[]\n    @Input() value: string[]\n    @Input() descriptionLabel = 'Description'\n    @Input( { transform: booleanAttribute } ) single \n    @Input() noRowsMessage = \"No items have been added.\"\n    @Input() displayColumnsProvider: ( cols: string[] ) => string[] = ( cols ) => cols\n    @Input() filterProvider: ( option: CodeDescription ) => boolean = () => true\n   \n    @Output() valueChange = new EventEmitter<string[]>();\n    @Output() filterClear = new EventEmitter<void>();\n    \n    @ViewChild( MatTable, {static: true} ) table!: MatTable<T>;\n    \n    @ContentChildren( MatColumnDef ) columnDefs!: QueryList<MatColumnDef>;\n    \n    searchText\n    searchRegexp: RegExp\n    defaultDisplayColumns = [ 'description', 'addRemove' ]\n    displayColumns = []\n\n    ngOnChanges( changes: SimpleChanges ): void {\n        if ( changes.options ) {\n            this.refreshRowList()\n        }\n    }\n\n    ngAfterContentInit(): void {\n        this.columnDefs.forEach(columnDef => this.table.addColumnDef(columnDef));\n\n        setTimeout( () => {\n            this.displayColumns = this.displayColumnsProvider( [ ...this.defaultDisplayColumns ] )\n        } )\n    }\n\n    getInitialPageState(): RowListState<{}> {\n        return {\n            filter: {},\n            pageConfig: {\n                pageSize: 0,\n                pageNumber: 1,\n                sortActive: '',\n                sortDirection: 'desc',\n            }\n        }\n    }\n\n    fetchRowListPage(): Observable<CodeDescription[]> {\n        return of( this.options.filter( o => this.filterOption( o ) ) )\n    }\n    \n    parseRows( res: any ): CodeDescription[] {\n        return res\n    }\n\n    parseTotalRowCount( res: any ): number {\n        return res.length\n    }\n\n    isSelected( item: CodeDescription ) {\n        return this.value?.includes( item.code )\n    }\n\n    onRowClick( item: CodeDescription ) {       \n        if ( this.single ) {\n            if ( this.isSelected( item ) ) {\n                this.value = []\n            }\n            else {\n                this.value = [ item.code ]\n            }\n        }\n        else {\n            let val = this.value || []\n\n            if ( this.isSelected( item ) ) {\n                this.value = val.filter( c => c != item.code )\n            }\n            else {\n                this.value = val.concat( item.code )\n            }\n        }\n\n        this.valueChange.emit( this.value )\n    }    \n\n    onClearFilters() {\n        this.searchText = null\n        this.searchRegexp = null\n        this.filterClear.emit()\n        this.refreshRowList()\n    }\n\n    onSearchTextChange( ev ) {\n        this.searchText = ev\n\n        let t = this.searchText?.trim()\n        if ( t ) {\n            t = t.toLowerCase().replace( /\\s+/g, '.*' )\n            this.searchRegexp = new RegExp( t, 'i' ) \n        }\n        else {\n            this.searchRegexp = null\n        }\n\n        this.refreshRowList()\n    }\n\n    filterOption( option: CodeDescription ): boolean {\n        if ( this.searchRegexp && !this.searchRegexp.test( option.description ) ) return false\n\n        return this.filterProvider( option )\n    }\n\n    savePageState(): void {\n        // state not saved\n    }\n}\n","@if ( !single ) {\n    <div class=\"summary\">\n        <h3>{{ value?.length || '0' }} Selected</h3>\n    </div>\n}\n\n<nrcl-filters-panel (clearFilters)=\"onClearFilters()\">\n    <nrcl-filter-search\n        [(value)]=\"searchText\"\n        (valueChange)=\"onSearchTextChange( $event )\">\n    </nrcl-filter-search>\n\n    <ng-content select=\"[filter]\"></ng-content>\n</nrcl-filters-panel>\n\n<nrcl-row-list-desktop [class.empty]=\"rows?.length == 0\">\n    <mat-table [dataSource]=\"rows\" >\n        <ng-container matColumnDef=\"description\">\n            <mat-header-cell *matHeaderCellDef>{{ descriptionLabel }}</mat-header-cell>\n            <mat-cell *matCellDef=\"let item\">\n                <nrcl-cell-content>{{ item.description }}</nrcl-cell-content>\n            </mat-cell>\n        </ng-container>\n\n        <ng-container matColumnDef=\"addRemove\">\n            <mat-header-cell *matHeaderCellDef>Add Remove</mat-header-cell>\n            <mat-cell *matCellDef=\"let item\">\n                <nrcl-indicator-select [selected]=\"isSelected( item )\"></nrcl-indicator-select>\n            </mat-cell>\n        </ng-container>\n\n        <ng-content></ng-content>\n\n        <mat-header-row *matHeaderRowDef=\"displayColumns; sticky: true\"></mat-header-row>\n\n        <mat-row\n            *matRowDef=\"let item; columns: displayColumns\"\n            [class.selected]=\"isSelected( item )\"\n            (click)=\"onRowClick( item )\"\n            (keypress)=\"onRowClick( item )\"\n        ></mat-row>\n    </mat-table>\n</nrcl-row-list-desktop>\n\n@if ( totalRowCount == 0 ) {\n    <nrcl-row-list-pagination\n        paginationId=\"list-select\"\n        [pageSize]=\"pageSize\"\n        [pageNumber]=\"pageNumber\"\n        [rowCount]=\"totalRowCount\"\n        (pageNumberChange)=\"onPageNumberChange( $event )\"\n        (pageSizeChange)=\"onPageSizeChange( $event )\"\n        [noRowsMessage]=\"noRowsMessage\"\n    ></nrcl-row-list-pagination>\n}\n"]}