@yuuvis/client-core 0.6.5

package/esm2022/lib/service/idm/idm.service.mjs

@@ -0,0 +1,34 @@
+import { inject, Injectable } from '@angular/core';
+import { map } from 'rxjs';
+import { BackendService } from '../backend/backend.service';
+import * as i0 from "@angular/core";
+export class IdmService {
+    #backend = inject(BackendService);
+    queryOrganizationEntity(term, targetTypes, size) {
+        return this.#backend.get(`/idm/search?search=${term}${size ? `&size=${size}` : ''}`).pipe(map((res) => [
+            ...(targetTypes.includes('user')
+                ? res.users.map((u) => ({
+                    id: u.id,
+                    title: `${u.lastname}, ${u.firstname} (${u.username})`, // TODO: u.title,
+                    type: 'user'
+                }))
+                : []),
+            ...(targetTypes.includes('role')
+                ? res.roles.map((u) => ({
+                    id: u.name,
+                    title: u.name,
+                    type: 'role'
+                }))
+                : [])
+        ]));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: IdmService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: IdmService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: IdmService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/service/logger/logger-console.service.mjs

@@ -0,0 +1,73 @@
+import { Injectable } from '@angular/core';
+import { ConfigService } from '../config/config.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../config/config.service";
+/**
+ * @ignore
+ */
+export class LoggerConsoleService {
+    constructor(config) {
+        this.config = config;
+        this.styles = {
+            info: 'color:blue',
+            debug: 'background: orange',
+            warn: 'background: rgba(255,0,0,.2);color: red',
+            error: 'background: red; color: #fff'
+        };
+    }
+    apply(fn, args) {
+        args = [`%c${fn}:`, 'font-family: monospace; font-size: 10px; padding: 2px 4px;' + this.styles[fn], ...args];
+        return this.shouldLog(fn) ? console && console[fn] && console[fn](...args) : null;
+    }
+    debug(...args) {
+        this.apply('debug', args);
+    }
+    error(...args) {
+        this.apply('error', args);
+    }
+    info(...args) {
+        this.apply('info', args);
+    }
+    log(...args) {
+        this.apply('log', args);
+    }
+    warn(...args) {
+        this.apply('warn', args);
+    }
+    shouldLog(level) {
+        let should = false;
+        const cfg = this.config.get('core.logging');
+        if (!cfg || !cfg.level)
+            return false;
+        switch (cfg.level) {
+            case 'debug': {
+                should = true;
+                break;
+            }
+            case 'error': {
+                should = ['error'].includes(level);
+                break;
+            }
+            case 'warn': {
+                should = ['warn', 'error'].includes(level);
+                break;
+            }
+            case 'info': {
+                should = ['info', 'warn', 'error'].includes(level);
+                break;
+            }
+            default: {
+            }
+        }
+        return should;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LoggerConsoleService, deps: [{ token: i1.ConfigService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LoggerConsoleService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LoggerConsoleService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.ConfigService }] });
+//# sourceMappingURL=data:application/json;base64,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

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

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

package/esm2022/lib/service/logger/logger.mjs

@@ -0,0 +1,27 @@
+/**
+ * Set up the default logger.
+ * The default logger doesn't actually log anything;
+ * but, it provides the Dependency-Injection (DI) token that the rest of the
+ * application can use for dependency resolution. Each platform can then override
+ * this with a platform-specific logger implementation.
+ *
+ * @ignore
+ */
+export class Logger {
+    error(...args) {
+        // ... the default logger does no work.
+    }
+    debug(...args) {
+        // ... the default logger does no work.
+    }
+    info(...args) {
+        // ... the default logger does no work.
+    }
+    log(...args) {
+        // ... the default logger does no work.
+    }
+    warn(...args) {
+        // ... the default logger does no work.
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9nZ2VyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy95dXV2aXMvY2xpZW50LWNvcmUvc3JjL2xpYi9zZXJ2aWNlL2xvZ2dlci9sb2dnZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUE7Ozs7Ozs7O0dBUUc7QUFDSCxNQUFNLE9BQU8sTUFBTTtJQUVWLEtBQUssQ0FBQyxHQUFHLElBQVc7UUFDekIsdUNBQXVDO0lBQ3pDLENBQUM7SUFFTSxLQUFLLENBQUMsR0FBRyxJQUFXO1FBQ3pCLHVDQUF1QztJQUN6QyxDQUFDO0lBRU0sSUFBSSxDQUFDLEdBQUcsSUFBVztRQUN4Qix1Q0FBdUM7SUFDekMsQ0FBQztJQUVNLEdBQUcsQ0FBQyxHQUFHLElBQVc7UUFDdkIsdUNBQXVDO0lBQ3pDLENBQUM7SUFFTSxJQUFJLENBQUMsR0FBRyxJQUFXO1FBQ3hCLHVDQUF1QztJQUN6QyxDQUFDO0NBRUYiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJTG9nZ2VyIH0gZnJvbSAnLi9sb2dnZXIuaW50ZXJmYWNlJztcblxuLyoqXG4gKiBTZXQgdXAgdGhlIGRlZmF1bHQgbG9nZ2VyLlxuICogVGhlIGRlZmF1bHQgbG9nZ2VyIGRvZXNuJ3QgYWN0dWFsbHkgbG9nIGFueXRoaW5nO1xuICogYnV0LCBpdCBwcm92aWRlcyB0aGUgRGVwZW5kZW5jeS1JbmplY3Rpb24gKERJKSB0b2tlbiB0aGF0IHRoZSByZXN0IG9mIHRoZSBcbiAqIGFwcGxpY2F0aW9uIGNhbiB1c2UgZm9yIGRlcGVuZGVuY3kgcmVzb2x1dGlvbi4gRWFjaCBwbGF0Zm9ybSBjYW4gdGhlbiBvdmVycmlkZSBcbiAqIHRoaXMgd2l0aCBhIHBsYXRmb3JtLXNwZWNpZmljIGxvZ2dlciBpbXBsZW1lbnRhdGlvbi5cbiAqXG4gKiBAaWdub3JlXG4gKi9cbmV4cG9ydCBjbGFzcyBMb2dnZXIgaW1wbGVtZW50cyBJTG9nZ2VyIHtcblxuICBwdWJsaWMgZXJyb3IoLi4uYXJnczogYW55W10pOiB2b2lkIHtcbiAgICAvLyAuLi4gdGhlIGRlZmF1bHQgbG9nZ2VyIGRvZXMgbm8gd29yay5cbiAgfVxuXG4gIHB1YmxpYyBkZWJ1ZyguLi5hcmdzOiBhbnlbXSk6IHZvaWQge1xuICAgIC8vIC4uLiB0aGUgZGVmYXVsdCBsb2dnZXIgZG9lcyBubyB3b3JrLlxuICB9XG5cbiAgcHVibGljIGluZm8oLi4uYXJnczogYW55W10pOiB2b2lkIHtcbiAgICAvLyAuLi4gdGhlIGRlZmF1bHQgbG9nZ2VyIGRvZXMgbm8gd29yay5cbiAgfVxuXG4gIHB1YmxpYyBsb2coLi4uYXJnczogYW55W10pOiB2b2lkIHtcbiAgICAvLyAuLi4gdGhlIGRlZmF1bHQgbG9nZ2VyIGRvZXMgbm8gd29yay5cbiAgfVxuXG4gIHB1YmxpYyB3YXJuKC4uLmFyZ3M6IGFueVtdKTogdm9pZCB7XG4gICAgLy8gLi4uIHRoZSBkZWZhdWx0IGxvZ2dlciBkb2VzIG5vIHdvcmsuXG4gIH1cblxufSJdfQ==

package/esm2022/lib/service/notification/notification.service.mjs

@@ -0,0 +1,131 @@
+import { Injectable, inject } from '@angular/core';
+import { ToastService } from '@yuuvis/components/toast';
+import { AuthService } from '../auth/auth.service';
+import { EventService } from '../event/event.service';
+import { YuvEventType } from '../event/events';
+import * as i0 from "@angular/core";
+/**
+ * Shows a message after completing each action.
+ */
+export class NotificationService {
+    #toastService;
+    #authService;
+    #eventService;
+    constructor() {
+        this.#toastService = inject(ToastService);
+        this.#authService = inject(AuthService);
+        this.#eventService = inject(EventService);
+        /**
+         * Set to true to suppress any notifications
+         */
+        this.silent = false;
+        /**
+         * Default Notofication Options
+         *
+         */
+        this.options = {
+            position: 'bottom-end'
+        };
+        this.#authService.authenticated$.subscribe((a) => (this.silent = !a));
+        this.#eventService.on(YuvEventType.LOGOUT).subscribe(() => (this.silent = true));
+    }
+    /**
+     * Show info colored massage (blue)
+     *
+     * @param string title
+     * @param string msg
+     */
+    info(title, msg) {
+        this.toast(title, msg);
+    }
+    /**
+     * Show success colored massage (green)
+     * @param string title
+     * @param string msg
+     */
+    success(title, msg) {
+        this.toast(title, msg, 'success');
+    }
+    /**
+     * can not be in use
+     *
+     * @param string title
+     * @param string msg
+     */
+    wait(title, msg) {
+        this.toast(title, msg, 'wait');
+    }
+    /**
+     * Show error colored massage (red)
+     *
+     * @param string title
+     * @param string msg
+     */
+    error(title, msg) {
+        this.toast(title, msg, 'error', {
+            duration: 5
+        });
+    }
+    /**
+     * Show warning colored massage (yellow)
+     *
+     * @param string title
+     * @param string msg
+     */
+    warning(title, msg) {
+        this.toast(title, msg, 'warning');
+    }
+    /**
+     * Public wrapper for accessing the Toastr
+     *
+     * @param string title
+     * @param string msg
+     * @param string mode
+     * @param _options
+     */
+    toast(title, msg, mode, _options) {
+        this.doToast(title, msg, { ...this.options, ..._options }, mode);
+    }
+    /**
+     * Accessing the toastr service
+     *
+     * @param string msg
+     * @param string title
+     * @param options
+     * @param string mode
+     */
+    doToast(title, msg, options, mode) {
+        if (this.silent)
+            return;
+        switch (mode) {
+            case 'success': {
+                this.#toastService.success(title, msg, options);
+                break;
+            }
+            case 'error': {
+                this.#toastService.error(title, msg, options);
+                break;
+            }
+            case 'warning': {
+                this.#toastService.warning(title, msg, options);
+                break;
+            }
+            case 'confirm': {
+                this.#toastService.info(title, msg, options);
+                break;
+            }
+            default: {
+                this.#toastService.info(title, msg, options);
+            }
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: NotificationService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: NotificationService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: NotificationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/service/object-config/object-config.interface.mjs

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

package/esm2022/lib/service/object-config/object-config.service.mjs

@@ -0,0 +1,229 @@
+import { Injectable, inject } from '@angular/core';
+import { ReplaySubject, map, tap } from 'rxjs';
+import { BaseObjectTypeField } from '../system/system.enum';
+import { SystemService } from '../system/system.service';
+import { UserService } from '../user/user.service';
+import * as i0 from "@angular/core";
+/**
+ * Service managing the configuarions for object types.
+ * Configuration means that you can pick certain fields
+ * of an object type and assign them to a config object.
+ */
+export class ObjectConfigService {
+    constructor() {
+        this.#system = inject(SystemService);
+        this.#user = inject(UserService);
+        this.OBJECT_CONFIG_STORAGE_KEY = 'yuv.framework.object-config';
+        this.#objectConfigsSource = new ReplaySubject();
+        this.#objectConfigs$ = this.#objectConfigsSource.asObservable();
+        this.#defaultObjectConfigs = {};
+        this.#registeredDefaultObjectConfigs = {
+            main: {},
+            buckets: []
+        };
+        this.#objectConfigs = {
+            main: {},
+            buckets: []
+        };
+    }
+    #system;
+    #user;
+    #objectConfigsSource;
+    #objectConfigs$;
+    #defaultObjectConfigs;
+    #registeredDefaultObjectConfigs;
+    #objectConfigs;
+    // called on core init (auth.service -> initApp)
+    init() {
+        console.log('ObjectConfigService.init', this.#user.getCurrentUser().userSettings);
+        return this.#user.loadObjectConfig().pipe(tap((res) => {
+            this.#getDefaultObjectConfig();
+            this.#objectConfigs = res || {
+                main: {},
+                buckets: []
+            };
+            this.#objectConfigsSource.next(this.#objectConfigs);
+        }));
+    }
+    getObjectConfigs$(bucket, includeDefaults) {
+        return this.#objectConfigs$.pipe(map((soc) => {
+            let ocr = soc.main;
+            const defaults = { ...this.#defaultObjectConfigs, ...this.#getRegisteredDefaults(bucket) };
+            if (bucket) {
+                const tileBucket = soc.buckets.find((b) => b.id === bucket);
+                if (tileBucket)
+                    ocr = tileBucket.configs;
+            }
+            return includeDefaults
+                ? {
+                    ...defaults,
+                    ...ocr
+                }
+                : { ...ocr };
+        }));
+    }
+    /**
+     * Register default object configs. Apps can pre-define how their
+     * objects should be rendered.
+     * @param bucket Name of a bucket to bind configs to (usually the ID of the app) to
+     * separate the configs from other apps. If not provided configs will be saved for
+     * the global scope
+     */
+    registerDefaults(configs, bucket) {
+        if (bucket) {
+            // does bucket exist?
+            const tileBucketIdx = this.#registeredDefaultObjectConfigs.buckets.findIndex((b) => b.id === bucket);
+            if (tileBucketIdx !== -1) {
+                this.#registeredDefaultObjectConfigs.buckets[tileBucketIdx].configs = {
+                    ...this.#registeredDefaultObjectConfigs.buckets[tileBucketIdx].configs,
+                    ...configs
+                };
+            }
+            else {
+                this.#registeredDefaultObjectConfigs.buckets.push({
+                    id: bucket,
+                    configs
+                });
+            }
+        }
+        else
+            this.#registeredDefaultObjectConfigs.main = { ...this.#registeredDefaultObjectConfigs.main, ...configs };
+    }
+    unregisterDefaults(configs, bucket) {
+        if (bucket) {
+            // does bucket exist?
+            const tileBucketIdx = this.#registeredDefaultObjectConfigs.buckets.findIndex((b) => b.id === bucket);
+            if (tileBucketIdx !== -1) {
+                this.#registeredDefaultObjectConfigs.buckets.splice(tileBucketIdx, 1);
+            }
+        }
+        else {
+            Object.keys(configs).forEach((key) => {
+                delete this.#registeredDefaultObjectConfigs.main[key];
+            });
+        }
+    }
+    #getRegisteredDefaults(bucket) {
+        if (bucket) {
+            const defaultTileBucket = this.#registeredDefaultObjectConfigs.buckets.find((b) => b.id === bucket);
+            return defaultTileBucket?.configs || {};
+        }
+        else
+            return this.#registeredDefaultObjectConfigs.main;
+    }
+    /**
+     * Get object config for an object type.
+     * @param objectTypeId ID of the object type to get the config for
+     * @param bucket Optional bucket ID to fetch the config from. Buckets
+     * define separated areas to store/receive those configs. This way
+     * components/apps can store different object configs than the ones
+     * used accross the whole client application.
+     */
+    getObjectConfig(type, bucket) {
+        const b = bucket ? this.#objectConfigs.buckets.find((b) => b.id === bucket) : undefined;
+        const otr = b ? b.configs : this.#objectConfigs.main;
+        const oc = otr[type.id];
+        return oc || this.#getRegisteredDefaults(bucket)[type.id];
+    }
+    saveObjectConfig(type, config, bucket) {
+        if (!this.#objectConfigs)
+            this.#objectConfigs = {
+                main: {},
+                buckets: []
+            };
+        if (bucket) {
+            // does bucket exist?
+            const tileBucketIdx = this.#objectConfigs.buckets.findIndex((b) => b.id === bucket);
+            if (tileBucketIdx !== -1) {
+                this.#objectConfigs.buckets[tileBucketIdx].configs[type.id] = config;
+            }
+            else {
+                const configs = {};
+                configs[type.id] = config;
+                this.#objectConfigs.buckets.push({
+                    id: bucket,
+                    configs
+                });
+            }
+        }
+        else {
+            this.#objectConfigs.main[type.id] = config;
+        }
+        this.#objectConfigsSource.next(this.#objectConfigs);
+        return this.#user.saveObjectConfig(this.#objectConfigs);
+    }
+    getDefaultConfig(objectTypeID) {
+        return this.#defaultObjectConfigs[objectTypeID];
+    }
+    getResolvedObjectConfig(data, type, bucket, includeDefaults) {
+        const defaultCfg = this.#defaultObjectConfigs[data[BaseObjectTypeField.OBJECT_TYPE_ID]];
+        let oc = this.getObjectConfig(type, bucket) || defaultCfg;
+        if (includeDefaults)
+            oc = { ...defaultCfg, ...oc };
+        const res = {
+            id: data[BaseObjectTypeField.OBJECT_ID],
+            objectTypeId: data[BaseObjectTypeField.OBJECT_TYPE_ID],
+            actions: oc.actions,
+            badges: oc.badges,
+            instanceData: data
+        };
+        if (oc.title)
+            res.title = {
+                propertyName: oc.title.propertyName,
+                value: data[oc.title.propertyName]
+            };
+        if (oc.description)
+            res.description = {
+                propertyName: oc.description.propertyName,
+                value: data[oc.description.propertyName]
+            };
+        if (oc.icon)
+            res.icon = {
+                propertyName: 'custom',
+                value: oc.icon.svg
+            };
+        if (oc.meta)
+            res.meta = {
+                propertyName: oc.meta.propertyName,
+                value: data[oc.meta.propertyName]
+            };
+        if (oc.aside)
+            res.aside = {
+                propertyName: oc.aside.propertyName,
+                value: data[oc.aside.propertyName]
+            };
+        return res;
+    }
+    /**
+     * Load default/fallbac configs based on the object types and
+     * their first properties
+     */
+    #getDefaultObjectConfig() {
+        this.#system.getObjectTypes(true).forEach((ot) => {
+            this.#defaultObjectConfigs[ot.id] = {
+                objectTypeId: ot.id,
+                title: this.#toObjectProperty(ot.fields[0]),
+                description: this.#toObjectProperty(ot.fields[1]),
+                meta: this.#toObjectProperty(ot.fields[2]),
+                aside: this.#toObjectProperty(ot.fields[3])
+            };
+        });
+    }
+    #toObjectProperty(field) {
+        return field
+            ? {
+                label: this.#system.getLocalizedLabel(field.id),
+                propertyName: field.id
+            }
+            : undefined;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ObjectConfigService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ObjectConfigService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ObjectConfigService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"object-config.service.js","sourceRoot":"","sources":["../../../../../../../../libs/yuuvis/client-core/src/lib/service/object-config/object-config.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, inject } from '@angular/core';\nimport { Observable, ReplaySubject, map, tap } from 'rxjs';\nimport { BaseObjectTypeField } from '../system/system.enum';\nimport { GenericObjectType, ObjectTypeField, VirtualObjectType } from '../system/system.interface';\nimport { SystemService } from '../system/system.service';\nimport { UserService } from '../user/user.service';\nimport {\n  ObjectConfig,\n  ObjectConfigBucket,\n  ObjectConfigProperty,\n  ObjectConfigRecord,\n  ResolvedObjectConfig,\n  StoredObjectConfig\n} from './object-config.interface';\n\n/**\n * Service managing the configuarions for object types.\n * Configuration means that you can pick certain fields\n * of an object type and assign them to a config object.\n */\n@Injectable({\n  providedIn: 'root'\n})\nexport class ObjectConfigService {\n  #system = inject(SystemService);\n  #user = inject(UserService);\n\n  OBJECT_CONFIG_STORAGE_KEY = 'yuv.framework.object-config';\n  #objectConfigsSource = new ReplaySubject<StoredObjectConfig>();\n  #objectConfigs$: Observable<StoredObjectConfig> = this.#objectConfigsSource.asObservable();\n\n  #defaultObjectConfigs: Record<string, ObjectConfig> = {};\n  #registeredDefaultObjectConfigs: StoredObjectConfig = {\n    main: {},\n    buckets: []\n  };\n  #objectConfigs: StoredObjectConfig = {\n    main: {},\n    buckets: []\n  };\n\n  // called on core init (auth.service -> initApp)\n  init(): Observable<any> {\n    console.log('ObjectConfigService.init', this.#user.getCurrentUser().userSettings);\n    return this.#user.loadObjectConfig().pipe(\n      tap((res) => {\n        this.#getDefaultObjectConfig();\n        this.#objectConfigs = res || {\n          main: {},\n          buckets: []\n        };\n        this.#objectConfigsSource.next(this.#objectConfigs);\n      })\n    );\n  }\n\n  getObjectConfigs$(bucket?: string, includeDefaults?: boolean): Observable<ObjectConfigRecord> {\n    return this.#objectConfigs$.pipe(\n      map((soc: StoredObjectConfig) => {\n        let ocr: ObjectConfigRecord = soc.main;\n        const defaults: ObjectConfigRecord = { ...this.#defaultObjectConfigs, ...this.#getRegisteredDefaults(bucket) };\n\n        if (bucket) {\n          const tileBucket: ObjectConfigBucket | undefined = soc.buckets.find((b) => b.id === bucket);\n          if (tileBucket) ocr = tileBucket.configs;\n        }\n\n        return includeDefaults\n          ? {\n              ...defaults,\n              ...ocr\n            }\n          : { ...ocr };\n      })\n    );\n  }\n\n  /**\n   * Register default object configs. Apps can pre-define how their\n   * objects should be rendered.\n   * @param bucket Name of a bucket to bind configs to (usually the ID of the app) to\n   * separate the configs from other apps. If not provided configs will be saved for\n   * the global scope\n   */\n  registerDefaults(configs: ObjectConfigRecord, bucket?: string) {\n    if (bucket) {\n      // does bucket exist?\n      const tileBucketIdx: number = this.#registeredDefaultObjectConfigs.buckets.findIndex((b) => b.id === bucket);\n      if (tileBucketIdx !== -1) {\n        this.#registeredDefaultObjectConfigs.buckets[tileBucketIdx].configs = {\n          ...this.#registeredDefaultObjectConfigs.buckets[tileBucketIdx].configs,\n          ...configs\n        };\n      } else {\n        this.#registeredDefaultObjectConfigs.buckets.push({\n          id: bucket,\n          configs\n        });\n      }\n    } else this.#registeredDefaultObjectConfigs.main = { ...this.#registeredDefaultObjectConfigs.main, ...configs };\n  }\n\n  unregisterDefaults(configs: ObjectConfigRecord, bucket?: string) {\n    if (bucket) {\n      // does bucket exist?\n      const tileBucketIdx: number = this.#registeredDefaultObjectConfigs.buckets.findIndex((b) => b.id === bucket);\n      if (tileBucketIdx !== -1) {\n        this.#registeredDefaultObjectConfigs.buckets.splice(tileBucketIdx, 1);\n      }\n    } else {\n      Object.keys(configs).forEach((key) => {\n        delete this.#registeredDefaultObjectConfigs.main[key];\n      });\n    }\n  }\n\n  #getRegisteredDefaults(bucket?: string): ObjectConfigRecord {\n    if (bucket) {\n      const defaultTileBucket: ObjectConfigBucket | undefined = this.#registeredDefaultObjectConfigs.buckets.find((b) => b.id === bucket);\n      return defaultTileBucket?.configs || {};\n    } else return this.#registeredDefaultObjectConfigs.main;\n  }\n\n  /**\n   * Get object config for an object type.\n   * @param objectTypeId ID of the object type to get the config for\n   * @param bucket Optional bucket ID to fetch the config from. Buckets\n   * define separated areas to store/receive those configs. This way\n   * components/apps can store different object configs than the ones\n   * used accross the whole client application.\n   */\n  getObjectConfig(type: VirtualObjectType, bucket?: string): ObjectConfig {\n    const b: ObjectConfigBucket | undefined = bucket ? this.#objectConfigs.buckets.find((b) => b.id === bucket) : undefined;\n    const otr: ObjectConfigRecord = b ? b.configs : this.#objectConfigs.main;\n\n    const oc = otr[type.id];\n    return oc || this.#getRegisteredDefaults(bucket)[type.id];\n  }\n\n  saveObjectConfig(type: VirtualObjectType, config: ObjectConfig, bucket?: string): Observable<any> {\n    if (!this.#objectConfigs)\n      this.#objectConfigs = {\n        main: {},\n        buckets: []\n      };\n    if (bucket) {\n      // does bucket exist?\n      const tileBucketIdx: number = this.#objectConfigs.buckets.findIndex((b) => b.id === bucket);\n      if (tileBucketIdx !== -1) {\n        this.#objectConfigs.buckets[tileBucketIdx].configs[type.id] = config;\n      } else {\n        const configs: ObjectConfigRecord = {};\n        configs[type.id] = config;\n\n        this.#objectConfigs.buckets.push({\n          id: bucket,\n          configs\n        });\n      }\n    } else {\n      this.#objectConfigs.main[type.id] = config;\n    }\n\n    this.#objectConfigsSource.next(this.#objectConfigs);\n    return this.#user.saveObjectConfig(this.#objectConfigs);\n  }\n\n  getDefaultConfig(objectTypeID: string): ObjectConfig {\n    return this.#defaultObjectConfigs[objectTypeID];\n  }\n\n  getResolvedObjectConfig(data: Record<string, any>, type: VirtualObjectType, bucket?: string, includeDefaults?: boolean): ResolvedObjectConfig {\n    const defaultCfg = this.#defaultObjectConfigs[data[BaseObjectTypeField.OBJECT_TYPE_ID]];\n    let oc = this.getObjectConfig(type, bucket) || defaultCfg;\n    if (includeDefaults) oc = { ...defaultCfg, ...oc };\n    const res: Partial<ResolvedObjectConfig> = {\n      id: data[BaseObjectTypeField.OBJECT_ID],\n      objectTypeId: data[BaseObjectTypeField.OBJECT_TYPE_ID],\n      actions: oc.actions,\n      badges: oc.badges,\n      instanceData: data\n    };\n\n    if (oc.title)\n      res.title = {\n        propertyName: oc.title.propertyName,\n        value: data[oc.title.propertyName]\n      };\n    if (oc.description)\n      res.description = {\n        propertyName: oc.description.propertyName,\n        value: data[oc.description.propertyName]\n      };\n    if (oc.icon)\n      res.icon = {\n        propertyName: 'custom',\n        value: oc.icon.svg\n      };\n    if (oc.meta)\n      res.meta = {\n        propertyName: oc.meta.propertyName,\n        value: data[oc.meta.propertyName]\n      };\n    if (oc.aside)\n      res.aside = {\n        propertyName: oc.aside.propertyName,\n        value: data[oc.aside.propertyName]\n      };\n\n    return res as ResolvedObjectConfig;\n  }\n\n  /**\n   * Load default/fallbac configs based on the object types and\n   * their first properties\n   */\n  #getDefaultObjectConfig(): void {\n    this.#system.getObjectTypes(true).forEach((ot: GenericObjectType) => {\n      this.#defaultObjectConfigs[ot.id] = {\n        objectTypeId: ot.id,\n        title: this.#toObjectProperty(ot.fields[0]),\n        description: this.#toObjectProperty(ot.fields[1]),\n        meta: this.#toObjectProperty(ot.fields[2]),\n        aside: this.#toObjectProperty(ot.fields[3])\n      };\n    });\n  }\n\n  #toObjectProperty(field: ObjectTypeField): ObjectConfigProperty | undefined {\n    return field\n      ? {\n          label: this.#system.getLocalizedLabel(field.id),\n          propertyName: field.id\n        }\n      : undefined;\n  }\n}\n"]}

package/esm2022/lib/service/pending-changes/pending-changes-component.interface.mjs

@@ -0,0 +1,5 @@
+/**
+ * Interface to be implemented by all components (state components) that are aware of pending changes
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGVuZGluZy1jaGFuZ2VzLWNvbXBvbmVudC5pbnRlcmZhY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL3l1dXZpcy9jbGllbnQtY29yZS9zcmMvbGliL3NlcnZpY2UvcGVuZGluZy1jaGFuZ2VzL3BlbmRpbmctY2hhbmdlcy1jb21wb25lbnQuaW50ZXJmYWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBJbnRlcmZhY2UgdG8gYmUgaW1wbGVtZW50ZWQgYnkgYWxsIGNvbXBvbmVudHMgKHN0YXRlIGNvbXBvbmVudHMpIHRoYXQgYXJlIGF3YXJlIG9mIHBlbmRpbmcgY2hhbmdlc1xuICovXG5cbmV4cG9ydCBpbnRlcmZhY2UgUGVuZGluZ0NoYW5nZXNDb21wb25lbnQge1xuICBoYXNQZW5kaW5nQ2hhbmdlczogKCkgPT4gYm9vbGVhbjtcbn1cbiJdfQ==

package/esm2022/lib/service/pending-changes/pending-changes-guard.service.mjs

@@ -0,0 +1,25 @@
+import { Injectable } from '@angular/core';
+import { PendingChangesService } from './pending-changes.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./pending-changes.service";
+/**
+ * Providing a `PendingChangesComponent`.
+ */
+export class PendingChangesGuard {
+    constructor(pendingChanges) {
+        this.pendingChanges = pendingChanges;
+    }
+    canDeactivate(component) {
+        // if there are no pending changes, just allow deactivation; else confirm first
+        return !this.pendingChanges.check(component);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: PendingChangesGuard, deps: [{ token: i1.PendingChangesService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: PendingChangesGuard, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: PendingChangesGuard, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.PendingChangesService }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGVuZGluZy1jaGFuZ2VzLWd1YXJkLnNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL3l1dXZpcy9jbGllbnQtY29yZS9zcmMvbGliL3NlcnZpY2UvcGVuZGluZy1jaGFuZ2VzL3BlbmRpbmctY2hhbmdlcy1ndWFyZC5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFHM0MsT0FBTyxFQUFFLHFCQUFxQixFQUFFLE1BQU0sMkJBQTJCLENBQUM7OztBQUNsRTs7R0FFRztBQUlILE1BQU0sT0FBTyxtQkFBbUI7SUFDOUIsWUFBb0IsY0FBcUM7UUFBckMsbUJBQWMsR0FBZCxjQUFjLENBQXVCO0lBQUcsQ0FBQztJQUU3RCxhQUFhLENBQUMsU0FBa0M7UUFDOUMsK0VBQStFO1FBQy9FLE9BQU8sQ0FBQyxJQUFJLENBQUMsY0FBYyxDQUFDLEtBQUssQ0FBQyxTQUFTLENBQUMsQ0FBQztJQUMvQyxDQUFDOytHQU5VLG1CQUFtQjttSEFBbkIsbUJBQW1CLGNBRmxCLE1BQU07OzRGQUVQLG1CQUFtQjtrQkFIL0IsVUFBVTttQkFBQztvQkFDVixVQUFVLEVBQUUsTUFBTTtpQkFDbkIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBDYW5EZWFjdGl2YXRlIH0gZnJvbSAnQGFuZ3VsYXIvcm91dGVyJztcbmltcG9ydCB7IFBlbmRpbmdDaGFuZ2VzQ29tcG9uZW50IH0gZnJvbSAnLi9wZW5kaW5nLWNoYW5nZXMtY29tcG9uZW50LmludGVyZmFjZSc7XG5pbXBvcnQgeyBQZW5kaW5nQ2hhbmdlc1NlcnZpY2UgfSBmcm9tICcuL3BlbmRpbmctY2hhbmdlcy5zZXJ2aWNlJztcbi8qKlxuICogUHJvdmlkaW5nIGEgYFBlbmRpbmdDaGFuZ2VzQ29tcG9uZW50YC5cbiAqL1xuQEluamVjdGFibGUoe1xuICBwcm92aWRlZEluOiAncm9vdCdcbn0pXG5leHBvcnQgY2xhc3MgUGVuZGluZ0NoYW5nZXNHdWFyZCBpbXBsZW1lbnRzIENhbkRlYWN0aXZhdGU8UGVuZGluZ0NoYW5nZXNDb21wb25lbnQ+IHtcbiAgY29uc3RydWN0b3IocHJpdmF0ZSBwZW5kaW5nQ2hhbmdlczogUGVuZGluZ0NoYW5nZXNTZXJ2aWNlKSB7fVxuXG4gIGNhbkRlYWN0aXZhdGUoY29tcG9uZW50OiBQZW5kaW5nQ2hhbmdlc0NvbXBvbmVudCk6IGJvb2xlYW4ge1xuICAgIC8vIGlmIHRoZXJlIGFyZSBubyBwZW5kaW5nIGNoYW5nZXMsIGp1c3QgYWxsb3cgZGVhY3RpdmF0aW9uOyBlbHNlIGNvbmZpcm0gZmlyc3RcbiAgICByZXR1cm4gIXRoaXMucGVuZGluZ0NoYW5nZXMuY2hlY2soY29tcG9uZW50KTtcbiAgfVxufVxuIl19