@tanstack/react-router 1.20.1 → 1.20.3-alpha.1

package/src/path.ts

@@ -1,280 +0,0 @@
-import { MatchLocation } from './RouterProvider'
-import { AnyPathParams } from './route'
-import { last } from './utils'
-
-export interface Segment {
-  type: 'pathname' | 'param' | 'wildcard'
-  value: string
-}
-
-export function joinPaths(paths: (string | undefined)[]) {
-  return cleanPath(paths.filter(Boolean).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 resolvePath(basepath: string, base: string, to: string) {
-  base = base.replace(new RegExp(`^${basepath}`), '/')
-  to = to.replace(new RegExp(`^${basepath}`), '/')
-
-  let baseSegments = parsePathname(base)
-  const toSegments = parsePathname(to)
-
-  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 === '..') {
-      // Extra trailing slash? pop it off
-      if (baseSegments.length > 1 && last(baseSegments)?.value === '/') {
-        baseSegments.pop()
-      }
-      baseSegments.pop()
-    } else if (toSegment.value === '.') {
-      return
-    } else {
-      baseSegments.push(toSegment)
-    }
-  })
-
-  const joined = joinPaths([basepath, ...baseSegments.map((d) => d.value)])
-
-  return cleanPath(joined)
-}
-
-export function parsePathname(pathname?: string): Segment[] {
-  if (!pathname) {
-    return []
-  }
-
-  pathname = cleanPath(pathname)
-
-  const segments: 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: part,
-      }
-    }),
-  )
-
-  if (pathname.slice(-1) === '/') {
-    pathname = pathname.substring(1)
-    segments.push({
-      type: 'pathname',
-      value: '/',
-    })
-  }
-
-  return segments
-}
-
-interface InterpolatePathOptions {
-  path?: string
-  params: any
-  leaveWildcards?: boolean
-  leaveParams?: boolean
-}
-export function interpolatePath({
-  path,
-  params,
-  leaveWildcards,
-  leaveParams,
-}: InterpolatePathOptions) {
-  const interpolatedPathSegments = parsePathname(path)
-
-  return joinPaths(
-    interpolatedPathSegments.map((segment) => {
-      if (segment.type === 'wildcard') {
-        const value = params._splat
-        if (leaveWildcards) return `${segment.value}${value ?? ''}`
-        return value
-      }
-
-      if (segment.type === 'param') {
-        if (leaveParams) {
-          const value = params[segment.value]
-          return `${segment.value}${value ?? ''}`
-        }
-        return params![segment.value.substring(1)] ?? 'undefined'
-      }
-
-      return segment.value
-    }),
-  )
-}
-
-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) {
-  return basepath != '/' ? pathname.replace(basepath, '') : pathname
-}
-
-export function matchByPath(
-  basepath: string,
-  from: string,
-  matchLocation: Pick<MatchLocation, 'to' | 'caseSensitive' | 'fuzzy'>,
-): Record<string, string> | undefined {
-  // Remove the base path from the pathname
-  from = removeBasepath(basepath, from)
-  // Default to to $ (wildcard)
-  const to = removeBasepath(basepath, `${matchLocation.to ?? '$'}`)
-
-  // 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> = {}
-
-  let 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') {
-          if (baseSegment?.value) {
-            const _splat = decodeURI(
-              joinPaths(baseSegments.slice(i).map((d) => d.value)),
-            )
-            // TODO: Deprecate *
-            params['*'] = _splat
-            params['_splat'] = _splat
-            return true
-          }
-          return false
-        }
-
-        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)] = decodeURI(
-              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 as Record<string, string>) : undefined
-}

package/src/qss.ts

@@ -1,53 +0,0 @@
-// @ts-nocheck
-
-// 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,
-    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
-}
-
-function toValue(mix) {
-  if (!mix) return ''
-  var str = decodeURIComponent(mix)
-  if (str === 'false') return false
-  if (str === 'true') return true
-  return +str * 0 === 0 && +str + '' === str ? +str : str
-}
-
-export function decode(str, pfx?: string) {
-  var tmp,
-    k,
-    out = {},
-    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()))
-    } else {
-      out[k] = toValue(tmp.shift())
-    }
-  }
-
-  return out
-}

package/src/redirects.ts

@@ -1,56 +0,0 @@
-import { PickAsRequired } from '.'
-import { NavigateOptions } from './link'
-import { AnyRoute } from './route'
-import { RoutePaths } from './routeInfo'
-import { RegisteredRouter } from './router'
-
-export type AnyRedirect = Redirect<any, any, any, any, any>
-
-export type Redirect<
-  TRouteTree extends AnyRoute = RegisteredRouter['routeTree'],
-  TFrom extends RoutePaths<TRouteTree> = '/',
-  TTo extends string = '',
-  TMaskFrom extends RoutePaths<TRouteTree> = TFrom,
-  TMaskTo extends string = '',
-> = {
-  /**
-   * @deprecated Use `statusCode` instead
-   **/
-  href?: string
-  code?: number
-  statusCode?: number
-  throw?: any
-} & NavigateOptions<TRouteTree, TFrom, TTo, TMaskFrom, TMaskTo>
-
-export type ResolvedRedirect<
-  TRouteTree extends AnyRoute = RegisteredRouter['routeTree'],
-  TFrom extends RoutePaths<TRouteTree> = '/',
-  TTo extends string = '',
-  TMaskFrom extends RoutePaths<TRouteTree> = TFrom,
-  TMaskTo extends string = '',
-> = PickAsRequired<
-  Redirect<TRouteTree, TFrom, TTo, TMaskFrom, TMaskTo>,
-  'code' | 'statusCode' | 'href'
->
-
-export function redirect<
-  TRouteTree extends AnyRoute = RegisteredRouter['routeTree'],
-  TFrom extends RoutePaths<TRouteTree> = '/',
-  TTo extends string = '',
-  TMaskFrom extends RoutePaths<TRouteTree> = TFrom,
-  TMaskTo extends string = '',
->(
-  opts: Redirect<TRouteTree, TFrom, TTo, TMaskFrom, TMaskTo>,
-): Redirect<TRouteTree, TFrom, TTo, TMaskFrom, TMaskTo> {
-  ;(opts as any).isRedirect = true
-  opts.statusCode = opts.statusCode || opts.code || 301
-  if (opts.throw ?? true) {
-    throw opts
-  }
-
-  return opts
-}
-
-export function isRedirect(obj: any): obj is AnyRedirect {
-  return !!obj?.isRedirect
-}