@coolon/angular-ui-powerups 13.1.7 → 13.2.1

package/esm2020/lib/components/tables/renderer/table-cell/table-cell.component.mjs

@@ -0,0 +1,93 @@
+import { Component, ComponentRef, HostBinding, Input } from '@angular/core';
+import { Command, Dsl } from '@coolon/pectin';
+import { DisposableComponent } from '../../../disposable-component';
+import { AbstractTableModel } from '../../abstract-table-model';
+import { ColumnModel } from '../../column/column-model';
+import { EditSession } from '../../editor/edit-session';
+import { CELL_RENDERER_PORTAL, CELL_EDITOR_PORTAL } from '../cell-portal-ref';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@angular/cdk/portal";
+export class TableCellComponent extends DisposableComponent {
+    constructor() {
+        super();
+        this.defaultClassNames = 'aup-cell-renderer';
+        this.fillCell = false;
+        this.padChild = false;
+        this.editRowCommand = Command.create(() => {
+            this.tableModel.startEditSession(this.row);
+        });
+    }
+    ngOnInit() {
+        const { chain, valueOf, before, when, after, observe, switchOn } = Dsl.disposeWith(this);
+        this.firstEditableColumn = chain(this.tableModel.firstEditableColumn$).equals(this.column); // this would break if the column changed.
+        this.column.attachCell(this);
+    }
+    hasActiveEditor() {
+        return !!this.editSession && !!this.column.hasEditorPortal();
+    }
+    initialiseRenderer(ref) {
+        this.column.onRendererAttached(this, ref);
+    }
+    initialiseEditor(ref) {
+        this.column.onEditorAttached(this, ref);
+        if (this.firstEditableColumn.value) {
+            // @see https://github.com/angular/components/issues/12070
+            setTimeout(() => this.tryAndFocusEditor(ref));
+        }
+    }
+    tryAndFocusEditor(ref) {
+        if (ref instanceof ComponentRef) {
+            const editor = ref.instance;
+            // CellEditorComponent<Row> | CellListEditorComponent<Row>
+            if (editor.requestFocus) {
+                editor.requestFocus();
+            }
+            else {
+                const model = (editor['valueModel'] || editor['listModel']);
+                model?.focusContext?.requestFocus();
+            }
+        }
+    }
+    // @Trace()
+    ngOnChanges(changes) {
+        this.column.updatePortalContent(this);
+    }
+    getRendererPortal() {
+        return this[CELL_RENDERER_PORTAL];
+    }
+    getEditorPortal() {
+        return this[CELL_EDITOR_PORTAL];
+    }
+    getRowData() {
+        return {
+            row: this.row,
+            editSession: this.editSession,
+            editRowCommand: this.editRowCommand
+        };
+    }
+}
+TableCellComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: TableCellComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+TableCellComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.3", type: TableCellComponent, selector: "aup-table-cell", inputs: { row: "row", column: "column", editSession: "editSession", tableModel: "tableModel" }, host: { properties: { "class": "this.defaultClassNames", "class.fillCell": "this.fillCell", "class.padChild": "this.padChild" } }, usesInheritance: true, usesOnChanges: true, ngImport: i0, template: "<ng-container *ngIf=\"!hasActiveEditor()\" [cdkPortalOutlet]=\"getRendererPortal()\" (attached)=\"initialiseRenderer($event)\"></ng-container>\n<ng-container *ngIf=\"hasActiveEditor()\" [cdkPortalOutlet]=\"getEditorPortal()\" (attached)=\"initialiseEditor($event)\"></ng-container>\n", styles: [""], directives: [{ type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i2.CdkPortalOutlet, selector: "[cdkPortalOutlet]", inputs: ["cdkPortalOutlet"], outputs: ["attached"], exportAs: ["cdkPortalOutlet"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: TableCellComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'aup-table-cell', template: "<ng-container *ngIf=\"!hasActiveEditor()\" [cdkPortalOutlet]=\"getRendererPortal()\" (attached)=\"initialiseRenderer($event)\"></ng-container>\n<ng-container *ngIf=\"hasActiveEditor()\" [cdkPortalOutlet]=\"getEditorPortal()\" (attached)=\"initialiseEditor($event)\"></ng-container>\n", styles: [""] }]
+        }], ctorParameters: function () { return []; }, propDecorators: { row: [{
+                type: Input
+            }], column: [{
+                type: Input
+            }], editSession: [{
+                type: Input
+            }], tableModel: [{
+                type: Input
+            }], defaultClassNames: [{
+                type: HostBinding,
+                args: ['class']
+            }], fillCell: [{
+                type: HostBinding,
+                args: ['class.fillCell']
+            }], padChild: [{
+                type: HostBinding,
+                args: ['class.padChild']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"table-cell.component.js","sourceRoot":"","sources":["../../../../../../../../../libs/angular-ui-powerups/src/lib/components/tables/renderer/table-cell/table-cell.component.ts","../../../../../../../../../libs/angular-ui-powerups/src/lib/components/tables/renderer/table-cell/table-cell.component.html"],"names":[],"mappings":"AAEA,OAAO,EAAC,SAAS,EAAE,YAAY,EAAE,WAAW,EAAE,KAAK,EAAmC,MAAM,eAAe,CAAC;AAC5G,OAAO,EAA0B,OAAO,EAAE,GAAG,EAA0B,MAAM,gBAAgB,CAAC;AAE9F,OAAO,EAAE,mBAAmB,EAAE,MAAM,+BAA+B,CAAC;AACpE,OAAO,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAEhE,OAAO,EAAE,WAAW,EAAW,MAAM,2BAA2B,CAAC;AACjE,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAExD,OAAO,EAAE,oBAAoB,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;;;;AAO9E,MAAM,OAAO,kBAAwB,SAAQ,mBAAmB;IA8B9D;QACE,KAAK,EAAE,CAAC;QAXV,sBAAiB,GAAG,mBAAmB,CAAC;QAGxC,aAAQ,GAAG,KAAK,CAAC;QAGjB,aAAQ,GAAG,KAAK,CAAC;QAMf,IAAI,CAAC,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,GAAG,EAAE;YACxC,IAAI,CAAC,UAAU,CAAC,gBAAgB,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QAC7C,CAAC,CAAC,CAAC;IACL,CAAC;IAED,QAAQ;QACN,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,GAAG,GAAG,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;QACzF,IAAI,CAAC,mBAAmB,GAAG,KAAK,CAAC,IAAI,CAAC,UAAU,CAAC,oBAAoB,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,0CAA0C;QACtI,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;IAC/B,CAAC;IAED,eAAe;QACb,OAAO,CAAC,CAAC,IAAI,CAAC,WAAW,IAAI,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,eAAe,EAAE,CAAC;IAC/D,CAAC;IAED,kBAAkB,CAAC,GAA+B;QAChD,IAAI,CAAC,MAAM,CAAC,kBAAkB,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;IAC5C,CAAC;IAED,gBAAgB,CAAC,GAA+B;QAC9C,IAAI,CAAC,MAAM,CAAC,gBAAgB,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;QACxC,IAAI,IAAI,CAAC,mBAAmB,CAAC,KAAK,EAAE;YAClC,0DAA0D;YAC1D,UAAU,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,CAAC,CAAC;SAC/C;IACH,CAAC;IAEO,iBAAiB,CAAC,GAA+B;QACvD,IAAI,GAAG,YAAY,YAAY,EAAE;YAC/B,MAAM,MAAM,GAAG,GAAG,CAAC,QAAQ,CAAC;YAC5B,0DAA0D;YAC1D,IAAI,MAAM,CAAC,YAAY,EAAE;gBACvB,MAAM,CAAC,YAAY,EAAE,CAAC;aACvB;iBAAM;gBACL,MAAM,KAAK,GAAG,CAAC,MAAM,CAAC,YAAY,CAAC,IAAI,MAAM,CAAC,WAAW,CAAC,CAAoB,CAAC;gBAC/E,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,CAAC;aACrC;SACF;IAEH,CAAC;IAED,WAAW;IACX,WAAW,CAAC,OAAsB;QAChC,IAAI,CAAC,MAAM,CAAC,mBAAmB,CAAC,IAAI,CAAC,CAAC;IACxC,CAAC;IAED,iBAAiB;QACf,OAAO,IAAI,CAAC,oBAAoB,CAAC,CAAC;IACpC,CAAC;IAED,eAAe;QACb,OAAO,IAAI,CAAC,kBAAkB,CAAC,CAAC;IAClC,CAAC;IAED,UAAU;QACR,OAAO;YACL,GAAG,EAAE,IAAI,CAAC,GAAG;YACb,WAAW,EAAE,IAAI,CAAC,WAAW;YAC7B,cAAc,EAAE,IAAI,CAAC,cAAc;SACpC,CAAC;IACJ,CAAC;;+GA5FU,kBAAkB;mGAAlB,kBAAkB,qUClB/B,6RAEA;2FDgBa,kBAAkB;kBAL9B,SAAS;+BACE,gBAAgB;0EAO1B,GAAG;sBADF,KAAK;gBAIN,MAAM;sBADL,KAAK;gBAIN,WAAW;sBADV,KAAK;gBAIN,UAAU;sBADT,KAAK;gBASN,iBAAiB;sBADhB,WAAW;uBAAC,OAAO;gBAIpB,QAAQ;sBADP,WAAW;uBAAC,gBAAgB;gBAI7B,QAAQ;sBADP,WAAW;uBAAC,gBAAgB","sourcesContent":["import { Portal } from '@angular/cdk/portal';\nimport {CdkPortalOutletAttachedRef} from \"@angular/cdk/portal/portal-directives\";\nimport {Component, ComponentRef, HostBinding, Input, OnChanges, OnInit, SimpleChanges} from '@angular/core';\nimport { BooleanValueModelChain, Command, Dsl, HasFocusContext, Trace } from '@coolon/pectin';\nimport { Stringy } from '@coolon/typescript-utilities';\nimport { DisposableComponent } from '../../../disposable-component';\nimport { AbstractTableModel } from '../../abstract-table-model';\nimport { CellEditorComponent, CellListEditorComponent } from '../cell-editors';\nimport { ColumnModel, RowData } from '../../column/column-model';\nimport { EditSession } from '../../editor/edit-session';\nimport { TableModel } from '../../table/table-model';\nimport { CELL_RENDERER_PORTAL, CELL_EDITOR_PORTAL } from '../cell-portal-ref';\n\n@Component({\n  selector: 'aup-table-cell',\n  templateUrl: './table-cell.component.html',\n  styleUrls: ['./table-cell.component.scss']\n})\nexport class TableCellComponent<Row> extends DisposableComponent implements OnInit, OnChanges {\n\n  @Input()\n  row: Row;\n\n  @Input()\n  column: ColumnModel<Row>;\n\n  @Input()\n  editSession: EditSession<Row>;\n\n  @Input()\n  tableModel: AbstractTableModel<Row>;\n\n  private editRowCommand: Command<void>;\n\n  [CELL_RENDERER_PORTAL]: Portal<any>;\n  [CELL_EDITOR_PORTAL]: Portal<any>;\n\n  @HostBinding('class')\n  defaultClassNames = 'aup-cell-renderer';\n\n  @HostBinding('class.fillCell')\n  fillCell = false;\n\n  @HostBinding('class.padChild')\n  padChild = false;\n\n  private firstEditableColumn: BooleanValueModelChain;\n\n  constructor() {\n    super();\n    this.editRowCommand = Command.create(() => {\n      this.tableModel.startEditSession(this.row);\n    });\n  }\n\n  ngOnInit(): void {\n    const { chain, valueOf, before, when, after, observe, switchOn } = Dsl.disposeWith(this);\n    this.firstEditableColumn = chain(this.tableModel.firstEditableColumn$).equals(this.column); // this would break if the column changed.\n    this.column.attachCell(this);\n  }\n\n  hasActiveEditor(): boolean {\n    return !!this.editSession && !!this.column.hasEditorPortal();\n  }\n\n  initialiseRenderer(ref: CdkPortalOutletAttachedRef) {\n    this.column.onRendererAttached(this, ref);\n  }\n\n  initialiseEditor(ref: CdkPortalOutletAttachedRef) {\n    this.column.onEditorAttached(this, ref);\n    if (this.firstEditableColumn.value) {\n      // @see https://github.com/angular/components/issues/12070\n      setTimeout(() => this.tryAndFocusEditor(ref));\n    }\n  }\n\n  private tryAndFocusEditor(ref: CdkPortalOutletAttachedRef) {\n    if (ref instanceof ComponentRef) {\n      const editor = ref.instance;\n      // CellEditorComponent<Row> | CellListEditorComponent<Row>\n      if (editor.requestFocus) {\n        editor.requestFocus();\n      } else {\n        const model = (editor['valueModel'] || editor['listModel']) as HasFocusContext;\n        model?.focusContext?.requestFocus();\n      }\n    }\n\n  }\n\n  // @Trace()\n  ngOnChanges(changes: SimpleChanges): void {\n    this.column.updatePortalContent(this);\n  }\n\n  getRendererPortal() {\n    return this[CELL_RENDERER_PORTAL];\n  }\n\n  getEditorPortal() {\n    return this[CELL_EDITOR_PORTAL];\n  }\n\n  getRowData(): RowData<Row> {\n    return {\n      row: this.row,\n      editSession: this.editSession,\n      editRowCommand: this.editRowCommand\n    };\n  }\n}\n","<ng-container *ngIf=\"!hasActiveEditor()\" [cdkPortalOutlet]=\"getRendererPortal()\" (attached)=\"initialiseRenderer($event)\"></ng-container>\n<ng-container *ngIf=\"hasActiveEditor()\" [cdkPortalOutlet]=\"getEditorPortal()\" (attached)=\"initialiseEditor($event)\"></ng-container>\n"]}

package/esm2020/lib/components/tables/renderer/table-header-cell/table-header-cell.component.mjs

@@ -0,0 +1,32 @@
+import { Component, HostBinding, Input } from '@angular/core';
+import { ColumnModel } from '../../column/column-model';
+import { HEADER_CELL_RENDERER_PORTAL } from '../cell-portal-ref';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/portal";
+export class TableHeaderCellComponent {
+    constructor() {
+        this.defaultClassNames = 'aup-header-cell-renderer';
+    }
+    ngOnInit() {
+        this.column.attachHeaderCell(this);
+    }
+    // @Trace()
+    initialiseHeader(ref) {
+        this.column.onHeaderAttached(this, ref);
+    }
+    getPortal() {
+        return this[HEADER_CELL_RENDERER_PORTAL];
+    }
+}
+TableHeaderCellComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: TableHeaderCellComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+TableHeaderCellComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.3", type: TableHeaderCellComponent, selector: "aup-table-header-cell", inputs: { column: "column" }, host: { properties: { "class": "this.defaultClassNames" } }, ngImport: i0, template: "<ng-container [cdkPortalOutlet]=\"getPortal()\" (attached)=\"initialiseHeader($event)\"></ng-container>\n", styles: [":host{display:flex;flex-direction:column;align-items:stretch;justify-content:center;height:100%}\n"], directives: [{ type: i1.CdkPortalOutlet, selector: "[cdkPortalOutlet]", inputs: ["cdkPortalOutlet"], outputs: ["attached"], exportAs: ["cdkPortalOutlet"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: TableHeaderCellComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'aup-table-header-cell', template: "<ng-container [cdkPortalOutlet]=\"getPortal()\" (attached)=\"initialiseHeader($event)\"></ng-container>\n", styles: [":host{display:flex;flex-direction:column;align-items:stretch;justify-content:center;height:100%}\n"] }]
+        }], ctorParameters: function () { return []; }, propDecorators: { column: [{
+                type: Input
+            }], defaultClassNames: [{
+                type: HostBinding,
+                args: ['class']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFibGUtaGVhZGVyLWNlbGwuY29tcG9uZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9hbmd1bGFyLXVpLXBvd2VydXBzL3NyYy9saWIvY29tcG9uZW50cy90YWJsZXMvcmVuZGVyZXIvdGFibGUtaGVhZGVyLWNlbGwvdGFibGUtaGVhZGVyLWNlbGwuY29tcG9uZW50LnRzIiwiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9hbmd1bGFyLXVpLXBvd2VydXBzL3NyYy9saWIvY29tcG9uZW50cy90YWJsZXMvcmVuZGVyZXIvdGFibGUtaGVhZGVyLWNlbGwvdGFibGUtaGVhZGVyLWNlbGwuY29tcG9uZW50Lmh0bWwiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsT0FBTyxFQUFDLFNBQVMsRUFBZ0IsV0FBVyxFQUFFLEtBQUssRUFBUyxNQUFNLGVBQWUsQ0FBQztBQUVsRixPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sMkJBQTJCLENBQUM7QUFDeEQsT0FBTyxFQUFFLDJCQUEyQixFQUFFLE1BQU0sb0JBQW9CLENBQUM7OztBQU9qRSxNQUFNLE9BQU8sd0JBQXdCO0lBVW5DO1FBSkEsc0JBQWlCLEdBQUcsMEJBQTBCLENBQUM7SUFLL0MsQ0FBQztJQUVELFFBQVE7UUFDTixJQUFJLENBQUMsTUFBTSxDQUFDLGdCQUFnQixDQUFDLElBQUksQ0FBQyxDQUFDO0lBQ3JDLENBQUM7SUFFRCxXQUFXO0lBQ1gsZ0JBQWdCLENBQUMsR0FBK0I7UUFDOUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxnQkFBZ0IsQ0FBQyxJQUFJLEVBQUUsR0FBRyxDQUFDLENBQUM7SUFDMUMsQ0FBQztJQUVELFNBQVM7UUFDUCxPQUFPLElBQUksQ0FBQywyQkFBMkIsQ0FBQyxDQUFDO0lBQzNDLENBQUM7O3FIQXhCVSx3QkFBd0I7eUdBQXhCLHdCQUF3Qix3SkNackMsMkdBQ0E7MkZEV2Esd0JBQXdCO2tCQUxwQyxTQUFTOytCQUNFLHVCQUF1QjswRUFPakMsTUFBTTtzQkFETCxLQUFLO2dCQUlOLGlCQUFpQjtzQkFEaEIsV0FBVzt1QkFBQyxPQUFPIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgUG9ydGFsIH0gZnJvbSAnQGFuZ3VsYXIvY2RrL3BvcnRhbCc7XG5pbXBvcnQge0Nka1BvcnRhbE91dGxldEF0dGFjaGVkUmVmfSBmcm9tIFwiQGFuZ3VsYXIvY2RrL3BvcnRhbC9wb3J0YWwtZGlyZWN0aXZlc1wiO1xuaW1wb3J0IHtDb21wb25lbnQsIENvbXBvbmVudFJlZiwgSG9zdEJpbmRpbmcsIElucHV0LCBPbkluaXR9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHtsYW5nfSBmcm9tIFwiQGNvb2xvbi90eXBlc2NyaXB0LXV0aWxpdGllc1wiO1xuaW1wb3J0IHsgQ29sdW1uTW9kZWwgfSBmcm9tICcuLi8uLi9jb2x1bW4vY29sdW1uLW1vZGVsJztcbmltcG9ydCB7IEhFQURFUl9DRUxMX1JFTkRFUkVSX1BPUlRBTCB9IGZyb20gJy4uL2NlbGwtcG9ydGFsLXJlZic7XG5cbkBDb21wb25lbnQoe1xuICBzZWxlY3RvcjogJ2F1cC10YWJsZS1oZWFkZXItY2VsbCcsXG4gIHRlbXBsYXRlVXJsOiAnLi90YWJsZS1oZWFkZXItY2VsbC5jb21wb25lbnQuaHRtbCcsXG4gIHN0eWxlVXJsczogWycuL3RhYmxlLWhlYWRlci1jZWxsLmNvbXBvbmVudC5zY3NzJ11cbn0pXG5leHBvcnQgY2xhc3MgVGFibGVIZWFkZXJDZWxsQ29tcG9uZW50IGltcGxlbWVudHMgT25Jbml0IHtcblxuICBASW5wdXQoKVxuICBjb2x1bW46IENvbHVtbk1vZGVsPGFueT47XG5cbiAgQEhvc3RCaW5kaW5nKCdjbGFzcycpXG4gIGRlZmF1bHRDbGFzc05hbWVzID0gJ2F1cC1oZWFkZXItY2VsbC1yZW5kZXJlcic7XG5cbiAgW0hFQURFUl9DRUxMX1JFTkRFUkVSX1BPUlRBTF06IFBvcnRhbDxhbnk+O1xuXG4gIGNvbnN0cnVjdG9yKCkge1xuICB9XG5cbiAgbmdPbkluaXQoKSB7XG4gICAgdGhpcy5jb2x1bW4uYXR0YWNoSGVhZGVyQ2VsbCh0aGlzKTtcbiAgfVxuXG4gIC8vIEBUcmFjZSgpXG4gIGluaXRpYWxpc2VIZWFkZXIocmVmOiBDZGtQb3J0YWxPdXRsZXRBdHRhY2hlZFJlZikge1xuICAgIHRoaXMuY29sdW1uLm9uSGVhZGVyQXR0YWNoZWQodGhpcywgcmVmKTtcbiAgfVxuXG4gIGdldFBvcnRhbCgpIHtcbiAgICByZXR1cm4gdGhpc1tIRUFERVJfQ0VMTF9SRU5ERVJFUl9QT1JUQUxdO1xuICB9XG59XG4iLCI8bmctY29udGFpbmVyIFtjZGtQb3J0YWxPdXRsZXRdPVwiZ2V0UG9ydGFsKClcIiAoYXR0YWNoZWQpPVwiaW5pdGlhbGlzZUhlYWRlcigkZXZlbnQpXCI+PC9uZy1jb250YWluZXI+XG4iXX0=

package/esm2020/lib/components/tables/search/column-text-search-formatter.mjs

@@ -0,0 +1,52 @@
+export class ColumnTextSearchFormatter {
+}
+(function (ColumnTextSearchFormatter) {
+    class Delegate extends ColumnTextSearchFormatter {
+    }
+    ColumnTextSearchFormatter.Delegate = Delegate;
+    class Delegating extends ColumnTextSearchFormatter.Delegate {
+        constructor(delegateClass) {
+            super();
+            this.delegateClass = delegateClass;
+        }
+        initialise(injector) {
+            this._delegate = injector.get(this.delegateClass);
+            if (this._delegate instanceof Delegating) {
+                this._delegate.initialise(injector);
+            }
+        }
+        format(row) {
+            return this._delegate ? this._delegate.format(row) : "";
+        }
+    }
+    ColumnTextSearchFormatter.Delegating = Delegating;
+    function forFormatter(formatter) {
+        return new class extends ColumnTextSearchFormatter {
+            format(value) {
+                return formatter(value);
+            }
+        };
+    }
+    ColumnTextSearchFormatter.forFormatter = forFormatter;
+    class Null extends ColumnTextSearchFormatter {
+        format(value) {
+            return "";
+        }
+    }
+    ColumnTextSearchFormatter.Null = Null;
+    class DefaultValueFormatter extends ColumnTextSearchFormatter {
+        format(value) {
+            let s = value?.toString() ?? "";
+            console.log("DefaultValueFormatter", { value, text: s });
+            return s;
+        }
+    }
+    ColumnTextSearchFormatter.DefaultValueFormatter = DefaultValueFormatter;
+    class DefaultArrayFormatter extends ColumnTextSearchFormatter {
+        format(value) {
+            return value ? value.map(it => it?.toString()).join(",") : "";
+        }
+    }
+    ColumnTextSearchFormatter.DefaultArrayFormatter = DefaultArrayFormatter;
+})(ColumnTextSearchFormatter || (ColumnTextSearchFormatter = {}));
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/components/tables/search/enable-cell-text-search.decorator.mjs

@@ -0,0 +1,30 @@
+import { Klass, assert } from "@coolon/typescript-utilities";
+import { Enum } from "typescript-string-enums";
+import { ColumnTextSearchFormatter } from "./column-text-search-formatter";
+const TEXT_SEARCH_FORMATTER_KEY = `aup:table:textSearchFormatter`;
+export const Keys = Enum("useFunction", "useInstance", "useClass");
+export function EnableCellTextSearch(options) {
+    assert.notNil(options);
+    return (constructor) => {
+        const klass = Klass.get(constructor);
+        assert.isFalsey(klass.hasOwnMetadata(TEXT_SEARCH_FORMATTER_KEY), "class already decorated with @EnableCellTextSearch");
+        klass.defineMetadata(TEXT_SEARCH_FORMATTER_KEY, options);
+    };
+}
+(function (EnableCellTextSearch) {
+    function getFormatter(renderer, useDefault) {
+        const options = Klass.get(renderer).getMetadata(TEXT_SEARCH_FORMATTER_KEY) ?? {};
+        if (options[Keys.useFunction]) {
+            return ColumnTextSearchFormatter.forFormatter(options[Keys.useFunction]);
+        }
+        if (options[Keys.useInstance]) {
+            return options[Keys.useInstance];
+        }
+        if (options[Keys.useClass]) {
+            return new ColumnTextSearchFormatter.Delegating(options[Keys.useClass]);
+        }
+        return useDefault();
+    }
+    EnableCellTextSearch.getFormatter = getFormatter;
+})(EnableCellTextSearch || (EnableCellTextSearch = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW5hYmxlLWNlbGwtdGV4dC1zZWFyY2guZGVjb3JhdG9yLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9hbmd1bGFyLXVpLXBvd2VydXBzL3NyYy9saWIvY29tcG9uZW50cy90YWJsZXMvc2VhcmNoL2VuYWJsZS1jZWxsLXRleHQtc2VhcmNoLmRlY29yYXRvci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQUUsS0FBSyxFQUFFLE1BQU0sRUFBdUIsTUFBTSw4QkFBOEIsQ0FBQztBQUNsRixPQUFPLEVBQUUsSUFBSSxFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFDL0MsT0FBTyxFQUFFLHlCQUF5QixFQUFFLE1BQU0sZ0NBQWdDLENBQUM7QUFJM0UsTUFBTSx5QkFBeUIsR0FBRywrQkFBK0IsQ0FBQztBQUNsRSxNQUFNLENBQUMsTUFBTSxJQUFJLEdBQUcsSUFBSSxDQUFDLGFBQWEsRUFBRSxhQUFhLEVBQUUsVUFBVSxDQUFDLENBQUM7QUFlbkUsTUFBTSxVQUFVLG9CQUFvQixDQUFNLE9BQTREO0lBQ3BHLE1BQU0sQ0FBQyxNQUFNLENBQUMsT0FBTyxDQUFDLENBQUM7SUFDdkIsT0FBTyxDQUFDLFdBQXFCLEVBQUUsRUFBRTtRQUMvQixNQUFNLEtBQUssR0FBRyxLQUFLLENBQUMsR0FBRyxDQUFDLFdBQVcsQ0FBQyxDQUFDO1FBQ3JDLE1BQU0sQ0FBQyxRQUFRLENBQUMsS0FBSyxDQUFDLGNBQWMsQ0FBQyx5QkFBeUIsQ0FBQyxFQUFFLG9EQUFvRCxDQUFDLENBQUM7UUFDdkgsS0FBSyxDQUFDLGNBQWMsQ0FBQyx5QkFBeUIsRUFBRSxPQUFPLENBQUMsQ0FBQztJQUMzRCxDQUFDLENBQUM7QUFDSixDQUFDO0FBRUQsV0FBaUIsb0JBQW9CO0lBQ25DLFNBQWdCLFlBQVksQ0FBQyxRQUEwQyxFQUFFLFVBQWdEO1FBQ3ZILE1BQU0sT0FBTyxHQUFHLEtBQUssQ0FBQyxHQUFHLENBQUMsUUFBUSxDQUFDLENBQUMsV0FBVyxDQUFDLHlCQUF5QixDQUFDLElBQUksRUFBRSxDQUFDO1FBQ2pGLElBQUksT0FBTyxDQUFDLElBQUksQ0FBQyxXQUFXLENBQUMsRUFBRTtZQUM3QixPQUFPLHlCQUF5QixDQUFDLFlBQVksQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLFdBQVcsQ0FBQyxDQUFDLENBQUM7U0FDMUU7UUFDRCxJQUFJLE9BQU8sQ0FBQyxJQUFJLENBQUMsV0FBVyxDQUFDLEVBQUU7WUFDN0IsT0FBTyxPQUFPLENBQUMsSUFBSSxDQUFDLFdBQVcsQ0FBQyxDQUFDO1NBQ2xDO1FBQ0QsSUFBSSxPQUFPLENBQUMsSUFBSSxDQUFDLFFBQVEsQ0FBQyxFQUFFO1lBQzFCLE9BQU8sSUFBSSx5QkFBeUIsQ0FBQyxVQUFVLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxRQUFRLENBQUMsQ0FBQyxDQUFDO1NBQ3pFO1FBQ0QsT0FBTyxVQUFVLEVBQUUsQ0FBQztJQUN0QixDQUFDO0lBWmUsaUNBQVksZUFZM0IsQ0FBQTtBQUNILENBQUMsRUFkZ0Isb0JBQW9CLEtBQXBCLG9CQUFvQixRQWNwQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENvbXBvbmVudFR5cGUgfSBmcm9tIFwiQGFuZ3VsYXIvY2RrL292ZXJsYXlcIjtcbmltcG9ydCB7IEtsYXNzLCBhc3NlcnQsIGxhbmcsIENvbnN0cnVjdGFibGUgfSBmcm9tIFwiQGNvb2xvbi90eXBlc2NyaXB0LXV0aWxpdGllc1wiO1xuaW1wb3J0IHsgRW51bSB9IGZyb20gXCJ0eXBlc2NyaXB0LXN0cmluZy1lbnVtc1wiO1xuaW1wb3J0IHsgQ29sdW1uVGV4dFNlYXJjaEZvcm1hdHRlciB9IGZyb20gXCIuL2NvbHVtbi10ZXh0LXNlYXJjaC1mb3JtYXR0ZXJcIjtcbmltcG9ydCAqIGFzIF8gZnJvbSBcImxvZGFzaFwiO1xuaW1wb3J0IHsgQ2VsbFJlbmRlcmVyIH0gZnJvbSBcIi4uL3JlbmRlcmVyL2NlbGwtcmVuZGVyZXJcIjtcblxuY29uc3QgVEVYVF9TRUFSQ0hfRk9STUFUVEVSX0tFWSA9IGBhdXA6dGFibGU6dGV4dFNlYXJjaEZvcm1hdHRlcmA7XG5leHBvcnQgY29uc3QgS2V5cyA9IEVudW0oXCJ1c2VGdW5jdGlvblwiLCBcInVzZUluc3RhbmNlXCIsIFwidXNlQ2xhc3NcIik7XG5leHBvcnQgdHlwZSBLZXlzID0gRW51bTx0eXBlb2YgS2V5cz47XG5cbmludGVyZmFjZSBVc2VGdW5jdGlvbjxSb3c+IHtcbiAgW0tleXMudXNlRnVuY3Rpb25dOiAocm93OiBSb3cpID0+IHN0cmluZztcbn1cblxuaW50ZXJmYWNlIFVzZUluc3RhbmNlPFJvdz4ge1xuICBbS2V5cy51c2VJbnN0YW5jZV06IENvbHVtblRleHRTZWFyY2hGb3JtYXR0ZXI8Um93Pjtcbn1cblxuaW50ZXJmYWNlIFVzZUNsYXNzPFJvdz4ge1xuICBbS2V5cy51c2VDbGFzc106IENvbnN0cnVjdGFibGU8Q29sdW1uVGV4dFNlYXJjaEZvcm1hdHRlcjxSb3c+Pjtcbn1cblxuZXhwb3J0IGZ1bmN0aW9uIEVuYWJsZUNlbGxUZXh0U2VhcmNoPFJvdz4ob3B0aW9uczogVXNlRnVuY3Rpb248Um93PiB8IFVzZUluc3RhbmNlPFJvdz4gfCBVc2VDbGFzczxSb3c+KTogQ2xhc3NEZWNvcmF0b3Ige1xuICBhc3NlcnQubm90TmlsKG9wdGlvbnMpO1xuICByZXR1cm4gKGNvbnN0cnVjdG9yOiBGdW5jdGlvbikgPT4ge1xuICAgIGNvbnN0IGtsYXNzID0gS2xhc3MuZ2V0KGNvbnN0cnVjdG9yKTtcbiAgICBhc3NlcnQuaXNGYWxzZXkoa2xhc3MuaGFzT3duTWV0YWRhdGEoVEVYVF9TRUFSQ0hfRk9STUFUVEVSX0tFWSksIFwiY2xhc3MgYWxyZWFkeSBkZWNvcmF0ZWQgd2l0aCBARW5hYmxlQ2VsbFRleHRTZWFyY2hcIik7XG4gICAga2xhc3MuZGVmaW5lTWV0YWRhdGEoVEVYVF9TRUFSQ0hfRk9STUFUVEVSX0tFWSwgb3B0aW9ucyk7XG4gIH07XG59XG5cbmV4cG9ydCBuYW1lc3BhY2UgRW5hYmxlQ2VsbFRleHRTZWFyY2gge1xuICBleHBvcnQgZnVuY3Rpb24gZ2V0Rm9ybWF0dGVyKHJlbmRlcmVyOiBDb21wb25lbnRUeXBlPENlbGxSZW5kZXJlcjxhbnk+PiwgdXNlRGVmYXVsdDogKCkgPT4gQ29sdW1uVGV4dFNlYXJjaEZvcm1hdHRlcjxhbnk+KTogQ29sdW1uVGV4dFNlYXJjaEZvcm1hdHRlcjxhbnk+IHtcbiAgICBjb25zdCBvcHRpb25zID0gS2xhc3MuZ2V0KHJlbmRlcmVyKS5nZXRNZXRhZGF0YShURVhUX1NFQVJDSF9GT1JNQVRURVJfS0VZKSA/PyB7fTtcbiAgICBpZiAob3B0aW9uc1tLZXlzLnVzZUZ1bmN0aW9uXSkge1xuICAgICAgcmV0dXJuIENvbHVtblRleHRTZWFyY2hGb3JtYXR0ZXIuZm9yRm9ybWF0dGVyKG9wdGlvbnNbS2V5cy51c2VGdW5jdGlvbl0pO1xuICAgIH1cbiAgICBpZiAob3B0aW9uc1tLZXlzLnVzZUluc3RhbmNlXSkge1xuICAgICAgcmV0dXJuIG9wdGlvbnNbS2V5cy51c2VJbnN0YW5jZV07XG4gICAgfVxuICAgIGlmIChvcHRpb25zW0tleXMudXNlQ2xhc3NdKSB7XG4gICAgICByZXR1cm4gbmV3IENvbHVtblRleHRTZWFyY2hGb3JtYXR0ZXIuRGVsZWdhdGluZyhvcHRpb25zW0tleXMudXNlQ2xhc3NdKTtcbiAgICB9XG4gICAgcmV0dXJuIHVzZURlZmF1bHQoKTtcbiAgfVxufVxuIl19

package/esm2020/lib/components/tables/table/table-model.mjs

@@ -1,4 +1,4 @@
-import { AbstractTableModel } from '../abstract-table-model';
+import { AbstractTableModel } from "../abstract-table-model";
 /**
  * Example:
  * @example
@@ -86,16 +86,8 @@ export class TableModel extends AbstractTableModel {
         }
         this.setDataSource(sourceOfTruth);
     }
-    /**
-     * @deprecated use new TableModel(sourceOfTruth, table => {...}); instead.
-     * @param sourceOfTruth
-     * @param builder
-     */
-    static fromList(sourceOfTruth, builder) {
-        return new TableModel(sourceOfTruth, builder);
-    }
     addSelectionColumn(selectionModel, showSelectionColumn) {
         return this._addSelectionColumn(selectionModel, showSelectionColumn);
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFibGUtbW9kZWwuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2FuZ3VsYXItdWktcG93ZXJ1cHMvc3JjL2xpYi9jb21wb25lbnRzL3RhYmxlcy90YWJsZS90YWJsZS1tb2RlbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQztBQUc3RDs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0dBOEVHO0FBQ0gsTUFBTSxPQUFPLFVBQWdCLFNBQVEsa0JBQXVCO0lBRTFELFlBQVksYUFBNkIsRUFBRSxPQUEwQztRQUNuRixLQUFLLEVBQUUsQ0FBQztRQUNSLElBQUksT0FBTyxFQUFFO1lBQ1gsT0FBTyxDQUFDLElBQUksQ0FBQyxDQUFDO1NBQ2Y7UUFDRCxJQUFJLENBQUMsYUFBYSxDQUFDLGFBQWEsQ0FBQyxDQUFDO0lBQ3BDLENBQUM7SUFFRCxrQkFBa0IsQ0FBQyxjQUFvQyxFQUFFLG1CQUFtRDtRQUMxRyxPQUFPLElBQUksQ0FBQyxtQkFBbUIsQ0FBQyxjQUFjLEVBQUUsbUJBQW1CLENBQUMsQ0FBQztJQUN2RSxDQUFDO0NBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBMaXN0TW9kZWwsIFNlbGVjdGlvbk1vZGVsLCBWYWx1ZU1vZGVsIH0gZnJvbSBcIkBjb29sb24vcGVjdGluXCI7XG5pbXBvcnQgeyBBYnN0cmFjdFRhYmxlTW9kZWwgfSBmcm9tIFwiLi4vYWJzdHJhY3QtdGFibGUtbW9kZWxcIjtcbmltcG9ydCB7IFNlbGVjdGlvbkNvbHVtbk1vZGVsIH0gZnJvbSBcIi4uL2NvbHVtbi9zZWxlY3Rpb24tY29sdW1uLW1vZGVsXCI7XG5cbi8qKlxuICogRXhhbXBsZTpcbiAqIEBleGFtcGxlXG4gKiBjb25zdCBtb2RlbCA9IG5ldyBUYWJsZU1vZGVsKGhlcm9MaXN0LCB0YWJsZSA9PiB7XG4gKiAgIHRhYmxlLnBsdWNrKFwiZmlyc3ROYW1lXCIpO1xuICogICB0YWJsZS5wbHVjayhcImxhc3ROYW1lXCIpO1xuICogICB0YWJsZS5hZGRDdXN0b21Db2x1bW4oXCJmdWxsTmFtZVwiLCBoZXJvID0+IGAke2hlcm8uZmlyc3ROYW1lfSAke2hlcm8ubGFzdE5hbWV9YCk7XG4gKiB9KTtcbiAqXG4gKiBFZGl0YWJsZSB0YWJsZXNcbiAqIEBleGFtcGxlXG4gKiBjb25zdCBzYXZlQ29tbWFuZCA9IFVuYXJ5Q29tbWFuZC5jcmVhdGUoKGZvcm06IEZvcm08SGVybz4pID0+IHtcbiAqICAgaWYgKGZvcm0udmFsaWRhdGUoKSkge1xuICogICAgIC8vIG5vcm1hbCBmb3JtIHNhdmUgc3R1ZmZcbiAqICAgICByZXR1cm4gdHJ1ZTsgLy8gZmluaXNoIGVkaXRpbmdcbiAqICAgfVxuICogICByZXR1cm4gZmFsc2U7IC8vIGNvbnRpbnVlIGVkaXRpaW5nXG4gKiB9XG4gKiBjb25zdCBjb2xvcnNOYW1lczogTGlzdE1vZGVsPHN0cmluZz4gPSAuLi47XG4gKiBjb25zdCBtb2RlbCA9IFRhYmxlTW9kZWwuZnJvbUxpc3QoaGVyb0xpc3QsIHRhYmxlID0+IHtcbiAqICAgdGFibGUucGx1Y2soXCJmaXJzdE5hbWVcIikuY2VsbEVkaXRvcihTdHJpbmdJbnB1dENvbXBvbmVudCk7IDwtLSBpbnRlcmZhY2UgQ2VsbEVkaXRvciB7IHZhbHVlTW9kZWw6ICBEaXJ0eVRyYWNraW5nRm9ybS5WYWx1ZU1vZGVsPHN0cmluZz4gfCBWYWx1ZU1vZGVsPHN0cmluZz47IH1cbiAqICAgdGFibGUucGx1Y2soXCJsYXN0TmFtZVwiKS5jZWxsRWRpdG9yKFN0cmluZ0lucHV0Q29tcG9uZW50LCB7XG4gKiAgICAgdmFsaWRhdG9yczogW1ZhbGlkYXRvci5wcmVzZW50KFwiV2UgbmVlZCBhIGxhc3QgbmFtZVwiKV1cbiAqICAgfSk7XG4gKiAgIHRhYmxlLnBsdWNrKFwiYWdlXCIpLmNlbGxFZGl0b3IoTnVtYmVySW5wdXRDb21wb25lbnQpO1xuICogICB0YWJsZS5wbHVjayhcImZhdm9yaXRlQ29sb3JcIikuY2VsbEVkaXRvcihTZWxlY3RJbnB1dENvbXBvbmVudCwge1xuICogICAgIGluaXRpYWxpc2VDb21wb25lbnQoY29tcG9uZW50OiBTZWxlY3RJbnB1dENvbXBvbmVudCkge1xuICogICAgICAgc2VsZWN0SW5wdXQub3B0aW9uc01vZGVsID0gY29sb3JzTmFtZXM7IC8vIDwtIGluaXRpYWxpc2Ugb3VyIGNvbXBvbmVudFxuICogICAgIH1cbiAqICAgfSk7XG4gKiAgIHRhYmxlLmFkZEVkaXRDb250cm9scyhzYXZlQ29tbWFuZCk7IC8vIDwtIHJlcXVpcmVkIHRvIGVuYWJsZSBlZGl0aW5nXG4gKiB9KTtcbiAqXG4gKiBTZWxlY3Rpb24gbW9kZWxzXG4gKiBAZXhhbXBsZVxuICogY29uc3QgbW9kZWwgPSBuZXcgVGFibGVNb2RlbChoZXJvTGlzdCwgdGFibGUgPT4ge1xuICogICB0YWJsZS5hZGRTZWxlY3Rpb25Db2x1bW4oc2VsZWN0aW9uTW9kZWwpOyAvLyA8LSBjYW4gYmUgc2luZ2xlIG9yIG11bHRpcGxlIHNlbGVjdGlvbiBtb2RlbFxuICogICB0YWJsZS5wbHVjayhcImZpcnN0TmFtZVwiKTtcbiAqICAgdGFibGUucGx1Y2soXCJsYXN0TmFtZVwiKTtcbiAqIH0pO1xuICpcbiAqIEN1c3RvbSBjZWxsIHJlbmRlcmVycyBhbmQgZWRpdG9yc1xuICogQGV4YW1wbGVcbiAqIGNvbnN0IG1vZGVsID0gbmV3IFRhYmxlTW9kZWwoaGVyb0xpc3QsIHRhYmxlID0+IHtcbiAqICAgdGFibGUucGx1Y2soXCJmYXZvcml0ZUNvbG9yXCIpXG4gKiAgICAgIC5jZWxsSGVhZGVyUmVuZGVyZXIoQ2VsbEhlYWRlclJlbmRlcmVyQ29tcG9uZW50LCAoY29tcG9uZW50LCBjb2x1bW4pID0+IHtcbiAqICAgICAgICAvLyBjb25maWd1cmUgeW91ciBjb21wb25lbnQgd2l0aCB3aGF0IGV2ZXIgeW91IG5lZWQuXG4gKiAgICAgIH0pO1xuICogICAgICAuY2VsbFJlbmRlcmVyKENlbGxSZW5kZXJlckNvbXBvbmVudCkgLy8gPC0tIGludGVyZmFjZSBDZWxsRWRpdG9yIHsgdmFsdWU6IHN0cmluZzsgfVxuICogICAgICAuY2VsbEVkaXRvcihDZWxsRWRpdG9yQ29tcG9uZW50Lik7IC8vIDwtLSBpbnRlcmZhY2UgQ2VsbEVkaXRvciB7IHZhbHVlTW9kZWw6ICBEaXJ0eVRyYWNraW5nRm9ybS5WYWx1ZU1vZGVsPHN0cmluZz4gfCBWYWx1ZU1vZGVsPHN0cmluZz47IH1cbiAqICAgdGFibGUuYWRkQ3VzdG9tQ29sdW1uKFwiZnVsbE5hbWVcIiwgaGVybyA9PiBgJHtoZXJvLmZpcnN0TmFtZX0gJHtoZXJvLmxhc3ROYW1lfWApO1xuICogfSk7XG4gKlxuICogVGVtcGxhdGUgY29sdW1uc1xuICogQGV4YW1wbGVcbiAqIGNvbnN0IG1vZGVsID0gbmV3IFRhYmxlTW9kZWwoaGVyb0xpc3QsIHRhYmxlID0+IHtcbiAqICAgdGFibGUuYWRkU2VsZWN0aW9uQ29sdW1uKHNlbGVjdGlvbk1vZGVsKTsgLy8gPC0gY2FuIGJlIHNpbmdsZSBvciBtdWx0aXBsZSBzZWxlY3Rpb24gbW9kZWxcbiAqICAgdGFibGUuYWRkVGVtcGxhdGVDb2x1bW4oXCJteVRlbXBsYXRlXCIpO1xuICogfSk7XG4gKlxuICogPGRpdiAqYXVwQ29sdW1uVGVtcGxhdGU9XCJsZXQgaGVybzsgY29sdW1uSWQ6ICdteVRlbXBsYXRlJ1wiPnt7aGVyby5hZ2V9fTwvZGl2PlxuICpcbiAqIEkxOG5cbiAqIEBleGFtcGxlXG4gKiBbdGFibGUueW1sXVxuICogdGFibGU6XG4gKiAgIGNvbHVtbnMoQ29sdW1uVGV4dFByb3BlcnRpZXNbXSk6XG4gKiAgICAgIGZpcnN0TmFtZTpcbiAqICAgICAgICAgaGVhZGVyVGV4dDogXCJGaXJzdCBOYW1lXCJcbiAqICAgICAgZnVsbE5hbWU6XG4gKiAgICAgICAgIGhlYWRlclRleHQ6IFwiRnVsbCBOYW1lXCJcbiAqXG4gKiBjb25zdCBtb2RlbCA9IG5ldyBUYWJsZU1vZGVsKGhlcm9MaXN0LCB0YWJsZSA9PiB7XG4gKiAgIHRhYmxlLnBsdWNrKFwiZmF2b3JpdGVDb2xvclwiKS5jZWxsUmVuZGVyZXIoLi4uKS5jZWxsRWRpdG9yKC4uLik7XG4gKiAgIHRhYmxlLmFkZEN1c3RvbUNvbHVtbihcImZ1bGxOYW1lXCIsIGhlcm8gPT4gYCR7aGVyby5maXJzdE5hbWV9ICR7aGVyby5sYXN0TmFtZX1gKTtcbiAqXG4gKiAgIHRhYmxlLmNvbHVtblRleHRQcm9wZXJ0aWVzKEkxOG4udGFibGUuY29sdW1ucyk7IC8vIDwtIGNvbmZpZ3VyZXMgYWxsIGNvbHVtbnNcbiAqIH0pO1xuICovXG5leHBvcnQgY2xhc3MgVGFibGVNb2RlbDxSb3c+IGV4dGVuZHMgQWJzdHJhY3RUYWJsZU1vZGVsPFJvdz4ge1xuXG4gIGNvbnN0cnVjdG9yKHNvdXJjZU9mVHJ1dGg6IExpc3RNb2RlbDxSb3c+LCBidWlsZGVyPzogKHRhYmxlOiBUYWJsZU1vZGVsPFJvdz4pID0+IHZvaWQpIHtcbiAgICBzdXBlcigpO1xuICAgIGlmIChidWlsZGVyKSB7XG4gICAgICBidWlsZGVyKHRoaXMpO1xuICAgIH1cbiAgICB0aGlzLnNldERhdGFTb3VyY2Uoc291cmNlT2ZUcnV0aCk7XG4gIH1cblxuICBhZGRTZWxlY3Rpb25Db2x1bW4oc2VsZWN0aW9uTW9kZWw/OiBTZWxlY3Rpb25Nb2RlbDxSb3c+LCBzaG93U2VsZWN0aW9uQ29sdW1uPzogVmFsdWVNb2RlbDxib29sZWFuPiB8IGJvb2xlYW4pOiBTZWxlY3Rpb25Db2x1bW5Nb2RlbDxSb3c+IHtcbiAgICByZXR1cm4gdGhpcy5fYWRkU2VsZWN0aW9uQ29sdW1uKHNlbGVjdGlvbk1vZGVsLCBzaG93U2VsZWN0aW9uQ29sdW1uKTtcbiAgfVxufVxuIl19

package/esm2020/lib/components/tables/table/table.component.mjs

@@ -1,17 +1,17 @@
 import { __decorate, __metadata } from "tslib";
-import { Component, ElementRef, Input, NgZone } from '@angular/core';
+import { Component, ElementRef, Injector, Input, NgZone } from "@angular/core";
 import { TrackExternal } from '@coolon/pectin';
 import { AbstractTableModel } from '../abstract-table-model';
 import { AbstractTableComponent } from '../abstract-table.component';
 import * as i0 from "@angular/core";
 import * as i1 from "@angular/material/table";
-import * as i2 from "./table-header-cell-renderer/table-header-cell-renderer.component";
-import * as i3 from "./table-cell-renderer/table-cell-renderer.component";
+import * as i2 from "../renderer/table-header-cell/table-header-cell.component";
+import * as i3 from "../renderer/table-cell/table-cell.component";
 import * as i4 from "@angular/common";
 /**
  * Create your model:
  * @example
- * this.heroTableModel = TableModel.fromList(heroList, table => {
+ * this.heroTableModel = new TableModel(heroList, table => {
  *   table.pluck("firstName");
  *   table.pluck("lastName");
  *   table.addCustomColumn("fullName", hero => `${hero.firstName} ${hero.lastName}`);
@@ -23,7 +23,7 @@ import * as i4 from "@angular/common";
  *
  * Column templates
  * @example
- * this.heroTableModel = TableModel.fromList(heroList, table => {
+ * this.heroTableModel = new TableModel(heroList, table => {
  *   table.pluck("firstName");
  *   table.pluck("lastName");
  *   table.addTemplateColumn("specialColumn");
@@ -69,17 +69,17 @@ import * as i4 from "@angular/common";
  * }
  */
 export class TableComponent extends AbstractTableComponent {
-    constructor(elementRef, ngZone) {
-        super(elementRef, ngZone);
+    constructor(elementRef, ngZone, injector) {
+        super(elementRef, ngZone, injector);
     }
     getModel() {
         return this.tableModel;
     }
 }
-TableComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: TableComponent, deps: [{ token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+TableComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: TableComponent, deps: [{ token: i0.ElementRef }, { token: i0.NgZone }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Component });
 TableComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.3", type: TableComponent, selector: "aup-table", inputs: { tableModel: "tableModel" }, providers: [
         { provide: AbstractTableComponent, useExisting: TableComponent }
-    ], usesInheritance: true, ngImport: i0, template: "<div class=\"scroll-container\">\n  <table mat-table [dataSource]=\"getModel().dataSource.value\" [trackBy]=\"getModel().trackBy\">\n\n    <ng-container *ngFor=\"let column of columns.value; index as index; first as first; last as last\"\n                  matColumnDef=\"{{column.columnId}}\">\n      <th mat-header-cell *matHeaderCellDef [class.flex]=\"column.isFlex()\" [class.hide]=\"!column.isVisible()\">\n        <aup-table-header-cell-renderer [column]=\"column\"\n                                        [attr.column-index]=\"index\"\n                                        [attr.column-id]=\"column.columnId\"\n                                        [class]=\"getColumnClasses(column.columnId)\"\n        ></aup-table-header-cell-renderer>\n      </th>\n      <td mat-cell *matCellDef=\"let row\" (click)=\"notifyCellClicked(column, row)\"\n          [class.enable-cursor]=\"getModel().isCursorEnabled(column)\"\n          [class.flex]=\"column.isFlex()\"\n          [class.hide]=\"!column.isVisible()\"\n      >\n        <aup-table-cell-renderer [column]=\"column\"\n                                 [row]=\"row\"\n                                 [tableModel]=\"getModel()\"\n                                 [editSession]=\"getModel().getEditSessionFor(row)\"\n                                 [attr.column-index]=\"index\"\n                                 [attr.column-id]=\"column.columnId\"\n                                 [class]=\"getColumnClasses(column.columnId)\"\n        ></aup-table-cell-renderer>\n      </td>\n    </ng-container>\n\n    <tr mat-header-row *matHeaderRowDef=\"columnIds.value\"></tr>\n    <tr mat-row *matRowDef=\"let row; columns: columnIds.value; let i = index\"\n        [ngClass]=\"getModel().getRowClasses(row)\" [class.enable-hover]=\"getModel().isHoverEnabled()\"\n        [attr.aup-row-id]=\"getModel().trackBy(i, row)\"\n    ></tr>\n\n  </table>\n</div>\n", styles: [":host{display:flex;flex-direction:column;align-items:stretch}:host table{width:100%}:host.enable-scrolling{min-height:0}:host.enable-scrolling .scroll-container{flex:1;flex-basis:0;overflow-y:auto;display:flex;flex-direction:column;align-items:stretch}\n"], components: [{ type: i1.MatTable, selector: "mat-table, table[mat-table]", exportAs: ["matTable"] }, { type: i2.TableHeaderCellRendererComponent, selector: "aup-table-header-cell-renderer", inputs: ["column"] }, { type: i3.TableCellRendererComponent, selector: "aup-table-cell-renderer", inputs: ["row", "column", "editSession", "tableModel"] }, { type: i1.MatHeaderRow, selector: "mat-header-row, tr[mat-header-row]", exportAs: ["matHeaderRow"] }, { type: i1.MatRow, selector: "mat-row, tr[mat-row]", exportAs: ["matRow"] }], directives: [{ type: i4.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i1.MatColumnDef, selector: "[matColumnDef]", inputs: ["sticky", "matColumnDef"] }, { type: i1.MatHeaderCellDef, selector: "[matHeaderCellDef]" }, { type: i1.MatHeaderCell, selector: "mat-header-cell, th[mat-header-cell]" }, { type: i1.MatCellDef, selector: "[matCellDef]" }, { type: i1.MatCell, selector: "mat-cell, td[mat-cell]" }, { type: i1.MatHeaderRowDef, selector: "[matHeaderRowDef]", inputs: ["matHeaderRowDef", "matHeaderRowDefSticky"] }, { type: i1.MatRowDef, selector: "[matRowDef]", inputs: ["matRowDefColumns", "matRowDefWhen"] }, { type: i4.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }] });
+    ], usesInheritance: true, ngImport: i0, template: "<div class=\"scroll-container\">\n  <table mat-table [dataSource]=\"getModel().dataSource.value\" [trackBy]=\"getModel().trackBy\">\n\n    <ng-container *ngFor=\"let column of columns.value; index as index; first as first; last as last\"\n                  matColumnDef=\"{{column.columnId}}\">\n      <th mat-header-cell *matHeaderCellDef [class.flex]=\"column.isFlex()\" [class.hide]=\"!column.isVisible()\">\n        <aup-table-header-cell [column]=\"column\"\n                               [attr.column-index]=\"index\"\n                               [attr.column-id]=\"column.columnId\"\n                               [class]=\"getColumnClasses(column.columnId)\"\n        ></aup-table-header-cell>\n      </th>\n      <td mat-cell *matCellDef=\"let row\" (click)=\"notifyCellClicked(column, row)\"\n          [class.enable-cursor]=\"getModel().isCursorEnabled(column)\"\n          [class.flex]=\"column.isFlex()\"\n          [class.hide]=\"!column.isVisible()\"\n      >\n        <aup-table-cell [column]=\"column\"\n                        [row]=\"row\"\n                        [tableModel]=\"getModel()\"\n                        [editSession]=\"getModel().getEditSessionFor(row)\"\n                        [attr.column-index]=\"index\"\n                        [attr.column-id]=\"column.columnId\"\n                        [class]=\"getColumnClasses(column.columnId)\"\n        ></aup-table-cell>\n      </td>\n    </ng-container>\n\n    <tr mat-header-row *matHeaderRowDef=\"columnIds.value\"></tr>\n    <tr mat-row *matRowDef=\"let row; columns: columnIds.value; let i = index\"\n        [ngClass]=\"getModel().getRowClasses(row)\" [class.enable-hover]=\"getModel().isHoverEnabled()\"\n        [attr.aup-row-id]=\"getModel().trackBy(i, row)\"\n    ></tr>\n\n  </table>\n</div>\n", styles: [":host{display:flex;flex-direction:column;align-items:stretch}:host table{width:100%}:host.enable-scrolling{min-height:0}:host.enable-scrolling .scroll-container{flex:1;flex-basis:0;overflow-y:auto;display:flex;flex-direction:column;align-items:stretch}\n"], components: [{ type: i1.MatTable, selector: "mat-table, table[mat-table]", exportAs: ["matTable"] }, { type: i2.TableHeaderCellComponent, selector: "aup-table-header-cell", inputs: ["column"] }, { type: i3.TableCellComponent, selector: "aup-table-cell", inputs: ["row", "column", "editSession", "tableModel"] }, { type: i1.MatHeaderRow, selector: "mat-header-row, tr[mat-header-row]", exportAs: ["matHeaderRow"] }, { type: i1.MatRow, selector: "mat-row, tr[mat-row]", exportAs: ["matRow"] }], directives: [{ type: i4.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i1.MatColumnDef, selector: "[matColumnDef]", inputs: ["sticky", "matColumnDef"] }, { type: i1.MatHeaderCellDef, selector: "[matHeaderCellDef]" }, { type: i1.MatHeaderCell, selector: "mat-header-cell, th[mat-header-cell]" }, { type: i1.MatCellDef, selector: "[matCellDef]" }, { type: i1.MatCell, selector: "mat-cell, td[mat-cell]" }, { type: i1.MatHeaderRowDef, selector: "[matHeaderRowDef]", inputs: ["matHeaderRowDef", "matHeaderRowDefSticky"] }, { type: i1.MatRowDef, selector: "[matRowDef]", inputs: ["matRowDefColumns", "matRowDefWhen"] }, { type: i4.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }] });
 __decorate([
     TrackExternal(),
     __metadata("design:type", AbstractTableModel)
@@ -88,8 +88,8 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.3", ngImpor
             type: Component,
             args: [{ selector: 'aup-table', providers: [
                         { provide: AbstractTableComponent, useExisting: TableComponent }
-                    ], template: "<div class=\"scroll-container\">\n  <table mat-table [dataSource]=\"getModel().dataSource.value\" [trackBy]=\"getModel().trackBy\">\n\n    <ng-container *ngFor=\"let column of columns.value; index as index; first as first; last as last\"\n                  matColumnDef=\"{{column.columnId}}\">\n      <th mat-header-cell *matHeaderCellDef [class.flex]=\"column.isFlex()\" [class.hide]=\"!column.isVisible()\">\n        <aup-table-header-cell-renderer [column]=\"column\"\n                                        [attr.column-index]=\"index\"\n                                        [attr.column-id]=\"column.columnId\"\n                                        [class]=\"getColumnClasses(column.columnId)\"\n        ></aup-table-header-cell-renderer>\n      </th>\n      <td mat-cell *matCellDef=\"let row\" (click)=\"notifyCellClicked(column, row)\"\n          [class.enable-cursor]=\"getModel().isCursorEnabled(column)\"\n          [class.flex]=\"column.isFlex()\"\n          [class.hide]=\"!column.isVisible()\"\n      >\n        <aup-table-cell-renderer [column]=\"column\"\n                                 [row]=\"row\"\n                                 [tableModel]=\"getModel()\"\n                                 [editSession]=\"getModel().getEditSessionFor(row)\"\n                                 [attr.column-index]=\"index\"\n                                 [attr.column-id]=\"column.columnId\"\n                                 [class]=\"getColumnClasses(column.columnId)\"\n        ></aup-table-cell-renderer>\n      </td>\n    </ng-container>\n\n    <tr mat-header-row *matHeaderRowDef=\"columnIds.value\"></tr>\n    <tr mat-row *matRowDef=\"let row; columns: columnIds.value; let i = index\"\n        [ngClass]=\"getModel().getRowClasses(row)\" [class.enable-hover]=\"getModel().isHoverEnabled()\"\n        [attr.aup-row-id]=\"getModel().trackBy(i, row)\"\n    ></tr>\n\n  </table>\n</div>\n", styles: [":host{display:flex;flex-direction:column;align-items:stretch}:host table{width:100%}:host.enable-scrolling{min-height:0}:host.enable-scrolling .scroll-container{flex:1;flex-basis:0;overflow-y:auto;display:flex;flex-direction:column;align-items:stretch}\n"] }]
-        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.NgZone }]; }, propDecorators: { tableModel: [{
+                    ], template: "<div class=\"scroll-container\">\n  <table mat-table [dataSource]=\"getModel().dataSource.value\" [trackBy]=\"getModel().trackBy\">\n\n    <ng-container *ngFor=\"let column of columns.value; index as index; first as first; last as last\"\n                  matColumnDef=\"{{column.columnId}}\">\n      <th mat-header-cell *matHeaderCellDef [class.flex]=\"column.isFlex()\" [class.hide]=\"!column.isVisible()\">\n        <aup-table-header-cell [column]=\"column\"\n                               [attr.column-index]=\"index\"\n                               [attr.column-id]=\"column.columnId\"\n                               [class]=\"getColumnClasses(column.columnId)\"\n        ></aup-table-header-cell>\n      </th>\n      <td mat-cell *matCellDef=\"let row\" (click)=\"notifyCellClicked(column, row)\"\n          [class.enable-cursor]=\"getModel().isCursorEnabled(column)\"\n          [class.flex]=\"column.isFlex()\"\n          [class.hide]=\"!column.isVisible()\"\n      >\n        <aup-table-cell [column]=\"column\"\n                        [row]=\"row\"\n                        [tableModel]=\"getModel()\"\n                        [editSession]=\"getModel().getEditSessionFor(row)\"\n                        [attr.column-index]=\"index\"\n                        [attr.column-id]=\"column.columnId\"\n                        [class]=\"getColumnClasses(column.columnId)\"\n        ></aup-table-cell>\n      </td>\n    </ng-container>\n\n    <tr mat-header-row *matHeaderRowDef=\"columnIds.value\"></tr>\n    <tr mat-row *matRowDef=\"let row; columns: columnIds.value; let i = index\"\n        [ngClass]=\"getModel().getRowClasses(row)\" [class.enable-hover]=\"getModel().isHoverEnabled()\"\n        [attr.aup-row-id]=\"getModel().trackBy(i, row)\"\n    ></tr>\n\n  </table>\n</div>\n", styles: [":host{display:flex;flex-direction:column;align-items:stretch}:host table{width:100%}:host.enable-scrolling{min-height:0}:host.enable-scrolling .scroll-container{flex:1;flex-basis:0;overflow-y:auto;display:flex;flex-direction:column;align-items:stretch}\n"] }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.NgZone }, { type: i0.Injector }]; }, propDecorators: { tableModel: [{
                 type: Input
             }] } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/components/tables/table-row-menu/table-row-menu.component.mjs

@@ -0,0 +1,84 @@
+import { Component, Input, ViewChild } from '@angular/core';
+import { MatMenuTrigger } from '@angular/material/menu';
+import { Dsl } from '@coolon/pectin';
+import { DisposableComponent } from '../../disposable-component';
+import * as i0 from "@angular/core";
+import * as i1 from "../../commands/group/tool-bar/tool-bar.component";
+import * as i2 from "../../commands/command/command.component";
+import * as i3 from "../../commands/group/popup-menu/more-menu.component";
+import * as i4 from "@angular/common";
+class MenuItemData {
+    constructor(factory, face) {
+        this.factory = factory;
+        this.face = face;
+    }
+}
+/**
+ *
+ */
+export class TableRowMenuComponent extends DisposableComponent {
+    constructor() {
+        super();
+        this.actions = [];
+        this.moreActions = [];
+    }
+    registerAction(commandFactory, properties) {
+        this.actions.push(new MenuItemData(commandFactory, properties));
+    }
+    registerMoreAction(commandFactory, properties) {
+        this.moreActions.push(new MenuItemData(commandFactory, properties));
+    }
+    createMoreMenuCommand(item, value) {
+        const { when } = Dsl.disposeWith(this);
+        const command = item.factory.create(value);
+        when(command.busy).becomesFalsey(() => {
+            this.closeMoreMenu();
+        });
+        return command;
+    }
+    closeMoreMenu() {
+        this.menu.closeMenu();
+    }
+}
+TableRowMenuComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: TableRowMenuComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+TableRowMenuComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.3", type: TableRowMenuComponent, selector: "aup-table-row-menu", inputs: { value: "value" }, viewQueries: [{ propertyName: "menu", first: true, predicate: MatMenuTrigger, descendants: true }], usesInheritance: true, ngImport: i0, template: `
+      <aup-tool-bar>
+          <aup-command *ngFor="let action of actions" [command]="action.factory.create(value)"
+                       [face]="action.face"></aup-command>
+      </aup-tool-bar>
+      <ng-container *ngIf="moreActions.length > 0">
+          <aup-more-menu>
+              <aup-command *ngFor="let action of moreActions" [command]="action.factory.create(value)"
+                           [face]="action.face"></aup-command>
+          </aup-more-menu>
+      </ng-container>
+  `, isInline: true, styles: [":host{display:inline-flex;flex-direction:row;align-items:center}\n"], components: [{ type: i1.ToolBarComponent, selector: "aup-tool-bar" }, { type: i2.CommandComponent, selector: "aup-command", inputs: ["command", "faceModel", "face", "busyFaceModel", "busyFace", "alignFace"] }, { type: i3.MoreMenuComponent, selector: "aup-more-menu", inputs: ["tooltip"] }], directives: [{ type: i4.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i4.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: TableRowMenuComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'aup-table-row-menu',
+                    template: `
+      <aup-tool-bar>
+          <aup-command *ngFor="let action of actions" [command]="action.factory.create(value)"
+                       [face]="action.face"></aup-command>
+      </aup-tool-bar>
+      <ng-container *ngIf="moreActions.length > 0">
+          <aup-more-menu>
+              <aup-command *ngFor="let action of moreActions" [command]="action.factory.create(value)"
+                           [face]="action.face"></aup-command>
+          </aup-more-menu>
+      </ng-container>
+  `,
+                    styles: [`:host {
+    display: inline-flex;
+    flex-direction: row;
+    align-items: center;
+  }`]
+                }]
+        }], ctorParameters: function () { return []; }, propDecorators: { value: [{
+                type: Input
+            }], menu: [{
+                type: ViewChild,
+                args: [MatMenuTrigger]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/components/tables/tree-table/tree-label-cell-renderer/tree-label-cell-renderer.component.mjs

@@ -88,4 +88,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.3", ngImpor
                 'mat:chevron_right';
     };
 })(TreeLabelCellRendererComponent || (TreeLabelCellRendererComponent = {}));
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tree-label-cell-renderer.component.js","sourceRoot":"","sources":["../../../../../../../../../libs/angular-ui-powerups/src/lib/components/tables/tree-table/tree-label-cell-renderer/tree-label-cell-renderer.component.ts","../../../../../../../../../libs/angular-ui-powerups/src/lib/components/tables/tree-table/tree-label-cell-renderer/tree-label-cell-renderer.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, HostBinding, Input, OnInit } from '@angular/core';\nimport { Dsl, ListModelChain, MutableValueModel, StoreInValueModel, ValueModelChain } from '@coolon/pectin';\nimport { DisposableComponent } from '../../../disposable-component';\nimport { CellRenderer } from '../../table/cell-renderer';\nimport { DecoratedTreeNode } from '../decorated-tree-node';\nimport { TreeExpansionModel } from '../tree-expansion-model';\nimport { TreeInheritanceIconComponent } from '../tree-inheritance-icon/tree-inheritance-icon.component';\nimport { TreeTableModel } from '../tree-table-model';\n\n@Component({\n  selector: 'aup-tree-label-cell-renderer',\n  templateUrl: './tree-label-cell-renderer.component.html',\n  styleUrls: ['./tree-label-cell-renderer.component.scss']\n})\nexport class TreeLabelCellRendererComponent<T> extends DisposableComponent implements CellRenderer<T>, OnInit {\n\n  private nodeModel = new MutableValueModel<T>();\n\n  @Input()\n  @StoreInValueModel('nodeModel')\n  value: T;\n\n  @Input()\n  label: string;\n\n  @Input()\n  iconFactory: TreeTableModel.IconFactory<T>;\n\n  // TODO: Make this have a proper delegate so I can safely use it here..\n  @Input()\n  treeTableModel: TreeTableModel<T>;\n\n  readonly iconList: ListModelChain<TreeInheritanceIconComponent.Type>;\n\n  canExpand: ValueModelChain<boolean>;\n  canCollapse: ValueModelChain<boolean>;\n  iconModel: ValueModelChain<string>;\n\n  constructor() {\n    super();\n    const { chain } = Dsl.disposeWith(this);\n    this.iconList = chain(this.nodeModel).mapToList(node => {\n      const icons: TreeInheritanceIconComponent.Type[] = DecoratedTreeNode.getDecorator(node).ancestors().slice(1).map(ancestor => {\n        return DecoratedTreeNode.getDecorator(ancestor).isLastChild() ? TreeInheritanceIconComponent.Type.ICON_BLANK : TreeInheritanceIconComponent.Type.ICON_THROUGH;\n      });\n      if (!DecoratedTreeNode.getDecorator(node).isRoot()) {\n        icons.push(DecoratedTreeNode.getDecorator(node).isLastChild() ? TreeInheritanceIconComponent.Type.ICON_INHERITED_TERMINAL : TreeInheritanceIconComponent.Type.ICON_INHERITED_THROUGH_TERMINAL);\n      }\n      return icons;\n    });\n  }\n\n  ngOnInit(): void {\n    const { chain } = Dsl.disposeWith(this);\n    this.canExpand = chain(this.nodeModel).map(node => {\n      return DecoratedTreeNode.getDecorator(node).hasChildren() && this.treeTableModel.isCollapsed(node);\n    }, { dependsOn: this.treeTableModel.treeExpansionModel.isExpandedPredicate });\n\n    this.canCollapse = chain(this.nodeModel).map(node => {\n      return DecoratedTreeNode.getDecorator(node).hasChildren() && !this.treeTableModel.isCollapsed(node);\n    }, { dependsOn: this.treeTableModel.treeExpansionModel.isExpandedPredicate });\n\n    this.iconModel = chain(this.nodeModel).map(node => {\n      const expanded = this.treeTableModel.treeExpansionModel.isExpanded(this.node);\n      const iconFactory = this.iconFactory ?? TreeLabelCellRendererComponent.DEFAULT_ICON_FACTORY;\n      return iconFactory(node, expanded, TreeLabelCellRendererComponent.DEFAULT_ICON_FACTORY(node, expanded, undefined));\n    }, { dependsOn: this.treeTableModel.treeExpansionModel.isExpandedPredicate });\n  }\n\n  @HostBinding('class.root')\n  get isRoot() {\n    return DecoratedTreeNode.getDecorator(this.node).isRoot();\n  }\n\n  @HostBinding('class.leaf')\n  get isLeaf() {\n    return DecoratedTreeNode.getDecorator(this.node).isLeaf();\n  }\n\n  get node() {\n    return this.nodeModel.value;\n  }\n\n  // @Trace()\n  expandOrCollapse($event: MouseEvent, node: T) {\n    $event.preventDefault();\n    $event.stopPropagation();\n    this.treeTableModel.isCollapsed(node) ? this.treeTableModel.expand(node) : this.treeTableModel.collapse(node);\n  }\n}\n\nexport namespace TreeLabelCellRendererComponent {\n  export const DEFAULT_ICON_FACTORY: TreeTableModel.IconFactory<any> = (node: any, expanded: boolean, defaultIcon: string) => {\n    const isLeaf = DecoratedTreeNode.getDecorator(node).isLeaf();\n    return isLeaf ?\n      undefined :\n      expanded ?\n        'mat:expand_more' :\n        'mat:chevron_right';\n  };\n}\n","<div class=\"tree-icons\">\n  <aup-tree-inheritance-icon *ngFor=\"let type of iconList.value\" [type]=\"type\"></aup-tree-inheritance-icon>\n  <aup-icon *ngIf=\"iconModel.value\"\n            [icon]=\"iconModel.value\"\n            [class.clickable]=\"canExpand.value || canCollapse.value\"\n            (click)=\"expandOrCollapse($event, node)\" ></aup-icon>\n</div>\n<div class=\"label\">{{label}}</div>\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tree-label-cell-renderer.component.js","sourceRoot":"","sources":["../../../../../../../../../libs/angular-ui-powerups/src/lib/components/tables/tree-table/tree-label-cell-renderer/tree-label-cell-renderer.component.ts","../../../../../../../../../libs/angular-ui-powerups/src/lib/components/tables/tree-table/tree-label-cell-renderer/tree-label-cell-renderer.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, HostBinding, Input, OnInit } from '@angular/core';\nimport { Dsl, ListModelChain, MutableValueModel, StoreInValueModel, ValueModelChain } from '@coolon/pectin';\nimport { DisposableComponent } from '../../../disposable-component';\nimport { CellRenderer } from '../../renderer/cell-renderer';\nimport { DecoratedTreeNode } from '../decorated-tree-node';\nimport { TreeExpansionModel } from '../tree-expansion-model';\nimport { TreeInheritanceIconComponent } from '../tree-inheritance-icon/tree-inheritance-icon.component';\nimport { TreeTableModel } from '../tree-table-model';\n\n@Component({\n  selector: 'aup-tree-label-cell-renderer',\n  templateUrl: './tree-label-cell-renderer.component.html',\n  styleUrls: ['./tree-label-cell-renderer.component.scss']\n})\nexport class TreeLabelCellRendererComponent<T> extends DisposableComponent implements CellRenderer<T>, OnInit {\n\n  private nodeModel = new MutableValueModel<T>();\n\n  @Input()\n  @StoreInValueModel('nodeModel')\n  value: T;\n\n  @Input()\n  label: string;\n\n  @Input()\n  iconFactory: TreeTableModel.IconFactory<T>;\n\n  // TODO: Make this have a proper delegate so I can safely use it here..\n  @Input()\n  treeTableModel: TreeTableModel<T>;\n\n  readonly iconList: ListModelChain<TreeInheritanceIconComponent.Type>;\n\n  canExpand: ValueModelChain<boolean>;\n  canCollapse: ValueModelChain<boolean>;\n  iconModel: ValueModelChain<string>;\n\n  constructor() {\n    super();\n    const { chain } = Dsl.disposeWith(this);\n    this.iconList = chain(this.nodeModel).mapToList(node => {\n      const icons: TreeInheritanceIconComponent.Type[] = DecoratedTreeNode.getDecorator(node).ancestors().slice(1).map(ancestor => {\n        return DecoratedTreeNode.getDecorator(ancestor).isLastChild() ? TreeInheritanceIconComponent.Type.ICON_BLANK : TreeInheritanceIconComponent.Type.ICON_THROUGH;\n      });\n      if (!DecoratedTreeNode.getDecorator(node).isRoot()) {\n        icons.push(DecoratedTreeNode.getDecorator(node).isLastChild() ? TreeInheritanceIconComponent.Type.ICON_INHERITED_TERMINAL : TreeInheritanceIconComponent.Type.ICON_INHERITED_THROUGH_TERMINAL);\n      }\n      return icons;\n    });\n  }\n\n  ngOnInit(): void {\n    const { chain } = Dsl.disposeWith(this);\n    this.canExpand = chain(this.nodeModel).map(node => {\n      return DecoratedTreeNode.getDecorator(node).hasChildren() && this.treeTableModel.isCollapsed(node);\n    }, { dependsOn: this.treeTableModel.treeExpansionModel.isExpandedPredicate });\n\n    this.canCollapse = chain(this.nodeModel).map(node => {\n      return DecoratedTreeNode.getDecorator(node).hasChildren() && !this.treeTableModel.isCollapsed(node);\n    }, { dependsOn: this.treeTableModel.treeExpansionModel.isExpandedPredicate });\n\n    this.iconModel = chain(this.nodeModel).map(node => {\n      const expanded = this.treeTableModel.treeExpansionModel.isExpanded(this.node);\n      const iconFactory = this.iconFactory ?? TreeLabelCellRendererComponent.DEFAULT_ICON_FACTORY;\n      return iconFactory(node, expanded, TreeLabelCellRendererComponent.DEFAULT_ICON_FACTORY(node, expanded, undefined));\n    }, { dependsOn: this.treeTableModel.treeExpansionModel.isExpandedPredicate });\n  }\n\n  @HostBinding('class.root')\n  get isRoot() {\n    return DecoratedTreeNode.getDecorator(this.node).isRoot();\n  }\n\n  @HostBinding('class.leaf')\n  get isLeaf() {\n    return DecoratedTreeNode.getDecorator(this.node).isLeaf();\n  }\n\n  get node() {\n    return this.nodeModel.value;\n  }\n\n  // @Trace()\n  expandOrCollapse($event: MouseEvent, node: T) {\n    $event.preventDefault();\n    $event.stopPropagation();\n    this.treeTableModel.isCollapsed(node) ? this.treeTableModel.expand(node) : this.treeTableModel.collapse(node);\n  }\n}\n\nexport namespace TreeLabelCellRendererComponent {\n  export const DEFAULT_ICON_FACTORY: TreeTableModel.IconFactory<any> = (node: any, expanded: boolean, defaultIcon: string) => {\n    const isLeaf = DecoratedTreeNode.getDecorator(node).isLeaf();\n    return isLeaf ?\n      undefined :\n      expanded ?\n        'mat:expand_more' :\n        'mat:chevron_right';\n  };\n}\n","<div class=\"tree-icons\">\n  <aup-tree-inheritance-icon *ngFor=\"let type of iconList.value\" [type]=\"type\"></aup-tree-inheritance-icon>\n  <aup-icon *ngIf=\"iconModel.value\"\n            [icon]=\"iconModel.value\"\n            [class.clickable]=\"canExpand.value || canCollapse.value\"\n            (click)=\"expandOrCollapse($event, node)\" ></aup-icon>\n</div>\n<div class=\"label\">{{label}}</div>\n"]}