@tanstack/router-core 1.136.4 → 1.136.5

package/dist/cjs/path.cjs

@@ -1,10 +1,7 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const utils = require("./utils.cjs");
-const SEGMENT_TYPE_PATHNAME = 0;
-const SEGMENT_TYPE_PARAM = 1;
-const SEGMENT_TYPE_WILDCARD = 2;
-const SEGMENT_TYPE_OPTIONAL_PARAM = 3;
+const newProcessRouteTree = require("./new-process-route-tree.cjs");
 function joinPaths(paths) {
   return cleanPath(
     paths.filter((val) => {
@@ -33,247 +30,168 @@ 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({
   base,
   to,
   trailingSlash = "never",
-  parseCache
+  cache
 }) {
-  let baseSegments = parsePathname(base, parseCache).slice();
-  const toSegments = parsePathname(to, parseCache);
-  if (baseSegments.length > 1 && utils.last(baseSegments)?.value === "/") {
-    baseSegments.pop();
+  const isAbsolute = to.startsWith("/");
+  const isBase = !isAbsolute && to === ".";
+  let key;
+  if (cache) {
+    key = isAbsolute ? to : isBase ? base : base + "\0" + to;
+    const cached = cache.get(key);
+    if (cached) return cached;
   }
-  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 === length - 1) {
-        baseSegments.push(toSegment);
-      } else ;
-    } else if (value === "..") {
+  let baseSegments;
+  if (isBase) {
+    baseSegments = base.split("/");
+  } else if (isAbsolute) {
+    baseSegments = to.split("/");
+  } else {
+    baseSegments = base.split("/");
+    while (baseSegments.length > 1 && utils.last(baseSegments) === "") {
       baseSegments.pop();
-    } else if (value === ".") ;
-    else {
-      baseSegments.push(toSegment);
+    }
+    const toSegments = to.split("/");
+    for (let index = 0, length = toSegments.length; index < length; index++) {
+      const value = toSegments[index];
+      if (value === "") {
+        if (!index) {
+          baseSegments = [value];
+        } else if (index === length - 1) {
+          baseSegments.push(value);
+        } else ;
+      } else if (value === "..") {
+        baseSegments.pop();
+      } else if (value === ".") ;
+      else {
+        baseSegments.push(value);
+      }
     }
   }
   if (baseSegments.length > 1) {
-    if (utils.last(baseSegments).value === "/") {
+    if (utils.last(baseSegments) === "") {
       if (trailingSlash === "never") {
         baseSegments.pop();
       }
     } else if (trailingSlash === "always") {
-      baseSegments.push({ type: SEGMENT_TYPE_PATHNAME, value: "/" });
+      baseSegments.push("");
     }
   }
-  const segmentValues = baseSegments.map(segmentToString);
-  const joined = joinPaths(segmentValues);
-  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 baseParsePathname(pathname) {
-  pathname = cleanPath(pathname);
-  const segments = [];
-  if (pathname.slice(0, 1) === "/") {
-    pathname = pathname.substring(1);
-    segments.push({
-      type: SEGMENT_TYPE_PATHNAME,
-      value: "/"
-    });
-  }
-  if (!pathname) {
-    return segments;
+  let segment;
+  let joined = "";
+  for (let i = 0; i < baseSegments.length; i++) {
+    if (i > 0) joined += "/";
+    const part = baseSegments[i];
+    if (!part) continue;
+    segment = newProcessRouteTree.parseSegment(part, 0, segment);
+    const kind = segment[0];
+    if (kind === newProcessRouteTree.SEGMENT_TYPE_PATHNAME) {
+      joined += part;
+      continue;
+    }
+    const end = segment[5];
+    const prefix = part.substring(0, segment[1]);
+    const suffix = part.substring(segment[4], end);
+    const value = part.substring(segment[2], segment[3]);
+    if (kind === newProcessRouteTree.SEGMENT_TYPE_PARAM) {
+      joined += prefix || suffix ? `${prefix}{$${value}}${suffix}` : `$${value}`;
+    } else if (kind === newProcessRouteTree.SEGMENT_TYPE_WILDCARD) {
+      joined += prefix || suffix ? `${prefix}{$}${suffix}` : "$";
+    } else {
+      joined += `${prefix}{-$${value}}${suffix}`;
+    }
   }
-  const split = pathname.split("/").filter(Boolean);
-  segments.push(
-    ...split.map((part) => {
-      const wildcardBracesMatch = part.match(WILDCARD_W_CURLY_BRACES_RE);
-      if (wildcardBracesMatch) {
-        const prefix = wildcardBracesMatch[1];
-        const suffix = wildcardBracesMatch[2];
-        return {
-          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: SEGMENT_TYPE_PARAM,
-          value: "" + paramName,
-          prefixSegment: prefix || void 0,
-          suffixSegment: suffix || void 0
-        };
-      }
-      if (PARAM_RE.test(part)) {
-        const paramName = part.substring(1);
-        return {
-          type: SEGMENT_TYPE_PARAM,
-          value: "$" + paramName,
-          prefixSegment: void 0,
-          suffixSegment: void 0
-        };
-      }
-      if (WILDCARD_RE.test(part)) {
-        return {
-          type: SEGMENT_TYPE_WILDCARD,
-          value: "$",
-          prefixSegment: void 0,
-          suffixSegment: void 0
-        };
-      }
-      return {
-        type: SEGMENT_TYPE_PATHNAME,
-        value: part
-      };
-    })
-  );
-  if (pathname.slice(-1) === "/") {
-    pathname = pathname.substring(1);
-    segments.push({
-      type: SEGMENT_TYPE_PATHNAME,
-      value: "/"
-    });
+  joined = cleanPath(joined);
+  const result = joined || "/";
+  if (key && cache) cache.set(key, result);
+  return result;
+}
+function encodeParam(key, params, decodeCharMap) {
+  const value = params[key];
+  if (typeof value !== "string") return value;
+  if (key === "_splat") {
+    return encodeURI(value);
+  } else {
+    return encodePathParam(value, decodeCharMap);
   }
-  return segments;
 }
 function interpolatePath({
   path,
   params,
-  decodeCharMap,
-  parseCache
+  decodeCharMap
 }) {
-  const interpolatedPathSegments = parsePathname(path, parseCache);
-  function encodeParam(key) {
-    const value = params[key];
-    const isValueString = typeof value === "string";
-    if (key === "*" || key === "_splat") {
-      return isValueString ? encodeURI(value) : value;
-    } else {
-      return isValueString ? encodePathParam(value, decodeCharMap) : value;
-    }
-  }
   let isMissingParams = false;
   const usedParams = {};
-  const interpolatedPath = joinPaths(
-    interpolatedPathSegments.map((segment) => {
-      if (segment.type === SEGMENT_TYPE_PATHNAME) {
-        return segment.value;
-      }
-      if (segment.type === SEGMENT_TYPE_WILDCARD) {
-        usedParams._splat = params._splat;
-        usedParams["*"] = params._splat;
-        const segmentPrefix = segment.prefixSegment || "";
-        const segmentSuffix = segment.suffixSegment || "";
-        if (!params._splat) {
-          isMissingParams = true;
-          if (segmentPrefix || segmentSuffix) {
-            return `${segmentPrefix}${segmentSuffix}`;
-          }
-          return void 0;
+  if (!path || path === "/")
+    return { interpolatedPath: "/", usedParams, isMissingParams };
+  if (!path.includes("$"))
+    return { interpolatedPath: path, usedParams, isMissingParams };
+  const length = path.length;
+  let cursor = 0;
+  let segment;
+  let joined = "";
+  while (cursor < length) {
+    const start = cursor;
+    segment = newProcessRouteTree.parseSegment(path, start, segment);
+    const end = segment[5];
+    cursor = end + 1;
+    if (start === end) continue;
+    const kind = segment[0];
+    if (kind === newProcessRouteTree.SEGMENT_TYPE_PATHNAME) {
+      joined += "/" + path.substring(start, end);
+      continue;
+    }
+    if (kind === newProcessRouteTree.SEGMENT_TYPE_WILDCARD) {
+      const splat = params._splat;
+      usedParams._splat = splat;
+      usedParams["*"] = splat;
+      const prefix = path.substring(start, segment[1]);
+      const suffix = path.substring(segment[4], end);
+      if (!splat) {
+        isMissingParams = true;
+        if (prefix || suffix) {
+          joined += "/" + prefix + suffix;
         }
-        const value = encodeParam("_splat");
-        return `${segmentPrefix}${value}${segmentSuffix}`;
+        continue;
       }
-      if (segment.type === SEGMENT_TYPE_PARAM) {
-        const key = segment.value.substring(1);
-        if (!isMissingParams && !(key in params)) {
-          isMissingParams = true;
-        }
-        usedParams[key] = params[key];
-        const segmentPrefix = segment.prefixSegment || "";
-        const segmentSuffix = segment.suffixSegment || "";
-        return `${segmentPrefix}${encodeParam(key) ?? "undefined"}${segmentSuffix}`;
+      const value = encodeParam("_splat", params, decodeCharMap);
+      joined += "/" + prefix + value + suffix;
+      continue;
+    }
+    if (kind === newProcessRouteTree.SEGMENT_TYPE_PARAM) {
+      const key = path.substring(segment[2], segment[3]);
+      if (!isMissingParams && !(key in params)) {
+        isMissingParams = true;
       }
-      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 (segmentPrefix || segmentSuffix) {
-            return `${segmentPrefix}${segmentSuffix}`;
-          }
-          return void 0;
+      usedParams[key] = params[key];
+      const prefix = path.substring(start, segment[1]);
+      const suffix = path.substring(segment[4], end);
+      const value = encodeParam(key, params, decodeCharMap) ?? "undefined";
+      joined += "/" + prefix + value + suffix;
+      continue;
+    }
+    if (kind === newProcessRouteTree.SEGMENT_TYPE_OPTIONAL_PARAM) {
+      const key = path.substring(segment[2], segment[3]);
+      const prefix = path.substring(start, segment[1]);
+      const suffix = path.substring(segment[4], end);
+      const valueRaw = params[key];
+      if (valueRaw == null) {
+        if (prefix || suffix) {
+          joined += "/" + prefix + suffix;
         }
-        usedParams[key] = params[key];
-        return `${segmentPrefix}${encodeParam(key) ?? ""}${segmentSuffix}`;
+        continue;
       }
-      return segment.value;
-    })
-  );
+      usedParams[key] = valueRaw;
+      const value = encodeParam(key, params, decodeCharMap) ?? "";
+      joined += "/" + prefix + value + suffix;
+      continue;
+    }
+  }
+  if (path.endsWith("/")) joined += "/";
+  const interpolatedPath = joined || "/";
   return { usedParams, interpolatedPath, isMissingParams };
 }
 function encodePathParam(value, decodeCharMap) {
@@ -285,229 +203,10 @@ function encodePathParam(value, decodeCharMap) {
   }
   return encoded;
 }
-function matchPathname(currentPathname, matchLocation, parseCache) {
-  const pathParams = matchByPath(currentPathname, matchLocation, parseCache);
-  if (matchLocation.to && !pathParams) {
-    return;
-  }
-  return pathParams ?? {};
-}
-function matchByPath(from, {
-  to,
-  fuzzy,
-  caseSensitive
-}, parseCache) {
-  const stringTo = to;
-  const baseSegments = parsePathname(
-    from.startsWith("/") ? from : `/${from}`,
-    parseCache
-  );
-  const routeSegments = parsePathname(
-    stringTo.startsWith("/") ? stringTo : `/${stringTo}`,
-    parseCache
-  );
-  const params = {};
-  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 ("suffixSegment" in routeSegment) {
-            if (!baseSegments[baseSegments.length - 1]?.value.endsWith(suffix)) {
-              return false;
-            }
-          }
-          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
-            );
-          }
-          _splat = rejoinedSplat;
-        } else {
-          _splat = decodeURI(
-            joinPaths(remainingBaseSegments.map((d) => d.value))
-          );
-        }
-        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 (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;
-          }
-          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);
-            }
-            if (suffix && paramValue.endsWith(suffix)) {
-              paramValue = paramValue.slice(
-                0,
-                paramValue.length - suffix.length
-              );
-            }
-            _paramValue = decodeURIComponent(paramValue);
-            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 (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;
-    }
-    break;
-  }
-  return true;
-}
-exports.SEGMENT_TYPE_OPTIONAL_PARAM = SEGMENT_TYPE_OPTIONAL_PARAM;
-exports.SEGMENT_TYPE_PARAM = SEGMENT_TYPE_PARAM;
-exports.SEGMENT_TYPE_PATHNAME = SEGMENT_TYPE_PATHNAME;
-exports.SEGMENT_TYPE_WILDCARD = SEGMENT_TYPE_WILDCARD;
 exports.cleanPath = cleanPath;
 exports.exactPathTest = exactPathTest;
 exports.interpolatePath = interpolatePath;
 exports.joinPaths = joinPaths;
-exports.matchByPath = matchByPath;
-exports.matchPathname = matchPathname;
-exports.parsePathname = parsePathname;
 exports.removeTrailingSlash = removeTrailingSlash;
 exports.resolvePath = resolvePath;
 exports.trimPath = trimPath;