@netgrif/components-core 6.0.1

package/esm2015/lib/utility/grid-layout/grid-layout-helper.js

@@ -0,0 +1,76 @@
+import { GridFiller } from './model/grid-filler';
+export class GridLayoutHelper {
+    constructor(_log) {
+        this._log = _log;
+    }
+    static addGridRows(grid, newRowCount, columnCount) {
+        while (grid.length < newRowCount) {
+            grid.push(GridLayoutHelper.newGridRow(columnCount));
+        }
+    }
+    static newGridRow(cols) {
+        return [new GridFiller(0, cols - 1)];
+    }
+    fillBlankSpace(gridElements, columnCount, elementVisibilityCondition = () => true) {
+        const grid = [];
+        gridElements.forEach(element => {
+            const elementRowEnd = element.layout.y + element.layout.rows - 1;
+            const elementColEnd = element.layout.x + element.layout.cols - 1;
+            if (elementRowEnd >= grid.length) {
+                GridLayoutHelper.addGridRows(grid, elementRowEnd + 1, columnCount);
+            }
+            for (let row = element.layout.y; row <= elementRowEnd; row++) {
+                if (!elementVisibilityCondition(element)) {
+                    for (const filler of grid[row]) {
+                        filler.isIntentional = false;
+                    }
+                }
+                else {
+                    const newFillers = [];
+                    for (const filler of grid[row]) {
+                        newFillers.push(...filler.fillersAfterCover(element.layout.x, elementColEnd));
+                    }
+                    grid[row] = newFillers;
+                }
+            }
+        });
+        const result = gridElements.filter(element => elementVisibilityCondition(element))
+            .map(element => ({
+            item: element,
+            type: element.type,
+            layout: element.layout
+        }));
+        let encounteredFirst = false;
+        for (let y = grid.length - 1; y >= 0; y--) {
+            const row = grid[y];
+            if (row.length === 0) {
+                encounteredFirst = true;
+            }
+            row.forEach(filler => {
+                if (!encounteredFirst && !filler.isFullWidth(columnCount)) {
+                    encounteredFirst = true;
+                }
+                if (encounteredFirst && (filler.isIntentional || !filler.isFullWidth(columnCount))) {
+                    result.push(filler.convertToGridElement(y));
+                }
+            });
+        }
+        return result.sort((a, b) => {
+            if (a.layout.y < b.layout.y) {
+                return -1;
+            }
+            else if (a.layout.y > b.layout.y) {
+                return 1;
+            }
+            if (a.layout.x < b.layout.x) {
+                return -1;
+            }
+            else if (a.layout.x > b.layout.x) {
+                return 1;
+            }
+            this._log.warn('Two elements in grid layout have the same X and Y coordinates! Make sure your data is valid.');
+            return 0;
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"grid-layout-helper.js","sourceRoot":"ng://@netgrif/components-core/","sources":["lib/utility/grid-layout/grid-layout-helper.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,UAAU,EAAC,MAAM,qBAAqB,CAAC;AAK/C,MAAM,OAAO,gBAAgB;IAEzB,YAAoB,IAAmB;QAAnB,SAAI,GAAJ,IAAI,CAAe;IACvC,CAAC;IAEO,MAAM,CAAC,WAAW,CAAC,IAA8B,EAAE,WAAmB,EAAE,WAAmB;QAC/F,OAAO,IAAI,CAAC,MAAM,GAAG,WAAW,EAAE;YAC9B,IAAI,CAAC,IAAI,CAAC,gBAAgB,CAAC,UAAU,CAAC,WAAW,CAAC,CAAC,CAAC;SACvD;IACL,CAAC;IAEO,MAAM,CAAC,UAAU,CAAC,IAAY;QAClC,OAAO,CAAC,IAAI,UAAU,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,CAAC,CAAC,CAAC;IACzC,CAAC;IAEM,cAAc,CAAC,YAAgC,EAChC,WAAmB,EACnB,6BAAwD,GAAG,EAAE,CAAC,IAAI;QACpF,MAAM,IAAI,GAA6B,EAAE,CAAC;QAE1C,YAAY,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE;YAC3B,MAAM,aAAa,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,IAAI,GAAG,CAAC,CAAC;YACjE,MAAM,aAAa,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,IAAI,GAAG,CAAC,CAAC;YACjE,IAAI,aAAa,IAAI,IAAI,CAAC,MAAM,EAAE;gBAC9B,gBAAgB,CAAC,WAAW,CAAC,IAAI,EAAE,aAAa,GAAG,CAAC,EAAE,WAAW,CAAC,CAAC;aACtE;YACD,KAAK,IAAI,GAAG,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,EAAE,GAAG,IAAI,aAAa,EAAE,GAAG,EAAE,EAAE;gBAC1D,IAAI,CAAC,0BAA0B,CAAC,OAAO,CAAC,EAAE;oBACtC,KAAK,MAAM,MAAM,IAAI,IAAI,CAAC,GAAG,CAAC,EAAE;wBAC5B,MAAM,CAAC,aAAa,GAAG,KAAK,CAAC;qBAChC;iBACJ;qBAAM;oBACH,MAAM,UAAU,GAAG,EAAE,CAAC;oBACtB,KAAK,MAAM,MAAM,IAAI,IAAI,CAAC,GAAG,CAAC,EAAE;wBAC5B,UAAU,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC,iBAAiB,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,EAAE,aAAa,CAAC,CAAC,CAAC;qBACjF;oBACD,IAAI,CAAC,GAAG,CAAC,GAAG,UAAU,CAAC;iBAC1B;aACJ;QACL,CAAC,CAAC,CAAC;QAEH,MAAM,MAAM,GAAwC,YAAY,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,CAAC,0BAA0B,CAAC,OAAO,CAAC,CAAC;aAClH,GAAG,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC;YACb,IAAI,EAAE,OAAO;YACb,IAAI,EAAE,OAAO,CAAC,IAAI;YAClB,MAAM,EAAE,OAAO,CAAC,MAAM;SACzB,CAAC,CAAC,CAAC;QACR,IAAI,gBAAgB,GAAG,KAAK,CAAC;QAC7B,KAAK,IAAI,CAAC,GAAG,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,EAAE;YACvC,MAAM,GAAG,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;YACpB,IAAI,GAAG,CAAC,MAAM,KAAK,CAAC,EAAE;gBAClB,gBAAgB,GAAG,IAAI,CAAC;aAC3B;YACD,GAAG,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE;gBACjB,IAAI,CAAC,gBAAgB,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,WAAW,CAAC,EAAE;oBACvD,gBAAgB,GAAG,IAAI,CAAC;iBAC3B;gBACD,IAAI,gBAAgB,IAAI,CAAC,MAAM,CAAC,aAAa,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,WAAW,CAAC,CAAC,EAAE;oBAChF,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,oBAAoB,CAAC,CAAC,CAAC,CAAC,CAAC;iBAC/C;YACL,CAAC,CAAC,CAAC;SACN;QAED,OAAO,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE;YACxB,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC,EAAE;gBACzB,OAAO,CAAC,CAAC,CAAC;aACb;iBAAM,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC,EAAE;gBAChC,OAAO,CAAC,CAAC;aACZ;YACD,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC,EAAE;gBACzB,OAAO,CAAC,CAAC,CAAC;aACb;iBAAM,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC,EAAE;gBAChC,OAAO,CAAC,CAAC;aACZ;YACD,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,8FAA8F,CAAC,CAAC;YAC/G,OAAO,CAAC,CAAC;QACb,CAAC,CAAC,CAAC;IACP,CAAC;CAEJ","sourcesContent":["import {GridFiller} from './model/grid-filler';\nimport {GridElementWithItem} from './model/grid-element-with-item';\nimport {GridElement} from './model/grid-element';\nimport {LoggerService} from '../../logger/services/logger.service';\n\nexport class GridLayoutHelper {\n\n    constructor(private _log: LoggerService) {\n    }\n\n    private static addGridRows(grid: Array<Array<GridFiller>>, newRowCount: number, columnCount: number): void {\n        while (grid.length < newRowCount) {\n            grid.push(GridLayoutHelper.newGridRow(columnCount));\n        }\n    }\n\n    private static newGridRow(cols: number): Array<GridFiller> {\n        return [new GridFiller(0, cols - 1)];\n    }\n\n    public fillBlankSpace(gridElements: Array<GridElement>,\n                          columnCount: number,\n                          elementVisibilityCondition: (element: any) => boolean = () => true): Array<GridElementWithItem<unknown>> {\n        const grid: Array<Array<GridFiller>> = [];\n\n        gridElements.forEach(element => {\n            const elementRowEnd = element.layout.y + element.layout.rows - 1;\n            const elementColEnd = element.layout.x + element.layout.cols - 1;\n            if (elementRowEnd >= grid.length) {\n                GridLayoutHelper.addGridRows(grid, elementRowEnd + 1, columnCount);\n            }\n            for (let row = element.layout.y; row <= elementRowEnd; row++) {\n                if (!elementVisibilityCondition(element)) {\n                    for (const filler of grid[row]) {\n                        filler.isIntentional = false;\n                    }\n                } else {\n                    const newFillers = [];\n                    for (const filler of grid[row]) {\n                        newFillers.push(...filler.fillersAfterCover(element.layout.x, elementColEnd));\n                    }\n                    grid[row] = newFillers;\n                }\n            }\n        });\n\n        const result: Array<GridElementWithItem<unknown>> = gridElements.filter(element => elementVisibilityCondition(element))\n            .map(element => ({\n                item: element,\n                type: element.type,\n                layout: element.layout\n            }));\n        let encounteredFirst = false;\n        for (let y = grid.length - 1; y >= 0; y--) {\n            const row = grid[y];\n            if (row.length === 0) {\n                encounteredFirst = true;\n            }\n            row.forEach(filler => {\n                if (!encounteredFirst && !filler.isFullWidth(columnCount)) {\n                    encounteredFirst = true;\n                }\n                if (encounteredFirst && (filler.isIntentional || !filler.isFullWidth(columnCount))) {\n                    result.push(filler.convertToGridElement(y));\n                }\n            });\n        }\n\n        return result.sort((a, b) => {\n            if (a.layout.y < b.layout.y) {\n                return -1;\n            } else if (a.layout.y > b.layout.y) {\n                return 1;\n            }\n            if (a.layout.x < b.layout.x) {\n                return -1;\n            } else if (a.layout.x > b.layout.x) {\n                return 1;\n            }\n            this._log.warn('Two elements in grid layout have the same X and Y coordinates! Make sure your data is valid.');\n            return 0;\n        });\n    }\n\n}\n"]}

package/esm2015/lib/utility/grid-layout/model/grid-element-with-item.js

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

package/esm2015/lib/utility/grid-layout/model/grid-element.js

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

package/esm2015/lib/utility/grid-layout/model/grid-filler.js

@@ -0,0 +1,50 @@
+export class GridFiller {
+    constructor(start, end) {
+        this.start = start;
+        this.end = end;
+        this.isIntentional = true;
+    }
+    fillersAfterCover(start, end) {
+        this.isIntentional = false;
+        if (this.start < start) {
+            if (end < this.end) {
+                // split the filler into two
+                const rightHalf = new GridFiller(end + 1, this.end);
+                this.end = start - 1;
+                rightHalf.isIntentional = false;
+                return [this, rightHalf];
+            }
+            else {
+                // end might be cut-off
+                this.end = Math.min(this.end, start - 1);
+                return [this];
+            }
+        }
+        else {
+            if (end < this.end) {
+                // start might be cut-off
+                this.start = Math.max(this.start, end + 1);
+                return [this];
+            }
+            else {
+                // entire filler is covered
+                return [];
+            }
+        }
+    }
+    convertToGridElement(y) {
+        return {
+            type: 'blank',
+            layout: {
+                x: this.start,
+                y,
+                rows: 1,
+                cols: this.end - this.start + 1
+            }
+        };
+    }
+    isFullWidth(width) {
+        return this.start === 0 && this.end === width - 1;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/utility/incrementing-counter.js

@@ -0,0 +1,21 @@
+/**
+ * A counter that returns an incremented value, whenever it is called
+ */
+export class IncrementingCounter {
+    constructor() {
+        this.i = 0;
+    }
+    /**
+     * @returns a number one greater than the previous number. The first call to this method returns `0`.
+     */
+    next() {
+        return this.i++;
+    }
+    /**
+     * @returns the last returned number. If no call to [next()]{@link IncrementingCounter#next} has been made, returns `-1`.
+     */
+    lastUsed() {
+        return this.i - 1;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5jcmVtZW50aW5nLWNvdW50ZXIuanMiLCJzb3VyY2VSb290Ijoibmc6Ly9AbmV0Z3JpZi9jb21wb25lbnRzLWNvcmUvIiwic291cmNlcyI6WyJsaWIvdXRpbGl0eS9pbmNyZW1lbnRpbmctY291bnRlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUNILE1BQU0sT0FBTyxtQkFBbUI7SUFBaEM7UUFDWSxNQUFDLEdBQUcsQ0FBQyxDQUFDO0lBZWxCLENBQUM7SUFiRzs7T0FFRztJQUNJLElBQUk7UUFDUCxPQUFPLElBQUksQ0FBQyxDQUFDLEVBQUUsQ0FBQztJQUNwQixDQUFDO0lBRUQ7O09BRUc7SUFDSSxRQUFRO1FBQ1gsT0FBTyxJQUFJLENBQUMsQ0FBQyxHQUFHLENBQUMsQ0FBQztJQUN0QixDQUFDO0NBQ0oiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEEgY291bnRlciB0aGF0IHJldHVybnMgYW4gaW5jcmVtZW50ZWQgdmFsdWUsIHdoZW5ldmVyIGl0IGlzIGNhbGxlZFxuICovXG5leHBvcnQgY2xhc3MgSW5jcmVtZW50aW5nQ291bnRlciB7XG4gICAgcHJpdmF0ZSBpID0gMDtcblxuICAgIC8qKlxuICAgICAqIEByZXR1cm5zIGEgbnVtYmVyIG9uZSBncmVhdGVyIHRoYW4gdGhlIHByZXZpb3VzIG51bWJlci4gVGhlIGZpcnN0IGNhbGwgdG8gdGhpcyBtZXRob2QgcmV0dXJucyBgMGAuXG4gICAgICovXG4gICAgcHVibGljIG5leHQoKTogbnVtYmVyIHtcbiAgICAgICAgcmV0dXJuIHRoaXMuaSsrO1xuICAgIH1cblxuICAgIC8qKlxuICAgICAqIEByZXR1cm5zIHRoZSBsYXN0IHJldHVybmVkIG51bWJlci4gSWYgbm8gY2FsbCB0byBbbmV4dCgpXXtAbGluayBJbmNyZW1lbnRpbmdDb3VudGVyI25leHR9IGhhcyBiZWVuIG1hZGUsIHJldHVybnMgYC0xYC5cbiAgICAgKi9cbiAgICBwdWJsaWMgbGFzdFVzZWQoKTogbnVtYmVyIHtcbiAgICAgICAgcmV0dXJuIHRoaXMuaSAtIDE7XG4gICAgfVxufVxuIl19

package/esm2015/lib/utility/loading-emitter.js

@@ -0,0 +1,19 @@
+import { BehaviorSubject } from 'rxjs';
+export class LoadingEmitter extends BehaviorSubject {
+    constructor(initial = false) {
+        super(initial);
+    }
+    get isActive() {
+        return this.getValue();
+    }
+    on() {
+        this.next(true);
+    }
+    off() {
+        this.next(false);
+    }
+    toggle() {
+        this.next(!this.getValue());
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9hZGluZy1lbWl0dGVyLmpzIiwic291cmNlUm9vdCI6Im5nOi8vQG5ldGdyaWYvY29tcG9uZW50cy1jb3JlLyIsInNvdXJjZXMiOlsibGliL3V0aWxpdHkvbG9hZGluZy1lbWl0dGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBQyxlQUFlLEVBQUMsTUFBTSxNQUFNLENBQUM7QUFFckMsTUFBTSxPQUFPLGNBQWUsU0FBUSxlQUF3QjtJQUV4RCxZQUFZLE9BQU8sR0FBRyxLQUFLO1FBQ3ZCLEtBQUssQ0FBQyxPQUFPLENBQUMsQ0FBQztJQUNuQixDQUFDO0lBRUQsSUFBVyxRQUFRO1FBQ2YsT0FBTyxJQUFJLENBQUMsUUFBUSxFQUFFLENBQUM7SUFDM0IsQ0FBQztJQUVNLEVBQUU7UUFDTCxJQUFJLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFDO0lBQ3BCLENBQUM7SUFFTSxHQUFHO1FBQ04sSUFBSSxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsQ0FBQztJQUNyQixDQUFDO0lBRU0sTUFBTTtRQUNULElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQyxJQUFJLENBQUMsUUFBUSxFQUFFLENBQUMsQ0FBQztJQUNoQyxDQUFDO0NBQ0oiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge0JlaGF2aW9yU3ViamVjdH0gZnJvbSAncnhqcyc7XG5cbmV4cG9ydCBjbGFzcyBMb2FkaW5nRW1pdHRlciBleHRlbmRzIEJlaGF2aW9yU3ViamVjdDxib29sZWFuPiB7XG5cbiAgICBjb25zdHJ1Y3Rvcihpbml0aWFsID0gZmFsc2UpIHtcbiAgICAgICAgc3VwZXIoaW5pdGlhbCk7XG4gICAgfVxuXG4gICAgcHVibGljIGdldCBpc0FjdGl2ZSgpOiBib29sZWFuIHtcbiAgICAgICAgcmV0dXJuIHRoaXMuZ2V0VmFsdWUoKTtcbiAgICB9XG5cbiAgICBwdWJsaWMgb24oKSB7XG4gICAgICAgIHRoaXMubmV4dCh0cnVlKTtcbiAgICB9XG5cbiAgICBwdWJsaWMgb2ZmKCkge1xuICAgICAgICB0aGlzLm5leHQoZmFsc2UpO1xuICAgIH1cblxuICAgIHB1YmxpYyB0b2dnbGUoKSB7XG4gICAgICAgIHRoaXMubmV4dCghdGhpcy5nZXRWYWx1ZSgpKTtcbiAgICB9XG59XG4iXX0=

package/esm2015/lib/utility/loading-with-filter-emitter.js

@@ -0,0 +1,30 @@
+import { BehaviorSubject, from } from 'rxjs';
+import { reduce } from 'rxjs/operators';
+export class LoadingWithFilterEmitter extends BehaviorSubject {
+    constructor(initial = false) {
+        super(initial);
+        this._loadingStates = new Map();
+    }
+    get isActive() {
+        return this.getValue();
+    }
+    isActiveWithFilter(withFilter) {
+        return !!this._loadingStates.get(withFilter);
+    }
+    on(withFilter) {
+        this.nextValue(withFilter, true);
+    }
+    off(withFilter) {
+        this.nextValue(withFilter, false);
+    }
+    toggle(withFilter) {
+        this.nextValue(withFilter, !this.isActiveWithFilter(withFilter));
+    }
+    nextValue(withFilter, loading) {
+        this._loadingStates.set(withFilter, loading);
+        from(this._loadingStates.values())
+            .pipe(reduce((acc, val) => acc || val, false))
+            .subscribe(result => this.next(result));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/utility/navigation-item-task-filter-factory.js

@@ -0,0 +1,11 @@
+/**
+ * Converts an {@link NAE_NAVIGATION_ITEM_TASK_DATA} injection token into {@link NAE_BASE_FILTER}
+ * @param extractionService
+ * @param navigationItemTaskData a navigation item task containing the aggregated data representing a navigation item
+ */
+export function navigationItemTaskFilterFactory(extractionService, navigationItemTaskData) {
+    return {
+        filter: extractionService.extractCompleteFilterFromData(navigationItemTaskData)
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmF2aWdhdGlvbi1pdGVtLXRhc2stZmlsdGVyLWZhY3RvcnkuanMiLCJzb3VyY2VSb290Ijoibmc6Ly9AbmV0Z3JpZi9jb21wb25lbnRzLWNvcmUvIiwic291cmNlcyI6WyJsaWIvdXRpbGl0eS9uYXZpZ2F0aW9uLWl0ZW0tdGFzay1maWx0ZXItZmFjdG9yeS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFLQTs7OztHQUlHO0FBQ0gsTUFBTSxVQUFVLCtCQUErQixDQUFDLGlCQUEwQyxFQUMxQyxzQkFBd0M7SUFDcEYsT0FBTztRQUNILE1BQU0sRUFBRSxpQkFBaUIsQ0FBQyw2QkFBNkIsQ0FBQyxzQkFBc0IsQ0FBQztLQUNsRixDQUFDO0FBQ04sQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7QmFzZUZpbHRlcn0gZnJvbSAnLi4vc2VhcmNoL21vZGVscy9iYXNlLWZpbHRlcic7XG5pbXBvcnQge05BRV9OQVZJR0FUSU9OX0lURU1fVEFTS19EQVRBfSBmcm9tICcuLi9uYXZpZ2F0aW9uL21vZGVsL2ZpbHRlci1jYXNlLWluamVjdGlvbi10b2tlbic7XG5pbXBvcnQge0RhdGFHcm91cH0gZnJvbSAnLi4vcmVzb3VyY2VzL2ludGVyZmFjZS9kYXRhLWdyb3Vwcyc7XG5pbXBvcnQge0ZpbHRlckV4dHJhY3Rpb25TZXJ2aWNlfSBmcm9tICcuLi9uYXZpZ2F0aW9uL3V0aWxpdHkvZmlsdGVyLWV4dHJhY3Rpb24uc2VydmljZSc7XG5cbi8qKlxuICogQ29udmVydHMgYW4ge0BsaW5rIE5BRV9OQVZJR0FUSU9OX0lURU1fVEFTS19EQVRBfSBpbmplY3Rpb24gdG9rZW4gaW50byB7QGxpbmsgTkFFX0JBU0VfRklMVEVSfVxuICogQHBhcmFtIGV4dHJhY3Rpb25TZXJ2aWNlXG4gKiBAcGFyYW0gbmF2aWdhdGlvbkl0ZW1UYXNrRGF0YSBhIG5hdmlnYXRpb24gaXRlbSB0YXNrIGNvbnRhaW5pbmcgdGhlIGFnZ3JlZ2F0ZWQgZGF0YSByZXByZXNlbnRpbmcgYSBuYXZpZ2F0aW9uIGl0ZW1cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIG5hdmlnYXRpb25JdGVtVGFza0ZpbHRlckZhY3RvcnkoZXh0cmFjdGlvblNlcnZpY2U6IEZpbHRlckV4dHJhY3Rpb25TZXJ2aWNlLFxuICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgbmF2aWdhdGlvbkl0ZW1UYXNrRGF0YTogQXJyYXk8RGF0YUdyb3VwPik6IEJhc2VGaWx0ZXIge1xuICAgIHJldHVybiB7XG4gICAgICAgIGZpbHRlcjogZXh0cmFjdGlvblNlcnZpY2UuZXh0cmFjdENvbXBsZXRlRmlsdGVyRnJvbURhdGEobmF2aWdhdGlvbkl0ZW1UYXNrRGF0YSlcbiAgICB9O1xufVxuIl19

package/esm2015/lib/utility/navigation-item-task-search-categories-factory.js

@@ -0,0 +1,35 @@
+import { UserFilterConstants } from '../filter/models/user-filter-constants';
+import { getFieldFromDataGroups } from './get-field';
+import { FilterType } from '../filter/models/filter-type';
+/**
+ * Creates search categories based on the metadata stored in the filter case
+ * @param categoryResolverService
+ * @param navigationItemTaskData task data of a navigation item task, the data must contain a filter field, that is used
+ * to generate the categories
+ * @param defaultCaseSearchCategories the default case search categories that should be merged with the categories provided by the filter
+ * field, if the filter metadata allow it and the filter is a case filter
+ * @param defaultTaskSearchCategories the default task search categories that should be merged with the categories provided by the filter
+ * field, if the filter metadata allow it and the filter is a task filter
+ */
+export function navigationItemTaskCategoryFactory(categoryResolverService, navigationItemTaskData, defaultCaseSearchCategories, defaultTaskSearchCategories) {
+    const filterField = getFieldFromDataGroups(navigationItemTaskData, UserFilterConstants.FILTER_FIELD_ID);
+    if (filterField === undefined) {
+        throw new Error(`Provided navigation item task data does not contain a filter field with ID '${UserFilterConstants.FILTER_FIELD_ID}'! Search categories cannot be generated from it!`);
+    }
+    const merge = new Set();
+    const cats = filterField.filterMetadata.searchCategories.map(cat => {
+        const category = categoryResolverService.toClass(cat);
+        merge.add(category);
+        return category;
+    });
+    if (filterField.filterMetadata.defaultSearchCategories) {
+        (filterField.filterMetadata.filterType === FilterType.CASE ? defaultCaseSearchCategories : defaultTaskSearchCategories)
+            .forEach(cat => {
+            if (!merge.has(cat)) {
+                cats.push(cat);
+            }
+        });
+    }
+    return cats;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmF2aWdhdGlvbi1pdGVtLXRhc2stc2VhcmNoLWNhdGVnb3JpZXMtZmFjdG9yeS5qcyIsInNvdXJjZVJvb3QiOiJuZzovL0BuZXRncmlmL2NvbXBvbmVudHMtY29yZS8iLCJzb3VyY2VzIjpbImxpYi91dGlsaXR5L25hdmlnYXRpb24taXRlbS10YXNrLXNlYXJjaC1jYXRlZ29yaWVzLWZhY3RvcnkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsT0FBTyxFQUFDLG1CQUFtQixFQUFDLE1BQU0sd0NBQXdDLENBQUM7QUFDM0UsT0FBTyxFQUFDLHNCQUFzQixFQUFDLE1BQU0sYUFBYSxDQUFDO0FBSW5ELE9BQU8sRUFBQyxVQUFVLEVBQUMsTUFBTSw4QkFBOEIsQ0FBQztBQUV4RDs7Ozs7Ozs7O0dBU0c7QUFDSCxNQUFNLFVBQVUsaUNBQWlDLENBQUMsdUJBQWdELEVBQ2hELHNCQUF3QyxFQUN4QywyQkFBdUQsRUFDdkQsMkJBQXVEO0lBQ3JHLE1BQU0sV0FBVyxHQUFHLHNCQUFzQixDQUFDLHNCQUFzQixFQUFFLG1CQUFtQixDQUFDLGVBQWUsQ0FBZ0IsQ0FBQztJQUV2SCxJQUFJLFdBQVcsS0FBSyxTQUFTLEVBQUU7UUFDM0IsTUFBTSxJQUFJLEtBQUssQ0FDWCwrRUFBK0UsbUJBQW1CLENBQUMsZUFDbkcsbURBQW1ELENBQUMsQ0FBQztLQUM1RDtJQUVELE1BQU0sS0FBSyxHQUFHLElBQUksR0FBRyxFQUFFLENBQUM7SUFDeEIsTUFBTSxJQUFJLEdBQUcsV0FBVyxDQUFDLGNBQWMsQ0FBQyxnQkFBZ0IsQ0FBQyxHQUFHLENBQUMsR0FBRyxDQUFDLEVBQUU7UUFDL0QsTUFBTSxRQUFRLEdBQUcsdUJBQXVCLENBQUMsT0FBTyxDQUFDLEdBQUcsQ0FBQyxDQUFDO1FBQ3RELEtBQUssQ0FBQyxHQUFHLENBQUMsUUFBUSxDQUFDLENBQUM7UUFDcEIsT0FBTyxRQUFRLENBQUM7SUFDcEIsQ0FBQyxDQUFDLENBQUM7SUFFSCxJQUFJLFdBQVcsQ0FBQyxjQUFjLENBQUMsdUJBQXVCLEVBQUU7UUFDcEQsQ0FBQyxXQUFXLENBQUMsY0FBYyxDQUFDLFVBQVUsS0FBSyxVQUFVLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQywyQkFBMkIsQ0FBQyxDQUFDLENBQUMsMkJBQTJCLENBQUM7YUFDbEgsT0FBTyxDQUFDLEdBQUcsQ0FBQyxFQUFFO1lBQ1gsSUFBSSxDQUFDLEtBQUssQ0FBQyxHQUFHLENBQUMsR0FBRyxDQUFDLEVBQUU7Z0JBQ2pCLElBQUksQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDLENBQUM7YUFDbEI7UUFDTCxDQUFDLENBQUMsQ0FBQztLQUNWO0lBRUQsT0FBTyxJQUFJLENBQUM7QUFDaEIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7VHlwZX0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQge0NhdGVnb3J5fSBmcm9tICcuLi9zZWFyY2gvbW9kZWxzL2NhdGVnb3J5L2NhdGVnb3J5JztcbmltcG9ydCB7VXNlckZpbHRlckNvbnN0YW50c30gZnJvbSAnLi4vZmlsdGVyL21vZGVscy91c2VyLWZpbHRlci1jb25zdGFudHMnO1xuaW1wb3J0IHtnZXRGaWVsZEZyb21EYXRhR3JvdXBzfSBmcm9tICcuL2dldC1maWVsZCc7XG5pbXBvcnQge0ZpbHRlckZpZWxkfSBmcm9tICcuLi9kYXRhLWZpZWxkcy9maWx0ZXItZmllbGQvbW9kZWxzL2ZpbHRlci1maWVsZCc7XG5pbXBvcnQge0RhdGFHcm91cH0gZnJvbSAnLi4vcmVzb3VyY2VzL2ludGVyZmFjZS9kYXRhLWdyb3Vwcyc7XG5pbXBvcnQge0NhdGVnb3J5UmVzb2x2ZXJTZXJ2aWNlfSBmcm9tICcuLi9zZWFyY2gvY2F0ZWdvcnktZmFjdG9yeS9jYXRlZ29yeS1yZXNvbHZlci5zZXJ2aWNlJztcbmltcG9ydCB7RmlsdGVyVHlwZX0gZnJvbSAnLi4vZmlsdGVyL21vZGVscy9maWx0ZXItdHlwZSc7XG5cbi8qKlxuICogQ3JlYXRlcyBzZWFyY2ggY2F0ZWdvcmllcyBiYXNlZCBvbiB0aGUgbWV0YWRhdGEgc3RvcmVkIGluIHRoZSBmaWx0ZXIgY2FzZVxuICogQHBhcmFtIGNhdGVnb3J5UmVzb2x2ZXJTZXJ2aWNlXG4gKiBAcGFyYW0gbmF2aWdhdGlvbkl0ZW1UYXNrRGF0YSB0YXNrIGRhdGEgb2YgYSBuYXZpZ2F0aW9uIGl0ZW0gdGFzaywgdGhlIGRhdGEgbXVzdCBjb250YWluIGEgZmlsdGVyIGZpZWxkLCB0aGF0IGlzIHVzZWRcbiAqIHRvIGdlbmVyYXRlIHRoZSBjYXRlZ29yaWVzXG4gKiBAcGFyYW0gZGVmYXVsdENhc2VTZWFyY2hDYXRlZ29yaWVzIHRoZSBkZWZhdWx0IGNhc2Ugc2VhcmNoIGNhdGVnb3JpZXMgdGhhdCBzaG91bGQgYmUgbWVyZ2VkIHdpdGggdGhlIGNhdGVnb3JpZXMgcHJvdmlkZWQgYnkgdGhlIGZpbHRlclxuICogZmllbGQsIGlmIHRoZSBmaWx0ZXIgbWV0YWRhdGEgYWxsb3cgaXQgYW5kIHRoZSBmaWx0ZXIgaXMgYSBjYXNlIGZpbHRlclxuICogQHBhcmFtIGRlZmF1bHRUYXNrU2VhcmNoQ2F0ZWdvcmllcyB0aGUgZGVmYXVsdCB0YXNrIHNlYXJjaCBjYXRlZ29yaWVzIHRoYXQgc2hvdWxkIGJlIG1lcmdlZCB3aXRoIHRoZSBjYXRlZ29yaWVzIHByb3ZpZGVkIGJ5IHRoZSBmaWx0ZXJcbiAqIGZpZWxkLCBpZiB0aGUgZmlsdGVyIG1ldGFkYXRhIGFsbG93IGl0IGFuZCB0aGUgZmlsdGVyIGlzIGEgdGFzayBmaWx0ZXJcbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIG5hdmlnYXRpb25JdGVtVGFza0NhdGVnb3J5RmFjdG9yeShjYXRlZ29yeVJlc29sdmVyU2VydmljZTogQ2F0ZWdvcnlSZXNvbHZlclNlcnZpY2UsXG4gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIG5hdmlnYXRpb25JdGVtVGFza0RhdGE6IEFycmF5PERhdGFHcm91cD4sXG4gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGRlZmF1bHRDYXNlU2VhcmNoQ2F0ZWdvcmllczogQXJyYXk8VHlwZTxDYXRlZ29yeTxhbnk+Pj4sXG4gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGRlZmF1bHRUYXNrU2VhcmNoQ2F0ZWdvcmllczogQXJyYXk8VHlwZTxDYXRlZ29yeTxhbnk+Pj4pOiBBcnJheTxUeXBlPENhdGVnb3J5PGFueT4+PiB7XG4gICAgY29uc3QgZmlsdGVyRmllbGQgPSBnZXRGaWVsZEZyb21EYXRhR3JvdXBzKG5hdmlnYXRpb25JdGVtVGFza0RhdGEsIFVzZXJGaWx0ZXJDb25zdGFudHMuRklMVEVSX0ZJRUxEX0lEKSBhcyBGaWx0ZXJGaWVsZDtcblxuICAgIGlmIChmaWx0ZXJGaWVsZCA9PT0gdW5kZWZpbmVkKSB7XG4gICAgICAgIHRocm93IG5ldyBFcnJvcihcbiAgICAgICAgICAgIGBQcm92aWRlZCBuYXZpZ2F0aW9uIGl0ZW0gdGFzayBkYXRhIGRvZXMgbm90IGNvbnRhaW4gYSBmaWx0ZXIgZmllbGQgd2l0aCBJRCAnJHtVc2VyRmlsdGVyQ29uc3RhbnRzLkZJTFRFUl9GSUVMRF9JRFxuICAgICAgICAgICAgfSchIFNlYXJjaCBjYXRlZ29yaWVzIGNhbm5vdCBiZSBnZW5lcmF0ZWQgZnJvbSBpdCFgKTtcbiAgICB9XG5cbiAgICBjb25zdCBtZXJnZSA9IG5ldyBTZXQoKTtcbiAgICBjb25zdCBjYXRzID0gZmlsdGVyRmllbGQuZmlsdGVyTWV0YWRhdGEuc2VhcmNoQ2F0ZWdvcmllcy5tYXAoY2F0ID0+IHtcbiAgICAgICAgY29uc3QgY2F0ZWdvcnkgPSBjYXRlZ29yeVJlc29sdmVyU2VydmljZS50b0NsYXNzKGNhdCk7XG4gICAgICAgIG1lcmdlLmFkZChjYXRlZ29yeSk7XG4gICAgICAgIHJldHVybiBjYXRlZ29yeTtcbiAgICB9KTtcblxuICAgIGlmIChmaWx0ZXJGaWVsZC5maWx0ZXJNZXRhZGF0YS5kZWZhdWx0U2VhcmNoQ2F0ZWdvcmllcykge1xuICAgICAgICAoZmlsdGVyRmllbGQuZmlsdGVyTWV0YWRhdGEuZmlsdGVyVHlwZSA9PT0gRmlsdGVyVHlwZS5DQVNFID8gZGVmYXVsdENhc2VTZWFyY2hDYXRlZ29yaWVzIDogZGVmYXVsdFRhc2tTZWFyY2hDYXRlZ29yaWVzKVxuICAgICAgICAgICAgLmZvckVhY2goY2F0ID0+IHtcbiAgICAgICAgICAgICAgICBpZiAoIW1lcmdlLmhhcyhjYXQpKSB7XG4gICAgICAgICAgICAgICAgICAgIGNhdHMucHVzaChjYXQpO1xuICAgICAgICAgICAgICAgIH1cbiAgICAgICAgICAgIH0pO1xuICAgIH1cblxuICAgIHJldHVybiBjYXRzO1xufVxuIl19

package/esm2015/lib/utility/of-void.js

@@ -0,0 +1,12 @@
+import { Observable } from 'rxjs';
+/**
+ * This function is meant to work as a call to rxjs's `of` function without any arguments
+ * @returns a void Observable, that calls next once and then completes
+ */
+export function ofVoid() {
+    return new Observable(o => {
+        o.next();
+        o.complete();
+    });
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib2Ytdm9pZC5qcyIsInNvdXJjZVJvb3QiOiJuZzovL0BuZXRncmlmL2NvbXBvbmVudHMtY29yZS8iLCJzb3VyY2VzIjpbImxpYi91dGlsaXR5L29mLXZvaWQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFDLFVBQVUsRUFBQyxNQUFNLE1BQU0sQ0FBQztBQUVoQzs7O0dBR0c7QUFDSCxNQUFNLFVBQVUsTUFBTTtJQUNsQixPQUFPLElBQUksVUFBVSxDQUFPLENBQUMsQ0FBQyxFQUFFO1FBQzVCLENBQUMsQ0FBQyxJQUFJLEVBQUUsQ0FBQztRQUNULENBQUMsQ0FBQyxRQUFRLEVBQUUsQ0FBQztJQUNqQixDQUFDLENBQUMsQ0FBQztBQUNQLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge09ic2VydmFibGV9IGZyb20gJ3J4anMnO1xuXG4vKipcbiAqIFRoaXMgZnVuY3Rpb24gaXMgbWVhbnQgdG8gd29yayBhcyBhIGNhbGwgdG8gcnhqcydzIGBvZmAgZnVuY3Rpb24gd2l0aG91dCBhbnkgYXJndW1lbnRzXG4gKiBAcmV0dXJucyBhIHZvaWQgT2JzZXJ2YWJsZSwgdGhhdCBjYWxscyBuZXh0IG9uY2UgYW5kIHRoZW4gY29tcGxldGVzXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBvZlZvaWQoKTogT2JzZXJ2YWJsZTx2b2lkPiB7XG4gICAgcmV0dXJuIG5ldyBPYnNlcnZhYmxlPHZvaWQ+KG8gPT4ge1xuICAgICAgICBvLm5leHQoKTtcbiAgICAgICAgby5jb21wbGV0ZSgpO1xuICAgIH0pO1xufVxuIl19

package/esm2015/lib/utility/pagination/load-all-pages.js

@@ -0,0 +1,46 @@
+import { forkJoin, of } from 'rxjs';
+import { HttpParams } from '@angular/common/http';
+import { concatMap, map } from 'rxjs/operators';
+import { hasContent } from './page-has-content';
+/**
+ * Loads all pages from the given endpoint and returns their content as one array
+ * @param source the method that is used to load an individual page, it must support pagination parameters
+ * @param filter the filter/query object that is used to specify the requested objects. The `source` argument must accept this filter.
+ * @param pagination configuration of the initial pagination.
+ * Pages will be loaded from the provided page number onwards, page size will be upheld.
+ * @returns content of all pages from the given page onwards (or from the start if no `pagination` argument was provided) as a single Array
+ */
+export function loadAllPages(source, filter, pagination) {
+    const basePagination = pagination ? pagination : { number: 0, size: 20, totalPages: undefined, totalElements: undefined };
+    return source(filter, paginationParams(basePagination)).pipe(map(page => {
+        basePagination.totalPages = page.pagination.totalPages;
+        const pages = {};
+        pages[basePagination.number] = (of(page.content));
+        if (basePagination.number < basePagination.totalPages) {
+            for (let pn = basePagination.number + 1; pn < basePagination.totalPages; pn++) {
+                const pagin = Object.assign({}, basePagination, { number: pn });
+                pages[pn] = mapToContent(source, filter, pagin);
+            }
+        }
+        return forkJoin(pages);
+    }), concatMap(o => o), map((joined) => {
+        const result = [];
+        Object.values(joined).filter(v => Array.isArray(v)).forEach(arr => result.push(...arr));
+        return result;
+    }));
+}
+function paginationParams(basePagination, pageNumber) {
+    let params = new HttpParams();
+    params = params.set('size', basePagination.size + '');
+    params = params.set('page', (pageNumber !== undefined ? pageNumber : basePagination.number) + '');
+    return params;
+}
+function mapToContent(source, filter, pagination) {
+    return source(filter, paginationParams(pagination)).pipe(map(page => {
+        if (hasContent(page)) {
+            return page.content;
+        }
+        return [];
+    }));
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/utility/pagination/page-has-content.js

@@ -0,0 +1,8 @@
+/**
+ * @param page a {@link Page} of objects returned by backend
+ * @returns returns `true` if the page is defined and has content with non-zero length. Returns `false` otherwise.
+ */
+export function hasContent(page) {
+    return !!page && !!page.content && Array.isArray(page.content) && page.content.length > 0;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGFnZS1oYXMtY29udGVudC5qcyIsInNvdXJjZVJvb3QiOiJuZzovL0BuZXRncmlmL2NvbXBvbmVudHMtY29yZS8iLCJzb3VyY2VzIjpbImxpYi91dGlsaXR5L3BhZ2luYXRpb24vcGFnZS1oYXMtY29udGVudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQTs7O0dBR0c7QUFDSCxNQUFNLFVBQVUsVUFBVSxDQUFDLElBQStCO0lBQ3RELE9BQU8sQ0FBQyxDQUFDLElBQUksSUFBSSxDQUFDLENBQUMsSUFBSSxDQUFDLE9BQU8sSUFBSSxLQUFLLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsSUFBSSxJQUFJLENBQUMsT0FBTyxDQUFDLE1BQU0sR0FBRyxDQUFDLENBQUM7QUFDOUYsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7UGFnZX0gZnJvbSAnLi4vLi4vcmVzb3VyY2VzL2ludGVyZmFjZS9wYWdlJztcblxuLyoqXG4gKiBAcGFyYW0gcGFnZSBhIHtAbGluayBQYWdlfSBvZiBvYmplY3RzIHJldHVybmVkIGJ5IGJhY2tlbmRcbiAqIEByZXR1cm5zIHJldHVybnMgYHRydWVgIGlmIHRoZSBwYWdlIGlzIGRlZmluZWQgYW5kIGhhcyBjb250ZW50IHdpdGggbm9uLXplcm8gbGVuZ3RoLiBSZXR1cm5zIGBmYWxzZWAgb3RoZXJ3aXNlLlxuICovXG5leHBvcnQgZnVuY3Rpb24gaGFzQ29udGVudChwYWdlOiBQYWdlPHVua25vd24+IHwgdW5kZWZpbmVkKTogYm9vbGVhbiB7XG4gICAgcmV0dXJuICEhcGFnZSAmJiAhIXBhZ2UuY29udGVudCAmJiBBcnJheS5pc0FycmF5KHBhZ2UuY29udGVudCkgJiYgcGFnZS5jb250ZW50Lmxlbmd0aCA+IDA7XG59XG4iXX0=

package/esm2015/lib/utility/process-message-response.js

@@ -0,0 +1,17 @@
+import { of, throwError } from 'rxjs';
+/**
+ * Transforms a {@link MessageResource} object into a stream containing either the message
+ * or an error if the message resource contains an error.
+ *
+ * Can be used with rxjs' `switchMap` process responses from backend.
+ * @param message a {@link MessageResource} object
+ */
+export function processMessageResponse(message) {
+    if (message.error) {
+        return throwError(new Error(message.error));
+    }
+    else {
+        return of(message);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvY2Vzcy1tZXNzYWdlLXJlc3BvbnNlLmpzIiwic291cmNlUm9vdCI6Im5nOi8vQG5ldGdyaWYvY29tcG9uZW50cy1jb3JlLyIsInNvdXJjZXMiOlsibGliL3V0aWxpdHkvcHJvY2Vzcy1tZXNzYWdlLXJlc3BvbnNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sRUFBYSxFQUFFLEVBQUUsVUFBVSxFQUFDLE1BQU0sTUFBTSxDQUFDO0FBRWhEOzs7Ozs7R0FNRztBQUNILE1BQU0sVUFBVSxzQkFBc0IsQ0FBQyxPQUF3QjtJQUMzRCxJQUFJLE9BQU8sQ0FBQyxLQUFLLEVBQUU7UUFDZixPQUFPLFVBQVUsQ0FBQyxJQUFJLEtBQUssQ0FBQyxPQUFPLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQztLQUMvQztTQUFNO1FBQ0gsT0FBTyxFQUFFLENBQUMsT0FBTyxDQUFDLENBQUM7S0FDdEI7QUFDTCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtNZXNzYWdlUmVzb3VyY2V9IGZyb20gJy4uL3Jlc291cmNlcy9pbnRlcmZhY2UvbWVzc2FnZS1yZXNvdXJjZSc7XG5pbXBvcnQge09ic2VydmFibGUsIG9mLCB0aHJvd0Vycm9yfSBmcm9tICdyeGpzJztcblxuLyoqXG4gKiBUcmFuc2Zvcm1zIGEge0BsaW5rIE1lc3NhZ2VSZXNvdXJjZX0gb2JqZWN0IGludG8gYSBzdHJlYW0gY29udGFpbmluZyBlaXRoZXIgdGhlIG1lc3NhZ2VcbiAqIG9yIGFuIGVycm9yIGlmIHRoZSBtZXNzYWdlIHJlc291cmNlIGNvbnRhaW5zIGFuIGVycm9yLlxuICpcbiAqIENhbiBiZSB1c2VkIHdpdGggcnhqcycgYHN3aXRjaE1hcGAgcHJvY2VzcyByZXNwb25zZXMgZnJvbSBiYWNrZW5kLlxuICogQHBhcmFtIG1lc3NhZ2UgYSB7QGxpbmsgTWVzc2FnZVJlc291cmNlfSBvYmplY3RcbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIHByb2Nlc3NNZXNzYWdlUmVzcG9uc2UobWVzc2FnZTogTWVzc2FnZVJlc291cmNlKTogT2JzZXJ2YWJsZTxNZXNzYWdlUmVzb3VyY2U+IHtcbiAgICBpZiAobWVzc2FnZS5lcnJvcikge1xuICAgICAgICByZXR1cm4gdGhyb3dFcnJvcihuZXcgRXJyb3IobWVzc2FnZS5lcnJvcikpO1xuICAgIH0gZWxzZSB7XG4gICAgICAgIHJldHVybiBvZihtZXNzYWdlKTtcbiAgICB9XG59XG4iXX0=

package/esm2015/lib/utility/public-api.js

@@ -0,0 +1,47 @@
+export * from './of-void';
+export * from './loading-emitter';
+export * from './loading-with-filter-emitter';
+export * from './get-immediate-data';
+export * from './get-field';
+export * from './call-chain/call-chain.service';
+export * from './call-chain/after-action';
+export * from './pagination/page-has-content';
+export * from './pagination/load-all-pages';
+export * from './service/spinner-overlay.service';
+export * from './service/case-list-font-color.service';
+export * from './incrementing-counter';
+export * from './array-to-observable';
+export * from './process-message-response';
+export * from './result-with-after-actions';
+export * from './clear-time-information';
+export * from './refresh-tree';
+export * from './destroy-subscription';
+export * from './navigation-item-task-filter-factory';
+export * from './navigation-item-task-search-categories-factory';
+/* TESTS */
+export * from './tests/mocks/mock-authentication.service';
+export * from './tests/mocks/mock-user-preference.service';
+export * from './tests/mocks/mock-user-resource.service';
+export * from './tests/mocks/mock-authentication-method-service';
+export * from './tests/mocks/mock-sign-up.service';
+export * from './tests/mocks/mock-user-autocomplete-value';
+export * from './tests/utility/create-mock-task';
+export * from './tests/utility/create-mock-case';
+export * from './tests/utility/create-mock-immediate-data';
+export * from './tests/utility/create-mock-page';
+export * from './tests/utility/create-mock-net';
+export * from './tests/utility/create-mock-datagroup';
+export * from './tests/utility/create-mock-field';
+export * from './tests/utility/create-mock-case-outcome';
+export * from './tests/utility/create-mock-task-outcome';
+export * from './tests/utility/create-mock-get-data-outcome';
+export * from './tests/utility/create-mock-set-data-outcome';
+export * from './tests/utility/create-mock-petri-net-outcome';
+export * from './tests/utility/configure-category';
+export * from './tests/search-category-mock-dependencies';
+export * from './tests/test-config';
+export * from './tests/test-factory-methods';
+export * from './tests/test-view-service';
+export * from './tests/mocks/mock-endpoint';
+export * from './tests/test-mock-dependencies.module';
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/utility/refresh-tree.js

@@ -0,0 +1,9 @@
+/**
+ * Forces a re-render of the tree backed by the datasource
+ */
+export function refreshTree(tree) {
+    const d = tree.data;
+    tree.data = null;
+    tree.data = d;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVmcmVzaC10cmVlLmpzIiwic291cmNlUm9vdCI6Im5nOi8vQG5ldGdyaWYvY29tcG9uZW50cy1jb3JlLyIsInNvdXJjZXMiOlsibGliL3V0aWxpdHkvcmVmcmVzaC10cmVlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBOztHQUVHO0FBQ0gsTUFBTSxVQUFVLFdBQVcsQ0FBQyxJQUFzQztJQUM5RCxNQUFNLENBQUMsR0FBRyxJQUFJLENBQUMsSUFBSSxDQUFDO0lBQ3BCLElBQUksQ0FBQyxJQUFJLEdBQUcsSUFBSSxDQUFDO0lBQ2pCLElBQUksQ0FBQyxJQUFJLEdBQUcsQ0FBQyxDQUFDO0FBQ2xCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge01hdFRyZWVOZXN0ZWREYXRhU291cmNlfSBmcm9tICdAYW5ndWxhci9tYXRlcmlhbC90cmVlJztcblxuLyoqXG4gKiBGb3JjZXMgYSByZS1yZW5kZXIgb2YgdGhlIHRyZWUgYmFja2VkIGJ5IHRoZSBkYXRhc291cmNlXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiByZWZyZXNoVHJlZSh0cmVlOiBNYXRUcmVlTmVzdGVkRGF0YVNvdXJjZTx1bmtub3duPikge1xuICAgIGNvbnN0IGQgPSB0cmVlLmRhdGE7XG4gICAgdHJlZS5kYXRhID0gbnVsbDtcbiAgICB0cmVlLmRhdGEgPSBkO1xufVxuIl19

package/esm2015/lib/utility/result-with-after-actions.js

@@ -0,0 +1,27 @@
+/**
+ * A utility class that carries an operation result of any type
+ * along with executable after actions that should be performed at a later time.
+ */
+export class ResultWithAfterActions {
+    /**
+     * @param _result the result of an operation
+     * @param _afterActions the lambdas that should be executed at some later time. Defaults to an empty array.
+     */
+    constructor(_result, _afterActions = []) {
+        this._result = _result;
+        this._afterActions = _afterActions;
+    }
+    /**
+     * The result of an operations.
+     */
+    get result() {
+        return this._result;
+    }
+    /**
+     * Executes all the after action lambdas.
+     */
+    executeAfterActions() {
+        this._afterActions.forEach(action => action());
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVzdWx0LXdpdGgtYWZ0ZXItYWN0aW9ucy5qcyIsInNvdXJjZVJvb3QiOiJuZzovL0BuZXRncmlmL2NvbXBvbmVudHMtY29yZS8iLCJzb3VyY2VzIjpbImxpYi91dGlsaXR5L3Jlc3VsdC13aXRoLWFmdGVyLWFjdGlvbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7OztHQUdHO0FBQ0gsTUFBTSxPQUFPLHNCQUFzQjtJQUUvQjs7O09BR0c7SUFDSCxZQUFzQixPQUFVLEVBQVksZ0JBQW1DLEVBQUU7UUFBM0QsWUFBTyxHQUFQLE9BQU8sQ0FBRztRQUFZLGtCQUFhLEdBQWIsYUFBYSxDQUF3QjtJQUNqRixDQUFDO0lBRUQ7O09BRUc7SUFDSCxJQUFXLE1BQU07UUFDYixPQUFPLElBQUksQ0FBQyxPQUFPLENBQUM7SUFDeEIsQ0FBQztJQUVEOztPQUVHO0lBQ0ksbUJBQW1CO1FBQ3RCLElBQUksQ0FBQyxhQUFhLENBQUMsT0FBTyxDQUFDLE1BQU0sQ0FBQyxFQUFFLENBQUMsTUFBTSxFQUFFLENBQUMsQ0FBQztJQUNuRCxDQUFDO0NBQ0oiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEEgdXRpbGl0eSBjbGFzcyB0aGF0IGNhcnJpZXMgYW4gb3BlcmF0aW9uIHJlc3VsdCBvZiBhbnkgdHlwZVxuICogYWxvbmcgd2l0aCBleGVjdXRhYmxlIGFmdGVyIGFjdGlvbnMgdGhhdCBzaG91bGQgYmUgcGVyZm9ybWVkIGF0IGEgbGF0ZXIgdGltZS5cbiAqL1xuZXhwb3J0IGNsYXNzIFJlc3VsdFdpdGhBZnRlckFjdGlvbnM8VD4ge1xuXG4gICAgLyoqXG4gICAgICogQHBhcmFtIF9yZXN1bHQgdGhlIHJlc3VsdCBvZiBhbiBvcGVyYXRpb25cbiAgICAgKiBAcGFyYW0gX2FmdGVyQWN0aW9ucyB0aGUgbGFtYmRhcyB0aGF0IHNob3VsZCBiZSBleGVjdXRlZCBhdCBzb21lIGxhdGVyIHRpbWUuIERlZmF1bHRzIHRvIGFuIGVtcHR5IGFycmF5LlxuICAgICAqL1xuICAgIGNvbnN0cnVjdG9yKHByb3RlY3RlZCBfcmVzdWx0OiBULCBwcm90ZWN0ZWQgX2FmdGVyQWN0aW9uczogQXJyYXk8KCkgPT4gdm9pZD4gPSBbXSkge1xuICAgIH1cblxuICAgIC8qKlxuICAgICAqIFRoZSByZXN1bHQgb2YgYW4gb3BlcmF0aW9ucy5cbiAgICAgKi9cbiAgICBwdWJsaWMgZ2V0IHJlc3VsdCgpOiBUIHtcbiAgICAgICAgcmV0dXJuIHRoaXMuX3Jlc3VsdDtcbiAgICB9XG5cbiAgICAvKipcbiAgICAgKiBFeGVjdXRlcyBhbGwgdGhlIGFmdGVyIGFjdGlvbiBsYW1iZGFzLlxuICAgICAqL1xuICAgIHB1YmxpYyBleGVjdXRlQWZ0ZXJBY3Rpb25zKCk6IHZvaWQge1xuICAgICAgICB0aGlzLl9hZnRlckFjdGlvbnMuZm9yRWFjaChhY3Rpb24gPT4gYWN0aW9uKCkpO1xuICAgIH1cbn1cbiJdfQ==

package/esm2015/lib/utility/service/case-list-font-color.service.js

@@ -0,0 +1,45 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class CaseListFontColorService {
+    constructor() {
+        this.cache = {};
+    }
+    /**
+     * Computes if font color of line should be white or black based on chosen hex case color.
+     * Hex color is converted to its rbg components and decides from them if case color is dark or light.
+     * Threshold for color lightness decision can be changed if needed
+     *
+     * @param caseColor string color of case
+     * @returns font color black or white
+     */
+    computeCaseFontColor(caseColor) {
+        // check if hex color
+        if (caseColor === undefined) {
+            return 'black';
+        }
+        if (caseColor in this.cache) {
+            return this.cache[caseColor];
+        }
+        const m = caseColor.match(/^#?([\da-f]{2})([\da-f]{2})([\da-f]{2})$/i);
+        if (m === null || m.length !== 4) {
+            this.cache[caseColor] = 'black';
+            return 'black';
+        }
+        const r = parseInt(m[1], 16);
+        const g = parseInt(m[2], 16);
+        const b = parseInt(m[3], 16);
+        // možné špecifickejšie upraviť threshold hodnotu
+        const fontColor = (((r * 0.299) + (g * 0.587) + (b * 0.114)) > 150) ?
+            'black' : 'white';
+        this.cache[caseColor] = fontColor;
+        return fontColor;
+    }
+}
+CaseListFontColorService.ɵprov = i0.ɵɵdefineInjectable({ factory: function CaseListFontColorService_Factory() { return new CaseListFontColorService(); }, token: CaseListFontColorService, providedIn: "root" });
+CaseListFontColorService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root'
+            },] }
+];
+CaseListFontColorService.ctorParameters = () => [];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/utility/service/spinner-overlay.service.js

@@ -0,0 +1,48 @@
+import { Injectable } from '@angular/core';
+import { Overlay, OverlayRef } from '@angular/cdk/overlay';
+import { Subject } from 'rxjs';
+import { map, scan } from 'rxjs/operators';
+import { ComponentPortal } from '@angular/cdk/portal';
+import { MatSpinner } from '@angular/material/progress-spinner';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/overlay";
+export class SpinnerOverlayService {
+    constructor(overlay) {
+        this.overlay = overlay;
+        this.spin$ = new Subject();
+        this._spinner = this._createSpinner();
+        this.spin$.pipe(map(v => v ? 1 : -1), scan((acc, curr) => (acc + curr) >= 0 ? (acc + curr) : 0, 0)).subscribe(result => result === 1 ? this._show() : (this._spinner.hasAttached() ? this._hide() : null));
+    }
+    ngOnDestroy() {
+        this.spin$.complete();
+    }
+    _createSpinner() {
+        return this.overlay.create({
+            hasBackdrop: true,
+            // backdropClass: 'dark-backdrop',
+            positionStrategy: this.overlay.position()
+                .global()
+                .centerHorizontally()
+                .centerVertically()
+        });
+    }
+    _show() {
+        this._spinner.attach(new ComponentPortal(MatSpinner));
+    }
+    _hide() {
+        this._spinner.detach();
+    }
+}
+SpinnerOverlayService.ctorParameters = () => [
+    { type: Overlay }
+];
+SpinnerOverlayService.ɵprov = i0.ɵɵdefineInjectable({ factory: function SpinnerOverlayService_Factory() { return new SpinnerOverlayService(i0.ɵɵinject(i1.Overlay)); }, token: SpinnerOverlayService, providedIn: "root" });
+SpinnerOverlayService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root'
+            },] }
+];
+SpinnerOverlayService.ctorParameters = () => [
+    { type: Overlay }
+];
+//# sourceMappingURL=data:application/json;base64,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