@tanstack/router-core 0.0.1-beta.9 → 1.97.24

package/src/path.ts

@@ -1,14 +1,20 @@
-import { AnyPathParams } from './routeConfig'
-import { MatchLocation } from './router'
 import { last } from './utils'
+import type { MatchLocation } from './RouterProvider'
+import type { AnyPathParams } from './route'
 
 export interface Segment {
   type: 'pathname' | 'param' | 'wildcard'
   value: string
 }
 
-export function joinPaths(paths: (string | undefined)[]) {
-  return cleanPath(paths.filter(Boolean).join('/'))
+export function joinPaths(paths: Array<string | undefined>) {
+  return cleanPath(
+    paths
+      .filter((val) => {
+        return val !== undefined
+      })
+      .join('/'),
+  )
 }
 
 export function cleanPath(path: string) {
@@ -28,13 +34,79 @@ export function trimPath(path: string) {
   return trimPathRight(trimPathLeft(path))
 }
 
-export function resolvePath(basepath: string, base: string, to: string) {
-  base = base.replace(new RegExp(`^${basepath}`), '/')
-  to = to.replace(new RegExp(`^${basepath}`), '/')
+export function removeTrailingSlash(value: string, basepath: string): string {
+  if (value.endsWith('/') && value !== '/' && value !== `${basepath}/`) {
+    return value.slice(0, -1)
+  }
+  return value
+}
+
+// intended to only compare path name
+// see the usage in the isActive under useLinkProps
+// /sample/path1 = /sample/path1/
+// /sample/path1/some <> /sample/path1
+export function exactPathTest(
+  pathName1: string,
+  pathName2: string,
+  basepath: string,
+): boolean {
+  return (
+    removeTrailingSlash(pathName1, basepath) ===
+    removeTrailingSlash(pathName2, basepath)
+  )
+}
+
+// When resolving relative paths, we treat all paths as if they are trailing slash
+// documents. All trailing slashes are removed after the path is resolved.
+// Here are a few examples:
+//
+// /a/b/c + ./d = /a/b/c/d
+// /a/b/c + ../d = /a/b/d
+// /a/b/c + ./d/ = /a/b/c/d
+// /a/b/c + ../d/ = /a/b/d
+// /a/b/c + ./ = /a/b/c
+//
+// Absolute paths that start with `/` short circuit the resolution process to the root
+// path.
+//
+// Here are some examples:
+//
+// /a/b/c + /d = /d
+// /a/b/c + /d/ = /d
+// /a/b/c + / = /
+//
+// Non-.-prefixed paths are still treated as relative paths, resolved like `./`
+//
+// Here are some examples:
+//
+// /a/b/c + d = /a/b/c/d
+// /a/b/c + d/ = /a/b/c/d
+// /a/b/c + d/e = /a/b/c/d/e
+interface ResolvePathOptions {
+  basepath: string
+  base: string
+  to: string
+  trailingSlash?: 'always' | 'never' | 'preserve'
+  caseSensitive?: boolean
+}
+
+export function resolvePath({
+  basepath,
+  base,
+  to,
+  trailingSlash = 'never',
+  caseSensitive,
+}: ResolvePathOptions) {
+  base = removeBasepath(basepath, base, caseSensitive)
+  to = removeBasepath(basepath, to, caseSensitive)
 
   let baseSegments = parsePathname(base)
   const toSegments = parsePathname(to)
 
+  if (baseSegments.length > 1 && last(baseSegments)?.value === '/') {
+    baseSegments.pop()
+  }
+
   toSegments.forEach((toSegment, index) => {
     if (toSegment.value === '/') {
       if (!index) {
@@ -47,31 +119,36 @@ export function resolvePath(basepath: string, base: string, to: string) {
         // ignore inter-slashes
       }
     } else if (toSegment.value === '..') {
-      // Extra trailing slash? pop it off
-      if (baseSegments.length > 1 && last(baseSegments)?.value === '/') {
-        baseSegments.pop()
-      }
       baseSegments.pop()
     } else if (toSegment.value === '.') {
-      return
+      // ignore
     } else {
       baseSegments.push(toSegment)
     }
   })
 
-  const joined = joinPaths([basepath, ...baseSegments.map((d) => d.value)])
+  if (baseSegments.length > 1) {
+    if (last(baseSegments)?.value === '/') {
+      if (trailingSlash === 'never') {
+        baseSegments.pop()
+      }
+    } else if (trailingSlash === 'always') {
+      baseSegments.push({ type: 'pathname', value: '/' })
+    }
+  }
 
+  const joined = joinPaths([basepath, ...baseSegments.map((d) => d.value)])
   return cleanPath(joined)
 }
 
-export function parsePathname(pathname?: string): Segment[] {
+export function parsePathname(pathname?: string): Array<Segment> {
   if (!pathname) {
     return []
   }
 
   pathname = cleanPath(pathname)
 
-  const segments: Segment[] = []
+  const segments: Array<Segment> = []
 
   if (pathname.slice(0, 1) === '/') {
     pathname = pathname.substring(1)
@@ -90,14 +167,14 @@ export function parsePathname(pathname?: string): Segment[] {
 
   segments.push(
     ...split.map((part): Segment => {
-      if (part.startsWith('*')) {
+      if (part === '$' || part === '*') {
         return {
           type: 'wildcard',
           value: part,
         }
       }
 
-      if (part.charAt(0) === ':') {
+      if (part.charAt(0) === '$') {
         return {
           type: 'param',
           value: part,
@@ -106,7 +183,7 @@ export function parsePathname(pathname?: string): Segment[] {
 
       return {
         type: 'pathname',
-        value: part,
+        value: decodeURI(part),
       }
     }),
   )
@@ -122,21 +199,52 @@ export function parsePathname(pathname?: string): Segment[] {
   return segments
 }
 
-export function interpolatePath(
-  path: string | undefined,
-  params: any,
-  leaveWildcard?: boolean,
-) {
+interface InterpolatePathOptions {
+  path?: string
+  params: Record<string, unknown>
+  leaveWildcards?: boolean
+  leaveParams?: boolean
+  // Map of encoded chars to decoded chars (e.g. '%40' -> '@') that should remain decoded in path params
+  decodeCharMap?: Map<string, string>
+}
+
+export function interpolatePath({
+  path,
+  params,
+  leaveWildcards,
+  leaveParams,
+  decodeCharMap,
+}: InterpolatePathOptions) {
   const interpolatedPathSegments = parsePathname(path)
+  const encodedParams: any = {}
+
+  for (const [key, value] of Object.entries(params)) {
+    const isValueString = typeof value === 'string'
+
+    if (['*', '_splat'].includes(key)) {
+      // the splat/catch-all routes shouldn't have the '/' encoded out
+      encodedParams[key] = isValueString ? encodeURI(value) : value
+    } else {
+      encodedParams[key] = isValueString
+        ? encodePathParam(value, decodeCharMap)
+        : value
+    }
+  }
 
   return joinPaths(
     interpolatedPathSegments.map((segment) => {
-      if (segment.value === '*' && !leaveWildcard) {
-        return ''
+      if (segment.type === 'wildcard') {
+        const value = encodedParams._splat
+        if (leaveWildcards) return `${segment.value}${value ?? ''}`
+        return value
       }
 
       if (segment.type === 'param') {
-        return params![segment.value.substring(1)] ?? ''
+        if (leaveParams) {
+          const value = encodedParams[segment.value]
+          return `${segment.value}${value ?? ''}`
+        }
+        return encodedParams![segment.value.substring(1)] ?? 'undefined'
       }
 
       return segment.value
@@ -144,34 +252,111 @@ export function interpolatePath(
   )
 }
 
+function encodePathParam(value: string, decodeCharMap?: Map<string, string>) {
+  let encoded = encodeURIComponent(value)
+  if (decodeCharMap) {
+    for (const [encodedChar, char] of decodeCharMap) {
+      encoded = encoded.replaceAll(encodedChar, char)
+    }
+  }
+  return encoded
+}
+
 export function matchPathname(
+  basepath: string,
   currentPathname: string,
   matchLocation: Pick<MatchLocation, 'to' | 'fuzzy' | 'caseSensitive'>,
 ): AnyPathParams | undefined {
-  const pathParams = matchByPath(currentPathname, matchLocation)
-  // const searchMatched = matchBySearch(currentLocation.search, matchLocation)
+  const pathParams = matchByPath(basepath, currentPathname, matchLocation)
+  // const searchMatched = matchBySearch(location.search, matchLocation)
 
   if (matchLocation.to && !pathParams) {
     return
   }
 
-  // if (matchLocation.search && !searchMatched) {
-  //   return
-  // }
-
   return pathParams ?? {}
 }
 
+export function removeBasepath(
+  basepath: string,
+  pathname: string,
+  caseSensitive: boolean = false,
+) {
+  // normalize basepath and pathname for case-insensitive comparison if needed
+  const normalizedBasepath = caseSensitive ? basepath : basepath.toLowerCase()
+  const normalizedPathname = caseSensitive ? pathname : pathname.toLowerCase()
+
+  switch (true) {
+    // default behaviour is to serve app from the root - pathname
+    // left untouched
+    case normalizedBasepath === '/':
+      return pathname
+
+    // shortcut for removing the basepath if it matches the pathname
+    case normalizedPathname === normalizedBasepath:
+      return ''
+
+    // in case pathname is shorter than basepath - there is
+    // nothing to remove
+    case pathname.length < basepath.length:
+      return pathname
+
+    // avoid matching partial segments - strict equality handled
+    // earlier, otherwise, basepath separated from pathname with
+    // separator, therefore lack of separator means partial
+    // segment match (`/app` should not match `/application`)
+    case normalizedPathname[normalizedBasepath.length] !== '/':
+      return pathname
+
+    // remove the basepath from the pathname if it starts with it
+    case normalizedPathname.startsWith(normalizedBasepath):
+      return pathname.slice(basepath.length)
+
+    // otherwise, return the pathname as is
+    default:
+      return pathname
+  }
+}
+
 export function matchByPath(
+  basepath: string,
   from: string,
   matchLocation: Pick<MatchLocation, 'to' | 'caseSensitive' | 'fuzzy'>,
 ): Record<string, string> | undefined {
+  // check basepath first
+  if (basepath !== '/' && !from.startsWith(basepath)) {
+    return undefined
+  }
+  // Remove the base path from the pathname
+  from = removeBasepath(basepath, from, matchLocation.caseSensitive)
+  // Default to to $ (wildcard)
+  const to = removeBasepath(
+    basepath,
+    `${matchLocation.to ?? '$'}`,
+    matchLocation.caseSensitive,
+  )
+
+  // Parse the from and to
   const baseSegments = parsePathname(from)
-  const routeSegments = parsePathname(`${matchLocation.to ?? '*'}`)
+  const routeSegments = parsePathname(to)
+
+  if (!from.startsWith('/')) {
+    baseSegments.unshift({
+      type: 'pathname',
+      value: '/',
+    })
+  }
+
+  if (!to.startsWith('/')) {
+    routeSegments.unshift({
+      type: 'pathname',
+      value: '/',
+    })
+  }
 
   const params: Record<string, string> = {}
 
-  let isMatch = (() => {
+  const isMatch = (() => {
     for (
       let i = 0;
       i < Math.max(baseSegments.length, routeSegments.length);
@@ -180,16 +365,18 @@ export function matchByPath(
       const baseSegment = baseSegments[i]
       const routeSegment = routeSegments[i]
 
-      const isLastRouteSegment = i === routeSegments.length - 1
-      const isLastBaseSegment = i === baseSegments.length - 1
+      const isLastBaseSegment = i >= baseSegments.length - 1
+      const isLastRouteSegment = i >= routeSegments.length - 1
 
       if (routeSegment) {
         if (routeSegment.type === 'wildcard') {
-          if (baseSegment?.value) {
-            params['*'] = joinPaths(baseSegments.slice(i).map((d) => d.value))
-            return true
-          }
-          return false
+          const _splat = decodeURI(
+            joinPaths(baseSegments.slice(i).map((d) => d.value)),
+          )
+          // TODO: Deprecate *
+          params['*'] = _splat
+          params['_splat'] = _splat
+          return true
         }
 
         if (routeSegment.type === 'pathname') {
@@ -216,21 +403,25 @@ export function matchByPath(
         }
 
         if (routeSegment.type === 'param') {
-          if (baseSegment?.value === '/') {
+          if (baseSegment.value === '/') {
             return false
           }
-          if (!baseSegment.value.startsWith(':')) {
-            params[routeSegment.value.substring(1)] = baseSegment.value
+          if (baseSegment.value.charAt(0) !== '$') {
+            params[routeSegment.value.substring(1)] = decodeURIComponent(
+              baseSegment.value,
+            )
           }
         }
       }
 
-      if (isLastRouteSegment && !isLastBaseSegment) {
-        return !!matchLocation.fuzzy
+      if (!isLastBaseSegment && isLastRouteSegment) {
+        params['**'] = joinPaths(baseSegments.slice(i + 1).map((d) => d.value))
+        return !!matchLocation.fuzzy && routeSegment?.value !== '/'
       }
     }
+
     return true
   })()
 
-  return isMatch ? (params as Record<string, string>) : undefined
+  return isMatch ? params : undefined
 }

package/src/qss.ts

@@ -1,9 +1,22 @@
-// @ts-nocheck
+/**
+ * Program uses a modified version of the `qss` package:
+ * Copyright (c) Luke Edwards luke.edwards05@gmail.com, MIT License
+ * https://github.com/lukeed/qss/blob/master/license.md
+ */
 
-// qss has been slightly modified and inlined here for our use cases (and compression's sake). We've included it as a hard dependency for MIT license attribution.
-
-export function encode(obj, pfx?: string) {
-  var k,
+/**
+ * Encodes an object into a query string.
+ * @param obj - The object to encode into a query string.
+ * @param [pfx] - An optional prefix to add before the query string.
+ * @returns The encoded query string.
+ * @example
+ * ```
+ * // Example input: encode({ token: 'foo', key: 'value' })
+ * // Expected output: "token=foo&key=value"
+ * ```
+ */
+export function encode(obj: any, pfx?: string) {
+  let k,
     i,
     tmp,
     str = ''
@@ -25,28 +38,52 @@ export function encode(obj, pfx?: string) {
   return (pfx || '') + str
 }
 
-function toValue(mix) {
+/**
+ * Converts a string value to its appropriate type (string, number, boolean).
+ * @param mix - The string value to convert.
+ * @returns The converted value.
+ * @example
+ * // Example input: toValue("123")
+ * // Expected output: 123
+ */
+function toValue(mix: any) {
   if (!mix) return ''
-  var str = decodeURIComponent(mix)
+  const str = decodeURIComponent(mix)
   if (str === 'false') return false
   if (str === 'true') return true
-  if (str.charAt(0) === '0') return str
-  return +str * 0 === 0 ? +str : str
+  return +str * 0 === 0 && +str + '' === str ? +str : str
 }
 
-export function decode(str) {
-  var tmp,
-    k,
-    out = {},
-    arr = str.split('&')
+/**
+ * Decodes a query string into an object.
+ * @param str - The query string to decode.
+ * @param [pfx] - An optional prefix to filter out from the query string.
+ * @returns The decoded key-value pairs in an object format.
+ * @example
+ * // Example input: decode("token=foo&key=value")
+ * // Expected output: { "token": "foo", "key": "value" }
+ */
+export function decode(str: any, pfx?: string) {
+  let tmp, k
+  const out: any = {},
+    arr = (pfx ? str.substr(pfx.length) : str).split('&')
 
   while ((tmp = arr.shift())) {
-    tmp = tmp.split('=')
-    k = tmp.shift()
-    if (out[k] !== void 0) {
-      out[k] = [].concat(out[k], toValue(tmp.shift()))
+    const equalIndex = tmp.indexOf('=')
+    if (equalIndex !== -1) {
+      k = tmp.slice(0, equalIndex)
+      k = decodeURIComponent(k)
+      const value = tmp.slice(equalIndex + 1)
+      if (out[k] !== void 0) {
+        // @ts-expect-error
+        out[k] = [].concat(out[k], toValue(value))
+      } else {
+        out[k] = toValue(value)
+      }
     } else {
-      out[k] = toValue(tmp.shift())
+      k = tmp
+      k = decodeURIComponent(k)
+      out[k] = ''
     }
   }
 

package/src/root.ts

@@ -0,0 +1,2 @@
+export const rootRouteId = '__root__'
+export type RootRouteId = typeof rootRouteId