@tanstack/router-core 1.132.0-alpha.2 → 1.132.0-alpha.20

package/src/location.ts

@@ -2,12 +2,50 @@ import type { ParsedHistoryState } from '@tanstack/history'
 import type { AnySchema } from './validators'
 
 export interface ParsedLocation<TSearchObj extends AnySchema = {}> {
+  /**
+   * The full path of the location, including pathname, search, and hash.
+   * Does not include the origin. Is the equivalent of calling
+   * `url.replace(url.origin, '')`
+   */
   href: string
+  /**
+   * @description The pathname of the location, including the leading slash.
+   */
   pathname: string
+  /**
+   * The parsed search parameters of the location in object form.
+   */
   search: TSearchObj
+  /**
+   * The search string of the location, including the leading question mark.
+   */
   searchStr: string
+  /**
+   * The in-memory state of the location as it *may* exist in the browser's history.
+   */
   state: ParsedHistoryState
+  /**
+   * The hash of the location, including the leading hash character.
+   */
   hash: string
+  /**
+   * The masked location of the location.
+   */
   maskedLocation?: ParsedLocation<TSearchObj>
+  /**
+   * Whether to unmask the location on reload.
+   */
   unmaskOnReload?: boolean
+  /**
+   * @private
+   * @description The public href of the location, including the origin before any rewrites.
+   * If a rewrite is applied, the `href` property will be the rewritten URL.
+   */
+  publicHref: string
+  /**
+   * @private
+   * @description The full URL of the location, including the origin.
+   * @private
+   */
+  url: string
 }

package/src/path.ts

@@ -97,11 +97,9 @@ export function exactPathTest(
 // /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
   parseCache?: ParsePathnameCache
 }
 
@@ -151,16 +149,11 @@ function segmentToString(segment: Segment): string {
 }
 
 export function resolvePath({
-  basepath,
   base,
   to,
   trailingSlash = 'never',
-  caseSensitive,
   parseCache,
 }: ResolvePathOptions) {
-  base = removeBasepath(basepath, base, caseSensitive)
-  to = removeBasepath(basepath, to, caseSensitive)
-
   let baseSegments = parsePathname(base, parseCache).slice()
   const toSegments = parsePathname(to, parseCache)
 
@@ -201,7 +194,8 @@ export function resolvePath({
   }
 
   const segmentValues = baseSegments.map(segmentToString)
-  const joined = joinPaths([basepath, ...segmentValues])
+  // const joined = joinPaths([basepath, ...segmentValues])
+  const joined = joinPaths(segmentValues)
   return joined
 }
 
@@ -403,6 +397,10 @@ export function interpolatePath({
 
       if (segment.type === SEGMENT_TYPE_WILDCARD) {
         usedParams._splat = params._splat
+
+        // TODO: Deprecate *
+        usedParams['*'] = params._splat
+
         const segmentPrefix = segment.prefixSegment || ''
         const segmentSuffix = segment.suffixSegment || ''
 
@@ -491,17 +489,11 @@ function encodePathParam(value: string, decodeCharMap?: Map<string, string>) {
 }
 
 export function matchPathname(
-  basepath: string,
   currentPathname: string,
   matchLocation: Pick<MatchLocation, 'to' | 'fuzzy' | 'caseSensitive'>,
   parseCache?: ParsePathnameCache,
 ): AnyPathParams | undefined {
-  const pathParams = matchByPath(
-    basepath,
-    currentPathname,
-    matchLocation,
-    parseCache,
-  )
+  const pathParams = matchByPath(currentPathname, matchLocation, parseCache)
   // const searchMatched = matchBySearch(location.search, matchLocation)
 
   if (matchLocation.to && !pathParams) {
@@ -511,49 +503,7 @@ export function matchPathname(
   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,
   {
     to,
@@ -562,14 +512,7 @@ export function matchByPath(
   }: Pick<MatchLocation, 'to' | 'caseSensitive' | 'fuzzy'>,
   parseCache?: ParsePathnameCache,
 ): 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, caseSensitive)
-  // Default to to $ (wildcard)
-  to = removeBasepath(basepath, `${to ?? '$'}`, caseSensitive)
+  const stringTo = to as string
 
   // Parse the from and to
   const baseSegments = parsePathname(
@@ -577,7 +520,7 @@ export function matchByPath(
     parseCache,
   )
   const routeSegments = parsePathname(
-    to.startsWith('/') ? to : `/${to}`,
+    stringTo.startsWith('/') ? stringTo : `/${stringTo}`,
     parseCache,
   )
 

package/src/qss.ts

@@ -6,12 +6,15 @@
  * This reimplementation uses modern browser APIs
  * (namely URLSearchParams) and TypeScript while still
  * maintaining the original functionality and interface.
+ *
+ * Update: this implementation has also been mangled to
+ * fit exactly our use-case (single value per key in encoding).
  */
 
 /**
  * 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.
+ * @param stringify - An optional custom stringify function.
  * @returns The encoded query string.
  * @example
  * ```
@@ -19,18 +22,20 @@
  * // Expected output: "token=foo&key=value"
  * ```
  */
-export function encode(obj: any, pfx?: string) {
-  const normalizedObject = Object.entries(obj).flatMap(([key, value]) => {
-    if (Array.isArray(value)) {
-      return value.map((v) => [key, String(v)])
-    } else {
-      return [[key, String(value)]]
-    }
-  })
+export function encode(
+  obj: Record<string, any>,
+  stringify: (value: any) => string = String,
+): string {
+  const result = new URLSearchParams()
 
-  const searchParams = new URLSearchParams(normalizedObject)
+  for (const key in obj) {
+    const val = obj[key]
+    if (val !== undefined) {
+      result.set(key, stringify(val))
+    }
+  }
 
-  return (pfx || '') + searchParams.toString()
+  return result.toString()
 }
 
 /**
@@ -52,28 +57,26 @@ function toValue(str: unknown) {
 /**
  * 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): any {
-  const searchParamsPart = pfx ? str.slice(pfx.length) : str
-  const searchParams = new URLSearchParams(searchParamsPart)
+export function decode(str: any): any {
+  const searchParams = new URLSearchParams(str)
 
-  const entries = [...searchParams.entries()]
+  const result: Record<string, unknown> = {}
 
-  return entries.reduce<Record<string, unknown>>((acc, [key, value]) => {
-    const previousValue = acc[key]
+  for (const [key, value] of searchParams.entries()) {
+    const previousValue = result[key]
     if (previousValue == null) {
-      acc[key] = toValue(value)
+      result[key] = toValue(value)
+    } else if (Array.isArray(previousValue)) {
+      previousValue.push(toValue(value))
     } else {
-      acc[key] = Array.isArray(previousValue)
-        ? [...previousValue, toValue(value)]
-        : [previousValue, toValue(value)]
+      result[key] = [previousValue, toValue(value)]
     }
+  }
 
-    return acc
-  }, {})
+  return result
 }

package/src/redirect.ts

@@ -65,9 +65,9 @@ export function redirect<
 ): Redirect<TRouter, TFrom, TTo, TMaskFrom, TMaskTo> {
   opts.statusCode = opts.statusCode || opts.code || 307
 
-  if (!opts.reloadDocument) {
+  if (!opts.reloadDocument && typeof opts.href === 'string') {
     try {
-      new URL(`${opts.href}`)
+      new URL(opts.href)
       opts.reloadDocument = true
     } catch {}
   }
@@ -103,7 +103,7 @@ export function isResolvedRedirect(
 }
 
 export function parseRedirect(obj: any) {
-  if (typeof obj === 'object' && obj.isSerializedRedirect) {
+  if (obj !== null && typeof obj === 'object' && obj.isSerializedRedirect) {
     return redirect(obj)
   }
 

package/src/rewrite.ts

@@ -0,0 +1,70 @@
+import { joinPaths, trimPath } from './path'
+import type { LocationRewrite } from './router'
+
+export function composeRewrites(rewrites: Array<LocationRewrite>) {
+  return {
+    input: ({ url }) => {
+      for (const rewrite of rewrites) {
+        url = executeRewriteInput(rewrite, url)
+      }
+      return url
+    },
+    output: ({ url }) => {
+      for (let i = rewrites.length - 1; i >= 0; i--) {
+        url = executeRewriteOutput(rewrites[i], url)
+      }
+      return url
+    },
+  } satisfies LocationRewrite
+}
+
+export function rewriteBasepath(opts: {
+  basepath: string
+  caseSensitive?: boolean
+}) {
+  const trimmedBasepath = trimPath(opts.basepath)
+  const regex = new RegExp(
+    `^/${trimmedBasepath}/`,
+    opts.caseSensitive ? '' : 'i',
+  )
+  return {
+    input: ({ url }) => {
+      url.pathname = url.pathname.replace(regex, '/')
+      return url
+    },
+    output: ({ url }) => {
+      url.pathname = joinPaths(['/', trimmedBasepath, url.pathname])
+      return url
+    },
+  } satisfies LocationRewrite
+}
+
+export function executeRewriteInput(
+  rewrite: LocationRewrite | undefined,
+  url: URL,
+): URL {
+  const res = rewrite?.input?.({ url })
+  if (res) {
+    if (typeof res === 'string') {
+      return new URL(res)
+    } else if (res instanceof URL) {
+      return res
+    }
+  }
+  return url
+}
+
+export function executeRewriteOutput(
+  rewrite: LocationRewrite | undefined,
+  url: URL,
+): URL {
+  const res = rewrite?.output?.({ url })
+  if (res) {
+    if (typeof res === 'string') {
+      return new URL(res)
+    } else if (res instanceof URL) {
+      return res
+    }
+  }
+  return url
+}