@yuuvis/client-shell-core 0.6.5

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

@@ -0,0 +1,124 @@
+import { DmsObject, ObjectCreateFlavor } from '@yuuvis/client-core';
+import { Observable } from 'rxjs';
+import { App, AppSchema, AppSchemaFlavor, ClientShellConfig, GlobalShortcut, ObjectFlavor, ShellAppSettings } from '../../client-shell.interface';
+import { TileExtension } from '../../tile-extension.interface';
+import * as i0 from "@angular/core";
+export declare class ShellService {
+    #private;
+    private translate;
+    private _busyCount;
+    private isBusySubject;
+    isBusy$: Observable<boolean>;
+    appSettings$: Observable<ShellAppSettings[]>;
+    appBaseRoutes: Record<string, string>;
+    shellConfig: import("@angular/core").WritableSignal<ClientShellConfig>;
+    /** 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.
+     */
+    globalShortcuts$: Observable<GlobalShortcut>;
+    private _extensions;
+    private _objectFlavors;
+    private _objectCreateFlavors;
+    setShellConfig(csc: ClientShellConfig): void;
+    setAppBaseRoutes(apps: App[]): void;
+    registerApp(schema: AppSchema): void;
+    getRegisteredApp(id: string): AppSchema | undefined;
+    /**
+     * 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: string, cfg: ShellAppSettings): void;
+    /**
+     * Load persisted settings for a specific app
+     * @param appID ID of the app to load the settings for
+     */
+    usersAppSettings$(appID: string): Observable<ShellAppSettings | undefined>;
+    saveUsersAppSettings(appID: string, settings: ShellAppSettings): Observable<any>;
+    addBusy(): void;
+    removeBusy(): void;
+    exposeObjectCreateFlavors(flavors: ObjectCreateFlavor[]): void;
+    concealObjectCreateFlavors(flavors: ObjectCreateFlavor[]): void;
+    getObjectCreateFlavors(): ObjectCreateFlavor[];
+    /**
+     * 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: AppSchemaFlavor[], app?: string): void;
+    /**
+     * Removes exposed object flavors from the shell.
+     * @param flavors Array of flavors to be concealed
+     */
+    concealObjectFlavors(flavors: AppSchemaFlavor[], app?: string): void;
+    /**
+     * 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: AppSchemaFlavor, app?: string): void;
+    /**
+     * 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: AppSchemaFlavor, app?: string): void;
+    /**
+     * 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?: string): ObjectFlavor[];
+    /**
+     * 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: DmsObject, flavor: ObjectFlavor, data?: any): Observable<boolean>;
+    removeObjectFlavor(dmsObject: DmsObject, flavor: ObjectFlavor): Observable<any>;
+    /**
+     * 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: string, app?: string, customFlavors?: ObjectFlavor[]): ObjectFlavor[];
+    /**
+     * 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: DmsObject): {
+        applied: ObjectFlavor[];
+        applicable: ObjectFlavor[];
+    };
+    applyObjectFlavor(dmsObject: DmsObject, flavor: ObjectFlavor, data?: Record<string, unknown>): Observable<DmsObject>;
+    registerTileExtension(ext: TileExtension): void;
+    /**
+     * Get tile extensions for a certain type
+     * @param typeId ID of the type to fetch extesion for (objectTypeID or secondaryObjectTypeID)
+     * @returns
+     */
+    getRegisteredTileExtensions(): Record<string, TileExtension>;
+    _init(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ShellService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ShellService>;
+}

package/lib/services/shell-notifications/shell-notifications.interface.d.ts

@@ -0,0 +1,10 @@
+export interface ShellNotification {
+    title: string;
+    description?: string;
+    icon?: string;
+    app?: string;
+    level?: ShellNotificationLevel;
+    targetRoute?: string;
+    removeOnTargetRouteNavigated?: boolean;
+}
+export type ShellNotificationLevel = 'alert' | 'info' | 'warning' | 'success';

package/lib/services/shell-notifications/shell-notifications.service.d.ts

@@ -0,0 +1,34 @@
+import { ShellNotification } from './shell-notifications.interface';
+import { Observable } from 'rxjs';
+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 declare class ShellNotificationsService {
+    #private;
+    private LOCAL_STORAGE_KEY;
+    private appCache;
+    private translate;
+    private _notifications;
+    private _notificationsSource;
+    shellNotifications$: Observable<ShellNotificationItem[]>;
+    constructor();
+    add(notification: ShellNotification, nativeNotification?: boolean): void;
+    remove(id: string): void;
+    removeAll(): void;
+    markAllAsSeen(): void;
+    getNotificationById(id: string): ShellNotificationItem | undefined;
+    private _updateNotifications;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ShellNotificationsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ShellNotificationsService>;
+}
+type ShellNotificationItem = ShellNotification & {
+    id: string;
+    timestamp: number;
+    seen: boolean;
+};
+export {};

package/lib/tile-extension.interface.d.ts

@@ -0,0 +1,12 @@
+import { Type } from "@angular/core";
+export interface TileExtension {
+    typeId: string;
+    cmp: Type<TileExtensionComponent>;
+}
+export interface TileExtensionComponent {
+    data: any;
+}
+export interface TileExtensionDirectiveInput {
+    typeId: string;
+    data: any;
+}

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@yuuvis/client-shell-core",
+  "version": "0.6.5",
+  "peerDependencies": {
+    "@angular/common": "^18.2.0",
+    "@angular/core": "^18.2.0",
+    "@angular/forms": "^18.2.0"
+  },
+  "dependencies": {
+    "@yuuvis/client-core": "0.6.5",
+    "tslib": "^2.3.0"
+  },
+  "sideEffects": false,
+  "module": "esm2022/yuuvis-client-shell-core.mjs",
+  "typings": "index.d.ts",
+  "exports": {
+    "./package.json": {
+      "default": "./package.json"
+    },
+    ".": {
+      "types": "./index.d.ts",
+      "esm2022": "./esm2022/yuuvis-client-shell-core.mjs",
+      "esm": "./esm2022/yuuvis-client-shell-core.mjs",
+      "default": "./esm2022/yuuvis-client-shell-core.mjs"
+    }
+  }
+}