@ngrdt/router 0.0.13 → 0.0.17

package/README.md

@@ -1,255 +1,255 @@
-# @ngrdt/router
-
-Main use for this package is to define routes and their parameters in one place in app. It is recommended to define special `routes` module in every app using `@ngrdt/router` where all `RdtRoute` objects are defined using `RdtRouteBuilder`. Individual application modules then import these objects, define Angular routes and provide implementation details such as which component is rendered, state, guards, etc.
-
-This approach ensures that each route is defined exactly once and can be easily edited if necessary. `@ngrdt/router` also provides set of useful tools to help you with common routing tasks.
-
-### Instalation
-
-`npm install @ngrdt/router`
-
-## Basic usage
-
-### Application routes file
-
-Create special `nx` library (not `NgModule`) for instance `@example-app/routes`. In this library you will create file called `routes.ts` and in it individual `RdtRoute` objects like so:
-
-```typescript
-export const DASHBOARD_ITEM_ROUTE = new RdtRouteBuilder()
-  .setName('Dashboard item')
-  .setPath(':id')
-  .setParam('id', 'number')
-  .build();
-
-export const DASHBOARD_ROUTE = new RdtRouteBuilder()
-  .setName('Dashboard')
-  .setPath('dashboard')
-  .setChildren(DASHBOARD_ITEM_ROUTE)
-  .build();
-
-export const SETTINGS_ROUTE = new RdtRouteBuilder()
-  .setName('Settings')
-  .setPath('settings')
-  .setCanBeEntered(() => 
-    inject(ExampleAppPermissionService).hasPermission('SETTINGS_ACCESS')
-  )
-  .build();
-```
-
-This file should only contain imports to interfaces used by `RdtRouteBuilder` as template parameter. No component, ngModule or guards such as `CanActivateFn` should be imported here. This approach will save you later headache with circular dependency.
-
-`RdtRouterService` needs to be aware of all routes defined therefore you must provide it in your `ApplicationConfig` like so:
-
-```typescript
-import { RDT_ROUTES_PROVIDER, RdtRoute } from '@ngrdt/router';
-import * as ALL_ROUTES_OBJ from './rdt-routes';
-const ALL_ROUTES = Object.values(ALL_ROUTES_OBJ) as RdtRoute[];
-
-export const appConfig: ApplicationConfig = {
-  providers: [
-    {
-      provide: RDT_ROUTES_PROVIDER,
-      useValue: ALL_ROUTES,
-    },
-  ]
-}
-```
-
-### Angular routes files
-
-Now you have to bind `RdtRoute` objects to individual modules, components, states, effects, guards and other implementation details. Instead of defining routes directly you import `RdtRoute` from `@example-app/routes` and then define `routes.ts` like so:
-
-```typescript
-export const routes: Route[] = [
-  DASHBOARD_ROUTE.toAngularRoute()
-    .setComponent(DashboardComponent)
-    .setChildren(
-      DASHBOARD_ITEM_ROUTE.toAngularRoute()
-        .setComponent(DashboardItemComponent)
-        .addCanDeactivate(preventDataLossGuardFn)
-        .build()
-    )
-    .build(),
-]
-```
-
-This array is then used as in regular Angular project. Note that child routes must be added as children here as well.
-
-
-### Child routes and parameters
-
-You may nest child routes and also create routes with typed parameters to link them with particular type.
-
-For instance lets say there's a route displaying users which has a child route to display more information about a single user. By providing `User` type to `RdtRouteBuilder` and defining types of parameters we can use `RdtRoute` object to parse path to extract parameters.
-
-```typescript
-interface User {
-  userId: number;
-  name: string;
-}
-
-export const USER_DETAIL_ROUTE = new RdtRouteBuilder<User>()
-  .setName('User detail')
-  .setPath(':userId/:name')
-  .setParam('userId', 'number')
-  .setParam('name', 'string')
-  .build();
-
-export const USER_LIST_ROUTE = new RdtRouteBuilder()
-  .setName('Users')
-  .setPath('users')
-  .setChildren(USER_DETAIL_ROUTE)
-  .build();
-```
-
-Then we navigate to user detail like so:
-
-```typescript
-const params: Partial<User> = {
-  userId: 123,
-  name: 'Josef',
-};
-
-inject(RdtRouterService).navigate(USER_DETAIL_ROUTE, params);
-```
-
-`RdtRouterService` is aware of the type so you can use it to parse absolute path into `User` object. Route knows `userId` is `number` so it will parse it. If parameter is missing or is of wrong type, then `parseAbsoluteUrl` returns `null`. Return value is a wrapper object with `get(route: RdtRoute)` method to get parsed parameters of given route or its parents.
-
-
-```typescript
-const user: User = USER_DETAIL_ROUTE
-  .parse('/users/123/Josef')
-  .get(USER_DETAIL_ROUTE);
-```
-
-### More parameter examples
-
-#### Static parameters
-
-Imagine your app contains list of users and each user has set of tasks. The routes are defined as follows:
-
-```typescript
-interface User {
-  userId: number,
-  name: string,
-  address: string,
-  tasks: Task[]
-}
-
-interface Task {
-  taskId: number,
-  description: string
-}
-
-
-export const TASK_DETAIL_ROUTE = new RdtRouteBuilder<Task>()
-  .setName('Task detail')
-  .setPath('task/:taskId')
-  .setParam('taskId', 'number')
-  .build();
-
-export const USER_DETAIL_ROUTE = new RdtRouteBuilder<User>()
-  .setName('User detail')
-  .setPath(':userId')
-  .setParam('userId', 'number')
-  .setChildren(TASK_DETAIL_ROUTE)
-  .build();
-
-export const USER_LIST_ROUTE = new RdtRouteBuilder()
-  .setName('Users')
-  .setPath('user')
-  .setChildren(USER_DETAIL_ROUTE)
-  .build();
-```
-
-This translates into path `/user/:userId/task/:taskId` for task detail route.
-
-Now inside `UserDetailComponent` there's a for loop rendering individual tasks and you want to have links to them. You cannot use directly:
-
-```html
-<button [rdtRouterLink]="TASK_DETAIL_ROUTE" [params]="task"></button>
-```
-Because task does not specify `userId`. For this you must provide static parameters for every parent route - `User` for `USER_DETAIL_ROUTE` in this case:
-
-```typescript
-@Input()
-user!: User;
-
-taskRoute!: RdtRoute<Task>;
-
-ngOnInit() {
-  this.taskRoute = TASK_DETAIL_ROUTE.withStaticParams(USER_DETAIL_ROUTE, this.user);
-}
-```
-Method `withStaticParams()` returns clone of `TASK_DETAIL_ROUTE` and all of its parent routes while fixing parameters. You can chain calling `withStaticParams` with itself or other method calls.
-
-```html
-<button [rdtRouterLink]="taskRoute" [params]="task"></button>
-```
-
-## Ecosystem
-
-### RdtRouterLink
-
-`RdtRouterLink` is equivalent of `RouterLink` in Angular. It supports basically the same functionality, but adds type safety. `RdtRouterLink` will be disabled if `canBeEntered` of its route returns `false`.
-
-```typescript
-readonly userRoute = USER_DETAIL_ROUTE;
-readonly user$ = inject(UserService).getUser$();
-```
-
-```html
-<button 
-  [rdtRouterLink]="userRoute" 
-  [params]="user$ | async"
-  target="_blank">
-Link to user
-</button>
-```
-
-### RdtMenu
-
-`RdtRoute` can be passed directly into `RdtMenuItem`. If `canBeEntered` returns `false`, then the item won't be visible. This is useful to hide items user has no permission for.
-
-Method `withStaticParams` lets us provide parameters for given `RdtRoute`, because `RdtMenuItem` does not accept route parameters.
-
-```typescript
-public getMenuItems(): RdtMenuItem[] {
-  const user: Partial<User> = {
-    userId: 123,
-    name: 'Josef'
-  };
-
-  return [
-    {
-      label: 'All users',
-      routerLink: USER_LIST_ROUTE
-    },
-    {
-      label: 'Josef',
-      routerLink: USER_DETAIL_ROUTE.withStaticParams(user)
-    }
-  ];
-}
-```
-
-### RdtAngularRoute
-
-`RdtAngularRoute` is a container class for `RdtRoute` which functionally does two things: verifies that routes were defined correctly and enables you to provide guards, effects, component or module. Don't forget to call `build()` for it to generate Angular `Route`.
-
-### RdtRouterService
-
-`RdtRouterService` has similar features as Angular `Router`.
-
-#### `parseAbsoluteUrl()`
-Method will parse absolute path, recognize `RdtRoute` and parse its parameters. If no parameter is provided, then window location is used.
-
-#### `navigateBack()`
-
-Will push parent route to navigation stack. Function works anywhere in the app unlike similar Angular-based solution using `ActivatedRoute`.
-
-Hitting native browser back button will take you back forward. In case you want true back function, use `inject(Location).back()` which removes from navigation stack, but can potentially take you outside of the app or close browser window.
-
-#### `previousUrl` and `currentUrl`
-
+# @ngrdt/router
+
+Main use for this package is to define routes and their parameters in one place in app. It is recommended to define special `routes` module in every app using `@ngrdt/router` where all `RdtRoute` objects are defined using `RdtRouteBuilder`. Individual application modules then import these objects, define Angular routes and provide implementation details such as which component is rendered, state, guards, etc.
+
+This approach ensures that each route is defined exactly once and can be easily edited if necessary. `@ngrdt/router` also provides set of useful tools to help you with common routing tasks.
+
+### Instalation
+
+`npm install @ngrdt/router`
+
+## Basic usage
+
+### Application routes file
+
+Create special `nx` library (not `NgModule`) for instance `@example-app/routes`. In this library you will create file called `routes.ts` and in it individual `RdtRoute` objects like so:
+
+```typescript
+export const DASHBOARD_ITEM_ROUTE = new RdtRouteBuilder()
+  .setName('Dashboard item')
+  .setPath(':id')
+  .setParam('id', 'number')
+  .build();
+
+export const DASHBOARD_ROUTE = new RdtRouteBuilder()
+  .setName('Dashboard')
+  .setPath('dashboard')
+  .setChildren(DASHBOARD_ITEM_ROUTE)
+  .build();
+
+export const SETTINGS_ROUTE = new RdtRouteBuilder()
+  .setName('Settings')
+  .setPath('settings')
+  .setCanBeEntered(() => 
+    inject(ExampleAppPermissionService).hasPermission('SETTINGS_ACCESS')
+  )
+  .build();
+```
+
+This file should only contain imports to interfaces used by `RdtRouteBuilder` as template parameter. No component, ngModule or guards such as `CanActivateFn` should be imported here. This approach will save you later headache with circular dependency.
+
+`RdtRouterService` needs to be aware of all routes defined therefore you must provide it in your `ApplicationConfig` like so:
+
+```typescript
+import { RDT_ROUTES_PROVIDER, RdtRoute } from '@ngrdt/router';
+import * as ALL_ROUTES_OBJ from './rdt-routes';
+const ALL_ROUTES = Object.values(ALL_ROUTES_OBJ) as RdtRoute[];
+
+export const appConfig: ApplicationConfig = {
+  providers: [
+    {
+      provide: RDT_ROUTES_PROVIDER,
+      useValue: ALL_ROUTES,
+    },
+  ]
+}
+```
+
+### Angular routes files
+
+Now you have to bind `RdtRoute` objects to individual modules, components, states, effects, guards and other implementation details. Instead of defining routes directly you import `RdtRoute` from `@example-app/routes` and then define `routes.ts` like so:
+
+```typescript
+export const routes: Route[] = [
+  DASHBOARD_ROUTE.toAngularRoute()
+    .setComponent(DashboardComponent)
+    .setChildren(
+      DASHBOARD_ITEM_ROUTE.toAngularRoute()
+        .setComponent(DashboardItemComponent)
+        .addCanDeactivate(preventDataLossGuardFn)
+        .build()
+    )
+    .build(),
+]
+```
+
+This array is then used as in regular Angular project. Note that child routes must be added as children here as well.
+
+
+### Child routes and parameters
+
+You may nest child routes and also create routes with typed parameters to link them with particular type.
+
+For instance lets say there's a route displaying users which has a child route to display more information about a single user. By providing `User` type to `RdtRouteBuilder` and defining types of parameters we can use `RdtRoute` object to parse path to extract parameters.
+
+```typescript
+interface User {
+  userId: number;
+  name: string;
+}
+
+export const USER_DETAIL_ROUTE = new RdtRouteBuilder<User>()
+  .setName('User detail')
+  .setPath(':userId/:name')
+  .setParam('userId', 'number')
+  .setParam('name', 'string')
+  .build();
+
+export const USER_LIST_ROUTE = new RdtRouteBuilder()
+  .setName('Users')
+  .setPath('users')
+  .setChildren(USER_DETAIL_ROUTE)
+  .build();
+```
+
+Then we navigate to user detail like so:
+
+```typescript
+const params: Partial<User> = {
+  userId: 123,
+  name: 'Josef',
+};
+
+inject(RdtRouterService).navigate(USER_DETAIL_ROUTE, params);
+```
+
+`RdtRouterService` is aware of the type so you can use it to parse absolute path into `User` object. Route knows `userId` is `number` so it will parse it. If parameter is missing or is of wrong type, then `parseAbsoluteUrl` returns `null`. Return value is a wrapper object with `get(route: RdtRoute)` method to get parsed parameters of given route or its parents.
+
+
+```typescript
+const user: User = USER_DETAIL_ROUTE
+  .parse('/users/123/Josef')
+  .get(USER_DETAIL_ROUTE);
+```
+
+### More parameter examples
+
+#### Static parameters
+
+Imagine your app contains list of users and each user has set of tasks. The routes are defined as follows:
+
+```typescript
+interface User {
+  userId: number,
+  name: string,
+  address: string,
+  tasks: Task[]
+}
+
+interface Task {
+  taskId: number,
+  description: string
+}
+
+
+export const TASK_DETAIL_ROUTE = new RdtRouteBuilder<Task>()
+  .setName('Task detail')
+  .setPath('task/:taskId')
+  .setParam('taskId', 'number')
+  .build();
+
+export const USER_DETAIL_ROUTE = new RdtRouteBuilder<User>()
+  .setName('User detail')
+  .setPath(':userId')
+  .setParam('userId', 'number')
+  .setChildren(TASK_DETAIL_ROUTE)
+  .build();
+
+export const USER_LIST_ROUTE = new RdtRouteBuilder()
+  .setName('Users')
+  .setPath('user')
+  .setChildren(USER_DETAIL_ROUTE)
+  .build();
+```
+
+This translates into path `/user/:userId/task/:taskId` for task detail route.
+
+Now inside `UserDetailComponent` there's a for loop rendering individual tasks and you want to have links to them. You cannot use directly:
+
+```html
+<button [rdtRouterLink]="TASK_DETAIL_ROUTE" [params]="task"></button>
+```
+Because task does not specify `userId`. For this you must provide static parameters for every parent route - `User` for `USER_DETAIL_ROUTE` in this case:
+
+```typescript
+@Input()
+user!: User;
+
+taskRoute!: RdtRoute<Task>;
+
+ngOnInit() {
+  this.taskRoute = TASK_DETAIL_ROUTE.withStaticParams(USER_DETAIL_ROUTE, this.user);
+}
+```
+Method `withStaticParams()` returns clone of `TASK_DETAIL_ROUTE` and all of its parent routes while fixing parameters. You can chain calling `withStaticParams` with itself or other method calls.
+
+```html
+<button [rdtRouterLink]="taskRoute" [params]="task"></button>
+```
+
+## Ecosystem
+
+### RdtRouterLink
+
+`RdtRouterLink` is equivalent of `RouterLink` in Angular. It supports basically the same functionality, but adds type safety. `RdtRouterLink` will be disabled if `canBeEntered` of its route returns `false`.
+
+```typescript
+readonly userRoute = USER_DETAIL_ROUTE;
+readonly user$ = inject(UserService).getUser$();
+```
+
+```html
+<button 
+  [rdtRouterLink]="userRoute" 
+  [params]="user$ | async"
+  target="_blank">
+Link to user
+</button>
+```
+
+### RdtMenu
+
+`RdtRoute` can be passed directly into `RdtMenuItem`. If `canBeEntered` returns `false`, then the item won't be visible. This is useful to hide items user has no permission for.
+
+Method `withStaticParams` lets us provide parameters for given `RdtRoute`, because `RdtMenuItem` does not accept route parameters.
+
+```typescript
+public getMenuItems(): RdtMenuItem[] {
+  const user: Partial<User> = {
+    userId: 123,
+    name: 'Josef'
+  };
+
+  return [
+    {
+      label: 'All users',
+      routerLink: USER_LIST_ROUTE
+    },
+    {
+      label: 'Josef',
+      routerLink: USER_DETAIL_ROUTE.withStaticParams(user)
+    }
+  ];
+}
+```
+
+### RdtAngularRoute
+
+`RdtAngularRoute` is a container class for `RdtRoute` which functionally does two things: verifies that routes were defined correctly and enables you to provide guards, effects, component or module. Don't forget to call `build()` for it to generate Angular `Route`.
+
+### RdtRouterService
+
+`RdtRouterService` has similar features as Angular `Router`.
+
+#### `parseAbsoluteUrl()`
+Method will parse absolute path, recognize `RdtRoute` and parse its parameters. If no parameter is provided, then window location is used.
+
+#### `navigateBack()`
+
+Will push parent route to navigation stack. Function works anywhere in the app unlike similar Angular-based solution using `ActivatedRoute`.
+
+Hitting native browser back button will take you back forward. In case you want true back function, use `inject(Location).back()` which removes from navigation stack, but can potentially take you outside of the app or close browser window.
+
+#### `previousUrl` and `currentUrl`
+
 Cached sync values of previous and current path values. For example `/dashboard` or `/user/123/task/xyz`.

package/esm2022/index.mjs

@@ -10,4 +10,4 @@ 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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9AbmdyZHQvcm91dGVyL3NyYy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLDRDQUE0QyxDQUFDO0FBQzNELGNBQWMsOENBQThDLENBQUM7QUFDN0QsY0FBYyxtQ0FBbUMsQ0FBQztBQUNsRCxjQUFjLGlDQUFpQyxDQUFDO0FBRWhELGNBQWMsMkJBQTJCLENBQUM7QUFDMUMsY0FBYyxtQ0FBbUMsQ0FBQztBQUNsRCxjQUFjLDJCQUEyQixDQUFDO0FBQzFDLGNBQWMsbUNBQW1DLENBQUM7QUFFbEQsY0FBYyxpREFBaUQsQ0FBQztBQUNoRSxjQUFjLDRDQUE0QyxDQUFDO0FBRTNELGNBQWMseUNBQXlDLENBQUM7QUFDeEQsY0FBYyxzQ0FBc0MsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vbGliL3NlcnZpY2VzL3JkdC1jYW5ub3QtYmUtZW50ZXJlZC50b2tlbic7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9zZXJ2aWNlcy9yZHQtY29uZmlybS1kYXRhLWxvc3Muc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9zZXJ2aWNlcy9yZHQtcm91dGVyLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvc2VydmljZXMvcmR0LXJvdXRlcy50b2tlbic7XG5cbmV4cG9ydCAqIGZyb20gJy4vbGliL3JkdC1yb3V0ZS9jb25zdGFudHMnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvcmR0LXJvdXRlL3JkdC1hbmd1bGFyLXJvdXRlJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL3JkdC1yb3V0ZS9yZHQtcm91dGUnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvcmR0LXJvdXRlL3JkdC1yb3V0ZS1idWlsZGVyJztcblxuZXhwb3J0ICogZnJvbSAnLi9saWIvZGlyZWN0aXZlcy9yZHQtYW55LXJvdXRlLWFjdGl2ZS5kaXJlY3RpdmUnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvZGlyZWN0aXZlcy9yZHQtcm91dGVyLWxpbmsuZGlyZWN0aXZlJztcblxuZXhwb3J0ICogZnJvbSAnLi9saWIvZ3VhcmRzL2dsb2JhbC1yb3V0ZS1ndWFyZC5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2d1YXJkcy9wcmV2ZW50LWRhdGEtbG9zcy5ndWFyZCc7XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9AbmdyZHQvcm91dGVyL3NyYy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLDRDQUE0QyxDQUFDO0FBQzNELGNBQWMsOENBQThDLENBQUM7QUFDN0QsY0FBYyxtQ0FBbUMsQ0FBQztBQUNsRCxjQUFjLGlDQUFpQyxDQUFDO0FBRWhELGNBQWMsMkJBQTJCLENBQUM7QUFDMUMsY0FBYyxtQ0FBbUMsQ0FBQztBQUNsRCxjQUFjLDJCQUEyQixDQUFDO0FBQzFDLGNBQWMsbUNBQW1DLENBQUM7QUFFbEQsY0FBYyxpREFBaUQsQ0FBQztBQUNoRSxjQUFjLDRDQUE0QyxDQUFDO0FBRTNELGNBQWMseUNBQXlDLENBQUM7QUFDeEQsY0FBYyxzQ0FBc0MsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vbGliL3NlcnZpY2VzL3JkdC1jYW5ub3QtYmUtZW50ZXJlZC50b2tlbic7XHJcbmV4cG9ydCAqIGZyb20gJy4vbGliL3NlcnZpY2VzL3JkdC1jb25maXJtLWRhdGEtbG9zcy5zZXJ2aWNlJztcclxuZXhwb3J0ICogZnJvbSAnLi9saWIvc2VydmljZXMvcmR0LXJvdXRlci5zZXJ2aWNlJztcclxuZXhwb3J0ICogZnJvbSAnLi9saWIvc2VydmljZXMvcmR0LXJvdXRlcy50b2tlbic7XHJcblxyXG5leHBvcnQgKiBmcm9tICcuL2xpYi9yZHQtcm91dGUvY29uc3RhbnRzJztcclxuZXhwb3J0ICogZnJvbSAnLi9saWIvcmR0LXJvdXRlL3JkdC1hbmd1bGFyLXJvdXRlJztcclxuZXhwb3J0ICogZnJvbSAnLi9saWIvcmR0LXJvdXRlL3JkdC1yb3V0ZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vbGliL3JkdC1yb3V0ZS9yZHQtcm91dGUtYnVpbGRlcic7XHJcblxyXG5leHBvcnQgKiBmcm9tICcuL2xpYi9kaXJlY3RpdmVzL3JkdC1hbnktcm91dGUtYWN0aXZlLmRpcmVjdGl2ZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vbGliL2RpcmVjdGl2ZXMvcmR0LXJvdXRlci1saW5rLmRpcmVjdGl2ZSc7XHJcblxyXG5leHBvcnQgKiBmcm9tICcuL2xpYi9ndWFyZHMvZ2xvYmFsLXJvdXRlLWd1YXJkLnNlcnZpY2UnO1xyXG5leHBvcnQgKiBmcm9tICcuL2xpYi9ndWFyZHMvcHJldmVudC1kYXRhLWxvc3MuZ3VhcmQnO1xyXG4iXX0=

package/esm2022/lib/rdt-route/rdt-angular-route.mjs

@@ -152,7 +152,9 @@ export class RdtAngularRoute {
             return undefined;
         }
         const routeSegmentLength = this.route.path.split('/').length;
-        const regex = new RegExp(`^${this.route.regex.source}$`);
+        const regex = this.route.regex
+            ? new RegExp(`^${this.route.regex.source}$`)
+            : this.route.absoluteRegex;
         return [
             (route, segments) => {
                 const path = segments
@@ -191,4 +193,4 @@ export class RdtAngularRoute {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rdt-angular-route.js","sourceRoot":"","sources":["../../../../../../@ngrdt/router/src/lib/rdt-route/rdt-angular-route.ts"],"names":[],"mappings":"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","sourcesContent":["import { Location } from '@angular/common';\r\nimport {\r\n  EnvironmentInjector,\r\n  EnvironmentProviders,\r\n  inject,\r\n  Provider,\r\n  runInInjectionContext,\r\n  Type,\r\n} from '@angular/core';\r\nimport {\r\n  ActivatedRouteSnapshot,\r\n  CanActivateChildFn,\r\n  CanActivateFn,\r\n  CanDeactivateFn,\r\n  CanMatchFn,\r\n  Data,\r\n  LoadChildrenCallback,\r\n  ResolveFn,\r\n  Route,\r\n  Router,\r\n  RouterStateSnapshot,\r\n  RunGuardsAndResolvers,\r\n  UrlSegment,\r\n} from '@angular/router';\r\nimport { RDT_CANNOT_BE_ENTERED_PROVIDER } from '../services/rdt-cannot-be-entered.token';\r\nimport { RdtNavigationSource } from './constants';\r\nimport { RdtRoute } from './rdt-route';\r\n\r\nexport class RdtAngularRoute<T extends object> {\r\n  private route: RdtRoute<T>;\r\n  private children: Route[] = [];\r\n\r\n  // Must be set from component declaration files\r\n  private loadChildren?: LoadChildrenCallback;\r\n  private component?: Type<any>;\r\n  private providers: (Provider | EnvironmentProviders)[] = [];\r\n  private resolvers: { [key: string]: ResolveFn<unknown> } = {};\r\n  private canActivate: CanActivateFn[] = [];\r\n  private canActivateChild: CanActivateChildFn[] = [];\r\n  private canDeactivate: CanDeactivateFn<T>[] = [];\r\n  private runGuardsAndResolvers?: RunGuardsAndResolvers;\r\n  private data?: Data;\r\n\r\n  constructor(route: RdtRoute<T>) {\r\n    this.route = route;\r\n  }\r\n\r\n  provide(...providers: Type<unknown>[]) {\r\n    this.providers.push(...providers);\r\n    return this;\r\n  }\r\n\r\n  setModule(callback: LoadChildrenCallback) {\r\n    this.loadChildren = callback;\r\n    return this;\r\n  }\r\n\r\n  setComponent(comp: Type<any>) {\r\n    this.component = comp;\r\n    return this;\r\n  }\r\n\r\n  setChildren(...routes: Route[]) {\r\n    this.children = routes;\r\n    return this;\r\n  }\r\n\r\n  addResolve(paramName: string, resolver: ResolveFn<unknown>) {\r\n    this.resolvers[paramName] = resolver;\r\n    return this;\r\n  }\r\n\r\n  addCanActivate(...fns: CanActivateFn[]) {\r\n    this.canActivate.push(...fns);\r\n    return this;\r\n  }\r\n\r\n  addCanDeactivate(...fns: CanDeactivateFn<any>[]) {\r\n    this.canDeactivate.push(...fns);\r\n    return this;\r\n  }\r\n\r\n  addCanActivateChild(...fns: CanActivateChildFn[]) {\r\n    this.canActivateChild.push(...fns);\r\n    return this;\r\n  }\r\n\r\n  setRunGuardsAndResolvers(value: RunGuardsAndResolvers) {\r\n    this.runGuardsAndResolvers = value;\r\n    return this;\r\n  }\r\n\r\n  build(): Route {\r\n    this.checkChildrenMatch();\r\n\r\n    let res: Route = {\r\n      path: this.route.path,\r\n      providers: this.providers,\r\n      title: this.route.name,\r\n      canMatch: this.getCanMatch(),\r\n    };\r\n\r\n    if (this.component) {\r\n      res.component = this.component;\r\n    } else if (this.loadChildren) {\r\n      res.loadChildren = this.loadChildren;\r\n    }\r\n\r\n    res.data = this.data ?? {\r\n      breadcrumb: {\r\n        label: this.route.name,\r\n        disable: this.route.entryDisabled,\r\n        staticStateParams: {\r\n          src: RdtNavigationSource.BREADCRUMB,\r\n        },\r\n      },\r\n      ...this.route.data,\r\n    };\r\n\r\n    const guard: CanActivateFn = (\r\n      route: ActivatedRouteSnapshot,\r\n      state: RouterStateSnapshot\r\n    ) => {\r\n      const injector = inject(EnvironmentInjector);\r\n      if (\r\n        runInInjectionContext(\r\n          injector,\r\n          this.route.canBeEntered.bind(this.route)\r\n        )\r\n      ) {\r\n        return true;\r\n      } else {\r\n        const router = inject(Router);\r\n        const location = inject(Location);\r\n        let url = inject(RDT_CANNOT_BE_ENTERED_PROVIDER);\r\n        if (typeof url === 'function') {\r\n          //console.error(this.route.absolutePath);\r\n          url = runInInjectionContext(\r\n            injector,\r\n            url.bind(url, location.path(), state.url, this.route)\r\n          );\r\n        }\r\n        if (typeof url === 'string') {\r\n          return router.parseUrl(url);\r\n        } else {\r\n          return false;\r\n        }\r\n      }\r\n    };\r\n    this.canActivate.push(guard);\r\n\r\n    res.canActivate = this.canActivate;\r\n    res.canDeactivate = this.canDeactivate;\r\n\r\n    // If children exist, change\r\n    // {\r\n    //    path: '/path',\r\n    //    component: FeatureComponent,\r\n    //    children: [...]\r\n    // }\r\n    // into\r\n    // {\r\n    //    path: '/path',\r\n    //    children: [\r\n    //      {\r\n    //        path: '',\r\n    //        component: FeatureComponent\r\n    //      },\r\n    //    ...\r\n    //    ]\r\n    //    }\r\n    if (this.children.length > 0) {\r\n      if (this.loadChildren || this.component) {\r\n        const path = res.path;\r\n        res.path = '';\r\n        res.pathMatch = 'full';\r\n        res.canMatch = undefined;\r\n        res = {\r\n          path: path,\r\n          children: [res, ...this.children],\r\n          canActivateChild: this.canActivateChild,\r\n          canMatch: this.getCanMatch(),\r\n        };\r\n      } else {\r\n        res.children = this.children;\r\n      }\r\n    }\r\n\r\n    if (Object.keys(this.resolvers).length > 0) {\r\n      res.resolve = this.resolvers;\r\n    }\r\n\r\n    if (this.runGuardsAndResolvers) {\r\n      res.runGuardsAndResolvers = this.runGuardsAndResolvers;\r\n    }\r\n\r\n    return res;\r\n  }\r\n\r\n  private getCanMatch(): CanMatchFn[] | undefined {\r\n    const paramMap = this.route.paramMap;\r\n    const hasNumberParams = Object.keys(paramMap).some(\r\n      (p) => paramMap[p as keyof T] === 'number'\r\n    );\r\n    if (!hasNumberParams) {\r\n      return undefined;\r\n    }\r\n    const routeSegmentLength = this.route.path.split('/').length;\r\n    const regex = new RegExp(`^${this.route.regex.source}$`);\r\n    return [\r\n      (route: Route, segments: UrlSegment[]) => {\r\n        const path = segments\r\n          .slice(0, routeSegmentLength)\r\n          .map((s) => s.path)\r\n          .join('/');\r\n        return regex.test(path);\r\n      },\r\n    ];\r\n  }\r\n\r\n  private checkChildrenMatch() {\r\n    // Check that all routes are present if route is not\r\n    // lazy loaded module.\r\n    if (\r\n      !this.loadChildren &&\r\n      (this.route.children.length > 0 || this.children.length > 0)\r\n    ) {\r\n      if (this.children.length < this.route.children.length) {\r\n        throw new Error(\r\n          `RdtRoute ${this.route.name} has ${\r\n            this.route.children.length\r\n          } children, but RdtAngularRoute has ${\r\n            this.children.length\r\n          }. These numbers must match. Did you forget to call .setChildren() method in global routes definition? Routes with following names should be present: ${this.route.children\r\n            .map((ch) => ch.name)\r\n            .join(', ')}`\r\n        );\r\n      } else if (this.children.length > this.route.children.length) {\r\n        throw new Error(\r\n          `RdtRoute ${this.route.name} has ${\r\n            this.route.children.length\r\n          } children, but RdtAngularRoute has ${\r\n            this.children.length\r\n          }. These numbers must match. Did you forget to call .setChildren() method in feature shell routes definition? Routes with following paths should be present: ${this.children\r\n            .map((ch) => ch.path)\r\n            .join(', ')}`\r\n        );\r\n      }\r\n      const n1 = this.children.map((ch) => ch.path!);\r\n      const n2 = this.route.children.map((ch) => ch.path);\r\n      n1.sort();\r\n      n2.sort();\r\n      for (let i = 0; i < n1.length; i++) {\r\n        if (n1[i] !== n2[i]) {\r\n          throw new Error(\r\n            `Paths of children provided in RdtRoute and\r\n            RdtAngularRoute do not match. ${n1[i]} != ${n2[i]}`\r\n          );\r\n        }\r\n      }\r\n    }\r\n  }\r\n}\r\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rdt-angular-route.js","sourceRoot":"","sources":["../../../../../../@ngrdt/router/src/lib/rdt-route/rdt-angular-route.ts"],"names":[],"mappings":"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","sourcesContent":["import { Location } from '@angular/common';\r\nimport {\r\n  EnvironmentInjector,\r\n  EnvironmentProviders,\r\n  inject,\r\n  Provider,\r\n  runInInjectionContext,\r\n  Type,\r\n} from '@angular/core';\r\nimport {\r\n  ActivatedRouteSnapshot,\r\n  CanActivateChildFn,\r\n  CanActivateFn,\r\n  CanDeactivateFn,\r\n  CanMatchFn,\r\n  Data,\r\n  LoadChildrenCallback,\r\n  ResolveFn,\r\n  Route,\r\n  Router,\r\n  RouterStateSnapshot,\r\n  RunGuardsAndResolvers,\r\n  UrlSegment,\r\n} from '@angular/router';\r\nimport { RDT_CANNOT_BE_ENTERED_PROVIDER } from '../services/rdt-cannot-be-entered.token';\r\nimport { RdtNavigationSource } from './constants';\r\nimport { RdtRoute } from './rdt-route';\r\n\r\nexport class RdtAngularRoute<T extends object> {\r\n  private route: RdtRoute<T>;\r\n  private children: Route[] = [];\r\n\r\n  // Must be set from component declaration files\r\n  private loadChildren?: LoadChildrenCallback;\r\n  private component?: Type<any>;\r\n  private providers: (Provider | EnvironmentProviders)[] = [];\r\n  private resolvers: { [key: string]: ResolveFn<unknown> } = {};\r\n  private canActivate: CanActivateFn[] = [];\r\n  private canActivateChild: CanActivateChildFn[] = [];\r\n  private canDeactivate: CanDeactivateFn<T>[] = [];\r\n  private runGuardsAndResolvers?: RunGuardsAndResolvers;\r\n  private data?: Data;\r\n\r\n  constructor(route: RdtRoute<T>) {\r\n    this.route = route;\r\n  }\r\n\r\n  provide(...providers: Type<unknown>[]) {\r\n    this.providers.push(...providers);\r\n    return this;\r\n  }\r\n\r\n  setModule(callback: LoadChildrenCallback) {\r\n    this.loadChildren = callback;\r\n    return this;\r\n  }\r\n\r\n  setComponent(comp: Type<any>) {\r\n    this.component = comp;\r\n    return this;\r\n  }\r\n\r\n  setChildren(...routes: Route[]) {\r\n    this.children = routes;\r\n    return this;\r\n  }\r\n\r\n  addResolve(paramName: string, resolver: ResolveFn<unknown>) {\r\n    this.resolvers[paramName] = resolver;\r\n    return this;\r\n  }\r\n\r\n  addCanActivate(...fns: CanActivateFn[]) {\r\n    this.canActivate.push(...fns);\r\n    return this;\r\n  }\r\n\r\n  addCanDeactivate(...fns: CanDeactivateFn<any>[]) {\r\n    this.canDeactivate.push(...fns);\r\n    return this;\r\n  }\r\n\r\n  addCanActivateChild(...fns: CanActivateChildFn[]) {\r\n    this.canActivateChild.push(...fns);\r\n    return this;\r\n  }\r\n\r\n  setRunGuardsAndResolvers(value: RunGuardsAndResolvers) {\r\n    this.runGuardsAndResolvers = value;\r\n    return this;\r\n  }\r\n\r\n  build(): Route {\r\n    this.checkChildrenMatch();\r\n\r\n    let res: Route = {\r\n      path: this.route.path,\r\n      providers: this.providers,\r\n      title: this.route.name,\r\n      canMatch: this.getCanMatch(),\r\n    };\r\n\r\n    if (this.component) {\r\n      res.component = this.component;\r\n    } else if (this.loadChildren) {\r\n      res.loadChildren = this.loadChildren;\r\n    }\r\n\r\n    res.data = this.data ?? {\r\n      breadcrumb: {\r\n        label: this.route.name,\r\n        disable: this.route.entryDisabled,\r\n        staticStateParams: {\r\n          src: RdtNavigationSource.BREADCRUMB,\r\n        },\r\n      },\r\n      ...this.route.data,\r\n    };\r\n\r\n    const guard: CanActivateFn = (\r\n      route: ActivatedRouteSnapshot,\r\n      state: RouterStateSnapshot\r\n    ) => {\r\n      const injector = inject(EnvironmentInjector);\r\n      if (\r\n        runInInjectionContext(\r\n          injector,\r\n          this.route.canBeEntered.bind(this.route)\r\n        )\r\n      ) {\r\n        return true;\r\n      } else {\r\n        const router = inject(Router);\r\n        const location = inject(Location);\r\n        let url = inject(RDT_CANNOT_BE_ENTERED_PROVIDER);\r\n        if (typeof url === 'function') {\r\n          //console.error(this.route.absolutePath);\r\n          url = runInInjectionContext(\r\n            injector,\r\n            url.bind(url, location.path(), state.url, this.route)\r\n          );\r\n        }\r\n        if (typeof url === 'string') {\r\n          return router.parseUrl(url);\r\n        } else {\r\n          return false;\r\n        }\r\n      }\r\n    };\r\n    this.canActivate.push(guard);\r\n\r\n    res.canActivate = this.canActivate;\r\n    res.canDeactivate = this.canDeactivate;\r\n\r\n    // If children exist, change\r\n    // {\r\n    //    path: '/path',\r\n    //    component: FeatureComponent,\r\n    //    children: [...]\r\n    // }\r\n    // into\r\n    // {\r\n    //    path: '/path',\r\n    //    children: [\r\n    //      {\r\n    //        path: '',\r\n    //        component: FeatureComponent\r\n    //      },\r\n    //    ...\r\n    //    ]\r\n    //    }\r\n    if (this.children.length > 0) {\r\n      if (this.loadChildren || this.component) {\r\n        const path = res.path;\r\n        res.path = '';\r\n        res.pathMatch = 'full';\r\n        res.canMatch = undefined;\r\n        res = {\r\n          path: path,\r\n          children: [res, ...this.children],\r\n          canActivateChild: this.canActivateChild,\r\n          canMatch: this.getCanMatch(),\r\n        };\r\n      } else {\r\n        res.children = this.children;\r\n      }\r\n    }\r\n\r\n    if (Object.keys(this.resolvers).length > 0) {\r\n      res.resolve = this.resolvers;\r\n    }\r\n\r\n    if (this.runGuardsAndResolvers) {\r\n      res.runGuardsAndResolvers = this.runGuardsAndResolvers;\r\n    }\r\n\r\n    return res;\r\n  }\r\n\r\n  private getCanMatch(): CanMatchFn[] | undefined {\r\n    const paramMap = this.route.paramMap;\r\n    const hasNumberParams = Object.keys(paramMap).some(\r\n      (p) => paramMap[p as keyof T] === 'number'\r\n    );\r\n    if (!hasNumberParams) {\r\n      return undefined;\r\n    }\r\n    const routeSegmentLength = this.route.path.split('/').length;\r\n    const regex = this.route.regex\r\n      ? new RegExp(`^${this.route.regex.source}$`)\r\n      : this.route.absoluteRegex;\r\n    return [\r\n      (route: Route, segments: UrlSegment[]) => {\r\n        const path = segments\r\n          .slice(0, routeSegmentLength)\r\n          .map((s) => s.path)\r\n          .join('/');\r\n        return regex.test(path);\r\n      },\r\n    ];\r\n  }\r\n\r\n  private checkChildrenMatch() {\r\n    // Check that all routes are present if route is not\r\n    // lazy loaded module.\r\n    if (\r\n      !this.loadChildren &&\r\n      (this.route.children.length > 0 || this.children.length > 0)\r\n    ) {\r\n      if (this.children.length < this.route.children.length) {\r\n        throw new Error(\r\n          `RdtRoute ${this.route.name} has ${\r\n            this.route.children.length\r\n          } children, but RdtAngularRoute has ${\r\n            this.children.length\r\n          }. These numbers must match. Did you forget to call .setChildren() method in global routes definition? Routes with following names should be present: ${this.route.children\r\n            .map((ch) => ch.name)\r\n            .join(', ')}`\r\n        );\r\n      } else if (this.children.length > this.route.children.length) {\r\n        throw new Error(\r\n          `RdtRoute ${this.route.name} has ${\r\n            this.route.children.length\r\n          } children, but RdtAngularRoute has ${\r\n            this.children.length\r\n          }. These numbers must match. Did you forget to call .setChildren() method in feature shell routes definition? Routes with following paths should be present: ${this.children\r\n            .map((ch) => ch.path)\r\n            .join(', ')}`\r\n        );\r\n      }\r\n      const n1 = this.children.map((ch) => ch.path!);\r\n      const n2 = this.route.children.map((ch) => ch.path);\r\n      n1.sort();\r\n      n2.sort();\r\n      for (let i = 0; i < n1.length; i++) {\r\n        if (n1[i] !== n2[i]) {\r\n          throw new Error(\r\n            `Paths of children provided in RdtRoute and\r\n            RdtAngularRoute do not match. ${n1[i]} != ${n2[i]}`\r\n          );\r\n        }\r\n      }\r\n    }\r\n  }\r\n}\r\n"]}