@tanstack/router-core 1.120.4-alpha.19 → 1.120.4

package/src/path.ts

@@ -5,9 +5,6 @@ import type { AnyPathParams } from './route'
 export interface Segment {
   type: 'pathname' | 'param' | 'wildcard'
   value: string
-  // Add a new property to store the static segment if present
-  prefixSegment?: string
-  suffixSegment?: string
 }
 
 export function joinPaths(paths: Array<string | undefined>) {
@@ -140,52 +137,10 @@ export function resolvePath({
     }
   }
 
-  const segmentValues = baseSegments.map((segment) => {
-    if (segment.type === 'param') {
-      const param = segment.value.substring(1)
-      if (segment.prefixSegment && segment.suffixSegment) {
-        return `${segment.prefixSegment}{$${param}}${segment.suffixSegment}`
-      } else if (segment.prefixSegment) {
-        return `${segment.prefixSegment}{$${param}}`
-      } else if (segment.suffixSegment) {
-        return `{$${param}}${segment.suffixSegment}`
-      }
-    }
-    if (segment.type === 'wildcard') {
-      if (segment.prefixSegment && segment.suffixSegment) {
-        return `${segment.prefixSegment}{$}${segment.suffixSegment}`
-      } else if (segment.prefixSegment) {
-        return `${segment.prefixSegment}{$}`
-      } else if (segment.suffixSegment) {
-        return `{$}${segment.suffixSegment}`
-      }
-    }
-    return segment.value
-  })
-  const joined = joinPaths([basepath, ...segmentValues])
+  const joined = joinPaths([basepath, ...baseSegments.map((d) => d.value)])
   return cleanPath(joined)
 }
 
-const PARAM_RE = /^\$.{1,}$/ // $paramName
-const PARAM_W_CURLY_BRACES_RE = /^(.*?)\{(\$[a-zA-Z_$][a-zA-Z0-9_$]*)\}(.*)$/ // prefix{$paramName}suffix
-const WILDCARD_RE = /^\$$/ // $
-const WILDCARD_W_CURLY_BRACES_RE = /^(.*?)\{\$\}(.*)$/ // prefix{$}suffix
-
-/**
- * Required: `/foo/$bar` ✅
- * Prefix and Suffix: `/foo/prefix${bar}suffix` ✅
- * Wildcard: `/foo/$` ✅
- * Wildcard with Prefix and Suffix: `/foo/prefix{$}suffix` ✅
- *
- * Future:
- * Optional: `/foo/{-bar}`
- * Optional named segment: `/foo/{bar}`
- * Optional named segment with Prefix and Suffix: `/foo/prefix{-bar}suffix`
- * Escape special characters:
- * - `/foo/[$]` - Static route
- * - `/foo/[$]{$foo} - Dynamic route with a static prefix of `$`
- * - `/foo/{$foo}[$]` - Dynamic route with a static suffix of `$`
- */
 export function parsePathname(pathname?: string): Array<Segment> {
   if (!pathname) {
     return []
@@ -212,55 +167,20 @@ export function parsePathname(pathname?: string): Array<Segment> {
 
   segments.push(
     ...split.map((part): Segment => {
-      // Check for wildcard with curly braces: prefix{$}suffix
-      const wildcardBracesMatch = part.match(WILDCARD_W_CURLY_BRACES_RE)
-      if (wildcardBracesMatch) {
-        const prefix = wildcardBracesMatch[1]
-        const suffix = wildcardBracesMatch[2]
+      if (part === '$' || part === '*') {
         return {
           type: 'wildcard',
-          value: '$',
-          prefixSegment: prefix || undefined,
-          suffixSegment: suffix || undefined,
+          value: part,
         }
       }
 
-      // Check for the new parameter format: prefix{$paramName}suffix
-      const paramBracesMatch = part.match(PARAM_W_CURLY_BRACES_RE)
-      if (paramBracesMatch) {
-        const prefix = paramBracesMatch[1]
-        const paramName = paramBracesMatch[2]
-        const suffix = paramBracesMatch[3]
+      if (part.charAt(0) === '$') {
         return {
           type: 'param',
-          value: '' + paramName,
-          prefixSegment: prefix || undefined,
-          suffixSegment: suffix || undefined,
+          value: part,
         }
       }
 
-      // Check for bare parameter format: $paramName (without curly braces)
-      if (PARAM_RE.test(part)) {
-        const paramName = part.substring(1)
-        return {
-          type: 'param',
-          value: '$' + paramName,
-          prefixSegment: undefined,
-          suffixSegment: undefined,
-        }
-      }
-
-      // Check for bare wildcard: $ (without curly braces)
-      if (WILDCARD_RE.test(part)) {
-        return {
-          type: 'wildcard',
-          value: '$',
-          prefixSegment: undefined,
-          suffixSegment: undefined,
-        }
-      }
-
-      // Handle regular pathname segment
       return {
         type: 'pathname',
         value: part.includes('%25')
@@ -328,13 +248,9 @@ export function interpolatePath({
     interpolatedPathSegments.map((segment) => {
       if (segment.type === 'wildcard') {
         usedParams._splat = params._splat
-        const segmentPrefix = segment.prefixSegment || ''
-        const segmentSuffix = segment.suffixSegment || ''
         const value = encodeParam('_splat')
-        if (leaveWildcards) {
-          return `${segmentPrefix}${segment.value}${value ?? ''}${segmentSuffix}`
-        }
-        return `${segmentPrefix}${value}${segmentSuffix}`
+        if (leaveWildcards) return `${segment.value}${value ?? ''}`
+        return value
       }
 
       if (segment.type === 'param') {
@@ -343,14 +259,11 @@ export function interpolatePath({
           isMissingParams = true
         }
         usedParams[key] = params[key]
-
-        const segmentPrefix = segment.prefixSegment || ''
-        const segmentSuffix = segment.suffixSegment || ''
         if (leaveParams) {
           const value = encodeParam(segment.value)
-          return `${segmentPrefix}${segment.value}${value ?? ''}${segmentSuffix}`
+          return `${segment.value}${value ?? ''}`
         }
-        return `${segmentPrefix}${encodeParam(key) ?? 'undefined'}${segmentSuffix}`
+        return encodeParam(key) ?? 'undefined'
       }
 
       return segment.value
@@ -477,57 +390,9 @@ export function matchByPath(
 
       if (routeSegment) {
         if (routeSegment.type === 'wildcard') {
-          // Capture all remaining segments for a wildcard
-          const remainingBaseSegments = baseSegments.slice(i)
-
-          let _splat: string
-
-          // If this is a wildcard with prefix/suffix, we need to handle the first segment specially
-          if (routeSegment.prefixSegment || routeSegment.suffixSegment) {
-            if (!baseSegment) return false
-
-            const prefix = routeSegment.prefixSegment || ''
-            const suffix = routeSegment.suffixSegment || ''
-
-            // Check if the base segment starts with prefix and ends with suffix
-            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)),
-            )
-
-            // Remove the prefix and suffix from the rejoined splat
-            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 {
-            // If no prefix/suffix, just rejoin the remaining segments
-            _splat = decodeURI(
-              joinPaths(remainingBaseSegments.map((d) => d.value)),
-            )
-          }
-
+          const _splat = decodeURI(
+            joinPaths(baseSegments.slice(i).map((d) => d.value)),
+          )
           // TODO: Deprecate *
           params['*'] = _splat
           params['_splat'] = _splat
@@ -561,41 +426,11 @@ export function matchByPath(
           if (baseSegment.value === '/') {
             return false
           }
-
-          let _paramValue: string
-
-          // If this param has prefix/suffix, we need to extract the actual parameter value
-          if (routeSegment.prefixSegment || routeSegment.suffixSegment) {
-            const prefix = routeSegment.prefixSegment || ''
-            const suffix = routeSegment.suffixSegment || ''
-
-            // Check if the base segment starts with prefix and ends with suffix
-            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)
-          } else {
-            // If no prefix/suffix, just decode the base segment value
-            _paramValue = decodeURIComponent(baseSegment.value)
+          if (baseSegment.value.charAt(0) !== '$') {
+            params[routeSegment.value.substring(1)] = decodeURIComponent(
+              baseSegment.value,
+            )
           }
-
-          params[routeSegment.value.substring(1)] = _paramValue
         }
       }
 

package/src/redirect.ts

@@ -1,5 +1,6 @@
 import type { NavigateOptions } from './link'
 import type { AnyRouter, RegisteredRouter } from './router'
+import type { PickAsRequired } from './utils'
 
 export type AnyRedirect = Redirect<any, any, any, any, any>
 
@@ -12,17 +13,6 @@ export type Redirect<
   TTo extends string | undefined = undefined,
   TMaskFrom extends string = TFrom,
   TMaskTo extends string = '.',
-> = Response & {
-  options: NavigateOptions<TRouter, TFrom, TTo, TMaskFrom, TMaskTo>
-  redirectHandled?: boolean
-}
-
-export type RedirectOptions<
-  TRouter extends AnyRouter = RegisteredRouter,
-  TFrom extends string = string,
-  TTo extends string | undefined = undefined,
-  TMaskFrom extends string = TFrom,
-  TMaskTo extends string = '.',
 > = {
   href?: string
   /**
@@ -52,7 +42,12 @@ export type ResolvedRedirect<
   TTo extends string = '',
   TMaskFrom extends string = TFrom,
   TMaskTo extends string = '',
-> = Redirect<TRouter, TFrom, TTo, TMaskFrom, TMaskTo>
+> = PickAsRequired<
+  Redirect<TRouter, TFrom, TTo, TMaskFrom, TMaskTo>,
+  'code' | 'statusCode' | 'headers'
+> & {
+  href: string
+}
 
 export function redirect<
   TRouter extends AnyRouter = RegisteredRouter,
@@ -61,40 +56,30 @@ export function redirect<
   const TMaskFrom extends string = TFrom,
   const TMaskTo extends string = '',
 >(
-  opts: RedirectOptions<TRouter, TFrom, TTo, TMaskFrom, TMaskTo>,
+  opts: Redirect<TRouter, TFrom, TTo, TMaskFrom, TMaskTo>,
 ): Redirect<TRouter, TFrom, TTo, TMaskFrom, TMaskTo> {
+  ;(opts as any).isRedirect = true
   opts.statusCode = opts.statusCode || opts.code || 307
-  const headers = new Headers(opts.headers || {})
-
-  const response = new Response(null, {
-    status: opts.statusCode,
-    headers,
-  })
-
-  ;(response as Redirect<TRouter, TFrom, TTo, TMaskFrom, TMaskTo>).options =
-    opts
+  opts.headers = opts.headers || {}
+  if (!opts.reloadDocument) {
+    opts.reloadDocument = false
+    try {
+      new URL(`${opts.href}`)
+      opts.reloadDocument = true
+    } catch {}
+  }
 
   if (opts.throw) {
-    throw response
+    throw opts
   }
 
-  return response as Redirect<TRouter, TFrom, TTo, TMaskFrom, TMaskTo>
+  return opts
 }
 
 export function isRedirect(obj: any): obj is AnyRedirect {
-  return obj instanceof Response && !!(obj as any).options
+  return !!obj?.isRedirect
 }
 
-export function isResolvedRedirect(
-  obj: any,
-): obj is AnyRedirect & { options: { href: string } } {
-  return isRedirect(obj) && !!obj.options.href
-}
-
-export function parseRedirect(obj: any) {
-  if (typeof obj === 'object' && obj.isSerializedRedirect) {
-    return redirect(obj)
-  }
-
-  return undefined
+export function isResolvedRedirect(obj: any): obj is ResolvedRedirect {
+  return !!obj?.isRedirect && obj.href
 }

package/src/route.ts

@@ -1,4 +1,3 @@
-import invariant from 'tiny-invariant'
 import { joinPaths, trimPathLeft } from './path'
 import { notFound } from './not-found'
 import { rootRouteId } from './root'
@@ -21,8 +20,6 @@ import type {
   Constrain,
   Expand,
   IntersectAssign,
-  LooseAsyncReturnType,
-  LooseReturnType,
   NoInfer,
 } from './utils'
 import type {
@@ -153,24 +150,27 @@ export type ResolveSearchSchema<TSearchValidator> =
           ? ResolveSearchSchemaFn<TSearchValidator['parse']>
           : ResolveSearchSchemaFn<TSearchValidator>
 
-export type ResolveRequiredParams<TPath extends string, T> = {
-  [K in ParsePathParams<TPath>['required']]: T
-}
+export type ParseSplatParams<TPath extends string> = TPath &
+  `${string}$` extends never
+  ? TPath & `${string}$/${string}` extends never
+    ? never
+    : '_splat'
+  : '_splat'
 
-export type ResolveOptionalParams<TPath extends string, T> = {
-  [K in ParsePathParams<TPath>['optional']]?: T
+export interface SplatParams {
+  _splat?: string
 }
 
-export type ResolveParams<
-  TPath extends string,
-  T = string,
-> = ResolveRequiredParams<TPath, T> & ResolveOptionalParams<TPath, T>
+export type ResolveParams<TPath extends string> =
+  ParseSplatParams<TPath> extends never
+    ? Record<ParsePathParams<TPath>, string>
+    : Record<ParsePathParams<TPath>, string> & SplatParams
 
 export type ParseParamsFn<in out TPath extends string, in out TParams> = (
-  rawParams: Expand<ResolveParams<TPath>>,
-) => TParams extends ResolveParams<TPath, any>
+  rawParams: ResolveParams<TPath>,
+) => TParams extends Record<ParsePathParams<TPath>, any>
   ? TParams
-  : ResolveParams<TPath, any>
+  : Record<ParsePathParams<TPath>, any>
 
 export type StringifyParamsFn<in out TPath extends string, in out TParams> = (
   params: TParams,
@@ -270,6 +270,20 @@ export type TrimPathRight<T extends string> = T extends '/'
     ? TrimPathRight<U>
     : T
 
+export type LooseReturnType<T> = T extends (
+  ...args: Array<any>
+) => infer TReturn
+  ? TReturn
+  : never
+
+export type LooseAsyncReturnType<T> = T extends (
+  ...args: Array<any>
+) => infer TReturn
+  ? TReturn extends Promise<infer TReturn>
+    ? TReturn
+    : TReturn
+  : never
+
 export type ContextReturnType<TContextFn> = unknown extends TContextFn
   ? TContextFn
   : LooseReturnType<TContextFn> extends never
@@ -434,7 +448,7 @@ export interface RouteExtensions<in out TId, in out TFullPath> {
 }
 
 export type RouteLazyFn<TRoute extends AnyRoute> = (
-  lazyFn: () => Promise<LazyRoute<TRoute>>,
+  lazyFn: () => Promise<LazyRoute>,
 ) => TRoute
 
 export type RouteAddChildrenFn<
@@ -588,26 +602,7 @@ export interface Route<
   >
   isRoot: TParentRoute extends AnyRoute ? true : false
   _componentsPromise?: Promise<Array<void>>
-  lazyFn?: () => Promise<
-    LazyRoute<
-      Route<
-        TParentRoute,
-        TPath,
-        TFullPath,
-        TCustomId,
-        TId,
-        TSearchValidator,
-        TParams,
-        TRouterContext,
-        TRouteContextFn,
-        TBeforeLoadFn,
-        TLoaderDeps,
-        TLoaderFn,
-        TChildren,
-        TFileRouteTypes
-      >
-    >
-  >
+  lazyFn?: () => Promise<LazyRoute>
   _lazyPromise?: Promise<void>
   rank: number
   to: TrimPathRight<TFullPath>
@@ -626,24 +621,7 @@ export interface Route<
       TBeforeLoadFn
     >,
   ) => this
-  lazy: RouteLazyFn<
-    Route<
-      TParentRoute,
-      TPath,
-      TFullPath,
-      TCustomId,
-      TId,
-      TSearchValidator,
-      TParams,
-      TRouterContext,
-      TRouteContextFn,
-      TBeforeLoadFn,
-      TLoaderDeps,
-      TLoaderFn,
-      TChildren,
-      TFileRouteTypes
-    >
-  >
+  lazy: RouteLazyFn<this>
   addChildren: RouteAddChildrenFn<
     TParentRoute,
     TPath,
@@ -1358,26 +1336,7 @@ export class BaseRoute<
   children?: TChildren
   originalIndex?: number
   rank!: number
-  lazyFn?: () => Promise<
-    LazyRoute<
-      Route<
-        TParentRoute,
-        TPath,
-        TFullPath,
-        TCustomId,
-        TId,
-        TSearchValidator,
-        TParams,
-        TRouterContext,
-        TRouteContextFn,
-        TBeforeLoadFn,
-        TLoaderDeps,
-        TLoaderFn,
-        TChildren,
-        TFileRouteTypes
-      >
-    >
-  >
+  lazyFn?: () => Promise<LazyRoute>
   _lazyPromise?: Promise<void>
   _componentsPromise?: Promise<Array<void>>
 
@@ -1450,8 +1409,7 @@ export class BaseRoute<
     if (isRoot) {
       this._path = rootRouteId as TPath
     } else if (!this.parentRoute) {
-      invariant(
-        false,
+      throw new Error(
         `Child Route instances must pass a 'getParentRoute: () => ParentRoute' option that returns a Route instance.`,
       )
     }
@@ -1491,16 +1449,6 @@ export class BaseRoute<
     this._ssr = options?.ssr ?? opts.defaultSsr ?? true
   }
 
-  clone = (other: typeof this) => {
-    this._path = other._path
-    this._id = other._id
-    this._fullPath = other._fullPath
-    this._to = other._to
-    this._ssr = other._ssr
-    this.options.getParentRoute = other.options.getParentRoute
-    this.children = other.children
-  }
-
   addChildren: RouteAddChildrenFn<
     TParentRoute,
     TPath,
@@ -1614,24 +1562,7 @@ export class BaseRoute<
     return this
   }
 
-  lazy: RouteLazyFn<
-    Route<
-      TParentRoute,
-      TPath,
-      TFullPath,
-      TCustomId,
-      TId,
-      TSearchValidator,
-      TParams,
-      TRouterContext,
-      TRouteContextFn,
-      TBeforeLoadFn,
-      TLoaderDeps,
-      TLoaderFn,
-      TChildren,
-      TFileRouteTypes
-    >
-  > = (lazyFn) => {
+  lazy: RouteLazyFn<this> = (lazyFn) => {
     this.lazyFn = lazyFn
     return this
   }