@ngrdt/router 0.0.7 → 0.0.9

package/lib/rdt-route/rdt-route.d.ts

@@ -1,7 +1,7 @@
-import { ParamMapping, ParamTypeMap } from './utils';
+import { Injector } from '@angular/core';
 import { Params } from '@angular/router';
 import { RdtAngularRoute } from './rdt-angular-route';
-import { Injector } from '@angular/core';
+import { ParamMapping, ParamTypeMap, RdtReadonlyParameters } from './utils';
 export declare function ALWAYS_TRUE(): boolean;
 export declare class RdtRoute<T extends object = any> {
     protected orderedParams: string[];
@@ -18,33 +18,115 @@ export declare class RdtRoute<T extends object = any> {
     protected _entryDisabled: boolean;
     protected _canBeEntered: () => 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;
+    /**
+     * 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;
+    /**
+     * 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;
-    parseAbsoluteUrl(url: string): Record<string, any> | null;
+    /**
+     * 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<T>, 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>;
 }

package/lib/rdt-route/utils.d.ts

@@ -1,3 +1,4 @@
+import { RdtRoute } from './rdt-route';
 export type ParamTypeMap<T> = {
     [key in keyof T]?: 'string' | 'number';
 };
@@ -8,3 +9,13 @@ export interface ParamMapping {
 export interface StaticRouteParams {
     [absolutePath: string]: object;
 }
+export type RdtRedirectReturnType = string | void | undefined;
+export type RdtRedirectFn = (currentPath: string, targetPath: string, targetRoute: RdtRoute) => RdtRedirectReturnType;
+export declare class RdtReadonlyParameters {
+    protected readonly params: StaticRouteParams;
+    constructor(params?: StaticRouteParams);
+    get<T extends object>(route: RdtRoute<T>): Partial<T> | null;
+}
+export declare class RdtParameters extends RdtReadonlyParameters {
+    set<T extends object>(route: RdtRoute<T>, params: Partial<T>): void;
+}

package/lib/services/rdt-cannot-be-entered.token.d.ts

@@ -1,2 +1,7 @@
 import { InjectionToken } from '@angular/core';
-export declare const RDT_CANNOT_BE_ENTERED_PROVIDER: InjectionToken<string | false>;
+import { RdtRedirectFn, RdtRedirectReturnType } from '../rdt-route/utils';
+/**
+ * Injection token that defines behavior when route cannot be entered (canBeEntered returns false).
+ * If value is undefined, route will be redirected to ''.
+ */
+export declare const RDT_CANNOT_BE_ENTERED_PROVIDER: InjectionToken<RdtRedirectFn | RdtRedirectReturnType>;

package/lib/services/rdt-router.service.d.ts

@@ -1,6 +1,7 @@
 import { NavigationEnd, Params } from '@angular/router';
 import { Observable } from 'rxjs';
 import { RdtRoute } from '../rdt-route/rdt-route';
+import { RdtReadonlyParameters } from '../rdt-route/utils';
 import * as i0 from "@angular/core";
 export interface RdtNavigateParams {
     state?: Params;
@@ -17,11 +18,11 @@ export declare class RdtRouterService {
     get currentUrl(): string | null;
     parsePreviousUrl(): {
         route: RdtRoute<any>;
-        params: Record<string, any>;
+        params: RdtReadonlyParameters;
     } | null;
     parseCurrentUrl(): {
         route: RdtRoute<any>;
-        params: Record<string, any>;
+        params: RdtReadonlyParameters;
     } | null;
     readonly navigationEnd$: Observable<NavigationEnd>;
     readonly nextNavigationEnd$: Observable<NavigationEnd>;
@@ -30,10 +31,10 @@ export declare class RdtRouterService {
     navigateHome(params?: RdtNavigateParams): Promise<boolean>;
     parseAbsoluteUrl(url?: string): {
         route: RdtRoute<any>;
-        params: Record<string, any>;
+        params: RdtReadonlyParameters;
     } | null;
     navigateBack(params?: RdtNavigateParams): Promise<boolean> | null;
-    extractAllParams(currentRoute?: RdtRoute): Record<string, any> | null;
+    extractAllParams(currentRoute?: RdtRoute): RdtReadonlyParameters | null;
     isParentOfCurrentLocation(route: RdtRoute): boolean;
     removeQueryParams(...paramNames: string[]): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<RdtRouterService, never>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ngrdt/router",
-  "version": "0.0.7",
+  "version": "0.0.9",
   "peerDependencies": {
     "@angular/common": "^18.2.0",
     "@angular/core": "^18.2.0",