@netgrif/components-core 6.0.1

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

@@ -0,0 +1,247 @@
+import { __read, __spread } from "tslib";
+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
+ */
+var Subgrid = /** @class */ (function () {
+    /**
+     * @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
+     */
+    function Subgrid(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([]);
+    }
+    Object.defineProperty(Subgrid.prototype, "content", {
+        get: function () {
+            return this._renderedContent$.value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Completes the underlying stream and clears any running timeouts
+     */
+    Subgrid.prototype.destroy = function () {
+        this._renderedContent$.complete();
+        if (this._asyncRenderingTimeout !== undefined) {
+            window.clearTimeout(this._asyncRenderingTimeout);
+        }
+    };
+    /**
+     * @returns the columns configuration for the grid layout
+     */
+    Subgrid.prototype.getGridColumns = function () {
+        return 'repeat(' + this.cols + ', 1fr)';
+    };
+    Subgrid.prototype.getRunningTitleCount = function () {
+        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
+     */
+    Subgrid.prototype.addField = function (field, type) {
+        var 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
+     */
+    Subgrid.prototype.addTitle = function (dataGroup) {
+        var element = this.groupTitleElement(dataGroup);
+        this.addElement(element);
+        return element;
+    };
+    Subgrid.prototype.addElement = function (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.
+     */
+    Subgrid.prototype.addRow = function (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
+     */
+    Subgrid.prototype.finalize = function () {
+        this.fillEmptySpace();
+        this.createGridAreasString();
+    };
+    /**
+     * Fills empty tiles in the grid with blank elements
+     */
+    Subgrid.prototype.fillEmptySpace = function () {
+        var _this = this;
+        var runningBlanksCount = new IncrementingCounter();
+        this._grid.forEach(function (row) {
+            for (var i = 0; i < row.length; i++) {
+                if (row[i] !== '') {
+                    continue;
+                }
+                var 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
+     */
+    Subgrid.prototype.fieldElement = function (field, type) {
+        return { gridAreaId: this.assureUniqueness(field.stringId), type: 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.
+     */
+    Subgrid.prototype.fillerElement = function (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.
+     */
+    Subgrid.prototype.groupTitleElement = function (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.
+     */
+    Subgrid.prototype.assureUniqueness = function (identifier) {
+        var alphaNumIdentifier = 'x' + identifier.replace(/[^0-9a-z]/gi, '');
+        if (!this._existingIdentifiers.has(alphaNumIdentifier)) {
+            this._existingIdentifiers.add(alphaNumIdentifier);
+            return alphaNumIdentifier;
+        }
+        var variation;
+        var 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
+     */
+    Subgrid.prototype.createGridAreasString = function () {
+        this.gridAreas = this._grid.map(function (row) { return row.join(' '); }).join(' | ');
+    };
+    /**
+     * Marks all contained elements as kept and displays them.
+     */
+    Subgrid.prototype.displayAllFields = function () {
+        this._keptElements = __spread(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"
+     */
+    Subgrid.prototype.determineKeptFields = function (subgrid) {
+        var _this = this;
+        this._keptElements = [];
+        this._newElements = [];
+        this._content.forEach(function (element) {
+            if (subgrid.content.some(function (el) { return 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.
+     */
+    Subgrid.prototype.renderContentOverTime = function (callback, first) {
+        if (first === void 0) { first = false; }
+        if (this._newElements === undefined) {
+            this._newElements = Array.from(this._content);
+            this._keptElements = [];
+        }
+        this.spreadFieldRenderingOverTime(callback, first ? 1 : 0);
+    };
+    Subgrid.prototype.spreadFieldRenderingOverTime = function (callback, iteration) {
+        var _this = this;
+        if (iteration === void 0) { iteration = 0; }
+        this._asyncRenderingTimeout = undefined;
+        var fieldsInCurrentIteration = this._newElements.slice(0, iteration * this._asyncRenderingConfig.batchSize);
+        var placeholdersInCurrentIteration = this._newElements.slice(iteration * this._asyncRenderingConfig.batchSize, iteration * this._asyncRenderingConfig.batchSize + this._asyncRenderingConfig.numberOfPlaceholders);
+        fieldsInCurrentIteration.push.apply(fieldsInCurrentIteration, __spread(placeholdersInCurrentIteration.map(function (field) { return ({ gridAreaId: field.gridAreaId, type: TaskElementType.LOADER }); })));
+        this._renderedContent$.next(__spread(this._keptElements, fieldsInCurrentIteration));
+        if (this._asyncRenderingConfig.batchSize * iteration < this._newElements.length) {
+            this._asyncRenderingTimeout = window.setTimeout(function () {
+                _this.spreadFieldRenderingOverTime(callback, iteration + 1);
+            }, this._asyncRenderingConfig.batchDelay);
+        }
+        else {
+            callback();
+        }
+    };
+    return Subgrid;
+}());
+export { Subgrid };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"subgrid.js","sourceRoot":"ng://@netgrif/components-core/","sources":["lib/task-content/model/subgrid.ts"],"names":[],"mappings":"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","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/esm5/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=

package/esm5/lib/task-content/model/task-event-notification.js

@@ -0,0 +1,15 @@
+/**
+ * @param task affected Task object
+ * @param event the reported Task event
+ * @param success success state of the reported event
+ * @returns the notification informing about the event
+ */
+export function createTaskEventNotification(task, event, success) {
+    return {
+        taskId: task.stringId,
+        transitionId: task.transitionId,
+        event: event,
+        success: success
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFzay1ldmVudC1ub3RpZmljYXRpb24uanMiLCJzb3VyY2VSb290Ijoibmc6Ly9AbmV0Z3JpZi9jb21wb25lbnRzLWNvcmUvIiwic291cmNlcyI6WyJsaWIvdGFzay1jb250ZW50L21vZGVsL3Rhc2stZXZlbnQtbm90aWZpY2F0aW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQTJCQTs7Ozs7R0FLRztBQUNILE1BQU0sVUFBVSwyQkFBMkIsQ0FBQyxJQUFVLEVBQUUsS0FBZ0IsRUFBRSxPQUFnQjtJQUN0RixPQUFPO1FBQ0gsTUFBTSxFQUFFLElBQUksQ0FBQyxRQUFRO1FBQ3JCLFlBQVksRUFBRSxJQUFJLENBQUMsWUFBWTtRQUMvQixLQUFLLE9BQUE7UUFDTCxPQUFPLFNBQUE7S0FDVixDQUFDO0FBQ04sQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7VGFza0V2ZW50fSBmcm9tICcuL3Rhc2stZXZlbnQnO1xuaW1wb3J0IHtUYXNrfSBmcm9tICcuLi8uLi9yZXNvdXJjZXMvcHVibGljLWFwaSc7XG5cbi8qKlxuICogSG9sZHMgdGhlIGluZm9ybWF0aW9uIGFib3V0IGFuIGV2ZW50IHRoYXQgb2NjdXJyZWQgdG8gc29tZSB7QGxpbmsgVGFza30gcmVzb3VyY2UuXG4gKlxuICogVGFzayBldmVudHMgY29ycmVzcG9uZCBtb3JlIG9yIGxlc3MgMS10by0xIHRvIGJhY2tlbmQgY2FsbHMgYW5kIHRoZWlyIHJlc3VsdHMuXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgVGFza0V2ZW50Tm90aWZpY2F0aW9uIHtcbiAgICAvKipcbiAgICAgKiBTdHJpbmdJZCBvZiB0aGUgYWZmZWN0ZWQge0BsaW5rIFRhc2t9XG4gICAgICovXG4gICAgdGFza0lkOiBzdHJpbmc7XG4gICAgLyoqXG4gICAgICogU3RyaW5nSWQgb2YgdGhlIFRyYW5zaXRpb25cbiAgICAgKi9cbiAgICB0cmFuc2l0aW9uSWQ6IHN0cmluZztcbiAgICAvKipcbiAgICAgKiBUaGUgZXZlbnQgdGhhdCBvY2N1cnJlZFxuICAgICAqL1xuICAgIGV2ZW50OiBUYXNrRXZlbnQ7XG4gICAgLyoqXG4gICAgICogU3VjY2VzcyBzdGF0ZSBvZiB0aGUgZXZlbnRcbiAgICAgKi9cbiAgICBzdWNjZXNzOiBib29sZWFuO1xufVxuXG4vKipcbiAqIEBwYXJhbSB0YXNrIGFmZmVjdGVkIFRhc2sgb2JqZWN0XG4gKiBAcGFyYW0gZXZlbnQgdGhlIHJlcG9ydGVkIFRhc2sgZXZlbnRcbiAqIEBwYXJhbSBzdWNjZXNzIHN1Y2Nlc3Mgc3RhdGUgb2YgdGhlIHJlcG9ydGVkIGV2ZW50XG4gKiBAcmV0dXJucyB0aGUgbm90aWZpY2F0aW9uIGluZm9ybWluZyBhYm91dCB0aGUgZXZlbnRcbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGNyZWF0ZVRhc2tFdmVudE5vdGlmaWNhdGlvbih0YXNrOiBUYXNrLCBldmVudDogVGFza0V2ZW50LCBzdWNjZXNzOiBib29sZWFuKTogVGFza0V2ZW50Tm90aWZpY2F0aW9uIHtcbiAgICByZXR1cm4ge1xuICAgICAgICB0YXNrSWQ6IHRhc2suc3RyaW5nSWQsXG4gICAgICAgIHRyYW5zaXRpb25JZDogdGFzay50cmFuc2l0aW9uSWQsXG4gICAgICAgIGV2ZW50LFxuICAgICAgICBzdWNjZXNzXG4gICAgfTtcbn1cbiJdfQ==

package/esm5/lib/task-content/model/task-event.js

@@ -0,0 +1,10 @@
+export var TaskEvent;
+(function (TaskEvent) {
+    TaskEvent["ASSIGN"] = "assign";
+    TaskEvent["FINISH"] = "finish";
+    TaskEvent["CANCEL"] = "cancel";
+    TaskEvent["DELEGATE"] = "delegate";
+    TaskEvent["SET_DATA"] = "set data";
+    TaskEvent["GET_DATA"] = "get data";
+})(TaskEvent || (TaskEvent = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFzay1ldmVudC5qcyIsInNvdXJjZVJvb3QiOiJuZzovL0BuZXRncmlmL2NvbXBvbmVudHMtY29yZS8iLCJzb3VyY2VzIjpbImxpYi90YXNrLWNvbnRlbnQvbW9kZWwvdGFzay1ldmVudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLENBQU4sSUFBWSxTQU9YO0FBUEQsV0FBWSxTQUFTO0lBQ2pCLDhCQUFpQixDQUFBO0lBQ2pCLDhCQUFpQixDQUFBO0lBQ2pCLDhCQUFpQixDQUFBO0lBQ2pCLGtDQUFxQixDQUFBO0lBQ3JCLGtDQUFxQixDQUFBO0lBQ3JCLGtDQUFxQixDQUFBO0FBQ3pCLENBQUMsRUFQVyxTQUFTLEtBQVQsU0FBUyxRQU9wQiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBlbnVtIFRhc2tFdmVudCB7XG4gICAgQVNTSUdOID0gJ2Fzc2lnbicsXG4gICAgRklOSVNIID0gJ2ZpbmlzaCcsXG4gICAgQ0FOQ0VMID0gJ2NhbmNlbCcsXG4gICAgREVMRUdBVEUgPSAnZGVsZWdhdGUnLFxuICAgIFNFVF9EQVRBID0gJ3NldCBkYXRhJyxcbiAgICBHRVRfREFUQSA9ICdnZXQgZGF0YScsXG59XG4iXX0=

package/esm5/lib/task-content/public-api.js

@@ -0,0 +1,21 @@
+/* SERVICES */
+export * from './services/task-event.service';
+export * from './services/field-converter.service';
+export * from './services/task-content.service';
+export * from './services/single-task-content.service';
+export * from './services/unlimited-task-content.service';
+/* MODELS */
+export * from './model/policy';
+export * from './model/task-event-notification';
+export * from './model/task-event';
+export * from './model/field-type-resource';
+export * from './model/task-content-element-type';
+export * from './model/datafield-grid-layout-element';
+export * from './model/async-rendering-configuration';
+export * from './model/async-rendering-configuration-injection-token';
+export * from './model/subgrid';
+export * from './model/split-data-group';
+/* MODULES */
+export * from './task-content/abstract-task-content.component';
+export * from './field-component-resolver/abstract-field-component-resolver.component';
+//# sourceMappingURL=data:application/json;base64,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