@energycap/components 0.31.0 → 0.31.1-ECAP-12439-angular-14.20220901-1019

package/esm2020/lib/display/table/table-selectable-row.component.mjs

@@ -0,0 +1,235 @@
+import { Component, HostBinding, HostListener, Input } from '@angular/core';
+import { FormArray, FormControl } from '@angular/forms';
+import { Subject } from 'rxjs';
+import { debounceTime, takeUntil } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "./table-locked-column.component";
+import * as i2 from "../../controls/checkbox/checkbox.component";
+import * as i3 from "@angular/common";
+export class TableSelectableRowContext {
+    constructor() {
+        /**specify the form control to use for the selectAll checkbox or provide your own.
+         * This can be useful if you want to subscribe to changes to change button states as the selection changes
+         * or if you want to add it to an already-existing form group
+         */
+        this.selectAllCheckbox = new FormControl(false);
+        /**specify the FormArray to use for the dependent checkboxes of the selectAll checkbox
+         * The dependent checkboxes will add and remove themselves automatically and the selectAll
+         * box will react accordingly. Do not provide your own controls
+         * This can be useful if you want to subscribe to changes to change button states as the selection changes
+         * or if you want to add it to an already-existing form group
+         */
+        this.rowCheckboxes = new FormArray([]);
+        /**The index of the last row the user clicked. This allows multiple directives on a screen to coordinate
+         * for reacting to shift+click actions that should automatically select multiple rows between the clicked rows
+         * defaults to -1 to indicate that no user click has been captured
+         */
+        this.lastClickedIndex = -1;
+        /**A subject that is triggered when a row-based directive is added or removed. It allows
+         * the master checkbox in the header to know that it needs to reset tracking information
+         * without replacing the actual FormArray that the hosting component may be subscribed to for changes
+         */
+        this.rowAddedOrRemoved = new Subject();
+        /**
+         * Set to true to disable Shift-Click/Ctrl-Click functionality
+         */
+        this.disableAdvancedRowClickBehavior = false;
+        /**
+         * Set to list of indices of controls that should not toggle when master/header checkbox toggles
+         */
+        this.nonDependentCheckboxes = [];
+    }
+}
+export class TableSelectableRowComponent {
+    constructor() {
+        /**The ID root to use for the checkbox and table cell */
+        this.id = '';
+        this._selectionEnabled = true;
+        /*Required for all rows. The row index this component represents, to allow it to know how to handle shift+clicks.
+          Defaults to -1 which will cause the directive to behave as a header row*/
+        this.rowIndex = -1;
+        /**The options used to lock the checkbox column to the left of the table, must be modified by host
+         * if the checkbox is not the first column in the table
+         */
+        this.lockedColOptions = { border: false, left: 0 };
+        /** Automatically set to true based on checkbox state, used to highlight the row to match our table selected row styles */
+        this.isSelected = false;
+        /** Automatically set to true if no rowIndex is provided or the row index is less than zero */
+        this.isHeader = false;
+        /**
+         * Set to true if you want the checkbox to be disabled.
+         *
+         * When you use this property, make sure you set `disableAdvancedRowClickBehavior: true`
+         * in the `TableSelectableRowContext`, or undesired side-effects will occur.
+         */
+        this.isCheckboxDisabled = false;
+        /* A reference that we can change when a control is replaced to force the master checkbox reference to update
+           without also replacing the form array that the host component may be watching for selected row changes */
+        this.dependentCheckboxesReference = { controls: [] };
+        this.checkboxAttributeID = '';
+        /**Sends an event when the component is destroyed so that it can unsubscribe from any observables */
+        this.destroyed = new Subject();
+    }
+    /** Disables the selection functionality when false */
+    set isSelectionEnabled(value) { this._selectionEnabled = value !== false; }
+    get isSelectionEnabled() { return this._selectionEnabled; }
+    /**Validate and populate the context as the table is dynamically built. Because the context is shared between the
+     * header and each of the rows, changes to it can be used to determine what is happening and hook up the correct
+     * subscriptions for selectAll. The user can provide an existing formArray for the rows and form control for the header,
+     * or it can just be the default empty ones created by the context class.
+    */
+    ngOnInit() {
+        this.isHeader = this.rowIndex < 0;
+        if (!this.context) {
+            console.error('ecTableSelectableRow requires a defined SelectableTableRowContext to be shared with all instances in one table.');
+        }
+        else {
+            let rowCheckbox = this.context?.rowCheckboxes?.at(this.rowIndex);
+            if (!this.isHeader && !rowCheckbox) {
+                rowCheckbox = new FormControl(this.isSelected);
+                this.context?.rowCheckboxes.push(rowCheckbox);
+            }
+            this.formControl = this.isHeader ? this.context.selectAllCheckbox : rowCheckbox;
+            this.watchForChanges();
+        }
+    }
+    /**Watch for changes to the row index that can occur if the table is reordered in-place instead of
+     * recreated from scratch. Re-capture the correct form control to keep everything in sync
+     */
+    ngOnChanges(changes) {
+        if (changes.rowIndex && !this.isHeader) {
+            this.formControl = this.context.rowCheckboxes.at(this.rowIndex);
+            this.checkboxAttributeID = `${this.id}_row${this.rowIndex}_ecCheckbox`;
+        }
+        if (changes.isSelectionEnabled && !this.isSelectionEnabled && this.formControl?.value === true) {
+            this.formControl.setValue(false);
+        }
+        if (changes.isSelected && this.formControl) {
+            this.formControl.setValue(this.isSelected);
+        }
+    }
+    /** Tell the header checkbox to refresh the selectAll subscription because a row was removed*/
+    ngOnDestroy() {
+        if (!this.isHeader && this.formControl) {
+            this.context.rowAddedOrRemoved.next();
+            //find the location in the array that matches the checkbox. If many rows are being removed it may not match rowIndex yet
+            let matchIndex = this.context.rowCheckboxes.controls.findIndex(c => c == this.formControl);
+            if (matchIndex >= 0) {
+                this.context.rowCheckboxes.removeAt(matchIndex);
+            }
+        }
+    }
+    /**Handle when a user clicks on a table row (or something inside it which bubbles up) to increase the hit area for row selection
+     * Only work on the table body (not the header) because the header may have other click handlers for sort etc that we don't care about.
+     * Handle shift and control select as well as checkbox click like windows explorer or the original bill lists do.
+    */
+    rowClicked(event) {
+        if (!this.isHeader && this.isSelectionEnabled && !this.isCheckboxDisabled) {
+            let targetEl = event?.target;
+            //clicking on a row always toggles that row. Sometimes the shift-select will toggle it back
+            this.formControl.setValue(!this.formControl.value);
+            if (!this.context.disableAdvancedRowClickBehavior) {
+                this.handleShiftSelect(event);
+            }
+        }
+    }
+    watchForChanges() {
+        //watch for rows being replaced so that the master checkbox and shift-select support can be reset to match
+        //this keeps the master in sync as the table changes pages etc and stops unexpected rows from being selected after redraw
+        if (this.isHeader) {
+            this.context.rowAddedOrRemoved.pipe(debounceTime(10), takeUntil(this.destroyed)).subscribe(() => {
+                this.context.lastClickedIndex = -1;
+                // exclude nonDependentCheckboxes (some may not be allowed to be deselected)
+                let dependentCheckboxes = [];
+                this.context.rowCheckboxes.controls.forEach((control, index) => {
+                    if (!this.context.nonDependentCheckboxes.includes(index)) {
+                        dependentCheckboxes.push(control);
+                    }
+                });
+                this.dependentCheckboxesReference = { controls: dependentCheckboxes };
+            });
+        }
+        else {
+            this.context.rowAddedOrRemoved.next();
+            //watch for the checkbox state to change on a child row and set the row isSelected class / highlight to match
+            //this way the rows match even if external code updates the form model
+            this.formControl?.valueChanges.pipe(takeUntil(this.destroyed)).subscribe((value) => {
+                this.isSelected = value;
+            });
+        }
+    }
+    /**
+      * If they are holding the shift key, try to select all the checkboxes between their last selection
+      * and most recent selection. The logic is setup to behave the way windows explorer behaves
+      * We don't allow drag-to-select like the kendo tables, but it means users can highlight text and copy+paste to excel etc
+      * so I think this is actually preferable
+      */
+    handleShiftSelect(event) {
+        let lastIndex = this.context.lastClickedIndex;
+        let curIndex = this.rowIndex;
+        if (event.shiftKey && lastIndex >= 0) {
+            this.clearAllRows();
+            if (curIndex > lastIndex) {
+                for (var index = lastIndex; index <= curIndex; index++) {
+                    this.context.rowCheckboxes.at(index).setValue(true);
+                }
+            }
+            else if (curIndex < lastIndex) {
+                for (var index = lastIndex; index >= curIndex; index--) {
+                    this.context.rowCheckboxes.at(index).setValue(true);
+                }
+            }
+            else if (curIndex === lastIndex) {
+                this.formControl.setValue(true);
+            }
+            document.getSelection()?.removeAllRanges();
+        }
+        else {
+            //record the current row index for future row clicks to know where they last interacted
+            //but only if they don't have shift down for this click. If shift is down then the next shift+click
+            //should be considered an extension (or contraction) of the original multi-row selection
+            this.context.lastClickedIndex = this.rowIndex;
+        }
+    }
+    clearAllRows() {
+        this.context.rowCheckboxes.controls.forEach(control => control.setValue(false));
+    }
+}
+TableSelectableRowComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: TableSelectableRowComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+TableSelectableRowComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.11", type: TableSelectableRowComponent, selector: "[ecTableSelectableRow]", inputs: { id: "id", isSelectionEnabled: ["ecTableSelectableRow", "isSelectionEnabled"], context: ["selectionContext", "context"], rowIndex: "rowIndex", lockedColOptions: "lockedColOptions", isSelected: "isSelected", isCheckboxDisabled: "isCheckboxDisabled" }, host: { listeners: { "click": "rowClicked($event)" }, properties: { "attr.id": "this.id", "class.is-enabled": "this.isSelectionEnabled", "class.is-selected": "this.isSelected", "class.is-header": "this.isHeader" } }, usesOnChanges: true, ngImport: i0, template: "<!-- any elements of the existing table row that must go before the row selection checkbox can be marked with a class of before-checkbox -->\r\n<ng-content select=\".before-checkbox\"></ng-content>\r\n<ng-container *ngIf=\"isSelectionEnabled\">\r\n  <th *ngIf=\"isHeader\"\r\n      class=\"checkbox\"\r\n      [ecTableLockedColumn]=\"lockedColOptions\">\r\n    <ec-checkbox id=\"{{id}}_selectAll\"\r\n                 class=\"m-0\"\r\n                 *ngIf=\"context?.selectAllCheckbox\"\r\n                 [formModel]=\"context?.selectAllCheckbox\"\r\n                 [dependentCheckboxesGroup]=\"dependentCheckboxesReference\"\r\n                 [ignoreDisabledDependents]=\"false\">\r\n    </ec-checkbox>\r\n  </th>\r\n  <td *ngIf=\"!isHeader && formControl\"\r\n      class=\"checkbox\"\r\n      [ecTableLockedColumn]=\"lockedColOptions\">\r\n    <!-- Use [readonly] and not [disabled] for isCheckboxDisabled to prevent user interaction\r\n         and allow the value to be visible to other components (for example, when they subscribe\r\n         to valueChanges on the FormArray that contains all the checkbox FormControls). -->\r\n    <ec-checkbox id=\"{{id}}_row{{rowIndex}}_checkbox\"\r\n                 [readonly]=\"isCheckboxDisabled\"\r\n                 [attr.id]=\"checkboxAttributeID\"\r\n                 class=\"m-0 row-checkbox\"\r\n                 [formModel]=\"formControl\">\r\n    </ec-checkbox>\r\n  </td>\r\n</ng-container>\r\n<!-- The rest of the table row -->\r\n<ng-content></ng-content>", styles: [":host.is-enabled:not(.is-header){cursor:pointer}:host .checkbox{padding-left:1px;padding-right:1px;width:1.125rem}:host .checkbox:first-child{padding-left:.5rem;width:1.5625rem}:host.border-bottom-0 .checkbox{border-bottom:0}td.checkbox ec-checkbox ::ng-deep *{pointer-events:none}th.checkbox{vertical-align:var(--ec-table-selectable-row-vertical-align-checkbox-th, middle)}td.checkbox{vertical-align:var(--ec-table-selectable-row-vertical-align-checkbox-td, top)}\n"], components: [{ type: i1.TableLockedColumnComponent, selector: "[ecTableLockedColumn]", inputs: ["ecTableLockedColumn"] }, { type: i2.CheckboxComponent, selector: "ec-checkbox", inputs: ["name", "dependentCheckboxesGroup", "ignoreDisabledDependents"] }], directives: [{ type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: TableSelectableRowComponent, decorators: [{
+            type: Component,
+            args: [{ selector: '[ecTableSelectableRow]', template: "<!-- any elements of the existing table row that must go before the row selection checkbox can be marked with a class of before-checkbox -->\r\n<ng-content select=\".before-checkbox\"></ng-content>\r\n<ng-container *ngIf=\"isSelectionEnabled\">\r\n  <th *ngIf=\"isHeader\"\r\n      class=\"checkbox\"\r\n      [ecTableLockedColumn]=\"lockedColOptions\">\r\n    <ec-checkbox id=\"{{id}}_selectAll\"\r\n                 class=\"m-0\"\r\n                 *ngIf=\"context?.selectAllCheckbox\"\r\n                 [formModel]=\"context?.selectAllCheckbox\"\r\n                 [dependentCheckboxesGroup]=\"dependentCheckboxesReference\"\r\n                 [ignoreDisabledDependents]=\"false\">\r\n    </ec-checkbox>\r\n  </th>\r\n  <td *ngIf=\"!isHeader && formControl\"\r\n      class=\"checkbox\"\r\n      [ecTableLockedColumn]=\"lockedColOptions\">\r\n    <!-- Use [readonly] and not [disabled] for isCheckboxDisabled to prevent user interaction\r\n         and allow the value to be visible to other components (for example, when they subscribe\r\n         to valueChanges on the FormArray that contains all the checkbox FormControls). -->\r\n    <ec-checkbox id=\"{{id}}_row{{rowIndex}}_checkbox\"\r\n                 [readonly]=\"isCheckboxDisabled\"\r\n                 [attr.id]=\"checkboxAttributeID\"\r\n                 class=\"m-0 row-checkbox\"\r\n                 [formModel]=\"formControl\">\r\n    </ec-checkbox>\r\n  </td>\r\n</ng-container>\r\n<!-- The rest of the table row -->\r\n<ng-content></ng-content>", styles: [":host.is-enabled:not(.is-header){cursor:pointer}:host .checkbox{padding-left:1px;padding-right:1px;width:1.125rem}:host .checkbox:first-child{padding-left:.5rem;width:1.5625rem}:host.border-bottom-0 .checkbox{border-bottom:0}td.checkbox ec-checkbox ::ng-deep *{pointer-events:none}th.checkbox{vertical-align:var(--ec-table-selectable-row-vertical-align-checkbox-th, middle)}td.checkbox{vertical-align:var(--ec-table-selectable-row-vertical-align-checkbox-td, top)}\n"] }]
+        }], propDecorators: { id: [{
+                type: HostBinding,
+                args: ['attr.id']
+            }, {
+                type: Input
+            }], isSelectionEnabled: [{
+                type: HostBinding,
+                args: ['class.is-enabled']
+            }, {
+                type: Input,
+                args: ['ecTableSelectableRow']
+            }], context: [{
+                type: Input,
+                args: ['selectionContext']
+            }], rowIndex: [{
+                type: Input
+            }], lockedColOptions: [{
+                type: Input
+            }], isSelected: [{
+                type: HostBinding,
+                args: ['class.is-selected']
+            }, {
+                type: Input
+            }], isHeader: [{
+                type: HostBinding,
+                args: ['class.is-header']
+            }], isCheckboxDisabled: [{
+                type: Input
+            }], rowClicked: [{
+                type: HostListener,
+                args: ['click', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"table-selectable-row.component.js","sourceRoot":"","sources":["../../../../../../projects/components/src/lib/display/table/table-selectable-row.component.ts","../../../../../../projects/components/src/lib/display/table/table-selectable-row.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, HostBinding, HostListener, Input, OnChanges, OnDestroy, OnInit, SimpleChanges } from '@angular/core';\r\nimport { AbstractControl, FormArray, FormControl } from '@angular/forms';\r\nimport { Subject } from 'rxjs';\r\nimport { debounceTime, takeUntil } from 'rxjs/operators';\r\n\r\nexport class TableSelectableRowContext {\r\n  /**specify the form control to use for the selectAll checkbox or provide your own.\r\n   * This can be useful if you want to subscribe to changes to change button states as the selection changes\r\n   * or if you want to add it to an already-existing form group\r\n   */\r\n  public selectAllCheckbox: AbstractControl = new FormControl(false);\r\n\r\n  /**specify the FormArray to use for the dependent checkboxes of the selectAll checkbox\r\n   * The dependent checkboxes will add and remove themselves automatically and the selectAll\r\n   * box will react accordingly. Do not provide your own controls\r\n   * This can be useful if you want to subscribe to changes to change button states as the selection changes\r\n   * or if you want to add it to an already-existing form group\r\n   */\r\n  public rowCheckboxes: FormArray = new FormArray([]);\r\n\r\n  /**The index of the last row the user clicked. This allows multiple directives on a screen to coordinate\r\n   * for reacting to shift+click actions that should automatically select multiple rows between the clicked rows\r\n   * defaults to -1 to indicate that no user click has been captured\r\n   */\r\n  public lastClickedIndex: number = -1;\r\n\r\n  /**A subject that is triggered when a row-based directive is added or removed. It allows\r\n   * the master checkbox in the header to know that it needs to reset tracking information\r\n   * without replacing the actual FormArray that the hosting component may be subscribed to for changes\r\n   */\r\n  public rowAddedOrRemoved: Subject<void> = new Subject();\r\n\r\n  /**\r\n   * Set to true to disable Shift-Click/Ctrl-Click functionality\r\n   */\r\n  public disableAdvancedRowClickBehavior: boolean = false;\r\n\r\n  /**\r\n   * Set to list of indices of controls that should not toggle when master/header checkbox toggles\r\n   */\r\n  public nonDependentCheckboxes: number[] = [];\r\n}\r\n\r\n@Component({\r\n  selector: '[ecTableSelectableRow]',\r\n  templateUrl: './table-selectable-row.component.html',\r\n  styleUrls: ['./table-selectable-row.component.scss']\r\n})\r\nexport class TableSelectableRowComponent implements OnInit, OnDestroy, OnChanges {\r\n  /**The ID root to use for the checkbox and table cell */\r\n  @HostBinding('attr.id')\r\n  @Input()\r\n  public id: string = '';\r\n\r\n  /** Disables the selection functionality when false */\r\n  @HostBinding('class.is-enabled')\r\n  @Input('ecTableSelectableRow')\r\n  public set isSelectionEnabled(value: boolean | null | undefined) { this._selectionEnabled = value !== false; }\r\n  public get isSelectionEnabled() { return this._selectionEnabled; }\r\n  private _selectionEnabled: boolean = true;\r\n\r\n  /**Shared context between master and children. Child directive adds its own FormControl to this\r\n  and removes it onDestroy. The same context object must be used for all directives in a single table*/\r\n  @Input('selectionContext')\r\n  public context!: TableSelectableRowContext;\r\n\r\n  /*Required for all rows. The row index this component represents, to allow it to know how to handle shift+clicks.\r\n    Defaults to -1 which will cause the directive to behave as a header row*/\r\n  @Input()\r\n  public rowIndex: number = -1;\r\n\r\n  /**The options used to lock the checkbox column to the left of the table, must be modified by host\r\n   * if the checkbox is not the first column in the table\r\n   */\r\n  @Input()\r\n  public lockedColOptions: { border: boolean, left?: number, right?: number } = { border: false, left: 0 };\r\n\r\n  /** Automatically set to true based on checkbox state, used to highlight the row to match our table selected row styles */\r\n  @HostBinding('class.is-selected')\r\n  @Input()\r\n  public isSelected = false;\r\n\r\n  /** Automatically set to true if no rowIndex is provided or the row index is less than zero */\r\n  @HostBinding('class.is-header')\r\n  public isHeader: boolean = false;\r\n\r\n  /**\r\n   * Set to true if you want the checkbox to be disabled.\r\n   *\r\n   * When you use this property, make sure you set `disableAdvancedRowClickBehavior: true`\r\n   * in the `TableSelectableRowContext`, or undesired side-effects will occur.\r\n   */\r\n  @Input()\r\n  public isCheckboxDisabled?: boolean = false;\r\n\r\n  /* A reference that we can change when a control is replaced to force the master checkbox reference to update\r\n     without also replacing the form array that the host component may be watching for selected row changes */\r\n  public dependentCheckboxesReference: { controls: AbstractControl[] } = { controls: [] };\r\n\r\n  /*Capture the form control this component creates to allow cleanup later on and expose it to the row*/\r\n  public formControl!: AbstractControl;\r\n\r\n  public checkboxAttributeID: string = '';\r\n\r\n  /**Sends an event when the component is destroyed so that it can unsubscribe from any observables */\r\n  private destroyed = new Subject<void>();\r\n\r\n  /**Validate and populate the context as the table is dynamically built. Because the context is shared between the\r\n   * header and each of the rows, changes to it can be used to determine what is happening and hook up the correct\r\n   * subscriptions for selectAll. The user can provide an existing formArray for the rows and form control for the header,\r\n   * or it can just be the default empty ones created by the context class.\r\n  */\r\n  public ngOnInit() {\r\n    this.isHeader = this.rowIndex < 0;\r\n    if (!this.context) {\r\n      console.error('ecTableSelectableRow requires a defined SelectableTableRowContext to be shared with all instances in one table.');\r\n    } else {\r\n      let rowCheckbox = this.context?.rowCheckboxes?.at(this.rowIndex);\r\n\r\n      if (!this.isHeader && !rowCheckbox) {\r\n        rowCheckbox = new FormControl(this.isSelected);\r\n        this.context?.rowCheckboxes.push(rowCheckbox);\r\n      }\r\n\r\n      this.formControl = this.isHeader ? this.context.selectAllCheckbox : rowCheckbox;\r\n      this.watchForChanges();\r\n    }\r\n  }\r\n\r\n  /**Watch for changes to the row index that can occur if the table is reordered in-place instead of\r\n   * recreated from scratch. Re-capture the correct form control to keep everything in sync\r\n   */\r\n  public ngOnChanges(changes: SimpleChanges) {\r\n    if (changes.rowIndex && !this.isHeader) {\r\n      this.formControl = this.context.rowCheckboxes.at(this.rowIndex);\r\n      this.checkboxAttributeID = `${this.id}_row${this.rowIndex}_ecCheckbox`;\r\n    }\r\n\r\n    if (changes.isSelectionEnabled && !this.isSelectionEnabled && this.formControl?.value === true) {\r\n      this.formControl.setValue(false);\r\n    }\r\n\r\n    if (changes.isSelected && this.formControl) {\r\n      this.formControl.setValue(this.isSelected);\r\n    }\r\n  }\r\n\r\n  /** Tell the header checkbox to refresh the selectAll subscription because a row was removed*/\r\n  public ngOnDestroy() {\r\n    if (!this.isHeader && this.formControl) {\r\n      this.context.rowAddedOrRemoved.next();\r\n\r\n      //find the location in the array that matches the checkbox. If many rows are being removed it may not match rowIndex yet\r\n      let matchIndex = this.context.rowCheckboxes.controls.findIndex(c => c == this.formControl);\r\n      if (matchIndex >= 0) {\r\n        this.context.rowCheckboxes.removeAt(matchIndex);\r\n      }\r\n    }\r\n  }\r\n\r\n  /**Handle when a user clicks on a table row (or something inside it which bubbles up) to increase the hit area for row selection\r\n   * Only work on the table body (not the header) because the header may have other click handlers for sort etc that we don't care about.\r\n   * Handle shift and control select as well as checkbox click like windows explorer or the original bill lists do.\r\n  */\r\n  @HostListener('click', ['$event'])\r\n  public rowClicked(event: MouseEvent) {\r\n    if (!this.isHeader && this.isSelectionEnabled && !this.isCheckboxDisabled) {\r\n      let targetEl = event?.target as HTMLElement;\r\n\r\n      //clicking on a row always toggles that row. Sometimes the shift-select will toggle it back\r\n      this.formControl.setValue(!this.formControl.value);\r\n\r\n      if (!this.context.disableAdvancedRowClickBehavior) {\r\n        this.handleShiftSelect(event);\r\n      }\r\n    }\r\n  }\r\n\r\n  private watchForChanges() {\r\n    //watch for rows being replaced so that the master checkbox and shift-select support can be reset to match\r\n    //this keeps the master in sync as the table changes pages etc and stops unexpected rows from being selected after redraw\r\n    if (this.isHeader) {\r\n      this.context.rowAddedOrRemoved.pipe(debounceTime(10), takeUntil(this.destroyed)).subscribe(() => {\r\n        this.context.lastClickedIndex = -1;\r\n\r\n        // exclude nonDependentCheckboxes (some may not be allowed to be deselected)\r\n        let dependentCheckboxes: AbstractControl[] = [];\r\n        this.context.rowCheckboxes.controls.forEach((control, index) => {\r\n          if (!this.context.nonDependentCheckboxes.includes(index)) {\r\n            dependentCheckboxes.push(control);\r\n          }\r\n        });\r\n\r\n        this.dependentCheckboxesReference = { controls: dependentCheckboxes };\r\n      });\r\n    } else {\r\n      this.context.rowAddedOrRemoved.next();\r\n\r\n      //watch for the checkbox state to change on a child row and set the row isSelected class / highlight to match\r\n      //this way the rows match even if external code updates the form model\r\n      this.formControl?.valueChanges.pipe(takeUntil(this.destroyed)).subscribe((value: boolean) => {\r\n        this.isSelected = value;\r\n      });\r\n    }\r\n\r\n  }\r\n\r\n  /**\r\n    * If they are holding the shift key, try to select all the checkboxes between their last selection\r\n    * and most recent selection. The logic is setup to behave the way windows explorer behaves\r\n    * We don't allow drag-to-select like the kendo tables, but it means users can highlight text and copy+paste to excel etc\r\n    * so I think this is actually preferable\r\n    */\r\n  private handleShiftSelect(event: MouseEvent) {\r\n    let lastIndex = this.context.lastClickedIndex;\r\n    let curIndex = this.rowIndex;\r\n    if (event.shiftKey && lastIndex >= 0) {\r\n      this.clearAllRows();\r\n      if (curIndex > lastIndex) {\r\n        for (var index = lastIndex; index <= curIndex; index++) {\r\n          this.context.rowCheckboxes.at(index).setValue(true);\r\n        }\r\n      } else if (curIndex < lastIndex) {\r\n        for (var index = lastIndex; index >= curIndex; index--) {\r\n          this.context.rowCheckboxes.at(index).setValue(true);\r\n        }\r\n      } else if (curIndex === lastIndex) {\r\n        this.formControl.setValue(true);\r\n      }\r\n\r\n      document.getSelection()?.removeAllRanges();\r\n    } else {\r\n      //record the current row index for future row clicks to know where they last interacted\r\n      //but only if they don't have shift down for this click. If shift is down then the next shift+click\r\n      //should be considered an extension (or contraction) of the original multi-row selection\r\n      this.context.lastClickedIndex = this.rowIndex;\r\n    }\r\n  }\r\n\r\n  private clearAllRows() {\r\n    this.context.rowCheckboxes.controls.forEach(control => control.setValue(false));\r\n  }\r\n}\r\n","<!-- any elements of the existing table row that must go before the row selection checkbox can be marked with a class of before-checkbox -->\r\n<ng-content select=\".before-checkbox\"></ng-content>\r\n<ng-container *ngIf=\"isSelectionEnabled\">\r\n  <th *ngIf=\"isHeader\"\r\n      class=\"checkbox\"\r\n      [ecTableLockedColumn]=\"lockedColOptions\">\r\n    <ec-checkbox id=\"{{id}}_selectAll\"\r\n                 class=\"m-0\"\r\n                 *ngIf=\"context?.selectAllCheckbox\"\r\n                 [formModel]=\"context?.selectAllCheckbox\"\r\n                 [dependentCheckboxesGroup]=\"dependentCheckboxesReference\"\r\n                 [ignoreDisabledDependents]=\"false\">\r\n    </ec-checkbox>\r\n  </th>\r\n  <td *ngIf=\"!isHeader && formControl\"\r\n      class=\"checkbox\"\r\n      [ecTableLockedColumn]=\"lockedColOptions\">\r\n    <!-- Use [readonly] and not [disabled] for isCheckboxDisabled to prevent user interaction\r\n         and allow the value to be visible to other components (for example, when they subscribe\r\n         to valueChanges on the FormArray that contains all the checkbox FormControls). -->\r\n    <ec-checkbox id=\"{{id}}_row{{rowIndex}}_checkbox\"\r\n                 [readonly]=\"isCheckboxDisabled\"\r\n                 [attr.id]=\"checkboxAttributeID\"\r\n                 class=\"m-0 row-checkbox\"\r\n                 [formModel]=\"formControl\">\r\n    </ec-checkbox>\r\n  </td>\r\n</ng-container>\r\n<!-- The rest of the table row -->\r\n<ng-content></ng-content>"]}

package/esm2020/lib/display/table/table.component.mjs

@@ -0,0 +1,244 @@
+import { Component, ContentChildren, EventEmitter, HostBinding, Input, Output, ViewEncapsulation } from '@angular/core';
+import { isEqual } from 'lodash';
+import { Subject } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+import { ResizableColumnComponent } from './resizable-column.component';
+import { TableMasterRowComponent } from './table-master-row.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "./resizable-table.directive";
+export class TableComponent {
+    constructor(renderer, el) {
+        this.renderer = renderer;
+        this.el = el;
+        this.id = '';
+        /**
+         * Enables table scrolling with a sticky header and footer. Use
+         * <thead> and <tfoot> elements for styles to be applied correctly.
+         */
+        this.scrollable = false;
+        /**
+         * Enables resizable table columns. Apply the 'is-resizable' class
+         * to the <th> of a table column than can be resized.
+         */
+        this.resizable = false;
+        /**
+         * Turns on condensed table styling. By default a condensed table
+         * has no row borders. To show borders, apply the 'has-borders' class
+         * to the <ec-table> element
+         */
+        this.condensed = false;
+        /**
+         * Enables sorting by clicking on table columns. To make a column sortable
+         * apply the `data-sortable` attribute to the columns `<th>` element with
+         * the value of the field used to sort the column. When a column is clicked
+         * the fields and current sort direction is emitted from the `sortChange`
+         * output
+         *
+         * @example
+         * ```html
+         * <ec-table [sortable]="true" [sort]="currentSort" (sortChange)="onSort($event)">
+         *  <thead>
+         *    <th data-sortable="name">Name</th>
+         *    <th data-sortable="qty">Qty.</th>
+         *    <th data-sortable="price">Price</th>
+         *  </thead>
+         *  ...
+         * </ec-table>
+         * ```
+         */
+        this.sortable = false;
+        /** Set to true if selectionContext is defined */
+        this.selectable = false;
+        /** Hides/shows the selection toolbar template when 1 or more rows is selected */
+        this.hasSelection = false;
+        /**
+         * Enables form table styling to allow form controls inside table cells.
+         */
+        this.isForm = false;
+        /**
+         * Emits the new sort value whenever a sortable column is clicked
+         */
+        this.sortChange = new EventEmitter();
+        /**
+         * True if a TableMasterRowComponent exists in the table content
+         */
+        this.hasMasterDetailRows = false;
+        /**
+         * Unlisten function returned by `renderer.listen()` that are called
+         * OnDestroy to clean up all listeners
+         */
+        this.unlisteners = [];
+        /** A map of sortable `<th>` elements */
+        this.sortableCols = {};
+        this.destroyed = new Subject();
+    }
+    ngOnChanges(changes) {
+        if (this.sortable && changes.sort && changes.sort.currentValue && !changes.sort.firstChange) {
+            const newValue = changes.sort.currentValue;
+            if (!this.currentSort || !isEqual(newValue, this.currentSort)) {
+                this.onSort(newValue.field, newValue.direction);
+            }
+        }
+    }
+    ngAfterContentInit() {
+        this.hasMasterDetailRows = !!this.masterRows.length;
+        this.masterRows.changes.pipe(takeUntil(this.destroyed)).subscribe(() => {
+            this.hasMasterDetailRows = !!this.masterRows.length;
+        });
+        this.resizableColumns = this.searchableTableResizableColumns || this._resizableColumns;
+    }
+    ngAfterViewInit() {
+        if (this.sortable) {
+            this.initSortable();
+        }
+        if (this.selectable) {
+            this.initSelectable();
+        }
+    }
+    ngOnDestroy() {
+        if (this.unlisteners.length) {
+            this.unlisteners.forEach(unlisten => unlisten());
+        }
+        this.destroyed.next();
+        this.destroyed.unsubscribe();
+    }
+    /**
+     * Get all elements inside the host element that match a selector
+     * @param selector - Any valid selector for [querySelectorAll](https://developer.mozilla.org/en-US/docs/Web/API/Document/querySelectorAll)
+     */
+    queryElements(selector) {
+        const table = this.el.nativeElement;
+        return Array.from(table.querySelectorAll(selector));
+    }
+    /**
+     * Store a `<th>` for each sortable column and attach a click
+     * event listener.
+     */
+    initSortable() {
+        this.queryElements('th').forEach(th => {
+            if (th.hasAttribute('data-sortfield')) {
+                const field = th.getAttribute('data-sortfield');
+                if (field) {
+                    this.sortableCols[field] = th;
+                    const unlisten = this.renderer.listen(th, 'click', (event) => {
+                        // Do not sort if the event target was the resizable handle
+                        if (th.classList.contains('is-resizable') && event.target && event.target.classList.contains('handle')) {
+                            return;
+                        }
+                        this.onSort(field);
+                    });
+                    // Store unlisten function to remove listener when component is destroyed
+                    this.unlisteners.push(unlisten);
+                }
+                else {
+                    console.error(`data-sortfield attribute was not assigned a value.`, th);
+                }
+            }
+        });
+        // Set the initial sort
+        if (this.sort) {
+            this.onSort(this.sort.field, this.sort.direction);
+        }
+    }
+    /**
+     * Find the sorted column and apply the desc or asc class in order
+     * to show the correct sort icon. If another field was sorted, reset it.
+     * Emit the current field and direction of the sorted column
+     * @param field
+     */
+    onSort(field, direction) {
+        const th = this.sortableCols[field];
+        if (!th) {
+            return;
+        }
+        if (this.currentSort && this.currentSort.field !== field) {
+            this.renderer.removeClass(this.sortableCols[this.currentSort.field], `is-sorted-${this.currentSort.direction}`);
+        }
+        if (th.classList.contains('is-sorted-desc')) {
+            this.renderer.removeClass(th, 'is-sorted-desc');
+            if (!direction) {
+                direction = 'asc';
+            }
+        }
+        else {
+            if (th.classList.contains('is-sorted-asc')) {
+                this.renderer.removeClass(th, 'is-sorted-asc');
+            }
+            if (!direction) {
+                direction = 'desc';
+            }
+        }
+        this.renderer.addClass(th, `is-sorted-${direction}`);
+        const sortEvent = { field: field, direction: direction };
+        this.currentSort = sortEvent;
+        this.sortChange.emit(sortEvent);
+    }
+    initSelectable() {
+        this.selectionContext.rowCheckboxes.valueChanges.pipe(takeUntil(this.destroyed)).subscribe((value) => {
+            this.hasSelection = value.some(v => v);
+        });
+    }
+}
+TableComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: TableComponent, deps: [{ token: i0.Renderer2 }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Component });
+TableComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.11", type: TableComponent, selector: "ec-table", inputs: { id: "id", scrollable: "scrollable", resizable: "resizable", condensed: "condensed", sortable: "sortable", selectionContext: "selectionContext", selectionToolbarTemplate: "selectionToolbarTemplate", selectable: "selectable", isForm: "isForm", sort: "sort", searchableTableResizableColumns: ["resizableColumns", "searchableTableResizableColumns"] }, outputs: { sortChange: "sortChange" }, host: { properties: { "attr.id": "this.id", "class.is-scrollable": "this.scrollable", "class.is-resizable": "this.resizable", "class.is-condensed": "this.condensed", "class.is-sortable": "this.sortable", "class.is-selectable": "this.selectable", "class.is-form-table": "this.isForm", "class.is-master-detail": "this.hasMasterDetailRows" } }, queries: [{ propertyName: "masterRows", predicate: TableMasterRowComponent, descendants: true }, { propertyName: "_resizableColumns", predicate: ResizableColumnComponent, descendants: true }], usesOnChanges: true, ngImport: i0, template: "<div class=\"selectable-table-toolbar\"\r\n     *ngIf=\"hasSelection && selectionToolbarTemplate\">\r\n  <ng-container *ngTemplateOutlet=\"selectionToolbarTemplate\"></ng-container>\r\n</div>\r\n<div id=\"{{id}}-scroll-container\" \r\n     class=\"table-scroll-container\">\r\n  <table class=\"main-table\"\r\n         id=\"{{id}}\"\r\n         [ecResizableTable]=\"resizable\"\r\n         [containerEl]=\"el\"\r\n         [sortableTable]=\"sortable\"\r\n         [resizableColumns]=\"resizableColumns\">\r\n    <ng-content></ng-content>\r\n  </table>\r\n</div>", styles: [":root{--ec-font-size-icon: 1rem;--ec-color-icon: rgba(26, 26, 35, .66)}@keyframes spin{0%{transform:rotate(0)}to{transform:rotate(1turn)}}ec-table{display:flex;position:relative;min-height:0}ec-table .table-scroll-container{flex:1 1;min-height:0;overflow-y:auto}ec-table .main-table{border-collapse:separate;border-spacing:0;width:100%;font-size:var(--ec-font-size-label)}ec-table .main-table th{height:2rem;line-height:1rem;padding:.5rem;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;border-bottom:1px solid var(--ec-border-color-dark);color:var(--ec-color-secondary-dark);font-weight:400;vertical-align:middle}ec-table .main-table th:first-child{padding-left:1rem}ec-table .main-table th:last-child{padding-right:1rem}ec-table .main-table td{height:2rem;line-height:1rem;padding:.5rem;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;border-top:1px solid var(--ec-border-color);vertical-align:top}ec-table .main-table td:first-child{padding-left:1rem}ec-table .main-table td:last-child{padding-right:1rem}ec-table .main-table tbody>tr:first-child td{border-top:0}ec-table .main-table tbody>tr.is-error td{background-color:var(--ec-background-color-danger)}ec-table .main-table tbody>tr.is-success td{background-color:var(--ec-background-color-success)}ec-table .main-table tfoot td{font-weight:700}ec-table .main-table tbody>tr.is-selected>td,ec-table .main-table tbody>tr.is-selected{background-color:var(--ec-background-color-selected)}ec-table .main-table tr.is-heading td{color:var(--ec-color-secondary-dark);font-size:var(--ec-font-size-label);font-weight:var(--ec-font-weight-bold);line-height:1.333333333;text-transform:uppercase;padding-bottom:0;vertical-align:bottom;border-top:0}ec-table .main-table tr.is-heading+tr td{border-top:0}ec-table .main-table th.actions-col,ec-table .main-table td.actions-col{padding:0}ec-table .main-table th.actions-1,ec-table .main-table td.actions-1{width:2.0625rem}ec-table .main-table th.actions-2,ec-table .main-table td.actions-2{width:4.0625rem}ec-table .main-table th.actions-3,ec-table .main-table td.actions-3{width:6.0625rem}ec-table .main-table th.actions-4,ec-table .main-table td.actions-4{width:8.0625rem}ec-table .main-table th.actions-5,ec-table .main-table td.actions-5{width:10.0625rem}ec-table.is-condensed th,ec-table.is-condensed td{padding-top:.25rem;padding-bottom:.25rem;height:1.5rem}ec-table.is-condensed:not(.has-borders)>table td{border-bottom-width:0;border-top-width:0}ec-table .selectable-table-toolbar{align-items:center;background-color:var(--ec-background-color);border-bottom:1px solid var(--ec-border-color-dark);display:flex;padding:0 .5rem;position:absolute;left:calc(var(--selection-toolbar-left, 0rem) + 1.5625rem);top:0;height:3rem;right:0;z-index:4}ec-table.is-scrollable>.table-scroll-container>table{position:relative}ec-table.is-scrollable>.table-scroll-container>table>thead th{background-color:var(--ec-background-color);position:sticky!important;top:0;z-index:1}ec-table.is-scrollable>.table-scroll-container>table>tfoot td{background-color:var(--ec-background-color);position:sticky!important;bottom:0;z-index:1}ec-table.is-scrollable.bg-body>.table-scroll-container>table>thead th{background-color:var(--ec-background-color-body)}ec-table.is-scrollable.bg-body>.table-scroll-container>table>tfoot td{background-color:var(--ec-background-color-body)}ec-table.is-sortable th[data-sortfield]{-webkit-user-select:none;user-select:none}ec-table.is-sortable th[data-sortfield].is-resizable .content-wrapper{display:flex;cursor:pointer}ec-table.is-sortable th[data-sortfield].is-resizable .content{flex:0 1 auto}ec-table.is-sortable th[data-sortfield].is-resizable .content-wrapper:after{flex:none;content:\"\";background-repeat:no-repeat;background-position:center;width:.875rem;height:.875rem;margin:0 .25rem;vertical-align:top;display:none}ec-table.is-sortable th[data-sortfield].is-resizable.is-sorted-desc .content-wrapper:after,ec-table.is-sortable th[data-sortfield].is-resizable.is-sorted-asc .content-wrapper:after{background-image:url('data:image/svg+xml;charset=utf8,<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 32 32\"><path fill=\"rgba(26, 26, 35, 0.66)\" d=\"M14 8.828V27a2 2 0 1 0 4 0V8.828l4.586 4.586a2 2 0 0 0 2.828-2.828l-8-8a2 2 0 0 0-2.828 0l-8 8a2 2 0 0 0 2.828 2.828L14 8.828z\"/></svg>');display:inline-block}ec-table.is-sortable th[data-sortfield].is-resizable.is-sorted-desc .content-wrapper:after{transform:scaleY(-1)}ec-table.is-sortable th[data-sortfield].is-resizable.text-right .content-wrapper{flex-direction:row-reverse}ec-table.is-sortable th[data-sortfield]:not(.is-resizable){cursor:pointer}ec-table.is-sortable th[data-sortfield]:not(.is-resizable):after{content:\"\";background-repeat:no-repeat;background-position:center;width:.875rem;height:.875rem;margin:0 .25rem;vertical-align:top;display:none}ec-table.is-sortable th[data-sortfield]:not(.is-resizable).is-sorted-desc:after,ec-table.is-sortable th[data-sortfield]:not(.is-resizable).is-sorted-asc:after{background-image:url('data:image/svg+xml;charset=utf8,<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 32 32\"><path fill=\"rgba(26, 26, 35, 0.66)\" d=\"M14 8.828V27a2 2 0 1 0 4 0V8.828l4.586 4.586a2 2 0 0 0 2.828-2.828l-8-8a2 2 0 0 0-2.828 0l-8 8a2 2 0 0 0 2.828 2.828L14 8.828z\"/></svg>');display:inline-block}ec-table.is-sortable th[data-sortfield]:not(.is-resizable).is-sorted-desc:after{transform:scaleY(-1)}ec-table.is-sortable th[data-sortfield]:not(.is-resizable).text-right:after{content:\"\";display:none!important}ec-table.is-sortable th[data-sortfield]:not(.is-resizable).text-right:before{content:\"\";background-repeat:no-repeat;background-position:center;width:.875rem;height:.875rem;margin:0 .25rem;vertical-align:top;display:none}ec-table.is-sortable th[data-sortfield]:not(.is-resizable).text-right.is-sorted-desc:before,ec-table.is-sortable th[data-sortfield]:not(.is-resizable).text-right.is-sorted-asc:before{background-image:url('data:image/svg+xml;charset=utf8,<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 32 32\"><path fill=\"rgba(26, 26, 35, 0.66)\" d=\"M14 8.828V27a2 2 0 1 0 4 0V8.828l4.586 4.586a2 2 0 0 0 2.828-2.828l-8-8a2 2 0 0 0-2.828 0l-8 8a2 2 0 0 0 2.828 2.828L14 8.828z\"/></svg>');display:inline-block}ec-table.is-sortable th[data-sortfield]:not(.is-resizable).text-right.is-sorted-desc:before{transform:scaleY(-1)}ec-table.is-resizable .main-table{table-layout:fixed;width:100%}ec-table.is-resizable th.is-resizable{position:relative;overflow:visible;z-index:1}ec-table.is-resizable th.is-resizable.is-active{-webkit-user-select:none;user-select:none}ec-table.is-resizable th.is-resizable.is-active .handle:after{background-color:var(--ec-color-interactive)}ec-table.is-resizable th.is-resizable .handle{position:absolute;right:-7px;width:13px;height:100%;top:0;padding:0 5px;z-index:var(--ec-z-index-splitter);right:0;padding:.5rem 0 .5rem 10px}ec-table.is-resizable th.is-resizable .handle:after{content:\"\";display:block;transition:background-color .3s ease;height:100%;position:relative}ec-table.is-resizable th.is-resizable .handle:hover{cursor:col-resize}ec-table.is-resizable th.is-resizable .handle:hover:after{background-color:var(--ec-color-interactive)}ec-table.is-resizable th.is-resizable .handle:before{content:\"\";display:block;width:1px;background-color:var(--ec-border-color-legacy);position:absolute;top:.5rem;bottom:.5rem;right:0}ec-table.is-resizable th.is-resizable .content{overflow:hidden;text-overflow:clip;white-space:nowrap}ec-table.is-resizable th.is-resizable:last-child .handle:before{display:none}ec-table.is-resizable td,ec-table.is-resizable th{overflow:hidden;text-overflow:clip;white-space:nowrap}ec-table.is-selectable .main-table thead th{height:3rem}ec-table.is-selectable .main-table tbody>tr:hover>td{background-color:var(--ec-background-color-hover);border-color:transparent;cursor:pointer}ec-table.is-selectable .main-table tbody>tr:hover.is-selected{background-color:var(--ec-background-color-selected)}ec-table.is-selectable .main-table tbody>tr:hover+tr>td{border-color:var(--ec-background-color-hover)}ec-table.is-selectable th.is-resizable .handle{padding-top:1rem;padding-bottom:1rem}ec-table.is-selectable th.is-resizable .handle:before{top:1rem;bottom:1rem}ec-table.is-master-detail>table{table-layout:fixed}ec-table.is-form-table td{padding-bottom:.25rem;padding-top:.25rem;height:2.5rem;line-height:2rem;border-top:0;font-size:var(--ec-font-size-body)}ec-table.is-form-table tr:first-child td{padding-top:.5rem;height:2.75rem}ec-table.is-form-table tr:last-child td{padding-bottom:.5rem;height:2.75rem}ec-table.is-fixed .main-table{table-layout:fixed}\n"], directives: [{ type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i1.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet"] }, { type: i2.ResizableTableDirective, selector: "[ecResizableTable]", inputs: ["ecResizableTable", "containerEl", "sortableTable", "resizableColumns"] }], encapsulation: i0.ViewEncapsulation.None });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: TableComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'ec-table', encapsulation: ViewEncapsulation.None, template: "<div class=\"selectable-table-toolbar\"\r\n     *ngIf=\"hasSelection && selectionToolbarTemplate\">\r\n  <ng-container *ngTemplateOutlet=\"selectionToolbarTemplate\"></ng-container>\r\n</div>\r\n<div id=\"{{id}}-scroll-container\" \r\n     class=\"table-scroll-container\">\r\n  <table class=\"main-table\"\r\n         id=\"{{id}}\"\r\n         [ecResizableTable]=\"resizable\"\r\n         [containerEl]=\"el\"\r\n         [sortableTable]=\"sortable\"\r\n         [resizableColumns]=\"resizableColumns\">\r\n    <ng-content></ng-content>\r\n  </table>\r\n</div>", styles: [":root{--ec-font-size-icon: 1rem;--ec-color-icon: rgba(26, 26, 35, .66)}@keyframes spin{0%{transform:rotate(0)}to{transform:rotate(1turn)}}ec-table{display:flex;position:relative;min-height:0}ec-table .table-scroll-container{flex:1 1;min-height:0;overflow-y:auto}ec-table .main-table{border-collapse:separate;border-spacing:0;width:100%;font-size:var(--ec-font-size-label)}ec-table .main-table th{height:2rem;line-height:1rem;padding:.5rem;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;border-bottom:1px solid var(--ec-border-color-dark);color:var(--ec-color-secondary-dark);font-weight:400;vertical-align:middle}ec-table .main-table th:first-child{padding-left:1rem}ec-table .main-table th:last-child{padding-right:1rem}ec-table .main-table td{height:2rem;line-height:1rem;padding:.5rem;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;border-top:1px solid var(--ec-border-color);vertical-align:top}ec-table .main-table td:first-child{padding-left:1rem}ec-table .main-table td:last-child{padding-right:1rem}ec-table .main-table tbody>tr:first-child td{border-top:0}ec-table .main-table tbody>tr.is-error td{background-color:var(--ec-background-color-danger)}ec-table .main-table tbody>tr.is-success td{background-color:var(--ec-background-color-success)}ec-table .main-table tfoot td{font-weight:700}ec-table .main-table tbody>tr.is-selected>td,ec-table .main-table tbody>tr.is-selected{background-color:var(--ec-background-color-selected)}ec-table .main-table tr.is-heading td{color:var(--ec-color-secondary-dark);font-size:var(--ec-font-size-label);font-weight:var(--ec-font-weight-bold);line-height:1.333333333;text-transform:uppercase;padding-bottom:0;vertical-align:bottom;border-top:0}ec-table .main-table tr.is-heading+tr td{border-top:0}ec-table .main-table th.actions-col,ec-table .main-table td.actions-col{padding:0}ec-table .main-table th.actions-1,ec-table .main-table td.actions-1{width:2.0625rem}ec-table .main-table th.actions-2,ec-table .main-table td.actions-2{width:4.0625rem}ec-table .main-table th.actions-3,ec-table .main-table td.actions-3{width:6.0625rem}ec-table .main-table th.actions-4,ec-table .main-table td.actions-4{width:8.0625rem}ec-table .main-table th.actions-5,ec-table .main-table td.actions-5{width:10.0625rem}ec-table.is-condensed th,ec-table.is-condensed td{padding-top:.25rem;padding-bottom:.25rem;height:1.5rem}ec-table.is-condensed:not(.has-borders)>table td{border-bottom-width:0;border-top-width:0}ec-table .selectable-table-toolbar{align-items:center;background-color:var(--ec-background-color);border-bottom:1px solid var(--ec-border-color-dark);display:flex;padding:0 .5rem;position:absolute;left:calc(var(--selection-toolbar-left, 0rem) + 1.5625rem);top:0;height:3rem;right:0;z-index:4}ec-table.is-scrollable>.table-scroll-container>table{position:relative}ec-table.is-scrollable>.table-scroll-container>table>thead th{background-color:var(--ec-background-color);position:sticky!important;top:0;z-index:1}ec-table.is-scrollable>.table-scroll-container>table>tfoot td{background-color:var(--ec-background-color);position:sticky!important;bottom:0;z-index:1}ec-table.is-scrollable.bg-body>.table-scroll-container>table>thead th{background-color:var(--ec-background-color-body)}ec-table.is-scrollable.bg-body>.table-scroll-container>table>tfoot td{background-color:var(--ec-background-color-body)}ec-table.is-sortable th[data-sortfield]{-webkit-user-select:none;user-select:none}ec-table.is-sortable th[data-sortfield].is-resizable .content-wrapper{display:flex;cursor:pointer}ec-table.is-sortable th[data-sortfield].is-resizable .content{flex:0 1 auto}ec-table.is-sortable th[data-sortfield].is-resizable .content-wrapper:after{flex:none;content:\"\";background-repeat:no-repeat;background-position:center;width:.875rem;height:.875rem;margin:0 .25rem;vertical-align:top;display:none}ec-table.is-sortable th[data-sortfield].is-resizable.is-sorted-desc .content-wrapper:after,ec-table.is-sortable th[data-sortfield].is-resizable.is-sorted-asc .content-wrapper:after{background-image:url('data:image/svg+xml;charset=utf8,<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 32 32\"><path fill=\"rgba(26, 26, 35, 0.66)\" d=\"M14 8.828V27a2 2 0 1 0 4 0V8.828l4.586 4.586a2 2 0 0 0 2.828-2.828l-8-8a2 2 0 0 0-2.828 0l-8 8a2 2 0 0 0 2.828 2.828L14 8.828z\"/></svg>');display:inline-block}ec-table.is-sortable th[data-sortfield].is-resizable.is-sorted-desc .content-wrapper:after{transform:scaleY(-1)}ec-table.is-sortable th[data-sortfield].is-resizable.text-right .content-wrapper{flex-direction:row-reverse}ec-table.is-sortable th[data-sortfield]:not(.is-resizable){cursor:pointer}ec-table.is-sortable th[data-sortfield]:not(.is-resizable):after{content:\"\";background-repeat:no-repeat;background-position:center;width:.875rem;height:.875rem;margin:0 .25rem;vertical-align:top;display:none}ec-table.is-sortable th[data-sortfield]:not(.is-resizable).is-sorted-desc:after,ec-table.is-sortable th[data-sortfield]:not(.is-resizable).is-sorted-asc:after{background-image:url('data:image/svg+xml;charset=utf8,<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 32 32\"><path fill=\"rgba(26, 26, 35, 0.66)\" d=\"M14 8.828V27a2 2 0 1 0 4 0V8.828l4.586 4.586a2 2 0 0 0 2.828-2.828l-8-8a2 2 0 0 0-2.828 0l-8 8a2 2 0 0 0 2.828 2.828L14 8.828z\"/></svg>');display:inline-block}ec-table.is-sortable th[data-sortfield]:not(.is-resizable).is-sorted-desc:after{transform:scaleY(-1)}ec-table.is-sortable th[data-sortfield]:not(.is-resizable).text-right:after{content:\"\";display:none!important}ec-table.is-sortable th[data-sortfield]:not(.is-resizable).text-right:before{content:\"\";background-repeat:no-repeat;background-position:center;width:.875rem;height:.875rem;margin:0 .25rem;vertical-align:top;display:none}ec-table.is-sortable th[data-sortfield]:not(.is-resizable).text-right.is-sorted-desc:before,ec-table.is-sortable th[data-sortfield]:not(.is-resizable).text-right.is-sorted-asc:before{background-image:url('data:image/svg+xml;charset=utf8,<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 32 32\"><path fill=\"rgba(26, 26, 35, 0.66)\" d=\"M14 8.828V27a2 2 0 1 0 4 0V8.828l4.586 4.586a2 2 0 0 0 2.828-2.828l-8-8a2 2 0 0 0-2.828 0l-8 8a2 2 0 0 0 2.828 2.828L14 8.828z\"/></svg>');display:inline-block}ec-table.is-sortable th[data-sortfield]:not(.is-resizable).text-right.is-sorted-desc:before{transform:scaleY(-1)}ec-table.is-resizable .main-table{table-layout:fixed;width:100%}ec-table.is-resizable th.is-resizable{position:relative;overflow:visible;z-index:1}ec-table.is-resizable th.is-resizable.is-active{-webkit-user-select:none;user-select:none}ec-table.is-resizable th.is-resizable.is-active .handle:after{background-color:var(--ec-color-interactive)}ec-table.is-resizable th.is-resizable .handle{position:absolute;right:-7px;width:13px;height:100%;top:0;padding:0 5px;z-index:var(--ec-z-index-splitter);right:0;padding:.5rem 0 .5rem 10px}ec-table.is-resizable th.is-resizable .handle:after{content:\"\";display:block;transition:background-color .3s ease;height:100%;position:relative}ec-table.is-resizable th.is-resizable .handle:hover{cursor:col-resize}ec-table.is-resizable th.is-resizable .handle:hover:after{background-color:var(--ec-color-interactive)}ec-table.is-resizable th.is-resizable .handle:before{content:\"\";display:block;width:1px;background-color:var(--ec-border-color-legacy);position:absolute;top:.5rem;bottom:.5rem;right:0}ec-table.is-resizable th.is-resizable .content{overflow:hidden;text-overflow:clip;white-space:nowrap}ec-table.is-resizable th.is-resizable:last-child .handle:before{display:none}ec-table.is-resizable td,ec-table.is-resizable th{overflow:hidden;text-overflow:clip;white-space:nowrap}ec-table.is-selectable .main-table thead th{height:3rem}ec-table.is-selectable .main-table tbody>tr:hover>td{background-color:var(--ec-background-color-hover);border-color:transparent;cursor:pointer}ec-table.is-selectable .main-table tbody>tr:hover.is-selected{background-color:var(--ec-background-color-selected)}ec-table.is-selectable .main-table tbody>tr:hover+tr>td{border-color:var(--ec-background-color-hover)}ec-table.is-selectable th.is-resizable .handle{padding-top:1rem;padding-bottom:1rem}ec-table.is-selectable th.is-resizable .handle:before{top:1rem;bottom:1rem}ec-table.is-master-detail>table{table-layout:fixed}ec-table.is-form-table td{padding-bottom:.25rem;padding-top:.25rem;height:2.5rem;line-height:2rem;border-top:0;font-size:var(--ec-font-size-body)}ec-table.is-form-table tr:first-child td{padding-top:.5rem;height:2.75rem}ec-table.is-form-table tr:last-child td{padding-bottom:.5rem;height:2.75rem}ec-table.is-fixed .main-table{table-layout:fixed}\n"] }]
+        }], ctorParameters: function () { return [{ type: i0.Renderer2 }, { type: i0.ElementRef }]; }, propDecorators: { id: [{
+                type: HostBinding,
+                args: ['attr.id']
+            }, {
+                type: Input
+            }], scrollable: [{
+                type: HostBinding,
+                args: ['class.is-scrollable']
+            }, {
+                type: Input
+            }], resizable: [{
+                type: HostBinding,
+                args: ['class.is-resizable']
+            }, {
+                type: Input
+            }], condensed: [{
+                type: HostBinding,
+                args: ['class.is-condensed']
+            }, {
+                type: Input
+            }], sortable: [{
+                type: HostBinding,
+                args: ['class.is-sortable']
+            }, {
+                type: Input
+            }], selectionContext: [{
+                type: Input
+            }], selectionToolbarTemplate: [{
+                type: Input
+            }], selectable: [{
+                type: HostBinding,
+                args: ['class.is-selectable']
+            }, {
+                type: Input
+            }], isForm: [{
+                type: HostBinding,
+                args: ['class.is-form-table']
+            }, {
+                type: Input
+            }], sort: [{
+                type: Input
+            }], sortChange: [{
+                type: Output
+            }], hasMasterDetailRows: [{
+                type: HostBinding,
+                args: ['class.is-master-detail']
+            }], masterRows: [{
+                type: ContentChildren,
+                args: [TableMasterRowComponent, { descendants: true }]
+            }], _resizableColumns: [{
+                type: ContentChildren,
+                args: [ResizableColumnComponent, { descendants: true }]
+            }], searchableTableResizableColumns: [{
+                type: Input,
+                args: ['resizableColumns']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"table.component.js","sourceRoot":"","sources":["../../../../../../projects/components/src/lib/display/table/table.component.ts","../../../../../../projects/components/src/lib/display/table/table.component.html"],"names":[],"mappings":"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","sourcesContent":["import { AfterContentInit, AfterViewInit, Component, ContentChildren, ElementRef, EventEmitter, HostBinding, Input, OnChanges, OnDestroy, Output, QueryList, Renderer2, SimpleChanges, TemplateRef, ViewEncapsulation } from '@angular/core';\r\nimport { isEqual } from 'lodash';\r\nimport { Subject } from 'rxjs';\r\nimport { takeUntil } from 'rxjs/operators';\r\nimport { ResizableColumnComponent } from './resizable-column.component';\r\nimport { TableMasterRowComponent } from './table-master-row.component';\r\nimport { TableSelectableRowContext } from './table-selectable-row.component';\r\n\r\nexport type TableSortDirection = 'desc' | 'asc';\r\nexport interface TableSort {\r\n  field: string;\r\n  direction: TableSortDirection;\r\n}\r\n\r\n@Component({\r\n  selector: 'ec-table',\r\n  templateUrl: './table.component.html',\r\n  styleUrls: ['./table.component.scss'],\r\n  encapsulation: ViewEncapsulation.None\r\n})\r\nexport class TableComponent implements AfterViewInit, OnDestroy, OnChanges, AfterContentInit{\r\n  @HostBinding('attr.id')\r\n  @Input() id = '';\r\n\r\n  /**\r\n   * Enables table scrolling with a sticky header and footer. Use\r\n   * <thead> and <tfoot> elements for styles to be applied correctly. \r\n   */\r\n  @HostBinding('class.is-scrollable')\r\n  @Input() scrollable = false;\r\n  \r\n  /**\r\n   * Enables resizable table columns. Apply the 'is-resizable' class\r\n   * to the <th> of a table column than can be resized.\r\n   */\r\n  @HostBinding('class.is-resizable')\r\n  @Input() resizable = false;\r\n  \r\n  /** \r\n   * Turns on condensed table styling. By default a condensed table\r\n   * has no row borders. To show borders, apply the 'has-borders' class\r\n   * to the <ec-table> element\r\n   */\r\n  @HostBinding('class.is-condensed')\r\n  @Input() condensed = false;\r\n  \r\n  /** \r\n   * Enables sorting by clicking on table columns. To make a column sortable\r\n   * apply the `data-sortable` attribute to the columns `<th>` element with \r\n   * the value of the field used to sort the column. When a column is clicked\r\n   * the fields and current sort direction is emitted from the `sortChange`\r\n   * output\r\n   * \r\n   * @example\r\n   * ```html\r\n   * <ec-table [sortable]=\"true\" [sort]=\"currentSort\" (sortChange)=\"onSort($event)\">\r\n   *  <thead>\r\n   *    <th data-sortable=\"name\">Name</th>\r\n   *    <th data-sortable=\"qty\">Qty.</th>\r\n   *    <th data-sortable=\"price\">Price</th>\r\n   *  </thead>\r\n   *  ...\r\n   * </ec-table>\r\n   * ```\r\n   */\r\n  @HostBinding('class.is-sortable')\r\n  @Input() sortable = false;\r\n  \r\n  /**\r\n   * Shared context of TableSelectableRowComponents in the table. Will turn on highlighting on row hover.\r\n   * Add the `TableSelectableRowComponent` to the table content to add checkboxes to each row and assign a \r\n   * TemplateRef to the `[selectionToolbarTemplate]` input that includes actions to take on selected items \r\n   * that will appear over the table header when 1 or more rows are selected.\r\n   */\r\n  @Input() selectionContext?: TableSelectableRowContext;\r\n\r\n  /** Include actions to display in a bar over the table header when 1 or more rows are selected. Requires `[selectionContext]` to be defined */\r\n  @Input() selectionToolbarTemplate?: TemplateRef<any>;\r\n  \r\n  /** Set to true if selectionContext is defined */\r\n  @HostBinding('class.is-selectable')\r\n  @Input() selectable = false;\r\n\r\n  /** Hides/shows the selection toolbar template when 1 or more rows is selected */\r\n  hasSelection = false\r\n\r\n  /**\r\n   * Enables form table styling to allow form controls inside table cells.\r\n   */\r\n  @HostBinding('class.is-form-table')\r\n  @Input() isForm = false;\r\n  \r\n  /**\r\n   * The current sort field and direction ('desc' or 'asc')\r\n   */\r\n  @Input() sort?: TableSort;\r\n\r\n  /**\r\n   * Emits the new sort value whenever a sortable column is clicked\r\n   */\r\n  @Output() sortChange: EventEmitter<TableSort> = new EventEmitter();\r\n\r\n  /**\r\n   * True if a TableMasterRowComponent exists in the table content\r\n   */\r\n  @HostBinding('class.is-master-detail') hasMasterDetailRows = false;\r\n\r\n  @ContentChildren(TableMasterRowComponent, {descendants: true}) masterRows!: QueryList<TableMasterRowComponent>;\r\n\r\n  public resizableColumns!: QueryList<ResizableColumnComponent>;\r\n  @ContentChildren(ResizableColumnComponent, {descendants: true}) _resizableColumns!: QueryList<ResizableColumnComponent>;\r\n\r\n  @Input('resizableColumns') searchableTableResizableColumns?: QueryList<ResizableColumnComponent>;\r\n\r\n  /**\r\n   * Unlisten function returned by `renderer.listen()` that are called\r\n   * OnDestroy to clean up all listeners\r\n   */\r\n  private unlisteners: (() => void)[] = [];\r\n  \r\n  /** The current sort value */\r\n  private currentSort?: TableSort;\r\n  \r\n  /** A map of sortable `<th>` elements */\r\n  private sortableCols: {[field: string]: HTMLTableHeaderCellElement} = {};\r\n\r\n  private destroyed: Subject<void> = new Subject();\r\n  \r\n  constructor(private renderer: Renderer2, public el: ElementRef) {}\r\n\r\n  ngOnChanges(changes: SimpleChanges): void {\r\n    if (this.sortable && changes.sort && changes.sort.currentValue && !changes.sort.firstChange) {\r\n      const newValue: TableSort = changes.sort.currentValue;\r\n      if (!this.currentSort || !isEqual(newValue, this.currentSort)){\r\n        this.onSort(newValue.field, newValue.direction);\r\n      }\r\n    }\r\n  }\r\n\r\n  ngAfterContentInit(): void {\r\n    this.hasMasterDetailRows = !!this.masterRows.length;\r\n    \r\n    this.masterRows.changes.pipe(\r\n      takeUntil(this.destroyed)\r\n    ).subscribe(() => {\r\n      this.hasMasterDetailRows = !!this.masterRows.length;\r\n    });\r\n\r\n    this.resizableColumns = this.searchableTableResizableColumns || this._resizableColumns;\r\n  }\r\n  \r\n  ngAfterViewInit(): void {\r\n    if (this.sortable) {\r\n      this.initSortable();\r\n    }\r\n\r\n    if (this.selectable) {\r\n      this.initSelectable();\r\n    }\r\n  }\r\n  \r\n  ngOnDestroy(): void {\r\n    if (this.unlisteners.length) {\r\n      this.unlisteners.forEach(unlisten => unlisten());\r\n    }\r\n    \r\n    this.destroyed.next();\r\n    this.destroyed.unsubscribe();\r\n  }\r\n\r\n  /**\r\n   * Get all elements inside the host element that match a selector \r\n   * @param selector - Any valid selector for [querySelectorAll](https://developer.mozilla.org/en-US/docs/Web/API/Document/querySelectorAll)\r\n   */\r\n  private queryElements<T>(selector: string): T[] {\r\n    const table = this.el.nativeElement;\r\n    return Array.from(table.querySelectorAll(selector));\r\n  }\r\n\r\n  /**\r\n   * Store a `<th>` for each sortable column and attach a click\r\n   * event listener. \r\n   */\r\n  private initSortable(): void {\r\n    this.queryElements<HTMLTableHeaderCellElement>('th').forEach(th => {\r\n      if (th.hasAttribute('data-sortfield')) {\r\n        \r\n        const field = th.getAttribute('data-sortfield');\r\n        if (field) {\r\n          this.sortableCols[field] = th;\r\n          const unlisten = this.renderer.listen(th, 'click', (event: MouseEvent) => {\r\n\r\n            // Do not sort if the event target was the resizable handle\r\n            if (th.classList.contains('is-resizable') && event.target && (<HTMLElement>event.target).classList.contains('handle')) {\r\n              return;\r\n            }\r\n\r\n            this.onSort(field);\r\n          });\r\n  \r\n          // Store unlisten function to remove listener when component is destroyed\r\n          this.unlisteners.push(unlisten);\r\n        } else {\r\n          console.error(`data-sortfield attribute was not assigned a value.`, th);\r\n        }\r\n      }\r\n    });\r\n\r\n    // Set the initial sort\r\n    if (this.sort) {\r\n      this.onSort(this.sort.field, this.sort.direction);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Find the sorted column and apply the desc or asc class in order\r\n   * to show the correct sort icon. If another field was sorted, reset it.\r\n   * Emit the current field and direction of the sorted column\r\n   * @param field \r\n   */\r\n  private onSort(field: string, direction?: TableSortDirection): void {\r\n    const th = this.sortableCols[field];\r\n    if (!th) { return; }\r\n    \r\n    if (this.currentSort && this.currentSort.field !== field) {\r\n      this.renderer.removeClass(this.sortableCols[this.currentSort.field], `is-sorted-${this.currentSort.direction}`);\r\n    } \r\n    \r\n    if (th.classList.contains('is-sorted-desc')) {\r\n      this.renderer.removeClass(th, 'is-sorted-desc');\r\n\r\n      if (!direction) {\r\n        direction = 'asc';\r\n      }\r\n\r\n    } else {\r\n      if (th.classList.contains('is-sorted-asc')) {\r\n        this.renderer.removeClass(th, 'is-sorted-asc');\r\n      }\r\n\r\n      if (!direction) {\r\n        direction = 'desc';\r\n      }\r\n    }\r\n\r\n    this.renderer.addClass(th, `is-sorted-${direction}`);\r\n\r\n    const sortEvent = {field: field, direction: direction};\r\n    this.currentSort = sortEvent;\r\n    this.sortChange.emit(sortEvent);\r\n  }\r\n\r\n  private initSelectable(): void {\r\n    this.selectionContext!.rowCheckboxes.valueChanges.pipe(\r\n      takeUntil(this.destroyed)\r\n    ).subscribe((value: boolean[]) => {\r\n      this.hasSelection = value.some(v => v);\r\n    });\r\n  }\r\n}","<div class=\"selectable-table-toolbar\"\r\n     *ngIf=\"hasSelection && selectionToolbarTemplate\">\r\n  <ng-container *ngTemplateOutlet=\"selectionToolbarTemplate\"></ng-container>\r\n</div>\r\n<div id=\"{{id}}-scroll-container\" \r\n     class=\"table-scroll-container\">\r\n  <table class=\"main-table\"\r\n         id=\"{{id}}\"\r\n         [ecResizableTable]=\"resizable\"\r\n         [containerEl]=\"el\"\r\n         [sortableTable]=\"sortable\"\r\n         [resizableColumns]=\"resizableColumns\">\r\n    <ng-content></ng-content>\r\n  </table>\r\n</div>"]}