@tinkoff/router 0.2.6 → 0.2.8

package/lib/router/abstract.js

@@ -0,0 +1,404 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var isString = require('@tinkoff/utils/is/string');
+var isObject = require('@tinkoff/utils/is/object');
+var url = require('@tinkoff/url');
+var utils$1 = require('../tree/utils.js');
+var logger = require('../logger.js');
+var utils = require('../utils.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var isString__default = /*#__PURE__*/_interopDefaultLegacy(isString);
+var isObject__default = /*#__PURE__*/_interopDefaultLegacy(isObject);
+
+class AbstractRouter {
+    constructor({ trailingSlash, mergeSlashes, beforeResolve = [], beforeNavigate = [], afterNavigate = [], beforeUpdateCurrent = [], afterUpdateCurrent = [], guards = [], onChange = [], onRedirect, onNotFound, onBlock, }) {
+        this.started = false;
+        this.trailingSlash = false;
+        this.strictTrailingSlash = true;
+        this.mergeSlashes = false;
+        this.trailingSlash = trailingSlash !== null && trailingSlash !== void 0 ? trailingSlash : false;
+        this.strictTrailingSlash = typeof trailingSlash === 'undefined';
+        this.mergeSlashes = mergeSlashes !== null && mergeSlashes !== void 0 ? mergeSlashes : false;
+        this.hooks = new Map([
+            ['beforeResolve', new Set(beforeResolve)],
+            ['beforeNavigate', new Set(beforeNavigate)],
+            ['afterNavigate', new Set(afterNavigate)],
+            ['beforeUpdateCurrent', new Set(beforeUpdateCurrent)],
+            ['afterUpdateCurrent', new Set(afterUpdateCurrent)],
+        ]);
+        this.guards = new Set(guards);
+        this.syncHooks = new Map([['change', new Set(onChange)]]);
+        this.onRedirect = onRedirect;
+        this.onNotFound = onNotFound;
+        this.onBlock = onBlock;
+    }
+    // start is using as marker that any preparation for proper work has done in the app
+    // and now router can manage any navigations
+    async start() {
+        logger.logger.debug({
+            event: 'start',
+        });
+        this.started = true;
+    }
+    getCurrentRoute() {
+        var _a, _b, _c;
+        // when something will try to get currentRoute while navigating, it will get route which router currently navigating
+        // in case some handler supposed to load data of route or similar
+        return (_b = (_a = this.currentNavigation) === null || _a === void 0 ? void 0 : _a.to) !== null && _b !== void 0 ? _b : (_c = this.lastNavigation) === null || _c === void 0 ? void 0 : _c.to;
+    }
+    getCurrentUrl() {
+        var _a, _b, _c;
+        // same as getCurrentRoute
+        return (_b = (_a = this.currentNavigation) === null || _a === void 0 ? void 0 : _a.url) !== null && _b !== void 0 ? _b : (_c = this.lastNavigation) === null || _c === void 0 ? void 0 : _c.url;
+    }
+    getLastRoute() {
+        var _a;
+        return (_a = this.lastNavigation) === null || _a === void 0 ? void 0 : _a.to;
+    }
+    getLastUrl() {
+        var _a;
+        return (_a = this.lastNavigation) === null || _a === void 0 ? void 0 : _a.url;
+    }
+    commitNavigation(navigation) {
+        logger.logger.debug({
+            event: 'commit-navigation',
+            navigation,
+        });
+        if (!navigation.history) {
+            // in case we came from history do not history back to prevent infinity recursive calls
+            this.history.save(navigation);
+        }
+        this.lastNavigation = navigation;
+        this.currentNavigation = null;
+        this.runSyncHooks('change', navigation);
+    }
+    async updateCurrentRoute(updateRouteOptions) {
+        return this.internalUpdateCurrentRoute(updateRouteOptions, {});
+    }
+    async internalUpdateCurrentRoute(updateRouteOptions, { history }) {
+        var _a;
+        const prevNavigation = (_a = this.currentNavigation) !== null && _a !== void 0 ? _a : this.lastNavigation;
+        if (!prevNavigation) {
+            throw new Error('updateCurrentRoute should only be called after navigate to some route');
+        }
+        const { replace, params, navigateState } = updateRouteOptions;
+        const { to: from, url: fromUrl } = prevNavigation;
+        const navigation = {
+            type: 'updateCurrentRoute',
+            from,
+            to: this.resolveRoute({ params, navigateState }, { wildcard: true }),
+            url: this.resolveUrl(updateRouteOptions),
+            fromUrl,
+            replace,
+            history,
+            navigateState,
+            code: updateRouteOptions.code,
+        };
+        logger.logger.debug({
+            event: 'update-current-route',
+            updateRouteOptions,
+            navigation,
+        });
+        await this.run(navigation);
+    }
+    async runUpdateCurrentRoute(navigation) {
+        await this.runHooks('beforeUpdateCurrent', navigation);
+        this.commitNavigation(navigation);
+        await this.runHooks('afterUpdateCurrent', navigation);
+    }
+    async navigate(navigateOptions) {
+        return this.internalNavigate(utils.makeNavigateOptions(navigateOptions), {});
+    }
+    async internalNavigate(navigateOptions, { history, redirect }) {
+        var _a;
+        const { url, replace, params, navigateState, code } = navigateOptions;
+        const prevNavigation = redirect
+            ? this.lastNavigation
+            : (_a = this.currentNavigation) !== null && _a !== void 0 ? _a : this.lastNavigation;
+        if (!url && !prevNavigation) {
+            throw new Error('Navigate url should be specified and cannot be omitted for first navigation');
+        }
+        const resolvedUrl = this.resolveUrl(navigateOptions);
+        const { to: from, url: fromUrl } = prevNavigation !== null && prevNavigation !== void 0 ? prevNavigation : {};
+        const redirectFrom = redirect ? this.currentNavigation.to : undefined;
+        let navigation = {
+            type: 'navigate',
+            from,
+            url: resolvedUrl,
+            fromUrl,
+            replace,
+            history,
+            navigateState,
+            code,
+            redirect,
+            redirectFrom,
+        };
+        await this.runHooks('beforeResolve', navigation);
+        const to = this.resolveRoute({ url: resolvedUrl, params, navigateState }, { wildcard: true });
+        if (to) {
+            navigation = {
+                ...navigation,
+                to,
+            };
+        }
+        logger.logger.debug({
+            event: 'navigation',
+            navigation,
+        });
+        if (!navigation.to) {
+            return this.notfound(navigation);
+        }
+        await this.run(navigation);
+    }
+    async runNavigate(navigation) {
+        // check for redirect in new route description
+        if (navigation.to.redirect) {
+            return this.redirect(navigation, utils.makeNavigateOptions(navigation.to.redirect));
+        }
+        await this.runGuards(navigation);
+        await this.runHooks('beforeNavigate', navigation);
+        this.commitNavigation(navigation);
+        await this.runHooks('afterNavigate', navigation);
+    }
+    async run(navigation) {
+        this.currentNavigation = navigation;
+        if (navigation.type === 'navigate') {
+            await this.runNavigate(navigation);
+        }
+        if (navigation.type === 'updateCurrentRoute') {
+            await this.runUpdateCurrentRoute(navigation);
+        }
+    }
+    resolve(resolveOptions, options) {
+        const opts = typeof resolveOptions === 'string' ? { url: resolveOptions } : resolveOptions;
+        return this.resolveRoute({ ...opts, url: url.parse(opts.url) }, options);
+    }
+    back(options) {
+        return this.go(-1, options);
+    }
+    forward() {
+        return this.go(1);
+    }
+    async go(to, options) {
+        logger.logger.debug({
+            event: 'history.go',
+            to,
+        });
+        return this.history.go(to, options);
+    }
+    isNavigating() {
+        return !!this.currentNavigation;
+    }
+    async dehydrate() {
+        throw new Error('Not implemented');
+    }
+    async rehydrate(navigation) {
+        throw new Error('Not implemented');
+    }
+    addRoute(route) {
+        var _a;
+        (_a = this.tree) === null || _a === void 0 ? void 0 : _a.addRoute(route);
+    }
+    async redirect(navigation, target) {
+        var _a;
+        logger.logger.debug({
+            event: 'redirect',
+            navigation,
+            target,
+        });
+        return (_a = this.onRedirect) === null || _a === void 0 ? void 0 : _a.call(this, {
+            ...navigation,
+            from: navigation.to,
+            fromUrl: navigation.url,
+            to: null,
+            url: this.resolveUrl(target),
+        });
+    }
+    async notfound(navigation) {
+        var _a;
+        logger.logger.debug({
+            event: 'not-found',
+            navigation,
+        });
+        return (_a = this.onNotFound) === null || _a === void 0 ? void 0 : _a.call(this, navigation);
+    }
+    async block(navigation) {
+        logger.logger.debug({
+            event: 'blocked',
+            navigation,
+        });
+        this.currentNavigation = null;
+        if (this.onBlock) {
+            return this.onBlock(navigation);
+        }
+        throw new Error('Navigation blocked');
+    }
+    normalizePathname(pathname) {
+        let normalized = pathname;
+        if (this.mergeSlashes) {
+            normalized = utils.normalizeManySlashes(normalized);
+        }
+        if (!this.strictTrailingSlash) {
+            normalized = utils.normalizeTrailingSlash(normalized, this.trailingSlash);
+        }
+        return normalized;
+    }
+    resolveUrl({ url: url$1, query = {}, params, preserveQuery, hash }) {
+        var _a;
+        const currentRoute = this.getCurrentRoute();
+        const currentUrl = this.getCurrentUrl();
+        const resultUrl = url$1 ? url.rawResolveUrl((_a = currentUrl === null || currentUrl === void 0 ? void 0 : currentUrl.href) !== null && _a !== void 0 ? _a : '', url$1) : url.rawParse(currentUrl.href);
+        let { pathname } = resultUrl;
+        if (params) {
+            if (url$1) {
+                pathname = utils$1.makePath(resultUrl.pathname, params);
+            }
+            else if (currentRoute) {
+                pathname = utils$1.makePath(currentRoute.path, { ...currentRoute.params, ...params });
+            }
+        }
+        if (utils.isSameHost(resultUrl)) {
+            pathname = this.normalizePathname(pathname);
+        }
+        return url.convertRawUrl(url.rawAssignUrl(resultUrl, {
+            pathname,
+            search: url$1 ? resultUrl.search : '',
+            query: {
+                ...(preserveQuery ? this.getCurrentUrl().query : {}),
+                ...query,
+            },
+            hash: hash !== null && hash !== void 0 ? hash : resultUrl.hash,
+        }));
+    }
+    resolveRoute({ url, params, navigateState }, { wildcard } = {}) {
+        var _a, _b;
+        let route = url ? (_a = this.tree) === null || _a === void 0 ? void 0 : _a.getRoute(url.pathname) : this.getCurrentRoute();
+        if (wildcard && !route && url) {
+            // if ordinary route not found look for a wildcard route
+            route = (_b = this.tree) === null || _b === void 0 ? void 0 : _b.getWildcard(url.pathname);
+        }
+        if (!route) {
+            return;
+        }
+        // if condition is true route data not changed, so no need to create new reference for route object
+        if (!params && navigateState === route.navigateState) {
+            return route;
+        }
+        return {
+            ...route,
+            params: { ...route.params, ...params },
+            navigateState,
+        };
+    }
+    async runGuards(navigation) {
+        logger.logger.debug({
+            event: 'guards.run',
+            navigation,
+        });
+        if (!this.guards) {
+            logger.logger.debug({
+                event: 'guards.empty',
+                navigation,
+            });
+            return;
+        }
+        const results = await Promise.all(Array.from(this.guards).map((guard) => Promise.resolve(guard(navigation)).catch((error) => {
+            logger.logger.warn({
+                event: 'guard.error',
+                error,
+            });
+        })));
+        logger.logger.debug({
+            event: 'guards.done',
+            navigation,
+            results,
+        });
+        for (const result of results) {
+            if (result === false) {
+                return this.block(navigation);
+            }
+            if (isString__default["default"](result) || isObject__default["default"](result)) {
+                return this.redirect(navigation, utils.makeNavigateOptions(result));
+            }
+        }
+    }
+    registerGuard(guard) {
+        return utils.registerHook(this.guards, guard);
+    }
+    runSyncHooks(hookName, navigation) {
+        logger.logger.debug({
+            event: 'sync-hooks.run',
+            hookName,
+            navigation,
+        });
+        const hooks = this.syncHooks.get(hookName);
+        if (!hooks) {
+            logger.logger.debug({
+                event: 'sync-hooks.empty',
+                hookName,
+                navigation,
+            });
+            return;
+        }
+        for (const hook of hooks) {
+            try {
+                hook(navigation);
+            }
+            catch (error) {
+                logger.logger.warn({
+                    event: 'sync-hooks.error',
+                    error,
+                });
+            }
+        }
+        logger.logger.debug({
+            event: 'sync-hooks.done',
+            hookName,
+            navigation,
+        });
+    }
+    registerSyncHook(hookName, hook) {
+        return utils.registerHook(this.syncHooks.get(hookName), hook);
+    }
+    async runHooks(hookName, navigation) {
+        logger.logger.debug({
+            event: 'hooks.run',
+            hookName,
+            navigation,
+        });
+        const hooks = this.hooks.get(hookName);
+        if (!hooks) {
+            logger.logger.debug({
+                event: 'hooks.empty',
+                hookName,
+                navigation,
+            });
+            return;
+        }
+        await Promise.all(Array.from(hooks).map((hook) => Promise.resolve(hook(navigation)).catch((error) => {
+            logger.logger.warn({
+                event: 'hook.error',
+                error,
+            });
+            // rethrow error for beforeResolve to prevent showing not found page
+            // if app has problems while loading info about routes
+            if (hookName === 'beforeResolve') {
+                throw error;
+            }
+        })));
+        logger.logger.debug({
+            event: 'hooks.done',
+            hookName,
+            navigation,
+        });
+    }
+    registerHook(hookName, hook) {
+        return utils.registerHook(this.hooks.get(hookName), hook);
+    }
+}
+
+exports.AbstractRouter = AbstractRouter;

package/lib/router/browser.browser.js

@@ -0,0 +1,166 @@
+import { ClientRouter } from './client.browser.js';
+import { logger } from '../logger.browser.js';
+import { RouteTree } from '../tree/tree.browser.js';
+
+const DELAY_CHECK_INTERVAL = 50;
+class Router extends ClientRouter {
+    constructor(options) {
+        super(options);
+        this.tree = new RouteTree(options.routes);
+        this.history.setTree(this.tree);
+    }
+    async rehydrate(navigation) {
+        return this.resolveIfDelayFound(super.rehydrate(navigation));
+    }
+    async start() {
+        await super.start();
+        if (this.delayedNavigation) {
+            const { delayedNavigation } = this;
+            this.delayedNavigation = null;
+            return this.flattenDelayedNavigation(delayedNavigation);
+        }
+    }
+    async run(navigation) {
+        // if router is not started yet delay current navigation without blocking promise resolving
+        if (!this.started) {
+            this.delayNavigation(navigation);
+            return;
+        }
+        // if we have already running navigation delay current one and call it later
+        if (this.currentNavigation) {
+            return this.delayNavigation(navigation);
+        }
+        // ignore previous navigations that were put in delayedNavigation as we have more fresh navigation to execute
+        if (this.delayedNavigation) {
+            logger.info({
+                event: 'delay-navigation-drop',
+                delayedNavigation: this.delayedNavigation,
+                navigation,
+            });
+            this.delayedNavigation = null;
+        }
+        return this.flattenDelayedNavigation(navigation);
+    }
+    delayNavigation(navigation) {
+        this.delayedNavigation = navigation;
+        logger.info({
+            event: 'delay-navigation',
+            navigation,
+        });
+        if (this.delayedPromise) {
+            return this.delayedPromise;
+        }
+        // resolve promise only after latest navigation has been executed
+        this.delayedPromise = new Promise((resolve, reject) => {
+            this.delayedResolve = resolve;
+            this.delayedReject = reject;
+        });
+        return this.delayedPromise;
+    }
+    commitNavigation(navigation) {
+        // if we have parallel navigation do not update current url, as it outdated anyway
+        if (navigation.cancelled) {
+            logger.debug({
+                event: 'delay-ignore-commit',
+                navigation,
+            });
+            return;
+        }
+        return super.commitNavigation(navigation);
+    }
+    async runGuards(navigation) {
+        // drop checking guards if we have delayed navigation
+        if (navigation.cancelled) {
+            logger.debug({
+                event: 'delay-ignore-guards',
+                navigation,
+            });
+            return;
+        }
+        return super.runGuards(navigation);
+    }
+    async runHooks(hookName, navigation) {
+        // drop hook calls if we have an other navigation delayed
+        // except only for case when current navigation already happened
+        // and we should synchronize this update with app
+        // (in case app has some logic for currently showing url on afterNavigate or afterRouteUpdate)
+        if (navigation.cancelled && this.lastNavigation !== navigation) {
+            logger.debug({
+                event: 'delay-ignore-hooks',
+                navigation,
+            });
+            return;
+        }
+        try {
+            await super.runHooks(hookName, navigation);
+        }
+        catch (error) {
+            return this.notfound(navigation);
+        }
+    }
+    async resolveIfDelayFound(task) {
+        let delayResolve;
+        const timer = setInterval(() => {
+            var _a;
+            if (this.delayedNavigation) {
+                if (this.delayedNavigation.type === 'navigate' ||
+                    this.delayedNavigation.type === ((_a = this.currentNavigation) === null || _a === void 0 ? void 0 : _a.type)) {
+                    logger.info({
+                        event: 'delay-navigation-found',
+                        navigation: this.delayedNavigation,
+                    });
+                    // set cancelled flag
+                    if (this.currentNavigation) {
+                        this.currentNavigation.cancelled = true;
+                        this.currentNavigation = null;
+                    }
+                    // resolve current navigation to start new navigation asap
+                    delayResolve();
+                }
+                else {
+                    // updateCurrentRoute should happen only after currentNavigation, so resolve it first to prevent dead-lock
+                    this.delayedResolve();
+                }
+            }
+        }, DELAY_CHECK_INTERVAL);
+        await Promise.race([
+            task,
+            new Promise((resolve) => {
+                delayResolve = resolve;
+            }),
+        ]);
+        clearInterval(timer);
+        delayResolve();
+    }
+    async flattenDelayedNavigation(navigation) {
+        const flatten = async (nav) => {
+            await this.resolveIfDelayFound(super.run(nav));
+            // if new navigation has been called while this navigation lasts
+            // call new navigation execution
+            if (this.delayedNavigation) {
+                const { delayedNavigation } = this;
+                logger.info({
+                    event: 'delay-navigation-run',
+                    navigation: delayedNavigation,
+                });
+                this.delayedNavigation = null;
+                return flatten(delayedNavigation);
+            }
+        };
+        return flatten(navigation)
+            .then(() => {
+            var _a;
+            (_a = this.delayedResolve) === null || _a === void 0 ? void 0 : _a.call(this);
+        }, (err) => {
+            var _a;
+            (_a = this.delayedReject) === null || _a === void 0 ? void 0 : _a.call(this, err);
+        })
+            .finally(() => {
+            this.delayedPromise = null;
+            this.delayedResolve = null;
+            this.delayedReject = null;
+        });
+    }
+}
+
+export { Router };

package/lib/router/client.browser.js

@@ -0,0 +1,116 @@
+import { parse } from '@tinkoff/url';
+import { AbstractRouter } from './abstract.browser.js';
+import { isSameHost } from '../utils.browser.js';
+import { logger } from '../logger.browser.js';
+import { ClientHistory } from '../history/client.browser.js';
+
+class ClientRouter extends AbstractRouter {
+    constructor(options) {
+        super(options);
+        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 flag for cases when we don't have initial router state from server - CSR fallback for example
+        const fullRehydration = !navigation.to;
+        logger.debug({
+            event: 'rehydrate',
+            navigation,
+        });
+        const url = parse(window.location.href);
+        this.currentNavigation = {
+            ...navigation,
+            type: 'navigate',
+            url,
+        };
+        this.lastNavigation = this.currentNavigation;
+        if (fullRehydration) {
+            await this.runHooks('beforeResolve', this.currentNavigation);
+            const to = this.resolveRoute({ url }, { wildcard: true });
+            this.currentNavigation.to = to;
+        }
+        // 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 (fullRehydration) {
+            this.runSyncHooks('change', this.currentNavigation);
+        }
+        this.currentNavigation = null;
+        // add dehydrated route to tree to prevent its loading
+        if (!fullRehydration) {
+            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,
+            });
+        }
+    }
+    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);
+        return this.internalNavigate({
+            ...target,
+            replace: target.replace || navigation.replace,
+        }, {
+            redirect: true,
+        });
+    }
+}
+
+export { ClientRouter };