@firestitch/list 12.20.1 → 13.0.0

package/esm2020/app/components/body/row/row.component.mjs

@@ -0,0 +1,308 @@
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, ElementRef, EventEmitter, HostBinding, Input, KeyValueDiffers, Renderer2, ViewChildren, } from '@angular/core';
+import { Subject } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+import { ReorderPosition, ReorderStrategy, } from '../../../classes/reorder-controller';
+import { SelectionController } from '../../../classes/selection-controller';
+import { FsListDraggableListDirective } from '../../../directives/draggable-list/draggable-list.directive';
+import { Row } from '../../../models/row';
+import { RowAction } from '../../../models/row-action.model';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../directives/draggable-list/draggable-list.directive";
+import * as i2 from "@angular/material/checkbox";
+import * as i3 from "./cell/cell.component";
+import * as i4 from "./actions/actions.component";
+import * as i5 from "@angular/material/icon";
+import * as i6 from "@angular/common";
+export class FsRowComponent {
+    constructor(el, _cdRef, _differs, _renderer, _draggableList) {
+        this.el = el;
+        this._cdRef = _cdRef;
+        this._differs = _differs;
+        this._renderer = _renderer;
+        this._draggableList = _draggableList;
+        this.role = 'row';
+        this.rowActionsRaw = [];
+        this.groupActionsRaw = [];
+        this.hasRowActions = false;
+        this.rowEvents = {};
+        this.restoreMode = false;
+        this.ReorderPosition = ReorderPosition;
+        this.ReorderStrategy = ReorderStrategy;
+        this.rowActions = [];
+        this.menuRowActions = [];
+        this.inlineRowActions = [];
+        this.selected = false;
+        this.indeterminateSelected = false;
+        this._eventListeners = [];
+        this._destroy$ = new Subject();
+        this._rowDiffer = _differs.find({}).create();
+    }
+    get isGroupRow() {
+        return this.row.isGroup;
+    }
+    get isGroupChildRow() {
+        return this.row.isGroupChild;
+    }
+    get isGroupFooterRow() {
+        return this.row.isGroupFooter;
+    }
+    get isDragDisabled() {
+        return !this.selected && this.reorderMultiple && !!this.selection.selectedRows.size;
+    }
+    get isMultipleSelection() {
+        const multiple = this.reorderMultiple;
+        return multiple && this.selected;
+    }
+    get rowCssClass() {
+        let classes = ['fs-list-row'];
+        if (this.rowIndex % 2 !== 0) {
+            classes.push('fs-list-row-odd');
+        }
+        if (this.rowIndex % 2 === 0) {
+            classes.push('fs-list-row-even');
+        }
+        if (this.row?.isGroup) {
+            classes.push('fs-list-row-group');
+        }
+        else if (this.row?.isChild) { // TODO fix isChild & all
+            classes.push('fs-list-row-group-child');
+        }
+        else if (this.row?.isGroupFooter) {
+            classes.push('fs-list-row-group-footer');
+        }
+        else {
+            classes.push('fs-list-row-body');
+        }
+        if (this.rowClass) {
+            classes = [
+                ...classes,
+                ...this._getRowClasses(this.rowClass),
+            ];
+        }
+        return classes.join(' ');
+    }
+    get dragCellVisible() {
+        return !this.row.isGroup;
+    }
+    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._initRowEvents();
+        this._initSelection();
+        if (this.row && this.row.isGroup) {
+            if (this.row && this.row.isGroup && this.groupActionsRaw) {
+                this.rowActions = this.groupActionsRaw.map((action) => new RowAction(action));
+                this._filterActionsByCategories();
+            }
+        }
+        else if (this.rowActionsRaw) {
+            this.rowActions = this.rowActionsRaw.map((action) => new RowAction(action));
+            this._filterActionsByCategories();
+        }
+    }
+    ngDoCheck() {
+        if (this._rowDiffer.diff(this.row)) {
+            if (this.rowActions) {
+                this.rowActions.forEach((action) => {
+                    action.checkShowStatus(this.row.data, this.rowIndex);
+                    action.updateLink(this.row.data);
+                });
+                this._filterActionsByCategories();
+            }
+            this._cdRef.markForCheck();
+        }
+    }
+    ngOnDestroy() {
+        this._eventListeners.forEach((listener) => {
+            listener();
+        });
+        this._destroy$.next();
+        this._destroy$.complete();
+    }
+    /**
+     * Select row by checkbox
+     *
+     * @param event
+     */
+    selectRow(event) {
+        this.selection.rowSelectionChange(this.row, event.checked);
+        this._cdRef.markForCheck();
+    }
+    /**
+     * Track By for improve change detection
+     *
+     * @param index
+     */
+    trackByFn(index) {
+        return index;
+    }
+    dragStart(event) {
+        if (this.reorderEnabled && !this.isDragDisabled) {
+            event.preventDefault();
+            event.stopPropagation();
+            this._draggableList.dragStart(this.el.nativeElement);
+        }
+    }
+    /**
+     * Set event listeners for row
+     */
+    _initRowEvents() {
+        Object.keys(this.rowEvents || {})
+            .forEach((event) => {
+            if (this.rowEvents.hasOwnProperty(event)) {
+                const listener = this._renderer
+                    .listen(this.el.nativeElement, event, (evt) => {
+                    if (!this.reorderEnabled) {
+                        this.rowEvents[event]({
+                            event: evt,
+                            row: this.row.data,
+                            rowIndex: this.rowIndex,
+                        });
+                    }
+                });
+                this._eventListeners.push(listener);
+            }
+        });
+    }
+    _getRowClasses(rowClass) {
+        const classes = [];
+        const options = {
+            index: this.rowIndex,
+            type: this.row.type,
+        };
+        if (this.row.isGroup) {
+            options.groupIndex = this.row.index;
+        }
+        else if (this.row.isChild || this.row.isGroupFooter) { // TODO fix isChild & all
+            options.groupIndex = this.row.parent.index;
+        }
+        const resultClass = rowClass(this.row.data, options);
+        if (resultClass) {
+            if (typeof resultClass === 'string') {
+                classes.push(resultClass);
+            }
+            else if (typeof resultClass === 'object') {
+                const keys = Object.keys(resultClass);
+                for (const k of keys) {
+                    if (resultClass[k] === true) {
+                        classes.push(k);
+                    }
+                }
+            }
+        }
+        return classes;
+    }
+    /**
+     * Subscribe to selection change events
+     */
+    _initSelection() {
+        if (this.selection) {
+            this.selected = this.row && this.selection.isRowSelected(this.row.data);
+            this.selection.selectionChange$
+                .pipe(
+            // // Would like to respond only when checkbox on top is changed
+            // // or was clicked "Select All" in selection dialog
+            // filter(({type}) => {
+            //   return type === SelectionChangeType.AllVisibleSelectionChange
+            //     || type === SelectionChangeType.SelectedAll;
+            // }),
+            takeUntil(this._destroy$))
+                .subscribe(() => {
+                this.selected = this.row && this.selection.isRowSelected(this.row.data);
+                if (this.row?.isGroup) {
+                    const groupSelection = this.selection.isGroupSelected(this.row);
+                    if (groupSelection === 'indeterminate') {
+                        this.selected = true;
+                        this.indeterminateSelected = true;
+                    }
+                    else {
+                        this.selected = groupSelection;
+                        this.indeterminateSelected = false;
+                    }
+                }
+                this._cdRef.markForCheck();
+            });
+        }
+    }
+    _filterActionsByCategories() {
+        this.menuRowActions = [];
+        this.inlineRowActions = [];
+        this.restoreAction = null;
+        this.rowActions.forEach((action) => {
+            if (!action.isShown) {
+                return;
+            }
+            if (action.menu && !action.restore) {
+                this.menuRowActions.push(action);
+            }
+            else if (!action.menu && !action.restore) {
+                this.inlineRowActions.push(action);
+            }
+            else if (action.restore) {
+                this.restoreAction = action;
+            }
+        });
+    }
+}
+FsRowComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: FsRowComponent, deps: [{ token: i0.ElementRef }, { token: i0.ChangeDetectorRef }, { token: i0.KeyValueDiffers }, { token: i0.Renderer2 }, { token: i1.FsListDraggableListDirective }], target: i0.ɵɵFactoryTarget.Component });
+FsRowComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.4.0", type: FsRowComponent, selector: "[fs-list-row]", inputs: { row: "row", rowActionsRaw: "rowActionsRaw", groupActionsRaw: "groupActionsRaw", hasRowActions: "hasRowActions", rowEvents: "rowEvents", rowClass: "rowClass", restoreMode: "restoreMode", rowIndex: "rowIndex", columns: "columns", selection: "selection", rowRemoved: "rowRemoved", activeFiltersCount: "activeFiltersCount", reorderEnabled: "reorderEnabled", reorderPosition: "reorderPosition", reorderStrategy: "reorderStrategy", reorderMultiple: "reorderMultiple" }, host: { properties: { "attr.role": "this.role", "class.drag-row": "this.reorderEnabled", "class.multiple-selection": "this.isMultipleSelection", "class": "this.rowCssClass" } }, viewQueries: [{ propertyName: "cellRefs", predicate: ["td"], descendants: true }], ngImport: i0, template: "<!-- Drag -->\n<ng-container *ngIf=\"leftDragDropEnabled\">\n  <ng-container *ngTemplateOutlet=\"dragCell\"></ng-container>\n</ng-container>\n\n<!-- Selection -->\n<ng-container *ngIf=\"selection && !(selection.disabled$ | async)\">\n  <td class=\"fs-list-col fs-list-col-selection\">\n    <ng-container *ngIf=\"!row.isGroupFooter\">\n      <mat-checkbox \n        (change)=\"selectRow($event)\"\n        [checked]=\"selected\"\n        [indeterminate]=\"indeterminateSelected\">\n      </mat-checkbox>\n    </ng-container>\n  </td>\n</ng-container>\n\n<!-- Content -->\n<ng-container *ngFor=\"let column of columns; trackBy: trackByFn; let isFirst = first\">\n  <td fs-cell\n      *ngIf=\"(isGroupRow && !column.groupHeaderColspanned)\n        || (isGroupFooterRow && !column.groupFooterColspanned)\n        || (!isGroupRow && !isGroupFooterRow && !column.cellColspanned)\"\n      [column]=\"column\"\n      [row]=\"row\"\n      [rowIndex]=\"rowIndex\"\n      [class]=\"(isGroupRow && column.groupHeaderConfigs.classesString)\n        || (isGroupFooterRow && column.groupFooterConfigs.classesString)\n        || (!isGroupFooterRow && column.cellConfigs.classesString)\"\n      [ngClass]=\"{ 'primary-col': isFirst }\"\n      [attr.colspan]=\"(isGroupRow && column.groupHeaderConfigs.colspan)\n        || (isGroupFooterRow && column.groupFooterConfigs.colspan)\n        || column.cellConfigs.colspan\"\n      [attr.width]=\"column.width\"\n  >\n  </td>\n</ng-container>\n\n<!-- Drag -->\n<ng-container *ngIf=\"rightDragDropEnabled\">\n  <ng-container *ngTemplateOutlet=\"dragCell\"></ng-container>\n</ng-container>\n\n<!-- Row Actions -->\n<td *ngIf=\"hasRowActions && !(reorderEnabled && reorderStrategy === ReorderStrategy.Manual)\" class=\"fs-list-col row-actions\">\n  <ng-container *ngIf=\"!isGroupFooterRow\">\n    <fs-list-row-actions\n      [row]=\"row\"\n      [index]=\"rowIndex\"\n      [rowActions]=\"rowActions\"\n      [menuRowActions]=\"menuRowActions\"\n      [inlineRowActions]=\"inlineRowActions\"\n      [restoreAction]=\"restoreAction\"\n      [restoreMode]=\"restoreMode\"\n      [rowRemoved]=\"rowRemoved\">\n    </fs-list-row-actions>\n  </ng-container>\n</td>\n\n<ng-template #dragCell>\n  <ng-container *ngIf=\"dragCellVisible && !isGroupFooterRow; else emptyCell\">\n    <td \n        class=\"fs-list-col drag-col\"\n        [class.drag-disabled]=\"isDragDisabled\"\n        (mousedown)=\"dragStart($event)\"\n        (touchstart)=\"dragStart($event)\">\n      <mat-icon>drag_handle</mat-icon>\n    </td>\n  </ng-container>\n  <ng-template #emptyCell>\n    <td class=\"fs-list-col drag-col\"></td>\n  </ng-template>\n</ng-template>\n", styles: [":host.drag-hidden{display:none}:host.draggable{opacity:.8;position:fixed;z-index:9999;box-shadow:2px 2px 2px #9e9e9ea6;border-radius:5px}:host.draggable td{border:none;background-color:#fff}:host.draggable-elem td{background-color:#c3c3c3}td.drag-col{width:24px;text-align:center;cursor:grab}td.drag-col.drag-disabled{opacity:.4;cursor:no-drop}td.drag-col mat-icon{display:flex}td.fs-list-col-selection{padding:10px}td.row-actions{width:1%;white-space:nowrap;overflow:hidden}td.row-actions .row-inline-action{margin-left:12px;display:inline-block}td.row-actions .row-inline-action:first-child{margin-left:0}td.row-actions .row-inline-action-icon,td.row-actions .row-inline-action-fab,td.row-actions .row-inline-action-mini-fab,td.row-actions .row-menu-action{width:35px;justify-content:center;align-items:center}td.left{text-align:left}td.center{text-align:center}td.right{text-align:right}\n"], components: [{ type: i2.MatCheckbox, selector: "mat-checkbox", inputs: ["disableRipple", "color", "tabIndex", "aria-label", "aria-labelledby", "aria-describedby", "id", "required", "labelPosition", "name", "value", "checked", "disabled", "indeterminate"], outputs: ["change", "indeterminateChange"], exportAs: ["matCheckbox"] }, { type: i3.FsCellComponent, selector: "[fs-cell]", inputs: ["column", "row", "rowIndex"] }, { type: i4.FsRowActionsComponent, selector: "fs-list-row-actions", inputs: ["row", "index", "restoreMode", "rowActions", "rowRemoved", "menuRowActions", "inlineRowActions", "restoreAction"] }, { type: i5.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }], directives: [{ type: i6.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i6.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet"] }, { type: i6.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i6.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }], pipes: { "async": i6.AsyncPipe }, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: FsRowComponent, decorators: [{
+            type: Component,
+            args: [{ selector: '[fs-list-row]', changeDetection: ChangeDetectionStrategy.OnPush, template: "<!-- Drag -->\n<ng-container *ngIf=\"leftDragDropEnabled\">\n  <ng-container *ngTemplateOutlet=\"dragCell\"></ng-container>\n</ng-container>\n\n<!-- Selection -->\n<ng-container *ngIf=\"selection && !(selection.disabled$ | async)\">\n  <td class=\"fs-list-col fs-list-col-selection\">\n    <ng-container *ngIf=\"!row.isGroupFooter\">\n      <mat-checkbox \n        (change)=\"selectRow($event)\"\n        [checked]=\"selected\"\n        [indeterminate]=\"indeterminateSelected\">\n      </mat-checkbox>\n    </ng-container>\n  </td>\n</ng-container>\n\n<!-- Content -->\n<ng-container *ngFor=\"let column of columns; trackBy: trackByFn; let isFirst = first\">\n  <td fs-cell\n      *ngIf=\"(isGroupRow && !column.groupHeaderColspanned)\n        || (isGroupFooterRow && !column.groupFooterColspanned)\n        || (!isGroupRow && !isGroupFooterRow && !column.cellColspanned)\"\n      [column]=\"column\"\n      [row]=\"row\"\n      [rowIndex]=\"rowIndex\"\n      [class]=\"(isGroupRow && column.groupHeaderConfigs.classesString)\n        || (isGroupFooterRow && column.groupFooterConfigs.classesString)\n        || (!isGroupFooterRow && column.cellConfigs.classesString)\"\n      [ngClass]=\"{ 'primary-col': isFirst }\"\n      [attr.colspan]=\"(isGroupRow && column.groupHeaderConfigs.colspan)\n        || (isGroupFooterRow && column.groupFooterConfigs.colspan)\n        || column.cellConfigs.colspan\"\n      [attr.width]=\"column.width\"\n  >\n  </td>\n</ng-container>\n\n<!-- Drag -->\n<ng-container *ngIf=\"rightDragDropEnabled\">\n  <ng-container *ngTemplateOutlet=\"dragCell\"></ng-container>\n</ng-container>\n\n<!-- Row Actions -->\n<td *ngIf=\"hasRowActions && !(reorderEnabled && reorderStrategy === ReorderStrategy.Manual)\" class=\"fs-list-col row-actions\">\n  <ng-container *ngIf=\"!isGroupFooterRow\">\n    <fs-list-row-actions\n      [row]=\"row\"\n      [index]=\"rowIndex\"\n      [rowActions]=\"rowActions\"\n      [menuRowActions]=\"menuRowActions\"\n      [inlineRowActions]=\"inlineRowActions\"\n      [restoreAction]=\"restoreAction\"\n      [restoreMode]=\"restoreMode\"\n      [rowRemoved]=\"rowRemoved\">\n    </fs-list-row-actions>\n  </ng-container>\n</td>\n\n<ng-template #dragCell>\n  <ng-container *ngIf=\"dragCellVisible && !isGroupFooterRow; else emptyCell\">\n    <td \n        class=\"fs-list-col drag-col\"\n        [class.drag-disabled]=\"isDragDisabled\"\n        (mousedown)=\"dragStart($event)\"\n        (touchstart)=\"dragStart($event)\">\n      <mat-icon>drag_handle</mat-icon>\n    </td>\n  </ng-container>\n  <ng-template #emptyCell>\n    <td class=\"fs-list-col drag-col\"></td>\n  </ng-template>\n</ng-template>\n", styles: [":host.drag-hidden{display:none}:host.draggable{opacity:.8;position:fixed;z-index:9999;box-shadow:2px 2px 2px #9e9e9ea6;border-radius:5px}:host.draggable td{border:none;background-color:#fff}:host.draggable-elem td{background-color:#c3c3c3}td.drag-col{width:24px;text-align:center;cursor:grab}td.drag-col.drag-disabled{opacity:.4;cursor:no-drop}td.drag-col mat-icon{display:flex}td.fs-list-col-selection{padding:10px}td.row-actions{width:1%;white-space:nowrap;overflow:hidden}td.row-actions .row-inline-action{margin-left:12px;display:inline-block}td.row-actions .row-inline-action:first-child{margin-left:0}td.row-actions .row-inline-action-icon,td.row-actions .row-inline-action-fab,td.row-actions .row-inline-action-mini-fab,td.row-actions .row-menu-action{width:35px;justify-content:center;align-items:center}td.left{text-align:left}td.center{text-align:center}td.right{text-align:right}\n"] }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.ChangeDetectorRef }, { type: i0.KeyValueDiffers }, { type: i0.Renderer2 }, { type: i1.FsListDraggableListDirective }]; }, propDecorators: { role: [{
+                type: HostBinding,
+                args: ['attr.role']
+            }], row: [{
+                type: Input
+            }], rowActionsRaw: [{
+                type: Input
+            }], groupActionsRaw: [{
+                type: Input
+            }], hasRowActions: [{
+                type: Input
+            }], rowEvents: [{
+                type: Input
+            }], rowClass: [{
+                type: Input
+            }], restoreMode: [{
+                type: Input
+            }], rowIndex: [{
+                type: Input
+            }], columns: [{
+                type: Input
+            }], selection: [{
+                type: Input
+            }], rowRemoved: [{
+                type: Input
+            }], activeFiltersCount: [{
+                type: Input
+            }], reorderEnabled: [{
+                type: Input
+            }, {
+                type: HostBinding,
+                args: ['class.drag-row']
+            }], reorderPosition: [{
+                type: Input
+            }], reorderStrategy: [{
+                type: Input
+            }], reorderMultiple: [{
+                type: Input
+            }], cellRefs: [{
+                type: ViewChildren,
+                args: ['td']
+            }], isMultipleSelection: [{
+                type: HostBinding,
+                args: ['class.multiple-selection']
+            }], rowCssClass: [{
+                type: HostBinding,
+                args: ['class']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"row.component.js","sourceRoot":"","sources":["../../../../../../src/app/components/body/row/row.component.ts","../../../../../../src/app/components/body/row/row.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  ChangeDetectionStrategy,\n  ChangeDetectorRef,\n  Component,\n  DoCheck,\n  ElementRef,\n  EventEmitter,\n  HostBinding,\n  Input,\n  KeyValueDiffer,\n  KeyValueDiffers,\n  OnDestroy,\n  OnInit,\n  Renderer2,\n  ViewChildren,\n} from '@angular/core';\n\nimport { MatCheckboxChange } from '@angular/material/checkbox';\n\nimport { Subject } from 'rxjs';\nimport { takeUntil } from 'rxjs/operators';\n\nimport {\n  ReorderPosition,\n  ReorderStrategy,\n} from '../../../classes/reorder-controller';\nimport { SelectionController } from '../../../classes/selection-controller';\nimport { FsListDraggableListDirective } from '../../../directives/draggable-list/draggable-list.directive';\nimport { FsListRowClassOptions } from '../../../interfaces';\nimport { Column } from '../../../models/column.model';\nimport { Row } from '../../../models/row';\nimport { RowAction } from '../../../models/row-action.model';\n\n\n@Component({\n  selector: '[fs-list-row]',\n  templateUrl: './row.component.html',\n  styleUrls: ['./row.component.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class FsRowComponent implements OnInit, DoCheck, OnDestroy {\n\n  @HostBinding('attr.role')\n  public role = 'row';\n\n  @Input() public row: Row;\n  @Input() public rowActionsRaw: any[] = [];\n  @Input() public groupActionsRaw: any[] = [];\n  @Input() public hasRowActions = false;\n  @Input() public rowEvents = {};\n  @Input() public rowClass;\n  @Input() public restoreMode = false;\n  @Input() public rowIndex: number;\n  @Input() public columns: Column[];\n  @Input() public selection: SelectionController;\n  @Input() public rowRemoved: EventEmitter<any>;\n  @Input() public activeFiltersCount: number;\n\n  @Input()\n  @HostBinding('class.drag-row')\n  public reorderEnabled: boolean;\n\n  @Input() public reorderPosition: ReorderPosition | null;\n  @Input() public reorderStrategy: ReorderStrategy | null;\n  @Input() public reorderMultiple: boolean;\n\n\n  @ViewChildren('td')\n  public cellRefs;\n\n  public readonly ReorderPosition = ReorderPosition;\n  public readonly ReorderStrategy = ReorderStrategy;\n  public rowActions: RowAction[] = [];\n  public menuRowActions: RowAction[] = [];\n  public inlineRowActions: RowAction[] = [];\n  public restoreAction: RowAction;\n  public selected = false;\n  public indeterminateSelected: boolean | 'indeterminate' = false;\n\n  private _rowDiffer: KeyValueDiffer<any, any>;\n  private _eventListeners = [];\n  private _destroy$ = new Subject();\n\n  constructor(\n    public el: ElementRef,\n    private _cdRef: ChangeDetectorRef,\n    private _differs: KeyValueDiffers,\n    private _renderer: Renderer2,\n    private _draggableList: FsListDraggableListDirective,\n  ) {\n    this._rowDiffer = _differs.find({}).create();\n  }\n\n  public get isGroupRow(): boolean {\n    return this.row.isGroup;\n  }\n\n  public get isGroupChildRow(): boolean {\n    return this.row.isGroupChild;\n  }\n\n  public get isGroupFooterRow(): boolean {\n    return this.row.isGroupFooter;\n  }\n\n  public get isDragDisabled(): boolean {\n    return !this.selected && this.reorderMultiple && !!this.selection.selectedRows.size;\n  }\n\n  @HostBinding('class.multiple-selection')\n  public get isMultipleSelection() {\n    const multiple = this.reorderMultiple;\n\n    return multiple && this.selected;\n  }\n\n  @HostBinding('class')\n  public get rowCssClass() {\n    let classes = ['fs-list-row'];\n\n    if (this.rowIndex % 2 !== 0) {\n      classes.push('fs-list-row-odd');\n    }\n    if (this.rowIndex % 2 === 0) {\n      classes.push('fs-list-row-even');\n    }\n\n    if (this.row?.isGroup) {\n      classes.push('fs-list-row-group');\n    } else if ((this.row as any)?.isChild) { // TODO fix isChild & all\n      classes.push('fs-list-row-group-child');\n    } else if (this.row?.isGroupFooter) {\n      classes.push('fs-list-row-group-footer');\n    } else {\n      classes.push('fs-list-row-body');\n    }\n\n    if (this.rowClass) {\n      classes = [\n        ...classes,\n        ...this._getRowClasses(this.rowClass),\n      ];\n    }\n\n    return classes.join(' ');\n  }\n\n  public get dragCellVisible(): boolean {\n    return !this.row.isGroup;\n  }\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._initRowEvents();\n    this._initSelection();\n\n    if (this.row && this.row.isGroup) {\n      if (this.row && this.row.isGroup && this.groupActionsRaw) {\n        this.rowActions = this.groupActionsRaw.map((action) => new RowAction(action));\n\n        this._filterActionsByCategories();\n      }\n    } else if (this.rowActionsRaw) {\n      this.rowActions = this.rowActionsRaw.map((action) => new RowAction(action));\n\n      this._filterActionsByCategories();\n    }\n  }\n\n  public ngDoCheck() {\n    if (this._rowDiffer.diff(this.row)) {\n      if (this.rowActions) {\n        this.rowActions.forEach((action) => {\n          action.checkShowStatus(this.row.data, this.rowIndex);\n          action.updateLink(this.row.data);\n        });\n        this._filterActionsByCategories();\n      }\n\n      this._cdRef.markForCheck();\n    }\n  }\n\n  public ngOnDestroy() {\n    this._eventListeners.forEach((listener) => {\n      listener();\n    });\n\n    this._destroy$.next();\n    this._destroy$.complete();\n  }\n\n  /**\n   * Select row by checkbox\n   *\n   * @param event\n   */\n  public selectRow(event: MatCheckboxChange) {\n    this.selection.rowSelectionChange(this.row, event.checked);\n    this._cdRef.markForCheck();\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  public dragStart(event) {\n    if (this.reorderEnabled && !this.isDragDisabled) {\n      event.preventDefault();\n      event.stopPropagation();\n\n      this._draggableList.dragStart(this.el.nativeElement);\n    }\n  }\n\n  /**\n   * Set event listeners for row\n   */\n  private _initRowEvents() {\n    Object.keys(this.rowEvents || {})\n      .forEach((event) => {\n        if (this.rowEvents.hasOwnProperty(event)) {\n          const listener = this._renderer\n            .listen(this.el.nativeElement, event, (evt) => {\n              if (!this.reorderEnabled) {\n                this.rowEvents[event]({\n                  event: evt,\n                  row: this.row.data,\n                  rowIndex: this.rowIndex,\n                });\n              }\n            });\n\n          this._eventListeners.push(listener);\n        }\n      });\n  }\n\n  private _getRowClasses(rowClass): string[] {\n    const classes = [];\n    const options: FsListRowClassOptions = {\n      index: this.rowIndex,\n      type: this.row.type,\n    };\n\n    if (this.row.isGroup) {\n      options.groupIndex = this.row.index;\n    } else if ((this.row as any).isChild || this.row.isGroupFooter) { // TODO fix isChild & all\n      options.groupIndex = this.row.parent.index;\n    }\n\n    const resultClass = rowClass(this.row.data, options);\n    if(resultClass) {\n      if (typeof resultClass === 'string') {\n        classes.push(resultClass);\n      } else if (typeof resultClass === 'object') {\n        const keys = Object.keys(resultClass);\n        for (const k of keys) {\n          if (resultClass[k] === true) {\n            classes.push(k);\n          }\n        }\n      }\n    }\n\n    return classes;\n  }\n\n  /**\n   * Subscribe to selection change events\n   */\n  private _initSelection() {\n    if (this.selection) {\n      this.selected = this.row && this.selection.isRowSelected(this.row.data);\n\n      this.selection.selectionChange$\n        .pipe(\n          // // Would like to respond only when checkbox on top is changed\n          // // or was clicked \"Select All\" in selection dialog\n          // filter(({type}) => {\n          //   return type === SelectionChangeType.AllVisibleSelectionChange\n          //     || type === SelectionChangeType.SelectedAll;\n          // }),\n          takeUntil(this._destroy$),\n        )\n        .subscribe(() => {\n          this.selected = this.row && this.selection.isRowSelected(this.row.data);\n\n          if (this.row?.isGroup) {\n            const groupSelection = this.selection.isGroupSelected(this.row);\n\n            if (groupSelection === 'indeterminate') {\n              this.selected = true;\n              this.indeterminateSelected = true;\n            } else {\n              this.selected = groupSelection;\n              this.indeterminateSelected = false;\n            }\n          }\n\n          this._cdRef.markForCheck();\n        });\n    }\n  }\n\n  private _filterActionsByCategories() {\n    this.menuRowActions = [];\n    this.inlineRowActions = [];\n    this.restoreAction = null;\n\n    this.rowActions.forEach((action) => {\n\n      if (!action.isShown) {\n        return;\n      }\n\n      if (action.menu && !action.restore) {\n        this.menuRowActions.push(action);\n      } else if (!action.menu && !action.restore) {\n        this.inlineRowActions.push(action);\n      } else if (action.restore) {\n        this.restoreAction = action;\n      }\n    });\n  }\n}\n","<!-- Drag -->\n<ng-container *ngIf=\"leftDragDropEnabled\">\n  <ng-container *ngTemplateOutlet=\"dragCell\"></ng-container>\n</ng-container>\n\n<!-- Selection -->\n<ng-container *ngIf=\"selection && !(selection.disabled$ | async)\">\n  <td class=\"fs-list-col fs-list-col-selection\">\n    <ng-container *ngIf=\"!row.isGroupFooter\">\n      <mat-checkbox \n        (change)=\"selectRow($event)\"\n        [checked]=\"selected\"\n        [indeterminate]=\"indeterminateSelected\">\n      </mat-checkbox>\n    </ng-container>\n  </td>\n</ng-container>\n\n<!-- Content -->\n<ng-container *ngFor=\"let column of columns; trackBy: trackByFn; let isFirst = first\">\n  <td fs-cell\n      *ngIf=\"(isGroupRow && !column.groupHeaderColspanned)\n        || (isGroupFooterRow && !column.groupFooterColspanned)\n        || (!isGroupRow && !isGroupFooterRow && !column.cellColspanned)\"\n      [column]=\"column\"\n      [row]=\"row\"\n      [rowIndex]=\"rowIndex\"\n      [class]=\"(isGroupRow && column.groupHeaderConfigs.classesString)\n        || (isGroupFooterRow && column.groupFooterConfigs.classesString)\n        || (!isGroupFooterRow && column.cellConfigs.classesString)\"\n      [ngClass]=\"{ 'primary-col': isFirst }\"\n      [attr.colspan]=\"(isGroupRow && column.groupHeaderConfigs.colspan)\n        || (isGroupFooterRow && column.groupFooterConfigs.colspan)\n        || column.cellConfigs.colspan\"\n      [attr.width]=\"column.width\"\n  >\n  </td>\n</ng-container>\n\n<!-- Drag -->\n<ng-container *ngIf=\"rightDragDropEnabled\">\n  <ng-container *ngTemplateOutlet=\"dragCell\"></ng-container>\n</ng-container>\n\n<!-- Row Actions -->\n<td *ngIf=\"hasRowActions && !(reorderEnabled && reorderStrategy === ReorderStrategy.Manual)\" class=\"fs-list-col row-actions\">\n  <ng-container *ngIf=\"!isGroupFooterRow\">\n    <fs-list-row-actions\n      [row]=\"row\"\n      [index]=\"rowIndex\"\n      [rowActions]=\"rowActions\"\n      [menuRowActions]=\"menuRowActions\"\n      [inlineRowActions]=\"inlineRowActions\"\n      [restoreAction]=\"restoreAction\"\n      [restoreMode]=\"restoreMode\"\n      [rowRemoved]=\"rowRemoved\">\n    </fs-list-row-actions>\n  </ng-container>\n</td>\n\n<ng-template #dragCell>\n  <ng-container *ngIf=\"dragCellVisible && !isGroupFooterRow; else emptyCell\">\n    <td \n        class=\"fs-list-col drag-col\"\n        [class.drag-disabled]=\"isDragDisabled\"\n        (mousedown)=\"dragStart($event)\"\n        (touchstart)=\"dragStart($event)\">\n      <mat-icon>drag_handle</mat-icon>\n    </td>\n  </ng-container>\n  <ng-template #emptyCell>\n    <td class=\"fs-list-col drag-col\"></td>\n  </ng-template>\n</ng-template>\n"]}

package/esm2020/app/components/customize-cols/customize-cols.component.mjs

@@ -0,0 +1,68 @@
+import { ChangeDetectionStrategy, Component, Inject } from '@angular/core';
+import { MAT_DIALOG_DATA, MatDialogRef } from '@angular/material/dialog';
+import { Observable, Subject } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/dialog";
+import * as i2 from "@angular/material/checkbox";
+import * as i3 from "@angular/material/icon";
+import * as i4 from "@angular/material/button";
+import * as i5 from "@angular/common";
+import * as i6 from "@angular/material/tooltip";
+export class CustomizeColsDialogComponent {
+    constructor(data, _dialog) {
+        this._dialog = _dialog;
+        this.columns = [];
+        this.saveDisabled = false;
+        this._destroy$ = new Subject();
+        this.columns = data.columns;
+        this._changeFn = data.changeFn;
+    }
+    ngOnDestroy() {
+        this._destroy$.next();
+        this._destroy$.complete();
+    }
+    visibilityChange(event, column) {
+        column.show = event.checked;
+    }
+    save() {
+        const data = this.columns
+            .filter((column) => !!column.name)
+            .map((column) => {
+            return {
+                name: column.name,
+                show: column.show,
+            };
+        });
+        this.saveDisabled = true;
+        const changed = this._changeFn(data);
+        if (changed instanceof Observable) {
+            changed
+                .pipe(takeUntil(this._destroy$))
+                .subscribe({
+                next: () => {
+                    this._dialog.close(this.columns);
+                },
+                error: () => {
+                    this.saveDisabled = false;
+                },
+            });
+        }
+        else {
+            this._dialog.close(this.columns);
+        }
+    }
+    cancel() {
+        this._dialog.close();
+    }
+}
+CustomizeColsDialogComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: CustomizeColsDialogComponent, deps: [{ token: MAT_DIALOG_DATA }, { token: i1.MatDialogRef }], target: i0.ɵɵFactoryTarget.Component });
+CustomizeColsDialogComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.4.0", type: CustomizeColsDialogComponent, selector: "ng-component", ngImport: i0, template: "<h1 matDialogTitle>Customize Columns</h1>\r\n<mat-dialog-content>\r\n  <div *ngFor=\"let column of columns\">\r\n    <mat-checkbox [checked]=\"column.show\" (change)=\"visibilityChange($event, column)\" [disabled]=\"column.disabled\">\r\n      <ng-container *ngIf=\"!column.title; else titleLable\">\r\n        <ng-template [ngTemplateOutlet]=\"column.template\"></ng-template>\r\n      </ng-container>\r\n      <ng-template #titleLable>\r\n        {{ column.title }}\r\n      </ng-template>\r\n\r\n      <ng-container *ngIf=\"column.tooltip\">\r\n        <mat-icon [matTooltip]=\"column.tooltip\">\r\n          help\r\n        </mat-icon>\r\n      </ng-container>\r\n    </mat-checkbox>\r\n  </div>\r\n</mat-dialog-content>\r\n<mat-dialog-actions>\r\n  <button type=\"button\" mat-button color=\"primary\" (click)=\"save()\" [disabled]=\"saveDisabled\">Save</button>\r\n  <button type=\"button\" mat-button (click)=\"cancel()\">Cancel</button>\r\n</mat-dialog-actions>\r\n", styles: [".mat-checkbox{min-height:32px;display:block}.mat-icon{font-size:14px;height:14px;width:14px;vertical-align:middle}\n"], components: [{ type: i2.MatCheckbox, selector: "mat-checkbox", inputs: ["disableRipple", "color", "tabIndex", "aria-label", "aria-labelledby", "aria-describedby", "id", "required", "labelPosition", "name", "value", "checked", "disabled", "indeterminate"], outputs: ["change", "indeterminateChange"], exportAs: ["matCheckbox"] }, { type: i3.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { type: i4.MatButton, selector: "button[mat-button], button[mat-raised-button], button[mat-icon-button],             button[mat-fab], button[mat-mini-fab], button[mat-stroked-button],             button[mat-flat-button]", inputs: ["disabled", "disableRipple", "color"], exportAs: ["matButton"] }], directives: [{ type: i1.MatDialogTitle, selector: "[mat-dialog-title], [matDialogTitle]", inputs: ["id"], exportAs: ["matDialogTitle"] }, { type: i1.MatDialogContent, selector: "[mat-dialog-content], mat-dialog-content, [matDialogContent]" }, { type: i5.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i5.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i5.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet"] }, { type: i6.MatTooltip, selector: "[matTooltip]", exportAs: ["matTooltip"] }, { type: i1.MatDialogActions, selector: "[mat-dialog-actions], mat-dialog-actions, [matDialogActions]" }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: CustomizeColsDialogComponent, decorators: [{
+            type: Component,
+            args: [{ changeDetection: ChangeDetectionStrategy.OnPush, template: "<h1 matDialogTitle>Customize Columns</h1>\r\n<mat-dialog-content>\r\n  <div *ngFor=\"let column of columns\">\r\n    <mat-checkbox [checked]=\"column.show\" (change)=\"visibilityChange($event, column)\" [disabled]=\"column.disabled\">\r\n      <ng-container *ngIf=\"!column.title; else titleLable\">\r\n        <ng-template [ngTemplateOutlet]=\"column.template\"></ng-template>\r\n      </ng-container>\r\n      <ng-template #titleLable>\r\n        {{ column.title }}\r\n      </ng-template>\r\n\r\n      <ng-container *ngIf=\"column.tooltip\">\r\n        <mat-icon [matTooltip]=\"column.tooltip\">\r\n          help\r\n        </mat-icon>\r\n      </ng-container>\r\n    </mat-checkbox>\r\n  </div>\r\n</mat-dialog-content>\r\n<mat-dialog-actions>\r\n  <button type=\"button\" mat-button color=\"primary\" (click)=\"save()\" [disabled]=\"saveDisabled\">Save</button>\r\n  <button type=\"button\" mat-button (click)=\"cancel()\">Cancel</button>\r\n</mat-dialog-actions>\r\n", styles: [".mat-checkbox{min-height:32px;display:block}.mat-icon{font-size:14px;height:14px;width:14px;vertical-align:middle}\n"] }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [MAT_DIALOG_DATA]
+                }] }, { type: i1.MatDialogRef }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/app/components/footer/footer-row/footer-cell/footer-cell.component.mjs

@@ -0,0 +1,16 @@
+import { ChangeDetectionStrategy, Component } from '@angular/core';
+import { FsCellComponent } from '../../../body/row/cell/cell.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+export class FsFooterCellComponent extends FsCellComponent {
+    constructor() {
+        super();
+    }
+}
+FsFooterCellComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: FsFooterCellComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+FsFooterCellComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.4.0", type: FsFooterCellComponent, selector: "[fs-list-footer-cell]", usesInheritance: true, ngImport: i0, template: "<ng-template [ngTemplateOutlet]=\"column.footerTemplate || cell\" [ngTemplateOutletContext]=\"cellContext\"></ng-template>\r\n\r\n<ng-template #cell let-value=\"value\">\r\n  {{value}}\r\n</ng-template>\r\n", directives: [{ type: i1.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: FsFooterCellComponent, decorators: [{
+            type: Component,
+            args: [{ selector: '[fs-list-footer-cell]', changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-template [ngTemplateOutlet]=\"column.footerTemplate || cell\" [ngTemplateOutletContext]=\"cellContext\"></ng-template>\r\n\r\n<ng-template #cell let-value=\"value\">\r\n  {{value}}\r\n</ng-template>\r\n" }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZm9vdGVyLWNlbGwuY29tcG9uZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vc3JjL2FwcC9jb21wb25lbnRzL2Zvb3Rlci9mb290ZXItcm93L2Zvb3Rlci1jZWxsL2Zvb3Rlci1jZWxsLmNvbXBvbmVudC50cyIsIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3NyYy9hcHAvY29tcG9uZW50cy9mb290ZXIvZm9vdGVyLXJvdy9mb290ZXItY2VsbC9mb290ZXItY2VsbC5jb21wb25lbnQuaHRtbCJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsdUJBQXVCLEVBQUUsU0FBUyxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRW5FLE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSx1Q0FBdUMsQ0FBQzs7O0FBUXhFLE1BQU0sT0FBTyxxQkFBc0IsU0FBUSxlQUFlO0lBRXhEO1FBQ0UsS0FBSyxFQUFFLENBQUM7SUFDVixDQUFDOztrSEFKVSxxQkFBcUI7c0dBQXJCLHFCQUFxQixvRkNWbEMsZ05BS0E7MkZES2EscUJBQXFCO2tCQUxqQyxTQUFTOytCQUNFLHVCQUF1QixtQkFFaEIsdUJBQXVCLENBQUMsTUFBTSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENoYW5nZURldGVjdGlvblN0cmF0ZWd5LCBDb21wb25lbnQgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcclxuXHJcbmltcG9ydCB7IEZzQ2VsbENvbXBvbmVudCB9IGZyb20gJy4uLy4uLy4uL2JvZHkvcm93L2NlbGwvY2VsbC5jb21wb25lbnQnO1xyXG5cclxuXHJcbkBDb21wb25lbnQoe1xyXG4gIHNlbGVjdG9yOiAnW2ZzLWxpc3QtZm9vdGVyLWNlbGxdJyxcclxuICB0ZW1wbGF0ZVVybDogJy4vZm9vdGVyLWNlbGwuY29tcG9uZW50Lmh0bWwnLFxyXG4gIGNoYW5nZURldGVjdGlvbjogQ2hhbmdlRGV0ZWN0aW9uU3RyYXRlZ3kuT25QdXNoLFxyXG59KVxyXG5leHBvcnQgY2xhc3MgRnNGb290ZXJDZWxsQ29tcG9uZW50IGV4dGVuZHMgRnNDZWxsQ29tcG9uZW50IHtcclxuXHJcbiAgY29uc3RydWN0b3IoKSB7XHJcbiAgICBzdXBlcigpO1xyXG4gIH1cclxufVxyXG4iLCI8bmctdGVtcGxhdGUgW25nVGVtcGxhdGVPdXRsZXRdPVwiY29sdW1uLmZvb3RlclRlbXBsYXRlIHx8IGNlbGxcIiBbbmdUZW1wbGF0ZU91dGxldENvbnRleHRdPVwiY2VsbENvbnRleHRcIj48L25nLXRlbXBsYXRlPlxyXG5cclxuPG5nLXRlbXBsYXRlICNjZWxsIGxldC12YWx1ZT1cInZhbHVlXCI+XHJcbiAge3t2YWx1ZX19XHJcbjwvbmctdGVtcGxhdGU+XHJcbiJdfQ==

package/esm2020/app/components/footer/footer-row/footer-row.component.mjs

@@ -0,0 +1,28 @@
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, ElementRef, Input, KeyValueDiffers, Renderer2, } from '@angular/core';
+import { ReorderPosition, ReorderStrategy } from '../../../classes/reorder-controller';
+import { FsRowComponent } from '../../body/row/row.component';
+import * as i0 from "@angular/core";
+import * as i1 from "./footer-cell/footer-cell.component";
+import * as i2 from "@angular/common";
+export class FsFooterRowComponent extends FsRowComponent {
+    constructor(el, cdRef, differs, renderer) {
+        super(el, cdRef, differs, renderer, null);
+    }
+}
+FsFooterRowComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: FsFooterRowComponent, deps: [{ token: i0.ElementRef }, { token: i0.ChangeDetectorRef }, { token: i0.KeyValueDiffers }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Component });
+FsFooterRowComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.4.0", type: FsFooterRowComponent, selector: "[fs-list-footer-row]", inputs: { hasRowActions: "hasRowActions", activeFiltersCount: "activeFiltersCount", reorderEnabled: "reorderEnabled", reorderPosition: "reorderPosition", reorderStrategy: "reorderStrategy" }, usesInheritance: true, ngImport: i0, template: "<td *ngIf=\"leftDragDropEnabled\" class=\"fs-list-col drag-col\"></td>\n\n<td *ngIf=\"selection\" class=\"fs-list-col fs-list-col-selection\"></td>\n<ng-container *ngFor=\"let column of columns; trackBy: trackByFn\">\n  <td \n    *ngIf=\"!column.footerColspanned\"\n    fs-list-footer-cell\n    [column]=\"column\"\n    [row]=\"row\"\n    [rowIndex]=\"rowIndex\"\n    [ngClass]=\"column.footerConfigs.classesArray\"\n    [attr.colspan]=\"column.footerConfigs.colspan\"\n    [attr.width]=\"column.width\">\n  </td>\n</ng-container>\n\n<!-- Drag -->\n<td *ngIf=\"rightDragDropEnabled\" class=\"fs-list-col row-actions\"></td>\n\n<!-- Row Actions -->\n<td *ngIf=\"hasRowActions && !(reorderEnabled && reorderStrategy === ReorderStrategy.Manual)\" class=\"fs-list-col drag-col\"></td>\n", styles: ["td.left{text-align:left}td.center{text-align:center}td.right{text-align:right}\n"], components: [{ type: i1.FsFooterCellComponent, selector: "[fs-list-footer-cell]" }], directives: [{ type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i2.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: FsFooterRowComponent, decorators: [{
+            type: Component,
+            args: [{ selector: '[fs-list-footer-row]', changeDetection: ChangeDetectionStrategy.OnPush, template: "<td *ngIf=\"leftDragDropEnabled\" class=\"fs-list-col drag-col\"></td>\n\n<td *ngIf=\"selection\" class=\"fs-list-col fs-list-col-selection\"></td>\n<ng-container *ngFor=\"let column of columns; trackBy: trackByFn\">\n  <td \n    *ngIf=\"!column.footerColspanned\"\n    fs-list-footer-cell\n    [column]=\"column\"\n    [row]=\"row\"\n    [rowIndex]=\"rowIndex\"\n    [ngClass]=\"column.footerConfigs.classesArray\"\n    [attr.colspan]=\"column.footerConfigs.colspan\"\n    [attr.width]=\"column.width\">\n  </td>\n</ng-container>\n\n<!-- Drag -->\n<td *ngIf=\"rightDragDropEnabled\" class=\"fs-list-col row-actions\"></td>\n\n<!-- Row Actions -->\n<td *ngIf=\"hasRowActions && !(reorderEnabled && reorderStrategy === ReorderStrategy.Manual)\" class=\"fs-list-col drag-col\"></td>\n", styles: ["td.left{text-align:left}td.center{text-align:center}td.right{text-align:right}\n"] }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.ChangeDetectorRef }, { type: i0.KeyValueDiffers }, { type: i0.Renderer2 }]; }, propDecorators: { hasRowActions: [{
+                type: Input
+            }], activeFiltersCount: [{
+                type: Input
+            }], reorderEnabled: [{
+                type: Input
+            }], reorderPosition: [{
+                type: Input
+            }], reorderStrategy: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/app/components/footer/footer.component.mjs

@@ -0,0 +1,31 @@
+import { ChangeDetectionStrategy, Component, Input, } from '@angular/core';
+import { ReorderPosition, ReorderStrategy } from '../../classes/reorder-controller';
+import { SelectionController } from '../../classes/selection-controller';
+import * as i0 from "@angular/core";
+import * as i1 from "./footer-row/footer-row.component";
+export class FsFooterComponent {
+    constructor() {
+        this.columns = [];
+    }
+}
+FsFooterComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: FsFooterComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+FsFooterComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.4.0", type: FsFooterComponent, selector: "[fs-list-footer]", inputs: { hasRowActions: "hasRowActions", columns: "columns", selection: "selection", activeFiltersCount: "activeFiltersCount", reorderEnabled: "reorderEnabled", reorderPosition: "reorderPosition", reorderStrategy: "reorderStrategy" }, ngImport: i0, template: "<tr \n    fs-list-footer-row\n    [columns]=\"columns\"\n    [hasRowActions]=\"hasRowActions\"\n    [selection]=\"selection\"\n    [activeFiltersCount]=\"activeFiltersCount\"\n    [reorderEnabled]=\"reorderEnabled\"\n    [reorderPosition]=\"reorderPosition\"\n    [reorderStrategy]=\"reorderStrategy\">\n</tr>\n", styles: [""], components: [{ type: i1.FsFooterRowComponent, selector: "[fs-list-footer-row]", inputs: ["hasRowActions", "activeFiltersCount", "reorderEnabled", "reorderPosition", "reorderStrategy"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: FsFooterComponent, decorators: [{
+            type: Component,
+            args: [{ selector: '[fs-list-footer]', changeDetection: ChangeDetectionStrategy.OnPush, template: "<tr \n    fs-list-footer-row\n    [columns]=\"columns\"\n    [hasRowActions]=\"hasRowActions\"\n    [selection]=\"selection\"\n    [activeFiltersCount]=\"activeFiltersCount\"\n    [reorderEnabled]=\"reorderEnabled\"\n    [reorderPosition]=\"reorderPosition\"\n    [reorderStrategy]=\"reorderStrategy\">\n</tr>\n", styles: [""] }]
+        }], propDecorators: { hasRowActions: [{
+                type: Input
+            }], columns: [{
+                type: Input
+            }], selection: [{
+                type: Input
+            }], activeFiltersCount: [{
+                type: Input
+            }], reorderEnabled: [{
+                type: Input
+            }], reorderPosition: [{
+                type: Input
+            }], reorderStrategy: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/app/components/head/head-cell/head-cell.component.mjs

@@ -0,0 +1,29 @@
+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: "13.4.0", ngImport: i0, type: FsHeadCellComponent, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.KeyValueDiffers }], target: i0.ɵɵFactoryTarget.Component });
+FsHeadCellComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.4.0", 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: "13.4.0", ngImport: i0, type: FsHeadCellComponent, decorators: [{
+            type: Component,
+            args: [{ selector: '[fs-head-cell]', changeDetection: ChangeDetectionStrategy.OnPush, 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"] }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.KeyValueDiffers }]; } });
+//# sourceMappingURL=data:application/json;base64,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