@yuuvis/client-shell-core 0.6.5

package/esm2022/lib/services/shell/shell.service.mjs

@@ -0,0 +1,295 @@
+import { inject, Injectable, signal } from '@angular/core';
+import { BaseObjectTypeField, DmsService, SystemService, TranslateService, UserService, Utils } from '@yuuvis/client-core';
+import { YvcOverlayService } from '@yuuvis/components/overlay';
+import { BehaviorSubject, debounceTime, filter, fromEvent, map, of, ReplaySubject, switchMap } from 'rxjs';
+import { CLIENT_SHELL_ASSETS } from '../../client-shell.assets';
+import * as i0 from "@angular/core";
+export class ShellService {
+    constructor() {
+        this.#dmsService = inject(DmsService);
+        this.#overlay = inject(YvcOverlayService);
+        this.#system = inject(SystemService);
+        this.#userService = inject(UserService);
+        this.translate = inject(TranslateService);
+        this._busyCount = 0;
+        this.isBusySubject = new BehaviorSubject(false);
+        this.isBusy$ = this.isBusySubject.asObservable().pipe(debounceTime(500));
+        this.#appSettings = {};
+        this.#appSettingsSubject = new ReplaySubject();
+        this.appSettings$ = this.#appSettingsSubject.asObservable().pipe(debounceTime(500));
+        this.#appSchemata = [];
+        this.appBaseRoutes = {};
+        this.#defaultShellConfig = {
+            icons: {
+                appIcon: CLIENT_SHELL_ASSETS.icons?.appIcon,
+                logout: CLIENT_SHELL_ASSETS.icons?.logout,
+                settings: CLIENT_SHELL_ASSETS.icons?.settings,
+                notifications: CLIENT_SHELL_ASSETS.icons?.notifications
+            }
+        };
+        this.shellConfig = signal(this.#defaultShellConfig);
+        /** TODO: implement this feature ????
+         * Global shortcuts are captured by the shell to provide a consistent experience
+         * accross all apps. Search is one example. Apps should not define their own shourtcuts
+         * for search. Instead they should subscribe to the global shortcuts and initialize their
+         * search based on the global search shortcut.
+         */
+        this.globalShortcuts$ = fromEvent(document, 'keydown').pipe(map((e) => {
+            // global shortcut for search
+            // if (e.ctrlKey && e.code === 'KeyF') {
+            //   e.preventDefault();
+            //   return GlobalShortcut.search;
+            // }
+            return undefined;
+        }), filter((s) => s !== undefined), map((s) => s));
+        this._extensions = {};
+        this._objectFlavors = [];
+        this._objectCreateFlavors = [];
+    }
+    #dmsService;
+    #overlay;
+    #system;
+    #userService;
+    #appSettings;
+    #appSettingsSubject;
+    #appSchemata;
+    #defaultShellConfig;
+    setShellConfig(csc) {
+        this.shellConfig.update((sc) => ({
+            icons: {
+                appIcon: csc.icons?.appIcon ?? sc.icons?.appIcon,
+                logout: csc.icons?.logout ?? sc.icons?.logout,
+                settings: csc.icons?.settings ?? sc.icons?.settings,
+                notifications: csc.icons?.settings ?? sc.icons?.notifications
+            }
+        }));
+    }
+    setAppBaseRoutes(apps) {
+        apps.forEach((a) => (this.appBaseRoutes[a.id] = a.path || ''));
+    }
+    registerApp(schema) {
+        this.#appSchemata.push(schema);
+    }
+    getRegisteredApp(id) {
+        return this.#appSchemata.find((a) => a.id === id);
+    }
+    /**
+     * Register settings for apps to hook into shell settings page.
+     * These exposed settings will be saved in the users settings on the backend.
+     * @param appID ID of the app that exposes the settings
+     * @param cfg ShellAppSettings object containing the settings
+     */
+    registerAppSettings(appID, cfg) {
+        this.#appSettings[appID] = cfg;
+        this.#appSettingsSubject.next(this.#getAppSettings());
+    }
+    /**
+     * Load persisted settings for a specific app
+     * @param appID ID of the app to load the settings for
+     */
+    usersAppSettings$(appID) {
+        return this.#userService.user$.pipe(map((u) => {
+            return u && u.userSettings.clientAppSettings ? u.userSettings.clientAppSettings[appID] : undefined;
+        }));
+    }
+    saveUsersAppSettings(appID, settings) {
+        return this.#userService.saveUserSettings({ clientAppSettings: { [appID]: settings } });
+    }
+    #getAppSettings() {
+        return Object.keys(this.#appSettings)
+            .map((key) => ({
+            appID: this.#appSettings[key].appID,
+            label: this.#appSettings[key].label,
+            properties: this.#appSettings[key].properties
+        }))
+            .sort();
+    }
+    addBusy() {
+        if (this._busyCount === 0) {
+            this.isBusySubject.next(true);
+        }
+        this._busyCount++;
+    }
+    removeBusy() {
+        this._busyCount--;
+        if (this._busyCount === 0) {
+            this.isBusySubject.next(false);
+        }
+    }
+    exposeObjectCreateFlavors(flavors) {
+        flavors.forEach((flavor) => {
+            const idx = this._objectCreateFlavors.findIndex((f) => f.id === flavor.id);
+            if (idx === -1)
+                this._objectCreateFlavors.push(flavor);
+        });
+    }
+    concealObjectCreateFlavors(flavors) {
+        const fid = flavors.map((f) => f.id);
+        this._objectCreateFlavors = this._objectCreateFlavors.filter((f) => !fid.includes(f.id));
+    }
+    getObjectCreateFlavors() {
+        return this._objectCreateFlavors;
+    }
+    /**
+     * Exposes a list of object flavors to the shell.
+     * Flavors are able to be applied to objects and add new metadata properties to them.
+     * @param flavors Array of flavors to be exposed
+     * @param app Optional ID of the app that exposes the flavors (defaults to 'global' if not provided)
+     */
+    exposeObjectFlavors(flavors, app = 'global') {
+        flavors.forEach((f) => this.exposeObjectFlavor(f, app));
+    }
+    /**
+     * Removes exposed object flavors from the shell.
+     * @param flavors Array of flavors to be concealed
+     */
+    concealObjectFlavors(flavors, app = 'global') {
+        flavors.forEach((f) => this.concealObjectFlavor(f, app));
+    }
+    /**
+     * Exposes an object flavor to the shell. Flavors are able to be applied to objects
+     * in order to add a new aspect to them. An object containing an image for example could
+     * be added a flavor of 'EXIF Data' that will add the corresponding SOT to it. This way the
+     * object gets new metadata properties. If supported, these metadata could even be extracted
+     * from the file and filled out automatically.
+     * @param flavor The flavor object to be exposed
+     * @param app Optional ID of the app that exposes the flavor (defaults to 'global' if not provided)
+     */
+    exposeObjectFlavor(flavor, app = 'global') {
+        const idx = this._objectFlavors.findIndex((f) => f.id === flavor.id && f.app === app);
+        if (idx === -1)
+            this._objectFlavors.push({ ...flavor, app });
+    }
+    /**
+     * Removes an exposed object flavor from the shell.
+     * @param flavor Flavor to be concealed
+     * @param app Optional ID of the app that exposes the flavor (defaults to 'global' if not provided)
+     */
+    concealObjectFlavor(flavor, app = 'global') {
+        this._objectFlavors = this._objectFlavors.filter((f) => f.id !== flavor.id && f.app !== app);
+    }
+    /**
+     * Get registered object flavors
+     * @param app Optional app ID that restricts the returned flavors to the ones
+     * provided by a particular app. If not provided all flavors are returned
+     * @returns Array of matching object flavors
+     */
+    getObjectFlavors(app) {
+        return app ? this._objectFlavors.filter((of) => of.app === app) : this._objectFlavors;
+    }
+    /**
+     * Triggers the application of an object flavor. If the flavor has an applyComponent
+     * defined, the overlay will be opened with the component. Otherwise the flavor will
+     * be applied directly to the object.
+     * @param dmsObject The object to apply the flavor to
+     * @param flavor The flavor to apply
+     * @param data Optional data to be passed to the flavor component
+     * @returns Observable that emits true if the flavor was applied successfully
+     */
+    triggerApplyObjectFlavor(dmsObject, flavor, data) {
+        if (dmsObject) {
+            if (flavor.applyComponent) {
+                this.#overlay.open(flavor.applyComponent, {
+                    dmsObject,
+                    flavor,
+                    data
+                });
+                return of(true);
+            }
+            else {
+                const sots = dmsObject.data[BaseObjectTypeField.SECONDARY_OBJECT_TYPE_IDS] || [];
+                const data = {};
+                data[BaseObjectTypeField.SECONDARY_OBJECT_TYPE_IDS] = [...sots, flavor.sot];
+                return this.#dmsService.updateDmsObject(dmsObject?.id, data).pipe(map(() => true));
+            }
+        }
+        else
+            return of(false);
+    }
+    removeObjectFlavor(dmsObject, flavor) {
+        return this.#overlay
+            .confirm({
+            message: this.translate.instant('yuv.shell.flavor.remove.confirm.message', {
+                flavor: this.translate.instant(flavor.id)
+            })
+        })
+            .pipe(switchMap((confirmed) => {
+            if (confirmed) {
+                // remove SOT ...
+                const data = {
+                    [BaseObjectTypeField.SECONDARY_OBJECT_TYPE_IDS]: dmsObject.data[BaseObjectTypeField.SECONDARY_OBJECT_TYPE_IDS].filter((sot) => sot !== flavor.sot)
+                };
+                // ... and all the properties that came with it
+                this.#system.getSecondaryObjectType(flavor.sot)?.fields.forEach((p) => {
+                    data[p.id] = null;
+                });
+                return this.#dmsService.updateDmsObject(dmsObject.id, data).pipe(map(() => true));
+            }
+            else
+                return of(false);
+        }));
+    }
+    /**
+     * Get object flavors applicable for a certain mimetype
+     * @param mimeType Mime type or mime type pattern like 'image/*'
+     * @param app Optional app ID that restricts the returned flavors to the ones
+     * provided by a particular app
+     * @param customFlavors Optional array of custom flavors to also take into account.
+     * This could be flavors managed by an app itself that are not supposed to be
+     * exposed to other apps
+     * @returns Array of matching object flavors
+     */
+    getApplicableObjectFlavors(mimeType, app, customFlavors) {
+        return [...(customFlavors || []), ...this._objectFlavors].filter((of) => of.applicableTo?.mimeTypes.some((mtp) => Utils.patternToRegExp(mtp).test(mimeType)) && (!app || of.app === app));
+    }
+    /**
+     * Get applied and applicable object flavors for a certain object
+     * @param dmsObject DmsObject to get flavors for
+     * @returns Object containing two arrays: applied and applicable flavors
+     */
+    getAppliedObjectFlavors(dmsObject) {
+        const applied = [];
+        const applicable = [];
+        if (dmsObject) {
+            const sots = dmsObject.data[BaseObjectTypeField.SECONDARY_OBJECT_TYPE_IDS] || [];
+            if (dmsObject.content) {
+                this.getApplicableObjectFlavors(dmsObject.content.mimeType).forEach((flavor) => {
+                    if (sots.includes(flavor.sot)) {
+                        applied.push(flavor);
+                    }
+                    else {
+                        applicable.push(flavor);
+                    }
+                });
+            }
+        }
+        return { applied, applicable };
+    }
+    applyObjectFlavor(dmsObject, flavor, data = {}) {
+        const sots = dmsObject.data[BaseObjectTypeField.SECONDARY_OBJECT_TYPE_IDS] || [];
+        data[BaseObjectTypeField.SECONDARY_OBJECT_TYPE_IDS] = [...sots, flavor.sot];
+        return this.#dmsService.updateDmsObject(dmsObject.id, data);
+    }
+    registerTileExtension(ext) {
+        this._extensions[ext.typeId] = ext;
+    }
+    /**
+     * Get tile extensions for a certain type
+     * @param typeId ID of the type to fetch extesion for (objectTypeID or secondaryObjectTypeID)
+     * @returns
+     */
+    getRegisteredTileExtensions() {
+        return this._extensions;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
+    _init() { }
+    static { this.ɵfac = function ShellService_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || ShellService)(); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: ShellService, factory: ShellService.ɵfac, providedIn: 'root' }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ShellService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root'
+            }]
+    }], null, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"shell.service.js","sourceRoot":"","sources":["../../../../../../../../libs/yuuvis/client-shell-core/src/lib/services/shell/shell.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { inject, Injectable, signal } from '@angular/core';\nimport {\n  BaseObjectTypeField,\n  DmsObject,\n  DmsService,\n  ObjectCreateFlavor,\n  SystemService,\n  TranslateService,\n  UserService,\n  Utils,\n  YuvUser\n} from '@yuuvis/client-core';\nimport { YvcOverlayService } from '@yuuvis/components/overlay';\nimport { BehaviorSubject, debounceTime, filter, fromEvent, map, Observable, of, ReplaySubject, switchMap } from 'rxjs';\nimport { CLIENT_SHELL_ASSETS } from '../../client-shell.assets';\nimport { App, AppSchema, AppSchemaFlavor, ClientShellConfig, GlobalShortcut, ObjectFlavor, ShellAppSettings } from '../../client-shell.interface';\nimport { TileExtension } from '../../tile-extension.interface';\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class ShellService {\n  #dmsService = inject(DmsService);\n  #overlay = inject(YvcOverlayService);\n  #system = inject(SystemService);\n  #userService = inject(UserService);\n  private translate = inject(TranslateService);\n\n  private _busyCount = 0;\n  private isBusySubject = new BehaviorSubject<boolean>(false);\n  isBusy$ = this.isBusySubject.asObservable().pipe(debounceTime(500));\n\n  #appSettings: Record<string, ShellAppSettings> = {};\n  #appSettingsSubject = new ReplaySubject<ShellAppSettings[]>();\n  appSettings$ = this.#appSettingsSubject.asObservable().pipe(debounceTime(500));\n\n  #appSchemata: AppSchema[] = [];\n  appBaseRoutes: Record<string, string> = {};\n\n  #defaultShellConfig: ClientShellConfig = {\n    icons: {\n      appIcon: CLIENT_SHELL_ASSETS.icons?.appIcon,\n      logout: CLIENT_SHELL_ASSETS.icons?.logout,\n      settings: CLIENT_SHELL_ASSETS.icons?.settings,\n      notifications: CLIENT_SHELL_ASSETS.icons?.notifications\n    }\n  };\n  shellConfig = signal<ClientShellConfig>(this.#defaultShellConfig);\n\n  /** TODO: implement this feature ????\n   * Global shortcuts are captured by the shell to provide a consistent experience\n   * accross all apps. Search is one example. Apps should not define their own shourtcuts\n   * for search. Instead they should subscribe to the global shortcuts and initialize their\n   * search based on the global search shortcut.\n   */\n  globalShortcuts$: Observable<GlobalShortcut> = fromEvent<KeyboardEvent>(document, 'keydown').pipe(\n    map((e: KeyboardEvent) => {\n      // global shortcut for search\n      // if (e.ctrlKey && e.code === 'KeyF') {\n      //   e.preventDefault();\n      //   return GlobalShortcut.search;\n      // }\n      return undefined;\n    }),\n    filter((s: GlobalShortcut | undefined) => s !== undefined),\n    map((s) => s as GlobalShortcut)\n  );\n\n  private _extensions: Record<string, TileExtension> = {};\n  private _objectFlavors: ObjectFlavor[] = [];\n  private _objectCreateFlavors: ObjectCreateFlavor[] = [];\n\n  setShellConfig(csc: ClientShellConfig) {\n    this.shellConfig.update((sc) => ({\n      icons: {\n        appIcon: csc.icons?.appIcon ?? sc.icons?.appIcon,\n        logout: csc.icons?.logout ?? sc.icons?.logout,\n        settings: csc.icons?.settings ?? sc.icons?.settings,\n        notifications: csc.icons?.settings ?? sc.icons?.notifications\n      }\n    }));\n  }\n\n  setAppBaseRoutes(apps: App[]) {\n    apps.forEach((a) => (this.appBaseRoutes[a.id] = a.path || ''));\n  }\n\n  registerApp(schema: AppSchema) {\n    this.#appSchemata.push(schema);\n  }\n\n  getRegisteredApp(id: string): AppSchema | undefined {\n    return this.#appSchemata.find((a) => a.id === id);\n  }\n\n  /**\n   * Register settings for apps to hook into shell settings page.\n   * These exposed settings will be saved in the users settings on the backend.\n   * @param appID ID of the app that exposes the settings\n   * @param cfg ShellAppSettings object containing the settings\n   */\n  registerAppSettings(appID: string, cfg: ShellAppSettings) {\n    this.#appSettings[appID] = cfg;\n    this.#appSettingsSubject.next(this.#getAppSettings());\n  }\n\n  /**\n   * Load persisted settings for a specific app\n   * @param appID ID of the app to load the settings for\n   */\n  usersAppSettings$(appID: string): Observable<ShellAppSettings | undefined> {\n    return this.#userService.user$.pipe(\n      map((u: YuvUser | undefined) => {\n        return u && u.userSettings.clientAppSettings ? u.userSettings.clientAppSettings[appID] : undefined;\n      })\n    );\n  }\n\n  saveUsersAppSettings(appID: string, settings: ShellAppSettings): Observable<any> {\n    return this.#userService.saveUserSettings({ clientAppSettings: { [appID]: settings } });\n  }\n\n  #getAppSettings(): ShellAppSettings[] {\n    return Object.keys(this.#appSettings)\n      .map((key: string) => ({\n        appID: this.#appSettings[key].appID,\n        label: this.#appSettings[key].label,\n        properties: this.#appSettings[key].properties\n      }))\n      .sort();\n  }\n\n  addBusy() {\n    if (this._busyCount === 0) {\n      this.isBusySubject.next(true);\n    }\n    this._busyCount++;\n  }\n  removeBusy() {\n    this._busyCount--;\n    if (this._busyCount === 0) {\n      this.isBusySubject.next(false);\n    }\n  }\n\n  exposeObjectCreateFlavors(flavors: ObjectCreateFlavor[]) {\n    flavors.forEach((flavor: ObjectCreateFlavor) => {\n      const idx = this._objectCreateFlavors.findIndex((f) => f.id === flavor.id);\n      if (idx === -1) this._objectCreateFlavors.push(flavor);\n    });\n  }\n\n  concealObjectCreateFlavors(flavors: ObjectCreateFlavor[]) {\n    const fid = flavors.map((f) => f.id);\n    this._objectCreateFlavors = this._objectCreateFlavors.filter((f) => !fid.includes(f.id));\n  }\n\n  getObjectCreateFlavors(): ObjectCreateFlavor[] {\n    return this._objectCreateFlavors;\n  }\n\n  /**\n   * Exposes a list of object flavors to the shell.\n   * Flavors are able to be applied to objects and add new metadata properties to them.\n   * @param flavors Array of flavors to be exposed\n   * @param app Optional ID of the app that exposes the flavors (defaults to 'global' if not provided)\n   */\n  exposeObjectFlavors(flavors: AppSchemaFlavor[], app = 'global') {\n    flavors.forEach((f) => this.exposeObjectFlavor(f, app));\n  }\n\n  /**\n   * Removes exposed object flavors from the shell.\n   * @param flavors Array of flavors to be concealed\n   */\n  concealObjectFlavors(flavors: AppSchemaFlavor[], app = 'global') {\n    flavors.forEach((f) => this.concealObjectFlavor(f, app));\n  }\n\n  /**\n   * Exposes an object flavor to the shell. Flavors are able to be applied to objects\n   * in order to add a new aspect to them. An object containing an image for example could\n   * be added a flavor of 'EXIF Data' that will add the corresponding SOT to it. This way the\n   * object gets new metadata properties. If supported, these metadata could even be extracted\n   * from the file and filled out automatically.\n   * @param flavor The flavor object to be exposed\n   * @param app Optional ID of the app that exposes the flavor (defaults to 'global' if not provided)\n   */\n  exposeObjectFlavor(flavor: AppSchemaFlavor, app = 'global') {\n    const idx = this._objectFlavors.findIndex((f) => f.id === flavor.id && f.app === app);\n    if (idx === -1) this._objectFlavors.push({ ...flavor, app });\n  }\n\n  /**\n   * Removes an exposed object flavor from the shell.\n   * @param flavor Flavor to be concealed\n   * @param app Optional ID of the app that exposes the flavor (defaults to 'global' if not provided)\n   */\n  concealObjectFlavor(flavor: AppSchemaFlavor, app = 'global') {\n    this._objectFlavors = this._objectFlavors.filter((f) => f.id !== flavor.id && f.app !== app);\n  }\n\n  /**\n   * Get registered object flavors\n   * @param app Optional app ID that restricts the returned flavors to the ones\n   * provided by a particular app. If not provided all flavors are returned\n   * @returns Array of matching object flavors\n   */\n  getObjectFlavors(app?: string): ObjectFlavor[] {\n    return app ? this._objectFlavors.filter((of) => of.app === app) : this._objectFlavors;\n  }\n\n  /**\n   * Triggers the application of an object flavor. If the flavor has an applyComponent\n   * defined, the overlay will be opened with the component. Otherwise the flavor will\n   * be applied directly to the object.\n   * @param dmsObject The object to apply the flavor to\n   * @param flavor The flavor to apply\n   * @param data Optional data to be passed to the flavor component\n   * @returns Observable that emits true if the flavor was applied successfully\n   */\n  triggerApplyObjectFlavor(dmsObject: DmsObject, flavor: ObjectFlavor, data?: any): Observable<boolean> {\n    if (dmsObject) {\n      if (flavor.applyComponent) {\n        this.#overlay.open(flavor.applyComponent, {\n          dmsObject,\n          flavor,\n          data\n        });\n        return of(true);\n      } else {\n        const sots: string[] = (dmsObject.data[BaseObjectTypeField.SECONDARY_OBJECT_TYPE_IDS] as string[]) || [];\n        const data: any = {};\n        data[BaseObjectTypeField.SECONDARY_OBJECT_TYPE_IDS] = [...sots, flavor.sot];\n        return this.#dmsService.updateDmsObject(dmsObject?.id, data).pipe(map(() => true));\n      }\n    } else return of(false);\n  }\n\n  removeObjectFlavor(dmsObject: DmsObject, flavor: ObjectFlavor): Observable<any> {\n    return this.#overlay\n      .confirm({\n        message: this.translate.instant('yuv.shell.flavor.remove.confirm.message', {\n          flavor: this.translate.instant(flavor.id)\n        })\n      })\n      .pipe(\n        switchMap((confirmed: boolean) => {\n          if (confirmed) {\n            // remove SOT ...\n            const data: Record<string, unknown> = {\n              [BaseObjectTypeField.SECONDARY_OBJECT_TYPE_IDS]: (dmsObject.data[BaseObjectTypeField.SECONDARY_OBJECT_TYPE_IDS] as string[]).filter(\n                (sot: string) => sot !== flavor.sot\n              )\n            };\n            // ... and all the properties that came with it\n            this.#system.getSecondaryObjectType(flavor.sot)?.fields.forEach((p) => {\n              data[p.id] = null;\n            });\n\n            return this.#dmsService.updateDmsObject(dmsObject.id, data).pipe(map(() => true));\n          } else return of(false);\n        })\n      );\n  }\n\n  /**\n   * Get object flavors applicable for a certain mimetype\n   * @param mimeType Mime type or mime type pattern like 'image/*'\n   * @param app Optional app ID that restricts the returned flavors to the ones\n   * provided by a particular app\n   * @param customFlavors Optional array of custom flavors to also take into account.\n   * This could be flavors managed by an app itself that are not supposed to be\n   * exposed to other apps\n   * @returns Array of matching object flavors\n   */\n  getApplicableObjectFlavors(mimeType: string, app?: string, customFlavors?: ObjectFlavor[]): ObjectFlavor[] {\n    return [...(customFlavors || []), ...this._objectFlavors].filter(\n      (of: ObjectFlavor) => of.applicableTo?.mimeTypes.some((mtp) => Utils.patternToRegExp(mtp).test(mimeType)) && (!app || of.app === app)\n    );\n  }\n\n  /**\n   * Get applied and applicable object flavors for a certain object\n   * @param dmsObject DmsObject to get flavors for\n   * @returns Object containing two arrays: applied and applicable flavors\n   */\n  getAppliedObjectFlavors(dmsObject: DmsObject): {\n    applied: ObjectFlavor[];\n    applicable: ObjectFlavor[];\n  } {\n    const applied: ObjectFlavor[] = [];\n    const applicable: ObjectFlavor[] = [];\n    if (dmsObject) {\n      const sots: string[] = (dmsObject.data[BaseObjectTypeField.SECONDARY_OBJECT_TYPE_IDS] as string[]) || [];\n      if (dmsObject.content) {\n        this.getApplicableObjectFlavors(dmsObject.content.mimeType).forEach((flavor: ObjectFlavor) => {\n          if (sots.includes(flavor.sot)) {\n            applied.push(flavor);\n          } else {\n            applicable.push(flavor);\n          }\n        });\n      }\n    }\n    return { applied, applicable };\n  }\n\n  applyObjectFlavor(dmsObject: DmsObject, flavor: ObjectFlavor, data: Record<string, unknown> = {}): Observable<DmsObject> {\n    const sots: string[] = (dmsObject.data[BaseObjectTypeField.SECONDARY_OBJECT_TYPE_IDS] as string[]) || [];\n    data[BaseObjectTypeField.SECONDARY_OBJECT_TYPE_IDS] = [...sots, flavor.sot];\n    return this.#dmsService.updateDmsObject(dmsObject.id, data);\n  }\n\n  registerTileExtension(ext: TileExtension) {\n    this._extensions[ext.typeId] = ext;\n  }\n\n  /**\n   * Get tile extensions for a certain type\n   * @param typeId ID of the type to fetch extesion for (objectTypeID or secondaryObjectTypeID)\n   * @returns\n   */\n  getRegisteredTileExtensions(): Record<string, TileExtension> {\n    return this._extensions;\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-empty-function\n  _init() {}\n}\n"]}

package/esm2022/lib/services/shell-notifications/shell-notifications.interface.mjs

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

package/esm2022/lib/services/shell-notifications/shell-notifications.service.mjs

@@ -0,0 +1,89 @@
+import { Injectable, inject } from '@angular/core';
+import { ReplaySubject } from 'rxjs';
+import { AppCacheService, NativeNotificationService, TranslateService, Utils } from '@yuuvis/client-core';
+import { ShellService } from '../shell/shell.service';
+import { Router } from '@angular/router';
+import * as i0 from "@angular/core";
+/**
+ * Service managing shell notifications.
+ * Every app could propagate shell notifications. They will be published
+ * in the notifications section of the shell. Incoming new messahes will
+ * also add an indicator to the icon in the shell bar.
+ *
+ */
+export class ShellNotificationsService {
+    #shell;
+    #router;
+    #nativeNotificationService;
+    constructor() {
+        this.LOCAL_STORAGE_KEY = 'yuv.shell.notifications';
+        this.appCache = inject(AppCacheService);
+        this.#shell = inject(ShellService);
+        this.#router = inject(Router);
+        this.translate = inject(TranslateService);
+        this.#nativeNotificationService = inject(NativeNotificationService);
+        this._notifications = [];
+        this._notificationsSource = new ReplaySubject();
+        this.shellNotifications$ = this._notificationsSource.asObservable();
+        this.appCache.getItem(this.LOCAL_STORAGE_KEY).subscribe((res) => {
+            this._notifications = res || [];
+            this._notificationsSource.next(this._notifications);
+        });
+    }
+    // getNotifications(id: string) {
+    //   const file = [
+    //     { id: 'io.yuuvis.app.drive', count: 2, maxLevel: 'info' },
+    //     { id: 'io.yuuvis.app.tasks', count: 222, maxLevel: 'warning' }
+    //   ];
+    //   return file.find((f) => f.id === id);
+    // }
+    add(notification, nativeNotification = false) {
+        this._notifications.push({
+            ...notification,
+            id: Utils.uuid(),
+            timestamp: new Date().getTime(),
+            seen: false
+        });
+        // check for unseen items
+        if (document.hidden && nativeNotification && this._notifications.some((n) => !n.seen)) {
+            this.#nativeNotificationService.showNotification(this.translate.instant('yuv.shell.notification.native.title'), {
+                onClick: () => this.#router.navigate([{ outlets: { aside: 'notifications' } }]),
+                options: {
+                    body: this.translate.instant('yuv.shell.notification.native.message'),
+                    // badge: this.#shell.shellConfig().icons!.appIcon,
+                    icon: 'https://budgie.enaioci.net/client/assets/_yuuvis/theme/favicon.svg'
+                }
+            });
+        }
+        this._updateNotifications();
+    }
+    remove(id) {
+        this._notifications = this._notifications.filter((n) => n.id !== id);
+        this._updateNotifications();
+    }
+    removeAll() {
+        this._notifications = [];
+        this._updateNotifications();
+    }
+    markAllAsSeen() {
+        this._notifications.forEach((n) => (n.seen = true));
+        this._updateNotifications();
+    }
+    getNotificationById(id) {
+        return this._notifications.find((n) => n.id === id);
+    }
+    _updateNotifications() {
+        this._notifications = this._notifications.sort((a, b) => b.timestamp - a.timestamp);
+        this._notificationsSource.next(this._notifications);
+        this.appCache.setItem(this.LOCAL_STORAGE_KEY, this._notifications).subscribe();
+    }
+    static { this.ɵfac = function ShellNotificationsService_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || ShellNotificationsService)(); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: ShellNotificationsService, factory: ShellNotificationsService.ɵfac, providedIn: 'root' }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ShellNotificationsService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root'
+            }]
+    }], () => [], null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"shell-notifications.service.js","sourceRoot":"","sources":["../../../../../../../../libs/yuuvis/client-shell-core/src/lib/services/shell-notifications/shell-notifications.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, inject } from '@angular/core';\nimport { ShellNotification } from './shell-notifications.interface';\nimport { Observable, ReplaySubject } from 'rxjs';\nimport { AppCacheService, NativeNotificationService, TranslateService, Utils } from '@yuuvis/client-core';\nimport { ShellService } from '../shell/shell.service';\nimport { Router } from '@angular/router';\n\n/**\n * Service managing shell notifications.\n * Every app could propagate shell notifications. They will be published\n * in the notifications section of the shell. Incoming new messahes will\n * also add an indicator to the icon in the shell bar.\n *\n */\n@Injectable({\n  providedIn: 'root'\n})\nexport class ShellNotificationsService {\n  private LOCAL_STORAGE_KEY = 'yuv.shell.notifications';\n  private appCache = inject(AppCacheService);\n  #shell = inject(ShellService);\n  #router = inject(Router);\n  private translate = inject(TranslateService);\n  #nativeNotificationService = inject(NativeNotificationService);\n\n  private _notifications: ShellNotificationItem[] = [];\n  private _notificationsSource = new ReplaySubject<ShellNotificationItem[]>();\n  shellNotifications$: Observable<ShellNotificationItem[]> = this._notificationsSource.asObservable();\n\n  constructor() {\n    this.appCache.getItem(this.LOCAL_STORAGE_KEY).subscribe((res) => {\n      this._notifications = res || [];\n      this._notificationsSource.next(this._notifications);\n    });\n  }\n\n  // getNotifications(id: string) {\n  //   const file = [\n  //     { id: 'io.yuuvis.app.drive', count: 2, maxLevel: 'info' },\n  //     { id: 'io.yuuvis.app.tasks', count: 222, maxLevel: 'warning' }\n  //   ];\n\n  //   return file.find((f) => f.id === id);\n  // }\n\n  add(notification: ShellNotification, nativeNotification = false) {\n    this._notifications.push({\n      ...notification,\n      id: Utils.uuid(),\n      timestamp: new Date().getTime(),\n      seen: false\n    });\n    // check for unseen items\n    if (document.hidden && nativeNotification && this._notifications.some((n) => !n.seen)) {\n      this.#nativeNotificationService.showNotification(this.translate.instant('yuv.shell.notification.native.title'), {\n        onClick: () => this.#router.navigate([{ outlets: { aside: 'notifications' } }]),\n        options: {\n          body: this.translate.instant('yuv.shell.notification.native.message'),\n          // badge: this.#shell.shellConfig().icons!.appIcon,\n          icon: 'https://budgie.enaioci.net/client/assets/_yuuvis/theme/favicon.svg'\n        }\n      });\n    }\n    this._updateNotifications();\n  }\n\n  remove(id: string) {\n    this._notifications = this._notifications.filter((n) => n.id !== id);\n    this._updateNotifications();\n  }\n\n  removeAll() {\n    this._notifications = [];\n    this._updateNotifications();\n  }\n\n  markAllAsSeen() {\n    this._notifications.forEach((n) => (n.seen = true));\n    this._updateNotifications();\n  }\n\n  getNotificationById(id: string): ShellNotificationItem | undefined {\n    return this._notifications.find((n) => n.id === id);\n  }\n\n  private _updateNotifications() {\n    this._notifications = this._notifications.sort((a, b) => b.timestamp - a.timestamp);\n    this._notificationsSource.next(this._notifications);\n    this.appCache.setItem(this.LOCAL_STORAGE_KEY, this._notifications).subscribe();\n  }\n}\n\ntype ShellNotificationItem = ShellNotification & {\n  id: string;\n  timestamp: number;\n  seen: boolean;\n};\n"]}

package/esm2022/lib/tile-extension.interface.mjs

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

package/esm2022/yuuvis-client-shell-core.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoieXV1dmlzLWNsaWVudC1zaGVsbC1jb3JlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vbGlicy95dXV2aXMvY2xpZW50LXNoZWxsLWNvcmUvc3JjL3l1dXZpcy1jbGllbnQtc2hlbGwtY29yZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsU0FBUyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL2luZGV4JztcbiJdfQ==

package/index.d.ts

@@ -0,0 +1,9 @@
+export * from './lib/client-shell.interface';
+export * from './lib/services/command-palette/command-palette.interface';
+export * from './lib/services/command-palette/command-palette.service';
+export * from './lib/services/command-palette/command-palette/command-palette.component';
+export * from './lib/services/shell-notifications/shell-notifications.interface';
+export * from './lib/services/shell-notifications/shell-notifications.service';
+export * from './lib/services/shell/shell.service';
+export * from './lib/tile-extension.interface';
+export * from './lib/services/shell/shell.extentions.service';

package/lib/client-shell.assets.d.ts

@@ -0,0 +1,8 @@
+export declare const CLIENT_SHELL_ASSETS: {
+    icons: {
+        appIcon: string;
+        settings: string;
+        logout: string;
+        notifications: string;
+    };
+};

package/lib/client-shell.interface.d.ts

@@ -0,0 +1,55 @@
+import { Type } from '@angular/core';
+import { Route } from '@angular/router';
+import { ObjectCreateFlavor, ObjectTypeFlavor, VirtualObjectType } from '@yuuvis/client-core';
+export interface ClientShellConfig {
+    icons?: {
+        appIcon?: string;
+        logout?: string;
+        settings?: string;
+        notifications?: string;
+    };
+}
+export interface App extends Route {
+    id: string;
+    icon?: string;
+    permissions?: AppPermission;
+}
+export interface AppPermission {
+    allow: string[];
+    deny: string[];
+}
+export interface AccentColor {
+    label: string;
+    name: string;
+    tone: string;
+}
+export interface ShellAppSettings {
+    appID: string;
+    label: string;
+    properties: ShellAppSettingProperty[];
+}
+export interface ShellAppSettingProperty {
+    label: string;
+    name: string;
+    type: string;
+    value?: string | boolean | number;
+}
+export interface AppSchema {
+    id: string;
+    name: string;
+    icon: string;
+    types: Record<string, VirtualObjectType>;
+    flavors: AppSchemaFlavor[];
+    createFlavors?: ObjectCreateFlavor[];
+}
+export type ObjectFlavor = AppSchemaFlavor & {
+    app: string;
+};
+export interface AppSchemaFlavor extends ObjectTypeFlavor {
+    objectTypeID: string;
+    descriptionKey?: string;
+    applyComponent?: Type<any>;
+}
+export declare enum GlobalShortcut {
+    search = "search"
+}

package/lib/services/command-palette/command-palette/command-palette.component.d.ts

@@ -0,0 +1,31 @@
+import { AfterViewInit, ElementRef, EventEmitter, OnInit } from '@angular/core';
+import { CommandPaletteCommand, DisabledCause } from '../command-palette.interface';
+import { CommandPaletteService } from '../command-palette.service';
+import * as i0 from "@angular/core";
+export declare class CommandPaletteComponent implements OnInit, AfterViewInit {
+    private cmdService;
+    private elRef;
+    private _commands;
+    private _cci;
+    set currentCommandIndex(i: number);
+    get currentCommandIndex(): number;
+    commands: CommandPaletteCommand[];
+    searchTerm: string;
+    keepFocus: boolean;
+    message: string | undefined;
+    disabledCauses: DisabledCause[];
+    placeholder: string | undefined;
+    searchTermChange: EventEmitter<string>;
+    onArrowDown(e: KeyboardEvent): void;
+    onArrowUp(e: KeyboardEvent): void;
+    onEnter(): void;
+    constructor(cmdService: CommandPaletteService, elRef: ElementRef);
+    onTermChange(term: string): void;
+    onInputBlur(): void;
+    triggerCommand(command?: CommandPaletteCommand): void;
+    highlight(txt: string | undefined): string | undefined;
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CommandPaletteComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CommandPaletteComponent, "yuv-command-palette", never, {}, { "searchTermChange": "searchTermChange"; }, never, never, true, never>;
+}

package/lib/services/command-palette/command-palette.interface.d.ts

@@ -0,0 +1,16 @@
+export interface CommandPaletteModuleConfig {
+    triggerKey?: string;
+    accentColor?: string;
+    searchModeIndicator?: string;
+    placeholder?: string;
+}
+export interface CommandPaletteCommand {
+    id: string;
+    label: string;
+    description?: string;
+    callback?: () => void;
+}
+export interface DisabledCause {
+    id: string;
+    message: string;
+}

package/lib/services/command-palette/command-palette.service.d.ts

@@ -0,0 +1,41 @@
+import { Observable } from 'rxjs';
+import { CommandPaletteCommand, DisabledCause } from './command-palette.interface';
+import * as i0 from "@angular/core";
+export declare class CommandPaletteService {
+    private overlayService;
+    readonly actionKey: string;
+    private _ac;
+    private overlayRef;
+    private overlayVisible;
+    disabledCauses: DisabledCause[];
+    placeholder: string;
+    private overlayVisibleSource;
+    overlayVisible$: Observable<boolean>;
+    private commands;
+    private commandSource;
+    command$: Observable<CommandPaletteCommand>;
+    onSearchTerm: (term: string, cb: (res: CommandPaletteCommand[]) => void) => void;
+    constructor();
+    getCommands(): CommandPaletteCommand[];
+    registerCommand(command: CommandPaletteCommand): Observable<CommandPaletteCommand>;
+    registerCommands(commands: CommandPaletteCommand[]): Observable<CommandPaletteCommand>;
+    unregisterCommand(id: string): void;
+    unregisterCommands(ids: string[]): void;
+    /**
+     * Updates the properties of the registered commands. This is usefull when
+     * the language of the app changes and you want to update the commands labels.
+     * Based on the IDs propeties of the registered commands will be updated.
+     * @param cmds Commands containing the updated properties
+     */
+    updateCommands(cmds: CommandPaletteCommand[]): void;
+    triggerCommand(cmd: CommandPaletteCommand): void;
+    addDisabledCause(cause: DisabledCause): void;
+    removeDisabledCause(id: string): void;
+    removeAllDisabledCauses(): void;
+    private _processCommands;
+    private _actionKeyClick;
+    private appendComponentToBody;
+    private removeComponentFromBody;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CommandPaletteService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CommandPaletteService>;
+}

package/lib/services/shell/shell.extentions.service.d.ts

@@ -0,0 +1,2 @@
+import { EnvironmentProviders, ImportProvidersSource } from '@angular/core';
+export declare const importShellExtentions: (extentions: ImportProvidersSource[]) => EnvironmentProviders[];