@yuuvis/client-core 0.6.5

package/esm2022/lib/service/auth/auth.service.mjs

@@ -0,0 +1,130 @@
+import { inject, Inject, Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { map, switchMap, tap } from 'rxjs/operators';
+import { YuvUser } from '../../model/yuv-user.model';
+import { Utils } from '../../util/utils';
+import { BackendService } from '../backend/backend.service';
+import { AppCacheService } from '../cache/app-cache.service';
+import { CoreConfig } from '../config/core-config';
+import { CORE_CONFIG } from '../config/core-config.tokens';
+import { EventService } from '../event/event.service';
+import { YuvEventType } from '../event/events';
+import { SystemService } from '../system/system.service';
+import { UserService } from '../user/user.service';
+import { ObjectConfigService } from '../object-config/object-config.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../config/core-config";
+/**
+ * Service handling authentication related issues.
+ */
+export class AuthService {
+    #eventService;
+    #userService;
+    #objectConfigService;
+    #appCache;
+    #systemService;
+    #backend;
+    #INITAL_REQUEST_STORAGE_KEY;
+    #authenticated;
+    #authSource;
+    #authData;
+    constructor(coreConfig) {
+        this.coreConfig = coreConfig;
+        this.#eventService = inject(EventService);
+        this.#userService = inject(UserService);
+        this.#objectConfigService = inject(ObjectConfigService);
+        this.#appCache = inject(AppCacheService);
+        this.#systemService = inject(SystemService);
+        this.#backend = inject(BackendService);
+        this.#INITAL_REQUEST_STORAGE_KEY = 'yuv.core.auth.initialrequest';
+        this.USER_FETCH_URI = '/idm/whoami';
+        this.#authenticated = false;
+        this.#authSource = new BehaviorSubject(false);
+        this.authenticated$ = this.#authSource.asObservable();
+    }
+    isLoggedIn() {
+        return this.#authenticated;
+    }
+    /**
+     * Called while app/core is initialized (APP_INITIALIZER)
+     * @ignore
+     */
+    initUser() {
+        return this.fetchUser();
+    }
+    /**
+     * Get the current tenant or the previous one persisted locally
+     */
+    getTenant() {
+        return this.#authData?.tenant;
+    }
+    /**
+     * Fetch information about the user currently logged in
+     */
+    fetchUser() {
+        return this.#backend.get(this.USER_FETCH_URI).pipe(tap(() => {
+            this.#authenticated = true;
+            this.#authSource.next(this.#authenticated);
+        }), switchMap((userJson) => this.#initApp(userJson)));
+    }
+    /**
+     * Logs out the current user.
+     */
+    logout() {
+        this.#authenticated = false;
+        this.#authSource.next(this.#authenticated);
+        this.#eventService.trigger(YuvEventType.LOGOUT);
+    }
+    // called on core init
+    setInitialRequestUri() {
+        const ignore = ['/', '/index.html'];
+        let uri = `${location.pathname}${location.search}`.replace(Utils.getBaseHref(), '');
+        uri = !uri.startsWith('/') ? `/${uri}` : uri;
+        if (!ignore.includes(uri)) {
+            this.#appCache
+                .setItem(this.#INITAL_REQUEST_STORAGE_KEY, {
+                uri: uri,
+                timestamp: Date.now()
+            })
+                .subscribe();
+        }
+    }
+    /**
+     * Get the URL that entered the app. May be a deep link that could then be
+     * picked up again after user has been authenticated.
+     */
+    getInitialRequestUri() {
+        return this.#appCache.getItem(this.#INITAL_REQUEST_STORAGE_KEY);
+    }
+    resetInitialRequestUri() {
+        return this.#appCache.removeItem(this.#INITAL_REQUEST_STORAGE_KEY);
+    }
+    /**
+     * Initialize/setup the application for a given user. This involves fetching
+     * settings and schema information.
+     * @param userJson Data retrieved from the backend
+     */
+    #initApp(userJson) {
+        return this.#userService.fetchUserSettings().pipe(switchMap((userSettings) => {
+            const currentUser = new YuvUser(userJson, userSettings);
+            this.#userService.setCurrentUser(currentUser);
+            this.#authData = {
+                tenant: currentUser.tenant,
+                language: currentUser.getClientLocale()
+            };
+            return this.#systemService.getSystemDefinition(this.#authData).pipe(switchMap(() => this.#objectConfigService.init()), map(() => currentUser));
+        }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AuthService, deps: [{ token: CORE_CONFIG }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AuthService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AuthService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.CoreConfig, decorators: [{
+                    type: Inject,
+                    args: [CORE_CONFIG]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auth.service.js","sourceRoot":"","sources":["../../../../../../../../libs/yuuvis/client-core/src/lib/service/auth/auth.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { inject, Inject, Injectable } from '@angular/core';\nimport { BehaviorSubject, Observable } from 'rxjs';\nimport { map, switchMap, tap } from 'rxjs/operators';\nimport { UserSettings, YuvUser } from '../../model/yuv-user.model';\nimport { Utils } from '../../util/utils';\nimport { BackendService } from '../backend/backend.service';\nimport { AppCacheService } from '../cache/app-cache.service';\nimport { CoreConfig } from '../config/core-config';\nimport { CORE_CONFIG } from '../config/core-config.tokens';\nimport { EventService } from '../event/event.service';\nimport { YuvEventType } from '../event/events';\nimport { SystemService } from '../system/system.service';\nimport { UserService } from '../user/user.service';\nimport { YuvInitError } from './auth.interface';\nimport { ObjectConfigService } from '../object-config/object-config.service';\n\n/**\n * Service handling authentication related issues.\n */\n@Injectable({\n  providedIn: 'root'\n})\nexport class AuthService {\n  #eventService = inject(EventService);\n  #userService = inject(UserService);\n  #objectConfigService = inject(ObjectConfigService);\n  #appCache = inject(AppCacheService);\n  #systemService = inject(SystemService);\n  #backend = inject(BackendService);\n\n  #INITAL_REQUEST_STORAGE_KEY = 'yuv.core.auth.initialrequest';\n  readonly USER_FETCH_URI = '/idm/whoami';\n\n  #authenticated = false;\n  #authSource = new BehaviorSubject<boolean>(false);\n  authenticated$: Observable<boolean> = this.#authSource.asObservable();\n\n  #authData!: AuthData;\n  // set by core-init\n  initError?: YuvInitError;\n\n  constructor(@Inject(CORE_CONFIG) public coreConfig: CoreConfig) {}\n\n  isLoggedIn() {\n    return this.#authenticated;\n  }\n\n  /**\n   * Called while app/core is initialized (APP_INITIALIZER)\n   * @ignore\n   */\n  initUser() {\n    return this.fetchUser();\n  }\n\n  /**\n   * Get the current tenant or the previous one persisted locally\n   */\n  getTenant(): string {\n    return this.#authData?.tenant;\n  }\n\n  /**\n   * Fetch information about the user currently logged in\n   */\n  fetchUser(): Observable<YuvUser> {\n    return this.#backend.get(this.USER_FETCH_URI).pipe(\n      tap(() => {\n        this.#authenticated = true;\n        this.#authSource.next(this.#authenticated);\n      }),\n      switchMap((userJson: any) => this.#initApp(userJson))\n    );\n  }\n\n  /**\n   * Logs out the current user.\n   */\n  logout() {\n    this.#authenticated = false;\n    this.#authSource.next(this.#authenticated);\n    this.#eventService.trigger(YuvEventType.LOGOUT);\n  }\n\n  // called on core init\n  setInitialRequestUri() {\n    const ignore = ['/', '/index.html'];\n    let uri = `${location.pathname}${location.search}`.replace(Utils.getBaseHref(), '');\n    uri = !uri.startsWith('/') ? `/${uri}` : uri;\n\n    if (!ignore.includes(uri)) {\n      this.#appCache\n        .setItem(this.#INITAL_REQUEST_STORAGE_KEY, {\n          uri: uri,\n          timestamp: Date.now()\n        })\n        .subscribe();\n    }\n  }\n\n  /**\n   * Get the URL that entered the app. May be a deep link that could then be\n   * picked up again after user has been authenticated.\n   */\n  getInitialRequestUri(): Observable<{ uri: string; timestamp: number }> {\n    return this.#appCache.getItem(this.#INITAL_REQUEST_STORAGE_KEY);\n  }\n\n  resetInitialRequestUri(): Observable<any> {\n    return this.#appCache.removeItem(this.#INITAL_REQUEST_STORAGE_KEY);\n  }\n\n  /**\n   * Initialize/setup the application for a given user. This involves fetching\n   * settings and schema information.\n   * @param userJson Data retrieved from the backend\n   */\n  #initApp(userJson: any): Observable<YuvUser> {\n    return this.#userService.fetchUserSettings().pipe(\n      switchMap((userSettings: UserSettings) => {\n        const currentUser = new YuvUser(userJson, userSettings);\n        this.#userService.setCurrentUser(currentUser);\n        this.#authData = {\n          tenant: currentUser.tenant,\n          language: currentUser.getClientLocale()\n        };\n        return this.#systemService.getSystemDefinition(this.#authData).pipe(\n          switchMap(() => this.#objectConfigService.init()),\n          map(() => currentUser)\n        );\n      })\n    );\n  }\n}\n\nexport interface AuthData {\n  tenant: string;\n  language: string;\n}\n"]}

package/esm2022/lib/service/auth/oidc.service.mjs

@@ -0,0 +1,81 @@
+import { Inject, Injectable, Optional } from '@angular/core';
+import { OAuthModuleConfig, OAuthService } from 'angular-oauth2-oidc';
+import { from, Observable, of } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { CoreConfig } from '../config/core-config';
+import { CORE_CONFIG } from '../config/core-config.tokens';
+import * as i0 from "@angular/core";
+import * as i1 from "angular-oauth2-oidc";
+import * as i2 from "../config/core-config";
+export class OidcService {
+    constructor(oAuthConfig, config, oauthService) {
+        this.oAuthConfig = oAuthConfig;
+        this.config = config;
+        this.oauthService = oauthService;
+    }
+    initOpenIdConnect(oidc) {
+        oidc = this.config.oidc = oidc || this.config.oidc;
+        if (oidc?.host) {
+            oidc.host = oidc.host.endsWith('/') ? oidc.host.substring(0, -1) : oidc.host;
+        }
+        else
+            return of(undefined);
+        this.oAuthConfig.resourceServer = {
+            sendAccessToken: true,
+            allowedUrls: [oidc.host]
+        };
+        const authConfig = {
+            strictDiscoveryDocumentValidation: false,
+            issuer: oidc.issuer,
+            redirectUri: oidc.redirectUri || window.location.origin + '/',
+            postLogoutRedirectUri: oidc.postLogoutRedirectUri || window.location.origin + '/',
+            clientId: oidc.clientId,
+            responseType: 'code',
+            scope: 'openid profile email offline_access',
+            showDebugInformation: false,
+            requireHttps: false,
+            disableAtHashCheck: true,
+            sessionCheckIntervall: 60000,
+            sessionChecksEnabled: true,
+            clearHashAfterLogin: false,
+            silentRefreshTimeout: 5000 // For faster testing
+        };
+        this.oauthService.configure(authConfig);
+        this.oauthService.setupAutomaticSilentRefresh();
+        return from(this.oauthService.loadDiscoveryDocumentAndLogin()).pipe(map(() => this.config.oidc));
+    }
+    logout() {
+        this.oauthService.logOut();
+    }
+    setupCookie(viewer, path, headers) {
+        return new Observable((subscriber) => {
+            let iframe = document.querySelector('body > iframe#__oidc');
+            if (!iframe) {
+                iframe = document.createElement('iframe');
+                iframe.style.display = 'none';
+                iframe.id = '__oidc';
+                iframe.onload = () => {
+                    iframe.subscriber.next({});
+                    iframe.subscriber.complete();
+                };
+            }
+            iframe.subscriber = subscriber;
+            iframe.setAttribute('src', `${viewer}/download?setCookie=/&path=${encodeURIComponent(path)}&headers=${encodeURIComponent(JSON.stringify(headers))}`);
+            document.body.appendChild(iframe);
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: OidcService, deps: [{ token: i1.OAuthModuleConfig, optional: true }, { token: CORE_CONFIG }, { token: i1.OAuthService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: OidcService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: OidcService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.OAuthModuleConfig, decorators: [{
+                    type: Optional
+                }] }, { type: i2.CoreConfig, decorators: [{
+                    type: Inject,
+                    args: [CORE_CONFIG]
+                }] }, { type: i1.OAuthService }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/service/backend/api.enum.mjs

@@ -0,0 +1,11 @@
+// enumeration of API endpoints provided by the backend
+export var ApiBase;
+(function (ApiBase) {
+    ApiBase["core"] = "api";
+    ApiBase["apiWeb"] = "api-web/api";
+    ApiBase["predict"] = "predict-api/api";
+    // TODO: all custom services are deployed using this base
+    ApiBase["custom"] = "custom";
+    ApiBase["none"] = "";
+})(ApiBase || (ApiBase = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXBpLmVudW0uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL3l1dXZpcy9jbGllbnQtY29yZS9zcmMvbGliL3NlcnZpY2UvYmFja2VuZC9hcGkuZW51bS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSx1REFBdUQ7QUFDdkQsTUFBTSxDQUFOLElBQVksT0FPWDtBQVBELFdBQVksT0FBTztJQUNqQix1QkFBWSxDQUFBO0lBQ1osaUNBQXNCLENBQUE7SUFDdEIsc0NBQTJCLENBQUE7SUFDM0IseURBQXlEO0lBQ3pELDRCQUFpQixDQUFBO0lBQ2pCLG9CQUFTLENBQUE7QUFDWCxDQUFDLEVBUFcsT0FBTyxLQUFQLE9BQU8sUUFPbEIiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBlbnVtZXJhdGlvbiBvZiBBUEkgZW5kcG9pbnRzIHByb3ZpZGVkIGJ5IHRoZSBiYWNrZW5kXG5leHBvcnQgZW51bSBBcGlCYXNlIHtcbiAgY29yZSA9ICdhcGknLFxuICBhcGlXZWIgPSAnYXBpLXdlYi9hcGknLFxuICBwcmVkaWN0ID0gJ3ByZWRpY3QtYXBpL2FwaScsXG4gIC8vIFRPRE86IGFsbCBjdXN0b20gc2VydmljZXMgYXJlIGRlcGxveWVkIHVzaW5nIHRoaXMgYmFzZVxuICBjdXN0b20gPSAnY3VzdG9tJyxcbiAgbm9uZSA9ICcnXG59XG4iXX0=

package/esm2022/lib/service/backend/backend.interface.mjs

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

package/esm2022/lib/service/backend/backend.service.mjs

@@ -0,0 +1,206 @@
+import { HttpClient, HttpHeaders } from '@angular/common/http';
+import { inject, Injectable } from '@angular/core';
+import { forkJoin, of } from 'rxjs';
+import { catchError, finalize, shareReplay, tap } from 'rxjs/operators';
+import { ConfigService } from '../config/config.service';
+import { Logger } from '../logger/logger';
+import { ApiBase } from './api.enum';
+import * as i0 from "@angular/core";
+/**
+ * Service for providing an yuuvis Backend
+ */
+export class BackendService {
+    constructor() {
+        this.#http = inject(HttpClient);
+        this.#logger = inject(Logger);
+        this.configService = inject(ConfigService);
+        this.#cache = new Map();
+        this.#temp = new Map();
+        this.#headers = new HttpHeaders({
+            'Content-Type': 'application/json'
+        });
+    }
+    #http;
+    #logger;
+    #cache;
+    #temp;
+    #headers;
+    authUsesOpenIdConnect() {
+        return this.configService.authUsesOpenIdConnect();
+    }
+    /**
+     * OpenIdConnect authorization headers
+     */
+    getAuthHeaders() {
+        return this.configService.getAuthHeaders();
+    }
+    /**
+     * Add a new header.
+     * @param key The headers name
+     * @param value The value to be added to the headers. Setting this to null
+     * will remove the header
+     */
+    setHeader(key, value) {
+        if (value && value.length) {
+            this.#headers = this.#headers.set(key, value);
+        }
+        else {
+            this.#headers = this.#headers.delete(key);
+        }
+    }
+    /**
+     * Wrapped HTTP GET method
+     * @param uri The REST URI to be queried
+     * @param base The Base URI (backend service) to be used
+     * @param requestOptions Additional request options
+     * @returns The data retrieved from the given endpoint
+     */
+    get(uri, base, requestOptions) {
+        return this.#http.get(this.getApiBase(base) + uri, this.getHttpOptions(requestOptions));
+    }
+    /**
+     * Wrapped HTTP POST method
+     * @param uri The target REST URI
+     * @param data Data to be 'posted'
+     * @param base The Base URI (backend service) to be used
+     * @param requestOptions Additional request options
+     * @returns The return value of the target POST endpoint
+     */
+    post(uri, data, base, requestOptions) {
+        const baseUri = this.getApiBase(base);
+        const payload = data && typeof data === 'object' ? JSON.stringify(data) : data || '';
+        return this.#http.post(`${baseUri}${uri}`, payload, this.getHttpOptions(requestOptions));
+    }
+    /**
+     * Performs a multipart form data POST request.
+     * @param uri The target REST URI
+     * @param formData FormData to be 'posted'
+     * @param base The Base URI (backend service) to be used
+     * @param requestOptions Additional request options
+     * @returns The return value of the target POST endpoint
+     */
+    postMultiPart(uri, formData, base, requestOptions) {
+        return this.#http.post(`${this.getApiBase(base)}${uri}`, formData, this.getHttpOptions(requestOptions));
+    }
+    /**
+     * Wrapped HTTP PATCH method
+     * @param uri The target REST URI
+     * @param data Data to be 'patched'
+     * @param base The Base URI (backend service) to be used
+     * @param requestOptions Additional request options
+     * @returns The return value of the target PATCH endpoint
+     */
+    patch(uri, data, base, requestOptions) {
+        const baseUri = this.getApiBase(base);
+        const payload = data ? JSON.stringify(data) : '';
+        return this.#http.patch(`${baseUri}${uri}`, payload, this.getHttpOptions(requestOptions));
+    }
+    /**
+     * Wrapped HTTP PUT method
+     * @param uri The target REST URI
+     * @param data Data to be 'posted'
+     * @param base The Base URI (backend service) to be used
+     * @param requestOptions Additional request options
+     * @returns The return value of the target PUT endpoint
+     */
+    put(uri, data, base, requestOptions) {
+        return this.#http.put(this.getApiBase(base) + uri, data, this.getHttpOptions(requestOptions));
+    }
+    /**
+     * Wrapped HTTP DELETE method
+     * @param uri The target REST URI
+     * @param base The Base URI (backend service) to be used
+     * @param requestOptions Additional request options
+     * @returns The return value of the target DELETE endpoint
+     */
+    delete(uri, base, requestOptions) {
+        return this.#http.delete(this.getApiBase(base) + uri, this.getHttpOptions(requestOptions));
+    }
+    /**
+     * @ignore
+     * Cache for small requests like icons and configs
+     *
+     * @param string uri
+     * @returns Observable<any>
+     */
+    getViaCache(uri) {
+        if (this.#cache.has(uri)) {
+            return of(this.#cache.get(uri));
+        }
+        else {
+            const requestOptions = {
+                responseType: 'text',
+                headers: this.getAuthHeaders()
+            };
+            return this.getViaTempCache(uri, () => this.#http.get(uri, requestOptions).pipe(tap((text) => this.#cache.set(uri, text))));
+        }
+    }
+    /**
+     * @ignore
+     * Temporary Cache for multiple identical requests
+     *
+     * @param string id
+     * @param Function request
+     * @returns Observable<any>
+     */
+    getViaTempCache(id, request) {
+        if (this.#temp.has(id)) {
+            return this.#temp.get(id);
+        }
+        else {
+            const resp = (request ? request() : this.get(id)).pipe(finalize(() => this.#temp.delete(id)), shareReplay(1));
+            this.#temp.set(id, resp);
+            return resp;
+        }
+    }
+    download(uri, filename) {
+        if (document && document.body) {
+            const a = document.createElement('a');
+            a.setAttribute('href', uri);
+            a.style.display = 'none';
+            a.setAttribute('download', filename || 'download');
+            document.body.appendChild(a);
+            a.click();
+            document.body.removeChild(a);
+        }
+        else {
+            this.#logger.error('Environment not supported. Downloading contents relies on a DOM being available.');
+        }
+    }
+    /**
+     * Gets the base URI for an API endpoint
+     * @param api The API to get the base URI for. Leaving this blank will return
+     * base URI for the web API
+     * @param origin The flag to include location origin
+     * @returns Base URI for the given API.
+     */
+    getApiBase(api = ApiBase.apiWeb, origin = false) {
+        return this.configService.getApiBase(api, origin);
+    }
+    /**
+     * @ignore
+     */
+    getHttpOptions(requestOptions) {
+        // Object.entries(this.getAuthHeaders()).forEach(([h, v]) => this.setHeader(h, v as string));
+        this.getAuthHeaders()
+            .keys()
+            .forEach((k) => this.setHeader(k, this.getAuthHeaders().get(k)));
+        return Object.assign({ headers: this.#headers }, requestOptions);
+    }
+    /**
+     * Batch service
+     */
+    batch(requests) {
+        const httpRequests = requests.map((r) => this[(r.method || 'get').toLowerCase()]
+            .apply(this, [r.uri, r.body, r.base, r.requestOptions].filter((a) => a))
+            .pipe(catchError((err) => of({ _error: err }))));
+        return forkJoin(httpRequests);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: BackendService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: BackendService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: BackendService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"backend.service.js","sourceRoot":"","sources":["../../../../../../../../libs/yuuvis/client-core/src/lib/service/backend/backend.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAC/D,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,EAAE,QAAQ,EAAc,EAAE,EAAE,MAAM,MAAM,CAAC;AAChD,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,WAAW,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAC;AACxE,OAAO,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AACzD,OAAO,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAC1C,OAAO,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;;AAGrC;;GAEG;AAEH,MAAM,OAAO,cAAc;IAD3B;QAEE,UAAK,GAAG,MAAM,CAAC,UAAU,CAAC,CAAC;QAC3B,YAAO,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC;QACzB,kBAAa,GAAG,MAAM,CAAC,aAAa,CAAC,CAAC;QAEtC,WAAM,GAAG,IAAI,GAAG,EAAe,CAAC;QAChC,UAAK,GAAG,IAAI,GAAG,EAA2B,CAAC;QAC3C,aAAQ,GAAG,IAAI,WAAW,CAAC;YACzB,cAAc,EAAE,kBAAkB;SACnC,CAAC,CAAC;KA+LJ;IAvMC,KAAK,CAAsB;IAC3B,OAAO,CAAkB;IAGzB,MAAM,CAA0B;IAChC,KAAK,CAAsC;IAC3C,QAAQ,CAEL;IAEH,qBAAqB;QACnB,OAAO,IAAI,CAAC,aAAa,CAAC,qBAAqB,EAAE,CAAC;IACpD,CAAC;IAED;;OAEG;IACH,cAAc;QACZ,OAAO,IAAI,CAAC,aAAa,CAAC,cAAc,EAAE,CAAC;IAC7C,CAAC;IAED;;;;;OAKG;IACH,SAAS,CAAC,GAAW,EAAE,KAAa;QAClC,IAAI,KAAK,IAAI,KAAK,CAAC,MAAM,EAAE,CAAC;YAC1B,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;QAChD,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;QAC5C,CAAC;IACH,CAAC;IAED;;;;;;OAMG;IACH,GAAG,CAAC,GAAW,EAAE,IAAa,EAAE,cAA4B;QAC1D,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,GAAG,GAAG,EAAE,IAAI,CAAC,cAAc,CAAC,cAAc,CAAC,CAAC,CAAC;IAC1F,CAAC;IAED;;;;;;;OAOG;IACI,IAAI,CAAC,GAAW,EAAE,IAAU,EAAE,IAAa,EAAE,cAA4B;QAC9E,MAAM,OAAO,GAAG,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;QACtC,MAAM,OAAO,GAAG,IAAI,IAAI,OAAO,IAAI,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,IAAI,EAAE,CAAC;QACrF,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,OAAO,GAAG,GAAG,EAAE,EAAE,OAAO,EAAE,IAAI,CAAC,cAAc,CAAC,cAAc,CAAC,CAAC,CAAC;IAC3F,CAAC;IAED;;;;;;;OAOG;IACI,aAAa,CAAC,GAAW,EAAE,QAAkB,EAAE,IAAa,EAAE,cAA4B;QAC/F,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,GAAG,GAAG,EAAE,EAAE,QAAQ,EAAE,IAAI,CAAC,cAAc,CAAC,cAAc,CAAC,CAAC,CAAC;IAC1G,CAAC;IAED;;;;;;;OAOG;IACI,KAAK,CAAC,GAAW,EAAE,IAAU,EAAE,IAAa,EAAE,cAA4B;QAC/E,MAAM,OAAO,GAAG,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;QACtC,MAAM,OAAO,GAAG,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;QACjD,OAAO,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,GAAG,OAAO,GAAG,GAAG,EAAE,EAAE,OAAO,EAAE,IAAI,CAAC,cAAc,CAAC,cAAc,CAAC,CAAC,CAAC;IAC5F,CAAC;IAED;;;;;;;OAOG;IACI,GAAG,CAAC,GAAW,EAAE,IAAU,EAAE,IAAa,EAAE,cAA4B;QAC7E,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,GAAG,GAAG,EAAE,IAAI,EAAE,IAAI,CAAC,cAAc,CAAC,cAAc,CAAC,CAAC,CAAC;IAChG,CAAC;IAED;;;;;;OAMG;IACI,MAAM,CAAC,GAAW,EAAE,IAAa,EAAE,cAAkC;QAC1E,OAAO,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,GAAG,GAAG,EAAE,IAAI,CAAC,cAAc,CAAC,cAAc,CAAC,CAAC,CAAC;IAC7F,CAAC;IAED;;;;;;OAMG;IACI,WAAW,CAAC,GAAW;QAC5B,IAAI,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;YACzB,OAAO,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC;QAClC,CAAC;aAAM,CAAC;YACN,MAAM,cAAc,GAAQ;gBAC1B,YAAY,EAAE,MAAM;gBACpB,OAAO,EAAE,IAAI,CAAC,cAAc,EAAE;aAC/B,CAAC;YACF,OAAO,IAAI,CAAC,eAAe,CAAC,GAAG,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,EAAE,cAAc,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;QAC9H,CAAC;IACH,CAAC;IAED;;;;;;;OAOG;IACI,eAAe,CAAC,EAAU,EAAE,OAAkC;QACnE,IAAI,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,CAAC;YACvB,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,CAAE,CAAC;QAC7B,CAAC;aAAM,CAAC;YACN,MAAM,IAAI,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CACpD,QAAQ,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,EACrC,WAAW,CAAC,CAAC,CAAC,CACf,CAAC;YACF,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,EAAE,IAAI,CAAC,CAAC;YACzB,OAAO,IAAI,CAAC;QACd,CAAC;IACH,CAAC;IAEM,QAAQ,CAAC,GAAW,EAAE,QAAiB;QAC5C,IAAI,QAAQ,IAAI,QAAQ,CAAC,IAAI,EAAE,CAAC;YAC9B,MAAM,CAAC,GAAG,QAAQ,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC;YACtC,CAAC,CAAC,YAAY,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;YAC5B,CAAC,CAAC,KAAK,CAAC,OAAO,GAAG,MAAM,CAAC;YACzB,CAAC,CAAC,YAAY,CAAC,UAAU,EAAE,QAAQ,IAAI,UAAU,CAAC,CAAC;YACnD,QAAQ,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;YAC7B,CAAC,CAAC,KAAK,EAAE,CAAC;YACV,QAAQ,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;QAC/B,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,kFAAkF,CAAC,CAAC;QACzG,CAAC;IACH,CAAC;IAED;;;;;;OAMG;IACH,UAAU,CAAC,MAAc,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,KAAK;QACrD,OAAO,IAAI,CAAC,aAAa,CAAC,UAAU,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC;IACpD,CAAC;IAED;;OAEG;IACH,cAAc,CAAC,cAA4B;QACzC,6FAA6F;QAC7F,IAAI,CAAC,cAAc,EAAE;aAClB,IAAI,EAAE;aACN,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,EAAE,IAAI,CAAC,cAAc,EAAE,CAAC,GAAG,CAAC,CAAC,CAAE,CAAC,CAAC,CAAC;QACpE,OAAO,MAAM,CAAC,MAAM,CAAC,EAAE,OAAO,EAAE,IAAI,CAAC,QAAQ,EAAE,EAAE,cAAc,CAAC,CAAC;IACnE,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,QAAqG;QACzG,MAAM,YAAY,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CACrC,IAAY,CAAC,CAAC,CAAC,CAAC,MAAM,IAAI,KAAK,CAAC,CAAC,WAAW,EAAE,CAAC;aAC7C,KAAK,CACJ,IAAI,EACJ,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,cAAc,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAC3D;aACA,IAAI,CAAC,UAAU,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC,CAClD,CAAC;QACF,OAAO,QAAQ,CAAC,YAAY,CAAsB,CAAC;IACrD,CAAC;+GAvMU,cAAc;mHAAd,cAAc,cADD,MAAM;;4FACnB,cAAc;kBAD1B,UAAU;mBAAC,EAAE,UAAU,EAAE,MAAM,EAAE","sourcesContent":["import { HttpClient, HttpHeaders } from '@angular/common/http';\nimport { inject, Injectable } from '@angular/core';\nimport { forkJoin, Observable, of } from 'rxjs';\nimport { catchError, finalize, shareReplay, tap } from 'rxjs/operators';\nimport { ConfigService } from '../config/config.service';\nimport { Logger } from '../logger/logger';\nimport { ApiBase } from './api.enum';\nimport { HttpDeleteOptions, HttpOptions } from './backend.interface';\n\n/**\n * Service for providing an yuuvis Backend\n */\n@Injectable({ providedIn: 'root' })\nexport class BackendService {\n  #http = inject(HttpClient);\n  #logger = inject(Logger);\n  configService = inject(ConfigService);\n\n  #cache = new Map<string, any>();\n  #temp = new Map<string, Observable<any>>();\n  #headers = new HttpHeaders({\n    'Content-Type': 'application/json'\n  });\n\n  authUsesOpenIdConnect(): boolean {\n    return this.configService.authUsesOpenIdConnect();\n  }\n\n  /**\n   * OpenIdConnect authorization headers\n   */\n  getAuthHeaders() {\n    return this.configService.getAuthHeaders();\n  }\n\n  /**\n   * Add a new header.\n   * @param key The headers name\n   * @param value The value to be added to the headers. Setting this to null\n   * will remove the header\n   */\n  setHeader(key: string, value: string) {\n    if (value && value.length) {\n      this.#headers = this.#headers.set(key, value);\n    } else {\n      this.#headers = this.#headers.delete(key);\n    }\n  }\n\n  /**\n   * Wrapped HTTP GET method\n   * @param uri The REST URI to be queried\n   * @param base The Base URI (backend service) to be used\n   * @param requestOptions Additional request options\n   * @returns The data retrieved from the given endpoint\n   */\n  get(uri: string, base?: string, requestOptions?: HttpOptions): Observable<any> {\n    return this.#http.get(this.getApiBase(base) + uri, this.getHttpOptions(requestOptions));\n  }\n\n  /**\n   * Wrapped HTTP POST method\n   * @param uri The target REST URI\n   * @param data Data to be 'posted'\n   * @param base The Base URI (backend service) to be used\n   * @param requestOptions Additional request options\n   * @returns The return value of the target POST endpoint\n   */\n  public post(uri: string, data?: any, base?: string, requestOptions?: HttpOptions): Observable<any> {\n    const baseUri = this.getApiBase(base);\n    const payload = data && typeof data === 'object' ? JSON.stringify(data) : data || '';\n    return this.#http.post(`${baseUri}${uri}`, payload, this.getHttpOptions(requestOptions));\n  }\n\n  /**\n   * Performs a multipart form data POST request.\n   * @param uri The target REST URI\n   * @param formData FormData to be 'posted'\n   * @param base The Base URI (backend service) to be used\n   * @param requestOptions Additional request options\n   * @returns The return value of the target POST endpoint\n   */\n  public postMultiPart(uri: string, formData: FormData, base?: string, requestOptions?: HttpOptions): Observable<any> {\n    return this.#http.post(`${this.getApiBase(base)}${uri}`, formData, this.getHttpOptions(requestOptions));\n  }\n\n  /**\n   * Wrapped HTTP PATCH method\n   * @param uri The target REST URI\n   * @param data Data to be 'patched'\n   * @param base The Base URI (backend service) to be used\n   * @param requestOptions Additional request options\n   * @returns The return value of the target PATCH endpoint\n   */\n  public patch(uri: string, data?: any, base?: string, requestOptions?: HttpOptions): Observable<any> {\n    const baseUri = this.getApiBase(base);\n    const payload = data ? JSON.stringify(data) : '';\n    return this.#http.patch(`${baseUri}${uri}`, payload, this.getHttpOptions(requestOptions));\n  }\n\n  /**\n   * Wrapped HTTP PUT method\n   * @param uri The target REST URI\n   * @param data Data to be 'posted'\n   * @param base The Base URI (backend service) to be used\n   * @param requestOptions Additional request options\n   * @returns The return value of the target PUT endpoint\n   */\n  public put(uri: string, data?: any, base?: string, requestOptions?: HttpOptions): Observable<any> {\n    return this.#http.put(this.getApiBase(base) + uri, data, this.getHttpOptions(requestOptions));\n  }\n\n  /**\n   * Wrapped HTTP DELETE method\n   * @param uri The target REST URI\n   * @param base The Base URI (backend service) to be used\n   * @param requestOptions Additional request options\n   * @returns The return value of the target DELETE endpoint\n   */\n  public delete(uri: string, base?: string, requestOptions?: HttpDeleteOptions): Observable<any> {\n    return this.#http.delete(this.getApiBase(base) + uri, this.getHttpOptions(requestOptions));\n  }\n\n  /**\n   * @ignore\n   * Cache for small requests like icons and configs\n   *\n   * @param string uri\n   * @returns Observable<any>\n   */\n  public getViaCache(uri: string): Observable<any> {\n    if (this.#cache.has(uri)) {\n      return of(this.#cache.get(uri));\n    } else {\n      const requestOptions: any = {\n        responseType: 'text',\n        headers: this.getAuthHeaders()\n      };\n      return this.getViaTempCache(uri, () => this.#http.get(uri, requestOptions).pipe(tap((text) => this.#cache.set(uri, text))));\n    }\n  }\n\n  /**\n   * @ignore\n   * Temporary Cache for multiple identical requests\n   *\n   * @param string id\n   * @param Function request\n   * @returns Observable<any>\n   */\n  public getViaTempCache(id: string, request?: () => Observable<object>): Observable<any> {\n    if (this.#temp.has(id)) {\n      return this.#temp.get(id)!;\n    } else {\n      const resp = (request ? request() : this.get(id)).pipe(\n        finalize(() => this.#temp.delete(id)),\n        shareReplay(1)\n      );\n      this.#temp.set(id, resp);\n      return resp;\n    }\n  }\n\n  public download(uri: string, filename?: string) {\n    if (document && document.body) {\n      const a = document.createElement('a');\n      a.setAttribute('href', uri);\n      a.style.display = 'none';\n      a.setAttribute('download', filename || 'download');\n      document.body.appendChild(a);\n      a.click();\n      document.body.removeChild(a);\n    } else {\n      this.#logger.error('Environment not supported. Downloading contents relies on a DOM being available.');\n    }\n  }\n\n  /**\n   * Gets the base URI for an API endpoint\n   * @param api The API to get the base URI for. Leaving this blank will return\n   * base URI for the web API\n   * @param origin The flag to include location origin\n   * @returns Base URI for the given API.\n   */\n  getApiBase(api: string = ApiBase.apiWeb, origin = false): string {\n    return this.configService.getApiBase(api, origin);\n  }\n\n  /**\n   * @ignore\n   */\n  getHttpOptions(requestOptions?: HttpOptions): HttpOptions {\n    // Object.entries(this.getAuthHeaders()).forEach(([h, v]) => this.setHeader(h, v as string));\n    this.getAuthHeaders()\n      .keys()\n      .forEach((k) => this.setHeader(k, this.getAuthHeaders().get(k)!));\n    return Object.assign({ headers: this.#headers }, requestOptions);\n  }\n\n  /**\n   * Batch service\n   */\n  batch(requests: { method?: string; uri: string; body?: any; base?: string; requestOptions?: HttpOptions }[]) {\n    const httpRequests = requests.map((r) =>\n      (this as any)[(r.method || 'get').toLowerCase()]\n        .apply(\n          this,\n          [r.uri, r.body, r.base, r.requestOptions].filter((a) => a)\n        )\n        .pipe(catchError((err) => of({ _error: err })))\n    );\n    return forkJoin(httpRequests) as Observable<any[]>;\n  }\n}\n"]}

package/esm2022/lib/service/bpm/bpm.interface.mjs

@@ -0,0 +1,8 @@
+export const ProcessAction = {
+    complete: 'complete',
+    claim: 'claim',
+    delegate: 'delegate',
+    resolve: 'resolve',
+    save: 'save'
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/service/bpm/bpm.service.mjs

@@ -0,0 +1,51 @@
+import { inject, Injectable } from '@angular/core';
+import { BackendService } from '../backend/backend.service';
+import { ProcessAction } from './bpm.interface';
+import { map, of } from 'rxjs';
+import { ApiBase } from '../backend/api.enum';
+import { Utils } from '../../util/utils';
+import * as i0 from "@angular/core";
+export class BpmService {
+    #backend = inject(BackendService);
+    startProcess(payload) {
+        return this.#backend.post('/bpm/processes', payload, ApiBase.apiWeb);
+    }
+    /**
+     * Finsihes a task.
+     * @param taskId ID of the taks to finish
+     * @param payload Data to be send with the complete request (may contain attachments, a new subject or variables)
+     */
+    completeTask(taskId, payload) {
+        return this.#putTask(taskId, ProcessAction.complete, payload || {});
+    }
+    updateTask(taskId, payload) {
+        return this.#putTask(taskId, ProcessAction.save, payload || {});
+    }
+    //TODO: replace with propper service call
+    getProcessPoll() {
+        const random = Math.random();
+        console.log('getProcessPoll: ', { random });
+        return of([{ title: `task title ${random}`, duedate: new Date() }]);
+    }
+    getProcessInstance(processDefinitionKey, options) {
+        return this.#backend
+            .get(`/bpm/processes${Utils.optionsToURLParams({ ...options, processDefinitionKey })}`, ApiBase.apiWeb)
+            .pipe(map(({ objects }) => objects[0]));
+    }
+    deleteProcess(processInstanceId) {
+        return this.#backend.delete(`/bpm/processes/${processInstanceId}`, ApiBase.apiWeb);
+    }
+    #putTask(taskId, action, payload) {
+        const pl = { ...payload, action: action };
+        return this.#backend.put(`/bpm/tasks/${taskId}`, pl, ApiBase.apiWeb);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: BpmService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: BpmService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: BpmService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/service/cache/app-cache.service.mjs

@@ -0,0 +1,51 @@
+import { inject, Injectable } from '@angular/core';
+import { StorageMap } from '@ngx-pwa/local-storage';
+import { forkJoin, Observable, of } from 'rxjs';
+import { first, map, switchMap } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+/**
+ * Service for saving or caching data on the users device. It uses the most efficient storage
+ * available  (IndexDB, localstorage, ...) on the device. Depending on the type of storage used,
+ * its limitations apply.
+ */
+export class AppCacheService {
+    #storage = inject(StorageMap);
+    setItem(key, value) {
+        return this.#storage.set(key, value).pipe(map(() => true));
+    }
+    getItem(key) {
+        return this.#storage.get(key);
+    }
+    removeItem(key) {
+        return this.#storage.delete(key).pipe(map(() => true));
+    }
+    clear(filter) {
+        return filter
+            ? this.getStorageKeys().pipe(switchMap((keys) => {
+                const list = keys.filter((k) => filter(k)).map((k) => this.removeItem(k));
+                return list.length ? forkJoin(list).pipe(map(() => true)) : of(true);
+            }))
+            : this.#storage.clear().pipe(map(() => true));
+    }
+    getStorageKeys() {
+        return new Observable((observer) => {
+            const keys = [];
+            this.#storage.keys().subscribe({
+                next: (key) => keys.push(key),
+                complete: () => observer.next(keys)
+            });
+        }).pipe(first());
+    }
+    setStorage(options) {
+        return forkJoin(Object.keys(options || {}).map((k) => this.setItem(k, options[k])));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AppCacheService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AppCacheService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AppCacheService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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