@tanstack/router-core 0.0.1-beta.3 → 0.0.1-beta.30

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

@@ -12,61 +12,68 @@
 
 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');
 
-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
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
-const createDefaultHistory = () => isServer ? index.createMemoryHistory() : index.createBrowserHistory();
+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 ? history.createMemoryHistory() : history.createBrowserHistory();
+function getInitialRouterState() {
+  return {
+    status: 'idle',
+    location: null,
+    matches: [],
+    actions: {},
+    loaders: {},
+    lastUpdated: Date.now(),
+    isFetching: false,
+    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
     history,
     options: originalOptions,
     listeners: [],
-    removeActionQueue: [],
     // Resolved after construction
     basepath: '',
     routeTree: undefined,
     routesById: {},
     location: undefined,
-    allRouteInfo: undefined,
     //
-    navigationPromise: Promise.resolve(),
     resolveNavigation: () => {},
     matchCache: {},
-    state: {
-      status: 'idle',
-      location: null,
-      matches: [],
-      actions: {},
-      loaders: {},
-      loaderData: {},
-      lastUpdated: Date.now(),
-      isFetching: false,
-      isPreloading: false
+    state: getInitialRouterState(),
+    reset: () => {
+      router.state = getInitialRouterState();
+      router.notify();
     },
     startedLoadingAt: Date.now(),
     subscribe: listener => {
@@ -79,62 +86,104 @@ function createRouter(userOptions) {
       return router.routesById[id];
     },
     notify: () => {
-      router.state = _rollupPluginBabelHelpers["extends"]({}, router.state, {
-        isFetching: router.state.status === 'loading' || router.state.matches.some(d => d.isFetching),
-        isPreloading: Object.values(router.matchCache).some(d => d.match.isFetching && !router.state.matches.find(dd => dd.matchId === d.match.matchId))
-      });
-      route.cascadeLoaderData(router.state.matches);
+      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));
     },
+    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
+      };
+    },
+    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.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());
+      router.state = _rollupPluginBabelHelpers["extends"]({}, router.state, dehydratedState, {
+        matches
+      });
+    },
     mount: () => {
       const next = router.__.buildLocation({
         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);
-      } else {
-        router.loadLocation();
       }
+      if (!router.state.matches.length) {
+        router.load();
+      }
+      const unsub = router.history.listen(event => {
+        router.load(router.__.parseLocation(event.location, router.location));
+      });
 
-      const unsub = history.listen(event => {
-        router.loadLocation(router.__.parseLocation(event.location, router.location));
-      }); // addEventListener does not exist in React Native, but window does
+      // 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(); // Be sure to unsubscribe if a new handler is set
-
-        window.removeEventListener('visibilitychange', router.onFocus);
-        window.removeEventListener('focus', router.onFocus);
+        unsub();
+        if (!isServer && window.removeEventListener) {
+          // Be sure to unsubscribe if a new handler is set
+          window.removeEventListener('visibilitychange', router.onFocus);
+          window.removeEventListener('focus', router.onFocus);
+        }
       };
     },
     onFocus: () => {
-      router.loadLocation();
+      router.load();
     },
     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: () => {
@@ -143,58 +192,60 @@ function createRouter(userOptions) {
         match.cancel();
       });
     },
-    loadLocation: async next => {
+    load: async next => {
       const id = Math.random();
       router.startedLoadingAt = id;
-
       if (next) {
         // Ingest the new location
         router.location = next;
-      } // Clear out old actions
-
-
-      router.removeActionQueue.forEach(_ref => {
-        let {
-          action,
-          actionState
-        } = _ref;
-
-        if (router.state.currentAction === actionState) {
-          router.state.currentAction = undefined;
-        }
-
-        if (action.current === actionState) {
-          action.current = undefined;
-        }
-      });
-      router.removeActionQueue = []; // Cancel any pending matches
+      }
 
-      router.cancelMatches(); // Match the routes
+      // Cancel any pending matches
+      router.cancelMatches();
 
-      const matches = router.matchRoutes(location.pathname, {
+      // Match the routes
+      const matches = router.matchRoutes(router.location.pathname, {
         strictParseParams: true
       });
-      router.state = _rollupPluginBabelHelpers["extends"]({}, router.state, {
-        pending: {
+      if (typeof document !== 'undefined') {
+        router.state = _rollupPluginBabelHelpers["extends"]({}, router.state, {
+          pending: {
+            matches: matches,
+            location: router.location
+          },
+          status: 'loading'
+        });
+      } else {
+        router.state = _rollupPluginBabelHelpers["extends"]({}, router.state, {
           matches: matches,
-          location: router.location
-        },
-        status: 'loading'
-      });
-      router.notify(); // Load the matches
+          location: router.location,
+          status: 'loading'
+        });
+      }
 
-      await router.loadMatches(matches, {
-        withPending: 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({
+          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);
@@ -202,22 +253,23 @@ function createRouter(userOptions) {
           exiting.push(d);
         }
       });
+      const entering = matches.filter(d => {
+        return !previousMatches.find(dd => dd.matchId === d.matchId);
+      });
       const now = Date.now();
       exiting.forEach(d => {
-        var _ref2, _d$options$loaderGcMa, _ref3, _d$options$loaderMaxA;
-
+        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((_ref2 = (_d$options$loaderGcMa = d.options.loaderGcMaxAge) != null ? _d$options$loaderGcMa : router.options.defaultLoaderGcMaxAge) != null ? _ref2 : 0, (_ref3 = (_d$options$loaderMaxA = d.options.loaderMaxAge) != null ? _d$options$loaderMaxA : router.options.defaultLoaderMaxAge) != null ? _ref3 : 0);
-
+        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,
@@ -231,27 +283,24 @@ function createRouter(userOptions) {
           search: d.routeSearch
         });
       });
-      const entering = matches.filter(d => {
-        return !previousMatches.find(dd => dd.matchId === d.matchId);
-      });
       entering.forEach(d => {
-        d.__.onExit = d.options.onMatch == null ? void 0 : d.options.onMatch({
+        d.__.onExit = d.options.onLoaded == null ? void 0 : d.options.onLoaded({
           params: d.params,
           search: d.search
         });
         delete router.matchCache[d.matchId];
       });
-
-      if (matches.some(d => d.status === 'loading')) {
-        router.notify();
-        await Promise.all(matches.map(d => d.__.loaderPromise || Promise.resolve()));
-      }
-
       if (router.startedLoadingAt !== id) {
         // Ignore side-effects of match loading
         return;
       }
-
+      matches.forEach(match => {
+        // Clear actions
+        if (match.action) {
+          match.action.current = undefined;
+          match.action.submissions = [];
+        }
+      });
       router.state = _rollupPluginBabelHelpers["extends"]({}, router.state, {
         location: router.location,
         matches,
@@ -264,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];
       });
     },
@@ -283,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
@@ -292,133 +341,150 @@ function createRouter(userOptions) {
       return matches;
     },
     preloadRoute: async function preloadRoute(navigateOpts, loaderOpts) {
-      var _ref4, _ref5, _loaderOpts$maxAge, _ref6, _ref7, _loaderOpts$gcMaxAge;
-
+      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
       });
       await router.loadMatches(matches, {
         preload: true,
-        maxAge: (_ref4 = (_ref5 = (_loaderOpts$maxAge = loaderOpts.maxAge) != null ? _loaderOpts$maxAge : router.options.defaultPreloadMaxAge) != null ? _ref5 : router.options.defaultLoaderMaxAge) != null ? _ref4 : 0,
-        gcMaxAge: (_ref6 = (_ref7 = (_loaderOpts$gcMaxAge = loaderOpts.gcMaxAge) != null ? _loaderOpts$gcMaxAge : router.options.defaultPreloadGcMaxAge) != null ? _ref7 : router.options.defaultLoaderGcMaxAge) != null ? _ref6 : 0
+        maxAge: (_ref3 = (_ref4 = (_loaderOpts$maxAge = loaderOpts.maxAge) != null ? _loaderOpts$maxAge : router.options.defaultPreloadMaxAge) != null ? _ref4 : router.options.defaultLoaderMaxAge) != null ? _ref3 : 0,
+        gcMaxAge: (_ref5 = (_ref6 = (_loaderOpts$gcMaxAge = loaderOpts.gcMaxAge) != null ? _loaderOpts$gcMaxAge : router.options.defaultPreloadGcMaxAge) != null ? _ref6 : router.options.defaultLoaderGcMaxAge) != null ? _ref5 : 0
       });
       return matches;
     },
     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]);
-      route.cascadeLoaderData(matches);
+      cascadeLoaderData(matches);
       return matches;
     },
     loadMatches: async (resolvedMatches, loaderOpts) => {
       const matchPromises = resolvedMatches.map(async match => {
         // Validate the match (loads search params etc)
         match.__.validate();
-
         match.load(loaderOpts);
-
-        if (match.status === 'loading') {
-          // If requested, start the pending timers
-          if (loaderOpts != null && loaderOpts.withPending) match.__.startPending(); // Wait for the first sign of activity from the match
-          // This might be completion, error, or a pending state
-
+        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;
         }
       });
       router.notify();
       await Promise.all(matchPromises);
     },
+    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,
+          search: routeMatch.routeSearch,
+          signal: routeMatch.__.abortController.signal
+        }))) != null ? _await$routeMatch$opt : {};
+      } else {
+        const next = router.buildNext({
+          to: '.',
+          search: d => _rollupPluginBabelHelpers["extends"]({}, d != null ? d : {}, {
+            __data: {
+              matchId: routeMatch.matchId
+            }
+          })
+        });
+
+        // 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 => {
@@ -437,30 +503,26 @@ 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
       }));
     },
-    navigate: async _ref8 => {
+    navigate: async _ref7 => {
       let {
         from,
         to = '.',
@@ -468,21 +530,20 @@ function createRouter(userOptions) {
         hash,
         replace,
         params
-      } = _ref8;
+      } = _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,
@@ -492,9 +553,8 @@ function createRouter(userOptions) {
         params
       });
     },
-    buildLink: _ref9 => {
-      var _preload, _ref10;
-
+    buildLink: _ref8 => {
+      var _preload, _ref9;
       let {
         from,
         to = '.',
@@ -509,12 +569,13 @@ function createRouter(userOptions) {
         preloadGcMaxAge: userPreloadGcMaxAge,
         preloadDelay: userPreloadDelay,
         disabled
-      } = _ref9;
-
+      } = _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 {
@@ -522,7 +583,6 @@ function createRouter(userOptions) {
           href: to
         };
       } catch (e) {}
-
       const nextOpts = {
         from,
         to,
@@ -533,33 +593,35 @@ function createRouter(userOptions) {
       };
       const next = router.buildNext(nextOpts);
       preload = (_preload = preload) != null ? _preload : router.options.defaultPreload;
-      const preloadDelay = (_ref10 = userPreloadDelay != null ? userPreloadDelay : router.options.defaultPreloadDelay) != null ? _ref10 : 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, {
@@ -568,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, {
@@ -586,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,
@@ -609,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
@@ -634,18 +684,12 @@ function createRouter(userOptions) {
         const recurseRoutes = (routeConfigs, parent) => {
           return routeConfigs.map(routeConfig => {
             const routeOptions = routeConfig.options;
-            const route$1 = route.createRoute(routeConfig, routeOptions, parent, router); // {
-            //   pendingMs: routeOptions.pendingMs ?? router.defaultPendingMs,
-            //   pendingMinMs: routeOptions.pendingMinMs ?? router.defaultPendingMinMs,
-            // }
-
+            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;
@@ -654,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,
@@ -678,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);
@@ -732,25 +769,21 @@ 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,
             hash: next.hash,
             search: next.searchStr
-          }, {
+          }, _rollupPluginBabelHelpers["extends"]({
             id
-          });
+          }, next.state));
         } else {
           history.push({
             pathname: next.pathname,
@@ -760,30 +793,35 @@ function createRouter(userOptions) {
             id
           });
         }
-
         router.navigationPromise = new Promise(resolve => {
           const previousNavigationResolve = router.resolveNavigation;
-
           router.resolveNavigation = () => {
             previousNavigationResolve();
             resolve();
+            delete router.navigationPromise;
           };
         });
         return router.navigationPromise;
       }
     }
   };
-  router.location = router.__.parseLocation(history.location);
-  router.state.location = router.location;
-  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));
+    }
+  });
+}
 
 exports.createRouter = createRouter;
 //# sourceMappingURL=router.js.map