@tanstack/router-core 0.0.1-beta.5 → 0.0.1-beta.50

package/src/link.ts

@@ -1,11 +1,16 @@
-import { AnyPathParams } from './routeConfig'
 import {
   AnyAllRouteInfo,
   DefaultAllRouteInfo,
   RouteInfoByPath,
 } from './routeInfo'
-import { Location } from './router'
-import { Expand, NoInfer, PickAsRequired, PickRequired, Updater } from './utils'
+import { ParsedLocation, LocationState } from './router'
+import {
+  Expand,
+  NoInfer,
+  PickRequired,
+  UnionToIntersection,
+  Updater,
+} from './utils'
 
 export type LinkInfo =
   | {
@@ -14,7 +19,7 @@ export type LinkInfo =
     }
   | {
       type: 'internal'
-      next: Location
+      next: ParsedLocation
       handleFocus: (e: any) => void
       handleClick: (e: any) => void
       handleEnter: (e: any) => void
@@ -58,7 +63,7 @@ export type Split<S, TIncludeTrailingSlash = true> = S extends unknown
   : never
 
 export type ParsePathParams<T extends string> = Split<T>[number] extends infer U
-  ? U extends `:${infer V}`
+  ? U extends `$${infer V}`
     ? V
     : never
   : never
@@ -106,11 +111,20 @@ 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<
+export type NavigateOptions<
   TAllRouteInfo extends AnyAllRouteInfo = DefaultAllRouteInfo,
-  TFrom extends ValidFromPath<TAllRouteInfo> = '/',
+  TFrom extends TAllRouteInfo['routePaths'] = '/',
   TTo extends string = '.',
 > = ToOptions<TAllRouteInfo, TFrom, TTo> & {
   // Whether to replace the current history stack instead of pushing a new one
@@ -119,13 +133,15 @@ export type NavigateOptionsAbsolute<
 
 export type ToOptions<
   TAllRouteInfo extends AnyAllRouteInfo = DefaultAllRouteInfo,
-  TFrom extends ValidFromPath<TAllRouteInfo> = '/',
+  TFrom extends TAllRouteInfo['routePaths'] = '/',
   TTo extends string = '.',
   TResolvedTo = ResolveRelativePath<TFrom, NoInfer<TTo>>,
 > = {
   to?: ToPathOption<TAllRouteInfo, TFrom, TTo>
   // The new has string or a function to update it
   hash?: Updater<string>
+  // State to pass to the history stack
+  state?: 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
@@ -134,57 +150,84 @@ export type ToOptions<
   SearchParamOptions<TAllRouteInfo, TFrom, TResolvedTo> &
   PathParamOptions<TAllRouteInfo, TFrom, TResolvedTo>
 
-type SearchParamOptions<
+export type SearchParamOptions<
   TAllRouteInfo extends AnyAllRouteInfo,
   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
+  TFromSchema = Expand<
+    UnionToIntersection<
+      TAllRouteInfo['fullSearchSchema'] &
+        RouteInfoByPath<TAllRouteInfo, TFrom> extends never
+        ? {}
+        : RouteInfoByPath<TAllRouteInfo, TFrom>['fullSearchSchema']
+    >
+  >,
+  // Find the schema for the new path, and make optional any keys
+  // that are already defined in the current schema
+  TToSchema = Partial<
+    RouteInfoByPath<TAllRouteInfo, TFrom>['fullSearchSchema']
+  > &
+    Omit<
+      RouteInfoByPath<TAllRouteInfo, TTo>['fullSearchSchema'],
+      keyof PickRequired<
+        RouteInfoByPath<TAllRouteInfo, TFrom>['fullSearchSchema']
+      >
+    >,
+  TFromFullSchema = Expand<
+    UnionToIntersection<TAllRouteInfo['fullSearchSchema'] & TFromSchema>
+  >,
+  TToFullSchema = Expand<
+    UnionToIntersection<TAllRouteInfo['fullSearchSchema'] & TToSchema>
+  >,
+> = keyof PickRequired<TToSchema> extends never
   ? {
-      search?: SearchReducer<TFromSchema, TToSchema>
+      search?: true | SearchReducer<TFromFullSchema, TToFullSchema>
     }
   : {
-      // Must have required search params, enforce it
-      search: SearchReducer<TFromSchema, TToSchema>
+      search: SearchReducer<TFromFullSchema, TToFullSchema>
     }
 
 type SearchReducer<TFrom, TTo> =
   | { [TKey in keyof TTo]: TTo[TKey] }
   | ((current: TFrom) => TTo)
 
-type PathParamOptions<
+export type PathParamOptions<
   TAllRouteInfo extends AnyAllRouteInfo,
   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>
-      }
+  TFromSchema = Expand<
+    UnionToIntersection<
+      RouteInfoByPath<TAllRouteInfo, TFrom> extends never
+        ? {}
+        : RouteInfoByPath<TAllRouteInfo, TFrom>['allParams']
+    >
+  >,
+  // Find the schema for the new path, and make optional any keys
+  // that are already defined in the current schema
+  TToSchema = Partial<RouteInfoByPath<TAllRouteInfo, TFrom>['allParams']> &
+    Omit<
+      RouteInfoByPath<TAllRouteInfo, TTo>['allParams'],
+      keyof PickRequired<RouteInfoByPath<TAllRouteInfo, TFrom>['allParams']>
+    >,
+  TFromFullParams = Expand<
+    UnionToIntersection<TAllRouteInfo['allParams'] & TFromSchema>
+  >,
+  TToFullParams = Expand<
+    UnionToIntersection<TAllRouteInfo['allParams'] & TToSchema>
+  >,
+> = keyof PickRequired<TToSchema> extends never
+  ? {
+      params?: ParamsReducer<TFromFullParams, TToFullParams>
+    }
+  : {
+      params: ParamsReducer<TFromFullParams, TToFullParams>
+    }
 
 type ParamsReducer<TFrom, TTo> = TTo | ((current: TFrom) => TTo)
 
 export type ToPathOption<
   TAllRouteInfo extends AnyAllRouteInfo = DefaultAllRouteInfo,
-  TFrom extends ValidFromPath<TAllRouteInfo> = '/',
+  TFrom extends TAllRouteInfo['routePaths'] = '/',
   TTo extends string = '.',
 > =
   | TTo
@@ -196,7 +239,7 @@ export type ToPathOption<
 
 export type ToIdOption<
   TAllRouteInfo extends AnyAllRouteInfo = DefaultAllRouteInfo,
-  TFrom extends ValidFromPath<TAllRouteInfo> = '/',
+  TFrom extends TAllRouteInfo['routePaths'] = '/',
   TTo extends string = '.',
 > =
   | TTo
@@ -206,16 +249,16 @@ export type ToIdOption<
       NoInfer<TTo> & string
     >
 
-interface ActiveOptions {
+export interface ActiveOptions {
   exact?: boolean
   includeHash?: boolean
 }
 
 export type LinkOptions<
   TAllRouteInfo extends AnyAllRouteInfo = DefaultAllRouteInfo,
-  TFrom extends ValidFromPath<TAllRouteInfo> = '/',
+  TFrom extends TAllRouteInfo['routePaths'] = '/',
   TTo extends string = '.',
-> = NavigateOptionsAbsolute<TAllRouteInfo, TFrom, TTo> & {
+> = NavigateOptions<TAllRouteInfo, TFrom, TTo> & {
   // The standard anchor tag target attribute
   target?: HTMLAnchorElement['target']
   // Defaults to `{ exact: false, includeHash: false }`

package/src/path.ts

@@ -1,3 +1,4 @@
+import invariant from 'tiny-invariant'
 import { AnyPathParams } from './routeConfig'
 import { MatchLocation } from './router'
 import { last } from './utils'
@@ -97,7 +98,7 @@ export function parsePathname(pathname?: string): Segment[] {
         }
       }
 
-      if (part.charAt(0) === ':') {
+      if (part.charAt(0) === '$') {
         return {
           type: 'param',
           value: part,
@@ -145,29 +146,32 @@ export function interpolatePath(
 }
 
 export function matchPathname(
+  basepath: string,
   currentPathname: string,
   matchLocation: Pick<MatchLocation, 'to' | 'fuzzy' | 'caseSensitive'>,
 ): AnyPathParams | undefined {
-  const pathParams = matchByPath(currentPathname, matchLocation)
+  const pathParams = matchByPath(basepath, currentPathname, matchLocation)
   // const searchMatched = matchBySearch(currentLocation.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 {
+  if (!from.startsWith(basepath)) {
+    return undefined
+  }
+  from = basepath != '/' ? from.substring(basepath.length) : from
   const baseSegments = parsePathname(from)
-  const routeSegments = parsePathname(`${matchLocation.to ?? '*'}`)
+  const to = `${matchLocation.to ?? '*'}`
+  const routeSegments = parsePathname(to)
 
   const params: Record<string, string> = {}
 
@@ -219,7 +223,7 @@ export function matchByPath(
           if (baseSegment?.value === '/') {
             return false
           }
-          if (!baseSegment.value.startsWith(':')) {
+          if (baseSegment.value.charAt(0) !== '$') {
             params[routeSegment.value.substring(1)] = baseSegment.value
           }
         }

package/src/route.ts

@@ -1,243 +1,50 @@
-import {
-  CheckRelativePath,
-  LinkInfo,
-  LinkOptions,
-  ResolveRelativePath,
-  ToOptions,
-} from './link'
-import { LoaderContext, RouteConfig, RouteOptions } from './routeConfig'
+import { Action, ActionOptions } from './actions'
+import { RouteConfig, RouteOptions } from './routeConfig'
 import {
   AnyAllRouteInfo,
   AnyRouteInfo,
   DefaultAllRouteInfo,
   RouteInfo,
-  RouteInfoByPath,
 } from './routeInfo'
-import { RouteMatch } from './routeMatch'
-import {
-  Action,
-  ActionState,
-  Loader,
-  LoaderState,
-  MatchRouteOptions,
-  Router,
-} from './router'
-import { NoInfer, replaceEqualDeep } from './utils'
+import { Router } from './router'
 
-export interface AnyRoute extends Route<any, any> {}
+export interface AnyRoute extends Route<any, any, any> {}
 
-export interface Route<
+export class Route<
   TAllRouteInfo extends AnyAllRouteInfo = DefaultAllRouteInfo,
   TRouteInfo extends AnyRouteInfo = RouteInfo,
+  TRouterContext = unknown,
 > {
-  routeId: TRouteInfo['id']
-  routeRouteId: TRouteInfo['routeId']
-  routePath: TRouteInfo['path']
-  fullPath: TRouteInfo['fullPath']
-  parentRoute?: AnyRoute
+  routeInfo!: TRouteInfo
+  id!: TRouteInfo['id']
+  customId!: TRouteInfo['customId']
+  path!: TRouteInfo['path']
+  fullPath!: TRouteInfo['fullPath']
+  getParentRoute!: () => undefined | AnyRoute
   childRoutes?: AnyRoute[]
-  options: RouteOptions
-  router: Router<TAllRouteInfo['routeConfig'], TAllRouteInfo>
-  buildLink: <TTo extends string = '.'>(
-    options: Omit<
-      LinkOptions<TAllRouteInfo, TRouteInfo['fullPath'], TTo>,
-      'from'
-    >,
-  ) => LinkInfo
-  matchRoute: <
-    TTo extends string = '.',
-    TResolved extends string = ResolveRelativePath<TRouteInfo['id'], TTo>,
-  >(
-    matchLocation: CheckRelativePath<
-      TAllRouteInfo,
-      TRouteInfo['fullPath'],
-      NoInfer<TTo>
-    > &
-      Omit<ToOptions<TAllRouteInfo, TRouteInfo['fullPath'], TTo>, 'from'>,
-    opts?: MatchRouteOptions,
-  ) => RouteInfoByPath<TAllRouteInfo, TResolved>['allParams']
-  navigate: <TTo extends string = '.'>(
-    options: Omit<LinkOptions<TAllRouteInfo, TRouteInfo['id'], TTo>, 'from'>,
-  ) => Promise<void>
-  action: unknown extends TRouteInfo['actionResponse']
-    ?
-        | Action<TRouteInfo['actionPayload'], TRouteInfo['actionResponse']>
-        | undefined
-    : Action<TRouteInfo['actionPayload'], TRouteInfo['actionResponse']>
-  loader: unknown extends TRouteInfo['routeLoaderData']
-    ?
-        | Action<
-            LoaderContext<
-              TRouteInfo['fullSearchSchema'],
-              TRouteInfo['allParams']
-            >,
-            TRouteInfo['routeLoaderData']
-          >
-        | undefined
-    : Loader<
-        TRouteInfo['fullSearchSchema'],
-        TRouteInfo['allParams'],
-        TRouteInfo['routeLoaderData']
-      >
-}
-
-export function createRoute<
-  TAllRouteInfo extends AnyAllRouteInfo = DefaultAllRouteInfo,
-  TRouteInfo extends AnyRouteInfo = RouteInfo,
->(
-  routeConfig: RouteConfig,
-  options: TRouteInfo['options'],
-  parent: undefined | Route<TAllRouteInfo, any>,
-  router: Router<TAllRouteInfo['routeConfig'], TAllRouteInfo>,
-): Route<TAllRouteInfo, TRouteInfo> {
-  const { id, routeId, path: routePath, fullPath } = routeConfig
-
-  const action =
-    router.state.actions[id] ||
-    (() => {
-      router.state.actions[id] = {
-        pending: [],
-        submit: async <T, U>(
-          submission: T,
-          actionOpts?: { invalidate?: boolean },
-        ) => {
-          if (!route) {
-            return
-          }
-
-          const invalidate = actionOpts?.invalidate ?? true
-
-          const actionState: ActionState<T, U> = {
-            submittedAt: Date.now(),
-            status: 'pending',
-            submission,
-          }
-
-          action.current = actionState
-          action.latest = actionState
-          action.pending.push(actionState)
-
-          router.state = {
-            ...router.state,
-            currentAction: actionState,
-            latestAction: actionState,
-          }
-
-          router.notify()
-
-          try {
-            const res = await route.options.action?.(submission)
-            actionState.data = res as U
-            if (invalidate) {
-              router.invalidateRoute({ to: '.', fromCurrent: true })
-              await router.reload()
-            }
-            actionState.status = 'success'
-            return res
-          } catch (err) {
-            console.error(err)
-            actionState.error = err
-            actionState.status = 'error'
-          } finally {
-            action.pending = action.pending.filter((d) => d !== actionState)
-            router.removeActionQueue.push({ action, actionState })
-            router.notify()
-          }
-        },
-      }
-      return router.state.actions[id]!
-    })()
-
-  const loader =
-    router.state.loaders[id] ||
-    (() => {
-      router.state.loaders[id] = {
-        pending: [],
-        fetch: (async (loaderContext: LoaderContext<any, any>) => {
-          if (!route) {
-            return
-          }
-
-          const loaderState: LoaderState<any, any> = {
-            loadedAt: Date.now(),
-            loaderContext,
-          }
-
-          loader.current = loaderState
-          loader.latest = loaderState
-          loader.pending.push(loaderState)
-
-          // router.state = {
-          //   ...router.state,
-          //   currentAction: loaderState,
-          //   latestAction: loaderState,
-          // }
-
-          router.notify()
-
-          try {
-            return await route.options.loader?.(loaderContext)
-          } finally {
-            loader.pending = loader.pending.filter((d) => d !== loaderState)
-            // router.removeActionQueue.push({ loader, loaderState })
-            router.notify()
-          }
-        }) as any,
-      }
-      return router.state.loaders[id]!
-    })()
-
-  let route: Route<TAllRouteInfo, TRouteInfo> = {
-    routeId: id,
-    routeRouteId: routeId,
-    routePath,
-    fullPath,
-    options,
-    router,
-    childRoutes: undefined!,
-    parentRoute: parent,
-    action,
-    loader: loader as any,
-
-    buildLink: (options) => {
-      return router.buildLink({
-        ...options,
-        from: fullPath,
-      } as any) as any
-    },
-
-    navigate: (options) => {
-      return router.navigate({
-        ...options,
-        from: fullPath,
-      } as any) as any
-    },
-
-    matchRoute: (matchLocation, opts) => {
-      return router.matchRoute(
-        {
-          ...matchLocation,
-          from: fullPath,
-        } as any,
-        opts,
-      )
-    },
+  options!: RouteOptions
+  originalIndex!: number
+  getRouter!: () => Router<
+    TAllRouteInfo['routeConfig'],
+    TAllRouteInfo,
+    TRouterContext
+  >
+  constructor(
+    routeConfig: RouteConfig,
+    options: TRouteInfo['options'],
+    originalIndex: number,
+    parent: undefined | Route<TAllRouteInfo, any>,
+    router: Router<TAllRouteInfo['routeConfig'], TAllRouteInfo, TRouterContext>,
+  ) {
+    Object.assign(this, {
+      ...routeConfig,
+      originalIndex,
+      options,
+      getRouter: () => router,
+      childRoutes: undefined!,
+      getParentRoute: () => parent,
+    })
+
+    router.options.createRoute?.({ router, route: this })
   }
-
-  router.options.createRoute?.({ router, route })
-
-  return route
-}
-
-export function cascadeLoaderData(matches: RouteMatch<any, any>[]) {
-  matches.forEach((match, index) => {
-    const parent = matches[index - 1]
-
-    if (parent) {
-      match.loaderData = replaceEqualDeep(match.loaderData, {
-        ...parent.loaderData,
-        ...match.routeLoaderData,
-      })
-    }
-  })
 }