@angular-generic-table/core 5.0.0-rc.9 → 5.0.0

package/types/angular-generic-table-core.d.ts

@@ -0,0 +1,396 @@
+import * as _angular_core from '@angular/core';
+import { TemplateRef, Type, OnDestroy, TrackByFunction, PipeTransform, Injector } from '@angular/core';
+import { Observable } from 'rxjs';
+import * as i1 from '@angular/common';
+import { KeyValue } from '@angular/common';
+
+interface TableRow {
+    [key: string]: number | string | boolean | any;
+}
+
+type GtSortOrder<R = TableRow> = Array<GtSortConfig<R>>;
+interface GtSortConfig<R = {}> {
+    key: keyof R;
+    order: GtOrder;
+}
+type GtOrder = 'asc' | 'desc';
+
+interface GtCellContext<R = TableRow> {
+    row: R;
+    col: {
+        key: string;
+        value: TableColumn<R>;
+    };
+    index: number;
+    data: R[];
+    search: string | null;
+}
+interface GtHeaderContext<R = TableRow> {
+    column: {
+        key: string;
+        value: TableColumn<R>;
+    };
+    sortable: boolean;
+    sortOrder: GtSortOrder<R>;
+    search: string | null;
+    sort?: (event: MouseEvent) => void;
+}
+interface TableColumn<R = TableRow> {
+    header?: string | false;
+    headerTemplateRef?: TemplateRef<any>;
+    headerComponent?: Type<any>;
+    headerComponentInputs?: Record<string, unknown>;
+    headerReplaceFull?: boolean;
+    mobileHeader?: string | boolean;
+    hidden?: boolean;
+    sortable?: boolean;
+    order?: number;
+    search?: boolean | SearchFunction<R>;
+    templateRef?: TemplateRef<any>;
+    component?: Type<any>;
+    componentInputs?: Record<string, unknown>;
+    transform?: {
+        pipe: any;
+        args?: Array<any>;
+    };
+    class?: string;
+    mapTo?: {
+        path: string;
+        missingValue?: string | number;
+    };
+}
+type SearchFunction<R = TableRow> = (row: R, column: keyof R, value: typeof row[keyof R]) => string;
+
+interface TableConfig<R = TableRow> {
+    /** Disable sorting of table data, useful when sorting is handled externally e.g. server-side pagination. Table will still use sortOrder to visually show how the data is sorted. <p>**Default:** `false`</p> */
+    disableTableSort?: boolean;
+    /** Allows for a more mobile friendly layout by displaying columns as rows instead. This is accomplished with css by adding `table-mobile` class to table element and adding column headers as data labels to each row. <p>**Default:** `false`</p>*/
+    mobileLayout?: boolean;
+    /** Make row and/or column headers sticky by adding `gt-sticky-row-header` and `gt-sticky-column-header` to table to alter table behaviour using css. Please note that in order for headers to be sticky, table can't be placed inside element with overflow set to auto. <p>**Default:** `{row:false, column:false}`</p>*/
+    stickyHeaders?: {
+        row?: boolean;
+        column?: boolean;
+    };
+    /** Add one or more CSS classes to the table element e.g. `table table-striped table-bordered`. <p>**Default:** `table`</p>*/
+    class?: string;
+    rows?: {
+        [Property in keyof R]: TableColumn<R>;
+    };
+    columns?: {
+        [Property in keyof R]: TableColumn<R>;
+    };
+    pagination?: {
+        length?: number;
+    };
+    rowClick?: boolean;
+    /** Toggle row active state on mouse enter/leave (hover) <p>**Default:** `false`</p>*/
+    activateRowOnHover?: boolean;
+    /** Toggle row active state on keyboard navigation <p>**Default:** `false`</p>*/
+    activateRowOnKeyboardNavigation?: boolean;
+    deactivateRowOnLostFocus?: boolean;
+    footer?: {
+        headers?: {
+            [key: FooterCalculation | string]: string | boolean;
+        };
+        columns?: {
+            [Property in keyof R]: Partial<TableFooterColumn<R>>;
+        };
+        rowOrder?: Array<keyof R | FooterCalculation>;
+        emptyContent?: string;
+    };
+}
+interface TableFooterColumn<R> {
+    [key: FooterCalculation | string]: boolean | number | string | CalcFunc<R>;
+}
+interface CalcFunc<R> {
+    (data: Array<R>, key: keyof R): number | string;
+}
+type FooterCalculation = 'sum' | 'avg' | 'count' | 'max' | 'min';
+
+interface GtRowClickEvent<R = TableRow> {
+    row: R;
+    index: number;
+    event: MouseEvent;
+}
+interface GtRowActiveEvent<R = TableRow> {
+    row: R | null;
+    index: number | null;
+    event?: MouseEvent | KeyboardEvent;
+}
+interface GtRowSelectEvent<R = TableRow> {
+    row: R | null;
+    index: number | null;
+    event?: KeyboardEvent;
+}
+interface GtSortEvent<R = TableRow> {
+    key: keyof R;
+    order: GtOrder;
+    currentSortOrder: GtSortOrder<R>;
+    event?: MouseEvent;
+    addSortKey: boolean /** Add additional key to sort on multiple properties? True if the user is holding shift while sorting */;
+}
+interface GtPageChangeEvent {
+    index: number;
+}
+
+declare let dashed: (s: string) => string;
+declare let capitalize: (s: string) => string;
+declare let chunk: (array: Array<any>, chunkSize: number) => Array<Array<TableRow>>;
+declare let search: (text: string, caseSensitive: boolean, data: Array<TableRow>, config: TableConfig) => TableRow[];
+declare let calculate: (data: Array<TableRow>, config: TableConfig) => {
+    calculated: any;
+    calculations: string[];
+    calculatedColumnsCount: number;
+};
+/** sortOnMultipleKeys
+ * @description Sort data on multiple keys with locale-aware alphanumeric comparison
+ * @param {GtSortOrder} keys - array with sort config objects to sort on, data will be sorted according to array order
+ * @returns sort function
+ */
+declare const sortOnMultipleKeys: (keys: GtSortOrder) => ((a: TableRow, b: TableRow) => number);
+/** parseSortOrderParams
+ * @description Convert sort order query param to array with sort config objects
+ * @param sortParams - Query param string where each sort config object is separated by comma and order is indicated by + (ascending) or - (descending), e.g. _'name,-age'_
+ * @returns GtSortOrder - Array with sort config objects
+ */
+declare const parseSortOrderParams: (sortParams: string) => GtSortOrder;
+/** sortOrderConfigToParam
+ * @description Convert sort config object to string that can be used as query param when sorting is implemented server side
+ * @param sortConfig - Sort config object
+ * @returns string - Query param string where order is indicated by + (ascending) or - (descending), e.g. _'-name'_
+ */
+declare const sortOrderConfigToParam: (sortConfig: GtSortEvent | GtSortConfig) => string;
+/** sortOrderToParams
+ * @description Convert sort order array to string that can be used as query param when sorting is implemented server side
+ * @param sortOrder - Array with sort config objects
+ * @returns string - Query param string where each sort config object is separated by comma and order is indicated by + (ascending) or - (descending), e.g. _'name,-age'_
+ */
+declare const sortOrderToParams: (sortOrder: GtSortOrder) => string;
+
+interface GtPaginationClasses {
+    nav?: string;
+    ul?: string;
+    li?: string;
+    button?: string;
+}
+interface GtPaginationAriaLabels {
+    nav: string;
+    button: string;
+}
+interface GtPaginationInfo {
+    pageNext: number | null;
+    pageCurrent: number | null;
+    pagePrevious: number | null;
+    pageSize: number | null;
+    numberOfRecords: number | null;
+    pageTotal?: number | null;
+}
+
+interface TableInfo {
+    numberOfRecords: number;
+    pageSize?: number;
+    pageTotal: number;
+    lazyLoaded?: boolean;
+}
+
+interface TableMeta<R = TableRow> {
+    data: Array<Array<R>>;
+    config: TableConfig<R>;
+    info: TableInfo;
+}
+
+declare class CoreComponent implements OnDestroy {
+    private _destroyRef;
+    private _unsubscribe$;
+    readonly navigationKeys: _angular_core.InputSignal<string[]>;
+    readonly selectKeys: _angular_core.InputSignal<string[]>;
+    readonly config: _angular_core.InputSignal<TableConfig<any>>;
+    readonly data: _angular_core.InputSignal<TableRow[]>;
+    readonly searchTerm: _angular_core.InputSignal<string | null>;
+    readonly loading: _angular_core.InputSignal<boolean>;
+    readonly sortOrderInput: _angular_core.InputSignal<GtSortOrder<any>>;
+    readonly paginationIndexInput: _angular_core.InputSignal<number>;
+    readonly pagingInfo: _angular_core.InputSignal<GtPaginationInfo | null>;
+    readonly selection: _angular_core.InputSignal<any>;
+    readonly rowIdKey: _angular_core.InputSignal<string | undefined>;
+    readonly generateRowId: _angular_core.InputSignal<boolean>;
+    readonly trackRowByFnInput: _angular_core.InputSignal<TrackByFunction<TableRow> | undefined>;
+    readonly isRowSelectedFn: _angular_core.InputSignal<((row: TableRow | any, selection?: any) => boolean) | undefined>;
+    readonly customClassesInput: _angular_core.InputSignal<Partial<{
+        selectedRow: string;
+        activeRow: string;
+    }>>;
+    readonly rowClick: _angular_core.OutputEmitterRef<GtRowClickEvent<TableRow>>;
+    readonly rowSelect: _angular_core.OutputEmitterRef<GtRowSelectEvent<TableRow>>;
+    readonly sortOrderChange: _angular_core.OutputEmitterRef<GtSortOrder<TableRow>>;
+    readonly rowActiveOutput: _angular_core.OutputEmitterRef<GtRowActiveEvent<TableRow>>;
+    readonly columnSort: _angular_core.OutputEmitterRef<GtSortEvent<TableRow>>;
+    readonly pageChange: _angular_core.OutputEmitterRef<GtPageChangeEvent>;
+    protected sortOrder: _angular_core.WritableSignal<GtSortOrder<any>>;
+    protected currentPaginationIndex: _angular_core.WritableSignal<number>;
+    protected customClasses: _angular_core.Signal<{
+        selectedRow: string;
+        activeRow: string;
+    }>;
+    trackRowByFn: TrackByFunction<TableRow>;
+    /** Data with mapTo expansions and row IDs applied */
+    private expandedData;
+    /** Filtered data (search applied, no sort) */
+    private searchedData;
+    /** Sorted (and already searched) data */
+    private processedData;
+    /** Table meta: chunked data + config + pagination info */
+    protected table: _angular_core.Signal<TableMeta<TableRow>>;
+    /** Current table info */
+    readonly tableInfoSignal: _angular_core.Signal<TableInfo>;
+    /** Get tableInfo synchronously */
+    get tableInfo(): TableInfo | undefined;
+    /** Calculations for footer */
+    protected calculations: _angular_core.Signal<{
+        calculated: any;
+        calculations: string[];
+        calculatedColumnsCount: number;
+    }>;
+    /** Bounded pagination index (clamped to valid range) */
+    readonly boundedPaginationIndex: _angular_core.Signal<number>;
+    /** Number of visible columns */
+    protected colspan: _angular_core.Signal<number>;
+    /** Number of footer columns */
+    protected footerColspan: _angular_core.Signal<number>;
+    protected rowActiveState: _angular_core.WritableSignal<GtRowActiveEvent<TableRow>>;
+    activeRowIndex: number | null;
+    private _rowActiveEffect;
+    private _sortOrder$?;
+    get sortOrder$(): Observable<GtSortOrder>;
+    private _loading$?;
+    get loading$(): Observable<boolean>;
+    private _searchBy$?;
+    get searchBy$(): Observable<string | null>;
+    private _tableConfig$?;
+    get tableConfig$(): Observable<TableConfig>;
+    private _data$?;
+    get data$(): Observable<Array<TableRow>>;
+    private _table$?;
+    get table$(): Observable<TableMeta>;
+    private _tableInfo$?;
+    get tableInfo$(): Observable<TableInfo>;
+    private _currentPaginationIndex$?;
+    get currentPaginationIndex$(): Observable<number>;
+    private _calculations$?;
+    get calculations$(): Observable<ReturnType<typeof calculate>>;
+    private _rowActive$?;
+    get rowActive$(): Observable<GtRowActiveEvent>;
+    private _colspan$?;
+    get colspan$(): Observable<number>;
+    get paginationIndex(): number;
+    set paginationIndex(value: number);
+    protected headerSortFn(key: string): (event: MouseEvent) => void;
+    _rowClick(row: TableRow, index: number, event: MouseEvent): void;
+    _rowSelect(row: TableRow, index: number, event: KeyboardEvent): void;
+    activateRow(id: string, event?: MouseEvent | KeyboardEvent): void;
+    activateRow(index: number, event?: MouseEvent | KeyboardEvent): void;
+    activateRow(none: null, event?: MouseEvent | KeyboardEvent): void;
+    protected _activateRow(row: TableRow | null, index: number | null, event?: MouseEvent | KeyboardEvent): void;
+    /** sortByKey - Sort by key in table row */
+    sortByKey(key: keyof TableRow, $event?: MouseEvent): void;
+    private _columnOrder;
+    protected orderedColumns: _angular_core.Signal<KeyValue<string, TableColumn<TableRow>>[]>;
+    protected orderedRows: _angular_core.Signal<KeyValue<string, TableColumn<TableRow>>[]>;
+    nestedValue(object: any, mapTo: string, missingValue?: string | number | null): unknown;
+    private _unsubscribeFromKeyboardEvents$;
+    private _keyboardArrowEvent$;
+    protected listenToKeyboardEvents(): void;
+    unsubscribeFromKeyboardEvents(tableRef: HTMLTableElement): void;
+    private _handleNavigationEvent;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CoreComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CoreComponent, "angular-generic-table", never, { "navigationKeys": { "alias": "navigationKeys"; "required": false; "isSignal": true; }; "selectKeys": { "alias": "selectKeys"; "required": false; "isSignal": true; }; "config": { "alias": "config"; "required": false; "isSignal": true; }; "data": { "alias": "data"; "required": false; "isSignal": true; }; "searchTerm": { "alias": "search"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "sortOrderInput": { "alias": "sortOrder"; "required": false; "isSignal": true; }; "paginationIndexInput": { "alias": "paginationIndex"; "required": false; "isSignal": true; }; "pagingInfo": { "alias": "pagingInfo"; "required": false; "isSignal": true; }; "selection": { "alias": "selection"; "required": false; "isSignal": true; }; "rowIdKey": { "alias": "rowIdKey"; "required": false; "isSignal": true; }; "generateRowId": { "alias": "generateRowId"; "required": false; "isSignal": true; }; "trackRowByFnInput": { "alias": "trackRowByFn"; "required": false; "isSignal": true; }; "isRowSelectedFn": { "alias": "isRowSelectedFn"; "required": false; "isSignal": true; }; "customClassesInput": { "alias": "customClasses"; "required": false; "isSignal": true; }; }, { "rowClick": "rowClick"; "rowSelect": "rowSelect"; "sortOrderChange": "sortOrderChange"; "rowActiveOutput": "rowActive"; "columnSort": "columnSort"; "pageChange": "pageChange"; }, never, [".table-loading", ".table-no-data"], true, never>;
+}
+
+interface GtDelta {
+    relative: number | string;
+    absolute: number;
+}
+declare class GtDeltaComponent {
+    readonly data: _angular_core.InputSignal<TableRow[]>;
+    readonly index: _angular_core.InputSignal<number>;
+    readonly baseIndex: _angular_core.InputSignal<number | undefined>;
+    readonly classes: _angular_core.InputSignal<{
+        span: string;
+        positive: string;
+        negative: string;
+    }>;
+    readonly key: _angular_core.InputSignal<string>;
+    readonly notApplicableValue: _angular_core.InputSignal<string | null>;
+    readonly initialValue: _angular_core.InputSignal<string | number | null>;
+    readonly deltaTemplate: _angular_core.InputSignal<TemplateRef<any> | undefined>;
+    readonly value: _angular_core.Signal<GtDelta | undefined>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GtDeltaComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GtDeltaComponent, "gt-delta", never, { "data": { "alias": "data"; "required": false; "isSignal": true; }; "index": { "alias": "index"; "required": false; "isSignal": true; }; "baseIndex": { "alias": "baseIndex"; "required": false; "isSignal": true; }; "classes": { "alias": "classes"; "required": false; "isSignal": true; }; "key": { "alias": "key"; "required": false; "isSignal": true; }; "notApplicableValue": { "alias": "notApplicableValue"; "required": false; "isSignal": true; }; "initialValue": { "alias": "initialValue"; "required": false; "isSignal": true; }; "deltaTemplate": { "alias": "deltaTemplate"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class GenericTableCoreModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GenericTableCoreModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<GenericTableCoreModule, never, [typeof CoreComponent, typeof GtDeltaComponent], [typeof CoreComponent, typeof GtDeltaComponent]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<GenericTableCoreModule>;
+}
+
+declare class PaginationComponent {
+    readonly table: _angular_core.InputSignal<CoreComponent>;
+    readonly pagingInfo: _angular_core.InputSignal<GtPaginationInfo | undefined>;
+    readonly paginationLength: _angular_core.InputSignal<number>;
+    readonly classes: _angular_core.InputSignal<GtPaginationClasses>;
+    readonly ariaLabels: _angular_core.InputSignal<GtPaginationAriaLabels>;
+    /** Page numbers to display in the pagination component */
+    protected paginationListItems: _angular_core.Signal<number[]>;
+    /** Current page from the table */
+    protected currentPosition: _angular_core.Signal<number>;
+    private _generateList;
+    goToPage(index: number): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PaginationComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PaginationComponent, "angular-generic-table-pagination", never, { "table": { "alias": "table"; "required": true; "isSignal": true; }; "pagingInfo": { "alias": "pagingInfo"; "required": false; "isSignal": true; }; "paginationLength": { "alias": "paginationLength"; "required": false; "isSignal": true; }; "classes": { "alias": "classes"; "required": false; "isSignal": true; }; "ariaLabels": { "alias": "ariaLabels"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class GenericTablePaginationModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GenericTablePaginationModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<GenericTablePaginationModule, never, [typeof i1.CommonModule, typeof PaginationComponent], [typeof PaginationComponent]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<GenericTablePaginationModule>;
+}
+
+declare class CapitalCasePipe implements PipeTransform {
+    transform(s: string): any;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CapitalCasePipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<CapitalCasePipe, "capitalCase", true>;
+}
+
+declare class DashCasePipe implements PipeTransform {
+    transform(s: string): any;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DashCasePipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<DashCasePipe, "dashCase", true>;
+}
+
+declare class DynamicPipe implements PipeTransform {
+    private injector;
+    private _cache;
+    constructor(injector: Injector);
+    transform(value: any, requiredPipe: Type<any>, pipeArgs: any[]): any;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DynamicPipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<DynamicPipe, "dynamicPipe", true>;
+}
+
+declare class HighlightPipe implements PipeTransform {
+    private _cachedTerm;
+    private _cachedRegex;
+    transform(text: any, searchTerm: string | null): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HighlightPipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<HighlightPipe, "highlight", true>;
+}
+
+declare class SortClassPipe implements PipeTransform {
+    transform(sortOrder: GtSortOrder | null, key: string, context?: 'class' | 'aria' | 'order'): string | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SortClassPipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<SortClassPipe, "sortClass", true>;
+}
+
+export { CapitalCasePipe, CoreComponent, DashCasePipe, DynamicPipe, GenericTableCoreModule, GenericTablePaginationModule, GtDeltaComponent, HighlightPipe, PaginationComponent, SortClassPipe, calculate, capitalize, chunk, dashed, parseSortOrderParams, search, sortOnMultipleKeys, sortOrderConfigToParam, sortOrderToParams };
+export type { GtCellContext, GtDelta, GtHeaderContext, GtOrder, GtPageChangeEvent, GtPaginationAriaLabels, GtPaginationClasses, GtPaginationInfo, GtRowActiveEvent, GtRowClickEvent, GtRowSelectEvent, GtSortConfig, GtSortEvent, GtSortOrder, SearchFunction, TableColumn, TableConfig, TableInfo, TableMeta, TableRow };

package/angular-generic-table-core.d.ts

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

package/esm2020/angular-generic-table-core.mjs

@@ -1,5 +0,0 @@
-/**
- * Generated bundle index. Do not edit.
- */
-export * from './public-api';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYW5ndWxhci1nZW5lcmljLXRhYmxlLWNvcmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9wcm9qZWN0cy9jb3JlL3NyYy9hbmd1bGFyLWdlbmVyaWMtdGFibGUtY29yZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsY0FBYyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL3B1YmxpYy1hcGknO1xuIl19

package/esm2020/lib/core.component.mjs

@@ -1,122 +0,0 @@
-import { ChangeDetectionStrategy, Component, Input } from '@angular/core';
-import { BehaviorSubject, combineLatest, EMPTY, isObservable, of, ReplaySubject, Subject } from 'rxjs';
-import { map, shareReplay, startWith, switchMap, withLatestFrom } from 'rxjs/operators';
-import { Order } from './enums/order.enum';
-import { chunk, search } from './utilities/utilities';
-import * as i0 from "@angular/core";
-import * as i1 from "@angular/common";
-import * as i2 from "./pipes/sort-class.pipe";
-import * as i3 from "./pipes/dash-case.pipe";
-import * as i4 from "./pipes/capital-case.pipe";
-import * as i5 from "./pipes/highlight.pipe";
-import * as i6 from "./pipes/dynamic.pipe";
-export class CoreComponent {
-    constructor() {
-        this._loading$ = new ReplaySubject(1);
-        this.sortBy$ = new Subject();
-        // tslint:disable-next-line:variable-name
-        this._searchBy$ = new ReplaySubject(1);
-        this.searchBy$ = this._searchBy$.pipe(startWith(''), map((value) => (isObservable(value) ? value : of(value))), switchMap((obs) => obs), shareReplay(1));
-        // tslint:disable-next-line:variable-name
-        this._tableConfig$ = new ReplaySubject(1);
-        this.tableConfig$ = this._tableConfig$.pipe(map((value) => (isObservable(value) ? value : of(value))), switchMap((obs) => obs), shareReplay(1));
-        // tslint:disable-next-line:variable-name
-        this._data$ = new ReplaySubject(1);
-        this.data$ = this._data$.pipe(map((value) => (isObservable(value) ? value : of(value))), switchMap((obs) => combineLatest([obs, this.sortBy$.pipe(startWith(EMPTY)), this.searchBy$])), withLatestFrom(this.tableConfig$), map(([[data, sortBy, searchBy], config]) => {
-            // create a new array reference and sort new array (prevent mutating existing state)
-            data = [...data];
-            return !sortBy
-                ? searchBy
-                    ? search(searchBy, false, data, config)
-                    : data
-                : (searchBy ? search(searchBy, false, data, config) : data)?.sort((a, b) => {
-                    // TODO: improve logic
-                    const typed = sortBy;
-                    return a[typed.sortBy] > b[typed.sortBy]
-                        ? typed.sortByOrder === Order.ASC
-                            ? 1
-                            : -1
-                        : b[typed.sortBy] > a[typed.sortBy]
-                            ? typed.sortByOrder === Order.ASC
-                                ? -1
-                                : 1
-                            : 0;
-                });
-        }), shareReplay(1));
-        this.table$ = combineLatest([this.data$, this.tableConfig$]).pipe(map(([sorted, config]) => {
-            // if pagination is disabled...
-            if (!config.pagination || config.pagination.length === 0) {
-                // ...return unaltered array
-                return { data: [sorted], config, info: { records: sorted.length, pageTotal: 1 } };
-            }
-            // return record set
-            return {
-                data: chunk(sorted, +(config.pagination.length || 0)),
-                config,
-                info: {
-                    records: sorted.length,
-                    pageTotal: Math.ceil(sorted.length / +(config.pagination.length || 0)),
-                },
-            };
-        }), shareReplay(1));
-        this._currentPage$ = new BehaviorSubject(0);
-        this.currentPage$ = combineLatest([this._currentPage$, this.table$]).pipe(map(([page, table]) => {
-            // determine last page
-            const lastPage = Math.ceil(table.info.records / (table.config?.pagination?.length || table.info.records)) - 1;
-            // determine max/min position
-            return +page < 0 ? 0 : +page > lastPage ? lastPage : +page;
-        }), shareReplay(1));
-        this.colspan$ = this.tableConfig$.pipe(switchMap((config) => config.columns
-            ? of(Object.values(config.columns || config.rows || {}).filter((value) => value.hidden !== true).length)
-            : this.data$.pipe(map((data) => data.length + 1))));
-        this.columnOrder = (a, b) => {
-            return (a.value.order || 0) - (b.value.order || 0);
-        };
-    }
-    set loading(value) {
-        this._loading$.next(value);
-    }
-    set page(value) {
-        this._currentPage$.next(value);
-    }
-    set search(value) {
-        this._searchBy$.next(value);
-    }
-    set config(value) {
-        this._tableConfig$.next(value);
-    }
-    set data(value) {
-        this._data$.next(value);
-    }
-    get loading$() {
-        return this._loading$.pipe(startWith(false), map((value) => (isObservable(value) ? value : of(value))), switchMap((obs) => obs), shareReplay(1));
-    }
-    sort(property) {
-        const newSortOrder = this._sortBy?.sortBy !== property || this._sortBy?.sortByOrder === Order.DESC || !this._sortBy.sortByOrder
-            ? Order.ASC
-            : Order.DESC;
-        const newSortBy = {
-            sortBy: property,
-            sortByOrder: newSortOrder,
-        };
-        this.sortBy$.next(newSortBy);
-        this._sortBy = newSortBy;
-    }
-}
-CoreComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: CoreComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
-CoreComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.0.3", type: CoreComponent, selector: "angular-generic-table", inputs: { loading: "loading", page: "page", search: "search", config: "config", data: "data" }, ngImport: i0, template: "<table [ngClass]=\"(tableConfig$ | async)?.class || 'table'\" [class.table-mobile]=\"(tableConfig$ | async)?.mobileLayout\">\n  <thead>\n    <tr *ngIf=\"{\n    config:(tableConfig$ | async)!,\n    loading: loading$ | async\n    } as table\">\n      <ng-container *ngFor=\"let column of table?.config?.columns | keyvalue: columnOrder\">\n        <th\n          *ngIf=\"!column.value?.hidden\"\n          ngClass=\"{{ column.value?.sortable ? 'sort ' : '' }} {{ sortBy$ | async | sortClass: column.key }} {{\n            (column.key | dashCase) + '-column'\n          }} {{column.value.class}}\"\n          [class.disabled]=\"table.loading\"\n          (click)=\"table.loading || !column.value?.sortable || sort(column.key)\"\n        >\n          <span *ngIf=\"column.value?.header !== false\">{{ column.value?.header || column.key | capitalCase }}</span>\n        </th>\n      </ng-container>\n      <ng-container *ngIf=\"((table?.config?.rows | keyvalue: columnOrder)||[])[0] as headerRow\">\n        <th class=\"row-header\"\n            ngClass=\"{{ headerRow.value?.sortable ? 'sort ' : '' }} {{ sortBy$ | async | sortClass: headerRow.key }} {{\n            (headerRow.key | dashCase) + '-column'\n          }}\"\n            (click)=\"table.loading || !headerRow.value?.sortable || sort(headerRow.key)\">\n          <ng-container *ngIf=\"headerRow?.value?.header !== false\">{{headerRow?.value?.header || headerRow.key | capitalCase }}</ng-container>\n        </th>\n        <th *ngFor=\"let column of ((table$ | async)?.data || [])[0]\"  ngClass=\"{{headerRow.value?.class}}\">\n          <ng-container [ngTemplateOutlet]=\"(table.config?.rows || {})[headerRow.key].templateRef ? templateRef : (table.config?.rows || {})[headerRow.key].transform ? transformData:\n            rawData\" [ngTemplateOutletContext]=\"{row: column, column: headerRow, transform: (table.config?.rows || {})[headerRow.key].transform, templateRef: (table.config?.rows || {})[headerRow.key].templateRef, index: 0}\">\n          </ng-container>\n        </th>\n      </ng-container>\n    </tr>\n  </thead>\n  <tbody *ngIf=\"loading$ | async; else tableContent\">\n    <tr>\n      <td class=\"p-0\" [colSpan]=\"colspan$ | async\">\n        <ng-content select=\".table-loading\"></ng-content>\n      </td>\n    </tr>\n  </tbody>\n</table>\n<ng-template #tableContent>\n  <ng-container\n    *ngIf=\"(table$ | async)! as table\"\n  >\n    <tbody *ngIf=\"(table!.data![0] || table!.data!).length > 0; else noData\">\n      <ng-container *ngIf=\"table.config.columns\">\n        <tr *ngFor=\"let row of table!.data![(currentPage$ | async) || 0]; let i = index\" [attr.id]=\"'tableRow_' + i\">\n          <ng-container *ngFor=\"let column of table.config?.columns | keyvalue: columnOrder\">\n            <td *ngIf=\"!column.value?.hidden\" ngClass=\"{{(column.key | dashCase) + '-column'}} {{column.value?.class}}\">\n              <span *ngIf=\"column.value?.mobileHeader && table.config?.mobileLayout\" class=\"mobile-header\">{{ column.value?.mobileHeader !== true ? column.value?.mobileHeader : column.value?.header || column.key  | capitalCase }}</span>\n              <ng-container [ngTemplateOutlet]=\"(searchBy$ | async) && !(table.config?.columns || {})[column.key].templateRef ? highlighted:\n                (table.config?.columns || {})[column.key].templateRef ? templateRef : (table.config?.columns || {})[column.key].transform ? transformData:\n                rawData\" [ngTemplateOutletContext]=\"{row: row, column: column, search: (searchBy$ | async), transform: (table.config?.columns || {})[column.key].transform, templateRef: (table.config?.columns || {})[column.key].templateRef, index: i}\"></ng-container></td>\n          </ng-container>\n        </tr>\n      </ng-container>\n      <ng-container *ngIf=\"table.config.rows\">\n        <ng-container *ngFor=\"let row of table?.config?.rows | keyvalue: columnOrder | slice:1; let i = index\">\n          <tr *ngIf=\"!row.value?.hidden\" [attr.id]=\"'tableRow_' + i\" ngClass=\"{{(row.key | dashCase) + '-row'}}\">\n            <th class=\"row-header\">\n              <span *ngIf=\"row.value.mobileHeader\" class=\"mobile-header\">{{ row.value?.mobileHeader !== true ? row.value?.mobileHeader : row.value?.header || row.key  | capitalCase }}</span>\n              {{row.value?.header || row.key | capitalCase}}\n            </th>\n            <td *ngFor=\"let column of (table?.data || [])[0]\" ngClass=\"{{row.value?.class}}\">\n              <ng-container [ngTemplateOutlet]=\"(table.config?.rows || {})[row.key].templateRef ? templateRef : (table.config?.rows || {})[row.key].transform ? transformData:\n              rawData\" [ngTemplateOutletContext]=\"{row: column, column: row, transform: (table.config?.rows || {})[row.key].transform, templateRef: (table.config?.rows || {})[row.key].templateRef, index: i}\">\n              </ng-container>\n            </td>\n          </tr>\n        </ng-container>\n      </ng-container>\n    </tbody>\n  </ng-container>\n</ng-template>\n<ng-template #noData>\n  <tbody>\n  <tr>\n    <td class=\"p-0\" [colSpan]=\"colspan$ | async\">\n      <ng-content select=\".table-no-data\"></ng-content>\n    </td>\n  </tr>\n  </tbody>\n</ng-template>\n<ng-template #highlighted let-row=\"row\" let-column=\"column\" let-search=\"search\">\n  <div [innerHTML]=\"(row[column.key] | highlight: search)\"></div>\n</ng-template>\n<ng-template #rawData let-row=\"row\" let-column=\"column\">\n  {{row[column.key]}}\n</ng-template>\n<ng-template #transformData let-row=\"row\" let-column=\"column\" let-transform=\"transform\">\n  {{row[column.key] | dynamicPipe:transform.pipe:transform?.args}}\n</ng-template>\n<ng-template #templateRef let-row=\"row\" let-column=\"column\" let-index=\"index\" let-templateRef=\"templateRef\">\n  <ng-container [ngTemplateOutlet]=\"templateRef\"  [ngTemplateOutletContext]=\"{row: row, col: column, index: index}\"></ng-container>\n</ng-template>\n", directives: [{ type: i1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i1.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet"] }], pipes: { "async": i1.AsyncPipe, "keyvalue": i1.KeyValuePipe, "sortClass": i2.SortClassPipe, "dashCase": i3.DashCasePipe, "capitalCase": i4.CapitalCasePipe, "slice": i1.SlicePipe, "highlight": i5.HighlightPipe, "dynamicPipe": i6.DynamicPipe }, changeDetection: i0.ChangeDetectionStrategy.OnPush });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: CoreComponent, decorators: [{
-            type: Component,
-            args: [{ selector: 'angular-generic-table', styles: [], changeDetection: ChangeDetectionStrategy.OnPush, template: "<table [ngClass]=\"(tableConfig$ | async)?.class || 'table'\" [class.table-mobile]=\"(tableConfig$ | async)?.mobileLayout\">\n  <thead>\n    <tr *ngIf=\"{\n    config:(tableConfig$ | async)!,\n    loading: loading$ | async\n    } as table\">\n      <ng-container *ngFor=\"let column of table?.config?.columns | keyvalue: columnOrder\">\n        <th\n          *ngIf=\"!column.value?.hidden\"\n          ngClass=\"{{ column.value?.sortable ? 'sort ' : '' }} {{ sortBy$ | async | sortClass: column.key }} {{\n            (column.key | dashCase) + '-column'\n          }} {{column.value.class}}\"\n          [class.disabled]=\"table.loading\"\n          (click)=\"table.loading || !column.value?.sortable || sort(column.key)\"\n        >\n          <span *ngIf=\"column.value?.header !== false\">{{ column.value?.header || column.key | capitalCase }}</span>\n        </th>\n      </ng-container>\n      <ng-container *ngIf=\"((table?.config?.rows | keyvalue: columnOrder)||[])[0] as headerRow\">\n        <th class=\"row-header\"\n            ngClass=\"{{ headerRow.value?.sortable ? 'sort ' : '' }} {{ sortBy$ | async | sortClass: headerRow.key }} {{\n            (headerRow.key | dashCase) + '-column'\n          }}\"\n            (click)=\"table.loading || !headerRow.value?.sortable || sort(headerRow.key)\">\n          <ng-container *ngIf=\"headerRow?.value?.header !== false\">{{headerRow?.value?.header || headerRow.key | capitalCase }}</ng-container>\n        </th>\n        <th *ngFor=\"let column of ((table$ | async)?.data || [])[0]\"  ngClass=\"{{headerRow.value?.class}}\">\n          <ng-container [ngTemplateOutlet]=\"(table.config?.rows || {})[headerRow.key].templateRef ? templateRef : (table.config?.rows || {})[headerRow.key].transform ? transformData:\n            rawData\" [ngTemplateOutletContext]=\"{row: column, column: headerRow, transform: (table.config?.rows || {})[headerRow.key].transform, templateRef: (table.config?.rows || {})[headerRow.key].templateRef, index: 0}\">\n          </ng-container>\n        </th>\n      </ng-container>\n    </tr>\n  </thead>\n  <tbody *ngIf=\"loading$ | async; else tableContent\">\n    <tr>\n      <td class=\"p-0\" [colSpan]=\"colspan$ | async\">\n        <ng-content select=\".table-loading\"></ng-content>\n      </td>\n    </tr>\n  </tbody>\n</table>\n<ng-template #tableContent>\n  <ng-container\n    *ngIf=\"(table$ | async)! as table\"\n  >\n    <tbody *ngIf=\"(table!.data![0] || table!.data!).length > 0; else noData\">\n      <ng-container *ngIf=\"table.config.columns\">\n        <tr *ngFor=\"let row of table!.data![(currentPage$ | async) || 0]; let i = index\" [attr.id]=\"'tableRow_' + i\">\n          <ng-container *ngFor=\"let column of table.config?.columns | keyvalue: columnOrder\">\n            <td *ngIf=\"!column.value?.hidden\" ngClass=\"{{(column.key | dashCase) + '-column'}} {{column.value?.class}}\">\n              <span *ngIf=\"column.value?.mobileHeader && table.config?.mobileLayout\" class=\"mobile-header\">{{ column.value?.mobileHeader !== true ? column.value?.mobileHeader : column.value?.header || column.key  | capitalCase }}</span>\n              <ng-container [ngTemplateOutlet]=\"(searchBy$ | async) && !(table.config?.columns || {})[column.key].templateRef ? highlighted:\n                (table.config?.columns || {})[column.key].templateRef ? templateRef : (table.config?.columns || {})[column.key].transform ? transformData:\n                rawData\" [ngTemplateOutletContext]=\"{row: row, column: column, search: (searchBy$ | async), transform: (table.config?.columns || {})[column.key].transform, templateRef: (table.config?.columns || {})[column.key].templateRef, index: i}\"></ng-container></td>\n          </ng-container>\n        </tr>\n      </ng-container>\n      <ng-container *ngIf=\"table.config.rows\">\n        <ng-container *ngFor=\"let row of table?.config?.rows | keyvalue: columnOrder | slice:1; let i = index\">\n          <tr *ngIf=\"!row.value?.hidden\" [attr.id]=\"'tableRow_' + i\" ngClass=\"{{(row.key | dashCase) + '-row'}}\">\n            <th class=\"row-header\">\n              <span *ngIf=\"row.value.mobileHeader\" class=\"mobile-header\">{{ row.value?.mobileHeader !== true ? row.value?.mobileHeader : row.value?.header || row.key  | capitalCase }}</span>\n              {{row.value?.header || row.key | capitalCase}}\n            </th>\n            <td *ngFor=\"let column of (table?.data || [])[0]\" ngClass=\"{{row.value?.class}}\">\n              <ng-container [ngTemplateOutlet]=\"(table.config?.rows || {})[row.key].templateRef ? templateRef : (table.config?.rows || {})[row.key].transform ? transformData:\n              rawData\" [ngTemplateOutletContext]=\"{row: column, column: row, transform: (table.config?.rows || {})[row.key].transform, templateRef: (table.config?.rows || {})[row.key].templateRef, index: i}\">\n              </ng-container>\n            </td>\n          </tr>\n        </ng-container>\n      </ng-container>\n    </tbody>\n  </ng-container>\n</ng-template>\n<ng-template #noData>\n  <tbody>\n  <tr>\n    <td class=\"p-0\" [colSpan]=\"colspan$ | async\">\n      <ng-content select=\".table-no-data\"></ng-content>\n    </td>\n  </tr>\n  </tbody>\n</ng-template>\n<ng-template #highlighted let-row=\"row\" let-column=\"column\" let-search=\"search\">\n  <div [innerHTML]=\"(row[column.key] | highlight: search)\"></div>\n</ng-template>\n<ng-template #rawData let-row=\"row\" let-column=\"column\">\n  {{row[column.key]}}\n</ng-template>\n<ng-template #transformData let-row=\"row\" let-column=\"column\" let-transform=\"transform\">\n  {{row[column.key] | dynamicPipe:transform.pipe:transform?.args}}\n</ng-template>\n<ng-template #templateRef let-row=\"row\" let-column=\"column\" let-index=\"index\" let-templateRef=\"templateRef\">\n  <ng-container [ngTemplateOutlet]=\"templateRef\"  [ngTemplateOutletContext]=\"{row: row, col: column, index: index}\"></ng-container>\n</ng-template>\n" }]
-        }], propDecorators: { loading: [{
-                type: Input
-            }], page: [{
-                type: Input
-            }], search: [{
-                type: Input
-            }], config: [{
-                type: Input
-            }], data: [{
-                type: Input
-            }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"core.component.js","sourceRoot":"","sources":["../../../../projects/core/src/lib/core.component.ts","../../../../projects/core/src/lib/core.component.html"],"names":[],"mappings":"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","sourcesContent":["import { ChangeDetectionStrategy, Component, Input } from '@angular/core';\nimport { BehaviorSubject, combineLatest, EMPTY, isObservable, Observable, of, ReplaySubject, Subject } from 'rxjs';\nimport { TableConfig } from './models/table-config.interface';\nimport { KeyValue } from '@angular/common';\nimport { map, shareReplay, startWith, switchMap, withLatestFrom } from 'rxjs/operators';\nimport { TableColumn } from './models/table-column.interface';\nimport { Order } from './enums/order.enum';\nimport { chunk, search } from './utilities/utilities';\nimport { TableRow } from './models/table-row.interface';\nimport { TableSort } from './models/table-sort.interface';\nimport { TableMeta } from './models/table-meta.interface';\n\n@Component({\n  selector: 'angular-generic-table',\n  templateUrl: './core.component.html',\n  styles: [],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class CoreComponent {\n  @Input() set loading(value: Observable<boolean> | boolean) {\n    this._loading$.next(value);\n  }\n  @Input()\n  set page(value: number) {\n    this._currentPage$.next(value);\n  }\n\n  @Input()\n  set search(value: Observable<string> | string | null) {\n    this._searchBy$.next(value);\n  }\n\n  @Input()\n  set config(value: Observable<TableConfig> | TableConfig) {\n    this._tableConfig$.next(value);\n  }\n\n  @Input()\n  set data(value: Observable<Array<TableRow>> | Array<TableRow>) {\n    this._data$.next(value);\n  }\n\n  get loading$(): Observable<boolean> {\n    return this._loading$.pipe(\n      startWith(false),\n      map((value) => (isObservable(value) ? value : of(value))),\n      switchMap((obs) => obs),\n      shareReplay(1)\n    );\n  }\n\n  private _loading$: ReplaySubject<Observable<boolean> | boolean> = new ReplaySubject(1);\n  sortBy$: Subject<TableSort> = new Subject();\n  // tslint:disable-next-line:variable-name\n  private _sortBy: TableSort | undefined;\n\n  // tslint:disable-next-line:variable-name\n  private _searchBy$: ReplaySubject<Observable<string> | string | null> = new ReplaySubject(1);\n  searchBy$: Observable<string | null> = this._searchBy$.pipe(\n    startWith(''),\n    map((value) => (isObservable(value) ? value : of(value))),\n    switchMap((obs) => obs),\n    shareReplay(1)\n  );\n\n  // tslint:disable-next-line:variable-name\n  private _tableConfig$: ReplaySubject<TableConfig | Observable<TableConfig>> = new ReplaySubject(1);\n  tableConfig$: Observable<TableConfig> = this._tableConfig$.pipe(\n    map((value) => (isObservable(value) ? value : of(value))),\n    switchMap((obs) => obs),\n    shareReplay(1)\n  );\n\n  // tslint:disable-next-line:variable-name\n  private _data$: ReplaySubject<Array<TableRow> | Observable<Array<TableRow>>> = new ReplaySubject(1);\n  data$: Observable<Array<TableRow>> = this._data$.pipe(\n    map((value) => (isObservable(value) ? value : of(value))),\n    switchMap((obs) => combineLatest([obs, this.sortBy$.pipe(startWith(EMPTY)), this.searchBy$])),\n    withLatestFrom(this.tableConfig$),\n    map(([[data, sortBy, searchBy], config]) => {\n      // create a new array reference and sort new array (prevent mutating existing state)\n      data = [...data];\n      return !sortBy\n        ? searchBy\n          ? search(searchBy, false, data, config)\n          : data\n        : (searchBy ? search(searchBy, false, data, config) : data)?.sort((a, b) => {\n            // TODO: improve logic\n            const typed = sortBy as TableSort;\n            return a[typed.sortBy] > b[typed.sortBy]\n              ? typed.sortByOrder === Order.ASC\n                ? 1\n                : -1\n              : b[typed.sortBy] > a[typed.sortBy]\n              ? typed.sortByOrder === Order.ASC\n                ? -1\n                : 1\n              : 0;\n          });\n    }),\n    shareReplay(1)\n  );\n\n  table$: Observable<TableMeta> = combineLatest([this.data$, this.tableConfig$]).pipe(\n    map(([sorted, config]) => {\n      // if pagination is disabled...\n      if (!config.pagination || config.pagination.length === 0) {\n        // ...return unaltered array\n        return { data: [sorted], config, info: { records: sorted.length, pageTotal: 1 } };\n      }\n      // return record set\n      return {\n        data: chunk(sorted, +(config.pagination.length || 0)),\n        config,\n        info: {\n          records: sorted.length,\n          pageTotal: Math.ceil(sorted.length / +(config.pagination.length || 0)),\n        },\n      };\n    }),\n    shareReplay(1)\n  );\n\n  private _currentPage$: BehaviorSubject<number> = new BehaviorSubject(0);\n  currentPage$ = combineLatest([this._currentPage$, this.table$]).pipe(\n    map(([page, table]: any) => {\n      // determine last page\n      const lastPage = Math.ceil(table.info.records / (table.config?.pagination?.length || table.info.records)) - 1;\n      // determine max/min position\n      return +page < 0 ? 0 : +page > lastPage ? lastPage : +page;\n    }),\n    shareReplay(1)\n  );\n\n  colspan$ = this.tableConfig$.pipe(\n    switchMap((config) =>\n      config.columns\n        ? of(Object.values(config.columns || config.rows || {}).filter((value) => value.hidden !== true).length)\n        : this.data$.pipe(map((data) => data.length + 1))\n    )\n  );\n\n  sort(property: string): void {\n    const newSortOrder =\n      this._sortBy?.sortBy !== property || this._sortBy?.sortByOrder === Order.DESC || !this._sortBy.sortByOrder\n        ? Order.ASC\n        : Order.DESC;\n    const newSortBy = {\n      sortBy: property,\n      sortByOrder: newSortOrder,\n    };\n    this.sortBy$.next(newSortBy);\n    this._sortBy = newSortBy;\n  }\n\n  columnOrder = (a: KeyValue<string, TableColumn>, b: KeyValue<string, TableColumn>): number => {\n    return (a.value.order || 0) - (b.value.order || 0);\n  };\n}\n","<table [ngClass]=\"(tableConfig$ | async)?.class || 'table'\" [class.table-mobile]=\"(tableConfig$ | async)?.mobileLayout\">\n  <thead>\n    <tr *ngIf=\"{\n    config:(tableConfig$ | async)!,\n    loading: loading$ | async\n    } as table\">\n      <ng-container *ngFor=\"let column of table?.config?.columns | keyvalue: columnOrder\">\n        <th\n          *ngIf=\"!column.value?.hidden\"\n          ngClass=\"{{ column.value?.sortable ? 'sort ' : '' }} {{ sortBy$ | async | sortClass: column.key }} {{\n            (column.key | dashCase) + '-column'\n          }} {{column.value.class}}\"\n          [class.disabled]=\"table.loading\"\n          (click)=\"table.loading || !column.value?.sortable || sort(column.key)\"\n        >\n          <span *ngIf=\"column.value?.header !== false\">{{ column.value?.header || column.key | capitalCase }}</span>\n        </th>\n      </ng-container>\n      <ng-container *ngIf=\"((table?.config?.rows | keyvalue: columnOrder)||[])[0] as headerRow\">\n        <th class=\"row-header\"\n            ngClass=\"{{ headerRow.value?.sortable ? 'sort ' : '' }} {{ sortBy$ | async | sortClass: headerRow.key }} {{\n            (headerRow.key | dashCase) + '-column'\n          }}\"\n            (click)=\"table.loading || !headerRow.value?.sortable || sort(headerRow.key)\">\n          <ng-container *ngIf=\"headerRow?.value?.header !== false\">{{headerRow?.value?.header || headerRow.key | capitalCase }}</ng-container>\n        </th>\n        <th *ngFor=\"let column of ((table$ | async)?.data || [])[0]\"  ngClass=\"{{headerRow.value?.class}}\">\n          <ng-container [ngTemplateOutlet]=\"(table.config?.rows || {})[headerRow.key].templateRef ? templateRef : (table.config?.rows || {})[headerRow.key].transform ? transformData:\n            rawData\" [ngTemplateOutletContext]=\"{row: column, column: headerRow, transform: (table.config?.rows || {})[headerRow.key].transform, templateRef: (table.config?.rows || {})[headerRow.key].templateRef, index: 0}\">\n          </ng-container>\n        </th>\n      </ng-container>\n    </tr>\n  </thead>\n  <tbody *ngIf=\"loading$ | async; else tableContent\">\n    <tr>\n      <td class=\"p-0\" [colSpan]=\"colspan$ | async\">\n        <ng-content select=\".table-loading\"></ng-content>\n      </td>\n    </tr>\n  </tbody>\n</table>\n<ng-template #tableContent>\n  <ng-container\n    *ngIf=\"(table$ | async)! as table\"\n  >\n    <tbody *ngIf=\"(table!.data![0] || table!.data!).length > 0; else noData\">\n      <ng-container *ngIf=\"table.config.columns\">\n        <tr *ngFor=\"let row of table!.data![(currentPage$ | async) || 0]; let i = index\" [attr.id]=\"'tableRow_' + i\">\n          <ng-container *ngFor=\"let column of table.config?.columns | keyvalue: columnOrder\">\n            <td *ngIf=\"!column.value?.hidden\" ngClass=\"{{(column.key | dashCase) + '-column'}} {{column.value?.class}}\">\n              <span *ngIf=\"column.value?.mobileHeader && table.config?.mobileLayout\" class=\"mobile-header\">{{ column.value?.mobileHeader !== true ? column.value?.mobileHeader : column.value?.header || column.key  | capitalCase }}</span>\n              <ng-container [ngTemplateOutlet]=\"(searchBy$ | async) && !(table.config?.columns || {})[column.key].templateRef ? highlighted:\n                (table.config?.columns || {})[column.key].templateRef ? templateRef : (table.config?.columns || {})[column.key].transform ? transformData:\n                rawData\" [ngTemplateOutletContext]=\"{row: row, column: column, search: (searchBy$ | async), transform: (table.config?.columns || {})[column.key].transform, templateRef: (table.config?.columns || {})[column.key].templateRef, index: i}\"></ng-container></td>\n          </ng-container>\n        </tr>\n      </ng-container>\n      <ng-container *ngIf=\"table.config.rows\">\n        <ng-container *ngFor=\"let row of table?.config?.rows | keyvalue: columnOrder | slice:1; let i = index\">\n          <tr *ngIf=\"!row.value?.hidden\" [attr.id]=\"'tableRow_' + i\" ngClass=\"{{(row.key | dashCase) + '-row'}}\">\n            <th class=\"row-header\">\n              <span *ngIf=\"row.value.mobileHeader\" class=\"mobile-header\">{{ row.value?.mobileHeader !== true ? row.value?.mobileHeader : row.value?.header || row.key  | capitalCase }}</span>\n              {{row.value?.header || row.key | capitalCase}}\n            </th>\n            <td *ngFor=\"let column of (table?.data || [])[0]\" ngClass=\"{{row.value?.class}}\">\n              <ng-container [ngTemplateOutlet]=\"(table.config?.rows || {})[row.key].templateRef ? templateRef : (table.config?.rows || {})[row.key].transform ? transformData:\n              rawData\" [ngTemplateOutletContext]=\"{row: column, column: row, transform: (table.config?.rows || {})[row.key].transform, templateRef: (table.config?.rows || {})[row.key].templateRef, index: i}\">\n              </ng-container>\n            </td>\n          </tr>\n        </ng-container>\n      </ng-container>\n    </tbody>\n  </ng-container>\n</ng-template>\n<ng-template #noData>\n  <tbody>\n  <tr>\n    <td class=\"p-0\" [colSpan]=\"colspan$ | async\">\n      <ng-content select=\".table-no-data\"></ng-content>\n    </td>\n  </tr>\n  </tbody>\n</ng-template>\n<ng-template #highlighted let-row=\"row\" let-column=\"column\" let-search=\"search\">\n  <div [innerHTML]=\"(row[column.key] | highlight: search)\"></div>\n</ng-template>\n<ng-template #rawData let-row=\"row\" let-column=\"column\">\n  {{row[column.key]}}\n</ng-template>\n<ng-template #transformData let-row=\"row\" let-column=\"column\" let-transform=\"transform\">\n  {{row[column.key] | dynamicPipe:transform.pipe:transform?.args}}\n</ng-template>\n<ng-template #templateRef let-row=\"row\" let-column=\"column\" let-index=\"index\" let-templateRef=\"templateRef\">\n  <ng-container [ngTemplateOutlet]=\"templateRef\"  [ngTemplateOutletContext]=\"{row: row, col: column, index: index}\"></ng-container>\n</ng-template>\n"]}

package/esm2020/lib/core.module.mjs

@@ -1,23 +0,0 @@
-import { NgModule } from '@angular/core';
-import { CoreComponent } from './core.component';
-import { CommonModule } from '@angular/common';
-import { SortClassPipe } from './pipes/sort-class.pipe';
-import { DashCasePipe } from './pipes/dash-case.pipe';
-import { HighlightPipe } from './pipes/highlight.pipe';
-import { CapitalCasePipe } from './pipes/capital-case.pipe';
-import { DynamicPipe } from './pipes/dynamic.pipe';
-import * as i0 from "@angular/core";
-export class GenericTableCoreModule {
-}
-GenericTableCoreModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: GenericTableCoreModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-GenericTableCoreModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: GenericTableCoreModule, declarations: [CoreComponent, SortClassPipe, DashCasePipe, HighlightPipe, CapitalCasePipe, CapitalCasePipe, DynamicPipe], imports: [CommonModule], exports: [CoreComponent] });
-GenericTableCoreModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: GenericTableCoreModule, imports: [[CommonModule]] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: GenericTableCoreModule, decorators: [{
-            type: NgModule,
-            args: [{
-                    declarations: [CoreComponent, SortClassPipe, DashCasePipe, HighlightPipe, CapitalCasePipe, CapitalCasePipe, DynamicPipe],
-                    imports: [CommonModule],
-                    exports: [CoreComponent],
-                }]
-        }] });
-//# sourceMappingURL=data:application/json;base64,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