@ngrdt/router 0.0.1

package/README.md

@@ -0,0 +1,7 @@
+# @ngrdt/router
+
+This library was generated with [Nx](https://nx.dev).
+
+## Running unit tests
+
+Run `nx test @ngrdt/router` to execute the unit tests.

package/esm2022/index.mjs

@@ -0,0 +1,9 @@
+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/rdt-route';
+export * from './lib/rdt-route/rdt-route-builder';
+export * from './lib/rdt-route/rdt-angular-route';
+export * from './lib/rdt-route/constants';
+export * from './lib/directives/rdt-router-link.directive';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9AbmdyZHQvcm91dGVyL3NyYy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLDhDQUE4QyxDQUFDO0FBQzdELGNBQWMsbUNBQW1DLENBQUM7QUFDbEQsY0FBYyxpQ0FBaUMsQ0FBQztBQUVoRCxjQUFjLDJCQUEyQixDQUFDO0FBQzFDLGNBQWMsbUNBQW1DLENBQUM7QUFDbEQsY0FBYyxtQ0FBbUMsQ0FBQztBQUNsRCxjQUFjLDJCQUEyQixDQUFDO0FBRTFDLGNBQWMsNENBQTRDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2xpYi9zZXJ2aWNlcy9yZHQtY29uZmlybS1kYXRhLWxvc3Muc2VydmljZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vbGliL3NlcnZpY2VzL3JkdC1yb3V0ZXIuc2VydmljZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vbGliL3NlcnZpY2VzL3JkdC1yb3V0ZXMudG9rZW4nO1xyXG5cclxuZXhwb3J0ICogZnJvbSAnLi9saWIvcmR0LXJvdXRlL3JkdC1yb3V0ZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vbGliL3JkdC1yb3V0ZS9yZHQtcm91dGUtYnVpbGRlcic7XHJcbmV4cG9ydCAqIGZyb20gJy4vbGliL3JkdC1yb3V0ZS9yZHQtYW5ndWxhci1yb3V0ZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vbGliL3JkdC1yb3V0ZS9jb25zdGFudHMnO1xyXG5cclxuZXhwb3J0ICogZnJvbSAnLi9saWIvZGlyZWN0aXZlcy9yZHQtcm91dGVyLWxpbmsuZGlyZWN0aXZlJztcclxuIl19

package/esm2022/lib/directives/rdt-router-link.directive.mjs

@@ -0,0 +1,69 @@
+import { booleanAttribute, Directive, EnvironmentInjector, inject, Input, } from '@angular/core';
+import { RouterLink } from '@angular/router';
+import { RdtRoute } from '../rdt-route/rdt-route';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+export class RdtRouterLinkDirective {
+    routerLinkRef = inject(RouterLink, { self: true });
+    envInjector = inject(EnvironmentInjector);
+    route;
+    target = '_self';
+    params;
+    queryParams;
+    stateParams;
+    disabled = false;
+    ngOnInit() {
+        this.update();
+    }
+    ngOnChanges() {
+        this.update();
+    }
+    update() {
+        if (this.route.canBeEntered(this.envInjector) && !this.disabled) {
+            this.setLink();
+        }
+        else {
+            this.disableLink();
+        }
+    }
+    setLink() {
+        this.routerLinkRef.routerLink = this.route.createAbsoluteUrl(this.params);
+        this.routerLinkRef.state = this.stateParams ?? this.route.stateParams;
+        this.routerLinkRef.queryParams = this.queryParams ?? this.route.queryParams;
+        this.routerLinkRef.ngOnChanges({});
+    }
+    disableLink() {
+        this.routerLinkRef.routerLink = null;
+        this.routerLinkRef.ngOnChanges({});
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: RdtRouterLinkDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "18.2.7", type: RdtRouterLinkDirective, isStandalone: true, selector: "[rdtRouterLink]", inputs: { route: ["rdtRouterLink", "route"], target: "target", params: "params", queryParams: "queryParams", stateParams: "stateParams", disabled: ["disabled", "disabled", booleanAttribute] }, usesOnChanges: true, hostDirectives: [{ directive: i1.RouterLink, inputs: ["target", "target"] }], ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: RdtRouterLinkDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[rdtRouterLink]',
+                    standalone: true,
+                    hostDirectives: [
+                        {
+                            directive: RouterLink,
+                            inputs: ['target'],
+                        },
+                    ],
+                }]
+        }], propDecorators: { route: [{
+                type: Input,
+                args: [{ alias: 'rdtRouterLink', required: true }]
+            }], target: [{
+                type: Input
+            }], params: [{
+                type: Input
+            }], queryParams: [{
+                type: Input
+            }], stateParams: [{
+                type: Input
+            }], disabled: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,5 @@
+export var RdtNavigationSource;
+(function (RdtNavigationSource) {
+    RdtNavigationSource["BREADCRUMB"] = "breadcrumb";
+})(RdtNavigationSource || (RdtNavigationSource = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vQG5ncmR0L3JvdXRlci9zcmMvbGliL3JkdC1yb3V0ZS9jb25zdGFudHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxDQUFOLElBQVksbUJBRVg7QUFGRCxXQUFZLG1CQUFtQjtJQUM3QixnREFBeUIsQ0FBQTtBQUMzQixDQUFDLEVBRlcsbUJBQW1CLEtBQW5CLG1CQUFtQixRQUU5QiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBlbnVtIFJkdE5hdmlnYXRpb25Tb3VyY2Uge1xyXG4gIEJSRUFEQ1JVTUIgPSAnYnJlYWRjcnVtYicsXHJcbn1cclxuIl19

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

@@ -0,0 +1,173 @@
+import { EnvironmentInjector, inject, runInInjectionContext, } from '@angular/core';
+import { RdtNavigationSource } from './constants';
+export class RdtAngularRoute {
+    route;
+    children = [];
+    // Must be set from component declaration files
+    loadChildren;
+    component;
+    providers = [];
+    resolvers = {};
+    canActivate = [];
+    canActivateChild = [];
+    canDeactivate = [];
+    runGuardsAndResolvers;
+    constructor(route) {
+        this.route = route;
+    }
+    provide(...providers) {
+        this.providers.push(...providers);
+        return this;
+    }
+    setModule(callback) {
+        this.loadChildren = callback;
+        return this;
+    }
+    setComponent(comp) {
+        this.component = comp;
+        return this;
+    }
+    setChildren(...routes) {
+        this.children = routes;
+        return this;
+    }
+    addResolve(paramName, resolver) {
+        this.resolvers[paramName] = resolver;
+        return this;
+    }
+    addCanActivate(...fns) {
+        this.canActivate.push(...fns);
+        return this;
+    }
+    addCanDeactivate(...fns) {
+        this.canDeactivate.push(...fns);
+        return this;
+    }
+    addCanActivateChild(...fns) {
+        this.canActivateChild.push(...fns);
+        return this;
+    }
+    setRunGuardsAndResolvers(value) {
+        this.runGuardsAndResolvers = value;
+        return this;
+    }
+    build() {
+        this.checkChildrenMatch();
+        let res = {
+            path: this.route.path,
+            providers: this.providers,
+            title: this.route.name,
+            canMatch: this.getCanMatch(),
+        };
+        if (this.component) {
+            res.component = this.component;
+        }
+        else if (this.loadChildren) {
+            res.loadChildren = this.loadChildren;
+        }
+        res.data = {
+            breadcrumb: {
+                label: this.route.name,
+                disable: this.route.entryDisabled,
+                staticStateParams: {
+                    src: RdtNavigationSource.BREADCRUMB,
+                },
+            },
+        };
+        const guard = () => {
+            const injector = inject(EnvironmentInjector);
+            return runInInjectionContext(injector, this.route.canBeEntered.bind(this.route));
+        };
+        this.canActivate.push(guard);
+        this.canActivateChild.push(guard);
+        res.canActivate = this.canActivate;
+        res.canDeactivate = this.canDeactivate;
+        // If children exist, change
+        // {
+        //    path: '/path',
+        //    component: FeatureComponent,
+        //    children: [...]
+        // }
+        // into
+        // {
+        //    path: '/path',
+        //    children: [
+        //      {
+        //        path: '',
+        //        component: FeatureComponent
+        //      },
+        //    ...
+        //    ]
+        //    }
+        if (this.children.length > 0) {
+            if (this.loadChildren || this.component) {
+                const path = res.path;
+                res.path = '';
+                res.pathMatch = 'full';
+                res.canMatch = undefined;
+                res = {
+                    path: path,
+                    children: [res, ...this.children],
+                    canActivateChild: this.canActivateChild,
+                    canMatch: this.getCanMatch(),
+                };
+            }
+            else {
+                res.children = this.children;
+            }
+        }
+        if (Object.keys(this.resolvers).length > 0) {
+            res.resolve = this.resolvers;
+        }
+        if (this.runGuardsAndResolvers) {
+            res.runGuardsAndResolvers = this.runGuardsAndResolvers;
+        }
+        return res;
+    }
+    getCanMatch() {
+        const paramMap = this.route.paramMap;
+        const hasNumberParams = Object.keys(paramMap).some((p) => paramMap[p] === 'number');
+        if (!hasNumberParams) {
+            return undefined;
+        }
+        const routeSegmentLength = this.route.path.split('/').length;
+        const regex = new RegExp(`^${this.route.regex.source}$`);
+        return [
+            (route, segments) => {
+                const path = segments
+                    .slice(0, routeSegmentLength)
+                    .map((s) => s.path)
+                    .join('/');
+                return regex.test(path);
+            },
+        ];
+    }
+    checkChildrenMatch() {
+        // Check that all routes are present if route is not
+        // lazy loaded module.
+        if (!this.loadChildren &&
+            (this.route.children.length > 0 || this.children.length > 0)) {
+            if (this.children.length < this.route.children.length) {
+                throw new Error(`RdtRoute ${this.route.name} has ${this.route.children.length} children, but RdtAngularRoute has ${this.children.length}. 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
+                    .map((ch) => ch.name)
+                    .join(', ')}`);
+            }
+            else if (this.children.length > this.route.children.length) {
+                throw new Error(`RdtRoute ${this.route.name} has ${this.route.children.length} children, but RdtAngularRoute has ${this.children.length}. 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
+                    .map((ch) => ch.path)
+                    .join(', ')}`);
+            }
+            const n1 = this.children.map((ch) => ch.path);
+            const n2 = this.route.children.map((ch) => ch.path);
+            n1.sort();
+            n2.sort();
+            for (let i = 0; i < n1.length; i++) {
+                if (n1[i] !== n2[i]) {
+                    throw new Error(`Paths of children provided in RdtRoute and
+            RdtAngularRoute do not match. ${n1[i]} != ${n2[i]}`);
+                }
+            }
+        }
+    }
+}
+//# 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 {\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  CanActivateChildFn,\r\n  CanActivateFn,\r\n  CanDeactivateFn,\r\n  CanMatchFn,\r\n  LoadChildrenCallback,\r\n  ResolveFn,\r\n  Route,\r\n  RunGuardsAndResolvers,\r\n  UrlSegment,\r\n} from '@angular/router';\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 = () => {\r\n      const injector = inject(EnvironmentInjector);\r\n      return runInInjectionContext(\r\n        injector,\r\n        this.route.canBeEntered.bind(this.route)\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

@@ -0,0 +1,70 @@
+import { RdtRoute } from './rdt-route';
+const DEFAULT_PARAM_TYPE = 'number';
+export class RdtRouteBuilder extends RdtRoute {
+    setCanBeEntered(fn) {
+        this._canBeEntered = fn;
+        return this;
+    }
+    setEntryDisabled(value = true) {
+        this._entryDisabled = value;
+        return this;
+    }
+    setPath(path) {
+        this._path = path;
+        const s = path.split('/');
+        const params = [];
+        s.forEach((part) => {
+            if (part.includes(':')) {
+                const param = part.split(':')[1];
+                if (param) {
+                    params.push(param);
+                    if (!this._paramMap[param]) {
+                        this._paramMap[param] = DEFAULT_PARAM_TYPE;
+                    }
+                }
+            }
+        });
+        this.orderedParams = params;
+        return this;
+    }
+    setParam(paramName, type) {
+        this._paramMap[paramName] = type;
+        return this;
+    }
+    setName(name) {
+        this._name = name;
+        return this;
+    }
+    setChildren(...children) {
+        this._children = children;
+        for (const child of children) {
+            child._parent = this;
+        }
+        return this;
+    }
+    build() {
+        if (typeof this._path !== 'string') {
+            throw new Error('Please provide path for route. Empty string is acceptable.');
+        }
+        this.setRegex();
+        return this;
+    }
+    setRegex() {
+        const params = Object.keys(this._paramMap);
+        params.sort((a, b) => b.length - a.length);
+        let substituted = this.path;
+        params.forEach((p) => {
+            const type = this._paramMap[p];
+            if (!type) {
+                throw new Error('Params is not set i');
+            }
+            substituted = substituted.replace(`:${p}`, RdtRouteBuilder.groups[type]);
+        });
+        this._regex = new RegExp(substituted);
+    }
+    static groups = {
+        string: '(.+)',
+        number: '(\\d+)',
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,208 @@
+import { RdtStringUtils } from '@ngrdt/utils';
+import { RdtAngularRoute } from './rdt-angular-route';
+import { runInInjectionContext } from '@angular/core';
+export class RdtRoute {
+    orderedParams = [];
+    _paramMap = {};
+    _regex;
+    paramMappings = [];
+    _staticParams = {};
+    _queryParams = {};
+    _stateParams = {};
+    _name;
+    _path;
+    _parent = null;
+    _children = [];
+    _entryDisabled = false;
+    _canBeEntered = () => true;
+    _absoluteRegex;
+    get paramMap() {
+        return this._paramMap;
+    }
+    get name() {
+        return this._name;
+    }
+    get path() {
+        return this._path;
+    }
+    get parent() {
+        return this._parent;
+    }
+    get children() {
+        return this._children;
+    }
+    get basePath() {
+        return this._parent ? this._parent.absolutePath : '/';
+    }
+    get absolutePath() {
+        return RdtStringUtils.joinPaths(this.basePath, this._path);
+    }
+    get regex() {
+        return this._regex;
+    }
+    get absoluteRegex() {
+        if (this._absoluteRegex) {
+            return this._absoluteRegex;
+        }
+        if (this._parent) {
+            // Remove initial ^ and ending $
+            const parent = this._parent.absoluteRegex.source.slice(1, -1);
+            this._absoluteRegex = new RegExp('^' + RdtStringUtils.joinPaths(parent, this._regex.source) + '$');
+        }
+        else {
+            this._absoluteRegex = new RegExp('^' + RdtStringUtils.joinPaths('/', this._regex.source) + '$');
+        }
+        return this._absoluteRegex;
+    }
+    get entryDisabled() {
+        return this._entryDisabled;
+    }
+    get stateParams() {
+        return this._stateParams;
+    }
+    get queryParams() {
+        return this._queryParams;
+    }
+    testUrl(url) {
+        return this.absoluteRegex.test(url);
+    }
+    get staticParams() {
+        return { ...this._staticParams };
+    }
+    canBeEntered(injector) {
+        return injector
+            ? runInInjectionContext(injector, this._canBeEntered)
+            : this._canBeEntered();
+    }
+    // Extracts url parameters from absolute url.
+    parseAbsoluteUrl(url) {
+        const reg = this.absoluteRegex;
+        if (!reg.test(url)) {
+            return null;
+        }
+        const matches = reg.exec(url);
+        if (matches) {
+            const values = matches.slice(1).reverse();
+            return this.fill(values);
+        }
+        else {
+            return null;
+        }
+    }
+    fill(values, res = {}) {
+        const params = {};
+        const reversedParams = this.orderedParams.slice().reverse();
+        for (let i = 0; i < reversedParams.length && i < values.length; i++) {
+            const key = reversedParams[i];
+            const mappedKey = this.paramMappings.find((m) => m.urlName === key)?.tableName ?? key;
+            let val = values[i];
+            if (this._paramMap[key] === 'number') {
+                val = parseInt(val);
+            }
+            params[mappedKey] = val;
+        }
+        res[this.absolutePath] = params;
+        if (values.length > reversedParams.length && this._parent) {
+            this._parent.fill(values.slice(reversedParams.length), res);
+        }
+        return res;
+    }
+    createAbsoluteUrl(paramMap = this._staticParams) {
+        if (!this._parent) {
+            return this.createUrl(this.absolutePath, paramMap);
+        }
+        else {
+            return RdtStringUtils.joinPaths(this._parent.createAbsoluteUrl(), this.createRelativeUrl(paramMap));
+        }
+    }
+    createRelativeUrl(paramMap = this._staticParams) {
+        return this.createUrl(this.path, paramMap);
+    }
+    createUrl(path, paramMap) {
+        const paramNames = Object.keys(this._paramMap);
+        paramNames.sort((a, b) => b.length - a.length);
+        const extendedParamMap = { ...paramMap };
+        this.paramMappings.forEach((mapping) => {
+            if (mapping.tableName in paramMap) {
+                extendedParamMap[mapping.urlName] = paramMap[mapping.tableName];
+            }
+        });
+        paramNames.forEach((param) => {
+            path = path.replace(`:${param}`, `${extendedParamMap[param]}`);
+        });
+        return path;
+    }
+    toAngularRoute() {
+        if (!this._regex) {
+            throw new Error('You have to first call .build() on route!');
+        }
+        return new RdtAngularRoute(this);
+    }
+    // Provides static mapping for parameter names tableName -> urlName.
+    // Returns new instance of Dp3Route<T> that is clone of
+    // this route and its parents (NOT children).
+    withParamMappings(mappings) {
+        const clone = this.clone();
+        clone.paramMappings = mappings;
+        return clone;
+    }
+    // Sets selected parameters for itself and parents.
+    // Returns new instance of Dp3Route<T> that is clone of
+    // this route and its parents (NOT children).
+    withStaticParams(param1, param2) {
+        const clone = this.clone();
+        if (param2) {
+            const routeAbsPath = param1.absolutePath;
+            let current = clone;
+            while (current) {
+                if (current.absolutePath === routeAbsPath) {
+                    current._staticParams = param2;
+                }
+                current = current._parent;
+            }
+        }
+        else {
+            clone._staticParams = param1;
+        }
+        return clone;
+    }
+    withQueryParams(queryParams) {
+        const clone = this.clone();
+        clone._queryParams = { ...queryParams };
+        return clone;
+    }
+    withStateParams(stateParams) {
+        const clone = this.clone();
+        clone._stateParams = { ...stateParams };
+        return clone;
+    }
+    // Returns Partial of object that only contains properties
+    // necessary to create this route.
+    extractRouteParams(row) {
+        const res = {};
+        this.orderedParams.forEach((param) => {
+            const mapping = this.paramMappings.find((m) => m.urlName === param);
+            const mappedParam = (mapping?.tableName ?? param);
+            if (mappedParam in row) {
+                res[mappedParam] = row[mappedParam];
+            }
+        });
+        return res;
+    }
+    // Returns new instance of Dp3Route<T> that is clone of
+    // this route and its parents (NOT children).
+    clone() {
+        const clone = new RdtRoute();
+        clone._name = this._name;
+        clone._parent = this._parent?.clone() ?? null;
+        clone._path = this.path;
+        clone._entryDisabled = this._entryDisabled;
+        clone.orderedParams = [...this.orderedParams];
+        clone._paramMap = { ...this._paramMap };
+        clone._regex = new RegExp(this._regex);
+        clone.paramMappings = this.paramMappings;
+        clone._staticParams = this._staticParams;
+        return clone;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rdt-route.js","sourceRoot":"","sources":["../../../../../../@ngrdt/router/src/lib/rdt-route/rdt-route.ts"],"names":[],"mappings":"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","sourcesContent":["import { RdtStringUtils } from '@ngrdt/utils';\r\nimport { StaticRouteParams, ParamMapping, ParamTypeMap } from './utils';\r\nimport { Params } from '@angular/router';\r\nimport { RdtAngularRoute } from './rdt-angular-route';\r\nimport { Injector, runInInjectionContext } from '@angular/core';\r\n\r\nexport class RdtRoute<T extends object = any> {\r\n  protected orderedParams: string[] = [];\r\n  protected _paramMap: ParamTypeMap<T> = {};\r\n  protected _regex!: RegExp;\r\n  protected paramMappings: ParamMapping[] = [];\r\n  protected _staticParams: Partial<T> = {};\r\n  protected _queryParams: Params = {};\r\n  protected _stateParams: Params = {};\r\n\r\n  protected _name!: string;\r\n  protected _path!: string;\r\n  protected _parent: RdtRoute | null = null;\r\n  protected _children: RdtRoute[] = [];\r\n  protected _entryDisabled = false;\r\n  protected _canBeEntered: () => boolean = () => true;\r\n\r\n  private _absoluteRegex?: RegExp;\r\n\r\n  get paramMap(): Readonly<ParamTypeMap<T>> {\r\n    return this._paramMap;\r\n  }\r\n\r\n  get name() {\r\n    return this._name;\r\n  }\r\n\r\n  get path() {\r\n    return this._path;\r\n  }\r\n\r\n  get parent() {\r\n    return this._parent;\r\n  }\r\n\r\n  get children() {\r\n    return this._children;\r\n  }\r\n\r\n  get basePath(): string {\r\n    return this._parent ? this._parent.absolutePath : '/';\r\n  }\r\n\r\n  get absolutePath() {\r\n    return RdtStringUtils.joinPaths(this.basePath, this._path);\r\n  }\r\n\r\n  get regex() {\r\n    return this._regex;\r\n  }\r\n\r\n  get absoluteRegex(): RegExp {\r\n    if (this._absoluteRegex) {\r\n      return this._absoluteRegex;\r\n    }\r\n\r\n    if (this._parent) {\r\n      // Remove initial ^ and ending $\r\n      const parent = this._parent.absoluteRegex.source.slice(1, -1);\r\n      this._absoluteRegex = new RegExp(\r\n        '^' + RdtStringUtils.joinPaths(parent, this._regex.source) + '$'\r\n      );\r\n    } else {\r\n      this._absoluteRegex = new RegExp(\r\n        '^' + RdtStringUtils.joinPaths('/', this._regex.source) + '$'\r\n      );\r\n    }\r\n    return this._absoluteRegex;\r\n  }\r\n\r\n  get entryDisabled() {\r\n    return this._entryDisabled;\r\n  }\r\n\r\n  get stateParams() {\r\n    return this._stateParams;\r\n  }\r\n\r\n  get queryParams() {\r\n    return this._queryParams;\r\n  }\r\n\r\n  testUrl(url: string) {\r\n    return this.absoluteRegex.test(url);\r\n  }\r\n\r\n  get staticParams() {\r\n    return { ...this._staticParams };\r\n  }\r\n\r\n  canBeEntered(injector?: Injector): boolean {\r\n    return injector\r\n      ? runInInjectionContext(injector, this._canBeEntered)\r\n      : this._canBeEntered();\r\n  }\r\n\r\n  // Extracts url parameters from absolute url.\r\n  parseAbsoluteUrl(url: string): Record<string, any> | null {\r\n    const reg = this.absoluteRegex;\r\n    if (!reg.test(url)) {\r\n      return null;\r\n    }\r\n    const matches = reg.exec(url);\r\n    if (matches) {\r\n      const values = matches.slice(1).reverse();\r\n      return this.fill(values);\r\n    } else {\r\n      return null;\r\n    }\r\n  }\r\n\r\n  private fill(values: string[], res: Record<string, any> = {}) {\r\n    const params: { [key in keyof T]?: string | number } = {};\r\n    const reversedParams = this.orderedParams.slice().reverse();\r\n    for (let i = 0; i < reversedParams.length && i < values.length; i++) {\r\n      const key = reversedParams[i] as keyof T;\r\n      const mappedKey =\r\n        this.paramMappings.find((m) => m.urlName === key)?.tableName ?? key;\r\n      let val: string | number = values[i];\r\n\r\n      if (this._paramMap[key] === 'number') {\r\n        val = parseInt(val);\r\n      }\r\n      params[mappedKey as keyof T] = val;\r\n    }\r\n    res[this.absolutePath] = params;\r\n\r\n    if (values.length > reversedParams.length && this._parent) {\r\n      this._parent.fill(values.slice(reversedParams.length), res);\r\n    }\r\n    return res;\r\n  }\r\n\r\n  createAbsoluteUrl(paramMap: Partial<T> = this._staticParams): string {\r\n    if (!this._parent) {\r\n      return this.createUrl(this.absolutePath, paramMap);\r\n    } else {\r\n      return RdtStringUtils.joinPaths(\r\n        this._parent.createAbsoluteUrl(),\r\n        this.createRelativeUrl(paramMap)\r\n      );\r\n    }\r\n  }\r\n\r\n  createRelativeUrl(paramMap: Partial<T> = this._staticParams) {\r\n    return this.createUrl(this.path, paramMap);\r\n  }\r\n\r\n  private createUrl(path: string, paramMap: Partial<T>) {\r\n    const paramNames = Object.keys(this._paramMap);\r\n    paramNames.sort((a, b) => b.length - a.length);\r\n    const extendedParamMap: any = { ...paramMap };\r\n\r\n    this.paramMappings.forEach((mapping) => {\r\n      if (mapping.tableName in paramMap) {\r\n        extendedParamMap[mapping.urlName] = (paramMap as any)[\r\n          mapping.tableName\r\n        ];\r\n      }\r\n    });\r\n\r\n    paramNames.forEach((param) => {\r\n      path = path.replace(`:${param}`, `${extendedParamMap[param as keyof T]}`);\r\n    });\r\n\r\n    return path;\r\n  }\r\n\r\n  toAngularRoute() {\r\n    if (!this._regex) {\r\n      throw new Error('You have to first call .build() on route!');\r\n    }\r\n    return new RdtAngularRoute<T>(this);\r\n  }\r\n\r\n  // Provides static mapping for parameter names tableName -> urlName.\r\n  // Returns new instance of Dp3Route<T> that is clone of\r\n  // this route and its parents (NOT children).\r\n  withParamMappings(mappings: ParamMapping[]) {\r\n    const clone = this.clone();\r\n    clone.paramMappings = mappings;\r\n    return clone;\r\n  }\r\n\r\n  withStaticParams(params: T): RdtRoute<T>;\r\n  withStaticParams<T2 extends object>(\r\n    route: RdtRoute<T>,\r\n    params: T2\r\n  ): RdtRoute<T>;\r\n\r\n  // Sets selected parameters for itself and parents.\r\n  // Returns new instance of Dp3Route<T> that is clone of\r\n  // this route and its parents (NOT children).\r\n  withStaticParams<T2 extends object>(param1: RdtRoute<T2> | T, param2?: T2) {\r\n    const clone = this.clone();\r\n\r\n    if (param2) {\r\n      const routeAbsPath = (param1 as RdtRoute<T2>).absolutePath;\r\n      let current: RdtRoute | null = clone;\r\n\r\n      while (current) {\r\n        if (current.absolutePath === routeAbsPath) {\r\n          current._staticParams = param2;\r\n        }\r\n        current = current._parent;\r\n      }\r\n    } else {\r\n      clone._staticParams = param1 as T;\r\n    }\r\n    return clone;\r\n  }\r\n\r\n  withQueryParams(queryParams: Params) {\r\n    const clone = this.clone();\r\n    clone._queryParams = { ...queryParams };\r\n    return clone;\r\n  }\r\n\r\n  withStateParams(stateParams: Params) {\r\n    const clone = this.clone();\r\n    clone._stateParams = { ...stateParams };\r\n    return clone;\r\n  }\r\n\r\n  // Returns Partial of object that only contains properties\r\n  // necessary to create this route.\r\n  extractRouteParams(row: T): Partial<T> {\r\n    const res: Partial<T> = {};\r\n\r\n    this.orderedParams.forEach((param) => {\r\n      const mapping = this.paramMappings.find((m) => m.urlName === param);\r\n      const mappedParam = (mapping?.tableName ?? param) as keyof T;\r\n      if (mappedParam in row) {\r\n        res[mappedParam] = row[mappedParam];\r\n      }\r\n    });\r\n\r\n    return res;\r\n  }\r\n\r\n  // Returns new instance of Dp3Route<T> that is clone of\r\n  // this route and its parents (NOT children).\r\n  clone() {\r\n    const clone = new RdtRoute<T>();\r\n    clone._name = this._name;\r\n    clone._parent = this._parent?.clone() ?? null;\r\n    clone._path = this.path;\r\n    clone._entryDisabled = this._entryDisabled;\r\n    clone.orderedParams = [...this.orderedParams];\r\n    clone._paramMap = { ...this._paramMap };\r\n    clone._regex = new RegExp(this._regex);\r\n    clone.paramMappings = this.paramMappings;\r\n    clone._staticParams = this._staticParams;\r\n    return clone;\r\n  }\r\n}\r\n"]}

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9AbmdyZHQvcm91dGVyL3NyYy9saWIvcmR0LXJvdXRlL3V0aWxzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgdHlwZSBQYXJhbVR5cGVNYXA8VD4gPSB7XHJcbiAgW2tleSBpbiBrZXlvZiBUXT86ICdzdHJpbmcnIHwgJ251bWJlcic7XHJcbn07XHJcblxyXG5leHBvcnQgaW50ZXJmYWNlIFBhcmFtTWFwcGluZyB7XHJcbiAgdXJsTmFtZTogc3RyaW5nO1xyXG4gIHRhYmxlTmFtZTogc3RyaW5nO1xyXG59XHJcblxyXG5leHBvcnQgaW50ZXJmYWNlIFN0YXRpY1JvdXRlUGFyYW1zIHtcclxuICBbYWJzb2x1dGVQYXRoOiBzdHJpbmddOiBvYmplY3Q7XHJcbn1cclxuIl19