@depup/tanstack__react-router 1.166.4-depup.0

package/src/router.ts

@@ -0,0 +1,127 @@
+import { RouterCore } from '@tanstack/router-core'
+import { createFileRoute, createLazyFileRoute } from './fileRoute'
+import type { RouterHistory } from '@tanstack/history'
+import type {
+  AnyRoute,
+  CreateRouterFn,
+  RouterConstructorOptions,
+  TrailingSlashOption,
+} from '@tanstack/router-core'
+
+import type {
+  ErrorRouteComponent,
+  NotFoundRouteComponent,
+  RouteComponent,
+} from './route'
+
+declare module '@tanstack/router-core' {
+  export interface RouterOptionsExtensions {
+    /**
+     * The default `component` a route should use if no component is provided.
+     *
+     * @default Outlet
+     * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/RouterOptionsType#defaultcomponent-property)
+     */
+    defaultComponent?: RouteComponent
+    /**
+     * The default `errorComponent` a route should use if no error component is provided.
+     *
+     * @default ErrorComponent
+     * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/RouterOptionsType#defaulterrorcomponent-property)
+     * @link [Guide](https://tanstack.com/router/latest/docs/framework/react/guide/data-loading#handling-errors-with-routeoptionserrorcomponent)
+     */
+    defaultErrorComponent?: ErrorRouteComponent
+    /**
+     * The default `pendingComponent` a route should use if no pending component is provided.
+     *
+     * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/RouterOptionsType#defaultpendingcomponent-property)
+     * @link [Guide](https://tanstack.com/router/latest/docs/framework/react/guide/data-loading#showing-a-pending-component)
+     */
+    defaultPendingComponent?: RouteComponent
+    /**
+     * The default `notFoundComponent` a route should use if no notFound component is provided.
+     *
+     * @default NotFound
+     * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/RouterOptionsType#defaultnotfoundcomponent-property)
+     * @link [Guide](https://tanstack.com/router/latest/docs/framework/react/guide/not-found-errors#default-router-wide-not-found-handling)
+     */
+    defaultNotFoundComponent?: NotFoundRouteComponent
+    /**
+     * A component that will be used to wrap the entire router.
+     *
+     * This is useful for providing a context to the entire router.
+     *
+     * Only non-DOM-rendering components like providers should be used, anything else will cause a hydration error.
+     *
+     * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/RouterOptionsType#wrap-property)
+     */
+    Wrap?: (props: { children: any }) => React.JSX.Element
+    /**
+     * A component that will be used to wrap the inner contents of the router.
+     *
+     * This is useful for providing a context to the inner contents of the router where you also need access to the router context and hooks.
+     *
+     * Only non-DOM-rendering components like providers should be used, anything else will cause a hydration error.
+     *
+     * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/RouterOptionsType#innerwrap-property)
+     */
+    InnerWrap?: (props: { children: any }) => React.JSX.Element
+
+    /**
+     * The default `onCatch` handler for errors caught by the Router ErrorBoundary
+     *
+     * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/RouterOptionsType#defaultoncatch-property)
+     * @link [Guide](https://tanstack.com/router/latest/docs/framework/react/guide/data-loading#handling-errors-with-routeoptionsoncatch)
+     */
+    defaultOnCatch?: (error: Error, errorInfo: React.ErrorInfo) => void
+  }
+}
+
+/**
+ * Creates a new Router instance for React.
+ *
+ * Pass the returned router to `RouterProvider` to enable routing.
+ * Notable options: `routeTree` (your route definitions) and `context`
+ * (required if the root route was created with `createRootRouteWithContext`).
+ *
+ * @param options Router options used to configure the router.
+ * @returns A Router instance to be provided to `RouterProvider`.
+ * @link https://tanstack.com/router/latest/docs/framework/react/api/router/createRouterFunction
+ */
+export const createRouter: CreateRouterFn = (options) => {
+  return new Router(options)
+}
+
+export class Router<
+  in out TRouteTree extends AnyRoute,
+  in out TTrailingSlashOption extends TrailingSlashOption = 'never',
+  in out TDefaultStructuralSharingOption extends boolean = false,
+  in out TRouterHistory extends RouterHistory = RouterHistory,
+  in out TDehydrated extends Record<string, any> = Record<string, any>,
+> extends RouterCore<
+  TRouteTree,
+  TTrailingSlashOption,
+  TDefaultStructuralSharingOption,
+  TRouterHistory,
+  TDehydrated
+> {
+  constructor(
+    options: RouterConstructorOptions<
+      TRouteTree,
+      TTrailingSlashOption,
+      TDefaultStructuralSharingOption,
+      TRouterHistory,
+      TDehydrated
+    >,
+  ) {
+    super(options)
+  }
+}
+
+if (typeof globalThis !== 'undefined') {
+  ;(globalThis as any).createFileRoute = createFileRoute
+  ;(globalThis as any).createLazyFileRoute = createLazyFileRoute
+} else if (typeof window !== 'undefined') {
+  ;(window as any).createFileRoute = createFileRoute
+  ;(window as any).createLazyFileRoute = createLazyFileRoute
+}

package/src/routerContext.tsx

@@ -0,0 +1,4 @@
+import * as React from 'react'
+import type { AnyRouter } from '@tanstack/router-core'
+
+export const routerContext = React.createContext<AnyRouter>(null!)

package/src/scroll-restoration.tsx

@@ -0,0 +1,45 @@
+import {
+  defaultGetScrollRestorationKey,
+  escapeHtml,
+  restoreScroll,
+  storageKey,
+} from '@tanstack/router-core'
+import { isServer } from '@tanstack/router-core/isServer'
+import { useRouter } from './useRouter'
+import { ScriptOnce } from './ScriptOnce'
+
+export function ScrollRestoration() {
+  const router = useRouter()
+  if (!router.isScrollRestoring || !(isServer ?? router.isServer)) {
+    return null
+  }
+  if (typeof router.options.scrollRestoration === 'function') {
+    const shouldRestore = router.options.scrollRestoration({
+      location: router.latestLocation,
+    })
+    if (!shouldRestore) {
+      return null
+    }
+  }
+  const getKey =
+    router.options.getScrollRestorationKey || defaultGetScrollRestorationKey
+  const userKey = getKey(router.latestLocation)
+  const resolvedKey =
+    userKey !== defaultGetScrollRestorationKey(router.latestLocation)
+      ? userKey
+      : undefined
+
+  const restoreScrollOptions: Parameters<typeof restoreScroll>[0] = {
+    storageKey,
+    shouldScrollRestoration: true,
+  }
+  if (resolvedKey) {
+    restoreScrollOptions.key = resolvedKey
+  }
+
+  return (
+    <ScriptOnce
+      children={`(${restoreScroll.toString()})(${escapeHtml(JSON.stringify(restoreScrollOptions))})`}
+    />
+  )
+}

package/src/ssr/RouterClient.tsx

@@ -0,0 +1,22 @@
+import { hydrate } from '@tanstack/router-core/ssr/client'
+import { Await } from '../awaited'
+import { RouterProvider } from '../RouterProvider'
+import type { AnyRouter } from '@tanstack/router-core'
+
+let hydrationPromise: Promise<void | Array<Array<void>>> | undefined
+
+export function RouterClient(props: { router: AnyRouter }) {
+  if (!hydrationPromise) {
+    if (!props.router.state.matches.length) {
+      hydrationPromise = hydrate(props.router)
+    } else {
+      hydrationPromise = Promise.resolve()
+    }
+  }
+  return (
+    <Await
+      promise={hydrationPromise}
+      children={() => <RouterProvider router={props.router} />}
+    />
+  )
+}

package/src/ssr/RouterServer.tsx

@@ -0,0 +1,9 @@
+import * as React from 'react'
+import { RouterProvider } from '../RouterProvider'
+import type { AnyRouter } from '@tanstack/router-core'
+
+export function RouterServer<TRouter extends AnyRouter>(props: {
+  router: TRouter
+}) {
+  return <RouterProvider router={props.router} />
+}

package/src/ssr/client.ts

@@ -0,0 +1,2 @@
+export { RouterClient } from './RouterClient'
+export * from '@tanstack/router-core/ssr/client'

package/src/ssr/defaultRenderHandler.tsx

@@ -0,0 +1,12 @@
+import { defineHandlerCallback } from '@tanstack/router-core/ssr/server'
+import { renderRouterToString } from './renderRouterToString'
+import { RouterServer } from './RouterServer'
+
+export const defaultRenderHandler = defineHandlerCallback(
+  ({ router, responseHeaders }) =>
+    renderRouterToString({
+      router,
+      responseHeaders,
+      children: <RouterServer router={router} />,
+    }),
+)

package/src/ssr/defaultStreamHandler.tsx

@@ -0,0 +1,13 @@
+import { defineHandlerCallback } from '@tanstack/router-core/ssr/server'
+import { RouterServer } from './RouterServer'
+import { renderRouterToStream } from './renderRouterToStream'
+
+export const defaultStreamHandler = defineHandlerCallback(
+  ({ request, router, responseHeaders }) =>
+    renderRouterToStream({
+      request,
+      router,
+      responseHeaders,
+      children: <RouterServer router={router} />,
+    }),
+)

package/src/ssr/renderRouterToStream.tsx

@@ -0,0 +1,90 @@
+import { PassThrough } from 'node:stream'
+import ReactDOMServer from 'react-dom/server'
+import { isbot } from 'isbot'
+import {
+  transformPipeableStreamWithRouter,
+  transformReadableStreamWithRouter,
+} from '@tanstack/router-core/ssr/server'
+import type { AnyRouter } from '@tanstack/router-core'
+import type { ReadableStream } from 'node:stream/web'
+import type { ReactNode } from 'react'
+
+export const renderRouterToStream = async ({
+  request,
+  router,
+  responseHeaders,
+  children,
+}: {
+  request: Request
+  router: AnyRouter
+  responseHeaders: Headers
+  children: ReactNode
+}) => {
+  if (typeof ReactDOMServer.renderToReadableStream === 'function') {
+    const stream = await ReactDOMServer.renderToReadableStream(children, {
+      signal: request.signal,
+      nonce: router.options.ssr?.nonce,
+      progressiveChunkSize: Number.POSITIVE_INFINITY,
+    })
+
+    if (isbot(request.headers.get('User-Agent'))) {
+      await stream.allReady
+    }
+
+    const responseStream = transformReadableStreamWithRouter(
+      router,
+      stream as unknown as ReadableStream,
+    )
+    return new Response(responseStream as any, {
+      status: router.state.statusCode,
+      headers: responseHeaders,
+    })
+  }
+
+  if (typeof ReactDOMServer.renderToPipeableStream === 'function') {
+    const reactAppPassthrough = new PassThrough()
+
+    try {
+      const pipeable = ReactDOMServer.renderToPipeableStream(children, {
+        nonce: router.options.ssr?.nonce,
+        progressiveChunkSize: Number.POSITIVE_INFINITY,
+        ...(isbot(request.headers.get('User-Agent'))
+          ? {
+              onAllReady() {
+                pipeable.pipe(reactAppPassthrough)
+              },
+            }
+          : {
+              onShellReady() {
+                pipeable.pipe(reactAppPassthrough)
+              },
+            }),
+        onError: (error, info) => {
+          console.error('Error in renderToPipeableStream:', error, info)
+          // Destroy the passthrough stream on error
+          if (!reactAppPassthrough.destroyed) {
+            reactAppPassthrough.destroy(
+              error instanceof Error ? error : new Error(String(error)),
+            )
+          }
+        },
+      })
+    } catch (e) {
+      console.error('Error in renderToPipeableStream:', e)
+      reactAppPassthrough.destroy(e instanceof Error ? e : new Error(String(e)))
+    }
+
+    const responseStream = transformPipeableStreamWithRouter(
+      router,
+      reactAppPassthrough,
+    )
+    return new Response(responseStream as any, {
+      status: router.state.statusCode,
+      headers: responseHeaders,
+    })
+  }
+
+  throw new Error(
+    'No renderToReadableStream or renderToPipeableStream found in react-dom/server. Ensure you are using a version of react-dom that supports streaming.',
+  )
+}

package/src/ssr/renderRouterToString.tsx

@@ -0,0 +1,36 @@
+import ReactDOMServer from 'react-dom/server'
+import type { ReactNode } from 'react'
+import type { AnyRouter } from '@tanstack/router-core'
+
+export const renderRouterToString = async ({
+  router,
+  responseHeaders,
+  children,
+}: {
+  router: AnyRouter
+  responseHeaders: Headers
+  children: ReactNode
+}) => {
+  try {
+    let html = ReactDOMServer.renderToString(children)
+    router.serverSsr!.setRenderFinished()
+
+    const injectedHtml = router.serverSsr!.takeBufferedHtml()
+    if (injectedHtml) {
+      html = html.replace(`</body>`, () => `${injectedHtml}</body>`)
+    }
+
+    return new Response(`<!DOCTYPE html>${html}`, {
+      status: router.state.statusCode,
+      headers: responseHeaders,
+    })
+  } catch (error) {
+    console.error('Render to string error:', error)
+    return new Response('Internal Server Error', {
+      status: 500,
+      headers: responseHeaders,
+    })
+  } finally {
+    router.serverSsr?.cleanup()
+  }
+}

package/src/ssr/serializer.ts

@@ -0,0 +1,7 @@
+import type * as React from 'react'
+
+declare module '@tanstack/router-core' {
+  export interface SerializerExtensions {
+    ReadableStream: React.JSX.Element
+  }
+}

package/src/ssr/server.ts

@@ -0,0 +1,6 @@
+export { RouterServer } from './RouterServer'
+export { defaultRenderHandler } from './defaultRenderHandler'
+export { defaultStreamHandler } from './defaultStreamHandler'
+export { renderRouterToStream } from './renderRouterToStream'
+export { renderRouterToString } from './renderRouterToString'
+export * from '@tanstack/router-core/ssr/server'

package/src/structuralSharing.ts

@@ -0,0 +1,47 @@
+import type {
+  AnyRouter,
+  Constrain,
+  OptionalStructuralSharing,
+  ValidateJSON,
+} from '@tanstack/router-core'
+
+export type DefaultStructuralSharingEnabled<TRouter extends AnyRouter> =
+  boolean extends TRouter['options']['defaultStructuralSharing']
+    ? // for now, default to false.
+      // TODO in V2: default to true
+      false
+    : NonNullable<TRouter['options']['defaultStructuralSharing']>
+
+export interface RequiredStructuralSharing<TStructuralSharing, TConstraint> {
+  readonly structuralSharing: Constrain<TStructuralSharing, TConstraint>
+}
+
+export type StructuralSharingOption<
+  TRouter extends AnyRouter,
+  TSelected,
+  TStructuralSharing,
+> = unknown extends TSelected
+  ? OptionalStructuralSharing<TStructuralSharing, boolean>
+  : unknown extends TRouter['routeTree']
+    ? OptionalStructuralSharing<TStructuralSharing, boolean>
+    : TSelected extends ValidateJSON<TSelected>
+      ? OptionalStructuralSharing<TStructuralSharing, boolean>
+      : DefaultStructuralSharingEnabled<TRouter> extends true
+        ? RequiredStructuralSharing<TStructuralSharing, false>
+        : OptionalStructuralSharing<TStructuralSharing, false>
+
+export type StructuralSharingEnabled<
+  TRouter extends AnyRouter,
+  TStructuralSharing,
+> = boolean extends TStructuralSharing
+  ? DefaultStructuralSharingEnabled<TRouter>
+  : TStructuralSharing
+
+export type ValidateSelected<
+  TRouter extends AnyRouter,
+  TSelected,
+  TStructuralSharing,
+> =
+  StructuralSharingEnabled<TRouter, TStructuralSharing> extends true
+    ? ValidateJSON<TSelected>
+    : TSelected

package/src/typePrimitives.ts

@@ -0,0 +1,84 @@
+import type {
+  AnyRouter,
+  Constrain,
+  InferFrom,
+  InferMaskFrom,
+  InferMaskTo,
+  InferSelected,
+  InferShouldThrow,
+  InferStrict,
+  InferTo,
+  RegisteredRouter,
+} from '@tanstack/router-core'
+import type { LinkComponentProps } from './link'
+import type { UseParamsOptions } from './useParams'
+import type { UseSearchOptions } from './useSearch'
+
+export type ValidateLinkOptions<
+  TRouter extends AnyRouter = RegisteredRouter,
+  TOptions = unknown,
+  TDefaultFrom extends string = string,
+  TComp = 'a',
+> = Constrain<
+  TOptions,
+  LinkComponentProps<
+    TComp,
+    TRouter,
+    InferFrom<TOptions, TDefaultFrom>,
+    InferTo<TOptions>,
+    InferMaskFrom<TOptions>,
+    InferMaskTo<TOptions>
+  >
+>
+
+/**
+ * @private
+ */
+export type InferStructuralSharing<TOptions> = TOptions extends {
+  structuralSharing: infer TStructuralSharing
+}
+  ? TStructuralSharing
+  : unknown
+
+export type ValidateUseSearchOptions<
+  TOptions,
+  TRouter extends AnyRouter = RegisteredRouter,
+> = Constrain<
+  TOptions,
+  UseSearchOptions<
+    TRouter,
+    InferFrom<TOptions>,
+    InferStrict<TOptions>,
+    InferShouldThrow<TOptions>,
+    InferSelected<TOptions>,
+    InferStructuralSharing<TOptions>
+  >
+>
+
+export type ValidateUseParamsOptions<
+  TOptions,
+  TRouter extends AnyRouter = RegisteredRouter,
+> = Constrain<
+  TOptions,
+  UseParamsOptions<
+    TRouter,
+    InferFrom<TOptions>,
+    InferStrict<TOptions>,
+    InferShouldThrow<TOptions>,
+    InferSelected<TOptions>,
+    InferSelected<TOptions>
+  >
+>
+export type ValidateLinkOptionsArray<
+  TRouter extends AnyRouter = RegisteredRouter,
+  TOptions extends ReadonlyArray<any> = ReadonlyArray<unknown>,
+  TDefaultFrom extends string = string,
+  TComp = 'a',
+> = {
+  [K in keyof TOptions]: ValidateLinkOptions<
+    TRouter,
+    TOptions[K],
+    TDefaultFrom,
+    TComp
+  >
+}