@tanstack/react-router 1.97.19 → 1.97.21

package/src/path.ts

@@ -1,427 +0,0 @@
-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: Array<string | undefined>) {
-  return cleanPath(
-    paths
-      .filter((val) => {
-        return val !== undefined
-      })
-      .join('/'),
-  )
-}
-
-export function cleanPath(path: string) {
-  // remove double slashes
-  return path.replace(/\/{2,}/g, '/')
-}
-
-export function trimPathLeft(path: string) {
-  return path === '/' ? path : path.replace(/^\/{1,}/, '')
-}
-
-export function trimPathRight(path: string) {
-  return path === '/' ? path : path.replace(/\/{1,}$/, '')
-}
-
-export function trimPath(path: string) {
-  return trimPathRight(trimPathLeft(path))
-}
-
-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) {
-        // Leading slash
-        baseSegments = [toSegment]
-      } else if (index === toSegments.length - 1) {
-        // Trailing Slash
-        baseSegments.push(toSegment)
-      } else {
-        // ignore inter-slashes
-      }
-    } else if (toSegment.value === '..') {
-      baseSegments.pop()
-    } else if (toSegment.value === '.') {
-      // ignore
-    } else {
-      baseSegments.push(toSegment)
-    }
-  })
-
-  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): Array<Segment> {
-  if (!pathname) {
-    return []
-  }
-
-  pathname = cleanPath(pathname)
-
-  const segments: Array<Segment> = []
-
-  if (pathname.slice(0, 1) === '/') {
-    pathname = pathname.substring(1)
-    segments.push({
-      type: 'pathname',
-      value: '/',
-    })
-  }
-
-  if (!pathname) {
-    return segments
-  }
-
-  // Remove empty segments and '.' segments
-  const split = pathname.split('/').filter(Boolean)
-
-  segments.push(
-    ...split.map((part): Segment => {
-      if (part === '$' || part === '*') {
-        return {
-          type: 'wildcard',
-          value: part,
-        }
-      }
-
-      if (part.charAt(0) === '$') {
-        return {
-          type: 'param',
-          value: part,
-        }
-      }
-
-      return {
-        type: 'pathname',
-        value: decodeURI(part),
-      }
-    }),
-  )
-
-  if (pathname.slice(-1) === '/') {
-    pathname = pathname.substring(1)
-    segments.push({
-      type: 'pathname',
-      value: '/',
-    })
-  }
-
-  return segments
-}
-
-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.type === 'wildcard') {
-        const value = encodedParams._splat
-        if (leaveWildcards) return `${segment.value}${value ?? ''}`
-        return value
-      }
-
-      if (segment.type === 'param') {
-        if (leaveParams) {
-          const value = encodedParams[segment.value]
-          return `${segment.value}${value ?? ''}`
-        }
-        return encodedParams![segment.value.substring(1)] ?? 'undefined'
-      }
-
-      return segment.value
-    }),
-  )
-}
-
-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(basepath, currentPathname, matchLocation)
-  // const searchMatched = matchBySearch(location.search, matchLocation)
-
-  if (matchLocation.to && !pathParams) {
-    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(to)
-
-  if (!from.startsWith('/')) {
-    baseSegments.unshift({
-      type: 'pathname',
-      value: '/',
-    })
-  }
-
-  if (!to.startsWith('/')) {
-    routeSegments.unshift({
-      type: 'pathname',
-      value: '/',
-    })
-  }
-
-  const params: Record<string, string> = {}
-
-  const isMatch = (() => {
-    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 _splat = decodeURI(
-            joinPaths(baseSegments.slice(i).map((d) => d.value)),
-          )
-          // TODO: Deprecate *
-          params['*'] = _splat
-          params['_splat'] = _splat
-          return true
-        }
-
-        if (routeSegment.type === 'pathname') {
-          if (routeSegment.value === '/' && !baseSegment?.value) {
-            return true
-          }
-
-          if (baseSegment) {
-            if (matchLocation.caseSensitive) {
-              if (routeSegment.value !== baseSegment.value) {
-                return false
-              }
-            } else if (
-              routeSegment.value.toLowerCase() !==
-              baseSegment.value.toLowerCase()
-            ) {
-              return false
-            }
-          }
-        }
-
-        if (!baseSegment) {
-          return false
-        }
-
-        if (routeSegment.type === 'param') {
-          if (baseSegment.value === '/') {
-            return false
-          }
-          if (baseSegment.value.charAt(0) !== '$') {
-            params[routeSegment.value.substring(1)] = decodeURIComponent(
-              baseSegment.value,
-            )
-          }
-        }
-      }
-
-      if (!isLastBaseSegment && isLastRouteSegment) {
-        params['**'] = joinPaths(baseSegments.slice(i + 1).map((d) => d.value))
-        return !!matchLocation.fuzzy && routeSegment?.value !== '/'
-      }
-    }
-
-    return true
-  })()
-
-  return isMatch ? params : undefined
-}

package/src/qss.ts

@@ -1,91 +0,0 @@
-/**
- * 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
- */
-
-/**
- * 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 = ''
-
-  for (k in obj) {
-    if ((tmp = obj[k]) !== void 0) {
-      if (Array.isArray(tmp)) {
-        for (i = 0; i < tmp.length; i++) {
-          str && (str += '&')
-          str += encodeURIComponent(k) + '=' + encodeURIComponent(tmp[i])
-        }
-      } else {
-        str && (str += '&')
-        str += encodeURIComponent(k) + '=' + encodeURIComponent(tmp)
-      }
-    }
-  }
-
-  return (pfx || '') + str
-}
-
-/**
- * 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 ''
-  const str = decodeURIComponent(mix)
-  if (str === 'false') return false
-  if (str === 'true') return true
-  return +str * 0 === 0 && +str + '' === str ? +str : str
-}
-
-/**
- * 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())) {
-    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 {
-      k = tmp
-      k = decodeURIComponent(k)
-      out[k] = ''
-    }
-  }
-
-  return out
-}

package/src/root.ts

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

package/src/searchMiddleware.ts

@@ -1,54 +0,0 @@
-import { deepEqual } from './utils'
-import type { NoInfer, PickOptional } from './utils'
-import type { SearchMiddleware } from './route'
-import type { IsRequiredParams } from './link'
-
-export function retainSearchParams<TSearchSchema extends object>(
-  keys: Array<keyof TSearchSchema> | true,
-): SearchMiddleware<TSearchSchema> {
-  return ({ search, next }) => {
-    const result = next(search)
-    if (keys === true) {
-      return { ...search, ...result }
-    }
-    // add missing keys from search to result
-    keys.forEach((key) => {
-      if (!(key in result)) {
-        result[key] = search[key]
-      }
-    })
-    return result
-  }
-}
-
-export function stripSearchParams<
-  TSearchSchema,
-  TOptionalProps = PickOptional<NoInfer<TSearchSchema>>,
-  const TValues =
-    | Partial<NoInfer<TOptionalProps>>
-    | Array<keyof TOptionalProps>,
-  const TInput = IsRequiredParams<TSearchSchema> extends never
-    ? TValues | true
-    : TValues,
->(input: NoInfer<TInput>): SearchMiddleware<TSearchSchema> {
-  return ({ search, next }) => {
-    if (input === true) {
-      return {}
-    }
-    const result = next(search) as Record<string, unknown>
-    if (Array.isArray(input)) {
-      input.forEach((key) => {
-        delete result[key]
-      })
-    } else {
-      Object.entries(input as Record<string, unknown>).forEach(
-        ([key, value]) => {
-          if (deepEqual(result[key], value)) {
-            delete result[key]
-          }
-        },
-      )
-    }
-    return result as any
-  }
-}

package/src/searchParams.ts

@@ -1,77 +0,0 @@
-import { decode, encode } from './qss'
-import type { AnySchema } from './validators'
-
-export const defaultParseSearch = parseSearchWith(JSON.parse)
-export const defaultStringifySearch = stringifySearchWith(
-  JSON.stringify,
-  JSON.parse,
-)
-
-export function parseSearchWith(parser: (str: string) => any) {
-  return (searchStr: string): AnySchema => {
-    if (searchStr.substring(0, 1) === '?') {
-      searchStr = searchStr.substring(1)
-    }
-
-    const query: Record<string, unknown> = decode(searchStr)
-
-    // Try to parse any query params that might be json
-    for (const key in query) {
-      const value = query[key]
-      if (typeof value === 'string') {
-        try {
-          query[key] = parser(value)
-        } catch (err) {
-          //
-        }
-      }
-    }
-
-    return query
-  }
-}
-
-export function stringifySearchWith(
-  stringify: (search: any) => string,
-  parser?: (str: string) => any,
-) {
-  function stringifyValue(val: any) {
-    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: Record<string, any>) => {
-    search = { ...search }
-
-    Object.keys(search).forEach((key) => {
-      const val = search[key]
-      if (typeof val === 'undefined' || val === undefined) {
-        delete search[key]
-      } else {
-        search[key] = stringifyValue(val)
-      }
-    })
-
-    const searchStr = encode(search as Record<string, string>).toString()
-
-    return searchStr ? `?${searchStr}` : ''
-  }
-}
-
-export type SearchSerializer = (searchObj: Record<string, any>) => string
-export type SearchParser = (searchStr: string) => Record<string, any>

package/src/serializer.ts

@@ -1,24 +0,0 @@
-export interface StartSerializer {
-  stringify: (obj: unknown) => string
-  parse: (str: string) => unknown
-  encode: <T>(value: T) => T
-  decode: <T>(value: T) => T
-}
-
-export type SerializerStringifyBy<T, TSerializable> = T extends TSerializable
-  ? T
-  : T extends (...args: Array<any>) => any
-    ? 'Function is not serializable'
-    : { [K in keyof T]: SerializerStringifyBy<T[K], TSerializable> }
-
-export type SerializerParseBy<T, TSerializable> = T extends TSerializable
-  ? T
-  : T extends React.JSX.Element
-    ? ReadableStream
-    : { [K in keyof T]: SerializerParseBy<T[K], TSerializable> }
-
-export type Serializable = Date | undefined | Error | FormData
-
-export type SerializerStringify<T> = SerializerStringifyBy<T, Serializable>
-
-export type SerializerParse<T> = SerializerParseBy<T, Serializable>