@ngrdt/router 0.0.97 → 0.0.99

package/fesm2022/ngrdt-router.mjs

@@ -1,13 +1,12 @@
 import * as i0 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 { InjectionToken, inject, EnvironmentInjector, runInInjectionContext, makeEnvironmentProviders, Injectable, DestroyRef, Renderer2, ElementRef, Input, Directive, afterNextRender, input, linkedSignal, booleanAttribute, computed, effect } from '@angular/core';
+import { Location, PlatformLocation } from '@angular/common';
 import * as i1 from '@angular/router';
 import { Router, NavigationEnd, RouterModule, RouterLink, GuardsCheckStart } from '@angular/router';
 import { RdtStringUtils } from '@ngrdt/utils';
+import { filter, take, fromEvent } from 'rxjs';
 import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
 import { RDT_BUTTON_BASE_PROVIDER } from '@ngrdt/button';
-import { RdtComponentGuardStoreService } from '@ngrdt/core';
 
 /**
  * Injection token that defines behavior when route cannot be entered (canBeEntered returns false).
@@ -15,15 +14,12 @@ import { RdtComponentGuardStoreService } from '@ngrdt/core';
  */
 const RDT_CANNOT_BE_ENTERED_PROVIDER = new InjectionToken('RDT_CANNOT_BE_ENTERED', { factory: () => undefined, providedIn: 'root' });
 
-const RDT_CONFIRM_DATA_LOSS_SERVICE = new InjectionToken('RDT_CONFIRM_DATA_LOSS_SERVICE', { factory: () => new RdtConfirmDataLossServiceAlert() });
-class RdtConfirmDataLossService {
-}
-class RdtConfirmDataLossServiceAlert extends RdtConfirmDataLossService {
-    confirmDataLoss() {
-        return defer(() => of(confirm('Are you sure you want to leave this page?')));
-    }
-}
-
+/**
+ * Type-safe container for route parameters keyed by route instance.
+ * Stores params for multiple routes in a hierarchy (e.g. parent + child params from a single URL).
+ * Parameters are keyed internally by absolute path, so two different `RdtRoute` instances
+ * with the same path share the same slot.
+ */
 class RdtParameters {
     params;
     constructor(params = {}) {
@@ -57,177 +53,23 @@ function ALWAYS_TRUE() {
     return true;
 }
 
-const RDT_ROUTES_PROVIDER = new InjectionToken('RDT_ROUTES_PROVIDER');
-
-const DEFAULT_TARGET = '_self';
-const RDT_STATE_PARAMS_KEY = 'RdtStateParams';
-class RdtRouterService {
-    allRoutes = inject(RDT_ROUTES_PROVIDER, { optional: true });
-    baseHref = inject(PlatformLocation).getBaseHrefFromDOM();
-    location = inject(Location);
-    router = inject(Router);
-    _previousUrl = null;
-    _currentUrl = null;
-    get previousUrl() {
-        return this._previousUrl;
-    }
-    get currentUrl() {
-        return this._currentUrl;
-    }
-    parsePreviousUrl() {
-        return this._previousUrl ? this.parseAbsoluteUrl(this._previousUrl) : null;
-    }
-    parseCurrentUrl() {
-        return this._currentUrl ? this.parseAbsoluteUrl(this._currentUrl) : null;
-    }
-    navigationEnd$ = this.router.events.pipe(filter((e) => e instanceof NavigationEnd));
-    nextNavigationEnd$ = this.navigationEnd$.pipe(take(1));
-    constructor() {
-        if (this.allRoutes === null) {
-            console.warn('All routes not provided. Make sure to provide RDT_ROUTES_PROVIDER with RdtRoute[].');
-            this.allRoutes = [];
-        }
-        this.navigationEnd$.subscribe((e) => {
-            this._previousUrl = this._currentUrl;
-            this._currentUrl = e.url;
-        });
-    }
-    /**
-     * @returns window.history.state extended by state parameters passed from parent window.
-     */
-    getHistoryState() {
-        if ('RdtStateParams' in window &&
-            typeof window[RDT_STATE_PARAMS_KEY] === 'object') {
-            return { ...window[RDT_STATE_PARAMS_KEY], ...(history.state ?? {}) };
-        }
-        else {
-            return history.state ?? {};
-        }
-    }
-    /**
-     * Navigates to the specified route.
-     * @param link Route to navigate to.
-     * @param params Parameter of route passed as first argument or RdtParameters object.
-     * @param extras Allows you to specify additional parameters for navigation. These extras have higher priority than those defined in the route.
-     * @returns Promise that resolves when navigation is complete.
-     */
-    navigate(link, params, extras) {
-        let url;
-        if (params instanceof RdtParameters) {
-            let linkCpy = link;
-            for (let r = linkCpy; r !== null; r = r.parent) {
-                const p = params.get(r);
-                if (p) {
-                    linkCpy = linkCpy.withStaticParams(r, p);
-                }
-            }
-            url = linkCpy.createAbsoluteUrl();
-        }
-        else {
-            url = params ? link.createAbsoluteUrl(params) : link.createAbsoluteUrl();
-        }
-        const target = extras?.target ?? DEFAULT_TARGET;
-        const queryParams = extras?.query ?? link.queryParams;
-        const stateParams = extras?.state ?? link.stateParams;
-        if (target === '_self') {
-            return this.router.navigate([url], {
-                queryParams: queryParams,
-                state: stateParams,
-                replaceUrl: extras?.replaceUrl,
-            });
-        }
-        const absolutePath = RdtStringUtils.createAbsoluteUrl(url, this.baseHref);
-        const pathWithParams = RdtStringUtils.appendQueryParams(absolutePath, queryParams);
-        const win = window.open(pathWithParams, target);
-        if (win) {
-            win[RDT_STATE_PARAMS_KEY] = stateParams;
-        }
-        return Promise.resolve(true);
-    }
-    navigateHome(extras) {
-        return this.router.navigateByUrl(RdtStringUtils.appendQueryParams('/', extras?.query ?? {}), {
-            state: extras?.state,
-            replaceUrl: extras?.replaceUrl,
-        });
-    }
-    navigateBack(extras) {
-        const parsed = this.parseAbsoluteUrl();
-        if (parsed) {
-            let route = parsed.route.withStaticParams(parsed.params);
-            do {
-                route = route.parent;
-            } while (route && route.entryDisabled);
-            // In case route has no ancestor with allowed entry,
-            if (!route) {
-                return this.navigateHome(extras);
-            }
-            if (extras) {
-                if (extras.query) {
-                    route = route.withQueryParams(extras.query);
-                }
-                if (extras.state) {
-                    route = route.withStateParams(extras.state);
-                }
-            }
-            return this.navigate(route, extras);
-        }
-        else {
-            console.warn(`Cannot go back from ${this.location.path()} because no route matches current url`);
-            return null;
-        }
-    }
-    /**
-     * This method will try to find matching route for given absolute URL, extract its parameters and return them.
-     * If no route matches the URL, it returns null. Parameters are extracted only for the last matching route, not ancestors.
-     * @param url Absolute URL to parse (e.g. '/home/details/123?query=abc').
-     * @returns Object containing the matching route and its parameters, or null if no route is matching.
-     */
-    parseAbsoluteUrl(url = this.location.path()) {
-        const stripped = RdtStringUtils.stripQueryParams(url);
-        if (this.allRoutes) {
-            for (const route of this.allRoutes) {
-                const params = route.parseAbsoluteUrl(stripped);
-                if (params) {
-                    return { route, params };
-                }
-            }
-        }
-        return null;
-    }
-    extractAllParams(currentRoute) {
-        if (!currentRoute) {
-            const parsed = this.parseAbsoluteUrl();
-            if (!parsed) {
-                console.warn('No route matches current url.');
-                return null;
-            }
-            currentRoute = parsed.route;
-        }
-        const url = this.location.path();
-        return currentRoute.parseAbsoluteUrl(url);
-    }
-    isParentOfCurrentLocation(route) {
-        return true;
-    }
-    removeQueryParams(...paramNames) {
-        const regex = new RegExp(`[?&](${paramNames.join('|')})=[^&]*`, 'g');
-        return history.replaceState(history.state, '', location.pathname + location.search.replace(regex, '').replace(/^&/, '?'));
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.0", ngImport: i0, type: RdtRouterService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.0.0", ngImport: i0, type: RdtRouterService, providedIn: 'root' });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.0", ngImport: i0, type: RdtRouterService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }], ctorParameters: () => [] });
-
 var RdtNavigationSource;
 (function (RdtNavigationSource) {
     RdtNavigationSource["BREADCRUMB"] = "breadcrumb";
 })(RdtNavigationSource || (RdtNavigationSource = {}));
 
+/**
+ * Bridges an `RdtRoute` to Angular's `Route` config.
+ * Obtained via `RdtRoute.toAngularRoute()`. Use the fluent API to attach
+ * components, guards, resolvers, and providers, then call `build()` to produce
+ * the Angular `Route` object.
+ *
+ * `build()` validates that children defined on the `RdtRoute` match the children
+ * passed via `withChildren()` — a mismatch throws at startup, catching misconfiguration early.
+ *
+ * When a route has both a component and children, `build()` automatically restructures
+ * the output into Angular's required wrapper format (parent with empty-path child for the component).
+ */
 class RdtAngularRoute {
     route;
     children = [];
@@ -427,8 +269,8 @@ class RdtAngularRoute {
     }
     getCanMatch() {
         const paramMap = this.route.paramMap;
-        const hasNumberParams = Object.keys(paramMap).some((p) => paramMap[p] === 'number');
-        if (!hasNumberParams) {
+        const hasConstrainedParams = Object.keys(paramMap).some((p) => paramMap[p] === 'number' || Array.isArray(paramMap[p]));
+        if (!hasConstrainedParams) {
             return undefined;
         }
         const routeSegmentLength = this.route.path.split('/').length;
@@ -564,6 +406,19 @@ class RdtRouteBase {
     }
 }
 
+/**
+ * Immutable, type-safe route definition. Created via `RdtRouteBuilder.build()`.
+ *
+ * Each instance represents a single route in the hierarchy and holds its path pattern,
+ * parameter types, parent reference, and access guard. Use `withStaticParams()`,
+ * `withQueryParams()`, or `withStateParams()` to create derived instances with
+ * pre-filled values (the original is never mutated).
+ *
+ * To bridge to Angular's router, call `toAngularRoute()` to get an `RdtAngularRoute`
+ * builder that produces an Angular `Route` config object.
+ *
+ * @typeParam T - Shape of this route's own parameters.
+ */
 class RdtRoute extends RdtRouteBase {
     _absoluteRegex;
     _staticParams = {};
@@ -712,7 +567,7 @@ class RdtRoute extends RdtRouteBase {
         for (let i = 0; i < reversedParams.length && i < values.length; i++) {
             const key = reversedParams[i];
             const mappedKey = this._paramMappings.find((m) => m.urlName === key)?.tableName ?? key;
-            let val = values[i];
+            let val = decodeURIComponent(values[i]);
             if (this._paramMap[key] === 'number') {
                 val = parseInt(val);
             }
@@ -755,7 +610,11 @@ class RdtRoute extends RdtRouteBase {
                 throw new Error(`Param ${param} is missing for route ${this.absolutePath}. Please pass object with required parameters.`);
             }
             const value = extendedParamMap[param];
-            path = path.replace(`:${param}`, `${value}`);
+            const type = this._paramMap[param];
+            if (Array.isArray(type) && !type.includes(`${value}`)) {
+                throw new Error(`Value "${value}" is not allowed for enum param "${param}" in route ${this.absolutePath}. Allowed values: ${type.join(', ')}`);
+            }
+            path = path.replace(`:${param}`, encodeURIComponent(`${value}`));
         });
         return path;
     }
@@ -846,8 +705,18 @@ class RdtRoute extends RdtRouteBase {
         clone._paramMappings = this._paramMappings;
         clone._staticParams = { ...this._staticParams };
         clone._stateParams = { ...this._stateParams };
+        clone._canBeEntered = this._canBeEntered;
+        clone._queryParams = { ...this._queryParams };
         return clone;
     }
+    static getGroup(type) {
+        if (Array.isArray(type)) {
+            return ('(' +
+                type.map((v) => v.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')).join('|') +
+                ')');
+        }
+        return RdtRoute.groups[type];
+    }
     setRegex() {
         const params = Object.keys(this._paramMap);
         params.sort((a, b) => b.length - a.length);
@@ -857,7 +726,7 @@ class RdtRoute extends RdtRouteBase {
             if (!type) {
                 throw new Error('Params is not set i');
             }
-            substituted = substituted.replace(`:${p}`, RdtRoute.groups[type]);
+            substituted = substituted.replace(`:${p}`, RdtRoute.getGroup(type));
         });
         if (substituted === '') {
             this._regex = null;
@@ -883,12 +752,228 @@ class RdtRoute extends RdtRouteBase {
         return route;
     }
     static groups = {
-        string: '([\\w_\\-]+)',
-        number: '(\\d+)',
+        string: '([^/]+)',
+        number: '(-?\\d+)',
     };
 }
 
+/**
+ * Injection token holding all application routes as a flat array.
+ * Used internally by `RdtRouterService` to match URLs and enable type-safe navigation.
+ * Prefer using `provideRdtRoutes()` instead of providing this token directly.
+ */
+const RDT_ROUTES_PROVIDER = new InjectionToken('RDT_ROUTES_PROVIDER');
+/**
+ * Provides all application routes to `RdtRouterService`.
+ * Accepts either a route module object (`import * as routes from './routes'`)
+ * or a plain array of `RdtRoute` instances.
+ *
+ * @example
+ * ```ts
+ * import * as ALL_ROUTES from './rdt-routes';
+ *
+ * export const appConfig: ApplicationConfig = {
+ *   providers: [
+ *     provideRdtRoutes(ALL_ROUTES),
+ *   ],
+ * };
+ * ```
+ */
+function provideRdtRoutes(routes) {
+    const routeArray = Array.isArray(routes)
+        ? routes
+        : Object.values(routes).filter((v) => v instanceof RdtRoute);
+    return makeEnvironmentProviders([
+        { provide: RDT_ROUTES_PROVIDER, useValue: routeArray },
+    ]);
+}
+
+const DEFAULT_TARGET = '_self';
+const RDT_STATE_PARAMS_KEY = 'RdtStateParams';
+/**
+ * Central navigation service for type-safe routing.
+ * Wraps Angular's `Router` with `RdtRoute`-based navigation, URL parsing, and history tracking.
+ * Requires `RDT_ROUTES_PROVIDER` to be configured with all application routes.
+ */
+class RdtRouterService {
+    allRoutes = inject(RDT_ROUTES_PROVIDER, { optional: true });
+    baseHref = inject(PlatformLocation).getBaseHrefFromDOM();
+    location = inject(Location);
+    router = inject(Router);
+    _previousUrl = null;
+    _currentUrl = null;
+    get previousUrl() {
+        return this._previousUrl;
+    }
+    get currentUrl() {
+        return this._currentUrl;
+    }
+    parsePreviousUrl() {
+        return this._previousUrl ? this.parseAbsoluteUrl(this._previousUrl) : null;
+    }
+    parseCurrentUrl() {
+        return this._currentUrl ? this.parseAbsoluteUrl(this._currentUrl) : null;
+    }
+    navigationEnd$ = this.router.events.pipe(filter((e) => e instanceof NavigationEnd));
+    nextNavigationEnd$ = this.navigationEnd$.pipe(take(1));
+    constructor() {
+        if (this.allRoutes === null) {
+            console.warn('All routes not provided. Make sure to provide RDT_ROUTES_PROVIDER with RdtRoute[].');
+            this.allRoutes = [];
+        }
+        this.navigationEnd$.subscribe((e) => {
+            this._previousUrl = this._currentUrl;
+            this._currentUrl = e.url;
+        });
+    }
+    /**
+     * @returns window.history.state extended by state parameters passed from parent window.
+     */
+    getHistoryState() {
+        if ('RdtStateParams' in window &&
+            typeof window[RDT_STATE_PARAMS_KEY] === 'object') {
+            return { ...window[RDT_STATE_PARAMS_KEY], ...(history.state ?? {}) };
+        }
+        else {
+            return history.state ?? {};
+        }
+    }
+    /**
+     * Navigates to the specified route.
+     * @param link Route to navigate to.
+     * @param params Parameter of route passed as first argument or RdtParameters object.
+     * @param extras Allows you to specify additional parameters for navigation. These extras have higher priority than those defined in the route.
+     * @returns Promise that resolves when navigation is complete.
+     */
+    navigate(link, params, extras) {
+        let url;
+        if (params instanceof RdtParameters) {
+            let linkCpy = link;
+            for (let r = linkCpy; r !== null; r = r.parent) {
+                const p = params.get(r);
+                if (p) {
+                    linkCpy = linkCpy.withStaticParams(r, p);
+                }
+            }
+            url = linkCpy.createAbsoluteUrl();
+        }
+        else {
+            url = params ? link.createAbsoluteUrl(params) : link.createAbsoluteUrl();
+        }
+        const target = extras?.target ?? DEFAULT_TARGET;
+        const queryParams = extras?.query ?? link.queryParams;
+        const stateParams = extras?.state ?? link.stateParams;
+        if (target === '_self') {
+            return this.router.navigate([url], {
+                queryParams: queryParams,
+                state: stateParams,
+                replaceUrl: extras?.replaceUrl,
+            });
+        }
+        const absolutePath = RdtStringUtils.createAbsoluteUrl(url, this.baseHref);
+        const pathWithParams = RdtStringUtils.appendQueryParams(absolutePath, queryParams);
+        const win = window.open(pathWithParams, target);
+        if (win) {
+            win[RDT_STATE_PARAMS_KEY] = stateParams;
+        }
+        return Promise.resolve(true);
+    }
+    navigateHome(extras) {
+        return this.router.navigateByUrl(RdtStringUtils.appendQueryParams('/', extras?.query ?? {}), {
+            state: extras?.state,
+            replaceUrl: extras?.replaceUrl,
+        });
+    }
+    navigateBack(extras) {
+        const parsed = this.parseAbsoluteUrl();
+        if (parsed) {
+            let route = parsed.route.withStaticParams(parsed.params);
+            do {
+                route = route.parent;
+            } while (route && route.entryDisabled);
+            // In case route has no ancestor with allowed entry,
+            if (!route) {
+                return this.navigateHome(extras);
+            }
+            if (extras) {
+                if (extras.query) {
+                    route = route.withQueryParams(extras.query);
+                }
+                if (extras.state) {
+                    route = route.withStateParams(extras.state);
+                }
+            }
+            return this.navigate(route, extras);
+        }
+        else {
+            console.warn(`Cannot go back from ${this.location.path()} because no route matches current url`);
+            return null;
+        }
+    }
+    /**
+     * This method will try to find matching route for given absolute URL, extract its parameters and return them.
+     * If no route matches the URL, it returns null. Parameters are extracted only for the last matching route, not ancestors.
+     * @param url Absolute URL to parse (e.g. '/home/details/123?query=abc').
+     * @returns Object containing the matching route and its parameters, or null if no route is matching.
+     */
+    parseAbsoluteUrl(url = this.location.path()) {
+        const stripped = RdtStringUtils.stripQueryParams(url);
+        if (this.allRoutes) {
+            for (const route of this.allRoutes) {
+                const params = route.parseAbsoluteUrl(stripped);
+                if (params) {
+                    return { route, params };
+                }
+            }
+        }
+        return null;
+    }
+    extractAllParams(currentRoute) {
+        if (!currentRoute) {
+            const parsed = this.parseAbsoluteUrl();
+            if (!parsed) {
+                console.warn('No route matches current url.');
+                return null;
+            }
+            currentRoute = parsed.route;
+        }
+        const url = this.location.path();
+        return currentRoute.parseAbsoluteUrl(url);
+    }
+    isParentOfCurrentLocation(route) {
+        return true;
+    }
+    removeQueryParams(...paramNames) {
+        const regex = new RegExp(`[?&](${paramNames.join('|')})=[^&]*`, 'g');
+        return history.replaceState(history.state, '', location.pathname + location.search.replace(regex, '').replace(/^&/, '?'));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.2", ngImport: i0, type: RdtRouterService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.1.2", ngImport: i0, type: RdtRouterService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.2", ngImport: i0, type: RdtRouterService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [] });
+
 const DEFAULT_PARAM_TYPE = 'number';
+/**
+ * Fluent builder for creating `RdtRoute` instances.
+ * Routes are defined once in a central file and referenced everywhere by object, eliminating string-based path typos.
+ *
+ * @example
+ * ```ts
+ * const USER_DETAIL = new RdtRouteBuilder<{ userId: number }>()
+ *   .withName('User Detail')
+ *   .withPath(':userId')
+ *   .withParam('userId', 'number')
+ *   .withCanBeEntered((route, params) => params.params.userId !== 0)
+ *   .build();
+ * ```
+ *
+ * @typeParam T - Shape of the route's parameters. Enforced at compile time when navigating or creating URLs.
+ */
 class RdtRouteBuilder extends RdtRouteBase {
     get canBeEntered() {
         return this._canBeEntered;
@@ -976,8 +1061,8 @@ class RdtRouteBuilder extends RdtRouteBase {
     }
     /**
      * Defines parameter type and lets framework parse it.
-     * @param paramName
-     * @param type
+     * @param paramName Name of the parameter in the path.
+     * @param type 'string', 'number', or an array of allowed string values (enum).
      */
     withParam(paramName, type) {
         this._paramMap[paramName] = type;
@@ -1122,10 +1207,10 @@ class RdtAnyRouteActiveDirective {
             return input;
         }
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.0", ngImport: i0, type: RdtAnyRouteActiveDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
-    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "20.0.0", type: RdtAnyRouteActiveDirective, isStandalone: true, selector: "[rdtAnyRouteActive]", inputs: { anyRouteActive: ["rdtAnyRouteActive", "anyRouteActive"], watchedRoutes: "watchedRoutes", anyRouteActiveOptions: "anyRouteActiveOptions", ariaCurrentWhenActive: "ariaCurrentWhenActive" }, providers: [RouterModule], usesOnChanges: true, ngImport: i0 });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.2", ngImport: i0, type: RdtAnyRouteActiveDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.1.2", type: RdtAnyRouteActiveDirective, isStandalone: true, selector: "[rdtAnyRouteActive]", inputs: { anyRouteActive: ["rdtAnyRouteActive", "anyRouteActive"], watchedRoutes: "watchedRoutes", anyRouteActiveOptions: "anyRouteActiveOptions", ariaCurrentWhenActive: "ariaCurrentWhenActive" }, providers: [RouterModule], usesOnChanges: true, ngImport: i0 });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.0", ngImport: i0, type: RdtAnyRouteActiveDirective, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.2", ngImport: i0, type: RdtAnyRouteActiveDirective, decorators: [{
             type: Directive,
             args: [{
                     selector: '[rdtAnyRouteActive]',
@@ -1165,10 +1250,10 @@ class RdtBackLinkDirective {
             }
         });
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.0", ngImport: i0, type: RdtBackLinkDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
-    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "20.0.0", type: RdtBackLinkDirective, isStandalone: true, selector: "[rdtBackLink]", ngImport: i0 });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.2", ngImport: i0, type: RdtBackLinkDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.1.2", type: RdtBackLinkDirective, isStandalone: true, selector: "[rdtBackLink]", ngImport: i0 });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.0", ngImport: i0, type: RdtBackLinkDirective, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.2", ngImport: i0, type: RdtBackLinkDirective, decorators: [{
             type: Directive,
             args: [{
                     selector: '[rdtBackLink]',
@@ -1184,16 +1269,14 @@ class RdtRouterLinkDirective {
     });
     routerLinkRef = inject(RouterLink, { self: true });
     envInjector = inject(EnvironmentInjector);
-    routeInput = input.required({ alias: 'rdtRouterLink' });
-    route = linkedSignal(() => this.routeInput());
-    target = input('_self');
-    params = input();
-    queryParams = input();
-    stateParams = input();
-    disabled = input(false, {
-        alias: 'rdtDisabled',
-        transform: booleanAttribute,
-    });
+    routeInput = input.required({ ...(ngDevMode ? { debugName: "routeInput" } : {}), alias: 'rdtRouterLink' });
+    route = linkedSignal(() => this.routeInput(), ...(ngDevMode ? [{ debugName: "route" }] : []));
+    target = input('_self', ...(ngDevMode ? [{ debugName: "target" }] : []));
+    params = input(...(ngDevMode ? [undefined, { debugName: "params" }] : []));
+    queryParams = input(...(ngDevMode ? [undefined, { debugName: "queryParams" }] : []));
+    stateParams = input(...(ngDevMode ? [undefined, { debugName: "stateParams" }] : []));
+    disabled = input(false, { ...(ngDevMode ? { debugName: "disabled" } : {}), alias: 'rdtDisabled',
+        transform: booleanAttribute });
     canBeEntered = computed(() => {
         const route = this.route();
         const disabled = this.disabled();
@@ -1206,7 +1289,7 @@ class RdtRouterLinkDirective {
             state: this.stateParams(),
         };
         return route.canBeEntered(this.envInjector, combinedParams);
-    });
+    }, ...(ngDevMode ? [{ debugName: "canBeEntered" }] : []));
     updateEffect = effect(() => {
         if (this.buttonRef) {
             this.updateButton();
@@ -1214,7 +1297,7 @@ class RdtRouterLinkDirective {
         else {
             this.updateRouterLink();
         }
-    });
+    }, ...(ngDevMode ? [{ debugName: "updateEffect" }] : []));
     updateButton() {
         const route = this.route();
         if (!route) {
@@ -1292,10 +1375,10 @@ class RdtRouterLinkDirective {
     getNgHref(route) {
         return route.createAbsoluteUrl(this.params());
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.0", ngImport: i0, type: RdtRouterLinkDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
-    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "20.0.0", type: RdtRouterLinkDirective, isStandalone: true, selector: "[rdtRouterLink]", inputs: { routeInput: { classPropertyName: "routeInput", publicName: "rdtRouterLink", isSignal: true, isRequired: true, transformFunction: null }, target: { classPropertyName: "target", publicName: "target", isSignal: true, isRequired: false, transformFunction: null }, params: { classPropertyName: "params", publicName: "params", isSignal: true, isRequired: false, transformFunction: null }, queryParams: { classPropertyName: "queryParams", publicName: "queryParams", isSignal: true, isRequired: false, transformFunction: null }, stateParams: { classPropertyName: "stateParams", publicName: "stateParams", isSignal: true, isRequired: false, transformFunction: null }, disabled: { classPropertyName: "disabled", publicName: "rdtDisabled", isSignal: true, isRequired: false, transformFunction: null } }, hostDirectives: [{ directive: i1.RouterLink, inputs: ["target", "target", "replaceUrl", "replaceUrl"] }], ngImport: i0 });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.2", ngImport: i0, type: RdtRouterLinkDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "21.1.2", type: RdtRouterLinkDirective, isStandalone: true, selector: "[rdtRouterLink]", inputs: { routeInput: { classPropertyName: "routeInput", publicName: "rdtRouterLink", isSignal: true, isRequired: true, transformFunction: null }, target: { classPropertyName: "target", publicName: "target", isSignal: true, isRequired: false, transformFunction: null }, params: { classPropertyName: "params", publicName: "params", isSignal: true, isRequired: false, transformFunction: null }, queryParams: { classPropertyName: "queryParams", publicName: "queryParams", isSignal: true, isRequired: false, transformFunction: null }, stateParams: { classPropertyName: "stateParams", publicName: "stateParams", isSignal: true, isRequired: false, transformFunction: null }, disabled: { classPropertyName: "disabled", publicName: "rdtDisabled", isSignal: true, isRequired: false, transformFunction: null } }, hostDirectives: [{ directive: i1.RouterLink, inputs: ["target", "target", "replaceUrl", "replaceUrl"] }], ngImport: i0 });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.0", ngImport: i0, type: RdtRouterLinkDirective, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.2", ngImport: i0, type: RdtRouterLinkDirective, decorators: [{
             type: Directive,
             args: [{
                     selector: '[rdtRouterLink]',
@@ -1307,19 +1390,33 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.0", ngImpor
                         },
                     ],
                 }]
-        }] });
+        }], propDecorators: { routeInput: [{ type: i0.Input, args: [{ isSignal: true, alias: "rdtRouterLink", required: true }] }], target: [{ type: i0.Input, args: [{ isSignal: true, alias: "target", required: false }] }], params: [{ type: i0.Input, args: [{ isSignal: true, alias: "params", required: false }] }], queryParams: [{ type: i0.Input, args: [{ isSignal: true, alias: "queryParams", required: false }] }], stateParams: [{ type: i0.Input, args: [{ isSignal: true, alias: "stateParams", required: false }] }], disabled: [{ type: i0.Input, args: [{ isSignal: true, alias: "rdtDisabled", required: false }] }] } });
 
-const preventDataLossGuardFn = () => {
-    const guardStore = inject(RdtComponentGuardStoreService);
-    return guardStore.checkCanLeaveGlobal$();
+/**
+ * `CanDeactivate` guard that blocks navigation when there are unsaved changes.
+ * The routed component must implement `RdtGuardedContainer` from `@ngrdt/core`.
+ * Add to routes via `RdtAngularRoute.addCanDeactivate(preventDataLossGuardFn)`.
+ */
+const preventDataLossGuardFn = (component) => {
+    if (!component.guardRegistry.hasLeaveBlockers())
+        return true;
+    return component.guardRegistry.canLeaveAll();
 };
 
+/**
+ * Ensures that `preventDataLossGuardFn` is applied to every route at runtime,
+ * even if it was not explicitly added in the route definition.
+ * Call `ensureGlobalGuards()` once during app initialization.
+ *
+ * Also patches the browser back button behavior: replaces the URL back to the
+ * previous value during guard checks so the address bar doesn't flash the new URL
+ * before the guard potentially rejects it.
+ */
 class GlobalRouteGuardService {
     router;
     constructor(router) {
         this.router = router;
     }
-    // This will help ensure that routes are automatically protected by ensuring that global guards are applied to every route
     ensureGlobalGuards() {
         let lastUrl = '';
         this.router.events.subscribe((e) => {
@@ -1352,10 +1449,10 @@ class GlobalRouteGuardService {
             canDeactivateGuards.push(preventDataLossGuardFn);
         }
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.0", ngImport: i0, type: GlobalRouteGuardService, deps: [{ token: i1.Router }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.0.0", ngImport: i0, type: GlobalRouteGuardService, providedIn: 'root' });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.2", ngImport: i0, type: GlobalRouteGuardService, deps: [{ token: i1.Router }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.1.2", ngImport: i0, type: GlobalRouteGuardService, providedIn: 'root' });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.0", ngImport: i0, type: GlobalRouteGuardService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.2", ngImport: i0, type: GlobalRouteGuardService, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }], ctorParameters: () => [{ type: i1.Router }] });
@@ -1364,5 +1461,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.0", ngImpor
  * Generated bundle index. Do not edit.
  */
 
-export { GlobalRouteGuardService, PERMISSION_DISABLED_KEY, RDT_CANNOT_BE_ENTERED_PROVIDER, RDT_CONFIRM_DATA_LOSS_SERVICE, RDT_ROUTES_PROVIDER, RdtAngularRoute, RdtAnyRouteActiveDirective, RdtBackLinkDirective, RdtConfirmDataLossService, RdtConfirmDataLossServiceAlert, RdtNavigationSource, RdtParameters, RdtRoute, RdtRouteBuilder, RdtRouterLinkDirective, RdtRouterService, preventDataLossGuardFn };
+export { GlobalRouteGuardService, PERMISSION_DISABLED_KEY, RDT_CANNOT_BE_ENTERED_PROVIDER, RDT_ROUTES_PROVIDER, RdtAngularRoute, RdtAnyRouteActiveDirective, RdtBackLinkDirective, RdtNavigationSource, RdtParameters, RdtRoute, RdtRouteBuilder, RdtRouterLinkDirective, RdtRouterService, preventDataLossGuardFn, provideRdtRoutes };
 //# sourceMappingURL=ngrdt-router.mjs.map