@tanstack/router-core 0.0.1-beta.19 → 0.0.1-beta.190

package/src/link.ts

@@ -1,11 +1,15 @@
-import { AnyPathParams } from './routeConfig'
+import { Trim } from './fileRoute'
+import { AnyRoute } from './route'
+import { AllParams, RouteByPath, RouteIds, RoutePaths } from './routeInfo'
+import { LocationState, ParsedLocation } from './router'
 import {
-  AnyAllRouteInfo,
-  DefaultAllRouteInfo,
-  RouteInfoByPath,
-} from './routeInfo'
-import { Location, LocationState } from './router'
-import { Expand, NoInfer, PickAsRequired, PickRequired, Updater } from './utils'
+  Expand,
+  NoInfer,
+  NonNullableUpdater,
+  PickRequired,
+  UnionToIntersection,
+  Updater,
+} from './utils'
 
 export type LinkInfo =
   | {
@@ -14,20 +18,17 @@ export type LinkInfo =
     }
   | {
       type: 'internal'
-      next: Location
+      next: ParsedLocation
       handleFocus: (e: any) => void
       handleClick: (e: any) => void
       handleEnter: (e: any) => void
       handleLeave: (e: any) => void
+      handleTouchStart: (e: any) => void
       isActive: boolean
       disabled?: boolean
     }
 
-type StartsWith<A, B> = A extends `${B extends string ? B : never}${infer _}`
-  ? true
-  : false
-
-type CleanPath<T extends string> = T extends `${infer L}//${infer R}`
+export type CleanPath<T extends string> = T extends `${infer L}//${infer R}`
   ? CleanPath<`${CleanPath<L>}/${CleanPath<R>}`>
   : T extends `${infer L}//`
   ? `${CleanPath<L>}/`
@@ -57,20 +58,20 @@ export type Split<S, TIncludeTrailingSlash = true> = S extends unknown
     : never
   : never
 
-export type ParsePathParams<T extends string> = Split<T>[number] extends infer U
-  ? U extends `:${infer V}`
-    ? V
-    : never
-  : never
+export type ParsePathParams<T extends string> = keyof {
+  [K in Trim<Split<T>[number], '_'> as K extends `$${infer L}` ? L : never]: K
+}
 
-type Join<T> = T extends []
+export type Join<T, Delimiter extends string = '/'> = T extends []
   ? ''
   : T extends [infer L extends string]
   ? L
   : T extends [infer L extends string, ...infer Tail extends [...string[]]]
-  ? CleanPath<`${L}/${Join<Tail>}`>
+  ? CleanPath<`${L}${Delimiter}${Join<Tail>}`>
   : never
 
+export type Last<T extends any[]> = T extends [...infer _, infer L] ? L : never
+
 export type RelativeToPathAutoComplete<
   AllPaths extends string,
   TFrom extends string,
@@ -106,128 +107,157 @@ export type RelativeToPathAutoComplete<
     ]
     ? `${TTo}${Join<RestPath>}`
     : never
-  : './' | '../' | AllPaths
+  :
+      | (TFrom extends `/`
+          ? never
+          : SplitPaths extends [...Split<TFrom, false>, ...infer RestPath]
+          ? Join<RestPath> extends { length: 0 }
+            ? never
+            : './'
+          : never)
+      | (TFrom extends `/` ? never : '../')
+      | AllPaths
 
-export type NavigateOptionsAbsolute<
-  TAllRouteInfo extends AnyAllRouteInfo = DefaultAllRouteInfo,
-  TFrom extends ValidFromPath<TAllRouteInfo> = '/',
-  TTo extends string = '.',
-> = ToOptions<TAllRouteInfo, TFrom, TTo> & {
-  // Whether to replace the current history stack instead of pushing a new one
+export type NavigateOptions<
+  TRouteTree extends AnyRoute = AnyRoute,
+  TFrom extends RoutePaths<TRouteTree> = '/',
+  TTo extends string = '',
+  TMaskFrom extends RoutePaths<TRouteTree> = TFrom,
+  TMaskTo extends string = '',
+> = ToOptions<TRouteTree, TFrom, TTo, TMaskFrom, TMaskTo> & {
+  // `replace` is a boolean that determines whether the navigation should replace the current history entry or push a new one.
   replace?: boolean
+  resetScroll?: boolean
 }
 
 export type ToOptions<
-  TAllRouteInfo extends AnyAllRouteInfo = DefaultAllRouteInfo,
-  TFrom extends ValidFromPath<TAllRouteInfo> = '/',
-  TTo extends string = '.',
-  TResolvedTo = ResolveRelativePath<TFrom, NoInfer<TTo>>,
+  TRouteTree extends AnyRoute = AnyRoute,
+  TFrom extends RoutePaths<TRouteTree> = '/',
+  TTo extends string = '',
+  TMaskFrom extends RoutePaths<TRouteTree> = '/',
+  TMaskTo extends string = '',
+> = ToSubOptions<TRouteTree, TFrom, TTo> & {
+  mask?: ToMaskOptions<TRouteTree, TMaskFrom, TMaskTo>
+}
+
+export type ToMaskOptions<
+  TRouteTree extends AnyRoute = AnyRoute,
+  TMaskFrom extends RoutePaths<TRouteTree> = '/',
+  TMaskTo extends string = '',
+> = ToSubOptions<TRouteTree, TMaskFrom, TMaskTo> & {
+  unmaskOnReload?: boolean
+}
+
+export type ToSubOptions<
+  TRouteTree extends AnyRoute = AnyRoute,
+  TFrom extends RoutePaths<TRouteTree> = '/',
+  TTo extends string = '',
+  TResolved = ResolveRelativePath<TFrom, NoInfer<TTo>>,
 > = {
-  to?: ToPathOption<TAllRouteInfo, TFrom, TTo>
+  to?: ToPathOption<TRouteTree, TFrom, TTo>
   // The new has string or a function to update it
-  hash?: Updater<string>
+  hash?: true | Updater<string>
   // State to pass to the history stack
-  state?: LocationState
+  state?: true | NonNullableUpdater<LocationState>
   // The source route path. This is automatically set when using route-level APIs, but for type-safe relative routing on the router itself, this is required
   from?: TFrom
   // // When using relative route paths, this option forces resolution from the current path, instead of the route API's path or `from` path
   // fromCurrent?: boolean
-} & CheckPath<TAllRouteInfo, NoInfer<TResolvedTo>, {}> &
-  SearchParamOptions<TAllRouteInfo, TFrom, TResolvedTo> &
-  PathParamOptions<TAllRouteInfo, TFrom, TResolvedTo>
+} & CheckPath<TRouteTree, NoInfer<TResolved>, {}> &
+  SearchParamOptions<TRouteTree, TFrom, TResolved> &
+  PathParamOptions<TRouteTree, TFrom, TResolved>
 
-type SearchParamOptions<
-  TAllRouteInfo extends AnyAllRouteInfo,
+export type SearchParamOptions<
+  TRouteTree extends AnyRoute,
   TFrom,
   TTo,
-  TFromSchema = RouteInfoByPath<TAllRouteInfo, TFrom>['fullSearchSchema'],
-  TToSchema = RouteInfoByPath<TAllRouteInfo, TTo>['fullSearchSchema'],
-> = StartsWith<TFrom, TTo> extends true // If the next route search extend or cover the from route, params will be optional
-  ? {
-      search?: SearchReducer<TFromSchema, TToSchema>
-    }
-  : // Optional search params? Allow it
-  keyof PickRequired<TToSchema> extends never
+  TFromSearchEnsured = Expand<
+    UnionToIntersection<
+      PickRequired<RouteByPath<TRouteTree, TFrom>['types']['fullSearchSchema']>
+    >
+  >,
+  TFromSearchOptional = Omit<AllParams<TRouteTree>, keyof TFromSearchEnsured>,
+  TFromSearch = Expand<TFromSearchEnsured & TFromSearchOptional>,
+  TToSearch = Expand<RouteByPath<TRouteTree, TTo>['types']['fullSearchSchema']>,
+> = keyof PickRequired<TToSearch> extends never
   ? {
-      search?: SearchReducer<TFromSchema, TToSchema>
+      search?: true | SearchReducer<TFromSearch, TToSearch>
     }
   : {
-      // Must have required search params, enforce it
-      search: SearchReducer<TFromSchema, TToSchema>
+      search: TFromSearchEnsured extends PickRequired<TToSearch>
+        ? true | SearchReducer<TFromSearch, TToSearch>
+        : SearchReducer<TFromSearch, TToSearch>
     }
 
-type SearchReducer<TFrom, TTo> =
-  | { [TKey in keyof TTo]: TTo[TKey] }
-  | ((current: TFrom) => TTo)
+type SearchReducer<TFrom, TTo> = TTo | ((current: TFrom) => TTo)
 
-type PathParamOptions<
-  TAllRouteInfo extends AnyAllRouteInfo,
+export type PathParamOptions<
+  TRouteTree extends AnyRoute,
   TFrom,
   TTo,
-  TFromParams = RouteInfoByPath<TAllRouteInfo, TFrom>['allParams'],
-  TToParams = RouteInfoByPath<TAllRouteInfo, TTo>['allParams'],
-> =
-  // If the next routes params extend or cover the from route, params will be optional
-  StartsWith<TFrom, TTo> extends true
-    ? {
-        params?: ParamsReducer<TFromParams, TToParams>
-      }
-    : // If the next route doesn't have params, warn if any have been passed
-    AnyPathParams extends TToParams
-    ? {
-        params?: ParamsReducer<TFromParams, Record<string, never>>
-      }
-    : // If the next route has params, enforce them
-      {
-        params: ParamsReducer<TFromParams, TToParams>
-      }
+  TFromParamsEnsured = Expand<
+    UnionToIntersection<
+      PickRequired<RouteByPath<TRouteTree, TFrom>['types']['allParams']>
+    >
+  >,
+  TFromParamsOptional = Omit<AllParams<TRouteTree>, keyof TFromParamsEnsured>,
+  TFromParams = Expand<TFromParamsOptional & TFromParamsEnsured>,
+  TToParams = Expand<RouteByPath<TRouteTree, TTo>['types']['allParams']>,
+> = keyof PickRequired<TToParams> extends never
+  ? {
+      params?: true | ParamsReducer<TFromParams, TToParams>
+    }
+  : {
+      params: TFromParamsEnsured extends PickRequired<TToParams>
+        ? true | ParamsReducer<TFromParams, TToParams>
+        : ParamsReducer<TFromParams, TToParams>
+    }
 
 type ParamsReducer<TFrom, TTo> = TTo | ((current: TFrom) => TTo)
 
 export type ToPathOption<
-  TAllRouteInfo extends AnyAllRouteInfo = DefaultAllRouteInfo,
-  TFrom extends ValidFromPath<TAllRouteInfo> = '/',
-  TTo extends string = '.',
+  TRouteTree extends AnyRoute = AnyRoute,
+  TFrom extends RoutePaths<TRouteTree> = '/',
+  TTo extends string = '',
 > =
   | TTo
   | RelativeToPathAutoComplete<
-      TAllRouteInfo['routePaths'],
+      RoutePaths<TRouteTree>,
       NoInfer<TFrom> extends string ? NoInfer<TFrom> : '',
       NoInfer<TTo> & string
     >
 
 export type ToIdOption<
-  TAllRouteInfo extends AnyAllRouteInfo = DefaultAllRouteInfo,
-  TFrom extends ValidFromPath<TAllRouteInfo> = '/',
-  TTo extends string = '.',
+  TRouteTree extends AnyRoute = AnyRoute,
+  TFrom extends RoutePaths<TRouteTree> = '/',
+  TTo extends string = '',
 > =
   | TTo
   | RelativeToPathAutoComplete<
-      TAllRouteInfo['routeIds'],
+      RouteIds<TRouteTree>,
       NoInfer<TFrom> extends string ? NoInfer<TFrom> : '',
       NoInfer<TTo> & string
     >
 
-interface ActiveOptions {
+export interface ActiveOptions {
   exact?: boolean
   includeHash?: boolean
+  includeSearch?: boolean
 }
 
 export type LinkOptions<
-  TAllRouteInfo extends AnyAllRouteInfo = DefaultAllRouteInfo,
-  TFrom extends ValidFromPath<TAllRouteInfo> = '/',
-  TTo extends string = '.',
-> = NavigateOptionsAbsolute<TAllRouteInfo, TFrom, TTo> & {
+  TRouteTree extends AnyRoute = AnyRoute,
+  TFrom extends RoutePaths<TRouteTree> = '/',
+  TTo extends string = '',
+  TMaskFrom extends RoutePaths<TRouteTree> = TFrom,
+  TMaskTo extends string = '',
+> = NavigateOptions<TRouteTree, TFrom, TTo, TMaskFrom, TMaskTo> & {
   // The standard anchor tag target attribute
   target?: HTMLAnchorElement['target']
   // Defaults to `{ exact: false, includeHash: false }`
   activeOptions?: ActiveOptions
   // If set, will preload the linked route on hover and cache it for this many milliseconds in hopes that the user will eventually navigate there.
   preload?: false | 'intent'
-  // When preloaded, the preloaded result will be considered "fresh" for this duration in milliseconds
-  preloadMaxAge?: number
-  // When preloaded and subsequently inactive, the preloaded result will remain in memory for this duration in milliseconds
-  preloadGcMaxAge?: number
   // Delay intent preloading by this many milliseconds. If the intent exits before this delay, the preload will be cancelled.
   preloadDelay?: number
   // If true, will render the link without the href attribute
@@ -235,58 +265,47 @@ export type LinkOptions<
 }
 
 export type CheckRelativePath<
-  TAllRouteInfo extends AnyAllRouteInfo,
+  TRouteTree extends AnyRoute,
   TFrom,
   TTo,
 > = TTo extends string
   ? TFrom extends string
-    ? ResolveRelativePath<TFrom, TTo> extends TAllRouteInfo['routePaths']
+    ? ResolveRelativePath<TFrom, TTo> extends RoutePaths<TRouteTree>
       ? {}
       : {
           Error: `${TFrom} + ${TTo} resolves to ${ResolveRelativePath<
             TFrom,
             TTo
           >}, which is not a valid route path.`
-          'Valid Route Paths': TAllRouteInfo['routePaths']
+          'Valid Route Paths': RoutePaths<TRouteTree>
         }
     : {}
   : {}
 
-export type CheckPath<
-  TAllRouteInfo extends AnyAllRouteInfo,
+export type CheckPath<TRouteTree extends AnyRoute, TPath, TPass> = Exclude<
   TPath,
-  TPass,
-> = Exclude<TPath, TAllRouteInfo['routePaths']> extends never
+  RoutePaths<TRouteTree>
+> extends never
   ? TPass
-  : CheckPathError<TAllRouteInfo, Exclude<TPath, TAllRouteInfo['routePaths']>>
+  : CheckPathError<TRouteTree, Exclude<TPath, RoutePaths<TRouteTree>>>
 
-export type CheckPathError<
-  TAllRouteInfo extends AnyAllRouteInfo,
-  TInvalids,
-> = Expand<{
-  Error: `${TInvalids extends string
-    ? TInvalids
-    : never} is not a valid route path.`
-  'Valid Route Paths': TAllRouteInfo['routePaths']
-}>
+export type CheckPathError<TRouteTree extends AnyRoute, TInvalids> = {
+  to: RoutePaths<TRouteTree>
+}
 
-export type CheckId<
-  TAllRouteInfo extends AnyAllRouteInfo,
+export type CheckId<TRouteTree extends AnyRoute, TPath, TPass> = Exclude<
   TPath,
-  TPass,
-> = Exclude<TPath, TAllRouteInfo['routeIds']> extends never
+  RouteIds<TRouteTree>
+> extends never
   ? TPass
-  : CheckIdError<TAllRouteInfo, Exclude<TPath, TAllRouteInfo['routeIds']>>
+  : CheckIdError<TRouteTree, Exclude<TPath, RouteIds<TRouteTree>>>
 
-export type CheckIdError<
-  TAllRouteInfo extends AnyAllRouteInfo,
-  TInvalids,
-> = Expand<{
+export type CheckIdError<TRouteTree extends AnyRoute, TInvalids> = {
   Error: `${TInvalids extends string
     ? TInvalids
     : never} is not a valid route ID.`
-  'Valid Route IDs': TAllRouteInfo['routeIds']
-}>
+  'Valid Route IDs': RouteIds<TRouteTree>
+}
 
 export type ResolveRelativePath<TFrom, TTo = '.'> = TFrom extends string
   ? TTo extends string
@@ -311,11 +330,3 @@ export type ResolveRelativePath<TFrom, TTo = '.'> = TFrom extends string
       : CleanPath<Join<['/', ...Split<TFrom>, ...Split<TTo>]>>
     : never
   : never
-
-export type ValidFromPath<
-  TAllRouteInfo extends AnyAllRouteInfo = DefaultAllRouteInfo,
-> =
-  | undefined
-  | (string extends TAllRouteInfo['routePaths']
-      ? string
-      : TAllRouteInfo['routePaths'])

package/src/path.ts

@@ -1,4 +1,4 @@
-import { AnyPathParams } from './routeConfig'
+import { AnyPathParams } from './route'
 import { MatchLocation } from './router'
 import { last } from './utils'
 
@@ -90,14 +90,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,
@@ -125,14 +125,16 @@ export function parsePathname(pathname?: string): Segment[] {
 export function interpolatePath(
   path: string | undefined,
   params: any,
-  leaveWildcard?: boolean,
+  leaveWildcards: boolean = false,
 ) {
   const interpolatedPathSegments = parsePathname(path)
 
   return joinPaths(
     interpolatedPathSegments.map((segment) => {
-      if (segment.value === '*' && !leaveWildcard) {
-        return ''
+      if (segment.type === 'wildcard') {
+        const value = params[segment.value]
+        if (leaveWildcards) return `${segment.value}${value ?? ''}`
+        return value
       }
 
       if (segment.type === 'param') {
@@ -145,29 +147,46 @@ export function interpolatePath(
 }
 
 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 matchByPath(
+  basepath: string,
   from: string,
   matchLocation: Pick<MatchLocation, 'to' | 'caseSensitive' | 'fuzzy'>,
 ): Record<string, string> | undefined {
+  // Remove the base path from the pathname
+  from = basepath != '/' ? from.substring(basepath.length) : from
+  // Default to to $ (wildcard)
+  const to = `${matchLocation.to ?? '$'}`
+  // 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> = {}
 
@@ -180,8 +199,8 @@ 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') {
@@ -219,16 +238,17 @@ export function matchByPath(
           if (baseSegment?.value === '/') {
             return false
           }
-          if (!baseSegment.value.startsWith(':')) {
+          if (baseSegment.value.charAt(0) !== '$') {
             params[routeSegment.value.substring(1)] = baseSegment.value
           }
         }
       }
 
-      if (isLastRouteSegment && !isLastBaseSegment) {
+      if (!isLastBaseSegment && isLastRouteSegment) {
         return !!matchLocation.fuzzy
       }
     }
+
     return true
   })()
 

package/src/qss.ts

@@ -30,8 +30,7 @@ function toValue(mix) {
   var 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) {