@ngrdt/router 0.0.17 → 0.0.18

package/index.d.ts

@@ -1,12 +1,416 @@
-export * from './lib/services/rdt-cannot-be-entered.token';
-export * from './lib/services/rdt-confirm-data-loss.service';
-export * from './lib/services/rdt-router.service';
-export * from './lib/services/rdt-routes.token';
-export * from './lib/rdt-route/constants';
-export * from './lib/rdt-route/rdt-angular-route';
-export * from './lib/rdt-route/rdt-route';
-export * from './lib/rdt-route/rdt-route-builder';
-export * from './lib/directives/rdt-any-route-active.directive';
-export * from './lib/directives/rdt-router-link.directive';
-export * from './lib/guards/global-route-guard.service';
-export * from './lib/guards/prevent-data-loss.guard';
+import * as i0 from '@angular/core';
+import { Type, Injector, InjectionToken, OnInit, OnChanges, SimpleChanges } from '@angular/core';
+import * as i1 from '@angular/router';
+import { LoadChildrenCallback, Route, ResolveFn, CanActivateFn, CanDeactivateFn, CanActivateChildFn, RunGuardsAndResolvers, Params, Data, NavigationEnd, IsActiveMatchOptions, Router } from '@angular/router';
+import { Observable } from 'rxjs';
+
+declare class RdtAngularRoute<T extends object> {
+    private route;
+    private children;
+    private loadChildren?;
+    private component?;
+    private providers;
+    private resolvers;
+    private canActivate;
+    private canActivateChild;
+    private canDeactivate;
+    private runGuardsAndResolvers?;
+    private data?;
+    constructor(route: RdtRoute<T>);
+    provide(...providers: Type<unknown>[]): this;
+    withModule(callback: LoadChildrenCallback): this;
+    /**
+     * @deprecated Use withModule() instead.
+     */
+    setModule(callback: LoadChildrenCallback): this;
+    withComponent(comp: Type<any>): this;
+    /**
+     * @deprecated Use withComponent() instead.
+     */
+    setComponent(comp: Type<any>): this;
+    withChildren(...routes: Route[]): this;
+    /**
+     * @deprecated Use withChildren() instead.
+     */
+    setChildren(...routes: Route[]): this;
+    addResolve(paramName: string, resolver: ResolveFn<unknown>): this;
+    addCanActivate(...fns: CanActivateFn[]): this;
+    addCanDeactivate(...fns: CanDeactivateFn<any>[]): this;
+    addCanActivateChild(...fns: CanActivateChildFn[]): this;
+    withRunGuardsAndResolvers(value: RunGuardsAndResolvers): this;
+    /**
+     * @deprecated Use withRunGuardsAndResolvers() instead.
+     */
+    setRunGuardsAndResolvers(value: RunGuardsAndResolvers): this;
+    build(): Route;
+    private getCanMatch;
+    private checkChildrenMatch;
+}
+
+declare function ALWAYS_TRUE(): boolean;
+declare class RdtRoute<T extends object = any> {
+    protected orderedParams: string[];
+    protected _paramMap: ParamTypeMap<T>;
+    protected _regex: RegExp | null;
+    protected paramMappings: ParamMapping[];
+    protected _staticParams: Partial<T>;
+    protected _queryParams: Params;
+    protected _stateParams: Params;
+    protected _data: Data;
+    protected _name: string;
+    protected _path: string;
+    protected _parent: RdtRoute | null;
+    protected _children: RdtRoute[];
+    protected _entryDisabled: boolean;
+    protected _canBeEntered: () => boolean;
+    protected _built: boolean;
+    private _absoluteRegex?;
+    /**
+     * Map of parameters and their types.
+     */
+    get paramMap(): Readonly<ParamTypeMap<T>>;
+    /**
+     * Human readable name for display in breadcrumbs, title, etc.
+     */
+    get name(): string;
+    /**
+     * Path of the route relative to parent route.
+     */
+    get path(): string;
+    /**
+     * Parent route.
+     */
+    get parent(): RdtRoute<any> | null;
+    /**
+     * Child routes.
+     */
+    get children(): RdtRoute<any>[];
+    /**
+     * Absolute path of parent route or '/' if there is no parent.
+     * Hostname excluded.
+     */
+    get basePath(): string;
+    /**
+     * Absolute path of the route. Hostname excluded.
+     */
+    get absolutePath(): string;
+    /**
+     * Regular expression route path relative to parent route.
+     * Hostname excluded.
+     */
+    get regex(): RegExp | null;
+    /**
+     * Regular expression to match only this route (not children
+     * or parent routes). Hostname excluded.
+     */
+    get absoluteRegex(): RegExp;
+    /**
+     * Denotes disabled route entry.
+     * If true, route should have no NgModule
+     * or component and only serves as virtual module
+     * for breadcrumb.
+     */
+    get entryDisabled(): boolean;
+    /**
+     * Statically set state params used when navigating to this instance.
+     */
+    get stateParams(): Params;
+    /**
+     * Statically set query params used when navigating to this instance.
+     */
+    get queryParams(): Params;
+    /**
+     * @param url Absolute path to test.
+     * @returns True if url matches this route.
+     */
+    testUrl(url: string): boolean;
+    /**
+     * Statically set parameters used when navigating to this instance.
+     */
+    get staticParams(): Partial<T>;
+    get hasCanBeEnteredGuard(): boolean;
+    /**
+     * Data that is passed to Angular route definition.
+     */
+    get data(): Data;
+    /**
+     * Meta guard that is used by [rdtRouterLink] and RdtMenu
+     * to determine if route can be entered.
+     * @param injector Environment or custom injector.
+     * @returns True if route can be entered.
+     */
+    canBeEntered(injector?: Injector): boolean;
+    /**
+     * Extracts url parameters from absolute path for this path and each parent.
+     */
+    parseAbsoluteUrl(url: string): RdtReadonlyParameters | null;
+    private fill;
+    /**
+     * Fills parameters in path with values from paramMap.
+     * Use withStaticParams() beforehand in case parent paths contain parameters.
+     * @param paramMap Must contain all parameters for this route.
+     * @returns Absolute path.
+     */
+    createAbsoluteUrl(paramMap?: Partial<T>): string;
+    createRelativeUrl(paramMap?: Partial<T>): string;
+    private createUrl;
+    toAngularRoute(): RdtAngularRoute<T>;
+    /**
+     * Provides static mapping for parameter names tableName -> urlName.
+     * Returns new instance of RdtRoute<T> that is clone of
+     * this route and its parents (NOT children).
+     * @returns Clone of this route with mapped parameter names.
+     */
+    withParamMappings(mappings: ParamMapping[]): RdtRoute<T>;
+    /**
+     * Sets static parameters for this route.
+     * @param params Static parameters for this route.
+     * @returns Clone of this with static parameters set.
+     */
+    withStaticParams(params: T): RdtRoute<T>;
+    withStaticParams<T2 extends object>(route: RdtRoute<T2>, params: T2): RdtRoute<T>;
+    withQueryParams(queryParams: Params): RdtRoute<T>;
+    withStateParams(stateParams: Params): RdtRoute<T>;
+    /**
+     * @returns Partial of object that only contains properties necessary to create this route.
+     */
+    extractRouteParams(row: T): Partial<T>;
+    /**
+     * @returns New instance of RdtRoute<T> that is clone of
+     * this route and its parents (NOT children).
+     */
+    clone(): RdtRoute<T>;
+}
+
+type ParamTypeMap<T> = {
+    [key in keyof T]?: 'string' | 'number';
+};
+interface ParamMapping {
+    urlName: string;
+    tableName: string;
+}
+interface StaticRouteParams {
+    [absolutePath: string]: object;
+}
+type RdtRedirectReturnType = string | void | undefined;
+type RdtRedirectFn = (currentPath: string, targetPath: string, targetRoute: RdtRoute) => RdtRedirectReturnType;
+declare class RdtReadonlyParameters {
+    protected readonly params: StaticRouteParams;
+    constructor(params?: StaticRouteParams);
+    get<T extends object>(route: RdtRoute<T>): Partial<T> | null;
+}
+
+/**
+ * Injection token that defines behavior when route cannot be entered (canBeEntered returns false).
+ * If value is undefined, route will be redirected to ''.
+ */
+declare const RDT_CANNOT_BE_ENTERED_PROVIDER: InjectionToken<RdtRedirectFn | RdtRedirectReturnType>;
+
+declare const RDT_CONFIRM_DATA_LOSS_SERVICE: InjectionToken<RdtConfirmDataLossService>;
+declare abstract class RdtConfirmDataLossService {
+    abstract confirmDataLoss(): Observable<boolean>;
+}
+declare class RdtConfirmDataLossServiceAlert extends RdtConfirmDataLossService {
+    confirmDataLoss(): Observable<boolean>;
+}
+
+interface RdtNavigateExtras {
+    state?: Params;
+    query?: Params;
+    target?: '_blank' | '_self' | '_parent' | '_top';
+    replaceUrl?: boolean;
+}
+declare class RdtRouterService {
+    readonly allRoutes: RdtRoute<any>[] | null;
+    private readonly location;
+    private readonly router;
+    private readonly baseHref;
+    private _previousUrl;
+    private _currentUrl;
+    get previousUrl(): string | null;
+    get currentUrl(): string | null;
+    parsePreviousUrl(): {
+        route: RdtRoute<any>;
+        params: RdtReadonlyParameters;
+    } | null;
+    parseCurrentUrl(): {
+        route: RdtRoute<any>;
+        params: RdtReadonlyParameters;
+    } | null;
+    readonly navigationEnd$: Observable<NavigationEnd>;
+    readonly nextNavigationEnd$: Observable<NavigationEnd>;
+    constructor();
+    /**
+     * @returns window.history.state extended by state parameters passed from parent window.
+     */
+    getHistoryState(): any;
+    /**
+     * Navigates to the specified route.
+     * @param link Route to navigate to.
+     * @param params Parameter of route passed as first argument.
+     * @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<T extends object>(link: RdtRoute<T>, params?: Partial<T>, extras?: RdtNavigateExtras): Promise<boolean>;
+    navigateHome(extras?: RdtNavigateExtras): Promise<boolean>;
+    navigateBack(extras?: RdtNavigateExtras): Promise<boolean> | 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?: string): {
+        route: RdtRoute<any>;
+        params: RdtReadonlyParameters;
+    } | null;
+    extractAllParams(currentRoute?: RdtRoute): RdtReadonlyParameters | null;
+    isParentOfCurrentLocation(route: RdtRoute): boolean;
+    removeQueryParams(...paramNames: string[]): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdtRouterService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RdtRouterService>;
+}
+
+declare const RDT_ROUTES_PROVIDER: InjectionToken<RdtRoute<any>[]>;
+
+declare enum RdtNavigationSource {
+    BREADCRUMB = "breadcrumb"
+}
+
+declare class RdtRouteBuilder<T extends object = any> extends RdtRoute<T> {
+    /**
+     * CanBeEntered function is synchronous function which
+     * lets framework hide menu buttons and disable links.
+     * Function is run in environment injection context, so
+     * you can inject global services, tokens, etc.
+     * @param fn
+     */
+    withCanBeEntered(fn: () => boolean): this;
+    /**
+     * @deprecated Use withCanBeEntered() instead.
+     */
+    setCanBeEntered(fn: () => boolean): this;
+    /**
+     * Entry disabled route will generate disabled breadcrumb.
+     * It should not have any component nor module added to it.
+     * @param value
+     * @returns
+     */
+    withEntryDisabled(value?: boolean): this;
+    /**
+     * @deprecated Use withEntryDisabled() instead.
+     */
+    setEntryDisabled(value?: boolean): this;
+    /**
+     * Sets path relative to parent. It is defined the same way as Angular route path including parameters.
+     * You need to call setParam() for each parameter you use in the path.
+     */
+    withPath(path: string): this;
+    /**
+     * @deprecated Use withPath() instead.
+     */
+    setPath(path: string): this;
+    /**
+     * Sets Angular route data.
+     * @param data Angular route data object. Breadcrumb key is merged into it.
+     */
+    withData(data: Data): this;
+    /**
+     * @deprecated Use withData() instead.
+     */
+    setData(data: Data): this;
+    /**
+     * Defines parameter type and lets framework parse it.
+     * @param paramName
+     * @param type
+     */
+    withParam(paramName: keyof T, type: 'string' | 'number'): this;
+    /**
+     * @deprecated Use withParam() instead.
+     */
+    setParam(paramName: keyof T, type: 'string' | 'number'): this;
+    /**
+     * Sets name to display in breadcrumb, etc.
+     */
+    withName(name: string): this;
+    /**
+     * @deprecated Use withName() instead.
+     */
+    setName(name: string): this;
+    /**
+     * Call .build() on children before you call this method!
+     */
+    withChildren(...children: RdtRoute[]): this;
+    /**
+     * @deprecated Use withChildren() instead.
+     */
+    setChildren(...children: RdtRoute[]): this;
+    build(): RdtRoute<T>;
+    private setRegex;
+    private static readonly groups;
+}
+
+/**
+ * Directive that appends class to host if any of the watched routes is active.
+ */
+declare class RdtAnyRouteActiveDirective implements OnInit, OnChanges {
+    private readonly destroyRef;
+    private readonly router;
+    private readonly renderer;
+    private readonly elRef;
+    set anyRouteActive(data: string[] | string);
+    watchedRoutes: (string | string[])[];
+    set anyRouteActiveOptions(value: {
+        exact: boolean;
+    } | IsActiveMatchOptions);
+    private _anyRouteActiveOptions;
+    ariaCurrentWhenActive?: 'page' | 'step' | 'location' | 'date' | 'time' | true | false;
+    get isActive(): boolean;
+    private _isActive;
+    private classes;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    update(): void;
+    private setAriaCurrent;
+    private setClasses;
+    private addClass;
+    private removeClass;
+    private listenRouterEvents;
+    private parseClasses;
+    private parseOptions;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdtAnyRouteActiveDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdtAnyRouteActiveDirective, "[rdtAnyRouteActive]", never, { "anyRouteActive": { "alias": "rdtAnyRouteActive"; "required": true; }; "watchedRoutes": { "alias": "watchedRoutes"; "required": true; }; "anyRouteActiveOptions": { "alias": "anyRouteActiveOptions"; "required": false; }; "ariaCurrentWhenActive": { "alias": "ariaCurrentWhenActive"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class RdtRouterLinkDirective<T extends object> implements OnInit, OnChanges {
+    private readonly routerLinkRef;
+    private readonly envInjector;
+    route: RdtRoute<T>;
+    target: '_blank' | '_self' | '_parent' | '_top';
+    params?: Partial<T>;
+    queryParams?: Params;
+    stateParams?: Params;
+    disabled: boolean;
+    ngOnInit(): void;
+    ngOnChanges(): void;
+    private update;
+    private setLink;
+    private disableLink;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdtRouterLinkDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdtRouterLinkDirective<any>, "[rdtRouterLink]", never, { "route": { "alias": "rdtRouterLink"; "required": true; }; "target": { "alias": "target"; "required": false; }; "params": { "alias": "params"; "required": false; }; "queryParams": { "alias": "queryParams"; "required": false; }; "stateParams": { "alias": "stateParams"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, never, true, [{ directive: typeof i1.RouterLink; inputs: { "target": "target"; }; outputs: {}; }]>;
+    static ngAcceptInputType_disabled: unknown;
+}
+
+declare class GlobalRouteGuardService {
+    private router;
+    constructor(router: Router);
+    ensureGlobalGuards(): void;
+    private ensureCanDeactivateGuards;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GlobalRouteGuardService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<GlobalRouteGuardService>;
+}
+
+declare const preventDataLossGuardFn: CanDeactivateFn<any>;
+
+export { ALWAYS_TRUE, GlobalRouteGuardService, RDT_CANNOT_BE_ENTERED_PROVIDER, RDT_CONFIRM_DATA_LOSS_SERVICE, RDT_ROUTES_PROVIDER, RdtAngularRoute, RdtAnyRouteActiveDirective, RdtConfirmDataLossService, RdtConfirmDataLossServiceAlert, RdtNavigationSource, RdtRoute, RdtRouteBuilder, RdtRouterLinkDirective, RdtRouterService, preventDataLossGuardFn };
+export type { RdtNavigateExtras };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ngrdt/router",
-  "version": "v0.0.17",
+  "version": "v0.0.18",
   "peerDependencies": {
     "@angular/common": ">=18.2.0",
     "@angular/core": ">=18.2.0",
@@ -18,8 +18,6 @@
     },
     ".": {
       "types": "./index.d.ts",
-      "esm2022": "./esm2022/ngrdt-router.mjs",
-      "esm": "./esm2022/ngrdt-router.mjs",
       "default": "./fesm2022/ngrdt-router.mjs"
     }
   },

package/esm2022/index.mjs

@@ -1,13 +0,0 @@
-export * from './lib/services/rdt-cannot-be-entered.token';
-export * from './lib/services/rdt-confirm-data-loss.service';
-export * from './lib/services/rdt-router.service';
-export * from './lib/services/rdt-routes.token';
-export * from './lib/rdt-route/constants';
-export * from './lib/rdt-route/rdt-angular-route';
-export * from './lib/rdt-route/rdt-route';
-export * from './lib/rdt-route/rdt-route-builder';
-export * from './lib/directives/rdt-any-route-active.directive';
-export * from './lib/directives/rdt-router-link.directive';
-export * from './lib/guards/global-route-guard.service';
-export * from './lib/guards/prevent-data-loss.guard';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9AbmdyZHQvcm91dGVyL3NyYy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLDRDQUE0QyxDQUFDO0FBQzNELGNBQWMsOENBQThDLENBQUM7QUFDN0QsY0FBYyxtQ0FBbUMsQ0FBQztBQUNsRCxjQUFjLGlDQUFpQyxDQUFDO0FBRWhELGNBQWMsMkJBQTJCLENBQUM7QUFDMUMsY0FBYyxtQ0FBbUMsQ0FBQztBQUNsRCxjQUFjLDJCQUEyQixDQUFDO0FBQzFDLGNBQWMsbUNBQW1DLENBQUM7QUFFbEQsY0FBYyxpREFBaUQsQ0FBQztBQUNoRSxjQUFjLDRDQUE0QyxDQUFDO0FBRTNELGNBQWMseUNBQXlDLENBQUM7QUFDeEQsY0FBYyxzQ0FBc0MsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vbGliL3NlcnZpY2VzL3JkdC1jYW5ub3QtYmUtZW50ZXJlZC50b2tlbic7XHJcbmV4cG9ydCAqIGZyb20gJy4vbGliL3NlcnZpY2VzL3JkdC1jb25maXJtLWRhdGEtbG9zcy5zZXJ2aWNlJztcclxuZXhwb3J0ICogZnJvbSAnLi9saWIvc2VydmljZXMvcmR0LXJvdXRlci5zZXJ2aWNlJztcclxuZXhwb3J0ICogZnJvbSAnLi9saWIvc2VydmljZXMvcmR0LXJvdXRlcy50b2tlbic7XHJcblxyXG5leHBvcnQgKiBmcm9tICcuL2xpYi9yZHQtcm91dGUvY29uc3RhbnRzJztcclxuZXhwb3J0ICogZnJvbSAnLi9saWIvcmR0LXJvdXRlL3JkdC1hbmd1bGFyLXJvdXRlJztcclxuZXhwb3J0ICogZnJvbSAnLi9saWIvcmR0LXJvdXRlL3JkdC1yb3V0ZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vbGliL3JkdC1yb3V0ZS9yZHQtcm91dGUtYnVpbGRlcic7XHJcblxyXG5leHBvcnQgKiBmcm9tICcuL2xpYi9kaXJlY3RpdmVzL3JkdC1hbnktcm91dGUtYWN0aXZlLmRpcmVjdGl2ZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vbGliL2RpcmVjdGl2ZXMvcmR0LXJvdXRlci1saW5rLmRpcmVjdGl2ZSc7XHJcblxyXG5leHBvcnQgKiBmcm9tICcuL2xpYi9ndWFyZHMvZ2xvYmFsLXJvdXRlLWd1YXJkLnNlcnZpY2UnO1xyXG5leHBvcnQgKiBmcm9tICcuL2xpYi9ndWFyZHMvcHJldmVudC1kYXRhLWxvc3MuZ3VhcmQnO1xyXG4iXX0=

package/esm2022/lib/directives/rdt-any-route-active.directive.mjs

@@ -1,126 +0,0 @@
-import { DestroyRef, Directive, ElementRef, Input, Renderer2, inject, } from '@angular/core';
-import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
-import { NavigationEnd, Router, RouterModule, } from '@angular/router';
-import { filter } from 'rxjs';
-import * as i0 from "@angular/core";
-const EXACT_TRUE_OPTS = {
-    paths: 'exact',
-    queryParams: 'exact',
-    fragment: 'ignored',
-    matrixParams: 'ignored',
-};
-const EXACT_FALSE_OPTS = {
-    paths: 'subset',
-    queryParams: 'subset',
-    fragment: 'ignored',
-    matrixParams: 'ignored',
-};
-/**
- * Directive that appends class to host if any of the watched routes is active.
- */
-export class RdtAnyRouteActiveDirective {
-    destroyRef = inject(DestroyRef);
-    router = inject(Router);
-    renderer = inject(Renderer2);
-    elRef = inject(ElementRef);
-    set anyRouteActive(data) {
-        this.classes = this.parseClasses(data);
-    }
-    watchedRoutes = [];
-    set anyRouteActiveOptions(value) {
-        this._anyRouteActiveOptions = this.parseOptions(value);
-    }
-    _anyRouteActiveOptions = EXACT_FALSE_OPTS;
-    ariaCurrentWhenActive;
-    get isActive() {
-        return this._isActive;
-    }
-    _isActive = false;
-    classes = [];
-    ngOnInit() {
-        this.update();
-        this.listenRouterEvents();
-    }
-    ngOnChanges(changes) {
-        if (changes['anyRouteActive']?.previousValue) {
-            const prev = this.parseClasses(changes['anyRouteActive'].previousValue);
-            prev.forEach((c) => this.removeClass(c));
-        }
-        this.update();
-    }
-    update() {
-        this._isActive = this.watchedRoutes.some((route) => {
-            const param = typeof route === 'string' ? route : this.router.createUrlTree(route);
-            return this.router.isActive(param, this._anyRouteActiveOptions);
-        });
-        this.setClasses();
-        this.setAriaCurrent();
-    }
-    setAriaCurrent() {
-        const el = this.elRef.nativeElement;
-        if (this._isActive && this.ariaCurrentWhenActive !== undefined) {
-            const value = this.ariaCurrentWhenActive.toString();
-            this.renderer.setAttribute(el, 'aria-current', value);
-        }
-        else {
-            this.renderer.removeAttribute(el, 'aria-current');
-        }
-    }
-    setClasses() {
-        if (this._isActive) {
-            this.classes.forEach((c) => this.addClass(c));
-        }
-        else {
-            this.classes.forEach((c) => this.removeClass(c));
-        }
-    }
-    addClass(className) {
-        this.renderer.addClass(this.elRef.nativeElement, className);
-    }
-    removeClass(className) {
-        this.renderer.removeClass(this.elRef.nativeElement, className);
-    }
-    listenRouterEvents() {
-        this.router.events
-            .pipe(filter((ev) => ev instanceof NavigationEnd), takeUntilDestroyed(this.destroyRef))
-            .subscribe(() => this.update());
-    }
-    parseClasses(data) {
-        const classes = Array.isArray(data) ? data : data.split(' ');
-        return classes.filter((c) => !!c);
-    }
-    parseOptions(input) {
-        if ('exact' in input) {
-            if (input.exact) {
-                return EXACT_TRUE_OPTS;
-            }
-            else {
-                return EXACT_FALSE_OPTS;
-            }
-        }
-        else {
-            return input;
-        }
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: RdtAnyRouteActiveDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
-    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.7", 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: "18.2.7", ngImport: i0, type: RdtAnyRouteActiveDirective, decorators: [{
-            type: Directive,
-            args: [{
-                    selector: '[rdtAnyRouteActive]',
-                    standalone: true,
-                    providers: [RouterModule],
-                }]
-        }], propDecorators: { anyRouteActive: [{
-                type: Input,
-                args: [{ required: true, alias: 'rdtAnyRouteActive' }]
-            }], watchedRoutes: [{
-                type: Input,
-                args: [{ required: true }]
-            }], anyRouteActiveOptions: [{
-                type: Input
-            }], ariaCurrentWhenActive: [{
-                type: Input
-            }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rdt-any-route-active.directive.js","sourceRoot":"","sources":["../../../../../../@ngrdt/router/src/lib/directives/rdt-any-route-active.directive.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,UAAU,EACV,SAAS,EACT,UAAU,EACV,KAAK,EAGL,SAAS,EAET,MAAM,GACP,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAChE,OAAO,EAEL,aAAa,EACb,MAAM,EACN,YAAY,GACb,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;;AAE9B,MAAM,eAAe,GAAyB;IAC5C,KAAK,EAAE,OAAO;IACd,WAAW,EAAE,OAAO;IACpB,QAAQ,EAAE,SAAS;IACnB,YAAY,EAAE,SAAS;CACxB,CAAC;AAEF,MAAM,gBAAgB,GAAyB;IAC7C,KAAK,EAAE,QAAQ;IACf,WAAW,EAAE,QAAQ;IACrB,QAAQ,EAAE,SAAS;IACnB,YAAY,EAAE,SAAS;CACxB,CAAC;AAEF;;GAEG;AAMH,MAAM,OAAO,0BAA0B;IACpB,UAAU,GAAG,MAAM,CAAC,UAAU,CAAC,CAAC;IAChC,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC;IACxB,QAAQ,GAAG,MAAM,CAAC,SAAS,CAAC,CAAC;IAC7B,KAAK,GAA4B,MAAM,CAAC,UAAU,CAAC,CAAC;IAErE,IACI,cAAc,CAAC,IAAuB;QACxC,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;IACzC,CAAC;IAGD,aAAa,GAA0B,EAAE,CAAC;IAE1C,IACI,qBAAqB,CAAC,KAAgD;QACxE,IAAI,CAAC,sBAAsB,GAAG,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;IACzD,CAAC;IACO,sBAAsB,GAAyB,gBAAgB,CAAC;IAGxE,qBAAqB,CAOX;IAEV,IAAI,QAAQ;QACV,OAAO,IAAI,CAAC,SAAS,CAAC;IACxB,CAAC;IACO,SAAS,GAAG,KAAK,CAAC;IAElB,OAAO,GAAa,EAAE,CAAC;IAE/B,QAAQ;QACN,IAAI,CAAC,MAAM,EAAE,CAAC;QACd,IAAI,CAAC,kBAAkB,EAAE,CAAC;IAC5B,CAAC;IAED,WAAW,CAAC,OAAsB;QAChC,IAAI,OAAO,CAAC,gBAAgB,CAAC,EAAE,aAAa,EAAE,CAAC;YAC7C,MAAM,IAAI,GAAG,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,gBAAgB,CAAC,CAAC,aAAa,CAAC,CAAC;YACxE,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC;QAC3C,CAAC;QAED,IAAI,CAAC,MAAM,EAAE,CAAC;IAChB,CAAC;IAED,MAAM;QACJ,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE;YACjD,MAAM,KAAK,GACT,OAAO,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;YACvE,OAAO,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAC,sBAAsB,CAAC,CAAC;QAClE,CAAC,CAAC,CAAC;QACH,IAAI,CAAC,UAAU,EAAE,CAAC;QAClB,IAAI,CAAC,cAAc,EAAE,CAAC;IACxB,CAAC;IAEO,cAAc;QACpB,MAAM,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,aAAa,CAAC;QAEpC,IAAI,IAAI,CAAC,SAAS,IAAI,IAAI,CAAC,qBAAqB,KAAK,SAAS,EAAE,CAAC;YAC/D,MAAM,KAAK,GAAG,IAAI,CAAC,qBAAqB,CAAC,QAAQ,EAAE,CAAC;YACpD,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC,EAAE,EAAE,cAAc,EAAE,KAAK,CAAC,CAAC;QACxD,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,QAAQ,CAAC,eAAe,CAAC,EAAE,EAAE,cAAc,CAAC,CAAC;QACpD,CAAC;IACH,CAAC;IAEO,UAAU;QAChB,IAAI,IAAI,CAAC,SAAS,EAAE,CAAC;YACnB,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;QAChD,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC;QACnD,CAAC;IACH,CAAC;IAEO,QAAQ,CAAC,SAAiB;QAChC,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,aAAa,EAAE,SAAS,CAAC,CAAC;IAC9D,CAAC;IAEO,WAAW,CAAC,SAAiB;QACnC,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,IAAI,CAAC,KAAK,CAAC,aAAa,EAAE,SAAS,CAAC,CAAC;IACjE,CAAC;IAEO,kBAAkB;QACxB,IAAI,CAAC,MAAM,CAAC,MAAM;aACf,IAAI,CACH,MAAM,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,YAAY,aAAa,CAAC,EAC3C,kBAAkB,CAAC,IAAI,CAAC,UAAU,CAAC,CACpC;aACA,SAAS,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC;IACpC,CAAC;IAEO,YAAY,CAAC,IAAuB;QAC1C,MAAM,OAAO,GAAG,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QAC7D,OAAO,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IACpC,CAAC;IAEO,YAAY,CAAC,KAAgD;QACnE,IAAI,OAAO,IAAI,KAAK,EAAE,CAAC;YACrB,IAAI,KAAK,CAAC,KAAK,EAAE,CAAC;gBAChB,OAAO,eAAe,CAAC;YACzB,CAAC;iBAAM,CAAC;gBACN,OAAO,gBAAgB,CAAC;YAC1B,CAAC;QACH,CAAC;aAAM,CAAC;YACN,OAAO,KAAK,CAAC;QACf,CAAC;IACH,CAAC;uGAhHU,0BAA0B;2FAA1B,0BAA0B,uQAF1B,CAAC,YAAY,CAAC;;2FAEd,0BAA0B;kBALtC,SAAS;mBAAC;oBACT,QAAQ,EAAE,qBAAqB;oBAC/B,UAAU,EAAE,IAAI;oBAChB,SAAS,EAAE,CAAC,YAAY,CAAC;iBAC1B;8BAQK,cAAc;sBADjB,KAAK;uBAAC,EAAE,QAAQ,EAAE,IAAI,EAAE,KAAK,EAAE,mBAAmB,EAAE;gBAMrD,aAAa;sBADZ,KAAK;uBAAC,EAAE,QAAQ,EAAE,IAAI,EAAE;gBAIrB,qBAAqB;sBADxB,KAAK;gBAON,qBAAqB;sBADpB,KAAK","sourcesContent":["import {\r\n  DestroyRef,\r\n  Directive,\r\n  ElementRef,\r\n  Input,\r\n  OnChanges,\r\n  OnInit,\r\n  Renderer2,\r\n  SimpleChanges,\r\n  inject,\r\n} from '@angular/core';\r\nimport { takeUntilDestroyed } from '@angular/core/rxjs-interop';\r\nimport {\r\n  IsActiveMatchOptions,\r\n  NavigationEnd,\r\n  Router,\r\n  RouterModule,\r\n} from '@angular/router';\r\nimport { filter } from 'rxjs';\r\n\r\nconst EXACT_TRUE_OPTS: IsActiveMatchOptions = {\r\n  paths: 'exact',\r\n  queryParams: 'exact',\r\n  fragment: 'ignored',\r\n  matrixParams: 'ignored',\r\n};\r\n\r\nconst EXACT_FALSE_OPTS: IsActiveMatchOptions = {\r\n  paths: 'subset',\r\n  queryParams: 'subset',\r\n  fragment: 'ignored',\r\n  matrixParams: 'ignored',\r\n};\r\n\r\n/**\r\n * Directive that appends class to host if any of the watched routes is active.\r\n */\r\n@Directive({\r\n  selector: '[rdtAnyRouteActive]',\r\n  standalone: true,\r\n  providers: [RouterModule],\r\n})\r\nexport class RdtAnyRouteActiveDirective implements OnInit, OnChanges {\r\n  private readonly destroyRef = inject(DestroyRef);\r\n  private readonly router = inject(Router);\r\n  private readonly renderer = inject(Renderer2);\r\n  private readonly elRef: ElementRef<HTMLElement> = inject(ElementRef);\r\n\r\n  @Input({ required: true, alias: 'rdtAnyRouteActive' })\r\n  set anyRouteActive(data: string[] | string) {\r\n    this.classes = this.parseClasses(data);\r\n  }\r\n\r\n  @Input({ required: true })\r\n  watchedRoutes: (string | string[])[] = [];\r\n\r\n  @Input()\r\n  set anyRouteActiveOptions(value: { exact: boolean } | IsActiveMatchOptions) {\r\n    this._anyRouteActiveOptions = this.parseOptions(value);\r\n  }\r\n  private _anyRouteActiveOptions: IsActiveMatchOptions = EXACT_FALSE_OPTS;\r\n\r\n  @Input()\r\n  ariaCurrentWhenActive?:\r\n    | 'page'\r\n    | 'step'\r\n    | 'location'\r\n    | 'date'\r\n    | 'time'\r\n    | true\r\n    | false;\r\n\r\n  get isActive() {\r\n    return this._isActive;\r\n  }\r\n  private _isActive = false;\r\n\r\n  private classes: string[] = [];\r\n\r\n  ngOnInit() {\r\n    this.update();\r\n    this.listenRouterEvents();\r\n  }\r\n\r\n  ngOnChanges(changes: SimpleChanges): void {\r\n    if (changes['anyRouteActive']?.previousValue) {\r\n      const prev = this.parseClasses(changes['anyRouteActive'].previousValue);\r\n      prev.forEach((c) => this.removeClass(c));\r\n    }\r\n\r\n    this.update();\r\n  }\r\n\r\n  update() {\r\n    this._isActive = this.watchedRoutes.some((route) => {\r\n      const param =\r\n        typeof route === 'string' ? route : this.router.createUrlTree(route);\r\n      return this.router.isActive(param, this._anyRouteActiveOptions);\r\n    });\r\n    this.setClasses();\r\n    this.setAriaCurrent();\r\n  }\r\n\r\n  private setAriaCurrent() {\r\n    const el = this.elRef.nativeElement;\r\n\r\n    if (this._isActive && this.ariaCurrentWhenActive !== undefined) {\r\n      const value = this.ariaCurrentWhenActive.toString();\r\n      this.renderer.setAttribute(el, 'aria-current', value);\r\n    } else {\r\n      this.renderer.removeAttribute(el, 'aria-current');\r\n    }\r\n  }\r\n\r\n  private setClasses() {\r\n    if (this._isActive) {\r\n      this.classes.forEach((c) => this.addClass(c));\r\n    } else {\r\n      this.classes.forEach((c) => this.removeClass(c));\r\n    }\r\n  }\r\n\r\n  private addClass(className: string) {\r\n    this.renderer.addClass(this.elRef.nativeElement, className);\r\n  }\r\n\r\n  private removeClass(className: string) {\r\n    this.renderer.removeClass(this.elRef.nativeElement, className);\r\n  }\r\n\r\n  private listenRouterEvents() {\r\n    this.router.events\r\n      .pipe(\r\n        filter((ev) => ev instanceof NavigationEnd),\r\n        takeUntilDestroyed(this.destroyRef)\r\n      )\r\n      .subscribe(() => this.update());\r\n  }\r\n\r\n  private parseClasses(data: string[] | string) {\r\n    const classes = Array.isArray(data) ? data : data.split(' ');\r\n    return classes.filter((c) => !!c);\r\n  }\r\n\r\n  private parseOptions(input: { exact: boolean } | IsActiveMatchOptions) {\r\n    if ('exact' in input) {\r\n      if (input.exact) {\r\n        return EXACT_TRUE_OPTS;\r\n      } else {\r\n        return EXACT_FALSE_OPTS;\r\n      }\r\n    } else {\r\n      return input;\r\n    }\r\n  }\r\n}\r\n"]}