@tinkoff/router 0.2.7 → 0.2.9

package/lib/router/client.d.ts

@@ -2,6 +2,7 @@ import type { Options } from './abstract';
 import { AbstractRouter } from './abstract';
 import type { Navigation, NavigateOptions } from '../types';
 export declare abstract class ClientRouter extends AbstractRouter {
+    protected fullRehydrationInProcess: boolean;
     constructor(options: Options);
     rehydrate(navigation: Navigation): Promise<void>;
     protected resolveRoute(...options: Parameters<AbstractRouter['resolveRoute']>): import("../types").NavigationRoute;

package/lib/router/client.es.js

@@ -0,0 +1,129 @@
+import { parse } from '@tinkoff/url';
+import { AbstractRouter } from './abstract.es.js';
+import { makeNavigateOptions, isSameHost } from '../utils.es.js';
+import { logger } from '../logger.es.js';
+import { ClientHistory } from '../history/client.es.js';
+
+class ClientRouter extends AbstractRouter {
+    constructor(options) {
+        super(options);
+        // this flag for cases when we don't have initial router state from server - CSR fallback initialization
+        this.fullRehydrationInProcess = null;
+        this.history = new ClientHistory();
+        this.history.listen(async ({ type, url, navigateState, replace, history }) => {
+            var _a;
+            const currentUrl = this.getCurrentUrl();
+            const { pathname, query } = this.resolveUrl({ url });
+            const isSameUrlNavigation = currentUrl.pathname === pathname;
+            if (type === 'updateCurrentRoute' || (!type && isSameUrlNavigation)) {
+                const route = (_a = this.tree) === null || _a === void 0 ? void 0 : _a.getRoute(pathname);
+                await this.internalUpdateCurrentRoute({
+                    params: route === null || route === void 0 ? void 0 : route.params,
+                    query,
+                    replace,
+                    navigateState,
+                }, { history });
+            }
+            else {
+                await this.internalNavigate({
+                    url,
+                    replace,
+                    navigateState,
+                }, { history });
+            }
+        });
+    }
+    async rehydrate(navigation) {
+        this.fullRehydrationInProcess = !navigation.to;
+        logger.debug({
+            event: 'rehydrate',
+            navigation,
+        });
+        const url = parse(window.location.href);
+        this.currentNavigation = {
+            ...navigation,
+            type: 'navigate',
+            url,
+        };
+        this.lastNavigation = this.currentNavigation;
+        if (this.fullRehydrationInProcess) {
+            await this.runHooks('beforeResolve', this.currentNavigation);
+            const to = this.resolveRoute({ url }, { wildcard: true });
+            const redirect = to === null || to === void 0 ? void 0 : to.redirect;
+            this.currentNavigation.to = to;
+            if (redirect) {
+                return this.redirect(this.currentNavigation, makeNavigateOptions(redirect));
+            }
+        }
+        // rerun guard check in case it differs from server side
+        await this.runGuards(this.currentNavigation);
+        // and init any history listeners
+        this.history.init(this.currentNavigation);
+        if (this.fullRehydrationInProcess) {
+            this.runSyncHooks('change', this.currentNavigation);
+        }
+        this.currentNavigation = null;
+        // add dehydrated route to tree to prevent its loading
+        if (!this.fullRehydrationInProcess) {
+            this.addRoute({
+                name: navigation.to.name,
+                path: navigation.to.path,
+                config: navigation.to.config,
+                // in case we have loaded page from some path-changing proxy
+                // save this actual path as alias
+                alias: url.pathname,
+            });
+        }
+        this.fullRehydrationInProcess = null;
+    }
+    resolveRoute(...options) {
+        const { url } = options[0];
+        // navigation for other hosts should be considered as external navigation
+        if (url && !isSameHost(url)) {
+            return;
+        }
+        return super.resolveRoute(...options);
+    }
+    async notfound(navigation) {
+        var _a, _b;
+        await super.notfound(navigation);
+        // in case we didn't find any matched route just force hard page navigation
+        const prevUrl = (_b = (_a = navigation.fromUrl) === null || _a === void 0 ? void 0 : _a.href) !== null && _b !== void 0 ? _b : window.location.href;
+        const nextUrl = navigation.url.href;
+        const isNoSpaNavigation = navigation.from && !navigation.to;
+        // prevent redirect cycle on the same page,
+        // except cases when we run no-spa navigations,
+        // because we need hard reload in this cases
+        if (isNoSpaNavigation ? true : prevUrl !== nextUrl) {
+            if (navigation.replace) {
+                window.location.replace(nextUrl);
+            }
+            else {
+                window.location.assign(nextUrl);
+            }
+        }
+        // prevent routing from any continues navigation returning promise which will be not resolved
+        return new Promise(() => { });
+    }
+    async block(navigation) {
+        return this.notfound(navigation);
+    }
+    async redirect(navigation, target) {
+        await super.redirect(navigation, target);
+        // on CSR fallback initialization, if we found a redirect,
+        // we need to make hard reload for prevent current page rendering
+        if (this.fullRehydrationInProcess) {
+            window.location.replace(target.url);
+            // prevent routing from any continues navigation returning promise which will be not resolved
+            return new Promise(() => { });
+        }
+        return this.internalNavigate({
+            ...target,
+            replace: target.replace || navigation.replace,
+        }, {
+            redirect: true,
+        });
+    }
+}
+
+export { ClientRouter };

package/lib/router/client.js

@@ -0,0 +1,133 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var url = require('@tinkoff/url');
+var abstract = require('./abstract.js');
+var utils = require('../utils.js');
+var logger = require('../logger.js');
+var client = require('../history/client.js');
+
+class ClientRouter extends abstract.AbstractRouter {
+    constructor(options) {
+        super(options);
+        // this flag for cases when we don't have initial router state from server - CSR fallback initialization
+        this.fullRehydrationInProcess = null;
+        this.history = new client.ClientHistory();
+        this.history.listen(async ({ type, url, navigateState, replace, history }) => {
+            var _a;
+            const currentUrl = this.getCurrentUrl();
+            const { pathname, query } = this.resolveUrl({ url });
+            const isSameUrlNavigation = currentUrl.pathname === pathname;
+            if (type === 'updateCurrentRoute' || (!type && isSameUrlNavigation)) {
+                const route = (_a = this.tree) === null || _a === void 0 ? void 0 : _a.getRoute(pathname);
+                await this.internalUpdateCurrentRoute({
+                    params: route === null || route === void 0 ? void 0 : route.params,
+                    query,
+                    replace,
+                    navigateState,
+                }, { history });
+            }
+            else {
+                await this.internalNavigate({
+                    url,
+                    replace,
+                    navigateState,
+                }, { history });
+            }
+        });
+    }
+    async rehydrate(navigation) {
+        this.fullRehydrationInProcess = !navigation.to;
+        logger.logger.debug({
+            event: 'rehydrate',
+            navigation,
+        });
+        const url$1 = url.parse(window.location.href);
+        this.currentNavigation = {
+            ...navigation,
+            type: 'navigate',
+            url: url$1,
+        };
+        this.lastNavigation = this.currentNavigation;
+        if (this.fullRehydrationInProcess) {
+            await this.runHooks('beforeResolve', this.currentNavigation);
+            const to = this.resolveRoute({ url: url$1 }, { wildcard: true });
+            const redirect = to === null || to === void 0 ? void 0 : to.redirect;
+            this.currentNavigation.to = to;
+            if (redirect) {
+                return this.redirect(this.currentNavigation, utils.makeNavigateOptions(redirect));
+            }
+        }
+        // rerun guard check in case it differs from server side
+        await this.runGuards(this.currentNavigation);
+        // and init any history listeners
+        this.history.init(this.currentNavigation);
+        if (this.fullRehydrationInProcess) {
+            this.runSyncHooks('change', this.currentNavigation);
+        }
+        this.currentNavigation = null;
+        // add dehydrated route to tree to prevent its loading
+        if (!this.fullRehydrationInProcess) {
+            this.addRoute({
+                name: navigation.to.name,
+                path: navigation.to.path,
+                config: navigation.to.config,
+                // in case we have loaded page from some path-changing proxy
+                // save this actual path as alias
+                alias: url$1.pathname,
+            });
+        }
+        this.fullRehydrationInProcess = null;
+    }
+    resolveRoute(...options) {
+        const { url } = options[0];
+        // navigation for other hosts should be considered as external navigation
+        if (url && !utils.isSameHost(url)) {
+            return;
+        }
+        return super.resolveRoute(...options);
+    }
+    async notfound(navigation) {
+        var _a, _b;
+        await super.notfound(navigation);
+        // in case we didn't find any matched route just force hard page navigation
+        const prevUrl = (_b = (_a = navigation.fromUrl) === null || _a === void 0 ? void 0 : _a.href) !== null && _b !== void 0 ? _b : window.location.href;
+        const nextUrl = navigation.url.href;
+        const isNoSpaNavigation = navigation.from && !navigation.to;
+        // prevent redirect cycle on the same page,
+        // except cases when we run no-spa navigations,
+        // because we need hard reload in this cases
+        if (isNoSpaNavigation ? true : prevUrl !== nextUrl) {
+            if (navigation.replace) {
+                window.location.replace(nextUrl);
+            }
+            else {
+                window.location.assign(nextUrl);
+            }
+        }
+        // prevent routing from any continues navigation returning promise which will be not resolved
+        return new Promise(() => { });
+    }
+    async block(navigation) {
+        return this.notfound(navigation);
+    }
+    async redirect(navigation, target) {
+        await super.redirect(navigation, target);
+        // on CSR fallback initialization, if we found a redirect,
+        // we need to make hard reload for prevent current page rendering
+        if (this.fullRehydrationInProcess) {
+            window.location.replace(target.url);
+            // prevent routing from any continues navigation returning promise which will be not resolved
+            return new Promise(() => { });
+        }
+        return this.internalNavigate({
+            ...target,
+            replace: target.replace || navigation.replace,
+        }, {
+            redirect: true,
+        });
+    }
+}
+
+exports.ClientRouter = ClientRouter;

package/lib/router/clientNoSpa.browser.js

@@ -0,0 +1,17 @@
+import { ClientRouter } from './client.browser.js';
+
+const omitHash = (url) => url.href.replace(/#.*$/, '');
+class NoSpaRouter extends ClientRouter {
+    run(navigation) {
+        const { type, fromUrl, url } = navigation;
+        // support only updateCurrentRoute or hash navigations
+        if (type === 'updateCurrentRoute' || omitHash(url) === omitHash(fromUrl)) {
+            return super.run(navigation);
+        }
+        return this.notfound(navigation);
+    }
+    // do not call any hooks as it is only supports url updates with hash
+    async runHooks() { }
+}
+
+export { NoSpaRouter };

package/lib/router/clientNoSpa.es.js

@@ -0,0 +1,17 @@
+import { ClientRouter } from './client.es.js';
+
+const omitHash = (url) => url.href.replace(/#.*$/, '');
+class NoSpaRouter extends ClientRouter {
+    run(navigation) {
+        const { type, fromUrl, url } = navigation;
+        // support only updateCurrentRoute or hash navigations
+        if (type === 'updateCurrentRoute' || omitHash(url) === omitHash(fromUrl)) {
+            return super.run(navigation);
+        }
+        return this.notfound(navigation);
+    }
+    // do not call any hooks as it is only supports url updates with hash
+    async runHooks() { }
+}
+
+export { NoSpaRouter };

package/lib/router/clientNoSpa.js

@@ -0,0 +1,21 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var client = require('./client.js');
+
+const omitHash = (url) => url.href.replace(/#.*$/, '');
+class NoSpaRouter extends client.ClientRouter {
+    run(navigation) {
+        const { type, fromUrl, url } = navigation;
+        // support only updateCurrentRoute or hash navigations
+        if (type === 'updateCurrentRoute' || omitHash(url) === omitHash(fromUrl)) {
+            return super.run(navigation);
+        }
+        return this.notfound(navigation);
+    }
+    // do not call any hooks as it is only supports url updates with hash
+    async runHooks() { }
+}
+
+exports.NoSpaRouter = NoSpaRouter;

package/lib/router/server.es.js

@@ -0,0 +1,85 @@
+import { isInvalidUrl } from '@tinkoff/url';
+import { AbstractRouter } from './abstract.es.js';
+import { ServerHistory } from '../history/server.es.js';
+import { RouteTree } from '../tree/tree.es.js';
+import { logger } from '../logger.es.js';
+
+class Router extends AbstractRouter {
+    constructor(options) {
+        var _a;
+        super(options);
+        this.blocked = false;
+        this.tree = new RouteTree(options.routes);
+        this.defaultRedirectCode = (_a = options.defaultRedirectCode) !== null && _a !== void 0 ? _a : 308;
+        this.history = new ServerHistory();
+    }
+    async dehydrate() {
+        logger.debug({
+            event: 'dehydrate',
+            navigation: this.lastNavigation,
+        });
+        return this.lastNavigation;
+    }
+    async internalNavigate(navigateOptions, internalOptions) {
+        // any navigation after initial should be considered as redirects
+        if (this.getCurrentRoute()) {
+            return this.redirect(this.lastNavigation, navigateOptions);
+        }
+        return super.internalNavigate(navigateOptions, internalOptions);
+    }
+    async run(navigation) {
+        if (this.redirectCode) {
+            return this.redirect(navigation, { url: navigation.url.href, code: this.redirectCode });
+        }
+        await super.run(navigation);
+    }
+    async redirect(navigation, target) {
+        logger.debug({
+            event: 'redirect',
+            navigation,
+            target,
+        });
+        this.blocked = true;
+        return this.onRedirect({
+            ...navigation,
+            from: navigation.to,
+            fromUrl: navigation.url,
+            to: null,
+            url: this.resolveUrl(target),
+            code: target.code,
+        });
+    }
+    async notfound(navigation) {
+        this.blocked = true;
+        return super.notfound(navigation);
+    }
+    normalizePathname(pathname) {
+        const normalized = super.normalizePathname(pathname);
+        if (normalized !== pathname) {
+            this.redirectCode = this.defaultRedirectCode;
+        }
+        return normalized;
+    }
+    resolveUrl(options) {
+        if (options.url && isInvalidUrl(options.url)) {
+            this.redirectCode = this.defaultRedirectCode;
+        }
+        return super.resolveUrl(options);
+    }
+    async runHooks(hookName, navigation) {
+        // do not run hooks if another parallel navigation has been called
+        if (this.blocked) {
+            return;
+        }
+        return super.runHooks(hookName, navigation);
+    }
+    async runGuards(navigation) {
+        // do not run guards if another parallel navigation has been called
+        if (this.blocked) {
+            return;
+        }
+        return super.runGuards(navigation);
+    }
+}
+
+export { Router };

package/lib/router/server.js

@@ -0,0 +1,89 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var url = require('@tinkoff/url');
+var abstract = require('./abstract.js');
+var server = require('../history/server.js');
+var tree = require('../tree/tree.js');
+var logger = require('../logger.js');
+
+class Router extends abstract.AbstractRouter {
+    constructor(options) {
+        var _a;
+        super(options);
+        this.blocked = false;
+        this.tree = new tree.RouteTree(options.routes);
+        this.defaultRedirectCode = (_a = options.defaultRedirectCode) !== null && _a !== void 0 ? _a : 308;
+        this.history = new server.ServerHistory();
+    }
+    async dehydrate() {
+        logger.logger.debug({
+            event: 'dehydrate',
+            navigation: this.lastNavigation,
+        });
+        return this.lastNavigation;
+    }
+    async internalNavigate(navigateOptions, internalOptions) {
+        // any navigation after initial should be considered as redirects
+        if (this.getCurrentRoute()) {
+            return this.redirect(this.lastNavigation, navigateOptions);
+        }
+        return super.internalNavigate(navigateOptions, internalOptions);
+    }
+    async run(navigation) {
+        if (this.redirectCode) {
+            return this.redirect(navigation, { url: navigation.url.href, code: this.redirectCode });
+        }
+        await super.run(navigation);
+    }
+    async redirect(navigation, target) {
+        logger.logger.debug({
+            event: 'redirect',
+            navigation,
+            target,
+        });
+        this.blocked = true;
+        return this.onRedirect({
+            ...navigation,
+            from: navigation.to,
+            fromUrl: navigation.url,
+            to: null,
+            url: this.resolveUrl(target),
+            code: target.code,
+        });
+    }
+    async notfound(navigation) {
+        this.blocked = true;
+        return super.notfound(navigation);
+    }
+    normalizePathname(pathname) {
+        const normalized = super.normalizePathname(pathname);
+        if (normalized !== pathname) {
+            this.redirectCode = this.defaultRedirectCode;
+        }
+        return normalized;
+    }
+    resolveUrl(options) {
+        if (options.url && url.isInvalidUrl(options.url)) {
+            this.redirectCode = this.defaultRedirectCode;
+        }
+        return super.resolveUrl(options);
+    }
+    async runHooks(hookName, navigation) {
+        // do not run hooks if another parallel navigation has been called
+        if (this.blocked) {
+            return;
+        }
+        return super.runHooks(hookName, navigation);
+    }
+    async runGuards(navigation) {
+        // do not run guards if another parallel navigation has been called
+        if (this.blocked) {
+            return;
+        }
+        return super.runGuards(navigation);
+    }
+}
+
+exports.Router = Router;

package/lib/tree/constants.browser.js

@@ -0,0 +1,6 @@
+const PARAMETER_DELIMITER = ':';
+const WILDCARD_REGEXP = /\*/;
+const HISTORY_FALLBACK_REGEXP = /<history-fallback>/;
+const PARAM_PARSER_REGEXP = /([^(?]+)(?:\((.+)\))?(\?)?/;
+
+export { HISTORY_FALLBACK_REGEXP, PARAMETER_DELIMITER, PARAM_PARSER_REGEXP, WILDCARD_REGEXP };

package/lib/tree/constants.es.js

@@ -0,0 +1,6 @@
+const PARAMETER_DELIMITER = ':';
+const WILDCARD_REGEXP = /\*/;
+const HISTORY_FALLBACK_REGEXP = /<history-fallback>/;
+const PARAM_PARSER_REGEXP = /([^(?]+)(?:\((.+)\))?(\?)?/;
+
+export { HISTORY_FALLBACK_REGEXP, PARAMETER_DELIMITER, PARAM_PARSER_REGEXP, WILDCARD_REGEXP };

package/lib/tree/constants.js

@@ -0,0 +1,13 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const PARAMETER_DELIMITER = ':';
+const WILDCARD_REGEXP = /\*/;
+const HISTORY_FALLBACK_REGEXP = /<history-fallback>/;
+const PARAM_PARSER_REGEXP = /([^(?]+)(?:\((.+)\))?(\?)?/;
+
+exports.HISTORY_FALLBACK_REGEXP = HISTORY_FALLBACK_REGEXP;
+exports.PARAMETER_DELIMITER = PARAMETER_DELIMITER;
+exports.PARAM_PARSER_REGEXP = PARAM_PARSER_REGEXP;
+exports.WILDCARD_REGEXP = WILDCARD_REGEXP;

package/lib/tree/tree.browser.js

@@ -0,0 +1,148 @@
+import each from '@tinkoff/utils/array/each';
+import find from '@tinkoff/utils/array/find';
+import findIndex from '@tinkoff/utils/array/findIndex';
+import { getParts, parse } from './utils.browser.js';
+import { HISTORY_FALLBACK_REGEXP } from './constants.browser.js';
+
+const createTree = (route) => {
+    return {
+        route,
+        children: Object.create(null),
+        parameters: [],
+    };
+};
+const createNavigationRoute = (route, pathname, params) => {
+    return {
+        ...route,
+        actualPath: pathname,
+        params: params !== null && params !== void 0 ? params : {},
+    };
+};
+class RouteTree {
+    constructor(routes) {
+        this.tree = createTree();
+        each((route) => this.addRoute(route), routes);
+    }
+    // eslint-disable-next-line max-statements
+    addRoute(route) {
+        const parts = getParts(route.path);
+        let currentTree = this.tree;
+        for (let i = 0; i < parts.length; i++) {
+            const part = parts[i];
+            const parsed = parse(part);
+            if (parsed.type === 1 /* PartType.historyFallback */) {
+                currentTree.historyFallbackRoute = route;
+                return;
+            }
+            if (parsed.type === 2 /* PartType.wildcard */) {
+                currentTree.wildcardRoute = route;
+                return;
+            }
+            if (parsed.type === 3 /* PartType.parameter */) {
+                const { paramName, regexp, optional } = parsed;
+                // prevent from creating new entries for same route
+                const found = find((par) => par.key === part, currentTree.parameters);
+                if (found) {
+                    currentTree = found.tree;
+                }
+                else {
+                    const parameter = {
+                        key: part,
+                        paramName,
+                        regexp,
+                        optional,
+                        tree: createTree(),
+                    };
+                    if (regexp && !optional) {
+                        // insert parameters with regexp before
+                        const index = findIndex((par) => !par.regexp, currentTree.parameters);
+                        currentTree.parameters.splice(index, 0, parameter);
+                    }
+                    else {
+                        currentTree.parameters.push(parameter);
+                    }
+                    currentTree = parameter.tree;
+                }
+            }
+            else {
+                if (!currentTree.children[part]) {
+                    currentTree.children[part] = createTree();
+                }
+                currentTree = currentTree.children[part];
+            }
+        }
+        currentTree.route = route;
+    }
+    getRoute(pathname) {
+        return this.findRoute(pathname, 'route');
+    }
+    getWildcard(pathname) {
+        return this.findRoute(pathname, 'wildcardRoute');
+    }
+    getHistoryFallback(pathname) {
+        const route = this.findRoute(pathname, 'historyFallbackRoute');
+        return (route && {
+            ...route,
+            // remove <history-fallback> from path
+            actualPath: route.path.replace(HISTORY_FALLBACK_REGEXP, '') || '/',
+        });
+    }
+    // eslint-disable-next-line max-statements
+    findRoute(pathname, propertyName) {
+        // we should use exact match only for classic route
+        // as special routes (for not-found and history-fallback) are defined for whole subtree
+        const exactMatch = propertyName === 'route';
+        const parts = getParts(pathname);
+        const queue = [
+            [this.tree, 0],
+        ];
+        while (queue.length) {
+            const [currentTree, index, params] = queue.pop();
+            const { children, parameters } = currentTree;
+            // this flag mean we can only check for optional parameters
+            // as we didn't find static route for this path, but still may find
+            // some inner route inside optional branch
+            // the value of parameter will be empty in this case ofc
+            let optionalOnly = false;
+            if (index >= parts.length) {
+                if (currentTree[propertyName]) {
+                    return createNavigationRoute(currentTree[propertyName], pathname, params);
+                }
+                // here we cant check any options except for optional parameters
+                optionalOnly = true;
+            }
+            // first add to queue special routes (not-found or history-fallback) to check it after other cases, as it will be processed last
+            if (!exactMatch && currentTree[propertyName]) {
+                queue.push([currentTree, parts.length, params]);
+            }
+            const part = parts[index];
+            const child = children[part];
+            // then add checks for only optional
+            for (const param of parameters) {
+                const { optional, tree } = param;
+                if (optional) {
+                    queue.push([tree, index, params]);
+                }
+            }
+            if (optionalOnly) {
+                continue;
+            }
+            // for non-optional cases
+            for (let i = parameters.length - 1; i >= 0; i--) {
+                const param = parameters[i];
+                const { paramName, tree, regexp } = param;
+                const match = regexp === null || regexp === void 0 ? void 0 : regexp.exec(part);
+                const paramValue = regexp ? match === null || match === void 0 ? void 0 : match[1] : part;
+                if (paramValue) {
+                    queue.push([tree, index + 1, { ...params, [paramName]: paramValue }]);
+                }
+            }
+            if (child) {
+                // add checks for static child subtree last as it will be processed first after queue.pop
+                queue.push([child, index + 1, params]);
+            }
+        }
+    }
+}
+
+export { RouteTree };