@luigi-project/client-support-angular 2.18.1-dev.20241230034 → 2.18.1-dev.20241240825

package/esm2022/lib/component/luigi.preload.component.mjs

@@ -0,0 +1,11 @@
+import { Component } from '@angular/core';
+import * as i0 from "@angular/core";
+export class LuigiPreloadComponent {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.10", ngImport: i0, type: LuigiPreloadComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.10", type: LuigiPreloadComponent, selector: "lib-client-support-angular", ngImport: i0, template: "<p luigipreload=\"luigipreload\"></p>\n" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.10", ngImport: i0, type: LuigiPreloadComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'lib-client-support-angular', template: "<p luigipreload=\"luigipreload\"></p>\n" }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibHVpZ2kucHJlbG9hZC5jb21wb25lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jbGllbnQtc3VwcG9ydC1hbmd1bGFyL3NyYy9saWIvY29tcG9uZW50L2x1aWdpLnByZWxvYWQuY29tcG9uZW50LnRzIiwiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvY2xpZW50LXN1cHBvcnQtYW5ndWxhci9zcmMvbGliL2NvbXBvbmVudC9sdWlnaS5wcmVsb2FkLmNvbXBvbmVudC5odG1sIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSxlQUFlLENBQUM7O0FBTTFDLE1BQU0sT0FBTyxxQkFBcUI7K0dBQXJCLHFCQUFxQjttR0FBckIscUJBQXFCLGtFQ05sQyx5Q0FDQTs7NEZES2EscUJBQXFCO2tCQUpqQyxTQUFTOytCQUNFLDRCQUE0QiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENvbXBvbmVudCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5AQ29tcG9uZW50KHtcbiAgc2VsZWN0b3I6ICdsaWItY2xpZW50LXN1cHBvcnQtYW5ndWxhcicsXG4gIHRlbXBsYXRlVXJsOiAnLi9sdWlnaS5wcmVsb2FkLmNvbXBvbmVudC5odG1sJyxcbn0pXG5leHBvcnQgY2xhc3MgTHVpZ2lQcmVsb2FkQ29tcG9uZW50IHt9XG4iLCI8cCBsdWlnaXByZWxvYWQ9XCJsdWlnaXByZWxvYWRcIj48L3A+XG4iXX0=

package/esm2022/lib/luigi-mock/luigi-mock.module.mjs

@@ -0,0 +1,40 @@
+import { APP_INITIALIZER, NgModule } from '@angular/core';
+import { LuigiMockEngine } from '@luigi-project/testing-utilities';
+import * as i0 from "@angular/core";
+// @dynamic
+/*
+ * This class mocks Luigi Core related functionality.
+ *
+ * Micro Frontends that use Luigi Client would usually communicate with Luigi Core
+ * back and forth. When testing Luigi Client based components, Luigi Core might
+ * not be present which leads into limitations on integration/e2e testing for standalone
+ * microfrontends.
+ *
+ * This module adds a hook to the window postMessage API by adding an event listener to the
+ * global message event of the window object and mocking the callback.
+ * In the normal workflow this message would picked up by Luigi Core which then sends the response back.
+ */
+export class LuigiMockModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.10", ngImport: i0, type: LuigiMockModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.10", ngImport: i0, type: LuigiMockModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.10", ngImport: i0, type: LuigiMockModule, providers: [
+            {
+                provide: APP_INITIALIZER,
+                useFactory: LuigiMockEngine.initPostMessageHook,
+                multi: true
+            }
+        ] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.10", ngImport: i0, type: LuigiMockModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    providers: [
+                        {
+                            provide: APP_INITIALIZER,
+                            useFactory: LuigiMockEngine.initPostMessageHook,
+                            multi: true
+                        }
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/luigi.angular.support.module.mjs

@@ -0,0 +1,70 @@
+import { NgModule } from '@angular/core';
+import { RouteReuseStrategy, RouterModule } from '@angular/router';
+import { LuigiPreloadComponent } from './component/luigi.preload.component';
+import { LuigiRouteStrategy } from './route/luigi-route-strategy';
+import { LuigiContextService } from './service/luigi-context.service';
+import { LuigiContextServiceImpl } from './service/luigi-context.service.impl';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+export const staticRoutes = [
+    // here an example if you want to specify that this component is a virtualTree element in Luigi Core navigation
+    {
+        path: 'luigi-client-support-preload',
+        component: LuigiPreloadComponent,
+        data: { fromVirtualTreeRoot: true }
+    },
+    // here an example if you want to specify that this component is a Luigi component and you want to change the navigation in Luigi core
+    {
+        path: 'luigi-client-support-preload',
+        component: LuigiPreloadComponent,
+        data: { luigiRoute: '/home/reload' }
+    },
+    /**
+     * here an example if you want to reuse the component and not recreating every time you navigate to it (a singleton Component)
+     * it requires in your module to redefine
+     */
+    {
+        path: 'luigi-client-support-preload=component',
+        component: LuigiPreloadComponent,
+        data: { reuse: true }
+    },
+    // here an example if you want to update modalPathParam on internal navigation
+    {
+        path: 'luigi-client-support-preload',
+        component: LuigiPreloadComponent,
+        data: { updateModalPathParam: true }
+    }
+];
+export class LuigiAngularSupportModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.10", ngImport: i0, type: LuigiAngularSupportModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.10", ngImport: i0, type: LuigiAngularSupportModule, declarations: [LuigiPreloadComponent], imports: [i1.RouterModule], exports: [LuigiPreloadComponent] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.10", ngImport: i0, type: LuigiAngularSupportModule, providers: [
+            {
+                provide: LuigiContextService,
+                useClass: LuigiContextServiceImpl
+            },
+            {
+                provide: RouteReuseStrategy,
+                useClass: LuigiRouteStrategy
+            }
+        ], imports: [RouterModule.forChild(staticRoutes)] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.10", ngImport: i0, type: LuigiAngularSupportModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [LuigiPreloadComponent],
+                    imports: [RouterModule.forChild(staticRoutes)],
+                    providers: [
+                        {
+                            provide: LuigiContextService,
+                            useClass: LuigiContextServiceImpl
+                        },
+                        {
+                            provide: RouteReuseStrategy,
+                            useClass: LuigiRouteStrategy
+                        }
+                    ],
+                    exports: [LuigiPreloadComponent]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/route/luigi-activated-route-snapshot-helper.mjs

@@ -0,0 +1,11 @@
+export class LuigiActivatedRouteSnapshotHelper {
+    // tslint:disable-next-line:variable-name
+    static { this._current = null; }
+    static getCurrent() {
+        return LuigiActivatedRouteSnapshotHelper._current;
+    }
+    static setCurrent(current) {
+        LuigiActivatedRouteSnapshotHelper._current = current;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibHVpZ2ktYWN0aXZhdGVkLXJvdXRlLXNuYXBzaG90LWhlbHBlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2NsaWVudC1zdXBwb3J0LWFuZ3VsYXIvc3JjL2xpYi9yb3V0ZS9sdWlnaS1hY3RpdmF0ZWQtcm91dGUtc25hcHNob3QtaGVscGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE1BQU0sT0FBTyxpQ0FBaUM7SUFDNUMseUNBQXlDO2FBQzFCLGFBQVEsR0FBNEIsSUFBMEMsQ0FBQztJQUU5RixNQUFNLENBQUMsVUFBVTtRQUNmLE9BQU8saUNBQWlDLENBQUMsUUFBUSxDQUFDO0lBQ3BELENBQUM7SUFFRCxNQUFNLENBQUMsVUFBVSxDQUFDLE9BQStCO1FBQy9DLGlDQUFpQyxDQUFDLFFBQVEsR0FBRyxPQUFPLENBQUM7SUFDdkQsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEFjdGl2YXRlZFJvdXRlU25hcHNob3QgfSBmcm9tICdAYW5ndWxhci9yb3V0ZXInO1xuXG5leHBvcnQgY2xhc3MgTHVpZ2lBY3RpdmF0ZWRSb3V0ZVNuYXBzaG90SGVscGVyIHtcbiAgLy8gdHNsaW50OmRpc2FibGUtbmV4dC1saW5lOnZhcmlhYmxlLW5hbWVcbiAgcHJpdmF0ZSBzdGF0aWMgX2N1cnJlbnQ6IEFjdGl2YXRlZFJvdXRlU25hcHNob3QgPSAobnVsbCBhcyB1bmtub3duKSBhcyBBY3RpdmF0ZWRSb3V0ZVNuYXBzaG90O1xuXG4gIHN0YXRpYyBnZXRDdXJyZW50KCk6IEFjdGl2YXRlZFJvdXRlU25hcHNob3Qge1xuICAgIHJldHVybiBMdWlnaUFjdGl2YXRlZFJvdXRlU25hcHNob3RIZWxwZXIuX2N1cnJlbnQ7XG4gIH1cblxuICBzdGF0aWMgc2V0Q3VycmVudChjdXJyZW50OiBBY3RpdmF0ZWRSb3V0ZVNuYXBzaG90KTogdm9pZCB7XG4gICAgTHVpZ2lBY3RpdmF0ZWRSb3V0ZVNuYXBzaG90SGVscGVyLl9jdXJyZW50ID0gY3VycmVudDtcbiAgfVxufVxuIl19

package/esm2022/lib/service/luigi-auto-routing.service.mjs

@@ -0,0 +1,135 @@
+import { Injectable, DestroyRef, inject } from '@angular/core';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { NavigationEnd, convertToParamMap } from '@angular/router';
+import { linkManager, uxManager, isLuigiClientInitialized } from '@luigi-project/client';
+import { filter } from 'rxjs/operators';
+import { LuigiActivatedRouteSnapshotHelper } from '../route/luigi-activated-route-snapshot-helper';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+import * as i2 from "./luigi-context.service";
+export class LuigiAutoRoutingService {
+    constructor(router, luigiContextService) {
+        this.router = router;
+        this.luigiContextService = luigiContextService;
+        this.destroyRef = inject(DestroyRef);
+        this.router.events
+            .pipe(this.doFilter(), takeUntilDestroyed(this.destroyRef))
+            .subscribe((event) => this.doSubscription(event));
+    }
+    doFilter() {
+        return filter((event) => !!(event instanceof NavigationEnd && event?.url?.length && !history?.state?.luigiInduced));
+    }
+    /**
+     * This method will be take in consideration angular route that having in data object the paramter
+     * fromVirtualTreeRoot: true, here an example:
+     * {path: 'demo', component: DemoComponent, data:{fromVirtualTreeRoot: true}}
+     * Another option is to specify the LuigiPath: if you add in route data luigiRoute:'/xxxx/xxx';
+     * in the case we will update the path in LuigiCore navigation, here an example
+     * {path: 'demo', component: DemoComponent, data:{luigiRoute: '/home/demo''}}
+     * If updateModalPathParam is specified, than modalPathParam will be updated upon internal navigation:
+     * {path: 'demo', component: DemoComponent, data:{updateModalPathParam: true}}
+     * @param event the NavigationEnd event
+     */
+    doSubscription(event) {
+        let current = LuigiActivatedRouteSnapshotHelper.getCurrent();
+        if (!current) {
+            current = this.router.routerState.root.snapshot;
+            while (current?.children?.length) {
+                // handle multiple children
+                let primary = null;
+                current.children.forEach((childSnapshot) => {
+                    if (childSnapshot?.outlet === 'primary') {
+                        primary = childSnapshot;
+                    }
+                });
+                if (primary) {
+                    current = primary;
+                }
+                else if (current.firstChild) {
+                    current = current.firstChild;
+                }
+                else {
+                    break;
+                }
+            }
+        }
+        if (current?.data && isLuigiClientInitialized()) {
+            const ux = uxManager();
+            let lm = linkManager().withoutSync();
+            let route;
+            if (current.data.luigiRoute) {
+                route = this.getResolvedLuigiRoute(current);
+                if (current.data.fromContext) {
+                    if (!this.luigiContextService.getContext()) {
+                        console.debug('Ignoring auto navigation request, luigi context not set');
+                        return;
+                    }
+                    if (current.data.fromContext === true) {
+                        lm = lm.fromClosestContext();
+                    }
+                    else {
+                        lm = lm.fromContext(current.data.fromContext);
+                    }
+                }
+            }
+            else if (current.data.fromVirtualTreeRoot) {
+                let url = event.url;
+                const truncate = current.data.fromVirtualTreeRoot.truncate;
+                if (truncate) {
+                    if (truncate.indexOf('*') === 0) {
+                        const index = url.indexOf(truncate.substring(1));
+                        url = url.substring(index + truncate.length - 1);
+                    }
+                    else if (url.indexOf(truncate) === 0) {
+                        url = url.substring(truncate.length);
+                    }
+                }
+                route = url;
+                console.debug('Calling fromVirtualTreeRoot for url ==> ' + route);
+                lm = lm.fromVirtualTreeRoot();
+            }
+            if (ux.isModal()) {
+                if (current.data.updateModalDataPath) {
+                    lm.updateModalPathInternalNavigation(route, {}, current.data.addHistoryEntry);
+                }
+            }
+            else if (route) {
+                lm.navigate(route);
+            }
+        }
+    }
+    getResolvedLuigiRoute(current) {
+        let route = current.data.luigiRoute;
+        const allParams = this.getAllParamsFromParents(current);
+        if (!route || !allParams) {
+            return route;
+        }
+        const pmap = convertToParamMap(allParams);
+        pmap.keys.forEach((key) => {
+            pmap.getAll(key).forEach((param) => {
+                route = route?.replace(':' + key, param);
+            });
+        });
+        return route;
+    }
+    getAllParamsFromParents(current) {
+        let allParams = {};
+        let currentToCheck = current;
+        while (currentToCheck) {
+            if (currentToCheck.params) {
+                allParams = { ...allParams, ...currentToCheck.params };
+            }
+            currentToCheck = currentToCheck.parent;
+        }
+        return allParams;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.10", ngImport: i0, type: LuigiAutoRoutingService, deps: [{ token: i1.Router }, { token: i2.LuigiContextService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.10", ngImport: i0, type: LuigiAutoRoutingService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.10", ngImport: i0, type: LuigiAutoRoutingService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.Router }, { type: i2.LuigiContextService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"luigi-auto-routing.service.js","sourceRoot":"","sources":["../../../../../projects/client-support-angular/src/lib/service/luigi-auto-routing.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAC/D,OAAO,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAChE,OAAO,EAAiC,aAAa,EAAoB,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AACpH,OAAO,EAAE,WAAW,EAAE,SAAS,EAAE,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AAEzF,OAAO,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AACxC,OAAO,EAAE,iCAAiC,EAAE,MAAM,gDAAgD,CAAC;;;;AAMnG,MAAM,OAAO,uBAAuB;IAGlC,YACU,MAAc,EACd,mBAAwC;QADxC,WAAM,GAAN,MAAM,CAAQ;QACd,wBAAmB,GAAnB,mBAAmB,CAAqB;QAJ1C,eAAU,GAAG,MAAM,CAAC,UAAU,CAAC,CAAC;QAMtC,IAAI,CAAC,MAAM,CAAC,MAAM;aACf,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,EAAE,kBAAkB,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;aAC1D,SAAS,CAAC,CAAC,KAAoB,EAAE,EAAE,CAAC,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC,CAAC;IACrE,CAAC;IAED,QAAQ;QACN,OAAO,MAAM,CACX,CAAC,KAAY,EAA0B,EAAE,CACvC,CAAC,CAAC,CAAC,KAAK,YAAY,aAAa,IAAI,KAAK,EAAE,GAAG,EAAE,MAAM,IAAI,CAAC,OAAO,EAAE,KAAK,EAAE,YAAY,CAAC,CAC5F,CAAC;IACJ,CAAC;IAED;;;;;;;;;;OAUG;IACH,cAAc,CAAC,KAAoB;QACjC,IAAI,OAAO,GAAkC,iCAAiC,CAAC,UAAU,EAAE,CAAC;QAE5F,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,OAAO,GAAG,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,IAAI,CAAC,QAAQ,CAAC;YAEhD,OAAO,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,CAAC;gBACjC,2BAA2B;gBAC3B,IAAI,OAAO,GAAkC,IAAI,CAAC;gBAElD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,aAAqC,EAAE,EAAE;oBACjE,IAAI,aAAa,EAAE,MAAM,KAAK,SAAS,EAAE,CAAC;wBACxC,OAAO,GAAG,aAAa,CAAC;oBAC1B,CAAC;gBACH,CAAC,CAAC,CAAC;gBAEH,IAAI,OAAO,EAAE,CAAC;oBACZ,OAAO,GAAG,OAAO,CAAC;gBACpB,CAAC;qBAAM,IAAI,OAAO,CAAC,UAAU,EAAE,CAAC;oBAC9B,OAAO,GAAG,OAAO,CAAC,UAAU,CAAC;gBAC/B,CAAC;qBAAM,CAAC;oBACN,MAAM;gBACR,CAAC;YACH,CAAC;QACH,CAAC;QAED,IAAI,OAAO,EAAE,IAAI,IAAI,wBAAwB,EAAE,EAAE,CAAC;YAChD,MAAM,EAAE,GAAG,SAAS,EAAE,CAAC;YACvB,IAAI,EAAE,GAAG,WAAW,EAAE,CAAC,WAAW,EAAE,CAAC;YACrC,IAAI,KAAyB,CAAC;YAE9B,IAAI,OAAO,CAAC,IAAI,CAAC,UAAU,EAAE,CAAC;gBAC5B,KAAK,GAAG,IAAI,CAAC,qBAAqB,CAAC,OAAO,CAAC,CAAC;gBAE5C,IAAI,OAAO,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC;oBAC7B,IAAI,CAAC,IAAI,CAAC,mBAAmB,CAAC,UAAU,EAAE,EAAE,CAAC;wBAC3C,OAAO,CAAC,KAAK,CAAC,yDAAyD,CAAC,CAAC;wBACzE,OAAO;oBACT,CAAC;oBAED,IAAI,OAAO,CAAC,IAAI,CAAC,WAAW,KAAK,IAAI,EAAE,CAAC;wBACtC,EAAE,GAAG,EAAE,CAAC,kBAAkB,EAAE,CAAC;oBAC/B,CAAC;yBAAM,CAAC;wBACN,EAAE,GAAG,EAAE,CAAC,WAAW,CAAC,OAAO,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;oBAChD,CAAC;gBACH,CAAC;YACH,CAAC;iBAAM,IAAI,OAAO,CAAC,IAAI,CAAC,mBAAmB,EAAE,CAAC;gBAC5C,IAAI,GAAG,GAAG,KAAK,CAAC,GAAG,CAAC;gBACpB,MAAM,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC,mBAAmB,CAAC,QAAQ,CAAC;gBAE3D,IAAI,QAAQ,EAAE,CAAC;oBACb,IAAI,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC;wBAChC,MAAM,KAAK,GAAG,GAAG,CAAC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC;wBAEjD,GAAG,GAAG,GAAG,CAAC,SAAS,CAAC,KAAK,GAAG,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;oBACnD,CAAC;yBAAM,IAAI,GAAG,CAAC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;wBACvC,GAAG,GAAG,GAAG,CAAC,SAAS,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;oBACvC,CAAC;gBACH,CAAC;gBAED,KAAK,GAAG,GAAG,CAAC;gBACZ,OAAO,CAAC,KAAK,CAAC,0CAA0C,GAAG,KAAK,CAAC,CAAC;gBAClE,EAAE,GAAG,EAAE,CAAC,mBAAmB,EAAE,CAAC;YAChC,CAAC;YAED,IAAI,EAAE,CAAC,OAAO,EAAE,EAAE,CAAC;gBACjB,IAAI,OAAO,CAAC,IAAI,CAAC,mBAAmB,EAAE,CAAC;oBACrC,EAAE,CAAC,iCAAiC,CAAC,KAAe,EAAE,EAAE,EAAE,OAAO,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;gBAC1F,CAAC;YACH,CAAC;iBAAM,IAAI,KAAK,EAAE,CAAC;gBACjB,EAAE,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;YACrB,CAAC;QACH,CAAC;IACH,CAAC;IAED,qBAAqB,CAAC,OAA+B;QACnD,IAAI,KAAK,GAAuB,OAAO,CAAC,IAAI,CAAC,UAAU,CAAC;QACxD,MAAM,SAAS,GAAG,IAAI,CAAC,uBAAuB,CAAC,OAAO,CAAC,CAAC;QAExD,IAAI,CAAC,KAAK,IAAI,CAAC,SAAS,EAAE,CAAC;YACzB,OAAO,KAAK,CAAC;QACf,CAAC;QAED,MAAM,IAAI,GAAa,iBAAiB,CAAC,SAAS,CAAC,CAAC;QAEpD,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,GAAW,EAAE,EAAE;YAChC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC,CAAC,KAAa,EAAE,EAAE;gBACzC,KAAK,GAAG,KAAK,EAAE,OAAO,CAAC,GAAG,GAAG,GAAG,EAAE,KAAK,CAAC,CAAC;YAC3C,CAAC,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;QAEH,OAAO,KAAK,CAAC;IACf,CAAC;IAED,uBAAuB,CAAC,OAA+B;QACrD,IAAI,SAAS,GAA8B,EAAE,CAAC;QAC9C,IAAI,cAAc,GAAkC,OAAO,CAAC;QAE5D,OAAO,cAAc,EAAE,CAAC;YACtB,IAAI,cAAc,CAAC,MAAM,EAAE,CAAC;gBAC1B,SAAS,GAAG,EAAE,GAAG,SAAS,EAAE,GAAG,cAAc,CAAC,MAAM,EAAE,CAAC;YACzD,CAAC;YAED,cAAc,GAAG,cAAc,CAAC,MAAM,CAAC;QACzC,CAAC;QAED,OAAO,SAAS,CAAC;IACnB,CAAC;+GAzIU,uBAAuB;mHAAvB,uBAAuB,cAFtB,MAAM;;4FAEP,uBAAuB;kBAHnC,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["import { Injectable, DestroyRef, inject } from '@angular/core';\nimport { takeUntilDestroyed } from '@angular/core/rxjs-interop';\nimport { ActivatedRouteSnapshot, Event, NavigationEnd, ParamMap, Router, convertToParamMap } from '@angular/router';\nimport { linkManager, uxManager, isLuigiClientInitialized } from '@luigi-project/client';\nimport { OperatorFunction } from 'rxjs';\nimport { filter } from 'rxjs/operators';\nimport { LuigiActivatedRouteSnapshotHelper } from '../route/luigi-activated-route-snapshot-helper';\nimport { LuigiContextService } from './luigi-context.service';\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class LuigiAutoRoutingService {\n  private destroyRef = inject(DestroyRef);\n\n  constructor(\n    private router: Router,\n    private luigiContextService: LuigiContextService\n  ) {\n    this.router.events\n      .pipe(this.doFilter(), takeUntilDestroyed(this.destroyRef))\n      .subscribe((event: NavigationEnd) => this.doSubscription(event));\n  }\n\n  doFilter(): OperatorFunction<Event, NavigationEnd> {\n    return filter(\n      (event: Event): event is NavigationEnd =>\n        !!(event instanceof NavigationEnd && event?.url?.length && !history?.state?.luigiInduced)\n    );\n  }\n\n  /**\n   * This method will be take in consideration angular route that having in data object the paramter\n   * fromVirtualTreeRoot: true, here an example:\n   * {path: 'demo', component: DemoComponent, data:{fromVirtualTreeRoot: true}}\n   * Another option is to specify the LuigiPath: if you add in route data luigiRoute:'/xxxx/xxx';\n   * in the case we will update the path in LuigiCore navigation, here an example\n   * {path: 'demo', component: DemoComponent, data:{luigiRoute: '/home/demo''}}\n   * If updateModalPathParam is specified, than modalPathParam will be updated upon internal navigation:\n   * {path: 'demo', component: DemoComponent, data:{updateModalPathParam: true}}\n   * @param event the NavigationEnd event\n   */\n  doSubscription(event: NavigationEnd): void {\n    let current: ActivatedRouteSnapshot | null = LuigiActivatedRouteSnapshotHelper.getCurrent();\n\n    if (!current) {\n      current = this.router.routerState.root.snapshot;\n\n      while (current?.children?.length) {\n        // handle multiple children\n        let primary: ActivatedRouteSnapshot | null = null;\n\n        current.children.forEach((childSnapshot: ActivatedRouteSnapshot) => {\n          if (childSnapshot?.outlet === 'primary') {\n            primary = childSnapshot;\n          }\n        });\n\n        if (primary) {\n          current = primary;\n        } else if (current.firstChild) {\n          current = current.firstChild;\n        } else {\n          break;\n        }\n      }\n    }\n\n    if (current?.data && isLuigiClientInitialized()) {\n      const ux = uxManager();\n      let lm = linkManager().withoutSync();\n      let route: string | undefined;\n\n      if (current.data.luigiRoute) {\n        route = this.getResolvedLuigiRoute(current);\n\n        if (current.data.fromContext) {\n          if (!this.luigiContextService.getContext()) {\n            console.debug('Ignoring auto navigation request, luigi context not set');\n            return;\n          }\n\n          if (current.data.fromContext === true) {\n            lm = lm.fromClosestContext();\n          } else {\n            lm = lm.fromContext(current.data.fromContext);\n          }\n        }\n      } else if (current.data.fromVirtualTreeRoot) {\n        let url = event.url;\n        const truncate = current.data.fromVirtualTreeRoot.truncate;\n\n        if (truncate) {\n          if (truncate.indexOf('*') === 0) {\n            const index = url.indexOf(truncate.substring(1));\n\n            url = url.substring(index + truncate.length - 1);\n          } else if (url.indexOf(truncate) === 0) {\n            url = url.substring(truncate.length);\n          }\n        }\n\n        route = url;\n        console.debug('Calling fromVirtualTreeRoot for url ==> ' + route);\n        lm = lm.fromVirtualTreeRoot();\n      }\n\n      if (ux.isModal()) {\n        if (current.data.updateModalDataPath) {\n          lm.updateModalPathInternalNavigation(route as string, {}, current.data.addHistoryEntry);\n        }\n      } else if (route) {\n        lm.navigate(route);\n      }\n    }\n  }\n\n  getResolvedLuigiRoute(current: ActivatedRouteSnapshot): string | undefined {\n    let route: string | undefined = current.data.luigiRoute;\n    const allParams = this.getAllParamsFromParents(current);\n\n    if (!route || !allParams) {\n      return route;\n    }\n\n    const pmap: ParamMap = convertToParamMap(allParams);\n\n    pmap.keys.forEach((key: string) => {\n      pmap.getAll(key).forEach((param: string) => {\n        route = route?.replace(':' + key, param);\n      });\n    });\n\n    return route;\n  }\n\n  getAllParamsFromParents(current: ActivatedRouteSnapshot): { [key: string]: string } | undefined {\n    let allParams: { [key: string]: string } = {};\n    let currentToCheck: ActivatedRouteSnapshot | null = current;\n\n    while (currentToCheck) {\n      if (currentToCheck.params) {\n        allParams = { ...allParams, ...currentToCheck.params };\n      }\n\n      currentToCheck = currentToCheck.parent;\n    }\n\n    return allParams;\n  }\n}\n"]}

package/esm2022/lib/service/luigi-context.model.mjs

@@ -0,0 +1,6 @@
+export var ILuigiContextTypes;
+(function (ILuigiContextTypes) {
+    ILuigiContextTypes[ILuigiContextTypes["INIT"] = 0] = "INIT";
+    ILuigiContextTypes[ILuigiContextTypes["UPDATE"] = 1] = "UPDATE";
+})(ILuigiContextTypes || (ILuigiContextTypes = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibHVpZ2ktY29udGV4dC5tb2RlbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2NsaWVudC1zdXBwb3J0LWFuZ3VsYXIvc3JjL2xpYi9zZXJ2aWNlL2x1aWdpLWNvbnRleHQubW9kZWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsTUFBTSxDQUFOLElBQVksa0JBR1g7QUFIRCxXQUFZLGtCQUFrQjtJQUM1QiwyREFBSSxDQUFBO0lBQ0osK0RBQU0sQ0FBQTtBQUNSLENBQUMsRUFIVyxrQkFBa0IsS0FBbEIsa0JBQWtCLFFBRzdCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ29udGV4dCB9IGZyb20gJ0BsdWlnaS1wcm9qZWN0L2NsaWVudCc7XG5cbmV4cG9ydCBlbnVtIElMdWlnaUNvbnRleHRUeXBlcyB7XG4gIElOSVQsXG4gIFVQREFURVxufVxuXG5leHBvcnQgaW50ZXJmYWNlIElDb250ZXh0TWVzc2FnZSB7XG4gIGNvbnRleHQ6IENvbnRleHQ7XG4gIGNvbnRleHRUeXBlOiBJTHVpZ2lDb250ZXh0VHlwZXM7XG59XG4iXX0=

package/esm2022/lib/service/luigi-context.service.impl.mjs

@@ -0,0 +1,75 @@
+import { inject, Injectable, NgZone } from '@angular/core';
+import { addInitListener, addContextUpdateListener } from '@luigi-project/client';
+import { ReplaySubject } from 'rxjs';
+import { first } from 'rxjs/operators';
+import { ILuigiContextTypes } from './luigi-context.model';
+import * as i0 from "@angular/core";
+export class LuigiContextServiceImpl {
+    constructor() {
+        this.subject = new ReplaySubject(1);
+        this.ngZone = inject(NgZone);
+        addInitListener((initContext) => {
+            this.addListener(ILuigiContextTypes.INIT, initContext);
+        });
+        addContextUpdateListener((updateContext) => {
+            this.addListener(ILuigiContextTypes.UPDATE, updateContext);
+        });
+    }
+    addListener(contextType, context) {
+        this.setContext({
+            contextType,
+            context
+        });
+    }
+    contextObservable() {
+        return this.subject.asObservable();
+    }
+    /**
+     * Get latest context object retrieved from luigi core application or empty object, if not yet set.
+     */
+    getContext() {
+        return this.currentContext?.context || {};
+    }
+    /**
+     * Get a promise that resolves when context is set.
+     */
+    getContextAsync() {
+        return new Promise((resolve) => {
+            const context = this.getContext();
+            if (this.isObject(context) && Object.keys(context)?.length) {
+                resolve(this.getContext());
+            }
+            else {
+                this.contextObservable()
+                    .pipe(first())
+                    .subscribe((ctx) => resolve(ctx.context));
+            }
+        });
+    }
+    /**
+     * Checks if input is an object.
+     * @param objectToCheck mixed
+     * @returns {boolean}
+     */
+    isObject(objectToCheck) {
+        return !!(objectToCheck && typeof objectToCheck === 'object' && !Array.isArray(objectToCheck));
+    }
+    /**
+     * Set current context
+     */
+    setContext(obj) {
+        this.ngZone.run(() => {
+            this.currentContext = obj;
+            this.subject.next(obj);
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.10", ngImport: i0, type: LuigiContextServiceImpl, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.10", ngImport: i0, type: LuigiContextServiceImpl, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.10", ngImport: i0, type: LuigiContextServiceImpl, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/service/luigi-context.service.mjs

@@ -0,0 +1,3 @@
+export class LuigiContextService {
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibHVpZ2ktY29udGV4dC5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvY2xpZW50LXN1cHBvcnQtYW5ndWxhci9zcmMvbGliL3NlcnZpY2UvbHVpZ2ktY29udGV4dC5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUlBLE1BQU0sT0FBZ0IsbUJBQW1CO0NBZ0J4QyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENvbnRleHQgfSBmcm9tICdAbHVpZ2ktcHJvamVjdC9jbGllbnQnO1xuaW1wb3J0IHsgT2JzZXJ2YWJsZSB9IGZyb20gJ3J4anMnO1xuaW1wb3J0IHsgSUNvbnRleHRNZXNzYWdlIH0gZnJvbSAnLi9sdWlnaS1jb250ZXh0Lm1vZGVsJztcblxuZXhwb3J0IGFic3RyYWN0IGNsYXNzIEx1aWdpQ29udGV4dFNlcnZpY2Uge1xuICAvKipcbiAgICogTGlzdGVuIHRvIGNvbnRleHQgY2hhbmdlc1xuICAgKiBSZWNlaXZlcyBjdXJyZW50IHZhbHVlLCBldmVuIGlmIHRoZSBldmVudCB3YXMgYWxyZWFkeSBkaXNwYXRjaGVkIGVhcmxpZXIuXG4gICAqL1xuICBhYnN0cmFjdCBjb250ZXh0T2JzZXJ2YWJsZSgpOiBPYnNlcnZhYmxlPElDb250ZXh0TWVzc2FnZT47XG5cbiAgLyoqXG4gICAqIEdldCBsYXRlc3Qgc2V0IGNvbnRleHQgb2JqZWN0XG4gICAqL1xuICBhYnN0cmFjdCBnZXRDb250ZXh0KCk6IENvbnRleHQ7XG5cbiAgLyoqXG4gICAqIEdldCBhIHByb21pc2UgdGhhdCByZXNvbHZlcyB3aGVuIGNvbnRleHQgaXMgc2V0LlxuICAgKi9cbiAgYWJzdHJhY3QgZ2V0Q29udGV4dEFzeW5jKCk6IFByb21pc2U8Q29udGV4dD47XG59XG4iXX0=

package/esm2022/public-api.mjs

@@ -0,0 +1,11 @@
+/*
+ * Public API Surface of client-support-angular
+ */
+export * from './lib/component/luigi.preload.component';
+export * from './lib/luigi-mock/luigi-mock.module';
+export * from './lib/luigi.angular.support.module';
+export * from './lib/service/luigi-auto-routing.service';
+export * from './lib/service/luigi-context.model';
+export * from './lib/service/luigi-context.service';
+export * from './lib/service/luigi-context.service.impl';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL2NsaWVudC1zdXBwb3J0LWFuZ3VsYXIvc3JjL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLHlDQUF5QyxDQUFDO0FBQ3hELGNBQWMsb0NBQW9DLENBQUM7QUFDbkQsY0FBYyxvQ0FBb0MsQ0FBQztBQUNuRCxjQUFjLDBDQUEwQyxDQUFDO0FBQ3pELGNBQWMsbUNBQW1DLENBQUM7QUFDbEQsY0FBYyxxQ0FBcUMsQ0FBQztBQUNwRCxjQUFjLDBDQUEwQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLypcbiAqIFB1YmxpYyBBUEkgU3VyZmFjZSBvZiBjbGllbnQtc3VwcG9ydC1hbmd1bGFyXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9saWIvY29tcG9uZW50L2x1aWdpLnByZWxvYWQuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2x1aWdpLW1vY2svbHVpZ2ktbW9jay5tb2R1bGUnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvbHVpZ2kuYW5ndWxhci5zdXBwb3J0Lm1vZHVsZSc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9zZXJ2aWNlL2x1aWdpLWF1dG8tcm91dGluZy5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL3NlcnZpY2UvbHVpZ2ktY29udGV4dC5tb2RlbCc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9zZXJ2aWNlL2x1aWdpLWNvbnRleHQuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9zZXJ2aWNlL2x1aWdpLWNvbnRleHQuc2VydmljZS5pbXBsJztcbiJdfQ==