@netgrif/components-core 6.0.1

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

@@ -0,0 +1,68 @@
+/**
+ * Holds the common functionality for all Services that work with a single Task object.
+ */
+var TaskHandlingService = /** @class */ (function () {
+    /**
+     * @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.
+     */
+    function TaskHandlingService(_taskContentService, _selectedCaseService) {
+        if (_selectedCaseService === void 0) { _selectedCaseService = null; }
+        this._taskContentService = _taskContentService;
+        this._selectedCaseService = _selectedCaseService;
+    }
+    Object.defineProperty(TaskHandlingService.prototype, "_task", {
+        /**
+         * @returns the Task object held by {@link TaskContentService} or `undefined` if the Service currently holds no Task.
+         */
+        get: function () {
+            return this._taskContentService.task;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(TaskHandlingService.prototype, "_safeTask", {
+        /**
+         * Throws an error if the {@link TaskContentService} didn't have the Task object set yet.
+         *
+         * @returns the Task object held by {@link TaskContentService}.
+         */
+        get: function () {
+            var task = this._taskContentService.task;
+            if (!task) {
+                throw new Error('Attempting to access Task object of an uninitialized TaskContentService');
+            }
+            return task;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * @returns `true` if a {@link Task} instance is set, `false` otherwise
+     */
+    TaskHandlingService.prototype.isTaskPresent = function () {
+        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.
+     */
+    TaskHandlingService.prototype.isTaskRelevant = function (requestedTaskId) {
+        return this.isTaskPresent()
+            && this._task.stringId === requestedTaskId
+            && (!this._selectedCaseService
+                || (!!this._selectedCaseService
+                    && !!this._selectedCaseService.selectedCase
+                    && this._task.caseId === this._selectedCaseService.selectedCase.stringId));
+    };
+    return TaskHandlingService;
+}());
+export { TaskHandlingService };
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,118 @@
+import { __extends } from "tslib";
+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.
+ */
+var TaskRequestStateService = /** @class */ (function (_super) {
+    __extends(TaskRequestStateService, _super);
+    function TaskRequestStateService(_taskContent) {
+        var _this = _super.call(this, _taskContent) || this;
+        _this._loading = new LoadingEmitter();
+        _this._updating = new LoadingEmitter();
+        _taskContent.task$.subscribe(function () {
+            _this._loading.off();
+            _this._updating.off();
+        });
+        return _this;
+    }
+    /**
+     * @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.
+     */
+    TaskRequestStateService.prototype.isLoading = function (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
+     */
+    TaskRequestStateService.prototype.startLoading = function (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
+     */
+    TaskRequestStateService.prototype.stopLoading = function (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.
+     */
+    TaskRequestStateService.prototype.isUpdating = function (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
+     */
+    TaskRequestStateService.prototype.startUpdating = function (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
+     */
+    TaskRequestStateService.prototype.stopUpdating = function (taskId) {
+        if (!this.isTaskRelevant(taskId)) {
+            return;
+        }
+        this._updating.off();
+    };
+    TaskRequestStateService.prototype.ngOnDestroy = function () {
+        this._loading.complete();
+        this._updating.complete();
+    };
+    TaskRequestStateService.ctorParameters = function () { return [
+        { type: TaskContentService }
+    ]; };
+    TaskRequestStateService.decorators = [
+        { type: Injectable }
+    ];
+    TaskRequestStateService.ctorParameters = function () { return [
+        { type: TaskContentService }
+    ]; };
+    return TaskRequestStateService;
+}(TaskHandlingService));
+export { TaskRequestStateService };
+//# 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;AACH;IAC6C,2CAAmB;IAK5D,iCAAY,YAAgC;QAA5C,YACI,kBAAM,YAAY,CAAC,SAOtB;QANG,KAAI,CAAC,QAAQ,GAAG,IAAI,cAAc,EAAE,CAAC;QACrC,KAAI,CAAC,SAAS,GAAG,IAAI,cAAc,EAAE,CAAC;QACtC,YAAY,CAAC,KAAK,CAAC,SAAS,CAAC;YACzB,KAAI,CAAC,QAAQ,CAAC,GAAG,EAAE,CAAC;YACpB,KAAI,CAAC,SAAS,CAAC,GAAG,EAAE,CAAC;QACzB,CAAC,CAAC,CAAC;;IACP,CAAC;IAED;;;;;;OAMG;IACI,2CAAS,GAAhB,UAAiB,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,8CAAY,GAAnB,UAAoB,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,6CAAW,GAAlB,UAAmB,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,4CAAU,GAAjB,UAAkB,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,+CAAa,GAApB,UAAqB,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,8CAAY,GAAnB,UAAoB,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,6CAAW,GAAX;QACI,IAAI,CAAC,QAAQ,CAAC,QAAQ,EAAE,CAAC;QACzB,IAAI,CAAC,SAAS,CAAC,QAAQ,EAAE,CAAC;IAC9B,CAAC;;gBAjGyB,kBAAkB;;;gBAN/C,UAAU;;;gBATH,kBAAkB;;IAiH1B,8BAAC;CAAA,AAxGD,CAC6C,mBAAmB,GAuG/D;SAvGY,uBAAuB","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/esm5/lib/task-content/field-component-resolver/abstract-field-component-resolver.component.js

@@ -0,0 +1,41 @@
+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.
+ */
+var AbstractFieldComponentResolverComponent = /** @class */ (function () {
+    function AbstractFieldComponentResolverComponent(taskContentService) {
+        this.taskContentService = taskContentService;
+        this.fieldTypeEnum = FieldTypeResource;
+        this.taskElementEnum = TaskElementType;
+    }
+    AbstractFieldComponentResolverComponent.prototype.isOffsetPresent = function () {
+        return !!this.taskContentService.task && !!this.taskContentService.task.layout && !!this.taskContentService.task.layout.offset;
+    };
+    AbstractFieldComponentResolverComponent.prototype.getFieldOffset = function () {
+        return this.isOffsetPresent() ? this.taskContentService.task.layout.offset : 0;
+    };
+    AbstractFieldComponentResolverComponent.prototype.getElementType = function () {
+        return this.gridElement.type;
+    };
+    AbstractFieldComponentResolverComponent.prototype.getDataGroupTitle = function () {
+        return this.gridElement.title;
+    };
+    AbstractFieldComponentResolverComponent.prototype.getDataField = function () {
+        return this.gridElement.item;
+    };
+    AbstractFieldComponentResolverComponent.prototype.getTaskId = function () {
+        return this.taskContentService.task.stringId;
+    };
+    AbstractFieldComponentResolverComponent.prototype.isField = function () {
+        return this.gridElement.type !== TaskElementType.BLANK && this.gridElement.type !== TaskElementType.DATA_GROUP_TITLE
+            && this.gridElement.type !== FieldTypeResource.I18N;
+    };
+    AbstractFieldComponentResolverComponent.propDecorators = {
+        gridElement: [{ type: Input }]
+    };
+    return AbstractFieldComponentResolverComponent;
+}());
+export { AbstractFieldComponentResolverComponent };
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/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 var NAE_ASYNC_RENDERING_CONFIGURATION = new InjectionToken('NaeAsyncRenderingConfiguration');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXN5bmMtcmVuZGVyaW5nLWNvbmZpZ3VyYXRpb24taW5qZWN0aW9uLXRva2VuLmpzIiwic291cmNlUm9vdCI6Im5nOi8vQG5ldGdyaWYvY29tcG9uZW50cy1jb3JlLyIsInNvdXJjZXMiOlsibGliL3Rhc2stY29udGVudC9tb2RlbC9hc3luYy1yZW5kZXJpbmctY29uZmlndXJhdGlvbi1pbmplY3Rpb24tdG9rZW4udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFDLGNBQWMsRUFBQyxNQUFNLGVBQWUsQ0FBQztBQUc3Qzs7OztHQUlHO0FBQ0gsTUFBTSxDQUFDLElBQU0saUNBQWlDLEdBQUcsSUFBSSxjQUFjLENBQThCLGdDQUFnQyxDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge0luamVjdGlvblRva2VufSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7QXN5bmNSZW5kZXJpbmdDb25maWd1cmF0aW9ufSBmcm9tICcuL2FzeW5jLXJlbmRlcmluZy1jb25maWd1cmF0aW9uJztcblxuLyoqXG4gKiBIb2xkcyBjb25maWd1cmF0aW9uIG9mIHRoZSB0YXNrIGNvbnRlbnQgYXN5bmMgcmVuZGVyaW5nIHByb3BlcnRpZXMuXG4gKlxuICogVGhlIHZhbHVlIHJlcHJlc2VudHMgdGhlIG51bWJlciBvZiBlbGVtZW50cyByZW5kZXJlZCBpbiBvbmUgcmVuZGVyaW5nIGN5Y2xlXG4gKi9cbmV4cG9ydCBjb25zdCBOQUVfQVNZTkNfUkVOREVSSU5HX0NPTkZJR1VSQVRJT04gPSBuZXcgSW5qZWN0aW9uVG9rZW48QXN5bmNSZW5kZXJpbmdDb25maWd1cmF0aW9uPignTmFlQXN5bmNSZW5kZXJpbmdDb25maWd1cmF0aW9uJyk7XG4iXX0=

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

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

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

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

package/esm5/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/esm5/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/esm5/lib/task-content/model/resource-interface.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVzb3VyY2UtaW50ZXJmYWNlLmpzIiwic291cmNlUm9vdCI6Im5nOi8vQG5ldGdyaWYvY29tcG9uZW50cy1jb3JlLyIsInNvdXJjZXMiOlsibGliL3Rhc2stY29udGVudC9tb2RlbC9yZXNvdXJjZS1pbnRlcmZhY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7QmVoYXZpb3J9IGZyb20gJy4uLy4uL2RhdGEtZmllbGRzL21vZGVscy9iZWhhdmlvcic7XG5pbXBvcnQge0xheW91dH0gZnJvbSAnLi4vLi4vZGF0YS1maWVsZHMvbW9kZWxzL2xheW91dCc7XG5pbXBvcnQge1ZhbGlkYXRpb259IGZyb20gJy4uLy4uL2RhdGEtZmllbGRzL21vZGVscy92YWxpZGF0aW9uJztcbmltcG9ydCB7RmllbGRUeXBlUmVzb3VyY2V9IGZyb20gJy4vZmllbGQtdHlwZS1yZXNvdXJjZSc7XG5pbXBvcnQge0Zvcm1hdEZpbHRlcn0gZnJvbSAnLi4vLi4vZGF0YS1maWVsZHMvbW9kZWxzL2Zvcm1hdC1maWx0ZXInO1xuaW1wb3J0IHtDb21wb25lbnR9IGZyb20gJy4uLy4uL2RhdGEtZmllbGRzL21vZGVscy9jb21wb25lbnQnO1xuaW1wb3J0IHtGaWx0ZXJNZXRhZGF0YX0gZnJvbSAnLi4vLi4vc2VhcmNoL21vZGVscy9wZXJzaXN0YW5jZS9maWx0ZXItbWV0YWRhdGEnO1xuXG5leHBvcnQgaW50ZXJmYWNlIERhdGFGaWVsZFJlc291cmNlIHtcbiAgICBzdHJpbmdJZDogc3RyaW5nO1xuICAgIHR5cGU6IEZpZWxkVHlwZVJlc291cmNlO1xuICAgIG5hbWU6IHN0cmluZztcbiAgICBkZXNjcmlwdGlvbj86IHN0cmluZztcbiAgICBwbGFjZWhvbGRlcj86IHN0cmluZztcbiAgICBiZWhhdmlvcjogQmVoYXZpb3I7XG4gICAgbGF5b3V0PzogTGF5b3V0O1xuICAgIG9yZGVyOiBudW1iZXI7XG4gICAgdmFsdWU/OiBzdHJpbmcgfCBudW1iZXIgfCBBcnJheTxzdHJpbmc+IHwgYm9vbGVhbiB8IEFycmF5PG51bWJlcj4gfCBhbnk7XG4gICAgZGVmYXVsdFZhbHVlPzogc3RyaW5nIHwgbnVtYmVyIHwgQXJyYXk8c3RyaW5nPiB8IGJvb2xlYW47XG4gICAgY2hvaWNlcz86IEFycmF5PHN0cmluZz47XG4gICAgLypAZGVwcmVjYXRlZCovXG4gICAgdmlldz86IHtcbiAgICAgICAgLypAZGVwcmVjYXRlZCovXG4gICAgICAgIHZhbHVlOiBzdHJpbmc7XG4gICAgfTtcbiAgICBtaW5WYWx1ZT86IG51bWJlcjtcbiAgICBtaW5EYXRlPzogc3RyaW5nO1xuICAgIHZhbGlkYXRpb25zPzogQXJyYXk8VmFsaWRhdGlvbj47XG4gICAgY29tcG9uZW50PzogQ29tcG9uZW50O1xuICAgIHN1YlR5cGU/OiBzdHJpbmc7XG4gICAgLypAZGVwcmVjYXRlZCovXG4gICAgZm9ybWF0dGluZz86IHN0cmluZztcbiAgICBmb3JtYXRGaWx0ZXI/OiBGb3JtYXRGaWx0ZXI7XG4gICAgcm9sZXM/OiBBcnJheTxhbnk+O1xuICAgIG9wdGlvbnM/OiB7XG4gICAgICAgIFtrOiBzdHJpbmddOiBzdHJpbmdcbiAgICB9O1xuICAgIGFsbG93ZWROZXRzPzogQXJyYXk8c3RyaW5nPjtcbiAgICBmaWx0ZXJNZXRhZGF0YT86IEZpbHRlck1ldGFkYXRhO1xuICAgIHBhcmVudFRhc2tJZD86IHN0cmluZztcbn1cbiJdfQ==

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

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