@tanstack/react-router 0.0.1-beta.22 → 0.0.1-beta.220

package/src/awaited.tsx

@@ -0,0 +1,40 @@
+import { useRouter } from './RouterProvider'
+import { DeferredPromise, isDehydratedDeferred } from './defer'
+
+export type AwaitOptions<T> = {
+  promise: DeferredPromise<T>
+}
+
+export function useAwaited<T>({ promise }: AwaitOptions<T>): [T] {
+  const router = useRouter()
+
+  let state = promise.__deferredState
+  const key = `__TSR__DEFERRED__${state.uid}`
+
+  if (isDehydratedDeferred(promise)) {
+    state = router.hydrateData(key)!
+    promise = Promise.resolve(state.data) as DeferredPromise<any>
+    promise.__deferredState = state
+  }
+
+  if (state.status === 'pending') {
+    throw promise
+  }
+
+  if (state.status === 'error') {
+    throw state.error
+  }
+
+  router.dehydrateData(key, state)
+
+  return [state.data]
+}
+
+export function Await<T>(
+  props: AwaitOptions<T> & {
+    children: (result: T) => JSX.Element
+  },
+) {
+  const awaited = useAwaited(props)
+  return props.children(...awaited)
+}

package/src/defer.ts

@@ -0,0 +1,55 @@
+export type DeferredPromiseState<T> = { uid: string } & (
+  | {
+      status: 'pending'
+      data?: T
+      error?: unknown
+    }
+  | {
+      status: 'success'
+      data: T
+    }
+  | {
+      status: 'error'
+      data?: T
+      error: unknown
+    }
+)
+
+export type DeferredPromise<T> = Promise<T> & {
+  __deferredState: DeferredPromiseState<T>
+}
+
+export function defer<T>(_promise: Promise<T>) {
+  const promise = _promise as DeferredPromise<T>
+
+  if (!promise.__deferredState) {
+    promise.__deferredState = {
+      uid: Math.random().toString(36).slice(2),
+      status: 'pending',
+    }
+
+    const state = promise.__deferredState
+
+    promise
+      .then((data) => {
+        state.status = 'success' as any
+        state.data = data
+      })
+      .catch((error) => {
+        state.status = 'error' as any
+        state.error = error
+      })
+  }
+
+  return promise
+}
+
+export function isDehydratedDeferred(obj: any): boolean {
+  return (
+    typeof obj === 'object' &&
+    obj !== null &&
+    !(obj instanceof Promise) &&
+    !obj.then &&
+    '__deferredState' in obj
+  )
+}

package/src/fileRoute.ts

@@ -0,0 +1,153 @@
+import { ParsePathParams } from './link'
+import {
+  AnyRoute,
+  ResolveFullPath,
+  ResolveFullSearchSchema,
+  MergeFromFromParent,
+  RouteContext,
+  AnyContext,
+  RouteOptions,
+  UpdatableRouteOptions,
+  Route,
+  AnyPathParams,
+  RootRouteId,
+  TrimPathLeft,
+  RouteConstraints,
+} from './route'
+import { Assign, AssignAll, Expand, IsAny } from './utils'
+
+export interface FileRoutesByPath {
+  // '/': {
+  //   parentRoute: typeof rootRoute
+  // }
+}
+
+type Replace<
+  S extends string,
+  From extends string,
+  To extends string,
+> = S extends `${infer Start}${From}${infer Rest}`
+  ? `${Start}${To}${Replace<Rest, From, To>}`
+  : S
+
+export type TrimLeft<
+  T extends string,
+  S extends string,
+> = T extends `${S}${infer U}` ? U : T
+
+export type TrimRight<
+  T extends string,
+  S extends string,
+> = T extends `${infer U}${S}` ? U : T
+
+export type Trim<T extends string, S extends string> = TrimLeft<
+  TrimRight<T, S>,
+  S
+>
+
+export type RemoveUnderScores<T extends string> = Replace<
+  Replace<TrimRight<TrimLeft<T, '/_'>, '_'>, '_/', '/'>,
+  '/_',
+  '/'
+>
+
+export type ResolveFilePath<
+  TParentRoute extends AnyRoute,
+  TFilePath extends string,
+> = TParentRoute['id'] extends RootRouteId
+  ? TrimPathLeft<TFilePath>
+  : Replace<
+      TrimPathLeft<TFilePath>,
+      TrimPathLeft<TParentRoute['types']['customId']>,
+      ''
+    >
+
+export type FileRoutePath<
+  TParentRoute extends AnyRoute,
+  TFilePath extends string,
+> = ResolveFilePath<TParentRoute, TFilePath> extends `_${infer _}`
+  ? string
+  : ResolveFilePath<TParentRoute, TFilePath>
+
+export class FileRoute<
+  TFilePath extends keyof FileRoutesByPath,
+  TParentRoute extends AnyRoute = FileRoutesByPath[TFilePath]['parentRoute'],
+  TId extends RouteConstraints['TId'] = TFilePath,
+  TPath extends RouteConstraints['TPath'] = FileRoutePath<
+    TParentRoute,
+    TFilePath
+  >,
+  TFullPath extends RouteConstraints['TFullPath'] = ResolveFullPath<
+    TParentRoute,
+    RemoveUnderScores<TPath>
+  >,
+> {
+  constructor(public path: TFilePath) {}
+
+  createRoute = <
+    TSearchSchema extends RouteConstraints['TSearchSchema'] = {},
+    TFullSearchSchema extends RouteConstraints['TFullSearchSchema'] = ResolveFullSearchSchema<
+      TParentRoute,
+      TSearchSchema
+    >,
+    TParams extends RouteConstraints['TParams'] = ParsePathParams<TPath> extends never
+      ? AnyPathParams
+      : Record<ParsePathParams<TPath>, RouteConstraints['TPath']>,
+    TAllParams extends RouteConstraints['TAllParams'] = MergeFromFromParent<
+      TParentRoute['types']['allParams'],
+      TParams
+    >,
+    TRouteContext extends RouteConstraints['TRouteContext'] = RouteContext,
+    TContext extends Expand<
+      Assign<IsAny<TParentRoute['types']['allContext'], {}>, TRouteContext>
+    > = Expand<
+      Assign<IsAny<TParentRoute['types']['allContext'], {}>, TRouteContext>
+    >,
+    TRouterContext extends RouteConstraints['TRouterContext'] = AnyContext,
+    TLoaderData extends any = unknown,
+    TChildren extends RouteConstraints['TChildren'] = unknown,
+    TRouteTree extends RouteConstraints['TRouteTree'] = AnyRoute,
+  >(
+    options: Omit<
+      RouteOptions<
+        TParentRoute,
+        string,
+        string,
+        TSearchSchema,
+        TFullSearchSchema,
+        TParams,
+        TAllParams,
+        TRouteContext,
+        TContext,
+        TLoaderData
+      >,
+      'getParentRoute' | 'path' | 'id'
+    > &
+      UpdatableRouteOptions<
+        TFullSearchSchema,
+        TAllParams,
+        TContext,
+        TLoaderData
+      >,
+  ): Route<
+    TParentRoute,
+    TPath,
+    TFullPath,
+    TFilePath,
+    TId,
+    TSearchSchema,
+    TFullSearchSchema,
+    TParams,
+    TAllParams,
+    TRouteContext,
+    TContext,
+    TRouterContext,
+    TLoaderData,
+    TChildren,
+    TRouteTree
+  > => {
+    const route = new Route(options as any)
+    ;(route as any).isRoot = false
+    return route as any
+  }
+}

package/src/history.ts

@@ -0,0 +1,8 @@
+import { HistoryLocation } from '@tanstack/history'
+
+declare module '@tanstack/history' {
+  interface HistoryState {
+    __tempLocation?: HistoryLocation
+    __tempKey?: string
+  }
+}