@tinkoff/router 0.5.116 → 0.5.198

package/lib/router/abstract.browser.js

@@ -7,16 +7,33 @@ import { logger } from '../logger.browser.js';
 import { makeNavigateOptions, normalizeManySlashes, normalizeTrailingSlash, isSameHost } from '../utils.browser.js';
 
 class AbstractRouter {
+    started = false;
+    trailingSlash = false;
+    strictTrailingSlash = true;
+    viewTransitionsEnabled = false;
+    mergeSlashes = false;
+    currentNavigation;
+    lastNavigation;
+    history;
+    tree;
+    guards;
+    hooks;
+    syncHooks;
+    navigateHook;
+    updateHook;
+    runNavigateHook;
+    runUpdateHook;
+    redirectHook;
+    notfoundHook;
+    blockHook;
+    hooksFactory;
+    plugins;
+    currentUuid;
+    hooksIndex = 0;
+    syncHooksIndex = 0;
+    guardsIndex = 0;
     // 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;
@@ -85,6 +102,9 @@ class AbstractRouter {
             plugin.apply(this);
         });
     }
+    onRedirect;
+    onNotFound;
+    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() {
@@ -157,7 +177,7 @@ class AbstractRouter {
         await this.navigateHook.callPromise({ navigateOptions });
     }
     async internalNavigate(navigateOptions, { history, redirect }) {
-        const { url, replace, params, navigateState, code, viewTransition } = navigateOptions;
+        const { url, replace, params, navigateState, code, isBack, viewTransition, viewTransitionTypes, hasUAVisualTransition, } = navigateOptions;
         const prevNavigation = redirect
             ? this.lastNavigation
             : (this.currentNavigation ?? this.lastNavigation);
@@ -166,7 +186,7 @@ class AbstractRouter {
         }
         const resolvedUrl = this.resolveUrl(navigateOptions);
         const { to: from, url: fromUrl } = prevNavigation ?? {};
-        const redirectFrom = redirect ? this.currentNavigation.to : undefined;
+        const redirectFrom = redirect ? this.getCurrentRoute() : undefined;
         let navigation = {
             type: 'navigate',
             from,
@@ -178,10 +198,13 @@ class AbstractRouter {
             code,
             redirect,
             redirectFrom,
+            isBack,
+            hasUAVisualTransition,
             key: this.uuid(),
         };
-        if (this.viewTransitionsEnabled && viewTransition !== undefined) {
+        if (this.viewTransitionsEnabled && viewTransition !== undefined && !hasUAVisualTransition) {
             navigation.viewTransition = viewTransition;
+            navigation.viewTransitionTypes = viewTransitionTypes;
         }
         await this.runHooks('beforeResolve', navigation);
         const to = this.resolveRoute({ url: resolvedUrl, params, navigateState }, { wildcard: true });
@@ -238,6 +261,7 @@ class AbstractRouter {
     async rehydrate(navigation) {
         throw new Error('Not implemented');
     }
+    unsubscribe() { }
     addRoute(route) {
         this.tree?.addRoute(route);
     }
@@ -356,10 +380,11 @@ class AbstractRouter {
         }
     }
     registerGuard(guard) {
-        const untap = this.guards.tapPromise(guard.name ?? `guard-${this.guardsIndex++}`, async (_, { allResults, navigation }) => {
+        const index = this.guardsIndex++;
+        const untap = this.guards.tapPromise(guard.name ?? `guard-${index}`, async (_, { allResults, navigation }) => {
             try {
                 const result = await guard(navigation);
-                allResults.push(result);
+                allResults[index] = result;
             }
             catch (error) {
                 logger.warn({

package/lib/router/abstract.d.ts

@@ -98,6 +98,7 @@ export declare abstract class AbstractRouter {
     isNavigating(): boolean;
     dehydrate(): Promise<Navigation>;
     rehydrate(navigation: Partial<Navigation>): Promise<void>;
+    unsubscribe(): void;
     addRoute(route: Route): void;
     protected redirect(navigation: Navigation, target: NavigateOptions): Promise<void>;
     protected notfound(navigation: Navigation): Promise<void>;

package/lib/router/abstract.es.js

@@ -7,16 +7,33 @@ import { logger } from '../logger.es.js';
 import { makeNavigateOptions, normalizeManySlashes, normalizeTrailingSlash, isSameHost } from '../utils.es.js';
 
 class AbstractRouter {
+    started = false;
+    trailingSlash = false;
+    strictTrailingSlash = true;
+    viewTransitionsEnabled = false;
+    mergeSlashes = false;
+    currentNavigation;
+    lastNavigation;
+    history;
+    tree;
+    guards;
+    hooks;
+    syncHooks;
+    navigateHook;
+    updateHook;
+    runNavigateHook;
+    runUpdateHook;
+    redirectHook;
+    notfoundHook;
+    blockHook;
+    hooksFactory;
+    plugins;
+    currentUuid;
+    hooksIndex = 0;
+    syncHooksIndex = 0;
+    guardsIndex = 0;
     // 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;
@@ -85,6 +102,9 @@ class AbstractRouter {
             plugin.apply(this);
         });
     }
+    onRedirect;
+    onNotFound;
+    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() {
@@ -157,7 +177,7 @@ class AbstractRouter {
         await this.navigateHook.callPromise({ navigateOptions });
     }
     async internalNavigate(navigateOptions, { history, redirect }) {
-        const { url, replace, params, navigateState, code, viewTransition } = navigateOptions;
+        const { url, replace, params, navigateState, code, isBack, viewTransition, viewTransitionTypes, hasUAVisualTransition, } = navigateOptions;
         const prevNavigation = redirect
             ? this.lastNavigation
             : (this.currentNavigation ?? this.lastNavigation);
@@ -166,7 +186,7 @@ class AbstractRouter {
         }
         const resolvedUrl = this.resolveUrl(navigateOptions);
         const { to: from, url: fromUrl } = prevNavigation ?? {};
-        const redirectFrom = redirect ? this.currentNavigation.to : undefined;
+        const redirectFrom = redirect ? this.getCurrentRoute() : undefined;
         let navigation = {
             type: 'navigate',
             from,
@@ -178,10 +198,13 @@ class AbstractRouter {
             code,
             redirect,
             redirectFrom,
+            isBack,
+            hasUAVisualTransition,
             key: this.uuid(),
         };
-        if (this.viewTransitionsEnabled && viewTransition !== undefined) {
+        if (this.viewTransitionsEnabled && viewTransition !== undefined && !hasUAVisualTransition) {
             navigation.viewTransition = viewTransition;
+            navigation.viewTransitionTypes = viewTransitionTypes;
         }
         await this.runHooks('beforeResolve', navigation);
         const to = this.resolveRoute({ url: resolvedUrl, params, navigateState }, { wildcard: true });
@@ -238,6 +261,7 @@ class AbstractRouter {
     async rehydrate(navigation) {
         throw new Error('Not implemented');
     }
+    unsubscribe() { }
     addRoute(route) {
         this.tree?.addRoute(route);
     }
@@ -356,10 +380,11 @@ class AbstractRouter {
         }
     }
     registerGuard(guard) {
-        const untap = this.guards.tapPromise(guard.name ?? `guard-${this.guardsIndex++}`, async (_, { allResults, navigation }) => {
+        const index = this.guardsIndex++;
+        const untap = this.guards.tapPromise(guard.name ?? `guard-${index}`, async (_, { allResults, navigation }) => {
             try {
                 const result = await guard(navigation);
-                allResults.push(result);
+                allResults[index] = result;
             }
             catch (error) {
                 logger.warn({

package/lib/router/abstract.js

@@ -16,16 +16,33 @@ var isString__default = /*#__PURE__*/_interopDefaultLegacy(isString);
 var isObject__default = /*#__PURE__*/_interopDefaultLegacy(isObject);
 
 class AbstractRouter {
+    started = false;
+    trailingSlash = false;
+    strictTrailingSlash = true;
+    viewTransitionsEnabled = false;
+    mergeSlashes = false;
+    currentNavigation;
+    lastNavigation;
+    history;
+    tree;
+    guards;
+    hooks;
+    syncHooks;
+    navigateHook;
+    updateHook;
+    runNavigateHook;
+    runUpdateHook;
+    redirectHook;
+    notfoundHook;
+    blockHook;
+    hooksFactory;
+    plugins;
+    currentUuid;
+    hooksIndex = 0;
+    syncHooksIndex = 0;
+    guardsIndex = 0;
     // 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;
@@ -94,6 +111,9 @@ class AbstractRouter {
             plugin.apply(this);
         });
     }
+    onRedirect;
+    onNotFound;
+    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() {
@@ -166,7 +186,7 @@ class AbstractRouter {
         await this.navigateHook.callPromise({ navigateOptions });
     }
     async internalNavigate(navigateOptions, { history, redirect }) {
-        const { url, replace, params, navigateState, code, viewTransition } = navigateOptions;
+        const { url, replace, params, navigateState, code, isBack, viewTransition, viewTransitionTypes, hasUAVisualTransition, } = navigateOptions;
         const prevNavigation = redirect
             ? this.lastNavigation
             : (this.currentNavigation ?? this.lastNavigation);
@@ -175,7 +195,7 @@ class AbstractRouter {
         }
         const resolvedUrl = this.resolveUrl(navigateOptions);
         const { to: from, url: fromUrl } = prevNavigation ?? {};
-        const redirectFrom = redirect ? this.currentNavigation.to : undefined;
+        const redirectFrom = redirect ? this.getCurrentRoute() : undefined;
         let navigation = {
             type: 'navigate',
             from,
@@ -187,10 +207,13 @@ class AbstractRouter {
             code,
             redirect,
             redirectFrom,
+            isBack,
+            hasUAVisualTransition,
             key: this.uuid(),
         };
-        if (this.viewTransitionsEnabled && viewTransition !== undefined) {
+        if (this.viewTransitionsEnabled && viewTransition !== undefined && !hasUAVisualTransition) {
             navigation.viewTransition = viewTransition;
+            navigation.viewTransitionTypes = viewTransitionTypes;
         }
         await this.runHooks('beforeResolve', navigation);
         const to = this.resolveRoute({ url: resolvedUrl, params, navigateState }, { wildcard: true });
@@ -247,6 +270,7 @@ class AbstractRouter {
     async rehydrate(navigation) {
         throw new Error('Not implemented');
     }
+    unsubscribe() { }
     addRoute(route) {
         this.tree?.addRoute(route);
     }
@@ -365,10 +389,11 @@ class AbstractRouter {
         }
     }
     registerGuard(guard) {
-        const untap = this.guards.tapPromise(guard.name ?? `guard-${this.guardsIndex++}`, async (_, { allResults, navigation }) => {
+        const index = this.guardsIndex++;
+        const untap = this.guards.tapPromise(guard.name ?? `guard-${index}`, async (_, { allResults, navigation }) => {
             try {
                 const result = await guard(navigation);
-                allResults.push(result);
+                allResults[index] = result;
             }
             catch (error) {
                 logger.logger.warn({

package/lib/router/browser.browser.js

@@ -1,10 +1,17 @@
 import { ClientRouter } from './client.browser.js';
 import { logger } from '../logger.browser.js';
 import { RouteTree } from '../tree/tree.browser.js';
+import { NAVIGATION_TYPE } from './constants.browser.js';
 
 const DELAY_CHECK_INTERVAL = 50;
 const APPLIED_VIEW_TRANSITIONS_KEY = '_t_view_transitions';
 class Router extends ClientRouter {
+    delayedNavigation;
+    delayedPromise;
+    delayedResolve;
+    delayedReject;
+    // Store applied view transitions, so we can apply them on back navigations
+    appliedViewTransitions;
     constructor(options) {
         super(options);
         this.tree = new RouteTree(options.routes);
@@ -29,8 +36,22 @@ class Router extends ClientRouter {
     }
     async run(payload) {
         const navigation = { ...payload };
-        if (this.viewTransitionsEnabled) {
-            navigation.viewTransition = this.shouldApplyViewTransition(payload);
+        const to = (navigation.to.redirect !== undefined
+            ? this.resolve(navigation.to.redirect)?.actualPath
+            : navigation.to?.actualPath) ?? '';
+        const from = navigation.from?.actualPath ?? '';
+        if (this.viewTransitionsEnabled && to !== from && !navigation.hasUAVisualTransition) {
+            navigation.viewTransition = this.shouldApplyViewTransition(navigation, to);
+            const hasNavigationType = !!navigation.viewTransitionTypes &&
+                navigation.viewTransitionTypes.some((type) => Object.values(NAVIGATION_TYPE).includes(type));
+            // add a navigation type only if it has not been provided
+            if (navigation.viewTransition && !hasNavigationType) {
+                const navigationType = this.getNavigationType(navigation);
+                // add a navigation type to transition types
+                navigation.viewTransitionTypes = navigation.viewTransitionTypes
+                    ? [...(navigation.viewTransitionTypes ?? []), navigationType]
+                    : [navigationType];
+            }
         }
         // if router is not started yet delay current navigation without blocking promise resolving
         if (!this.started) {
@@ -169,39 +190,59 @@ class Router extends ClientRouter {
             this.delayedReject = null;
         });
     }
-    shouldApplyViewTransition(navigation) {
-        const from = navigation.from.actualPath;
-        const to = navigation.to.redirect !== undefined
-            ? this.resolve(navigation.to.redirect)?.actualPath
-            : navigation.to?.actualPath;
-        // If View Transition enabled to current navigation, save it
-        if (navigation.viewTransition) {
-            const toPaths = this.appliedViewTransitions.get(from);
-            if (this.appliedViewTransitions.get(from)) {
-                toPaths.add(to);
-            }
-            else {
-                this.appliedViewTransitions.set(from, new Set([to]));
-            }
+    getNavigationType(navigation) {
+        // if it is back navigation
+        if (navigation.history && navigation.isBack) {
+            return NAVIGATION_TYPE.BACK;
+        }
+        return NAVIGATION_TYPE.FORWARD;
+    }
+    shouldApplyViewTransition(navigation, to) {
+        const from = navigation.from?.actualPath ?? '';
+        const historyState = this.history.getCurrentState();
+        if (!historyState) {
+            return false;
+        }
+        const historyIndex = historyState.index;
+        const prevTransitionFrom = this.getPrevTransition(navigation);
+        // handle back navigation when prev navigation was with VT enabled
+        if (navigation.history && prevTransitionFrom === to) {
             return true;
         }
-        const priorPaths = this.appliedViewTransitions.get(from);
-        // If we were on the route with view transition previously,
-        // then there must be back navigation with view transition also
-        if (priorPaths !== undefined && priorPaths.has(to)) {
+        if (navigation.viewTransition) {
+            // add transition except history navigations with VT enabled
+            !navigation.history && this.appliedViewTransitions.set(historyIndex, from);
             return true;
         }
-        // If we don't have a previous forward navigation, assume we are
-        // going back from the new route and enable view transition if it
-        // was previously enabled
-        return this.appliedViewTransitions.has(to);
+        // handle forward navigation
+        if (navigation.history && !navigation.isBack) {
+            // returns true if prev navigation was with VT enabled
+            return !!prevTransitionFrom;
+        }
+        // if we have forward navigation without VT enabled and stored val for this index
+        if (!navigation.history && this.appliedViewTransitions.has(historyIndex)) {
+            this.appliedViewTransitions.delete(historyIndex);
+        }
+        return false;
+    }
+    getPrevTransition(navigation) {
+        const historyState = this.history.getCurrentState();
+        if (!historyState) {
+            return false;
+        }
+        const historyIndex = historyState.index;
+        const index = navigation.history && navigation.isBack ? historyIndex : historyIndex - 1;
+        return this.appliedViewTransitions.get(index);
     }
     restoreAppliedViewTransitions() {
         try {
             const valueFromStorage = sessionStorage.getItem(APPLIED_VIEW_TRANSITIONS_KEY);
             if (valueFromStorage !== null) {
                 const parsedValue = JSON.parse(valueFromStorage);
-                this.appliedViewTransitions = new Map(Object.entries(parsedValue).map(([key, value]) => [key, new Set(value)]));
+                this.appliedViewTransitions = new Map(Object.entries(parsedValue).map(([key, value]) => [
+                    Number.parseInt(key, 10),
+                    value,
+                ]));
                 return;
             }
             this.appliedViewTransitions = new Map();
@@ -215,7 +256,7 @@ class Router extends ClientRouter {
             try {
                 const valueToSave = {};
                 for (const [key, value] of this.appliedViewTransitions) {
-                    valueToSave[key] = [...value];
+                    valueToSave[key] = value;
                 }
                 sessionStorage.setItem(APPLIED_VIEW_TRANSITIONS_KEY, JSON.stringify(valueToSave));
             }

package/lib/router/browser.d.ts

@@ -1,6 +1,6 @@
 import type { Options } from './abstract';
 import { ClientRouter } from './client';
-import type { Navigation, HookName } from '../types';
+import type { HookName, Navigation } from '../types';
 export declare class Router extends ClientRouter {
     protected delayedNavigation: Navigation;
     protected delayedPromise: Promise<void>;
@@ -17,7 +17,9 @@ export declare class Router extends ClientRouter {
     protected runHooks(hookName: HookName, navigation: Navigation): Promise<void>;
     private resolveIfDelayFound;
     private flattenDelayedNavigation;
+    private getNavigationType;
     private shouldApplyViewTransition;
+    private getPrevTransition;
     private restoreAppliedViewTransitions;
     private saveAppliedViewTransitions;
     cancel(): Navigation;

package/lib/router/client.browser.js

@@ -5,12 +5,12 @@ import { logger } from '../logger.browser.js';
 import { ClientHistory } from '../history/client.browser.js';
 
 class ClientRouter extends AbstractRouter {
+    // this flag for cases when we don't have initial router state from server - CSR fallback initialization
+    fullRehydrationInProcess = null;
     constructor(options) {
         super(options);
-        // this flag for cases when we don't have initial router state from server - CSR fallback initialization
-        this.fullRehydrationInProcess = null;
         this.history = new ClientHistory();
-        this.history.listen(async ({ type, url, navigateState, replace, history }) => {
+        this.history.listen(async ({ type, url, navigateState, replace, history, hasUAVisualTransition, ...rest }) => {
             const currentUrl = this.getCurrentUrl();
             const { pathname, query, hash } = this.resolveUrl({ url });
             const isSameUrlNavigation = (currentUrl ? currentUrl.pathname : window.location.pathname) === pathname;
@@ -47,6 +47,8 @@ class ClientRouter extends AbstractRouter {
                     url,
                     replace,
                     navigateState,
+                    hasUAVisualTransition,
+                    ...rest,
                 }, { history });
             }
         });
@@ -146,6 +148,9 @@ class ClientRouter extends AbstractRouter {
             redirect: true,
         });
     }
+    unsubscribe() {
+        this.history.unsubscribe();
+    }
 }
 
 export { ClientRouter };

package/lib/router/client.d.ts

@@ -9,5 +9,6 @@ export declare abstract class ClientRouter extends AbstractRouter {
     protected notfound(navigation: Navigation): Promise<void>;
     protected block(navigation: Navigation): Promise<void>;
     protected redirect(navigation: Navigation, target: NavigateOptions): Promise<void>;
+    unsubscribe(): void;
 }
 //# sourceMappingURL=client.d.ts.map

package/lib/router/client.es.js

@@ -5,12 +5,12 @@ import { logger } from '../logger.es.js';
 import { ClientHistory } from '../history/client.es.js';
 
 class ClientRouter extends AbstractRouter {
+    // this flag for cases when we don't have initial router state from server - CSR fallback initialization
+    fullRehydrationInProcess = null;
     constructor(options) {
         super(options);
-        // this flag for cases when we don't have initial router state from server - CSR fallback initialization
-        this.fullRehydrationInProcess = null;
         this.history = new ClientHistory();
-        this.history.listen(async ({ type, url, navigateState, replace, history }) => {
+        this.history.listen(async ({ type, url, navigateState, replace, history, hasUAVisualTransition, ...rest }) => {
             const currentUrl = this.getCurrentUrl();
             const { pathname, query, hash } = this.resolveUrl({ url });
             const isSameUrlNavigation = (currentUrl ? currentUrl.pathname : window.location.pathname) === pathname;
@@ -47,6 +47,8 @@ class ClientRouter extends AbstractRouter {
                     url,
                     replace,
                     navigateState,
+                    hasUAVisualTransition,
+                    ...rest,
                 }, { history });
             }
         });
@@ -146,6 +148,9 @@ class ClientRouter extends AbstractRouter {
             redirect: true,
         });
     }
+    unsubscribe() {
+        this.history.unsubscribe();
+    }
 }
 
 export { ClientRouter };

package/lib/router/client.js

@@ -9,12 +9,12 @@ var logger = require('../logger.js');
 var client = require('../history/client.js');
 
 class ClientRouter extends abstract.AbstractRouter {
+    // this flag for cases when we don't have initial router state from server - CSR fallback initialization
+    fullRehydrationInProcess = null;
     constructor(options) {
         super(options);
-        // this flag for cases when we don't have initial router state from server - CSR fallback initialization
-        this.fullRehydrationInProcess = null;
         this.history = new client.ClientHistory();
-        this.history.listen(async ({ type, url, navigateState, replace, history }) => {
+        this.history.listen(async ({ type, url, navigateState, replace, history, hasUAVisualTransition, ...rest }) => {
             const currentUrl = this.getCurrentUrl();
             const { pathname, query, hash } = this.resolveUrl({ url });
             const isSameUrlNavigation = (currentUrl ? currentUrl.pathname : window.location.pathname) === pathname;
@@ -51,6 +51,8 @@ class ClientRouter extends abstract.AbstractRouter {
                     url,
                     replace,
                     navigateState,
+                    hasUAVisualTransition,
+                    ...rest,
                 }, { history });
             }
         });
@@ -150,6 +152,9 @@ class ClientRouter extends abstract.AbstractRouter {
             redirect: true,
         });
     }
+    unsubscribe() {
+        this.history.unsubscribe();
+    }
 }
 
 exports.ClientRouter = ClientRouter;

package/lib/router/constants.browser.js

@@ -0,0 +1,6 @@
+const NAVIGATION_TYPE = {
+    FORWARD: 'tramvai_vt_forward',
+    BACK: 'tramvai_vt_back',
+};
+
+export { NAVIGATION_TYPE };

package/lib/router/constants.d.ts

@@ -0,0 +1,5 @@
+export declare const NAVIGATION_TYPE: {
+    readonly FORWARD: "tramvai_vt_forward";
+    readonly BACK: "tramvai_vt_back";
+};
+//# sourceMappingURL=constants.d.ts.map

package/lib/router/constants.es.js

@@ -0,0 +1,6 @@
+const NAVIGATION_TYPE = {
+    FORWARD: 'tramvai_vt_forward',
+    BACK: 'tramvai_vt_back',
+};
+
+export { NAVIGATION_TYPE };

package/lib/router/constants.js

@@ -0,0 +1,10 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const NAVIGATION_TYPE = {
+    FORWARD: 'tramvai_vt_forward',
+    BACK: 'tramvai_vt_back',
+};
+
+exports.NAVIGATION_TYPE = NAVIGATION_TYPE;

package/lib/router/server.es.js

@@ -5,9 +5,11 @@ import { RouteTree } from '../tree/tree.es.js';
 import { logger } from '../logger.es.js';
 
 class Router extends AbstractRouter {
+    defaultRedirectCode;
+    blocked = false;
+    redirectCode;
     constructor(options) {
         super(options);
-        this.blocked = false;
         this.tree = new RouteTree(options.routes);
         this.defaultRedirectCode = options.defaultRedirectCode ?? 308;
         this.history = new ServerHistory();

package/lib/router/server.js

@@ -9,9 +9,11 @@ var tree = require('../tree/tree.js');
 var logger = require('../logger.js');
 
 class Router extends abstract.AbstractRouter {
+    defaultRedirectCode;
+    blocked = false;
+    redirectCode;
     constructor(options) {
         super(options);
-        this.blocked = false;
         this.tree = new tree.RouteTree(options.routes);
         this.defaultRedirectCode = options.defaultRedirectCode ?? 308;
         this.history = new server.ServerHistory();

package/lib/tree/tree.browser.js

@@ -19,6 +19,7 @@ const createNavigationRoute = (route, pathname, params) => {
     };
 };
 class RouteTree {
+    tree;
     constructor(routes) {
         this.tree = createTree();
         each((route) => this.addRoute(route), routes);