@firestitch/list 13.0.1 → 13.0.3

package/esm2015/app/components/head/head-cell/head-cell.component.js

@@ -0,0 +1,34 @@
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, KeyValueDiffers, } from '@angular/core';
+import { FsCellComponent } from '../../body/row/cell/cell.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/icon";
+import * as i2 from "@angular/common";
+export class FsHeadCellComponent extends FsCellComponent {
+    constructor(_cdRef, _differs) {
+        super();
+        this._cdRef = _cdRef;
+        this._differs = _differs;
+        this.cellContext = {};
+        this._columnDiffer = this._differs.find({}).create();
+    }
+    ngDoCheck() {
+        if (this._columnDiffer.diff(this.column)) {
+            this._cdRef.markForCheck();
+        }
+    }
+    initCellContext() {
+        this.cellContext.value = this.column.title;
+    }
+}
+FsHeadCellComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FsHeadCellComponent, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.KeyValueDiffers }], target: i0.ɵɵFactoryTarget.Component });
+FsHeadCellComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.17", type: FsHeadCellComponent, selector: "[fs-head-cell]", usesInheritance: true, ngImport: i0, template: "<div class=\"wrap\">\n    <span class=\"title\">\n      <ng-template [ngIf]=\"!column.headerTemplate\">{{column.title}}</ng-template>\n      <ng-template\n        [ngIf]=\"column.headerTemplate\"\n        [ngTemplateOutlet]=\"column.headerTemplate\"\n        [ngTemplateOutletContext]=\"cellContext\">\n      </ng-template>\n    </span>\n  <div class=\"direction\" *ngIf=\"column.ordered\" [ngSwitch]=\"column.sortingDirection$ | async\">\n    <mat-icon class=\"material-icons\" role=\"img\" aria-label=\"arrow_downward\" *ngSwitchCase=\"'asc'\">arrow_downward</mat-icon>\n    <mat-icon class=\"material-icons\" role=\"img\" aria-label=\"arrow_upward\" *ngSwitchCase=\"'desc'\">arrow_upward</mat-icon>\n  </div>\n</div>\n", styles: [".wrap{display:inline-flex;align-items:center}.wrap mat-icon{font-size:14px;display:block;height:14px;width:14px}.wrap .direction{margin-left:5px}\n"], components: [{ type: i1.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }], directives: [{ type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i2.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet"] }, { type: i2.NgSwitch, selector: "[ngSwitch]", inputs: ["ngSwitch"] }, { type: i2.NgSwitchCase, selector: "[ngSwitchCase]", inputs: ["ngSwitchCase"] }], pipes: { "async": i2.AsyncPipe }, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FsHeadCellComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: '[fs-head-cell]',
+                    templateUrl: './head-cell.component.html',
+                    styleUrls: ['./head-cell.component.scss'],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.KeyValueDiffers }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaGVhZC1jZWxsLmNvbXBvbmVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3NyYy9hcHAvY29tcG9uZW50cy9oZWFkL2hlYWQtY2VsbC9oZWFkLWNlbGwuY29tcG9uZW50LnRzIiwiLi4vLi4vLi4vLi4vLi4vLi4vc3JjL2FwcC9jb21wb25lbnRzL2hlYWQvaGVhZC1jZWxsL2hlYWQtY2VsbC5jb21wb25lbnQuaHRtbCJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQ0wsdUJBQXVCLEVBQ3ZCLGlCQUFpQixFQUNqQixTQUFTLEVBR1QsZUFBZSxHQUNoQixNQUFNLGVBQWUsQ0FBQztBQUV2QixPQUFPLEVBQUUsZUFBZSxFQUFFLE1BQU0sb0NBQW9DLENBQUM7Ozs7QUFTckUsTUFBTSxPQUFPLG1CQUFvQixTQUFRLGVBQWU7SUFNdEQsWUFDVSxNQUF5QixFQUN6QixRQUF5QjtRQUVqQyxLQUFLLEVBQUUsQ0FBQztRQUhBLFdBQU0sR0FBTixNQUFNLENBQW1CO1FBQ3pCLGFBQVEsR0FBUixRQUFRLENBQWlCO1FBTjVCLGdCQUFXLEdBQVEsRUFBRSxDQUFDO1FBUzNCLElBQUksQ0FBQyxhQUFhLEdBQUcsSUFBSSxDQUFDLFFBQVEsQ0FBQyxJQUFJLENBQUMsRUFBRSxDQUFDLENBQUMsTUFBTSxFQUFFLENBQUM7SUFDdkQsQ0FBQztJQUVNLFNBQVM7UUFDZCxJQUFJLElBQUksQ0FBQyxhQUFhLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxNQUFNLENBQUMsRUFBRTtZQUN4QyxJQUFJLENBQUMsTUFBTSxDQUFDLFlBQVksRUFBRSxDQUFDO1NBQzVCO0lBQ0gsQ0FBQztJQUVNLGVBQWU7UUFDcEIsSUFBSSxDQUFDLFdBQVcsQ0FBQyxLQUFLLEdBQUcsSUFBSSxDQUFDLE1BQU0sQ0FBQyxLQUFLLENBQUM7SUFDN0MsQ0FBQzs7aUhBdEJVLG1CQUFtQjtxR0FBbkIsbUJBQW1CLDZFQ2xCaEMsbXRCQWNBOzRGRElhLG1CQUFtQjtrQkFOL0IsU0FBUzttQkFBQztvQkFDVCxRQUFRLEVBQUUsZ0JBQWdCO29CQUMxQixXQUFXLEVBQUUsNEJBQTRCO29CQUN6QyxTQUFTLEVBQUUsQ0FBQyw0QkFBNEIsQ0FBQztvQkFDekMsZUFBZSxFQUFFLHVCQUF1QixDQUFDLE1BQU07aUJBQ2hEIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtcbiAgQ2hhbmdlRGV0ZWN0aW9uU3RyYXRlZ3ksXG4gIENoYW5nZURldGVjdG9yUmVmLFxuICBDb21wb25lbnQsXG4gIERvQ2hlY2ssXG4gIEtleVZhbHVlRGlmZmVyLFxuICBLZXlWYWx1ZURpZmZlcnMsXG59IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5pbXBvcnQgeyBGc0NlbGxDb21wb25lbnQgfSBmcm9tICcuLi8uLi9ib2R5L3Jvdy9jZWxsL2NlbGwuY29tcG9uZW50JztcblxuXG5AQ29tcG9uZW50KHtcbiAgc2VsZWN0b3I6ICdbZnMtaGVhZC1jZWxsXScsXG4gIHRlbXBsYXRlVXJsOiAnLi9oZWFkLWNlbGwuY29tcG9uZW50Lmh0bWwnLFxuICBzdHlsZVVybHM6IFsnLi9oZWFkLWNlbGwuY29tcG9uZW50LnNjc3MnXSxcbiAgY2hhbmdlRGV0ZWN0aW9uOiBDaGFuZ2VEZXRlY3Rpb25TdHJhdGVneS5PblB1c2gsXG59KVxuZXhwb3J0IGNsYXNzIEZzSGVhZENlbGxDb21wb25lbnQgZXh0ZW5kcyBGc0NlbGxDb21wb25lbnQgaW1wbGVtZW50cyBEb0NoZWNrIHtcblxuICBwdWJsaWMgY2VsbENvbnRleHQ6IGFueSA9IHt9O1xuXG4gIHByaXZhdGUgX2NvbHVtbkRpZmZlcjogS2V5VmFsdWVEaWZmZXI8c3RyaW5nLCBhbnk+O1xuXG4gIGNvbnN0cnVjdG9yKFxuICAgIHByaXZhdGUgX2NkUmVmOiBDaGFuZ2VEZXRlY3RvclJlZixcbiAgICBwcml2YXRlIF9kaWZmZXJzOiBLZXlWYWx1ZURpZmZlcnMsXG4gICkge1xuICAgIHN1cGVyKCk7XG4gICAgdGhpcy5fY29sdW1uRGlmZmVyID0gdGhpcy5fZGlmZmVycy5maW5kKHt9KS5jcmVhdGUoKTtcbiAgfVxuXG4gIHB1YmxpYyBuZ0RvQ2hlY2soKSB7XG4gICAgaWYgKHRoaXMuX2NvbHVtbkRpZmZlci5kaWZmKHRoaXMuY29sdW1uKSkge1xuICAgICAgdGhpcy5fY2RSZWYubWFya0ZvckNoZWNrKCk7XG4gICAgfVxuICB9XG5cbiAgcHVibGljIGluaXRDZWxsQ29udGV4dCgpIHtcbiAgICB0aGlzLmNlbGxDb250ZXh0LnZhbHVlID0gdGhpcy5jb2x1bW4udGl0bGU7XG4gIH1cbn1cbiIsIjxkaXYgY2xhc3M9XCJ3cmFwXCI+XG4gICAgPHNwYW4gY2xhc3M9XCJ0aXRsZVwiPlxuICAgICAgPG5nLXRlbXBsYXRlIFtuZ0lmXT1cIiFjb2x1bW4uaGVhZGVyVGVtcGxhdGVcIj57e2NvbHVtbi50aXRsZX19PC9uZy10ZW1wbGF0ZT5cbiAgICAgIDxuZy10ZW1wbGF0ZVxuICAgICAgICBbbmdJZl09XCJjb2x1bW4uaGVhZGVyVGVtcGxhdGVcIlxuICAgICAgICBbbmdUZW1wbGF0ZU91dGxldF09XCJjb2x1bW4uaGVhZGVyVGVtcGxhdGVcIlxuICAgICAgICBbbmdUZW1wbGF0ZU91dGxldENvbnRleHRdPVwiY2VsbENvbnRleHRcIj5cbiAgICAgIDwvbmctdGVtcGxhdGU+XG4gICAgPC9zcGFuPlxuICA8ZGl2IGNsYXNzPVwiZGlyZWN0aW9uXCIgKm5nSWY9XCJjb2x1bW4ub3JkZXJlZFwiIFtuZ1N3aXRjaF09XCJjb2x1bW4uc29ydGluZ0RpcmVjdGlvbiQgfCBhc3luY1wiPlxuICAgIDxtYXQtaWNvbiBjbGFzcz1cIm1hdGVyaWFsLWljb25zXCIgcm9sZT1cImltZ1wiIGFyaWEtbGFiZWw9XCJhcnJvd19kb3dud2FyZFwiICpuZ1N3aXRjaENhc2U9XCInYXNjJ1wiPmFycm93X2Rvd253YXJkPC9tYXQtaWNvbj5cbiAgICA8bWF0LWljb24gY2xhc3M9XCJtYXRlcmlhbC1pY29uc1wiIHJvbGU9XCJpbWdcIiBhcmlhLWxhYmVsPVwiYXJyb3dfdXB3YXJkXCIgKm5nU3dpdGNoQ2FzZT1cIidkZXNjJ1wiPmFycm93X3Vwd2FyZDwvbWF0LWljb24+XG4gIDwvZGl2PlxuPC9kaXY+XG4iXX0=

package/esm2015/app/components/head/head.component.js

@@ -0,0 +1,108 @@
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, Input, ViewChild, ViewContainerRef, } from '@angular/core';
+import { Subject } from 'rxjs';
+import { filter, takeUntil } from 'rxjs/operators';
+import { ReorderPosition, ReorderStrategy, } from '../../classes/reorder-controller';
+import { SelectionChangeType, SelectionController } from '../../classes/selection-controller';
+import { SortingController } from '../../classes/sorting-controller';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/checkbox";
+import * as i2 from "./head-cell/head-cell.component";
+import * as i3 from "@angular/common";
+export class FsHeadComponent {
+    constructor(_cdRef) {
+        this._cdRef = _cdRef;
+        this.selectedAll = false;
+        this.ReorderStrategyEnum = ReorderStrategy;
+        this._destroy$ = new Subject();
+    }
+    get leftDragDropEnabled() {
+        return this.reorderEnabled
+            && this.reorderPosition === ReorderPosition.Left
+            && this.activeFiltersCount === 0;
+    }
+    get rightDragDropEnabled() {
+        return this.reorderEnabled
+            && this.reorderPosition === ReorderPosition.Right
+            && this.activeFiltersCount === 0;
+    }
+    ngOnInit() {
+        this._initSorting();
+        this._initSelection();
+    }
+    ngOnDestroy() {
+        this._destroy$.next();
+        this._destroy$.complete();
+    }
+    /**
+     * Select All Visible Rows
+     *
+     * @param event
+     */
+    selectAll(event) {
+        this.selection.selectAllVisibleRows(event.checked);
+    }
+    /**
+     * Track By for improve change detection
+     *
+     * @param index
+     */
+    trackByFn(index) {
+        return index;
+    }
+    /**
+     * Subscribe to sorting change
+     */
+    _initSorting() {
+        this.sorting.sortingChanged$
+            .pipe(takeUntil(this._destroy$))
+            .subscribe(() => {
+            this._cdRef.detectChanges();
+        });
+    }
+    /**
+     * Subscribe to selection change
+     */
+    _initSelection() {
+        if (this.selection) {
+            this.selection.selectionChange$
+                .pipe(filter(({ type }) => (type === SelectionChangeType.AllVisibleSelectionChange
+                || type === SelectionChangeType.SelectedAll
+                || type === SelectionChangeType.RowSelectionChange)), takeUntil(this._destroy$))
+                .subscribe(({ type, payload: status }) => {
+                this.selectedAll = status;
+                this._cdRef.markForCheck();
+            });
+        }
+    }
+}
+FsHeadComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FsHeadComponent, deps: [{ token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
+FsHeadComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.17", type: FsHeadComponent, selector: "[fs-list-head]", inputs: { sorting: "sorting", columns: "columns", hasRowActions: "hasRowActions", selection: "selection", activeFiltersCount: "activeFiltersCount", reorderEnabled: "reorderEnabled", reorderPosition: "reorderPosition", reorderStrategy: "reorderStrategy" }, viewQueries: [{ propertyName: "rowsContainer", first: true, predicate: ["rowsContainer"], descendants: true, read: ViewContainerRef, static: true }], ngImport: i0, template: "<tr class=\"fs-list-row\">\n  <!-- Drag -->\n  <th *ngIf=\"leftDragDropEnabled\"\n      class=\"fs-list-col drag-col\">\n  </th>\n\n  <!-- Selection -->\n  <th *ngIf=\"selection && !(selection.disabled$ | async)\" class=\"fs-list-col fs-list-col-selection\">\n    <mat-checkbox (change)=\"selectAll($event)\" [checked]=\"selectedAll\"></mat-checkbox>\n  </th>\n\n  <!-- Content -->\n  <th \n    fs-head-cell *ngFor=\"let column of columns; trackBy: trackByFn\"\n    (click)=\"$event.stopPropagation(); sorting.sortBy(column)\"\n    [column]=\"column\"\n    [class.sorting]=\"column.sortable\"\n    [ngClass]=\"column.headerConfigs.classesArray\"\n    [attr.colspan]=\"column.headerConfigs.colspan\"\n    [attr.width]=\"column.width\">\n  </th>\n\n  <!-- Drag -->\n  <th *ngIf=\"rightDragDropEnabled\"\n      class=\"fs-list-col drag-col\">\n  </th>\n\n  <!-- Row Actions -->\n  <th *ngIf=\"hasRowActions && !(reorderEnabled && reorderStrategy === ReorderStrategyEnum.Manual)\" class=\"fs-list-col row-actions\"></th>\n</tr>\n", styles: ["th.fs-list-col-selection{width:1%;text-align:left}th.sorting{cursor:pointer}th.sorting:hover{background-color:#f6f6f6}th.sorting{background-image:none}th.left{text-align:left}th.center{text-align:center}th.right{text-align:right}\n"], components: [{ type: i1.MatCheckbox, selector: "mat-checkbox", inputs: ["disableRipple", "color", "tabIndex", "aria-label", "aria-labelledby", "id", "labelPosition", "name", "required", "checked", "disabled", "indeterminate", "aria-describedby", "value"], outputs: ["change", "indeterminateChange"], exportAs: ["matCheckbox"] }, { type: i2.FsHeadCellComponent, selector: "[fs-head-cell]" }], directives: [{ type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i3.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i3.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }], pipes: { "async": i3.AsyncPipe }, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FsHeadComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: '[fs-list-head]',
+                    templateUrl: './head.component.html',
+                    styleUrls: ['./head.component.scss'],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }]; }, propDecorators: { sorting: [{
+                type: Input
+            }], columns: [{
+                type: Input
+            }], hasRowActions: [{
+                type: Input
+            }], selection: [{
+                type: Input
+            }], activeFiltersCount: [{
+                type: Input
+            }], reorderEnabled: [{
+                type: Input
+            }], reorderPosition: [{
+                type: Input
+            }], reorderStrategy: [{
+                type: Input
+            }], rowsContainer: [{
+                type: ViewChild,
+                args: ['rowsContainer', { read: ViewContainerRef, static: true }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"head.component.js","sourceRoot":"","sources":["../../../../../src/app/components/head/head.component.ts","../../../../../src/app/components/head/head.component.html"],"names":[],"mappings":"AAAA,OAAO,EACL,uBAAuB,EACvB,iBAAiB,EACjB,SAAS,EACT,KAAK,EAGL,SAAS,EACT,gBAAgB,GACjB,MAAM,eAAe,CAAC;AAIvB,OAAO,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAC/B,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAEnD,OAAO,EACL,eAAe,EACf,eAAe,GAChB,MAAM,kCAAkC,CAAC;AAC1C,OAAO,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,MAAM,oCAAoC,CAAC;AAC9F,OAAO,EAAE,iBAAiB,EAAE,MAAM,kCAAkC,CAAC;;;;;AAUrE,MAAM,OAAO,eAAe;IAmB1B,YAAoB,MAAyB;QAAzB,WAAM,GAAN,MAAM,CAAmB;QALtC,gBAAW,GAAG,KAAK,CAAC;QACX,wBAAmB,GAAG,eAAe,CAAC;QAE9C,cAAS,GAAG,IAAI,OAAO,EAAE,CAAC;IAEe,CAAC;IAElD,IAAW,mBAAmB;QAC5B,OAAO,IAAI,CAAC,cAAc;eACrB,IAAI,CAAC,eAAe,KAAK,eAAe,CAAC,IAAI;eAC7C,IAAI,CAAC,kBAAkB,KAAK,CAAC,CAAC;IACrC,CAAC;IAED,IAAW,oBAAoB;QAC7B,OAAO,IAAI,CAAC,cAAc;eACrB,IAAI,CAAC,eAAe,KAAK,eAAe,CAAC,KAAK;eAC9C,IAAI,CAAC,kBAAkB,KAAK,CAAC,CAAC;IACrC,CAAC;IAEM,QAAQ;QACb,IAAI,CAAC,YAAY,EAAE,CAAC;QACpB,IAAI,CAAC,cAAc,EAAE,CAAC;IACxB,CAAC;IAEM,WAAW;QAChB,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC;QACtB,IAAI,CAAC,SAAS,CAAC,QAAQ,EAAE,CAAC;IAC5B,CAAC;IAED;;;;OAIG;IACI,SAAS,CAAC,KAAwB;QACvC,IAAI,CAAC,SAAS,CAAC,oBAAoB,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;IACrD,CAAC;IAED;;;;OAIG;IACI,SAAS,CAAC,KAAK;QACpB,OAAO,KAAK,CAAC;IACf,CAAC;IAED;;OAEG;IACK,YAAY;QAClB,IAAI,CAAC,OAAO,CAAC,eAAe;aACzB,IAAI,CACH,SAAS,CAAC,IAAI,CAAC,SAAS,CAAC,CAC1B;aACA,SAAS,CAAC,GAAG,EAAE;YACd,IAAI,CAAC,MAAM,CAAC,aAAa,EAAE,CAAC;QAC9B,CAAC,CAAC,CAAC;IACP,CAAC;IAED;;OAEG;IACK,cAAc;QACpB,IAAI,IAAI,CAAC,SAAS,EAAE;YAClB,IAAI,CAAC,SAAS,CAAC,gBAAgB;iBAC5B,IAAI,CACH,MAAM,CACJ,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,CACZ,IAAI,KAAK,mBAAmB,CAAC,yBAAyB;mBACnD,IAAI,KAAK,mBAAmB,CAAC,WAAW;mBACxC,IAAI,KAAK,mBAAmB,CAAC,kBAAkB,CACnD,CACF,EACD,SAAS,CAAC,IAAI,CAAC,SAAS,CAAC,CAC1B;iBACA,SAAS,CAAC,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,EAAE,EAAE;gBACvC,IAAI,CAAC,WAAW,GAAG,MAAM,CAAC;gBAE1B,IAAI,CAAC,MAAM,CAAC,YAAY,EAAE,CAAC;YAC7B,CAAC,CAAC,CAAC;SACN;IACH,CAAC;;6GAhGU,eAAe;iGAAf,eAAe,iZAWU,gBAAgB,2CC1CtD,mgCA8BA;4FDCa,eAAe;kBAN3B,SAAS;mBAAC;oBACT,QAAQ,EAAE,gBAAgB;oBAC1B,WAAW,EAAE,uBAAuB;oBACpC,SAAS,EAAE,CAAC,uBAAuB,CAAC;oBACpC,eAAe,EAAE,uBAAuB,CAAC,MAAM;iBAChD;wGAGiB,OAAO;sBAAtB,KAAK;gBACU,OAAO;sBAAtB,KAAK;gBACU,aAAa;sBAA5B,KAAK;gBACU,SAAS;sBAAxB,KAAK;gBACU,kBAAkB;sBAAjC,KAAK;gBACU,cAAc;sBAA7B,KAAK;gBACU,eAAe;sBAA9B,KAAK;gBACU,eAAe;sBAA9B,KAAK;gBAGC,aAAa;sBADnB,SAAS;uBAAC,eAAe,EAAE,EAAE,IAAI,EAAE,gBAAgB,EAAE,MAAM,EAAE,IAAI,EAAE","sourcesContent":["import {\n  ChangeDetectionStrategy,\n  ChangeDetectorRef,\n  Component,\n  Input,\n  OnDestroy,\n  OnInit,\n  ViewChild,\n  ViewContainerRef,\n} from '@angular/core';\n\nimport { MatCheckboxChange } from '@angular/material/checkbox';\n\nimport { Subject } from 'rxjs';\nimport { filter, takeUntil } from 'rxjs/operators';\n\nimport {\n  ReorderPosition,\n  ReorderStrategy,\n} from '../../classes/reorder-controller';\nimport { SelectionChangeType, SelectionController } from '../../classes/selection-controller';\nimport { SortingController } from '../../classes/sorting-controller';\nimport { Column } from '../../models/column.model';\n\n\n@Component({\n  selector: '[fs-list-head]',\n  templateUrl: './head.component.html',\n  styleUrls: ['./head.component.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class FsHeadComponent implements OnInit, OnDestroy {\n\n  @Input() public sorting: SortingController;\n  @Input() public columns: Column[];\n  @Input() public hasRowActions: boolean;\n  @Input() public selection: SelectionController;\n  @Input() public activeFiltersCount: number;\n  @Input() public reorderEnabled: boolean;\n  @Input() public reorderPosition: ReorderPosition | null;\n  @Input() public reorderStrategy: ReorderStrategy | null;\n\n  @ViewChild('rowsContainer', { read: ViewContainerRef, static: true })\n  public rowsContainer;\n\n  public selectedAll = false;\n  public readonly ReorderStrategyEnum = ReorderStrategy;\n\n  private _destroy$ = new Subject();\n\n  constructor(private _cdRef: ChangeDetectorRef) { }\n\n  public get leftDragDropEnabled(): boolean {\n    return this.reorderEnabled\n      && this.reorderPosition === ReorderPosition.Left\n      && this.activeFiltersCount === 0;\n  }\n\n  public get rightDragDropEnabled(): boolean {\n    return this.reorderEnabled\n      && this.reorderPosition === ReorderPosition.Right\n      && this.activeFiltersCount === 0;\n  }\n\n  public ngOnInit() {\n    this._initSorting();\n    this._initSelection();\n  }\n\n  public ngOnDestroy() {\n    this._destroy$.next();\n    this._destroy$.complete();\n  }\n\n  /**\n   * Select All Visible Rows\n   *\n   * @param event\n   */\n  public selectAll(event: MatCheckboxChange) {\n    this.selection.selectAllVisibleRows(event.checked);\n  }\n\n  /**\n   * Track By for improve change detection\n   *\n   * @param index\n   */\n  public trackByFn(index) {\n    return index;\n  }\n\n  /**\n   * Subscribe to sorting change\n   */\n  private _initSorting() {\n    this.sorting.sortingChanged$\n      .pipe(\n        takeUntil(this._destroy$),\n      )\n      .subscribe(() => {\n        this._cdRef.detectChanges();\n      });\n  }\n\n  /**\n   * Subscribe to selection change\n   */\n  private _initSelection() {\n    if (this.selection) {\n      this.selection.selectionChange$\n        .pipe(\n          filter(\n            ({ type }) => (\n              type === SelectionChangeType.AllVisibleSelectionChange\n              || type === SelectionChangeType.SelectedAll\n              || type === SelectionChangeType.RowSelectionChange\n            ),\n          ),\n          takeUntil(this._destroy$),\n        )\n        .subscribe(({ type, payload: status }) => {\n          this.selectedAll = status;\n\n          this._cdRef.markForCheck();\n        });\n    }\n  }\n}\n","<tr class=\"fs-list-row\">\n  <!-- Drag -->\n  <th *ngIf=\"leftDragDropEnabled\"\n      class=\"fs-list-col drag-col\">\n  </th>\n\n  <!-- Selection -->\n  <th *ngIf=\"selection && !(selection.disabled$ | async)\" class=\"fs-list-col fs-list-col-selection\">\n    <mat-checkbox (change)=\"selectAll($event)\" [checked]=\"selectedAll\"></mat-checkbox>\n  </th>\n\n  <!-- Content -->\n  <th \n    fs-head-cell *ngFor=\"let column of columns; trackBy: trackByFn\"\n    (click)=\"$event.stopPropagation(); sorting.sortBy(column)\"\n    [column]=\"column\"\n    [class.sorting]=\"column.sortable\"\n    [ngClass]=\"column.headerConfigs.classesArray\"\n    [attr.colspan]=\"column.headerConfigs.colspan\"\n    [attr.width]=\"column.width\">\n  </th>\n\n  <!-- Drag -->\n  <th *ngIf=\"rightDragDropEnabled\"\n      class=\"fs-list-col drag-col\">\n  </th>\n\n  <!-- Row Actions -->\n  <th *ngIf=\"hasRowActions && !(reorderEnabled && reorderStrategy === ReorderStrategyEnum.Manual)\" class=\"fs-list-col row-actions\"></th>\n</tr>\n"]}