@scion/workbench 17.0.0-beta.5 → 17.0.0-beta.7

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

@@ -0,0 +1,30 @@
+import { Injectable } from '@angular/core';
+import { WorkbenchCapabilities } from '@scion/workbench-client';
+import * as i0 from "@angular/core";
+/**
+ * Asserts view capabilities to have required properties and assigns each view capability a stable identifer required for persistent navigation.
+ */
+export class MicrofrontendViewCapabilityValidator {
+    async intercept(capability) {
+        if (capability.type !== WorkbenchCapabilities.View) {
+            return capability;
+        }
+        const viewCapability = capability;
+        // Assert the view capability to have a qualifier set.
+        if (!viewCapability.qualifier || !Object.keys(viewCapability.qualifier).length) {
+            throw Error(`[NullQualifierError] View capability requires a qualifier [capability=${JSON.stringify(viewCapability)}]`);
+        }
+        // Assert the view capability to have a path set.
+        const path = viewCapability.properties?.path;
+        if (path === undefined || path === null) {
+            throw Error(`[NullPathError] View capability requires a path to the microfrontend in its properties [capability=${JSON.stringify(viewCapability)}]`);
+        }
+        return capability;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: MicrofrontendViewCapabilityValidator, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: MicrofrontendViewCapabilityValidator }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: MicrofrontendViewCapabilityValidator, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,123 @@
+/*
+ * Copyright (c) 2018-2022 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 { MicrofrontendViewRoutes } from './microfrontend-view-routes';
+import { LoggerNames } from '../../logging';
+import { Beans } from '@scion/toolkit/bean-manager';
+import { Arrays, Dictionaries } from '@scion/toolkit/util';
+import { MicrofrontendWorkbenchView } from '../microfrontend-view/microfrontend-workbench-view.model';
+import * as i0 from "@angular/core";
+import * as i1 from "../../routing/workbench-router.service";
+import * as i2 from "../../view/workbench-view.registry";
+import * as i3 from "../../logging";
+/**
+ * Handles microfrontend view intents, instructing the workbench to navigate to the microfrontend of the resolved capability.
+ *
+ * View intents are handled in this interceptor and are not transported to the providing application, enabling support for applications
+ * that are not connected to the SCION Workbench.
+ */
+export class MicrofrontendViewIntentHandler {
+    constructor(_workbenchRouter, _viewRegistry, _logger) {
+        this._workbenchRouter = _workbenchRouter;
+        this._viewRegistry = _viewRegistry;
+        this._logger = _logger;
+    }
+    /**
+     * View intents are handled in this interceptor and then swallowed.
+     */
+    intercept(intentMessage, next) {
+        if (intentMessage.intent.type === WorkbenchCapabilities.View) {
+            return this.consumeViewIntent(intentMessage);
+        }
+        else {
+            return next.handle(intentMessage);
+        }
+    }
+    async consumeViewIntent(message) {
+        const replyTo = message.headers.get(MessageHeaders.ReplyTo);
+        const success = await this.navigate(message);
+        await Beans.get(MessageClient).publish(replyTo, success, { headers: new Map().set(MessageHeaders.Status, ResponseStatusCodes.TERMINAL) });
+    }
+    async navigate(message) {
+        const viewCapability = message.capability;
+        const intent = message.intent;
+        const extras = message.body ?? {};
+        const intentParams = Dictionaries.withoutUndefinedEntries(Dictionaries.coerce(intent.params));
+        const { urlParams, transientParams } = MicrofrontendViewRoutes.splitParams(intentParams, viewCapability);
+        const targets = this.resolveTargets(message, extras);
+        const routerNavigateCommand = extras.close ? [] : MicrofrontendViewRoutes.createMicrofrontendNavigateCommands(viewCapability.metadata.id, urlParams);
+        this._logger.debug(() => `Navigating to: ${viewCapability.properties.path}`, LoggerNames.MICROFRONTEND_ROUTING, routerNavigateCommand, viewCapability, transientParams);
+        const navigations = await Promise.all(Arrays.coerce(targets).map(target => {
+            return this._workbenchRouter.navigate(routerNavigateCommand, {
+                target,
+                activate: extras.activate,
+                close: extras.close,
+                blankInsertionIndex: extras.blankInsertionIndex,
+                cssClass: extras.cssClass,
+                state: Dictionaries.withoutUndefinedEntries({
+                    [MicrofrontendViewRoutes.STATE_TRANSIENT_PARAMS]: transientParams,
+                }),
+            });
+        }));
+        return navigations.every(Boolean);
+    }
+    /**
+     * Resolves the target(s) for this navigation.
+     */
+    resolveTargets(intentMessage, extras) {
+        // Closing a microfrontend view by viewId is not allowed, as this would violate the concept of intent-based view navigation.
+        if (extras.close && extras.target) {
+            throw Error(`[WorkbenchRouterError][IllegalArgumentError] The target must be empty if closing a view [target=${(extras.target)}]`);
+        }
+        if (extras.close) {
+            return this.resolvePresentViewIds(intentMessage, { matchWildcardParams: true }) ?? [];
+        }
+        if (!extras.target || extras.target === 'auto') {
+            return this.resolvePresentViewIds(intentMessage) ?? 'blank';
+        }
+        return extras.target;
+    }
+    /**
+     * Resolves opened views which match the given view intent.
+     * A view matches if its view capability and all its required parameters are equal.
+     *
+     * Allows matching wildcard parameters by setting the option `matchWildcardParameters` to `true`.
+     */
+    resolvePresentViewIds(intentMessage, options) {
+        const requiredParams = intentMessage.capability.params?.filter(param => param.required).map(param => param.name) ?? [];
+        const matchWildcardParams = options?.matchWildcardParams ?? false;
+        const viewIds = this._viewRegistry.views
+            .filter(view => {
+            const microfrontendWorkbenchView = view.adapt(MicrofrontendWorkbenchView);
+            if (!microfrontendWorkbenchView) {
+                return false;
+            }
+            // Test whether the capability matches.
+            if (microfrontendWorkbenchView.capability.metadata.id !== intentMessage.capability.metadata.id) {
+                return false;
+            }
+            // Test whether all "navigational" params match.
+            return requiredParams.every(name => {
+                const intentParamValue = intentMessage.intent.params.get(name);
+                return (matchWildcardParams && intentParamValue === '*') || intentParamValue === microfrontendWorkbenchView.params[name];
+            });
+        })
+            .map(view => view.id);
+        return viewIds.length ? viewIds : null;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: MicrofrontendViewIntentHandler, deps: [{ token: i1.WorkbenchRouter }, { token: i2.WorkbenchViewRegistry }, { token: i3.Logger }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: MicrofrontendViewIntentHandler }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.3", ngImport: i0, type: MicrofrontendViewIntentHandler, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.WorkbenchRouter }, { type: i2.WorkbenchViewRegistry }, { type: i3.Logger }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"microfrontend-view-intent-handler.interceptor.js","sourceRoot":"","sources":["../../../../../../../projects/scion/workbench/src/lib/microfrontend-platform/routing/microfrontend-view-intent-handler.interceptor.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAA4C,aAAa,EAAE,cAAc,EAAE,mBAAmB,EAAC,MAAM,+BAA+B,CAAC;AAC5I,OAAO,EAAC,UAAU,EAAC,MAAM,eAAe,CAAC;AACzC,OAAO,EAAC,qBAAqB,EAAqD,MAAM,yBAAyB,CAAC;AAElH,OAAO,EAAC,uBAAuB,EAAC,MAAM,6BAA6B,CAAC;AACpE,OAAO,EAAS,WAAW,EAAC,MAAM,eAAe,CAAC;AAClD,OAAO,EAAC,KAAK,EAAC,MAAM,6BAA6B,CAAC;AAClD,OAAO,EAAC,MAAM,EAAE,YAAY,EAAC,MAAM,qBAAqB,CAAC;AAEzD,OAAO,EAAC,0BAA0B,EAAC,MAAM,0DAA0D,CAAC;;;;;AAEpG;;;;;GAKG;AAEH,MAAM,OAAO,8BAA8B;IAEzC,YAAoB,gBAAiC,EACjC,aAAoC,EACpC,OAAe;QAFf,qBAAgB,GAAhB,gBAAgB,CAAiB;QACjC,kBAAa,GAAb,aAAa,CAAuB;QACpC,YAAO,GAAP,OAAO,CAAQ;IACnC,CAAC;IAED;;OAEG;IACI,SAAS,CAAC,aAA4B,EAAE,IAA4B;QACzE,IAAI,aAAa,CAAC,MAAM,CAAC,IAAI,KAAK,qBAAqB,CAAC,IAAI,EAAE;YAC5D,OAAO,IAAI,CAAC,iBAAiB,CAAC,aAAa,CAAC,CAAC;SAC9C;aACI;YACH,OAAO,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC;SACnC;IACH,CAAC;IAEO,KAAK,CAAC,iBAAiB,CAAC,OAA6D;QAC3F,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC;QAC5D,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;QAC7C,MAAM,KAAK,CAAC,GAAG,CAAC,aAAa,CAAC,CAAC,OAAO,CAAC,OAAO,EAAE,OAAO,EAAE,EAAC,OAAO,EAAE,IAAI,GAAG,EAAE,CAAC,GAAG,CAAC,cAAc,CAAC,MAAM,EAAE,mBAAmB,CAAC,QAAQ,CAAC,EAAC,CAAC,CAAC;IAC1I,CAAC;IAEO,KAAK,CAAC,QAAQ,CAAC,OAA6D;QAClF,MAAM,cAAc,GAAG,OAAO,CAAC,UAAqC,CAAC;QACrE,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;QAC9B,MAAM,MAAM,GAA8B,OAAO,CAAC,IAAI,IAAI,EAAE,CAAC;QAE7D,MAAM,YAAY,GAAG,YAAY,CAAC,uBAAuB,CAAC,YAAY,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC;QAC9F,MAAM,EAAC,SAAS,EAAE,eAAe,EAAC,GAAG,uBAAuB,CAAC,WAAW,CAAC,YAAY,EAAE,cAAc,CAAC,CAAC;QACvG,MAAM,OAAO,GAAG,IAAI,CAAC,cAAc,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;QACrD,MAAM,qBAAqB,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,uBAAuB,CAAC,mCAAmC,CAAC,cAAc,CAAC,QAAS,CAAC,EAAE,EAAE,SAAS,CAAC,CAAC;QAEtJ,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,kBAAkB,cAAc,CAAC,UAAU,CAAC,IAAI,EAAE,EAAE,WAAW,CAAC,qBAAqB,EAAE,qBAAqB,EAAE,cAAc,EAAE,eAAe,CAAC,CAAC;QACxK,MAAM,WAAW,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE;YACxE,OAAO,IAAI,CAAC,gBAAgB,CAAC,QAAQ,CAAC,qBAAqB,EAAE;gBAC3D,MAAM;gBACN,QAAQ,EAAE,MAAM,CAAC,QAAQ;gBACzB,KAAK,EAAE,MAAM,CAAC,KAAK;gBACnB,mBAAmB,EAAE,MAAM,CAAC,mBAAmB;gBAC/C,QAAQ,EAAE,MAAM,CAAC,QAAQ;gBACzB,KAAK,EAAE,YAAY,CAAC,uBAAuB,CAAC;oBAC1C,CAAC,uBAAuB,CAAC,sBAAsB,CAAC,EAAE,eAAe;iBAClE,CAAC;aACH,CAAC,CAAC;QACL,CAAC,CAAC,CAAC,CAAC;QACJ,OAAO,WAAW,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;IACpC,CAAC;IAED;;OAEG;IACK,cAAc,CAAC,aAA4B,EAAE,MAAiC;QACpF,4HAA4H;QAC5H,IAAI,MAAM,CAAC,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE;YACjC,MAAM,KAAK,CAAC,mGAAmG,CAAC,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;SACpI;QACD,IAAI,MAAM,CAAC,KAAK,EAAE;YAChB,OAAO,IAAI,CAAC,qBAAqB,CAAC,aAAa,EAAE,EAAC,mBAAmB,EAAE,IAAI,EAAC,CAAC,IAAI,EAAE,CAAC;SACrF;QACD,IAAI,CAAC,MAAM,CAAC,MAAM,IAAI,MAAM,CAAC,MAAM,KAAK,MAAM,EAAE;YAC9C,OAAO,IAAI,CAAC,qBAAqB,CAAC,aAAa,CAAC,IAAI,OAAO,CAAC;SAC7D;QACD,OAAO,MAAM,CAAC,MAAM,CAAC;IACvB,CAAC;IAED;;;;;OAKG;IACK,qBAAqB,CAAC,aAA4B,EAAE,OAAyC;QACnG,MAAM,cAAc,GAAG,aAAa,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC;QACvH,MAAM,mBAAmB,GAAG,OAAO,EAAE,mBAAmB,IAAI,KAAK,CAAC;QAElE,MAAM,OAAO,GAAG,IAAI,CAAC,aAAa,CAAC,KAAK;aACrC,MAAM,CAAC,IAAI,CAAC,EAAE;YACb,MAAM,0BAA0B,GAAG,IAAI,CAAC,KAAK,CAAC,0BAA0B,CAAC,CAAC;YAC1E,IAAI,CAAC,0BAA0B,EAAE;gBAC/B,OAAO,KAAK,CAAC;aACd;YAED,uCAAuC;YACvC,IAAI,0BAA0B,CAAC,UAAU,CAAC,QAAS,CAAC,EAAE,KAAK,aAAa,CAAC,UAAU,CAAC,QAAS,CAAC,EAAE,EAAE;gBAChG,OAAO,KAAK,CAAC;aACd;YAED,gDAAgD;YAChD,OAAO,cAAc,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE;gBACjC,MAAM,gBAAgB,GAAG,aAAa,CAAC,MAAM,CAAC,MAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;gBAChE,OAAO,CAAC,mBAAmB,IAAI,gBAAgB,KAAK,GAAG,CAAC,IAAI,gBAAgB,KAAK,0BAA0B,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;YAC3H,CAAC,CAAC,CAAC;QACL,CAAC,CAAC;aACD,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QAExB,OAAO,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC;IACzC,CAAC;8GAnGU,8BAA8B;kHAA9B,8BAA8B;;2FAA9B,8BAA8B;kBAD1C,UAAU","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 {Handler, IntentInterceptor, IntentMessage, MessageClient, MessageHeaders, ResponseStatusCodes} from '@scion/microfrontend-platform';\nimport {Injectable} from '@angular/core';\nimport {WorkbenchCapabilities, WorkbenchNavigationExtras, WorkbenchViewCapability} from '@scion/workbench-client';\nimport {WorkbenchRouter} from '../../routing/workbench-router.service';\nimport {MicrofrontendViewRoutes} from './microfrontend-view-routes';\nimport {Logger, LoggerNames} from '../../logging';\nimport {Beans} from '@scion/toolkit/bean-manager';\nimport {Arrays, Dictionaries} from '@scion/toolkit/util';\nimport {WorkbenchViewRegistry} from '../../view/workbench-view.registry';\nimport {MicrofrontendWorkbenchView} from '../microfrontend-view/microfrontend-workbench-view.model';\n\n/**\n * Handles microfrontend view intents, instructing the workbench to navigate to the microfrontend of the resolved capability.\n *\n * View 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 MicrofrontendViewIntentHandler implements IntentInterceptor {\n\n  constructor(private _workbenchRouter: WorkbenchRouter,\n              private _viewRegistry: WorkbenchViewRegistry,\n              private _logger: Logger) {\n  }\n\n  /**\n   * View 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.View) {\n      return this.consumeViewIntent(intentMessage);\n    }\n    else {\n      return next.handle(intentMessage);\n    }\n  }\n\n  private async consumeViewIntent(message: IntentMessage<WorkbenchNavigationExtras | undefined>): Promise<void> {\n    const replyTo = message.headers.get(MessageHeaders.ReplyTo);\n    const success = await this.navigate(message);\n    await Beans.get(MessageClient).publish(replyTo, success, {headers: new Map().set(MessageHeaders.Status, ResponseStatusCodes.TERMINAL)});\n  }\n\n  private async navigate(message: IntentMessage<WorkbenchNavigationExtras | undefined>): Promise<boolean> {\n    const viewCapability = message.capability as WorkbenchViewCapability;\n    const intent = message.intent;\n    const extras: WorkbenchNavigationExtras = message.body ?? {};\n\n    const intentParams = Dictionaries.withoutUndefinedEntries(Dictionaries.coerce(intent.params));\n    const {urlParams, transientParams} = MicrofrontendViewRoutes.splitParams(intentParams, viewCapability);\n    const targets = this.resolveTargets(message, extras);\n    const routerNavigateCommand = extras.close ? [] : MicrofrontendViewRoutes.createMicrofrontendNavigateCommands(viewCapability.metadata!.id, urlParams);\n\n    this._logger.debug(() => `Navigating to: ${viewCapability.properties.path}`, LoggerNames.MICROFRONTEND_ROUTING, routerNavigateCommand, viewCapability, transientParams);\n    const navigations = await Promise.all(Arrays.coerce(targets).map(target => {\n      return this._workbenchRouter.navigate(routerNavigateCommand, {\n        target,\n        activate: extras.activate,\n        close: extras.close,\n        blankInsertionIndex: extras.blankInsertionIndex,\n        cssClass: extras.cssClass,\n        state: Dictionaries.withoutUndefinedEntries({\n          [MicrofrontendViewRoutes.STATE_TRANSIENT_PARAMS]: transientParams,\n        }),\n      });\n    }));\n    return navigations.every(Boolean);\n  }\n\n  /**\n   * Resolves the target(s) for this navigation.\n   */\n  private resolveTargets(intentMessage: IntentMessage, extras: WorkbenchNavigationExtras): string | string[] {\n    // Closing a microfrontend view by viewId is not allowed, as this would violate the concept of intent-based view navigation.\n    if (extras.close && extras.target) {\n      throw Error(`[WorkbenchRouterError][IllegalArgumentError] The target must be empty if closing a view [target=${(extras.target)}]`);\n    }\n    if (extras.close) {\n      return this.resolvePresentViewIds(intentMessage, {matchWildcardParams: true}) ?? [];\n    }\n    if (!extras.target || extras.target === 'auto') {\n      return this.resolvePresentViewIds(intentMessage) ?? 'blank';\n    }\n    return extras.target;\n  }\n\n  /**\n   * Resolves opened views which match the given view intent.\n   * A view matches if its view capability and all its required parameters are equal.\n   *\n   * Allows matching wildcard parameters by setting the option `matchWildcardParameters` to `true`.\n   */\n  private resolvePresentViewIds(intentMessage: IntentMessage, options?: {matchWildcardParams?: boolean}): string[] | null {\n    const requiredParams = intentMessage.capability.params?.filter(param => param.required).map(param => param.name) ?? [];\n    const matchWildcardParams = options?.matchWildcardParams ?? false;\n\n    const viewIds = this._viewRegistry.views\n      .filter(view => {\n        const microfrontendWorkbenchView = view.adapt(MicrofrontendWorkbenchView);\n        if (!microfrontendWorkbenchView) {\n          return false;\n        }\n\n        // Test whether the capability matches.\n        if (microfrontendWorkbenchView.capability.metadata!.id !== intentMessage.capability.metadata!.id) {\n          return false;\n        }\n\n        // Test whether all \"navigational\" params match.\n        return requiredParams.every(name => {\n          const intentParamValue = intentMessage.intent.params!.get(name);\n          return (matchWildcardParams && intentParamValue === '*') || intentParamValue === microfrontendWorkbenchView.params[name];\n        });\n      })\n      .map(view => view.id);\n\n    return viewIds.length ? viewIds : null;\n  }\n}\n"]}

package/esm2022/lib/microfrontend-platform/routing/microfrontend-view-routes.mjs

@@ -0,0 +1,98 @@
+/*
+ * 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 { PRIMARY_OUTLET, UrlSegment } from '@angular/router';
+import { ɵMicrofrontendRouteParams } from '@scion/workbench-client';
+import { inject, Injector, runInInjectionContext } from '@angular/core';
+import { RouterUtils } from '../../routing/router.util';
+import { WorkbenchNavigationalStates } from '../../routing/workbench-navigational-states';
+/**
+ * Provides functions and constants specific to microfrontend routes.
+ */
+export const MicrofrontendViewRoutes = {
+    /**
+     * Prefix to identify a microfrontend route.
+     */
+    ROUTE_PREFIX: '~',
+    /**
+     * Key for associating transient parameters with a navigation.
+     */
+    STATE_TRANSIENT_PARAMS: 'transientParams',
+    /**
+     * Custom URL matcher for microfrontend URLs, enabling transient parameters to be provided as regular route parameters.
+     *
+     * A microfrontend route consists of two segments:
+     * 1. An identifier segment (`~`) to identify a microfrontend route.
+     * 2. Capability segment to identify the microfrontend capability.
+     *
+     * Parameters are included in the second segment as matrix parameters.
+     *
+     * Example URL: `~/a538d2a;param1=value1;param2=value
+     *
+     * @see MicrofrontendViewRoutes.createMicrofrontendNavigateCommands
+     */
+    provideMicrofrontendRouteMatcher: () => {
+        const injector = inject(Injector);
+        return (segments, group, route) => {
+            if (!RouterUtils.isPrimaryRouteTarget(route.outlet ?? PRIMARY_OUTLET)) {
+                return null;
+            }
+            if (!MicrofrontendViewRoutes.isMicrofrontendRoute(segments)) {
+                return null;
+            }
+            const viewState = runInInjectionContext(injector, () => WorkbenchNavigationalStates.resolveViewState(route.outlet));
+            const transientParams = viewState?.[MicrofrontendViewRoutes.STATE_TRANSIENT_PARAMS] ?? {};
+            const posParams = Object.entries(transientParams).map(([name, value]) => [name, new UrlSegment(value, {})]);
+            return {
+                consumed: segments,
+                posParams: {
+                    ...Object.fromEntries(posParams),
+                    [ɵMicrofrontendRouteParams.ɵVIEW_CAPABILITY_ID]: segments[1],
+                },
+            };
+        };
+    },
+    /**
+     * Creates routing commands to navigate a microfrontend.
+     *
+     * Format: ['~', '<capabilityId>, {params}]
+     *
+     * @see MicrofrontendViewRoutes.provideMicrofrontendRouteMatcher
+     */
+    createMicrofrontendNavigateCommands: (viewCapabilityId, params) => {
+        if (Object.keys(params).length) {
+            return [MicrofrontendViewRoutes.ROUTE_PREFIX, viewCapabilityId, params];
+        }
+        else {
+            return [MicrofrontendViewRoutes.ROUTE_PREFIX, viewCapabilityId];
+        }
+    },
+    /**
+     * Tests given URL to be a microfrontend route.
+     */
+    isMicrofrontendRoute: (segments) => {
+        return segments.length === 2 && segments[0].path === MicrofrontendViewRoutes.ROUTE_PREFIX;
+    },
+    /**
+     * Splits given params into URL and transient params.
+     */
+    splitParams: (params, capability) => {
+        const transientParamNames = new Set(capability.params?.filter(param => param.transient).map(param => param.name));
+        return Object.entries(params).reduce((groups, [name, value]) => {
+            if (transientParamNames.has(name)) {
+                groups.transientParams[name] = value;
+            }
+            else {
+                groups.urlParams[name] = value;
+            }
+            return groups;
+        }, { urlParams: {}, transientParams: {} });
+    },
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"microfrontend-view-routes.js","sourceRoot":"","sources":["../../../../../../../projects/scion/workbench/src/lib/microfrontend-platform/routing/microfrontend-view-routes.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 {Params, PRIMARY_OUTLET, Route, UrlMatcher, UrlMatchResult, UrlSegment, UrlSegmentGroup} from '@angular/router';\nimport {WorkbenchViewCapability, ɵMicrofrontendRouteParams} from '@scion/workbench-client';\nimport {inject, Injector, runInInjectionContext} from '@angular/core';\nimport {RouterUtils} from '../../routing/router.util';\nimport {WorkbenchNavigationalStates} from '../../routing/workbench-navigational-states';\nimport {Commands} from '../../routing/routing.model';\n\n/**\n * Provides functions and constants specific to microfrontend routes.\n */\nexport const MicrofrontendViewRoutes = {\n\n  /**\n   * Prefix to identify a microfrontend route.\n   */\n  ROUTE_PREFIX: '~',\n\n  /**\n   * Key for associating transient parameters with a navigation.\n   */\n  STATE_TRANSIENT_PARAMS: 'transientParams',\n\n  /**\n   * Custom URL matcher for microfrontend URLs, enabling transient parameters to be provided as regular route parameters.\n   *\n   * A microfrontend route consists of two segments:\n   * 1. An identifier segment (`~`) to identify a microfrontend route.\n   * 2. Capability segment to identify the microfrontend capability.\n   *\n   * Parameters are included in the second segment as matrix parameters.\n   *\n   * Example URL: `~/a538d2a;param1=value1;param2=value\n   *\n   * @see MicrofrontendViewRoutes.createMicrofrontendNavigateCommands\n   */\n  provideMicrofrontendRouteMatcher: (): UrlMatcher => {\n    const injector = inject(Injector);\n\n    return (segments: UrlSegment[], group: UrlSegmentGroup, route: Route): UrlMatchResult | null => {\n      if (!RouterUtils.isPrimaryRouteTarget(route.outlet ?? PRIMARY_OUTLET)) {\n        return null;\n      }\n      if (!MicrofrontendViewRoutes.isMicrofrontendRoute(segments)) {\n        return null;\n      }\n      const viewState = runInInjectionContext(injector, () => WorkbenchNavigationalStates.resolveViewState(route.outlet!));\n      const transientParams = viewState?.[MicrofrontendViewRoutes.STATE_TRANSIENT_PARAMS] ?? {};\n      const posParams = Object.entries(transientParams).map(([name, value]) => [name, new UrlSegment(value, {})]);\n\n      return {\n        consumed: segments,\n        posParams: {\n          ...Object.fromEntries(posParams),\n          [ɵMicrofrontendRouteParams.ɵVIEW_CAPABILITY_ID]: segments[1],\n        },\n      };\n    };\n  },\n\n  /**\n   * Creates routing commands to navigate a microfrontend.\n   *\n   * Format: ['~', '<capabilityId>, {params}]\n   *\n   * @see MicrofrontendViewRoutes.provideMicrofrontendRouteMatcher\n   */\n  createMicrofrontendNavigateCommands: (viewCapabilityId: string, params: Params): Commands => {\n    if (Object.keys(params).length) {\n      return [MicrofrontendViewRoutes.ROUTE_PREFIX, viewCapabilityId, params];\n    }\n    else {\n      return [MicrofrontendViewRoutes.ROUTE_PREFIX, viewCapabilityId];\n    }\n  },\n\n  /**\n   * Tests given URL to be a microfrontend route.\n   */\n  isMicrofrontendRoute: (segments: UrlSegment[]): boolean => {\n    return segments.length === 2 && segments[0].path === MicrofrontendViewRoutes.ROUTE_PREFIX;\n  },\n\n  /**\n   * Splits given params into URL and transient params.\n   */\n  splitParams: (params: Params, capability: WorkbenchViewCapability): {urlParams: Params; transientParams: Params} => {\n    const transientParamNames = new Set(capability.params?.filter(param => param.transient).map(param => param.name));\n\n    return Object.entries(params).reduce((groups, [name, value]) => {\n      if (transientParamNames.has(name)) {\n        groups.transientParams[name] = value;\n      }\n      else {\n        groups.urlParams[name] = value;\n      }\n      return groups;\n    }, {urlParams: {} as Params, transientParams: {} as Params});\n  },\n} as const;\n"]}

package/esm2022/lib/microfrontend-platform/workbench-microfrontend-support.mjs

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018-2022 Swiss Federal Railways
+ * 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
@@ -13,20 +13,24 @@ import { MicrofrontendPlatformInitializer } from './initialization/microfrontend
 import { APP_IDENTITY, IntentClient, ManifestService, MessageClient, MicrofrontendPlatformConfig, OutletRouter, PlatformPropertyService } from '@scion/microfrontend-platform';
 import { MICROFRONTEND_PLATFORM_POST_STARTUP, WORKBENCH_STARTUP } from '../startup/workbench-initializer';
 import { Beans } from '@scion/toolkit/bean-manager';
-import { WorkbenchMessageBoxService, WorkbenchNotificationService, WorkbenchPopupService, WorkbenchRouter, ɵMicrofrontendRouteParams } from '@scion/workbench-client';
+import { WorkbenchDialogService, WorkbenchMessageBoxService, WorkbenchNotificationService, WorkbenchPopupService, WorkbenchRouter } from '@scion/workbench-client';
 import { NgZoneObservableDecorator } from './initialization/ng-zone-observable-decorator';
 import { MicrofrontendViewCommandHandler } from './microfrontend-view/microfrontend-view-command-handler.service';
 import { MicrofrontendMessageBoxIntentHandler } from './microfrontend-message-box/microfrontend-message-box-intent-handler.service';
 import { MicrofrontendNotificationIntentHandler } from './microfrontend-notification/microfrontend-notification-intent-handler.service';
-import { MicrofrontendViewIntentInterceptor } from './routing/microfrontend-view-intent-interceptor.service';
-import { MicrofrontendPopupIntentInterceptor } from './microfrontend-popup/microfrontend-popup-intent-interceptor.service';
+import { MicrofrontendViewIntentHandler } from './routing/microfrontend-view-intent-handler.interceptor';
+import { MicrofrontendPopupIntentHandler } from './microfrontend-popup/microfrontend-popup-intent-handler.interceptor';
 import { WorkbenchHostManifestInterceptor } from './initialization/workbench-host-manifest-interceptor.service';
 import { ROUTES } from '@angular/router';
 import { MicrofrontendViewComponent } from './microfrontend-view/microfrontend-view.component';
-import { MicrofrontendViewRoutes } from './routing/microfrontend-routes';
-import { MicrofrontendViewCapabilityInterceptor } from './routing/microfrontend-view-capability-interceptor.service';
-import { MicrofrontendPopupCapabilityInterceptor } from './microfrontend-popup/microfrontend-popup-capability-interceptor.service';
+import { MicrofrontendViewRoutes } from './routing/microfrontend-view-routes';
+import { MicrofrontendViewCapabilityValidator } from './routing/microfrontend-view-capability-validator.interceptor';
+import { MicrofrontendViewCapabilityIdAssigner } from './routing/microfrontend-view-capability-id-assigner.interceptor';
+import { MicrofrontendPopupCapabilityValidator } from './microfrontend-popup/microfrontend-popup-capability-validator.interceptor';
+import { MicrofrontendDialogIntentHandler } from './microfrontend-dialog/microfrontend-dialog-intent-handler.interceptor';
+import { MicrofrontendDialogCapabilityValidator } from './microfrontend-dialog/microfrontend-dialog-capability-validator.interceptor';
 import { Defined } from '@scion/toolkit/util';
+import './microfrontend-platform.config'; // DO NOT REMOVE to augment `MicrofrontendPlatformConfig` with `splash` property.
 import * as i0 from "@angular/core";
 import * as i1 from "../workbench-module-config";
 /**
@@ -65,13 +69,16 @@ export function provideWorkbenchMicrofrontendSupport(workbenchModuleConfig) {
             provide: MicrofrontendPlatformConfig,
             useFactory: () => Defined.orElseThrow(inject(MicrofrontendPlatformInitializer).config, () => Error('[MicrofrontendPlatformError] Illegal state: Microfrontend platform configuration not loaded.')),
         },
-        MicrofrontendViewIntentInterceptor,
-        MicrofrontendPopupIntentInterceptor,
-        MicrofrontendViewCapabilityInterceptor,
-        MicrofrontendPopupCapabilityInterceptor,
+        MicrofrontendViewIntentHandler,
+        MicrofrontendPopupIntentHandler,
+        MicrofrontendDialogIntentHandler,
+        MicrofrontendViewCapabilityValidator,
+        MicrofrontendViewCapabilityIdAssigner,
+        MicrofrontendPopupCapabilityValidator,
+        MicrofrontendDialogCapabilityValidator,
         NgZoneObservableDecorator,
         WorkbenchHostManifestInterceptor,
-        provideMicrofrontendRoutes(),
+        provideMicrofrontendRoute(),
         provideMicrofrontendPlatformBeans(),
         provideWorkbenchClientBeans(),
     ]);
@@ -112,35 +119,24 @@ function provideWorkbenchClientBeans() {
     return makeEnvironmentProviders([
         { provide: WorkbenchRouter, useFactory: () => Beans.get(WorkbenchRouter) },
         { provide: WorkbenchPopupService, useFactory: () => Beans.get(WorkbenchPopupService) },
+        { provide: WorkbenchDialogService, useFactory: () => Beans.get(WorkbenchDialogService) },
         { provide: WorkbenchMessageBoxService, useFactory: () => Beans.get(WorkbenchMessageBoxService) },
         { provide: WorkbenchNotificationService, useFactory: () => Beans.get(WorkbenchNotificationService) },
     ]);
 }
 /**
- * Provides routes used for the integration of microfrontends.
+ * Provides the route for integrating microfrontends.
  */
-function provideMicrofrontendRoutes() {
-    // Define route for embedding the microfrontend of a view capability.
-    const viewMicrofrontendRoute = {
-        /*
-         * Format: '~;{qualifier}/<viewCapabilityId>;{params}'
-         *  - '{qualifier}' as matrix params of the first URL segment (~)
-         *  - '{params}' as matrix params of the second URL segment (viewCapabilityId)
-         */
-        path: `${MicrofrontendViewRoutes.ROUTE_PREFIX}/:${ɵMicrofrontendRouteParams.ɵVIEW_CAPABILITY_ID}`,
-        component: MicrofrontendViewComponent,
-        /*
-         * In the microfrontend view integration, parameters can be marked as 'transient'. Transient parameters are not added as matrix
-         * parameters to the URL but passed via navigational state to the component by {@link NavigationStateResolver}. The component can
-         * access transient params as resolved data via `ActivatedRoute.data[WorkbenchRouteData.state][MicrofrontendNavigationalStates.transientParams]`.
-         *
-         * However, by default, the Angular router only runs resolvers when the route's path or matrix parameters change. For this reason, we configure
-         * the microfrontend route to always run resolvers, allowing the update of transient parameters without URL change.
-         */
-        runGuardsAndResolvers: 'always',
-    };
+function provideMicrofrontendRoute() {
     return makeEnvironmentProviders([
-        { provide: ROUTES, multi: true, useValue: viewMicrofrontendRoute },
+        {
+            provide: ROUTES,
+            multi: true,
+            useFactory: () => ({
+                matcher: MicrofrontendViewRoutes.provideMicrofrontendRouteMatcher(),
+                component: MicrofrontendViewComponent,
+            }),
+        },
     ]);
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"workbench-microfrontend-support.js","sourceRoot":"","sources":["../../../../../../projects/scion/workbench/src/lib/microfrontend-platform/workbench-microfrontend-support.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 {MicrofrontendPlatformConfigLoader} from './microfrontend-platform-config-loader';\nimport {EnvironmentProviders, inject, Injectable, makeEnvironmentProviders} from '@angular/core';\nimport {MicrofrontendPlatformInitializer} from './initialization/microfrontend-platform-initializer.service';\nimport {APP_IDENTITY, IntentClient, ManifestService, MessageClient, MicrofrontendPlatformConfig, OutletRouter, PlatformPropertyService} from '@scion/microfrontend-platform';\nimport {MICROFRONTEND_PLATFORM_POST_STARTUP, WORKBENCH_STARTUP} from '../startup/workbench-initializer';\nimport {Beans} from '@scion/toolkit/bean-manager';\nimport {WorkbenchMessageBoxService, WorkbenchNotificationService, WorkbenchPopupService, WorkbenchRouter, ɵMicrofrontendRouteParams} from '@scion/workbench-client';\nimport {NgZoneObservableDecorator} from './initialization/ng-zone-observable-decorator';\nimport {WorkbenchModuleConfig} from '../workbench-module-config';\nimport {MicrofrontendViewCommandHandler} from './microfrontend-view/microfrontend-view-command-handler.service';\nimport {MicrofrontendMessageBoxIntentHandler} from './microfrontend-message-box/microfrontend-message-box-intent-handler.service';\nimport {MicrofrontendNotificationIntentHandler} from './microfrontend-notification/microfrontend-notification-intent-handler.service';\nimport {MicrofrontendViewIntentInterceptor} from './routing/microfrontend-view-intent-interceptor.service';\nimport {MicrofrontendPopupIntentInterceptor} from './microfrontend-popup/microfrontend-popup-intent-interceptor.service';\nimport {WorkbenchHostManifestInterceptor} from './initialization/workbench-host-manifest-interceptor.service';\nimport {Route, ROUTES} from '@angular/router';\nimport {MicrofrontendViewComponent} from './microfrontend-view/microfrontend-view.component';\nimport {MicrofrontendViewRoutes} from './routing/microfrontend-routes';\nimport {MicrofrontendViewCapabilityInterceptor} from './routing/microfrontend-view-capability-interceptor.service';\nimport {MicrofrontendPopupCapabilityInterceptor} from './microfrontend-popup/microfrontend-popup-capability-interceptor.service';\nimport {Defined} from '@scion/toolkit/util';\n\n/**\n * Provides a set of DI providers to set up microfrontend support in the workbench.\n */\nexport function provideWorkbenchMicrofrontendSupport(workbenchModuleConfig: WorkbenchModuleConfig): EnvironmentProviders | [] {\n  if (!workbenchModuleConfig.microfrontendPlatform) {\n    return [];\n  }\n\n  return makeEnvironmentProviders([\n    {\n      provide: WORKBENCH_STARTUP,\n      useExisting: MicrofrontendPlatformInitializer,\n      multi: true,\n    },\n    {\n      provide: MicrofrontendPlatformConfigLoader,\n      useClass: typeof workbenchModuleConfig.microfrontendPlatform === 'function' ? workbenchModuleConfig.microfrontendPlatform : StaticMicrofrontendPlatformConfigLoader,\n    },\n    {\n      provide: MICROFRONTEND_PLATFORM_POST_STARTUP,\n      useClass: MicrofrontendViewCommandHandler,\n      multi: true,\n    },\n    {\n      provide: MICROFRONTEND_PLATFORM_POST_STARTUP,\n      useClass: MicrofrontendMessageBoxIntentHandler,\n      multi: true,\n    },\n    {\n      provide: MICROFRONTEND_PLATFORM_POST_STARTUP,\n      useClass: MicrofrontendNotificationIntentHandler,\n      multi: true,\n    },\n    {\n      provide: MicrofrontendPlatformConfig,\n      useFactory: () => Defined.orElseThrow(inject(MicrofrontendPlatformInitializer).config, () => Error('[MicrofrontendPlatformError] Illegal state: Microfrontend platform configuration not loaded.')),\n    },\n    MicrofrontendViewIntentInterceptor,\n    MicrofrontendPopupIntentInterceptor,\n    MicrofrontendViewCapabilityInterceptor,\n    MicrofrontendPopupCapabilityInterceptor,\n    NgZoneObservableDecorator,\n    WorkbenchHostManifestInterceptor,\n    provideMicrofrontendRoutes(),\n    provideMicrofrontendPlatformBeans(),\n    provideWorkbenchClientBeans(),\n  ]);\n}\n\n/**\n * Provides {@link WorkbenchModuleConfig.microfrontendPlatform} config as passed to {@link WorkbenchModule.forRoot}.\n */\n@Injectable(/* DO NOT PROVIDE via 'providedIn' metadata as registered under `MicrofrontendPlatformConfigLoader` DI token. */)\nclass StaticMicrofrontendPlatformConfigLoader implements MicrofrontendPlatformConfigLoader {\n\n  constructor(private _workbenchModuleConfig: WorkbenchModuleConfig) {\n  }\n\n  public async load(): Promise<MicrofrontendPlatformConfig> {\n    return this._workbenchModuleConfig.microfrontendPlatform! as MicrofrontendPlatformConfig;\n  }\n}\n\n/**\n * Provides beans of @scion/microfrontend-platform for DI.\n */\nfunction provideMicrofrontendPlatformBeans(): EnvironmentProviders {\n  return makeEnvironmentProviders([\n    {provide: APP_IDENTITY, useFactory: () => Beans.get(APP_IDENTITY)},\n    {provide: MessageClient, useFactory: () => Beans.get(MessageClient)},\n    {provide: IntentClient, useFactory: () => Beans.get(IntentClient)},\n    {provide: OutletRouter, useFactory: () => Beans.get(OutletRouter)},\n    {provide: ManifestService, useFactory: () => Beans.get(ManifestService)},\n    {provide: PlatformPropertyService, useFactory: () => Beans.get(PlatformPropertyService)},\n  ]);\n}\n\n/**\n * Provides beans of @scion/workbench-client for DI.\n */\nfunction provideWorkbenchClientBeans(): EnvironmentProviders {\n  return makeEnvironmentProviders([\n    {provide: WorkbenchRouter, useFactory: () => Beans.get(WorkbenchRouter)},\n    {provide: WorkbenchPopupService, useFactory: () => Beans.get(WorkbenchPopupService)},\n    {provide: WorkbenchMessageBoxService, useFactory: () => Beans.get(WorkbenchMessageBoxService)},\n    {provide: WorkbenchNotificationService, useFactory: () => Beans.get(WorkbenchNotificationService)},\n  ]);\n}\n\n/**\n * Provides routes used for the integration of microfrontends.\n */\nfunction provideMicrofrontendRoutes(): EnvironmentProviders {\n  // Define route for embedding the microfrontend of a view capability.\n  const viewMicrofrontendRoute: Route = {\n    /*\n     * Format: '~;{qualifier}/<viewCapabilityId>;{params}'\n     *  - '{qualifier}' as matrix params of the first URL segment (~)\n     *  - '{params}' as matrix params of the second URL segment (viewCapabilityId)\n     */\n    path: `${MicrofrontendViewRoutes.ROUTE_PREFIX}/:${ɵMicrofrontendRouteParams.ɵVIEW_CAPABILITY_ID}`,\n    component: MicrofrontendViewComponent,\n    /*\n     * In the microfrontend view integration, parameters can be marked as 'transient'. Transient parameters are not added as matrix\n     * parameters to the URL but passed via navigational state to the component by {@link NavigationStateResolver}. The component can\n     * access transient params as resolved data via `ActivatedRoute.data[WorkbenchRouteData.state][MicrofrontendNavigationalStates.transientParams]`.\n     *\n     * However, by default, the Angular router only runs resolvers when the route's path or matrix parameters change. For this reason, we configure\n     * the microfrontend route to always run resolvers, allowing the update of transient parameters without URL change.\n     */\n    runGuardsAndResolvers: 'always',\n  };\n\n  return makeEnvironmentProviders([\n    {provide: ROUTES, multi: true, useValue: viewMicrofrontendRoute},\n  ]);\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"workbench-microfrontend-support.js","sourceRoot":"","sources":["../../../../../../projects/scion/workbench/src/lib/microfrontend-platform/workbench-microfrontend-support.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 {MicrofrontendPlatformConfigLoader} from './microfrontend-platform-config-loader';\nimport {EnvironmentProviders, inject, Injectable, makeEnvironmentProviders} from '@angular/core';\nimport {MicrofrontendPlatformInitializer} from './initialization/microfrontend-platform-initializer.service';\nimport {APP_IDENTITY, IntentClient, ManifestService, MessageClient, MicrofrontendPlatformConfig, OutletRouter, PlatformPropertyService} from '@scion/microfrontend-platform';\nimport {MICROFRONTEND_PLATFORM_POST_STARTUP, WORKBENCH_STARTUP} from '../startup/workbench-initializer';\nimport {Beans} from '@scion/toolkit/bean-manager';\nimport {WorkbenchDialogService, WorkbenchMessageBoxService, WorkbenchNotificationService, WorkbenchPopupService, WorkbenchRouter} from '@scion/workbench-client';\nimport {NgZoneObservableDecorator} from './initialization/ng-zone-observable-decorator';\nimport {WorkbenchModuleConfig} from '../workbench-module-config';\nimport {MicrofrontendViewCommandHandler} from './microfrontend-view/microfrontend-view-command-handler.service';\nimport {MicrofrontendMessageBoxIntentHandler} from './microfrontend-message-box/microfrontend-message-box-intent-handler.service';\nimport {MicrofrontendNotificationIntentHandler} from './microfrontend-notification/microfrontend-notification-intent-handler.service';\nimport {MicrofrontendViewIntentHandler} from './routing/microfrontend-view-intent-handler.interceptor';\nimport {MicrofrontendPopupIntentHandler} from './microfrontend-popup/microfrontend-popup-intent-handler.interceptor';\nimport {WorkbenchHostManifestInterceptor} from './initialization/workbench-host-manifest-interceptor.service';\nimport {Route, ROUTES} from '@angular/router';\nimport {MicrofrontendViewComponent} from './microfrontend-view/microfrontend-view.component';\nimport {MicrofrontendViewRoutes} from './routing/microfrontend-view-routes';\nimport {MicrofrontendViewCapabilityValidator} from './routing/microfrontend-view-capability-validator.interceptor';\nimport {MicrofrontendViewCapabilityIdAssigner} from './routing/microfrontend-view-capability-id-assigner.interceptor';\nimport {MicrofrontendPopupCapabilityValidator} from './microfrontend-popup/microfrontend-popup-capability-validator.interceptor';\nimport {MicrofrontendDialogIntentHandler} from './microfrontend-dialog/microfrontend-dialog-intent-handler.interceptor';\nimport {MicrofrontendDialogCapabilityValidator} from './microfrontend-dialog/microfrontend-dialog-capability-validator.interceptor';\nimport {Defined} from '@scion/toolkit/util';\nimport './microfrontend-platform.config'; // DO NOT REMOVE to augment `MicrofrontendPlatformConfig` with `splash` property.\n\n/**\n * Provides a set of DI providers to set up microfrontend support in the workbench.\n */\nexport function provideWorkbenchMicrofrontendSupport(workbenchModuleConfig: WorkbenchModuleConfig): EnvironmentProviders | [] {\n  if (!workbenchModuleConfig.microfrontendPlatform) {\n    return [];\n  }\n\n  return makeEnvironmentProviders([\n    {\n      provide: WORKBENCH_STARTUP,\n      useExisting: MicrofrontendPlatformInitializer,\n      multi: true,\n    },\n    {\n      provide: MicrofrontendPlatformConfigLoader,\n      useClass: typeof workbenchModuleConfig.microfrontendPlatform === 'function' ? workbenchModuleConfig.microfrontendPlatform : StaticMicrofrontendPlatformConfigLoader,\n    },\n    {\n      provide: MICROFRONTEND_PLATFORM_POST_STARTUP,\n      useClass: MicrofrontendViewCommandHandler,\n      multi: true,\n    },\n    {\n      provide: MICROFRONTEND_PLATFORM_POST_STARTUP,\n      useClass: MicrofrontendMessageBoxIntentHandler,\n      multi: true,\n    },\n    {\n      provide: MICROFRONTEND_PLATFORM_POST_STARTUP,\n      useClass: MicrofrontendNotificationIntentHandler,\n      multi: true,\n    },\n    {\n      provide: MicrofrontendPlatformConfig,\n      useFactory: () => Defined.orElseThrow(inject(MicrofrontendPlatformInitializer).config, () => Error('[MicrofrontendPlatformError] Illegal state: Microfrontend platform configuration not loaded.')),\n    },\n    MicrofrontendViewIntentHandler,\n    MicrofrontendPopupIntentHandler,\n    MicrofrontendDialogIntentHandler,\n    MicrofrontendViewCapabilityValidator,\n    MicrofrontendViewCapabilityIdAssigner,\n    MicrofrontendPopupCapabilityValidator,\n    MicrofrontendDialogCapabilityValidator,\n    NgZoneObservableDecorator,\n    WorkbenchHostManifestInterceptor,\n    provideMicrofrontendRoute(),\n    provideMicrofrontendPlatformBeans(),\n    provideWorkbenchClientBeans(),\n  ]);\n}\n\n/**\n * Provides {@link WorkbenchModuleConfig.microfrontendPlatform} config as passed to {@link WorkbenchModule.forRoot}.\n */\n@Injectable(/* DO NOT PROVIDE via 'providedIn' metadata as registered under `MicrofrontendPlatformConfigLoader` DI token. */)\nclass StaticMicrofrontendPlatformConfigLoader implements MicrofrontendPlatformConfigLoader {\n\n  constructor(private _workbenchModuleConfig: WorkbenchModuleConfig) {\n  }\n\n  public async load(): Promise<MicrofrontendPlatformConfig> {\n    return this._workbenchModuleConfig.microfrontendPlatform! as MicrofrontendPlatformConfig;\n  }\n}\n\n/**\n * Provides beans of @scion/microfrontend-platform for DI.\n */\nfunction provideMicrofrontendPlatformBeans(): EnvironmentProviders {\n  return makeEnvironmentProviders([\n    {provide: APP_IDENTITY, useFactory: () => Beans.get(APP_IDENTITY)},\n    {provide: MessageClient, useFactory: () => Beans.get(MessageClient)},\n    {provide: IntentClient, useFactory: () => Beans.get(IntentClient)},\n    {provide: OutletRouter, useFactory: () => Beans.get(OutletRouter)},\n    {provide: ManifestService, useFactory: () => Beans.get(ManifestService)},\n    {provide: PlatformPropertyService, useFactory: () => Beans.get(PlatformPropertyService)},\n  ]);\n}\n\n/**\n * Provides beans of @scion/workbench-client for DI.\n */\nfunction provideWorkbenchClientBeans(): EnvironmentProviders {\n  return makeEnvironmentProviders([\n    {provide: WorkbenchRouter, useFactory: () => Beans.get(WorkbenchRouter)},\n    {provide: WorkbenchPopupService, useFactory: () => Beans.get(WorkbenchPopupService)},\n    {provide: WorkbenchDialogService, useFactory: () => Beans.get(WorkbenchDialogService)},\n    {provide: WorkbenchMessageBoxService, useFactory: () => Beans.get(WorkbenchMessageBoxService)},\n    {provide: WorkbenchNotificationService, useFactory: () => Beans.get(WorkbenchNotificationService)},\n  ]);\n}\n\n/**\n * Provides the route for integrating microfrontends.\n */\nfunction provideMicrofrontendRoute(): EnvironmentProviders {\n  return makeEnvironmentProviders([\n    {\n      provide: ROUTES,\n      multi: true,\n      useFactory: (): Route => ({\n        matcher: MicrofrontendViewRoutes.provideMicrofrontendRouteMatcher(),\n        component: MicrofrontendViewComponent,\n      }),\n    },\n  ]);\n}\n"]}