@scion/workbench 18.0.0-beta.2 → 18.0.0-beta.4

package/esm2022/lib/microfrontend-platform/microfrontend-message-box/microfrontend-message-box.component.mjs

@@ -49,7 +49,7 @@ export class MicrofrontendMessageBoxComponent {
         this.navigate();
     }
     navigate() {
-        const application = this._manifestService.applications.find(app => app.symbolicName === this.capability.metadata.appSymbolicName);
+        const application = this._manifestService.getApplication(this.capability.metadata.appSymbolicName);
         this._logger.debug(() => `Loading microfrontend into workbench message box [app=${this.capability.metadata.appSymbolicName}, baseUrl=${application.baseUrl}, path=${this.capability.properties.path}].`, LoggerNames.MICROFRONTEND, this.params, this.capability);
         this._outletRouter.navigate(this.capability.properties.path, {
             outlet: this.outletName,
@@ -97,14 +97,14 @@ export class MicrofrontendMessageBoxComponent {
         this._outletRouter.navigate(null, { outlet: this.outletName }).then(); // Clear the outlet.
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: MicrofrontendMessageBoxComponent, deps: [{ token: i1.OutletRouter }, { token: i1.ManifestService }, { token: i2.WorkbenchLayoutService }, { token: i0.Injector }, { token: i3.Logger }], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.0.2", type: MicrofrontendMessageBoxComponent, isStandalone: true, selector: "wb-microfrontend-message-box", inputs: { capability: "capability", params: "params" }, host: { properties: { "class.workbench-drag": "this.isWorkbenchDrag" } }, viewQueries: [{ propertyName: "routerOutletElement", first: true, predicate: ["router_outlet"], descendants: true, static: true }], ngImport: i0, template: "<sci-router-outlet #router_outlet\n                   [name]=\"outletName\"\n                   [attr.data-capabilityid]=\"capability.metadata!.id\"\n                   [attr.data-app]=\"capability.metadata!.appSymbolicName\"\n                   keystrokes=\"keydown.escape\">\n  <ng-container *ngComponentOutlet=\"splash\"></ng-container>\n</sci-router-outlet>\n", styles: [":host{display:grid}:host.workbench-drag>sci-router-outlet{pointer-events:none}:host>sci-router-outlet::part(splash){display:grid}\n"], dependencies: [{ kind: "directive", type: NgComponentOutlet, selector: "[ngComponentOutlet]", inputs: ["ngComponentOutlet", "ngComponentOutletInputs", "ngComponentOutletInjector", "ngComponentOutletContent", "ngComponentOutletNgModule", "ngComponentOutletNgModuleFactory"] }] }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.0.2", type: MicrofrontendMessageBoxComponent, isStandalone: true, selector: "wb-microfrontend-message-box", inputs: { capability: "capability", params: "params" }, host: { properties: { "class.workbench-drag": "this.isWorkbenchDrag" } }, viewQueries: [{ propertyName: "routerOutletElement", first: true, predicate: ["router_outlet"], descendants: true, static: true }], ngImport: i0, template: "<sci-router-outlet #router_outlet\n                   [name]=\"outletName\"\n                   [attr.data-capabilityid]=\"capability.metadata!.id\"\n                   [attr.data-app]=\"capability.metadata!.appSymbolicName\"\n                   keystrokes=\"keydown.escape\">\n  <ng-container *ngComponentOutlet=\"splash\"/>\n</sci-router-outlet>\n", styles: [":host{display:grid}:host.workbench-drag>sci-router-outlet{pointer-events:none}:host>sci-router-outlet::part(splash){display:grid}\n"], dependencies: [{ kind: "directive", type: NgComponentOutlet, selector: "[ngComponentOutlet]", inputs: ["ngComponentOutlet", "ngComponentOutletInputs", "ngComponentOutletInjector", "ngComponentOutletContent", "ngComponentOutletNgModule", "ngComponentOutletNgModuleFactory"] }] }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: MicrofrontendMessageBoxComponent, decorators: [{
             type: Component,
             args: [{ selector: 'wb-microfrontend-message-box', standalone: true, imports: [
                         NgClass,
                         NgComponentOutlet,
-                    ], schemas: [CUSTOM_ELEMENTS_SCHEMA], template: "<sci-router-outlet #router_outlet\n                   [name]=\"outletName\"\n                   [attr.data-capabilityid]=\"capability.metadata!.id\"\n                   [attr.data-app]=\"capability.metadata!.appSymbolicName\"\n                   keystrokes=\"keydown.escape\">\n  <ng-container *ngComponentOutlet=\"splash\"></ng-container>\n</sci-router-outlet>\n", styles: [":host{display:grid}:host.workbench-drag>sci-router-outlet{pointer-events:none}:host>sci-router-outlet::part(splash){display:grid}\n"] }]
+                    ], schemas: [CUSTOM_ELEMENTS_SCHEMA], template: "<sci-router-outlet #router_outlet\n                   [name]=\"outletName\"\n                   [attr.data-capabilityid]=\"capability.metadata!.id\"\n                   [attr.data-app]=\"capability.metadata!.appSymbolicName\"\n                   keystrokes=\"keydown.escape\">\n  <ng-container *ngComponentOutlet=\"splash\"/>\n</sci-router-outlet>\n", styles: [":host{display:grid}:host.workbench-drag>sci-router-outlet{pointer-events:none}:host>sci-router-outlet::part(splash){display:grid}\n"] }]
         }], ctorParameters: () => [{ type: i1.OutletRouter }, { type: i1.ManifestService }, { type: i2.WorkbenchLayoutService }, { type: i0.Injector }, { type: i3.Logger }], propDecorators: { capability: [{
                 type: Input,
                 args: [{ required: true }]
@@ -118,4 +118,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImpor
                 type: ViewChild,
                 args: ['router_outlet', { static: true }]
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"microfrontend-message-box.component.js","sourceRoot":"","sources":["../../../../../../../projects/scion/workbench/src/lib/microfrontend-platform/microfrontend-message-box/microfrontend-message-box.component.ts","../../../../../../../projects/scion/workbench/src/lib/microfrontend-platform/microfrontend-message-box/microfrontend-message-box.component.html"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright (c) 2018-2024 Swiss Federal Railways\n *\n * This program and the accompanying materials are made\n * available under the terms of the Eclipse Public License 2.0\n * which is available at https://www.eclipse.org/legal/epl-2.0/\n *\n * SPDX-License-Identifier: EPL-2.0\n */\n\nimport {Component, CUSTOM_ELEMENTS_SCHEMA, ElementRef, HostBinding, inject, Injector, Input, OnDestroy, OnInit, runInInjectionContext, ViewChild} from '@angular/core';\nimport {ManifestService, MicrofrontendPlatformConfig, OutletRouter, SciRouterOutletElement} from '@scion/microfrontend-platform';\nimport {Logger, LoggerNames} from '../../logging';\nimport {WorkbenchMessageBoxCapability, ɵMESSAGE_BOX_CONTEXT, ɵMessageBoxContext} from '@scion/workbench-client';\nimport {NgClass, NgComponentOutlet} from '@angular/common';\nimport {takeUntilDestroyed} from '@angular/core/rxjs-interop';\nimport {WorkbenchLayoutService} from '../../layout/workbench-layout.service';\nimport {ComponentType} from '@angular/cdk/portal';\nimport {MicrofrontendSplashComponent} from '../microfrontend-splash/microfrontend-splash.component';\nimport {UUID} from '@scion/toolkit/uuid';\nimport {setStyle} from '../../common/dom.util';\nimport {Microfrontends} from '../common/microfrontend.util';\n\n/**\n * Displays the microfrontend of a given {@link WorkbenchMessageBoxCapability}.\n *\n * This component is designed to be displayed in a workbench message box.\n */\n@Component({\n  selector: 'wb-microfrontend-message-box',\n  styleUrls: ['./microfrontend-message-box.component.scss'],\n  templateUrl: './microfrontend-message-box.component.html',\n  standalone: true,\n  imports: [\n    NgClass,\n    NgComponentOutlet,\n  ],\n  schemas: [CUSTOM_ELEMENTS_SCHEMA], // required because <sci-router-outlet> is a custom element\n})\nexport class MicrofrontendMessageBoxComponent implements OnInit, OnDestroy {\n\n  protected readonly outletName = UUID.randomUUID();\n\n  @Input({required: true})\n  public capability!: WorkbenchMessageBoxCapability;\n\n  @Input({required: true})\n  public params!: Map<string, unknown>;\n\n  /**\n   * Indicates if a workbench drag operation is in progress, such as when dragging a view or moving a sash.\n   */\n  @HostBinding('class.workbench-drag')\n  public isWorkbenchDrag = false;\n\n  @ViewChild('router_outlet', {static: true})\n  public routerOutletElement!: ElementRef<SciRouterOutletElement>;\n\n  /**\n   * Splash to display until the microfrontend signals readiness.\n   */\n  protected splash: ComponentType<unknown>;\n\n  constructor(private _outletRouter: OutletRouter,\n              private _manifestService: ManifestService,\n              private _workbenchLayoutService: WorkbenchLayoutService,\n              private _injector: Injector,\n              private _logger: Logger) {\n    this._logger.debug(() => 'Constructing MicrofrontendMessageBoxComponent.', LoggerNames.MICROFRONTEND);\n    this.splash = inject(MicrofrontendPlatformConfig).splash ?? MicrofrontendSplashComponent;\n    this.installWorkbenchDragDetector();\n  }\n\n  public ngOnInit(): void {\n    this.setSizeProperties();\n    this.propagateMessageBoxContext();\n    this.propagateWorkbenchTheme();\n    this.navigate();\n  }\n\n  private navigate(): void {\n    const application = this._manifestService.applications.find(app => app.symbolicName === this.capability.metadata!.appSymbolicName)!;\n    this._logger.debug(() => `Loading microfrontend into workbench message box [app=${this.capability.metadata!.appSymbolicName}, baseUrl=${application.baseUrl}, path=${this.capability.properties.path}].`, LoggerNames.MICROFRONTEND, this.params, this.capability);\n    this._outletRouter.navigate(this.capability.properties.path, {\n      outlet: this.outletName,\n      relativeTo: application.baseUrl,\n      params: this.params,\n      pushStateToSessionHistoryStack: false,\n      showSplash: this.capability.properties.showSplash,\n    }).then();\n  }\n\n  /**\n   * Make the message box context available to embedded content.\n   */\n  private propagateMessageBoxContext(): void {\n    const context: ɵMessageBoxContext = {\n      capability: this.capability,\n      params: this.params,\n    };\n    this.routerOutletElement.nativeElement.setContextValue(ɵMESSAGE_BOX_CONTEXT, context);\n  }\n\n  private setSizeProperties(): void {\n    setStyle(this.routerOutletElement, {\n      'width': this.capability.properties.size?.width ?? '0', // allow content size to go bellow the default iframe size when reporting preferred size\n      'min-width': this.capability.properties.size?.minWidth ?? null,\n      'max-width': this.capability.properties.size?.maxWidth ?? null,\n      'height': this.capability.properties.size?.height ?? '0', // allow content size to go bellow the default iframe size when reporting preferred size\n      'min-height': this.capability.properties.size?.minHeight ?? null,\n      'max-height': this.capability.properties.size?.maxHeight ?? null,\n    });\n  }\n\n  private propagateWorkbenchTheme(): void {\n    runInInjectionContext(this._injector, () => Microfrontends.propagateTheme(this.routerOutletElement.nativeElement));\n  }\n\n  /**\n   * Sets the {@link isWorkbenchDrag} property when a workbench drag operation is detected,\n   * such as when dragging a view or moving a sash.\n   */\n  private installWorkbenchDragDetector(): void {\n    this._workbenchLayoutService.dragging$\n      .pipe(takeUntilDestroyed())\n      .subscribe(event => {\n        this.isWorkbenchDrag = (event === 'start');\n      });\n  }\n\n  public ngOnDestroy(): void {\n    this._outletRouter.navigate(null, {outlet: this.outletName}).then(); // Clear the outlet.\n  }\n}\n","<sci-router-outlet #router_outlet\n                   [name]=\"outletName\"\n                   [attr.data-capabilityid]=\"capability.metadata!.id\"\n                   [attr.data-app]=\"capability.metadata!.appSymbolicName\"\n                   keystrokes=\"keydown.escape\">\n  <ng-container *ngComponentOutlet=\"splash\"></ng-container>\n</sci-router-outlet>\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"microfrontend-message-box.component.js","sourceRoot":"","sources":["../../../../../../../projects/scion/workbench/src/lib/microfrontend-platform/microfrontend-message-box/microfrontend-message-box.component.ts","../../../../../../../projects/scion/workbench/src/lib/microfrontend-platform/microfrontend-message-box/microfrontend-message-box.component.html"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright (c) 2018-2024 Swiss Federal Railways\n *\n * This program and the accompanying materials are made\n * available under the terms of the Eclipse Public License 2.0\n * which is available at https://www.eclipse.org/legal/epl-2.0/\n *\n * SPDX-License-Identifier: EPL-2.0\n */\n\nimport {Component, CUSTOM_ELEMENTS_SCHEMA, ElementRef, HostBinding, inject, Injector, Input, OnDestroy, OnInit, runInInjectionContext, ViewChild} from '@angular/core';\nimport {ManifestService, MicrofrontendPlatformConfig, OutletRouter, SciRouterOutletElement} from '@scion/microfrontend-platform';\nimport {Logger, LoggerNames} from '../../logging';\nimport {WorkbenchMessageBoxCapability, ɵMESSAGE_BOX_CONTEXT, ɵMessageBoxContext} from '@scion/workbench-client';\nimport {NgClass, NgComponentOutlet} from '@angular/common';\nimport {takeUntilDestroyed} from '@angular/core/rxjs-interop';\nimport {WorkbenchLayoutService} from '../../layout/workbench-layout.service';\nimport {ComponentType} from '@angular/cdk/portal';\nimport {MicrofrontendSplashComponent} from '../microfrontend-splash/microfrontend-splash.component';\nimport {UUID} from '@scion/toolkit/uuid';\nimport {setStyle} from '../../common/dom.util';\nimport {Microfrontends} from '../common/microfrontend.util';\n\n/**\n * Displays the microfrontend of a given {@link WorkbenchMessageBoxCapability}.\n *\n * This component is designed to be displayed in a workbench message box.\n */\n@Component({\n  selector: 'wb-microfrontend-message-box',\n  styleUrls: ['./microfrontend-message-box.component.scss'],\n  templateUrl: './microfrontend-message-box.component.html',\n  standalone: true,\n  imports: [\n    NgClass,\n    NgComponentOutlet,\n  ],\n  schemas: [CUSTOM_ELEMENTS_SCHEMA], // required because <sci-router-outlet> is a custom element\n})\nexport class MicrofrontendMessageBoxComponent implements OnInit, OnDestroy {\n\n  protected readonly outletName = UUID.randomUUID();\n\n  @Input({required: true})\n  public capability!: WorkbenchMessageBoxCapability;\n\n  @Input({required: true})\n  public params!: Map<string, unknown>;\n\n  /**\n   * Indicates if a workbench drag operation is in progress, such as when dragging a view or moving a sash.\n   */\n  @HostBinding('class.workbench-drag')\n  public isWorkbenchDrag = false;\n\n  @ViewChild('router_outlet', {static: true})\n  public routerOutletElement!: ElementRef<SciRouterOutletElement>;\n\n  /**\n   * Splash to display until the microfrontend signals readiness.\n   */\n  protected splash: ComponentType<unknown>;\n\n  constructor(private _outletRouter: OutletRouter,\n              private _manifestService: ManifestService,\n              private _workbenchLayoutService: WorkbenchLayoutService,\n              private _injector: Injector,\n              private _logger: Logger) {\n    this._logger.debug(() => 'Constructing MicrofrontendMessageBoxComponent.', LoggerNames.MICROFRONTEND);\n    this.splash = inject(MicrofrontendPlatformConfig).splash ?? MicrofrontendSplashComponent;\n    this.installWorkbenchDragDetector();\n  }\n\n  public ngOnInit(): void {\n    this.setSizeProperties();\n    this.propagateMessageBoxContext();\n    this.propagateWorkbenchTheme();\n    this.navigate();\n  }\n\n  private navigate(): void {\n    const application = this._manifestService.getApplication(this.capability.metadata!.appSymbolicName);\n    this._logger.debug(() => `Loading microfrontend into workbench message box [app=${this.capability.metadata!.appSymbolicName}, baseUrl=${application.baseUrl}, path=${this.capability.properties.path}].`, LoggerNames.MICROFRONTEND, this.params, this.capability);\n    this._outletRouter.navigate(this.capability.properties.path, {\n      outlet: this.outletName,\n      relativeTo: application.baseUrl,\n      params: this.params,\n      pushStateToSessionHistoryStack: false,\n      showSplash: this.capability.properties.showSplash,\n    }).then();\n  }\n\n  /**\n   * Make the message box context available to embedded content.\n   */\n  private propagateMessageBoxContext(): void {\n    const context: ɵMessageBoxContext = {\n      capability: this.capability,\n      params: this.params,\n    };\n    this.routerOutletElement.nativeElement.setContextValue(ɵMESSAGE_BOX_CONTEXT, context);\n  }\n\n  private setSizeProperties(): void {\n    setStyle(this.routerOutletElement, {\n      'width': this.capability.properties.size?.width ?? '0', // allow content size to go bellow the default iframe size when reporting preferred size\n      'min-width': this.capability.properties.size?.minWidth ?? null,\n      'max-width': this.capability.properties.size?.maxWidth ?? null,\n      'height': this.capability.properties.size?.height ?? '0', // allow content size to go bellow the default iframe size when reporting preferred size\n      'min-height': this.capability.properties.size?.minHeight ?? null,\n      'max-height': this.capability.properties.size?.maxHeight ?? null,\n    });\n  }\n\n  private propagateWorkbenchTheme(): void {\n    runInInjectionContext(this._injector, () => Microfrontends.propagateTheme(this.routerOutletElement.nativeElement));\n  }\n\n  /**\n   * Sets the {@link isWorkbenchDrag} property when a workbench drag operation is detected,\n   * such as when dragging a view or moving a sash.\n   */\n  private installWorkbenchDragDetector(): void {\n    this._workbenchLayoutService.dragging$\n      .pipe(takeUntilDestroyed())\n      .subscribe(event => {\n        this.isWorkbenchDrag = (event === 'start');\n      });\n  }\n\n  public ngOnDestroy(): void {\n    this._outletRouter.navigate(null, {outlet: this.outletName}).then(); // Clear the outlet.\n  }\n}\n","<sci-router-outlet #router_outlet\n                   [name]=\"outletName\"\n                   [attr.data-capabilityid]=\"capability.metadata!.id\"\n                   [attr.data-app]=\"capability.metadata!.appSymbolicName\"\n                   keystrokes=\"keydown.escape\">\n  <ng-container *ngComponentOutlet=\"splash\"/>\n</sci-router-outlet>\n"]}

package/esm2022/lib/microfrontend-platform/microfrontend-perspective/microfrontend-perspective-capability-validator.interceptor.mjs

@@ -0,0 +1,39 @@
+import { Injectable } from '@angular/core';
+import { WorkbenchCapabilities } from '@scion/workbench-client';
+import { Objects } from '../../common/objects.util';
+import { MAIN_AREA } from '../../layout/workbench-layout';
+import * as i0 from "@angular/core";
+/**
+ * Asserts perspective capabilities to have required properties.
+ */
+export class MicrofrontendPerspectiveCapabilityValidator {
+    async intercept(capability) {
+        if (capability.type !== WorkbenchCapabilities.Perspective) {
+            return capability;
+        }
+        const perspectiveCapability = capability;
+        // Assert the perspective capability to have a qualifier set.
+        if (!Object.keys(perspectiveCapability.qualifier ?? {}).length) {
+            throw Error(`[NullQualifierError] Perspective capability requires a qualifier [capability=${JSON.stringify(perspectiveCapability)}]`);
+        }
+        // Assert the perspective capability to have a layout set.
+        if (!perspectiveCapability.properties?.layout) {
+            throw Error(`[NullLayoutError] Perspective capability requires a layout [application="${perspectiveCapability.metadata.appSymbolicName}", capability="${Objects.toMatrixNotation(perspectiveCapability.qualifier)}"]`);
+        }
+        // Assert the perspective capability to define parts.
+        if (!perspectiveCapability.properties.layout.length) {
+            throw Error(`[NullLayoutError] Perspective capability requires parts [application="${perspectiveCapability.metadata.appSymbolicName}", capability="${Objects.toMatrixNotation(perspectiveCapability.qualifier)}"]`);
+        }
+        // Assert no views to be added to the main area.
+        if (perspectiveCapability.properties.layout.find(part => part.id === MAIN_AREA)?.views?.length) {
+            throw Error(`[PerspectiveLayoutError] Perspective capability cannot add views to the main area [application="${perspectiveCapability.metadata.appSymbolicName}", capability="${Objects.toMatrixNotation(perspectiveCapability.qualifier)}"]`);
+        }
+        return capability;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: MicrofrontendPerspectiveCapabilityValidator, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: MicrofrontendPerspectiveCapabilityValidator }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: MicrofrontendPerspectiveCapabilityValidator, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/microfrontend-platform/microfrontend-perspective/microfrontend-perspective-installer.service.mjs

@@ -0,0 +1,120 @@
+/*
+ * Copyright (c) 2018-2024 Swiss Federal Railways
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+import { inject, Injectable, IterableDiffers } from '@angular/core';
+import { WorkbenchCapabilities } from '@scion/workbench-client';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { firstValueFrom } from 'rxjs';
+import { MicrofrontendViewRoutes } from '../routing/microfrontend-view-routes';
+import { LoggerNames } from '../../logging';
+import { filterArray } from '@scion/toolkit/operators';
+import { Objects } from '../../common/objects.util';
+import { WorkbenchPerspectiveData } from './workbench-perspective-data';
+import * as i0 from "@angular/core";
+import * as i1 from "@scion/microfrontend-platform";
+import * as i2 from "../../workbench.service";
+import * as i3 from "../../logging";
+/**
+ * Registers perspectives for workbench perspective capabilities.
+ */
+export class MicrofrontendPerspectiveInstaller {
+    constructor(_manifestService, _workbenchService, _logger) {
+        this._manifestService = _manifestService;
+        this._workbenchService = _workbenchService;
+        this._logger = _logger;
+        this.installPerspectiveCapabilityListener();
+    }
+    installPerspectiveCapabilityListener() {
+        const differ = inject(IterableDiffers).find([]).create((_index, perspectiveCapability) => perspectiveCapability.metadata.id);
+        this._manifestService.lookupCapabilities$({ type: WorkbenchCapabilities.Perspective })
+            .pipe(takeUntilDestroyed())
+            .subscribe(perspectiveCapabilities => {
+            const changes = differ.diff(perspectiveCapabilities);
+            changes?.forEachAddedItem(({ item: perspectiveCapability }) => this.registerPerspective(perspectiveCapability));
+        });
+    }
+    async registerPerspective(perspectiveCapability) {
+        return this._workbenchService.registerPerspective({
+            id: perspectiveCapability.metadata.id,
+            layout: this.createLayout(perspectiveCapability),
+            data: {
+                ...perspectiveCapability.properties?.data,
+                [WorkbenchPerspectiveData.capability]: perspectiveCapability,
+            },
+        });
+    }
+    createLayout(perspectiveCapability) {
+        return async (factory) => {
+            const [initialPart, ...parts] = perspectiveCapability.properties.layout;
+            // Add parts to the layout.
+            let layout = factory.addPart(initialPart.id);
+            for (const part of parts) {
+                layout = layout.addPart(part.id, {
+                    relativeTo: part.relativeTo,
+                    align: part.align,
+                    ratio: part.ratio,
+                });
+            }
+            // Add views to the layout.
+            for (const part of [initialPart, ...parts]) {
+                if (!part.views?.length) {
+                    continue;
+                }
+                for (const [viewIndex, view] of part.views.entries()) {
+                    const viewCapabilities = await this.lookupViewCapabilities(view.qualifier, {
+                        perspectiveProvider: perspectiveCapability.metadata.appSymbolicName,
+                        perspectiveQualifier: perspectiveCapability.qualifier,
+                    });
+                    viewCapabilities
+                        .map(viewCapability => viewCapability.metadata.id)
+                        .sort() // Ensure stable view order in case multiple capabilities match the qualifier.
+                        .forEach(viewCapabilityId => {
+                        const commands = MicrofrontendViewRoutes.createMicrofrontendNavigateCommands(viewCapabilityId, view.params ?? {});
+                        const alternativeViewId = `${part.id}-${viewCapabilityId}-${viewIndex}`;
+                        layout = layout
+                            .addView(alternativeViewId, { partId: part.id, activateView: view.active })
+                            .navigateView(alternativeViewId, commands, { cssClass: view.cssClass });
+                    });
+                    // Navigate to the "~" route if not finding a view capability, e.g., because the perspective provider references a private view capability
+                    // or has not declared an intention. Since there is no route registered under /~ the "Not Found" page will be displayed.
+                    if (!viewCapabilities.length) {
+                        this._logger.warn(() => `[NullCapabilityError] The perspective '${Objects.toMatrixNotation(perspectiveCapability.qualifier)}' cannot find the view '${Objects.toMatrixNotation(view.qualifier)}'. Verify the application is available and the view exists.`, LoggerNames.MICROFRONTEND);
+                        const alternativeViewId = `${part.id}-${viewIndex}`;
+                        layout = layout
+                            .addView(alternativeViewId, { partId: part.id, activateView: view.active })
+                            .navigateView(alternativeViewId, ['~', view.qualifier], { cssClass: view.cssClass });
+                    }
+                }
+            }
+            return layout;
+        };
+    }
+    /**
+     * Searches for views that match the specified qualifier and are accessible to the perspective provider,
+     * i.e., its own view capabilities or public view capabilities of other applications the perspective provider
+     * has an intention for.
+     */
+    async lookupViewCapabilities(qualifier, perspective) {
+        const viewCapabilities$ = this._manifestService.lookupCapabilities$({ type: WorkbenchCapabilities.View, qualifier })
+            .pipe(filterArray(async (viewCapability) => {
+            const allowed = await firstValueFrom(this._manifestService.isApplicationQualified$(perspective.perspectiveProvider, { capabilityId: viewCapability.metadata.id }));
+            if (!allowed) {
+                this._logger.warn(`[NotQualifiedError] Application '${(perspective.perspectiveProvider)}' is not allowed to reference the view '${Objects.toMatrixNotation(viewCapability.qualifier)}' in the perspective '${Objects.toMatrixNotation(perspective.perspectiveQualifier)}'. Ensure you have specified an intention and that the view is public.`, LoggerNames.MICROFRONTEND);
+            }
+            return allowed;
+        }));
+        return firstValueFrom(viewCapabilities$);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: MicrofrontendPerspectiveInstaller, deps: [{ token: i1.ManifestService }, { token: i2.WorkbenchService }, { token: i3.Logger }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: MicrofrontendPerspectiveInstaller }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: MicrofrontendPerspectiveInstaller, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.ManifestService }, { type: i2.WorkbenchService }, { type: i3.Logger }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"microfrontend-perspective-installer.service.js","sourceRoot":"","sources":["../../../../../../../projects/scion/workbench/src/lib/microfrontend-platform/microfrontend-perspective/microfrontend-perspective-installer.service.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright (c) 2018-2024 Swiss Federal Railways\n *\n * This program and the accompanying materials are made\n * available under the terms of the Eclipse Public License 2.0\n * which is available at https://www.eclipse.org/legal/epl-2.0/\n *\n * SPDX-License-Identifier: EPL-2.0\n */\n\nimport {inject, Injectable, IterableDiffers} from '@angular/core';\nimport {ManifestService, Qualifier} from '@scion/microfrontend-platform';\nimport {WorkbenchCapabilities, WorkbenchPerspectiveCapability, WorkbenchViewCapability} from '@scion/workbench-client';\nimport {WorkbenchService} from '../../workbench.service';\nimport {takeUntilDestroyed} from '@angular/core/rxjs-interop';\nimport {WorkbenchLayout} from '../../layout/workbench-layout';\nimport {WorkbenchLayoutFn} from '../../perspective/workbench-perspective.model';\nimport {firstValueFrom} from 'rxjs';\nimport {WorkbenchLayoutFactory} from '../../layout/workbench-layout.factory';\nimport {MicrofrontendViewRoutes} from '../routing/microfrontend-view-routes';\nimport {Logger, LoggerNames} from '../../logging';\nimport {filterArray} from '@scion/toolkit/operators';\nimport {Objects} from '../../common/objects.util';\nimport {WorkbenchPerspectiveData} from './workbench-perspective-data';\n\n/**\n * Registers perspectives for workbench perspective capabilities.\n */\n@Injectable(/* DO NOT PROVIDE via 'providedIn' metadata as only registered if microfrontend support is enabled. */)\nexport class MicrofrontendPerspectiveInstaller {\n\n  constructor(private _manifestService: ManifestService,\n              private _workbenchService: WorkbenchService,\n              private _logger: Logger) {\n    this.installPerspectiveCapabilityListener();\n  }\n\n  private installPerspectiveCapabilityListener(): void {\n    const differ = inject(IterableDiffers).find([]).create<WorkbenchPerspectiveCapability>((_index, perspectiveCapability) => perspectiveCapability.metadata!.id);\n    this._manifestService.lookupCapabilities$<WorkbenchPerspectiveCapability>({type: WorkbenchCapabilities.Perspective})\n      .pipe(takeUntilDestroyed())\n      .subscribe(perspectiveCapabilities => {\n        const changes = differ.diff(perspectiveCapabilities);\n        changes?.forEachAddedItem(({item: perspectiveCapability}) => this.registerPerspective(perspectiveCapability));\n      });\n  }\n\n  private async registerPerspective(perspectiveCapability: WorkbenchPerspectiveCapability): Promise<void> {\n    return this._workbenchService.registerPerspective({\n      id: perspectiveCapability.metadata!.id,\n      layout: this.createLayout(perspectiveCapability),\n      data: {\n        ...perspectiveCapability.properties?.data,\n        [WorkbenchPerspectiveData.capability]: perspectiveCapability,\n      },\n    });\n  }\n\n  private createLayout(perspectiveCapability: WorkbenchPerspectiveCapability): WorkbenchLayoutFn {\n    return async (factory: WorkbenchLayoutFactory): Promise<WorkbenchLayout> => {\n      const [initialPart, ...parts] = perspectiveCapability.properties.layout;\n\n      // Add parts to the layout.\n      let layout = factory.addPart(initialPart.id);\n      for (const part of parts) {\n        layout = layout.addPart(part.id, {\n          relativeTo: part.relativeTo,\n          align: part.align,\n          ratio: part.ratio,\n        });\n      }\n\n      // Add views to the layout.\n      for (const part of [initialPart, ...parts]) {\n        if (!part.views?.length) {\n          continue;\n        }\n\n        for (const [viewIndex, view] of part.views.entries()) {\n          const viewCapabilities = await this.lookupViewCapabilities(view.qualifier, {\n            perspectiveProvider: perspectiveCapability.metadata!.appSymbolicName,\n            perspectiveQualifier: perspectiveCapability.qualifier,\n          });\n\n          viewCapabilities\n            .map(viewCapability => viewCapability.metadata!.id)\n            .sort() // Ensure stable view order in case multiple capabilities match the qualifier.\n            .forEach(viewCapabilityId => {\n              const commands = MicrofrontendViewRoutes.createMicrofrontendNavigateCommands(viewCapabilityId, view.params ?? {});\n              const alternativeViewId = `${part.id}-${viewCapabilityId}-${viewIndex}`;\n              layout = layout\n                .addView(alternativeViewId, {partId: part.id, activateView: view.active})\n                .navigateView(alternativeViewId, commands, {cssClass: view.cssClass});\n            });\n\n          // Navigate to the \"~\" route if not finding a view capability, e.g., because the perspective provider references a private view capability\n          // or has not declared an intention. Since there is no route registered under /~ the \"Not Found\" page will be displayed.\n          if (!viewCapabilities.length) {\n            this._logger.warn(() => `[NullCapabilityError] The perspective '${Objects.toMatrixNotation(perspectiveCapability.qualifier)}' cannot find the view '${Objects.toMatrixNotation(view.qualifier)}'. Verify the application is available and the view exists.`, LoggerNames.MICROFRONTEND);\n            const alternativeViewId = `${part.id}-${viewIndex}`;\n            layout = layout\n              .addView(alternativeViewId, {partId: part.id, activateView: view.active})\n              .navigateView(alternativeViewId, ['~', view.qualifier], {cssClass: view.cssClass});\n          }\n        }\n      }\n\n      return layout;\n    };\n  }\n\n  /**\n   * Searches for views that match the specified qualifier and are accessible to the perspective provider,\n   * i.e., its own view capabilities or public view capabilities of other applications the perspective provider\n   * has an intention for.\n   */\n  private async lookupViewCapabilities(qualifier: Qualifier, perspective: {perspectiveProvider: string; perspectiveQualifier: Qualifier}): Promise<WorkbenchViewCapability[]> {\n    const viewCapabilities$ = this._manifestService.lookupCapabilities$<WorkbenchViewCapability>({type: WorkbenchCapabilities.View, qualifier})\n      .pipe(filterArray(async viewCapability => {\n        const allowed = await firstValueFrom(this._manifestService.isApplicationQualified$(perspective.perspectiveProvider, {capabilityId: viewCapability.metadata!.id}));\n        if (!allowed) {\n          this._logger.warn(`[NotQualifiedError] Application '${(perspective.perspectiveProvider)}' is not allowed to reference the view '${Objects.toMatrixNotation(viewCapability.qualifier)}' in the perspective '${Objects.toMatrixNotation(perspective.perspectiveQualifier)}'. Ensure you have specified an intention and that the view is public.`, LoggerNames.MICROFRONTEND);\n        }\n        return allowed;\n      }));\n    return firstValueFrom(viewCapabilities$);\n  }\n}\n"]}

package/esm2022/lib/microfrontend-platform/microfrontend-perspective/microfrontend-perspective-intent-handler.interceptor.mjs

@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) 2018-2024 Swiss Federal Railways
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+import { MessageClient, MessageHeaders, ResponseStatusCodes } from '@scion/microfrontend-platform';
+import { Injectable } from '@angular/core';
+import { WorkbenchCapabilities } from '@scion/workbench-client';
+import { LoggerNames } from '../../logging';
+import { Beans } from '@scion/toolkit/bean-manager';
+import * as i0 from "@angular/core";
+import * as i1 from "../../workbench.service";
+import * as i2 from "../../logging";
+/**
+ * Handles perspective intents, instructing the workbench to switch perspective.
+ */
+export class MicrofrontendPerspectiveIntentHandler {
+    constructor(_workbenchService, _logger) {
+        this._workbenchService = _workbenchService;
+        this._logger = _logger;
+    }
+    /**
+     * Perspective intents are handled in this interceptor and then swallowed.
+     */
+    intercept(intentMessage, next) {
+        if (intentMessage.intent.type === WorkbenchCapabilities.Perspective) {
+            return this.consumePerspectiveIntent(intentMessage);
+        }
+        else {
+            return next.handle(intentMessage);
+        }
+    }
+    async consumePerspectiveIntent(message) {
+        const replyTo = message.headers.get(MessageHeaders.ReplyTo);
+        const success = await this.switchPerspective(message);
+        if (replyTo) {
+            await Beans.get(MessageClient).publish(replyTo, success, { headers: new Map().set(MessageHeaders.Status, ResponseStatusCodes.TERMINAL) });
+        }
+    }
+    switchPerspective(message) {
+        const perspectiveId = message.capability.metadata.id;
+        this._logger.debug(() => `Switching to perspective ${perspectiveId}.`, LoggerNames.MICROFRONTEND);
+        return this._workbenchService.switchPerspective(perspectiveId);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: MicrofrontendPerspectiveIntentHandler, deps: [{ token: i1.WorkbenchService }, { token: i2.Logger }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: MicrofrontendPerspectiveIntentHandler }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: MicrofrontendPerspectiveIntentHandler, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.WorkbenchService }, { type: i2.Logger }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/microfrontend-platform/microfrontend-perspective/workbench-perspective-data.mjs

@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2018-2024 Swiss Federal Railways
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+/**
+ * Keys for associating workbench-specific data with a perspective.
+ */
+export const WorkbenchPerspectiveData = {
+    /**
+     * Property to get the capability providing the perspective.
+     */
+    capability: 'ɵcapability',
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid29ya2JlbmNoLXBlcnNwZWN0aXZlLWRhdGEuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9zY2lvbi93b3JrYmVuY2gvc3JjL2xpYi9taWNyb2Zyb250ZW5kLXBsYXRmb3JtL21pY3JvZnJvbnRlbmQtcGVyc3BlY3RpdmUvd29ya2JlbmNoLXBlcnNwZWN0aXZlLWRhdGEudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7O0dBUUc7QUFFSDs7R0FFRztBQUNILE1BQU0sQ0FBQyxNQUFNLHdCQUF3QixHQUFHO0lBRXRDOztPQUVHO0lBQ0gsVUFBVSxFQUFFLGFBQWE7Q0FDakIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qXG4gKiBDb3B5cmlnaHQgKGMpIDIwMTgtMjAyNCBTd2lzcyBGZWRlcmFsIFJhaWx3YXlzXG4gKlxuICogVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyBhcmUgbWFkZVxuICogYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSAyLjBcbiAqIHdoaWNoIGlzIGF2YWlsYWJsZSBhdCBodHRwczovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtMi4wL1xuICpcbiAqIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBFUEwtMi4wXG4gKi9cblxuLyoqXG4gKiBLZXlzIGZvciBhc3NvY2lhdGluZyB3b3JrYmVuY2gtc3BlY2lmaWMgZGF0YSB3aXRoIGEgcGVyc3BlY3RpdmUuXG4gKi9cbmV4cG9ydCBjb25zdCBXb3JrYmVuY2hQZXJzcGVjdGl2ZURhdGEgPSB7XG5cbiAgLyoqXG4gICAqIFByb3BlcnR5IHRvIGdldCB0aGUgY2FwYWJpbGl0eSBwcm92aWRpbmcgdGhlIHBlcnNwZWN0aXZlLlxuICAgKi9cbiAgY2FwYWJpbGl0eTogJ8m1Y2FwYWJpbGl0eScsXG59IGFzIGNvbnN0O1xuIl19

package/esm2022/lib/microfrontend-platform/microfrontend-popup/microfrontend-popup-capability-validator.interceptor.mjs

@@ -1,5 +1,6 @@
 import { Injectable } from '@angular/core';
 import { WorkbenchCapabilities } from '@scion/workbench-client';
+import { Objects } from '../../common/objects.util';
 import * as i0 from "@angular/core";
 /**
  * Asserts popup capabilities to have required properties.
@@ -11,13 +12,13 @@ export class MicrofrontendPopupCapabilityValidator {
         }
         const popupCapability = capability;
         // Assert the popup capability to have a qualifier set.
-        if (!popupCapability.qualifier || !Object.keys(popupCapability.qualifier).length) {
+        if (!Object.keys(popupCapability.qualifier ?? {}).length) {
             throw Error(`[NullQualifierError] Popup capability requires a qualifier [capability=${JSON.stringify(popupCapability)}]`);
         }
         // Assert the popup capability to have a path set.
         const path = popupCapability.properties?.path;
         if (path === undefined || path === null) {
-            throw Error(`[NullPathError] Popup capability requires a path to the microfrontend in its properties [capability=${JSON.stringify(popupCapability)}]`);
+            throw Error(`[NullPathError] Popup capability requires a path to the microfrontend in its properties [application="${popupCapability.metadata.appSymbolicName}", capability="${Objects.toMatrixNotation(popupCapability.qualifier)}"]`);
         }
         return popupCapability;
     }
@@ -27,4 +28,4 @@ export class MicrofrontendPopupCapabilityValidator {
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: MicrofrontendPopupCapabilityValidator, decorators: [{
             type: Injectable
         }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/microfrontend-platform/microfrontend-popup/microfrontend-popup-intent-handler.interceptor.mjs

@@ -7,20 +7,19 @@
  *
  * SPDX-License-Identifier: EPL-2.0
  */
-import { Injectable } from '@angular/core';
+import { inject, Injectable } from '@angular/core';
 import { APP_IDENTITY, mapToBody, MessageClient, MessageHeaders, ResponseStatusCodes } from '@scion/microfrontend-platform';
 import { WorkbenchCapabilities, ɵWorkbenchCommands } from '@scion/workbench-client';
 import { MicrofrontendPopupComponent } from './microfrontend-popup.component';
-import { LoggerNames } from '../../logging';
+import { Logger, LoggerNames } from '../../logging';
 import { Beans } from '@scion/toolkit/bean-manager';
 import { stringifyError } from '../../common/stringify-error.util';
 import { Arrays, Maps } from '@scion/toolkit/util';
+import { PopupService } from '../../popup/popup.service';
+import { WORKBENCH_VIEW_REGISTRY } from '../../view/workbench-view.registry';
 import { MicrofrontendHostPopupComponent } from '../microfrontend-host-popup/microfrontend-host-popup.component';
 import { MicrofrontendWorkbenchView } from '../microfrontend-view/microfrontend-workbench-view.model';
 import * as i0 from "@angular/core";
-import * as i1 from "../../popup/popup.service";
-import * as i2 from "../../view/workbench-view.registry";
-import * as i3 from "../../logging";
 /**
  * Handles popup intents, instructing the workbench to open a popup with the microfrontend declared on the resolved capability.
  *
@@ -30,10 +29,10 @@ import * as i3 from "../../logging";
  * that are not connected to the SCION Workbench.
  */
 export class MicrofrontendPopupIntentHandler {
-    constructor(_popupService, _viewRegistry, _logger) {
-        this._popupService = _popupService;
-        this._viewRegistry = _viewRegistry;
-        this._logger = _logger;
+    constructor() {
+        this._popupService = inject(PopupService);
+        this._viewRegistry = inject(WORKBENCH_VIEW_REGISTRY);
+        this._logger = inject(Logger);
         this._openedPopups = new Set();
     }
     /**
@@ -124,10 +123,10 @@ export class MicrofrontendPopupIntentHandler {
             viewCapabilityId: view.adapt(MicrofrontendWorkbenchView)?.capability.metadata.id,
         };
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: MicrofrontendPopupIntentHandler, deps: [{ token: i1.PopupService }, { token: i2.WorkbenchViewRegistry }, { token: i3.Logger }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: MicrofrontendPopupIntentHandler, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: MicrofrontendPopupIntentHandler }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: MicrofrontendPopupIntentHandler, decorators: [{
             type: Injectable
-        }], ctorParameters: () => [{ type: i1.PopupService }, { type: i2.WorkbenchViewRegistry }, { type: i3.Logger }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"microfrontend-popup-intent-handler.interceptor.js","sourceRoot":"","sources":["../../../../../../../projects/scion/workbench/src/lib/microfrontend-platform/microfrontend-popup/microfrontend-popup-intent-handler.interceptor.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright (c) 2018-2022 Swiss Federal Railways\n *\n * This program and the accompanying materials are made\n * available under the terms of the Eclipse Public License 2.0\n * which is available at https://www.eclipse.org/legal/epl-2.0/\n *\n * SPDX-License-Identifier: EPL-2.0\n */\n\nimport {Injectable} from '@angular/core';\nimport {APP_IDENTITY, Handler, IntentInterceptor, IntentMessage, mapToBody, MessageClient, MessageHeaders, ResponseStatusCodes} from '@scion/microfrontend-platform';\nimport {WorkbenchCapabilities, WorkbenchPopupCapability, WorkbenchPopupReferrer, ɵPopupContext, ɵWorkbenchCommands, ɵWorkbenchPopupCommand} from '@scion/workbench-client';\nimport {MicrofrontendPopupComponent} from './microfrontend-popup.component';\nimport {Observable} from 'rxjs';\nimport {Logger, LoggerNames} from '../../logging';\nimport {Beans} from '@scion/toolkit/bean-manager';\nimport {stringifyError} from '../../common/stringify-error.util';\nimport {Arrays, Maps} from '@scion/toolkit/util';\nimport {PopupService} from '../../popup/popup.service';\nimport {PopupOrigin} from '../../popup/popup.origin';\nimport {WorkbenchViewRegistry} from '../../view/workbench-view.registry';\nimport {MicrofrontendHostPopupComponent} from '../microfrontend-host-popup/microfrontend-host-popup.component';\nimport {MicrofrontendWorkbenchView} from '../microfrontend-view/microfrontend-workbench-view.model';\n\n/**\n * Handles popup intents, instructing the workbench to open a popup with the microfrontend declared on the resolved capability.\n *\n * Microfrontends of the host are displayed in {@link MicrofrontendHostPopupComponent}, microfrontends of other applications in {@link MicrofrontendPopupComponent}.\n *\n * Popup intents are handled in this interceptor and are not transported to the providing application, enabling support for applications\n * that are not connected to the SCION Workbench.\n */\n@Injectable(/* DO NOT PROVIDE via 'providedIn' metadata as only registered if microfrontend support is enabled. */)\nexport class MicrofrontendPopupIntentHandler implements IntentInterceptor {\n\n  private _openedPopups = new Set<string>();\n\n  constructor(private _popupService: PopupService,\n              private _viewRegistry: WorkbenchViewRegistry,\n              private _logger: Logger) {\n  }\n\n  /**\n   * Popup intents are handled in this interceptor and then swallowed.\n   */\n  public intercept(intentMessage: IntentMessage, next: Handler<IntentMessage>): Promise<void> {\n    if (intentMessage.intent.type === WorkbenchCapabilities.Popup) {\n      // Do not block the call until the popup is closed.\n      // Otherwise, the caller may receive a timeout error if not closing the popup before delivery confirmation expires.\n      this.consumePopupIntent(intentMessage).catch(error => this._logger.error('[PopupOpenError] Failed to open popup.', LoggerNames.MICROFRONTEND, intentMessage, error));\n      return Promise.resolve();\n    }\n    else {\n      return next.handle(intentMessage);\n    }\n  }\n\n  private async consumePopupIntent(message: IntentMessage<ɵWorkbenchPopupCommand>): Promise<void> {\n    const popupId = message.body!.popupId;\n    const replyTo = message.headers.get(MessageHeaders.ReplyTo);\n\n    // Ignore subsequent intents if a popup is already open, as it would lead to the first popup being closed.\n    if (this._openedPopups.has(popupId)) {\n      this._logger.warn('Ignoring popup intent because multiple popup providers found that match the popup intent. Most likely this is not intended and may indicate an incorrect manifest configuration.', message.intent);\n      return;\n    }\n\n    this._openedPopups.add(popupId);\n    try {\n      const result = await this.openPopup(message);\n      // Use 'Beans.opt' to not error if the platform is destroyed, e.g., in tests if not closing popups.\n      await Beans.opt(MessageClient)?.publish(replyTo, result, {headers: new Map().set(MessageHeaders.Status, ResponseStatusCodes.TERMINAL)});\n    }\n    catch (error) {\n      // Use 'Beans.opt' to not error if the platform is destroyed, e.g., in tests if not closing popups.\n      await Beans.opt(MessageClient)?.publish(replyTo, stringifyError(error), {headers: new Map().set(MessageHeaders.Status, ResponseStatusCodes.ERROR)});\n    }\n    finally {\n      this._openedPopups.delete(popupId);\n    }\n  }\n\n  /**\n   * Opens the microfrontend declared by the resolved capability in a popup.\n   */\n  private async openPopup(message: IntentMessage<ɵWorkbenchPopupCommand>): Promise<any> {\n    const command = message.body!;\n    const capability = message.capability as WorkbenchPopupCapability;\n    const isHostProvider = capability.metadata!.appSymbolicName === Beans.get(APP_IDENTITY);\n    this._logger.debug(() => 'Handling microfrontend popup command', LoggerNames.MICROFRONTEND, command);\n\n    const popupContext: ɵPopupContext = {\n      popupId: command.popupId,\n      capability: capability,\n      params: new Map([\n        ...Maps.coerce(message.intent.params),\n        ...Maps.coerce(message.intent.qualifier),\n      ]),\n      closeOnFocusLost: command.closeStrategy?.onFocusLost ?? true,\n      referrer: this.getReferrer(command),\n    };\n\n    return this._popupService.open({\n      id: command.popupId,\n      component: isHostProvider ? MicrofrontendHostPopupComponent : MicrofrontendPopupComponent,\n      input: popupContext,\n      anchor: this.observePopupOrigin$(command),\n      context: command.context,\n      align: command.align,\n      size: capability.properties?.size,\n      closeStrategy: isHostProvider ? command.closeStrategy : {\n        ...command.closeStrategy,\n        onFocusLost: false, // Closing the popup on focus loss is handled in {MicrofrontendPopupComponent}\n      },\n      cssClass: Arrays.coerce(capability.properties?.cssClass).concat(Arrays.coerce(command.cssClass)),\n    });\n  }\n\n  /**\n   * Constructs an Observable that, upon subscription, emits the position of the popup anchor, and then each time it is repositioned.\n   */\n  private observePopupOrigin$(command: ɵWorkbenchPopupCommand): Observable<PopupOrigin> {\n    return Beans.get(MessageClient).observe$<PopupOrigin>(ɵWorkbenchCommands.popupOriginTopic(command.popupId)).pipe(mapToBody());\n  }\n\n  /**\n   * Returns information about the context in which a popup was opened.\n   */\n  private getReferrer(command: ɵWorkbenchPopupCommand): WorkbenchPopupReferrer {\n    if (!command.context?.viewId) {\n      return {};\n    }\n\n    const view = this._viewRegistry.get(command.context.viewId);\n    return {\n      viewId: view.id,\n      viewCapabilityId: view.adapt(MicrofrontendWorkbenchView)?.capability.metadata!.id,\n    };\n  }\n}\n"]}
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"microfrontend-popup-intent-handler.interceptor.js","sourceRoot":"","sources":["../../../../../../../projects/scion/workbench/src/lib/microfrontend-platform/microfrontend-popup/microfrontend-popup-intent-handler.interceptor.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright (c) 2018-2022 Swiss Federal Railways\n *\n * This program and the accompanying materials are made\n * available under the terms of the Eclipse Public License 2.0\n * which is available at https://www.eclipse.org/legal/epl-2.0/\n *\n * SPDX-License-Identifier: EPL-2.0\n */\n\nimport {inject, Injectable} from '@angular/core';\nimport {APP_IDENTITY, Handler, IntentInterceptor, IntentMessage, mapToBody, MessageClient, MessageHeaders, ResponseStatusCodes} from '@scion/microfrontend-platform';\nimport {WorkbenchCapabilities, WorkbenchPopupCapability, WorkbenchPopupReferrer, ɵPopupContext, ɵWorkbenchCommands, ɵWorkbenchPopupCommand} from '@scion/workbench-client';\nimport {MicrofrontendPopupComponent} from './microfrontend-popup.component';\nimport {Observable} from 'rxjs';\nimport {Logger, LoggerNames} from '../../logging';\nimport {Beans} from '@scion/toolkit/bean-manager';\nimport {stringifyError} from '../../common/stringify-error.util';\nimport {Arrays, Maps} from '@scion/toolkit/util';\nimport {PopupService} from '../../popup/popup.service';\nimport {PopupOrigin} from '../../popup/popup.origin';\nimport {WORKBENCH_VIEW_REGISTRY} from '../../view/workbench-view.registry';\nimport {MicrofrontendHostPopupComponent} from '../microfrontend-host-popup/microfrontend-host-popup.component';\nimport {MicrofrontendWorkbenchView} from '../microfrontend-view/microfrontend-workbench-view.model';\n\n/**\n * Handles popup intents, instructing the workbench to open a popup with the microfrontend declared on the resolved capability.\n *\n * Microfrontends of the host are displayed in {@link MicrofrontendHostPopupComponent}, microfrontends of other applications in {@link MicrofrontendPopupComponent}.\n *\n * Popup intents are handled in this interceptor and are not transported to the providing application, enabling support for applications\n * that are not connected to the SCION Workbench.\n */\n@Injectable(/* DO NOT PROVIDE via 'providedIn' metadata as only registered if microfrontend support is enabled. */)\nexport class MicrofrontendPopupIntentHandler implements IntentInterceptor {\n\n  private readonly _popupService = inject(PopupService);\n  private readonly _viewRegistry = inject(WORKBENCH_VIEW_REGISTRY);\n  private readonly _logger = inject(Logger);\n  private readonly _openedPopups = new Set<string>();\n\n  /**\n   * Popup intents are handled in this interceptor and then swallowed.\n   */\n  public intercept(intentMessage: IntentMessage, next: Handler<IntentMessage>): Promise<void> {\n    if (intentMessage.intent.type === WorkbenchCapabilities.Popup) {\n      // Do not block the call until the popup is closed.\n      // Otherwise, the caller may receive a timeout error if not closing the popup before delivery confirmation expires.\n      this.consumePopupIntent(intentMessage).catch(error => this._logger.error('[PopupOpenError] Failed to open popup.', LoggerNames.MICROFRONTEND, intentMessage, error));\n      return Promise.resolve();\n    }\n    else {\n      return next.handle(intentMessage);\n    }\n  }\n\n  private async consumePopupIntent(message: IntentMessage<ɵWorkbenchPopupCommand>): Promise<void> {\n    const popupId = message.body!.popupId;\n    const replyTo = message.headers.get(MessageHeaders.ReplyTo);\n\n    // Ignore subsequent intents if a popup is already open, as it would lead to the first popup being closed.\n    if (this._openedPopups.has(popupId)) {\n      this._logger.warn('Ignoring popup intent because multiple popup providers found that match the popup intent. Most likely this is not intended and may indicate an incorrect manifest configuration.', message.intent);\n      return;\n    }\n\n    this._openedPopups.add(popupId);\n    try {\n      const result = await this.openPopup(message);\n      // Use 'Beans.opt' to not error if the platform is destroyed, e.g., in tests if not closing popups.\n      await Beans.opt(MessageClient)?.publish(replyTo, result, {headers: new Map().set(MessageHeaders.Status, ResponseStatusCodes.TERMINAL)});\n    }\n    catch (error) {\n      // Use 'Beans.opt' to not error if the platform is destroyed, e.g., in tests if not closing popups.\n      await Beans.opt(MessageClient)?.publish(replyTo, stringifyError(error), {headers: new Map().set(MessageHeaders.Status, ResponseStatusCodes.ERROR)});\n    }\n    finally {\n      this._openedPopups.delete(popupId);\n    }\n  }\n\n  /**\n   * Opens the microfrontend declared by the resolved capability in a popup.\n   */\n  private async openPopup(message: IntentMessage<ɵWorkbenchPopupCommand>): Promise<any> {\n    const command = message.body!;\n    const capability = message.capability as WorkbenchPopupCapability;\n    const isHostProvider = capability.metadata!.appSymbolicName === Beans.get(APP_IDENTITY);\n    this._logger.debug(() => 'Handling microfrontend popup command', LoggerNames.MICROFRONTEND, command);\n\n    const popupContext: ɵPopupContext = {\n      popupId: command.popupId,\n      capability: capability,\n      params: new Map([\n        ...Maps.coerce(message.intent.params),\n        ...Maps.coerce(message.intent.qualifier),\n      ]),\n      closeOnFocusLost: command.closeStrategy?.onFocusLost ?? true,\n      referrer: this.getReferrer(command),\n    };\n\n    return this._popupService.open({\n      id: command.popupId,\n      component: isHostProvider ? MicrofrontendHostPopupComponent : MicrofrontendPopupComponent,\n      input: popupContext,\n      anchor: this.observePopupOrigin$(command),\n      context: command.context,\n      align: command.align,\n      size: capability.properties?.size,\n      closeStrategy: isHostProvider ? command.closeStrategy : {\n        ...command.closeStrategy,\n        onFocusLost: false, // Closing the popup on focus loss is handled in {MicrofrontendPopupComponent}\n      },\n      cssClass: Arrays.coerce(capability.properties?.cssClass).concat(Arrays.coerce(command.cssClass)),\n    });\n  }\n\n  /**\n   * Constructs an Observable that, upon subscription, emits the position of the popup anchor, and then each time it is repositioned.\n   */\n  private observePopupOrigin$(command: ɵWorkbenchPopupCommand): Observable<PopupOrigin> {\n    return Beans.get(MessageClient).observe$<PopupOrigin>(ɵWorkbenchCommands.popupOriginTopic(command.popupId)).pipe(mapToBody());\n  }\n\n  /**\n   * Returns information about the context in which a popup was opened.\n   */\n  private getReferrer(command: ɵWorkbenchPopupCommand): WorkbenchPopupReferrer {\n    if (!command.context?.viewId) {\n      return {};\n    }\n\n    const view = this._viewRegistry.get(command.context.viewId);\n    return {\n      viewId: view.id,\n      viewCapabilityId: view.adapt(MicrofrontendWorkbenchView)?.capability.metadata!.id,\n    };\n  }\n}\n"]}