@netgrif/components-core 6.0.1

package/esm2015/lib/view/case-view/components/case-list/abstract-case-list.component.js

@@ -0,0 +1,82 @@
+import { EventEmitter, Inject, Input, Optional, Output, ViewChild } from '@angular/core';
+import { CaseViewService } from '../../service/case-view-service';
+import { CdkVirtualScrollViewport } from '@angular/cdk/scrolling';
+import { Subject } from 'rxjs';
+import { LoggerService } from '../../../../logger/services/logger.service';
+import { TabbedVirtualScrollComponent } from '../../../../panel/abstract/tabbed-virtual-scroll.component';
+import { NAE_TAB_DATA } from '../../../../tabs/tab-data-injection-token/tab-data-injection-token';
+import { ActivatedRoute } from '@angular/router';
+import { filter, takeUntil } from 'rxjs/operators';
+export class AbstractCaseListComponent extends TabbedVirtualScrollComponent {
+    constructor(_caseViewService, _log, injectedTabData, route) {
+        super(injectedTabData);
+        this._caseViewService = _caseViewService;
+        this._log = _log;
+        this.route = route;
+        this.responsiveBody = true;
+        this.showCasePanelIcon = true;
+        this.showDeleteMenu = false;
+        this.textEllipsis = false;
+        this.redirectEnabled = true;
+        this.cases$ = this._caseViewService.cases$;
+        this.unsubscribe$ = new Subject();
+        this.loading$ = this._caseViewService.loading$;
+        this.caseClick = new EventEmitter();
+        this.onRedirect();
+    }
+    ngOnDestroy() {
+        super.ngOnDestroy();
+        this.caseClick.complete();
+        this.unsubscribe$.complete();
+    }
+    trackBy(i) {
+        return i;
+    }
+    get loadedDataSize() {
+        return this.viewport && this.viewport.getDataLength() ? this.viewport.getDataLength() : 0;
+    }
+    loadNextPage() {
+        if (!this.viewport) {
+            return;
+        }
+        this._caseViewService.nextPage(this.viewport.getRenderedRange(), this.viewport.getDataLength());
+    }
+    onCaseClick(case_) {
+        this.caseClick.emit(case_);
+    }
+    onRedirect() {
+        if (!this.redirectEnabled) {
+            return;
+        }
+        this.route.queryParams.pipe(filter(pm => !!pm['caseId'])).subscribe(paramMap => {
+            this.redirectCaseId = paramMap['caseId'];
+            this.cases$.pipe(takeUntil(this.unsubscribe$)).subscribe(cases => {
+                if (cases !== undefined && cases.length > 0) {
+                    const _case = cases.find(c => c.stringId === this.redirectCaseId);
+                    if (_case !== undefined) {
+                        this.caseClick.emit(_case);
+                        this.unsubscribe$.next();
+                    }
+                }
+            });
+        });
+    }
+}
+AbstractCaseListComponent.ctorParameters = () => [
+    { type: CaseViewService },
+    { type: LoggerService },
+    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [NAE_TAB_DATA,] }] },
+    { type: ActivatedRoute }
+];
+AbstractCaseListComponent.propDecorators = {
+    selectedHeaders$: [{ type: Input }],
+    responsiveBody: [{ type: Input }],
+    caseClick: [{ type: Output }],
+    showCasePanelIcon: [{ type: Input }],
+    showDeleteMenu: [{ type: Input }],
+    textEllipsis: [{ type: Input }],
+    width: [{ type: Input }],
+    redirectEnabled: [{ type: Input }],
+    viewport: [{ type: ViewChild, args: [CdkVirtualScrollViewport,] }]
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"abstract-case-list.component.js","sourceRoot":"ng://@netgrif/components-core/","sources":["lib/view/case-view/components/case-list/abstract-case-list.component.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,YAAY,EACZ,MAAM,EACN,KAAK,EAEL,QAAQ,EACR,MAAM,EACN,SAAS,EACZ,MAAM,eAAe,CAAC;AACvB,OAAO,EAAC,eAAe,EAAC,MAAM,iCAAiC,CAAC;AAChE,OAAO,EAAC,wBAAwB,EAAC,MAAM,wBAAwB,CAAC;AAChE,OAAO,EAAa,OAAO,EAAC,MAAM,MAAM,CAAC;AAGzC,OAAO,EAAC,aAAa,EAAC,MAAM,4CAA4C,CAAC;AACzE,OAAO,EAAC,4BAA4B,EAAC,MAAM,4DAA4D,CAAC;AACxG,OAAO,EAAC,YAAY,EAAC,MAAM,oEAAoE,CAAC;AAEhG,OAAO,EAAC,cAAc,EAAC,MAAM,iBAAiB,CAAC;AAC/C,OAAO,EAAC,MAAM,EAAE,SAAS,EAAC,MAAM,gBAAgB,CAAC;AAEjD,MAAM,OAAgB,yBAA0B,SAAQ,4BAA4B;IAiBhF,YAAgC,gBAAiC,EACjC,IAAmB,EACK,eAAgC,EACxD,KAAsB;QAClD,KAAK,CAAC,eAAe,CAAC,CAAC;QAJK,qBAAgB,GAAhB,gBAAgB,CAAiB;QACjC,SAAI,GAAJ,IAAI,CAAe;QAEnB,UAAK,GAAL,KAAK,CAAiB;QAjB7C,mBAAc,GAAG,IAAI,CAAC;QAEtB,sBAAiB,GAAG,IAAI,CAAC;QACzB,mBAAc,GAAG,KAAK,CAAC;QACvB,iBAAY,GAAG,KAAK,CAAC;QAErB,oBAAe,GAAG,IAAI,CAAC;QAa5B,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC;QAC3C,IAAI,CAAC,YAAY,GAAG,IAAI,OAAO,EAAQ,CAAC;QACxC,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,gBAAgB,CAAC,QAAQ,CAAC;QAC/C,IAAI,CAAC,SAAS,GAAG,IAAI,YAAY,EAAQ,CAAC;QAC1C,IAAI,CAAC,UAAU,EAAE,CAAC;IACtB,CAAC;IAED,WAAW;QACP,KAAK,CAAC,WAAW,EAAE,CAAC;QACpB,IAAI,CAAC,SAAS,CAAC,QAAQ,EAAE,CAAC;QAC1B,IAAI,CAAC,YAAY,CAAC,QAAQ,EAAE,CAAC;IACjC,CAAC;IAEM,OAAO,CAAC,CAAC;QACZ,OAAO,CAAC,CAAC;IACb,CAAC;IAED,IAAW,cAAc;QACrB,OAAO,IAAI,CAAC,QAAQ,IAAI,IAAI,CAAC,QAAQ,CAAC,aAAa,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,aAAa,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;IAC9F,CAAC;IAEM,YAAY;QACf,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE;YAChB,OAAO;SACV;QACD,IAAI,CAAC,gBAAgB,CAAC,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC,gBAAgB,EAAE,EAAE,IAAI,CAAC,QAAQ,CAAC,aAAa,EAAE,CAAC,CAAC;IACpG,CAAC;IAEM,WAAW,CAAC,KAAW;QAC1B,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAC/B,CAAC;IAEM,UAAU;QACb,IAAI,CAAC,IAAI,CAAC,eAAe,EAAE;YACvB,OAAO;SACV;QAED,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,QAAQ,CAAC,EAAE;YACxE,IAAI,CAAC,cAAc,GAAG,QAAQ,CAAC,QAAQ,CAAC,CAAC;YACzC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE;gBAC7D,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE;oBACzC,MAAM,KAAK,GAAG,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,KAAK,IAAI,CAAC,cAAc,CAAC,CAAC;oBAClE,IAAI,KAAK,KAAK,SAAS,EAAE;wBACrB,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;wBAC3B,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,CAAC;qBAC5B;iBACJ;YACL,CAAC,CAAC,CAAC;QACV,CAAC,CAAC,CAAC;IACP,CAAC;;;YAnFG,eAAe;YAKf,aAAa;4CA0BM,QAAQ,YAAI,MAAM,SAAC,YAAY;YAtBlD,cAAc;;;+BAKjB,KAAK;6BACL,KAAK;wBACL,MAAM;gCACN,KAAK;6BACL,KAAK;2BACL,KAAK;oBACL,KAAK;8BACL,KAAK;uBAEL,SAAS,SAAC,wBAAwB","sourcesContent":["import {\n    EventEmitter,\n    Inject,\n    Input,\n    OnDestroy,\n    Optional,\n    Output,\n    ViewChild\n} from '@angular/core';\nimport {CaseViewService} from '../../service/case-view-service';\nimport {CdkVirtualScrollViewport} from '@angular/cdk/scrolling';\nimport {Observable, Subject} from 'rxjs';\nimport {Case} from '../../../../resources/interface/case';\nimport {HeaderColumn} from '../../../../header/models/header-column';\nimport {LoggerService} from '../../../../logger/services/logger.service';\nimport {TabbedVirtualScrollComponent} from '../../../../panel/abstract/tabbed-virtual-scroll.component';\nimport {NAE_TAB_DATA} from '../../../../tabs/tab-data-injection-token/tab-data-injection-token';\nimport {InjectedTabData} from '../../../../tabs/interfaces';\nimport {ActivatedRoute} from '@angular/router';\nimport {filter, takeUntil} from 'rxjs/operators';\n\nexport abstract class AbstractCaseListComponent extends TabbedVirtualScrollComponent implements OnDestroy {\n\n    @Input() selectedHeaders$: Observable<Array<HeaderColumn>>;\n    @Input() responsiveBody = true;\n    @Output() caseClick: EventEmitter<Case>;\n    @Input() showCasePanelIcon = true;\n    @Input() showDeleteMenu = false;\n    @Input() textEllipsis = false;\n    @Input() width: string;\n    @Input() redirectEnabled = true;\n\n    @ViewChild(CdkVirtualScrollViewport) public viewport: CdkVirtualScrollViewport;\n    public cases$: Observable<Array<Case>>;\n    public loading$: Observable<boolean>;\n    private redirectCaseId: string;\n    private unsubscribe$: Subject<void>;\n\n    protected constructor(protected _caseViewService: CaseViewService,\n                          protected _log: LoggerService,\n                          @Optional() @Inject(NAE_TAB_DATA) injectedTabData: InjectedTabData,\n                          protected route?: ActivatedRoute) {\n        super(injectedTabData);\n        this.cases$ = this._caseViewService.cases$;\n        this.unsubscribe$ = new Subject<void>();\n        this.loading$ = this._caseViewService.loading$;\n        this.caseClick = new EventEmitter<Case>();\n        this.onRedirect();\n    }\n\n    ngOnDestroy(): void {\n        super.ngOnDestroy();\n        this.caseClick.complete();\n        this.unsubscribe$.complete();\n    }\n\n    public trackBy(i): any {\n        return i;\n    }\n\n    public get loadedDataSize(): number {\n        return this.viewport && this.viewport.getDataLength() ? this.viewport.getDataLength() : 0;\n    }\n\n    public loadNextPage(): void {\n        if (!this.viewport) {\n            return;\n        }\n        this._caseViewService.nextPage(this.viewport.getRenderedRange(), this.viewport.getDataLength());\n    }\n\n    public onCaseClick(case_: Case) {\n        this.caseClick.emit(case_);\n    }\n\n    public onRedirect() {\n        if (!this.redirectEnabled) {\n            return;\n        }\n\n        this.route.queryParams.pipe(filter(pm => !!pm['caseId'])).subscribe(paramMap => {\n               this.redirectCaseId = paramMap['caseId'];\n               this.cases$.pipe(takeUntil(this.unsubscribe$)).subscribe(cases => {\n                   if (cases !== undefined && cases.length > 0) {\n                       const _case = cases.find(c => c.stringId === this.redirectCaseId);\n                       if (_case !== undefined) {\n                           this.caseClick.emit(_case);\n                           this.unsubscribe$.next();\n                       }\n                   }\n               });\n        });\n    }\n\n}\n"]}

package/esm2015/lib/view/case-view/models/case-page-load-request-result.js

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

package/esm2015/lib/view/case-view/models/case-view-params.js

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

package/esm2015/lib/view/case-view/models/new-case-configuration-injection-token.js

@@ -0,0 +1,7 @@
+import { InjectionToken } from '@angular/core';
+/**
+ * Can be used to provide case views with configuration of the {@link CaseViewService#createNewCase}[createNewCase()] method without
+ * having to extend the service and override the method.
+ */
+export const NAE_NEW_CASE_CONFIGURATION = new InjectionToken('NaeNewCaseConfiguration');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmV3LWNhc2UtY29uZmlndXJhdGlvbi1pbmplY3Rpb24tdG9rZW4uanMiLCJzb3VyY2VSb290Ijoibmc6Ly9AbmV0Z3JpZi9jb21wb25lbnRzLWNvcmUvIiwic291cmNlcyI6WyJsaWIvdmlldy9jYXNlLXZpZXcvbW9kZWxzL25ldy1jYXNlLWNvbmZpZ3VyYXRpb24taW5qZWN0aW9uLXRva2VuLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBQyxjQUFjLEVBQUMsTUFBTSxlQUFlLENBQUM7QUFHN0M7OztHQUdHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sMEJBQTBCLEdBQUcsSUFBSSxjQUFjLENBQXVCLHlCQUF5QixDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge0luamVjdGlvblRva2VufSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7TmV3Q2FzZUNvbmZpZ3VyYXRpb259IGZyb20gJy4vbmV3LWNhc2UtY29uZmlndXJhdGlvbic7XG5cbi8qKlxuICogQ2FuIGJlIHVzZWQgdG8gcHJvdmlkZSBjYXNlIHZpZXdzIHdpdGggY29uZmlndXJhdGlvbiBvZiB0aGUge0BsaW5rIENhc2VWaWV3U2VydmljZSNjcmVhdGVOZXdDYXNlfVtjcmVhdGVOZXdDYXNlKCldIG1ldGhvZCB3aXRob3V0XG4gKiBoYXZpbmcgdG8gZXh0ZW5kIHRoZSBzZXJ2aWNlIGFuZCBvdmVycmlkZSB0aGUgbWV0aG9kLlxuICovXG5leHBvcnQgY29uc3QgTkFFX05FV19DQVNFX0NPTkZJR1VSQVRJT04gPSBuZXcgSW5qZWN0aW9uVG9rZW48TmV3Q2FzZUNvbmZpZ3VyYXRpb24+KCdOYWVOZXdDYXNlQ29uZmlndXJhdGlvbicpO1xuIl19

package/esm2015/lib/view/case-view/models/new-case-configuration.js

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

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

@@ -0,0 +1,273 @@
+import { Inject, Injectable, Optional } from '@angular/core';
+import { SideMenuService } from '../../../side-menu/services/side-menu.service';
+import { CaseResourceService } from '../../../resources/engine-endpoint/case-resource.service';
+import { BehaviorSubject, of, Subject } from 'rxjs';
+import { HttpParams } from '@angular/common/http';
+import { LoggerService } from '../../../logger/services/logger.service';
+import { SnackBarService } from '../../../snack-bar/services/snack-bar.service';
+import { SearchService } from '../../../search/search-service/search.service';
+import { SideMenuSize } from '../../../side-menu/models/side-menu-size';
+import { TranslateService } from '@ngx-translate/core';
+import { catchError, concatMap, filter, map, mergeMap, scan, switchMap, tap } from 'rxjs/operators';
+import { CaseMetaField } from '../../../header/case-header/case-menta-enum';
+import { NAE_NEW_CASE_COMPONENT } from '../../../side-menu/content-components/injection-tokens';
+import { PageLoadRequestContext } from '../../abstract/page-load-request-context';
+import { LoadingWithFilterEmitter } from '../../../utility/loading-with-filter-emitter';
+import { UserService } from '../../../user/services/user.service';
+import { arrayToObservable } from '../../../utility/array-to-observable';
+import { PermissionType } from '../../../process/permissions';
+import { NAE_NEW_CASE_CONFIGURATION } from '../models/new-case-configuration-injection-token';
+import { ProcessService } from '../../../process/process.service';
+import { SearchIndexResolverService } from '../../../search/search-keyword-resolver-service/search-index-resolver.service';
+import { AllowedNetsService } from '../../../allowed-nets/services/allowed-nets.service';
+import { SortableView } from '../../abstract/sortable-view';
+import { PermissionService } from '../../../authorization/permission/permission.service';
+export class CaseViewService extends SortableView {
+    constructor(_allowedNetsService, _sideMenuService, _caseResourceService, _log, _snackBarService, _searchService, _translate, _user, _processService, resolver, _newCaseComponent, newCaseConfig, _permissionService) {
+        super(resolver);
+        this._allowedNetsService = _allowedNetsService;
+        this._sideMenuService = _sideMenuService;
+        this._caseResourceService = _caseResourceService;
+        this._log = _log;
+        this._snackBarService = _snackBarService;
+        this._searchService = _searchService;
+        this._translate = _translate;
+        this._user = _user;
+        this._processService = _processService;
+        this._newCaseComponent = _newCaseComponent;
+        this._permissionService = _permissionService;
+        this.DEFAULT_NEW_CASE_CONFIGURATION = {
+            useCachedProcesses: true
+        };
+        this._newCaseConfiguration = Object.assign({}, this.DEFAULT_NEW_CASE_CONFIGURATION);
+        if (newCaseConfig !== null) {
+            Object.assign(this._newCaseConfiguration, newCaseConfig);
+        }
+        this._loading$ = new LoadingWithFilterEmitter();
+        this._searchService.activeFilter$.subscribe(() => {
+            this.reload();
+        });
+        this._endOfData = false;
+        this._pagination = {
+            size: 25,
+            totalElements: undefined,
+            totalPages: undefined,
+            number: -1
+        };
+        this._nextPage$ = new BehaviorSubject(new PageLoadRequestContext(this.activeFilter, Object.assign({}, this._pagination, { number: 0 })));
+        const casesMap = this._nextPage$.pipe(mergeMap(p => this.loadPage(p)), map(pageLoadResult => {
+            if (pageLoadResult.requestContext && pageLoadResult.requestContext.clearLoaded) {
+                // we set an empty value to the virtual scroll and then replace it by the real value forcing it to redraw its content
+                const results = [{ cases: {}, requestContext: null }, pageLoadResult];
+                return arrayToObservable(results);
+            }
+            else {
+                return of(pageLoadResult);
+            }
+        }), concatMap(o => o), scan((acc, pageLoadResult) => {
+            if (pageLoadResult.requestContext === null) {
+                return pageLoadResult.cases;
+            }
+            else {
+                this._loading$.off(pageLoadResult.requestContext.filter);
+            }
+            Object.assign(this._pagination, pageLoadResult.requestContext.pagination);
+            return Object.assign(Object.assign({}, acc), pageLoadResult.cases);
+        }, {}));
+        this._cases$ = casesMap.pipe(map(v => Object.values(v)));
+    }
+    ngOnDestroy() {
+        super.ngOnDestroy();
+        this._loading$.complete();
+        this._nextPage$.complete();
+    }
+    get loading() {
+        return this._loading$.isActive;
+    }
+    get loading$() {
+        return this._loading$.asObservable();
+    }
+    get cases$() {
+        return this._cases$;
+    }
+    get activeFilter() {
+        return this._searchService.activeFilter;
+    }
+    loadPage(requestContext) {
+        if (requestContext === null || requestContext.pageNumber < 0) {
+            return of({ cases: {}, requestContext });
+        }
+        let params = new HttpParams();
+        params = this.addSortParams(params);
+        params = this.addPageParams(params, requestContext.pagination);
+        this._loading$.on(requestContext.filter);
+        return this._caseResourceService.searchCases(requestContext.filter, params).pipe(catchError(err => {
+            this._log.error('Loading cases has failed!', err);
+            this._loading$.off(requestContext.filter);
+            return of({ content: [], pagination: Object.assign({}, this._pagination) });
+        }), filter(() => {
+            const r = requestContext.filter === this._searchService.activeFilter;
+            if (!r) {
+                this._loading$.off(requestContext.filter);
+                this._log.debug('Received cases page is no longer relevant since the active filter has changed before it could arrive.'
+                    + ' Discarding...');
+            }
+            return r;
+        }), tap(c => {
+            Object.assign(requestContext.pagination, c.pagination);
+        }), tap(c => {
+            this._endOfData = !Array.isArray(c.content)
+                || c.content.length === 0
+                || c.pagination.number === c.pagination.totalPages;
+        }), map(cases => Array.isArray(cases.content) ? cases : Object.assign(Object.assign({}, cases), { content: [] })), map(cases => {
+            return cases.content.reduce((acc, cur) => {
+                return Object.assign(Object.assign({}, acc), { [cur.stringId]: cur });
+            }, {});
+        }), map(cases => ({ cases, requestContext })));
+    }
+    nextPage(renderedRange, totalLoaded, requestContext) {
+        if (requestContext === undefined) {
+            requestContext = new PageLoadRequestContext(this.activeFilter, this._pagination);
+            requestContext.pagination.number += 1;
+        }
+        if (this.isLoadingRelevantFilter(requestContext) || this._endOfData) {
+            return;
+        }
+        if (renderedRange.end === totalLoaded) {
+            this._nextPage$.next(requestContext);
+        }
+    }
+    isLoadingRelevantFilter(requestContext) {
+        return requestContext === undefined || this._loading$.isActiveWithFilter(requestContext.filter);
+    }
+    createNewCase(newCaseCreationConfiguration = {
+        enableCaseTitle: true,
+        isCaseTitleRequired: true
+    }) {
+        const myCase = new Subject();
+        this._sideMenuService.open(this._newCaseComponent, SideMenuSize.MEDIUM, {
+            allowedNets$: this.getNewCaseAllowedNets(),
+            newCaseCreationConfiguration
+        }).onClose.subscribe($event => {
+            this._log.debug($event.message, $event.data);
+            if ($event.data) {
+                this.reload();
+                myCase.next($event.data);
+            }
+            myCase.complete();
+        });
+        return myCase.asObservable();
+    }
+    createDefaultNewCase() {
+        const myCase = new Subject();
+        this.getNewCaseAllowedNets().subscribe((nets) => {
+            this._caseResourceService.createCase({
+                title: null,
+                color: 'panel-primary-icon',
+                netId: nets[0].stringId
+            }).subscribe((response) => {
+                this._snackBarService.openSuccessSnackBar(this._translate.instant('side-menu.new-case.createCase')
+                    + ' ' + this._translate.instant('side-menu.new-case.defaultCaseName'));
+                this.reload();
+                myCase.next(response.outcome.aCase);
+                myCase.complete();
+            }, error => this._snackBarService.openErrorSnackBar(error.message ? error.message : error));
+        });
+        return myCase;
+    }
+    getNewCaseAllowedNets() {
+        if (this._newCaseConfiguration.useCachedProcesses) {
+            return this._allowedNetsService.allowedNets$.pipe(map(net => net.filter(n => this._permissionService.hasNetPermission(PermissionType.CREATE, n))));
+        }
+        else {
+            return this._allowedNetsService.allowedNets$.pipe(switchMap(allowedNets => {
+                return this._processService.getNetReferences(allowedNets.map(net => net.identifier)).pipe(map(net => net.filter(n => this._permissionService.hasNetPermission(PermissionType.CREATE, n))));
+            }));
+        }
+    }
+    /**
+     * Returns number of allowed nets of case view
+     * @returns length of allowedNets array if it is defined, 0 if it is undefined
+     */
+    getAllowedNetsCount() {
+        return this._allowedNetsService.allowedNets === undefined ? 0 : this._allowedNetsService.allowedNets.length;
+    }
+    addPageParams(params, pagination) {
+        params = params.set('size', pagination.size + '');
+        params = params.set('page', pagination.number + '');
+        return params;
+    }
+    getDefaultSortParam() {
+        return 'stringId,desc';
+    }
+    getMetaFieldSortId() {
+        switch (this._lastHeaderSearchState.fieldIdentifier) {
+            case CaseMetaField.TITLE:
+                return 'title.keyword';
+            case CaseMetaField.VISUAL_ID:
+                return 'visualId.keyword';
+            case CaseMetaField.CREATION_DATE:
+                return 'creationDateSortable';
+            default:
+                return this._lastHeaderSearchState.fieldIdentifier;
+        }
+    }
+    reload() {
+        if (!this._cases$ || !this._pagination) {
+            return;
+        }
+        this._endOfData = false;
+        const requestContext = new PageLoadRequestContext(this.activeFilter, this._pagination, true);
+        requestContext.pagination.number = 0;
+        const range = {
+            start: -1,
+            end: 0
+        };
+        this.nextPage(range, 0, requestContext);
+    }
+    hasAuthority(authority) {
+        return this._user.hasAuthority(authority);
+    }
+    /**
+     * Determines whether the current user has the [VIEW]{@link PermissionType#VIEW} permission on the current case
+     * @param aCase the tested case
+     * @returns `true` if the current user has the `VIEW` permission on the tested case, `false` otherwise.
+     */
+    viewEnabled(aCase) {
+        return this._permissionService.hasCasePermission(aCase, PermissionType.VIEW);
+    }
+}
+CaseViewService.ctorParameters = () => [
+    { type: AllowedNetsService },
+    { type: SideMenuService },
+    { type: CaseResourceService },
+    { type: LoggerService },
+    { type: SnackBarService },
+    { type: SearchService },
+    { type: TranslateService },
+    { type: UserService },
+    { type: ProcessService },
+    { type: SearchIndexResolverService },
+    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [NAE_NEW_CASE_COMPONENT,] }] },
+    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [NAE_NEW_CASE_CONFIGURATION,] }] },
+    { type: PermissionService }
+];
+CaseViewService.decorators = [
+    { type: Injectable }
+];
+CaseViewService.ctorParameters = () => [
+    { type: AllowedNetsService },
+    { type: SideMenuService },
+    { type: CaseResourceService },
+    { type: LoggerService },
+    { type: SnackBarService },
+    { type: SearchService },
+    { type: TranslateService },
+    { type: UserService },
+    { type: ProcessService },
+    { type: SearchIndexResolverService },
+    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [NAE_NEW_CASE_COMPONENT,] }] },
+    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [NAE_NEW_CASE_CONFIGURATION,] }] },
+    { type: PermissionService }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"case-view-service.js","sourceRoot":"ng://@netgrif/components-core/","sources":["lib/view/case-view/service/case-view-service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Inject, Injectable, OnDestroy, Optional} from '@angular/core';\nimport {SideMenuService} from '../../../side-menu/services/side-menu.service';\nimport {CaseResourceService} from '../../../resources/engine-endpoint/case-resource.service';\nimport {BehaviorSubject, Observable, of, Subject} from 'rxjs';\nimport {HttpParams} from '@angular/common/http';\nimport {Case} from '../../../resources/interface/case';\nimport {LoggerService} from '../../../logger/services/logger.service';\nimport {SnackBarService} from '../../../snack-bar/services/snack-bar.service';\nimport {SearchService} from '../../../search/search-service/search.service';\nimport {SideMenuSize} from '../../../side-menu/models/side-menu-size';\nimport {TranslateService} from '@ngx-translate/core';\nimport {catchError, concatMap, filter, map, mergeMap, scan, switchMap, tap} from 'rxjs/operators';\nimport {Pagination} from '../../../resources/interface/pagination';\nimport {CaseMetaField} from '../../../header/case-header/case-menta-enum';\nimport {NAE_NEW_CASE_COMPONENT} from '../../../side-menu/content-components/injection-tokens';\nimport {PageLoadRequestContext} from '../../abstract/page-load-request-context';\nimport {Filter} from '../../../filter/models/filter';\nimport {ListRange} from '@angular/cdk/collections';\nimport {LoadingWithFilterEmitter} from '../../../utility/loading-with-filter-emitter';\nimport {CasePageLoadRequestResult} from '../models/case-page-load-request-result';\nimport {UserService} from '../../../user/services/user.service';\nimport {arrayToObservable} from '../../../utility/array-to-observable';\nimport {PermissionType} from '../../../process/permissions';\nimport {NAE_NEW_CASE_CONFIGURATION} from '../models/new-case-configuration-injection-token';\nimport {NewCaseConfiguration} from '../models/new-case-configuration';\nimport {ProcessService} from '../../../process/process.service';\nimport {PetriNetReferenceWithPermissions} from '../../../process/petri-net-reference-with-permissions';\nimport {SearchIndexResolverService} from '../../../search/search-keyword-resolver-service/search-index-resolver.service';\nimport {AllowedNetsService} from '../../../allowed-nets/services/allowed-nets.service';\nimport {SortableView} from '../../abstract/sortable-view';\nimport {NewCaseCreationConfigurationData} from '../../../side-menu/content-components/new-case/model/new-case-injection-data';\nimport {PermissionService} from '../../../authorization/permission/permission.service';\nimport {EventOutcomeMessageResource} from '../../../resources/interface/message-resource';\nimport {CreateCaseEventOutcome} from '../../../event/model/event-outcomes/case-outcomes/create-case-event-outcome';\n\n@Injectable()\nexport class CaseViewService extends SortableView implements OnDestroy {\n\n    readonly DEFAULT_NEW_CASE_CONFIGURATION: NewCaseConfiguration = {\n        useCachedProcesses: true\n    };\n\n    protected _loading$: LoadingWithFilterEmitter;\n    protected _cases$: Observable<Array<Case>>;\n    protected _nextPage$: BehaviorSubject<PageLoadRequestContext>;\n    protected _endOfData: boolean;\n    protected _pagination: Pagination;\n    protected _newCaseConfiguration: NewCaseConfiguration;\n\n    constructor(protected _allowedNetsService: AllowedNetsService,\n                protected _sideMenuService: SideMenuService,\n                protected _caseResourceService: CaseResourceService,\n                protected _log: LoggerService,\n                protected _snackBarService: SnackBarService,\n                protected _searchService: SearchService,\n                protected _translate: TranslateService,\n                protected _user: UserService,\n                protected _processService: ProcessService,\n                resolver: SearchIndexResolverService,\n                @Optional() @Inject(NAE_NEW_CASE_COMPONENT) protected _newCaseComponent: any,\n                @Optional() @Inject(NAE_NEW_CASE_CONFIGURATION) newCaseConfig: NewCaseConfiguration,\n                protected _permissionService: PermissionService) {\n        super(resolver);\n        this._newCaseConfiguration = {...this.DEFAULT_NEW_CASE_CONFIGURATION};\n        if (newCaseConfig !== null) {\n            Object.assign(this._newCaseConfiguration, newCaseConfig);\n        }\n        this._loading$ = new LoadingWithFilterEmitter();\n        this._searchService.activeFilter$.subscribe(() => {\n            this.reload();\n        });\n        this._endOfData = false;\n        this._pagination = {\n            size: 25,\n            totalElements: undefined,\n            totalPages: undefined,\n            number: -1\n        };\n        this._nextPage$ = new BehaviorSubject<PageLoadRequestContext>(\n            new PageLoadRequestContext(this.activeFilter, Object.assign({}, this._pagination, {number: 0}))\n        );\n\n        const casesMap = this._nextPage$.pipe(\n            mergeMap(p => this.loadPage(p)),\n            map(pageLoadResult => {\n                if (pageLoadResult.requestContext && pageLoadResult.requestContext.clearLoaded) {\n                    // we set an empty value to the virtual scroll and then replace it by the real value forcing it to redraw its content\n                    const results = [{cases: {}, requestContext: null}, pageLoadResult];\n                    return arrayToObservable(results);\n                } else {\n                    return of(pageLoadResult);\n                }\n            }),\n            concatMap(o => o),\n            scan((acc, pageLoadResult) => {\n                if (pageLoadResult.requestContext === null) {\n                    return pageLoadResult.cases;\n                } else {\n                    this._loading$.off(pageLoadResult.requestContext.filter);\n                }\n                Object.assign(this._pagination, pageLoadResult.requestContext.pagination);\n                return {...acc, ...pageLoadResult.cases};\n            }, {})\n        );\n        this._cases$ = casesMap.pipe(\n            map(v => Object.values(v))\n        );\n    }\n\n    ngOnDestroy(): void {\n        super.ngOnDestroy();\n        this._loading$.complete();\n        this._nextPage$.complete();\n    }\n\n    public get loading(): boolean {\n        return this._loading$.isActive;\n    }\n\n    public get loading$(): Observable<boolean> {\n        return this._loading$.asObservable();\n    }\n\n    public get cases$(): Observable<Array<Case>> {\n        return this._cases$;\n    }\n\n    protected get activeFilter(): Filter {\n        return this._searchService.activeFilter;\n    }\n\n    public loadPage(requestContext: PageLoadRequestContext): Observable<CasePageLoadRequestResult> {\n        if (requestContext === null || requestContext.pageNumber < 0) {\n            return of({cases: {}, requestContext});\n        }\n        let params: HttpParams = new HttpParams();\n        params = this.addSortParams(params);\n        params = this.addPageParams(params, requestContext.pagination);\n        this._loading$.on(requestContext.filter);\n\n        return this._caseResourceService.searchCases(requestContext.filter, params).pipe(\n            catchError(err => {\n                this._log.error('Loading cases has failed!', err);\n                this._loading$.off(requestContext.filter);\n                return of({content: [], pagination: {...this._pagination}});\n            }),\n            filter(() => {\n                const r = requestContext.filter === this._searchService.activeFilter;\n                if (!r) {\n                    this._loading$.off(requestContext.filter);\n                    this._log.debug('Received cases page is no longer relevant since the active filter has changed before it could arrive.'\n                        + ' Discarding...');\n                }\n                return r;\n            }),\n            tap(c => {\n                Object.assign(requestContext.pagination, c.pagination);\n            }),\n            tap(c => {\n                this._endOfData = !Array.isArray(c.content)\n                    || c.content.length === 0\n                    || c.pagination.number === c.pagination.totalPages;\n            }),\n            map(cases => Array.isArray(cases.content) ? cases : {...cases, content: []}),\n            map(cases => {\n                return cases.content.reduce((acc, cur) => {\n                    return {...acc, [cur.stringId]: cur};\n                }, {});\n            }),\n            map(cases => ({cases, requestContext}))\n        );\n    }\n\n    public nextPage(renderedRange: ListRange, totalLoaded: number, requestContext?: PageLoadRequestContext) {\n        if (requestContext === undefined) {\n            requestContext = new PageLoadRequestContext(this.activeFilter, this._pagination);\n            requestContext.pagination.number += 1;\n        }\n\n        if (this.isLoadingRelevantFilter(requestContext) || this._endOfData) {\n            return;\n        }\n\n        if (renderedRange.end === totalLoaded) {\n            this._nextPage$.next(requestContext);\n        }\n    }\n\n    private isLoadingRelevantFilter(requestContext?: PageLoadRequestContext): boolean {\n        return requestContext === undefined || this._loading$.isActiveWithFilter(requestContext.filter);\n    }\n\n    public createNewCase(newCaseCreationConfiguration: NewCaseCreationConfigurationData = {\n        enableCaseTitle: true,\n        isCaseTitleRequired: true\n    }): Observable<Case> {\n        const myCase = new Subject<Case>();\n        this._sideMenuService.open(this._newCaseComponent, SideMenuSize.MEDIUM, {\n            allowedNets$: this.getNewCaseAllowedNets(),\n            newCaseCreationConfiguration\n        }).onClose.subscribe($event => {\n            this._log.debug($event.message, $event.data);\n            if ($event.data) {\n                this.reload();\n                myCase.next($event.data);\n            }\n            myCase.complete();\n        });\n        return myCase.asObservable();\n    }\n\n    public createDefaultNewCase(): Observable<Case> {\n        const myCase = new Subject<Case>();\n        this.getNewCaseAllowedNets().subscribe((nets: Array<PetriNetReferenceWithPermissions>) => {\n            this._caseResourceService.createCase({\n                title: null,\n                color: 'panel-primary-icon',\n                netId: nets[0].stringId\n            }).subscribe((response: EventOutcomeMessageResource) => {\n                this._snackBarService.openSuccessSnackBar(this._translate.instant('side-menu.new-case.createCase')\n                    + ' ' + this._translate.instant('side-menu.new-case.defaultCaseName'));\n                this.reload();\n                myCase.next((response.outcome as CreateCaseEventOutcome).aCase);\n                myCase.complete();\n            }, error => this._snackBarService.openErrorSnackBar(error.message ? error.message : error));\n        });\n        return myCase;\n    }\n\n    protected getNewCaseAllowedNets(): Observable<Array<PetriNetReferenceWithPermissions>> {\n        if (this._newCaseConfiguration.useCachedProcesses) {\n            return this._allowedNetsService.allowedNets$.pipe(\n                map(net => net.filter(n => this._permissionService.hasNetPermission(PermissionType.CREATE, n)))\n            );\n        } else {\n            return this._allowedNetsService.allowedNets$.pipe(\n                switchMap(allowedNets => {\n                    return this._processService.getNetReferences(allowedNets.map(net => net.identifier)).pipe(\n                        map(net => net.filter(n => this._permissionService.hasNetPermission(PermissionType.CREATE, n)))\n                    );\n                })\n            );\n        }\n    }\n\n    /**\n     * Returns number of allowed nets of case view\n     * @returns length of allowedNets array if it is defined, 0 if it is undefined\n     */\n    public getAllowedNetsCount(): number {\n        return this._allowedNetsService.allowedNets === undefined ? 0 : this._allowedNetsService.allowedNets.length;\n    }\n\n    protected addPageParams(params: HttpParams, pagination: Pagination): HttpParams {\n        params = params.set('size', pagination.size + '');\n        params = params.set('page', pagination.number + '');\n        return params;\n    }\n\n    protected getDefaultSortParam(): string {\n        return 'stringId,desc';\n    }\n\n    protected getMetaFieldSortId(): string {\n        switch (this._lastHeaderSearchState.fieldIdentifier) {\n            case CaseMetaField.TITLE:\n                return 'title.keyword';\n            case CaseMetaField.VISUAL_ID:\n                return 'visualId.keyword';\n            case CaseMetaField.CREATION_DATE:\n                return 'creationDateSortable';\n            default:\n                return this._lastHeaderSearchState.fieldIdentifier;\n        }\n    }\n\n    public reload(): void {\n        if (!this._cases$ || !this._pagination) {\n            return;\n        }\n\n        this._endOfData = false;\n        const requestContext = new PageLoadRequestContext(this.activeFilter, this._pagination, true);\n        requestContext.pagination.number = 0;\n        const range = {\n            start: -1,\n            end: 0\n        };\n\n        this.nextPage(range, 0, requestContext);\n    }\n\n    public hasAuthority(authority: Array<string> | string): boolean {\n        return this._user.hasAuthority(authority);\n    }\n\n    /**\n     * Determines whether the current user has the [VIEW]{@link PermissionType#VIEW} permission on the current case\n     * @param aCase the tested case\n     * @returns `true` if the current user has the `VIEW` permission on the tested case, `false` otherwise.\n     */\n    public viewEnabled(aCase: Case): boolean {\n        return this._permissionService.hasCasePermission(aCase, PermissionType.VIEW);\n    }\n}\n"]}

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

@@ -0,0 +1,66 @@
+import { AbstractCaseView } from './abstract-case-view';
+import { Inject } from '@angular/core';
+import { NAE_TAB_DATA } from '../../tabs/tab-data-injection-token/tab-data-injection-token';
+import { LoggerService } from '../../logger/services/logger.service';
+import { CaseViewService } from './service/case-view-service';
+import { SimpleFilter } from '../../filter/models/simple-filter';
+import { FilterType } from '../../filter/models/filter-type';
+import { OverflowService } from '../../header/services/overflow.service';
+export class TabbedCaseView extends AbstractCaseView {
+    constructor(caseViewService, _loggerService, _injectedTabData, _overflowService, _autoswitchToTaskTab = true, _openExistingTab = true, _newCaseCreationConfig = {
+        enableCaseTitle: true,
+        isCaseTitleRequired: true
+    }) {
+        super(caseViewService, _overflowService, undefined, _newCaseCreationConfig);
+        this._loggerService = _loggerService;
+        this._injectedTabData = _injectedTabData;
+        this._overflowService = _overflowService;
+        this._autoswitchToTaskTab = _autoswitchToTaskTab;
+        this._openExistingTab = _openExistingTab;
+        this._newCaseCreationConfig = _newCaseCreationConfig;
+        this._correctlyInjected = !!this._injectedTabData.tabViewComponent && this._injectedTabData.tabViewOrder !== undefined;
+        if (!this._correctlyInjected) {
+            this._loggerService.warn('TabbedCaseView must inject a filled object of type InjectedTabbedCaseViewData to work properly!');
+        }
+    }
+    handleCaseClick(clickedCase) {
+        if (this._correctlyInjected) {
+            this.openTab(clickedCase);
+        }
+    }
+    createNewCase() {
+        const myCase = super.createNewCase();
+        myCase.subscribe(kaze => {
+            if (this._caseViewService.viewEnabled(kaze)) {
+                this.openTab(kaze);
+            }
+        });
+        return myCase;
+    }
+    openTab(openCase) {
+        this._injectedTabData.tabViewRef.openTab({
+            label: {
+                text: openCase.title,
+                icon: openCase.icon ? openCase.icon : 'check_box'
+            },
+            canBeClosed: true,
+            tabContentComponent: this._injectedTabData.tabViewComponent,
+            injectedObject: {
+                baseFilter: new SimpleFilter('', FilterType.TASK, { case: { id: `${openCase.stringId}` } }),
+                allowedNets: [openCase.processIdentifier]
+            },
+            order: this._injectedTabData.tabViewOrder,
+            parentUniqueId: this._injectedTabData.tabUniqueId
+        }, this._autoswitchToTaskTab, this._openExistingTab);
+    }
+}
+TabbedCaseView.ctorParameters = () => [
+    { type: CaseViewService },
+    { type: LoggerService },
+    { type: undefined, decorators: [{ type: Inject, args: [NAE_TAB_DATA,] }] },
+    { type: OverflowService },
+    null,
+    null,
+    { type: undefined }
+];
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,42 @@
+/* INTERFACES */
+export * from './case-view/models/case-view-params';
+export * from './case-view/models/case-page-load-request-result';
+export * from './case-view/models/new-case-configuration';
+export * from './task-view/models/task-view-params';
+export * from './task-view/models/injected-tabbed-task-view-data';
+export * from './task-view/models/task-page-load-request-result';
+export * from './task-view/models/task-view-configuration';
+export * from './tree-case-view/tree-component/model/case-tree-node';
+export * from './tree-case-view/tree-component/model/case-tree-path';
+export * from './tree-case-view/tree-component/model/expansion-tree';
+/* ENUMS */
+export * from './tree-case-view/model/tree-petriflow-identifiers';
+export * from './task-view/models/task-endpoint';
+/* CLASSES */
+export * from './case-view/abstract-case-view';
+export * from './case-view/tabbed-case-view';
+export * from './task-view/abstract-task-view';
+export * from './task-view/tabbed-task-view';
+export * from './abstract/view-with-headers';
+export * from './abstract/sortable-view';
+export * from './abstract/page-load-request-context';
+/* INJECTION TOKENS */
+export * from './case-view/models/new-case-configuration-injection-token';
+export * from './task-view/models/injection-token-task-endpoint';
+export * from './task-view/models/task-view-configuration-injection-token';
+export * from './workflow-view/models/injection-token-workflow-service';
+/* SERVICES */
+export * from './case-view/service/case-view-service';
+export * from './task-view/service/task-view.service';
+export * from './workflow-view/workflow-view.service';
+export * from './tree-case-view/tree-case-view.service';
+export * from './tree-case-view/tree-component/case-tree.service';
+export * from './tree-case-view/tree-task-content/tree-task-content.service';
+/* COMPONENTS */
+export * from './workflow-view/abstract-workflow-view.component';
+export * from './case-view/components/case-list/abstract-case-list.component';
+export * from './tree-case-view/tree-component/abstract-tree.component';
+export * from './tree-case-view/tree-component/add-child-node/abstract-add-child-node.component';
+export * from './tree-case-view/tree-component/remove-node/abstract-remove-node.component';
+export * from './tree-case-view/tree-task-content/abstract-tree-task-content.component';
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,13 @@
+import { ViewWithHeaders } from '../abstract/view-with-headers';
+export class AbstractTaskView extends ViewWithHeaders {
+    constructor(taskViewService) {
+        super(taskViewService);
+        this.taskViewService = taskViewService;
+        this.tasks$ = this.taskViewService.tasks$;
+        this.loading$ = this.taskViewService.loading$;
+    }
+    ngOnDestroy() {
+        super.ngOnDestroy();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWJzdHJhY3QtdGFzay12aWV3LmpzIiwic291cmNlUm9vdCI6Im5nOi8vQG5ldGdyaWYvY29tcG9uZW50cy1jb3JlLyIsInNvdXJjZXMiOlsibGliL3ZpZXcvdGFzay12aWV3L2Fic3RyYWN0LXRhc2stdmlldy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFJQSxPQUFPLEVBQUMsZUFBZSxFQUFDLE1BQU0sK0JBQStCLENBQUM7QUFHOUQsTUFBTSxPQUFnQixnQkFBaUIsU0FBUSxlQUFlO0lBSzFELFlBQWdDLGVBQWdDO1FBQzVELEtBQUssQ0FBQyxlQUFlLENBQUMsQ0FBQztRQURLLG9CQUFlLEdBQWYsZUFBZSxDQUFpQjtRQUU1RCxJQUFJLENBQUMsTUFBTSxHQUFHLElBQUksQ0FBQyxlQUFlLENBQUMsTUFBTSxDQUFDO1FBQzFDLElBQUksQ0FBQyxRQUFRLEdBQUcsSUFBSSxDQUFDLGVBQWUsQ0FBQyxRQUFRLENBQUM7SUFDbEQsQ0FBQztJQUVELFdBQVc7UUFDUCxLQUFLLENBQUMsV0FBVyxFQUFFLENBQUM7SUFDeEIsQ0FBQztDQUNKIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtPYnNlcnZhYmxlfSBmcm9tICdyeGpzJztcbmltcG9ydCB7T25EZXN0cm95fSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7VGFza1BhbmVsRGF0YX0gZnJvbSAnLi4vLi4vcGFuZWwvdGFzay1wYW5lbC1saXN0L3Rhc2stcGFuZWwtZGF0YS90YXNrLXBhbmVsLWRhdGEnO1xuaW1wb3J0IHtUYXNrVmlld1NlcnZpY2V9IGZyb20gJy4vc2VydmljZS90YXNrLXZpZXcuc2VydmljZSc7XG5pbXBvcnQge1ZpZXdXaXRoSGVhZGVyc30gZnJvbSAnLi4vYWJzdHJhY3Qvdmlldy13aXRoLWhlYWRlcnMnO1xuXG5cbmV4cG9ydCBhYnN0cmFjdCBjbGFzcyBBYnN0cmFjdFRhc2tWaWV3IGV4dGVuZHMgVmlld1dpdGhIZWFkZXJzIGltcGxlbWVudHMgT25EZXN0cm95IHtcblxuICAgIHB1YmxpYyB0YXNrcyQ6IE9ic2VydmFibGU8QXJyYXk8VGFza1BhbmVsRGF0YT4+O1xuICAgIHB1YmxpYyBsb2FkaW5nJDogT2JzZXJ2YWJsZTxib29sZWFuPjtcblxuICAgIHByb3RlY3RlZCBjb25zdHJ1Y3Rvcihwcm90ZWN0ZWQgdGFza1ZpZXdTZXJ2aWNlOiBUYXNrVmlld1NlcnZpY2UpIHtcbiAgICAgICAgc3VwZXIodGFza1ZpZXdTZXJ2aWNlKTtcbiAgICAgICAgdGhpcy50YXNrcyQgPSB0aGlzLnRhc2tWaWV3U2VydmljZS50YXNrcyQ7XG4gICAgICAgIHRoaXMubG9hZGluZyQgPSB0aGlzLnRhc2tWaWV3U2VydmljZS5sb2FkaW5nJDtcbiAgICB9XG5cbiAgICBuZ09uRGVzdHJveSgpIHtcbiAgICAgICAgc3VwZXIubmdPbkRlc3Ryb3koKTtcbiAgICB9XG59XG4iXX0=

package/esm2015/lib/view/task-view/models/injected-tabbed-task-view-data.js

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

package/esm2015/lib/view/task-view/models/injection-token-task-endpoint.js

@@ -0,0 +1,6 @@
+import { InjectionToken } from '@angular/core';
+/**
+ * @deprecated in 5.3.0 - Use {@link NAE_TASK_VIEW_CONFIGURATION} instead
+ */
+export const NAE_PREFERRED_TASK_ENDPOINT = new InjectionToken('NaePreferredTaskEndpoint');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5qZWN0aW9uLXRva2VuLXRhc2stZW5kcG9pbnQuanMiLCJzb3VyY2VSb290Ijoibmc6Ly9AbmV0Z3JpZi9jb21wb25lbnRzLWNvcmUvIiwic291cmNlcyI6WyJsaWIvdmlldy90YXNrLXZpZXcvbW9kZWxzL2luamVjdGlvbi10b2tlbi10YXNrLWVuZHBvaW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBQyxjQUFjLEVBQUMsTUFBTSxlQUFlLENBQUM7QUFHN0M7O0dBRUc7QUFDSCxNQUFNLENBQUMsTUFBTSwyQkFBMkIsR0FBRyxJQUFJLGNBQWMsQ0FBZSwwQkFBMEIsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtJbmplY3Rpb25Ub2tlbn0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQge1Rhc2tFbmRwb2ludH0gZnJvbSAnLi90YXNrLWVuZHBvaW50JztcblxuLyoqXG4gKiBAZGVwcmVjYXRlZCBpbiA1LjMuMCAtIFVzZSB7QGxpbmsgTkFFX1RBU0tfVklFV19DT05GSUdVUkFUSU9OfSBpbnN0ZWFkXG4gKi9cbmV4cG9ydCBjb25zdCBOQUVfUFJFRkVSUkVEX1RBU0tfRU5EUE9JTlQgPSBuZXcgSW5qZWN0aW9uVG9rZW48VGFza0VuZHBvaW50PignTmFlUHJlZmVycmVkVGFza0VuZHBvaW50Jyk7XG4iXX0=