@firestitch/list 12.12.3 → 12.12.5

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

@@ -1,91 +1,90 @@
-import { ChangeDetectionStrategy, ChangeDetectorRef, Component, Input, ViewChild, ViewContainerRef, } from '@angular/core';
-import { Subject } from 'rxjs';
-import { filter, takeUntil } from 'rxjs/operators';
-import { SortingController } from '../../classes/sorting-controller';
-import { ReorderController, ReorderPosition, ReorderStrategy } from '../../classes/reorder-controller';
-import { SelectionController, SelectionChangeType } from '../../classes/selection-controller';
-import * as i0 from "@angular/core";
-import * as i1 from "../../classes/reorder-controller";
-import * as i2 from "@angular/material/checkbox";
-import * as i3 from "./head-cell/head-cell.component";
-import * as i4 from "@angular/common";
-import * as i5 from "@angular/flex-layout/extended";
-export class FsHeadComponent {
-    constructor(reorderController, cdRef) {
-        this.reorderController = reorderController;
-        this.cdRef = cdRef;
-        this.selectedAll = false;
-        this.ReorderPosition = ReorderPosition;
-        this.ReorderStrategy = ReorderStrategy;
-        this._destroy$ = new Subject();
-    }
-    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.16", ngImport: i0, type: FsHeadComponent, deps: [{ token: i1.ReorderController }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
-FsHeadComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.16", type: FsHeadComponent, selector: "[fs-list-head]", inputs: { sorting: "sorting", columns: "columns", hasRowActions: "hasRowActions", selection: "selection" }, 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=\"reorderController.leftReorderActivated$ | async\" class=\"fs-list-col drag-col\"></th>\n\n  <!-- Selection -->\n  <th *ngIf=\"selection\" 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 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\"></th>\n\n  <!-- Drag -->\n  <th *ngIf=\"reorderController.rightReorderActivated$ | async\" class=\"fs-list-col drag-col\"></th>\n\n  <!-- Row Actions -->\n  <th *ngIf=\"hasRowActions && !(reorderController.manualReorderActivated$ | async)\" class=\"fs-list-col row-actions\"></th>\n</tr>\n", components: [{ type: i2.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: i3.FsHeadCellComponent, selector: "[fs-head-cell]" }], directives: [{ type: i4.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i4.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i4.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { type: i5.DefaultClassDirective, selector: "  [ngClass], [ngClass.xs], [ngClass.sm], [ngClass.md], [ngClass.lg], [ngClass.xl],  [ngClass.lt-sm], [ngClass.lt-md], [ngClass.lt-lg], [ngClass.lt-xl],  [ngClass.gt-xs], [ngClass.gt-sm], [ngClass.gt-md], [ngClass.gt-lg]", inputs: ["ngClass", "ngClass.xs", "ngClass.sm", "ngClass.md", "ngClass.lg", "ngClass.xl", "ngClass.lt-sm", "ngClass.lt-md", "ngClass.lt-lg", "ngClass.lt-xl", "ngClass.gt-xs", "ngClass.gt-sm", "ngClass.gt-md", "ngClass.gt-lg"] }], pipes: { "async": i4.AsyncPipe }, changeDetection: i0.ChangeDetectionStrategy.OnPush });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: FsHeadComponent, decorators: [{
-            type: Component,
-            args: [{
-                    selector: '[fs-list-head]',
-                    templateUrl: 'head.component.html',
-                    changeDetection: ChangeDetectionStrategy.OnPush
-                }]
-        }], ctorParameters: function () { return [{ type: i1.ReorderController }, { type: i0.ChangeDetectorRef }]; }, propDecorators: { sorting: [{
-                type: Input
-            }], columns: [{
-                type: Input
-            }], hasRowActions: [{
-                type: Input
-            }], selection: [{
-                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,EAEL,SAAS,EACT,gBAAgB,GACjB,MAAM,eAAe,CAAC;AAGvB,OAAO,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAC/B,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAGnD,OAAO,EAAE,iBAAiB,EAAE,MAAM,kCAAkC,CAAC;AACrE,OAAO,EACL,iBAAiB,EACjB,eAAe,EACf,eAAe,EAChB,MAAM,kCAAkC,CAAC;AAC1C,OAAO,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,MAAM,oCAAoC,CAAC;;;;;;;AAQ9F,MAAM,OAAO,eAAe;IAc1B,YACS,iBAAoC,EACnC,KAAwB;QADzB,sBAAiB,GAAjB,iBAAiB,CAAmB;QACnC,UAAK,GAAL,KAAK,CAAmB;QAR3B,gBAAW,GAAG,KAAK,CAAC;QACX,oBAAe,GAAG,eAAe,CAAC;QAClC,oBAAe,GAAG,eAAe,CAAC;QAE1C,cAAS,GAAG,IAAI,OAAO,EAAE,CAAC;IAK/B,CAAC;IAEG,QAAQ;QACb,IAAI,CAAC,WAAW,EAAE,CAAC;QACnB,IAAI,CAAC,aAAa,EAAE,CAAC;IACvB,CAAC;IAEM,WAAW;QAChB,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC;QACtB,IAAI,CAAC,SAAS,CAAC,QAAQ,EAAE,CAAC;IAC5B,CAAC;IAED;;;OAGG;IACI,SAAS,CAAC,KAAwB;QACvC,IAAI,CAAC,SAAS,CAAC,oBAAoB,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;IACrD,CAAC;IAED;;;OAGG;IACI,SAAS,CAAC,KAAK;QACpB,OAAO,KAAK,CAAC;IACf,CAAC;IAED;;OAEG;IACK,WAAW;QACjB,IAAI,CAAC,OAAO,CAAC,eAAe;aACzB,IAAI,CACH,SAAS,CAAC,IAAI,CAAC,SAAS,CAAC,CAC1B;aACA,SAAS,CAAC,GAAG,EAAE;YACd,IAAI,CAAC,KAAK,CAAC,aAAa,EAAE,CAAC;QAC7B,CAAC,CAAC,CAAC;IACP,CAAC;IAED;;OAEG;IACK,aAAa;QACnB,IAAI,IAAI,CAAC,SAAS,EAAE;YAClB,IAAI,CAAC,SAAS,CAAC,gBAAgB;iBAC5B,IAAI,CACH,MAAM,CACJ,CAAC,EAAC,IAAI,EAAC,EAAE,EAAE,CAAC,CACV,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,EAAC,IAAI,EAAE,OAAO,EAAE,MAAM,EAAC,EAAE,EAAE;gBACrC,IAAI,CAAC,WAAW,GAAG,MAAM,CAAC;gBAE1B,IAAI,CAAC,KAAK,CAAC,YAAY,EAAE,CAAC;YAC5B,CAAC,CAAC,CAAC;SACN;IACH,CAAC;;6GAhFU,eAAe;iGAAf,eAAe,6PAMU,gBAAgB,2CCnCtD,s/BAwBA;4FDKa,eAAe;kBAL3B,SAAS;mBAAC;oBACT,QAAQ,EAAE,gBAAgB;oBAC1B,WAAW,EAAE,qBAAqB;oBAClC,eAAe,EAAE,uBAAuB,CAAC,MAAM;iBAChD;wIAEU,OAAO;sBAAf,KAAK;gBACG,OAAO;sBAAf,KAAK;gBACG,aAAa;sBAArB,KAAK;gBACG,SAAS;sBAAjB,KAAK;gBAEgE,aAAa;sBAAlF,SAAS;uBAAC,eAAe,EAAE,EAAE,IAAI,EAAE,gBAAgB,EAAE,MAAM,EAAE,IAAI,EAAE","sourcesContent":["import {\n  ChangeDetectionStrategy,\n  ChangeDetectorRef,\n  Component,\n  Input,\n  OnInit,\n  ViewChild,\n  ViewContainerRef, OnDestroy,\n} from '@angular/core';\nimport { MatCheckboxChange } from '@angular/material/checkbox';\n\nimport { Subject } from 'rxjs';\nimport { filter, takeUntil } from 'rxjs/operators';\n\nimport { Column } from '../../models/column.model';\nimport { SortingController } from '../../classes/sorting-controller';\nimport {\n  ReorderController,\n  ReorderPosition,\n  ReorderStrategy\n} from '../../classes/reorder-controller';\nimport { SelectionController, SelectionChangeType } from '../../classes/selection-controller';\n\n\n@Component({\n  selector: '[fs-list-head]',\n  templateUrl: 'head.component.html',\n  changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class FsHeadComponent implements OnInit, OnDestroy {\n  @Input() sorting: SortingController;\n  @Input() columns: Column[];\n  @Input() hasRowActions: boolean;\n  @Input() selection: SelectionController;\n\n  @ViewChild('rowsContainer', { read: ViewContainerRef, static: true }) rowsContainer;\n\n  public selectedAll = false;\n  public readonly ReorderPosition = ReorderPosition;\n  public readonly ReorderStrategy = ReorderStrategy;\n\n  private _destroy$ = new Subject();\n\n  constructor(\n    public reorderController: ReorderController,\n    private cdRef: ChangeDetectorRef,\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   * @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   * @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=\"reorderController.leftReorderActivated$ | async\" class=\"fs-list-col drag-col\"></th>\n\n  <!-- Selection -->\n  <th *ngIf=\"selection\" 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 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\"></th>\n\n  <!-- Drag -->\n  <th *ngIf=\"reorderController.rightReorderActivated$ | async\" class=\"fs-list-col drag-col\"></th>\n\n  <!-- Row Actions -->\n  <th *ngIf=\"hasRowActions && !(reorderController.manualReorderActivated$ | async)\" class=\"fs-list-col row-actions\"></th>\n</tr>\n"]}
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, Input, ViewChild, ViewContainerRef, } from '@angular/core';
+import { Subject } from 'rxjs';
+import { filter, takeUntil } from 'rxjs/operators';
+import { SortingController } from '../../classes/sorting-controller';
+import { ReorderController, ReorderPosition, ReorderStrategy } from '../../classes/reorder-controller';
+import { SelectionController, SelectionChangeType } from '../../classes/selection-controller';
+import * as i0 from "@angular/core";
+import * as i1 from "../../classes/reorder-controller";
+import * as i2 from "@angular/material/checkbox";
+import * as i3 from "./head-cell/head-cell.component";
+import * as i4 from "@angular/common";
+export class FsHeadComponent {
+    constructor(reorderController, cdRef) {
+        this.reorderController = reorderController;
+        this.cdRef = cdRef;
+        this.selectedAll = false;
+        this.ReorderPosition = ReorderPosition;
+        this.ReorderStrategy = ReorderStrategy;
+        this._destroy$ = new Subject();
+    }
+    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.16", ngImport: i0, type: FsHeadComponent, deps: [{ token: i1.ReorderController }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
+FsHeadComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.16", type: FsHeadComponent, selector: "[fs-list-head]", inputs: { sorting: "sorting", columns: "columns", hasRowActions: "hasRowActions", selection: "selection" }, 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=\"reorderController.leftReorderActivated$ | async\" class=\"fs-list-col drag-col\"></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 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\"></th>\n\n  <!-- Drag -->\n  <th *ngIf=\"reorderController.rightReorderActivated$ | async\" class=\"fs-list-col drag-col\"></th>\n\n  <!-- Row Actions -->\n  <th *ngIf=\"hasRowActions && !(reorderController.manualReorderActivated$ | async)\" class=\"fs-list-col row-actions\"></th>\n</tr>\n", components: [{ type: i2.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: i3.FsHeadCellComponent, selector: "[fs-head-cell]" }], directives: [{ type: i4.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i4.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i4.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }], pipes: { "async": i4.AsyncPipe }, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: FsHeadComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: '[fs-list-head]',
+                    templateUrl: 'head.component.html',
+                    changeDetection: ChangeDetectionStrategy.OnPush
+                }]
+        }], ctorParameters: function () { return [{ type: i1.ReorderController }, { type: i0.ChangeDetectorRef }]; }, propDecorators: { sorting: [{
+                type: Input
+            }], columns: [{
+                type: Input
+            }], hasRowActions: [{
+                type: Input
+            }], selection: [{
+                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,EAEL,SAAS,EACT,gBAAgB,GACjB,MAAM,eAAe,CAAC;AAGvB,OAAO,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAC/B,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAGnD,OAAO,EAAE,iBAAiB,EAAE,MAAM,kCAAkC,CAAC;AACrE,OAAO,EACL,iBAAiB,EACjB,eAAe,EACf,eAAe,EAChB,MAAM,kCAAkC,CAAC;AAC1C,OAAO,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,MAAM,oCAAoC,CAAC;;;;;;AAQ9F,MAAM,OAAO,eAAe;IAc1B,YACS,iBAAoC,EACnC,KAAwB;QADzB,sBAAiB,GAAjB,iBAAiB,CAAmB;QACnC,UAAK,GAAL,KAAK,CAAmB;QAR3B,gBAAW,GAAG,KAAK,CAAC;QACX,oBAAe,GAAG,eAAe,CAAC;QAClC,oBAAe,GAAG,eAAe,CAAC;QAE1C,cAAS,GAAG,IAAI,OAAO,EAAE,CAAC;IAK/B,CAAC;IAEG,QAAQ;QACb,IAAI,CAAC,WAAW,EAAE,CAAC;QACnB,IAAI,CAAC,aAAa,EAAE,CAAC;IACvB,CAAC;IAEM,WAAW;QAChB,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC;QACtB,IAAI,CAAC,SAAS,CAAC,QAAQ,EAAE,CAAC;IAC5B,CAAC;IAED;;;OAGG;IACI,SAAS,CAAC,KAAwB;QACvC,IAAI,CAAC,SAAS,CAAC,oBAAoB,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;IACrD,CAAC;IAED;;;OAGG;IACI,SAAS,CAAC,KAAK;QACpB,OAAO,KAAK,CAAC;IACf,CAAC;IAED;;OAEG;IACK,WAAW;QACjB,IAAI,CAAC,OAAO,CAAC,eAAe;aACzB,IAAI,CACH,SAAS,CAAC,IAAI,CAAC,SAAS,CAAC,CAC1B;aACA,SAAS,CAAC,GAAG,EAAE;YACd,IAAI,CAAC,KAAK,CAAC,aAAa,EAAE,CAAC;QAC7B,CAAC,CAAC,CAAC;IACP,CAAC;IAED;;OAEG;IACK,aAAa;QACnB,IAAI,IAAI,CAAC,SAAS,EAAE;YAClB,IAAI,CAAC,SAAS,CAAC,gBAAgB;iBAC5B,IAAI,CACH,MAAM,CACJ,CAAC,EAAC,IAAI,EAAC,EAAE,EAAE,CAAC,CACV,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,EAAC,IAAI,EAAE,OAAO,EAAE,MAAM,EAAC,EAAE,EAAE;gBACrC,IAAI,CAAC,WAAW,GAAG,MAAM,CAAC;gBAE1B,IAAI,CAAC,KAAK,CAAC,YAAY,EAAE,CAAC;YAC5B,CAAC,CAAC,CAAC;SACN;IACH,CAAC;;6GAhFU,eAAe;iGAAf,eAAe,6PAMU,gBAAgB,2CCnCtD,whCAwBA;4FDKa,eAAe;kBAL3B,SAAS;mBAAC;oBACT,QAAQ,EAAE,gBAAgB;oBAC1B,WAAW,EAAE,qBAAqB;oBAClC,eAAe,EAAE,uBAAuB,CAAC,MAAM;iBAChD;wIAEU,OAAO;sBAAf,KAAK;gBACG,OAAO;sBAAf,KAAK;gBACG,aAAa;sBAArB,KAAK;gBACG,SAAS;sBAAjB,KAAK;gBAEgE,aAAa;sBAAlF,SAAS;uBAAC,eAAe,EAAE,EAAE,IAAI,EAAE,gBAAgB,EAAE,MAAM,EAAE,IAAI,EAAE","sourcesContent":["import {\r\n  ChangeDetectionStrategy,\r\n  ChangeDetectorRef,\r\n  Component,\r\n  Input,\r\n  OnInit,\r\n  ViewChild,\r\n  ViewContainerRef, OnDestroy,\r\n} from '@angular/core';\r\nimport { MatCheckboxChange } from '@angular/material/checkbox';\r\n\r\nimport { Subject } from 'rxjs';\r\nimport { filter, takeUntil } from 'rxjs/operators';\r\n\r\nimport { Column } from '../../models/column.model';\r\nimport { SortingController } from '../../classes/sorting-controller';\r\nimport {\r\n  ReorderController,\r\n  ReorderPosition,\r\n  ReorderStrategy\r\n} from '../../classes/reorder-controller';\r\nimport { SelectionController, SelectionChangeType } from '../../classes/selection-controller';\r\n\r\n\r\n@Component({\r\n  selector: '[fs-list-head]',\r\n  templateUrl: 'head.component.html',\r\n  changeDetection: ChangeDetectionStrategy.OnPush\r\n})\r\nexport class FsHeadComponent implements OnInit, OnDestroy {\r\n  @Input() sorting: SortingController;\r\n  @Input() columns: Column[];\r\n  @Input() hasRowActions: boolean;\r\n  @Input() selection: SelectionController;\r\n\r\n  @ViewChild('rowsContainer', { read: ViewContainerRef, static: true }) rowsContainer;\r\n\r\n  public selectedAll = false;\r\n  public readonly ReorderPosition = ReorderPosition;\r\n  public readonly ReorderStrategy = ReorderStrategy;\r\n\r\n  private _destroy$ = new Subject();\r\n\r\n  constructor(\r\n    public reorderController: ReorderController,\r\n    private cdRef: ChangeDetectorRef,\r\n  ) {}\r\n\r\n  public ngOnInit() {\r\n    this.initSorting();\r\n    this.initSelection();\r\n  }\r\n\r\n  public ngOnDestroy() {\r\n    this._destroy$.next();\r\n    this._destroy$.complete();\r\n  }\r\n\r\n  /**\r\n   * Select All Visible Rows\r\n   * @param event\r\n   */\r\n  public selectAll(event: MatCheckboxChange) {\r\n    this.selection.selectAllVisibleRows(event.checked);\r\n  }\r\n\r\n  /**\r\n   * Track By for improve change detection\r\n   * @param index\r\n   */\r\n  public trackByFn(index) {\r\n    return index;\r\n  }\r\n\r\n  /**\r\n   * Subscribe to sorting change\r\n   */\r\n  private initSorting() {\r\n    this.sorting.sortingChanged$\r\n      .pipe(\r\n        takeUntil(this._destroy$),\r\n      )\r\n      .subscribe(() => {\r\n        this.cdRef.detectChanges();\r\n      });\r\n  }\r\n\r\n  /**\r\n   * Subscribe to selection change\r\n   */\r\n  private initSelection() {\r\n    if (this.selection) {\r\n      this.selection.selectionChange$\r\n        .pipe(\r\n          filter(\r\n            ({type}) => (\r\n              type === SelectionChangeType.AllVisibleSelectionChange\r\n              || type === SelectionChangeType.SelectedAll\r\n              || type === SelectionChangeType.RowSelectionChange\r\n            )\r\n          ),\r\n          takeUntil(this._destroy$),\r\n        )\r\n        .subscribe(({type, payload: status}) => {\r\n          this.selectedAll = status;\r\n\r\n          this.cdRef.markForCheck();\r\n        });\r\n    }\r\n  }\r\n}\r\n","<tr class=\"fs-list-row\">\n  <!-- Drag -->\n  <th *ngIf=\"reorderController.leftReorderActivated$ | async\" class=\"fs-list-col drag-col\"></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 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\"></th>\n\n  <!-- Drag -->\n  <th *ngIf=\"reorderController.rightReorderActivated$ | async\" class=\"fs-list-col drag-col\"></th>\n\n  <!-- Row Actions -->\n  <th *ngIf=\"hasRowActions && !(reorderController.manualReorderActivated$ | async)\" class=\"fs-list-col row-actions\"></th>\n</tr>\n"]}