@den4ik92/ng2-smart-table 2.0.6 → 2.1.2

package/esm2022/lib/lib/grid.mjs

@@ -0,0 +1,218 @@
+import { Subject } from "rxjs";
+import { Deferred, getDeepFromObject } 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", false) ||
+            this.getSetting("actions.edit", false) ||
+            this.getSetting("actions.delete", false) ||
+            !!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);
+            if (changedRow) {
+                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) {
+        row.pending = true;
+        const deferred = new Deferred();
+        deferred.promise
+            .then((newData) => {
+            row.pending = false;
+            newData = newData ? newData : row.getNewData();
+            this.source.prepend(newData).then(() => {
+                this.createFormShown = false;
+                this.dataSet.createNewRow();
+            });
+        })
+            .catch((err) => {
+            row.pending = false;
+        });
+        if (this.getSetting("add.confirmCreate")) {
+            confirmEmitter.emit({
+                newData: row.getNewData(),
+                source: this.source,
+                confirm: deferred,
+            });
+        }
+        else {
+            deferred.resolve(false);
+        }
+    }
+    save(row, confirmEmitter) {
+        row.pending = true;
+        const deferred = new Deferred();
+        deferred.promise
+            .then((newData) => {
+            row.pending = false;
+            newData = newData ? newData : row.getNewData();
+            this.source.update(row.getData(), newData).then(() => {
+                row.isInEditing = false;
+            });
+        })
+            .catch((err) => {
+            row.pending = false;
+        });
+        if (this.getSetting("edit.confirmSave")) {
+            confirmEmitter.emit({
+                data: row.getData(),
+                newData: row.getNewData(),
+                source: this.source,
+                confirm: deferred,
+            });
+        }
+        else {
+            deferred.resolve(false);
+        }
+    }
+    delete(row, confirmEmitter) {
+        row.pending = true;
+        const deferred = new Deferred();
+        deferred.promise
+            .then(() => {
+            row.pending = false;
+            this.source.remove(row.getData());
+        })
+            .catch((err) => {
+            row.pending = false;
+            // doing nothing
+        });
+        if (this.getSetting("delete.confirmDelete")) {
+            confirmEmitter.emit({
+                data: row.getData(),
+                source: this.source,
+                confirm: deferred,
+            });
+        }
+        else {
+            deferred.resolve(false);
+        }
+        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 initialSort = this.getInitialSort();
+        if (initialSort) {
+            source.setSort([initialSort], false);
+        }
+        if (this.getSetting("pager.display") === true) {
+            source.setPaging(1, this.getSetting("pager.perPage"), false);
+        }
+        source.refresh();
+        return source;
+    }
+    getInitialSort() {
+        const defaultSortColumn = this.getColumns().find((column) => column.isSortable && column.defaultSortDirection);
+        if (!defaultSortColumn) {
+            return false;
+        }
+        return {
+            field: defaultSortColumn.id,
+            direction: defaultSortColumn.defaultSortDirection || "asc",
+            compare: defaultSortColumn.getCompareFunction(),
+        };
+    }
+    getSelectedRowsData() {
+        return this.dataSet.getRows();
+    }
+    selectAllRows(status) {
+        this.dataSet.setSelectAll(status);
+    }
+    getFirstRow() {
+        return this.dataSet.getFirstRow();
+    }
+    getLastRow() {
+        return this.dataSet.getLastRow();
+    }
+}
+//# 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 { LocalDataSource } from \"./data-source/local/local.data-source\";\nimport { Subject, Subscription } from \"rxjs\";\nimport { Observable } from \"rxjs\";\nimport { EventEmitter } from \"@angular/core\";\n\nimport { Deferred, getDeepFromObject } from \"./helpers\";\nimport { Column } from \"./data-set/column\";\nimport { Row } from \"./data-set/row\";\nimport { DataSet } from \"./data-set/data-set\";\nimport {\n  SmartTableSettings,\n  SmartTableColumnSettings,\n  SmartTableSortItem,\n} from \"./interfaces/smart-table.models\";\n\nexport class Grid {\n  createFormShown: boolean = false;\n\n  source!: LocalDataSource;\n  settings!: SmartTableSettings;\n  dataSet!: DataSet;\n\n  onSelectRowSource = new Subject<any>();\n  onDeselectRowSource = new Subject<any>();\n\n  private sourceOnChangedSubscription: Subscription | undefined;\n  private sourceOnUpdatedSubscription: Subscription | undefined;\n\n  constructor(source: LocalDataSource, 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 (\n      this.getSetting<boolean>(\"actions.add\", false) ||\n      this.getSetting<boolean>(\"actions.edit\", false) ||\n      this.getSetting<boolean>(\"actions.delete\", false) ||\n      !!this.getSetting<[]>(\"actions.custom\", [])?.length\n    );\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(\n      [],\n      this.getSetting<SmartTableColumnSettings[]>(\"columns\")\n    );\n\n    if (this.source) {\n      this.source.refresh();\n    }\n  }\n\n  getDataSet(): DataSet {\n    return this.dataSet;\n  }\n\n  setSource(source: LocalDataSource) {\n    this.source = this.prepareSource(source);\n    this.detach();\n\n    this.sourceOnChangedSubscription = this.source\n      .onChanged()\n      .subscribe((changes: any) => this.processDataChange(changes));\n\n    this.sourceOnUpdatedSubscription = this.source\n      .onUpdated()\n      .subscribe((data: any) => {\n        const changedRow = this.dataSet.findRowByData(data);\n        if (changedRow) {\n          changedRow.setData(data);\n        }\n      });\n  }\n\n  getSetting<T>(name: string, defaultValue?: any): T {\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    row.pending = true;\n    const deferred = new Deferred();\n    deferred.promise\n      .then((newData) => {\n        row.pending = false;\n        newData = newData ? newData : row.getNewData();\n        this.source.prepend(newData).then(() => {\n          this.createFormShown = false;\n          this.dataSet.createNewRow();\n        });\n      })\n      .catch((err) => {\n        row.pending = false;\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(false);\n    }\n  }\n\n  save(row: Row, confirmEmitter: EventEmitter<any>) {\n    row.pending = true;\n    const deferred = new Deferred();\n    deferred.promise\n      .then((newData) => {\n        row.pending = false;\n        newData = newData ? newData : row.getNewData();\n        this.source.update(row.getData(), newData).then(() => {\n          row.isInEditing = false;\n        });\n      })\n      .catch((err) => {\n        row.pending = false;\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(false);\n    }\n  }\n\n  delete(row: Row, confirmEmitter: EventEmitter<any>) {\n    row.pending = true;\n    const deferred = new Deferred();\n    deferred.promise\n      .then(() => {\n        row.pending = false;\n        this.source.remove(row.getData());\n      })\n      .catch((err) => {\n        row.pending = false;\n        // doing nothing\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(false);\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 (\n      [\"filter\", \"sort\", \"page\", \"remove\", \"refresh\", \"load\", \"paging\"].indexOf(\n        changes[\"action\"]\n      ) !== -1\n    ) {\n      return true;\n    } else if (\n      [\"prepend\", \"append\"].indexOf(changes[\"action\"]) !== -1 &&\n      !this.getSetting(\"pager.display\")\n    ) {\n      return true;\n    }\n    return false;\n  }\n\n  prepareSource(source: LocalDataSource): LocalDataSource {\n    const initialSort: SmartTableSortItem | false = this.getInitialSort();\n    if (initialSort) {\n      source.setSort([initialSort], false);\n    }\n    if (this.getSetting(\"pager.display\") === true) {\n      source.setPaging(1, this.getSetting(\"pager.perPage\"), false);\n    }\n\n    source.refresh();\n    return source;\n  }\n\n  getInitialSort(): SmartTableSortItem | false {\n    const defaultSortColumn = this.getColumns().find(\n      (column: Column) => column.isSortable && column.defaultSortDirection\n    );\n    if (!defaultSortColumn) {\n      return false;\n    }\n    return {\n      field: defaultSortColumn.id,\n      direction: defaultSortColumn.defaultSortDirection || \"asc\",\n      compare: defaultSortColumn.getCompareFunction(),\n    };\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"]}

package/{esm2020 → esm2022}/lib/lib/helpers.mjs

@@ -81,4 +81,4 @@ 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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
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2020 → esm2022}/lib/lib/interfaces/smart-table.models.mjs

@@ -13,4 +13,4 @@ export var SmartTableOnChangedEventName;
     SmartTableOnChangedEventName["prepend"] = "prepend";
     SmartTableOnChangedEventName["refresh"] = "refresh";
 })(SmartTableOnChangedEventName || (SmartTableOnChangedEventName = {}));
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"smart-table.models.js","sourceRoot":"","sources":["../../../../../../projects/ng2-smart-table/src/lib/lib/interfaces/smart-table.models.ts"],"names":[],"mappings":"AA+MA,MAAM,CAAN,IAAY,4BAaX;AAbD,WAAY,4BAA4B;IACvC,6CAAe,CAAA;IACf,iDAAmB,CAAA;IACnB,iDAAmB,CAAA;IACnB,6CAAe,CAAA;IACf,iDAAmB,CAAA;IACnB,+CAAiB,CAAA;IACjB,6CAAe,CAAA;IACf,2CAAa,CAAA;IACb,iDAAmB,CAAA;IACnB,iDAAmB,CAAA;IACnB,mDAAqB,CAAA;IACrB,mDAAqB,CAAA;AACtB,CAAC,EAbW,4BAA4B,KAA5B,4BAA4B,QAavC","sourcesContent":["import { LocalDataSource } from \"../data-source/local/local.data-source\";\nimport { Deferred } from \"../helpers\";\n\nexport interface SelectOption {\n\ttitle: string;\n\tvalue: any;\n}\n\ninterface ObjectAny {\n\t[key: string]: any;\n}\n\nexport interface SmartTableSettings<T extends ObjectAny = any> {\n\tmode?: 'inline' | 'external' | 'click-to-edit';\n\tselectMode?: 'single' | 'multi';\n\tselectedRowIndex?: number; //if need deselect first item set value < 0;\n\tswitchPageToSelectedRowPage?: boolean;\n\thideHeader?: boolean;\n\thideSubHeader?: boolean;\n\tactions?: SmartTableAction | false;\n\tfilter?: {\n\t\tinputClass: string;\n\t};\n\tedit?:\n\t| {\n\t\tinputClass?: string;\n\t\teditButtonContent?: string;\n\t\tsaveButtonContent?: string;\n\t\tcancelButtonContent?: string;\n\t\tconfirmSave?: boolean;\n\t}\n\t| false;\n\tadd?:\n\t| {\n\t\tinputClass?: string;\n\t\taddButtonContent?: string;\n\t\tcreateButtonContent?: string;\n\t\tcancelButtonContent?: string;\n\t\tconfirmCreate?: boolean;\n\t}\n\t| false;\n\tdelete?:\n\t| {\n\t\tdeleteButtonContent?: string;\n\t\tconfirmDelete?: boolean;\n\t}\n\t| false;\n\tattr?: {\n\t\tid?: string;\n\t\tclass?: string;\n\t};\n\tnoDataMessage?: string;\n\tcolumns: SmartTableColumnSettings<T>[];\n\tpager?: SmartTablePagerSettings | false;\n\trowClassFunction?: (row: { data: T }) => string;\n}\n\nexport interface SmartTableAction {\n\tcolumnTitle?: string;\n\tadd?: boolean;\n\tedit?: boolean;\n\tdelete?: boolean;\n\tcustom?: SmartTableCustomAction[];\n\tposition?: 'left' | 'right';\n}\n\nexport interface SmartTableCustomAction {\n\tname: string;\n\ttitle: string; // insert html content to action button\n}\n\nexport type SmartTableColumnSettingsTypes = 'text' | 'html' | 'custom'\n\nexport type SmartTableColumnSettings<T=any> = SmartTableTextHtmlColumn<T> | SmartTableCustomColumn<T>;\n\ninterface SmartTableDefaultColumn<T> {\n\tkey: keyof T;\n\ttitle: string;\n\twidth?: string; //example: '20px', '20%'\n\tclass?: string;\n\teditable?: boolean;\n\thide?: boolean;\n\tsort?: boolean;\n\taddable?: boolean;\n\tsortDirection?: SmartTableSortDirection | false;\n\teditor?: SmartTableEditorAndFilter;\n\tfilter?: SmartTableEditorAndFilter | false;\n\tcompareFunction?: (itemA: T, itemB: T) => number;\n\tvaluePrepareFunction?: (columnData: any, rowData: T) => any;\n\tfilterFunction?: (columnData: any, search: string) => boolean;\n}\n\ninterface SmartTableTextHtmlColumn<T> extends SmartTableDefaultColumn<T> {\n\ttype: 'text' | 'html';\n}\n\ninterface SmartTableCustomColumn<T> extends SmartTableDefaultColumn<T> {\n\ttype: 'custom';\n\trenderComponent: any;\n}\n\nexport type SmartTableEditorAndFilterTypes = 'text' | 'textarea' | 'list' | 'custom' | 'checkbox';\n\nexport type SmartTableEditorAndFilter =\n\t| SmartTableTextEditor\n\t| SmartTableEditorList\n\t| SmartTableEditorCheckbox\n\t| SmartTableEditorCustom;\n\ninterface SmartTableTextEditor {\n\ttype: 'text' | 'textarea';\n\tconfig: any;\n}\n\ninterface SmartTableEditorList {\n\ttype: 'list';\n\tconfig: {\n\t\tselectText?: string;\n\t\tlist: SelectOption[];\n\t};\n}\n\n//deprecated\ninterface SmartTableEditorCompleter {\n\ttype: 'completer';\n\tconfig: {\n\t\tcompleter: {\n\t\t\tdata: any[];\n\t\t\tsearchFields: string;\n\t\t\ttitleField: string;\n\t\t\tdescriptionField?: string;\n\t\t};\n\t};\n}\n\ninterface SmartTableEditorCheckbox {\n\ttype: 'checkbox';\n\tconfig?: {\n\t\ttrue: any;\n\t\tfalse: any;\n\t\tresetText?: string;\n\t};\n}\n\ninterface SmartTableEditorCustom {\n\ttype: 'custom';\n\tcomponent: any;\n\tconfig?: any;\n}\n\ninterface SmartTablePagerSettings {\n\tdisplay: boolean;\n\tpage?: number;\n\tperPage: number;\n\tperPageSelect?: number[];\n}\n\nexport interface SmartTableFilterItem {\n\tfield: string;\n\tsearch: string;\n\tfilter?: any;\n}\n\nexport interface SmartTablePagingItem {\n\tpage: number;\n\tperPage: number;\n}\n\nexport type SmartTableSortDirection = 'asc' | 'desc';\n\nexport interface SmartTableSortItem {\n\tfield: string;\n\tdirection: SmartTableSortDirection;\n\tcompare?: any;\n}\n\ninterface SmartTableDefaultEvent<T> {\n\tconfirm: Deferred;\n\tdata: T;\n\tsource: LocalDataSource;\n}\n\nexport type SmartTableConfirmDeleteEvent<T = any> = SmartTableDefaultEvent<T>;\n\nexport type SmartTableRowClickedEvent<T = any> = Omit<SmartTableDefaultEvent<T>, \"confirm\">\n\nexport interface SmartTableCustomEvent<T = any> extends Omit<SmartTableDefaultEvent<T>, \"confirm\"> {\n\taction: string;\n}\n\nexport interface SmartTableRowSelectEvent<T = any> extends Omit<SmartTableDefaultEvent<T>, \"confirm\"> {\n\tisSelected: boolean;\n\tselected: T[];\n}\n\nexport interface SmartTableConfirmEditEvent<T = any, N = T> extends SmartTableDefaultEvent<T> {\n\tnewData: N;\n}\n\nexport interface SmartTableCreateConfirm<T = any> extends Omit<SmartTableDefaultEvent<T>, \"data\"> {\n\tnewData: T;\n}\n\nexport interface ObjectStringString {\n\t[key: string]: string;\n}\n\nexport enum SmartTableOnChangedEventName {\n\t'load' = 'load',\n\t'paging' = 'paging',\n\t'update' = 'update',\n\t'page' = 'page',\n\t'filter' = 'filter',\n\t'empty' = 'empty',\n\t'sort' = 'sort',\n\t'add' = 'add',\n\t'remove' = 'remove',\n\t'append' = 'append',\n\t'prepend' = 'prepend',\n\t'refresh' = 'refresh',\n}\n\nexport type SmartTableOnChangedEventType = 'load' | 'prepend' | 'append' | 'update' | 'empty' | 'paging' | 'page' | 'filter' | 'sort' | 'add' | 'remove' | 'refresh';\n\nexport interface SmartTableOnChangedEvent<T extends ObjectAny = any> {\n\taction: SmartTableOnChangedEventType;\n\telements: T[];\n\tfilter: SmartTableFilterConf;\n\tpaging: SmartTablePagingItem | false;\n\tsort: SmartTableSortItem[];\n}\n\nexport interface SmartTableFilterConf { filters: SmartTableFilterItem[]; andOperator: boolean }"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"smart-table.models.js","sourceRoot":"","sources":["../../../../../../projects/ng2-smart-table/src/lib/lib/interfaces/smart-table.models.ts"],"names":[],"mappings":"AA+MA,MAAM,CAAN,IAAY,4BAaX;AAbD,WAAY,4BAA4B;IACvC,6CAAe,CAAA;IACf,iDAAmB,CAAA;IACnB,iDAAmB,CAAA;IACnB,6CAAe,CAAA;IACf,iDAAmB,CAAA;IACnB,+CAAiB,CAAA;IACjB,6CAAe,CAAA;IACf,2CAAa,CAAA;IACb,iDAAmB,CAAA;IACnB,iDAAmB,CAAA;IACnB,mDAAqB,CAAA;IACrB,mDAAqB,CAAA;AACtB,CAAC,EAbW,4BAA4B,KAA5B,4BAA4B,QAavC","sourcesContent":["import { LocalDataSource } from \"../data-source/local/local.data-source\";\nimport { Deferred } from \"../helpers\";\n\nexport interface SelectOption {\n\ttitle: string;\n\tvalue: any;\n}\n\ninterface ObjectAny {\n\t[key: string]: any;\n}\n\nexport interface SmartTableSettings<T extends ObjectAny = any> {\n\tmode?: 'inline' | 'external' | 'click-to-edit';\n\tselectMode?: 'single' | 'multi';\n\tselectedRowIndex?: number; //if need deselect first item set value < 0;\n\tswitchPageToSelectedRowPage?: boolean;\n\thideHeader?: boolean;\n\thideSubHeader?: boolean;\n\tactions?: SmartTableAction | false;\n\tfilter?: {\n\t\tinputClass: string;\n\t};\n\tedit?:\n\t| {\n\t\tinputClass?: string;\n\t\teditButtonContent?: string;\n\t\tsaveButtonContent?: string;\n\t\tcancelButtonContent?: string;\n\t\tconfirmSave?: boolean;\n\t}\n\t| false;\n\tadd?:\n\t| {\n\t\tinputClass?: string;\n\t\taddButtonContent?: string;\n\t\tcreateButtonContent?: string;\n\t\tcancelButtonContent?: string;\n\t\tconfirmCreate?: boolean;\n\t}\n\t| false;\n\tdelete?:\n\t| {\n\t\tdeleteButtonContent?: string;\n\t\tconfirmDelete?: boolean;\n\t}\n\t| false;\n\tattr?: {\n\t\tid?: string;\n\t\tclass?: string;\n\t};\n\tnoDataMessage?: string;\n\tcolumns: SmartTableColumnSettings<T>[];\n\tpager?: SmartTablePagerSettings | false;\n\trowClassFunction?: (row: { data: T }) => string;\n}\n\nexport interface SmartTableAction {\n\tcolumnTitle?: string;\n\tadd?: boolean;\n\tedit?: boolean;\n\tdelete?: boolean;\n\tcustom?: SmartTableCustomAction[];\n\tposition?: 'left' | 'right';\n}\n\nexport interface SmartTableCustomAction {\n\tname: string;\n\ttitle: string; // insert html content to action button\n}\n\nexport type SmartTableColumnSettingsTypes = 'text' | 'html' | 'custom'\n\nexport type SmartTableColumnSettings<T=any> = SmartTableTextHtmlColumn<T> | SmartTableCustomColumn<T>;\n\ninterface SmartTableDefaultColumn<T> {\n\tkey: keyof T;\n\ttitle: string;\n\twidth?: string; //example: '20px', '20%'\n\tclass?: string;\n\teditable?: boolean;\n\thide?: boolean;\n\tsort?: boolean;\n\taddable?: boolean;\n\tsortDirection?: SmartTableSortDirection | false;\n\teditor?: SmartTableEditorAndFilter;\n\tfilter?: SmartTableEditorAndFilter | false;\n\tcompareFunction?: (itemA: T, itemB: T) => number;\n\tvaluePrepareFunction?: (columnData: any, rowData: T) => any;\n\tfilterFunction?: (columnData: any, search: string) => boolean;\n}\n\ninterface SmartTableTextHtmlColumn<T> extends SmartTableDefaultColumn<T> {\n\ttype: 'text' | 'html';\n}\n\ninterface SmartTableCustomColumn<T> extends SmartTableDefaultColumn<T> {\n\ttype: 'custom';\n\trenderComponent: any;\n}\n\nexport type SmartTableEditorAndFilterTypes = 'text' | 'textarea' | 'list' | 'custom' | 'checkbox';\n\nexport type SmartTableEditorAndFilter =\n\t| SmartTableTextEditor\n\t| SmartTableEditorList\n\t| SmartTableEditorCheckbox\n\t| SmartTableEditorCustom;\n\ninterface SmartTableTextEditor {\n\ttype: 'text' | 'textarea';\n\tconfig: any;\n}\n\ninterface SmartTableEditorList {\n\ttype: 'list';\n\tconfig: {\n\t\tselectText?: string;\n\t\tlist: SelectOption[];\n\t};\n}\n\n//deprecated\ninterface SmartTableEditorCompleter {\n\ttype: 'completer';\n\tconfig: {\n\t\tcompleter: {\n\t\t\tdata: any[];\n\t\t\tsearchFields: string;\n\t\t\ttitleField: string;\n\t\t\tdescriptionField?: string;\n\t\t};\n\t};\n}\n\ninterface SmartTableEditorCheckbox {\n\ttype: 'checkbox';\n\tconfig?: {\n\t\ttrue: any;\n\t\tfalse: any;\n\t\tresetText?: string;\n\t};\n}\n\ninterface SmartTableEditorCustom {\n\ttype: 'custom';\n\tcomponent: any;\n\tconfig?: any;\n}\n\ninterface SmartTablePagerSettings {\n\tdisplay: boolean;\n\tpage?: number;\n\tperPage: number;\n\tperPageSelect?: number[];\n}\n\nexport interface SmartTableFilterItem {\n\tfield: string;\n\tsearch: string;\n\tfilter?: any;\n}\n\nexport interface SmartTablePagingItem {\n\tpage: number;\n\tperPage: number;\n}\n\nexport type SmartTableSortDirection = 'asc' | 'desc';\n\nexport interface SmartTableSortItem {\n\tfield: string;\n\tdirection: SmartTableSortDirection;\n\tcompare?: any;\n}\n\ninterface SmartTableDefaultEvent<T> {\n\tconfirm: Deferred<T>;\n\tdata: T;\n\tsource: LocalDataSource;\n}\n\nexport type SmartTableConfirmDeleteEvent<T = any> = SmartTableDefaultEvent<T>;\n\nexport type SmartTableRowClickedEvent<T = any> = Omit<SmartTableDefaultEvent<T>, \"confirm\">\n\nexport interface SmartTableCustomEvent<T = any> extends Omit<SmartTableDefaultEvent<T>, \"confirm\"> {\n\taction: string;\n}\n\nexport interface SmartTableRowSelectEvent<T = any> extends Omit<SmartTableDefaultEvent<T>, \"confirm\"> {\n\tisSelected: boolean;\n\tselected: T[];\n}\n\nexport interface SmartTableConfirmEditEvent<T = any, N = T> extends SmartTableDefaultEvent<T> {\n\tnewData: N;\n}\n\nexport interface SmartTableCreateConfirm<T = any> extends Omit<SmartTableDefaultEvent<T>, \"data\"> {\n\tnewData: T;\n}\n\nexport interface ObjectStringString {\n\t[key: string]: string;\n}\n\nexport enum SmartTableOnChangedEventName {\n\t'load' = 'load',\n\t'paging' = 'paging',\n\t'update' = 'update',\n\t'page' = 'page',\n\t'filter' = 'filter',\n\t'empty' = 'empty',\n\t'sort' = 'sort',\n\t'add' = 'add',\n\t'remove' = 'remove',\n\t'append' = 'append',\n\t'prepend' = 'prepend',\n\t'refresh' = 'refresh',\n}\n\nexport type SmartTableOnChangedEventType = 'load' | 'prepend' | 'append' | 'update' | 'empty' | 'paging' | 'page' | 'filter' | 'sort' | 'add' | 'remove' | 'refresh';\n\nexport interface SmartTableOnChangedEvent<T extends ObjectAny = any> {\n\taction: SmartTableOnChangedEventType;\n\telements: T[];\n\tfilter: SmartTableFilterConf;\n\tpaging: SmartTablePagingItem | false;\n\tsort: SmartTableSortItem[];\n}\n\nexport interface SmartTableFilterConf { filters: SmartTableFilterItem[]; andOperator: boolean }"]}

package/{esm2020 → esm2022}/lib/ng2-smart-table.component.mjs

@@ -133,10 +133,10 @@ export class Ng2SmartTableComponent {
             selected: this.grid.dataSet.getSelectedRowsData(),
         });
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: Ng2SmartTableComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: Ng2SmartTableComponent, selector: "ng2-smart-table", inputs: { source: "source", settings: "settings" }, outputs: { multiRowSelect: "multiRowSelect", rowClicked: "rowClicked", delete: "delete", edit: "edit", editCancel: "editCancel", create: "create", custom: "custom", deleteConfirm: "deleteConfirm", editConfirm: "editConfirm", createConfirm: "createConfirm", rowHover: "rowHover" }, usesOnChanges: true, ngImport: i0, 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                      (editCancel)=\"editCancel.emit($event)\"\n                      (delete)=\"delete.emit($event)\"\n                      (custom)=\"custom.emit($event)\"\n                      (userClickedRow)=\"emitUserRowClicked($event)\"\n                      (multipleSelectRow)=\"multipleSelectRow($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%;word-break:normal;word-break:keep-all;overflow:auto}: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"], dependencies: [{ kind: "directive", type: i1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i2.PagerComponent, selector: "ng2-smart-table-pager", inputs: ["source", "perPageSelect"], outputs: ["changePage"] }, { kind: "component", type: i3.Ng2SmartTableTbodyComponent, selector: "[ng2-st-tbody]", inputs: ["grid", "source", "deleteConfirm", "editConfirm", "rowClassFunction"], outputs: ["save", "cancel", "edit", "editCancel", "delete", "custom", "edited", "userSelectRow", "userClickedRow", "editRowSelect", "multipleSelectRow"] }, { kind: "component", type: i4.Ng2SmartTableTheadComponent, selector: "[ng2-st-thead]", inputs: ["grid", "source", "createConfirm"], outputs: ["sort", "selectAllRows", "create", "filter"] }] }); }
 }
-Ng2SmartTableComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: Ng2SmartTableComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
-Ng2SmartTableComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.9", type: Ng2SmartTableComponent, selector: "ng2-smart-table", inputs: { source: "source", settings: "settings" }, outputs: { multiRowSelect: "multiRowSelect", rowClicked: "rowClicked", delete: "delete", edit: "edit", editCancel: "editCancel", create: "create", custom: "custom", deleteConfirm: "deleteConfirm", editConfirm: "editConfirm", createConfirm: "createConfirm", rowHover: "rowHover" }, usesOnChanges: true, ngImport: i0, 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                      (editCancel)=\"editCancel.emit($event)\"\n                      (delete)=\"delete.emit($event)\"\n                      (custom)=\"custom.emit($event)\"\n                      (userClickedRow)=\"emitUserRowClicked($event)\"\n                      (multipleSelectRow)=\"multipleSelectRow($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%;word-break:normal;word-break:keep-all;overflow:auto}: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"], dependencies: [{ kind: "directive", type: i1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i2.PagerComponent, selector: "ng2-smart-table-pager", inputs: ["source", "perPageSelect"], outputs: ["changePage"] }, { kind: "component", type: i3.Ng2SmartTableTbodyComponent, selector: "[ng2-st-tbody]", inputs: ["grid", "source", "deleteConfirm", "editConfirm", "rowClassFunction"], outputs: ["save", "cancel", "edit", "editCancel", "delete", "custom", "edited", "userSelectRow", "userClickedRow", "editRowSelect", "multipleSelectRow"] }, { kind: "component", type: i4.Ng2SmartTableTheadComponent, selector: "[ng2-st-thead]", inputs: ["grid", "source", "createConfirm"], outputs: ["sort", "selectAllRows", "create", "filter"] }] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: Ng2SmartTableComponent, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: Ng2SmartTableComponent, decorators: [{
             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                      (editCancel)=\"editCancel.emit($event)\"\n                      (delete)=\"delete.emit($event)\"\n                      (custom)=\"custom.emit($event)\"\n                      (userClickedRow)=\"emitUserRowClicked($event)\"\n                      (multipleSelectRow)=\"multipleSelectRow($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%;word-break:normal;word-break:keep-all;overflow:auto}: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"] }]
         }], propDecorators: { source: [{
@@ -166,4 +166,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImpor
             }], 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 } from '@angular/core';\n\nimport { Grid } from './lib/grid';\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  @Input() source!: LocalDataSource;\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() editCancel = 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: number[] = [];\n  isHideHeader = false;\n  isHideSubHeader = false;\n  isPagerDisplay = false;\n  rowClassFunction: Function = ()=>'';\n\n  grid!: Grid;\n  defaultSettings: SmartTableSettings = {\n    mode: 'inline', // inline|external|click-to-edit\n    selectMode: 'single', // single|multi\n    selectedRowIndex: -1,\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: false,\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', false);\n    this.perPageSelect = this.grid.getSetting('pager.perPageSelect');\n    this.rowClassFunction = this.grid.getSetting('rowClassFunction', () => '');\n  }\n\n  protected multipleSelectRow(row: Row): void {\n    this.grid.multipleSelectRow(row);\n    this.emitUserSelectRow(row);\n  }\n\n  protected onSelectAllRows(): void {\n    this.grid.dataSet.isAllSelected;\n    this.grid.selectAllRows(!this.grid.dataSet.isAllSelected);\n    this.emitUserSelectRow(null);\n  }\n\n  protected onSelectRow(row: Row, state: boolean): void {\n    this.grid.selectRow(row, state);\n  }\n\n  protected emitUserRowClicked(row: Row): void {\n    this.rowClicked.emit({\n      data: row ? row.getData() : null,\n      source: this.source,\n    });\n  }\n\n  private initGrid(): void {\n    this.source = this.prepareSource();\n    this.grid = new Grid(this.source, this.prepareSettings());\n  }\n\n  private prepareSource(): LocalDataSource {\n    if (this.source instanceof LocalDataSource) {\n      return this.source;\n    }\n    return new LocalDataSource();\n  }\n\n  private prepareSettings(): SmartTableSettings {\n    return deepExtend({}, this.defaultSettings, this.settings);\n  }\n\n  private emitUserSelectRow(row: Row | null): void {\n    this.multiRowSelect.emit({\n      data: row ? row.getData() : null,\n      isSelected: row ? row.getIsSelected() : false,\n      source: this.source,\n      selected: this.grid.dataSet.getSelectedRowsData(),\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                      (editCancel)=\"editCancel.emit($event)\"\n                      (delete)=\"delete.emit($event)\"\n                      (custom)=\"custom.emit($event)\"\n                      (userClickedRow)=\"emitUserRowClicked($event)\"\n                      (multipleSelectRow)=\"multipleSelectRow($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"]}
+//# 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 } from '@angular/core';\n\nimport { Grid } from './lib/grid';\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  @Input() source!: LocalDataSource;\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() editCancel = 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: number[] = [];\n  isHideHeader = false;\n  isHideSubHeader = false;\n  isPagerDisplay = false;\n  rowClassFunction: Function = ()=>'';\n\n  grid!: Grid;\n  defaultSettings: SmartTableSettings = {\n    mode: 'inline', // inline|external|click-to-edit\n    selectMode: 'single', // single|multi\n    selectedRowIndex: -1,\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: false,\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', false);\n    this.perPageSelect = this.grid.getSetting('pager.perPageSelect');\n    this.rowClassFunction = this.grid.getSetting('rowClassFunction', () => '');\n  }\n\n  protected multipleSelectRow(row: Row): void {\n    this.grid.multipleSelectRow(row);\n    this.emitUserSelectRow(row);\n  }\n\n  protected onSelectAllRows(): void {\n    this.grid.dataSet.isAllSelected;\n    this.grid.selectAllRows(!this.grid.dataSet.isAllSelected);\n    this.emitUserSelectRow(null);\n  }\n\n  protected onSelectRow(row: Row, state: boolean): void {\n    this.grid.selectRow(row, state);\n  }\n\n  protected emitUserRowClicked(row: Row): void {\n    this.rowClicked.emit({\n      data: row ? row.getData() : null,\n      source: this.source,\n    });\n  }\n\n  private initGrid(): void {\n    this.source = this.prepareSource();\n    this.grid = new Grid(this.source, this.prepareSettings());\n  }\n\n  private prepareSource(): LocalDataSource {\n    if (this.source instanceof LocalDataSource) {\n      return this.source;\n    }\n    return new LocalDataSource();\n  }\n\n  private prepareSettings(): SmartTableSettings {\n    return deepExtend({}, this.defaultSettings, this.settings);\n  }\n\n  private emitUserSelectRow(row: Row | null): void {\n    this.multiRowSelect.emit({\n      data: row ? row.getData() : null,\n      isSelected: row ? row.getIsSelected() : false,\n      source: this.source,\n      selected: this.grid.dataSet.getSelectedRowsData(),\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                      (editCancel)=\"editCancel.emit($event)\"\n                      (delete)=\"delete.emit($event)\"\n                      (custom)=\"custom.emit($event)\"\n                      (userClickedRow)=\"emitUserRowClicked($event)\"\n                      (multipleSelectRow)=\"multipleSelectRow($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"]}

package/{esm2020 → esm2022}/lib/ng2-smart-table.module.mjs

@@ -9,25 +9,25 @@ import { THeadModule } from './components/thead/thead.module';
 import { Ng2SmartTableComponent } from './ng2-smart-table.component';
 import * as i0 from "@angular/core";
 export class Ng2SmartTableModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: Ng2SmartTableModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.2.12", ngImport: i0, type: Ng2SmartTableModule, declarations: [Ng2SmartTableComponent], imports: [CommonModule,
+            FormsModule,
+            ReactiveFormsModule,
+            CellModule,
+            FilterModule,
+            PagerModule,
+            TBodyModule,
+            THeadModule], exports: [Ng2SmartTableComponent] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: Ng2SmartTableModule, imports: [CommonModule,
+            FormsModule,
+            ReactiveFormsModule,
+            CellModule,
+            FilterModule,
+            PagerModule,
+            TBodyModule,
+            THeadModule] }); }
 }
-Ng2SmartTableModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: Ng2SmartTableModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-Ng2SmartTableModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.9", ngImport: i0, type: Ng2SmartTableModule, declarations: [Ng2SmartTableComponent], imports: [CommonModule,
-        FormsModule,
-        ReactiveFormsModule,
-        CellModule,
-        FilterModule,
-        PagerModule,
-        TBodyModule,
-        THeadModule], exports: [Ng2SmartTableComponent] });
-Ng2SmartTableModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: Ng2SmartTableModule, imports: [CommonModule,
-        FormsModule,
-        ReactiveFormsModule,
-        CellModule,
-        FilterModule,
-        PagerModule,
-        TBodyModule,
-        THeadModule] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: Ng2SmartTableModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: Ng2SmartTableModule, decorators: [{
             type: NgModule,
             args: [{
                     imports: [
@@ -48,4 +48,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImpor
                     ],
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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