@tanstack/solid-router 1.108.0

package/src/matchContext.tsx

@@ -0,0 +1,10 @@
+import * as Solid from 'solid-js'
+
+export const matchContext = Solid.createContext<
+  Solid.Accessor<string | undefined>
+>(() => undefined)
+
+// N.B. this only exists so we can conditionally call useContext on it when we are not interested in the nearest match
+export const dummyMatchContext = Solid.createContext<
+  Solid.Accessor<string | undefined>
+>(() => undefined)

package/src/not-found.tsx

@@ -0,0 +1,69 @@
+import { CatchBoundary } from './CatchBoundary'
+import { useRouterState } from './useRouterState'
+import type * as Solid from 'solid-js'
+import type { RegisteredRouter } from './router'
+import type { RouteIds } from './routeInfo'
+
+export type NotFoundError = {
+  /**
+    @deprecated
+    Use `routeId: rootRouteId` instead
+  */
+  global?: boolean
+  /**
+    @private
+    Do not use this. It's used internally to indicate a path matching error
+  */
+  _global?: boolean
+  data?: any
+  throw?: boolean
+  routeId?: RouteIds<RegisteredRouter['routeTree']>
+  headers?: HeadersInit
+}
+
+export function notFound(options: NotFoundError = {}) {
+  ;(options as any).isNotFound = true
+  if (options.throw) throw options
+  return options
+}
+
+export function isNotFound(obj: any): obj is NotFoundError {
+  return !!obj?.isNotFound
+}
+
+export function CatchNotFound(props: {
+  fallback?: (error: NotFoundError) => Solid.JSX.Element
+  onCatch?: (error: Error) => void
+  children: Solid.JSX.Element
+}) {
+  // TODO: Some way for the user to programmatically reset the not-found boundary?
+  const resetKey = useRouterState({
+    select: (s) => `not-found-${s.location.pathname}-${s.status}`,
+  })
+
+  return (
+    <CatchBoundary
+      getResetKey={() => resetKey()}
+      onCatch={(error) => {
+        if (isNotFound(error)) {
+          props.onCatch?.(error)
+        } else {
+          throw error
+        }
+      }}
+      errorComponent={({ error }: { error: Error }) => {
+        if (isNotFound(error)) {
+          return props.fallback?.(error)
+        } else {
+          throw error
+        }
+      }}
+    >
+      {props.children}
+    </CatchBoundary>
+  )
+}
+
+export function DefaultGlobalNotFound() {
+  return <p>Not Found</p>
+}

package/src/redirects.ts

@@ -0,0 +1,71 @@
+import type { NavigateOptions } from './link'
+import type { RoutePaths } from './routeInfo'
+import type { AnyRouter, RegisteredRouter } from './router'
+import type { PickAsRequired } from '@tanstack/router-core'
+
+export type AnyRedirect = Redirect<any, any, any, any, any>
+
+export type Redirect<
+  TRouter extends AnyRouter = RegisteredRouter,
+  TFrom extends RoutePaths<TRouter['routeTree']> | string = '/',
+  TTo extends string | undefined = '.',
+  TMaskFrom extends RoutePaths<TRouter['routeTree']> | string = TFrom,
+  TMaskTo extends string = '.',
+> = {
+  href?: string
+  /**
+   * @deprecated Use `statusCode` instead
+   **/
+  code?: number
+  statusCode?: number
+  throw?: any
+  headers?: HeadersInit
+} & NavigateOptions<TRouter, TFrom, TTo, TMaskFrom, TMaskTo>
+
+export type ResolvedRedirect<
+  TRouter extends AnyRouter = RegisteredRouter,
+  TFrom extends RoutePaths<TRouter['routeTree']> = '/',
+  TTo extends string = '',
+  TMaskFrom extends RoutePaths<TRouter['routeTree']> = TFrom,
+  TMaskTo extends string = '',
+> = PickAsRequired<
+  Redirect<TRouter, TFrom, TTo, TMaskFrom, TMaskTo>,
+  'code' | 'statusCode' | 'headers'
+> & {
+  href: string
+}
+
+export function redirect<
+  TRouter extends RegisteredRouter,
+  const TTo extends string | undefined,
+  const TFrom extends string = string,
+  const TMaskFrom extends string = TFrom,
+  const TMaskTo extends string = '',
+>(
+  opts: Redirect<TRouter, TFrom, TTo, TMaskFrom, TMaskTo>,
+): Redirect<TRouter, TFrom, TTo, TMaskFrom, TMaskTo> {
+  ;(opts as any).isRedirect = true
+  opts.statusCode = opts.statusCode || opts.code || 307
+  opts.headers = opts.headers || {}
+  if (!opts.reloadDocument) {
+    opts.reloadDocument = false
+    try {
+      new URL(`${opts.href}`)
+      opts.reloadDocument = true
+    } catch {}
+  }
+
+  if (opts.throw) {
+    throw opts
+  }
+
+  return opts
+}
+
+export function isRedirect(obj: any): obj is AnyRedirect {
+  return !!obj?.isRedirect
+}
+
+export function isResolvedRedirect(obj: any): obj is ResolvedRedirect {
+  return !!obj?.isRedirect && obj.href
+}

package/src/renderRouteNotFound.tsx

@@ -0,0 +1,27 @@
+import warning from 'tiny-warning'
+import { DefaultGlobalNotFound } from './not-found'
+import type { AnyRouter } from './router'
+import type { AnyRoute } from './route'
+
+export function renderRouteNotFound(
+  router: AnyRouter,
+  route: AnyRoute,
+  data: any,
+) {
+  if (!route.options.notFoundComponent) {
+    if (router.options.defaultNotFoundComponent) {
+      return <router.options.defaultNotFoundComponent data={data} />
+    }
+
+    if (process.env.NODE_ENV === 'development') {
+      warning(
+        route.options.notFoundComponent,
+        `A notFoundError was encountered on the route with ID "${route.id}", but a notFoundComponent option was not configured, nor was a router level defaultNotFoundComponent configured. Consider configuring at least one of these to avoid TanStack Router's overly generic defaultNotFoundComponent (<div>Not Found<div>)`,
+      )
+    }
+
+    return <DefaultGlobalNotFound />
+  }
+
+  return <route.options.notFoundComponent data={data} />
+}