@tanstack/router-core 0.0.1-alpha.8 → 0.0.1-beta.1

package/build/esm/index.js

@@ -1260,6 +1260,40 @@ function createRoute(routeConfig, options, parent, router) {
     return router.state.actions[id];
   })();
 
+  const loader = router.state.loaders[id] || (() => {
+    router.state.loaders[id] = {
+      pending: [],
+      fetch: async loaderContext => {
+        if (!route) {
+          return;
+        }
+
+        const loaderState = {
+          loadedAt: Date.now(),
+          loaderContext
+        };
+        loader.current = loaderState;
+        loader.latest = loaderState;
+        loader.pending.push(loaderState); // router.state = {
+        //   ...router.state,
+        //   currentAction: loaderState,
+        //   latestAction: loaderState,
+        // }
+
+        router.notify();
+
+        try {
+          return await (route.options.loader == null ? void 0 : route.options.loader(loaderContext));
+        } finally {
+          loader.pending = loader.pending.filter(d => d !== loaderState); // router.removeActionQueue.push({ loader, loaderState })
+
+          router.notify();
+        }
+      }
+    };
+    return router.state.loaders[id];
+  })();
+
   let route = {
     routeId: id,
     routeRouteId: routeId,
@@ -1270,6 +1304,7 @@ function createRoute(routeConfig, options, parent, router) {
     childRoutes: undefined,
     parentRoute: parent,
     action,
+    loader: loader,
     buildLink: options => {
       return router.buildLink(_extends({}, options, {
         from: fullPath
@@ -1365,12 +1400,10 @@ function createRouteMatch(router, route, opts) {
     isPending: false,
     isFetching: false,
     isInvalid: false,
+    invalidAt: Infinity,
     getIsInvalid: () => {
-      var _ref, _routeMatch$options$l;
-
       const now = Date.now();
-      const maxAge = (_ref = (_routeMatch$options$l = routeMatch.options.loaderMaxAge) != null ? _routeMatch$options$l : router.options.defaultLoaderMaxAge) != null ? _ref : 0;
-      return routeMatch.isInvalid || routeMatch.updatedAt + maxAge < now;
+      return routeMatch.isInvalid || routeMatch.invalidAt < now;
     },
     __: {
       abortController: new AbortController(),
@@ -1459,9 +1492,33 @@ function createRouteMatch(router, route, opts) {
       routeMatch.isInvalid = true;
     },
     hasLoaders: () => {
-      return !!(route.options.loader || route.options.import || elementTypes.some(d => typeof route.options[d] === 'function'));
+      return !!(route.options.loader || elementTypes.some(d => typeof route.options[d] === 'function'));
+    },
+    load: async loaderOpts => {
+      const now = Date.now();
+      const minMaxAge = loaderOpts != null && loaderOpts.preload ? Math.max(loaderOpts == null ? void 0 : loaderOpts.maxAge, loaderOpts == null ? void 0 : loaderOpts.gcMaxAge) : 0; // If this is a preload, add it to the preload cache
+
+      if (loaderOpts != null && loaderOpts.preload && minMaxAge > 0) {
+        // If the match is currently active, don't preload it
+        if (router.state.matches.find(d => d.matchId === routeMatch.matchId)) {
+          return;
+        }
+
+        router.matchCache[routeMatch.matchId] = {
+          gc: now + loaderOpts.gcMaxAge,
+          match: routeMatch
+        };
+      } // If the match is invalid, errored or idle, trigger it to load
+
+
+      if (routeMatch.status === 'success' && routeMatch.getIsInvalid() || routeMatch.status === 'error' || routeMatch.status === 'idle') {
+        const maxAge = loaderOpts != null && loaderOpts.preload ? loaderOpts == null ? void 0 : loaderOpts.maxAge : undefined;
+        routeMatch.fetch({
+          maxAge
+        });
+      }
     },
-    load: async () => {
+    fetch: async opts => {
       const id = '' + Date.now() + Math.random();
       routeMatch.__.latestId = id; // If the match was in an error state, set it
       // to a loading state again. Otherwise, keep it
@@ -1480,21 +1537,7 @@ function createRouteMatch(router, route, opts) {
         routeMatch.__.resolve = resolve;
 
         const loaderPromise = (async () => {
-          const importer = routeMatch.options.import; // First, run any importers
-
-          if (importer) {
-            routeMatch.__.importPromise = importer({
-              params: routeMatch.params // search: routeMatch.search,
-
-            }).then(imported => {
-              routeMatch.__ = _extends({}, routeMatch.__, imported);
-            });
-          } // Wait for the importer to finish before
-          // attempting to load elements and data
-
-
-          await routeMatch.__.importPromise; // Next, load the elements and data in parallel
-
+          // Load the elements and data in parallel
           routeMatch.__.elementsPromise = (async () => {
             // then run all element and data loaders in parallel
             // For each element type, potentially load it asynchronously
@@ -1505,17 +1548,14 @@ function createRouteMatch(router, route, opts) {
                 return;
               }
 
-              if (typeof routeElement === 'function') {
-                const res = await routeElement(routeMatch);
-                routeMatch.__[type] = res;
-              } else {
-                routeMatch.__[type] = routeMatch.options[type];
-              }
+              routeMatch.__[type] = await router.options.createElement(routeElement);
             }));
           })();
 
           routeMatch.__.dataPromise = Promise.resolve().then(async () => {
             try {
+              var _ref, _ref2, _opts$maxAge;
+
               if (routeMatch.options.loader) {
                 const data = await routeMatch.options.loader({
                   params: routeMatch.params,
@@ -1533,6 +1573,7 @@ function createRouteMatch(router, route, opts) {
               routeMatch.error = undefined;
               routeMatch.status = 'success';
               routeMatch.updatedAt = Date.now();
+              routeMatch.invalidAt = routeMatch.updatedAt + ((_ref = (_ref2 = (_opts$maxAge = opts == null ? void 0 : opts.maxAge) != null ? _opts$maxAge : routeMatch.options.loaderMaxAge) != null ? _ref2 : router.options.defaultLoaderMaxAge) != null ? _ref : 0);
             } catch (err) {
               if (id !== routeMatch.__.latestId) {
                 return routeMatch.__.loaderPromise;
@@ -1655,13 +1696,15 @@ function createRouter(userOptions) {
   const originalOptions = _extends({
     defaultLoaderGcMaxAge: 5 * 60 * 1000,
     defaultLoaderMaxAge: 0,
-    defaultLinkPreloadDelay: 50
+    defaultPreloadMaxAge: 2000,
+    defaultPreloadDelay: 50
   }, userOptions, {
     stringifySearch: (_userOptions$stringif = userOptions == null ? void 0 : userOptions.stringifySearch) != null ? _userOptions$stringif : defaultStringifySearch,
     parseSearch: (_userOptions$parseSea = userOptions == null ? void 0 : userOptions.parseSearch) != null ? _userOptions$parseSea : defaultParseSearch
   });
 
   let router = {
+    history,
     options: originalOptions,
     listeners: [],
     removeActionQueue: [],
@@ -1680,6 +1723,7 @@ function createRouter(userOptions) {
       location: null,
       matches: [],
       actions: {},
+      loaders: {},
       loaderData: {},
       lastUpdated: Date.now(),
       isFetching: false,
@@ -1704,21 +1748,22 @@ function createRouter(userOptions) {
       router.listeners.forEach(listener => listener());
     },
     mount: () => {
-      const next = router.buildLocation({
+      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 (next.href !== router.location.href) {
-        router.commitLocation(next, true);
+        router.__.commitLocation(next, true);
       } else {
         router.loadLocation();
       }
 
       const unsub = history.listen(event => {
-        router.loadLocation(router.parseLocation(event.location, router.location));
+        router.loadLocation(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
 
@@ -1748,169 +1793,11 @@ function createRouter(userOptions) {
 
       if (routeConfig) {
         router.routesById = {};
-        router.routeTree = router.buildRouteTree(routeConfig);
+        router.routeTree = router.__.buildRouteTree(routeConfig);
       }
 
       return router;
     },
-    buildRouteTree: rootRouteConfig => {
-      const recurseRoutes = (routeConfigs, parent) => {
-        return routeConfigs.map(routeConfig => {
-          const routeOptions = routeConfig.options;
-          const route = createRoute(routeConfig, routeOptions, parent, router); // {
-          //   pendingMs: routeOptions.pendingMs ?? router.defaultPendingMs,
-          //   pendingMinMs: routeOptions.pendingMinMs ?? router.defaultPendingMinMs,
-          // }
-
-          const existingRoute = router.routesById[route.routeId];
-
-          if (existingRoute) {
-            if (process.env.NODE_ENV !== 'production') {
-              console.warn("Duplicate routes found with id: " + String(route.routeId), router.routesById, route);
-            }
-
-            throw new Error();
-          }
-          router.routesById[route.routeId] = route;
-          const children = routeConfig.children;
-          route.childRoutes = children != null && children.length ? recurseRoutes(children, route) : undefined;
-          return route;
-        });
-      };
-
-      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,
-        searchStr: location.search,
-        search: replaceEqualDeep(previousLocation == null ? void 0 : previousLocation.search, parsedSearch),
-        hash: (_location$hash$split$ = location.hash.split('#').reverse()[0]) != null ? _location$hash$split$ : '',
-        href: "" + location.pathname + location.search + location.hash,
-        state: location.state,
-        key: location.key
-      };
-    },
-    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 = 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 = _extends({}, (_last = last(fromMatches)) == null ? void 0 : _last.params);
-
-      let nextParams = ((_dest$params = dest.params) != null ? _dest$params : true) === true ? prevParams : functionalUpdate(dest.params, prevParams);
-
-      if (nextParams) {
-        toMatches.map(d => d.options.stringifyParams).filter(Boolean).forEach(fn => {
-          Object.assign({}, nextParams, fn(nextParams));
-        });
-      }
-
-      pathname = 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
-
-      const destSearch = dest.search === true ? preFilteredSearch // Preserve resolvedFrom true
-      : dest.search ? (_functionalUpdate = functionalUpdate(dest.search, preFilteredSearch)) != null ? _functionalUpdate : {} // Updater
-      : (_dest$__preSearchFilt2 = dest.__preSearchFilters) != null && _dest$__preSearchFilt2.length ? preFilteredSearch // Preserve resolvedFrom 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 = replaceEqualDeep(router.location.search, postFilteredSearch);
-      const searchStr = router.options.stringifySearch(search);
-      let hash = dest.hash === true ? router.location.hash : functionalUpdate(dest.hash, router.location.hash);
-      hash = hash ? "#" + hash : '';
-      return {
-        pathname,
-        search,
-        searchStr,
-        state: router.location.state,
-        hash,
-        href: "" + pathname + searchStr + hash,
-        key: dest.key
-      };
-    },
-    commitLocation: (next, replace) => {
-      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
-        }, {
-          id
-        });
-      } else {
-        history.push({
-          pathname: next.pathname,
-          hash: next.hash,
-          search: next.searchStr
-        }, {
-          id
-        });
-      }
-
-      router.navigationPromise = new Promise(resolve => {
-        const previousNavigationResolve = router.resolveNavigation;
-
-        router.resolveNavigation = () => {
-          previousNavigationResolve();
-          resolve();
-        };
-      });
-      return router.navigationPromise;
-    },
-    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(_extends({}, opts, {
-        __preSearchFilters,
-        __postSearchFilters
-      }));
-    },
     cancelMatches: () => {
       var _router$state$pending, _router$state$pending2;
       [...router.state.matches, ...((_router$state$pending = (_router$state$pending2 = router.state.pending) == null ? void 0 : _router$state$pending2.matches) != null ? _router$state$pending : [])].forEach(match => {
@@ -2013,6 +1900,7 @@ function createRouter(userOptions) {
           params: d.params,
           search: d.search
         });
+        delete router.matchCache[d.matchId];
       });
 
       if (matches.some(d => d.status === 'loading')) {
@@ -2052,7 +1940,21 @@ function createRouter(userOptions) {
         delete router.matchCache[matchId];
       });
     },
-    loadRoute: async function loadRoute(navigateOpts, loaderOpts) {
+    loadRoute: async function loadRoute(navigateOpts) {
+      if (navigateOpts === void 0) {
+        navigateOpts = router.location;
+      }
+
+      const next = router.buildNext(navigateOpts);
+      const matches = router.matchRoutes(next.pathname, {
+        strictParseParams: true
+      });
+      await router.loadMatches(matches);
+      return matches;
+    },
+    preloadRoute: async function preloadRoute(navigateOpts, loaderOpts) {
+      var _ref4, _ref5, _loaderOpts$maxAge, _ref6, _ref7, _loaderOpts$gcMaxAge;
+
       if (navigateOpts === void 0) {
         navigateOpts = router.location;
       }
@@ -2063,7 +1965,8 @@ function createRouter(userOptions) {
       });
       await router.loadMatches(matches, {
         preload: true,
-        maxAge: loaderOpts.maxAge
+        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
       });
       return matches;
     },
@@ -2157,33 +2060,11 @@ function createRouter(userOptions) {
       return matches;
     },
     loadMatches: async (resolvedMatches, loaderOpts) => {
-      const now = Date.now();
       const matchPromises = resolvedMatches.map(async match => {
         // Validate the match (loads search params etc)
-        match.__.validate(); // // If the match doesn't have a loader, don't attempt to load it
-        // if (!match.hasLoaders()) {
-        //   return
-        // }
-        // If this is a preload, add it to the preload cache
-
-
-        if (loaderOpts != null && loaderOpts.preload && (loaderOpts == null ? void 0 : loaderOpts.maxAge) > 0) {
-          // If the match is currently active, don't preload it
-          if (router.state.matches.find(d => d.matchId === match.matchId)) {
-            return;
-          }
-
-          router.matchCache[match.matchId] = {
-            gc: now + loaderOpts.maxAge,
-            // TODO: Should this use the route's maxAge?
-            match
-          };
-        } // If the match is invalid, errored or idle, trigger it to load
-
+        match.__.validate();
 
-        if (match.status === 'success' && match.getIsInvalid() || match.status === 'error' || match.status === 'idle') {
-          match.load();
-        }
+        match.load(loaderOpts);
 
         if (match.status === 'loading') {
           // If requested, start the pending timers
@@ -2207,7 +2088,7 @@ function createRouter(userOptions) {
         }
       });
     },
-    reload: () => router._navigate({
+    reload: () => router.__.navigate({
       fromCurrent: true,
       replace: true,
       search: true
@@ -2240,11 +2121,7 @@ function createRouter(userOptions) {
         to: next.pathname
       }));
     },
-    _navigate: location => {
-      const next = router.buildNext(location);
-      return router.commitLocation(next, location.replace);
-    },
-    navigate: async _ref4 => {
+    navigate: async _ref8 => {
       let {
         from,
         to = '.',
@@ -2252,7 +2129,7 @@ function createRouter(userOptions) {
         hash,
         replace,
         params
-      } = _ref4;
+      } = _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
@@ -2267,7 +2144,7 @@ function createRouter(userOptions) {
       } catch (e) {}
 
       invariant(!isExternal, 'Attempting to navigate to external url with router.navigate!');
-      return router._navigate({
+      return router.__.navigate({
         from: fromString,
         to: toString,
         search,
@@ -2276,8 +2153,8 @@ function createRouter(userOptions) {
         params
       });
     },
-    buildLink: _ref5 => {
-      var _preload, _ref6, _ref7, _ref8;
+    buildLink: _ref9 => {
+      var _preload, _ref10;
 
       let {
         from,
@@ -2290,9 +2167,10 @@ function createRouter(userOptions) {
         activeOptions,
         preload,
         preloadMaxAge: userPreloadMaxAge,
+        preloadGcMaxAge: userPreloadGcMaxAge,
         preloadDelay: userPreloadDelay,
         disabled
-      } = _ref5;
+      } = _ref9;
 
       // If this link simply reloads the current route,
       // make sure it has a new key so it will trigger a data refresh
@@ -2315,9 +2193,8 @@ function createRouter(userOptions) {
         replace
       };
       const next = router.buildNext(nextOpts);
-      preload = (_preload = preload) != null ? _preload : router.options.defaultLinkPreload;
-      const preloadMaxAge = (_ref6 = (_ref7 = userPreloadMaxAge != null ? userPreloadMaxAge : router.options.defaultLinkPreloadMaxAge) != null ? _ref7 : router.options.defaultLoaderGcMaxAge) != null ? _ref6 : 0;
-      const preloadDelay = (_ref8 = userPreloadDelay != null ? userPreloadDelay : router.options.defaultLinkPreloadDelay) != null ? _ref8 : 0; // Compare path/hash for matches
+      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 pathIsEqual = router.state.location.pathname === next.pathname;
       const currentPathSplit = router.state.location.pathname.split('/');
@@ -2339,15 +2216,16 @@ function createRouter(userOptions) {
           } // All is well? Navigate!)
 
 
-          router._navigate(nextOpts);
+          router.__.navigate(nextOpts);
         }
       }; // The click handler
 
 
       const handleFocus = e => {
-        if (preload && preloadMaxAge > 0) {
-          router.loadRoute(nextOpts, {
-            maxAge: preloadMaxAge
+        if (preload) {
+          router.preloadRoute(nextOpts, {
+            maxAge: userPreloadMaxAge,
+            gcMaxAge: userPreloadGcMaxAge
           });
         }
       };
@@ -2355,15 +2233,16 @@ function createRouter(userOptions) {
       const handleEnter = e => {
         const target = e.target || {};
 
-        if (preload && preloadMaxAge > 0) {
+        if (preload) {
           if (target.preloadTimeout) {
             return;
           }
 
           target.preloadTimeout = setTimeout(() => {
             target.preloadTimeout = null;
-            router.loadRoute(nextOpts, {
-              maxAge: preloadMaxAge
+            router.preloadRoute(nextOpts, {
+              maxAge: userPreloadMaxAge,
+              gcMaxAge: userPreloadGcMaxAge
             });
           }, preloadDelay);
         }
@@ -2388,9 +2267,174 @@ function createRouter(userOptions) {
         isActive,
         disabled
       };
+    },
+    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(_extends({}, opts, {
+        __preSearchFilters,
+        __postSearchFilters
+      }));
+    },
+    __: {
+      buildRouteTree: rootRouteConfig => {
+        const recurseRoutes = (routeConfigs, parent) => {
+          return routeConfigs.map(routeConfig => {
+            const routeOptions = routeConfig.options;
+            const route = createRoute(routeConfig, routeOptions, parent, router); // {
+            //   pendingMs: routeOptions.pendingMs ?? router.defaultPendingMs,
+            //   pendingMinMs: routeOptions.pendingMinMs ?? router.defaultPendingMinMs,
+            // }
+
+            const existingRoute = router.routesById[route.routeId];
+
+            if (existingRoute) {
+              if (process.env.NODE_ENV !== 'production') {
+                console.warn("Duplicate routes found with id: " + String(route.routeId), router.routesById, route);
+              }
+
+              throw new Error();
+            }
+            router.routesById[route.routeId] = route;
+            const children = routeConfig.children;
+            route.childRoutes = children != null && children.length ? recurseRoutes(children, route) : undefined;
+            return route;
+          });
+        };
+
+        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,
+          searchStr: location.search,
+          search: replaceEqualDeep(previousLocation == null ? void 0 : previousLocation.search, parsedSearch),
+          hash: (_location$hash$split$ = location.hash.split('#').reverse()[0]) != null ? _location$hash$split$ : '',
+          href: "" + location.pathname + location.search + location.hash,
+          state: location.state,
+          key: location.key
+        };
+      },
+      navigate: location => {
+        const next = router.buildNext(location);
+        return router.__.commitLocation(next, location.replace);
+      },
+      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 = 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 = _extends({}, (_last = last(fromMatches)) == null ? void 0 : _last.params);
+
+        let nextParams = ((_dest$params = dest.params) != null ? _dest$params : true) === true ? prevParams : functionalUpdate(dest.params, prevParams);
+
+        if (nextParams) {
+          toMatches.map(d => d.options.stringifyParams).filter(Boolean).forEach(fn => {
+            Object.assign({}, nextParams, fn(nextParams));
+          });
+        }
+
+        pathname = 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
+
+        const destSearch = dest.search === true ? preFilteredSearch // Preserve resolvedFrom true
+        : dest.search ? (_functionalUpdate = functionalUpdate(dest.search, preFilteredSearch)) != null ? _functionalUpdate : {} // Updater
+        : (_dest$__preSearchFilt2 = dest.__preSearchFilters) != null && _dest$__preSearchFilt2.length ? preFilteredSearch // Preserve resolvedFrom 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 = replaceEqualDeep(router.location.search, postFilteredSearch);
+        const searchStr = router.options.stringifySearch(search);
+        let hash = dest.hash === true ? router.location.hash : functionalUpdate(dest.hash, router.location.hash);
+        hash = hash ? "#" + hash : '';
+        return {
+          pathname,
+          search,
+          searchStr,
+          state: router.location.state,
+          hash,
+          href: "" + pathname + searchStr + hash,
+          key: dest.key
+        };
+      },
+      commitLocation: (next, replace) => {
+        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
+          }, {
+            id
+          });
+        } else {
+          history.push({
+            pathname: next.pathname,
+            hash: next.hash,
+            search: next.searchStr
+          }, {
+            id
+          });
+        }
+
+        router.navigationPromise = new Promise(resolve => {
+          const previousNavigationResolve = router.resolveNavigation;
+
+          router.resolveNavigation = () => {
+            previousNavigationResolve();
+            resolve();
+          };
+        });
+        return router.navigationPromise;
+      }
     }
   };
-  router.location = router.parseLocation(history.location);
+  router.location = router.__.parseLocation(history.location);
   router.state.location = router.location;
   router.update(userOptions); // Allow frameworks to hook into the router creation