@ngrdt/router 0.0.1

package/fesm2022/ngrdt-router.mjs

@@ -0,0 +1,660 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, inject, Injectable, EnvironmentInjector, runInInjectionContext, booleanAttribute, Directive, Input } from '@angular/core';
+import { defer, of, filter, take } from 'rxjs';
+import { Location, PlatformLocation } from '@angular/common';
+import * as i1 from '@angular/router';
+import { Router, NavigationEnd, RouterLink } from '@angular/router';
+import { RdtStringUtils } from '@ngrdt/utils';
+
+const RDT_CONFIRM_DATA_LOSS_SERVICE = new InjectionToken('RDT_CONFIRM_DATA_LOSS_SERVICE', { factory: () => new RdtConfirmDataLossServiceAlert() });
+class RdtConfirmDataLossService {
+}
+class RdtConfirmDataLossServiceAlert extends RdtConfirmDataLossService {
+    confirmDataLoss() {
+        return defer(() => of(confirm('Are you sure you want to leave this page?')));
+    }
+}
+
+const RDT_ROUTES_TOKEN = new InjectionToken('RDT_ROUTES_TOKEN');
+
+class RdtRouterService {
+    allRoutes = inject(RDT_ROUTES_TOKEN, { optional: true });
+    location = inject(Location);
+    router = inject(Router);
+    baseHref = inject(PlatformLocation).getBaseHrefFromDOM();
+    _previousUrl = null;
+    _currentUrl = null;
+    get previousUrl() {
+        return this._previousUrl;
+    }
+    get currentUrl() {
+        return this._currentUrl;
+    }
+    parsePreviousUrl() {
+        return this._previousUrl ? this.parseAbsoluteUrl(this._previousUrl) : null;
+    }
+    parseCurrentUrl() {
+        return this._currentUrl ? this.parseAbsoluteUrl(this._currentUrl) : null;
+    }
+    navigationEnd$ = this.router.events.pipe(filter((e) => e instanceof NavigationEnd));
+    nextNavigationEnd$ = this.navigationEnd$.pipe(take(1));
+    constructor() {
+        if (this.allRoutes === null) {
+            console.warn('All routes not provided. Make sure to provide RDT_ROUTES_TOKEN with RdtRoute[].');
+            this.allRoutes = [];
+        }
+        this.navigationEnd$.subscribe((e) => {
+            this._previousUrl = this._currentUrl;
+            this._currentUrl = e.url;
+        });
+    }
+    navigate(link, params, target = '_self') {
+        const url = params
+            ? link.createAbsoluteUrl(params)
+            : link.createAbsoluteUrl();
+        if (target === '_self') {
+            return this.router.navigate([url], {
+                queryParams: link.queryParams,
+                state: link.stateParams,
+            });
+        }
+        const absolutePath = RdtStringUtils.createAbsoluteUrl(url, this.baseHref);
+        const pathWithParams = RdtStringUtils.appendQueryParams(absolutePath, link.queryParams);
+        const win = window.open(pathWithParams, target);
+        if (win) {
+            win.RdtStateParams = link.stateParams;
+        }
+        return Promise.resolve(true);
+    }
+    navigateHome(params) {
+        return this.router.navigateByUrl(RdtStringUtils.appendQueryParams('/', params?.query ?? {}), {
+            state: params?.state,
+        });
+    }
+    parseAbsoluteUrl(url = this.location.path()) {
+        if (this.allRoutes) {
+            for (const route of this.allRoutes) {
+                const params = route.parseAbsoluteUrl(url);
+                if (params) {
+                    return { route, params };
+                }
+            }
+        }
+        return null;
+    }
+    navigateBack(params) {
+        const parsed = this.parseAbsoluteUrl();
+        if (parsed) {
+            let route = parsed.route.withStaticParams(parsed.params);
+            do {
+                route = route.parent;
+            } while (route && route.entryDisabled);
+            // In case route has no ancestor with allowed entry,
+            if (!route) {
+                return this.navigateHome(params);
+            }
+            if (params) {
+                if (params.query) {
+                    route = route.withQueryParams(params.query);
+                }
+                if (params.state) {
+                    route = route.withStateParams(params.state);
+                }
+            }
+            return this.navigate(route);
+        }
+        else {
+            console.warn(`Cannot go back from ${this.location.path()} because no route matches current url`);
+            return null;
+        }
+    }
+    extractAllParams(currentRoute) {
+        if (!currentRoute) {
+            const parsed = this.parseAbsoluteUrl();
+            if (!parsed) {
+                console.warn('No route matches current url.');
+                return {};
+            }
+            currentRoute = parsed.route;
+        }
+        const url = this.location.path();
+        return currentRoute.parseAbsoluteUrl(url);
+    }
+    isParentOfCurrentLocation(route) {
+        console.log(this.parseAbsoluteUrl());
+        return true;
+    }
+    removeQueryParams(...paramNames) {
+        const regex = new RegExp(`[?&](${paramNames.join('|')})=[^&]*`, 'g');
+        return history.replaceState(null, '', location.pathname + location.search.replace(regex, '').replace(/^&/, '?'));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: RdtRouterService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: RdtRouterService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: RdtRouterService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [] });
+
+var RdtNavigationSource;
+(function (RdtNavigationSource) {
+    RdtNavigationSource["BREADCRUMB"] = "breadcrumb";
+})(RdtNavigationSource || (RdtNavigationSource = {}));
+
+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]}`);
+                }
+            }
+        }
+    }
+}
+
+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;
+    }
+}
+
+const DEFAULT_PARAM_TYPE = 'number';
+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+)',
+    };
+}
+
+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 }]
+            }] } });
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { RDT_CONFIRM_DATA_LOSS_SERVICE, RDT_ROUTES_TOKEN, RdtAngularRoute, RdtConfirmDataLossService, RdtConfirmDataLossServiceAlert, RdtNavigationSource, RdtRoute, RdtRouteBuilder, RdtRouterLinkDirective, RdtRouterService };
+//# sourceMappingURL=ngrdt-router.mjs.map