@tanstack/router-core 0.0.1-beta.9 → 1.97.21

package/src/route.ts

@@ -1,230 +1,303 @@
-import {
-  CheckRelativePath,
-  LinkInfo,
-  LinkOptions,
-  ResolveRelativePath,
-  ToOptions,
-} from './link'
-import { LoaderContext, 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'
-
-export interface AnyRoute extends Route<any, any> {}
-
-export interface Route<
-  TAllRouteInfo extends AnyAllRouteInfo = DefaultAllRouteInfo,
-  TRouteInfo extends AnyRouteInfo = RouteInfo,
-> {
-  routeId: TRouteInfo['id']
-  routeRouteId: TRouteInfo['routeId']
-  routePath: TRouteInfo['path']
-  fullPath: TRouteInfo['fullPath']
-  parentRoute?: 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']
-      >
+import type { ParsePathParams } from './link'
+import type { RootRouteId } from './root'
+import type { Assign } from './utils'
+import type {
+  AnySchema,
+  AnyStandardSchemaValidator,
+  AnyValidatorAdapter,
+  AnyValidatorObj,
+  StandardSchemaValidator,
+  ValidatorAdapter,
+  ValidatorFn,
+  ValidatorObj,
+} from './validators'
+
+export type AnyPathParams = {}
+
+export type SearchSchemaInput = {
+  __TSearchSchemaInput__: 'TSearchSchemaInput'
 }
 
-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,
+export type AnyContext = {}
+
+export interface RouteContext {}
+
+export type PreloadableObj = { preload?: () => Promise<void> }
+
+export type RoutePathOptions<TCustomId, TPath> =
+  | {
+      path: TPath
+    }
+  | {
+      id: TCustomId
+    }
+
+export interface StaticDataRouteOption {}
+
+export type RoutePathOptionsIntersection<TCustomId, TPath> = {
+  path: TPath
+  id: TCustomId
+}
+
+export type SearchFilter<TInput, TResult = TInput> = (prev: TInput) => TResult
+
+export type SearchMiddlewareContext<TSearchSchema> = {
+  search: TSearchSchema
+  next: (newSearch: TSearchSchema) => TSearchSchema
+}
+
+export type SearchMiddleware<TSearchSchema> = (
+  ctx: SearchMiddlewareContext<TSearchSchema>,
+) => TSearchSchema
+
+export type ResolveId<
+  TParentRoute,
+  TCustomId extends string,
+  TPath extends string,
+> = TParentRoute extends { id: infer TParentId extends string }
+  ? RoutePrefix<TParentId, string extends TCustomId ? TPath : TCustomId>
+  : RootRouteId
+
+export type InferFullSearchSchema<TRoute> = TRoute extends {
+  types: {
+    fullSearchSchema: infer TFullSearchSchema
+  }
+}
+  ? TFullSearchSchema
+  : {}
+
+export type InferFullSearchSchemaInput<TRoute> = TRoute extends {
+  types: {
+    fullSearchSchemaInput: infer TFullSearchSchemaInput
+  }
+}
+  ? TFullSearchSchemaInput
+  : {}
+
+export type InferAllParams<TRoute> = TRoute extends {
+  types: {
+    allParams: infer TAllParams
+  }
+}
+  ? TAllParams
+  : {}
+
+export type InferAllContext<TRoute> = unknown extends TRoute
+  ? TRoute
+  : TRoute extends {
+        types: {
+          allContext: infer TAllContext
+        }
       }
-      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,
-      )
-    },
+    ? TAllContext
+    : {}
+
+export type ResolveSearchSchemaFnInput<TSearchValidator> =
+  TSearchValidator extends (input: infer TSearchSchemaInput) => any
+    ? TSearchSchemaInput extends SearchSchemaInput
+      ? Omit<TSearchSchemaInput, keyof SearchSchemaInput>
+      : ResolveSearchSchemaFn<TSearchValidator>
+    : AnySchema
+
+export type ResolveSearchSchemaInput<TSearchValidator> =
+  TSearchValidator extends AnyStandardSchemaValidator
+    ? NonNullable<TSearchValidator['~standard']['types']>['input']
+    : TSearchValidator extends AnyValidatorAdapter
+      ? TSearchValidator['types']['input']
+      : TSearchValidator extends AnyValidatorObj
+        ? ResolveSearchSchemaFnInput<TSearchValidator['parse']>
+        : ResolveSearchSchemaFnInput<TSearchValidator>
+
+export type ResolveSearchSchemaFn<TSearchValidator> = TSearchValidator extends (
+  ...args: any
+) => infer TSearchSchema
+  ? TSearchSchema
+  : AnySchema
+
+export type ResolveSearchSchema<TSearchValidator> =
+  unknown extends TSearchValidator
+    ? TSearchValidator
+    : TSearchValidator extends AnyStandardSchemaValidator
+      ? NonNullable<TSearchValidator['~standard']['types']>['output']
+      : TSearchValidator extends AnyValidatorAdapter
+        ? TSearchValidator['types']['output']
+        : TSearchValidator extends AnyValidatorObj
+          ? ResolveSearchSchemaFn<TSearchValidator['parse']>
+          : ResolveSearchSchemaFn<TSearchValidator>
+
+export type ParseSplatParams<TPath extends string> = TPath &
+  `${string}$` extends never
+  ? TPath & `${string}$/${string}` extends never
+    ? never
+    : '_splat'
+  : '_splat'
+
+export interface SplatParams {
+  _splat?: string
+}
+
+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: ResolveParams<TPath>,
+) => TParams extends Record<ParsePathParams<TPath>, any>
+  ? TParams
+  : Record<ParsePathParams<TPath>, any>
+
+export type StringifyParamsFn<in out TPath extends string, in out TParams> = (
+  params: TParams,
+) => ResolveParams<TPath>
+
+export type ParamsOptions<in out TPath extends string, in out TParams> = {
+  params?: {
+    parse?: ParseParamsFn<TPath, TParams>
+    stringify?: StringifyParamsFn<TPath, TParams>
   }
 
-  router.options.createRoute?.({ router, route })
+  /** 
+  @deprecated Use params.parse instead
+  */
+  parseParams?: ParseParamsFn<TPath, TParams>
+
+  /** 
+  @deprecated Use params.stringify instead
+  */
+  stringifyParams?: StringifyParamsFn<TPath, TParams>
+}
+
+interface RequiredStaticDataRouteOption {
+  staticData: StaticDataRouteOption
+}
+
+interface OptionalStaticDataRouteOption {
+  staticData?: StaticDataRouteOption
+}
+
+export type UpdatableStaticRouteOption = {} extends StaticDataRouteOption
+  ? OptionalStaticDataRouteOption
+  : RequiredStaticDataRouteOption
+
+export type MetaDescriptor =
+  | { charSet: 'utf-8' }
+  | { title: string }
+  | { name: string; content: string }
+  | { property: string; content: string }
+  | { httpEquiv: string; content: string }
+  | { 'script:ld+json': LdJsonObject }
+  | { tagName: 'meta' | 'link'; [name: string]: string }
+  | Record<string, unknown>
 
-  return route
+type LdJsonObject = { [Key in string]: LdJsonValue } & {
+  [Key in string]?: LdJsonValue | undefined
 }
+type LdJsonArray = Array<LdJsonValue> | ReadonlyArray<LdJsonValue>
+type LdJsonPrimitive = string | number | boolean | null
+type LdJsonValue = LdJsonPrimitive | LdJsonObject | LdJsonArray
+
+export type RouteLinkEntry = {}
+
+export type SearchValidator<TInput, TOutput> =
+  | ValidatorObj<TInput, TOutput>
+  | ValidatorFn<TInput, TOutput>
+  | ValidatorAdapter<TInput, TOutput>
+  | StandardSchemaValidator<TInput, TOutput>
+  | undefined
+
+export type AnySearchValidator = SearchValidator<any, any>
+
+export type DefaultSearchValidator = SearchValidator<
+  Record<string, unknown>,
+  AnySchema
+>
+
+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
+    ? AnyContext
+    : LooseReturnType<TContextFn>
+
+export type ContextAsyncReturnType<TContextFn> = unknown extends TContextFn
+  ? TContextFn
+  : LooseAsyncReturnType<TContextFn> extends never
+    ? AnyContext
+    : LooseAsyncReturnType<TContextFn>
+
+export type ResolveRouteContext<TRouteContextFn, TBeforeLoadFn> = Assign<
+  ContextReturnType<TRouteContextFn>,
+  ContextAsyncReturnType<TBeforeLoadFn>
+>
+
+export type ResolveLoaderData<TLoaderFn> = unknown extends TLoaderFn
+  ? TLoaderFn
+  : LooseAsyncReturnType<TLoaderFn> extends never
+    ? {}
+    : LooseAsyncReturnType<TLoaderFn>
+
+export type RoutePrefix<
+  TPrefix extends string,
+  TPath extends string,
+> = string extends TPath
+  ? RootRouteId
+  : TPath extends string
+    ? TPrefix extends RootRouteId
+      ? TPath extends '/'
+        ? '/'
+        : `/${TrimPath<TPath>}`
+      : `${TPrefix}/${TPath}` extends '/'
+        ? '/'
+        : `/${TrimPathLeft<`${TrimPathRight<TPrefix>}/${TrimPath<TPath>}`>}`
+    : never
+
+export type TrimPath<T extends string> = '' extends T
+  ? ''
+  : TrimPathRight<TrimPathLeft<T>>
+
+export type TrimPathLeft<T extends string> =
+  T extends `${RootRouteId}/${infer U}`
+    ? TrimPathLeft<U>
+    : T extends `/${infer U}`
+      ? TrimPathLeft<U>
+      : T
+export type TrimPathRight<T extends string> = T extends '/'
+  ? '/'
+  : T extends `${infer U}/`
+    ? TrimPathRight<U>
+    : T
+
+/**
+ * @deprecated Use `ErrorComponentProps` instead.
+ */
+export type ErrorRouteProps = {
+  error: unknown
+  info?: { componentStack: string }
+  reset: () => void
+}
+
+export type ErrorComponentProps = {
+  error: Error
+  info?: { componentStack: string }
+  reset: () => void
+}
+export type NotFoundRouteProps = {
+  // TODO: Make sure this is `| null | undefined` (this is for global not-founds)
+  data: unknown
+}
+
+//