@firestitch/list 15.0.0 → 16.0.0

package/esm2022/app/classes/sorting-controller.mjs

@@ -0,0 +1,207 @@
+import { BehaviorSubject, Subject } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+import { ColumnAttributes } from '../models/column-attributes';
+import { Column, SortingDirection } from '../models/column.model';
+export class SortingController {
+    config;
+    sortingColumns = [];
+    fakeSortingColumns = [];
+    sortingColumn;
+    _initialized = new BehaviorSubject(false);
+    _sortingChanged$ = new Subject();
+    _onDestroy = new Subject();
+    constructor() { }
+    get sortingChanged$() {
+        return this._sortingChanged$.pipe(takeUntil(this._onDestroy));
+    }
+    get initialized$() {
+        return this._initialized.pipe(takeUntil(this._onDestroy));
+    }
+    get value() {
+        if (this.sortingColumn) {
+            return {
+                value: this.sortingColumn.name,
+                direction: this.sortingColumn.direction,
+            };
+        }
+        return undefined;
+    }
+    get initialization() {
+        return !this._initialized.getValue();
+    }
+    get isDefined() {
+        return !!this.sortingColumn;
+    }
+    set _initialization(value) {
+        this._initialized.next(!value);
+    }
+    addSortableColumn(column) {
+        this.sortingColumns.push(column);
+    }
+    clearSortableColumns() {
+        this.sortingColumns = [];
+    }
+    /**
+     * Set Sortable Direction
+     *
+     * @param direction
+     */
+    sortDirection(direction) {
+        if (this.sortingColumn && this.sortingColumn.sortingDirection !== direction) {
+            this._setSortingDirection(direction);
+            this._notifySortChanged();
+        }
+    }
+    /**
+     * Sort By
+     *
+     * @param column
+     */
+    sortBy(column) {
+        if (column.sortable) {
+            this._setSortingColumn(column);
+            this._notifySortChanged();
+        }
+    }
+    /**
+     * Same as sortBy, but need only column name as parameter for sort
+     *
+     * @param name
+     */
+    sortByColumnWithName(name) {
+        const column = this.getColumn(name);
+        if (!column) {
+            return;
+        }
+        this._setSortingColumn(column);
+        this._notifySortChanged();
+    }
+    /**
+     * Init fake columns for sorting
+     *
+     * @param columns
+     */
+    initFakeColumns(columns) {
+        columns.forEach((column) => {
+            const attributes = new ColumnAttributes({
+                title: column.name,
+                name: column.value,
+                sortable: true,
+                direction: column.direction,
+            });
+            const fakeColumn = new Column({
+                attributes,
+            });
+            this.fakeSortingColumns.push(fakeColumn);
+        });
+    }
+    /**
+     * Set initial sorting
+     *
+     * @param sort
+     */
+    initialSortBy(sort) {
+        this._initialization = true;
+        if (!sort) {
+            this._trySortByDefaultSortableColumn();
+            if (!this.sortingColumn) {
+                this.sortByFirstSortbale();
+            }
+            this._initialization = false;
+            return;
+        }
+        if (!this.getColumn(sort.value)) {
+            this.sortByFirstSortbale();
+            console.warn(`
+        Not possible to do initial sort by "${sort.value}" column.
+        Column with name "${sort.value}" does not exists.
+        Check your lister configuration.
+      `);
+        }
+        else {
+            this.sortByColumnWithName(sort.value);
+            const direction = (sort.direction === undefined || sort.direction === 'asc')
+                ? SortingDirection.asc
+                : SortingDirection.desc;
+            this._setSortingDirection(direction);
+        }
+        this._initialization = false;
+    }
+    /**
+     * Sort by first of available sorting columns
+     */
+    sortByFirstSortbale() {
+        const column = this.sortingColumns.find((col) => col.sortable);
+        if (!column) {
+            return;
+        }
+        this.sortBy(column);
+        this.sortDirection(column.direction || SortingDirection.asc);
+    }
+    /**
+     * Merge sorting and fake sorting cols
+     * Fake sorting cols it's cols which don't represented in table cols, like abstract cols
+     */
+    makeSortingList() {
+        return [
+            ...this.sortingColumns,
+            ...this.fakeSortingColumns,
+        ].reduce((acc, column) => {
+            const sortingItem = {
+                name: column.title,
+                value: column.name,
+                default: this.sortingColumn && this.sortingColumn.name === column.name,
+            };
+            acc.push(sortingItem);
+            return acc;
+        }, []);
+    }
+    getColumn(name) {
+        return [...this.sortingColumns, ...this.fakeSortingColumns]
+            .find((col) => col.name === name && col.sortable);
+    }
+    /**
+     * Destroy
+     */
+    destroy() {
+        this._onDestroy.next();
+        this._onDestroy.complete();
+    }
+    _setSortingColumn(column) {
+        // Can't do sort by non sortable column
+        if (!column.sortable) {
+            return false;
+        }
+        // Column was ordered before
+        if (column.ordered) {
+            column.changeDirection();
+        }
+        else {
+            [...this.fakeSortingColumns, ...this.sortingColumns]
+                .filter((col) => col.ordered)
+                .forEach((col) => col.ordered = false);
+            column.ordered = true;
+        }
+        this.sortingColumn = column;
+    }
+    _setSortingDirection(direction) {
+        this.sortingColumn.sortingDirection = direction;
+    }
+    _notifySortChanged() {
+        if (this.initialization) {
+            return;
+        }
+        this._sortingChanged$.next({
+            sortBy: this.sortingColumn.name,
+            sortDirection: this.sortingColumn.direction,
+        });
+    }
+    _trySortByDefaultSortableColumn() {
+        const sortableDefault = this.sortingColumns
+            .find((column) => column.sortableDefault);
+        if (sortableDefault) {
+            this.sortByColumnWithName(sortableDefault.name);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sorting-controller.js","sourceRoot":"","sources":["../../../../src/app/classes/sorting-controller.ts"],"names":[],"mappings":"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","sourcesContent":["import { BehaviorSubject, Observable, Subject } from 'rxjs';\nimport { takeUntil } from 'rxjs/operators';\n\nimport { FsListSortConfig, SortingChangeEvent } from '../interfaces';\nimport { ColumnAttributes } from '../models/column-attributes';\nimport { Column, SortingDirection } from '../models/column.model';\n\nimport { List } from './list-controller';\n\n\nexport class SortingController {\n  public config: List;\n\n  public sortingColumns: Column[] = [];\n  public fakeSortingColumns: Column[] = [];\n  public sortingColumn: Column;\n\n  private _initialized = new BehaviorSubject<boolean>(false);\n  private _sortingChanged$ = new Subject<SortingChangeEvent>();\n  private _onDestroy = new Subject();\n\n  constructor() {}\n\n  public get sortingChanged$(): Observable<SortingChangeEvent> {\n    return this._sortingChanged$.pipe(takeUntil(this._onDestroy));\n  }\n\n  public get initialized$(): Observable<boolean> {\n    return this._initialized.pipe(takeUntil(this._onDestroy));\n  }\n\n  public get value(): FsListSortConfig | undefined {\n    if (this.sortingColumn) {\n      return {\n        value: this.sortingColumn.name,\n        direction: this.sortingColumn.direction,\n      };\n    }\n\n    return undefined;\n  }\n\n  public get initialization(): boolean {\n    return !this._initialized.getValue();\n  }\n\n  public get isDefined(): boolean {\n    return !!this.sortingColumn;\n  }\n\n  private set _initialization(value: boolean) {\n    this._initialized.next(!value);\n  }\n\n  public addSortableColumn(column: Column) {\n    this.sortingColumns.push(column);\n  }\n\n  public clearSortableColumns(): void {\n    this.sortingColumns = [];\n  }\n\n  /**\n   * Set Sortable Direction\n   *\n   * @param direction\n   */\n  public sortDirection(direction) {\n    if (this.sortingColumn && this.sortingColumn.sortingDirection !== direction) {\n      this._setSortingDirection(direction);\n\n      this._notifySortChanged();\n    }\n  }\n\n  /**\n   * Sort By\n   *\n   * @param column\n   */\n  public sortBy(column: Column) {\n    if (column.sortable) {\n      this._setSortingColumn(column);\n\n      this._notifySortChanged();\n    }\n  }\n\n  /**\n   * Same as sortBy, but need only column name as parameter for sort\n   *\n   * @param name\n   */\n  public sortByColumnWithName(name: string) {\n    const column = this.getColumn(name);\n\n    if (!column) {\n      return;\n    }\n\n    this._setSortingColumn(column);\n\n    this._notifySortChanged();\n  }\n\n  /**\n   * Init fake columns for sorting\n   *\n   * @param columns\n   */\n  public initFakeColumns(columns) {\n    columns.forEach((column) => {\n      const attributes = new ColumnAttributes({\n        title: column.name,\n        name: column.value,\n        sortable: true,\n        direction: column.direction,\n      });\n\n      const fakeColumn = new Column({\n        attributes,\n      });\n\n      this.fakeSortingColumns.push(fakeColumn);\n    });\n  }\n\n  /**\n   * Set initial sorting\n   *\n   * @param sort\n   */\n  public initialSortBy(sort: FsListSortConfig) {\n    this._initialization = true;\n\n    if (!sort) {\n      this._trySortByDefaultSortableColumn();\n\n      if (!this.sortingColumn) {\n        this.sortByFirstSortbale();\n      }\n\n      this._initialization = false;\n\n      return;\n    }\n\n    if (!this.getColumn(sort.value)) {\n      this.sortByFirstSortbale();\n\n      console.warn(`\n        Not possible to do initial sort by \"${sort.value}\" column.\n        Column with name \"${sort.value}\" does not exists.\n        Check your lister configuration.\n      `);\n    } else {\n      this.sortByColumnWithName(sort.value);\n\n      const direction = (sort.direction === undefined || sort.direction === 'asc')\n        ? SortingDirection.asc\n        : SortingDirection.desc;\n      this._setSortingDirection(direction);\n    }\n\n    this._initialization = false;\n  }\n\n  /**\n   * Sort by first of available sorting columns\n   */\n  public sortByFirstSortbale() {\n    const column =\n      this.sortingColumns.find((col) => col.sortable);\n\n    if (!column) {\n      return;\n    }\n\n    this.sortBy(column);\n    this.sortDirection(column.direction || SortingDirection.asc);\n  }\n\n  /**\n   * Merge sorting and fake sorting cols\n   * Fake sorting cols it's cols which don't represented in table cols, like abstract cols\n   */\n  public makeSortingList() {\n    return [\n      ...this.sortingColumns,\n      ...this.fakeSortingColumns,\n    ].reduce((acc, column) => {\n\n      const sortingItem = {\n        name: column.title,\n        value: column.name,\n        default: this.sortingColumn && this.sortingColumn.name === column.name,\n      };\n\n      acc.push(sortingItem);\n\n      return acc;\n    }, []);\n  }\n\n  public getColumn(name: string): Column {\n    return [...this.sortingColumns, ...this.fakeSortingColumns]\n      .find((col) => col.name === name && col.sortable);\n  }\n\n  /**\n   * Destroy\n   */\n  public destroy() {\n    this._onDestroy.next();\n    this._onDestroy.complete();\n  }\n\n  private _setSortingColumn(column: Column) {\n    // Can't do sort by non sortable column\n    if (!column.sortable) {\n      return false;\n    }\n\n    // Column was ordered before\n    if (column.ordered) {\n      column.changeDirection();\n    } else {\n      [...this.fakeSortingColumns, ...this.sortingColumns]\n        .filter((col) => col.ordered)\n        .forEach((col) => col.ordered = false);\n\n      column.ordered = true;\n    }\n\n    this.sortingColumn = column;\n  }\n\n  private _setSortingDirection(direction) {\n    this.sortingColumn.sortingDirection = direction;\n  }\n\n  private _notifySortChanged() {\n    if (this.initialization) {\n      return;\n    }\n\n    this._sortingChanged$.next({\n      sortBy: this.sortingColumn.name,\n      sortDirection: this.sortingColumn.direction,\n    });\n  }\n\n  private _trySortByDefaultSortableColumn(): void {\n    const sortableDefault = this.sortingColumns\n      .find((column) => column.sortableDefault);\n\n    if (sortableDefault) {\n      this.sortByColumnWithName(sortableDefault.name);\n    }\n  }\n}\n"]}

package/esm2022/app/components/body/body.component.mjs

@@ -0,0 +1,73 @@
+import { ChangeDetectionStrategy, Component, ContentChild, EventEmitter, Input, TemplateRef, ViewChild, ViewContainerRef, } from '@angular/core';
+import { ReorderPosition, ReorderStrategy } from '../../classes/reorder-controller';
+import { SelectionController } from '../../classes/selection-controller';
+import { FsRowComponent } from './row/row.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "./row/row.component";
+import * as i3 from "../../directives/draggable-row/draggable-row.directive";
+export class FsBodyComponent {
+    rows;
+    columns = [];
+    hasFooter = false;
+    rowActionsRaw = [];
+    groupActionsRaw = [];
+    rowEvents = {};
+    rowClass;
+    hasRowActions = false;
+    selection;
+    restoreMode = false;
+    rowRemoved;
+    activeFiltersCount;
+    reorderEnabled;
+    reorderPosition;
+    reorderStrategy;
+    reorderMultiple;
+    rowsContainer;
+    headerTemplate;
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: FsBodyComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: FsBodyComponent, selector: "[fs-list-body]", inputs: { rows: "rows", columns: "columns", hasFooter: "hasFooter", rowActionsRaw: "rowActionsRaw", groupActionsRaw: "groupActionsRaw", rowEvents: "rowEvents", rowClass: "rowClass", hasRowActions: "hasRowActions", selection: "selection", restoreMode: "restoreMode", rowRemoved: "rowRemoved", activeFiltersCount: "activeFiltersCount", reorderEnabled: "reorderEnabled", reorderPosition: "reorderPosition", reorderStrategy: "reorderStrategy", reorderMultiple: "reorderMultiple" }, queries: [{ propertyName: "headerTemplate", first: true, predicate: FsRowComponent, descendants: true, read: TemplateRef, static: true }], viewQueries: [{ propertyName: "rowsContainer", first: true, predicate: ["rowsContainer"], descendants: true, read: ViewContainerRef, static: true }], ngImport: i0, template: "<ng-container *ngFor=\"let row of rows; let i = index;\">\n  <tr\n    fs-list-row\n    fsListDraggableRow\n    [row]=\"row\"\n    [rowIndex]=\"i\"\n    [columns]=\"columns\"\n    [rowActionsRaw]=\"rowActionsRaw\"\n    [groupActionsRaw]=\"groupActionsRaw\"\n    [hasRowActions]=\"hasRowActions\"\n    [rowEvents]=\"rowEvents\"\n    [rowClass]=\"rowClass\"\n    [selection]=\"selection\"\n    [restoreMode]=\"restoreMode\"\n    [rowRemoved]=\"rowRemoved\"\n    [activeFiltersCount]=\"activeFiltersCount\"\n    [reorderEnabled]=\"reorderEnabled\"\n    [reorderPosition]=\"reorderPosition\"\n    [reorderStrategy]=\"reorderStrategy\"\n    [reorderMultiple]=\"reorderMultiple\">\n  </tr>\n</ng-container>\n", styles: [":host.drag-hidden .drag-col{opacity:0!important;cursor:default}:host.disabled{opacity:.4;pointer-events:none}\n"], dependencies: [{ kind: "directive", type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "component", type: i2.FsRowComponent, selector: "[fs-list-row]", inputs: ["row", "rowActionsRaw", "groupActionsRaw", "hasRowActions", "rowEvents", "rowClass", "restoreMode", "rowIndex", "columns", "selection", "rowRemoved", "activeFiltersCount", "reorderEnabled", "reorderPosition", "reorderStrategy", "reorderMultiple"] }, { kind: "directive", type: i3.FsListDraggableRowDirective, selector: "[fsListDraggableRow]", inputs: ["row"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: FsBodyComponent, decorators: [{
+            type: Component,
+            args: [{ selector: '[fs-list-body]', changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-container *ngFor=\"let row of rows; let i = index;\">\n  <tr\n    fs-list-row\n    fsListDraggableRow\n    [row]=\"row\"\n    [rowIndex]=\"i\"\n    [columns]=\"columns\"\n    [rowActionsRaw]=\"rowActionsRaw\"\n    [groupActionsRaw]=\"groupActionsRaw\"\n    [hasRowActions]=\"hasRowActions\"\n    [rowEvents]=\"rowEvents\"\n    [rowClass]=\"rowClass\"\n    [selection]=\"selection\"\n    [restoreMode]=\"restoreMode\"\n    [rowRemoved]=\"rowRemoved\"\n    [activeFiltersCount]=\"activeFiltersCount\"\n    [reorderEnabled]=\"reorderEnabled\"\n    [reorderPosition]=\"reorderPosition\"\n    [reorderStrategy]=\"reorderStrategy\"\n    [reorderMultiple]=\"reorderMultiple\">\n  </tr>\n</ng-container>\n", styles: [":host.drag-hidden .drag-col{opacity:0!important;cursor:default}:host.disabled{opacity:.4;pointer-events:none}\n"] }]
+        }], propDecorators: { rows: [{
+                type: Input
+            }], columns: [{
+                type: Input
+            }], hasFooter: [{
+                type: Input
+            }], rowActionsRaw: [{
+                type: Input
+            }], groupActionsRaw: [{
+                type: Input
+            }], rowEvents: [{
+                type: Input
+            }], rowClass: [{
+                type: Input
+            }], hasRowActions: [{
+                type: Input
+            }], selection: [{
+                type: Input
+            }], restoreMode: [{
+                type: Input
+            }], rowRemoved: [{
+                type: Input
+            }], activeFiltersCount: [{
+                type: Input
+            }], reorderEnabled: [{
+                type: Input
+            }], reorderPosition: [{
+                type: Input
+            }], reorderStrategy: [{
+                type: Input
+            }], reorderMultiple: [{
+                type: Input
+            }], rowsContainer: [{
+                type: ViewChild,
+                args: ['rowsContainer', { read: ViewContainerRef, static: true }]
+            }], headerTemplate: [{
+                type: ContentChild,
+                args: [FsRowComponent, { read: TemplateRef, static: true }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/app/components/body/row/actions/actions.component.mjs

@@ -0,0 +1,102 @@
+import { ChangeDetectionStrategy, Component, EventEmitter, Input, } from '@angular/core';
+import { FsPrompt } from '@firestitch/prompt';
+import { Observable, Subject } from 'rxjs';
+import { take, takeUntil } from 'rxjs/operators';
+import { Row } from '../../../../models/row';
+import { RowAction } from '../../../../models/row-action.model';
+import * as i0 from "@angular/core";
+import * as i1 from "@firestitch/prompt";
+import * as i2 from "@angular/common";
+import * as i3 from "@angular/material/icon";
+import * as i4 from "@firestitch/menu";
+import * as i5 from "../inline-action/inline-action.component";
+import * as i6 from "../menu-action/menu-action.component";
+import * as i7 from "../../../../pipes/action-label";
+export class FsRowActionsComponent {
+    _prompt;
+    row;
+    index;
+    restoreMode = false;
+    rowActions = [];
+    rowRemoved;
+    menuRowActions = [];
+    inlineRowActions = [];
+    restoreAction;
+    _destroy$ = new Subject();
+    constructor(_prompt) {
+        this._prompt = _prompt;
+    }
+    actionClick(action, row, event, menuRef) {
+        if (action.remove) {
+            if (typeof action.remove === 'boolean') {
+                this._removeAction(action, row.data, event, this.index);
+            }
+            else {
+                this._prompt.confirm({
+                    title: action.remove.title,
+                    template: action.remove.template,
+                    autofocus: true,
+                })
+                    .pipe(take(1), takeUntil(this._destroy$))
+                    .subscribe(() => {
+                    this._removeAction(action, row.data, event, this.index);
+                });
+            }
+        }
+        else {
+            action.click(row.data, event, this.index, menuRef);
+        }
+    }
+    /**
+     * Track By for improve change detection
+     *
+     * @param index
+     */
+    trackByFn(index) {
+        return index;
+    }
+    /**
+     * Emit that some row must be removed
+     *
+     * @param action
+     * @param row
+     * @param event
+     * @param index
+     */
+    _removeAction(action, row, event, index) {
+        const removeObservable = action.click(row, event, index);
+        if (removeObservable && removeObservable instanceof Observable) {
+            removeObservable
+                .pipe(take(1), takeUntil(this._destroy$))
+                .subscribe(() => {
+                this.rowRemoved.emit(row);
+            });
+        }
+        else {
+            this.rowRemoved.emit(row);
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: FsRowActionsComponent, deps: [{ token: i1.FsPrompt }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: FsRowActionsComponent, selector: "fs-list-row-actions", inputs: { row: "row", index: "index", restoreMode: "restoreMode", rowActions: "rowActions", rowRemoved: "rowRemoved", menuRowActions: "menuRowActions", inlineRowActions: "inlineRowActions", restoreAction: "restoreAction" }, ngImport: i0, template: "<ng-container *ngIf=\"!restoreMode || (restoreMode && !restoreAction)\">\n  <ng-container *ngFor=\"let action of inlineRowActions; trackBy: trackByFn\">\n    <fs-list-row-inline-action\n      class=\"row-inline-action row-inline-action-{{action.type}}\"\n      [action]=\"action\"\n      [ngClass]=\"{'mobile-hide': action.menu === undefined}\"\n      (clicked)=\"actionClick(action, row, $event)\"\n      (fileSelect)=\"action.fileConfig.select($event, row, index)\">\n    </fs-list-row-inline-action>\n  </ng-container>\n</ng-container>\n\n<!-- Menu -->\n<fs-menu\n    class=\"row-menu-action\"\n    *ngIf=\"menuRowActions.length || (restoreMode && restoreAction)\"\n    #menuRef>\n  <!-- Case when we have usual menu actions -->\n  <ng-container *ngIf=\"!restoreMode || (restoreMode && !restoreAction)\">\n    <ng-container *ngFor=\"let action of inlineRowActions; trackBy: trackByFn\">\n      <ng-template\n          class=\"hidden-mobile-menu-action\"\n          fs-menu-item\n          [link]=\"action.routerLink?.link\"\n          [queryParams]=\"action.routerLink?.queryParams\"\n          [target]=\"action.routerLink?.target\"\n          [hidden]=\"action.menu !== undefined && !action.isShown\">\n        <fs-list-row-menu-action\n          [icon]=\"action.icon\"\n          [label]=\"action.label\"\n          [row]=\"row\"\n          [file]=\"action.fileConfig\"\n          (fileSelect)=\"action.fileConfig.select($event, row, index)\"\n          (fileError)=\"action.fileConfig.error && action.fileConfig.error($event)\">\n        </fs-list-row-menu-action>\n      </ng-template>\n    </ng-container>\n\n    <ng-container *ngFor=\"let action of menuRowActions; trackBy: trackByFn\">\n      <ng-container *ngIf=\"action.isGroup else simpleMenuItem\">\n        <fs-menu-group [label]=\"action.label | actionLabel:row\">\n          <ng-container *ngFor=\"let subAction of action.rowActions\">\n            <ng-template\n                fs-menu-item\n                [link]=\"subAction.routerLink?.link\"\n                [queryParams]=\"subAction.routerLink?.queryParams\"\n                [target]=\"subAction.routerLink?.target\"\n                [hidden]=\"!subAction.isShown\"\n                [class]=\"subAction.className\"\n                (click)=\"actionClick(subAction, row, $event, menuRef);\">\n              <fs-list-row-menu-action\n                [icon]=\"subAction.icon\"\n                [label]=\"subAction.label\"\n                [row]=\"row\"\n                [file]=\"subAction.fileConfig\"\n                (fileSelect)=\"subAction.fileConfig.select($event, row, index)\"\n                (fileError)=\"subAction.fileConfig.error && subAction.fileConfig.error($event)\">\n              </fs-list-row-menu-action>\n            </ng-template>\n          </ng-container>\n        </fs-menu-group>\n      </ng-container>\n      <ng-template #simpleMenuItem>\n        <ng-template\n            fs-menu-item\n            [link]=\"action.routerLink?.link\"\n            [queryParams]=\"action.routerLink?.queryParams\"\n            [target]=\"action.routerLink?.target\"\n            [hidden]=\"!action.isShown\"\n            [class]=\"action.className\"\n            (click)=\"actionClick(action, row, $event, menuRef);\">\n          <fs-list-row-menu-action\n            [icon]=\"action.icon\"\n            [label]=\"action.label\"\n            [row]=\"row\"\n            [file]=\"action.fileConfig\"\n            (fileSelect)=\"action.fileConfig.select($event, row, index)\"\n            (fileError)=\"action.fileConfig.error && action.fileConfig.error($event)\">\n          </fs-list-row-menu-action>\n        </ng-template>\n      </ng-template>\n    </ng-container>\n  </ng-container>\n\n  <!-- Case when we have restore mode enabled and must hide menu actions -->\n  <ng-container *ngIf=\"restoreMode && restoreAction\">\n    <ng-template fs-menu-item (click)=\"actionClick(restoreAction, row, $event, menuRef)\">\n      <mat-icon *ngIf=\"restoreAction.icon\">{{restoreAction.icon}}</mat-icon>\n      {{restoreAction.label | actionLabel:row}}\n    </ng-template>\n  </ng-container>\n</fs-menu>\n", styles: [":host ::ng-deep fs-list-row-inline-action{margin-left:5px}:host ::ng-deep fs-list-row-inline-action:first-child{margin-left:0}::ng-deep .hidden-mobile-menu-action{display:none!important}\n"], dependencies: [{ kind: "directive", type: i2.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i3.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "component", type: i4.FsMenuComponent, selector: "fs-menu", inputs: ["class", "buttonClass", "buttonType", "buttonColor"], outputs: ["opened", "closed"] }, { kind: "directive", type: i4.FsMenuItemDirective, selector: "fs-menu-group,[fs-menu-item]" }, { kind: "component", type: i5.FsRowInlineActionComponent, selector: "fs-list-row-inline-action", inputs: ["action"], outputs: ["clicked", "fileSelect"] }, { kind: "component", type: i6.FsRowMenuActionComponent, selector: "fs-list-row-menu-action", inputs: ["row", "icon", "label", "file"], outputs: ["fileSelect", "fileError"] }, { kind: "pipe", type: i7.ActionLabelPipe, name: "actionLabel" }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: FsRowActionsComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'fs-list-row-actions', changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-container *ngIf=\"!restoreMode || (restoreMode && !restoreAction)\">\n  <ng-container *ngFor=\"let action of inlineRowActions; trackBy: trackByFn\">\n    <fs-list-row-inline-action\n      class=\"row-inline-action row-inline-action-{{action.type}}\"\n      [action]=\"action\"\n      [ngClass]=\"{'mobile-hide': action.menu === undefined}\"\n      (clicked)=\"actionClick(action, row, $event)\"\n      (fileSelect)=\"action.fileConfig.select($event, row, index)\">\n    </fs-list-row-inline-action>\n  </ng-container>\n</ng-container>\n\n<!-- Menu -->\n<fs-menu\n    class=\"row-menu-action\"\n    *ngIf=\"menuRowActions.length || (restoreMode && restoreAction)\"\n    #menuRef>\n  <!-- Case when we have usual menu actions -->\n  <ng-container *ngIf=\"!restoreMode || (restoreMode && !restoreAction)\">\n    <ng-container *ngFor=\"let action of inlineRowActions; trackBy: trackByFn\">\n      <ng-template\n          class=\"hidden-mobile-menu-action\"\n          fs-menu-item\n          [link]=\"action.routerLink?.link\"\n          [queryParams]=\"action.routerLink?.queryParams\"\n          [target]=\"action.routerLink?.target\"\n          [hidden]=\"action.menu !== undefined && !action.isShown\">\n        <fs-list-row-menu-action\n          [icon]=\"action.icon\"\n          [label]=\"action.label\"\n          [row]=\"row\"\n          [file]=\"action.fileConfig\"\n          (fileSelect)=\"action.fileConfig.select($event, row, index)\"\n          (fileError)=\"action.fileConfig.error && action.fileConfig.error($event)\">\n        </fs-list-row-menu-action>\n      </ng-template>\n    </ng-container>\n\n    <ng-container *ngFor=\"let action of menuRowActions; trackBy: trackByFn\">\n      <ng-container *ngIf=\"action.isGroup else simpleMenuItem\">\n        <fs-menu-group [label]=\"action.label | actionLabel:row\">\n          <ng-container *ngFor=\"let subAction of action.rowActions\">\n            <ng-template\n                fs-menu-item\n                [link]=\"subAction.routerLink?.link\"\n                [queryParams]=\"subAction.routerLink?.queryParams\"\n                [target]=\"subAction.routerLink?.target\"\n                [hidden]=\"!subAction.isShown\"\n                [class]=\"subAction.className\"\n                (click)=\"actionClick(subAction, row, $event, menuRef);\">\n              <fs-list-row-menu-action\n                [icon]=\"subAction.icon\"\n                [label]=\"subAction.label\"\n                [row]=\"row\"\n                [file]=\"subAction.fileConfig\"\n                (fileSelect)=\"subAction.fileConfig.select($event, row, index)\"\n                (fileError)=\"subAction.fileConfig.error && subAction.fileConfig.error($event)\">\n              </fs-list-row-menu-action>\n            </ng-template>\n          </ng-container>\n        </fs-menu-group>\n      </ng-container>\n      <ng-template #simpleMenuItem>\n        <ng-template\n            fs-menu-item\n            [link]=\"action.routerLink?.link\"\n            [queryParams]=\"action.routerLink?.queryParams\"\n            [target]=\"action.routerLink?.target\"\n            [hidden]=\"!action.isShown\"\n            [class]=\"action.className\"\n            (click)=\"actionClick(action, row, $event, menuRef);\">\n          <fs-list-row-menu-action\n            [icon]=\"action.icon\"\n            [label]=\"action.label\"\n            [row]=\"row\"\n            [file]=\"action.fileConfig\"\n            (fileSelect)=\"action.fileConfig.select($event, row, index)\"\n            (fileError)=\"action.fileConfig.error && action.fileConfig.error($event)\">\n          </fs-list-row-menu-action>\n        </ng-template>\n      </ng-template>\n    </ng-container>\n  </ng-container>\n\n  <!-- Case when we have restore mode enabled and must hide menu actions -->\n  <ng-container *ngIf=\"restoreMode && restoreAction\">\n    <ng-template fs-menu-item (click)=\"actionClick(restoreAction, row, $event, menuRef)\">\n      <mat-icon *ngIf=\"restoreAction.icon\">{{restoreAction.icon}}</mat-icon>\n      {{restoreAction.label | actionLabel:row}}\n    </ng-template>\n  </ng-container>\n</fs-menu>\n", styles: [":host ::ng-deep fs-list-row-inline-action{margin-left:5px}:host ::ng-deep fs-list-row-inline-action:first-child{margin-left:0}::ng-deep .hidden-mobile-menu-action{display:none!important}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.FsPrompt }]; }, propDecorators: { row: [{
+                type: Input
+            }], index: [{
+                type: Input
+            }], restoreMode: [{
+                type: Input
+            }], rowActions: [{
+                type: Input
+            }], rowRemoved: [{
+                type: Input
+            }], menuRowActions: [{
+                type: Input
+            }], inlineRowActions: [{
+                type: Input
+            }], restoreAction: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"actions.component.js","sourceRoot":"","sources":["../../../../../../../src/app/components/body/row/actions/actions.component.ts","../../../../../../../src/app/components/body/row/actions/actions.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  ChangeDetectionStrategy,\n  Component,\n  EventEmitter,\n  Input,\n} from '@angular/core';\n\nimport { FsPrompt } from '@firestitch/prompt';\n\nimport { Observable, Subject } from 'rxjs';\nimport { take, takeUntil } from 'rxjs/operators';\n\n\nimport { Row } from '../../../../models/row';\nimport { RowAction } from '../../../../models/row-action.model';\n\n\n@Component({\n  selector: 'fs-list-row-actions',\n  templateUrl: './actions.component.html',\n  styleUrls: ['./actions.component.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class FsRowActionsComponent {\n\n  @Input()\n  public row: Row;\n\n  @Input()\n  public index: number;\n\n  @Input()\n  public restoreMode = false;\n\n  @Input()\n  public rowActions: RowAction[] = [];\n\n  @Input()\n  public rowRemoved: EventEmitter<any>;\n\n  @Input()\n  public menuRowActions: RowAction[] = [];\n\n  @Input()\n  public inlineRowActions: RowAction[] = [];\n\n  @Input()\n  public restoreAction: RowAction;\n\n  private _destroy$ = new Subject();\n\n  constructor(\n    private _prompt: FsPrompt,\n  ) { }\n\n  public actionClick(action: RowAction, row: any, event: any, menuRef?) {\n    if (action.remove) {\n      if (typeof action.remove === 'boolean') {\n        this._removeAction(action, row.data, event, this.index);\n      } else {\n        this._prompt.confirm({\n          title: action.remove.title,\n          template: action.remove.template,\n          autofocus: true,\n        })\n          .pipe(\n            take(1),\n            takeUntil(this._destroy$),\n          )\n          .subscribe(() => {\n            this._removeAction(action, row.data, event, this.index);\n          });\n      }\n    } else {\n      action.click(row.data, event, this.index, menuRef);\n    }\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   * Emit that some row must be removed\n   *\n   * @param action\n   * @param row\n   * @param event\n   * @param index\n   */\n  private _removeAction(action, row, event, index) {\n    const removeObservable = action.click(row, event, index);\n\n    if (removeObservable && removeObservable instanceof Observable) {\n      removeObservable\n        .pipe(\n          take(1),\n          takeUntil(this._destroy$),\n        )\n        .subscribe(() => {\n          this.rowRemoved.emit(row);\n        });\n    } else {\n      this.rowRemoved.emit(row);\n    }\n  }\n}\n","<ng-container *ngIf=\"!restoreMode || (restoreMode && !restoreAction)\">\n  <ng-container *ngFor=\"let action of inlineRowActions; trackBy: trackByFn\">\n    <fs-list-row-inline-action\n      class=\"row-inline-action row-inline-action-{{action.type}}\"\n      [action]=\"action\"\n      [ngClass]=\"{'mobile-hide': action.menu === undefined}\"\n      (clicked)=\"actionClick(action, row, $event)\"\n      (fileSelect)=\"action.fileConfig.select($event, row, index)\">\n    </fs-list-row-inline-action>\n  </ng-container>\n</ng-container>\n\n<!-- Menu -->\n<fs-menu\n    class=\"row-menu-action\"\n    *ngIf=\"menuRowActions.length || (restoreMode && restoreAction)\"\n    #menuRef>\n  <!-- Case when we have usual menu actions -->\n  <ng-container *ngIf=\"!restoreMode || (restoreMode && !restoreAction)\">\n    <ng-container *ngFor=\"let action of inlineRowActions; trackBy: trackByFn\">\n      <ng-template\n          class=\"hidden-mobile-menu-action\"\n          fs-menu-item\n          [link]=\"action.routerLink?.link\"\n          [queryParams]=\"action.routerLink?.queryParams\"\n          [target]=\"action.routerLink?.target\"\n          [hidden]=\"action.menu !== undefined && !action.isShown\">\n        <fs-list-row-menu-action\n          [icon]=\"action.icon\"\n          [label]=\"action.label\"\n          [row]=\"row\"\n          [file]=\"action.fileConfig\"\n          (fileSelect)=\"action.fileConfig.select($event, row, index)\"\n          (fileError)=\"action.fileConfig.error && action.fileConfig.error($event)\">\n        </fs-list-row-menu-action>\n      </ng-template>\n    </ng-container>\n\n    <ng-container *ngFor=\"let action of menuRowActions; trackBy: trackByFn\">\n      <ng-container *ngIf=\"action.isGroup else simpleMenuItem\">\n        <fs-menu-group [label]=\"action.label | actionLabel:row\">\n          <ng-container *ngFor=\"let subAction of action.rowActions\">\n            <ng-template\n                fs-menu-item\n                [link]=\"subAction.routerLink?.link\"\n                [queryParams]=\"subAction.routerLink?.queryParams\"\n                [target]=\"subAction.routerLink?.target\"\n                [hidden]=\"!subAction.isShown\"\n                [class]=\"subAction.className\"\n                (click)=\"actionClick(subAction, row, $event, menuRef);\">\n              <fs-list-row-menu-action\n                [icon]=\"subAction.icon\"\n                [label]=\"subAction.label\"\n                [row]=\"row\"\n                [file]=\"subAction.fileConfig\"\n                (fileSelect)=\"subAction.fileConfig.select($event, row, index)\"\n                (fileError)=\"subAction.fileConfig.error && subAction.fileConfig.error($event)\">\n              </fs-list-row-menu-action>\n            </ng-template>\n          </ng-container>\n        </fs-menu-group>\n      </ng-container>\n      <ng-template #simpleMenuItem>\n        <ng-template\n            fs-menu-item\n            [link]=\"action.routerLink?.link\"\n            [queryParams]=\"action.routerLink?.queryParams\"\n            [target]=\"action.routerLink?.target\"\n            [hidden]=\"!action.isShown\"\n            [class]=\"action.className\"\n            (click)=\"actionClick(action, row, $event, menuRef);\">\n          <fs-list-row-menu-action\n            [icon]=\"action.icon\"\n            [label]=\"action.label\"\n            [row]=\"row\"\n            [file]=\"action.fileConfig\"\n            (fileSelect)=\"action.fileConfig.select($event, row, index)\"\n            (fileError)=\"action.fileConfig.error && action.fileConfig.error($event)\">\n          </fs-list-row-menu-action>\n        </ng-template>\n      </ng-template>\n    </ng-container>\n  </ng-container>\n\n  <!-- Case when we have restore mode enabled and must hide menu actions -->\n  <ng-container *ngIf=\"restoreMode && restoreAction\">\n    <ng-template fs-menu-item (click)=\"actionClick(restoreAction, row, $event, menuRef)\">\n      <mat-icon *ngIf=\"restoreAction.icon\">{{restoreAction.icon}}</mat-icon>\n      {{restoreAction.label | actionLabel:row}}\n    </ng-template>\n  </ng-container>\n</fs-menu>\n"]}

package/esm2022/app/components/body/row/cell/cell.component.mjs

@@ -0,0 +1,109 @@
+import { ChangeDetectionStrategy, Component, HostBinding, Input, } from '@angular/core';
+import { Subject } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+import { Column } from '../../../../models/column.model';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+export class FsCellComponent {
+    isColl = true;
+    role = 'gridcell';
+    column;
+    row; // tmp
+    rowIndex;
+    cellContext = {};
+    cellTemplate;
+    _destroy$ = new Subject();
+    ngOnInit() {
+        this._listenGroupOpen();
+    }
+    ngDoCheck() {
+        // TODO fixme remove or improve
+        if (this.row) {
+            this.cellContext.groupIndex = this.row.index;
+        }
+    }
+    ngOnChanges(changes) {
+        if (changes.rowIndex?.currentValue !== changes.rowIndex?.previousValue) {
+            this.cellContext.index = this.rowIndex;
+            this.cellContext.groupIndex = this.row.index;
+        }
+        if (changes.column?.currentValue !== changes.column?.previousValue) {
+            this._initCellContext();
+            this._initCellTemplate();
+        }
+    }
+    ngOnDestroy() {
+        this._destroy$.next();
+        this._destroy$.complete();
+    }
+    _initCellContext() {
+        this.cellContext.index = this.rowIndex;
+        if (this.row) {
+            if (this.row.isGroup) {
+                this.cellContext.groupIndex = this.row.index;
+            }
+            else if (this.row.isChild || this.row.isGroupFooter) {
+                this.cellContext.groupIndex = this.row.index;
+                this.cellContext.groupRow = this.row.parent.data;
+                this.cellContext.group = this.row.parent.data;
+            }
+            if (this.row.isGroup) {
+                this.cellContext.group = this.row.data;
+                this.cellContext.groupChildren = this.row.children
+                    .map((child) => child.data);
+            }
+            else if (this.row.isGroupFooter) {
+                this.cellContext.group = this.row.parent.data;
+                this.cellContext.groupIndex = this.row.index;
+                this.cellContext.groupChildren = this.row.parent.children
+                    .map((child) => child.data);
+            }
+        }
+        this.cellContext.column = this.column;
+        if (this.row) {
+            this.cellContext.$implicit = this.row.data;
+            this.cellContext.row = this.row.data;
+            this.cellContext.value = this.row.data[this.column.name];
+            this.cellContext.expanded = this.row.expanded;
+        }
+    }
+    _initCellTemplate() {
+        if (this.row?.isGroup) {
+            this.cellTemplate = this.column.groupHeaderTemplate || this.column.cellTemplate;
+        }
+        else if (this.row?.isGroupFooter) {
+            this.cellTemplate = this.column.groupFooterTemplate || this.column.cellTemplate;
+        }
+        else {
+            this.cellTemplate = this.column.cellTemplate;
+        }
+    }
+    _listenGroupOpen() {
+        if (this.row && this.row.isGroup) {
+            this.row.expanded$
+                .pipe(takeUntil(this._destroy$))
+                .subscribe((status) => {
+                this.cellContext.expanded = status;
+            });
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: FsCellComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: FsCellComponent, selector: "[fs-cell]", inputs: { column: "column", row: "row", rowIndex: "rowIndex" }, host: { properties: { "class.fs-list-col": "this.isColl", "attr.role": "this.role" } }, usesOnChanges: true, ngImport: i0, template: "<ng-template [ngTemplateOutlet]=\"cellTemplate || defaultCellTemplate\" [ngTemplateOutletContext]=\"cellContext\"></ng-template>\n\n<ng-template #defaultCellTemplate let-value=\"value\">\n  {{value}}\n</ng-template>\n", dependencies: [{ kind: "directive", type: i1.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: FsCellComponent, decorators: [{
+            type: Component,
+            args: [{ selector: '[fs-cell]', changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-template [ngTemplateOutlet]=\"cellTemplate || defaultCellTemplate\" [ngTemplateOutletContext]=\"cellContext\"></ng-template>\n\n<ng-template #defaultCellTemplate let-value=\"value\">\n  {{value}}\n</ng-template>\n" }]
+        }], propDecorators: { isColl: [{
+                type: HostBinding,
+                args: ['class.fs-list-col']
+            }], role: [{
+                type: HostBinding,
+                args: ['attr.role']
+            }], column: [{
+                type: Input
+            }], row: [{
+                type: Input
+            }], rowIndex: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cell.component.js","sourceRoot":"","sources":["../../../../../../../src/app/components/body/row/cell/cell.component.ts","../../../../../../../src/app/components/body/row/cell/cell.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  ChangeDetectionStrategy,\n  Component, DoCheck,\n  HostBinding,\n  Input, OnChanges, OnDestroy,\n  OnInit, SimpleChanges,\n  TemplateRef,\n} from '@angular/core';\n\nimport { Subject } from 'rxjs';\nimport { takeUntil } from 'rxjs/operators';\n\nimport { Column } from '../../../../models/column.model';\n\n\n@Component({\n  selector: '[fs-cell]',\n  templateUrl: './cell.component.html',\n  changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class FsCellComponent implements OnInit, OnChanges, DoCheck, OnDestroy {\n\n  @HostBinding('class.fs-list-col') public isColl = true;\n\n  @HostBinding('attr.role') public role = 'gridcell';\n\n  @Input() public column: Column;\n  @Input() public row: any; // tmp\n  @Input() public rowIndex: number;\n\n  public cellContext: any = {};\n  public cellTemplate: TemplateRef<any>;\n\n  private _destroy$ = new Subject<void>();\n\n  public ngOnInit() {\n    this._listenGroupOpen();\n  }\n\n  public ngDoCheck() {\n    // TODO fixme remove or improve\n    if (this.row) {\n      this.cellContext.groupIndex = this.row.index;\n    }\n  }\n\n  public ngOnChanges(changes: SimpleChanges): void {\n    if (changes.rowIndex?.currentValue !== changes.rowIndex?.previousValue) {\n      this.cellContext.index = this.rowIndex;\n      this.cellContext.groupIndex = this.row.index;\n    }\n\n    if (changes.column?.currentValue !== changes.column?.previousValue) {\n      this._initCellContext();\n      this._initCellTemplate();\n    }\n  }\n\n  public ngOnDestroy(): void {\n    this._destroy$.next();\n    this._destroy$.complete();\n  }\n\n  private _initCellContext() {\n    this.cellContext.index = this.rowIndex;\n\n    if (this.row) {\n      if (this.row.isGroup) {\n        this.cellContext.groupIndex = this.row.index;\n      } else if (this.row.isChild || this.row.isGroupFooter) {\n        this.cellContext.groupIndex = this.row.index;\n        this.cellContext.groupRow = this.row.parent.data;\n        this.cellContext.group = this.row.parent.data;\n      }\n\n      if (this.row.isGroup) {\n        this.cellContext.group = this.row.data;\n        this.cellContext.groupChildren = this.row.children\n          .map((child) => child.data);\n      } else if (this.row.isGroupFooter) {\n        this.cellContext.group = this.row.parent.data;\n        this.cellContext.groupIndex = this.row.index;\n        this.cellContext.groupChildren = this.row.parent.children\n          .map((child) => child.data);\n      }\n    }\n\n    this.cellContext.column = this.column;\n    if (this.row) {\n      this.cellContext.$implicit = this.row.data;\n      this.cellContext.row = this.row.data;\n      this.cellContext.value = this.row.data[this.column.name];\n      this.cellContext.expanded = this.row.expanded;\n    }\n  }\n\n  private _initCellTemplate() {\n    if (this.row?.isGroup) {\n      this.cellTemplate = this.column.groupHeaderTemplate || this.column.cellTemplate;\n    } else if (this.row?.isGroupFooter) {\n      this.cellTemplate = this.column.groupFooterTemplate || this.column.cellTemplate;\n    } else {\n      this.cellTemplate = this.column.cellTemplate;\n    }\n  }\n\n  private _listenGroupOpen() {\n    if (this.row && this.row.isGroup) {\n      this.row.expanded$\n        .pipe(\n          takeUntil(this._destroy$),\n        )\n        .subscribe((status) => {\n          this.cellContext.expanded = status;\n        });\n    }\n  }\n}\n","<ng-template [ngTemplateOutlet]=\"cellTemplate || defaultCellTemplate\" [ngTemplateOutletContext]=\"cellContext\"></ng-template>\n\n<ng-template #defaultCellTemplate let-value=\"value\">\n  {{value}}\n</ng-template>\n"]}