@netgrif/components-core 6.0.1

package/esm5/lib/tabs/interfaces.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/lib/tabs/public-api.js

@@ -0,0 +1,6 @@
+export * from './interfaces';
+export * from './tab-data-injection-token/tab-data-injection-token';
+export * from './tab-view/abstract-tab-view.component';
+export * from './tab-creation-detector/abstract-tab-creation-detector.component';
+export * from './classes/tab-view';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiJuZzovL0BuZXRncmlmL2NvbXBvbmVudHMtY29yZS8iLCJzb3VyY2VzIjpbImxpYi90YWJzL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxxREFBcUQsQ0FBQztBQUNwRSxjQUFjLHdDQUF3QyxDQUFDO0FBQ3ZELGNBQWMsa0VBQWtFLENBQUM7QUFDakYsY0FBYyxvQkFBb0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vaW50ZXJmYWNlcyc7XG5leHBvcnQgKiBmcm9tICcuL3RhYi1kYXRhLWluamVjdGlvbi10b2tlbi90YWItZGF0YS1pbmplY3Rpb24tdG9rZW4nO1xuZXhwb3J0ICogZnJvbSAnLi90YWItdmlldy9hYnN0cmFjdC10YWItdmlldy5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi90YWItY3JlYXRpb24tZGV0ZWN0b3IvYWJzdHJhY3QtdGFiLWNyZWF0aW9uLWRldGVjdG9yLmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL2NsYXNzZXMvdGFiLXZpZXcnO1xuIl19

package/esm5/lib/tabs/tab-creation-detector/abstract-tab-creation-detector.component.js

@@ -0,0 +1,21 @@
+import { Input } from '@angular/core';
+/**
+ * @ignore
+ * Class that detects tab content creation and then initializes then calls the provided `initializeTab` function.
+ * It is necessary if the tab content is lazy loaded, because the
+ * ComponentPortal's outlet must be initialized before the Portal itself is created.
+ */
+var AbstractTabCreationDetectorComponent = /** @class */ (function () {
+    function AbstractTabCreationDetectorComponent() {
+    }
+    AbstractTabCreationDetectorComponent.prototype.ngOnInit = function () {
+        this.initializeTabFunction(this.tabIndex);
+    };
+    AbstractTabCreationDetectorComponent.propDecorators = {
+        initializeTabFunction: [{ type: Input }],
+        tabIndex: [{ type: Input }]
+    };
+    return AbstractTabCreationDetectorComponent;
+}());
+export { AbstractTabCreationDetectorComponent };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWJzdHJhY3QtdGFiLWNyZWF0aW9uLWRldGVjdG9yLmNvbXBvbmVudC5qcyIsInNvdXJjZVJvb3QiOiJuZzovL0BuZXRncmlmL2NvbXBvbmVudHMtY29yZS8iLCJzb3VyY2VzIjpbImxpYi90YWJzL3RhYi1jcmVhdGlvbi1kZXRlY3Rvci9hYnN0cmFjdC10YWItY3JlYXRpb24tZGV0ZWN0b3IuY29tcG9uZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBQyxLQUFLLEVBQVMsTUFBTSxlQUFlLENBQUM7QUFFNUM7Ozs7O0dBS0c7QUFDSDtJQUFBO0lBZUEsQ0FBQztJQUpHLHVEQUFRLEdBQVI7UUFDSSxJQUFJLENBQUMscUJBQXFCLENBQUMsSUFBSSxDQUFDLFFBQVEsQ0FBQyxDQUFDO0lBQzlDLENBQUM7O3dDQVJBLEtBQUs7MkJBSUwsS0FBSzs7SUFNViwyQ0FBQztDQUFBLEFBZkQsSUFlQztTQWZxQixvQ0FBb0MiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge0lucHV0LCBPbkluaXR9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG4vKipcbiAqIEBpZ25vcmVcbiAqIENsYXNzIHRoYXQgZGV0ZWN0cyB0YWIgY29udGVudCBjcmVhdGlvbiBhbmQgdGhlbiBpbml0aWFsaXplcyB0aGVuIGNhbGxzIHRoZSBwcm92aWRlZCBgaW5pdGlhbGl6ZVRhYmAgZnVuY3Rpb24uXG4gKiBJdCBpcyBuZWNlc3NhcnkgaWYgdGhlIHRhYiBjb250ZW50IGlzIGxhenkgbG9hZGVkLCBiZWNhdXNlIHRoZVxuICogQ29tcG9uZW50UG9ydGFsJ3Mgb3V0bGV0IG11c3QgYmUgaW5pdGlhbGl6ZWQgYmVmb3JlIHRoZSBQb3J0YWwgaXRzZWxmIGlzIGNyZWF0ZWQuXG4gKi9cbmV4cG9ydCBhYnN0cmFjdCBjbGFzcyBBYnN0cmFjdFRhYkNyZWF0aW9uRGV0ZWN0b3JDb21wb25lbnQgaW1wbGVtZW50cyBPbkluaXQge1xuXG4gICAgLyoqXG4gICAgICogZnVuY3Rpb24gdGhhdCBzaG91bGQgYmUgY2FsbGVkIHdoZW4gdGhlIHRhYiBjb250ZW50IGlzIGNyZWF0ZWRcbiAgICAgKi9cbiAgICBASW5wdXQoKSBpbml0aWFsaXplVGFiRnVuY3Rpb246IChpbmRleDogbnVtYmVyKSA9PiB2b2lkO1xuICAgIC8qKlxuICAgICAqIGluZGV4IG9mIHRoZSB0YWIgdGhhdCB0aGUgYGluaXRpYWxpemVUYWJGdW5jdGlvbmAgc2hvdWxkIGJlIGNhbGxlZCBmb3JcbiAgICAgKi9cbiAgICBASW5wdXQoKSB0YWJJbmRleDogbnVtYmVyO1xuXG4gICAgbmdPbkluaXQoKSB7XG4gICAgICAgIHRoaXMuaW5pdGlhbGl6ZVRhYkZ1bmN0aW9uKHRoaXMudGFiSW5kZXgpO1xuICAgIH1cblxufVxuIl19

package/esm5/lib/tabs/tab-data-injection-token/tab-data-injection-token.js

@@ -0,0 +1,8 @@
+import { InjectionToken } from '@angular/core';
+/**
+ * Injection token for injection of {@link InjectedTabData} into tabs in {@link TabView}.
+ *
+ * Also see {@link TabContent} for more information.
+ */
+export var NAE_TAB_DATA = new InjectionToken('NaeTabData');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFiLWRhdGEtaW5qZWN0aW9uLXRva2VuLmpzIiwic291cmNlUm9vdCI6Im5nOi8vQG5ldGdyaWYvY29tcG9uZW50cy1jb3JlLyIsInNvdXJjZXMiOlsibGliL3RhYnMvdGFiLWRhdGEtaW5qZWN0aW9uLXRva2VuL3RhYi1kYXRhLWluamVjdGlvbi10b2tlbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUMsY0FBYyxFQUFDLE1BQU0sZUFBZSxDQUFDO0FBRzdDOzs7O0dBSUc7QUFDSCxNQUFNLENBQUMsSUFBTSxZQUFZLEdBQUcsSUFBSSxjQUFjLENBQWtCLFlBQVksQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtJbmplY3Rpb25Ub2tlbn0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQge0luamVjdGVkVGFiRGF0YX0gZnJvbSAnLi4vaW50ZXJmYWNlcyc7XG5cbi8qKlxuICogSW5qZWN0aW9uIHRva2VuIGZvciBpbmplY3Rpb24gb2Yge0BsaW5rIEluamVjdGVkVGFiRGF0YX0gaW50byB0YWJzIGluIHtAbGluayBUYWJWaWV3fS5cbiAqXG4gKiBBbHNvIHNlZSB7QGxpbmsgVGFiQ29udGVudH0gZm9yIG1vcmUgaW5mb3JtYXRpb24uXG4gKi9cbmV4cG9ydCBjb25zdCBOQUVfVEFCX0RBVEEgPSBuZXcgSW5qZWN0aW9uVG9rZW48SW5qZWN0ZWRUYWJEYXRhPignTmFlVGFiRGF0YScpO1xuIl19

package/esm5/lib/tabs/tab-view/abstract-tab-view.component.js

@@ -0,0 +1,71 @@
+import { Input } from '@angular/core';
+import { TabView } from '../classes/tab-view';
+import { ReplaySubject } from 'rxjs';
+import { take } from 'rxjs/operators';
+/**
+ * Component that renders a tab view.
+ *
+ * See {@link TabView} for the class that holds the logic for this view.
+ */
+var AbstractTabViewComponent = /** @class */ (function () {
+    function AbstractTabViewComponent(_viewService, _logger, _injector) {
+        var _this = this;
+        this._viewService = _viewService;
+        this._logger = _logger;
+        this._injector = _injector;
+        this.align = 'start';
+        this.offset = '';
+        /**
+         * @ignore
+         * lambda function that is passed to the {@link AbstractTabCreationDetectorComponent}s
+         */
+        this.initializeTabLambda = function (index) { _this.tabView.initializeTab(index); };
+    }
+    AbstractTabViewComponent.prototype.ngOnInit = function () {
+        this.tabView = new TabView(this._viewService, this._logger, this.initialTabs, this._injector);
+    };
+    AbstractTabViewComponent.prototype.ngOnDestroy = function () {
+        this.tabView.openedTabs.forEach(function (tab) { return tab.destroy(); });
+    };
+    AbstractTabViewComponent.prototype.badgeHidden = function (tab) {
+        var stream$ = new ReplaySubject(1);
+        if (tab.label && tab.label.count) {
+            tab.label.count.pipe(take(1)).subscribe(function () {
+                stream$.next(false);
+                stream$.complete();
+            });
+        }
+        else {
+            stream$.next(true);
+            stream$.complete();
+        }
+        return stream$;
+    };
+    AbstractTabViewComponent.prototype.badgeCount = function (tab) {
+        var _this = this;
+        var stream$ = new ReplaySubject(1);
+        if (tab.label && tab.label.count) {
+            tab.label.count.pipe(take(1)).subscribe(function (count) {
+                stream$.next(count + '');
+                _this.setOffset((count + '').length);
+                stream$.complete();
+            });
+        }
+        else {
+            stream$.next('0');
+            stream$.complete();
+        }
+        return stream$;
+    };
+    AbstractTabViewComponent.prototype.setOffset = function (count) {
+        this.offset = Array(count * 2).join('\xa0');
+    };
+    AbstractTabViewComponent.propDecorators = {
+        initialTabs: [{ type: Input }],
+        stretch: [{ type: Input }],
+        align: [{ type: Input }]
+    };
+    return AbstractTabViewComponent;
+}());
+export { AbstractTabViewComponent };
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/lib/task/interfaces/task-operations.js

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

package/esm5/lib/task/models/null-task-operations.js

@@ -0,0 +1,30 @@
+/**
+ * Null implementation of the {@link TaskOperations} interface.
+ */
+var NullTaskOperations = /** @class */ (function () {
+    function NullTaskOperations() {
+    }
+    /**
+     * Calling this function does nothing
+     */
+    NullTaskOperations.prototype.close = function () {
+    };
+    /**
+     * Calling this function does nothing
+     */
+    NullTaskOperations.prototype.open = function () {
+    };
+    /**
+     * Calling this function does nothing
+     */
+    NullTaskOperations.prototype.reload = function () {
+    };
+    /**
+     * Calling this function does nothing
+     */
+    NullTaskOperations.prototype.forceReload = function () {
+    };
+    return NullTaskOperations;
+}());
+export { NullTaskOperations };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibnVsbC10YXNrLW9wZXJhdGlvbnMuanMiLCJzb3VyY2VSb290Ijoibmc6Ly9AbmV0Z3JpZi9jb21wb25lbnRzLWNvcmUvIiwic291cmNlcyI6WyJsaWIvdGFzay9tb2RlbHMvbnVsbC10YXNrLW9wZXJhdGlvbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUE7O0dBRUc7QUFDSDtJQUFBO0lBd0JBLENBQUM7SUF2Qkc7O09BRUc7SUFDSCxrQ0FBSyxHQUFMO0lBQ0EsQ0FBQztJQUVEOztPQUVHO0lBQ0gsaUNBQUksR0FBSjtJQUNBLENBQUM7SUFFRDs7T0FFRztJQUNILG1DQUFNLEdBQU47SUFDQSxDQUFDO0lBRUQ7O09BRUc7SUFDSCx3Q0FBVyxHQUFYO0lBQ0EsQ0FBQztJQUNMLHlCQUFDO0FBQUQsQ0FBQyxBQXhCRCxJQXdCQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7VGFza09wZXJhdGlvbnN9IGZyb20gJy4uL2ludGVyZmFjZXMvdGFzay1vcGVyYXRpb25zJztcblxuLyoqXG4gKiBOdWxsIGltcGxlbWVudGF0aW9uIG9mIHRoZSB7QGxpbmsgVGFza09wZXJhdGlvbnN9IGludGVyZmFjZS5cbiAqL1xuZXhwb3J0IGNsYXNzIE51bGxUYXNrT3BlcmF0aW9ucyBpbXBsZW1lbnRzIFRhc2tPcGVyYXRpb25zIHtcbiAgICAvKipcbiAgICAgKiBDYWxsaW5nIHRoaXMgZnVuY3Rpb24gZG9lcyBub3RoaW5nXG4gICAgICovXG4gICAgY2xvc2UoKTogdm9pZCB7XG4gICAgfVxuXG4gICAgLyoqXG4gICAgICogQ2FsbGluZyB0aGlzIGZ1bmN0aW9uIGRvZXMgbm90aGluZ1xuICAgICAqL1xuICAgIG9wZW4oKTogdm9pZCB7XG4gICAgfVxuXG4gICAgLyoqXG4gICAgICogQ2FsbGluZyB0aGlzIGZ1bmN0aW9uIGRvZXMgbm90aGluZ1xuICAgICAqL1xuICAgIHJlbG9hZCgpOiB2b2lkIHtcbiAgICB9XG5cbiAgICAvKipcbiAgICAgKiBDYWxsaW5nIHRoaXMgZnVuY3Rpb24gZG9lcyBub3RoaW5nXG4gICAgICovXG4gICAgZm9yY2VSZWxvYWQoKTogdm9pZCB7XG4gICAgfVxufVxuIl19

package/esm5/lib/task/models/subject-task-operations.js

@@ -0,0 +1,76 @@
+import { Subject } from 'rxjs';
+/**
+ * An implementation of the {@link TaskOperations} interface that provides a Subject for both operations.
+ */
+var SubjectTaskOperations = /** @class */ (function () {
+    function SubjectTaskOperations() {
+        this._open = new Subject();
+        this._close = new Subject();
+        this._reload = new Subject();
+        this._forceReload = new Subject();
+    }
+    /**
+     * Emits into the [open$]{@link SubjectTaskOperations#open$} stream.
+     */
+    SubjectTaskOperations.prototype.open = function () {
+        this._open.next();
+    };
+    /**
+     * Emits into the [close$]{@link SubjectTaskOperations#close$} stream.
+     */
+    SubjectTaskOperations.prototype.close = function () {
+        this._close.next();
+    };
+    /**
+     * Emits into the [reload$]{@link SubjectTaskOperations#reload$} stream.
+     */
+    SubjectTaskOperations.prototype.reload = function () {
+        this._reload.next();
+    };
+    /**
+     * Emits into the [forceReload$]{@link SubjectTaskOperations#forceReload$} stream.
+     */
+    SubjectTaskOperations.prototype.forceReload = function () {
+        this._forceReload.next();
+    };
+    Object.defineProperty(SubjectTaskOperations.prototype, "open$", {
+        get: function () {
+            return this._open.asObservable();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(SubjectTaskOperations.prototype, "close$", {
+        get: function () {
+            return this._close.asObservable();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(SubjectTaskOperations.prototype, "reload$", {
+        get: function () {
+            return this._reload.asObservable();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(SubjectTaskOperations.prototype, "forceReload$", {
+        get: function () {
+            return this._forceReload.asObservable();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Completes the underlying streams
+     */
+    SubjectTaskOperations.prototype.ngOnDestroy = function () {
+        this._open.complete();
+        this._close.complete();
+        this._reload.complete();
+        this._forceReload.complete();
+    };
+    return SubjectTaskOperations;
+}());
+export { SubjectTaskOperations };
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/lib/task/models/task-operations-injection-token.js

@@ -0,0 +1,3 @@
+import { InjectionToken } from '@angular/core';
+export var NAE_TASK_OPERATIONS = new InjectionToken('NaeTaskOperationsInterface');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFzay1vcGVyYXRpb25zLWluamVjdGlvbi10b2tlbi5qcyIsInNvdXJjZVJvb3QiOiJuZzovL0BuZXRncmlmL2NvbXBvbmVudHMtY29yZS8iLCJzb3VyY2VzIjpbImxpYi90YXNrL21vZGVscy90YXNrLW9wZXJhdGlvbnMtaW5qZWN0aW9uLXRva2VuLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBQyxjQUFjLEVBQUMsTUFBTSxlQUFlLENBQUM7QUFHN0MsTUFBTSxDQUFDLElBQU0sbUJBQW1CLEdBQUcsSUFBSSxjQUFjLENBQWlCLDRCQUE0QixDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge0luamVjdGlvblRva2VufSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7VGFza09wZXJhdGlvbnN9IGZyb20gJy4uL2ludGVyZmFjZXMvdGFzay1vcGVyYXRpb25zJztcblxuZXhwb3J0IGNvbnN0IE5BRV9UQVNLX09QRVJBVElPTlMgPSBuZXcgSW5qZWN0aW9uVG9rZW48VGFza09wZXJhdGlvbnM+KCdOYWVUYXNrT3BlcmF0aW9uc0ludGVyZmFjZScpO1xuIl19

package/esm5/lib/task/models/task-set-data-request-context.js

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

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

@@ -0,0 +1,19 @@
+/* SERVICES */
+export * from './services/assign-task.service';
+export * from './services/cancel-task.service';
+export * from './services/delegate-task.service';
+export * from './services/finish-task.service';
+export * from './services/task-request-state.service';
+export * from './services/task-data.service';
+export * from './services/data-focus-policy.service';
+export * from './services/assign-policy.service';
+export * from './services/finish-policy.service';
+export * from './services/task-handling-service';
+export * from './services/selected-case.service';
+/* MODELS */
+export * from './models/task-operations-injection-token';
+export * from './models/subject-task-operations';
+export * from './models/null-task-operations';
+/* INTERFACES */
+export * from './interfaces/task-operations';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiJuZzovL0BuZXRncmlmL2NvbXBvbmVudHMtY29yZS8iLCJzb3VyY2VzIjpbImxpYi90YXNrL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYztBQUNkLGNBQWMsZ0NBQWdDLENBQUM7QUFDL0MsY0FBYyxnQ0FBZ0MsQ0FBQztBQUMvQyxjQUFjLGtDQUFrQyxDQUFDO0FBQ2pELGNBQWMsZ0NBQWdDLENBQUM7QUFDL0MsY0FBYyx1Q0FBdUMsQ0FBQztBQUN0RCxjQUFjLDhCQUE4QixDQUFDO0FBQzdDLGNBQWMsc0NBQXNDLENBQUM7QUFDckQsY0FBYyxrQ0FBa0MsQ0FBQztBQUNqRCxjQUFjLGtDQUFrQyxDQUFDO0FBQ2pELGNBQWMsa0NBQWtDLENBQUM7QUFDakQsY0FBYyxrQ0FBa0MsQ0FBQztBQUVqRCxZQUFZO0FBQ1osY0FBYywwQ0FBMEMsQ0FBQztBQUN6RCxjQUFjLGtDQUFrQyxDQUFDO0FBQ2pELGNBQWMsK0JBQStCLENBQUM7QUFFOUMsZ0JBQWdCO0FBQ2hCLGNBQWMsOEJBQThCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKiBTRVJWSUNFUyAqL1xuZXhwb3J0ICogZnJvbSAnLi9zZXJ2aWNlcy9hc3NpZ24tdGFzay5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vc2VydmljZXMvY2FuY2VsLXRhc2suc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL3NlcnZpY2VzL2RlbGVnYXRlLXRhc2suc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL3NlcnZpY2VzL2ZpbmlzaC10YXNrLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9zZXJ2aWNlcy90YXNrLXJlcXVlc3Qtc3RhdGUuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL3NlcnZpY2VzL3Rhc2stZGF0YS5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vc2VydmljZXMvZGF0YS1mb2N1cy1wb2xpY3kuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL3NlcnZpY2VzL2Fzc2lnbi1wb2xpY3kuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL3NlcnZpY2VzL2ZpbmlzaC1wb2xpY3kuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL3NlcnZpY2VzL3Rhc2staGFuZGxpbmctc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL3NlcnZpY2VzL3NlbGVjdGVkLWNhc2Uuc2VydmljZSc7XG5cbi8qIE1PREVMUyAqL1xuZXhwb3J0ICogZnJvbSAnLi9tb2RlbHMvdGFzay1vcGVyYXRpb25zLWluamVjdGlvbi10b2tlbic7XG5leHBvcnQgKiBmcm9tICcuL21vZGVscy9zdWJqZWN0LXRhc2stb3BlcmF0aW9ucyc7XG5leHBvcnQgKiBmcm9tICcuL21vZGVscy9udWxsLXRhc2stb3BlcmF0aW9ucyc7XG5cbi8qIElOVEVSRkFDRVMgKi9cbmV4cG9ydCAqIGZyb20gJy4vaW50ZXJmYWNlcy90YXNrLW9wZXJhdGlvbnMnO1xuIl19

package/esm5/lib/task/services/assign-policy.service.js

@@ -0,0 +1,189 @@
+import { __extends } from "tslib";
+import { Inject, Injectable } from '@angular/core';
+import { AssignPolicy } from '../../task-content/model/policy';
+import { TaskHandlingService } from './task-handling-service';
+import { TaskContentService } from '../../task-content/services/task-content.service';
+import { TaskDataService } from './task-data.service';
+import { AssignTaskService } from './assign-task.service';
+import { CancelTaskService } from './cancel-task.service';
+import { FinishPolicyService } from './finish-policy.service';
+import { NAE_TASK_OPERATIONS } from '../models/task-operations-injection-token';
+import { CallChainService } from '../../utility/call-chain/call-chain.service';
+import { UserComparatorService } from '../../user/services/user-comparator.service';
+import { AfterAction } from '../../utility/call-chain/after-action';
+import { PermissionService } from '../../authorization/permission/permission.service';
+import { PermissionType } from '../../process/permissions';
+/**
+ * Handles the sequence of actions that are performed when a task is being assigned, based on the task's configuration.
+ */
+var AssignPolicyService = /** @class */ (function (_super) {
+    __extends(AssignPolicyService, _super);
+    function AssignPolicyService(_taskDataService, _assignTaskService, _cancelTaskService, _finishPolicyService, _callchain, _userComparatorService, _taskOperations, taskContentService, _permissionService) {
+        var _this = _super.call(this, taskContentService) || this;
+        _this._taskDataService = _taskDataService;
+        _this._assignTaskService = _assignTaskService;
+        _this._cancelTaskService = _cancelTaskService;
+        _this._finishPolicyService = _finishPolicyService;
+        _this._callchain = _callchain;
+        _this._userComparatorService = _userComparatorService;
+        _this._taskOperations = _taskOperations;
+        _this._permissionService = _permissionService;
+        _this._isForced = false;
+        return _this;
+    }
+    Object.defineProperty(AssignPolicyService.prototype, "forced", {
+        get: function () {
+            return this._isForced;
+        },
+        set: function (bool) {
+            this._isForced = bool;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Performs the actions that correspond to the policy defined by the Task on it's assignment.
+     * @param taskOpened whether the Task was 'opened' (eg. task panel is expanding) or 'closed' (eg. task panel is collapsing)
+     * @param afterAction the action that should be performed when the assign policy (and all following policies) finishes
+     */
+    AssignPolicyService.prototype.performAssignPolicy = function (taskOpened, afterAction) {
+        if (afterAction === void 0) { afterAction = new AfterAction(); }
+        if (this._safeTask.assignPolicy === AssignPolicy.auto
+            && this._permissionService.hasTaskPermission(this._safeTask, PermissionType.ASSIGN)) {
+            this.autoAssignPolicy(taskOpened, afterAction);
+        }
+        else {
+            this.manualAssignPolicy(taskOpened, afterAction);
+        }
+    };
+    /**
+     * Performs the actions that correspond to the [Auto Assign Policy]{@link AssignPolicy#auto}.
+     * @param taskOpened whether the Task was 'opened' (eg. task panel is expanding) or 'closed' (eg. task panel is collapsing)
+     * @param afterAction the action that should be performed when the assign policy (and all following policies) finishes
+     */
+    AssignPolicyService.prototype.autoAssignPolicy = function (taskOpened, afterAction) {
+        if (taskOpened) {
+            this.autoAssignOpenedPolicy(afterAction);
+        }
+        else {
+            this.autoAssignClosedPolicy(afterAction);
+        }
+    };
+    /**
+     * Performs the actions that correspond to the [Auto Assign Policy]{@link AssignPolicy#auto}
+     * when a task is 'opening' (eg. task panel is expanding).
+     *
+     * Assigns the task, reloads the current task page, loads task data and performs the finish policy.
+     *
+     * See [finish policy]{@link FinishPolicyService#performFinishPolicy} for more information.
+     *
+     * @param afterAction the action that should be performed when the assign policy (and all following policies) finishes
+     */
+    AssignPolicyService.prototype.autoAssignOpenedPolicy = function (afterAction) {
+        var _this = this;
+        this._assignTaskService.assign(this._callchain.create((function (assignSuccess) {
+            _this.afterAssignOpenPolicy(assignSuccess, afterAction);
+        })));
+    };
+    /**
+     * Reloads the current page of tasks if the preceding assign operation succeeded. Then initializes the task's data fields.
+     * @param assignSuccess whether the preceding assign succeeded or not
+     * @param afterAction the action that should be performed when the assign policy (and all following policies) finishes
+     */
+    AssignPolicyService.prototype.afterAssignOpenPolicy = function (assignSuccess, afterAction) {
+        var _this = this;
+        if (!assignSuccess) {
+            afterAction.resolve(false);
+            return;
+        }
+        this._taskDataService.initializeTaskDataFields(this._callchain.create(function (requestSuccessful) {
+            if (requestSuccessful) {
+                _this._finishPolicyService.performFinishPolicy(afterAction);
+            }
+            else {
+                afterAction.resolve(false);
+            }
+        }), this._isForced);
+    };
+    /**
+     * Requests a reload of the task and then requests the task to be closed.
+     *
+     * @param afterAction the action that should be performed when the assign policy (and all following policies) finishes
+     */
+    AssignPolicyService.prototype.autoAssignClosedPolicy = function (afterAction) {
+        var _this = this;
+        if (!this._userComparatorService.compareUsers(this._task.user)) {
+            this._taskOperations.close();
+            afterAction.next(false);
+            afterAction.complete();
+            return;
+        }
+        this._cancelTaskService.cancel(this._callchain.create(function (requestSuccess) {
+            _this._taskOperations.close();
+            afterAction.next(requestSuccess);
+            afterAction.complete();
+        }));
+    };
+    /**
+     * Performs the actions that correspond to the [Manual Assign Policy]{@link AssignPolicy#manual}.
+     * @param taskOpened whether the Task was 'opened' (eg. task panel is expanding) or 'closed' (eg. task panel is collapsing)
+     * @param afterAction the action that should be performed when the assign policy (and all following policies) finishes
+     */
+    AssignPolicyService.prototype.manualAssignPolicy = function (taskOpened, afterAction) {
+        if (taskOpened) {
+            this.manualAssignOpenedPolicy(afterAction);
+        }
+        else {
+            afterAction.resolve(false);
+        }
+    };
+    /**
+     * Performs the actions that correspond to the [Manual Assign Policy]{@link AssignPolicy#manual}
+     * when a task is 'opening' (eg. task panel is expanding).
+     *
+     * Loads task data and performs the [finish policy]{@link FinishPolicyService#performFinishPolicy}.
+     *
+     * See [finish policy]{@link FinishPolicyService#performFinishPolicy} for more information.
+     *
+     * @param afterAction the action that should be performed when the assign policy (and all following policies) finishes
+     */
+    AssignPolicyService.prototype.manualAssignOpenedPolicy = function (afterAction) {
+        var _this = this;
+        this._taskDataService.initializeTaskDataFields(this._callchain.create(function (requestSuccessful) {
+            if (requestSuccessful) {
+                _this._finishPolicyService.performFinishPolicy(afterAction);
+            }
+            else {
+                afterAction.resolve(false);
+            }
+        }), this._isForced);
+    };
+    AssignPolicyService.ctorParameters = function () { return [
+        { type: TaskDataService },
+        { type: AssignTaskService },
+        { type: CancelTaskService },
+        { type: FinishPolicyService },
+        { type: CallChainService },
+        { type: UserComparatorService },
+        { type: undefined, decorators: [{ type: Inject, args: [NAE_TASK_OPERATIONS,] }] },
+        { type: TaskContentService },
+        { type: PermissionService }
+    ]; };
+    AssignPolicyService.decorators = [
+        { type: Injectable }
+    ];
+    AssignPolicyService.ctorParameters = function () { return [
+        { type: TaskDataService },
+        { type: AssignTaskService },
+        { type: CancelTaskService },
+        { type: FinishPolicyService },
+        { type: CallChainService },
+        { type: UserComparatorService },
+        { type: undefined, decorators: [{ type: Inject, args: [NAE_TASK_OPERATIONS,] }] },
+        { type: TaskContentService },
+        { type: PermissionService }
+    ]; };
+    return AssignPolicyService;
+}(TaskHandlingService));
+export { AssignPolicyService };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"assign-policy.service.js","sourceRoot":"ng://@netgrif/components-core/","sources":["lib/task/services/assign-policy.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Inject, Injectable} from '@angular/core';\nimport {AssignPolicy} from '../../task-content/model/policy';\nimport {TaskHandlingService} from './task-handling-service';\nimport {TaskContentService} from '../../task-content/services/task-content.service';\nimport {TaskDataService} from './task-data.service';\nimport {AssignTaskService} from './assign-task.service';\nimport {CancelTaskService} from './cancel-task.service';\nimport {FinishPolicyService} from './finish-policy.service';\nimport {NAE_TASK_OPERATIONS} from '../models/task-operations-injection-token';\nimport {TaskOperations} from '../interfaces/task-operations';\nimport {CallChainService} from '../../utility/call-chain/call-chain.service';\nimport {Subject} from 'rxjs';\nimport {UserComparatorService} from '../../user/services/user-comparator.service';\nimport {AfterAction} from '../../utility/call-chain/after-action';\nimport {PermissionService} from '../../authorization/permission/permission.service';\nimport {PermissionType} from '../../process/permissions';\n\n/**\n * Handles the sequence of actions that are performed when a task is being assigned, based on the task's configuration.\n */\n@Injectable()\nexport class AssignPolicyService extends TaskHandlingService {\n\n    private _isForced = false;\n\n    constructor(protected _taskDataService: TaskDataService,\n                protected _assignTaskService: AssignTaskService,\n                protected _cancelTaskService: CancelTaskService,\n                protected _finishPolicyService: FinishPolicyService,\n                protected _callchain: CallChainService,\n                protected _userComparatorService: UserComparatorService,\n                @Inject(NAE_TASK_OPERATIONS) protected _taskOperations: TaskOperations,\n                taskContentService: TaskContentService,\n                protected _permissionService: PermissionService) {\n        super(taskContentService);\n    }\n\n    get forced() {\n        return this._isForced;\n    }\n\n    set forced(bool: boolean) {\n        this._isForced = bool;\n    }\n\n    /**\n     * Performs the actions that correspond to the policy defined by the Task on it's assignment.\n     * @param taskOpened whether the Task was 'opened' (eg. task panel is expanding) or 'closed' (eg. task panel is collapsing)\n     * @param afterAction the action that should be performed when the assign policy (and all following policies) finishes\n     */\n    public performAssignPolicy(taskOpened: boolean, afterAction: AfterAction = new AfterAction()): void {\n        if (this._safeTask.assignPolicy === AssignPolicy.auto\n            && this._permissionService.hasTaskPermission(this._safeTask, PermissionType.ASSIGN)) {\n            this.autoAssignPolicy(taskOpened, afterAction);\n        } else {\n            this.manualAssignPolicy(taskOpened, afterAction);\n        }\n    }\n\n    /**\n     * Performs the actions that correspond to the [Auto Assign Policy]{@link AssignPolicy#auto}.\n     * @param taskOpened whether the Task was 'opened' (eg. task panel is expanding) or 'closed' (eg. task panel is collapsing)\n     * @param afterAction the action that should be performed when the assign policy (and all following policies) finishes\n     */\n    protected autoAssignPolicy(taskOpened: boolean, afterAction: AfterAction): void {\n        if (taskOpened) {\n            this.autoAssignOpenedPolicy(afterAction);\n        } else {\n            this.autoAssignClosedPolicy(afterAction);\n        }\n    }\n\n    /**\n     * Performs the actions that correspond to the [Auto Assign Policy]{@link AssignPolicy#auto}\n     * when a task is 'opening' (eg. task panel is expanding).\n     *\n     * Assigns the task, reloads the current task page, loads task data and performs the finish policy.\n     *\n     * See [finish policy]{@link FinishPolicyService#performFinishPolicy} for more information.\n     *\n     * @param afterAction the action that should be performed when the assign policy (and all following policies) finishes\n     */\n    protected autoAssignOpenedPolicy(afterAction: AfterAction): void {\n        this._assignTaskService.assign(\n            this._callchain.create((assignSuccess => {\n                this.afterAssignOpenPolicy(assignSuccess, afterAction);\n            }))\n        );\n    }\n\n    /**\n     * Reloads the current page of tasks if the preceding assign operation succeeded. Then initializes the task's data fields.\n     * @param assignSuccess whether the preceding assign succeeded or not\n     * @param afterAction the action that should be performed when the assign policy (and all following policies) finishes\n     */\n    protected afterAssignOpenPolicy(assignSuccess: boolean, afterAction: AfterAction): void {\n        if (!assignSuccess) {\n            afterAction.resolve(false);\n            return;\n        }\n\n        this._taskDataService.initializeTaskDataFields(\n            this._callchain.create((requestSuccessful) => {\n                if (requestSuccessful) {\n                    this._finishPolicyService.performFinishPolicy(afterAction);\n                } else {\n                    afterAction.resolve(false);\n                }\n            }),\n            this._isForced\n        );\n    }\n\n    /**\n     * Requests a reload of the task and then requests the task to be closed.\n     *\n     * @param afterAction the action that should be performed when the assign policy (and all following policies) finishes\n     */\n    protected autoAssignClosedPolicy(afterAction: Subject<boolean>): void {\n        if (!this._userComparatorService.compareUsers(this._task.user)) {\n            this._taskOperations.close();\n            afterAction.next(false);\n            afterAction.complete();\n            return;\n    }\n        this._cancelTaskService.cancel(\n            this._callchain.create((requestSuccess) => {\n                this._taskOperations.close();\n                afterAction.next(requestSuccess);\n                afterAction.complete();\n            })\n        );\n    }\n\n    /**\n     * Performs the actions that correspond to the [Manual Assign Policy]{@link AssignPolicy#manual}.\n     * @param taskOpened whether the Task was 'opened' (eg. task panel is expanding) or 'closed' (eg. task panel is collapsing)\n     * @param afterAction the action that should be performed when the assign policy (and all following policies) finishes\n     */\n    protected manualAssignPolicy(taskOpened: boolean, afterAction: AfterAction): void {\n        if (taskOpened) {\n            this.manualAssignOpenedPolicy(afterAction);\n        } else {\n            afterAction.resolve(false);\n        }\n    }\n\n    /**\n     * Performs the actions that correspond to the [Manual Assign Policy]{@link AssignPolicy#manual}\n     * when a task is 'opening' (eg. task panel is expanding).\n     *\n     * Loads task data and performs the [finish policy]{@link FinishPolicyService#performFinishPolicy}.\n     *\n     * See [finish policy]{@link FinishPolicyService#performFinishPolicy} for more information.\n     *\n     * @param afterAction the action that should be performed when the assign policy (and all following policies) finishes\n     */\n    protected manualAssignOpenedPolicy(afterAction: AfterAction): void {\n        this._taskDataService.initializeTaskDataFields(\n            this._callchain.create((requestSuccessful) => {\n                if (requestSuccessful) {\n                    this._finishPolicyService.performFinishPolicy(afterAction);\n                } else {\n                    afterAction.resolve(false);\n                }\n            }),\n            this._isForced\n        );\n    }\n}\n"]}