@tanstack/router-core 0.0.1-beta.25 → 0.0.1-beta.29

package/build/cjs/{packages/router-core/src/router.js → router.js}

@@ -12,21 +12,25 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var _rollupPluginBabelHelpers = require('../../../_virtual/_rollupPluginBabelHelpers.js');
-var index = require('../../../node_modules/history/index.js');
-var tinyInvariant = require('../../../node_modules/tiny-invariant/dist/esm/tiny-invariant.js');
+var _rollupPluginBabelHelpers = require('./_virtual/_rollupPluginBabelHelpers.js');
+var history = require('history');
+var invariant = require('tiny-invariant');
 var path = require('./path.js');
 var route = require('./route.js');
 var routeMatch = require('./routeMatch.js');
 var searchParams = require('./searchParams.js');
 var utils = require('./utils.js');
 
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var invariant__default = /*#__PURE__*/_interopDefaultLegacy(invariant);
+
 var _window$document;
 // Detect if we're in the DOM
-const isServer = typeof window === 'undefined' || !((_window$document = window.document) != null && _window$document.createElement); // This is the default history object if none is defined
-
-const createDefaultHistory = () => isServer ? index.createMemoryHistory() : index.createBrowserHistory();
+const isServer = typeof window === 'undefined' || !((_window$document = window.document) != null && _window$document.createElement);
 
+// This is the default history object if none is defined
+const createDefaultHistory = () => isServer ? history.createMemoryHistory() : history.createBrowserHistory();
 function getInitialRouterState() {
   return {
     status: 'idle',
@@ -39,22 +43,19 @@ function getInitialRouterState() {
     isPreloading: false
   };
 }
-
 function createRouter(userOptions) {
   var _userOptions$stringif, _userOptions$parseSea;
-
   const history = (userOptions == null ? void 0 : userOptions.history) || createDefaultHistory();
-
   const originalOptions = _rollupPluginBabelHelpers["extends"]({
     defaultLoaderGcMaxAge: 5 * 60 * 1000,
     defaultLoaderMaxAge: 0,
     defaultPreloadMaxAge: 2000,
-    defaultPreloadDelay: 50
+    defaultPreloadDelay: 50,
+    context: undefined
   }, userOptions, {
     stringifySearch: (_userOptions$stringif = userOptions == null ? void 0 : userOptions.stringifySearch) != null ? _userOptions$stringif : searchParams.defaultStringifySearch,
     parseSearch: (_userOptions$parseSea = userOptions == null ? void 0 : userOptions.parseSearch) != null ? _userOptions$parseSea : searchParams.defaultParseSearch
   });
-
   let router = {
     types: undefined,
     // public api
@@ -62,13 +63,11 @@ function createRouter(userOptions) {
     options: originalOptions,
     listeners: [],
     // Resolved after construction
-    context: {},
     basepath: '',
     routeTree: undefined,
     routesById: {},
     location: undefined,
     //
-    navigationPromise: Promise.resolve(),
     resolveNavigation: () => {},
     matchCache: {},
     state: getInitialRouterState(),
@@ -89,30 +88,38 @@ function createRouter(userOptions) {
     notify: () => {
       const isFetching = router.state.status === 'loading' || router.state.matches.some(d => d.isFetching);
       const isPreloading = Object.values(router.matchCache).some(d => d.match.isFetching && !router.state.matches.find(dd => dd.matchId === d.match.matchId));
-
       if (router.state.isFetching !== isFetching || router.state.isPreloading !== isPreloading) {
         router.state = _rollupPluginBabelHelpers["extends"]({}, router.state, {
           isFetching,
           isPreloading
         });
       }
-
       cascadeLoaderData(router.state.matches);
       router.listeners.forEach(listener => listener(router));
     },
-    dehydrateState: () => {
-      return _rollupPluginBabelHelpers["extends"]({}, utils.pick(router.state, ['status', 'location', 'lastUpdated']), {
-        matches: router.state.matches.map(match => utils.pick(match, ['matchId', 'status', 'routeLoaderData', 'loaderData', 'isInvalid', 'invalidAt']))
-      });
+    dehydrate: () => {
+      return {
+        location: router.location,
+        state: _rollupPluginBabelHelpers["extends"]({}, utils.pick(router.state, ['status', 'location', 'lastUpdated', 'location']), {
+          matches: router.state.matches.map(match => utils.pick(match, ['matchId', 'status', 'routeLoaderData', 'loaderData', 'isInvalid', 'invalidAt']))
+        }),
+        context: router.options.context
+      };
     },
-    hydrateState: dehydratedState => {
+    hydrate: dehydratedState => {
+      // Update the location
+      router.location = dehydratedState.location;
+
+      // Update the context
+      router.options.context = dehydratedState.context;
+
       // Match the routes
       const matches = router.matchRoutes(router.location.pathname, {
         strictParseParams: true
       });
       matches.forEach((match, index) => {
-        const dehydratedMatch = dehydratedState.matches[index];
-        tinyInvariant["default"](dehydratedMatch, 'Oh no! Dehydrated route matches did not match the active state of the router 😬');
+        const dehydratedMatch = dehydratedState.state.matches[index];
+        invariant__default["default"](dehydratedMatch, 'Oh no! Dehydrated route matches did not match the active state of the router 😬');
         Object.assign(match, dehydratedMatch);
       });
       matches.forEach(match => match.__.validate());
@@ -125,32 +132,29 @@ function createRouter(userOptions) {
         to: '.',
         search: true,
         hash: true
-      }); // If the current location isn't updated, trigger a navigation
-      // to the current location. Otherwise, load the current location.
-
+      });
 
+      // If the current location isn't updated, trigger a navigation
+      // to the current location. Otherwise, load the current location.
       if (next.href !== router.location.href) {
         router.__.commitLocation(next, true);
       }
-
       if (!router.state.matches.length) {
         router.load();
       }
-
       const unsub = router.history.listen(event => {
         router.load(router.__.parseLocation(event.location, router.location));
-      }); // addEventListener does not exist in React Native, but window does
-      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+      });
 
+      // addEventListener does not exist in React Native, but window does
+      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
       if (!isServer && window.addEventListener) {
         // Listen to visibillitychange and focus
         window.addEventListener('visibilitychange', router.onFocus, false);
         window.addEventListener('focus', router.onFocus, false);
       }
-
       return () => {
         unsub();
-
         if (!isServer && window.removeEventListener) {
           // Be sure to unsubscribe if a new handler is set
           window.removeEventListener('visibilitychange', router.onFocus);
@@ -163,28 +167,23 @@ function createRouter(userOptions) {
     },
     update: opts => {
       const newHistory = (opts == null ? void 0 : opts.history) !== router.history;
-
       if (!router.location || newHistory) {
         if (opts != null && opts.history) {
           router.history = opts.history;
         }
-
         router.location = router.__.parseLocation(router.history.location);
         router.state.location = router.location;
       }
-
       Object.assign(router.options, opts);
       const {
         basepath,
         routeConfig
       } = router.options;
       router.basepath = path.cleanPath("/" + (basepath != null ? basepath : ''));
-
       if (routeConfig) {
         router.routesById = {};
         router.routeTree = router.__.buildRouteTree(routeConfig);
       }
-
       return router;
     },
     cancelMatches: () => {
@@ -196,31 +195,18 @@ function createRouter(userOptions) {
     load: async next => {
       const id = Math.random();
       router.startedLoadingAt = id;
-
       if (next) {
         // Ingest the new location
         router.location = next;
-      } // Cancel any pending matches
-
+      }
 
-      router.cancelMatches(); // Match the routes
+      // Cancel any pending matches
+      router.cancelMatches();
 
+      // Match the routes
       const matches = router.matchRoutes(router.location.pathname, {
         strictParseParams: true
-      }); // Check if each match middleware to see if the route can be accessed
-
-      try {
-        await Promise.all(matches.map(match => match.options.beforeLoad == null ? void 0 : match.options.beforeLoad({
-          context: router.context
-        })));
-      } catch (err) {
-        if (err != null && err.then) {
-          await new Promise(() => {});
-        }
-
-        throw err;
-      }
-
+      });
       if (typeof document !== 'undefined') {
         router.state = _rollupPluginBabelHelpers["extends"]({}, router.state, {
           pending: {
@@ -237,18 +223,29 @@ function createRouter(userOptions) {
         });
       }
 
-      router.notify(); // Load the matches
+      // Check if each match middleware to see if the route can be accessed
+      try {
+        await Promise.all(matches.map(match => match.options.beforeLoad == null ? void 0 : match.options.beforeLoad({
+          router: router,
+          match
+        })));
+      } catch (err) {
+        if (err != null && err.then) {
+          await new Promise(() => {});
+        }
+        throw err;
+      }
+      router.notify();
 
+      // Load the matches
       await router.loadMatches(matches);
-
       if (router.startedLoadingAt !== id) {
         // Ignore side-effects of match loading
         return router.navigationPromise;
       }
-
       const previousMatches = router.state.matches;
       const exiting = [],
-            staying = [];
+        staying = [];
       previousMatches.forEach(d => {
         if (matches.find(dd => dd.matchId === d.matchId)) {
           staying.push(d);
@@ -262,19 +259,17 @@ function createRouter(userOptions) {
       const now = Date.now();
       exiting.forEach(d => {
         var _ref, _d$options$loaderGcMa, _ref2, _d$options$loaderMaxA;
-
         d.__.onExit == null ? void 0 : d.__.onExit({
           params: d.params,
           search: d.routeSearch
-        }); // Clear idle error states when match leaves
+        });
 
+        // Clear idle error states when match leaves
         if (d.status === 'error' && !d.isFetching) {
           d.status = 'idle';
           d.error = undefined;
         }
-
         const gc = Math.max((_ref = (_d$options$loaderGcMa = d.options.loaderGcMaxAge) != null ? _d$options$loaderGcMa : router.options.defaultLoaderGcMaxAge) != null ? _ref : 0, (_ref2 = (_d$options$loaderMaxA = d.options.loaderMaxAge) != null ? _d$options$loaderMaxA : router.options.defaultLoaderMaxAge) != null ? _ref2 : 0);
-
         if (gc > 0) {
           router.matchCache[d.matchId] = {
             gc: gc == Infinity ? Number.MAX_SAFE_INTEGER : now + gc,
@@ -295,12 +290,10 @@ function createRouter(userOptions) {
         });
         delete router.matchCache[d.matchId];
       });
-
       if (router.startedLoadingAt !== id) {
         // Ignore side-effects of match loading
         return;
       }
-
       matches.forEach(match => {
         // Clear actions
         if (match.action) {
@@ -320,18 +313,19 @@ function createRouter(userOptions) {
     cleanMatchCache: () => {
       const now = Date.now();
       Object.keys(router.matchCache).forEach(matchId => {
-        const entry = router.matchCache[matchId]; // Don't remove loading matches
+        const entry = router.matchCache[matchId];
 
+        // Don't remove loading matches
         if (entry.match.status === 'loading') {
           return;
-        } // Do not remove successful matches that are still valid
-
+        }
 
+        // Do not remove successful matches that are still valid
         if (entry.gc > 0 && entry.gc > now) {
           return;
-        } // Everything else gets removed
-
+        }
 
+        // Everything else gets removed
         delete router.matchCache[matchId];
       });
     },
@@ -339,7 +333,6 @@ function createRouter(userOptions) {
       if (navigateOpts === void 0) {
         navigateOpts = router.location;
       }
-
       const next = router.buildNext(navigateOpts);
       const matches = router.matchRoutes(next.pathname, {
         strictParseParams: true
@@ -349,11 +342,9 @@ function createRouter(userOptions) {
     },
     preloadRoute: async function preloadRoute(navigateOpts, loaderOpts) {
       var _ref3, _ref4, _loaderOpts$maxAge, _ref5, _ref6, _loaderOpts$gcMaxAge;
-
       if (navigateOpts === void 0) {
         navigateOpts = router.location;
       }
-
       const next = router.buildNext(navigateOpts);
       const matches = router.matchRoutes(next.pathname, {
         strictParseParams: true
@@ -367,90 +358,70 @@ function createRouter(userOptions) {
     },
     matchRoutes: (pathname, opts) => {
       var _router$state$pending3, _router$state$pending4;
-
       router.cleanMatchCache();
       const matches = [];
-
       if (!router.routeTree) {
         return matches;
       }
-
       const existingMatches = [...router.state.matches, ...((_router$state$pending3 = (_router$state$pending4 = router.state.pending) == null ? void 0 : _router$state$pending4.matches) != null ? _router$state$pending3 : [])];
-
       const recurse = async routes => {
         var _parentMatch$params, _router$options$filte, _foundRoute$childRout;
-
         const parentMatch = utils.last(matches);
         let params = (_parentMatch$params = parentMatch == null ? void 0 : parentMatch.params) != null ? _parentMatch$params : {};
         const filteredRoutes = (_router$options$filte = router.options.filterRoutes == null ? void 0 : router.options.filterRoutes(routes)) != null ? _router$options$filte : routes;
         let foundRoutes = [];
-
         const findMatchInRoutes = (parentRoutes, routes) => {
           routes.some(route => {
             var _route$childRoutes, _route$childRoutes2, _route$options$caseSe;
-
             if (!route.routePath && (_route$childRoutes = route.childRoutes) != null && _route$childRoutes.length) {
               return findMatchInRoutes([...foundRoutes, route], route.childRoutes);
             }
-
             const fuzzy = !!(route.routePath !== '/' || (_route$childRoutes2 = route.childRoutes) != null && _route$childRoutes2.length);
             const matchParams = path.matchPathname(pathname, {
               to: route.fullPath,
               fuzzy,
               caseSensitive: (_route$options$caseSe = route.options.caseSensitive) != null ? _route$options$caseSe : router.options.caseSensitive
             });
-
             if (matchParams) {
               let parsedParams;
-
               try {
                 var _route$options$parseP;
-
                 parsedParams = (_route$options$parseP = route.options.parseParams == null ? void 0 : route.options.parseParams(matchParams)) != null ? _route$options$parseP : matchParams;
               } catch (err) {
                 if (opts != null && opts.strictParseParams) {
                   throw err;
                 }
               }
-
               params = _rollupPluginBabelHelpers["extends"]({}, params, parsedParams);
             }
-
             if (!!matchParams) {
               foundRoutes = [...parentRoutes, route];
             }
-
             return !!foundRoutes.length;
           });
           return !!foundRoutes.length;
         };
-
         findMatchInRoutes([], filteredRoutes);
-
         if (!foundRoutes.length) {
           return;
         }
-
         foundRoutes.forEach(foundRoute => {
           var _router$matchCache$ma;
-
           const interpolatedPath = path.interpolatePath(foundRoute.routePath, params);
           const matchId = path.interpolatePath(foundRoute.routeId, params, true);
           const match = existingMatches.find(d => d.matchId === matchId) || ((_router$matchCache$ma = router.matchCache[matchId]) == null ? void 0 : _router$matchCache$ma.match) || routeMatch.createRouteMatch(router, foundRoute, {
             parentMatch,
             matchId,
             params,
-            pathname: path.joinPaths([pathname, interpolatedPath])
+            pathname: path.joinPaths([router.basepath, interpolatedPath])
           });
           matches.push(match);
         });
         const foundRoute = utils.last(foundRoutes);
-
         if ((_foundRoute$childRout = foundRoute.childRoutes) != null && _foundRoute$childRout.length) {
           recurse(foundRoute.childRoutes);
         }
       };
-
       recurse([router.routeTree]);
       cascadeLoaderData(matches);
       return matches;
@@ -459,14 +430,11 @@ function createRouter(userOptions) {
       const matchPromises = resolvedMatches.map(async match => {
         // Validate the match (loads search params etc)
         match.__.validate();
-
         match.load(loaderOpts);
         const search = match.search;
-
         if (search.__data && search.__data.matchId !== match.matchId) {
           return;
         }
-
         if (match.__.loadPromise) {
           // Wait for the first sign of activity from the match
           await match.__.loadPromise;
@@ -478,7 +446,6 @@ function createRouter(userOptions) {
     loadMatchData: async routeMatch => {
       if (isServer || !router.options.useServerData) {
         var _await$routeMatch$opt;
-
         return (_await$routeMatch$opt = await (routeMatch.options.loader == null ? void 0 : routeMatch.options.loader({
           // parentLoaderPromise: routeMatch.parentMatch?.__.dataPromise,
           params: routeMatch.params,
@@ -494,21 +461,30 @@ function createRouter(userOptions) {
             }
           })
         });
-        const res = await fetch(next.href, {
-          method: 'GET' // signal: routeMatch.__.abortController.signal,
 
+        // Refresh:
+        // '/dashboard'
+        // '/dashboard/invoices/'
+        // '/dashboard/invoices/123'
+
+        // New:
+        // '/dashboard/invoices/456'
+
+        // TODO: batch requests when possible
+
+        const res = await fetch(next.href, {
+          method: 'GET'
+          // signal: routeMatch.__.abortController.signal,
         });
 
         if (res.ok) {
           return res.json();
         }
-
         throw new Error('Failed to fetch match data');
       }
     },
     invalidateRoute: opts => {
       var _router$state$pending5, _router$state$pending6;
-
       const next = router.buildNext(opts);
       const unloadedMatchIds = router.matchRoutes(next.pathname).map(d => d.matchId);
       [...router.state.matches, ...((_router$state$pending5 = (_router$state$pending6 = router.state.pending) == null ? void 0 : _router$state$pending6.matches) != null ? _router$state$pending5 : [])].forEach(match => {
@@ -527,25 +503,21 @@ function createRouter(userOptions) {
     },
     matchRoute: (location, opts) => {
       var _location$from;
-
       // const location = router.buildNext(opts)
+
       location = _rollupPluginBabelHelpers["extends"]({}, location, {
         to: location.to ? router.resolvePath((_location$from = location.from) != null ? _location$from : '', location.to) : undefined
       });
       const next = router.buildNext(location);
-
       if (opts != null && opts.pending) {
         var _router$state$pending7;
-
         if (!((_router$state$pending7 = router.state.pending) != null && _router$state$pending7.location)) {
           return false;
         }
-
         return !!path.matchPathname(router.state.pending.location.pathname, _rollupPluginBabelHelpers["extends"]({}, opts, {
           to: next.pathname
         }));
       }
-
       return !!path.matchPathname(router.state.location.pathname, _rollupPluginBabelHelpers["extends"]({}, opts, {
         to: next.pathname
       }));
@@ -561,18 +533,17 @@ function createRouter(userOptions) {
       } = _ref7;
       // If this link simply reloads the current route,
       // make sure it has a new key so it will trigger a data refresh
+
       // If this `to` is a valid external URL, return
       // null for LinkUtils
       const toString = String(to);
       const fromString = String(from);
       let isExternal;
-
       try {
         new URL("" + toString);
         isExternal = true;
       } catch (e) {}
-
-      tinyInvariant["default"](!isExternal, 'Attempting to navigate to external url with router.navigate!');
+      invariant__default["default"](!isExternal, 'Attempting to navigate to external url with router.navigate!');
       return router.__.navigate({
         from: fromString,
         to: toString,
@@ -584,7 +555,6 @@ function createRouter(userOptions) {
     },
     buildLink: _ref8 => {
       var _preload, _ref9;
-
       let {
         from,
         to = '.',
@@ -600,11 +570,12 @@ function createRouter(userOptions) {
         preloadDelay: userPreloadDelay,
         disabled
       } = _ref8;
-
       // If this link simply reloads the current route,
       // make sure it has a new key so it will trigger a data refresh
+
       // If this `to` is a valid external URL, return
       // null for LinkUtils
+
       try {
         new URL("" + to);
         return {
@@ -612,7 +583,6 @@ function createRouter(userOptions) {
           href: to
         };
       } catch (e) {}
-
       const nextOpts = {
         from,
         to,
@@ -623,33 +593,35 @@ function createRouter(userOptions) {
       };
       const next = router.buildNext(nextOpts);
       preload = (_preload = preload) != null ? _preload : router.options.defaultPreload;
-      const preloadDelay = (_ref9 = userPreloadDelay != null ? userPreloadDelay : router.options.defaultPreloadDelay) != null ? _ref9 : 0; // Compare path/hash for matches
+      const preloadDelay = (_ref9 = userPreloadDelay != null ? userPreloadDelay : router.options.defaultPreloadDelay) != null ? _ref9 : 0;
 
+      // Compare path/hash for matches
       const pathIsEqual = router.state.location.pathname === next.pathname;
       const currentPathSplit = router.state.location.pathname.split('/');
       const nextPathSplit = next.pathname.split('/');
       const pathIsFuzzyEqual = nextPathSplit.every((d, i) => d === currentPathSplit[i]);
-      const hashIsEqual = router.state.location.hash === next.hash; // Combine the matches based on user options
-
+      const hashIsEqual = router.state.location.hash === next.hash;
+      // Combine the matches based on user options
       const pathTest = activeOptions != null && activeOptions.exact ? pathIsEqual : pathIsFuzzyEqual;
-      const hashTest = activeOptions != null && activeOptions.includeHash ? hashIsEqual : true; // The final "active" test
+      const hashTest = activeOptions != null && activeOptions.includeHash ? hashIsEqual : true;
 
-      const isActive = pathTest && hashTest; // The click handler
+      // The final "active" test
+      const isActive = pathTest && hashTest;
 
+      // The click handler
       const handleClick = e => {
         if (!disabled && !isCtrlEvent(e) && !e.defaultPrevented && (!target || target === '_self') && e.button === 0) {
           e.preventDefault();
-
           if (pathIsEqual && !search && !hash) {
             router.invalidateRoute(nextOpts);
-          } // All is well? Navigate!)
-
+          }
 
+          // All is well? Navigate!)
           router.__.navigate(nextOpts);
         }
-      }; // The click handler
-
+      };
 
+      // The click handler
       const handleFocus = e => {
         if (preload) {
           router.preloadRoute(nextOpts, {
@@ -658,15 +630,12 @@ function createRouter(userOptions) {
           });
         }
       };
-
       const handleEnter = e => {
         const target = e.target || {};
-
         if (preload) {
           if (target.preloadTimeout) {
             return;
           }
-
           target.preloadTimeout = setTimeout(() => {
             target.preloadTimeout = null;
             router.preloadRoute(nextOpts, {
@@ -676,16 +645,13 @@ function createRouter(userOptions) {
           }, preloadDelay);
         }
       };
-
       const handleLeave = e => {
         const target = e.target || {};
-
         if (target.preloadTimeout) {
           clearTimeout(target.preloadTimeout);
           target.preloadTimeout = null;
         }
       };
-
       return {
         type: 'internal',
         next,
@@ -699,21 +665,15 @@ function createRouter(userOptions) {
     },
     buildNext: opts => {
       const next = router.__.buildLocation(opts);
-
       const matches = router.matchRoutes(next.pathname);
-
       const __preSearchFilters = matches.map(match => {
         var _match$options$preSea;
-
         return (_match$options$preSea = match.options.preSearchFilters) != null ? _match$options$preSea : [];
       }).flat().filter(Boolean);
-
       const __postSearchFilters = matches.map(match => {
         var _match$options$postSe;
-
         return (_match$options$postSe = match.options.postSearchFilters) != null ? _match$options$postSe : [];
       }).flat().filter(Boolean);
-
       return router.__.buildLocation(_rollupPluginBabelHelpers["extends"]({}, opts, {
         __preSearchFilters,
         __postSearchFilters
@@ -726,12 +686,10 @@ function createRouter(userOptions) {
             const routeOptions = routeConfig.options;
             const route$1 = route.createRoute(routeConfig, routeOptions, parent, router);
             const existingRoute = router.routesById[route$1.routeId];
-
             if (existingRoute) {
               if (process.env.NODE_ENV !== 'production') {
                 console.warn("Duplicate routes found with id: " + String(route$1.routeId), router.routesById, route$1);
               }
-
               throw new Error();
             }
             router.routesById[route$1.routeId] = route$1;
@@ -740,13 +698,11 @@ function createRouter(userOptions) {
             return route$1;
           });
         };
-
         const routes = recurseRoutes([rootRouteConfig]);
         return routes[0];
       },
       parseLocation: (location, previousLocation) => {
         var _location$hash$split$;
-
         const parsedSearch = router.options.parseSearch(location.search);
         return {
           pathname: location.pathname,
@@ -764,41 +720,36 @@ function createRouter(userOptions) {
       },
       buildLocation: function buildLocation(dest) {
         var _dest$from, _router$basepath, _dest$to, _last, _dest$params, _dest$__preSearchFilt, _functionalUpdate, _dest$__preSearchFilt2, _dest$__postSearchFil;
-
         if (dest === void 0) {
           dest = {};
         }
-
         // const resolvedFrom: Location = {
         //   ...router.location,
         const fromPathname = dest.fromCurrent ? router.location.pathname : (_dest$from = dest.from) != null ? _dest$from : router.location.pathname;
-
         let pathname = path.resolvePath((_router$basepath = router.basepath) != null ? _router$basepath : '/', fromPathname, "" + ((_dest$to = dest.to) != null ? _dest$to : '.'));
-
         const fromMatches = router.matchRoutes(router.location.pathname, {
           strictParseParams: true
         });
         const toMatches = router.matchRoutes(pathname);
-
         const prevParams = _rollupPluginBabelHelpers["extends"]({}, (_last = utils.last(fromMatches)) == null ? void 0 : _last.params);
-
         let nextParams = ((_dest$params = dest.params) != null ? _dest$params : true) === true ? prevParams : utils.functionalUpdate(dest.params, prevParams);
-
         if (nextParams) {
           toMatches.map(d => d.options.stringifyParams).filter(Boolean).forEach(fn => {
             Object.assign({}, nextParams, fn(nextParams));
           });
         }
+        pathname = path.interpolatePath(pathname, nextParams != null ? nextParams : {});
 
-        pathname = path.interpolatePath(pathname, nextParams != null ? nextParams : {}); // Pre filters first
-
-        const preFilteredSearch = (_dest$__preSearchFilt = dest.__preSearchFilters) != null && _dest$__preSearchFilt.length ? dest.__preSearchFilters.reduce((prev, next) => next(prev), router.location.search) : router.location.search; // Then the link/navigate function
+        // Pre filters first
+        const preFilteredSearch = (_dest$__preSearchFilt = dest.__preSearchFilters) != null && _dest$__preSearchFilt.length ? dest.__preSearchFilters.reduce((prev, next) => next(prev), router.location.search) : router.location.search;
 
+        // Then the link/navigate function
         const destSearch = dest.search === true ? preFilteredSearch // Preserve resolvedFrom true
         : dest.search ? (_functionalUpdate = utils.functionalUpdate(dest.search, preFilteredSearch)) != null ? _functionalUpdate : {} // Updater
         : (_dest$__preSearchFilt2 = dest.__preSearchFilters) != null && _dest$__preSearchFilt2.length ? preFilteredSearch // Preserve resolvedFrom filters
-        : {}; // Then post filters
+        : {};
 
+        // Then post filters
         const postFilteredSearch = (_dest$__postSearchFil = dest.__postSearchFilters) != null && _dest$__postSearchFil.length ? dest.__postSearchFilters.reduce((prev, next) => next(prev), destSearch) : destSearch;
         const search = utils.replaceEqualDeep(router.location.search, postFilteredSearch);
         const searchStr = router.options.stringifySearch(search);
@@ -818,17 +769,13 @@ function createRouter(userOptions) {
         const id = '' + Date.now() + Math.random();
         if (router.navigateTimeout) clearTimeout(router.navigateTimeout);
         let nextAction = 'replace';
-
         if (!replace) {
           nextAction = 'push';
         }
-
         const isSameUrl = router.__.parseLocation(history.location).href === next.href;
-
         if (isSameUrl && !next.key) {
           nextAction = 'replace';
         }
-
         if (nextAction === 'replace') {
           history.replace({
             pathname: next.pathname,
@@ -846,33 +793,30 @@ function createRouter(userOptions) {
             id
           });
         }
-
         router.navigationPromise = new Promise(resolve => {
           const previousNavigationResolve = router.resolveNavigation;
-
           router.resolveNavigation = () => {
             previousNavigationResolve();
             resolve();
+            delete router.navigationPromise;
           };
         });
         return router.navigationPromise;
       }
     }
   };
-  router.update(userOptions); // Allow frameworks to hook into the router creation
+  router.update(userOptions);
 
+  // Allow frameworks to hook into the router creation
   router.options.createRouter == null ? void 0 : router.options.createRouter(router);
   return router;
 }
-
 function isCtrlEvent(e) {
   return !!(e.metaKey || e.altKey || e.ctrlKey || e.shiftKey);
 }
-
 function cascadeLoaderData(matches) {
   matches.forEach((match, index) => {
     const parent = matches[index - 1];
-
     if (parent) {
       match.loaderData = utils.replaceEqualDeep(match.loaderData, _rollupPluginBabelHelpers["extends"]({}, parent.loaderData, match.routeLoaderData));
     }