@ngrdt/router 0.0.8 → 0.0.10

package/README.md

@@ -1,54 +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`
 
-### Define Route
+## 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
 
-```javascript
-export const COOL_ROUTE = new RdtRouteBuilder()
-  .setName('Cool Route')
-  .setPath('cool-route')
-  .setCanBeEntered(() => inject(MockPermissionService).hasPermission('COOL_ACCESS'))
+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);
 ```
 
-### Define Child 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();
 
-```javascript
-export const COOL_ROUTE_CHILD = new RdtRouteBuilder()
-  .setName('Cool Route child')
-  .setPath(':coolId')
-  .setCanBeEntered(() => inject(MockPermissionService).hasPermission('COOL_CHILD_ACCESS'))
+export const USER_DETAIL_ROUTE = new RdtRouteBuilder<User>()
+  .setName('User detail')
+  .setPath(':userId')
+  .setParam('userId', 'number')
+  .setChildren(TASK_DETAIL_ROUTE)
   .build();
 
-PARENT_ROUTE.setChildren(COOL_ROUTE_CHILD);
+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:
 
-### Define Angular Route
+```typescript
+@Input()
+user!: User;
 
-```javascript
-// Create angular route
-COOL_ROUTE.toAngularRoute().setComponent(RouteLevel1Component).build();
+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.
 
-// Get information of route
-COOL_ROUTE.name;
+```html
+<button [rdtRouterLink]="taskRoute" [params]="task"></button>
 ```
 
-### Use It in template
+## 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]="COOL_ROUTE" [params]="{ coolId: 123 }">Go to Level 2</button>
+<button 
+  [rdtRouterLink]="userRoute" 
+  [params]="user$ | async"
+  target="_blank">
+Link to user
+</button>
 ```
 
-### See other cool features like
+### RdtMenu
 
-```javascript
-private readonly rdtRouter: RdtRouterService = inject(RdtRouterService);
+`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.
 
-rdtRouter.navigate(...);
-rdtRouter.parseAbsoluteUrl(...);
-rdtRouter.navigateBack(...);
-...
+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/lib/rdt-route/rdt-angular-route.mjs

@@ -76,10 +76,16 @@ export class RdtAngularRoute {
                     src: RdtNavigationSource.BREADCRUMB,
                 },
             },
+            ...this.route.data,
         };
         const guard = (route, state) => {
             const injector = inject(EnvironmentInjector);
-            if (runInInjectionContext(injector, this.route.canBeEntered.bind(this.route))) {
+            if (
+            //runInInjectionContext(
+            //  injector,
+            //  this.route.canBeEntered.bind(this.route)
+            //)
+            false) {
                 return true;
             }
             else {
@@ -87,7 +93,9 @@ export class RdtAngularRoute {
                 const location = inject(Location);
                 let url = inject(RDT_CANNOT_BE_ENTERED_PROVIDER);
                 if (typeof url === 'function') {
+                    console.error(this.route.absolutePath);
                     url = runInInjectionContext(injector, url.bind(url, location.path(), state.url, this.route));
+                    return true;
                 }
                 if (typeof url === 'string') {
                     return router.parseUrl(url);
@@ -98,7 +106,7 @@ export class RdtAngularRoute {
             }
         };
         this.canActivate.push(guard);
-        this.canActivateChild.push(guard);
+        //this.canActivateChild.push(guard);
         res.canActivate = this.canActivate;
         res.canDeactivate = this.canDeactivate;
         // If children exist, change
@@ -189,4 +197,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  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\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 = {\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    };\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          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    this.canActivateChild.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  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\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 = {\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        false\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          return true;\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    //this.canActivateChild.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"]}

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

@@ -27,6 +27,10 @@ export class RdtRouteBuilder extends RdtRoute {
         this.orderedParams = params;
         return this;
     }
+    setData(data) {
+        this._data = data;
+        return this;
+    }
     setParam(paramName, type) {
         this._paramMap[paramName] = type;
         return this;
@@ -67,4 +71,4 @@ export class RdtRouteBuilder extends RdtRoute {
         number: '(\\d+)',
     };
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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