@tanstack/router-core 0.0.1-alpha.3 → 0.0.1-alpha.5

package/build/esm/index.js

@@ -835,6 +835,20 @@ function parsePath(path) {
   return parsedPath;
 }
 
+var isProduction = process.env.NODE_ENV === 'production';
+var prefix = 'Invariant failed';
+function invariant(condition, message) {
+    if (condition) {
+        return;
+    }
+    if (isProduction) {
+        throw new Error(prefix);
+    }
+    var provided = typeof message === 'function' ? message() : message;
+    var value = provided ? "".concat(prefix, ": ").concat(provided) : prefix;
+    throw new Error(value);
+}
+
 // @ts-nocheck
 // We're inlining qss here for compression's sake, but we've included it as a hard dependency for the MIT license it requires.
 function encode(obj, pfx) {
@@ -888,7 +902,7 @@ function decode(str) {
   return out;
 }
 
-const createRouteConfig = function createRouteConfig(options, children, isRoot, parentId) {
+const createRouteConfig = function createRouteConfig(options, children, isRoot, parentId, parentPath) {
   if (options === void 0) {
     options = {};
   }
@@ -899,8 +913,6 @@ const createRouteConfig = function createRouteConfig(options, children, isRoot,
 
   if (isRoot) {
     options.path = rootRouteId;
-  } else {
-    warning(!options.path, 'Routes must have a path property.');
   } // Strip the root from parentIds
 
 
@@ -908,13 +920,14 @@ const createRouteConfig = function createRouteConfig(options, children, isRoot,
     parentId = '';
   }
 
-  let path = String(isRoot ? rootRouteId : options.path); // If the path is anything other than an index path, trim it up
+  let path = isRoot ? rootRouteId : options.path; // If the path is anything other than an index path, trim it up
 
-  if (path !== '/') {
+  if (path && path !== '/') {
     path = trimPath(path);
   }
 
-  let id = joinPaths([parentId, path]);
+  const routeId = path || options.id;
+  let id = joinPaths([parentId, routeId]);
 
   if (path === rootRouteId) {
     path = '/';
@@ -924,14 +937,15 @@ const createRouteConfig = function createRouteConfig(options, children, isRoot,
     id = joinPaths(['/', id]);
   }
 
-  const fullPath = id === rootRouteId ? '/' : trimPathRight(id);
+  const fullPath = id === rootRouteId ? '/' : trimPathRight(joinPaths([parentPath, path]));
   return {
     id: id,
+    routeId: routeId,
     path: path,
     fullPath: fullPath,
     options: options,
     children,
-    addChildren: cb => createRouteConfig(options, cb(childOptions => createRouteConfig(childOptions, undefined, false, id)), false, parentId)
+    addChildren: cb => createRouteConfig(options, cb(childOptions => createRouteConfig(childOptions, undefined, false, id, fullPath)), false, parentId, parentPath)
   };
 };
 const rootRouteId = '__root__';
@@ -954,6 +968,7 @@ function createRouter(userOptions) {
   let router = {
     options: originalOptions,
     listeners: [],
+    removeActionQueue: [],
     // Resolved after construction
     basepath: '',
     routeTree: undefined,
@@ -1077,12 +1092,14 @@ function createRouter(userOptions) {
         strictParseParams: true
       });
       const toMatches = router.matchRoutes(pathname);
-      const prevParams = (_last = last(fromMatches)) == null ? void 0 : _last.params;
+
+      const prevParams = _extends$1({}, (_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));
+          Object.assign({}, nextParams, fn(nextParams));
         });
       }
 
@@ -1185,22 +1202,33 @@ function createRouter(userOptions) {
       router.startedLoadingAt = id;
 
       if (next) {
+        // If the location.href has changed
         // Ingest the new location
         router.location = next;
-      } // Cancel any pending matches
+      } // 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
 
       const unloadedMatches = router.matchRoutes(location.pathname, {
         strictParseParams: true
       });
-      unloadedMatches.forEach((match, index) => {
-        const parent = unloadedMatches[index - 1];
-        const child = unloadedMatches[index + 1];
-        if (parent) match.__.setParentMatch(parent);
-        if (child) match.__.addChildMatch(child);
-      });
       router.state = _extends$1({}, router.state, {
         pending: {
           matches: unloadedMatches,
@@ -1307,59 +1335,81 @@ function createRouter(userOptions) {
 
       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, parentMatch) => {
-        var _parentMatch$params, _router$options$filte, _router$preloadCache$, _route$childRoutes2;
+      const recurse = async routes => {
+        var _parentMatch$params, _router$options$filte, _foundRoute$childRout;
 
+        const parentMatch = 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;
-        const route = filteredRoutes == null ? void 0 : filteredRoutes.find(route => {
-          var _route$childRoutes, _route$options$caseSe;
-
-          const fuzzy = !!(route.routePath !== '/' || (_route$childRoutes = route.childRoutes) != null && _route$childRoutes.length);
-          const matchParams = matchPathname(pathname, {
-            to: route.fullPath,
-            fuzzy,
-            caseSensitive: (_route$options$caseSe = route.options.caseSensitive) != null ? _route$options$caseSe : router.options.caseSensitive
-          });
+        let foundRoutes = [];
 
-          if (matchParams) {
-            let parsedParams;
+        const findMatchInRoutes = (parentRoutes, routes) => {
+          routes.some(route => {
+            var _route$childRoutes, _route$childRoutes2, _route$options$caseSe;
 
-            try {
-              var _route$options$parseP;
+            if (!route.routePath && (_route$childRoutes = route.childRoutes) != null && _route$childRoutes.length) {
+              return findMatchInRoutes([...foundRoutes, route], route.childRoutes);
+            }
 
-              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;
+            const fuzzy = !!(route.routePath !== '/' || (_route$childRoutes2 = route.childRoutes) != null && _route$childRoutes2.length);
+            const matchParams = 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 = _extends$1({}, params, parsedParams);
             }
 
-            params = _extends$1({}, params, parsedParams);
-          }
+            if (!!matchParams) {
+              foundRoutes = [...parentRoutes, route];
+            }
 
-          return !!matchParams;
-        });
+            return !!foundRoutes.length;
+          });
+          return !!foundRoutes.length;
+        };
 
-        if (!route) {
+        findMatchInRoutes([], filteredRoutes);
+
+        if (!foundRoutes.length) {
           return;
         }
 
-        const interpolatedPath = interpolatePath(route.routePath, params);
-        const matchId = interpolatePath(route.routeId, params, true);
-        const match = existingMatches.find(d => d.matchId === matchId) || ((_router$preloadCache$ = router.preloadCache[matchId]) == null ? void 0 : _router$preloadCache$.match) || createRouteMatch(router, route, {
-          matchId,
-          params,
-          pathname: joinPaths([pathname, interpolatedPath])
+        foundRoutes.forEach(foundRoute => {
+          var _router$preloadCache$;
+
+          const interpolatedPath = interpolatePath(foundRoute.routePath, params);
+          const matchId = interpolatePath(foundRoute.routeId, params, true);
+          const match = existingMatches.find(d => d.matchId === matchId) || ((_router$preloadCache$ = router.preloadCache[matchId]) == null ? void 0 : _router$preloadCache$.match) || createRouteMatch(router, foundRoute, {
+            matchId,
+            params,
+            pathname: joinPaths([pathname, interpolatedPath])
+          });
+          matches.push(match);
         });
-        matches.push(match);
+        const foundRoute = last(foundRoutes);
 
-        if ((_route$childRoutes2 = route.childRoutes) != null && _route$childRoutes2.length) {
-          recurse(route.childRoutes, match);
+        if ((_foundRoute$childRout = foundRoute.childRoutes) != null && _foundRoute$childRout.length) {
+          recurse(foundRoute.childRoutes);
         }
       };
 
       recurse([router.routeTree]);
+      cascadeLoaderData(matches);
       return matches;
     },
     loadMatches: async (resolvedMatches, loaderOpts) => {
@@ -1438,14 +1488,14 @@ function createRouter(userOptions) {
       const next = router.buildNext(location);
       return router.commitLocation(next, location.replace);
     },
-    navigate: async _ref => {
+    navigate: async _ref2 => {
       let {
         from,
         to = '.',
         search,
         hash,
         replace
-      } = _ref;
+      } = _ref2;
       // 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
@@ -1459,14 +1509,7 @@ function createRouter(userOptions) {
         isExternal = true;
       } catch (e) {}
 
-      if (isExternal) {
-        if (process.env.NODE_ENV !== 'production') {
-          throw new Error('Attempting to navigate to external url with router.navigate!');
-        }
-
-        return;
-      }
-
+      invariant(!isExternal, 'Attempting to navigate to external url with router.navigate!');
       return router._navigate({
         from: fromString,
         to: toString,
@@ -1474,8 +1517,8 @@ function createRouter(userOptions) {
         hash
       });
     },
-    buildLink: _ref2 => {
-      var _preload, _ref3, _ref4;
+    buildLink: _ref3 => {
+      var _preload, _ref4, _ref5;
 
       let {
         from,
@@ -1490,7 +1533,7 @@ function createRouter(userOptions) {
         preloadMaxAge: userPreloadMaxAge,
         preloadDelay: userPreloadDelay,
         disabled
-      } = _ref2;
+      } = _ref3;
 
       // If this link simply reloads the current route,
       // make sure it has a new key so it will trigger a data refresh
@@ -1514,8 +1557,8 @@ function createRouter(userOptions) {
       };
       const next = router.buildNext(nextOpts);
       preload = (_preload = preload) != null ? _preload : router.options.defaultLinkPreload;
-      const preloadMaxAge = (_ref3 = userPreloadMaxAge != null ? userPreloadMaxAge : router.options.defaultLinkPreloadMaxAge) != null ? _ref3 : 2000;
-      const preloadDelay = (_ref4 = userPreloadDelay != null ? userPreloadDelay : router.options.defaultLinkPreloadDelay) != null ? _ref4 : 50; // Compare path/hash for matches
+      const preloadMaxAge = (_ref4 = userPreloadMaxAge != null ? userPreloadMaxAge : router.options.defaultLinkPreloadMaxAge) != null ? _ref4 : 2000;
+      const preloadDelay = (_ref5 = userPreloadDelay != null ? userPreloadDelay : router.options.defaultLinkPreloadDelay) != null ? _ref5 : 50; // Compare path/hash for matches
 
       const pathIsEqual = router.state.location.pathname === next.pathname;
       const currentPathSplit = router.state.location.pathname.split('/');
@@ -1589,11 +1632,11 @@ function createRouter(userOptions) {
     },
     __experimental__createSnapshot: () => {
       return _extends$1({}, router.state, {
-        matches: router.state.matches.map(_ref5 => {
+        matches: router.state.matches.map(_ref6 => {
           let {
             routeLoaderData: loaderData,
             matchId
-          } = _ref5;
+          } = _ref6;
           return {
             matchId,
             loaderData
@@ -1621,13 +1664,14 @@ function createRoute(routeConfig, options, parent, router) {
   //       ]).replace(new RegExp(`^${rootRouteId}`), '')
   // ) as TRouteInfo['id']
   const {
-    id: routeId,
+    id,
+    routeId,
     path: routePath,
     fullPath
   } = routeConfig;
 
-  const action = router.state.actions[routeId] || (() => {
-    router.state.actions[routeId] = {
+  const action = router.state.actions[id] || (() => {
+    router.state.actions[id] = {
       pending: [],
       submit: async (submission, actionOpts) => {
         var _actionOpts$invalidat;
@@ -1642,10 +1686,12 @@ function createRoute(routeConfig, options, parent, router) {
           status: 'pending',
           submission
         };
+        action.current = actionState;
         action.latest = actionState;
         action.pending.push(actionState);
         router.state = _extends$1({}, router.state, {
-          action: actionState
+          currentAction: actionState,
+          latestAction: actionState
         });
         router.notify();
 
@@ -1669,20 +1715,20 @@ function createRoute(routeConfig, options, parent, router) {
           actionState.status = 'error';
         } finally {
           action.pending = action.pending.filter(d => d !== actionState);
-
-          if (actionState === router.state.action) {
-            router.state.action = undefined;
-          }
-
+          router.removeActionQueue.push({
+            action,
+            actionState
+          });
           router.notify();
         }
       }
     };
-    return router.state.actions[routeId];
+    return router.state.actions[id];
   })();
 
   let route = {
-    routeId,
+    routeId: id,
+    routeRouteId: routeId,
     routePath,
     fullPath,
     options,
@@ -1759,16 +1805,17 @@ function createRouteMatch(router, route, opts) {
         clearTimeout(routeMatch.__.pendingMinTimeout);
         delete routeMatch.__.pendingMinPromise;
       },
-      setParentMatch: parentMatch => {
-        routeMatch.parentMatch = parentMatch;
-      },
-      addChildMatch: childMatch => {
-        if (routeMatch.childMatches.find(d => d.matchId === childMatch.matchId)) {
-          return;
-        }
-
-        routeMatch.childMatches.push(childMatch);
-      },
+      // setParentMatch: (parentMatch?: RouteMatch) => {
+      //   routeMatch.parentMatch = parentMatch
+      // },
+      // addChildMatch: (childMatch: RouteMatch) => {
+      //   if (
+      //     routeMatch.childMatches.find((d) => d.matchId === childMatch.matchId)
+      //   ) {
+      //     return
+      //   }
+      //   routeMatch.childMatches.push(childMatch)
+      // },
       validate: () => {
         var _routeMatch$parentMat, _routeMatch$parentMat2;
 
@@ -1872,7 +1919,6 @@ function createRouteMatch(router, route, opts) {
               }
 
               routeMatch.routeLoaderData = replaceEqualDeep(routeMatch.routeLoaderData, data);
-              cascadeLoaderData(routeMatch);
               routeMatch.error = undefined;
               routeMatch.status = 'success';
               routeMatch.updatedAt = Date.now();
@@ -1932,16 +1978,14 @@ function createRouteMatch(router, route, opts) {
   return routeMatch;
 }
 
-function cascadeLoaderData(routeMatch) {
-  if (routeMatch.parentMatch) {
-    routeMatch.loaderData = replaceEqualDeep(routeMatch.loaderData, _extends$1({}, routeMatch.parentMatch.loaderData, routeMatch.routeLoaderData));
-  }
+function cascadeLoaderData(matches) {
+  matches.forEach((match, index) => {
+    const parent = matches[index - 1];
 
-  if (routeMatch.childMatches.length) {
-    routeMatch.childMatches.forEach(childMatch => {
-      cascadeLoaderData(childMatch);
-    });
-  }
+    if (parent) {
+      match.loaderData = replaceEqualDeep(match.loaderData, _extends$1({}, parent.loaderData, match.routeLoaderData));
+    }
+  });
 }
 
 function matchPathname(currentPathname, matchLocation) {
@@ -2293,5 +2337,5 @@ function last(arr) {
   return arr[arr.length - 1];
 }
 
-export { createBrowserHistory, createHashHistory, createMemoryHistory, createRoute, createRouteConfig, createRouteMatch, createRouter, defaultParseSearch, defaultStringifySearch, functionalUpdate, last, matchByPath, matchPathname, parsePathname, parseSearchWith, replaceEqualDeep, _resolvePath as resolvePath, rootRouteId, stringifySearchWith, warning };
+export { createBrowserHistory, createHashHistory, createMemoryHistory, createRoute, createRouteConfig, createRouteMatch, createRouter, defaultParseSearch, defaultStringifySearch, functionalUpdate, invariant, last, matchByPath, matchPathname, parsePathname, parseSearchWith, replaceEqualDeep, _resolvePath as resolvePath, rootRouteId, stringifySearchWith, warning };
 //# sourceMappingURL=index.js.map