@tanstack/router-core 0.0.1-beta.156 → 0.0.1-beta.158

package/build/umd/index.development.js

@@ -731,7 +731,7 @@
     }
 
     const defaultParseSearch = parseSearchWith(JSON.parse);
-    const defaultStringifySearch = stringifySearchWith(JSON.stringify);
+    const defaultStringifySearch = stringifySearchWith(JSON.stringify, JSON.parse);
     function parseSearchWith(parser) {
       return searchStr => {
         if (searchStr.substring(0, 1) === '?') {
@@ -753,7 +753,26 @@
         return query;
       };
     }
-    function stringifySearchWith(stringify) {
+    function stringifySearchWith(stringify, parser) {
+      function stringifyValue(val) {
+        if (typeof val === 'object' && val !== null) {
+          try {
+            return stringify(val);
+          } catch (err) {
+            // silent
+          }
+        } else if (typeof val === 'string' && typeof parser === 'function') {
+          try {
+            // Check if it's a valid parseable string.
+            // If it is, then stringify it again.
+            parser(val);
+            return stringify(val);
+          } catch (err) {
+            // silent
+          }
+        }
+        return val;
+      }
       return search => {
         search = {
           ...search
@@ -763,12 +782,10 @@
             const val = search[key];
             if (typeof val === 'undefined' || val === undefined) {
               delete search[key];
-            } else if (val && typeof val === 'object' && val !== null) {
-              try {
-                search[key] = stringify(val);
-              } catch (err) {
-                // silent
-              }
+            } else if (Array.isArray(val)) {
+              search[key] = val.map(stringifyValue);
+            } else {
+              search[key] = stringifyValue(val);
             }
           });
         }
@@ -1044,42 +1061,36 @@
           if (routeCursor) matchedRoutes.unshift(routeCursor);
         }
 
-        // Alright, by now we should have all of our
-        // matching routes and their param pairs, let's
-        // Turn them into actual `Match` objects and
-        // accumulate the params into a single params bag
-        let allParams = {};
-
         // Existing matches are matches that are already loaded along with
         // pending matches that are still loading
 
-        const matches = matchedRoutes.map(route => {
-          let parsedParams;
+        const parseErrors = matchedRoutes.map(route => {
           let parsedParamsError;
-          try {
-            parsedParams = route.options.parseParams?.(routeParams) ?? routeParams;
-            // (typeof route.options.parseParams === 'object' &&
-            // route.options.parseParams.parse
-            //   ? route.options.parseParams.parse(routeParams)
-            //   : (route.options.parseParams as any)?.(routeParams!)) ?? routeParams
-          } catch (err) {
-            parsedParamsError = new PathParamError(err.message, {
-              cause: err
-            });
-            if (opts?.throwOnError) {
-              throw parsedParamsError;
+          if (route.options.parseParams) {
+            try {
+              const parsedParams = route.options.parseParams(routeParams);
+              // Add the parsed params to the accumulated params bag
+              Object.assign(routeParams, parsedParams);
+            } catch (err) {
+              parsedParamsError = new PathParamError(err.message, {
+                cause: err
+              });
+              if (opts?.throwOnError) {
+                throw parsedParamsError;
+              }
+              return parsedParamsError;
             }
           }
-
-          // Add the parsed params to the accumulated params bag
-          Object.assign(allParams, parsedParams);
-          const interpolatedPath = interpolatePath(route.path, allParams);
+          return;
+        });
+        const matches = matchedRoutes.map((route, index) => {
+          const interpolatedPath = interpolatePath(route.path, routeParams);
           const key = route.options.key ? route.options.key({
-            params: allParams,
+            params: routeParams,
             search: locationSearch
           }) ?? '' : '';
           const stringifiedKey = key ? JSON.stringify(key) : '';
-          const matchId = interpolatePath(route.id, allParams, true) + stringifiedKey;
+          const matchId = interpolatePath(route.id, routeParams, true) + stringifiedKey;
 
           // Waste not, want not. If we already have a match for this route,
           // reuse it. This is important for layout routes, which might stick
@@ -1097,7 +1108,7 @@
             id: matchId,
             key: stringifiedKey,
             routeId: route.id,
-            params: allParams,
+            params: routeParams,
             pathname: joinPaths([this.basepath, interpolatedPath]),
             updatedAt: Date.now(),
             invalidAt: Infinity,
@@ -1108,7 +1119,7 @@
             isFetching: false,
             invalid: false,
             error: undefined,
-            paramsError: parsedParamsError,
+            paramsError: parseErrors[index],
             searchError: undefined,
             loaderData: undefined,
             loadPromise: Promise.resolve(),