@netgrif/components-core 6.0.1

package/esm2015/lib/task-content/task-content/abstract-task-content.component.js

@@ -0,0 +1,656 @@
+import { EventEmitter, Inject, Input, Optional, Output } from '@angular/core';
+import { FieldConverterService } from '../services/field-converter.service';
+import { TaskContentService } from '../services/task-content.service';
+import { PaperViewService } from '../../navigation/quick-panel/components/paper-view.service';
+import { LoggerService } from '../../logger/services/logger.service';
+import { TaskEventService } from '../services/task-event.service';
+import { DataGroupAlignment } from '../../resources/interface/data-groups';
+import { TaskElementType } from '../model/task-content-element-type';
+import { DataGroupCompact, DataGroupHideEmptyRows, DataGroupLayoutType } from '../../resources/interface/data-group-layout';
+import { FieldAlignment } from '../../resources/interface/field-alignment';
+import { FieldTypeResource } from '../model/field-type-resource';
+import { LoadingEmitter } from '../../utility/loading-emitter';
+import { BehaviorSubject } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { NAE_ASYNC_RENDERING_CONFIGURATION } from '../model/async-rendering-configuration-injection-token';
+import { TaskRefField } from '../../data-fields/task-ref-field/model/task-ref-field';
+import { Subgrid } from '../model/subgrid';
+import { IncrementingCounter } from '../../utility/incrementing-counter';
+export class AbstractTaskContentComponent {
+    constructor(_fieldConverter, taskContentService, _paperView, _logger, _taskEventService = null, asyncRenderingConfiguration = null) {
+        this._fieldConverter = _fieldConverter;
+        this.taskContentService = taskContentService;
+        this._paperView = _paperView;
+        this._logger = _logger;
+        this._taskEventService = _taskEventService;
+        this.DEFAULT_LAYOUT_TYPE = DataGroupLayoutType.LEGACY;
+        this.DEFAULT_FIELD_ALIGNMENT = FieldAlignment.CENTER;
+        this.DEFAULT_ASYNC_RENDERING_CONFIGURATION = {
+            batchSize: 4,
+            batchDelay: 200,
+            numberOfPlaceholders: 4,
+            enableAsyncRenderingForNewFields: true,
+            enableAsyncRenderingOnTaskExpand: true
+        };
+        this.DEFAULT_COMPACT_DIRECTION = DataGroupCompact.NONE;
+        this.DEFAULT_HIDE_EMPTY_ROWS = DataGroupHideEmptyRows.ALL;
+        /**
+         * Exists to allow references to the enum in the HTML
+         */
+        this.fieldTypeResource = FieldTypeResource;
+        /**
+         * Whether an icon should be displayed when the no data message is shown.
+         *
+         * An icon is displayed by default
+         */
+        this.displayNoDataIcon = true;
+        /**
+         * Defines the row height of one row in task content
+         */
+        this.rowHeight = 105;
+        this.trackBySubgridFn = (index, subgrid) => subgrid.subgridId;
+        this.trackByFn = (index, element) => this.trackByDatafields(index, element);
+        this._asyncRenderingConfig = Object.assign({}, this.DEFAULT_ASYNC_RENDERING_CONFIGURATION);
+        if (asyncRenderingConfiguration !== null) {
+            Object.assign(this._asyncRenderingConfig, asyncRenderingConfiguration);
+        }
+        this.loading$ = new LoadingEmitter(true);
+        this._dataSource$ = new BehaviorSubject([]);
+        this.hasDataToDisplay$ = this._dataSource$.pipe(map(data => {
+            return data.length !== 0;
+        }));
+        this._subTaskContent = this.taskContentService.$shouldCreate.subscribe(data => {
+            if (data.length !== 0) {
+                this.computeDefaultLayoutConfiguration();
+                this.computeLayoutData(data);
+            }
+            else {
+                this.renderContent();
+            }
+            this.loading$.off();
+        });
+        if (this._taskEventService !== null) {
+            this.taskEvent = new EventEmitter();
+            this._subTaskEvent = _taskEventService.taskEventNotifications$.subscribe(event => {
+                this.taskEvent.emit(event);
+            });
+        }
+    }
+    ngOnDestroy() {
+        this.loading$.complete();
+        this._dataSource$.complete();
+        this._subTaskContent.unsubscribe();
+        if (this.taskEvent) {
+            this.taskEvent.complete();
+        }
+        if (this._subTaskEvent) {
+            this._subTaskEvent.unsubscribe();
+        }
+        if (this._asyncRenderTimeout !== undefined) {
+            window.clearTimeout(this._asyncRenderTimeout);
+        }
+    }
+    get taskId() {
+        return this.taskContentService.task.stringId;
+    }
+    get dataSource() {
+        return this._dataSource$.getValue();
+    }
+    /**
+     * @returns the number of columns as specified by the tasks layout property, or 4 if no value is specified.
+     */
+    getNumberOfFormColumns() {
+        if (!this.taskContentService.task
+            || !this.taskContentService.task.layout
+            || this.taskContentService.task.layout.cols === undefined) {
+            return 4;
+        }
+        else {
+            return this.taskContentService.task.layout.cols;
+        }
+    }
+    isPaperView() {
+        return this._paperView.paperView;
+    }
+    /**
+     * @param item an object containing grid element information
+     * @returns the Angular flex layouts alignment property for individual data fields based on
+     * the layout configuration specified by the process
+     */
+    getItemAlignment(item) {
+        var _a, _b, _c;
+        if (item.alignment) {
+            return item.alignment;
+        }
+        const fieldAlignment = (_c = (_b = (_a = item.item) === null || _a === void 0 ? void 0 : _a.localLayout) === null || _b === void 0 ? void 0 : _b.alignment) !== null && _c !== void 0 ? _c : this._defaultAlignment;
+        let alignment;
+        switch (fieldAlignment) {
+            case FieldAlignment.TOP:
+                alignment = 'start';
+                break;
+            case FieldAlignment.CENTER:
+                alignment = 'center';
+                break;
+            case FieldAlignment.BOTTOM:
+                alignment = 'end';
+                break;
+        }
+        item.alignment = 'space-between ' + alignment;
+        return item.alignment;
+    }
+    /**
+     * Computes component height if the rows attribute of task layout is set.
+     */
+    resolveContentHeightCss() {
+        if (this.scrollingNeeded()) {
+            return this.taskContentService.task.layout.rows * this.rowHeight + 'px';
+        }
+        else {
+            return '100%';
+        }
+    }
+    /**
+     * Decides whether there is a fixed number of rows and it need-s scrolling
+     */
+    scrollingNeeded() {
+        return this.taskContentService.task
+            && !!this.taskContentService.task.layout
+            && !!this.taskContentService.task.layout.rows
+            && this.taskContentService.task.layout.rows > 0;
+    }
+    /**
+     * @returns the default alignment for the displayed task that can be overridden by fields individual property.
+     * If te task specifies no default value the [global default]{@link AbstractTaskContentComponent#DEFAULT_FIELD_ALIGNMENT}
+     * value is returned.
+     */
+    computeDefaultLayoutConfiguration() {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        this._defaultAlignment = (_c = (_b = (_a = this.taskContentService.task) === null || _a === void 0 ? void 0 : _a.layout) === null || _b === void 0 ? void 0 : _b.fieldAlignment) !== null && _c !== void 0 ? _c : this.DEFAULT_FIELD_ALIGNMENT;
+        this._defaultCompactDirection = (_f = (_e = (_d = this.taskContentService.task) === null || _d === void 0 ? void 0 : _d.layout) === null || _e === void 0 ? void 0 : _e.compactDirection) !== null && _f !== void 0 ? _f : this.DEFAULT_COMPACT_DIRECTION;
+        this._defaultHideEmptyRows = (_j = (_h = (_g = this.taskContentService.task) === null || _g === void 0 ? void 0 : _g.layout) === null || _h === void 0 ? void 0 : _h.hideEmptyRows) !== null && _j !== void 0 ? _j : this.DEFAULT_HIDE_EMPTY_ROWS;
+        this._defaultNumberOfCols = this.getNumberOfFormColumns();
+    }
+    /**
+     * Computes the layout data for the tasks grid layout and sets the result to the public properties
+     * of this class that are then bound to HTML.
+     * @param dataGroups the data groups that should be laid out
+     */
+    computeLayoutData(dataGroups) {
+        if (!this.taskContentService.task) {
+            this.renderContent();
+            return;
+        }
+        this._subgridIdCounter = new IncrementingCounter();
+        this._existingSubgridIds = new Set();
+        const result = new Map();
+        dataGroups = this.preprocessDataGroups(dataGroups);
+        const defaultLayout = this.taskContentService.task.layout && this.taskContentService.task.layout.type
+            ? this.taskContentService.task.layout.type
+            : this.DEFAULT_LAYOUT_TYPE;
+        dataGroups.forEach(group => {
+            var _a;
+            if (!group.layout) {
+                group.layout = { rows: undefined, cols: undefined, type: defaultLayout };
+            }
+            if (!group.layout.type) {
+                group.layout.type = defaultLayout;
+            }
+            const subgrid = new Subgrid(this.createSubgridId(group), (_a = group.layout.cols) !== null && _a !== void 0 ? _a : this._defaultNumberOfCols, this._asyncRenderingConfig);
+            if (group.title !== undefined) {
+                const title = subgrid.addTitle(group);
+                subgrid.addRow(this.newGridRow(subgrid.cols, title.gridAreaId));
+            }
+            switch (group.layout.type) {
+                case DataGroupLayoutType.GRID:
+                    this.computeGridLayout(group, subgrid);
+                    break;
+                case DataGroupLayoutType.FLOW:
+                    this.computeFlowLayout(group, subgrid);
+                    break;
+                case DataGroupLayoutType.LEGACY:
+                    this.computeLegacyLayout(group, subgrid);
+                    break;
+                default:
+                    throw new Error(`Unknown task layout type '${this.taskContentService.task.layout.type}'`);
+            }
+            subgrid.finalize();
+            result.set(subgrid.subgridId, subgrid);
+        });
+        this.renderFields(result);
+    }
+    renderFields(subgrids) {
+        const subgridsArray = Array.from(subgrids.values());
+        if (!this._asyncRenderingConfig.enableAsyncRenderingForNewFields
+            && !(this._asyncRenderingConfig.enableAsyncRenderingOnTaskExpand && this.taskContentService.isExpanding)) {
+            subgridsArray.forEach(subgrid => {
+                subgrid.displayAllFields();
+            });
+            this.renderContent(subgridsArray);
+            return;
+        }
+        if (!(this.taskContentService.isExpanding && this._asyncRenderingConfig.enableAsyncRenderingOnTaskExpand)) {
+            this._dataSource$.value.forEach(oldSubgrid => {
+                if (subgrids.has(oldSubgrid.subgridId)) {
+                    subgrids.get(oldSubgrid.subgridId).determineKeptFields(oldSubgrid);
+                }
+            });
+        }
+        this.renderContent(subgridsArray);
+        this.spreadFieldRenderingOverTime(subgridsArray);
+    }
+    spreadFieldRenderingOverTime(subgrids, iteration = 0) {
+        this._asyncRenderTimeout = undefined;
+        if (iteration < subgrids.length) {
+            this._asyncRenderTimeout = window.setTimeout(() => {
+                subgrids[iteration].renderContentOverTime(() => {
+                    this.spreadFieldRenderingOverTime(subgrids, iteration + 1);
+                }, iteration === 0);
+            });
+        }
+    }
+    /**
+     * Clones the content of the data groups to prevent unintentional memory accesses to source data.
+     * Rearranges the data groups to accommodate taskrefs. Filters out hidden and forbidden fields.
+     * @param dataGroups
+     * @returns the preprocesses data groups
+     */
+    preprocessDataGroups(dataGroups) {
+        dataGroups = this.cloneAndFilterHidden(dataGroups);
+        const result = [];
+        for (let i = 0; i < dataGroups.length; i++) {
+            const group = dataGroups[i];
+            if (!group.fields.some(f => this.isTaskRef(f))) {
+                result.push(group);
+                continue;
+            }
+            const split = this.splitDataGroupOnTaskRef(group);
+            if (split.startGroup !== undefined) {
+                result.push(split.startGroup);
+            }
+            if (split.taskRef.value.length === 0 || split.endGroup === undefined) {
+                if (split.endGroup !== undefined) {
+                    dataGroups.splice(i + 1, 0, split.endGroup);
+                }
+                continue;
+            }
+            const directChild = dataGroups[i + 1]; // the data group that immediately follows IS ALWAYS a direct child
+            let firstNonDescendantIndex = i + 2;
+            for (; firstNonDescendantIndex < dataGroups.length; firstNonDescendantIndex++) {
+                const nextGroup = dataGroups[firstNonDescendantIndex];
+                if (nextGroup.nestingLevel === undefined || nextGroup.nestingLevel < directChild.nestingLevel) {
+                    // end of the block of nested data groups
+                    break;
+                }
+                if (nextGroup.nestingLevel === directChild.nestingLevel
+                    && (nextGroup.parentTaskRefId !== split.taskRef.stringId
+                        || !split.taskRef.value.some(reffedTaskId => reffedTaskId === nextGroup.parentTaskId))) {
+                    break;
+                }
+            }
+            dataGroups.splice(firstNonDescendantIndex, 0, split.endGroup);
+        }
+        return result;
+    }
+    /**
+     * Creates a duplicate of the provided data group array and filters away any fields and data groups that are marked as hidden.
+     * Because of the duplication the filtering doesn't affect the original instances and they remain unchanged.
+     * @param dataGroups the data groups that should be filtered
+     * @returns the filtered duplicated data groups
+     */
+    cloneAndFilterHidden(dataGroups) {
+        const result = dataGroups.map(group => {
+            const g = Object.assign({}, group);
+            g.fields = g.fields.filter(field => !field.behavior.hidden && !field.behavior.forbidden).map(field => {
+                field.resetLocalLayout();
+                return field;
+            });
+            return g;
+        });
+        return result.filter(group => group.fields.length > 0);
+    }
+    isTaskRef(field) {
+        return field instanceof TaskRefField;
+    }
+    /**
+     * Sorts the input data group based on the Y coordinate of the fields and splits it into parts on the first task ref.
+     * If some fields appear before the first task ref they are extracted into a new [startGroup]{@link SplitDataGroup#startGroup}.
+     * If some fields appear after the first task ref they are extracted into a new [endGroup]{@link SplitDataGroup#endGroup}.
+     * @param dataGroup
+     * @protected
+     */
+    splitDataGroupOnTaskRef(dataGroup) {
+        dataGroup.fields.sort((a, b) => a.localLayout.y - b.localLayout.y);
+        const taskRefPosition = dataGroup.fields.findIndex(f => this.isTaskRef(f));
+        const result = {
+            taskRef: dataGroup.fields[taskRefPosition]
+        };
+        if (taskRefPosition !== 0) {
+            result.startGroup = {
+                title: dataGroup.title,
+                alignment: dataGroup.alignment,
+                layout: dataGroup.layout,
+                stretch: dataGroup.stretch,
+                fields: dataGroup.fields.slice(0, taskRefPosition),
+            };
+        }
+        if (taskRefPosition !== dataGroup.fields.length - 1) {
+            result.endGroup = {
+                title: undefined,
+                alignment: dataGroup.alignment,
+                layout: dataGroup.layout,
+                stretch: dataGroup.stretch,
+                fields: dataGroup.fields.slice(taskRefPosition + 1),
+            };
+            result.endGroup.fields.forEach(f => {
+                f.localLayout.y = f.localLayout.y - result.taskRef.localLayout.y - 1;
+            });
+        }
+        return result;
+    }
+    /**
+     * Computes the layout data for a single data group with grid layout. The resulting layout is saved into the input objects.
+     * @param dataGroup the data group that should be laid out into a grid
+     * @param subgrid the object that holds the context of the computed layouting unit
+     */
+    computeGridLayout(dataGroup, subgrid) {
+        const localGrid = [];
+        dataGroup.fields.forEach(dataField => {
+            if (!dataField.localLayout
+                || dataField.localLayout.x === undefined
+                || dataField.localLayout.y === undefined
+                || !dataField.localLayout.rows
+                || !dataField.localLayout.cols) {
+                throw new Error(`You cannot use 'grid' layout without specifying the layout of the data fields (field ID: ${dataField.stringId})`);
+            }
+            while (localGrid.length < dataField.localLayout.y + dataField.localLayout.rows) {
+                localGrid.push(this.newGridRow(subgrid.cols));
+            }
+            const fieldElement = subgrid.addField(dataField, this._fieldConverter.resolveType(dataField));
+            this.occupySpace(localGrid, dataField.localLayout.y, dataField.localLayout.x, dataField.localLayout.cols, fieldElement.gridAreaId, dataField.localLayout.rows);
+        });
+        this.collapseGridEmptySpace(localGrid, dataGroup.layout, subgrid);
+        localGrid.forEach(localGridRow => subgrid.addRow(localGridRow));
+    }
+    /**
+     * Applies the empty row removal and field compacting rules based on the provided layout configuration.
+     *
+     * The input grid is modified in place.
+     * @param grid the state of the grid that should be modified
+     * @param layout configuration of the applied compacting rules
+     * @param subgrid the object that holds the context of the computed layouting unit
+     */
+    collapseGridEmptySpace(grid, layout, subgrid) {
+        var _a, _b;
+        const hideRows = (_a = layout.hideEmptyRows) !== null && _a !== void 0 ? _a : this._defaultHideEmptyRows;
+        if (hideRows === DataGroupHideEmptyRows.ALL) {
+            this.removeEmptyRows(grid);
+        }
+        switch ((_b = layout.compactDirection) !== null && _b !== void 0 ? _b : this._defaultCompactDirection) {
+            case DataGroupCompact.UP:
+                this.compactFieldsUp(grid, hideRows, subgrid);
+                break;
+        }
+    }
+    /**
+     * Moves any element as far UP as it can go. Elements that were originally declared in the same row might end up in different rows.
+     * Resulting trailing empty rows are removed.
+     *
+     * The input grid is modified in place.
+     * @param grid the state of the grid that should be modified
+     * @param hideRows configuration for empty row removal during the compacting process
+     * @param subgrid the object that holds the context of the computed layouting unit
+     */
+    compactFieldsUp(grid, hideRows, subgrid) {
+        for (let rowIndex = 0; rowIndex < grid.length; rowIndex++) {
+            const row = grid[rowIndex];
+            for (let columnIndex = 0; columnIndex < row.length; columnIndex++) {
+                if (row[columnIndex] !== '') {
+                    continue;
+                }
+                let foundElement = false;
+                let foundElementRowIndex = rowIndex + 1;
+                for (; foundElementRowIndex < grid.length; foundElementRowIndex++) {
+                    if (grid[foundElementRowIndex][columnIndex] !== '') {
+                        foundElement = true;
+                        break;
+                    }
+                }
+                if (!foundElement) {
+                    continue;
+                }
+                if (columnIndex > 0 && grid[foundElementRowIndex][columnIndex - 1] === grid[foundElementRowIndex][columnIndex]) {
+                    continue;
+                }
+                const elementDimensions = this.getElementDimensions(grid, columnIndex, foundElementRowIndex, subgrid);
+                if (this.isAreaEmpty(grid, columnIndex, rowIndex, elementDimensions.width, foundElementRowIndex - rowIndex)) {
+                    const element = grid[foundElementRowIndex][columnIndex];
+                    this.occupySpace(grid, foundElementRowIndex, columnIndex, elementDimensions.width, '', elementDimensions.height, false);
+                    this.occupySpace(grid, rowIndex, columnIndex, elementDimensions.width, element, elementDimensions.height, false);
+                    if (hideRows !== DataGroupHideEmptyRows.NONE) {
+                        // we only check the rows potentially cleared by moving the grid element up
+                        this.removeEmptyRows(grid, foundElementRowIndex, foundElementRowIndex + elementDimensions.height);
+                    }
+                }
+            }
+        }
+    }
+    /**
+     * Removes rows from the grid that only contain empty elements (are empty). The grid is modified in place.
+     * @param grid the grid that should have it's empty rows removed
+     * @param firstRow the 0 based index of the first row that should be checked. Use 0 to start from the beginning of the grid.
+     *
+     * If no value is provided, the grid will be checked from the first row.
+     *
+     * @param lastRow the 0 based index of the row where the checking should end. The row with this index is not checked.
+     *
+     * If no value is provided the entire grid from the `firstRow` will be checked.
+     *
+     * If a value that is smaller or equal to the `firstRow` is provided no checks will be preformed.
+     */
+    removeEmptyRows(grid, firstRow = 0, lastRow = Number.POSITIVE_INFINITY) {
+        let i = firstRow;
+        while (i < grid.length && i < lastRow) {
+            if (grid[i].every(element => element === '')) {
+                grid.splice(i, 1);
+            }
+            else {
+                i++;
+            }
+        }
+    }
+    /**
+     * Determines the dimensions of the element in the grid with its top-left corner at the specified position
+     * @param grid the grid of elements
+     * @param x the X coordinate of the desired elements top-left corner
+     * @param y the Y coordinate of the desired elements top-left corner
+     * @param subgrid the object that holds the context of the computed layouting unit
+     * @returns the width and height of the specified element
+     */
+    getElementDimensions(grid, x, y, subgrid) {
+        const element = grid[y][x];
+        let width = 1;
+        while (x + width < subgrid.cols && grid[y][x + width] === element) {
+            width++;
+        }
+        let height = 1;
+        while (y + height < grid.length && grid[y + height][x] === element) {
+            height++;
+        }
+        return { width, height };
+    }
+    /**
+     * Determines whether the specified area in the grid contains no elements, or not
+     * @param grid the grid of elements
+     * @param x the X coordinate of the tested areas top-left corner
+     * @param y the Y coordinate of the tested areas top-left corner
+     * @param width the width of the tested area
+     * @param height the height of the tested area
+     */
+    isAreaEmpty(grid, x, y, width, height) {
+        for (let i = y; i < y + height; i++) {
+            for (let j = x; j < x + width; j++) {
+                if (grid[i][j] !== '') {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+    /**
+     * Computes the layout data for a single data group with flow layout. The resulting layout is saved into the input objects.
+     * @param dataGroup the data group that should be laid out into a grid using the flow algorithm
+     * @param subgrid the object that holds the context of the computed layouting unit
+     */
+    computeFlowLayout(dataGroup, subgrid) {
+        this.flowFields(dataGroup, subgrid, 1);
+    }
+    /**
+     * Computes the layout data for a single data group with legacy layout. The resulting layout is saved into the input objects.
+     *
+     * The legacy layout forces the number of columns to be 4 and logs a warning if this was not the case.
+     * @param dataGroup the data group that should be laid out into a grid using the legacy algorithm used in NAE versions < 4.0.0
+     * @param subgrid the object that holds the context of the computed layouting unit
+     */
+    computeLegacyLayout(dataGroup, subgrid) {
+        if (subgrid.cols !== 4) {
+            subgrid.cols = 4;
+            this._logger.warn(`Task with id '${this.taskContentService.task.stringId}' has a data group with legacy layout with a `
+                + `non-default number of columns. If you want to use a layout with different number of columns than 2 use a different `
+                + `layout type instead.`);
+        }
+        this.flowFields(dataGroup, subgrid, 2);
+    }
+    /**
+     * Lays out the fields from left to right, from top to bottom. If the width is greater than 1 and the block of flowed fields doesn't fit
+     * neatly into the columns (if the width of a single field is not a divisor of column count), then the entire block of fields is
+     * left aligned. The last row of fields is aligned to the left, center or right based on the data groups property.
+     * If the last row cannot be aligned to the exact center it is offset one grid tile to the left.
+     * @param dataGroup the data group that should be laid out into a grid
+     * @param subgrid the object that holds the context of the computed layouting unit
+     * @param fieldWidth the number of grid tiles, that should be occupied by each field
+     */
+    flowFields(dataGroup, subgrid, fieldWidth) {
+        const fieldsPerRow = Math.floor(subgrid.cols / fieldWidth);
+        const maxXPosition = fieldWidth * (fieldsPerRow - 1);
+        let xPosition = 0;
+        const localGrid = [];
+        dataGroup.fields.forEach((dataField, dataFieldCount) => {
+            const fieldElement = subgrid.addField(dataField, this._fieldConverter.resolveType(dataField));
+            if (dataGroup.stretch) {
+                subgrid.addRow(this.newGridRow(subgrid.cols, fieldElement.gridAreaId));
+                return; // continue
+            }
+            // else
+            if (xPosition === 0) {
+                localGrid.push(this.newGridRow(subgrid.cols));
+            }
+            if (xPosition === 0 && this.isLastRow(dataFieldCount, dataGroup, fieldsPerRow)) {
+                const fieldsInLastRow = dataGroup.fields.length % fieldsPerRow;
+                const rowWidth = maxXPosition + fieldWidth;
+                if (dataGroup.alignment === DataGroupAlignment.END) {
+                    xPosition = rowWidth - fieldWidth * fieldsInLastRow;
+                }
+                else if (dataGroup.alignment === DataGroupAlignment.CENTER) {
+                    xPosition = Math.floor((rowWidth - fieldsInLastRow * fieldWidth) / 2);
+                }
+            }
+            this.occupySpace(localGrid, localGrid.length - 1, xPosition, fieldWidth, fieldElement.gridAreaId);
+            xPosition += fieldWidth;
+            if (xPosition > maxXPosition) {
+                xPosition = 0;
+            }
+        });
+        localGrid.forEach(row => subgrid.addRow(row));
+    }
+    /**
+     * @param width width of the row
+     * @param content the value that should be used to fill all elements in the row
+     */
+    newGridRow(width, content = '') {
+        return Array(width).fill(content);
+    }
+    /**
+     * Fills the specified rectangular area with the specified value in the provided grid.
+     *
+     * If the specified area contains values other than the empty string an error will be thrown.
+     * @param grid the grid that should be modified
+     * @param y the 0 based row index of the top-left corner of the filled area
+     * @param x the 0 based column index of the top-left corner of the filled area
+     * @param width the width of the filled area
+     * @param value the value that is set into every cell of the grid inside the specified area
+     * @param height the height of the filled area
+     * @param checkOccupants whether the filled area should be checked for other elements.
+     * If a check is performed an error will be thrown if elements are found.
+     */
+    occupySpace(grid, y, x, width, value, height = 1, checkOccupants = true) {
+        for (let j = y; j < y + height; j++) {
+            for (let i = x; i < x + width; i++) {
+                if (checkOccupants && grid[j][i] !== '') {
+                    throw new Error(`Cannot place element ${value} into the grid layout, because it's space (x: ${i}, y: ${j})` +
+                        ` is already occupied by another element (${grid[j][i]})`);
+                }
+                grid[j][i] = value;
+            }
+        }
+    }
+    /**
+     * @param index the index of the checked element within its data group
+     * @param dataGroup the checked data group
+     * @param fieldsPerRow the number of fields that is required to fill an entire row
+     * @returns whether the field at the given index is within the last row of elements of the provided data group.
+     * Note that if the last row contains enough elements to be completely filled this method returns `false`.
+     */
+    isLastRow(index, dataGroup, fieldsPerRow) {
+        return index + fieldsPerRow >= dataGroup.fields.length;
+    }
+    /**
+     * Destroys the previous content and pushes the new content into the stream
+     * @param content the new content
+     */
+    renderContent(content = []) {
+        this._dataSource$.value.forEach(subgrid => subgrid.destroy());
+        this._dataSource$.next(content);
+    }
+    createSubgridId(dataGroup) {
+        let idBase;
+        if (dataGroup.parentTaskId !== undefined) {
+            idBase = [dataGroup.parentTaskId, dataGroup.parentTaskRefId, dataGroup.nestingLevel].join('#');
+        }
+        else {
+            idBase = 'root';
+        }
+        let id = idBase;
+        while (this._existingSubgridIds.has(id)) {
+            id = idBase + this._subgridIdCounter.next();
+        }
+        this._existingSubgridIds.add(id);
+        return id;
+    }
+    trackByDatafields(index, element) {
+        switch (element.type) {
+            case TaskElementType.BLANK:
+                return element.gridAreaId + '-' + this.taskContentService.$shouldCreateCounter.getValue();
+            case TaskElementType.LOADER:
+                return element.gridAreaId + '-L-' + this.taskContentService.$shouldCreateCounter.getValue();
+            case TaskElementType.DATA_GROUP_TITLE:
+                return element.title + '-' + this.taskContentService.$shouldCreateCounter.getValue();
+            default:
+                return element.item.stringId + '-' + this.taskContentService.$shouldCreateCounter.getValue();
+        }
+    }
+}
+AbstractTaskContentComponent.ctorParameters = () => [
+    { type: FieldConverterService },
+    { type: TaskContentService },
+    { type: PaperViewService },
+    { type: LoggerService },
+    { type: TaskEventService, decorators: [{ type: Optional }] },
+    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [NAE_ASYNC_RENDERING_CONFIGURATION,] }] }
+];
+AbstractTaskContentComponent.propDecorators = {
+    noDataText: [{ type: Input }],
+    noDataIcon: [{ type: Input }],
+    displayNoDataIcon: [{ type: Input }],
+    taskEvent: [{ type: Output }]
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"abstract-task-content.component.js","sourceRoot":"ng://@netgrif/components-core/","sources":["lib/task-content/task-content/abstract-task-content.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {EventEmitter, Inject, Input, OnDestroy, Optional, Output} from '@angular/core';\nimport {DatafieldGridLayoutElement} from '../model/datafield-grid-layout-element';\nimport {FieldConverterService} from '../services/field-converter.service';\nimport {TaskContentService} from '../services/task-content.service';\nimport {PaperViewService} from '../../navigation/quick-panel/components/paper-view.service';\nimport {LoggerService} from '../../logger/services/logger.service';\nimport {TaskEventNotification} from '../model/task-event-notification';\nimport {TaskEventService} from '../services/task-event.service';\nimport {DataGroup, DataGroupAlignment} from '../../resources/interface/data-groups';\nimport {TaskElementType} from '../model/task-content-element-type';\nimport {DataField} from '../../data-fields/models/abstract-data-field';\nimport {DataGroupCompact, DataGroupHideEmptyRows, DataGroupLayout, DataGroupLayoutType} from '../../resources/interface/data-group-layout';\nimport {FieldAlignment} from '../../resources/interface/field-alignment';\nimport {FieldTypeResource} from '../model/field-type-resource';\nimport {LoadingEmitter} from '../../utility/loading-emitter';\nimport {BehaviorSubject, Observable, Subscription} from 'rxjs';\nimport {map} from 'rxjs/operators';\nimport {NAE_ASYNC_RENDERING_CONFIGURATION} from '../model/async-rendering-configuration-injection-token';\nimport {AsyncRenderingConfiguration} from '../model/async-rendering-configuration';\nimport {TaskRefField} from '../../data-fields/task-ref-field/model/task-ref-field';\nimport {SplitDataGroup} from '../model/split-data-group';\nimport {Subgrid} from '../model/subgrid';\nimport {IncrementingCounter} from '../../utility/incrementing-counter';\n\nexport abstract class AbstractTaskContentComponent implements OnDestroy {\n    readonly DEFAULT_LAYOUT_TYPE = DataGroupLayoutType.LEGACY;\n    readonly DEFAULT_FIELD_ALIGNMENT = FieldAlignment.CENTER;\n    readonly DEFAULT_ASYNC_RENDERING_CONFIGURATION: AsyncRenderingConfiguration = {\n        batchSize: 4,\n        batchDelay: 200,\n        numberOfPlaceholders: 4,\n        enableAsyncRenderingForNewFields: true,\n        enableAsyncRenderingOnTaskExpand: true\n    };\n    readonly DEFAULT_COMPACT_DIRECTION = DataGroupCompact.NONE;\n    readonly DEFAULT_HIDE_EMPTY_ROWS = DataGroupHideEmptyRows.ALL;\n\n    /**\n     * Indicates whether data is being loaded from backend, or if it is being processed.\n     */\n    loading$: LoadingEmitter;\n    /**\n     * Emits `true` if there is at least one data field, that should be displayed. Emits `false` otherwise.\n     */\n    hasDataToDisplay$: Observable<boolean>;\n\n    /**\n     * Exists to allow references to the enum in the HTML\n     */\n    public fieldTypeResource = FieldTypeResource;\n\n    /**\n     * The translate text that should be displayed when the task contains no data.\n     *\n     * If a falsy value is provided the default text is displayed\n     */\n    @Input() noDataText: string;\n    /**\n     * The icon that should be displayed when the task contains no data.\n     *\n     * If a falsy value is provided the default icon is displayed\n     */\n    @Input() noDataIcon: string;\n    /**\n     * Whether an icon should be displayed when the no data message is shown.\n     *\n     * An icon is displayed by default\n     */\n    @Input() displayNoDataIcon = true;\n    /**\n     * Emits notifications about task events\n     */\n    @Output() taskEvent: EventEmitter<TaskEventNotification>;\n    /**\n     * The data fields that are currently displayed\n     */\n    protected _dataSource$: BehaviorSubject<Array<Subgrid>>;\n    protected _subTaskContent: Subscription;\n    protected _subTaskEvent: Subscription;\n    protected _asyncRenderingConfig: AsyncRenderingConfiguration;\n    protected _asyncRenderTimeout: number;\n\n    protected _defaultAlignment: FieldAlignment;\n    protected _defaultCompactDirection: DataGroupCompact;\n    protected _defaultHideEmptyRows: DataGroupHideEmptyRows;\n    protected _defaultNumberOfCols: number;\n\n    protected _subgridIdCounter: IncrementingCounter;\n    protected _existingSubgridIds: Set<string>;\n\n    /**\n     * Defines the row height of one row in task content\n     */\n    protected rowHeight = 105;\n\n    protected constructor(protected _fieldConverter: FieldConverterService,\n                          public taskContentService: TaskContentService,\n                          protected _paperView: PaperViewService,\n                          protected _logger: LoggerService,\n                          @Optional() protected _taskEventService: TaskEventService = null,\n                          @Optional() @Inject(NAE_ASYNC_RENDERING_CONFIGURATION)\n                              asyncRenderingConfiguration: AsyncRenderingConfiguration = null) {\n        this._asyncRenderingConfig = {...this.DEFAULT_ASYNC_RENDERING_CONFIGURATION};\n        if (asyncRenderingConfiguration !== null) {\n            Object.assign(this._asyncRenderingConfig, asyncRenderingConfiguration);\n        }\n\n        this.loading$ = new LoadingEmitter(true);\n        this._dataSource$ = new BehaviorSubject<Array<Subgrid>>([]);\n        this.hasDataToDisplay$ = this._dataSource$.pipe(map(data => {\n            return data.length !== 0;\n        }));\n\n        this._subTaskContent = this.taskContentService.$shouldCreate.subscribe(data => {\n            if (data.length !== 0) {\n                this.computeDefaultLayoutConfiguration();\n                this.computeLayoutData(data);\n            } else {\n                this.renderContent();\n            }\n            this.loading$.off();\n        });\n        if (this._taskEventService !== null) {\n            this.taskEvent = new EventEmitter<TaskEventNotification>();\n            this._subTaskEvent = _taskEventService.taskEventNotifications$.subscribe(event => {\n                this.taskEvent.emit(event);\n            });\n        }\n    }\n\n    ngOnDestroy(): void {\n        this.loading$.complete();\n        this._dataSource$.complete();\n        this._subTaskContent.unsubscribe();\n        if (this.taskEvent) {\n            this.taskEvent.complete();\n        }\n        if (this._subTaskEvent) {\n            this._subTaskEvent.unsubscribe();\n        }\n        if (this._asyncRenderTimeout !== undefined) {\n            window.clearTimeout(this._asyncRenderTimeout);\n        }\n    }\n\n    public get taskId(): string {\n        return this.taskContentService.task.stringId;\n    }\n\n    public get dataSource(): Array<Subgrid> {\n        return this._dataSource$.getValue();\n    }\n\n    /**\n     * @returns the number of columns as specified by the tasks layout property, or 4 if no value is specified.\n     */\n    public getNumberOfFormColumns(): number {\n        if (!this.taskContentService.task\n            || !this.taskContentService.task.layout\n            || this.taskContentService.task.layout.cols === undefined) {\n            return 4;\n        } else {\n            return this.taskContentService.task.layout.cols;\n        }\n    }\n\n    public isPaperView() {\n        return this._paperView.paperView;\n    }\n\n    /**\n     * @param item an object containing grid element information\n     * @returns the Angular flex layouts alignment property for individual data fields based on\n     * the layout configuration specified by the process\n     */\n    public getItemAlignment(item: DatafieldGridLayoutElement): string {\n        if (item.alignment) {\n            return item.alignment;\n        }\n\n        const fieldAlignment = item.item?.localLayout?.alignment ?? this._defaultAlignment;\n\n        let alignment;\n        switch (fieldAlignment) {\n            case FieldAlignment.TOP:\n                alignment = 'start';\n                break;\n            case FieldAlignment.CENTER:\n                alignment = 'center';\n                break;\n            case FieldAlignment.BOTTOM:\n                alignment = 'end';\n                break;\n        }\n\n        item.alignment = 'space-between ' + alignment;\n        return item.alignment;\n    }\n\n    /**\n     * Computes component height if the rows attribute of task layout is set.\n     */\n    public resolveContentHeightCss(): string {\n        if (this.scrollingNeeded()) {\n            return this.taskContentService.task.layout.rows * this.rowHeight + 'px';\n        } else {\n            return '100%';\n        }\n    }\n\n    /**\n     * Decides whether there is a fixed number of rows and it need-s scrolling\n     */\n    public scrollingNeeded(): boolean {\n        return this.taskContentService.task\n            && !!this.taskContentService.task.layout\n            && !!this.taskContentService.task.layout.rows\n            && this.taskContentService.task.layout.rows > 0;\n    }\n\n    /**\n     * @returns the default alignment for the displayed task that can be overridden by fields individual property.\n     * If te task specifies no default value the [global default]{@link AbstractTaskContentComponent#DEFAULT_FIELD_ALIGNMENT}\n     * value is returned.\n     */\n    protected computeDefaultLayoutConfiguration() {\n        this._defaultAlignment = this.taskContentService.task?.layout?.fieldAlignment ?? this.DEFAULT_FIELD_ALIGNMENT;\n        this._defaultCompactDirection = this.taskContentService.task?.layout?.compactDirection ?? this.DEFAULT_COMPACT_DIRECTION;\n        this._defaultHideEmptyRows = this.taskContentService.task?.layout?.hideEmptyRows ?? this.DEFAULT_HIDE_EMPTY_ROWS;\n        this._defaultNumberOfCols = this.getNumberOfFormColumns();\n    }\n\n    /**\n     * Computes the layout data for the tasks grid layout and sets the result to the public properties\n     * of this class that are then bound to HTML.\n     * @param dataGroups the data groups that should be laid out\n     */\n    public computeLayoutData(dataGroups: Array<DataGroup>) {\n        if (!this.taskContentService.task) {\n            this.renderContent();\n            return;\n        }\n\n        this._subgridIdCounter = new IncrementingCounter();\n        this._existingSubgridIds = new Set<string>();\n\n        const result = new Map<string, Subgrid>();\n\n        dataGroups = this.preprocessDataGroups(dataGroups);\n\n        const defaultLayout = this.taskContentService.task.layout && this.taskContentService.task.layout.type\n            ? this.taskContentService.task.layout.type\n            : this.DEFAULT_LAYOUT_TYPE;\n\n        dataGroups.forEach(group => {\n            if (!group.layout) {\n                group.layout = {rows: undefined, cols: undefined, type: defaultLayout};\n            }\n            if (!group.layout.type) {\n                group.layout.type = defaultLayout;\n            }\n\n            const subgrid = new Subgrid(\n                this.createSubgridId(group),\n                group.layout.cols ?? this._defaultNumberOfCols,\n                this._asyncRenderingConfig\n            );\n\n            if (group.title !== undefined) {\n                const title = subgrid.addTitle(group);\n                subgrid.addRow(this.newGridRow(subgrid.cols, title.gridAreaId));\n            }\n\n            switch (group.layout.type) {\n                case DataGroupLayoutType.GRID:\n                    this.computeGridLayout(group, subgrid);\n                    break;\n                case DataGroupLayoutType.FLOW:\n                    this.computeFlowLayout(group, subgrid);\n                    break;\n                case DataGroupLayoutType.LEGACY:\n                    this.computeLegacyLayout(group, subgrid);\n                    break;\n                default:\n                    throw new Error(`Unknown task layout type '${this.taskContentService.task.layout.type}'`);\n            }\n\n            subgrid.finalize();\n            result.set(subgrid.subgridId, subgrid);\n        });\n\n        this.renderFields(result);\n    }\n\n    protected renderFields(subgrids: Map<string, Subgrid>) {\n        const subgridsArray = Array.from(subgrids.values());\n\n        if (!this._asyncRenderingConfig.enableAsyncRenderingForNewFields\n            && !(this._asyncRenderingConfig.enableAsyncRenderingOnTaskExpand && this.taskContentService.isExpanding)) {\n            subgridsArray.forEach(subgrid => {\n                subgrid.displayAllFields();\n            });\n            this.renderContent(subgridsArray);\n            return;\n        }\n\n        if (!(this.taskContentService.isExpanding && this._asyncRenderingConfig.enableAsyncRenderingOnTaskExpand)) {\n            this._dataSource$.value.forEach(oldSubgrid => {\n                if (subgrids.has(oldSubgrid.subgridId)) {\n                    subgrids.get(oldSubgrid.subgridId).determineKeptFields(oldSubgrid);\n                }\n            });\n        }\n\n        this.renderContent(subgridsArray);\n        this.spreadFieldRenderingOverTime(subgridsArray);\n    }\n\n    protected spreadFieldRenderingOverTime(subgrids: Array<Subgrid>, iteration = 0) {\n        this._asyncRenderTimeout = undefined;\n        if (iteration < subgrids.length) {\n            this._asyncRenderTimeout = window.setTimeout(() => {\n                subgrids[iteration].renderContentOverTime(() => {\n                    this.spreadFieldRenderingOverTime(subgrids, iteration + 1);\n                }, iteration === 0);\n            });\n        }\n    }\n\n    /**\n     * Clones the content of the data groups to prevent unintentional memory accesses to source data.\n     * Rearranges the data groups to accommodate taskrefs. Filters out hidden and forbidden fields.\n     * @param dataGroups\n     * @returns the preprocesses data groups\n     */\n    protected preprocessDataGroups(dataGroups: Array<DataGroup>): Array<DataGroup> {\n        dataGroups = this.cloneAndFilterHidden(dataGroups);\n\n        const result = [];\n        for (let i = 0; i < dataGroups.length; i++) {\n            const group = dataGroups[i];\n            if (!group.fields.some(f => this.isTaskRef(f))) {\n                result.push(group);\n                continue;\n            }\n            const split = this.splitDataGroupOnTaskRef(group);\n            if (split.startGroup !== undefined) {\n                result.push(split.startGroup);\n            }\n\n            if (split.taskRef.value.length === 0 || split.endGroup === undefined) {\n                if (split.endGroup !== undefined) {\n                    dataGroups.splice(i + 1, 0, split.endGroup);\n                }\n                continue;\n            }\n\n            const directChild = dataGroups[i + 1]; // the data group that immediately follows IS ALWAYS a direct child\n            let firstNonDescendantIndex = i + 2;\n            for (; firstNonDescendantIndex < dataGroups.length; firstNonDescendantIndex++) {\n                const nextGroup = dataGroups[firstNonDescendantIndex];\n                if (nextGroup.nestingLevel === undefined || nextGroup.nestingLevel < directChild.nestingLevel) {\n                    // end of the block of nested data groups\n                    break;\n                }\n                if (nextGroup.nestingLevel === directChild.nestingLevel\n                    && (nextGroup.parentTaskRefId !== split.taskRef.stringId\n                        || !split.taskRef.value.some(reffedTaskId => reffedTaskId === nextGroup.parentTaskId))) {\n                    break;\n                }\n            }\n\n            dataGroups.splice(firstNonDescendantIndex, 0, split.endGroup);\n        }\n\n        return result;\n    }\n\n    /**\n     * Creates a duplicate of the provided data group array and filters away any fields and data groups that are marked as hidden.\n     * Because of the duplication the filtering doesn't affect the original instances and they remain unchanged.\n     * @param dataGroups the data groups that should be filtered\n     * @returns the filtered duplicated data groups\n     */\n    protected cloneAndFilterHidden(dataGroups: Array<DataGroup>): Array<DataGroup> {\n        const result = dataGroups.map(group => {\n            const g = {...group};\n            g.fields = g.fields.filter(field => !field.behavior.hidden && !field.behavior.forbidden).map(field => {\n                field.resetLocalLayout();\n                return field;\n            });\n            return g;\n        });\n\n        return result.filter(group => group.fields.length > 0);\n    }\n\n    protected isTaskRef(field: DataField<unknown>): boolean {\n        return field instanceof TaskRefField;\n    }\n\n    /**\n     * Sorts the input data group based on the Y coordinate of the fields and splits it into parts on the first task ref.\n     * If some fields appear before the first task ref they are extracted into a new [startGroup]{@link SplitDataGroup#startGroup}.\n     * If some fields appear after the first task ref they are extracted into a new [endGroup]{@link SplitDataGroup#endGroup}.\n     * @param dataGroup\n     * @protected\n     */\n    protected splitDataGroupOnTaskRef(dataGroup: DataGroup): SplitDataGroup {\n        dataGroup.fields.sort((a, b) => a.localLayout.y - b.localLayout.y);\n        const taskRefPosition = dataGroup.fields.findIndex(f => this.isTaskRef(f));\n        const result: SplitDataGroup = {\n            taskRef: dataGroup.fields[taskRefPosition]\n        };\n\n        if (taskRefPosition !== 0) {\n            result.startGroup = {\n                title: dataGroup.title,\n                alignment: dataGroup.alignment,\n                layout: dataGroup.layout,\n                stretch: dataGroup.stretch,\n                fields: dataGroup.fields.slice(0, taskRefPosition),\n            };\n        }\n\n        if (taskRefPosition !== dataGroup.fields.length - 1) {\n            result.endGroup = {\n                title: undefined,\n                alignment: dataGroup.alignment,\n                layout: dataGroup.layout,\n                stretch: dataGroup.stretch,\n                fields: dataGroup.fields.slice(taskRefPosition + 1),\n            };\n            result.endGroup.fields.forEach(f => {\n                f.localLayout.y = f.localLayout.y - result.taskRef.localLayout.y - 1;\n            });\n        }\n\n        return result;\n    }\n\n    /**\n     * Computes the layout data for a single data group with grid layout. The resulting layout is saved into the input objects.\n     * @param dataGroup the data group that should be laid out into a grid\n     * @param subgrid the object that holds the context of the computed layouting unit\n     */\n    protected computeGridLayout(dataGroup: DataGroup, subgrid: Subgrid) {\n        const localGrid: Array<Array<string>> = [];\n\n        dataGroup.fields.forEach(dataField => {\n            if (!dataField.localLayout\n                || dataField.localLayout.x === undefined\n                || dataField.localLayout.y === undefined\n                || !dataField.localLayout.rows\n                || !dataField.localLayout.cols) {\n                throw new Error(\n                    `You cannot use 'grid' layout without specifying the layout of the data fields (field ID: ${dataField.stringId})`);\n            }\n\n            while (localGrid.length < dataField.localLayout.y + dataField.localLayout.rows) {\n                localGrid.push(this.newGridRow(subgrid.cols));\n            }\n\n            const fieldElement = subgrid.addField(dataField, this._fieldConverter.resolveType(dataField));\n            this.occupySpace(localGrid, dataField.localLayout.y, dataField.localLayout.x,\n                dataField.localLayout.cols, fieldElement.gridAreaId, dataField.localLayout.rows);\n        });\n\n        this.collapseGridEmptySpace(localGrid, dataGroup.layout, subgrid);\n\n        localGrid.forEach(localGridRow => subgrid.addRow(localGridRow));\n    }\n\n    /**\n     * Applies the empty row removal and field compacting rules based on the provided layout configuration.\n     *\n     * The input grid is modified in place.\n     * @param grid the state of the grid that should be modified\n     * @param layout configuration of the applied compacting rules\n     * @param subgrid the object that holds the context of the computed layouting unit\n     */\n    protected collapseGridEmptySpace(grid: Array<Array<string>>, layout: DataGroupLayout, subgrid: Subgrid) {\n        const hideRows = layout.hideEmptyRows ?? this._defaultHideEmptyRows;\n\n        if (hideRows === DataGroupHideEmptyRows.ALL) {\n            this.removeEmptyRows(grid);\n        }\n\n        switch (layout.compactDirection ?? this._defaultCompactDirection) {\n            case DataGroupCompact.UP:\n                this.compactFieldsUp(grid, hideRows, subgrid);\n                break;\n        }\n    }\n\n    /**\n     * Moves any element as far UP as it can go. Elements that were originally declared in the same row might end up in different rows.\n     * Resulting trailing empty rows are removed.\n     *\n     * The input grid is modified in place.\n     * @param grid the state of the grid that should be modified\n     * @param hideRows configuration for empty row removal during the compacting process\n     * @param subgrid the object that holds the context of the computed layouting unit\n     */\n    protected compactFieldsUp(grid: Array<Array<string>>, hideRows: DataGroupHideEmptyRows, subgrid: Subgrid) {\n        for (let rowIndex = 0; rowIndex < grid.length; rowIndex++) {\n            const row = grid[rowIndex];\n\n            for (let columnIndex = 0; columnIndex < row.length; columnIndex++) {\n                if (row[columnIndex] !== '') {\n                    continue;\n                }\n\n                let foundElement = false;\n                let foundElementRowIndex = rowIndex + 1;\n                for (; foundElementRowIndex < grid.length; foundElementRowIndex++) {\n                    if (grid[foundElementRowIndex][columnIndex] !== '') {\n                        foundElement = true;\n                        break;\n                    }\n                }\n                if (!foundElement) {\n                    continue;\n                }\n\n                if (columnIndex > 0 && grid[foundElementRowIndex][columnIndex - 1] === grid[foundElementRowIndex][columnIndex]) {\n                    continue;\n                }\n\n                const elementDimensions = this.getElementDimensions(grid, columnIndex, foundElementRowIndex, subgrid);\n\n                if (this.isAreaEmpty(grid, columnIndex, rowIndex, elementDimensions.width, foundElementRowIndex - rowIndex)) {\n                    const element = grid[foundElementRowIndex][columnIndex];\n                    this.occupySpace(grid, foundElementRowIndex, columnIndex, elementDimensions.width, '', elementDimensions.height, false);\n                    this.occupySpace(grid, rowIndex, columnIndex, elementDimensions.width, element, elementDimensions.height, false);\n\n                    if (hideRows !== DataGroupHideEmptyRows.NONE) {\n                        // we only check the rows potentially cleared by moving the grid element up\n                        this.removeEmptyRows(grid, foundElementRowIndex, foundElementRowIndex + elementDimensions.height);\n                    }\n                }\n            }\n        }\n    }\n\n    /**\n     * Removes rows from the grid that only contain empty elements (are empty). The grid is modified in place.\n     * @param grid the grid that should have it's empty rows removed\n     * @param firstRow the 0 based index of the first row that should be checked. Use 0 to start from the beginning of the grid.\n     *\n     * If no value is provided, the grid will be checked from the first row.\n     *\n     * @param lastRow the 0 based index of the row where the checking should end. The row with this index is not checked.\n     *\n     * If no value is provided the entire grid from the `firstRow` will be checked.\n     *\n     * If a value that is smaller or equal to the `firstRow` is provided no checks will be preformed.\n     */\n    protected removeEmptyRows(grid: Array<Array<string>>, firstRow = 0, lastRow = Number.POSITIVE_INFINITY) {\n        let i = firstRow;\n        while (i < grid.length && i < lastRow) {\n            if (grid[i].every(element => element === '')) {\n                grid.splice(i, 1);\n            } else {\n                i++;\n            }\n        }\n    }\n\n    /**\n     * Determines the dimensions of the element in the grid with its top-left corner at the specified position\n     * @param grid the grid of elements\n     * @param x the X coordinate of the desired elements top-left corner\n     * @param y the Y coordinate of the desired elements top-left corner\n     * @param subgrid the object that holds the context of the computed layouting unit\n     * @returns the width and height of the specified element\n     */\n    protected getElementDimensions(grid: Array<Array<string>>, x: number, y: number, subgrid: Subgrid): { width: number, height: number } {\n        const element = grid[y][x];\n        let width = 1;\n        while (x + width < subgrid.cols && grid[y][x + width] === element) {\n            width++;\n        }\n        let height = 1;\n        while (y + height < grid.length && grid[y + height][x] === element) {\n            height++;\n        }\n        return {width, height};\n    }\n\n    /**\n     * Determines whether the specified area in the grid contains no elements, or not\n     * @param grid the grid of elements\n     * @param x the X coordinate of the tested areas top-left corner\n     * @param y the Y coordinate of the tested areas top-left corner\n     * @param width the width of the tested area\n     * @param height the height of the tested area\n     */\n    protected isAreaEmpty(grid: Array<Array<string>>, x: number, y: number, width: number, height: number): boolean {\n        for (let i = y; i < y + height; i++) {\n            for (let j = x; j < x + width; j++) {\n                if (grid[i][j] !== '') {\n                    return false;\n                }\n            }\n        }\n        return true;\n    }\n\n    /**\n     * Computes the layout data for a single data group with flow layout. The resulting layout is saved into the input objects.\n     * @param dataGroup the data group that should be laid out into a grid using the flow algorithm\n     * @param subgrid the object that holds the context of the computed layouting unit\n     */\n    protected computeFlowLayout(dataGroup: DataGroup, subgrid: Subgrid) {\n        this.flowFields(dataGroup, subgrid, 1);\n    }\n\n    /**\n     * Computes the layout data for a single data group with legacy layout. The resulting layout is saved into the input objects.\n     *\n     * The legacy layout forces the number of columns to be 4 and logs a warning if this was not the case.\n     * @param dataGroup the data group that should be laid out into a grid using the legacy algorithm used in NAE versions < 4.0.0\n     * @param subgrid the object that holds the context of the computed layouting unit\n     */\n    protected computeLegacyLayout(dataGroup: DataGroup, subgrid: Subgrid) {\n        if (subgrid.cols !== 4) {\n            subgrid.cols = 4;\n            this._logger.warn(`Task with id '${this.taskContentService.task.stringId}' has a data group with legacy layout with a `\n                + `non-default number of columns. If you want to use a layout with different number of columns than 2 use a different `\n                + `layout type instead.`);\n        }\n\n        this.flowFields(dataGroup, subgrid, 2);\n    }\n\n    /**\n     * Lays out the fields from left to right, from top to bottom. If the width is greater than 1 and the block of flowed fields doesn't fit\n     * neatly into the columns (if the width of a single field is not a divisor of column count), then the entire block of fields is\n     * left aligned. The last row of fields is aligned to the left, center or right based on the data groups property.\n     * If the last row cannot be aligned to the exact center it is offset one grid tile to the left.\n     * @param dataGroup the data group that should be laid out into a grid\n     * @param subgrid the object that holds the context of the computed layouting unit\n     * @param fieldWidth the number of grid tiles, that should be occupied by each field\n     */\n    protected flowFields(dataGroup: DataGroup, subgrid: Subgrid, fieldWidth: number) {\n        const fieldsPerRow = Math.floor(subgrid.cols / fieldWidth);\n        const maxXPosition = fieldWidth * (fieldsPerRow - 1);\n\n        let xPosition = 0;\n        const localGrid: Array<Array<string>> = [];\n        dataGroup.fields.forEach((dataField, dataFieldCount) => {\n            const fieldElement = subgrid.addField(dataField, this._fieldConverter.resolveType(dataField));\n            if (dataGroup.stretch) {\n                subgrid.addRow(this.newGridRow(subgrid.cols, fieldElement.gridAreaId));\n                return; // continue\n            }\n            // else\n            if (xPosition === 0) {\n                localGrid.push(this.newGridRow(subgrid.cols));\n            }\n            if (xPosition === 0 && this.isLastRow(dataFieldCount, dataGroup, fieldsPerRow)) {\n                const fieldsInLastRow = dataGroup.fields.length % fieldsPerRow;\n                const rowWidth = maxXPosition + fieldWidth;\n                if (dataGroup.alignment === DataGroupAlignment.END) {\n                    xPosition = rowWidth - fieldWidth * fieldsInLastRow;\n                } else if (dataGroup.alignment === DataGroupAlignment.CENTER) {\n                    xPosition = Math.floor((rowWidth - fieldsInLastRow * fieldWidth) / 2);\n                }\n            }\n            this.occupySpace(localGrid, localGrid.length - 1, xPosition, fieldWidth, fieldElement.gridAreaId);\n\n            xPosition += fieldWidth;\n            if (xPosition > maxXPosition) {\n                xPosition = 0;\n            }\n        });\n        localGrid.forEach(row => subgrid.addRow(row));\n    }\n\n    /**\n     * @param width width of the row\n     * @param content the value that should be used to fill all elements in the row\n     */\n    protected newGridRow(width: number, content = ''): Array<string> {\n        return Array(width).fill(content);\n    }\n\n    /**\n     * Fills the specified rectangular area with the specified value in the provided grid.\n     *\n     * If the specified area contains values other than the empty string an error will be thrown.\n     * @param grid the grid that should be modified\n     * @param y the 0 based row index of the top-left corner of the filled area\n     * @param x the 0 based column index of the top-left corner of the filled area\n     * @param width the width of the filled area\n     * @param value the value that is set into every cell of the grid inside the specified area\n     * @param height the height of the filled area\n     * @param checkOccupants whether the filled area should be checked for other elements.\n     * If a check is performed an error will be thrown if elements are found.\n     */\n    protected occupySpace(grid: Array<Array<string>>, y: number, x: number, width: number,\n                          value: string, height = 1, checkOccupants = true) {\n        for (let j = y; j < y + height; j++) {\n            for (let i = x; i < x + width; i++) {\n                if (checkOccupants && grid[j][i] !== '') {\n                    throw new Error(`Cannot place element ${value} into the grid layout, because it's space (x: ${i}, y: ${j})` +\n                        ` is already occupied by another element (${grid[j][i]})`);\n                }\n                grid[j][i] = value;\n            }\n        }\n    }\n\n    /**\n     * @param index the index of the checked element within its data group\n     * @param dataGroup the checked data group\n     * @param fieldsPerRow the number of fields that is required to fill an entire row\n     * @returns whether the field at the given index is within the last row of elements of the provided data group.\n     * Note that if the last row contains enough elements to be completely filled this method returns `false`.\n     */\n    protected isLastRow(index: number, dataGroup: DataGroup, fieldsPerRow: number): boolean {\n        return index + fieldsPerRow >= dataGroup.fields.length;\n    }\n\n    /**\n     * Destroys the previous content and pushes the new content into the stream\n     * @param content the new content\n     */\n    protected renderContent(content: Array<Subgrid> = []): void {\n        this._dataSource$.value.forEach(subgrid => subgrid.destroy());\n        this._dataSource$.next(content);\n    }\n\n    protected createSubgridId(dataGroup: DataGroup): string {\n        let idBase: string;\n        if (dataGroup.parentTaskId !== undefined) {\n            idBase = [dataGroup.parentTaskId, dataGroup.parentTaskRefId, dataGroup.nestingLevel].join('#');\n        } else {\n            idBase = 'root';\n        }\n        let id = idBase;\n        while (this._existingSubgridIds.has(id)) {\n            id = idBase + this._subgridIdCounter.next();\n        }\n        this._existingSubgridIds.add(id);\n        return id;\n    }\n\n    public trackBySubgridFn = (index: number, subgrid: Subgrid) => subgrid.subgridId;\n\n    public trackByFn = (index: number, element: DatafieldGridLayoutElement) => this.trackByDatafields(index, element);\n\n    protected trackByDatafields(index: number, element: DatafieldGridLayoutElement) {\n        switch (element.type) {\n            case TaskElementType.BLANK:\n                return element.gridAreaId + '-' + this.taskContentService.$shouldCreateCounter.getValue();\n            case TaskElementType.LOADER:\n                return element.gridAreaId + '-L-' + this.taskContentService.$shouldCreateCounter.getValue();\n            case TaskElementType.DATA_GROUP_TITLE:\n                return element.title + '-' + this.taskContentService.$shouldCreateCounter.getValue();\n            default:\n                return element.item.stringId + '-' + this.taskContentService.$shouldCreateCounter.getValue();\n        }\n    }\n}\n"]}