@tinkoff/router 0.2.7 → 0.2.8

package/lib/index.es.js

@@ -1,1097 +1,12 @@
-import { parse as parse$1, rawResolveUrl, rawParse, convertRawUrl, rawAssignUrl, isInvalidUrl } from '@tinkoff/url';
-import isString from '@tinkoff/utils/is/string';
-import isObject from '@tinkoff/utils/is/object';
-import map from '@tinkoff/utils/array/map';
-import T from '@tinkoff/utils/function/T';
-import noop from '@tinkoff/utils/function/noop';
-import each from '@tinkoff/utils/array/each';
-import find from '@tinkoff/utils/array/find';
-import findIndex from '@tinkoff/utils/array/findIndex';
-import { jsx } from 'react/jsx-runtime';
-import { useSyncExternalStore } from 'use-sync-external-store/shim';
-import { createContext, useContext, useCallback } from 'react';
-import { useShallowEqual } from '@tinkoff/react-hooks';
-
-const PARAMETER_DELIMITER = ':';
-const WILDCARD_REGEXP = /\*/;
-const HISTORY_FALLBACK_REGEXP = /<history-fallback>/;
-const PARAM_PARSER_REGEXP = /([^(?]+)(?:\((.+)\))?(\?)?/;
-
-const isFilePath = (pathname) => {
-    return /\/.+\.[^/]+$/.test(pathname);
-};
-const normalizeTrailingSlash = (pathname, trailingSlash = false) => {
-    const hasTrailingSlash = pathname.endsWith('/');
-    if (trailingSlash) {
-        return hasTrailingSlash || isFilePath(pathname) ? pathname : `${pathname}/`;
-    }
-    return pathname.length > 1 && hasTrailingSlash ? pathname.slice(0, -1) : pathname;
-};
-const normalizeManySlashes = (hrefOrPath) => {
-    const [href, ...search] = hrefOrPath.split('?');
-    return [href.replace(/\/+/g, '/').replace(/^(\w+):\//, '$1://'), ...search].join('?');
-};
-const isSameHost = typeof window === 'undefined'
-    ? T
-    : (url) => {
-        return !url.host || url.host === window.location.host;
-    };
-const makeNavigateOptions = (options) => {
-    if (typeof options === 'string') {
-        return { url: options };
-    }
-    return options;
-};
-const registerHook = (hooksSet, hook) => {
-    hooksSet.add(hook);
-    return () => {
-        hooksSet.delete(hook);
-    };
-};
-
-const getParts = (pathname) => pathname
-    .split('/')
-    .slice(pathname.startsWith('/') ? 1 : 0, pathname.endsWith('/') ? -1 : Infinity);
-const isHistoryFallback = (part) => {
-    return HISTORY_FALLBACK_REGEXP.test(part);
-};
-const isWildcard = (part) => {
-    return WILDCARD_REGEXP.test(part);
-};
-const isParameterized = (part) => {
-    return part.includes(PARAMETER_DELIMITER);
-};
-const parseParameter = (part) => {
-    const [prefix = '', param, postfix = ''] = part.split(PARAMETER_DELIMITER);
-    const match = PARAM_PARSER_REGEXP.exec(param);
-    if (!match) {
-        throw new Error('parameters should satisfy pattern "prefix:paramName(regexp)\\?:postfix"');
-    }
-    const [, paramName, regexp, optional] = match;
-    const useRegexp = prefix || postfix || regexp;
-    return {
-        type: 3 /* PartType.parameter */,
-        paramName,
-        regexp: useRegexp
-            ? new RegExp(`^${prefix}(${regexp || '.+'})${optional ? '?' : ''}${postfix}$`)
-            : undefined,
-        optional: !!optional && !prefix && !postfix,
-    };
-};
-const parse = (part) => {
-    if (isHistoryFallback(part)) {
-        return { type: 1 /* PartType.historyFallback */ };
-    }
-    if (isWildcard(part)) {
-        return { type: 2 /* PartType.wildcard */ };
-    }
-    if (isParameterized(part)) {
-        return parseParameter(part);
-    }
-    return { type: 0 /* PartType.literal */, value: part };
-};
-const makePath = (pathname, params) => {
-    const parts = getParts(pathname);
-    const result = map((part) => {
-        var _a;
-        if (isHistoryFallback(part) || isWildcard(part)) {
-            throw new Error(`Pathname should be only a string with dynamic parameters, not a special string, got ${pathname}`);
-        }
-        if (isParameterized(part)) {
-            const [prefix = '', param = '', postfix = ''] = part.split(PARAMETER_DELIMITER);
-            const match = PARAM_PARSER_REGEXP.exec(param);
-            if (!match) {
-                throw new Error('parameters should satisfy pattern "prefix:paramName(regexp)\\?:postfix"');
-            }
-            const [, paramName, regexp, optional] = match;
-            const value = (_a = params[paramName]) === null || _a === void 0 ? void 0 : _a.toString();
-            if (optional && !value) {
-                return '';
-            }
-            if (!value) {
-                throw new Error(`value for parameter for ${paramName} should be defined in params`);
-            }
-            if (regexp && !new RegExp(regexp).test(value)) {
-                throw new Error(`passed parameter for ${paramName} should satisfy regxep: ${regexp}, got: ${value}`);
-            }
-            return prefix + value + postfix || part;
-        }
-        return part;
-    }, parts).join('/');
-    return normalizeTrailingSlash(`/${result}`, pathname.endsWith('/'));
-};
-
-// eslint-disable-next-line import/no-mutable-exports
-let logger = {
-    trace: noop,
-    debug: noop,
-    info: noop,
-    warn: noop,
-    error: noop,
-};
-const setLogger = (newLogger) => {
-    logger = newLogger;
-};
-
-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$1(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);
-    }
-}
-
-class History {
-    init(navigation) { }
-    listen(listener) {
-        this.listener = listener;
-    }
-    setTree(tree) {
-        this.tree = tree;
-    }
-}
-
-class ServerHistory extends History {
-    save() { }
-    go() {
-        logger.warn({
-            event: 'history.server',
-            message: 'Trying to change history on server',
-        });
-        return Promise.resolve();
-    }
-}
-
-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]);
-            }
-        }
-    }
-}
-
-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);
-    }
-}
-
-const supportsHtml5History = typeof window !== 'undefined' && window.history && window.history.pushState;
-const wrapHistory = ({ onNavigate }) => {
-    if (!supportsHtml5History) {
-        const navigate = (data, title, url) => {
-            window.location.href = url.toString();
-        };
-        window.history.pushState = navigate;
-        window.history.replaceState = navigate;
-        return {
-            navigate: ({ path }) => navigate({}, '', path),
-            history: () => {
-                throw new Error('Method not implemented');
-            },
-            init: noop,
-            subscribe: noop,
-        };
-    }
-    let browserHistory = window.history;
-    if ('__originalHistory' in window.history) {
-        browserHistory = window.history.__originalHistory;
-    }
-    else {
-        window.history.__originalHistory = {
-            pushState: browserHistory.pushState.bind(window.history),
-            replaceState: browserHistory.replaceState.bind(window.history),
-            go: browserHistory.go.bind(window.history),
-        };
-    }
-    const pushState = browserHistory.pushState.bind(window.history);
-    const replaceState = browserHistory.replaceState.bind(window.history);
-    const go = browserHistory.go.bind(window.history);
-    const navigate = ({ path, replace, state }) => {
-        if (replace) {
-            replaceState(state, '', path);
-        }
-        else {
-            pushState(state, '', path);
-        }
-    };
-    const history = (delta) => {
-        go(delta);
-    };
-    const browserNavigate = (replace = false) => {
-        return (navigateState, title, url) => {
-            onNavigate({ url: url.toString(), replace, navigateState });
-        };
-    };
-    window.history.pushState = browserNavigate(false);
-    window.history.replaceState = browserNavigate(true);
-    window.history.go = history;
-    window.history.back = () => history(-1);
-    window.history.forward = () => history(1);
-    return {
-        navigate,
-        history,
-        init: (state) => {
-            replaceState(state, '');
-        },
-        subscribe: (handler) => {
-            window.addEventListener('popstate', ({ state }) => {
-                handler({
-                    path: window.location.pathname + window.location.search + window.location.hash,
-                    state,
-                });
-            });
-        },
-    };
-};
-
-const isHistoryState = (state) => {
-    return state && typeof state.key === 'string';
-};
-const generateKey = (navigation) => {
-    const { to } = navigation;
-    if (to) {
-        return `${to.name}_${to.path}`;
-    }
-};
-const generateState = (navigation, currentState) => {
-    const key = generateKey(navigation);
-    let { type } = navigation;
-    if (navigation.replace && currentState) {
-        type = currentState.type === type ? type : 'navigate';
-    }
-    return {
-        key,
-        type,
-        navigateState: navigation.navigateState,
-    };
-};
-class ClientHistory extends History {
-    constructor() {
-        super();
-        this.currentIndex = 0;
-        this.historyWrapper = wrapHistory({
-            onNavigate: ({ url, replace, navigateState }) => {
-                this.listener({
-                    url,
-                    replace,
-                    navigateState,
-                });
-            },
-        });
-    }
-    init(navigation) {
-        var _a;
-        this.currentState = isHistoryState((_a = window.history) === null || _a === void 0 ? void 0 : _a.state)
-            ? window.history.state
-            : generateState(navigation);
-        this.historyWrapper.init(this.currentState);
-        this.historyWrapper.subscribe(async ({ path, state }) => {
-            var _a, _b;
-            try {
-                let navigationType;
-                let navigateState;
-                if (isHistoryState(state)) {
-                    const { key: prevKey, type: prevType } = this.currentState;
-                    const { key, type } = state;
-                    this.currentState = state;
-                    navigateState = state.navigateState;
-                    if (key === prevKey &&
-                        (type === 'updateCurrentRoute' || prevType === 'updateCurrentRoute')) {
-                        navigationType = 'updateCurrentRoute';
-                    }
-                    else {
-                        navigationType = 'navigate';
-                    }
-                }
-                else {
-                    // if it is not HistoryState than it is probably not a state from @tinkoff/router so reset it
-                    this.currentIndex = 0;
-                }
-                await this.listener({
-                    type: navigationType,
-                    history: true,
-                    url: path,
-                    navigateState,
-                });
-                (_a = this.goPromiseResolve) === null || _a === void 0 ? void 0 : _a.call(this);
-            }
-            catch (err) {
-                (_b = this.goPromiseReject) === null || _b === void 0 ? void 0 : _b.call(this, err);
-            }
-        });
-    }
-    save(navigation) {
-        const { replace, url } = navigation;
-        if (!replace) {
-            this.currentIndex++;
-        }
-        this.currentState = generateState(navigation, this.currentState);
-        this.historyWrapper.navigate({
-            path: url.path,
-            replace,
-            state: this.currentState,
-        });
-    }
-    go(to, options) {
-        var _a;
-        const index = this.currentIndex + to;
-        if (index < 0) {
-            if (options === null || options === void 0 ? void 0 : options.historyFallback) {
-                return this.listener({
-                    url: options.historyFallback,
-                    type: 'navigate',
-                    history: false,
-                });
-            }
-            const historyFallbackRoute = (_a = this.tree) === null || _a === void 0 ? void 0 : _a.getHistoryFallback(window.location.pathname);
-            if (historyFallbackRoute) {
-                return this.listener({
-                    url: historyFallbackRoute.actualPath,
-                    type: 'navigate',
-                    history: false,
-                });
-            }
-        }
-        const promise = new Promise((resolve, reject) => {
-            this.goPromiseResolve = resolve;
-            this.goPromiseReject = reject;
-        });
-        this.historyWrapper.history(to);
-        return promise;
-    }
-}
-
-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) {
-        logger.debug({
-            event: 'rehydrate',
-            navigation,
-        });
-        const url = parse$1(window.location.href);
-        this.currentNavigation = {
-            ...navigation,
-            type: 'navigate',
-            url,
-        };
-        this.lastNavigation = this.currentNavigation;
-        // 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);
-        this.currentNavigation = null;
-        // add dehydrated route to tree to prevent its loading
-        if (navigation.to) {
-            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,
-        });
-    }
-}
-
-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() { }
-}
-
-const RouterContext = createContext(null);
-const RouteContext = createContext(null);
-const UrlContext = createContext(null);
-
-const Provider = ({ router, serverState, children }) => {
-    const route = useSyncExternalStore((cb) => router.registerSyncHook('change', cb), () => router.getLastRoute(), serverState ? () => serverState.currentRoute : () => router.getLastRoute());
-    const url = useSyncExternalStore((cb) => router.registerSyncHook('change', cb), () => router.getLastUrl(), serverState ? () => serverState.currentUrl : () => router.getLastUrl());
-    return (jsx(RouterContext.Provider, { value: router, children: jsx(RouteContext.Provider, { value: route, children: jsx(UrlContext.Provider, { value: url, children: children }) }) }));
-};
-Provider.displayName = 'Provider';
-
-const useRouter = () => {
-    return useContext(RouterContext);
-};
-
-const useRoute = () => {
-    return useContext(RouteContext);
-};
-
-const useUrl = () => {
-    return useContext(UrlContext);
-};
-
-const convertToNavigateOptions = (options) => {
-    return typeof options === 'string' ? { url: options } : options;
-};
-const useNavigate = (rootOptions) => {
-    const router = useRouter();
-    const rootOpts = useShallowEqual(convertToNavigateOptions(rootOptions));
-    return useCallback((specificOptions) => {
-        const opts = rootOpts !== null && rootOpts !== void 0 ? rootOpts : convertToNavigateOptions(specificOptions);
-        return router.navigate(opts);
-    }, [rootOpts, router]);
-};
-
-export { AbstractRouter, History, NoSpaRouter, Provider, RouteTree, Router, getParts, isHistoryFallback, isParameterized, isWildcard, logger, makePath, parse, setLogger, useNavigate, useRoute, useRouter, useUrl };
+export { Router } from './router/server.es.js';
+export { NoSpaRouter } from './router/clientNoSpa.es.js';
+export { AbstractRouter } from './router/abstract.es.js';
+export { History } from './history/base.es.js';
+export { logger, setLogger } from './logger.es.js';
+export { Provider } from './components/react/provider.es.js';
+export { useRouter } from './components/react/useRouter.es.js';
+export { useRoute } from './components/react/useRoute.es.js';
+export { useUrl } from './components/react/useUrl.es.js';
+export { useNavigate } from './components/react/useNavigate.es.js';
+export { RouteTree } from './tree/tree.es.js';
+export { getParts, isHistoryFallback, isParameterized, isWildcard, makePath, parse } from './tree/utils.es.js';