@netgrif/components-core 6.0.1

package/esm2015/lib/utility/tests/utility/create-mock-case.js

@@ -0,0 +1,36 @@
+/**
+ * Creates a mock Case instance with the given attributes.
+ *
+ * The attributes are filled with mostly empty values, if you want to make a test that uses some of them,
+ * we recommend setting them yourself, as the returned object might change between versions.
+ */
+export function createMockCase(stringId = 'stringId', processIdentifier = 'processIdentifier', title = 'title', petriNetId = 'petriNetId') {
+    return {
+        lastModified: [],
+        visualId: '',
+        petriNetObjectId: {
+            timestamp: 0,
+            machineIdentifier: 0,
+            processIdentifier: 0,
+            counter: 0,
+            timeSecond: 0,
+            time: 0,
+            date: 0
+        },
+        processIdentifier,
+        title,
+        color: '',
+        creationDate: [],
+        immediateData: [],
+        author: {
+            email: '',
+            fullName: ''
+        },
+        resetArcTokens: {},
+        stringId,
+        petriNetId,
+        permissions: {},
+        users: {}
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/utility/tests/utility/create-mock-datagroup.js

@@ -0,0 +1,35 @@
+import { DataGroupAlignment } from '../../../resources/interface/data-groups';
+import { DataGroupLayoutType } from '../../../resources/interface/data-group-layout';
+/**
+ * Creates a mock {@link DataGroup} object instance containing the provided fields and having the provided configuration.
+ * @param fields the {@link DataField}s contained in the data group
+ * @param title the optional title of the data group
+ * @param alignment alignment of the fields in non-full rows within the data group (affects flow and legacy layout)
+ * @param layoutType the layout type of the data group
+ * @param compact compacting rule for the data group
+ * @param hideRows row hiding rule for the data group
+ * @param stretch whether the `stretch` property of the data group is enabled or not
+ * @param cols the number of columns of the data group layout
+ * @param parentTaskId the ID of the parent task (if the data group is task-reffed)
+ * @param parentTaskRefId the ID of the parent task ref (if the data group is task-reffed)
+ * @param nestingLevel the nesting level of the data group (if the data group is task-reffed)
+ */
+export function createMockDataGroup(fields, title, alignment = DataGroupAlignment.START, layoutType = DataGroupLayoutType.LEGACY, compact, hideRows, stretch = false, cols = 4, parentTaskId, parentTaskRefId, nestingLevel) {
+    return {
+        fields,
+        title,
+        alignment,
+        stretch,
+        layout: {
+            type: layoutType,
+            rows: 0,
+            compactDirection: compact,
+            hideEmptyRows: hideRows,
+            cols
+        },
+        parentTaskId,
+        parentTaskRefId,
+        nestingLevel,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/utility/tests/utility/create-mock-field.js

@@ -0,0 +1,41 @@
+import { BooleanField } from '../../../data-fields/boolean-field/models/boolean-field';
+import { ButtonField } from '../../../data-fields/button-field/models/button-field';
+import { TemplateAppearance } from '../../../data-fields/models/template-appearance';
+import { MaterialAppearance } from '../../../data-fields/models/material-appearance';
+import { IncrementingCounter } from '../../incrementing-counter';
+import { TaskRefField } from '../../../data-fields/task-ref-field/model/task-ref-field';
+import { FieldTypeResource } from '../../../task-content/model/field-type-resource';
+/**
+ * Creates a mock boolean or button field, with the specified properties
+ * @param visible if `true` the fields behavior is set to `editable`, if `false` the fields behavior is set to `hidden`
+ * @param layout position of the field in the grid layout
+ * @param counterOrStringId if a `string` is provided its value will be used as the fields ID.
+ * If a number is provided the fields ID will be set to 'f<number>'.
+ * If an {@link IncrementingCounter} is provided the ID will follow the same pattern as for the `number` argument,
+ * but the counter will be used to generate the number.
+ * @param fieldType determines what type of field should be generated.
+ * Currently only `boolean`, `button` and `task ref` fields are supported. If an unsupported field type is used an error is thrown.
+ * @param taskRefValue determines the value of the task ref field if a task ref field is generated
+ */
+export function createMockField(visible = true, layout = { x: 0, y: 0, rows: 0, cols: 0 }, counterOrStringId = 0, fieldType = FieldTypeResource.BOOLEAN, taskRefValue = []) {
+    const b = visible ? { editable: true } : { hidden: true };
+    const l = Object.assign(Object.assign({}, layout), { template: TemplateAppearance.MATERIAL, appearance: MaterialAppearance.OUTLINE, offset: 0 });
+    let id;
+    if (counterOrStringId instanceof IncrementingCounter || typeof counterOrStringId === 'number') {
+        id = 'f' + (counterOrStringId instanceof IncrementingCounter ? counterOrStringId.next() : counterOrStringId);
+    }
+    else {
+        id = counterOrStringId;
+    }
+    switch (fieldType) {
+        case FieldTypeResource.BOOLEAN:
+            return new BooleanField(id, 'title', false, b, '', '', l);
+        case FieldTypeResource.BUTTON:
+            return new ButtonField(id, 'title', b, 0, '', '', l);
+        case FieldTypeResource.TASK_REF:
+            return new TaskRefField(id, 'title', taskRefValue, b, '', '', l);
+        default:
+            throw new Error(`createMockField does not currently support fields of type '${fieldType}'`);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/utility/tests/utility/create-mock-get-data-outcome.js

@@ -0,0 +1,15 @@
+import { createMockTask } from './create-mock-task';
+import { createMockNet } from './create-mock-net';
+import { createMockCase } from './create-mock-case';
+import { createMockField } from './create-mock-field';
+export function createMockGetDataOutcome(data = [createMockField()], task = createMockTask(), net = createMockNet(), aCase = createMockCase(), outcomes = []) {
+    return {
+        net,
+        aCase,
+        task,
+        outcomes,
+        message: 'Mock get data event outcome',
+        data
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/utility/tests/utility/create-mock-immediate-data.js

@@ -0,0 +1,15 @@
+/**
+ * Creates a mock ImmediateData instance with the given attributes.
+ *
+ * The attributes are filled with mostly empty values, if you want to make a test that uses some of them,
+ * we recommend setting them yourself, as the returned object might change between versions.
+ */
+export function createMockImmediateData(importId = 'importId', value = '', allowedNets) {
+    return {
+        stringId: importId,
+        type: '',
+        value,
+        allowedNets
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3JlYXRlLW1vY2staW1tZWRpYXRlLWRhdGEuanMiLCJzb3VyY2VSb290Ijoibmc6Ly9AbmV0Z3JpZi9jb21wb25lbnRzLWNvcmUvIiwic291cmNlcyI6WyJsaWIvdXRpbGl0eS90ZXN0cy91dGlsaXR5L2NyZWF0ZS1tb2NrLWltbWVkaWF0ZS1kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBOzs7OztHQUtHO0FBQ0gsTUFBTSxVQUFVLHVCQUF1QixDQUFDLFFBQVEsR0FBRyxVQUFVLEVBQUUsUUFBYSxFQUFFLEVBQUUsV0FBMkI7SUFDdkcsT0FBTztRQUNILFFBQVEsRUFBRSxRQUFRO1FBQ2xCLElBQUksRUFBRSxFQUFFO1FBQ1IsS0FBSztRQUNMLFdBQVc7S0FDZCxDQUFDO0FBQ04sQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7SW1tZWRpYXRlRGF0YX0gZnJvbSAnLi4vLi4vLi4vcmVzb3VyY2VzL2ludGVyZmFjZS9pbW1lZGlhdGUtZGF0YSc7XG5cbi8qKlxuICogQ3JlYXRlcyBhIG1vY2sgSW1tZWRpYXRlRGF0YSBpbnN0YW5jZSB3aXRoIHRoZSBnaXZlbiBhdHRyaWJ1dGVzLlxuICpcbiAqIFRoZSBhdHRyaWJ1dGVzIGFyZSBmaWxsZWQgd2l0aCBtb3N0bHkgZW1wdHkgdmFsdWVzLCBpZiB5b3Ugd2FudCB0byBtYWtlIGEgdGVzdCB0aGF0IHVzZXMgc29tZSBvZiB0aGVtLFxuICogd2UgcmVjb21tZW5kIHNldHRpbmcgdGhlbSB5b3Vyc2VsZiwgYXMgdGhlIHJldHVybmVkIG9iamVjdCBtaWdodCBjaGFuZ2UgYmV0d2VlbiB2ZXJzaW9ucy5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGNyZWF0ZU1vY2tJbW1lZGlhdGVEYXRhKGltcG9ydElkID0gJ2ltcG9ydElkJywgdmFsdWU6IGFueSA9ICcnLCBhbGxvd2VkTmV0cz86IEFycmF5PHN0cmluZz4pOiBJbW1lZGlhdGVEYXRhIHtcbiAgICByZXR1cm4ge1xuICAgICAgICBzdHJpbmdJZDogaW1wb3J0SWQsXG4gICAgICAgIHR5cGU6ICcnLFxuICAgICAgICB2YWx1ZSxcbiAgICAgICAgYWxsb3dlZE5ldHNcbiAgICB9O1xufVxuIl19

package/esm2015/lib/utility/tests/utility/create-mock-net.js

@@ -0,0 +1,27 @@
+import { Net } from '../../../process/net';
+/**
+ * Creates a mock Net instance with the given attributes.
+ *
+ * The attributes are filled with mostly empty values, if you want to make a test that uses some of them,
+ * we recommend setting them yourself, as the returned object might change between versions.
+ */
+export function createMockNet(stringId = 'stringId', identifier = 'identifier', title = 'title', roles = [], transitions = [], immediateData = []) {
+    const net = new Net({
+        stringId,
+        title,
+        identifier,
+        version: '1.0.0',
+        initials: 'NET',
+        defaultCaseName: '',
+        createdDate: [2021, 2, 4, 12, 50, 0, 1612443000],
+        author: {
+            email: '',
+            fullName: ''
+        },
+        immediateData
+    });
+    net.roles = roles;
+    net.transitions = transitions.map(t => (Object.assign(Object.assign({}, t), { petriNetId: '', immediateData: [] })));
+    return net;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/utility/tests/utility/create-mock-page.js

@@ -0,0 +1,23 @@
+/**
+ * @param content the contents of the page
+ * @returns a mock Page object with the size equivalent to the number of elements provided in the attribute.
+ * If the content is empty the `content` attribute of the returned object is set to an empty object to mimic backend behavior.
+ */
+export function createMockPage(content = []) {
+    const page = {
+        content: {},
+        pagination: {
+            size: 1,
+            totalElements: 0,
+            totalPages: 1,
+            number: 0
+        }
+    };
+    if (content.length > 0) {
+        page.content = content;
+        page.pagination.size = content.length;
+        page.pagination.totalElements = content.length;
+    }
+    return page;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3JlYXRlLW1vY2stcGFnZS5qcyIsInNvdXJjZVJvb3QiOiJuZzovL0BuZXRncmlmL2NvbXBvbmVudHMtY29yZS8iLCJzb3VyY2VzIjpbImxpYi91dGlsaXR5L3Rlc3RzL3V0aWxpdHkvY3JlYXRlLW1vY2stcGFnZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQTs7OztHQUlHO0FBQ0gsTUFBTSxVQUFVLGNBQWMsQ0FBSSxVQUFvQixFQUFFO0lBQ3BELE1BQU0sSUFBSSxHQUFZO1FBQ2xCLE9BQU8sRUFBRSxFQUFTO1FBQ2xCLFVBQVUsRUFBRTtZQUNSLElBQUksRUFBRSxDQUFDO1lBQ1AsYUFBYSxFQUFFLENBQUM7WUFDaEIsVUFBVSxFQUFFLENBQUM7WUFDYixNQUFNLEVBQUUsQ0FBQztTQUNaO0tBQ0osQ0FBQztJQUNGLElBQUksT0FBTyxDQUFDLE1BQU0sR0FBRyxDQUFDLEVBQUU7UUFDcEIsSUFBSSxDQUFDLE9BQU8sR0FBRyxPQUFPLENBQUM7UUFDdkIsSUFBSSxDQUFDLFVBQVUsQ0FBQyxJQUFJLEdBQUcsT0FBTyxDQUFDLE1BQU0sQ0FBQztRQUN0QyxJQUFJLENBQUMsVUFBVSxDQUFDLGFBQWEsR0FBRyxPQUFPLENBQUMsTUFBTSxDQUFDO0tBQ2xEO0lBQ0QsT0FBTyxJQUFJLENBQUM7QUFDaEIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7UGFnZX0gZnJvbSAnLi4vLi4vLi4vcmVzb3VyY2VzL2ludGVyZmFjZS9wYWdlJztcblxuLyoqXG4gKiBAcGFyYW0gY29udGVudCB0aGUgY29udGVudHMgb2YgdGhlIHBhZ2VcbiAqIEByZXR1cm5zIGEgbW9jayBQYWdlIG9iamVjdCB3aXRoIHRoZSBzaXplIGVxdWl2YWxlbnQgdG8gdGhlIG51bWJlciBvZiBlbGVtZW50cyBwcm92aWRlZCBpbiB0aGUgYXR0cmlidXRlLlxuICogSWYgdGhlIGNvbnRlbnQgaXMgZW1wdHkgdGhlIGBjb250ZW50YCBhdHRyaWJ1dGUgb2YgdGhlIHJldHVybmVkIG9iamVjdCBpcyBzZXQgdG8gYW4gZW1wdHkgb2JqZWN0IHRvIG1pbWljIGJhY2tlbmQgYmVoYXZpb3IuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBjcmVhdGVNb2NrUGFnZTxUPihjb250ZW50OiBBcnJheTxUPiA9IFtdKTogUGFnZTxUPiB7XG4gICAgY29uc3QgcGFnZTogUGFnZTxUPiA9IHtcbiAgICAgICAgY29udGVudDoge30gYXMgYW55LFxuICAgICAgICBwYWdpbmF0aW9uOiB7XG4gICAgICAgICAgICBzaXplOiAxLFxuICAgICAgICAgICAgdG90YWxFbGVtZW50czogMCxcbiAgICAgICAgICAgIHRvdGFsUGFnZXM6IDEsXG4gICAgICAgICAgICBudW1iZXI6IDBcbiAgICAgICAgfVxuICAgIH07XG4gICAgaWYgKGNvbnRlbnQubGVuZ3RoID4gMCkge1xuICAgICAgICBwYWdlLmNvbnRlbnQgPSBjb250ZW50O1xuICAgICAgICBwYWdlLnBhZ2luYXRpb24uc2l6ZSA9IGNvbnRlbnQubGVuZ3RoO1xuICAgICAgICBwYWdlLnBhZ2luYXRpb24udG90YWxFbGVtZW50cyA9IGNvbnRlbnQubGVuZ3RoO1xuICAgIH1cbiAgICByZXR1cm4gcGFnZTtcbn1cbiJdfQ==

package/esm2015/lib/utility/tests/utility/create-mock-petri-net-outcome.js

@@ -0,0 +1,14 @@
+import { createMockNet } from './create-mock-net';
+/**
+ * Creates a mock PetriNetEventOutcome with given net and outcomes attributes.
+ *
+ * If attributes are not specified, default values are used.
+ */
+export function createMockPetriNetOutcome(net = createMockNet(), outcomes = []) {
+    return {
+        outcomes,
+        net,
+        message: 'Mock petri net event outcome'
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3JlYXRlLW1vY2stcGV0cmktbmV0LW91dGNvbWUuanMiLCJzb3VyY2VSb290Ijoibmc6Ly9AbmV0Z3JpZi9jb21wb25lbnRzLWNvcmUvIiwic291cmNlcyI6WyJsaWIvdXRpbGl0eS90ZXN0cy91dGlsaXR5L2NyZWF0ZS1tb2NrLXBldHJpLW5ldC1vdXRjb21lLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sRUFBQyxhQUFhLEVBQUMsTUFBTSxtQkFBbUIsQ0FBQztBQUdoRDs7OztHQUlHO0FBQ0gsTUFBTSxVQUFVLHlCQUF5QixDQUFDLE1BQVcsYUFBYSxFQUFFLEVBQUUsV0FBZ0MsRUFBRTtJQUNwRyxPQUFPO1FBQ0gsUUFBUTtRQUNSLEdBQUc7UUFDSCxPQUFPLEVBQUUsOEJBQThCO0tBQ2xCLENBQUM7QUFDOUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7UGV0cmlOZXRFdmVudE91dGNvbWV9IGZyb20gJy4uLy4uLy4uL2V2ZW50L21vZGVsL2V2ZW50LW91dGNvbWVzL3BldHJpbmV0LW91dGNvbWVzL3BldHJpLW5ldC1ldmVudC1vdXRjb21lJztcbmltcG9ydCB7Y3JlYXRlTW9ja05ldH0gZnJvbSAnLi9jcmVhdGUtbW9jay1uZXQnO1xuaW1wb3J0IHtOZXR9IGZyb20gJy4uLy4uLy4uL3Byb2Nlc3MvbmV0JztcbmltcG9ydCB7RXZlbnRPdXRjb21lfSBmcm9tICcuLi8uLi8uLi9yZXNvdXJjZXMvaW50ZXJmYWNlL2V2ZW50LW91dGNvbWUnO1xuLyoqXG4gKiBDcmVhdGVzIGEgbW9jayBQZXRyaU5ldEV2ZW50T3V0Y29tZSB3aXRoIGdpdmVuIG5ldCBhbmQgb3V0Y29tZXMgYXR0cmlidXRlcy5cbiAqXG4gKiBJZiBhdHRyaWJ1dGVzIGFyZSBub3Qgc3BlY2lmaWVkLCBkZWZhdWx0IHZhbHVlcyBhcmUgdXNlZC5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGNyZWF0ZU1vY2tQZXRyaU5ldE91dGNvbWUobmV0OiBOZXQgPSBjcmVhdGVNb2NrTmV0KCksIG91dGNvbWVzOiBBcnJheTxFdmVudE91dGNvbWU+ID0gW10pIHtcbiAgICByZXR1cm4ge1xuICAgICAgICBvdXRjb21lcyxcbiAgICAgICAgbmV0LFxuICAgICAgICBtZXNzYWdlOiAnTW9jayBwZXRyaSBuZXQgZXZlbnQgb3V0Y29tZSdcbiAgICB9IGFzIFBldHJpTmV0RXZlbnRPdXRjb21lO1xufVxuIl19

package/esm2015/lib/utility/tests/utility/create-mock-set-data-outcome.js

@@ -0,0 +1,19 @@
+import { createMockTask } from './create-mock-task';
+import { createMockNet } from './create-mock-net';
+import { createMockCase } from './create-mock-case';
+/**
+ * Creates a mock TaskEventOutcome with given changedFields, task, net, case and outcomes attributes.
+ *
+ * If attributes are not specified, default values are used.
+ */
+export function createMockSetDataOutcome(changedFields = { changedFields: {} }, task = createMockTask(), net = createMockNet(), aCase = createMockCase(), outcomes = []) {
+    return {
+        net,
+        aCase,
+        task,
+        outcomes,
+        message: 'Mock set data event outcome',
+        changedFields,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/utility/tests/utility/create-mock-task-outcome.js

@@ -0,0 +1,18 @@
+import { createMockNet } from './create-mock-net';
+import { createMockCase } from './create-mock-case';
+import { createMockTask } from './create-mock-task';
+/**
+ * Creates a mock TaskEventOutcome with given task, net, case and outcomes attributes.
+ *
+ * If attributes are not specified, default values are used.
+ */
+export function createMockTaskOutcome(task = createMockTask(), net = createMockNet(), aCase = createMockCase(), outcomes = []) {
+    return {
+        outcomes,
+        task,
+        aCase,
+        net,
+        message: 'Mock case event outcome'
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/utility/tests/utility/create-mock-task.js

@@ -0,0 +1,34 @@
+import { AssignPolicy, DataFocusPolicy, FinishPolicy } from '../../../task-content/model/policy';
+/**
+ * Creates a mock Task instance with the given attributes.
+ *
+ * The attributes are filled with mostly empty values, if you want to make a test that uses some of them,
+ * we recommend setting them yourself, as the returned object might change between versions.
+ */
+export function createMockTask(stringId = 'stringId', title = 'taskTitle', transitionId = 'transitionId', cols = 4) {
+    return {
+        caseId: 'string',
+        transitionId,
+        title,
+        caseColor: 'string',
+        caseTitle: 'string',
+        user: undefined,
+        roles: {},
+        users: {},
+        userRefs: {},
+        startDate: undefined,
+        finishDate: undefined,
+        assignPolicy: AssignPolicy.manual,
+        dataFocusPolicy: DataFocusPolicy.manual,
+        finishPolicy: FinishPolicy.manual,
+        stringId,
+        layout: {
+            offset: 0,
+            rows: 0,
+            cols
+        },
+        dataGroups: [],
+        _links: {}
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3JlYXRlLW1vY2stdGFzay5qcyIsInNvdXJjZVJvb3QiOiJuZzovL0BuZXRncmlmL2NvbXBvbmVudHMtY29yZS8iLCJzb3VyY2VzIjpbImxpYi91dGlsaXR5L3Rlc3RzL3V0aWxpdHkvY3JlYXRlLW1vY2stdGFzay50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQUMsWUFBWSxFQUFFLGVBQWUsRUFBRSxZQUFZLEVBQUMsTUFBTSxvQ0FBb0MsQ0FBQztBQUUvRjs7Ozs7R0FLRztBQUNILE1BQU0sVUFBVSxjQUFjLENBQUMsUUFBUSxHQUFHLFVBQVUsRUFDckIsS0FBSyxHQUFHLFdBQVcsRUFDbkIsWUFBWSxHQUFHLGNBQWMsRUFDN0IsSUFBSSxHQUFHLENBQUM7SUFDbkMsT0FBTztRQUNILE1BQU0sRUFBRSxRQUFRO1FBQ2hCLFlBQVk7UUFDWixLQUFLO1FBQ0wsU0FBUyxFQUFFLFFBQVE7UUFDbkIsU0FBUyxFQUFFLFFBQVE7UUFDbkIsSUFBSSxFQUFFLFNBQVM7UUFDZixLQUFLLEVBQUUsRUFBRTtRQUNULEtBQUssRUFBRSxFQUFFO1FBQ1QsUUFBUSxFQUFFLEVBQUU7UUFDWixTQUFTLEVBQUUsU0FBUztRQUNwQixVQUFVLEVBQUUsU0FBUztRQUNyQixZQUFZLEVBQUUsWUFBWSxDQUFDLE1BQU07UUFDakMsZUFBZSxFQUFFLGVBQWUsQ0FBQyxNQUFNO1FBQ3ZDLFlBQVksRUFBRSxZQUFZLENBQUMsTUFBTTtRQUNqQyxRQUFRO1FBQ1IsTUFBTSxFQUFFO1lBQ0osTUFBTSxFQUFFLENBQUM7WUFDVCxJQUFJLEVBQUUsQ0FBQztZQUNQLElBQUk7U0FDUDtRQUNELFVBQVUsRUFBRSxFQUFFO1FBQ2QsTUFBTSxFQUFFLEVBQUU7S0FDYixDQUFDO0FBQ04sQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7VGFza30gZnJvbSAnLi4vLi4vLi4vcmVzb3VyY2VzL2ludGVyZmFjZS90YXNrJztcbmltcG9ydCB7QXNzaWduUG9saWN5LCBEYXRhRm9jdXNQb2xpY3ksIEZpbmlzaFBvbGljeX0gZnJvbSAnLi4vLi4vLi4vdGFzay1jb250ZW50L21vZGVsL3BvbGljeSc7XG5cbi8qKlxuICogQ3JlYXRlcyBhIG1vY2sgVGFzayBpbnN0YW5jZSB3aXRoIHRoZSBnaXZlbiBhdHRyaWJ1dGVzLlxuICpcbiAqIFRoZSBhdHRyaWJ1dGVzIGFyZSBmaWxsZWQgd2l0aCBtb3N0bHkgZW1wdHkgdmFsdWVzLCBpZiB5b3Ugd2FudCB0byBtYWtlIGEgdGVzdCB0aGF0IHVzZXMgc29tZSBvZiB0aGVtLFxuICogd2UgcmVjb21tZW5kIHNldHRpbmcgdGhlbSB5b3Vyc2VsZiwgYXMgdGhlIHJldHVybmVkIG9iamVjdCBtaWdodCBjaGFuZ2UgYmV0d2VlbiB2ZXJzaW9ucy5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGNyZWF0ZU1vY2tUYXNrKHN0cmluZ0lkID0gJ3N0cmluZ0lkJyxcbiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB0aXRsZSA9ICd0YXNrVGl0bGUnLFxuICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHRyYW5zaXRpb25JZCA9ICd0cmFuc2l0aW9uSWQnLFxuICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGNvbHMgPSA0KTogVGFzayB7XG4gICAgcmV0dXJuIHtcbiAgICAgICAgY2FzZUlkOiAnc3RyaW5nJyxcbiAgICAgICAgdHJhbnNpdGlvbklkLFxuICAgICAgICB0aXRsZSxcbiAgICAgICAgY2FzZUNvbG9yOiAnc3RyaW5nJyxcbiAgICAgICAgY2FzZVRpdGxlOiAnc3RyaW5nJyxcbiAgICAgICAgdXNlcjogdW5kZWZpbmVkLFxuICAgICAgICByb2xlczoge30sXG4gICAgICAgIHVzZXJzOiB7fSxcbiAgICAgICAgdXNlclJlZnM6IHt9LFxuICAgICAgICBzdGFydERhdGU6IHVuZGVmaW5lZCxcbiAgICAgICAgZmluaXNoRGF0ZTogdW5kZWZpbmVkLFxuICAgICAgICBhc3NpZ25Qb2xpY3k6IEFzc2lnblBvbGljeS5tYW51YWwsXG4gICAgICAgIGRhdGFGb2N1c1BvbGljeTogRGF0YUZvY3VzUG9saWN5Lm1hbnVhbCxcbiAgICAgICAgZmluaXNoUG9saWN5OiBGaW5pc2hQb2xpY3kubWFudWFsLFxuICAgICAgICBzdHJpbmdJZCxcbiAgICAgICAgbGF5b3V0OiB7XG4gICAgICAgICAgICBvZmZzZXQ6IDAsXG4gICAgICAgICAgICByb3dzOiAwLFxuICAgICAgICAgICAgY29sc1xuICAgICAgICB9LFxuICAgICAgICBkYXRhR3JvdXBzOiBbXSxcbiAgICAgICAgX2xpbmtzOiB7fVxuICAgIH07XG59XG4iXX0=

package/esm2015/lib/view/abstract/page-load-request-context.js

@@ -0,0 +1,25 @@
+/**
+ * Holds the information that accompanies a page load request. These information are held outside of the
+ * service that handles the requests, so that state information about multiple requests can be handled independently of each other.
+ */
+export class PageLoadRequestContext {
+    /**
+     * @param requestFilter the {@link Filter} that is used by the request. Context holds the passed reference.
+     * @param requestPagination the {@link Pagination} that is used by the request.
+     * Context creates a local copy of the passed objects content.
+     * @param clearLoaded whether the existing tasks or cases should be cleared and replaced by the result of this request.
+     * @param reloadCurrentTaskPage whether the current page of tasks should be updated with the result of the current request.
+     * Does not affect case requests.
+     */
+    constructor(requestFilter, requestPagination, clearLoaded = false, reloadCurrentTaskPage = false, force = false) {
+        this.filter = requestFilter;
+        this.pagination = Object.assign({}, requestPagination);
+        this.clearLoaded = clearLoaded;
+        this.reloadCurrentTaskPage = reloadCurrentTaskPage;
+        this.force = force;
+    }
+    get pageNumber() {
+        return this.pagination && this.pagination.number;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/view/abstract/sortable-view.js

@@ -0,0 +1,62 @@
+import { HeaderColumnType } from '../../header/models/header-column';
+import { HeaderChangeType } from '../../header/models/user-changes/header-change-type';
+import { SearchIndex } from '../../search/models/search-index';
+export class SortableView {
+    constructor(_resolver) {
+        this._resolver = _resolver;
+        this._lastHeaderSearchState = {
+            columnType: undefined,
+            fieldIdentifier: '',
+            sortDirection: '',
+            columnIdentifier: -1,
+            fieldType: undefined
+        };
+    }
+    ngOnDestroy() {
+        if (this._subHeader) {
+            this._subHeader.unsubscribe();
+        }
+    }
+    registerHeaderChange(headerChange$) {
+        this._subHeader = headerChange$.subscribe((header) => {
+            if (!header) {
+                return;
+            }
+            if (header.changeType === HeaderChangeType.SORT || header.changeType === HeaderChangeType.SEARCH) {
+                if (header.changeType === HeaderChangeType.SORT) {
+                    this._lastHeaderSearchState = header.description;
+                }
+                // TODO we might not need to search all the time, do some filtering
+                this.reload();
+            }
+        });
+    }
+    addSortParams(params) {
+        if (this._lastHeaderSearchState.sortDirection !== '') {
+            return params.set('sort', `${this.getSortId()},${this._lastHeaderSearchState.sortDirection}`);
+        }
+        else {
+            return params.set('sort', this.getDefaultSortParam());
+        }
+    }
+    getSortId() {
+        if (this._lastHeaderSearchState.columnType === HeaderColumnType.META) {
+            return this.getMetaFieldSortId();
+        }
+        else {
+            switch (this._lastHeaderSearchState.fieldType) {
+                case 'number':
+                    return this._resolver.getIndex(this._lastHeaderSearchState.fieldIdentifier, SearchIndex.NUMBER);
+                case 'date':
+                case 'dateTime':
+                    return this._resolver.getIndex(this._lastHeaderSearchState.fieldIdentifier, SearchIndex.TIMESTAMP);
+                case 'user':
+                case 'userList':
+                    return this._resolver.getIndex(this._lastHeaderSearchState.fieldIdentifier, SearchIndex.FULL_NAME, true);
+                default:
+                    return this._resolver.getIndex(this._lastHeaderSearchState.fieldIdentifier, SearchIndex.FULLTEXT, true);
+            }
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/view/abstract/view-with-headers.js

@@ -0,0 +1,20 @@
+import { ReplaySubject } from 'rxjs';
+export class ViewWithHeaders {
+    constructor(_sortableView) {
+        this._sortableView = _sortableView;
+        this._selectedHeaders$ = new ReplaySubject(1);
+    }
+    get selectedHeaders$() {
+        return this._selectedHeaders$.asObservable();
+    }
+    initializeHeader(headerComponent) {
+        headerComponent.headerService.selectedHeaders$.subscribe(selectedHeaders => this._selectedHeaders$.next(selectedHeaders));
+        if (!!this._sortableView) {
+            this._sortableView.registerHeaderChange(headerComponent.headerService.headerChange$);
+        }
+    }
+    ngOnDestroy() {
+        this._selectedHeaders$.complete();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/view/case-view/abstract-case-view.js

@@ -0,0 +1,40 @@
+import { HeaderType } from '../../header/models/header-type';
+import { ViewWithHeaders } from '../abstract/view-with-headers';
+export class AbstractCaseView extends ViewWithHeaders {
+    constructor(_caseViewService, _overflowService, _authority = [{ authority: 'ROLE_USER' }], _newCaseCreationConfig = {
+        enableCaseTitle: true,
+        isCaseTitleRequired: true
+    }) {
+        super(_caseViewService);
+        this._caseViewService = _caseViewService;
+        this._overflowService = _overflowService;
+        this._authority = _authority;
+        this._newCaseCreationConfig = _newCaseCreationConfig;
+        this.MINIMAL_OFFSET = 120;
+        this.headerType = HeaderType.CASE;
+        this._caseViewService.loading$.subscribe(loading => {
+            this.loading = loading;
+        });
+        this.cases$ = this._caseViewService.cases$;
+        this.authorityToCreate = _authority.map(a => a.authority);
+    }
+    createNewCase() {
+        if (this._newCaseCreationConfig.enableCaseTitle === false && this._caseViewService.getAllowedNetsCount() === 1) {
+            return this._caseViewService.createDefaultNewCase();
+        }
+        else {
+            return this._caseViewService.createNewCase(this._newCaseCreationConfig);
+        }
+    }
+    hasAuthority() {
+        return (this._caseViewService.hasAuthority(this.authorityToCreate) && this._caseViewService.getAllowedNetsCount() > 0);
+    }
+    getWidth() {
+        return (this._overflowService && this._overflowService.overflowMode && this._overflowService.columnCount) ?
+            `${this._overflowService.columnCount * this._overflowService.columnWidth + this.MINIMAL_OFFSET}px` : '100%';
+    }
+    getOverflowStatus() {
+        return this._overflowService ? this._overflowService.overflowMode : false;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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