@ngrdt/router 0.0.95 → 0.0.97

package/fesm2022/ngrdt-router.mjs

@@ -1,5 +1,5 @@
 import * as i0 from '@angular/core';
-import { InjectionToken, inject, Injectable, EnvironmentInjector, runInInjectionContext, DestroyRef, Renderer2, ElementRef, Input, Directive, afterNextRender, input, linkedSignal, booleanAttribute, effect } from '@angular/core';
+import { InjectionToken, inject, Injectable, EnvironmentInjector, runInInjectionContext, DestroyRef, Renderer2, ElementRef, Input, Directive, afterNextRender, input, linkedSignal, booleanAttribute, computed, effect } from '@angular/core';
 import { defer, of, filter, take, fromEvent } from 'rxjs';
 import { PlatformLocation, Location } from '@angular/common';
 import * as i1 from '@angular/router';
@@ -36,6 +36,15 @@ class RdtParameters {
         this.params[route.absolutePath] = params;
         return this;
     }
+    append(route, params) {
+        const existing = this.get(route) ?? {};
+        this.params[route.absolutePath] = { ...existing, ...params };
+        return this;
+    }
+    setAll(params) {
+        this.params = { ...this.params, ...params.params };
+        return this;
+    }
     *[Symbol.iterator]() {
         const keys = Object.keys(this.params);
         keys.sort((a, b) => a.length - b.length);
@@ -190,13 +199,12 @@ class RdtRouterService {
             const parsed = this.parseAbsoluteUrl();
             if (!parsed) {
                 console.warn('No route matches current url.');
-                return new RdtParameters();
+                return null;
             }
             currentRoute = parsed.route;
         }
         const url = this.location.path();
-        const stripped = RdtStringUtils.stripQueryParams(url);
-        return currentRoute.parseAbsoluteUrl(stripped);
+        return currentRoute.parseAbsoluteUrl(url);
     }
     isParentOfCurrentLocation(route) {
         return true;
@@ -337,7 +345,16 @@ class RdtAngularRoute {
         };
         const guard = (route, state) => {
             const injector = inject(EnvironmentInjector);
-            if (runInInjectionContext(injector, this.route.canBeEntered.bind(this.route))) {
+            const rdtRouter = inject(RdtRouterService);
+            const parsed = rdtRouter.parseAbsoluteUrl(state.url);
+            const combinedParams = parsed?.params ?? {
+                params: {},
+                query: {},
+                state: {},
+                route: new RdtParameters(),
+            };
+            combinedParams.query = route.queryParams;
+            if (runInInjectionContext(injector, () => this.route.canBeEnteredFn(parsed?.route ?? this.route, combinedParams))) {
                 return true;
             }
             else {
@@ -345,8 +362,7 @@ class RdtAngularRoute {
                 const location = inject(Location);
                 let url = inject(RDT_CANNOT_BE_ENTERED_PROVIDER);
                 if (typeof url === 'function') {
-                    //console.error(this.route.absolutePath);
-                    url = runInInjectionContext(injector, url.bind(url, location.path(), state.url, this.route));
+                    url = runInInjectionContext(injector, url.bind(url, location.path(), state.url, parsed?.route ?? this.route));
                 }
                 if (typeof url === 'string') {
                     return router.parseUrl(url);
@@ -622,31 +638,69 @@ class RdtRoute extends RdtRouteBase {
      * Meta guard that is used by [rdtRouterLink] and RdtMenu
      * to determine if route can be entered.
      * @param injector Environment or custom injector.
+     * @param params Optional parameters to pass to guard function.
      * @returns True if route can be entered.
      */
-    canBeEntered(injector) {
-        return injector
-            ? runInInjectionContext(injector, this._canBeEntered)
-            : this._canBeEntered();
+    canBeEntered(injector, combinedParams = {}) {
+        const route = this.getStaticParams();
+        let query = this._queryParams;
+        let state = this._stateParams;
+        if (combinedParams.params) {
+            route.set(this, combinedParams.params);
+        }
+        if (combinedParams.route) {
+            route.setAll(combinedParams.route);
+        }
+        if (combinedParams.query) {
+            query = { ...query, ...combinedParams.query };
+        }
+        if (combinedParams.state) {
+            state = { ...state, ...combinedParams.state };
+        }
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        let current = this;
+        while (current) {
+            const combined = {
+                params: route.get(current) ?? {},
+                route: route,
+                query: query,
+                state: state,
+            };
+            if (injector) {
+                const c = current;
+                if (!runInInjectionContext(injector, () => c._canBeEntered(c, combined))) {
+                    return false;
+                }
+            }
+            else if (!current._canBeEntered(current, combined)) {
+                return false;
+            }
+            current = current._parent;
+        }
+        return true;
+    }
+    get canBeEnteredFn() {
+        return this._canBeEntered;
     }
     /**
      * Extracts url parameters from absolute path for this path and each parent.
      */
     parseAbsoluteUrl(url) {
+        const path = RdtStringUtils.stripQueryParams(url);
         const reg = this.absoluteRegex;
-        if (!reg.test(url)) {
-            return null;
-        }
-        const matches = reg.exec(url);
+        const matches = reg.exec(path);
         if (matches) {
+            const query = RdtStringUtils.parseQueryParams(url);
             const values = matches.slice(1).reverse();
             const obj = this.fill(values);
-            if (obj) {
-                return new RdtParameters(obj);
-            }
-            else {
-                return null;
-            }
+            const route = new RdtParameters(obj);
+            const params = route.get(this) ?? {};
+            return {
+                params: params,
+                route: route,
+                query: query,
+                state: {},
+            };
         }
         else {
             return null;
@@ -766,6 +820,16 @@ class RdtRoute extends RdtRouteBase {
         });
         return res;
     }
+    getStaticParams() {
+        const res = new RdtParameters();
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        let current = this;
+        while (current) {
+            res.set(current, current._staticParams);
+            current = current._parent;
+        }
+        return res;
+    }
     /**
      * @returns New instance of RdtRoute<T> that is clone of
      * this route and its parents (NOT children).
@@ -1130,6 +1194,19 @@ class RdtRouterLinkDirective {
         alias: 'rdtDisabled',
         transform: booleanAttribute,
     });
+    canBeEntered = computed(() => {
+        const route = this.route();
+        const disabled = this.disabled();
+        if (!route || disabled) {
+            return false;
+        }
+        const combinedParams = {
+            params: this.params(),
+            query: this.queryParams(),
+            state: this.stateParams(),
+        };
+        return route.canBeEntered(this.envInjector, combinedParams);
+    });
     updateEffect = effect(() => {
         if (this.buttonRef) {
             this.updateButton();
@@ -1144,7 +1221,7 @@ class RdtRouterLinkDirective {
             this.clearButtonLink();
             return;
         }
-        if (route.canBeEntered(this.envInjector)) {
+        if (this.canBeEntered()) {
             this.setButtonLink(route);
         }
         else {
@@ -1182,7 +1259,7 @@ class RdtRouterLinkDirective {
         if (!route) {
             this.clearRouterLink();
         }
-        else if (route.canBeEntered(this.envInjector) && !this.disabled()) {
+        else if (this.canBeEntered()) {
             this.setRouterLink(route);
         }
         else {