@tinkoff/router 0.2.7 → 0.2.9

package/lib/router/abstract.es.js

@@ -0,0 +1,395 @@
+import isString from '@tinkoff/utils/is/string';
+import isObject from '@tinkoff/utils/is/object';
+import { parse, rawResolveUrl, rawParse, convertRawUrl, rawAssignUrl } from '@tinkoff/url';
+import { makePath } from '../tree/utils.es.js';
+import { logger } from '../logger.es.js';
+import { makeNavigateOptions, normalizeManySlashes, normalizeTrailingSlash, isSameHost, registerHook } from '../utils.es.js';
+
+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.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.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.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(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.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, 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: parse(opts.url) }, options);
+    }
+    back(options) {
+        return this.go(-1, options);
+    }
+    forward() {
+        return this.go(1);
+    }
+    async go(to, options) {
+        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.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.debug({
+            event: 'not-found',
+            navigation,
+        });
+        return (_a = this.onNotFound) === null || _a === void 0 ? void 0 : _a.call(this, navigation);
+    }
+    async block(navigation) {
+        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 = normalizeManySlashes(normalized);
+        }
+        if (!this.strictTrailingSlash) {
+            normalized = normalizeTrailingSlash(normalized, this.trailingSlash);
+        }
+        return normalized;
+    }
+    resolveUrl({ url, query = {}, params, preserveQuery, hash }) {
+        var _a;
+        const currentRoute = this.getCurrentRoute();
+        const currentUrl = this.getCurrentUrl();
+        const resultUrl = url ? rawResolveUrl((_a = currentUrl === null || currentUrl === void 0 ? void 0 : currentUrl.href) !== null && _a !== void 0 ? _a : '', url) : rawParse(currentUrl.href);
+        let { pathname } = resultUrl;
+        if (params) {
+            if (url) {
+                pathname = makePath(resultUrl.pathname, params);
+            }
+            else if (currentRoute) {
+                pathname = makePath(currentRoute.path, { ...currentRoute.params, ...params });
+            }
+        }
+        if (isSameHost(resultUrl)) {
+            pathname = this.normalizePathname(pathname);
+        }
+        return convertRawUrl(rawAssignUrl(resultUrl, {
+            pathname,
+            search: url ? 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.debug({
+            event: 'guards.run',
+            navigation,
+        });
+        if (!this.guards) {
+            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.warn({
+                event: 'guard.error',
+                error,
+            });
+        })));
+        logger.debug({
+            event: 'guards.done',
+            navigation,
+            results,
+        });
+        for (const result of results) {
+            if (result === false) {
+                return this.block(navigation);
+            }
+            if (isString(result) || isObject(result)) {
+                return this.redirect(navigation, makeNavigateOptions(result));
+            }
+        }
+    }
+    registerGuard(guard) {
+        return registerHook(this.guards, guard);
+    }
+    runSyncHooks(hookName, navigation) {
+        logger.debug({
+            event: 'sync-hooks.run',
+            hookName,
+            navigation,
+        });
+        const hooks = this.syncHooks.get(hookName);
+        if (!hooks) {
+            logger.debug({
+                event: 'sync-hooks.empty',
+                hookName,
+                navigation,
+            });
+            return;
+        }
+        for (const hook of hooks) {
+            try {
+                hook(navigation);
+            }
+            catch (error) {
+                logger.warn({
+                    event: 'sync-hooks.error',
+                    error,
+                });
+            }
+        }
+        logger.debug({
+            event: 'sync-hooks.done',
+            hookName,
+            navigation,
+        });
+    }
+    registerSyncHook(hookName, hook) {
+        return registerHook(this.syncHooks.get(hookName), hook);
+    }
+    async runHooks(hookName, navigation) {
+        logger.debug({
+            event: 'hooks.run',
+            hookName,
+            navigation,
+        });
+        const hooks = this.hooks.get(hookName);
+        if (!hooks) {
+            logger.debug({
+                event: 'hooks.empty',
+                hookName,
+                navigation,
+            });
+            return;
+        }
+        await Promise.all(Array.from(hooks).map((hook) => Promise.resolve(hook(navigation)).catch((error) => {
+            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.debug({
+            event: 'hooks.done',
+            hookName,
+            navigation,
+        });
+    }
+    registerHook(hookName, hook) {
+        return registerHook(this.hooks.get(hookName), hook);
+    }
+}
+
+export { AbstractRouter };