@firestitch/list 14.0.2 → 16.0.0

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

@@ -0,0 +1,211 @@
+import { isNumber } from 'lodash-es';
+import { BehaviorSubject, merge, Subject } from 'rxjs';
+import { skip, takeUntil, tap } from 'rxjs/operators';
+import { Column } from '../models/column.model';
+export class ColumnsController {
+    _visibleColumns$ = new BehaviorSubject([]);
+    _visibleColumnsShared$ = this._visibleColumns$.pipe();
+    _theadClass = '';
+    _loadFn;
+    _changeFn;
+    _customizeFieldTitleFn;
+    _customizeFieldDisabledFn;
+    _columnTooltipFn;
+    _isConfigured = false;
+    _loadFnConfigured = false;
+    _changeFnConfigured = false;
+    _columnsFetched = false;
+    _hasHeader = false;
+    _hasFooter = false;
+    _columns = [];
+    _defaultConfigs;
+    _columnsUpdated$ = new Subject();
+    _destroy$ = new Subject();
+    constructor() { }
+    get columns() {
+        return this._columns.slice();
+    }
+    get visibleColumns() {
+        return this._visibleColumns$.getValue();
+    }
+    get visibleColumns$() {
+        return this._visibleColumnsShared$;
+    }
+    get columnsForDialog() {
+        const hasCustomTitle = !!this._customizeFieldTitleFn;
+        const hasCustomDisabledStatus = !!this._customizeFieldDisabledFn;
+        const hasCustomTooltip = !!this._columnTooltipFn;
+        return this._columns
+            .filter((column) => column.customize && !!column.name)
+            .map((column) => {
+            const title = hasCustomTitle
+                ? this._customizeFieldTitleFn(column.name, column.title)
+                : column.name;
+            const disabled = hasCustomDisabledStatus
+                ? this._customizeFieldDisabledFn(column.name)
+                : false;
+            const tooltip = hasCustomTooltip
+                ? this._columnTooltipFn(column.name, column.visible, disabled)
+                : void 0;
+            return {
+                template: column.headerTemplate,
+                name: column.name,
+                show: column.visible,
+                title: title,
+                disabled: disabled,
+                tooltip: tooltip,
+            };
+        });
+    }
+    get columnsFetched() {
+        return this._columnsFetched;
+    }
+    get hasHeader() {
+        return this._hasHeader;
+    }
+    get hasFooter() {
+        return this._hasFooter;
+    }
+    get theadClass() {
+        return this._theadClass;
+    }
+    get configured() {
+        return this._isConfigured;
+    }
+    get loadFnConfigured() {
+        return this._loadFnConfigured;
+    }
+    get changeFnConfigured() {
+        return this._changeFnConfigured;
+    }
+    get changeFn() {
+        return this._changeFn;
+    }
+    get visibleColumnsNames() {
+        return this.visibleColumns
+            .map((column) => column.name)
+            .filter((name) => !!name);
+    }
+    setDefaults(defaults) {
+        this._defaultConfigs = defaults;
+    }
+    /**
+     * Set data from list config
+     * @param config
+     */
+    initConfig(config) {
+        if (config) {
+            if (config.load) {
+                this._loadFn = config.load;
+                this._loadFnConfigured = true;
+            }
+            if (config.change) {
+                this._changeFn = config.change;
+                this._changeFnConfigured = true;
+            }
+            if (config.title) {
+                this._customizeFieldTitleFn = config.title;
+            }
+            if (config.disabled) {
+                this._customizeFieldDisabledFn = config.disabled;
+            }
+            if (config.tooltip) {
+                this._columnTooltipFn = config.tooltip;
+            }
+            this._isConfigured = true;
+        }
+    }
+    /**
+     * Base initialization for columns
+     * @param templates
+     */
+    initializeColumns(templates) {
+        this._columns = [];
+        templates.forEach((column) => {
+            const col = new Column(column, this._defaultConfigs);
+            if (col.headerTemplate || col.title) {
+                this._hasHeader = true;
+            }
+            if (col.footerTemplate) {
+                this._hasFooter = true;
+            }
+            this._columns.push(col);
+        });
+        this._theadClass = this.hasHeader ? 'has-header' : '';
+        this._updateColspans('headerConfigs', 'headerColspanned');
+        this._updateColspans('groupHeaderConfigs', 'groupHeaderColspanned');
+        this._updateColspans('groupFooterConfigs', 'groupFooterColspanned');
+        this._updateColspans('cellConfigs', 'cellColspanned');
+        this._updateColspans('footerConfigs', 'footerColspanned');
+        this.updateVisibleColumns();
+        this._listenColumnVisibilityUpdates();
+    }
+    /**
+     * Load visiblity config for columns from remote
+     */
+    loadRemoteColumnConfigs() {
+        return this._loadFn()
+            .pipe(takeUntil(this._destroy$), tap((columnConfigs) => {
+            this._columnsFetched = true;
+            this.updateVisibilityForCols(columnConfigs);
+        }));
+    }
+    /**
+     * Set visible columns based on current columns show status
+     */
+    updateVisibleColumns() {
+        this._visibleColumns$.next(this._columns.filter((column) => column.visible) || []);
+    }
+    /**
+     * Update visibility based on passed config
+     * @param columnsConfig
+     */
+    updateVisibilityForCols(columnsConfig) {
+        columnsConfig.forEach((columnConfig) => {
+            const col = this._columns
+                .find((column) => column.name === columnConfig.name);
+            if (col) {
+                col.updateVisibility(columnConfig.show);
+            }
+        });
+        this.updateVisibleColumns();
+    }
+    destroy() {
+        this._destroy$.next();
+        this._destroy$.complete();
+        this._columnsUpdated$.complete();
+        this._columns = void 0;
+        this._visibleColumns$ = void 0;
+        this._defaultConfigs = void 0;
+        this._loadFn = void 0;
+        this._changeFn = void 0;
+    }
+    _listenColumnVisibilityUpdates() {
+        this._columnsUpdated$.next();
+        const columnsVisibility = this._columns.map((column) => {
+            return column.visible$.pipe(skip(1));
+        });
+        merge(...columnsVisibility)
+            .pipe(takeUntil(this._columnsUpdated$), takeUntil(this._destroy$))
+            .subscribe(() => {
+            this.updateVisibleColumns();
+        });
+    }
+    _updateColspans(config, updateFlag) {
+        this._columns.forEach((col, index) => {
+            if (col[config].colspan !== void 0) {
+                const spanTo = index + +col[config].colspan;
+                if (!isNumber(spanTo)) {
+                    return;
+                }
+                this._columns[index][updateFlag] = false;
+                for (let i = index + 1; i < spanTo; i++) {
+                    if (this._columns[i]) {
+                        this._columns[i][updateFlag] = true;
+                    }
+                }
+            }
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"columns-controller.js","sourceRoot":"","sources":["../../../../src/app/classes/columns-controller.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AACrC,OAAO,EAAE,eAAe,EAAE,KAAK,EAAc,OAAO,EAAE,MAAM,MAAM,CAAC;AACnE,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAC;AAEtD,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAWhD,MAAM,OAAO,iBAAiB;IAEpB,gBAAgB,GAAG,IAAI,eAAe,CAAW,EAAE,CAAC,CAAC;IACrD,sBAAsB,GAAG,IAAI,CAAC,gBAAgB,CAAC,IAAI,EAAE,CAAC;IACtD,WAAW,GAAG,EAAE,CAAC;IACjB,OAAO,CAAqB;IAC5B,SAAS,CAAuB;IAChC,sBAAsB,CAAsB;IAC5C,yBAAyB,CAAyB;IAClD,gBAAgB,CAAwB;IAExC,aAAa,GAAG,KAAK,CAAC;IACtB,iBAAiB,GAAG,KAAK,CAAC;IAC1B,mBAAmB,GAAG,KAAK,CAAC;IAC5B,eAAe,GAAG,KAAK,CAAC;IACxB,UAAU,GAAG,KAAK,CAAC;IACnB,UAAU,GAAG,KAAK,CAAC;IACnB,QAAQ,GAAa,EAAE,CAAC;IACxB,eAAe,CAAC;IAEhB,gBAAgB,GAAG,IAAI,OAAO,EAAQ,CAAC;IACvC,SAAS,GAAG,IAAI,OAAO,EAAQ,CAAC;IAExC,gBAAe,CAAC;IAEhB,IAAW,OAAO;QAChB,OAAO,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAC;IAC/B,CAAC;IAED,IAAW,cAAc;QACvB,OAAO,IAAI,CAAC,gBAAgB,CAAC,QAAQ,EAAE,CAAC;IAC1C,CAAC;IAED,IAAW,eAAe;QACxB,OAAO,IAAI,CAAC,sBAAsB,CAAC;IACrC,CAAC;IAED,IAAW,gBAAgB;QACzB,MAAM,cAAc,GAAG,CAAC,CAAC,IAAI,CAAC,sBAAsB,CAAC;QACrD,MAAM,uBAAuB,GAAG,CAAC,CAAC,IAAI,CAAC,yBAAyB,CAAC;QACjE,MAAM,gBAAgB,GAAG,CAAC,CAAC,IAAI,CAAC,gBAAgB,CAAC;QAEjD,OAAO,IAAI,CAAC,QAAQ;aACjB,MAAM,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,SAAS,IAAI,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC;aACrD,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE;YACd,MAAM,KAAK,GAAG,cAAc;gBAC1B,CAAC,CAAC,IAAI,CAAC,sBAAsB,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,KAAK,CAAC;gBACxD,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC;YAEhB,MAAM,QAAQ,GAAG,uBAAuB;gBACtC,CAAC,CAAC,IAAI,CAAC,yBAAyB,CAAC,MAAM,CAAC,IAAI,CAAC;gBAC7C,CAAC,CAAC,KAAK,CAAC;YAEV,MAAM,OAAO,GAAG,gBAAgB;gBAC9B,CAAC,CAAC,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,OAAO,EAAE,QAAQ,CAAC;gBAC9D,CAAC,CAAC,KAAK,CAAC,CAAC;YAEX,OAAO;gBACL,QAAQ,EAAE,MAAM,CAAC,cAAc;gBAC/B,IAAI,EAAE,MAAM,CAAC,IAAI;gBACjB,IAAI,EAAE,MAAM,CAAC,OAAO;gBACpB,KAAK,EAAE,KAAK;gBACZ,QAAQ,EAAE,QAAQ;gBAClB,OAAO,EAAE,OAAO;aACjB,CAAA;QACH,CAAC,CAAC,CAAC;IACP,CAAC;IAED,IAAW,cAAc;QACvB,OAAO,IAAI,CAAC,eAAe,CAAC;IAC9B,CAAC;IAED,IAAW,SAAS;QAClB,OAAO,IAAI,CAAC,UAAU,CAAC;IACzB,CAAC;IAED,IAAW,SAAS;QAClB,OAAO,IAAI,CAAC,UAAU,CAAC;IACzB,CAAC;IAED,IAAW,UAAU;QACnB,OAAO,IAAI,CAAC,WAAW,CAAC;IAC1B,CAAC;IAED,IAAW,UAAU;QACnB,OAAO,IAAI,CAAC,aAAa,CAAC;IAC5B,CAAC;IAED,IAAW,gBAAgB;QACzB,OAAO,IAAI,CAAC,iBAAiB,CAAC;IAChC,CAAC;IAED,IAAW,kBAAkB;QAC3B,OAAO,IAAI,CAAC,mBAAmB,CAAC;IAClC,CAAC;IAED,IAAW,QAAQ;QACjB,OAAO,IAAI,CAAC,SAAS,CAAC;IACxB,CAAC;IAED,IAAW,mBAAmB;QAC5B,OAAO,IAAI,CAAC,cAAc;aACvB,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC;aAC5B,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;IAC9B,CAAC;IAEM,WAAW,CAAC,QAAQ;QACzB,IAAI,CAAC,eAAe,GAAG,QAAQ,CAAC;IAClC,CAAC;IAED;;;OAGG;IACI,UAAU,CAAC,MAA0B;QAC1C,IAAI,MAAM,EAAE;YACV,IAAI,MAAM,CAAC,IAAI,EAAE;gBACf,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC,IAAI,CAAC;gBAC3B,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC;aAC/B;YAED,IAAI,MAAM,CAAC,MAAM,EAAE;gBACjB,IAAI,CAAC,SAAS,GAAG,MAAM,CAAC,MAAM,CAAC;gBAC/B,IAAI,CAAC,mBAAmB,GAAG,IAAI,CAAC;aACjC;YAED,IAAI,MAAM,CAAC,KAAK,EAAE;gBAChB,IAAI,CAAC,sBAAsB,GAAG,MAAM,CAAC,KAAK,CAAC;aAC5C;YAED,IAAI,MAAM,CAAC,QAAQ,EAAE;gBACnB,IAAI,CAAC,yBAAyB,GAAG,MAAM,CAAC,QAAQ,CAAC;aAClD;YAED,IAAI,MAAM,CAAC,OAAO,EAAE;gBAClB,IAAI,CAAC,gBAAgB,GAAG,MAAM,CAAC,OAAO,CAAC;aACxC;YAED,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC;SAC3B;IACH,CAAC;IAED;;;OAGG;IACI,iBAAiB,CAAC,SAAS;QAChC,IAAI,CAAC,QAAQ,GAAG,EAAE,CAAC;QAEnB,SAAS,CAAC,OAAO,CAAC,CAAC,MAAM,EAAE,EAAE;YAC3B,MAAM,GAAG,GAAG,IAAI,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,eAAe,CAAC,CAAC;YAGrD,IAAI,GAAG,CAAC,cAAc,IAAI,GAAG,CAAC,KAAK,EAAE;gBACnC,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;aACxB;YACD,IAAI,GAAG,CAAC,cAAc,EAAE;gBACtB,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;aACxB;YAED,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QAC1B,CAAC,CAAC,CAAC;QAEH,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,EAAE,CAAC;QAEtD,IAAI,CAAC,eAAe,CAAC,eAAe,EAAE,kBAAkB,CAAC,CAAC;QAC1D,IAAI,CAAC,eAAe,CAAC,oBAAoB,EAAE,uBAAuB,CAAC,CAAC;QACpE,IAAI,CAAC,eAAe,CAAC,oBAAoB,EAAE,uBAAuB,CAAC,CAAC;QACpE,IAAI,CAAC,eAAe,CAAC,aAAa,EAAE,gBAAgB,CAAC,CAAC;QACtD,IAAI,CAAC,eAAe,CAAC,eAAe,EAAE,kBAAkB,CAAC,CAAC;QAE1D,IAAI,CAAC,oBAAoB,EAAE,CAAC;QAC5B,IAAI,CAAC,8BAA8B,EAAE,CAAC;IACxC,CAAC;IAED;;OAEG;IACI,uBAAuB;QAC5B,OAAO,IAAI,CAAC,OAAO,EAAE;aAClB,IAAI,CACH,SAAS,CAAC,IAAI,CAAC,SAAS,CAAC,EACzB,GAAG,CAAC,CAAC,aAAa,EAAE,EAAE;YACpB,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC;YAC5B,IAAI,CAAC,uBAAuB,CAAC,aAAa,CAAC,CAAC;QAC9C,CAAC,CAAC,CACH,CAAA;IACL,CAAC;IAED;;OAEG;IACI,oBAAoB;QACzB,IAAI,CAAC,gBAAgB,CAAC,IAAI,CACxB,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,EAAE,CACvD,CAAC;IACJ,CAAC;IAED;;;OAGG;IACI,uBAAuB,CAAC,aAAa;QAC1C,aAAa,CAAC,OAAO,CAAC,CAAC,YAAY,EAAE,EAAE;YACrC,MAAM,GAAG,GAAG,IAAI,CAAC,QAAQ;iBACtB,IAAI,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,IAAI,KAAK,YAAY,CAAC,IAAI,CAAC,CAAC;YAEvD,IAAI,GAAG,EAAE;gBACP,GAAG,CAAC,gBAAgB,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;aACzC;QACH,CAAC,CAAC,CAAC;QAEH,IAAI,CAAC,oBAAoB,EAAE,CAAC;IAC9B,CAAC;IAEM,OAAO;QACZ,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC;QACtB,IAAI,CAAC,SAAS,CAAC,QAAQ,EAAE,CAAC;QAC1B,IAAI,CAAC,gBAAgB,CAAC,QAAQ,EAAE,CAAC;QAEjC,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC,CAAC;QACvB,IAAI,CAAC,gBAAgB,GAAG,KAAK,CAAC,CAAC;QAC/B,IAAI,CAAC,eAAe,GAAG,KAAK,CAAC,CAAC;QAE9B,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC,CAAC;QACtB,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC,CAAC;IAC1B,CAAC;IAEO,8BAA8B;QACpC,IAAI,CAAC,gBAAgB,CAAC,IAAI,EAAE,CAAC;QAE7B,MAAM,iBAAiB,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE;YACrD,OAAO,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAA;QACtC,CAAC,CAAC,CAAC;QAEH,KAAK,CAAC,GAAG,iBAAiB,CAAC;aACxB,IAAI,CACH,SAAS,CAAC,IAAI,CAAC,gBAAgB,CAAC,EAChC,SAAS,CAAC,IAAI,CAAC,SAAS,CAAC,CAC1B;aACA,SAAS,CAAC,GAAG,EAAE;YACd,IAAI,CAAC,oBAAoB,EAAE,CAAC;QAC9B,CAAC,CAAC,CAAA;IACN,CAAC;IAEO,eAAe,CAAC,MAAM,EAAE,UAAU;QACxC,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,GAAG,EAAE,KAAK,EAAE,EAAE;YAEnC,IAAI,GAAG,CAAC,MAAM,CAAC,CAAC,OAAO,KAAK,KAAK,CAAC,EAAE;gBAClC,MAAM,MAAM,GAAG,KAAK,GAAG,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC;gBAE5C,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE;oBACrB,OAAO;iBACR;gBACD,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,UAAU,CAAC,GAAG,KAAK,CAAC;gBAEzC,KAAK,IAAI,CAAC,GAAG,KAAK,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,EAAE,CAAC,EAAE,EAAE;oBACvC,IAAI,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE;wBACpB,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,GAAG,IAAI,CAAC;qBACrC;iBACF;aACF;QACH,CAAC,CAAC,CAAA;IACJ,CAAC;CAEF","sourcesContent":["import { isNumber } from 'lodash-es';\nimport { BehaviorSubject, merge, Observable, Subject } from 'rxjs';\nimport { skip, takeUntil, tap } from 'rxjs/operators';\n\nimport { Column } from '../models/column.model';\nimport {\n  FsListColumnChangeFn,\n  FsListColumnConfig,\n  FsListColumnDisabledFn,\n  FsListColumnLoadFn,\n  FsListColumnTitleFn,\n  FsListColumnTooltipFn,\n} from '../interfaces/listconfig.interface';\n\n\nexport class ColumnsController {\n\n  private _visibleColumns$ = new BehaviorSubject<Column[]>([]);\n  private _visibleColumnsShared$ = this._visibleColumns$.pipe();\n  private _theadClass = '';\n  private _loadFn: FsListColumnLoadFn;\n  private _changeFn: FsListColumnChangeFn;\n  private _customizeFieldTitleFn: FsListColumnTitleFn;\n  private _customizeFieldDisabledFn: FsListColumnDisabledFn;\n  private _columnTooltipFn: FsListColumnTooltipFn;\n\n  private _isConfigured = false;\n  private _loadFnConfigured = false;\n  private _changeFnConfigured = false;\n  private _columnsFetched = false;\n  private _hasHeader = false;\n  private _hasFooter = false;\n  private _columns: Column[] = [];\n  private _defaultConfigs;\n\n  private _columnsUpdated$ = new Subject<void>();\n  private _destroy$ = new Subject<void>();\n\n  constructor() {}\n\n  public get columns() {\n    return this._columns.slice();\n  }\n\n  public get visibleColumns(): Column[] {\n    return this._visibleColumns$.getValue();\n  }\n\n  public get visibleColumns$(): Observable<Column[]> {\n    return this._visibleColumnsShared$;\n  }\n\n  public get columnsForDialog() {\n    const hasCustomTitle = !!this._customizeFieldTitleFn;\n    const hasCustomDisabledStatus = !!this._customizeFieldDisabledFn;\n    const hasCustomTooltip = !!this._columnTooltipFn;\n\n    return this._columns\n      .filter((column) => column.customize && !!column.name)\n      .map((column) => {\n        const title = hasCustomTitle\n          ? this._customizeFieldTitleFn(column.name, column.title)\n          : column.name;\n\n        const disabled = hasCustomDisabledStatus\n          ? this._customizeFieldDisabledFn(column.name)\n          : false;\n\n        const tooltip = hasCustomTooltip\n          ? this._columnTooltipFn(column.name, column.visible, disabled)\n          : void 0;\n\n        return {\n          template: column.headerTemplate,\n          name: column.name,\n          show: column.visible,\n          title: title,\n          disabled: disabled,\n          tooltip: tooltip,\n        }\n      });\n  }\n\n  public get columnsFetched() {\n    return this._columnsFetched;\n  }\n\n  public get hasHeader() {\n    return this._hasHeader;\n  }\n\n  public get hasFooter() {\n    return this._hasFooter;\n  }\n\n  public get theadClass() {\n    return this._theadClass;\n  }\n\n  public get configured() {\n    return this._isConfigured;\n  }\n\n  public get loadFnConfigured() {\n    return this._loadFnConfigured;\n  }\n\n  public get changeFnConfigured() {\n    return this._changeFnConfigured;\n  }\n\n  public get changeFn() {\n    return this._changeFn;\n  }\n\n  public get visibleColumnsNames() {\n    return this.visibleColumns\n      .map((column) => column.name)\n      .filter((name) => !!name);\n  }\n\n  public setDefaults(defaults) {\n    this._defaultConfigs = defaults;\n  }\n\n  /**\n   * Set data from list config\n   * @param config\n   */\n  public initConfig(config: FsListColumnConfig) {\n    if (config) {\n      if (config.load) {\n        this._loadFn = config.load;\n        this._loadFnConfigured = true;\n      }\n\n      if (config.change) {\n        this._changeFn = config.change;\n        this._changeFnConfigured = true;\n      }\n\n      if (config.title) {\n        this._customizeFieldTitleFn = config.title;\n      }\n\n      if (config.disabled) {\n        this._customizeFieldDisabledFn = config.disabled;\n      }\n\n      if (config.tooltip) {\n        this._columnTooltipFn = config.tooltip;\n      }\n\n      this._isConfigured = true;\n    }\n  }\n\n  /**\n   * Base initialization for columns\n   * @param templates\n   */\n  public initializeColumns(templates) {\n    this._columns = [];\n\n    templates.forEach((column) => {\n      const col = new Column(column, this._defaultConfigs);\n\n\n      if (col.headerTemplate || col.title) {\n        this._hasHeader = true;\n      }\n      if (col.footerTemplate) {\n        this._hasFooter = true;\n      }\n\n      this._columns.push(col);\n    });\n\n    this._theadClass = this.hasHeader ? 'has-header' : '';\n\n    this._updateColspans('headerConfigs', 'headerColspanned');\n    this._updateColspans('groupHeaderConfigs', 'groupHeaderColspanned');\n    this._updateColspans('groupFooterConfigs', 'groupFooterColspanned');\n    this._updateColspans('cellConfigs', 'cellColspanned');\n    this._updateColspans('footerConfigs', 'footerColspanned');\n\n    this.updateVisibleColumns();\n    this._listenColumnVisibilityUpdates();\n  }\n\n  /**\n   * Load visiblity config for columns from remote\n   */\n  public loadRemoteColumnConfigs() {\n    return this._loadFn()\n      .pipe(\n        takeUntil(this._destroy$),\n        tap((columnConfigs) => {\n          this._columnsFetched = true;\n          this.updateVisibilityForCols(columnConfigs);\n        })\n      )\n  }\n\n  /**\n   * Set visible columns based on current columns show status\n   */\n  public updateVisibleColumns() {\n    this._visibleColumns$.next(\n      this._columns.filter((column) => column.visible) || []\n    );\n  }\n\n  /**\n   * Update visibility based on passed config\n   * @param columnsConfig\n   */\n  public updateVisibilityForCols(columnsConfig) {\n    columnsConfig.forEach((columnConfig) => {\n      const col = this._columns\n        .find((column) => column.name === columnConfig.name);\n\n      if (col) {\n        col.updateVisibility(columnConfig.show);\n      }\n    });\n\n    this.updateVisibleColumns();\n  }\n\n  public destroy() {\n    this._destroy$.next();\n    this._destroy$.complete();\n    this._columnsUpdated$.complete();\n\n    this._columns = void 0;\n    this._visibleColumns$ = void 0;\n    this._defaultConfigs = void 0;\n\n    this._loadFn = void 0;\n    this._changeFn = void 0;\n  }\n\n  private _listenColumnVisibilityUpdates() {\n    this._columnsUpdated$.next();\n\n    const columnsVisibility = this._columns.map((column) => {\n      return column.visible$.pipe(skip(1))\n    });\n\n    merge(...columnsVisibility)\n      .pipe(\n        takeUntil(this._columnsUpdated$),\n        takeUntil(this._destroy$),\n      )\n      .subscribe(() => {\n        this.updateVisibleColumns();\n      })\n  }\n\n  private _updateColspans(config, updateFlag) {\n    this._columns.forEach((col, index) => {\n\n      if (col[config].colspan !== void 0) {\n        const spanTo = index + +col[config].colspan;\n\n        if (!isNumber(spanTo)) {\n          return;\n        }\n        this._columns[index][updateFlag] = false;\n\n        for (let i = index + 1; i < spanTo; i++) {\n          if (this._columns[i]) {\n            this._columns[i][updateFlag] = true;\n          }\n        }\n      }\n    })\n  }\n\n}\n"]}

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

@@ -0,0 +1,348 @@
+import { BehaviorSubject, Subject } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+import { isFunction, isObject } from 'lodash-es';
+import { RowType } from '../enums/row-type.enum';
+import { FsListState } from '../enums/state.enum';
+import { Row } from '../models/row';
+import { ChildRow } from '../models/row/child-row';
+import { GroupFooterRow } from '../models/row/group-footer-row';
+import { GroupRow } from '../models/row/group-row';
+export class DataController {
+    _visibleRows$ = new BehaviorSubject([]);
+    _rowsRemoved$ = new Subject();
+    _remoteRowsChange$ = new Subject();
+    _store = new Map();
+    _rowsStack = [];
+    _operation;
+    _groupByFn;
+    _footerRowFn;
+    _compareByFn;
+    _initialExpand = true;
+    _groupEnabled = false;
+    _loadMoreEnabled;
+    _hasData = false;
+    _destroy$ = new Subject();
+    get visibleRowsData() {
+        return this.visibleRows.map((row) => row.data);
+    }
+    get rowsStack() {
+        return this._rowsStack.slice();
+    }
+    get groupEnabled() {
+        return this._groupEnabled;
+    }
+    set groupEnabled(value) {
+        this._groupEnabled = value;
+    }
+    get remoteRowsChange$() {
+        return this._remoteRowsChange$.pipe(takeUntil(this._destroy$));
+    }
+    get rowsRemoved$() {
+        return this._rowsRemoved$.pipe(takeUntil(this._destroy$));
+    }
+    get hasData() {
+        return this._hasData;
+    }
+    get operation() {
+        return this._operation;
+    }
+    get visibleRows$() {
+        return this._visibleRows$;
+    }
+    set visibleRows(value) {
+        this._visibleRows$.next(value);
+        this._hasData = this.visibleRows.length > 0;
+    }
+    get visibleRows() {
+        return this._visibleRows$.getValue();
+    }
+    get visibleRowsCount() {
+        return this.visibleRows.length;
+    }
+    get hasGroups() {
+        return this._compareByFn && this._groupByFn;
+    }
+    get reorderData() {
+        return this._rowsStack
+            .map((row) => row.getReorderData());
+    }
+    setGroupConfig(group) {
+        if (group) {
+            this._groupByFn = group.groupBy;
+            this._compareByFn = group.compareBy;
+            this._footerRowFn = group.footer || (() => false);
+            this._initialExpand = group.initialExpand ?? true;
+            // group mode enabled by default
+            this._groupEnabled = (group.enabled !== undefined)
+                ? group.enabled
+                : true;
+        }
+    }
+    setAdditionalConfigs(configs) {
+        this._loadMoreEnabled = configs.loadMoreEnabled;
+    }
+    /**
+     * Rows what was received from fetch function
+     * @param rows
+     */
+    setRowsFromResponse(rows) {
+        if (this._operation === FsListState.LoadMore ||
+            (this._operation === FsListState.PageChange && this._loadMoreEnabled)) {
+            this._extendRowsStack(rows);
+        }
+        else {
+            this._updateRowsStack(rows);
+        }
+        this._operation = FsListState.Idle;
+        this._updateVisibleRows();
+    }
+    /**
+     * Set current operation for list data flow
+     * @param value
+     */
+    setOperation(value) {
+        this._operation = value;
+    }
+    /**
+     * Remove rows from visible
+     */
+    clearRows() {
+        this.visibleRows = [];
+    }
+    /**
+     * Replace data for specified row
+     * @param targetRow
+     * @param trackBy
+     */
+    replaceData(targetRow, trackBy) {
+        const rowIndex = this._rowsStack.findIndex((listRow) => {
+            return trackBy(listRow.data, targetRow);
+        });
+        if (rowIndex > -1) {
+            this._rowsStack[rowIndex] = new Row(targetRow, RowType.Simple, { initialExpand: this._initialExpand });
+            this._updateVisibleRows();
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Update data for specified row
+     * @param rows
+     * @param trackBy
+     */
+    updateData(rows, trackBy) {
+        if (Array.isArray(rows)) {
+            let updateSuccess = false;
+            rows.forEach((item) => {
+                if (this.updateRow(item, trackBy)) {
+                    updateSuccess = true;
+                }
+            });
+            this._updateVisibleRows();
+            return updateSuccess;
+        }
+        const updated = this.updateRow(rows, trackBy);
+        this._updateVisibleRows();
+        return updated;
+    }
+    /**
+     * Remove data for specified row
+     * @param data
+     */
+    removeData(data) {
+        const removedRows = [];
+        const defaultTrackBy = (row, target) => {
+            return row === target;
+        };
+        if (Array.isArray(data)) {
+            //
+            data.forEach((item) => {
+                removedRows.push(...this.removeRow(item, defaultTrackBy));
+            });
+        }
+        else if (isFunction(data)) {
+            removedRows.push(...this.removeRow(null, data));
+        }
+        else if (isObject(data)) {
+            removedRows.push(...this.removeRow(data, defaultTrackBy));
+        }
+        if (removedRows.length > 0) {
+            this._updateVisibleRows();
+            this._rowsRemoved$.next(removedRows);
+        }
+        return !!removedRows.length;
+    }
+    swapRows(row1, row2, selectedRows, isMultipleDrag = false) {
+        let tmpEl;
+        const rowsStack = this._rowsStack;
+        const row1GlobalIndex = rowsStack.indexOf(row1);
+        const row2GlobalIndex = rowsStack.indexOf(row2);
+        tmpEl = rowsStack[row1GlobalIndex];
+        rowsStack[row1GlobalIndex] = rowsStack[row2GlobalIndex];
+        rowsStack[row2GlobalIndex] = tmpEl;
+        if (isMultipleDrag && Array.isArray(selectedRows)) {
+            if (!selectedRows.includes(row1)) {
+                selectedRows = [row1, ...selectedRows];
+            }
+            selectedRows
+                .filter((selectedRow) => {
+                return selectedRow !== row1;
+            })
+                .forEach((selectedRow) => {
+                const idx = rowsStack.indexOf(selectedRow);
+                rowsStack.splice(idx, 1);
+            });
+            const indexToInsertAfter = rowsStack.indexOf(tmpEl);
+            rowsStack.splice(indexToInsertAfter, 1);
+            selectedRows.forEach((selectedRow, offset) => {
+                rowsStack.splice(indexToInsertAfter + offset, 0, selectedRow);
+            });
+        }
+        this._rowsStack = [...rowsStack];
+    }
+    destroy() {
+        this._destroyRowsStack();
+        this._store.clear();
+        this._destroy$.next();
+        this._destroy$.complete();
+    }
+    toggleRowGroup(rowData) {
+        const row = this.visibleRows.find((visibleRow) => visibleRow.data === rowData);
+        row.toggleRowExpandStatus();
+        this._updateVisibleRows();
+    }
+    finishReorder() {
+        // TODO fixme remove or improve
+        if (this.groupEnabled) {
+            let group;
+            this._rowsStack
+                .forEach((row, index) => {
+                if (row.isGroup && row !== group) {
+                    group = row;
+                }
+                else {
+                    row.index = index - this._rowsStack.indexOf(group) - 1;
+                }
+            });
+        }
+        this._updateVisibleRows();
+    }
+    _updateRowsStack(rows) {
+        this._destroyRowsStack();
+        if (this.groupEnabled) {
+            this._store.clear();
+            this._rowsStack = [...this.groupRowsBy(rows)];
+        }
+        else {
+            rows = rows.map((row) => {
+                return new Row(row, RowType.Simple, { initialExpand: this._initialExpand });
+            });
+            this._rowsStack = [...rows];
+        }
+    }
+    _extendRowsStack(rows) {
+        if (this.groupEnabled) {
+            this._rowsStack = [...this.groupRowsBy(rows)];
+        }
+        else {
+            rows = rows.map((row) => {
+                return new Row(row, RowType.Simple, { initialExpand: this._initialExpand });
+            });
+            this._rowsStack = [...this._rowsStack, ...rows];
+        }
+    }
+    _destroyRowsStack() {
+        this._rowsStack.forEach((row) => row.destroy());
+    }
+    _updateVisibleRows() {
+        this.visibleRows = this._rowsStack
+            .filter((row, index) => {
+            return (!row.isChild && !row.isGroupFooter) || row.visible;
+        });
+    }
+    updateRow(targetRow, trackBy) {
+        if (trackBy === void 0) {
+            trackBy = (row, target) => {
+                return row === target;
+            };
+        }
+        const targetIndex = this._rowsStack.findIndex((listRow) => trackBy(listRow.data, targetRow));
+        if (targetIndex !== -1) {
+            const updateTarget = this._rowsStack[targetIndex];
+            const updatedData = { ...updateTarget.data, ...targetRow };
+            this._rowsStack[targetIndex] = new Row(updatedData, updateTarget.type, {
+                parent: updateTarget.parent,
+                initialExpand: updateTarget.expanded,
+            });
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Remove row from
+     * @param targetRow
+     * @param trackBy
+     */
+    removeRow(targetRow, trackBy) {
+        const rows = this._rowsStack;
+        const removedRows = [];
+        rows.forEach((listRow, index) => {
+            if (trackBy(listRow.data, targetRow)) {
+                const removedRow = rows.splice(index, 1);
+                removedRows.push(removedRow);
+            }
+        });
+        return removedRows;
+    }
+    /**
+     * Split existing rows by groups and store them for future use
+     */
+    groupRowsBy(rows) {
+        if (!this._groupByFn || !this._compareByFn) {
+            return rows;
+        }
+        const groupRows = [];
+        const footerRows = new Map();
+        rows.forEach((row) => {
+            const mainGroup = this._groupByFn(row);
+            const mainGroupKey = this._compareByFn(mainGroup);
+            if (!this._store.has(mainGroupKey)) {
+                const group = new GroupRow(mainGroup, this._initialExpand);
+                group.index = groupRows.length;
+                groupRows.push(group);
+                const childRow = new ChildRow(row, group);
+                this._store.set(mainGroupKey, group);
+                group.children.push(childRow);
+            }
+            else {
+                const group = this._store.get(mainGroupKey);
+                const childRow = new ChildRow(row, group);
+                group.children.push(childRow);
+            }
+        });
+        groupRows.forEach((groupRow) => {
+            const footerIndex = groupRow.children
+                .findIndex((row) => {
+                return this._footerRowFn(row.data, {
+                    ...groupRow.data,
+                    children: groupRow.childrenData,
+                });
+            });
+            if (footerIndex !== -1) {
+                const footerRow = groupRow.children.splice(footerIndex, footerIndex + 1)[0];
+                groupRow.children.push(new GroupFooterRow(footerRow.data, groupRow));
+            }
+        });
+        return Array.from(this._store.values())
+            .reduce((acc, item) => {
+            if (item.isGroup) {
+                acc.push(item, ...item.children);
+            }
+            else {
+                acc.push(item);
+            }
+            return acc;
+        }, []);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"data-controller.js","sourceRoot":"","sources":["../../../../src/app/classes/data-controller.ts"],"names":[],"mappings":"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","sourcesContent":["import { BehaviorSubject, Subject } from 'rxjs';\nimport { takeUntil } from 'rxjs/operators';\n\nimport { isFunction, isObject } from 'lodash-es';\n\nimport { RowType } from '../enums/row-type.enum';\nimport { FsListState } from '../enums/state.enum';\nimport {\n  FsListAbstractRow,\n  FsListGroupConfig,\n  FsListTrackByTargetRowFn,\n} from '../interfaces/listconfig.interface';\nimport { Row } from '../models/row';\nimport { ChildRow } from '../models/row/child-row';\nimport { GroupFooterRow } from '../models/row/group-footer-row';\nimport { GroupRow } from '../models/row/group-row';\n\n\nexport class DataController {\n\n  private readonly _visibleRows$ = new BehaviorSubject<Row[]>([]);\n  private readonly _rowsRemoved$ = new Subject<Row[]>();\n  private readonly _remoteRowsChange$ = new Subject<void>();\n\n  private _store = new Map();\n  private _rowsStack: Row[] = [];\n  private _operation: FsListState;\n\n  private _groupByFn: (row) => any[];\n  private _footerRowFn: (\n    row: { [key: string]: any },\n    group: {\n      [key: string]: any,\n      children: {\n        [key: string]: any\n      }[],\n    }\n  ) => boolean;\n  private _compareByFn: (group) => any;\n  private _initialExpand = true;\n  private _groupEnabled = false;\n\n  private _loadMoreEnabled: boolean;\n\n  private _hasData = false;\n\n  private readonly _destroy$ = new Subject<void>();\n\n  public get visibleRowsData() {\n    return this.visibleRows.map((row) => row.data);\n  }\n\n  public get rowsStack() {\n    return this._rowsStack.slice();\n  }\n\n  public get groupEnabled() {\n    return this._groupEnabled;\n  }\n\n  public set groupEnabled(value: boolean) {\n    this._groupEnabled = value;\n  }\n\n  public get remoteRowsChange$() {\n    return this._remoteRowsChange$.pipe(\n      takeUntil(this._destroy$),\n    );\n  }\n\n  public get rowsRemoved$() {\n    return this._rowsRemoved$.pipe(\n      takeUntil(this._destroy$),\n    );\n  }\n\n  public get hasData() {\n    return this._hasData;\n  }\n\n  public get operation() {\n    return this._operation;\n  }\n\n  public get visibleRows$() {\n    return this._visibleRows$;\n  }\n\n  public set visibleRows(value: any[]) {\n    this._visibleRows$.next(value);\n    this._hasData = this.visibleRows.length > 0;\n  }\n\n  public get visibleRows() {\n    return this._visibleRows$.getValue();\n  }\n\n  public get visibleRowsCount() {\n    return this.visibleRows.length;\n  }\n\n  public get hasGroups() {\n    return this._compareByFn && this._groupByFn;\n  }\n\n  public get reorderData() {\n    return this._rowsStack\n      .map((row) => row.getReorderData());\n  }\n\n  public setGroupConfig(group: FsListGroupConfig) {\n    if (group) {\n      this._groupByFn = group.groupBy;\n      this._compareByFn = group.compareBy;\n      this._footerRowFn = group.footer || (() => false);\n      this._initialExpand = group.initialExpand ?? true;\n\n      // group mode enabled by default\n      this._groupEnabled = (group.enabled !== undefined)\n        ? group.enabled\n        : true;\n    }\n  }\n\n  public setAdditionalConfigs(configs: { loadMoreEnabled: boolean }) {\n    this._loadMoreEnabled = configs.loadMoreEnabled;\n  }\n\n  /**\n   * Rows what was received from fetch function\n   * @param rows\n   */\n  public setRowsFromResponse(rows: any[]) {\n    if (\n      this._operation === FsListState.LoadMore ||\n        (this._operation === FsListState.PageChange && this._loadMoreEnabled)\n    ) {\n      this._extendRowsStack(rows);\n    } else {\n      this._updateRowsStack(rows);\n    }\n\n    this._operation = FsListState.Idle;\n\n    this._updateVisibleRows();\n  }\n\n  /**\n   * Set current operation for list data flow\n   * @param value\n   */\n  public setOperation(value: FsListState) {\n    this._operation = value;\n  }\n\n  /**\n   * Remove rows from visible\n   */\n  public clearRows() {\n    this.visibleRows = [];\n  }\n\n  /**\n   * Replace data for specified row\n   * @param targetRow\n   * @param trackBy\n   */\n  public replaceData(\n    targetRow: FsListAbstractRow,\n    trackBy?: FsListTrackByTargetRowFn,\n  ) {\n    const rowIndex = this._rowsStack.findIndex((listRow) => {\n      return trackBy(listRow.data, targetRow);\n    });\n\n    if (rowIndex > -1) {\n      this._rowsStack[rowIndex] = new Row(\n        targetRow,\n        RowType.Simple,\n        { initialExpand: this._initialExpand },\n      );\n\n      this._updateVisibleRows();\n\n      return true;\n    }\n \n    return false;\n    \n\n  }\n\n  /**\n   * Update data for specified row\n   * @param rows\n   * @param trackBy\n   */\n  public updateData(\n    rows: FsListAbstractRow | FsListAbstractRow[],\n    trackBy?: FsListTrackByTargetRowFn,\n  ): boolean {\n    if (Array.isArray(rows)) {\n      let updateSuccess = false;\n\n      rows.forEach((item) => {\n        if (this.updateRow(item, trackBy)) {\n          updateSuccess = true;\n        }\n      });\n\n      this._updateVisibleRows();\n\n      return updateSuccess;\n    } \n    const updated = this.updateRow(rows, trackBy);\n\n    this._updateVisibleRows();\n\n    return updated;\n    \n  }\n\n  /**\n   * Remove data for specified row\n   * @param data\n   */\n  public removeData(data: FsListAbstractRow | FsListAbstractRow[] | FsListTrackByTargetRowFn): boolean {\n    const removedRows = [];\n\n    const defaultTrackBy = (row, target) => {\n      return row === target;\n    };\n\n    if (Array.isArray(data)) {\n      //\n      data.forEach((item) => {\n        removedRows.push(...this.removeRow(item, defaultTrackBy));\n      });\n    } else if (isFunction(data)) {\n      removedRows.push(...this.removeRow(null, (data as FsListTrackByTargetRowFn)));\n    } else if (isObject(data)) {\n      removedRows.push(...this.removeRow(data, defaultTrackBy));\n    }\n\n    if (removedRows.length > 0) {\n      this._updateVisibleRows();\n\n      this._rowsRemoved$.next(removedRows);\n    }\n\n    return !!removedRows.length;\n  }\n\n  public swapRows(row1, row2, selectedRows?: Row[], isMultipleDrag = false) {\n    let tmpEl;\n    const rowsStack = this._rowsStack;\n    const row1GlobalIndex = rowsStack.indexOf(row1);\n    const row2GlobalIndex = rowsStack.indexOf(row2);\n\n    tmpEl = rowsStack[row1GlobalIndex];\n    rowsStack[row1GlobalIndex] = rowsStack[row2GlobalIndex];\n    rowsStack[row2GlobalIndex] = tmpEl;\n\n    if (isMultipleDrag && Array.isArray(selectedRows)) {\n      if (!selectedRows.includes(row1)) {\n        selectedRows = [row1, ...selectedRows];\n      }\n\n      selectedRows\n        .filter((selectedRow) => {\n          return selectedRow !== row1;\n        })\n        .forEach((selectedRow) => {\n          const idx = rowsStack.indexOf(selectedRow);\n          rowsStack.splice(idx, 1);\n        });\n\n      const indexToInsertAfter = rowsStack.indexOf(tmpEl);\n\n      rowsStack.splice(indexToInsertAfter, 1);\n\n      selectedRows.forEach((selectedRow, offset) => {\n        rowsStack.splice(indexToInsertAfter + offset, 0, selectedRow);\n      });\n    }\n\n    this._rowsStack = [...rowsStack];\n  }\n\n  public destroy() {\n    this._destroyRowsStack();\n    this._store.clear();\n\n    this._destroy$.next();\n    this._destroy$.complete();\n  }\n\n  public toggleRowGroup(rowData) {\n    const row = this.visibleRows.find((visibleRow) => visibleRow.data === rowData );\n    row.toggleRowExpandStatus();\n\n    this._updateVisibleRows();\n  }\n\n  public finishReorder(): void {\n    // TODO fixme remove or improve\n    if (this.groupEnabled) {\n      let group;\n      this._rowsStack\n        .forEach((row, index) => {\n          if (row.isGroup && row !== group) {\n            group = row;\n          } else {\n            row.index = index - this._rowsStack.indexOf(group) - 1;\n          }\n        });\n    }\n\n    this._updateVisibleRows();\n  }\n\n  private _updateRowsStack(rows) {\n    this._destroyRowsStack();\n\n    if (this.groupEnabled) {\n      this._store.clear();\n      this._rowsStack = [...this.groupRowsBy(rows)];\n    } else {\n      rows = rows.map((row) => {\n        return new Row(\n          row,\n          RowType.Simple,\n          { initialExpand: this._initialExpand },\n        );\n      });\n      this._rowsStack = [...rows];\n    }\n  }\n\n  private _extendRowsStack(rows) {\n    if (this.groupEnabled) {\n      this._rowsStack = [...this.groupRowsBy(rows)];\n    } else {\n      rows = rows.map((row) => {\n        return new Row(\n          row,\n          RowType.Simple,\n          { initialExpand: this._initialExpand },\n        );\n      });\n      this._rowsStack = [...this._rowsStack, ...rows];\n    }\n  }\n\n  private _destroyRowsStack() {\n    this._rowsStack.forEach((row) => row.destroy());\n  }\n\n  private _updateVisibleRows() {\n    this.visibleRows = this._rowsStack\n      .filter((row, index) => {\n        return (!(row as any).isChild && !row.isGroupFooter) || row.visible;\n      });\n  }\n\n  private updateRow(\n    targetRow: FsListAbstractRow,\n    trackBy?: (listRow: FsListAbstractRow, targetRow?: FsListAbstractRow) => boolean) {\n\n    if (trackBy === void 0) {\n      trackBy = (row, target) => {\n        return row === target;\n      };\n    }\n\n    const targetIndex = this._rowsStack.findIndex((listRow) => trackBy(listRow.data, targetRow));\n\n    if (targetIndex !== -1) {\n      const updateTarget = this._rowsStack[targetIndex];\n      const updatedData = { ...updateTarget.data, ...targetRow };\n\n      this._rowsStack[targetIndex] = new Row(\n        updatedData,\n        updateTarget.type,\n        {\n          parent: updateTarget.parent,\n          initialExpand: updateTarget.expanded,\n        },\n      );\n\n      return true;\n    }\n\n    return false;\n  }\n\n  /**\n   * Remove row from\n   * @param targetRow\n   * @param trackBy\n   */\n  private removeRow(\n    targetRow: FsListAbstractRow | null,\n    trackBy?: FsListTrackByTargetRowFn,\n  ) {\n\n    const rows = this._rowsStack;\n    const removedRows = [];\n\n    rows.forEach((listRow, index) => {\n      if (trackBy(listRow.data, targetRow)) {\n        const removedRow = rows.splice(index, 1);\n\n        removedRows.push(removedRow);\n      }\n    });\n\n    return removedRows;\n  }\n\n  /**\n   * Split existing rows by groups and store them for future use\n   */\n  private groupRowsBy(rows) {\n    if (!this._groupByFn || !this._compareByFn) {\n      return rows; \n    }\n\n    const groupRows: GroupRow[] = [];\n    const footerRows = new Map();\n\n    rows.forEach((row) => {\n      const mainGroup = this._groupByFn(row);\n      const mainGroupKey = this._compareByFn(mainGroup);\n\n      if (!this._store.has(mainGroupKey)) {\n        const group = new GroupRow(\n          mainGroup,\n          this._initialExpand,\n        );\n\n        group.index = groupRows.length;\n        groupRows.push(group);\n\n        const childRow = new ChildRow(row, group);\n\n        this._store.set(mainGroupKey, group);\n        group.children.push(childRow);\n      } else {\n        const group = this._store.get(mainGroupKey);\n        const childRow = new ChildRow(row, group);\n\n        group.children.push(childRow);\n      }\n    });\n\n    groupRows.forEach((groupRow) => {\n      const footerIndex = groupRow.children\n        .findIndex((row) => {\n          return this._footerRowFn(row.data, {\n            ...groupRow.data,\n            children: groupRow.childrenData,\n          });\n        });\n\n      if (footerIndex !== -1) {\n        const footerRow = groupRow.children.splice(footerIndex, footerIndex + 1)[0];\n        groupRow.children.push(new GroupFooterRow(footerRow.data, groupRow));\n      }\n    });\n\n    return Array.from(this._store.values())\n      .reduce((acc, item) => {\n        if (item.isGroup) {\n          acc.push(item, ...item.children);\n        } else {\n          acc.push(item);\n        }\n\n        return acc;\n      }, []);\n  }\n}\n"]}