@tinkoff/router 0.5.65 → 0.5.67

package/lib/router/abstract.browser.js

@@ -1,34 +1,89 @@
 import isString from '@tinkoff/utils/is/string';
 import isObject from '@tinkoff/utils/is/object';
 import { parse, rawResolveUrl, rawParse, convertRawUrl, rawAssignUrl } from '@tinkoff/url';
+import { TapableHooks } from '@tinkoff/hook-runner';
 import { makePath } from '../tree/utils.browser.js';
 import { logger } from '../logger.browser.js';
-import { makeNavigateOptions, normalizeManySlashes, normalizeTrailingSlash, isSameHost, registerHook } from '../utils.browser.js';
+import { makeNavigateOptions, normalizeManySlashes, normalizeTrailingSlash, isSameHost } from '../utils.browser.js';
 
 class AbstractRouter {
-    constructor({ trailingSlash, mergeSlashes, enableViewTransitions, beforeResolve = [], beforeNavigate = [], afterNavigate = [], beforeUpdateCurrent = [], afterUpdateCurrent = [], guards = [], onChange = [], onRedirect, onNotFound, onBlock, }) {
+    // eslint-disable-next-line max-statements
+    constructor({ trailingSlash, mergeSlashes, enableViewTransitions, beforeResolve = [], beforeNavigate = [], afterNavigate = [], beforeUpdateCurrent = [], afterUpdateCurrent = [], guards = [], onChange = [], onRedirect, onNotFound, onBlock, hooksFactory, plugins, }) {
         this.started = false;
         this.trailingSlash = false;
         this.strictTrailingSlash = true;
         this.viewTransitionsEnabled = false;
         this.mergeSlashes = false;
+        this.hooksIndex = 0;
+        this.syncHooksIndex = 0;
+        this.guardsIndex = 0;
         this.trailingSlash = trailingSlash ?? false;
         this.strictTrailingSlash = typeof trailingSlash === 'undefined';
         this.mergeSlashes = mergeSlashes ?? false;
         this.viewTransitionsEnabled = enableViewTransitions ?? 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.hooksFactory = hooksFactory ?? new TapableHooks();
+        this.plugins = plugins ?? [];
+        this.currentUuid = 0;
         this.onRedirect = onRedirect;
         this.onNotFound = onNotFound;
         this.onBlock = onBlock;
-        this.currentUuid = 0;
+        this.hooks = new Map([
+            ['beforeResolve', this.hooksFactory.createAsyncParallel('beforeResolve')],
+            ['beforeNavigate', this.hooksFactory.createAsyncParallel('beforeNavigate')],
+            ['afterNavigate', this.hooksFactory.createAsyncParallel('afterNavigate')],
+            ['beforeUpdateCurrent', this.hooksFactory.createAsyncParallel('beforeUpdateCurrent')],
+            ['afterUpdateCurrent', this.hooksFactory.createAsyncParallel('afterUpdateCurrent')],
+        ]);
+        beforeResolve.forEach((hook) => this.registerHook('beforeResolve', hook));
+        beforeNavigate.forEach((hook) => this.registerHook('beforeNavigate', hook));
+        afterNavigate.forEach((hook) => this.registerHook('afterNavigate', hook));
+        beforeUpdateCurrent.forEach((hook) => this.registerHook('beforeUpdateCurrent', hook));
+        afterUpdateCurrent.forEach((hook) => this.registerHook('afterUpdateCurrent', hook));
+        this.guards = this.hooksFactory.createAsyncParallel('guards');
+        guards.forEach((guard) => this.registerGuard(guard));
+        this.syncHooks = new Map([['change', this.hooksFactory.createSync('change')]]);
+        onChange.forEach((hook) => this.registerSyncHook('change', hook));
+        this.navigateHook = this.hooksFactory.createAsync('navigate');
+        this.updateHook = this.hooksFactory.createAsync('update');
+        this.runNavigateHook = this.hooksFactory.createAsync('runNavigate');
+        this.runUpdateHook = this.hooksFactory.createAsync('runUpdate');
+        this.redirectHook = this.hooksFactory.createAsync('redirect');
+        this.notfoundHook = this.hooksFactory.createAsync('notfound');
+        this.blockHook = this.hooksFactory.createAsync('block');
+        this.navigateHook.tapPromise('router', async (_, { navigateOptions }) => {
+            await this.internalNavigate(makeNavigateOptions(navigateOptions), {});
+        });
+        this.updateHook.tapPromise('router', async (_, { updateRouteOptions }) => {
+            await this.internalUpdateCurrentRoute(updateRouteOptions, {});
+        });
+        this.runNavigateHook.tapPromise('router', async (_, { navigation }) => {
+            // TODO navigate
+            // 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);
+        });
+        this.runUpdateHook.tapPromise('router', async (_, { navigation }) => {
+            await this.runHooks('beforeUpdateCurrent', navigation);
+            this.commitNavigation(navigation);
+            await this.runHooks('afterUpdateCurrent', navigation);
+        });
+        this.redirectHook.tapPromise('router', async (_, { navigation }) => {
+            await this.onRedirect?.(navigation);
+        });
+        this.notfoundHook.tapPromise('router', async (_, { navigation }) => {
+            await this.onNotFound?.(navigation);
+        });
+        this.blockHook.tapPromise('router', async (_, { navigation }) => {
+            await this.onBlock?.(navigation);
+        });
+        this.plugins.forEach((plugin) => {
+            plugin.apply(this);
+        });
     }
     // start is using as marker that any preparation for proper work has done in the app
     // and now router can manage any navigations
@@ -67,7 +122,7 @@ class AbstractRouter {
         this.runSyncHooks('change', navigation);
     }
     async updateCurrentRoute(updateRouteOptions) {
-        return this.internalUpdateCurrentRoute(updateRouteOptions, {});
+        await this.updateHook.callPromise({ updateRouteOptions });
     }
     async internalUpdateCurrentRoute(updateRouteOptions, { history }) {
         const prevNavigation = this.currentNavigation ?? this.lastNavigation;
@@ -96,12 +151,10 @@ class AbstractRouter {
         await this.run(navigation);
     }
     async runUpdateCurrentRoute(navigation) {
-        await this.runHooks('beforeUpdateCurrent', navigation);
-        this.commitNavigation(navigation);
-        await this.runHooks('afterUpdateCurrent', navigation);
+        await this.runUpdateHook.callPromise({ navigation });
     }
     async navigate(navigateOptions) {
-        return this.internalNavigate(makeNavigateOptions(navigateOptions), {});
+        await this.navigateHook.callPromise({ navigateOptions });
     }
     async internalNavigate(navigateOptions, { history, redirect }) {
         const { url, replace, params, navigateState, code, viewTransition } = navigateOptions;
@@ -148,14 +201,7 @@ class AbstractRouter {
         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);
+        await this.runNavigateHook.callPromise({ navigation });
     }
     async run(navigation) {
         this.currentNavigation = navigation;
@@ -201,12 +247,14 @@ class AbstractRouter {
             navigation,
             target,
         });
-        return this.onRedirect?.({
-            ...navigation,
-            from: navigation.to,
-            fromUrl: navigation.url,
-            to: null,
-            url: this.resolveUrl(target),
+        await this.redirectHook.callPromise({
+            navigation: {
+                ...navigation,
+                from: navigation.to,
+                fromUrl: navigation.url,
+                to: null,
+                url: this.resolveUrl(target),
+            },
         });
     }
     async notfound(navigation) {
@@ -214,7 +262,9 @@ class AbstractRouter {
             event: 'not-found',
             navigation,
         });
-        return this.onNotFound?.(navigation);
+        await this.notfoundHook.callPromise({
+            navigation,
+        });
     }
     async block(navigation) {
         logger.debug({
@@ -223,7 +273,8 @@ class AbstractRouter {
         });
         this.currentNavigation = null;
         if (this.onBlock) {
-            return this.onBlock(navigation);
+            await this.blockHook.callPromise({ navigation });
+            return;
         }
         throw new Error('Navigation blocked');
     }
@@ -288,19 +339,8 @@ class AbstractRouter {
             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,
-            });
-        })));
+        const results = [];
+        await this.guards.callPromise({ navigation, allResults: results });
         logger.debug({
             event: 'guards.done',
             navigation,
@@ -316,7 +356,20 @@ class AbstractRouter {
         }
     }
     registerGuard(guard) {
-        return registerHook(this.guards, guard);
+        const untap = this.guards.tapPromise(guard.name ?? `guard-${this.guardsIndex++}`, async (_, { allResults, navigation }) => {
+            try {
+                const result = await guard(navigation);
+                allResults.push(result);
+            }
+            catch (error) {
+                logger.warn({
+                    event: 'guard.error',
+                    error,
+                });
+                allResults.push(undefined);
+            }
+        });
+        return untap;
     }
     runSyncHooks(hookName, navigation) {
         logger.debug({
@@ -324,18 +377,19 @@ class AbstractRouter {
             hookName,
             navigation,
         });
-        const hooks = this.syncHooks.get(hookName);
-        if (!hooks) {
-            logger.debug({
-                event: 'sync-hooks.empty',
-                hookName,
-                navigation,
-            });
-            return;
-        }
-        for (const hook of hooks) {
+        this.syncHooks.get(hookName).call({ navigation });
+        logger.debug({
+            event: 'sync-hooks.done',
+            hookName,
+            navigation,
+        });
+    }
+    registerSyncHook(hookName, hook) {
+        const untap = this.syncHooks
+            .get(hookName)
+            .tap(hook.name ?? `sync-hook-${this.syncHooksIndex++}`, (_, { navigation }) => {
             try {
-                hook(navigation);
+                return hook(navigation);
             }
             catch (error) {
                 logger.warn({
@@ -343,15 +397,8 @@ class AbstractRouter {
                     error,
                 });
             }
-        }
-        logger.debug({
-            event: 'sync-hooks.done',
-            hookName,
-            navigation,
         });
-    }
-    registerSyncHook(hookName, hook) {
-        return registerHook(this.syncHooks.get(hookName), hook);
+        return untap;
     }
     async runHooks(hookName, navigation) {
         logger.debug({
@@ -359,26 +406,7 @@ class AbstractRouter {
             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;
-            }
-        })));
+        await this.hooks.get(hookName).callPromise({ navigation });
         logger.debug({
             event: 'hooks.done',
             hookName,
@@ -386,7 +414,25 @@ class AbstractRouter {
         });
     }
     registerHook(hookName, hook) {
-        return registerHook(this.hooks.get(hookName), hook);
+        const untap = this.hooks
+            .get(hookName)
+            .tapPromise(hook.name ?? `hook-${this.hooksIndex++}`, async (_, { navigation }) => {
+            try {
+                await 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;
+                }
+            }
+        });
+        return untap;
     }
     uuid() {
         return this.currentUuid++;

package/lib/router/abstract.d.ts

@@ -1,5 +1,7 @@
 import type { Url } from '@tinkoff/url';
-import type { Route, NavigateOptions, UpdateCurrentRouteOptions, Navigation, NavigationGuard, NavigationHook, NavigationSyncHook, HookName, Params, SyncHookName, HistoryOptions } from '../types';
+import type { AsyncParallelTapableHookInstance, AsyncTapableHookInstance, SyncTapableHookInstance } from '@tinkoff/hook-runner';
+import { TapableHooks } from '@tinkoff/hook-runner';
+import type { Route, NavigateOptions, UpdateCurrentRouteOptions, Navigation, NavigationGuard, NavigationHook, NavigationSyncHook, HookName, Params, SyncHookName, HistoryOptions, RouterPlugin } from '../types';
 import type { History } from '../history/base';
 import type { RouteTree } from '../tree/tree';
 export interface Options {
@@ -18,6 +20,8 @@ export interface Options {
     guards?: NavigationGuard[];
     onChange?: NavigationSyncHook[];
     defaultRedirectCode?: number;
+    hooksFactory?: TapableHooks;
+    plugins?: RouterPlugin[];
 }
 interface InternalOptions {
     history?: boolean;
@@ -33,11 +37,44 @@ export declare abstract class AbstractRouter {
     protected lastNavigation: Navigation;
     protected history: History;
     protected tree?: RouteTree;
-    protected guards: Set<NavigationGuard>;
-    protected hooks: Map<HookName, Set<NavigationHook>>;
-    protected syncHooks: Map<SyncHookName, Set<NavigationSyncHook>>;
+    readonly guards: AsyncParallelTapableHookInstance<{
+        navigation: Navigation;
+        allResults: Array<void | NavigateOptions | string | boolean>;
+    }>;
+    readonly hooks: Map<HookName, AsyncParallelTapableHookInstance<{
+        navigation: Navigation;
+    }>>;
+    readonly syncHooks: Map<SyncHookName, SyncTapableHookInstance<{
+        navigation: Navigation;
+    }>>;
+    readonly navigateHook: AsyncTapableHookInstance<{
+        navigateOptions: NavigateOptions | string;
+    }>;
+    readonly updateHook: AsyncTapableHookInstance<{
+        updateRouteOptions: UpdateCurrentRouteOptions;
+    }>;
+    readonly runNavigateHook: AsyncTapableHookInstance<{
+        navigation: Navigation;
+    }>;
+    readonly runUpdateHook: AsyncTapableHookInstance<{
+        navigation: Navigation;
+    }>;
+    readonly redirectHook: AsyncTapableHookInstance<{
+        navigation: Navigation;
+    }>;
+    readonly notfoundHook: AsyncTapableHookInstance<{
+        navigation: Navigation;
+    }>;
+    readonly blockHook: AsyncTapableHookInstance<{
+        navigation: Navigation;
+    }>;
+    protected hooksFactory: TapableHooks;
+    protected plugins?: RouterPlugin[];
     private currentUuid;
-    constructor({ trailingSlash, mergeSlashes, enableViewTransitions, beforeResolve, beforeNavigate, afterNavigate, beforeUpdateCurrent, afterUpdateCurrent, guards, onChange, onRedirect, onNotFound, onBlock, }: Options);
+    private hooksIndex;
+    private syncHooksIndex;
+    private guardsIndex;
+    constructor({ trailingSlash, mergeSlashes, enableViewTransitions, beforeResolve, beforeNavigate, afterNavigate, beforeUpdateCurrent, afterUpdateCurrent, guards, onChange, onRedirect, onNotFound, onBlock, hooksFactory, plugins, }: Options);
     protected onRedirect?: NavigationHook;
     protected onNotFound?: NavigationHook;
     protected onBlock?: NavigationHook;
@@ -76,11 +113,11 @@ export declare abstract class AbstractRouter {
         wildcard?: boolean;
     }): import("../types").NavigationRoute;
     protected runGuards(navigation: Navigation): Promise<void>;
-    registerGuard(guard: NavigationGuard): () => void;
+    registerGuard(guard: NavigationGuard): import("@tinkoff/hook-runner/lib/types").UntapCallback;
     protected runSyncHooks(hookName: SyncHookName, navigation: Navigation): void;
-    registerSyncHook(hookName: SyncHookName, hook: NavigationSyncHook): () => void;
+    registerSyncHook(hookName: SyncHookName, hook: NavigationSyncHook): import("@tinkoff/hook-runner/lib/types").UntapCallback;
     protected runHooks(hookName: HookName, navigation: Navigation): Promise<void>;
-    registerHook(hookName: HookName, hook: NavigationHook): () => void;
+    registerHook(hookName: HookName, hook: NavigationHook): import("@tinkoff/hook-runner/lib/types").UntapCallback;
     private uuid;
 }
 export {};

package/lib/router/abstract.es.js

@@ -1,34 +1,89 @@
 import isString from '@tinkoff/utils/is/string';
 import isObject from '@tinkoff/utils/is/object';
 import { parse, rawResolveUrl, rawParse, convertRawUrl, rawAssignUrl } from '@tinkoff/url';
+import { TapableHooks } from '@tinkoff/hook-runner';
 import { makePath } from '../tree/utils.es.js';
 import { logger } from '../logger.es.js';
-import { makeNavigateOptions, normalizeManySlashes, normalizeTrailingSlash, isSameHost, registerHook } from '../utils.es.js';
+import { makeNavigateOptions, normalizeManySlashes, normalizeTrailingSlash, isSameHost } from '../utils.es.js';
 
 class AbstractRouter {
-    constructor({ trailingSlash, mergeSlashes, enableViewTransitions, beforeResolve = [], beforeNavigate = [], afterNavigate = [], beforeUpdateCurrent = [], afterUpdateCurrent = [], guards = [], onChange = [], onRedirect, onNotFound, onBlock, }) {
+    // eslint-disable-next-line max-statements
+    constructor({ trailingSlash, mergeSlashes, enableViewTransitions, beforeResolve = [], beforeNavigate = [], afterNavigate = [], beforeUpdateCurrent = [], afterUpdateCurrent = [], guards = [], onChange = [], onRedirect, onNotFound, onBlock, hooksFactory, plugins, }) {
         this.started = false;
         this.trailingSlash = false;
         this.strictTrailingSlash = true;
         this.viewTransitionsEnabled = false;
         this.mergeSlashes = false;
+        this.hooksIndex = 0;
+        this.syncHooksIndex = 0;
+        this.guardsIndex = 0;
         this.trailingSlash = trailingSlash ?? false;
         this.strictTrailingSlash = typeof trailingSlash === 'undefined';
         this.mergeSlashes = mergeSlashes ?? false;
         this.viewTransitionsEnabled = enableViewTransitions ?? 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.hooksFactory = hooksFactory ?? new TapableHooks();
+        this.plugins = plugins ?? [];
+        this.currentUuid = 0;
         this.onRedirect = onRedirect;
         this.onNotFound = onNotFound;
         this.onBlock = onBlock;
-        this.currentUuid = 0;
+        this.hooks = new Map([
+            ['beforeResolve', this.hooksFactory.createAsyncParallel('beforeResolve')],
+            ['beforeNavigate', this.hooksFactory.createAsyncParallel('beforeNavigate')],
+            ['afterNavigate', this.hooksFactory.createAsyncParallel('afterNavigate')],
+            ['beforeUpdateCurrent', this.hooksFactory.createAsyncParallel('beforeUpdateCurrent')],
+            ['afterUpdateCurrent', this.hooksFactory.createAsyncParallel('afterUpdateCurrent')],
+        ]);
+        beforeResolve.forEach((hook) => this.registerHook('beforeResolve', hook));
+        beforeNavigate.forEach((hook) => this.registerHook('beforeNavigate', hook));
+        afterNavigate.forEach((hook) => this.registerHook('afterNavigate', hook));
+        beforeUpdateCurrent.forEach((hook) => this.registerHook('beforeUpdateCurrent', hook));
+        afterUpdateCurrent.forEach((hook) => this.registerHook('afterUpdateCurrent', hook));
+        this.guards = this.hooksFactory.createAsyncParallel('guards');
+        guards.forEach((guard) => this.registerGuard(guard));
+        this.syncHooks = new Map([['change', this.hooksFactory.createSync('change')]]);
+        onChange.forEach((hook) => this.registerSyncHook('change', hook));
+        this.navigateHook = this.hooksFactory.createAsync('navigate');
+        this.updateHook = this.hooksFactory.createAsync('update');
+        this.runNavigateHook = this.hooksFactory.createAsync('runNavigate');
+        this.runUpdateHook = this.hooksFactory.createAsync('runUpdate');
+        this.redirectHook = this.hooksFactory.createAsync('redirect');
+        this.notfoundHook = this.hooksFactory.createAsync('notfound');
+        this.blockHook = this.hooksFactory.createAsync('block');
+        this.navigateHook.tapPromise('router', async (_, { navigateOptions }) => {
+            await this.internalNavigate(makeNavigateOptions(navigateOptions), {});
+        });
+        this.updateHook.tapPromise('router', async (_, { updateRouteOptions }) => {
+            await this.internalUpdateCurrentRoute(updateRouteOptions, {});
+        });
+        this.runNavigateHook.tapPromise('router', async (_, { navigation }) => {
+            // TODO navigate
+            // 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);
+        });
+        this.runUpdateHook.tapPromise('router', async (_, { navigation }) => {
+            await this.runHooks('beforeUpdateCurrent', navigation);
+            this.commitNavigation(navigation);
+            await this.runHooks('afterUpdateCurrent', navigation);
+        });
+        this.redirectHook.tapPromise('router', async (_, { navigation }) => {
+            await this.onRedirect?.(navigation);
+        });
+        this.notfoundHook.tapPromise('router', async (_, { navigation }) => {
+            await this.onNotFound?.(navigation);
+        });
+        this.blockHook.tapPromise('router', async (_, { navigation }) => {
+            await this.onBlock?.(navigation);
+        });
+        this.plugins.forEach((plugin) => {
+            plugin.apply(this);
+        });
     }
     // start is using as marker that any preparation for proper work has done in the app
     // and now router can manage any navigations
@@ -67,7 +122,7 @@ class AbstractRouter {
         this.runSyncHooks('change', navigation);
     }
     async updateCurrentRoute(updateRouteOptions) {
-        return this.internalUpdateCurrentRoute(updateRouteOptions, {});
+        await this.updateHook.callPromise({ updateRouteOptions });
     }
     async internalUpdateCurrentRoute(updateRouteOptions, { history }) {
         const prevNavigation = this.currentNavigation ?? this.lastNavigation;
@@ -96,12 +151,10 @@ class AbstractRouter {
         await this.run(navigation);
     }
     async runUpdateCurrentRoute(navigation) {
-        await this.runHooks('beforeUpdateCurrent', navigation);
-        this.commitNavigation(navigation);
-        await this.runHooks('afterUpdateCurrent', navigation);
+        await this.runUpdateHook.callPromise({ navigation });
     }
     async navigate(navigateOptions) {
-        return this.internalNavigate(makeNavigateOptions(navigateOptions), {});
+        await this.navigateHook.callPromise({ navigateOptions });
     }
     async internalNavigate(navigateOptions, { history, redirect }) {
         const { url, replace, params, navigateState, code, viewTransition } = navigateOptions;
@@ -148,14 +201,7 @@ class AbstractRouter {
         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);
+        await this.runNavigateHook.callPromise({ navigation });
     }
     async run(navigation) {
         this.currentNavigation = navigation;
@@ -201,12 +247,14 @@ class AbstractRouter {
             navigation,
             target,
         });
-        return this.onRedirect?.({
-            ...navigation,
-            from: navigation.to,
-            fromUrl: navigation.url,
-            to: null,
-            url: this.resolveUrl(target),
+        await this.redirectHook.callPromise({
+            navigation: {
+                ...navigation,
+                from: navigation.to,
+                fromUrl: navigation.url,
+                to: null,
+                url: this.resolveUrl(target),
+            },
         });
     }
     async notfound(navigation) {
@@ -214,7 +262,9 @@ class AbstractRouter {
             event: 'not-found',
             navigation,
         });
-        return this.onNotFound?.(navigation);
+        await this.notfoundHook.callPromise({
+            navigation,
+        });
     }
     async block(navigation) {
         logger.debug({
@@ -223,7 +273,8 @@ class AbstractRouter {
         });
         this.currentNavigation = null;
         if (this.onBlock) {
-            return this.onBlock(navigation);
+            await this.blockHook.callPromise({ navigation });
+            return;
         }
         throw new Error('Navigation blocked');
     }
@@ -288,19 +339,8 @@ class AbstractRouter {
             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,
-            });
-        })));
+        const results = [];
+        await this.guards.callPromise({ navigation, allResults: results });
         logger.debug({
             event: 'guards.done',
             navigation,
@@ -316,7 +356,20 @@ class AbstractRouter {
         }
     }
     registerGuard(guard) {
-        return registerHook(this.guards, guard);
+        const untap = this.guards.tapPromise(guard.name ?? `guard-${this.guardsIndex++}`, async (_, { allResults, navigation }) => {
+            try {
+                const result = await guard(navigation);
+                allResults.push(result);
+            }
+            catch (error) {
+                logger.warn({
+                    event: 'guard.error',
+                    error,
+                });
+                allResults.push(undefined);
+            }
+        });
+        return untap;
     }
     runSyncHooks(hookName, navigation) {
         logger.debug({
@@ -324,18 +377,19 @@ class AbstractRouter {
             hookName,
             navigation,
         });
-        const hooks = this.syncHooks.get(hookName);
-        if (!hooks) {
-            logger.debug({
-                event: 'sync-hooks.empty',
-                hookName,
-                navigation,
-            });
-            return;
-        }
-        for (const hook of hooks) {
+        this.syncHooks.get(hookName).call({ navigation });
+        logger.debug({
+            event: 'sync-hooks.done',
+            hookName,
+            navigation,
+        });
+    }
+    registerSyncHook(hookName, hook) {
+        const untap = this.syncHooks
+            .get(hookName)
+            .tap(hook.name ?? `sync-hook-${this.syncHooksIndex++}`, (_, { navigation }) => {
             try {
-                hook(navigation);
+                return hook(navigation);
             }
             catch (error) {
                 logger.warn({
@@ -343,15 +397,8 @@ class AbstractRouter {
                     error,
                 });
             }
-        }
-        logger.debug({
-            event: 'sync-hooks.done',
-            hookName,
-            navigation,
         });
-    }
-    registerSyncHook(hookName, hook) {
-        return registerHook(this.syncHooks.get(hookName), hook);
+        return untap;
     }
     async runHooks(hookName, navigation) {
         logger.debug({
@@ -359,26 +406,7 @@ class AbstractRouter {
             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;
-            }
-        })));
+        await this.hooks.get(hookName).callPromise({ navigation });
         logger.debug({
             event: 'hooks.done',
             hookName,
@@ -386,7 +414,25 @@ class AbstractRouter {
         });
     }
     registerHook(hookName, hook) {
-        return registerHook(this.hooks.get(hookName), hook);
+        const untap = this.hooks
+            .get(hookName)
+            .tapPromise(hook.name ?? `hook-${this.hooksIndex++}`, async (_, { navigation }) => {
+            try {
+                await 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;
+                }
+            }
+        });
+        return untap;
     }
     uuid() {
         return this.currentUuid++;

package/lib/router/abstract.js

@@ -5,6 +5,7 @@ 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 hookRunner = require('@tinkoff/hook-runner');
 var utils$1 = require('../tree/utils.js');
 var logger = require('../logger.js');
 var utils = require('../utils.js');
@@ -15,29 +16,83 @@ var isString__default = /*#__PURE__*/_interopDefaultLegacy(isString);
 var isObject__default = /*#__PURE__*/_interopDefaultLegacy(isObject);
 
 class AbstractRouter {
-    constructor({ trailingSlash, mergeSlashes, enableViewTransitions, beforeResolve = [], beforeNavigate = [], afterNavigate = [], beforeUpdateCurrent = [], afterUpdateCurrent = [], guards = [], onChange = [], onRedirect, onNotFound, onBlock, }) {
+    // eslint-disable-next-line max-statements
+    constructor({ trailingSlash, mergeSlashes, enableViewTransitions, beforeResolve = [], beforeNavigate = [], afterNavigate = [], beforeUpdateCurrent = [], afterUpdateCurrent = [], guards = [], onChange = [], onRedirect, onNotFound, onBlock, hooksFactory, plugins, }) {
         this.started = false;
         this.trailingSlash = false;
         this.strictTrailingSlash = true;
         this.viewTransitionsEnabled = false;
         this.mergeSlashes = false;
+        this.hooksIndex = 0;
+        this.syncHooksIndex = 0;
+        this.guardsIndex = 0;
         this.trailingSlash = trailingSlash ?? false;
         this.strictTrailingSlash = typeof trailingSlash === 'undefined';
         this.mergeSlashes = mergeSlashes ?? false;
         this.viewTransitionsEnabled = enableViewTransitions ?? 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.hooksFactory = hooksFactory ?? new hookRunner.TapableHooks();
+        this.plugins = plugins ?? [];
+        this.currentUuid = 0;
         this.onRedirect = onRedirect;
         this.onNotFound = onNotFound;
         this.onBlock = onBlock;
-        this.currentUuid = 0;
+        this.hooks = new Map([
+            ['beforeResolve', this.hooksFactory.createAsyncParallel('beforeResolve')],
+            ['beforeNavigate', this.hooksFactory.createAsyncParallel('beforeNavigate')],
+            ['afterNavigate', this.hooksFactory.createAsyncParallel('afterNavigate')],
+            ['beforeUpdateCurrent', this.hooksFactory.createAsyncParallel('beforeUpdateCurrent')],
+            ['afterUpdateCurrent', this.hooksFactory.createAsyncParallel('afterUpdateCurrent')],
+        ]);
+        beforeResolve.forEach((hook) => this.registerHook('beforeResolve', hook));
+        beforeNavigate.forEach((hook) => this.registerHook('beforeNavigate', hook));
+        afterNavigate.forEach((hook) => this.registerHook('afterNavigate', hook));
+        beforeUpdateCurrent.forEach((hook) => this.registerHook('beforeUpdateCurrent', hook));
+        afterUpdateCurrent.forEach((hook) => this.registerHook('afterUpdateCurrent', hook));
+        this.guards = this.hooksFactory.createAsyncParallel('guards');
+        guards.forEach((guard) => this.registerGuard(guard));
+        this.syncHooks = new Map([['change', this.hooksFactory.createSync('change')]]);
+        onChange.forEach((hook) => this.registerSyncHook('change', hook));
+        this.navigateHook = this.hooksFactory.createAsync('navigate');
+        this.updateHook = this.hooksFactory.createAsync('update');
+        this.runNavigateHook = this.hooksFactory.createAsync('runNavigate');
+        this.runUpdateHook = this.hooksFactory.createAsync('runUpdate');
+        this.redirectHook = this.hooksFactory.createAsync('redirect');
+        this.notfoundHook = this.hooksFactory.createAsync('notfound');
+        this.blockHook = this.hooksFactory.createAsync('block');
+        this.navigateHook.tapPromise('router', async (_, { navigateOptions }) => {
+            await this.internalNavigate(utils.makeNavigateOptions(navigateOptions), {});
+        });
+        this.updateHook.tapPromise('router', async (_, { updateRouteOptions }) => {
+            await this.internalUpdateCurrentRoute(updateRouteOptions, {});
+        });
+        this.runNavigateHook.tapPromise('router', async (_, { navigation }) => {
+            // TODO navigate
+            // 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);
+        });
+        this.runUpdateHook.tapPromise('router', async (_, { navigation }) => {
+            await this.runHooks('beforeUpdateCurrent', navigation);
+            this.commitNavigation(navigation);
+            await this.runHooks('afterUpdateCurrent', navigation);
+        });
+        this.redirectHook.tapPromise('router', async (_, { navigation }) => {
+            await this.onRedirect?.(navigation);
+        });
+        this.notfoundHook.tapPromise('router', async (_, { navigation }) => {
+            await this.onNotFound?.(navigation);
+        });
+        this.blockHook.tapPromise('router', async (_, { navigation }) => {
+            await this.onBlock?.(navigation);
+        });
+        this.plugins.forEach((plugin) => {
+            plugin.apply(this);
+        });
     }
     // start is using as marker that any preparation for proper work has done in the app
     // and now router can manage any navigations
@@ -76,7 +131,7 @@ class AbstractRouter {
         this.runSyncHooks('change', navigation);
     }
     async updateCurrentRoute(updateRouteOptions) {
-        return this.internalUpdateCurrentRoute(updateRouteOptions, {});
+        await this.updateHook.callPromise({ updateRouteOptions });
     }
     async internalUpdateCurrentRoute(updateRouteOptions, { history }) {
         const prevNavigation = this.currentNavigation ?? this.lastNavigation;
@@ -105,12 +160,10 @@ class AbstractRouter {
         await this.run(navigation);
     }
     async runUpdateCurrentRoute(navigation) {
-        await this.runHooks('beforeUpdateCurrent', navigation);
-        this.commitNavigation(navigation);
-        await this.runHooks('afterUpdateCurrent', navigation);
+        await this.runUpdateHook.callPromise({ navigation });
     }
     async navigate(navigateOptions) {
-        return this.internalNavigate(utils.makeNavigateOptions(navigateOptions), {});
+        await this.navigateHook.callPromise({ navigateOptions });
     }
     async internalNavigate(navigateOptions, { history, redirect }) {
         const { url, replace, params, navigateState, code, viewTransition } = navigateOptions;
@@ -157,14 +210,7 @@ class AbstractRouter {
         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);
+        await this.runNavigateHook.callPromise({ navigation });
     }
     async run(navigation) {
         this.currentNavigation = navigation;
@@ -210,12 +256,14 @@ class AbstractRouter {
             navigation,
             target,
         });
-        return this.onRedirect?.({
-            ...navigation,
-            from: navigation.to,
-            fromUrl: navigation.url,
-            to: null,
-            url: this.resolveUrl(target),
+        await this.redirectHook.callPromise({
+            navigation: {
+                ...navigation,
+                from: navigation.to,
+                fromUrl: navigation.url,
+                to: null,
+                url: this.resolveUrl(target),
+            },
         });
     }
     async notfound(navigation) {
@@ -223,7 +271,9 @@ class AbstractRouter {
             event: 'not-found',
             navigation,
         });
-        return this.onNotFound?.(navigation);
+        await this.notfoundHook.callPromise({
+            navigation,
+        });
     }
     async block(navigation) {
         logger.logger.debug({
@@ -232,7 +282,8 @@ class AbstractRouter {
         });
         this.currentNavigation = null;
         if (this.onBlock) {
-            return this.onBlock(navigation);
+            await this.blockHook.callPromise({ navigation });
+            return;
         }
         throw new Error('Navigation blocked');
     }
@@ -297,19 +348,8 @@ class AbstractRouter {
             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,
-            });
-        })));
+        const results = [];
+        await this.guards.callPromise({ navigation, allResults: results });
         logger.logger.debug({
             event: 'guards.done',
             navigation,
@@ -325,7 +365,20 @@ class AbstractRouter {
         }
     }
     registerGuard(guard) {
-        return utils.registerHook(this.guards, guard);
+        const untap = this.guards.tapPromise(guard.name ?? `guard-${this.guardsIndex++}`, async (_, { allResults, navigation }) => {
+            try {
+                const result = await guard(navigation);
+                allResults.push(result);
+            }
+            catch (error) {
+                logger.logger.warn({
+                    event: 'guard.error',
+                    error,
+                });
+                allResults.push(undefined);
+            }
+        });
+        return untap;
     }
     runSyncHooks(hookName, navigation) {
         logger.logger.debug({
@@ -333,18 +386,19 @@ class AbstractRouter {
             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) {
+        this.syncHooks.get(hookName).call({ navigation });
+        logger.logger.debug({
+            event: 'sync-hooks.done',
+            hookName,
+            navigation,
+        });
+    }
+    registerSyncHook(hookName, hook) {
+        const untap = this.syncHooks
+            .get(hookName)
+            .tap(hook.name ?? `sync-hook-${this.syncHooksIndex++}`, (_, { navigation }) => {
             try {
-                hook(navigation);
+                return hook(navigation);
             }
             catch (error) {
                 logger.logger.warn({
@@ -352,15 +406,8 @@ class AbstractRouter {
                     error,
                 });
             }
-        }
-        logger.logger.debug({
-            event: 'sync-hooks.done',
-            hookName,
-            navigation,
         });
-    }
-    registerSyncHook(hookName, hook) {
-        return utils.registerHook(this.syncHooks.get(hookName), hook);
+        return untap;
     }
     async runHooks(hookName, navigation) {
         logger.logger.debug({
@@ -368,26 +415,7 @@ class AbstractRouter {
             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;
-            }
-        })));
+        await this.hooks.get(hookName).callPromise({ navigation });
         logger.logger.debug({
             event: 'hooks.done',
             hookName,
@@ -395,7 +423,25 @@ class AbstractRouter {
         });
     }
     registerHook(hookName, hook) {
-        return utils.registerHook(this.hooks.get(hookName), hook);
+        const untap = this.hooks
+            .get(hookName)
+            .tapPromise(hook.name ?? `hook-${this.hooksIndex++}`, async (_, { navigation }) => {
+            try {
+                await 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;
+                }
+            }
+        });
+        return untap;
     }
     uuid() {
         return this.currentUuid++;

package/lib/router/client.browser.js

@@ -12,7 +12,7 @@ class ClientRouter extends AbstractRouter {
         this.history = new ClientHistory();
         this.history.listen(async ({ type, url, navigateState, replace, history }) => {
             const currentUrl = this.getCurrentUrl();
-            const { pathname, query } = this.resolveUrl({ url });
+            const { pathname, query, hash } = this.resolveUrl({ url });
             const isSameUrlNavigation = (currentUrl ? currentUrl.pathname : window.location.pathname) === pathname;
             const isUpdateCurrentRoute = type === 'updateCurrentRoute' || (!type && isSameUrlNavigation);
             //
@@ -37,6 +37,7 @@ class ClientRouter extends AbstractRouter {
                 await this.internalUpdateCurrentRoute({
                     params: route?.params,
                     query,
+                    hash,
                     replace,
                     navigateState,
                 }, { history });
@@ -120,7 +121,8 @@ class ClientRouter extends AbstractRouter {
         }
         else if (this.onBlock) {
             // last resort case for CSR fallback
-            return this.onBlock(navigation);
+            await this.blockHook.callPromise({ navigation });
+            return;
         }
         // prevent routing from any continues navigation returning promise which will be not resolved
         return new Promise(() => { });

package/lib/router/client.es.js

@@ -12,7 +12,7 @@ class ClientRouter extends AbstractRouter {
         this.history = new ClientHistory();
         this.history.listen(async ({ type, url, navigateState, replace, history }) => {
             const currentUrl = this.getCurrentUrl();
-            const { pathname, query } = this.resolveUrl({ url });
+            const { pathname, query, hash } = this.resolveUrl({ url });
             const isSameUrlNavigation = (currentUrl ? currentUrl.pathname : window.location.pathname) === pathname;
             const isUpdateCurrentRoute = type === 'updateCurrentRoute' || (!type && isSameUrlNavigation);
             //
@@ -37,6 +37,7 @@ class ClientRouter extends AbstractRouter {
                 await this.internalUpdateCurrentRoute({
                     params: route?.params,
                     query,
+                    hash,
                     replace,
                     navigateState,
                 }, { history });
@@ -120,7 +121,8 @@ class ClientRouter extends AbstractRouter {
         }
         else if (this.onBlock) {
             // last resort case for CSR fallback
-            return this.onBlock(navigation);
+            await this.blockHook.callPromise({ navigation });
+            return;
         }
         // prevent routing from any continues navigation returning promise which will be not resolved
         return new Promise(() => { });

package/lib/router/client.js

@@ -16,7 +16,7 @@ class ClientRouter extends abstract.AbstractRouter {
         this.history = new client.ClientHistory();
         this.history.listen(async ({ type, url, navigateState, replace, history }) => {
             const currentUrl = this.getCurrentUrl();
-            const { pathname, query } = this.resolveUrl({ url });
+            const { pathname, query, hash } = this.resolveUrl({ url });
             const isSameUrlNavigation = (currentUrl ? currentUrl.pathname : window.location.pathname) === pathname;
             const isUpdateCurrentRoute = type === 'updateCurrentRoute' || (!type && isSameUrlNavigation);
             //
@@ -41,6 +41,7 @@ class ClientRouter extends abstract.AbstractRouter {
                 await this.internalUpdateCurrentRoute({
                     params: route?.params,
                     query,
+                    hash,
                     replace,
                     navigateState,
                 }, { history });
@@ -124,7 +125,8 @@ class ClientRouter extends abstract.AbstractRouter {
         }
         else if (this.onBlock) {
             // last resort case for CSR fallback
-            return this.onBlock(navigation);
+            await this.blockHook.callPromise({ navigation });
+            return;
         }
         // prevent routing from any continues navigation returning promise which will be not resolved
         return new Promise(() => { });

package/lib/router/server.es.js

@@ -39,13 +39,15 @@ class Router extends AbstractRouter {
             target,
         });
         this.blocked = true;
-        return this.onRedirect({
-            ...navigation,
-            from: navigation.to,
-            fromUrl: navigation.url,
-            to: null,
-            url: this.resolveUrl(target),
-            code: target.code,
+        await this.redirectHook.callPromise({
+            navigation: {
+                ...navigation,
+                from: navigation.to,
+                fromUrl: navigation.url,
+                to: null,
+                url: this.resolveUrl(target),
+                code: target.code,
+            },
         });
     }
     async notfound(navigation) {

package/lib/router/server.js

@@ -43,13 +43,15 @@ class Router extends abstract.AbstractRouter {
             target,
         });
         this.blocked = true;
-        return this.onRedirect({
-            ...navigation,
-            from: navigation.to,
-            fromUrl: navigation.url,
-            to: null,
-            url: this.resolveUrl(target),
-            code: target.code,
+        await this.redirectHook.callPromise({
+            navigation: {
+                ...navigation,
+                from: navigation.to,
+                fromUrl: navigation.url,
+                to: null,
+                url: this.resolveUrl(target),
+                code: target.code,
+            },
         });
     }
     async notfound(navigation) {

package/lib/types.d.ts

@@ -1,4 +1,5 @@
 import type { Url, Query } from '@tinkoff/url';
+import { AbstractRouter } from './router/abstract';
 export type Params = Record<string, string>;
 export interface RouteConfig {
     [key: string]: any;
@@ -63,4 +64,7 @@ export type NavigationHook = (navigation: Navigation) => Promise<void>;
 export type NavigationSyncHook = (navigation: Navigation) => void;
 export type HookName = 'beforeResolve' | 'beforeNavigate' | 'afterNavigate' | 'beforeUpdateCurrent' | 'afterUpdateCurrent';
 export type SyncHookName = 'change';
+export type RouterPlugin = {
+    apply(router: AbstractRouter): void;
+};
 //# sourceMappingURL=types.d.ts.map

package/lib/utils.browser.js

@@ -25,11 +25,5 @@ const makeNavigateOptions = (options) => {
     }
     return options;
 };
-const registerHook = (hooksSet, hook) => {
-    hooksSet.add(hook);
-    return () => {
-        hooksSet.delete(hook);
-    };
-};
 
-export { isFilePath, isSameHost, makeNavigateOptions, normalizeManySlashes, normalizeTrailingSlash, registerHook };
+export { isFilePath, isSameHost, makeNavigateOptions, normalizeManySlashes, normalizeTrailingSlash };

package/lib/utils.d.ts

@@ -1,9 +1,8 @@
 import type { Url } from '@tinkoff/url';
-import type { NavigateOptions, NavigationHook, NavigationSyncHook, NavigationGuard } from './types';
+import type { NavigateOptions } from './types';
 export declare const isFilePath: (pathname: string) => boolean;
 export declare const normalizeTrailingSlash: (pathname: string, trailingSlash?: boolean) => string;
 export declare const normalizeManySlashes: (hrefOrPath: string) => string;
 export declare const isSameHost: import("@tinkoff/utils/typings/types").Func<true> | ((url: Url | URL) => boolean);
 export declare const makeNavigateOptions: (options: string | NavigateOptions) => NavigateOptions;
-export declare const registerHook: <T extends NavigationHook | NavigationSyncHook | NavigationGuard>(hooksSet: Set<T>, hook: T) => () => void;
 //# sourceMappingURL=utils.d.ts.map

package/lib/utils.es.js

@@ -25,11 +25,5 @@ const makeNavigateOptions = (options) => {
     }
     return options;
 };
-const registerHook = (hooksSet, hook) => {
-    hooksSet.add(hook);
-    return () => {
-        hooksSet.delete(hook);
-    };
-};
 
-export { isFilePath, isSameHost, makeNavigateOptions, normalizeManySlashes, normalizeTrailingSlash, registerHook };
+export { isFilePath, isSameHost, makeNavigateOptions, normalizeManySlashes, normalizeTrailingSlash };

package/lib/utils.js

@@ -33,16 +33,9 @@ const makeNavigateOptions = (options) => {
     }
     return options;
 };
-const registerHook = (hooksSet, hook) => {
-    hooksSet.add(hook);
-    return () => {
-        hooksSet.delete(hook);
-    };
-};
 
 exports.isFilePath = isFilePath;
 exports.isSameHost = isSameHost;
 exports.makeNavigateOptions = makeNavigateOptions;
 exports.normalizeManySlashes = normalizeManySlashes;
 exports.normalizeTrailingSlash = normalizeTrailingSlash;
-exports.registerHook = registerHook;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tinkoff/router",
-  "version": "0.5.65",
+  "version": "0.5.67",
   "description": "router",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
@@ -24,10 +24,11 @@
     "@tinkoff/react-hooks": "0.4.2",
     "@tinkoff/url": "0.11.2",
     "@tinkoff/utils": "^2.1.2",
+    "@tinkoff/hook-runner": "0.7.3",
     "use-sync-external-store": "^1.2.0"
   },
   "peerDependencies": {
-    "@tramvai/core": "5.22.0",
+    "@tramvai/core": "5.24.0",
     "react": ">=16.14.0",
     "tslib": "^2.4.0"
   },