@tanstack/router-core 1.121.0-alpha.22 → 1.121.0-alpha.28

package/dist/esm/path.js

@@ -1,4 +1,8 @@
 import { last } from "./utils.js";
+const SEGMENT_TYPE_PATHNAME = 0;
+const SEGMENT_TYPE_PARAM = 1;
+const SEGMENT_TYPE_WILDCARD = 2;
+const SEGMENT_TYPE_OPTIONAL_PARAM = 3;
 function joinPaths(paths) {
   return cleanPath(
     paths.filter((val) => {
@@ -19,7 +23,7 @@ function trimPath(path) {
   return trimPathRight(trimPathLeft(path));
 }
 function removeTrailingSlash(value, basepath) {
-  if ((value == null ? void 0 : value.endsWith("/")) && value !== "/" && value !== `${basepath}/`) {
+  if (value?.endsWith("/") && value !== "/" && value !== `${basepath}/`) {
     return value.slice(0, -1);
   }
   return value;
@@ -27,83 +31,108 @@ function removeTrailingSlash(value, basepath) {
 function exactPathTest(pathName1, pathName2, basepath) {
   return removeTrailingSlash(pathName1, basepath) === removeTrailingSlash(pathName2, basepath);
 }
+function segmentToString(segment) {
+  const { type, value } = segment;
+  if (type === SEGMENT_TYPE_PATHNAME) {
+    return value;
+  }
+  const { prefixSegment, suffixSegment } = segment;
+  if (type === SEGMENT_TYPE_PARAM) {
+    const param = value.substring(1);
+    if (prefixSegment && suffixSegment) {
+      return `${prefixSegment}{$${param}}${suffixSegment}`;
+    } else if (prefixSegment) {
+      return `${prefixSegment}{$${param}}`;
+    } else if (suffixSegment) {
+      return `{$${param}}${suffixSegment}`;
+    }
+  }
+  if (type === SEGMENT_TYPE_OPTIONAL_PARAM) {
+    const param = value.substring(1);
+    if (prefixSegment && suffixSegment) {
+      return `${prefixSegment}{-$${param}}${suffixSegment}`;
+    } else if (prefixSegment) {
+      return `${prefixSegment}{-$${param}}`;
+    } else if (suffixSegment) {
+      return `{-$${param}}${suffixSegment}`;
+    }
+    return `{-$${param}}`;
+  }
+  if (type === SEGMENT_TYPE_WILDCARD) {
+    if (prefixSegment && suffixSegment) {
+      return `${prefixSegment}{$}${suffixSegment}`;
+    } else if (prefixSegment) {
+      return `${prefixSegment}{$}`;
+    } else if (suffixSegment) {
+      return `{$}${suffixSegment}`;
+    }
+  }
+  return value;
+}
 function resolvePath({
   basepath,
   base,
   to,
   trailingSlash = "never",
-  caseSensitive
+  caseSensitive,
+  parseCache
 }) {
-  var _a, _b;
   base = removeBasepath(basepath, base, caseSensitive);
   to = removeBasepath(basepath, to, caseSensitive);
-  let baseSegments = parsePathname(base);
-  const toSegments = parsePathname(to);
-  if (baseSegments.length > 1 && ((_a = last(baseSegments)) == null ? void 0 : _a.value) === "/") {
+  let baseSegments = parsePathname(base, parseCache).slice();
+  const toSegments = parsePathname(to, parseCache);
+  if (baseSegments.length > 1 && last(baseSegments)?.value === "/") {
     baseSegments.pop();
   }
-  toSegments.forEach((toSegment, index) => {
-    if (toSegment.value === "/") {
+  for (let index = 0, length = toSegments.length; index < length; index++) {
+    const toSegment = toSegments[index];
+    const value = toSegment.value;
+    if (value === "/") {
       if (!index) {
         baseSegments = [toSegment];
-      } else if (index === toSegments.length - 1) {
+      } else if (index === length - 1) {
         baseSegments.push(toSegment);
       } else ;
-    } else if (toSegment.value === "..") {
+    } else if (value === "..") {
       baseSegments.pop();
-    } else if (toSegment.value === ".") ;
+    } else if (value === ".") ;
     else {
       baseSegments.push(toSegment);
     }
-  });
+  }
   if (baseSegments.length > 1) {
-    if (((_b = last(baseSegments)) == null ? void 0 : _b.value) === "/") {
+    if (last(baseSegments).value === "/") {
       if (trailingSlash === "never") {
         baseSegments.pop();
       }
     } else if (trailingSlash === "always") {
-      baseSegments.push({ type: "pathname", value: "/" });
+      baseSegments.push({ type: SEGMENT_TYPE_PATHNAME, value: "/" });
     }
   }
-  const segmentValues = baseSegments.map((segment) => {
-    if (segment.type === "param") {
-      const param = segment.value.substring(1);
-      if (segment.prefixSegment && segment.suffixSegment) {
-        return `${segment.prefixSegment}{$${param}}${segment.suffixSegment}`;
-      } else if (segment.prefixSegment) {
-        return `${segment.prefixSegment}{$${param}}`;
-      } else if (segment.suffixSegment) {
-        return `{$${param}}${segment.suffixSegment}`;
-      }
-    }
-    if (segment.type === "wildcard") {
-      if (segment.prefixSegment && segment.suffixSegment) {
-        return `${segment.prefixSegment}{$}${segment.suffixSegment}`;
-      } else if (segment.prefixSegment) {
-        return `${segment.prefixSegment}{$}`;
-      } else if (segment.suffixSegment) {
-        return `{$}${segment.suffixSegment}`;
-      }
-    }
-    return segment.value;
-  });
+  const segmentValues = baseSegments.map(segmentToString);
   const joined = joinPaths([basepath, ...segmentValues]);
-  return cleanPath(joined);
+  return joined;
 }
+const parsePathname = (pathname, cache) => {
+  if (!pathname) return [];
+  const cached = cache?.get(pathname);
+  if (cached) return cached;
+  const parsed = baseParsePathname(pathname);
+  cache?.set(pathname, parsed);
+  return parsed;
+};
 const PARAM_RE = /^\$.{1,}$/;
 const PARAM_W_CURLY_BRACES_RE = /^(.*?)\{(\$[a-zA-Z_$][a-zA-Z0-9_$]*)\}(.*)$/;
+const OPTIONAL_PARAM_W_CURLY_BRACES_RE = /^(.*?)\{-(\$[a-zA-Z_$][a-zA-Z0-9_$]*)\}(.*)$/;
 const WILDCARD_RE = /^\$$/;
 const WILDCARD_W_CURLY_BRACES_RE = /^(.*?)\{\$\}(.*)$/;
-function parsePathname(pathname) {
-  if (!pathname) {
-    return [];
-  }
+function baseParsePathname(pathname) {
   pathname = cleanPath(pathname);
   const segments = [];
   if (pathname.slice(0, 1) === "/") {
     pathname = pathname.substring(1);
     segments.push({
-      type: "pathname",
+      type: SEGMENT_TYPE_PATHNAME,
       value: "/"
     });
   }
@@ -118,19 +147,34 @@ function parsePathname(pathname) {
         const prefix = wildcardBracesMatch[1];
         const suffix = wildcardBracesMatch[2];
         return {
-          type: "wildcard",
+          type: SEGMENT_TYPE_WILDCARD,
           value: "$",
           prefixSegment: prefix || void 0,
           suffixSegment: suffix || void 0
         };
       }
+      const optionalParamBracesMatch = part.match(
+        OPTIONAL_PARAM_W_CURLY_BRACES_RE
+      );
+      if (optionalParamBracesMatch) {
+        const prefix = optionalParamBracesMatch[1];
+        const paramName = optionalParamBracesMatch[2];
+        const suffix = optionalParamBracesMatch[3];
+        return {
+          type: SEGMENT_TYPE_OPTIONAL_PARAM,
+          value: paramName,
+          // Now just $paramName (no prefix)
+          prefixSegment: prefix || void 0,
+          suffixSegment: suffix || void 0
+        };
+      }
       const paramBracesMatch = part.match(PARAM_W_CURLY_BRACES_RE);
       if (paramBracesMatch) {
         const prefix = paramBracesMatch[1];
         const paramName = paramBracesMatch[2];
         const suffix = paramBracesMatch[3];
         return {
-          type: "param",
+          type: SEGMENT_TYPE_PARAM,
           value: "" + paramName,
           prefixSegment: prefix || void 0,
           suffixSegment: suffix || void 0
@@ -139,7 +183,7 @@ function parsePathname(pathname) {
       if (PARAM_RE.test(part)) {
         const paramName = part.substring(1);
         return {
-          type: "param",
+          type: SEGMENT_TYPE_PARAM,
           value: "$" + paramName,
           prefixSegment: void 0,
           suffixSegment: void 0
@@ -147,14 +191,14 @@ function parsePathname(pathname) {
       }
       if (WILDCARD_RE.test(part)) {
         return {
-          type: "wildcard",
+          type: SEGMENT_TYPE_WILDCARD,
           value: "$",
           prefixSegment: void 0,
           suffixSegment: void 0
         };
       }
       return {
-        type: "pathname",
+        type: SEGMENT_TYPE_PATHNAME,
         value: part.includes("%25") ? part.split("%25").map((segment) => decodeURI(segment)).join("%25") : decodeURI(part)
       };
     })
@@ -162,7 +206,7 @@ function parsePathname(pathname) {
   if (pathname.slice(-1) === "/") {
     pathname = pathname.substring(1);
     segments.push({
-      type: "pathname",
+      type: SEGMENT_TYPE_PATHNAME,
       value: "/"
     });
   }
@@ -173,13 +217,14 @@ function interpolatePath({
   params,
   leaveWildcards,
   leaveParams,
-  decodeCharMap
+  decodeCharMap,
+  parseCache
 }) {
-  const interpolatedPathSegments = parsePathname(path);
+  const interpolatedPathSegments = parsePathname(path, parseCache);
   function encodeParam(key) {
     const value = params[key];
     const isValueString = typeof value === "string";
-    if (["*", "_splat"].includes(key)) {
+    if (key === "*" || key === "_splat") {
       return isValueString ? encodeURI(value) : value;
     } else {
       return isValueString ? encodePathParam(value, decodeCharMap) : value;
@@ -189,17 +234,30 @@ function interpolatePath({
   const usedParams = {};
   const interpolatedPath = joinPaths(
     interpolatedPathSegments.map((segment) => {
-      if (segment.type === "wildcard") {
+      if (segment.type === SEGMENT_TYPE_PATHNAME) {
+        return segment.value;
+      }
+      if (segment.type === SEGMENT_TYPE_WILDCARD) {
         usedParams._splat = params._splat;
         const segmentPrefix = segment.prefixSegment || "";
         const segmentSuffix = segment.suffixSegment || "";
+        if (!("_splat" in params)) {
+          isMissingParams = true;
+          if (leaveWildcards) {
+            return `${segmentPrefix}${segment.value}${segmentSuffix}`;
+          }
+          if (segmentPrefix || segmentSuffix) {
+            return `${segmentPrefix}${segmentSuffix}`;
+          }
+          return void 0;
+        }
         const value = encodeParam("_splat");
         if (leaveWildcards) {
           return `${segmentPrefix}${segment.value}${value ?? ""}${segmentSuffix}`;
         }
         return `${segmentPrefix}${value}${segmentSuffix}`;
       }
-      if (segment.type === "param") {
+      if (segment.type === SEGMENT_TYPE_PARAM) {
         const key = segment.value.substring(1);
         if (!isMissingParams && !(key in params)) {
           isMissingParams = true;
@@ -213,6 +271,29 @@ function interpolatePath({
         }
         return `${segmentPrefix}${encodeParam(key) ?? "undefined"}${segmentSuffix}`;
       }
+      if (segment.type === SEGMENT_TYPE_OPTIONAL_PARAM) {
+        const key = segment.value.substring(1);
+        const segmentPrefix = segment.prefixSegment || "";
+        const segmentSuffix = segment.suffixSegment || "";
+        if (!(key in params) || params[key] == null) {
+          if (leaveWildcards) {
+            return `${segmentPrefix}${key}${segmentSuffix}`;
+          }
+          if (segmentPrefix || segmentSuffix) {
+            return `${segmentPrefix}${segmentSuffix}`;
+          }
+          return void 0;
+        }
+        usedParams[key] = params[key];
+        if (leaveParams) {
+          const value = encodeParam(segment.value);
+          return `${segmentPrefix}${segment.value}${value ?? ""}${segmentSuffix}`;
+        }
+        if (leaveWildcards) {
+          return `${segmentPrefix}${key}${encodeParam(key) ?? ""}${segmentSuffix}`;
+        }
+        return `${segmentPrefix}${encodeParam(key) ?? ""}${segmentSuffix}`;
+      }
       return segment.value;
     })
   );
@@ -227,8 +308,13 @@ function encodePathParam(value, decodeCharMap) {
   }
   return encoded;
 }
-function matchPathname(basepath, currentPathname, matchLocation) {
-  const pathParams = matchByPath(basepath, currentPathname, matchLocation);
+function matchPathname(basepath, currentPathname, matchLocation, parseCache) {
+  const pathParams = matchByPath(
+    basepath,
+    currentPathname,
+    matchLocation,
+    parseCache
+  );
   if (matchLocation.to && !pathParams) {
     return;
   }
@@ -263,111 +349,156 @@ function removeBasepath(basepath, pathname, caseSensitive = false) {
       return pathname;
   }
 }
-function matchByPath(basepath, from, matchLocation) {
+function matchByPath(basepath, from, {
+  to,
+  fuzzy,
+  caseSensitive
+}, parseCache) {
   if (basepath !== "/" && !from.startsWith(basepath)) {
     return void 0;
   }
-  from = removeBasepath(basepath, from, matchLocation.caseSensitive);
-  const to = removeBasepath(
-    basepath,
-    `${matchLocation.to ?? "$"}`,
-    matchLocation.caseSensitive
+  from = removeBasepath(basepath, from, caseSensitive);
+  to = removeBasepath(basepath, `${to ?? "$"}`, caseSensitive);
+  const baseSegments = parsePathname(
+    from.startsWith("/") ? from : `/${from}`,
+    parseCache
+  );
+  const routeSegments = parsePathname(
+    to.startsWith("/") ? to : `/${to}`,
+    parseCache
   );
-  const baseSegments = parsePathname(from);
-  const routeSegments = parsePathname(to);
-  if (!from.startsWith("/")) {
-    baseSegments.unshift({
-      type: "pathname",
-      value: "/"
-    });
-  }
-  if (!to.startsWith("/")) {
-    routeSegments.unshift({
-      type: "pathname",
-      value: "/"
-    });
-  }
   const params = {};
-  const isMatch = (() => {
-    var _a;
-    for (let i = 0; i < Math.max(baseSegments.length, routeSegments.length); i++) {
-      const baseSegment = baseSegments[i];
-      const routeSegment = routeSegments[i];
-      const isLastBaseSegment = i >= baseSegments.length - 1;
-      const isLastRouteSegment = i >= routeSegments.length - 1;
-      if (routeSegment) {
-        if (routeSegment.type === "wildcard") {
-          const remainingBaseSegments = baseSegments.slice(i);
-          let _splat;
-          if (routeSegment.prefixSegment || routeSegment.suffixSegment) {
-            if (!baseSegment) return false;
-            const prefix = routeSegment.prefixSegment || "";
-            const suffix = routeSegment.suffixSegment || "";
-            const baseValue = baseSegment.value;
-            if ("prefixSegment" in routeSegment) {
-              if (!baseValue.startsWith(prefix)) {
-                return false;
-              }
-            }
-            if ("suffixSegment" in routeSegment) {
-              if (!((_a = baseSegments[baseSegments.length - 1]) == null ? void 0 : _a.value.endsWith(suffix))) {
-                return false;
-              }
-            }
-            let rejoinedSplat = decodeURI(
-              joinPaths(remainingBaseSegments.map((d) => d.value))
-            );
-            if (prefix && rejoinedSplat.startsWith(prefix)) {
-              rejoinedSplat = rejoinedSplat.slice(prefix.length);
+  const result = isMatch(
+    baseSegments,
+    routeSegments,
+    params,
+    fuzzy,
+    caseSensitive
+  );
+  return result ? params : void 0;
+}
+function isMatch(baseSegments, routeSegments, params, fuzzy, caseSensitive) {
+  let baseIndex = 0;
+  let routeIndex = 0;
+  while (baseIndex < baseSegments.length || routeIndex < routeSegments.length) {
+    const baseSegment = baseSegments[baseIndex];
+    const routeSegment = routeSegments[routeIndex];
+    if (routeSegment) {
+      if (routeSegment.type === SEGMENT_TYPE_WILDCARD) {
+        const remainingBaseSegments = baseSegments.slice(baseIndex);
+        let _splat;
+        if (routeSegment.prefixSegment || routeSegment.suffixSegment) {
+          if (!baseSegment) return false;
+          const prefix = routeSegment.prefixSegment || "";
+          const suffix = routeSegment.suffixSegment || "";
+          const baseValue = baseSegment.value;
+          if ("prefixSegment" in routeSegment) {
+            if (!baseValue.startsWith(prefix)) {
+              return false;
             }
-            if (suffix && rejoinedSplat.endsWith(suffix)) {
-              rejoinedSplat = rejoinedSplat.slice(
-                0,
-                rejoinedSplat.length - suffix.length
-              );
+          }
+          if ("suffixSegment" in routeSegment) {
+            if (!baseSegments[baseSegments.length - 1]?.value.endsWith(suffix)) {
+              return false;
             }
-            _splat = rejoinedSplat;
-          } else {
-            _splat = decodeURI(
-              joinPaths(remainingBaseSegments.map((d) => d.value))
+          }
+          let rejoinedSplat = decodeURI(
+            joinPaths(remainingBaseSegments.map((d) => d.value))
+          );
+          if (prefix && rejoinedSplat.startsWith(prefix)) {
+            rejoinedSplat = rejoinedSplat.slice(prefix.length);
+          }
+          if (suffix && rejoinedSplat.endsWith(suffix)) {
+            rejoinedSplat = rejoinedSplat.slice(
+              0,
+              rejoinedSplat.length - suffix.length
             );
           }
-          params["*"] = _splat;
-          params["_splat"] = _splat;
-          return true;
+          _splat = rejoinedSplat;
+        } else {
+          _splat = decodeURI(
+            joinPaths(remainingBaseSegments.map((d) => d.value))
+          );
         }
-        if (routeSegment.type === "pathname") {
-          if (routeSegment.value === "/" && !(baseSegment == null ? void 0 : baseSegment.value)) {
-            return true;
-          }
-          if (baseSegment) {
-            if (matchLocation.caseSensitive) {
-              if (routeSegment.value !== baseSegment.value) {
-                return false;
-              }
-            } else if (routeSegment.value.toLowerCase() !== baseSegment.value.toLowerCase()) {
+        params["*"] = _splat;
+        params["_splat"] = _splat;
+        return true;
+      }
+      if (routeSegment.type === SEGMENT_TYPE_PATHNAME) {
+        if (routeSegment.value === "/" && !baseSegment?.value) {
+          routeIndex++;
+          continue;
+        }
+        if (baseSegment) {
+          if (caseSensitive) {
+            if (routeSegment.value !== baseSegment.value) {
               return false;
             }
+          } else if (routeSegment.value.toLowerCase() !== baseSegment.value.toLowerCase()) {
+            return false;
           }
+          baseIndex++;
+          routeIndex++;
+          continue;
+        } else {
+          return false;
         }
+      }
+      if (routeSegment.type === SEGMENT_TYPE_PARAM) {
         if (!baseSegment) {
           return false;
         }
-        if (routeSegment.type === "param") {
-          if (baseSegment.value === "/") {
+        if (baseSegment.value === "/") {
+          return false;
+        }
+        let _paramValue = "";
+        let matched = false;
+        if (routeSegment.prefixSegment || routeSegment.suffixSegment) {
+          const prefix = routeSegment.prefixSegment || "";
+          const suffix = routeSegment.suffixSegment || "";
+          const baseValue = baseSegment.value;
+          if (prefix && !baseValue.startsWith(prefix)) {
             return false;
           }
-          let _paramValue;
-          if (routeSegment.prefixSegment || routeSegment.suffixSegment) {
-            const prefix = routeSegment.prefixSegment || "";
-            const suffix = routeSegment.suffixSegment || "";
-            const baseValue = baseSegment.value;
-            if (prefix && !baseValue.startsWith(prefix)) {
-              return false;
-            }
-            if (suffix && !baseValue.endsWith(suffix)) {
-              return false;
-            }
+          if (suffix && !baseValue.endsWith(suffix)) {
+            return false;
+          }
+          let paramValue = baseValue;
+          if (prefix && paramValue.startsWith(prefix)) {
+            paramValue = paramValue.slice(prefix.length);
+          }
+          if (suffix && paramValue.endsWith(suffix)) {
+            paramValue = paramValue.slice(0, paramValue.length - suffix.length);
+          }
+          _paramValue = decodeURIComponent(paramValue);
+          matched = true;
+        } else {
+          _paramValue = decodeURIComponent(baseSegment.value);
+          matched = true;
+        }
+        if (matched) {
+          params[routeSegment.value.substring(1)] = _paramValue;
+          baseIndex++;
+        }
+        routeIndex++;
+        continue;
+      }
+      if (routeSegment.type === SEGMENT_TYPE_OPTIONAL_PARAM) {
+        if (!baseSegment) {
+          routeIndex++;
+          continue;
+        }
+        if (baseSegment.value === "/") {
+          routeIndex++;
+          continue;
+        }
+        let _paramValue = "";
+        let matched = false;
+        if (routeSegment.prefixSegment || routeSegment.suffixSegment) {
+          const prefix = routeSegment.prefixSegment || "";
+          const suffix = routeSegment.suffixSegment || "";
+          const baseValue = baseSegment.value;
+          if ((!prefix || baseValue.startsWith(prefix)) && (!suffix || baseValue.endsWith(suffix))) {
             let paramValue = baseValue;
             if (prefix && paramValue.startsWith(prefix)) {
               paramValue = paramValue.slice(prefix.length);
@@ -379,22 +510,59 @@ function matchByPath(basepath, from, matchLocation) {
               );
             }
             _paramValue = decodeURIComponent(paramValue);
-          } else {
+            matched = true;
+          }
+        } else {
+          let shouldMatchOptional = true;
+          for (let lookAhead = routeIndex + 1; lookAhead < routeSegments.length; lookAhead++) {
+            const futureRouteSegment = routeSegments[lookAhead];
+            if (futureRouteSegment?.type === SEGMENT_TYPE_PATHNAME && futureRouteSegment.value === baseSegment.value) {
+              shouldMatchOptional = false;
+              break;
+            }
+            if (futureRouteSegment?.type === SEGMENT_TYPE_PARAM || futureRouteSegment?.type === SEGMENT_TYPE_WILDCARD) {
+              if (baseSegments.length < routeSegments.length) {
+                shouldMatchOptional = false;
+              }
+              break;
+            }
+          }
+          if (shouldMatchOptional) {
             _paramValue = decodeURIComponent(baseSegment.value);
+            matched = true;
           }
+        }
+        if (matched) {
           params[routeSegment.value.substring(1)] = _paramValue;
+          baseIndex++;
         }
+        routeIndex++;
+        continue;
       }
-      if (!isLastBaseSegment && isLastRouteSegment) {
-        params["**"] = joinPaths(baseSegments.slice(i + 1).map((d) => d.value));
-        return !!matchLocation.fuzzy && (routeSegment == null ? void 0 : routeSegment.value) !== "/";
+    }
+    if (baseIndex < baseSegments.length && routeIndex >= routeSegments.length) {
+      params["**"] = joinPaths(
+        baseSegments.slice(baseIndex).map((d) => d.value)
+      );
+      return !!fuzzy && routeSegments[routeSegments.length - 1]?.value !== "/";
+    }
+    if (routeIndex < routeSegments.length && baseIndex >= baseSegments.length) {
+      for (let i = routeIndex; i < routeSegments.length; i++) {
+        if (routeSegments[i]?.type !== SEGMENT_TYPE_OPTIONAL_PARAM) {
+          return false;
+        }
       }
+      break;
     }
-    return true;
-  })();
-  return isMatch ? params : void 0;
+    break;
+  }
+  return true;
 }
 export {
+  SEGMENT_TYPE_OPTIONAL_PARAM,
+  SEGMENT_TYPE_PARAM,
+  SEGMENT_TYPE_PATHNAME,
+  SEGMENT_TYPE_WILDCARD,
   cleanPath,
   exactPathTest,
   interpolatePath,