@platform-mesh/portal-ui-lib 0.65.6 → 0.65.8

package/fesm2022/platform-mesh-portal-ui-lib-portal-options.mjs

@@ -5,7 +5,7 @@ import '@ui5/webcomponents/dist/Breadcrumbs.js';
 import '@ui5/webcomponents/dist/BreadcrumbsItem.js';
 import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
 import { ALL_NAMESPACE, kcpRootOrgsPath } from '@platform-mesh/portal-ui-lib/models';
-import { ResourceService, GatewayService, AccountInfoService, InstancePermissionsService, OrganizationReadyService, ErrorHandlerService } from '@platform-mesh/portal-ui-lib/services';
+import { ResourceService, GatewayService, AccountInfoService, InstancePermissionsService, OrganizationReadyService, ErrorHandlerService, NamespaceService } from '@platform-mesh/portal-ui-lib/services';
 import { isNamespacedResource, generateGraphQLFields, mergeListWithSubscriptionResult, permissionKey } from '@platform-mesh/portal-ui-lib/utils';
 import '@ui5/webcomponents/dist/ComboBox.js';
 import { Subject, defer, of, firstValueFrom } from 'rxjs';
@@ -1089,13 +1089,89 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.1", ngImpor
             args: [{ providedIn: 'root' }]
         }] });
 
+class NamespacedResourceSelectionService {
+    constructor() {
+        this.luigiCoreService = inject(LuigiCoreService);
+    }
+    resolveNamespace(entityNode, entityId, kcpPath, ctx) {
+        const searchNamespace = this.getSelectedSearchNamespace();
+        if (!isNamespacedResource(ctx)) {
+            return searchNamespace;
+        }
+        const entityTypeId = entityNode.defineEntity?.id;
+        const namespace = searchNamespace ??
+            this.getSelectedNamespace(entityTypeId, entityId, kcpPath);
+        this.selection =
+            entityTypeId && namespace
+                ? { entityTypeId, entityId, kcpPath, namespace }
+                : undefined;
+        return namespace;
+    }
+    restoreNamespaceSearchParam(nextNode, currentContext) {
+        const selection = this.selection;
+        if (!selection) {
+            return;
+        }
+        if (!this.isWithinSelectedResource(nextNode, currentContext, selection)) {
+            this.selection = undefined;
+            return;
+        }
+        if (this.getSelectedSearchNamespace()) {
+            return;
+        }
+        this.luigiCoreService
+            .routing()
+            .addSearchParams({ namespace: selection.namespace }, false, true);
+    }
+    getSelectedSearchNamespace() {
+        const namespace = this.luigiCoreService.routing().getSearchParams()
+            .namespace;
+        return namespace && namespace !== ALL_NAMESPACE ? namespace : undefined;
+    }
+    getSelectedNamespace(entityTypeId, entityId, kcpPath) {
+        const selection = this.selection;
+        if (!selection ||
+            selection.entityTypeId !== entityTypeId ||
+            selection.entityId !== entityId ||
+            selection.kcpPath !== kcpPath) {
+            return undefined;
+        }
+        return selection.namespace;
+    }
+    isWithinSelectedResource(node, currentContext, selection) {
+        for (let current = node; current; current = current.parent) {
+            if (current.defineEntity?.id === selection.entityTypeId &&
+                this.getEntityId(current, currentContext) === selection.entityId) {
+                return true;
+            }
+        }
+        return false;
+    }
+    getEntityId(entityNode, currentContext) {
+        const contextKey = entityNode.defineEntity?.contextKey;
+        const dynamicEntityId = contextKey
+            ? currentContext[contextKey]
+            : undefined;
+        return (dynamicEntityId ||
+            entityNode.context?.resourceDefinition?.name);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.1", ngImport: i0, type: NamespacedResourceSelectionService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.2.1", ngImport: i0, type: NamespacedResourceSelectionService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.1", ngImport: i0, type: NamespacedResourceSelectionService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
 class NodeChangeHookConfigServiceImpl {
     constructor() {
         this.luigiCoreService = inject(LuigiCoreService);
         this.crdGatewayKcpPatchResolver = inject(CrdGatewayKcpPatchResolver);
         this.persistentPanelService = inject(PersistentPanelService);
+        this.namespacedResourceSelectionService = inject(NamespacedResourceSelectionService);
     }
     async nodeChangeHook(prevNode, nextNode, currentContext) {
+        this.namespacedResourceSelectionService.restoreNamespaceSearchParam(nextNode, currentContext);
         const updatePersistentPanelTarget = this.persistentPanelService.beginTargetUpdate();
         if (nextNode.initialRoute &&
             nextNode.virtualTree &&
@@ -1136,7 +1212,8 @@ class NodeContextProcessingServiceImpl {
         this.instancePermissionsService = inject(InstancePermissionsService);
         this.organizationReadyService = inject(OrganizationReadyService);
         this.errorHandlerService = inject(ErrorHandlerService);
-        this.luigiCoreService = inject(LuigiCoreService);
+        this.namespaceService = inject(NamespaceService);
+        this.namespacedResourceSelectionService = inject(NamespacedResourceSelectionService);
     }
     async processNodeContext(dynamicEntityId, entityNode, ctx) {
         const kind = entityNode.defineEntity?.type;
@@ -1145,14 +1222,12 @@ class NodeContextProcessingServiceImpl {
             return;
         }
         const { kcpPath, accountPath } = await this.crdGatewayKcpPatchResolver.resolveCrdGatewayKcpPath(entityNode, entityId, kind);
-        const namespace = this.luigiCoreService.routing().getSearchParams().namespace !==
-            ALL_NAMESPACE
-            ? this.luigiCoreService.routing().getSearchParams().namespace
-            : undefined;
+        const namespace = this.namespacedResourceSelectionService.resolveNamespace(entityNode, entityId, kcpPath, ctx);
         // update the current already calculated by Luigi context for a node
         this.addFieldsToContext(ctx, entityId, kcpPath, accountPath, kind, namespace);
         // update the node context of sa node to contain the entity for future context calculations
         this.addFieldsToContext(entityNode.context, entityId, kcpPath, accountPath, kind, namespace);
+        await this.addNamespacesToContext(ctx, namespace);
         this.accamulatePortalPermissions(ctx);
         this.getEntityPermissions(ctx, namespace);
         try {
@@ -1202,6 +1277,17 @@ class NodeContextProcessingServiceImpl {
         ctx.accountPath = accountPath;
         ctx.namespaceId = namespace;
     }
+    async addNamespacesToContext(ctx, namespace) {
+        if (!isNamespacedResource(ctx) || namespace) {
+            return;
+        }
+        try {
+            ctx.namespaces = await firstValueFrom(this.namespaceService.list(ctx));
+        }
+        catch (e) {
+            this.errorHandlerService.showError(e, 'Failed to read namespaces.');
+        }
+    }
     addFieldsToContextFromAccountInfo(ctx, entityId, accountInfo) {
         const accountOriginClusterId = accountInfo.spec.account.originClusterId;
         const organizationOriginClusterId = accountInfo.spec.organization.originClusterId;
@@ -1261,7 +1347,6 @@ class CustomRoutingConfigServiceImpl {
     }
     getRoutingConfig() {
         return {
-            preserveQueryParams: true,
             pageNotFoundHandler: () => {
                 if (!this.envConfig?.baseDomain) {
                     return this.redirectTo('error/404');