@netgrif/components-core 6.0.1

package/esm2015/lib/task/services/task-handling-service.js

@@ -0,0 +1,57 @@
+/**
+ * Holds the common functionality for all Services that work with a single Task object.
+ */
+export class TaskHandlingService {
+    /**
+     * @param _taskContentService the service that holds the currently selected task, that is handled by the implementation of this class
+     * @param _selectedCaseService an optional service, that holds the currently selected case.
+     * It should be injected with the `@Optional()` annotation, since it might not be always provided.
+     */
+    constructor(_taskContentService, _selectedCaseService = null) {
+        this._taskContentService = _taskContentService;
+        this._selectedCaseService = _selectedCaseService;
+    }
+    /**
+     * @returns the Task object held by {@link TaskContentService} or `undefined` if the Service currently holds no Task.
+     */
+    get _task() {
+        return this._taskContentService.task;
+    }
+    /**
+     * Throws an error if the {@link TaskContentService} didn't have the Task object set yet.
+     *
+     * @returns the Task object held by {@link TaskContentService}.
+     */
+    get _safeTask() {
+        const task = this._taskContentService.task;
+        if (!task) {
+            throw new Error('Attempting to access Task object of an uninitialized TaskContentService');
+        }
+        return task;
+    }
+    /**
+     * @returns `true` if a {@link Task} instance is set, `false` otherwise
+     */
+    isTaskPresent() {
+        return !!this._taskContentService.task;
+    }
+    /**
+     * Checks whether the current state of the {@link TaskContentService} and optionally if the {@link SelectedCaseService}, is still
+     * relevant to the task that was requested.
+     *
+     * This method is useful if you use {@link UnlimitedTaskContentService}, or a similar implementation. It is possible for the currently
+     * "selected" task to change in-between a backend request was sent and the response was received. In that case the response is no longer
+     * relevant and should be discarded, otherwise an illegal task state could be achieved on frontend.
+     * @param requestedTaskId the `stringId` of the requested task
+     * @returns `true` if the requested task is still relevant to the state of the frontend. Returns `false` otherwise.
+     */
+    isTaskRelevant(requestedTaskId) {
+        return this.isTaskPresent()
+            && this._task.stringId === requestedTaskId
+            && (!this._selectedCaseService
+                || (!!this._selectedCaseService
+                    && !!this._selectedCaseService.selectedCase
+                    && this._task.caseId === this._selectedCaseService.selectedCase.stringId));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/task/services/task-request-state.service.js

@@ -0,0 +1,113 @@
+import { Injectable } from '@angular/core';
+import { LoadingEmitter } from '../../utility/loading-emitter';
+import { TaskContentService } from '../../task-content/services/task-content.service';
+import { TaskHandlingService } from './task-handling-service';
+/**
+ * Holds information about the state of backend requests regarding a single {@link Task} instance
+ * held within the {@link TaskContentService}.
+ *
+ * This Service is used by many other Services that handle the necessary logic for working with a single Task on frontend.
+ */
+export class TaskRequestStateService extends TaskHandlingService {
+    constructor(_taskContent) {
+        super(_taskContent);
+        this._loading = new LoadingEmitter();
+        this._updating = new LoadingEmitter();
+        _taskContent.task$.subscribe(() => {
+            this._loading.off();
+            this._updating.off();
+        });
+    }
+    /**
+     * @returns whether the task is currently loading, or `undefined` if the queried task is
+     * not held within the injected {@link TaskContentService}.
+     *
+     * @param taskId stringId of the {@link Task} we would like to get information about.
+     * If no value is provided, the state of the task held in the {@link TaskContentService} will be returned.
+     */
+    isLoading(taskId) {
+        if (taskId !== undefined && !this.isTaskRelevant(taskId)) {
+            return undefined;
+        }
+        return this._loading.isActive;
+    }
+    /**
+     * Changes the state of the loading indicator to `true`,
+     * if the task held within the injected {@link TaskContentService} has the Id that is provided as argument.
+     * This method does nothing otherwise.
+     *
+     * @param taskId stringId of the {@link Task} who's loading state we want to change
+     */
+    startLoading(taskId) {
+        if (!this.isTaskRelevant(taskId)) {
+            return;
+        }
+        this._loading.on();
+    }
+    /**
+     * Changes the state of the loading indicator to `false`,
+     * if the task held within the injected {@link TaskContentService} has the Id that is provided as argument.
+     * This method does nothing otherwise.
+     *
+     * @param taskId stringId of the {@link Task} who's loading state we want to change
+     */
+    stopLoading(taskId) {
+        if (!this.isTaskRelevant(taskId)) {
+            return;
+        }
+        this._loading.off();
+    }
+    /**
+     * @returns whether the task is currently updating it's data fields, or `undefined` if the queried task is
+     * not held within the injected {@link TaskContentService}.
+     *
+     * @param taskId stringId of the {@link Task} we would like to get information about.
+     * If no value is provided, the state of the task held in the {@link TaskContentService} will be returned.
+     */
+    isUpdating(taskId) {
+        if (taskId !== undefined && !this.isTaskRelevant(taskId)) {
+            return undefined;
+        }
+        return this._updating.isActive;
+    }
+    /**
+     * Changes the state of the updating indicator to `true`,
+     * if the task held within the injected {@link TaskContentService} has the Id that is provided as argument.
+     * This method does nothing otherwise.
+     *
+     * @param taskId stringId of the {@link Task} who's loading state we want to change
+     */
+    startUpdating(taskId) {
+        if (!this.isTaskRelevant(taskId)) {
+            return;
+        }
+        this._updating.on();
+    }
+    /**
+     * Changes the state of the updating indicator to `false`,
+     * if the task held within the injected {@link TaskContentService} has the Id that is provided as argument.
+     * This method does nothing otherwise.
+     *
+     * @param taskId stringId of the {@link Task} who's loading state we want to change
+     */
+    stopUpdating(taskId) {
+        if (!this.isTaskRelevant(taskId)) {
+            return;
+        }
+        this._updating.off();
+    }
+    ngOnDestroy() {
+        this._loading.complete();
+        this._updating.complete();
+    }
+}
+TaskRequestStateService.ctorParameters = () => [
+    { type: TaskContentService }
+];
+TaskRequestStateService.decorators = [
+    { type: Injectable }
+];
+TaskRequestStateService.ctorParameters = () => [
+    { type: TaskContentService }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"task-request-state.service.js","sourceRoot":"ng://@netgrif/components-core/","sources":["lib/task/services/task-request-state.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,UAAU,EAAY,MAAM,eAAe,CAAC;AACpD,OAAO,EAAC,cAAc,EAAC,MAAM,+BAA+B,CAAC;AAC7D,OAAO,EAAC,kBAAkB,EAAC,MAAM,kDAAkD,CAAC;AACpF,OAAO,EAAC,mBAAmB,EAAC,MAAM,yBAAyB,CAAC;AAE5D;;;;;GAKG;AAEH,MAAM,OAAO,uBAAwB,SAAQ,mBAAmB;IAK5D,YAAY,YAAgC;QACxC,KAAK,CAAC,YAAY,CAAC,CAAC;QACpB,IAAI,CAAC,QAAQ,GAAG,IAAI,cAAc,EAAE,CAAC;QACrC,IAAI,CAAC,SAAS,GAAG,IAAI,cAAc,EAAE,CAAC;QACtC,YAAY,CAAC,KAAK,CAAC,SAAS,CAAC,GAAG,EAAE;YAC9B,IAAI,CAAC,QAAQ,CAAC,GAAG,EAAE,CAAC;YACpB,IAAI,CAAC,SAAS,CAAC,GAAG,EAAE,CAAC;QACzB,CAAC,CAAC,CAAC;IACP,CAAC;IAED;;;;;;OAMG;IACI,SAAS,CAAC,MAAe;QAC5B,IAAI,MAAM,KAAK,SAAS,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,EAAE;YACtD,OAAO,SAAS,CAAC;SACpB;QACD,OAAO,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC;IAClC,CAAC;IAED;;;;;;OAMG;IACI,YAAY,CAAC,MAAc;QAC9B,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,EAAE;YAC9B,OAAO;SACV;QACD,IAAI,CAAC,QAAQ,CAAC,EAAE,EAAE,CAAC;IACvB,CAAC;IAED;;;;;;OAMG;IACI,WAAW,CAAC,MAAc;QAC7B,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,EAAE;YAC9B,OAAO;SACV;QACD,IAAI,CAAC,QAAQ,CAAC,GAAG,EAAE,CAAC;IACxB,CAAC;IAED;;;;;;OAMG;IACI,UAAU,CAAC,MAAe;QAC7B,IAAI,MAAM,KAAK,SAAS,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,EAAE;YACtD,OAAO,SAAS,CAAC;SACpB;QACD,OAAO,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC;IACnC,CAAC;IAED;;;;;;OAMG;IACI,aAAa,CAAC,MAAc;QAC/B,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,EAAE;YAC9B,OAAO;SACV;QACD,IAAI,CAAC,SAAS,CAAC,EAAE,EAAE,CAAC;IACxB,CAAC;IAED;;;;;;OAMG;IACI,YAAY,CAAC,MAAc;QAC9B,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,EAAE;YAC9B,OAAO;SACV;QACD,IAAI,CAAC,SAAS,CAAC,GAAG,EAAE,CAAC;IACzB,CAAC;IAED,WAAW;QACP,IAAI,CAAC,QAAQ,CAAC,QAAQ,EAAE,CAAC;QACzB,IAAI,CAAC,SAAS,CAAC,QAAQ,EAAE,CAAC;IAC9B,CAAC;;;YAjGyB,kBAAkB;;;YAN/C,UAAU;;;YATH,kBAAkB","sourcesContent":["import {Injectable, OnDestroy} from '@angular/core';\nimport {LoadingEmitter} from '../../utility/loading-emitter';\nimport {TaskContentService} from '../../task-content/services/task-content.service';\nimport {TaskHandlingService} from './task-handling-service';\n\n/**\n * Holds information about the state of backend requests regarding a single {@link Task} instance\n * held within the {@link TaskContentService}.\n *\n * This Service is used by many other Services that handle the necessary logic for working with a single Task on frontend.\n */\n@Injectable()\nexport class TaskRequestStateService extends TaskHandlingService implements OnDestroy {\n\n    protected _loading: LoadingEmitter;\n    protected _updating: LoadingEmitter;\n\n    constructor(_taskContent: TaskContentService) {\n        super(_taskContent);\n        this._loading = new LoadingEmitter();\n        this._updating = new LoadingEmitter();\n        _taskContent.task$.subscribe(() => {\n            this._loading.off();\n            this._updating.off();\n        });\n    }\n\n    /**\n     * @returns whether the task is currently loading, or `undefined` if the queried task is\n     * not held within the injected {@link TaskContentService}.\n     *\n     * @param taskId stringId of the {@link Task} we would like to get information about.\n     * If no value is provided, the state of the task held in the {@link TaskContentService} will be returned.\n     */\n    public isLoading(taskId?: string): boolean | undefined {\n        if (taskId !== undefined && !this.isTaskRelevant(taskId)) {\n            return undefined;\n        }\n        return this._loading.isActive;\n    }\n\n    /**\n     * Changes the state of the loading indicator to `true`,\n     * if the task held within the injected {@link TaskContentService} has the Id that is provided as argument.\n     * This method does nothing otherwise.\n     *\n     * @param taskId stringId of the {@link Task} who's loading state we want to change\n     */\n    public startLoading(taskId: string): void {\n        if (!this.isTaskRelevant(taskId)) {\n            return;\n        }\n        this._loading.on();\n    }\n\n    /**\n     * Changes the state of the loading indicator to `false`,\n     * if the task held within the injected {@link TaskContentService} has the Id that is provided as argument.\n     * This method does nothing otherwise.\n     *\n     * @param taskId stringId of the {@link Task} who's loading state we want to change\n     */\n    public stopLoading(taskId: string): void {\n        if (!this.isTaskRelevant(taskId)) {\n            return;\n        }\n        this._loading.off();\n    }\n\n    /**\n     * @returns whether the task is currently updating it's data fields, or `undefined` if the queried task is\n     * not held within the injected {@link TaskContentService}.\n     *\n     * @param taskId stringId of the {@link Task} we would like to get information about.\n     * If no value is provided, the state of the task held in the {@link TaskContentService} will be returned.\n     */\n    public isUpdating(taskId?: string): boolean | undefined {\n        if (taskId !== undefined && !this.isTaskRelevant(taskId)) {\n            return undefined;\n        }\n        return this._updating.isActive;\n    }\n\n    /**\n     * Changes the state of the updating indicator to `true`,\n     * if the task held within the injected {@link TaskContentService} has the Id that is provided as argument.\n     * This method does nothing otherwise.\n     *\n     * @param taskId stringId of the {@link Task} who's loading state we want to change\n     */\n    public startUpdating(taskId: string): void {\n        if (!this.isTaskRelevant(taskId)) {\n            return;\n        }\n        this._updating.on();\n    }\n\n    /**\n     * Changes the state of the updating indicator to `false`,\n     * if the task held within the injected {@link TaskContentService} has the Id that is provided as argument.\n     * This method does nothing otherwise.\n     *\n     * @param taskId stringId of the {@link Task} who's loading state we want to change\n     */\n    public stopUpdating(taskId: string): void {\n        if (!this.isTaskRelevant(taskId)) {\n            return;\n        }\n        this._updating.off();\n    }\n\n    ngOnDestroy(): void {\n        this._loading.complete();\n        this._updating.complete();\n    }\n}\n"]}

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

@@ -0,0 +1,39 @@
+import { Input } from '@angular/core';
+import { TaskElementType } from '../model/task-content-element-type';
+import { FieldTypeResource } from '../model/field-type-resource';
+/**
+ * Resolves the correct {@link AbstractDataFieldComponent} implementation for the provided data field object.
+ */
+export class AbstractFieldComponentResolverComponent {
+    constructor(taskContentService) {
+        this.taskContentService = taskContentService;
+        this.fieldTypeEnum = FieldTypeResource;
+        this.taskElementEnum = TaskElementType;
+    }
+    isOffsetPresent() {
+        return !!this.taskContentService.task && !!this.taskContentService.task.layout && !!this.taskContentService.task.layout.offset;
+    }
+    getFieldOffset() {
+        return this.isOffsetPresent() ? this.taskContentService.task.layout.offset : 0;
+    }
+    getElementType() {
+        return this.gridElement.type;
+    }
+    getDataGroupTitle() {
+        return this.gridElement.title;
+    }
+    getDataField() {
+        return this.gridElement.item;
+    }
+    getTaskId() {
+        return this.taskContentService.task.stringId;
+    }
+    isField() {
+        return this.gridElement.type !== TaskElementType.BLANK && this.gridElement.type !== TaskElementType.DATA_GROUP_TITLE
+            && this.gridElement.type !== FieldTypeResource.I18N;
+    }
+}
+AbstractFieldComponentResolverComponent.propDecorators = {
+    gridElement: [{ type: Input }]
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/task-content/model/async-rendering-configuration-injection-token.js

@@ -0,0 +1,8 @@
+import { InjectionToken } from '@angular/core';
+/**
+ * Holds configuration of the task content async rendering properties.
+ *
+ * The value represents the number of elements rendered in one rendering cycle
+ */
+export const NAE_ASYNC_RENDERING_CONFIGURATION = new InjectionToken('NaeAsyncRenderingConfiguration');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXN5bmMtcmVuZGVyaW5nLWNvbmZpZ3VyYXRpb24taW5qZWN0aW9uLXRva2VuLmpzIiwic291cmNlUm9vdCI6Im5nOi8vQG5ldGdyaWYvY29tcG9uZW50cy1jb3JlLyIsInNvdXJjZXMiOlsibGliL3Rhc2stY29udGVudC9tb2RlbC9hc3luYy1yZW5kZXJpbmctY29uZmlndXJhdGlvbi1pbmplY3Rpb24tdG9rZW4udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFDLGNBQWMsRUFBQyxNQUFNLGVBQWUsQ0FBQztBQUc3Qzs7OztHQUlHO0FBQ0gsTUFBTSxDQUFDLE1BQU0saUNBQWlDLEdBQUcsSUFBSSxjQUFjLENBQThCLGdDQUFnQyxDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge0luamVjdGlvblRva2VufSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7QXN5bmNSZW5kZXJpbmdDb25maWd1cmF0aW9ufSBmcm9tICcuL2FzeW5jLXJlbmRlcmluZy1jb25maWd1cmF0aW9uJztcblxuLyoqXG4gKiBIb2xkcyBjb25maWd1cmF0aW9uIG9mIHRoZSB0YXNrIGNvbnRlbnQgYXN5bmMgcmVuZGVyaW5nIHByb3BlcnRpZXMuXG4gKlxuICogVGhlIHZhbHVlIHJlcHJlc2VudHMgdGhlIG51bWJlciBvZiBlbGVtZW50cyByZW5kZXJlZCBpbiBvbmUgcmVuZGVyaW5nIGN5Y2xlXG4gKi9cbmV4cG9ydCBjb25zdCBOQUVfQVNZTkNfUkVOREVSSU5HX0NPTkZJR1VSQVRJT04gPSBuZXcgSW5qZWN0aW9uVG9rZW48QXN5bmNSZW5kZXJpbmdDb25maWd1cmF0aW9uPignTmFlQXN5bmNSZW5kZXJpbmdDb25maWd1cmF0aW9uJyk7XG4iXX0=

package/esm2015/lib/task-content/model/async-rendering-configuration.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXN5bmMtcmVuZGVyaW5nLWNvbmZpZ3VyYXRpb24uanMiLCJzb3VyY2VSb290Ijoibmc6Ly9AbmV0Z3JpZi9jb21wb25lbnRzLWNvcmUvIiwic291cmNlcyI6WyJsaWIvdGFzay1jb250ZW50L21vZGVsL2FzeW5jLXJlbmRlcmluZy1jb25maWd1cmF0aW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJcbmV4cG9ydCBpbnRlcmZhY2UgQXN5bmNSZW5kZXJpbmdDb25maWd1cmF0aW9uIHtcbiAgICAvKipcbiAgICAgKiBIb3cgbWFueSBpdGVtcyBhcmUgcmVuZGVyZWQgYXQgb25jZVxuICAgICAqL1xuICAgIGJhdGNoU2l6ZT86IG51bWJlcjtcbiAgICAvKipcbiAgICAgKiBXaGF0IGlzIHRoZSBkZWxheSBiZXR3ZWVuIHJlbmRlcnMgaW4gbWlsbGlzZWNvbmRzXG4gICAgICovXG4gICAgYmF0Y2hEZWxheT86IG51bWJlcjtcbiAgICAvKipcbiAgICAgKiBIb3cgbWFueSBwbGFjZWhvbGRlciBlbGVtZW50cyBhcmUgcmVuZGVyZWQgYWZ0ZXIgdGhlIGl0ZW1zXG4gICAgICovXG4gICAgbnVtYmVyT2ZQbGFjZWhvbGRlcnM/OiBudW1iZXI7XG4gICAgLyoqXG4gICAgICogV2hldGhlciBkYXRhIGZpZWxkcyB0aGF0IGFyZSBub3QgeWV0IHByZXNlbnQgaW4gdGhlIHRhc2sgY29udGVudCBzaG91bGQgYmUgcmVuZGVyZWQgYXN5bmNocm9ub3VzbHkgb3Igbm90XG4gICAgICovXG4gICAgZW5hYmxlQXN5bmNSZW5kZXJpbmdGb3JOZXdGaWVsZHM/OiBib29sZWFuO1xuICAgIC8qKlxuICAgICAqIFdoZXRoZXIgYWxsIGRhdGEgZmllbGRzIHRoYXQgYXJlIGFscmVhZHkgbG9hZGVkLCB3aGVuIGEgdGFzayBpcyBleHBhbmRlZCBzaG91bGQgYmUgcmVuZGVyZWQgYXN5bmNocm9ub3VzbHkgb3Igbm90XG4gICAgICovXG4gICAgZW5hYmxlQXN5bmNSZW5kZXJpbmdPblRhc2tFeHBhbmQ/OiBib29sZWFuO1xufVxuIl19

package/esm2015/lib/task-content/model/datafield-grid-layout-element.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0YWZpZWxkLWdyaWQtbGF5b3V0LWVsZW1lbnQuanMiLCJzb3VyY2VSb290Ijoibmc6Ly9AbmV0Z3JpZi9jb21wb25lbnRzLWNvcmUvIiwic291cmNlcyI6WyJsaWIvdGFzay1jb250ZW50L21vZGVsL2RhdGFmaWVsZC1ncmlkLWxheW91dC1lbGVtZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge0RhdGFGaWVsZH0gZnJvbSAnLi4vLi4vZGF0YS1maWVsZHMvbW9kZWxzL2Fic3RyYWN0LWRhdGEtZmllbGQnO1xuaW1wb3J0IHtUYXNrQ29udGVudEVsZW1lbnRUeXBlfSBmcm9tICcuL3Rhc2stY29udGVudC1lbGVtZW50LXR5cGUnO1xuXG5leHBvcnQgaW50ZXJmYWNlIERhdGFmaWVsZEdyaWRMYXlvdXRFbGVtZW50IHtcbiAgICB0aXRsZT86IHN0cmluZztcbiAgICBncmlkQXJlYUlkOiBzdHJpbmc7XG4gICAgdHlwZTogVGFza0NvbnRlbnRFbGVtZW50VHlwZTtcbiAgICBpdGVtPzogRGF0YUZpZWxkPHVua25vd24+O1xuICAgIGFsaWdubWVudD86IHN0cmluZztcbn1cbiJdfQ==

package/esm2015/lib/task-content/model/field-type-resource.js

@@ -0,0 +1,23 @@
+/**
+ * Contains types of renderable data fields.
+ */
+export var FieldTypeResource;
+(function (FieldTypeResource) {
+    FieldTypeResource["BOOLEAN"] = "boolean";
+    FieldTypeResource["TEXT"] = "text";
+    FieldTypeResource["NUMBER"] = "number";
+    FieldTypeResource["ENUMERATION"] = "enumeration";
+    FieldTypeResource["MULTICHOICE"] = "multichoice";
+    FieldTypeResource["DATE"] = "date";
+    FieldTypeResource["DATE_TIME"] = "dateTime";
+    FieldTypeResource["USER"] = "user";
+    FieldTypeResource["BUTTON"] = "button";
+    FieldTypeResource["FILE"] = "file";
+    FieldTypeResource["FILE_LIST"] = "fileList";
+    FieldTypeResource["ENUMERATION_MAP"] = "enumeration_map";
+    FieldTypeResource["MULTICHOICE_MAP"] = "multichoice_map";
+    FieldTypeResource["TASK_REF"] = "taskRef";
+    FieldTypeResource["FILTER"] = "filter";
+    FieldTypeResource["I18N"] = "i18n";
+})(FieldTypeResource || (FieldTypeResource = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmllbGQtdHlwZS1yZXNvdXJjZS5qcyIsInNvdXJjZVJvb3QiOiJuZzovL0BuZXRncmlmL2NvbXBvbmVudHMtY29yZS8iLCJzb3VyY2VzIjpbImxpYi90YXNrLWNvbnRlbnQvbW9kZWwvZmllbGQtdHlwZS1yZXNvdXJjZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUNILE1BQU0sQ0FBTixJQUFZLGlCQWlCWDtBQWpCRCxXQUFZLGlCQUFpQjtJQUN6Qix3Q0FBbUIsQ0FBQTtJQUNuQixrQ0FBYSxDQUFBO0lBQ2Isc0NBQWlCLENBQUE7SUFDakIsZ0RBQTJCLENBQUE7SUFDM0IsZ0RBQTJCLENBQUE7SUFDM0Isa0NBQWEsQ0FBQTtJQUNiLDJDQUFzQixDQUFBO0lBQ3RCLGtDQUFhLENBQUE7SUFDYixzQ0FBaUIsQ0FBQTtJQUNqQixrQ0FBYSxDQUFBO0lBQ2IsMkNBQXNCLENBQUE7SUFDdEIsd0RBQW1DLENBQUE7SUFDbkMsd0RBQW1DLENBQUE7SUFDbkMseUNBQW9CLENBQUE7SUFDcEIsc0NBQWlCLENBQUE7SUFDakIsa0NBQWEsQ0FBQTtBQUNqQixDQUFDLEVBakJXLGlCQUFpQixLQUFqQixpQkFBaUIsUUFpQjVCIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBDb250YWlucyB0eXBlcyBvZiByZW5kZXJhYmxlIGRhdGEgZmllbGRzLlxuICovXG5leHBvcnQgZW51bSBGaWVsZFR5cGVSZXNvdXJjZSB7XG4gICAgQk9PTEVBTiA9ICdib29sZWFuJyxcbiAgICBURVhUID0gJ3RleHQnLFxuICAgIE5VTUJFUiA9ICdudW1iZXInLFxuICAgIEVOVU1FUkFUSU9OID0gJ2VudW1lcmF0aW9uJyxcbiAgICBNVUxUSUNIT0lDRSA9ICdtdWx0aWNob2ljZScsXG4gICAgREFURSA9ICdkYXRlJyxcbiAgICBEQVRFX1RJTUUgPSAnZGF0ZVRpbWUnLFxuICAgIFVTRVIgPSAndXNlcicsXG4gICAgQlVUVE9OID0gJ2J1dHRvbicsXG4gICAgRklMRSA9ICdmaWxlJyxcbiAgICBGSUxFX0xJU1QgPSAnZmlsZUxpc3QnLFxuICAgIEVOVU1FUkFUSU9OX01BUCA9ICdlbnVtZXJhdGlvbl9tYXAnLFxuICAgIE1VTFRJQ0hPSUNFX01BUCA9ICdtdWx0aWNob2ljZV9tYXAnLFxuICAgIFRBU0tfUkVGID0gJ3Rhc2tSZWYnLFxuICAgIEZJTFRFUiA9ICdmaWx0ZXInLFxuICAgIEkxOE4gPSAnaTE4bidcbn1cbiJdfQ==

package/esm2015/lib/task-content/model/policy.js

@@ -0,0 +1,31 @@
+/**
+ * Enum AssignPolicy
+ *
+ * value: MANUAL | AUTO
+ */
+export var AssignPolicy;
+(function (AssignPolicy) {
+    AssignPolicy["manual"] = "MANUAL";
+    AssignPolicy["auto"] = "AUTO";
+})(AssignPolicy || (AssignPolicy = {}));
+/**
+ * Enum FinishPolicy
+ *
+ * value: MANUAL | AUTO_NO_DATA
+ */
+export var FinishPolicy;
+(function (FinishPolicy) {
+    FinishPolicy["manual"] = "MANUAL";
+    FinishPolicy["autoNoData"] = "AUTO_NO_DATA";
+})(FinishPolicy || (FinishPolicy = {}));
+/**
+ * Enum DataFocusPolicy
+ *
+ * value: MANUAL | AUTO_EMPTY_REQUIRED
+ */
+export var DataFocusPolicy;
+(function (DataFocusPolicy) {
+    DataFocusPolicy["manual"] = "MANUAL";
+    DataFocusPolicy["autoRequired"] = "AUTO_EMPTY_REQUIRED";
+})(DataFocusPolicy || (DataFocusPolicy = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicG9saWN5LmpzIiwic291cmNlUm9vdCI6Im5nOi8vQG5ldGdyaWYvY29tcG9uZW50cy1jb3JlLyIsInNvdXJjZXMiOlsibGliL3Rhc2stY29udGVudC9tb2RlbC9wb2xpY3kudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7R0FJRztBQUNILE1BQU0sQ0FBTixJQUFZLFlBR1g7QUFIRCxXQUFZLFlBQVk7SUFDcEIsaUNBQWlCLENBQUE7SUFDakIsNkJBQWEsQ0FBQTtBQUNqQixDQUFDLEVBSFcsWUFBWSxLQUFaLFlBQVksUUFHdkI7QUFDRDs7OztHQUlHO0FBQ0gsTUFBTSxDQUFOLElBQVksWUFHWDtBQUhELFdBQVksWUFBWTtJQUNwQixpQ0FBaUIsQ0FBQTtJQUNqQiwyQ0FBMkIsQ0FBQTtBQUMvQixDQUFDLEVBSFcsWUFBWSxLQUFaLFlBQVksUUFHdkI7QUFDRDs7OztHQUlHO0FBQ0gsTUFBTSxDQUFOLElBQVksZUFHWDtBQUhELFdBQVksZUFBZTtJQUN2QixvQ0FBaUIsQ0FBQTtJQUNqQix1REFBb0MsQ0FBQTtBQUN4QyxDQUFDLEVBSFcsZUFBZSxLQUFmLGVBQWUsUUFHMUIiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEVudW0gQXNzaWduUG9saWN5XG4gKlxuICogdmFsdWU6IE1BTlVBTCB8wqBBVVRPXG4gKi9cbmV4cG9ydCBlbnVtIEFzc2lnblBvbGljeSB7XG4gICAgbWFudWFsID0gJ01BTlVBTCcsXG4gICAgYXV0byA9ICdBVVRPJ1xufVxuLyoqXG4gKiBFbnVtIEZpbmlzaFBvbGljeVxuICpcbiAqIHZhbHVlOiBNQU5VQUwgfMKgQVVUT19OT19EQVRBXG4gKi9cbmV4cG9ydCBlbnVtIEZpbmlzaFBvbGljeSB7XG4gICAgbWFudWFsID0gJ01BTlVBTCcsXG4gICAgYXV0b05vRGF0YSA9ICdBVVRPX05PX0RBVEEnXG59XG4vKipcbiAqIEVudW0gRGF0YUZvY3VzUG9saWN5XG4gKlxuICogdmFsdWU6IE1BTlVBTCB8wqBBVVRPX0VNUFRZX1JFUVVJUkVEXG4gKi9cbmV4cG9ydCBlbnVtIERhdGFGb2N1c1BvbGljeSB7XG4gICAgbWFudWFsID0gJ01BTlVBTCcsXG4gICAgYXV0b1JlcXVpcmVkID0gJ0FVVE9fRU1QVFlfUkVRVUlSRUQnXG59XG4iXX0=

package/esm2015/lib/task-content/model/resource-interface.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/task-content/model/split-data-group.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3BsaXQtZGF0YS1ncm91cC5qcyIsInNvdXJjZVJvb3QiOiJuZzovL0BuZXRncmlmL2NvbXBvbmVudHMtY29yZS8iLCJzb3VyY2VzIjpbImxpYi90YXNrLWNvbnRlbnQvbW9kZWwvc3BsaXQtZGF0YS1ncm91cC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtEYXRhR3JvdXB9IGZyb20gJy4uLy4uL3Jlc291cmNlcy9pbnRlcmZhY2UvZGF0YS1ncm91cHMnO1xuaW1wb3J0IHtUYXNrUmVmRmllbGR9IGZyb20gJy4uLy4uL2RhdGEtZmllbGRzL3Rhc2stcmVmLWZpZWxkL21vZGVsL3Rhc2stcmVmLWZpZWxkJztcblxuZXhwb3J0IGludGVyZmFjZSBTcGxpdERhdGFHcm91cCB7XG4gICAgc3RhcnRHcm91cD86IERhdGFHcm91cDtcbiAgICB0YXNrUmVmOiBUYXNrUmVmRmllbGQ7XG4gICAgZW5kR3JvdXA/OiBEYXRhR3JvdXA7XG59XG4iXX0=

package/esm2015/lib/task-content/model/subgrid.js

@@ -0,0 +1,235 @@
+import { IncrementingCounter } from '../../utility/incrementing-counter';
+import { TaskElementType } from './task-content-element-type';
+import { BehaviorSubject } from 'rxjs';
+/**
+ * A configuration for one subgrid - a basic layouting unit
+ */
+export class Subgrid {
+    /**
+     * @param subgridId a unique identifier of the subgrid in the task layout
+     * @param cols Number of columns of the subgrid
+     * @param _asyncRenderingConfig configuration object for async rendering of data fields
+     */
+    constructor(subgridId, cols, _asyncRenderingConfig) {
+        this.subgridId = subgridId;
+        this.cols = cols;
+        this._asyncRenderingConfig = _asyncRenderingConfig;
+        /**
+         * The elements that are contained in the subgrid
+         */
+        this._content = [];
+        /**
+         * A 2D representation of the grid element IDs
+         */
+        this._grid = [];
+        /**
+         * Counter to assure element ID uniqueness
+         */
+        this._runningTitleCount = new IncrementingCounter();
+        /**
+         * Grid area identifiers that are already in use
+         */
+        this._existingIdentifiers = new Set();
+        this._renderedContent$ = new BehaviorSubject([]);
+    }
+    get content() {
+        return this._renderedContent$.value;
+    }
+    /**
+     * Completes the underlying stream and clears any running timeouts
+     */
+    destroy() {
+        this._renderedContent$.complete();
+        if (this._asyncRenderingTimeout !== undefined) {
+            window.clearTimeout(this._asyncRenderingTimeout);
+        }
+    }
+    /**
+     * @returns the columns configuration for the grid layout
+     */
+    getGridColumns() {
+        return 'repeat(' + this.cols + ', 1fr)';
+    }
+    getRunningTitleCount() {
+        return this._runningTitleCount;
+    }
+    /**
+     * Converts a {@link DataField} into a {@link DatafieldGridLayoutElement} and adds it to the content of this subgrid.
+     *
+     * Beware that this method DOES NOT add the element into the resulting grid. This must be done independently by calling the
+     * [addRow]{@link Subgrid#addRow} method.
+     * @param field the field that should be added to the subgrid
+     * @param type the type of the field
+     * @returns the created grid element
+     */
+    addField(field, type) {
+        const element = this.fieldElement(field, type);
+        this.addElement(element);
+        return element;
+    }
+    /**
+     * Converts a {@link DataGroup} into a {@link DatafieldGridLayoutElement} and adds it to the content of this subgrid.
+     *
+     * Beware that this method DOES NOT add the element into the resulting grid. This must be done independently by calling the
+     * [addRow]{@link Subgrid#addRow} method.
+     * @param dataGroup the data group whose title should be added to the grid
+     * @returns the created grid element
+     */
+    addTitle(dataGroup) {
+        const element = this.groupTitleElement(dataGroup);
+        this.addElement(element);
+        return element;
+    }
+    addElement(element) {
+        this._content.push(element);
+    }
+    /**
+     * Adds a row of CSS `gridAreaId`s into the grid that is held in this subgrid.
+     * @param row the field Ids. The width of the row should match the number of columns of the grid. If not an error is thrown.
+     */
+    addRow(row) {
+        if (row.length !== this.cols) {
+            throw new Error(`The provided grid layout row '${JSON.stringify(row)}' does not match the number of columns of this subgrid (${this.cols})`);
+        }
+        this._grid.push(row);
+    }
+    /**
+     * Converts the provided configuration into data that can be fed into CSS grid layout
+     */
+    finalize() {
+        this.fillEmptySpace();
+        this.createGridAreasString();
+    }
+    /**
+     * Fills empty tiles in the grid with blank elements
+     */
+    fillEmptySpace() {
+        const runningBlanksCount = new IncrementingCounter();
+        this._grid.forEach(row => {
+            for (let i = 0; i < row.length; i++) {
+                if (row[i] !== '') {
+                    continue;
+                }
+                const filler = this.fillerElement(runningBlanksCount);
+                row[i] = filler.gridAreaId;
+                this._content.push(filler);
+            }
+        });
+    }
+    /**
+     * @param field the field whose representation should be created
+     * @param type the type of the data field
+     * @returns an object that represents the provided data field in the layout
+     */
+    fieldElement(field, type) {
+        return { gridAreaId: this.assureUniqueness(field.stringId), type, item: field };
+    }
+    /**
+     * @param fillerCounter the counter that is used to track the number of already created filler elements
+     * @returns a filler element object with a unique ID. The provided counter is incremented by one.
+     */
+    fillerElement(fillerCounter) {
+        return { gridAreaId: this.assureUniqueness('blank' + fillerCounter.next()), type: TaskElementType.BLANK };
+    }
+    /**
+     * @param dataGroup the data group whose title element should be created
+     * @returns an object that represents a title element of the provided data group. The provided counter is incremented by one.
+     */
+    groupTitleElement(dataGroup) {
+        return {
+            title: dataGroup.title,
+            gridAreaId: this.assureUniqueness('group' + this._runningTitleCount.next()),
+            type: TaskElementType.DATA_GROUP_TITLE
+        };
+    }
+    /**
+     * Assures that the provided identifier will be unique.
+     * @param identifier the base for the identifier
+     * @returns the base identifier, if it already is unique. A unique variation on the base identifier if it is already in use.
+     */
+    assureUniqueness(identifier) {
+        const alphaNumIdentifier = 'x' + identifier.replace(/[^0-9a-z]/gi, '');
+        if (!this._existingIdentifiers.has(alphaNumIdentifier)) {
+            this._existingIdentifiers.add(alphaNumIdentifier);
+            return alphaNumIdentifier;
+        }
+        let variation;
+        const counter = new IncrementingCounter();
+        do {
+            variation = `x${counter.next()}${alphaNumIdentifier}`;
+        } while (this._existingIdentifiers.has(variation));
+        this._existingIdentifiers.add(variation);
+        return variation;
+    }
+    /**
+     * Joins the grid of element into a string accepted by `[gdAreas]` input property of Angular flex layout
+     */
+    createGridAreasString() {
+        this.gridAreas = this._grid.map(row => row.join(' ')).join(' | ');
+    }
+    /**
+     * Marks all contained elements as kept and displays them.
+     */
+    displayAllFields() {
+        this._keptElements = [...this._content];
+        this._newElements = [];
+        this._renderedContent$.next(this._keptElements);
+    }
+    /**
+     * Determines which elements from the provided subgrid are contained in this subgrid.
+     * Marks these elements as kept and displays them. Marks the remaining elements as new.
+     *
+     * New elements can be displayed asynchronously over time by calling the
+     * [renderContentOverTime]{@link Subgrid#renderContentOverTime} method.
+     * @param subgrid the "previous" subgrid that is used to compute the element "difference"
+     */
+    determineKeptFields(subgrid) {
+        this._keptElements = [];
+        this._newElements = [];
+        this._content.forEach(element => {
+            if (subgrid.content.some(el => el.gridAreaId === element.gridAreaId)) {
+                this._keptElements.push(element);
+            }
+            else {
+                this._newElements.push(element);
+            }
+        });
+        this._renderedContent$.next(this._keptElements);
+    }
+    /**
+     * If elements are not sorted into new and kept, marks all elements as new.
+     * The [determineKeptFields]{@link Subgrid#determineKeptFields} method can be used to mark elements as kept.
+     *
+     * Then pushes the new elements with the kept elements into the output array over time as specified by the
+     * {@link AsyncRenderingConfiguration} provided in the subgrids constructor.
+     *
+     * @param callback the function that is called once all new elements were pushed into the output array
+     * @param first whether this is the first subgrid that si rendered. If this is the first subgrid then on the initial rendering of
+     * elements a batch of new fields alongside the loader elements is displayed so that some content is immediately available.
+     * Otherwise The initial batch contains only loader elements. Being first effectively shortens the rendering by one batch, since the
+     * first loader-only batch is skipped.
+     */
+    renderContentOverTime(callback, first = false) {
+        if (this._newElements === undefined) {
+            this._newElements = Array.from(this._content);
+            this._keptElements = [];
+        }
+        this.spreadFieldRenderingOverTime(callback, first ? 1 : 0);
+    }
+    spreadFieldRenderingOverTime(callback, iteration = 0) {
+        this._asyncRenderingTimeout = undefined;
+        const fieldsInCurrentIteration = this._newElements.slice(0, iteration * this._asyncRenderingConfig.batchSize);
+        const placeholdersInCurrentIteration = this._newElements.slice(iteration * this._asyncRenderingConfig.batchSize, iteration * this._asyncRenderingConfig.batchSize + this._asyncRenderingConfig.numberOfPlaceholders);
+        fieldsInCurrentIteration.push(...placeholdersInCurrentIteration.map(field => ({ gridAreaId: field.gridAreaId, type: TaskElementType.LOADER })));
+        this._renderedContent$.next([...this._keptElements, ...fieldsInCurrentIteration]);
+        if (this._asyncRenderingConfig.batchSize * iteration < this._newElements.length) {
+            this._asyncRenderingTimeout = window.setTimeout(() => {
+                this.spreadFieldRenderingOverTime(callback, iteration + 1);
+            }, this._asyncRenderingConfig.batchDelay);
+        }
+        else {
+            callback();
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"subgrid.js","sourceRoot":"ng://@netgrif/components-core/","sources":["lib/task-content/model/subgrid.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,mBAAmB,EAAC,MAAM,oCAAoC,CAAC;AACvE,OAAO,EAAC,eAAe,EAAC,MAAM,6BAA6B,CAAC;AAI5D,OAAO,EAAC,eAAe,EAAC,MAAM,MAAM,CAAC;AAGrC;;GAEG;AACH,MAAM,OAAO,OAAO;IA6BhB;;;;OAIG;IACH,YAA0B,SAAiB,EAAS,IAAY,EAAY,qBAAkD;QAApG,cAAS,GAAT,SAAS,CAAQ;QAAS,SAAI,GAAJ,IAAI,CAAQ;QAAY,0BAAqB,GAArB,qBAAqB,CAA6B;QA7B9H;;WAEG;QACO,aAAQ,GAAsC,EAAE,CAAC;QAK3D;;WAEG;QACO,UAAK,GAAyB,EAAE,CAAC;QAC3C;;WAEG;QACO,uBAAkB,GAAwB,IAAI,mBAAmB,EAAE,CAAC;QAC9E;;WAEG;QACO,yBAAoB,GAAG,IAAI,GAAG,EAAU,CAAC;QAW/C,IAAI,CAAC,iBAAiB,GAAG,IAAI,eAAe,CAAoC,EAAE,CAAC,CAAC;IACxF,CAAC;IAED,IAAI,OAAO;QACP,OAAO,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC;IACxC,CAAC;IAED;;OAEG;IACI,OAAO;QACV,IAAI,CAAC,iBAAiB,CAAC,QAAQ,EAAE,CAAC;QAClC,IAAI,IAAI,CAAC,sBAAsB,KAAK,SAAS,EAAE;YAC3C,MAAM,CAAC,YAAY,CAAC,IAAI,CAAC,sBAAsB,CAAC,CAAC;SACpD;IACL,CAAC;IAED;;OAEG;IACI,cAAc;QACjB,OAAO,SAAS,GAAG,IAAI,CAAC,IAAI,GAAG,QAAQ,CAAC;IAC5C,CAAC;IAEM,oBAAoB;QACvB,OAAO,IAAI,CAAC,kBAAkB,CAAC;IACnC,CAAC;IAED;;;;;;;;OAQG;IACI,QAAQ,CAAC,KAAyB,EAAE,IAAuB;QAC9D,MAAM,OAAO,GAAG,IAAI,CAAC,YAAY,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;QAC/C,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;QACzB,OAAO,OAAO,CAAC;IACnB,CAAC;IAED;;;;;;;OAOG;IACI,QAAQ,CAAC,SAAoB;QAChC,MAAM,OAAO,GAAG,IAAI,CAAC,iBAAiB,CAAC,SAAS,CAAC,CAAC;QAClD,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;QACzB,OAAO,OAAO,CAAC;IACnB,CAAC;IAES,UAAU,CAAC,OAAmC;QACpD,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IAChC,CAAC;IAED;;;OAGG;IACI,MAAM,CAAC,GAAkB;QAC5B,IAAI,GAAG,CAAC,MAAM,KAAK,IAAI,CAAC,IAAI,EAAE;YAC1B,MAAM,IAAI,KAAK,CAAC,iCAAiC,IAAI,CAAC,SAAS,CAAC,GAAG,CACnE,2DAA2D,IAAI,CAAC,IAAI,GAAG,CAAC,CAAC;SAC5E;QACD,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IACzB,CAAC;IAED;;OAEG;IACI,QAAQ;QACX,IAAI,CAAC,cAAc,EAAE,CAAC;QACtB,IAAI,CAAC,qBAAqB,EAAE,CAAC;IACjC,CAAC;IAED;;OAEG;IACO,cAAc;QACpB,MAAM,kBAAkB,GAAG,IAAI,mBAAmB,EAAE,CAAC;QACrD,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE;YACrB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,GAAG,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;gBACjC,IAAI,GAAG,CAAC,CAAC,CAAC,KAAK,EAAE,EAAE;oBACf,SAAS;iBACZ;gBACD,MAAM,MAAM,GAAG,IAAI,CAAC,aAAa,CAAC,kBAAkB,CAAC,CAAC;gBACtD,GAAG,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,UAAU,CAAC;gBAC3B,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;aAC9B;QACL,CAAC,CAAC,CAAC;IACP,CAAC;IAED;;;;OAIG;IACO,YAAY,CAAC,KAAyB,EAAE,IAAuB;QACrE,OAAO,EAAC,UAAU,EAAE,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC,QAAQ,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAC,CAAC;IAClF,CAAC;IAED;;;OAGG;IACO,aAAa,CAAC,aAAkC;QACtD,OAAO,EAAC,UAAU,EAAE,IAAI,CAAC,gBAAgB,CAAC,OAAO,GAAG,aAAa,CAAC,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,eAAe,CAAC,KAAK,EAAC,CAAC;IAC5G,CAAC;IAED;;;OAGG;IACO,iBAAiB,CAAC,SAAoB;QAC5C,OAAO;YACH,KAAK,EAAE,SAAS,CAAC,KAAK;YACtB,UAAU,EAAE,IAAI,CAAC,gBAAgB,CAAC,OAAO,GAAG,IAAI,CAAC,kBAAkB,CAAC,IAAI,EAAE,CAAC;YAC3E,IAAI,EAAE,eAAe,CAAC,gBAAgB;SACzC,CAAC;IACN,CAAC;IAED;;;;OAIG;IACO,gBAAgB,CAAC,UAAkB;QACzC,MAAM,kBAAkB,GAAG,GAAG,GAAG,UAAU,CAAC,OAAO,CAAC,aAAa,EAAE,EAAE,CAAC,CAAC;QACvE,IAAI,CAAC,IAAI,CAAC,oBAAoB,CAAC,GAAG,CAAC,kBAAkB,CAAC,EAAE;YACpD,IAAI,CAAC,oBAAoB,CAAC,GAAG,CAAC,kBAAkB,CAAC,CAAC;YAClD,OAAO,kBAAkB,CAAC;SAC7B;QACD,IAAI,SAAS,CAAC;QACd,MAAM,OAAO,GAAG,IAAI,mBAAmB,EAAE,CAAC;QAC1C,GAAG;YACC,SAAS,GAAG,IAAI,OAAO,CAAC,IAAI,EAAE,GAAG,kBAAkB,EAAE,CAAC;SACzD,QAAQ,IAAI,CAAC,oBAAoB,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE;QACnD,IAAI,CAAC,oBAAoB,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;QACzC,OAAO,SAAS,CAAC;IACrB,CAAC;IAED;;OAEG;IACO,qBAAqB;QAC3B,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACtE,CAAC;IAED;;OAEG;IACI,gBAAgB;QACnB,IAAI,CAAC,aAAa,GAAG,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,CAAC;QACxC,IAAI,CAAC,YAAY,GAAG,EAAE,CAAC;QACvB,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;IACpD,CAAC;IAED;;;;;;;OAOG;IACI,mBAAmB,CAAC,OAAgB;QACvC,IAAI,CAAC,aAAa,GAAG,EAAE,CAAC;QACxB,IAAI,CAAC,YAAY,GAAG,EAAE,CAAC;QAEvB,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE;YAC5B,IAAI,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,UAAU,KAAK,OAAO,CAAC,UAAU,CAAC,EAAE;gBAClE,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;aACpC;iBAAM;gBACH,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;aACnC;QACL,CAAC,CAAC,CAAC;QAEH,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;IACpD,CAAC;IAED;;;;;;;;;;;;OAYG;IACI,qBAAqB,CAAC,QAAoB,EAAE,KAAK,GAAE,KAAK;QAC3D,IAAI,IAAI,CAAC,YAAY,KAAK,SAAS,EAAE;YACjC,IAAI,CAAC,YAAY,GAAG,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;YAC9C,IAAI,CAAC,aAAa,GAAG,EAAE,CAAC;SAC3B;QACD,IAAI,CAAC,4BAA4B,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAC/D,CAAC;IAES,4BAA4B,CAAC,QAAoB,EAAE,SAAS,GAAG,CAAC;QACtE,IAAI,CAAC,sBAAsB,GAAG,SAAS,CAAC;QACxC,MAAM,wBAAwB,GAAG,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC,EAAE,SAAS,GAAG,IAAI,CAAC,qBAAqB,CAAC,SAAS,CAAC,CAAC;QAC9G,MAAM,8BAA8B,GAAG,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,SAAS,GAAG,IAAI,CAAC,qBAAqB,CAAC,SAAS,EAC3G,SAAS,GAAG,IAAI,CAAC,qBAAqB,CAAC,SAAS,GAAG,IAAI,CAAC,qBAAqB,CAAC,oBAAoB,CAAC,CAAC;QAExG,wBAAwB,CAAC,IAAI,CACzB,GAAG,8BAA8B,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,EAAC,UAAU,EAAE,KAAK,CAAC,UAAU,EAAE,IAAI,EAAE,eAAe,CAAC,MAAM,EAAC,CAAC,CAAC,CAAC,CAAC;QAEpH,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC,GAAG,IAAI,CAAC,aAAa,EAAE,GAAG,wBAAwB,CAAC,CAAC,CAAC;QAClF,IAAI,IAAI,CAAC,qBAAqB,CAAC,SAAS,GAAG,SAAS,GAAG,IAAI,CAAC,YAAY,CAAC,MAAM,EAAE;YAC7E,IAAI,CAAC,sBAAsB,GAAG,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE;gBACjD,IAAI,CAAC,4BAA4B,CAAC,QAAQ,EAAE,SAAS,GAAG,CAAC,CAAC,CAAC;YAC/D,CAAC,EAAE,IAAI,CAAC,qBAAqB,CAAC,UAAU,CAAC,CAAC;SAC7C;aAAM;YACH,QAAQ,EAAE,CAAC;SACd;IACL,CAAC;CACJ","sourcesContent":["import {DatafieldGridLayoutElement} from './datafield-grid-layout-element';\nimport {IncrementingCounter} from '../../utility/incrementing-counter';\nimport {TaskElementType} from './task-content-element-type';\nimport {DataField} from '../../data-fields/models/abstract-data-field';\nimport {FieldTypeResource} from './field-type-resource';\nimport {DataGroup} from '../../resources/interface/data-groups';\nimport {BehaviorSubject} from 'rxjs';\nimport {AsyncRenderingConfiguration} from './async-rendering-configuration';\n\n/**\n * A configuration for one subgrid - a basic layouting unit\n */\nexport class Subgrid {\n    /**\n     * the css `gridAreas` configuration, that determines the layout of the grids content\n     */\n    gridAreas: string;\n    /**\n     * The elements that are contained in the subgrid\n     */\n    protected _content: Array<DatafieldGridLayoutElement> = [];\n    /**\n     * The elements that are contained in the subgrid and have already been rendered to the user\n     */\n    protected _renderedContent$: BehaviorSubject<Array<DatafieldGridLayoutElement>>;\n    /**\n     * A 2D representation of the grid element IDs\n     */\n    protected _grid: Array<Array<string>> = [];\n    /**\n     * Counter to assure element ID uniqueness\n     */\n    protected _runningTitleCount: IncrementingCounter = new IncrementingCounter();\n    /**\n     * Grid area identifiers that are already in use\n     */\n    protected _existingIdentifiers = new Set<string>();\n    protected _asyncRenderingTimeout: number;\n    protected _keptElements: Array<DatafieldGridLayoutElement>;\n    protected _newElements: Array<DatafieldGridLayoutElement>;\n\n    /**\n     * @param subgridId a unique identifier of the subgrid in the task layout\n     * @param cols Number of columns of the subgrid\n     * @param _asyncRenderingConfig configuration object for async rendering of data fields\n     */\n    public constructor(public subgridId: string, public cols: number, protected _asyncRenderingConfig: AsyncRenderingConfiguration) {\n        this._renderedContent$ = new BehaviorSubject<Array<DatafieldGridLayoutElement>>([]);\n    }\n\n    get content(): Array<DatafieldGridLayoutElement> {\n        return this._renderedContent$.value;\n    }\n\n    /**\n     * Completes the underlying stream and clears any running timeouts\n     */\n    public destroy() {\n        this._renderedContent$.complete();\n        if (this._asyncRenderingTimeout !== undefined) {\n            window.clearTimeout(this._asyncRenderingTimeout);\n        }\n    }\n\n    /**\n     * @returns the columns configuration for the grid layout\n     */\n    public getGridColumns(): string {\n        return 'repeat(' + this.cols + ', 1fr)';\n    }\n\n    public getRunningTitleCount(): IncrementingCounter {\n        return this._runningTitleCount;\n    }\n\n    /**\n     * Converts a {@link DataField} into a {@link DatafieldGridLayoutElement} and adds it to the content of this subgrid.\n     *\n     * Beware that this method DOES NOT add the element into the resulting grid. This must be done independently by calling the\n     * [addRow]{@link Subgrid#addRow} method.\n     * @param field the field that should be added to the subgrid\n     * @param type the type of the field\n     * @returns the created grid element\n     */\n    public addField(field: DataField<unknown>, type: FieldTypeResource): DatafieldGridLayoutElement {\n        const element = this.fieldElement(field, type);\n        this.addElement(element);\n        return element;\n    }\n\n    /**\n     * Converts a {@link DataGroup} into a {@link DatafieldGridLayoutElement} and adds it to the content of this subgrid.\n     *\n     * Beware that this method DOES NOT add the element into the resulting grid. This must be done independently by calling the\n     * [addRow]{@link Subgrid#addRow} method.\n     * @param dataGroup the data group whose title should be added to the grid\n     * @returns the created grid element\n     */\n    public addTitle(dataGroup: DataGroup): DatafieldGridLayoutElement {\n        const element = this.groupTitleElement(dataGroup);\n        this.addElement(element);\n        return element;\n    }\n\n    protected addElement(element: DatafieldGridLayoutElement): void {\n        this._content.push(element);\n    }\n\n    /**\n     * Adds a row of CSS `gridAreaId`s into the grid that is held in this subgrid.\n     * @param row the field Ids. The width of the row should match the number of columns of the grid. If not an error is thrown.\n     */\n    public addRow(row: Array<string>): void {\n        if (row.length !== this.cols) {\n            throw new Error(`The provided grid layout row '${JSON.stringify(row)\n            }' does not match the number of columns of this subgrid (${this.cols})`);\n        }\n        this._grid.push(row);\n    }\n\n    /**\n     * Converts the provided configuration into data that can be fed into CSS grid layout\n     */\n    public finalize() {\n        this.fillEmptySpace();\n        this.createGridAreasString();\n    }\n\n    /**\n     * Fills empty tiles in the grid with blank elements\n     */\n    protected fillEmptySpace() {\n        const runningBlanksCount = new IncrementingCounter();\n        this._grid.forEach(row => {\n            for (let i = 0; i < row.length; i++) {\n                if (row[i] !== '') {\n                    continue;\n                }\n                const filler = this.fillerElement(runningBlanksCount);\n                row[i] = filler.gridAreaId;\n                this._content.push(filler);\n            }\n        });\n    }\n\n    /**\n     * @param field the field whose representation should be created\n     * @param type the type of the data field\n     * @returns an object that represents the provided data field in the layout\n     */\n    protected fieldElement(field: DataField<unknown>, type: FieldTypeResource): DatafieldGridLayoutElement {\n        return {gridAreaId: this.assureUniqueness(field.stringId), type, item: field};\n    }\n\n    /**\n     * @param fillerCounter the counter that is used to track the number of already created filler elements\n     * @returns a filler element object with a unique ID. The provided counter is incremented by one.\n     */\n    protected fillerElement(fillerCounter: IncrementingCounter): DatafieldGridLayoutElement {\n        return {gridAreaId: this.assureUniqueness('blank' + fillerCounter.next()), type: TaskElementType.BLANK};\n    }\n\n    /**\n     * @param dataGroup the data group whose title element should be created\n     * @returns an object that represents a title element of the provided data group. The provided counter is incremented by one.\n     */\n    protected groupTitleElement(dataGroup: DataGroup): DatafieldGridLayoutElement {\n        return {\n            title: dataGroup.title,\n            gridAreaId: this.assureUniqueness('group' + this._runningTitleCount.next()),\n            type: TaskElementType.DATA_GROUP_TITLE\n        };\n    }\n\n    /**\n     * Assures that the provided identifier will be unique.\n     * @param identifier the base for the identifier\n     * @returns the base identifier, if it already is unique. A unique variation on the base identifier if it is already in use.\n     */\n    protected assureUniqueness(identifier: string): string {\n        const alphaNumIdentifier = 'x' + identifier.replace(/[^0-9a-z]/gi, '');\n        if (!this._existingIdentifiers.has(alphaNumIdentifier)) {\n            this._existingIdentifiers.add(alphaNumIdentifier);\n            return alphaNumIdentifier;\n        }\n        let variation;\n        const counter = new IncrementingCounter();\n        do {\n            variation = `x${counter.next()}${alphaNumIdentifier}`;\n        } while (this._existingIdentifiers.has(variation));\n        this._existingIdentifiers.add(variation);\n        return variation;\n    }\n\n    /**\n     * Joins the grid of element into a string accepted by `[gdAreas]` input property of Angular flex layout\n     */\n    protected createGridAreasString(): void {\n        this.gridAreas = this._grid.map(row => row.join(' ')).join(' | ');\n    }\n\n    /**\n     * Marks all contained elements as kept and displays them.\n     */\n    public displayAllFields(): void {\n        this._keptElements = [...this._content];\n        this._newElements = [];\n        this._renderedContent$.next(this._keptElements);\n    }\n\n    /**\n     * Determines which elements from the provided subgrid are contained in this subgrid.\n     * Marks these elements as kept and displays them. Marks the remaining elements as new.\n     *\n     * New elements can be displayed asynchronously over time by calling the\n     * [renderContentOverTime]{@link Subgrid#renderContentOverTime} method.\n     * @param subgrid the \"previous\" subgrid that is used to compute the element \"difference\"\n     */\n    public determineKeptFields(subgrid: Subgrid): void {\n        this._keptElements = [];\n        this._newElements = [];\n\n        this._content.forEach(element => {\n            if (subgrid.content.some(el => el.gridAreaId === element.gridAreaId)) {\n                this._keptElements.push(element);\n            } else {\n                this._newElements.push(element);\n            }\n        });\n\n        this._renderedContent$.next(this._keptElements);\n    }\n\n    /**\n     * If elements are not sorted into new and kept, marks all elements as new.\n     * The [determineKeptFields]{@link Subgrid#determineKeptFields} method can be used to mark elements as kept.\n     *\n     * Then pushes the new elements with the kept elements into the output array over time as specified by the\n     * {@link AsyncRenderingConfiguration} provided in the subgrids constructor.\n     *\n     * @param callback the function that is called once all new elements were pushed into the output array\n     * @param first whether this is the first subgrid that si rendered. If this is the first subgrid then on the initial rendering of\n     * elements a batch of new fields alongside the loader elements is displayed so that some content is immediately available.\n     * Otherwise The initial batch contains only loader elements. Being first effectively shortens the rendering by one batch, since the\n     * first loader-only batch is skipped.\n     */\n    public renderContentOverTime(callback: () => void, first= false) {\n        if (this._newElements === undefined) {\n            this._newElements = Array.from(this._content);\n            this._keptElements = [];\n        }\n        this.spreadFieldRenderingOverTime(callback, first ? 1 : 0);\n    }\n\n    protected spreadFieldRenderingOverTime(callback: () => void, iteration = 0) {\n        this._asyncRenderingTimeout = undefined;\n        const fieldsInCurrentIteration = this._newElements.slice(0, iteration * this._asyncRenderingConfig.batchSize);\n        const placeholdersInCurrentIteration = this._newElements.slice(iteration * this._asyncRenderingConfig.batchSize,\n            iteration * this._asyncRenderingConfig.batchSize + this._asyncRenderingConfig.numberOfPlaceholders);\n\n        fieldsInCurrentIteration.push(\n            ...placeholdersInCurrentIteration.map(field => ({gridAreaId: field.gridAreaId, type: TaskElementType.LOADER})));\n\n        this._renderedContent$.next([...this._keptElements, ...fieldsInCurrentIteration]);\n        if (this._asyncRenderingConfig.batchSize * iteration < this._newElements.length) {\n            this._asyncRenderingTimeout = window.setTimeout(() => {\n                this.spreadFieldRenderingOverTime(callback, iteration + 1);\n            }, this._asyncRenderingConfig.batchDelay);\n        } else {\n            callback();\n        }\n    }\n}\n"]}

package/esm2015/lib/task-content/model/task-content-element-type.js

@@ -0,0 +1,19 @@
+/**
+ * Contains types of elements that are used to construct task content, but are not data fields themselves.
+ */
+export var TaskElementType;
+(function (TaskElementType) {
+    /**
+     * Marks an empty tile in the task content grid
+     */
+    TaskElementType["BLANK"] = "blank";
+    /**
+     * Marks the space occupied by a data group title
+     */
+    TaskElementType["DATA_GROUP_TITLE"] = "title";
+    /**
+     * Marks the space occupied by a temporary loading placeholder
+     */
+    TaskElementType["LOADER"] = "loader";
+})(TaskElementType || (TaskElementType = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFzay1jb250ZW50LWVsZW1lbnQtdHlwZS5qcyIsInNvdXJjZVJvb3QiOiJuZzovL0BuZXRncmlmL2NvbXBvbmVudHMtY29yZS8iLCJzb3VyY2VzIjpbImxpYi90YXNrLWNvbnRlbnQvbW9kZWwvdGFzay1jb250ZW50LWVsZW1lbnQtdHlwZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFJQTs7R0FFRztBQUNILE1BQU0sQ0FBTixJQUFZLGVBYVg7QUFiRCxXQUFZLGVBQWU7SUFDdkI7O09BRUc7SUFDSCxrQ0FBZSxDQUFBO0lBQ2Y7O09BRUc7SUFDSCw2Q0FBMEIsQ0FBQTtJQUMxQjs7T0FFRztJQUNILG9DQUFpQixDQUFBO0FBQ3JCLENBQUMsRUFiVyxlQUFlLEtBQWYsZUFBZSxRQWExQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7RmllbGRUeXBlUmVzb3VyY2V9IGZyb20gJy4vZmllbGQtdHlwZS1yZXNvdXJjZSc7XG5cbmV4cG9ydCB0eXBlIFRhc2tDb250ZW50RWxlbWVudFR5cGUgPSBGaWVsZFR5cGVSZXNvdXJjZSB8IFRhc2tFbGVtZW50VHlwZTtcblxuLyoqXG4gKiBDb250YWlucyB0eXBlcyBvZiBlbGVtZW50cyB0aGF0IGFyZSB1c2VkIHRvIGNvbnN0cnVjdCB0YXNrIGNvbnRlbnQsIGJ1dCBhcmUgbm90IGRhdGEgZmllbGRzIHRoZW1zZWx2ZXMuXG4gKi9cbmV4cG9ydCBlbnVtIFRhc2tFbGVtZW50VHlwZSB7XG4gICAgLyoqXG4gICAgICogTWFya3MgYW4gZW1wdHkgdGlsZSBpbiB0aGUgdGFzayBjb250ZW50IGdyaWRcbiAgICAgKi9cbiAgICBCTEFOSyA9ICdibGFuaycsXG4gICAgLyoqXG4gICAgICogTWFya3MgdGhlIHNwYWNlIG9jY3VwaWVkIGJ5IGEgZGF0YSBncm91cCB0aXRsZVxuICAgICAqL1xuICAgIERBVEFfR1JPVVBfVElUTEUgPSAndGl0bGUnLFxuICAgIC8qKlxuICAgICAqIE1hcmtzIHRoZSBzcGFjZSBvY2N1cGllZCBieSBhIHRlbXBvcmFyeSBsb2FkaW5nIHBsYWNlaG9sZGVyXG4gICAgICovXG4gICAgTE9BREVSID0gJ2xvYWRlcicsXG59XG4iXX0=