@tinkoff/router 0.7.8 → 0.7.10

package/lib/router/abstract.browser.js

@@ -19,6 +19,7 @@ class AbstractRouter {
     guards;
     hooks;
     syncHooks;
+    internalHooks;
     navigateHook;
     updateHook;
     runNavigateHook;
@@ -98,6 +99,16 @@ class AbstractRouter {
         this.blockHook.tapPromise('router', async (_, { navigation }) => {
             await this.onBlock?.(navigation);
         });
+        this.internalHooks = {
+            'router:resolve-route': this.hooksFactory.createSync('router:resolve-route'),
+            'router:resolve-url': this.hooksFactory.createSync('router:resolve-url'),
+        };
+        this.internalHooks['router:resolve-route'].tap('router', (_, args) => {
+            return this._resolveRoute(...args);
+        });
+        this.internalHooks['router:resolve-url'].tap('router', (_, navigation) => {
+            return this._resolveUrl(navigation);
+        });
         this.plugins.forEach((plugin) => {
             plugin.apply(this);
         });
@@ -311,50 +322,11 @@ class AbstractRouter {
         }
         return normalized;
     }
-    resolveUrl({ url, query = {}, params, preserveQuery, hash }) {
-        const currentRoute = this.getCurrentRoute();
-        const currentUrl = this.getCurrentUrl();
-        const resultUrl = url ? rawResolveUrl(currentUrl?.href ?? '', 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 ?? resultUrl.hash,
-        }));
+    resolveUrl(navigation) {
+        return this.internalHooks['router:resolve-url'].call(navigation);
     }
-    resolveRoute({ url, params, navigateState }, { wildcard } = {}) {
-        let route = url ? this.tree?.getRoute(url.pathname) : this.getCurrentRoute();
-        if (wildcard && !route && url) {
-            // if ordinary route not found look for a wildcard route
-            route = this.tree?.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,
-        };
+    resolveRoute(...args) {
+        return this.internalHooks['router:resolve-route'].call(args);
     }
     async runGuards(navigation) {
         logger.debug({
@@ -460,6 +432,51 @@ class AbstractRouter {
     uuid() {
         return this.currentUuid++;
     }
+    _resolveUrl({ url, query = {}, params, preserveQuery, hash }) {
+        const currentRoute = this.getCurrentRoute();
+        const currentUrl = this.getCurrentUrl();
+        const resultUrl = url ? rawResolveUrl(currentUrl?.href ?? '', 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 ?? resultUrl.hash,
+        }));
+    }
+    _resolveRoute({ url, params, navigateState }, { wildcard } = {}) {
+        let route = url ? this.tree?.getRoute(url.pathname) : this.getCurrentRoute();
+        if (wildcard && !route && url) {
+            // if ordinary route not found look for a wildcard route
+            route = this.tree?.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,
+        };
+    }
 }
 
 export { AbstractRouter };

package/lib/router/abstract.d.ts

@@ -1,7 +1,7 @@
 import type { Url } from '@tinkoff/url';
 import type { AsyncParallelTapableHookInstance, AsyncTapableHookInstance, SyncTapableHookInstance } from '@tinkoff/hook-runner';
 import { TapableHooks } from '@tinkoff/hook-runner';
-import { Route, NavigateOptions, UpdateCurrentRouteOptions, Navigation, NavigationGuard, NavigationHook, NavigationSyncHook, HookName, Params, SyncHookName, HistoryOptions, RouterPlugin, BackNavigationType } from '../types';
+import { Route, NavigateOptions, UpdateCurrentRouteOptions, Navigation, NavigationGuard, NavigationHook, NavigationSyncHook, HookName, Params, SyncHookName, HistoryOptions, RouterPlugin, BackNavigationType, NavigationRoute } from '../types';
 import type { History } from '../history/base';
 import type { RouteTree } from '../tree/tree';
 export interface Options {
@@ -48,6 +48,10 @@ export declare abstract class AbstractRouter {
     readonly syncHooks: Map<SyncHookName, SyncTapableHookInstance<{
         navigation: Navigation;
     }>>;
+    readonly internalHooks: {
+        'router:resolve-route': SyncTapableHookInstance<Parameters<AbstractRouter['_resolveRoute']>, NavigationRoute | undefined>;
+        'router:resolve-url': SyncTapableHookInstance<NavigateOptions, Url>;
+    };
     readonly navigateHook: AsyncTapableHookInstance<{
         navigateOptions: NavigateOptions | string;
     }>;
@@ -80,9 +84,9 @@ export declare abstract class AbstractRouter {
     protected onNotFound?: NavigationHook;
     protected onBlock?: NavigationHook;
     start(): Promise<void>;
-    getCurrentRoute(): import("../types").NavigationRoute;
+    getCurrentRoute(): NavigationRoute;
     getCurrentUrl(): Url;
-    getLastRoute(): import("../types").NavigationRoute;
+    getLastRoute(): NavigationRoute;
     getLastUrl(): Url;
     protected commitNavigation(navigation: Navigation): void;
     updateCurrentRoute(updateRouteOptions: UpdateCurrentRouteOptions): Promise<void>;
@@ -92,7 +96,7 @@ export declare abstract class AbstractRouter {
     protected internalNavigate(navigateOptions: NavigateOptions, { history, redirect }: InternalOptions): Promise<void>;
     protected runNavigate(navigation: Navigation): Promise<void>;
     protected run(navigation: Navigation): Promise<void>;
-    resolve(resolveOptions: NavigateOptions | string, options?: Parameters<AbstractRouter['resolveRoute']>[1]): import("../types").NavigationRoute;
+    resolve(resolveOptions: NavigateOptions | string, options?: Parameters<AbstractRouter['resolveRoute']>[1]): NavigationRoute;
     back(options?: HistoryOptions): Promise<void>;
     forward(): Promise<void>;
     go(to: number, options?: HistoryOptions): Promise<void>;
@@ -106,14 +110,8 @@ export declare abstract class AbstractRouter {
     protected block(navigation: Navigation): Promise<void>;
     cancel(_?: Navigation): Navigation | void;
     protected normalizePathname(pathname?: string): string;
-    protected resolveUrl({ url, query, params, preserveQuery, hash }: NavigateOptions): Url;
-    protected resolveRoute({ url, params, navigateState }: {
-        url?: Url;
-        params?: Params;
-        navigateState?: any;
-    }, { wildcard }?: {
-        wildcard?: boolean;
-    }): import("../types").NavigationRoute;
+    protected resolveUrl(navigation: NavigateOptions): Url;
+    protected resolveRoute(...args: Parameters<AbstractRouter['_resolveRoute']>): NavigationRoute;
     protected runGuards(navigation: Navigation): Promise<void>;
     registerGuard(guard: NavigationGuard): import("@tinkoff/hook-runner/lib/types").UntapCallback;
     protected runSyncHooks(hookName: SyncHookName, navigation: Navigation): void;
@@ -121,6 +119,14 @@ export declare abstract class AbstractRouter {
     protected runHooks(hookName: HookName, navigation: Navigation): Promise<void>;
     registerHook(hookName: HookName, hook: NavigationHook): import("@tinkoff/hook-runner/lib/types").UntapCallback;
     private uuid;
+    protected _resolveUrl({ url, query, params, preserveQuery, hash }: NavigateOptions): Url;
+    protected _resolveRoute({ url, params, navigateState }: {
+        url?: Url;
+        params?: Params;
+        navigateState?: any;
+    }, { wildcard }?: {
+        wildcard?: boolean;
+    }): NavigationRoute;
 }
 export {};
 //# sourceMappingURL=abstract.d.ts.map

package/lib/router/abstract.es.js

@@ -19,6 +19,7 @@ class AbstractRouter {
     guards;
     hooks;
     syncHooks;
+    internalHooks;
     navigateHook;
     updateHook;
     runNavigateHook;
@@ -98,6 +99,16 @@ class AbstractRouter {
         this.blockHook.tapPromise('router', async (_, { navigation }) => {
             await this.onBlock?.(navigation);
         });
+        this.internalHooks = {
+            'router:resolve-route': this.hooksFactory.createSync('router:resolve-route'),
+            'router:resolve-url': this.hooksFactory.createSync('router:resolve-url'),
+        };
+        this.internalHooks['router:resolve-route'].tap('router', (_, args) => {
+            return this._resolveRoute(...args);
+        });
+        this.internalHooks['router:resolve-url'].tap('router', (_, navigation) => {
+            return this._resolveUrl(navigation);
+        });
         this.plugins.forEach((plugin) => {
             plugin.apply(this);
         });
@@ -311,50 +322,11 @@ class AbstractRouter {
         }
         return normalized;
     }
-    resolveUrl({ url, query = {}, params, preserveQuery, hash }) {
-        const currentRoute = this.getCurrentRoute();
-        const currentUrl = this.getCurrentUrl();
-        const resultUrl = url ? rawResolveUrl(currentUrl?.href ?? '', 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 ?? resultUrl.hash,
-        }));
+    resolveUrl(navigation) {
+        return this.internalHooks['router:resolve-url'].call(navigation);
     }
-    resolveRoute({ url, params, navigateState }, { wildcard } = {}) {
-        let route = url ? this.tree?.getRoute(url.pathname) : this.getCurrentRoute();
-        if (wildcard && !route && url) {
-            // if ordinary route not found look for a wildcard route
-            route = this.tree?.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,
-        };
+    resolveRoute(...args) {
+        return this.internalHooks['router:resolve-route'].call(args);
     }
     async runGuards(navigation) {
         logger.debug({
@@ -460,6 +432,51 @@ class AbstractRouter {
     uuid() {
         return this.currentUuid++;
     }
+    _resolveUrl({ url, query = {}, params, preserveQuery, hash }) {
+        const currentRoute = this.getCurrentRoute();
+        const currentUrl = this.getCurrentUrl();
+        const resultUrl = url ? rawResolveUrl(currentUrl?.href ?? '', 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 ?? resultUrl.hash,
+        }));
+    }
+    _resolveRoute({ url, params, navigateState }, { wildcard } = {}) {
+        let route = url ? this.tree?.getRoute(url.pathname) : this.getCurrentRoute();
+        if (wildcard && !route && url) {
+            // if ordinary route not found look for a wildcard route
+            route = this.tree?.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,
+        };
+    }
 }
 
 export { AbstractRouter };

package/lib/router/abstract.js

@@ -28,6 +28,7 @@ class AbstractRouter {
     guards;
     hooks;
     syncHooks;
+    internalHooks;
     navigateHook;
     updateHook;
     runNavigateHook;
@@ -107,6 +108,16 @@ class AbstractRouter {
         this.blockHook.tapPromise('router', async (_, { navigation }) => {
             await this.onBlock?.(navigation);
         });
+        this.internalHooks = {
+            'router:resolve-route': this.hooksFactory.createSync('router:resolve-route'),
+            'router:resolve-url': this.hooksFactory.createSync('router:resolve-url'),
+        };
+        this.internalHooks['router:resolve-route'].tap('router', (_, args) => {
+            return this._resolveRoute(...args);
+        });
+        this.internalHooks['router:resolve-url'].tap('router', (_, navigation) => {
+            return this._resolveUrl(navigation);
+        });
         this.plugins.forEach((plugin) => {
             plugin.apply(this);
         });
@@ -320,50 +331,11 @@ class AbstractRouter {
         }
         return normalized;
     }
-    resolveUrl({ url: url$1, query = {}, params, preserveQuery, hash }) {
-        const currentRoute = this.getCurrentRoute();
-        const currentUrl = this.getCurrentUrl();
-        const resultUrl = url$1 ? url.rawResolveUrl(currentUrl?.href ?? '', url$1) : url.rawParse(currentUrl.href);
-        let { pathname } = resultUrl;
-        if (params) {
-            if (url$1) {
-                pathname = utils$1.makePath(resultUrl.pathname, params);
-            }
-            else if (currentRoute) {
-                pathname = utils$1.makePath(currentRoute.path, { ...currentRoute.params, ...params });
-            }
-        }
-        if (utils.isSameHost(resultUrl)) {
-            pathname = this.normalizePathname(pathname);
-        }
-        return url.convertRawUrl(url.rawAssignUrl(resultUrl, {
-            pathname,
-            search: url$1 ? resultUrl.search : '',
-            query: {
-                ...(preserveQuery ? this.getCurrentUrl().query : {}),
-                ...query,
-            },
-            hash: hash ?? resultUrl.hash,
-        }));
+    resolveUrl(navigation) {
+        return this.internalHooks['router:resolve-url'].call(navigation);
     }
-    resolveRoute({ url, params, navigateState }, { wildcard } = {}) {
-        let route = url ? this.tree?.getRoute(url.pathname) : this.getCurrentRoute();
-        if (wildcard && !route && url) {
-            // if ordinary route not found look for a wildcard route
-            route = this.tree?.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,
-        };
+    resolveRoute(...args) {
+        return this.internalHooks['router:resolve-route'].call(args);
     }
     async runGuards(navigation) {
         logger.logger.debug({
@@ -469,6 +441,51 @@ class AbstractRouter {
     uuid() {
         return this.currentUuid++;
     }
+    _resolveUrl({ url: url$1, query = {}, params, preserveQuery, hash }) {
+        const currentRoute = this.getCurrentRoute();
+        const currentUrl = this.getCurrentUrl();
+        const resultUrl = url$1 ? url.rawResolveUrl(currentUrl?.href ?? '', url$1) : url.rawParse(currentUrl.href);
+        let { pathname } = resultUrl;
+        if (params) {
+            if (url$1) {
+                pathname = utils$1.makePath(resultUrl.pathname, params);
+            }
+            else if (currentRoute) {
+                pathname = utils$1.makePath(currentRoute.path, { ...currentRoute.params, ...params });
+            }
+        }
+        if (utils.isSameHost(resultUrl)) {
+            pathname = this.normalizePathname(pathname);
+        }
+        return url.convertRawUrl(url.rawAssignUrl(resultUrl, {
+            pathname,
+            search: url$1 ? resultUrl.search : '',
+            query: {
+                ...(preserveQuery ? this.getCurrentUrl().query : {}),
+                ...query,
+            },
+            hash: hash ?? resultUrl.hash,
+        }));
+    }
+    _resolveRoute({ url, params, navigateState }, { wildcard } = {}) {
+        let route = url ? this.tree?.getRoute(url.pathname) : this.getCurrentRoute();
+        if (wildcard && !route && url) {
+            // if ordinary route not found look for a wildcard route
+            route = this.tree?.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,
+        };
+    }
 }
 
 exports.AbstractRouter = AbstractRouter;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tinkoff/router",
-  "version": "0.7.8",
+  "version": "0.7.10",
   "description": "router",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
@@ -28,7 +28,7 @@
     "use-sync-external-store": "^1.4.0"
   },
   "peerDependencies": {
-    "@tramvai/core": "7.2.3",
+    "@tramvai/core": "7.3.1",
     "react": ">=16.14.0",
     "tslib": "^2.4.0"
   },