@netgrif/components-core 6.0.1

package/esm5/lib/user/services/user.service.js

@@ -0,0 +1,224 @@
+import { __assign } from "tslib";
+import { Injectable } from '@angular/core';
+import { ReplaySubject } from 'rxjs';
+import { User } from '../models/user';
+import { take, tap } from 'rxjs/operators';
+import { AuthenticationService } from '../../authentication/services/authentication/authentication.service';
+import { UserResourceService } from '../../resources/engine-endpoint/user-resource.service';
+import { UserTransformer } from '../../authentication/models/user.transformer';
+import { LoggerService } from '../../logger/services/logger.service';
+import { HttpErrorResponse } from '@angular/common/http';
+import { SessionService } from '../../authentication/session/services/session.service';
+import { AnonymousService } from '../../authentication/anonymous/anonymous.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../../authentication/services/authentication/authentication.service";
+import * as i2 from "../../resources/engine-endpoint/user-resource.service";
+import * as i3 from "../../authentication/models/user.transformer";
+import * as i4 from "../../logger/services/logger.service";
+import * as i5 from "../../authentication/session/services/session.service";
+import * as i6 from "../../authentication/anonymous/anonymous.service";
+var UserService = /** @class */ (function () {
+    function UserService(_authService, _userResource, _userTransform, _log, _session, _anonymousService) {
+        var _this = this;
+        this._authService = _authService;
+        this._userResource = _userResource;
+        this._userTransform = _userTransform;
+        this._log = _log;
+        this._session = _session;
+        this._anonymousService = _anonymousService;
+        this._user = this.emptyUser();
+        this._loginCalled = false;
+        this._userChange$ = new ReplaySubject(1);
+        this._anonymousUserChange$ = new ReplaySubject(1);
+        setTimeout(function () {
+            _this._subAuth = _this._authService.authenticated$.subscribe(function (auth) {
+                if (auth && !_this._loginCalled) {
+                    _this.loadUser();
+                }
+                else if (!auth) {
+                    _this.clearUser();
+                    _this.publishUserChange();
+                }
+            });
+        });
+        this._subAnonym = this._anonymousService.tokenSet.subscribe(function (token) {
+            if (token) {
+                _this.loadPublicUser();
+            }
+            else {
+                _this.clearUser();
+                _this.publishAnonymousUserChange();
+            }
+        });
+    }
+    Object.defineProperty(UserService.prototype, "user", {
+        get: function () {
+            return this._user;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(UserService.prototype, "user$", {
+        get: function () {
+            return this._userChange$.asObservable();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(UserService.prototype, "anonymousUser$", {
+        get: function () {
+            return this._anonymousUserChange$.asObservable();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    UserService.prototype.ngOnDestroy = function () {
+        this._userChange$.complete();
+        this._anonymousUserChange$.complete();
+        this._subAuth.unsubscribe();
+        this._subAnonym.unsubscribe();
+    };
+    /**
+     * Check if user has specified authority.
+     * @param authority - If provided authority is array of authorities.
+     *                    Method make intersection of the provided authorities and user's authorities.
+     *                    If calculated intersection isn't empty returns true, otherwise false.
+     */
+    UserService.prototype.hasAuthority = function (authority) {
+        var _this = this;
+        if (!authority || !this._user.authorities) {
+            return false;
+        }
+        if (authority instanceof Array) {
+            return authority.some(function (a) { return _this._user.authorities.some(function (u) { return u === a; }); });
+        }
+        else {
+            return this._user.authorities.some(function (a) { return a === authority; });
+        }
+    };
+    UserService.prototype.hasRole = function (role) {
+        if (!role || !this._user.roles) {
+            return false;
+        }
+        return this._user.roles.some(function (r) { return r === role; });
+    };
+    /**
+     * Checks whether the user has role with a specific stringId
+     * @param roleStringId ID of the role we want to check
+     */
+    UserService.prototype.hasRoleById = function (roleStringId) {
+        if (!roleStringId || !this._user.roles) {
+            return false;
+        }
+        return this._user.roles.some(function (r) { return r.stringId === roleStringId; });
+    };
+    /**
+     * Checks whether the user has role with the specified identifier in a process with the specified identifier (any version)
+     * @param roleIdentifier identifier (import ID) of the role we want to check
+     * @param netIdentifier identifier (import ID) of the process the role is defined in
+     */
+    UserService.prototype.hasRoleByIdentifier = function (roleIdentifier, netIdentifier) {
+        if (!roleIdentifier || !netIdentifier || !this._user.roles) {
+            return false;
+        }
+        return this._user.roles.some(function (r) { return r.netImportId === netIdentifier && r.importId === roleIdentifier; });
+    };
+    /**
+     * Checks whether the user has role with the specified name in a process with the specified identifier (any version)
+     * @param roleName name of the role we want to check
+     * @param netIdentifier identifier (import ID) of the process the role is defined in
+     */
+    UserService.prototype.hasRoleByName = function (roleName, netIdentifier) {
+        if (!roleName || !netIdentifier || !this._user.roles) {
+            return false;
+        }
+        return this._user.roles.some(function (r) { return r.netImportId === netIdentifier && r.name === roleName; });
+    };
+    UserService.prototype.login = function (credentials) {
+        var _this = this;
+        this._loginCalled = true;
+        return this._authService.login(credentials).pipe(tap(function (authUser) {
+            _this._user = authUser;
+            _this._loginCalled = false;
+            _this.publishUserChange();
+        }));
+    };
+    UserService.prototype.logout = function () {
+        var _this = this;
+        return this._authService.logout().pipe(tap(function () {
+            _this._user = _this.emptyUser();
+            _this.publishUserChange();
+        }));
+    };
+    UserService.prototype.reload = function () {
+        this.loadUser();
+    };
+    UserService.prototype.emptyUser = function () {
+        return new User('', '', '', '', [], [], [], []);
+    };
+    UserService.prototype.loadUser = function () {
+        var _this = this;
+        this._userResource.getLoggedUser().pipe(take(1)).subscribe(function (user) {
+            if (user) {
+                var backendUser = __assign(__assign({}, user), { id: user.id.toString() });
+                _this._user = _this._userTransform.transform(backendUser);
+                _this.publishUserChange();
+            }
+        }, function (error) {
+            if (error instanceof HttpErrorResponse && error.status === 401) {
+                _this._log.debug('Authentication token is invalid. Clearing stream');
+                _this._session.clear();
+            }
+            else {
+                _this._log.error('Loading logged user has failed! Initialisation has not be completed successfully!', error);
+            }
+        });
+    };
+    UserService.prototype.loadPublicUser = function () {
+        var _this = this;
+        this._userResource.getPublicLoggedUser().pipe(take(1)).subscribe(function (user) {
+            if (user) {
+                var backendUser = __assign(__assign({}, user), { id: user.id.toString() });
+                _this._user = _this._userTransform.transform(backendUser);
+                _this.publishAnonymousUserChange();
+            }
+        }, function (error) {
+            _this._log.error('Loading logged user has failed! Initialisation has not be completed successfully!', error);
+            _this._publicLoadCalled = false;
+        });
+    };
+    UserService.prototype.clearUser = function () {
+        this._user = this.emptyUser();
+    };
+    UserService.prototype.publishUserChange = function () {
+        this._userChange$.next(this.user);
+    };
+    UserService.prototype.publishAnonymousUserChange = function () {
+        this._anonymousUserChange$.next(this.user);
+    };
+    UserService.ctorParameters = function () { return [
+        { type: AuthenticationService },
+        { type: UserResourceService },
+        { type: UserTransformer },
+        { type: LoggerService },
+        { type: SessionService },
+        { type: AnonymousService }
+    ]; };
+    UserService.ɵprov = i0.ɵɵdefineInjectable({ factory: function UserService_Factory() { return new UserService(i0.ɵɵinject(i1.AuthenticationService), i0.ɵɵinject(i2.UserResourceService), i0.ɵɵinject(i3.UserTransformer), i0.ɵɵinject(i4.LoggerService), i0.ɵɵinject(i5.SessionService), i0.ɵɵinject(i6.AnonymousService)); }, token: UserService, providedIn: "root" });
+    UserService.decorators = [
+        { type: Injectable, args: [{
+                    providedIn: 'root'
+                },] }
+    ];
+    UserService.ctorParameters = function () { return [
+        { type: AuthenticationService },
+        { type: UserResourceService },
+        { type: UserTransformer },
+        { type: LoggerService },
+        { type: SessionService },
+        { type: AnonymousService }
+    ]; };
+    return UserService;
+}());
+export { UserService };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"user.service.js","sourceRoot":"ng://@netgrif/components-core/","sources":["lib/user/services/user.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Injectable, OnDestroy} from '@angular/core';\nimport {Observable, ReplaySubject, Subscription} from 'rxjs';\nimport {ProcessRole} from '../../resources/interface/process-role';\nimport {User} from '../models/user';\nimport {Credentials} from '../../authentication/models/credentials';\nimport {take, tap} from 'rxjs/operators';\nimport {AuthenticationService} from '../../authentication/services/authentication/authentication.service';\nimport {UserResourceService} from '../../resources/engine-endpoint/user-resource.service';\nimport {UserTransformer} from '../../authentication/models/user.transformer';\nimport {LoggerService} from '../../logger/services/logger.service';\nimport {HttpErrorResponse} from '@angular/common/http';\nimport {SessionService} from '../../authentication/session/services/session.service';\nimport {UserResource} from '../../resources/interface/user-resource';\nimport {AnonymousService} from '../../authentication/anonymous/anonymous.service';\n\n@Injectable({\n    providedIn: 'root'\n})\nexport class UserService implements OnDestroy {\n\n    protected _user: User;\n    protected _userChange$: ReplaySubject<User>;\n    protected _anonymousUserChange$: ReplaySubject<User>;\n    protected _loginCalled: boolean;\n    protected _subAuth: Subscription;\n    protected _subAnonym: Subscription;\n    private _publicLoadCalled: boolean;\n\n    constructor(protected _authService: AuthenticationService,\n                protected _userResource: UserResourceService,\n                protected _userTransform: UserTransformer,\n                protected _log: LoggerService,\n                protected _session: SessionService,\n                protected _anonymousService: AnonymousService) {\n        this._user = this.emptyUser();\n        this._loginCalled = false;\n        this._userChange$ = new ReplaySubject<User>(1);\n        this._anonymousUserChange$ = new ReplaySubject<User>(1);\n        setTimeout(() => {\n            this._subAuth = this._authService.authenticated$.subscribe(auth => {\n                if (auth && !this._loginCalled) {\n                    this.loadUser();\n                } else if (!auth) {\n                    this.clearUser();\n                    this.publishUserChange();\n                }\n            });\n        });\n        this._subAnonym = this._anonymousService.tokenSet.subscribe(token => {\n            if (token) {\n                this.loadPublicUser();\n            } else {\n                this.clearUser();\n                this.publishAnonymousUserChange();\n            }\n        });\n    }\n\n    get user() {\n        return this._user;\n    }\n\n    get user$(): Observable<User> {\n        return this._userChange$.asObservable();\n    }\n\n    get anonymousUser$(): Observable<User> {\n        return this._anonymousUserChange$.asObservable();\n    }\n\n    ngOnDestroy(): void {\n        this._userChange$.complete();\n        this._anonymousUserChange$.complete();\n        this._subAuth.unsubscribe();\n        this._subAnonym.unsubscribe();\n    }\n\n    /**\n     * Check if user has specified authority.\n     * @param authority - If provided authority is array of authorities.\n     *                    Method make intersection of the provided authorities and user's authorities.\n     *                    If calculated intersection isn't empty returns true, otherwise false.\n     */\n    public hasAuthority(authority: Array<string> | string): boolean {\n        if (!authority || !this._user.authorities) {\n            return false;\n        }\n        if (authority instanceof Array) {\n            return authority.some(a => this._user.authorities.some(u => u === a));\n        } else {\n            return this._user.authorities.some(a => a === authority);\n        }\n    }\n\n    public hasRole(role: ProcessRole): boolean {\n        if (!role || !this._user.roles) {\n            return false;\n        }\n        return this._user.roles.some(r => r === role);\n    }\n\n    /**\n     * Checks whether the user has role with a specific stringId\n     * @param roleStringId ID of the role we want to check\n     */\n    public hasRoleById(roleStringId: string): boolean {\n        if (!roleStringId || !this._user.roles) {\n            return false;\n        }\n        return this._user.roles.some(r => r.stringId === roleStringId);\n    }\n\n    /**\n     * Checks whether the user has role with the specified identifier in a process with the specified identifier (any version)\n     * @param roleIdentifier identifier (import ID) of the role we want to check\n     * @param netIdentifier identifier (import ID) of the process the role is defined in\n     */\n    public hasRoleByIdentifier(roleIdentifier: string, netIdentifier: string): boolean {\n        if (!roleIdentifier || !netIdentifier || !this._user.roles) {\n            return false;\n        }\n        return this._user.roles.some(r => r.netImportId === netIdentifier && r.importId === roleIdentifier);\n    }\n\n    /**\n     * Checks whether the user has role with the specified name in a process with the specified identifier (any version)\n     * @param roleName name of the role we want to check\n     * @param netIdentifier identifier (import ID) of the process the role is defined in\n     */\n    public hasRoleByName(roleName: string, netIdentifier: string): boolean {\n        if (!roleName || !netIdentifier || !this._user.roles) {\n            return false;\n        }\n        return this._user.roles.some(r => r.netImportId === netIdentifier && r.name === roleName);\n    }\n\n    public login(credentials: Credentials): Observable<User> {\n        this._loginCalled = true;\n        return this._authService.login(credentials).pipe(\n            tap((authUser: User) => {\n                this._user = authUser;\n                this._loginCalled = false;\n                this.publishUserChange();\n            })\n        );\n    }\n\n    public logout(): Observable<object> {\n        return this._authService.logout().pipe(\n            tap(() => {\n                this._user = this.emptyUser();\n                this.publishUserChange();\n            })\n        );\n    }\n\n    public reload(): void {\n        this.loadUser();\n    }\n\n    protected emptyUser() {\n        return new User('', '', '', '', [], [], [], []);\n    }\n\n    protected loadUser(): void {\n        this._userResource.getLoggedUser().pipe(take(1)).subscribe((user: UserResource) => {\n            if (user) {\n                const backendUser = {...user, id: user.id.toString()};\n                this._user = this._userTransform.transform(backendUser);\n                this.publishUserChange();\n            }\n        }, error => {\n            if (error instanceof HttpErrorResponse && error.status === 401) {\n                this._log.debug('Authentication token is invalid. Clearing stream');\n                this._session.clear();\n            } else {\n                this._log.error('Loading logged user has failed! Initialisation has not be completed successfully!', error);\n            }\n        });\n    }\n\n    public loadPublicUser(): void {\n        this._userResource.getPublicLoggedUser().pipe(take(1)).subscribe((user: UserResource) => {\n            if (user) {\n                const backendUser = {...user, id: user.id.toString()};\n                this._user = this._userTransform.transform(backendUser);\n                this.publishAnonymousUserChange();\n            }\n        }, error => {\n            this._log.error('Loading logged user has failed! Initialisation has not be completed successfully!', error);\n            this._publicLoadCalled = false;\n        });\n    }\n\n    public clearUser() {\n        this._user = this.emptyUser();\n    }\n\n    protected publishUserChange(): void {\n        this._userChange$.next(this.user);\n    }\n\n    protected publishAnonymousUserChange(): void {\n        this._anonymousUserChange$.next(this.user);\n    }\n}\n"]}

package/esm5/lib/user/services/view-id.service.js

@@ -0,0 +1,36 @@
+import { Inject, Injectable, Injector, Optional, SkipSelf } from '@angular/core';
+import { NAE_VIEW_ID_SEGMENT } from '../models/view-id-injection-tokens';
+var ViewIdService = /** @class */ (function () {
+    function ViewIdService(parentInjector, idSegment) {
+        this._viewId = '';
+        if (parentInjector !== null) {
+            var parentIdService = parentInjector.get(ViewIdService, null);
+            if (parentIdService !== null) {
+                this._viewId = parentIdService.viewId + ViewIdService.VIEW_ID_SEGMENT_SEPARATOR;
+            }
+        }
+        this._viewId += idSegment;
+    }
+    Object.defineProperty(ViewIdService.prototype, "viewId", {
+        get: function () {
+            return this._viewId;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    ViewIdService.VIEW_ID_SEGMENT_SEPARATOR = '-';
+    ViewIdService.ctorParameters = function () { return [
+        { type: Injector, decorators: [{ type: Optional }, { type: SkipSelf }] },
+        { type: String, decorators: [{ type: Inject, args: [NAE_VIEW_ID_SEGMENT,] }] }
+    ]; };
+    ViewIdService.decorators = [
+        { type: Injectable }
+    ];
+    ViewIdService.ctorParameters = function () { return [
+        { type: Injector, decorators: [{ type: Optional }, { type: SkipSelf }] },
+        { type: String, decorators: [{ type: Inject, args: [NAE_VIEW_ID_SEGMENT,] }] }
+    ]; };
+    return ViewIdService;
+}());
+export { ViewIdService };
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/lib/utility/array-to-observable.js

@@ -0,0 +1,10 @@
+import { timer } from 'rxjs';
+import { map, take } from 'rxjs/operators';
+/**
+ * @param observables an array of items
+ * @returns an observable that emits each item from the array in order.
+ */
+export function arrayToObservable(observables) {
+    return timer(0, 1).pipe(take(observables.length), map(function (i) { return observables[i]; }));
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXJyYXktdG8tb2JzZXJ2YWJsZS5qcyIsInNvdXJjZVJvb3QiOiJuZzovL0BuZXRncmlmL2NvbXBvbmVudHMtY29yZS8iLCJzb3VyY2VzIjpbImxpYi91dGlsaXR5L2FycmF5LXRvLW9ic2VydmFibGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFhLEtBQUssRUFBQyxNQUFNLE1BQU0sQ0FBQztBQUN2QyxPQUFPLEVBQUMsR0FBRyxFQUFFLElBQUksRUFBQyxNQUFNLGdCQUFnQixDQUFDO0FBRXpDOzs7R0FHRztBQUNILE1BQU0sVUFBVSxpQkFBaUIsQ0FBSSxXQUFxQjtJQUN0RCxPQUFPLEtBQUssQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxXQUFXLENBQUMsTUFBTSxDQUFDLEVBQUUsR0FBRyxDQUFDLFVBQUEsQ0FBQyxJQUFJLE9BQUEsV0FBVyxDQUFDLENBQUMsQ0FBQyxFQUFkLENBQWMsQ0FBQyxDQUFDLENBQUM7QUFDaEYsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7T2JzZXJ2YWJsZSwgdGltZXJ9IGZyb20gJ3J4anMnO1xuaW1wb3J0IHttYXAsIHRha2V9IGZyb20gJ3J4anMvb3BlcmF0b3JzJztcblxuLyoqXG4gKiBAcGFyYW0gb2JzZXJ2YWJsZXMgYW4gYXJyYXkgb2YgaXRlbXNcbiAqIEByZXR1cm5zIGFuIG9ic2VydmFibGUgdGhhdCBlbWl0cyBlYWNoIGl0ZW0gZnJvbSB0aGUgYXJyYXkgaW4gb3JkZXIuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBhcnJheVRvT2JzZXJ2YWJsZTxUPihvYnNlcnZhYmxlczogQXJyYXk8VD4pOiBPYnNlcnZhYmxlPFQ+IHtcbiAgICByZXR1cm4gdGltZXIoMCwgMSkucGlwZSh0YWtlKG9ic2VydmFibGVzLmxlbmd0aCksIG1hcChpID0+IG9ic2VydmFibGVzW2ldKSk7XG59XG4iXX0=

package/esm5/lib/utility/call-chain/after-action.js

@@ -0,0 +1,19 @@
+import { __extends } from "tslib";
+import { Subject } from 'rxjs';
+var AfterAction = /** @class */ (function (_super) {
+    __extends(AfterAction, _super);
+    function AfterAction() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    /**
+     * Emits the `resolution` and completes.
+     * @param resolution
+     */
+    AfterAction.prototype.resolve = function (resolution) {
+        this.next(resolution);
+        this.complete();
+    };
+    return AfterAction;
+}(Subject));
+export { AfterAction };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWZ0ZXItYWN0aW9uLmpzIiwic291cmNlUm9vdCI6Im5nOi8vQG5ldGdyaWYvY29tcG9uZW50cy1jb3JlLyIsInNvdXJjZXMiOlsibGliL3V0aWxpdHkvY2FsbC1jaGFpbi9hZnRlci1hY3Rpb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLE9BQU8sRUFBQyxPQUFPLEVBQUMsTUFBTSxNQUFNLENBQUM7QUFFN0I7SUFBaUMsK0JBQWdCO0lBQWpEOztJQVVBLENBQUM7SUFSRzs7O09BR0c7SUFDSSw2QkFBTyxHQUFkLFVBQWUsVUFBbUI7UUFDOUIsSUFBSSxDQUFDLElBQUksQ0FBQyxVQUFVLENBQUMsQ0FBQztRQUN0QixJQUFJLENBQUMsUUFBUSxFQUFFLENBQUM7SUFDcEIsQ0FBQztJQUNMLGtCQUFDO0FBQUQsQ0FBQyxBQVZELENBQWlDLE9BQU8sR0FVdkMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge1N1YmplY3R9IGZyb20gJ3J4anMnO1xuXG5leHBvcnQgY2xhc3MgQWZ0ZXJBY3Rpb24gZXh0ZW5kcyBTdWJqZWN0PGJvb2xlYW4+IHtcblxuICAgIC8qKlxuICAgICAqIEVtaXRzIHRoZSBgcmVzb2x1dGlvbmAgYW5kIGNvbXBsZXRlcy5cbiAgICAgKiBAcGFyYW0gcmVzb2x1dGlvblxuICAgICAqL1xuICAgIHB1YmxpYyByZXNvbHZlKHJlc29sdXRpb246IGJvb2xlYW4pIHtcbiAgICAgICAgdGhpcy5uZXh0KHJlc29sdXRpb24pO1xuICAgICAgICB0aGlzLmNvbXBsZXRlKCk7XG4gICAgfVxufVxuIl19

package/esm5/lib/utility/call-chain/call-chain.service.js

@@ -0,0 +1,36 @@
+import { Injectable } from '@angular/core';
+import { AfterAction } from './after-action';
+import * as i0 from "@angular/core";
+var CallChainService = /** @class */ (function () {
+    function CallChainService() {
+    }
+    /**
+     * Creates a call chain `Subject` that performs an action when a value is emitted into it.
+     *
+     * Useful for creating call chains for methods like [assign Task]{@link AssignTaskService#assign}.
+     * By using this function you don't have to handle the `Subject` logic and can only focus on the callback.
+     * This can make the code easier to understand as the intent is not obscured by the `Subject` handling.
+     *
+     * @param callback the function that should be executed when a value is emitted into the `Subject`.
+     * The emitted value is passed as the argument.
+     * @returns a subscribed `Subject` instance that performs the provided `callback` on the first emission and then completes
+     */
+    CallChainService.prototype.create = function (callback) {
+        var chain = new AfterAction();
+        chain.subscribe(function (result) {
+            callback(result);
+            chain.complete();
+        });
+        return chain;
+    };
+    CallChainService.ɵprov = i0.ɵɵdefineInjectable({ factory: function CallChainService_Factory() { return new CallChainService(); }, token: CallChainService, providedIn: "root" });
+    CallChainService.decorators = [
+        { type: Injectable, args: [{
+                    providedIn: 'root'
+                },] }
+    ];
+    CallChainService.ctorParameters = function () { return []; };
+    return CallChainService;
+}());
+export { CallChainService };
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/lib/utility/clear-time-information.js

@@ -0,0 +1,11 @@
+/**
+ * Sets milliseconds, seconds, minutes and hours of the provided Moment object to 0
+ * @param date object that we want to clear time information from
+ */
+export function clearTimeInformation(date) {
+    date.milliseconds(0);
+    date.seconds(0);
+    date.minutes(0);
+    date.hours(0);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xlYXItdGltZS1pbmZvcm1hdGlvbi5qcyIsInNvdXJjZVJvb3QiOiJuZzovL0BuZXRncmlmL2NvbXBvbmVudHMtY29yZS8iLCJzb3VyY2VzIjpbImxpYi91dGlsaXR5L2NsZWFyLXRpbWUtaW5mb3JtYXRpb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUE7OztHQUdHO0FBQ0gsTUFBTSxVQUFVLG9CQUFvQixDQUFDLElBQVk7SUFDN0MsSUFBSSxDQUFDLFlBQVksQ0FBQyxDQUFDLENBQUMsQ0FBQztJQUNyQixJQUFJLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FBQyxDQUFDO0lBQ2hCLElBQUksQ0FBQyxPQUFPLENBQUMsQ0FBQyxDQUFDLENBQUM7SUFDaEIsSUFBSSxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUMsQ0FBQztBQUNsQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtNb21lbnR9IGZyb20gJ21vbWVudCc7XG5cbi8qKlxuICogU2V0cyBtaWxsaXNlY29uZHMsIHNlY29uZHMsIG1pbnV0ZXMgYW5kIGhvdXJzIG9mIHRoZSBwcm92aWRlZCBNb21lbnQgb2JqZWN0IHRvIDBcbiAqIEBwYXJhbSBkYXRlIG9iamVjdCB0aGF0IHdlIHdhbnQgdG8gY2xlYXIgdGltZSBpbmZvcm1hdGlvbiBmcm9tXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBjbGVhclRpbWVJbmZvcm1hdGlvbihkYXRlOiBNb21lbnQpOiB2b2lkIHtcbiAgICBkYXRlLm1pbGxpc2Vjb25kcygwKTtcbiAgICBkYXRlLnNlY29uZHMoMCk7XG4gICAgZGF0ZS5taW51dGVzKDApO1xuICAgIGRhdGUuaG91cnMoMCk7XG59XG4iXX0=

package/esm5/lib/utility/destroy-subscription.js

@@ -0,0 +1,10 @@
+/**
+ * Unsubscribes the provided subscription, if it exists and is still opened
+ * @param sub the subscription that should be destroyed
+ */
+export function destroySubscription(sub) {
+    if (sub && !sub.closed) {
+        sub.unsubscribe();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVzdHJveS1zdWJzY3JpcHRpb24uanMiLCJzb3VyY2VSb290Ijoibmc6Ly9AbmV0Z3JpZi9jb21wb25lbnRzLWNvcmUvIiwic291cmNlcyI6WyJsaWIvdXRpbGl0eS9kZXN0cm95LXN1YnNjcmlwdGlvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQTs7O0dBR0c7QUFDSCxNQUFNLFVBQVUsbUJBQW1CLENBQUMsR0FBaUI7SUFDakQsSUFBSSxHQUFHLElBQUksQ0FBQyxHQUFHLENBQUMsTUFBTSxFQUFFO1FBQ3BCLEdBQUcsQ0FBQyxXQUFXLEVBQUUsQ0FBQztLQUNyQjtBQUNMLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge1N1YnNjcmlwdGlvbn0gZnJvbSAncnhqcyc7XG5cbi8qKlxuICogVW5zdWJzY3JpYmVzIHRoZSBwcm92aWRlZCBzdWJzY3JpcHRpb24sIGlmIGl0IGV4aXN0cyBhbmQgaXMgc3RpbGwgb3BlbmVkXG4gKiBAcGFyYW0gc3ViIHRoZSBzdWJzY3JpcHRpb24gdGhhdCBzaG91bGQgYmUgZGVzdHJveWVkXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBkZXN0cm95U3Vic2NyaXB0aW9uKHN1YjogU3Vic2NyaXB0aW9uKTogdm9pZCB7XG4gICAgaWYgKHN1YiAmJiAhc3ViLmNsb3NlZCkge1xuICAgICAgICBzdWIudW5zdWJzY3JpYmUoKTtcbiAgICB9XG59XG4iXX0=

package/esm5/lib/utility/get-field.js

@@ -0,0 +1,48 @@
+/**
+ * @param fields a collection of data fields
+ * @param fieldId the id of the desired field
+ * @returns a reference to the datafield with the specified id or `undefined` if such datafield could not be found
+ */
+export function getField(fields, fieldId) {
+    var index = getFieldIndex(fields, fieldId);
+    return index === -1 ? undefined : fields[index];
+}
+/**
+ * @param fields a collection of data fields
+ * @param fieldId the id of the desired field
+ * @returns the index of the datafield with the specified id or `-1` if such datafield could not be found
+ */
+export function getFieldIndex(fields, fieldId) {
+    return fields.findIndex(function (field) { return field.stringId === fieldId; });
+}
+/**
+ * @param groups a list of searched data groups
+ * @param fieldId the id of the desired field
+ * @returns a reference to the first occurrence of the datafield with the specified id or `undefined` if such datafield could not be found
+ */
+export function getFieldFromDataGroups(groups, fieldId) {
+    var indices = getFieldIndexFromDataGroups(groups, fieldId);
+    if (indices !== undefined) {
+        return groups[indices.dataGroupIndex].fields[indices.fieldIndex];
+    }
+    return undefined;
+}
+/**
+ * @param groups a list of searched data groups
+ * @param fieldId the id of the desired field
+ * @returns an object containing the index of the data group and the field within it corresponding to the first occurrence of a
+ * datafield with the specified id or `undefined` if such datafield could not be found
+ */
+export function getFieldIndexFromDataGroups(groups, fieldId) {
+    for (var i = 0; i < groups.length; i++) {
+        var fieldIndex = getFieldIndex(groups[i].fields, fieldId);
+        if (fieldIndex !== -1) {
+            return {
+                dataGroupIndex: i,
+                fieldIndex: fieldIndex
+            };
+        }
+    }
+    return undefined;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/lib/utility/get-immediate-data.js

@@ -0,0 +1,9 @@
+/**
+ * @param useCase the {@link Case} object who's immediate data we want to get
+ * @param fieldId the identifier of the field we want to get
+ * @returns the immediate data field if it exists on the case, `undefined` otherwise
+ */
+export function getImmediateData(useCase, fieldId) {
+    return useCase.immediateData.find(function (field) { return field.stringId === fieldId; });
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0LWltbWVkaWF0ZS1kYXRhLmpzIiwic291cmNlUm9vdCI6Im5nOi8vQG5ldGdyaWYvY29tcG9uZW50cy1jb3JlLyIsInNvdXJjZXMiOlsibGliL3V0aWxpdHkvZ2V0LWltbWVkaWF0ZS1kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUdBOzs7O0dBSUc7QUFDSCxNQUFNLFVBQVUsZ0JBQWdCLENBQUMsT0FBYSxFQUFFLE9BQWU7SUFDM0QsT0FBTyxPQUFPLENBQUMsYUFBYSxDQUFDLElBQUksQ0FBQyxVQUFBLEtBQUssSUFBSSxPQUFBLEtBQUssQ0FBQyxRQUFRLEtBQUssT0FBTyxFQUExQixDQUEwQixDQUFDLENBQUM7QUFDM0UsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7Q2FzZX0gZnJvbSAnLi4vcmVzb3VyY2VzL2ludGVyZmFjZS9jYXNlJztcbmltcG9ydCB7SW1tZWRpYXRlRGF0YX0gZnJvbSAnLi4vcmVzb3VyY2VzL2ludGVyZmFjZS9pbW1lZGlhdGUtZGF0YSc7XG5cbi8qKlxuICogQHBhcmFtIHVzZUNhc2UgdGhlIHtAbGluayBDYXNlfSBvYmplY3Qgd2hvJ3MgaW1tZWRpYXRlIGRhdGEgd2Ugd2FudCB0byBnZXRcbiAqIEBwYXJhbSBmaWVsZElkIHRoZSBpZGVudGlmaWVyIG9mIHRoZSBmaWVsZCB3ZSB3YW50IHRvIGdldFxuICogQHJldHVybnMgdGhlIGltbWVkaWF0ZSBkYXRhIGZpZWxkIGlmIGl0IGV4aXN0cyBvbiB0aGUgY2FzZSwgYHVuZGVmaW5lZGAgb3RoZXJ3aXNlXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBnZXRJbW1lZGlhdGVEYXRhKHVzZUNhc2U6IENhc2UsIGZpZWxkSWQ6IHN0cmluZyk6IEltbWVkaWF0ZURhdGEgfCB1bmRlZmluZWQge1xuICAgIHJldHVybiB1c2VDYXNlLmltbWVkaWF0ZURhdGEuZmluZChmaWVsZCA9PiBmaWVsZC5zdHJpbmdJZCA9PT0gZmllbGRJZCk7XG59XG4iXX0=

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

@@ -0,0 +1,105 @@
+import { __read, __spread, __values } from "tslib";
+import { GridFiller } from './model/grid-filler';
+var GridLayoutHelper = /** @class */ (function () {
+    function GridLayoutHelper(_log) {
+        this._log = _log;
+    }
+    GridLayoutHelper.addGridRows = function (grid, newRowCount, columnCount) {
+        while (grid.length < newRowCount) {
+            grid.push(GridLayoutHelper.newGridRow(columnCount));
+        }
+    };
+    GridLayoutHelper.newGridRow = function (cols) {
+        return [new GridFiller(0, cols - 1)];
+    };
+    GridLayoutHelper.prototype.fillBlankSpace = function (gridElements, columnCount, elementVisibilityCondition) {
+        var _this = this;
+        if (elementVisibilityCondition === void 0) { elementVisibilityCondition = function () { return true; }; }
+        var grid = [];
+        gridElements.forEach(function (element) {
+            var e_1, _a, e_2, _b;
+            var elementRowEnd = element.layout.y + element.layout.rows - 1;
+            var elementColEnd = element.layout.x + element.layout.cols - 1;
+            if (elementRowEnd >= grid.length) {
+                GridLayoutHelper.addGridRows(grid, elementRowEnd + 1, columnCount);
+            }
+            for (var row = element.layout.y; row <= elementRowEnd; row++) {
+                if (!elementVisibilityCondition(element)) {
+                    try {
+                        for (var _c = (e_1 = void 0, __values(grid[row])), _d = _c.next(); !_d.done; _d = _c.next()) {
+                            var filler = _d.value;
+                            filler.isIntentional = false;
+                        }
+                    }
+                    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                    finally {
+                        try {
+                            if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+                        }
+                        finally { if (e_1) throw e_1.error; }
+                    }
+                }
+                else {
+                    var newFillers = [];
+                    try {
+                        for (var _e = (e_2 = void 0, __values(grid[row])), _f = _e.next(); !_f.done; _f = _e.next()) {
+                            var filler = _f.value;
+                            newFillers.push.apply(newFillers, __spread(filler.fillersAfterCover(element.layout.x, elementColEnd)));
+                        }
+                    }
+                    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                    finally {
+                        try {
+                            if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+                        }
+                        finally { if (e_2) throw e_2.error; }
+                    }
+                    grid[row] = newFillers;
+                }
+            }
+        });
+        var result = gridElements.filter(function (element) { return elementVisibilityCondition(element); })
+            .map(function (element) { return ({
+            item: element,
+            type: element.type,
+            layout: element.layout
+        }); });
+        var encounteredFirst = false;
+        var _loop_1 = function (y) {
+            var row = grid[y];
+            if (row.length === 0) {
+                encounteredFirst = true;
+            }
+            row.forEach(function (filler) {
+                if (!encounteredFirst && !filler.isFullWidth(columnCount)) {
+                    encounteredFirst = true;
+                }
+                if (encounteredFirst && (filler.isIntentional || !filler.isFullWidth(columnCount))) {
+                    result.push(filler.convertToGridElement(y));
+                }
+            });
+        };
+        for (var y = grid.length - 1; y >= 0; y--) {
+            _loop_1(y);
+        }
+        return result.sort(function (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;
+        });
+    };
+    return GridLayoutHelper;
+}());
+export { GridLayoutHelper };
+//# 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;IAEI,0BAAoB,IAAmB;QAAnB,SAAI,GAAJ,IAAI,CAAe;IACvC,CAAC;IAEc,4BAAW,GAA1B,UAA2B,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;IAEc,2BAAU,GAAzB,UAA0B,IAAY;QAClC,OAAO,CAAC,IAAI,UAAU,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,CAAC,CAAC,CAAC;IACzC,CAAC;IAEM,yCAAc,GAArB,UAAsB,YAAgC,EAChC,WAAmB,EACnB,0BAAkE;QAFxF,iBA8DC;QA5DqB,2CAAA,EAAA,2CAA8D,OAAA,IAAI,EAAJ,CAAI;QACpF,IAAM,IAAI,GAA6B,EAAE,CAAC;QAE1C,YAAY,CAAC,OAAO,CAAC,UAAA,OAAO;;YACxB,IAAM,aAAa,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,IAAI,GAAG,CAAC,CAAC;YACjE,IAAM,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;;wBACtC,KAAqB,IAAA,oBAAA,SAAA,IAAI,CAAC,GAAG,CAAC,CAAA,CAAA,gBAAA,4BAAE;4BAA3B,IAAM,MAAM,WAAA;4BACb,MAAM,CAAC,aAAa,GAAG,KAAK,CAAC;yBAChC;;;;;;;;;iBACJ;qBAAM;oBACH,IAAM,UAAU,GAAG,EAAE,CAAC;;wBACtB,KAAqB,IAAA,oBAAA,SAAA,IAAI,CAAC,GAAG,CAAC,CAAA,CAAA,gBAAA,4BAAE;4BAA3B,IAAM,MAAM,WAAA;4BACb,UAAU,CAAC,IAAI,OAAf,UAAU,WAAS,MAAM,CAAC,iBAAiB,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,EAAE,aAAa,CAAC,GAAE;yBACjF;;;;;;;;;oBACD,IAAI,CAAC,GAAG,CAAC,GAAG,UAAU,CAAC;iBAC1B;aACJ;QACL,CAAC,CAAC,CAAC;QAEH,IAAM,MAAM,GAAwC,YAAY,CAAC,MAAM,CAAC,UAAA,OAAO,IAAI,OAAA,0BAA0B,CAAC,OAAO,CAAC,EAAnC,CAAmC,CAAC;aAClH,GAAG,CAAC,UAAA,OAAO,IAAI,OAAA,CAAC;YACb,IAAI,EAAE,OAAO;YACb,IAAI,EAAE,OAAO,CAAC,IAAI;YAClB,MAAM,EAAE,OAAO,CAAC,MAAM;SACzB,CAAC,EAJc,CAId,CAAC,CAAC;QACR,IAAI,gBAAgB,GAAG,KAAK,CAAC;gCACpB,CAAC;YACN,IAAM,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,UAAA,MAAM;gBACd,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;;QAZP,KAAK,IAAI,CAAC,GAAG,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE;oBAAhC,CAAC;SAaT;QAED,OAAO,MAAM,CAAC,IAAI,CAAC,UAAC,CAAC,EAAE,CAAC;YACpB,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,KAAI,CAAC,IAAI,CAAC,IAAI,CAAC,8FAA8F,CAAC,CAAC;YAC/G,OAAO,CAAC,CAAC;QACb,CAAC,CAAC,CAAC;IACP,CAAC;IAEL,uBAAC;AAAD,CAAC,AA/ED,IA+EC","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/esm5/lib/utility/grid-layout/model/grid-element-with-item.js

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

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

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