@den4ik92/ng2-smart-table 1.0.0

package/esm2020/lib/lib/grid.mjs

@@ -0,0 +1,220 @@
+import { Subject } from 'rxjs';
+import { Deferred, getDeepFromObject, getPageForRowIndex } from './helpers';
+import { DataSet } from './data-set/data-set';
+export class Grid {
+    constructor(source, settings) {
+        this.createFormShown = false;
+        this.onSelectRowSource = new Subject();
+        this.onDeselectRowSource = new Subject();
+        this.setSettings(settings);
+        this.setSource(source);
+    }
+    detach() {
+        if (this.sourceOnChangedSubscription) {
+            this.sourceOnChangedSubscription.unsubscribe();
+        }
+        if (this.sourceOnUpdatedSubscription) {
+            this.sourceOnUpdatedSubscription.unsubscribe();
+        }
+    }
+    showActionColumn(position) {
+        return this.isCurrentActionsPosition(position) && this.isActionsVisible();
+    }
+    isCurrentActionsPosition(position) {
+        return position == this.getSetting('actions.position');
+    }
+    isActionsVisible() {
+        return this.getSetting('actions.add') || this.getSetting('actions.edit') || this.getSetting('actions.delete') || this.getSetting('actions.custom').length;
+    }
+    isMultiSelectVisible() {
+        return this.getSetting('selectMode') === 'multi';
+    }
+    getNewRow() {
+        return this.dataSet.newRow;
+    }
+    setSettings(settings) {
+        this.settings = settings;
+        this.dataSet = new DataSet([], this.getSetting('columns'));
+        if (this.source) {
+            this.source.refresh();
+        }
+    }
+    getDataSet() {
+        return this.dataSet;
+    }
+    setSource(source) {
+        this.source = this.prepareSource(source);
+        this.detach();
+        this.sourceOnChangedSubscription = this.source.onChanged().subscribe((changes) => this.processDataChange(changes));
+        this.sourceOnUpdatedSubscription = this.source.onUpdated().subscribe((data) => {
+            const changedRow = this.dataSet.findRowByData(data);
+            changedRow.setData(data);
+        });
+    }
+    getSetting(name, defaultValue) {
+        return getDeepFromObject(this.settings, name, defaultValue);
+    }
+    getColumns() {
+        return this.dataSet.getColumns();
+    }
+    getRows() {
+        return this.dataSet.getRows();
+    }
+    selectRow(row, state) {
+        this.dataSet.selectRow(row, state);
+    }
+    multipleSelectRow(row) {
+        this.dataSet.multipleSelectRow(row);
+    }
+    onSelectRow() {
+        return this.onSelectRowSource.asObservable();
+    }
+    onDeselectRow() {
+        return this.onDeselectRowSource.asObservable();
+    }
+    edit(row) {
+        row.isInEditing = true;
+    }
+    create(row, confirmEmitter) {
+        const deferred = new Deferred();
+        deferred.promise.then((newData) => {
+            newData = newData ? newData : row.getNewData();
+            if (deferred.resolve.skipAdd) {
+                this.createFormShown = false;
+            }
+            else {
+                this.source.prepend(newData).then(() => {
+                    this.createFormShown = false;
+                    this.dataSet.createNewRow();
+                });
+            }
+        }).catch((err) => {
+            // doing nothing
+        });
+        if (this.getSetting('add.confirmCreate')) {
+            confirmEmitter.emit({
+                newData: row.getNewData(),
+                source: this.source,
+                confirm: deferred,
+            });
+        }
+        else {
+            deferred.resolve();
+        }
+    }
+    save(row, confirmEmitter) {
+        const deferred = new Deferred();
+        deferred.promise.then((newData) => {
+            newData = newData ? newData : row.getNewData();
+            if (deferred.resolve.skipEdit) {
+                row.isInEditing = false;
+            }
+            else {
+                this.source.update(row.getData(), newData).then(() => {
+                    row.isInEditing = false;
+                });
+            }
+        }).catch((err) => {
+            // doing nothing
+        });
+        if (this.getSetting('edit.confirmSave')) {
+            confirmEmitter.emit({
+                data: row.getData(),
+                newData: row.getNewData(),
+                source: this.source,
+                confirm: deferred,
+            });
+        }
+        else {
+            deferred.resolve();
+        }
+    }
+    delete(row, confirmEmitter) {
+        const deferred = new Deferred();
+        deferred.promise.then(() => {
+            this.source.remove(row.getData());
+        }).catch((err) => {
+            // doing nothing
+        });
+        if (this.getSetting('delete.confirmDelete')) {
+            confirmEmitter.emit({
+                data: row.getData(),
+                source: this.source,
+                confirm: deferred,
+            });
+        }
+        else {
+            deferred.resolve();
+        }
+        if (row.isSelected) {
+            this.dataSet.selectRow(row, false);
+        }
+    }
+    processDataChange(changes) {
+        if (this.shouldProcessChange(changes)) {
+            if (changes['action'] === 'load') {
+                this.dataSet.deselectAll();
+            }
+            this.dataSet.setData(changes['elements']);
+        }
+    }
+    shouldProcessChange(changes) {
+        if (['filter', 'sort', 'page', 'remove', 'refresh', 'load', 'paging'].indexOf(changes['action']) !== -1) {
+            return true;
+        }
+        else if (['prepend', 'append'].indexOf(changes['action']) !== -1 && !this.getSetting('pager.display')) {
+            return true;
+        }
+        return false;
+    }
+    prepareSource(source) {
+        const initialSource = this.getInitialSort();
+        if (initialSource && initialSource['field'] && initialSource['direction']) {
+            source.setSort([initialSource], false);
+        }
+        if (this.getSetting('pager.display') === true) {
+            source.setPaging(this.getPageToSelect(source), this.getSetting('pager.perPage'), false);
+        }
+        source.refresh();
+        return source;
+    }
+    getInitialSort() {
+        const sortConf = {};
+        this.getColumns().forEach((column) => {
+            if (column.isSortable && column.defaultSortDirection) {
+                sortConf['field'] = column.id;
+                sortConf['direction'] = column.defaultSortDirection;
+                sortConf['compare'] = column.getCompareFunction();
+            }
+        });
+        return sortConf;
+    }
+    getSelectedRowsData() {
+        return this.dataSet.getRows();
+    }
+    selectAllRows(status) {
+        this.dataSet.setSelectAll(status);
+    }
+    getFirstRow() {
+        return this.dataSet.getFirstRow();
+    }
+    getLastRow() {
+        return this.dataSet.getLastRow();
+    }
+    getSelectionInfo() {
+        const switchPageToSelectedRowPage = this.getSetting('switchPageToSelectedRowPage');
+        const selectedRowIndex = Number(this.getSetting('selectedRowIndex', 0)) || 0;
+        const { perPage, page } = this.getSetting('pager');
+        return { perPage, page, selectedRowIndex, switchPageToSelectedRowPage };
+    }
+    getPageToSelect(source) {
+        const { switchPageToSelectedRowPage, selectedRowIndex, perPage, page } = this.getSelectionInfo();
+        let pageToSelect = Math.max(1, page);
+        if (switchPageToSelectedRowPage && selectedRowIndex >= 0) {
+            pageToSelect = getPageForRowIndex(selectedRowIndex, perPage);
+        }
+        const maxPageAmount = Math.ceil(source.count() / perPage);
+        return maxPageAmount ? Math.min(pageToSelect, maxPageAmount) : pageToSelect;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"grid.js","sourceRoot":"","sources":["../../../../../projects/ng2-smart-table/src/lib/lib/grid.ts"],"names":[],"mappings":"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","sourcesContent":["import { Subject, Subscription } from 'rxjs';\nimport { Observable } from 'rxjs';\nimport { EventEmitter } from '@angular/core';\n\nimport { Deferred, getDeepFromObject, getPageForRowIndex } from './helpers';\nimport { Column } from './data-set/column';\nimport { Row } from './data-set/row';\nimport { DataSet } from './data-set/data-set';\nimport { DataSource } from './data-source/data-source';\nimport { SmartTableSettings } from './interfaces/smart-table.models';\n\nexport class Grid {\n\n  createFormShown: boolean = false;\n\n  source: DataSource;\n  settings: SmartTableSettings;\n  dataSet: DataSet;\n\n  onSelectRowSource = new Subject<any>();\n  onDeselectRowSource = new Subject<any>();\n\n  private sourceOnChangedSubscription: Subscription;\n  private sourceOnUpdatedSubscription: Subscription;\n\n  constructor(source: DataSource, settings: SmartTableSettings) {\n    this.setSettings(settings);\n    this.setSource(source);\n  }\n\n  detach(): void {\n    if (this.sourceOnChangedSubscription) {\n      this.sourceOnChangedSubscription.unsubscribe();\n    }\n    if (this.sourceOnUpdatedSubscription) {\n      this.sourceOnUpdatedSubscription.unsubscribe();\n    }\n  }\n\n  showActionColumn(position: string): boolean {\n    return this.isCurrentActionsPosition(position) && this.isActionsVisible();\n  }\n\n  isCurrentActionsPosition(position: string): boolean {\n    return position == this.getSetting('actions.position');\n  }\n\n  isActionsVisible(): boolean {\n    return this.getSetting('actions.add') || this.getSetting('actions.edit') || this.getSetting('actions.delete') || this.getSetting('actions.custom').length;\n  }\n\n  isMultiSelectVisible(): boolean {\n    return this.getSetting('selectMode') === 'multi';\n  }\n\n  getNewRow(): Row {\n    return this.dataSet.newRow;\n  }\n\n  setSettings(settings: SmartTableSettings) {\n    this.settings = settings;\n    this.dataSet = new DataSet([], this.getSetting('columns'));\n\n    if (this.source) {\n      this.source.refresh();\n    }\n  }\n\n  getDataSet(): DataSet {\n    return this.dataSet;\n  }\n\n  setSource(source: DataSource) {\n    this.source = this.prepareSource(source);\n    this.detach();\n\n    this.sourceOnChangedSubscription = this.source.onChanged().subscribe((changes: any) => this.processDataChange(changes));\n\n    this.sourceOnUpdatedSubscription = this.source.onUpdated().subscribe((data: any) => {\n      const changedRow = this.dataSet.findRowByData(data);\n      changedRow.setData(data);\n    });\n  }\n\n  getSetting(name: string, defaultValue?: any): any {\n    return getDeepFromObject(this.settings, name, defaultValue);\n  }\n\n  getColumns(): Array<Column> {\n    return this.dataSet.getColumns();\n  }\n\n  getRows(): Array<Row> {\n    return this.dataSet.getRows();\n  }\n\n  selectRow(row: Row, state: boolean) {\n    this.dataSet.selectRow(row, state);\n  }\n\n  multipleSelectRow(row: Row) {\n    this.dataSet.multipleSelectRow(row);\n  }\n\n  onSelectRow(): Observable<any> {\n    return this.onSelectRowSource.asObservable();\n  }\n\n  onDeselectRow(): Observable<any> {\n    return this.onDeselectRowSource.asObservable();\n  }\n\n  edit(row: Row) {\n    row.isInEditing = true;\n  }\n\n  create(row: Row, confirmEmitter: EventEmitter<any>) {\n\n    const deferred = new Deferred();\n    deferred.promise.then((newData) => {\n      newData = newData ? newData : row.getNewData();\n      if (deferred.resolve.skipAdd) {\n        this.createFormShown = false;\n      } else {\n        this.source.prepend(newData).then(() => {\n          this.createFormShown = false;\n          this.dataSet.createNewRow();\n        });\n      }\n    }).catch((err) => {\n      // doing nothing\n    });\n\n    if (this.getSetting('add.confirmCreate')) {\n      confirmEmitter.emit({\n        newData: row.getNewData(),\n        source: this.source,\n        confirm: deferred,\n      });\n    } else {\n      deferred.resolve();\n    }\n  }\n\n  save(row: Row, confirmEmitter: EventEmitter<any>) {\n\n    const deferred = new Deferred();\n    deferred.promise.then((newData) => {\n      newData = newData ? newData : row.getNewData();\n      if (deferred.resolve.skipEdit) {\n        row.isInEditing = false;\n      } else {\n        this.source.update(row.getData(), newData).then(() => {\n          row.isInEditing = false;\n        });\n      }\n    }).catch((err) => {\n      // doing nothing\n    });\n\n    if (this.getSetting('edit.confirmSave')) {\n      confirmEmitter.emit({\n        data: row.getData(),\n        newData: row.getNewData(),\n        source: this.source,\n        confirm: deferred,\n      });\n    } else {\n      deferred.resolve();\n    }\n  }\n\n  delete(row: Row, confirmEmitter: EventEmitter<any>) {\n    const deferred = new Deferred();\n    deferred.promise.then(() => {\n      this.source.remove(row.getData());\n    }).catch((err) => {\n      // doing nothing\n    });\n\n    if (this.getSetting('delete.confirmDelete')) {\n      confirmEmitter.emit({\n        data: row.getData(),\n        source: this.source,\n        confirm: deferred,\n      });\n    } else {\n      deferred.resolve();\n    }\n    if(row.isSelected) {\n      this.dataSet.selectRow(row, false);\n    }\n  }\n\n  processDataChange(changes: any) {\n    if (this.shouldProcessChange(changes)) {\n      if(changes['action'] === 'load') {\n        this.dataSet.deselectAll()\n      }\n      this.dataSet.setData(changes['elements']);\n    }\n  }\n\n  shouldProcessChange(changes: any): boolean {\n    if (['filter', 'sort', 'page', 'remove', 'refresh', 'load', 'paging'].indexOf(changes['action']) !== -1) {\n      return true;\n    } else if (['prepend', 'append'].indexOf(changes['action']) !== -1 && !this.getSetting('pager.display')) {\n      return true;\n    }\n    return false;\n  }\n\n  prepareSource(source: any): DataSource {\n    const initialSource: any = this.getInitialSort();\n    if (initialSource && initialSource['field'] && initialSource['direction']) {\n      source.setSort([initialSource], false);\n    }\n    if (this.getSetting('pager.display') === true) {\n      source.setPaging(this.getPageToSelect(source), this.getSetting('pager.perPage'), false);\n    }\n\n    source.refresh();\n    return source;\n  }\n\n  getInitialSort() {\n    const sortConf: any = {};\n    this.getColumns().forEach((column: Column) => {\n      if (column.isSortable && column.defaultSortDirection) {\n        sortConf['field'] = column.id;\n        sortConf['direction'] = column.defaultSortDirection;\n        sortConf['compare'] = column.getCompareFunction();\n      }\n    });\n    return sortConf;\n  }\n\n  getSelectedRowsData(): Array<any> {\n    return this.dataSet.getRows()\n  }\n\n  selectAllRows(status: boolean) {\n    this.dataSet.setSelectAll(status);\n  }\n\n  getFirstRow(): Row {\n    return this.dataSet.getFirstRow();\n  }\n\n  getLastRow(): Row {\n    return this.dataSet.getLastRow();\n  }\n\n  private getSelectionInfo(): { perPage: number, page: number, selectedRowIndex: number, switchPageToSelectedRowPage: boolean } {\n    const switchPageToSelectedRowPage: boolean = this.getSetting('switchPageToSelectedRowPage');\n    const selectedRowIndex: number = Number(this.getSetting('selectedRowIndex', 0)) || 0;\n    const { perPage, page }: { perPage: number, page: number } = this.getSetting('pager');\n    return { perPage, page, selectedRowIndex, switchPageToSelectedRowPage };\n  }\n\n  private getPageToSelect(source: DataSource): number {\n    const { switchPageToSelectedRowPage, selectedRowIndex, perPage, page } = this.getSelectionInfo();\n    let pageToSelect: number = Math.max(1, page);\n    if (switchPageToSelectedRowPage && selectedRowIndex >= 0) {\n      pageToSelect = getPageForRowIndex(selectedRowIndex, perPage);\n    }\n    const maxPageAmount: number = Math.ceil(source.count() / perPage);\n    return maxPageAmount ? Math.min(pageToSelect, maxPageAmount) : pageToSelect;\n  }\n}\n"]}

package/esm2020/lib/lib/helpers.mjs

@@ -0,0 +1,84 @@
+/**
+ * Extending object that entered in first argument.
+ *
+ * Returns extended object or false if have no target object or incorrect type.
+ *
+ * If you wish to clone source object (without modify it), just use empty new
+ * object as first argument, like this:
+ *   deepExtend({}, yourObj_1, [yourObj_N]);
+ */
+export const deepExtend = function (...objects) {
+    if (arguments.length < 1 || typeof arguments[0] !== 'object') {
+        return false;
+    }
+    if (arguments.length < 2) {
+        return arguments[0];
+    }
+    const target = arguments[0];
+    // convert arguments to array and cut off target object
+    const args = Array.prototype.slice.call(arguments, 1);
+    let val, src;
+    args.forEach((obj) => {
+        // skip argument if it is array or isn't object
+        if (typeof obj !== 'object' || Array.isArray(obj)) {
+            return;
+        }
+        Object.keys(obj).forEach(function (key) {
+            src = target[key]; // source value
+            val = obj[key]; // new value
+            // recursion prevention
+            if (val === target) {
+                return;
+                /**
+                 * if new value isn't object then just overwrite by new value
+                 * instead of extending.
+                 */
+            }
+            else if (typeof val !== 'object' || val === null) {
+                target[key] = val;
+                return;
+                // just clone arrays (and recursive clone objects inside)
+            }
+            else if (Array.isArray(val)) {
+                target[key] = [...val];
+                return;
+                // overwrite by new value if source isn't object or array
+            }
+            else if (typeof src !== 'object' || src === null || Array.isArray(src)) {
+                target[key] = deepExtend({}, val);
+                return;
+                // source value and new value is objects both, extending...
+            }
+            else {
+                target[key] = deepExtend(src, val);
+                return;
+            }
+        });
+    });
+    return target;
+};
+export class Deferred {
+    constructor() {
+        this.promise = new Promise((resolve, reject) => {
+            this.resolve = resolve;
+            this.reject = reject;
+        });
+    }
+}
+// getDeepFromObject({result: {data: 1}}, 'result.data', 2); // returns 1
+export function getDeepFromObject(object = {}, name, defaultValue) {
+    const keys = name.split('.');
+    // clone the object
+    let level = deepExtend({}, object);
+    keys.forEach((k) => {
+        if (level && typeof level[k] !== 'undefined') {
+            level = level[k];
+        }
+    });
+    return typeof level === 'undefined' ? defaultValue : level;
+}
+export function getPageForRowIndex(index, perPage) {
+    // we need to add 1 to convert 0-based index to 1-based page number.
+    return Math.floor(index / perPage) + 1;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/lib/interfaces/smart-table.models.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/ng2-smart-table.component.mjs

@@ -0,0 +1,203 @@
+import { Component, Input, Output, EventEmitter } from '@angular/core';
+import { Grid } from './lib/grid';
+import { DataSource } from './lib/data-source/data-source';
+import { deepExtend } from './lib/helpers';
+import { LocalDataSource } from './lib/data-source/local/local.data-source';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "./components/pager/pager.component";
+import * as i3 from "./components/tbody/tbody.component";
+import * as i4 from "./components/thead/thead.component";
+function Ng2SmartTableComponent_thead_1_Template(rf, ctx) { if (rf & 1) {
+    const _r3 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementStart(0, "thead", 4);
+    i0.ɵɵlistener("create", function Ng2SmartTableComponent_thead_1_Template_thead_create_0_listener($event) { i0.ɵɵrestoreView(_r3); const ctx_r2 = i0.ɵɵnextContext(); return i0.ɵɵresetView(ctx_r2.create.emit($event)); })("selectAllRows", function Ng2SmartTableComponent_thead_1_Template_thead_selectAllRows_0_listener() { i0.ɵɵrestoreView(_r3); const ctx_r4 = i0.ɵɵnextContext(); return i0.ɵɵresetView(ctx_r4.onSelectAllRows()); });
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const ctx_r0 = i0.ɵɵnextContext();
+    i0.ɵɵproperty("grid", ctx_r0.grid)("source", ctx_r0.source)("createConfirm", ctx_r0.createConfirm);
+} }
+function Ng2SmartTableComponent_ng2_smart_table_pager_3_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelement(0, "ng2-smart-table-pager", 5);
+} if (rf & 2) {
+    const ctx_r1 = i0.ɵɵnextContext();
+    i0.ɵɵproperty("source", ctx_r1.source)("perPageSelect", ctx_r1.perPageSelect);
+} }
+export class Ng2SmartTableComponent {
+    constructor() {
+        this.multiRowSelect = new EventEmitter();
+        this.rowClicked = new EventEmitter();
+        this.delete = new EventEmitter();
+        this.edit = new EventEmitter();
+        this.create = new EventEmitter();
+        this.custom = new EventEmitter();
+        this.deleteConfirm = new EventEmitter();
+        this.editConfirm = new EventEmitter();
+        this.createConfirm = new EventEmitter();
+        this.rowHover = new EventEmitter();
+        this.defaultSettings = {
+            mode: 'inline',
+            selectMode: 'single',
+            /**
+             * Points to an element in all data
+             *
+             * when < 0 all lines must be deselected
+             */
+            selectedRowIndex: 0,
+            switchPageToSelectedRowPage: false,
+            hideHeader: false,
+            hideSubHeader: false,
+            actions: {
+                columnTitle: 'Actions',
+                add: true,
+                edit: true,
+                delete: true,
+                custom: [],
+                position: 'left', // left|right
+            },
+            filter: {
+                inputClass: '',
+            },
+            edit: {
+                inputClass: '',
+                editButtonContent: 'Edit',
+                saveButtonContent: 'Update',
+                cancelButtonContent: 'Cancel',
+                confirmSave: false,
+            },
+            add: {
+                inputClass: '',
+                addButtonContent: 'Add New',
+                createButtonContent: 'Create',
+                cancelButtonContent: 'Cancel',
+                confirmCreate: false,
+            },
+            delete: {
+                deleteButtonContent: 'Delete',
+                confirmDelete: false,
+            },
+            attr: {
+                id: '',
+                class: '',
+            },
+            noDataMessage: 'No data found',
+            columns: {},
+            pager: {
+                display: true,
+                page: 1,
+                perPage: 10,
+            },
+            rowClassFunction: () => '',
+        };
+    }
+    ngOnChanges(changes) {
+        if (this.grid) {
+            if (changes['settings']) {
+                this.grid.setSettings(this.prepareSettings());
+            }
+            if (changes['source']) {
+                this.source = this.prepareSource();
+                this.grid.setSource(this.source);
+            }
+        }
+        else {
+            this.initGrid();
+        }
+        this.tableId = this.grid.getSetting('attr.id');
+        this.tableClass = this.grid.getSetting('attr.class');
+        this.isHideHeader = this.grid.getSetting('hideHeader');
+        this.isHideSubHeader = this.grid.getSetting('hideSubHeader');
+        this.isPagerDisplay = this.grid.getSetting('pager.display');
+        this.isPagerDisplay = this.grid.getSetting('pager.display');
+        this.perPageSelect = this.grid.getSetting('pager.perPageSelect');
+        this.rowClassFunction = this.grid.getSetting('rowClassFunction');
+    }
+    onRowHover(row) {
+        this.rowHover.emit(row);
+    }
+    multipleSelectRow(row) {
+        this.grid.multipleSelectRow(row);
+        this.emitUserSelectRow(row);
+    }
+    onSelectAllRows() {
+        this.grid.dataSet.isAllSelected;
+        this.grid.selectAllRows(!this.grid.dataSet.isAllSelected);
+        this.emitUserSelectRow(null);
+    }
+    onSelectRow(row, state) {
+        this.grid.selectRow(row, state);
+    }
+    initGrid() {
+        this.source = this.prepareSource();
+        this.grid = new Grid(this.source, this.prepareSettings());
+    }
+    prepareSource() {
+        if (this.source instanceof DataSource) {
+            return this.source;
+        }
+        return new LocalDataSource();
+    }
+    prepareSettings() {
+        return deepExtend({}, this.defaultSettings, this.settings);
+    }
+    emitUserSelectRow(row) {
+        this.multiRowSelect.emit({
+            data: row ? row.getData() : null,
+            isSelected: row ? row.getIsSelected() : null,
+            source: this.source,
+            selected: this.grid.dataSet.getSelectedRowsData(),
+        });
+    }
+    emitUserRowClicked(row) {
+        this.rowClicked.emit({
+            data: row ? row.getData() : null,
+            source: this.source,
+        });
+    }
+}
+Ng2SmartTableComponent.ɵfac = function Ng2SmartTableComponent_Factory(t) { return new (t || Ng2SmartTableComponent)(); };
+Ng2SmartTableComponent.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: Ng2SmartTableComponent, selectors: [["ng2-smart-table"]], inputs: { source: "source", settings: "settings" }, outputs: { multiRowSelect: "multiRowSelect", rowClicked: "rowClicked", delete: "delete", edit: "edit", create: "create", custom: "custom", deleteConfirm: "deleteConfirm", editConfirm: "editConfirm", createConfirm: "createConfirm", rowHover: "rowHover" }, features: [i0.ɵɵNgOnChangesFeature], decls: 4, vars: 9, consts: [[3, "id", "ngClass"], ["ng2-st-thead", "", 3, "grid", "source", "createConfirm", "create", "selectAllRows", 4, "ngIf"], ["ng2-st-tbody", "", 3, "grid", "source", "deleteConfirm", "editConfirm", "rowClassFunction", "edit", "delete", "custom", "userClickedRow", "multipleSelectRow", "rowHover"], [3, "source", "perPageSelect", 4, "ngIf"], ["ng2-st-thead", "", 3, "grid", "source", "createConfirm", "create", "selectAllRows"], [3, "source", "perPageSelect"]], template: function Ng2SmartTableComponent_Template(rf, ctx) { if (rf & 1) {
+        i0.ɵɵelementStart(0, "table", 0);
+        i0.ɵɵtemplate(1, Ng2SmartTableComponent_thead_1_Template, 1, 3, "thead", 1);
+        i0.ɵɵelementStart(2, "tbody", 2);
+        i0.ɵɵlistener("edit", function Ng2SmartTableComponent_Template_tbody_edit_2_listener($event) { return ctx.edit.emit($event); })("delete", function Ng2SmartTableComponent_Template_tbody_delete_2_listener($event) { return ctx.delete.emit($event); })("custom", function Ng2SmartTableComponent_Template_tbody_custom_2_listener($event) { return ctx.custom.emit($event); })("userClickedRow", function Ng2SmartTableComponent_Template_tbody_userClickedRow_2_listener($event) { return ctx.emitUserRowClicked($event); })("multipleSelectRow", function Ng2SmartTableComponent_Template_tbody_multipleSelectRow_2_listener($event) { return ctx.multipleSelectRow($event); })("rowHover", function Ng2SmartTableComponent_Template_tbody_rowHover_2_listener($event) { return ctx.onRowHover($event); });
+        i0.ɵɵelementEnd()();
+        i0.ɵɵtemplate(3, Ng2SmartTableComponent_ng2_smart_table_pager_3_Template, 1, 2, "ng2-smart-table-pager", 3);
+    } if (rf & 2) {
+        i0.ɵɵproperty("id", ctx.tableId)("ngClass", ctx.tableClass);
+        i0.ɵɵadvance(1);
+        i0.ɵɵproperty("ngIf", !ctx.isHideHeader || !ctx.isHideSubHeader);
+        i0.ɵɵadvance(1);
+        i0.ɵɵproperty("grid", ctx.grid)("source", ctx.source)("deleteConfirm", ctx.deleteConfirm)("editConfirm", ctx.editConfirm)("rowClassFunction", ctx.rowClassFunction);
+        i0.ɵɵadvance(1);
+        i0.ɵɵproperty("ngIf", ctx.isPagerDisplay);
+    } }, dependencies: [i1.NgClass, i1.NgIf, i2.PagerComponent, i3.Ng2SmartTableTbodyComponent, i4.Ng2SmartTableTheadComponent], styles: ["[_nghost-%COMP%]{font-size:1rem}[_nghost-%COMP%]     *{box-sizing:border-box}[_nghost-%COMP%]     button, [_nghost-%COMP%]     input, [_nghost-%COMP%]     optgroup, [_nghost-%COMP%]     select, [_nghost-%COMP%]     textarea{color:inherit;font:inherit;margin:0}[_nghost-%COMP%]     table{line-height:1.5em;border-collapse:collapse;border-spacing:0;display:table;width:100%;max-width:100%;overflow:auto;word-break:normal;word-break:keep-all}[_nghost-%COMP%]     table tr th{font-weight:700}[_nghost-%COMP%]     table tr section{font-size:.75em;font-weight:700}[_nghost-%COMP%]     table tr td, [_nghost-%COMP%]     table tr th{font-size:.875em;margin:0;padding:.5em 1em}[_nghost-%COMP%]     a{color:#1e6bb8;text-decoration:none}[_nghost-%COMP%]     a:hover{text-decoration:underline}"] });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(Ng2SmartTableComponent, [{
+        type: Component,
+        args: [{ selector: 'ng2-smart-table', template: "<table [id]=\"tableId\" [ngClass]=\"tableClass\">\n\n  <thead ng2-st-thead *ngIf=\"!isHideHeader || !isHideSubHeader\"\n                      [grid]=\"grid\"\n                      [source]=\"source\"\n                      [createConfirm]=\"createConfirm\"\n                      (create)=\"create.emit($event)\"\n                      (selectAllRows)=\"onSelectAllRows()\">\n  </thead>\n\n  <tbody ng2-st-tbody [grid]=\"grid\"\n                      [source]=\"source\"\n                      [deleteConfirm]=\"deleteConfirm\"\n                      [editConfirm]=\"editConfirm\"\n                      [rowClassFunction]=\"rowClassFunction\"\n                      (edit)=\"edit.emit($event)\"\n                      (delete)=\"delete.emit($event)\"\n                      (custom)=\"custom.emit($event)\"\n                      (userClickedRow)=\"emitUserRowClicked($event)\"\n                      (multipleSelectRow)=\"multipleSelectRow($event)\"\n                      (rowHover)=\"onRowHover($event)\">\n  </tbody>\n\n</table>\n\n<ng2-smart-table-pager *ngIf=\"isPagerDisplay\"\n                        [source]=\"source\"\n                        [perPageSelect]=\"perPageSelect\">\n</ng2-smart-table-pager>\n", styles: [":host{font-size:1rem}:host ::ng-deep *{box-sizing:border-box}:host ::ng-deep button,:host ::ng-deep input,:host ::ng-deep optgroup,:host ::ng-deep select,:host ::ng-deep textarea{color:inherit;font:inherit;margin:0}:host ::ng-deep table{line-height:1.5em;border-collapse:collapse;border-spacing:0;display:table;width:100%;max-width:100%;overflow:auto;word-break:normal;word-break:keep-all}:host ::ng-deep table tr th{font-weight:700}:host ::ng-deep table tr section{font-size:.75em;font-weight:700}:host ::ng-deep table tr td,:host ::ng-deep table tr th{font-size:.875em;margin:0;padding:.5em 1em}:host ::ng-deep a{color:#1e6bb8;text-decoration:none}:host ::ng-deep a:hover{text-decoration:underline}\n"] }]
+    }], null, { source: [{
+            type: Input
+        }], settings: [{
+            type: Input
+        }], multiRowSelect: [{
+            type: Output
+        }], rowClicked: [{
+            type: Output
+        }], delete: [{
+            type: Output
+        }], edit: [{
+            type: Output
+        }], create: [{
+            type: Output
+        }], custom: [{
+            type: Output
+        }], deleteConfirm: [{
+            type: Output
+        }], editConfirm: [{
+            type: Output
+        }], createConfirm: [{
+            type: Output
+        }], rowHover: [{
+            type: Output
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ng2-smart-table.component.js","sourceRoot":"","sources":["../../../../projects/ng2-smart-table/src/lib/ng2-smart-table.component.ts","../../../../projects/ng2-smart-table/src/lib/ng2-smart-table.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, Input, Output, SimpleChange, EventEmitter, OnChanges, OnDestroy } from '@angular/core';\nimport { Subject, Subscription } from 'rxjs';\n\nimport { Grid } from './lib/grid';\nimport { DataSource } from './lib/data-source/data-source';\nimport { Row } from './lib/data-set/row';\nimport { deepExtend } from './lib/helpers';\nimport { LocalDataSource } from './lib/data-source/local/local.data-source';\nimport { SmartTableConfirmDeleteEvent, SmartTableConfirmEditEvent, SmartTableCreateConfirm, SmartTableCustomEvent, SmartTableRowClickedEvent, SmartTableRowSelectEvent, SmartTableSettings } from './lib/interfaces/smart-table.models';\n\n@Component({\n  selector: 'ng2-smart-table',\n  styleUrls: ['./ng2-smart-table.component.scss'],\n  templateUrl: './ng2-smart-table.component.html',\n})\nexport class Ng2SmartTableComponent implements OnChanges {\n\n  @Input() source: DataSource;\n  @Input() settings: SmartTableSettings;\n\n  @Output() multiRowSelect = new EventEmitter<SmartTableRowSelectEvent>();\n  @Output() rowClicked = new EventEmitter<SmartTableRowClickedEvent>();\n  @Output() delete = new EventEmitter<any>();\n  @Output() edit = new EventEmitter<any>();\n  @Output() create = new EventEmitter<any>();\n  @Output() custom = new EventEmitter<SmartTableCustomEvent>();\n  @Output() deleteConfirm = new EventEmitter<SmartTableConfirmDeleteEvent>();\n  @Output() editConfirm = new EventEmitter<SmartTableConfirmEditEvent>();\n  @Output() createConfirm = new EventEmitter<SmartTableCreateConfirm>();\n  @Output() rowHover: EventEmitter<any> = new EventEmitter<any>();\n\n  tableClass: string;\n  tableId: string;\n  perPageSelect: any;\n  isHideHeader: boolean;\n  isHideSubHeader: boolean;\n  isPagerDisplay: boolean;\n  rowClassFunction: Function;\n\n  grid: Grid;\n  defaultSettings: SmartTableSettings = {\n    mode: 'inline', // inline|external|click-to-edit\n    selectMode: 'single', // single|multi\n    /**\n     * Points to an element in all data\n     *\n     * when < 0 all lines must be deselected\n     */\n    selectedRowIndex: 0,\n    switchPageToSelectedRowPage: false,\n    hideHeader: false,\n    hideSubHeader: false,\n    actions: {\n      columnTitle: 'Actions',\n      add: true,\n      edit: true,\n      delete: true,\n      custom: [],\n      position: 'left', // left|right\n    },\n    filter: {\n      inputClass: '',\n    },\n    edit: {\n      inputClass: '',\n      editButtonContent: 'Edit',\n      saveButtonContent: 'Update',\n      cancelButtonContent: 'Cancel',\n      confirmSave: false,\n    },\n    add: {\n      inputClass: '',\n      addButtonContent: 'Add New',\n      createButtonContent: 'Create',\n      cancelButtonContent: 'Cancel',\n      confirmCreate: false,\n    },\n    delete: {\n      deleteButtonContent: 'Delete',\n      confirmDelete: false,\n    },\n    attr: {\n      id: '',\n      class: '',\n    },\n    noDataMessage: 'No data found',\n    columns: {},\n    pager: {\n      display: true,\n      page: 1,\n      perPage: 10,\n    },\n    rowClassFunction: () => '',\n  };\n\n  ngOnChanges(changes: { [propertyName: string]: SimpleChange }) {\n    if (this.grid) {\n      if (changes['settings']) {\n        this.grid.setSettings(this.prepareSettings());\n      }\n      if (changes['source']) {\n        this.source = this.prepareSource();\n        this.grid.setSource(this.source);\n      }\n    } else {\n      this.initGrid();\n    }\n    this.tableId = this.grid.getSetting('attr.id');\n    this.tableClass = this.grid.getSetting('attr.class');\n    this.isHideHeader = this.grid.getSetting('hideHeader');\n    this.isHideSubHeader = this.grid.getSetting('hideSubHeader');\n    this.isPagerDisplay = this.grid.getSetting('pager.display');\n    this.isPagerDisplay = this.grid.getSetting('pager.display');\n    this.perPageSelect = this.grid.getSetting('pager.perPageSelect');\n    this.rowClassFunction = this.grid.getSetting('rowClassFunction');\n  }\n\n  onRowHover(row: Row) {\n    this.rowHover.emit(row);\n  }\n\n  multipleSelectRow(row: Row) {\n    this.grid.multipleSelectRow(row);\n    this.emitUserSelectRow(row);\n  }\n\n  onSelectAllRows() {\n    this.grid.dataSet.isAllSelected;\n    this.grid.selectAllRows(!this.grid.dataSet.isAllSelected);\n\n    this.emitUserSelectRow(null);\n  }\n\n  onSelectRow(row: Row, state: boolean) {\n    this.grid.selectRow(row, state);\n  }\n\n  initGrid() {\n    this.source = this.prepareSource();\n    this.grid = new Grid(this.source, this.prepareSettings());\n  }\n\n  prepareSource(): DataSource {\n    if (this.source instanceof DataSource) {\n      return this.source;\n    }\n    return new LocalDataSource();\n  }\n\n  prepareSettings(): SmartTableSettings {\n    return deepExtend({}, this.defaultSettings, this.settings);\n  }\n\n  private emitUserSelectRow(row: Row) {\n    this.multiRowSelect.emit({\n      data: row ? row.getData() : null,\n      isSelected: row ? row.getIsSelected() : null,\n      source: this.source,\n      selected: this.grid.dataSet.getSelectedRowsData(),\n    });\n  }  \n  \n  emitUserRowClicked(row: Row) {\n    this.rowClicked.emit({\n      data: row ? row.getData() : null,\n      source: this.source,\n    });\n  }\n}\n","<table [id]=\"tableId\" [ngClass]=\"tableClass\">\n\n  <thead ng2-st-thead *ngIf=\"!isHideHeader || !isHideSubHeader\"\n                      [grid]=\"grid\"\n                      [source]=\"source\"\n                      [createConfirm]=\"createConfirm\"\n                      (create)=\"create.emit($event)\"\n                      (selectAllRows)=\"onSelectAllRows()\">\n  </thead>\n\n  <tbody ng2-st-tbody [grid]=\"grid\"\n                      [source]=\"source\"\n                      [deleteConfirm]=\"deleteConfirm\"\n                      [editConfirm]=\"editConfirm\"\n                      [rowClassFunction]=\"rowClassFunction\"\n                      (edit)=\"edit.emit($event)\"\n                      (delete)=\"delete.emit($event)\"\n                      (custom)=\"custom.emit($event)\"\n                      (userClickedRow)=\"emitUserRowClicked($event)\"\n                      (multipleSelectRow)=\"multipleSelectRow($event)\"\n                      (rowHover)=\"onRowHover($event)\">\n  </tbody>\n\n</table>\n\n<ng2-smart-table-pager *ngIf=\"isPagerDisplay\"\n                        [source]=\"source\"\n                        [perPageSelect]=\"perPageSelect\">\n</ng2-smart-table-pager>\n"]}