@tanstack/react-router 1.97.19 → 1.97.21

package/src/routeInfo.ts

@@ -1,8 +1,12 @@
 import type { InferFileRouteTypes } from './fileRoute'
-import type { AddTrailingSlash, RemoveTrailingSlashes } from './link'
+import type {
+  AddTrailingSlash,
+  PartialMergeAll,
+  RemoveTrailingSlashes,
+  TrailingSlashOption,
+} from '@tanstack/router-core'
 import type { AnyRoute } from './route'
-import type { AnyRouter, TrailingSlashOption } from './router'
-import type { PartialMergeAll } from './utils'
+import type { AnyRouter } from './router'
 
 export type ParseRoute<TRouteTree, TAcc = TRouteTree> = TRouteTree extends {
   types: { children: infer TChildren }

package/src/router.ts

@@ -5,30 +5,28 @@ import {
 } from '@tanstack/history'
 import { Store, batch } from '@tanstack/react-store'
 import invariant from 'tiny-invariant'
-import { rootRouteId } from './root'
-import { defaultParseSearch, defaultStringifySearch } from './searchParams'
 import {
+  cleanPath,
   createControlledPromise,
   deepEqual,
+  defaultParseSearch,
+  defaultStringifySearch,
   functionalUpdate,
-  last,
-  pick,
-  replaceEqualDeep,
-} from './utils'
-import {
-  cleanPath,
   interpolatePath,
   joinPaths,
+  last,
   matchPathname,
   parsePathname,
+  pick,
+  replaceEqualDeep,
   resolvePath,
+  rootRouteId,
   trimPath,
   trimPathLeft,
   trimPathRight,
-} from './path'
+} from '@tanstack/router-core'
 import { isRedirect, isResolvedRedirect } from './redirects'
 import { isNotFound } from './not-found'
-import type { StartSerializer } from './serializer'
 import type * as React from 'react'
 import type {
   HistoryLocation,
@@ -37,9 +35,27 @@ import type {
   RouterHistory,
 } from '@tanstack/history'
 import type { NoInfer } from '@tanstack/react-store'
-import type { Manifest } from './manifest'
+
 import type {
   AnyContext,
+  AnySchema,
+  AnyValidator,
+  CommitLocationOptions,
+  ControlledPromise,
+  Manifest,
+  NonNullableUpdater,
+  ParsedLocation,
+  PickAsRequired,
+  ResolveRelativePath,
+  SearchMiddleware,
+  SearchParser,
+  SearchSerializer,
+  StartSerializer,
+  TrailingSlashOption,
+  Updater,
+  ViewTransitionOptions,
+} from '@tanstack/router-core'
+import type {
   AnyRoute,
   AnyRouteWithContext,
   BeforeLoadContextOptions,
@@ -50,8 +66,8 @@ import type {
   RouteComponent,
   RouteContextOptions,
   RouteMask,
-  SearchMiddleware,
 } from './route'
+
 import type {
   FullSearchSchema,
   RouteById,
@@ -59,29 +75,18 @@ import type {
   RoutesById,
   RoutesByPath,
 } from './routeInfo'
-import type {
-  ControlledPromise,
-  NonNullableUpdater,
-  PickAsRequired,
-  Updater,
-} from './utils'
 import type {
   AnyRouteMatch,
   MakeRouteMatch,
   MakeRouteMatchUnion,
   MatchRouteOptions,
 } from './Matches'
-import type { ParsedLocation } from './location'
-import type { SearchParser, SearchSerializer } from './searchParams'
-import type {
-  BuildLocationFn,
-  CommitLocationOptions,
-  NavigateFn,
-} from './RouterProvider'
+
+import type { BuildLocationFn, NavigateFn } from './RouterProvider'
+
 import type { AnyRedirect, ResolvedRedirect } from './redirects'
 import type { NotFoundError } from './not-found'
-import type { NavigateOptions, ResolveRelativePath, ToOptions } from './link'
-import type { AnySchema, AnyValidator } from './validators'
+import type { NavigateOptions, ToOptions } from './link'
 
 declare global {
   interface Window {
@@ -137,8 +142,6 @@ export type RouterContextOptions<TRouteTree extends AnyRoute> =
         context: InferRouterContext<TRouteTree>
       }
 
-export type TrailingSlashOption = 'always' | 'never' | 'preserve'
-
 export type InjectedHtmlEntry = Promise<string>
 
 export interface RouterOptions<
@@ -498,10 +501,6 @@ export interface MatchedRoutesResult {
   routeParams: Record<string, string>
 }
 
-export interface ViewTransitionOptions {
-  types: Array<string>
-}
-
 export type RouterConstructorOptions<
   TRouteTree extends AnyRoute,
   TTrailingSlashOption extends TrailingSlashOption,
@@ -3029,22 +3028,3 @@ export function getInitialRouterState(
     statusCode: 200,
   }
 }
-
-export function defaultSerializeError(err: unknown) {
-  if (err instanceof Error) {
-    const obj = {
-      name: err.name,
-      message: err.message,
-    }
-
-    if (process.env.NODE_ENV === 'development') {
-      ;(obj as any).stack = err.stack
-    }
-
-    return obj
-  }
-
-  return {
-    data: err,
-  }
-}

package/src/scroll-restoration.tsx

@@ -1,8 +1,7 @@
 import * as React from 'react'
+import { functionalUpdate } from '@tanstack/router-core'
 import { useRouter } from './useRouter'
-import { functionalUpdate } from './utils'
-import type { ParsedLocation } from './location'
-import type { NonNullableUpdater } from './utils'
+import type { NonNullableUpdater, ParsedLocation } from '@tanstack/router-core'
 
 const useLayoutEffect =
   typeof window !== 'undefined' ? React.useLayoutEffect : React.useEffect

package/src/structuralSharing.ts

@@ -1,4 +1,8 @@
-import type { Constrain, ValidateJSON } from './utils'
+import type {
+  Constrain,
+  OptionalStructuralSharing,
+  ValidateJSON,
+} from '@tanstack/router-core'
 import type { AnyRouter } from './router'
 
 export type DefaultStructuralSharingEnabled<TRouter extends AnyRouter> =
@@ -8,12 +12,6 @@ export type DefaultStructuralSharingEnabled<TRouter extends AnyRouter> =
       false
     : NonNullable<TRouter['options']['defaultStructuralSharing']>
 
-export interface OptionalStructuralSharing<TStructuralSharing, TConstraint> {
-  readonly structuralSharing?:
-    | Constrain<TStructuralSharing, TConstraint>
-    | undefined
-}
-
 export interface RequiredStructuralSharing<TStructuralSharing, TConstraint> {
   readonly structuralSharing: Constrain<TStructuralSharing, TConstraint>
 }

package/src/typePrimitives.ts

@@ -10,7 +10,7 @@ import type { RouteIds } from './routeInfo'
 import type { AnyRouter, RegisteredRouter } from './router'
 import type { UseParamsOptions, UseParamsResult } from './useParams'
 import type { UseSearchOptions, UseSearchResult } from './useSearch'
-import type { Constrain, ConstrainLiteral } from './utils'
+import type { Constrain, ConstrainLiteral } from '@tanstack/router-core'
 
 export type ValidateFromPath<
   TFrom,

package/src/useLoaderData.tsx

@@ -5,7 +5,8 @@ import type {
 } from './structuralSharing'
 import type { AnyRouter, RegisteredRouter } from './router'
 import type { AllLoaderData, RouteById } from './routeInfo'
-import type { Expand, StrictOrFrom } from './utils'
+import type { StrictOrFrom } from './utils'
+import type { Expand } from '@tanstack/router-core'
 
 export interface UseLoaderDataBaseOptions<
   TRouter extends AnyRouter,

package/src/useLoaderDeps.tsx

@@ -5,7 +5,8 @@ import type {
 } from './structuralSharing'
 import type { AnyRouter, RegisteredRouter } from './router'
 import type { RouteById } from './routeInfo'
-import type { Expand, StrictOrFrom } from './utils'
+import type { StrictOrFrom } from './utils'
+import type { Expand } from '@tanstack/router-core'
 
 export interface UseLoaderDepsBaseOptions<
   TRouter extends AnyRouter,

package/src/useMatch.tsx

@@ -8,7 +8,8 @@ import type {
 } from './structuralSharing'
 import type { AnyRouter, RegisteredRouter } from './router'
 import type { MakeRouteMatch, MakeRouteMatchUnion } from './Matches'
-import type { StrictOrFrom, ThrowOrOptional } from './utils'
+import type { StrictOrFrom } from './utils'
+import type { ThrowOrOptional } from '@tanstack/router-core'
 
 export interface UseMatchBaseOptions<
   TRouter extends AnyRouter,

package/src/useParams.tsx

@@ -5,7 +5,8 @@ import type {
 } from './structuralSharing'
 import type { AllParams, RouteById } from './routeInfo'
 import type { AnyRouter, RegisteredRouter } from './router'
-import type { Expand, StrictOrFrom } from './utils'
+import type { StrictOrFrom } from './utils'
+import type { Expand } from '@tanstack/router-core'
 
 export interface UseParamsBaseOptions<
   TRouter extends AnyRouter,

package/src/useRouteContext.ts

@@ -1,7 +1,8 @@
 import { useMatch } from './useMatch'
 import type { AllContext, RouteById } from './routeInfo'
 import type { AnyRouter, RegisteredRouter } from './router'
-import type { Expand, StrictOrFrom } from './utils'
+import type { StrictOrFrom } from './utils'
+import type { Expand } from '@tanstack/router-core'
 
 export interface UseRouteContextBaseOptions<
   TRouter extends AnyRouter,

package/src/useRouterState.tsx

@@ -1,7 +1,7 @@
 import { useStore } from '@tanstack/react-store'
 import { useRef } from 'react'
+import { replaceEqualDeep } from '@tanstack/router-core'
 import { useRouter } from './useRouter'
-import { replaceEqualDeep } from './utils'
 import type {
   StructuralSharingOption,
   ValidateSelected,

package/src/useSearch.tsx

@@ -5,7 +5,8 @@ import type {
 } from './structuralSharing'
 import type { FullSearchSchema, RouteById } from './routeInfo'
 import type { AnyRouter, RegisteredRouter } from './router'
-import type { Expand, StrictOrFrom } from './utils'
+import type { StrictOrFrom } from './utils'
+import type { Expand } from '@tanstack/router-core'
 
 export interface UseSearchBaseOptions<
   TRouter extends AnyRouter,

package/src/utils.ts

@@ -1,311 +1,7 @@
 import * as React from 'react'
 import type { RouteIds } from './routeInfo'
 import type { AnyRouter } from './router'
-
-export type NoInfer<T> = [T][T extends any ? 0 : never]
-export type IsAny<TValue, TYesResult, TNoResult = TValue> = 1 extends 0 & TValue
-  ? TYesResult
-  : TNoResult
-
-export type PickAsRequired<TValue, TKey extends keyof TValue> = Omit<
-  TValue,
-  TKey
-> &
-  Required<Pick<TValue, TKey>>
-
-export type PickRequired<T> = {
-  [K in keyof T as undefined extends T[K] ? never : K]: T[K]
-}
-
-export type PickOptional<T> = {
-  [K in keyof T as undefined extends T[K] ? K : never]: T[K]
-}
-
-// from https://stackoverflow.com/a/76458160
-export type WithoutEmpty<T> = T extends any ? ({} extends T ? never : T) : never
-
-// export type Expand<T> = T
-export type Expand<T> = T extends object
-  ? T extends infer O
-    ? O extends Function
-      ? O
-      : { [K in keyof O]: O[K] }
-    : never
-  : T
-
-export type DeepPartial<T> = T extends object
-  ? {
-      [P in keyof T]?: DeepPartial<T[P]>
-    }
-  : T
-
-export type MakeDifferenceOptional<TLeft, TRight> = Omit<
-  TRight,
-  keyof TLeft
-> & {
-  [K in keyof TLeft & keyof TRight]?: TRight[K]
-}
-
-// from https://stackoverflow.com/a/53955431
-// eslint-disable-next-line @typescript-eslint/naming-convention
-export type IsUnion<T, U extends T = T> = (
-  T extends any ? (U extends T ? false : true) : never
-) extends false
-  ? false
-  : true
-
-export type Assign<TLeft, TRight> = TLeft extends any
-  ? TRight extends any
-    ? keyof TLeft extends never
-      ? TRight
-      : keyof TRight extends never
-        ? TLeft
-        : keyof TLeft & keyof TRight extends never
-          ? TLeft & TRight
-          : Omit<TLeft, keyof TRight> & TRight
-    : never
-  : never
-
-export type Timeout = ReturnType<typeof setTimeout>
-
-export type Updater<TPrevious, TResult = TPrevious> =
-  | TResult
-  | ((prev?: TPrevious) => TResult)
-
-export type NonNullableUpdater<TPrevious, TResult = TPrevious> =
-  | TResult
-  | ((prev: TPrevious) => TResult)
-
-export type ExtractObjects<TUnion> = TUnion extends MergeAllPrimitive
-  ? never
-  : TUnion
-
-export type PartialMergeAllObject<TUnion> =
-  ExtractObjects<TUnion> extends infer TObj
-    ? {
-        [TKey in TObj extends any ? keyof TObj : never]?: TObj extends any
-          ? TKey extends keyof TObj
-            ? TObj[TKey]
-            : never
-          : never
-      }
-    : never
-
-export type MergeAllPrimitive =
-  | ReadonlyArray<any>
-  | number
-  | string
-  | bigint
-  | boolean
-  | symbol
-  | undefined
-  | null
-
-export type ExtractPrimitives<TUnion> = TUnion extends MergeAllPrimitive
-  ? TUnion
-  : TUnion extends object
-    ? never
-    : TUnion
-
-export type PartialMergeAll<TUnion> =
-  | ExtractPrimitives<TUnion>
-  | PartialMergeAllObject<TUnion>
-
-export type Constrain<T, TConstraint, TDefault = TConstraint> =
-  | (T extends TConstraint ? T : never)
-  | TDefault
-
-export type ConstrainLiteral<T, TConstraint, TDefault = TConstraint> =
-  | (T & TConstraint)
-  | TDefault
-
-/**
- * To be added to router types
- */
-export type UnionToIntersection<T> = (
-  T extends any ? (arg: T) => any : never
-) extends (arg: infer T) => any
-  ? T
-  : never
-
-/**
- * Merges everything in a union into one object.
- * This mapped type is homomorphic which means it preserves stuff! :)
- */
-export type MergeAllObjects<
-  TUnion,
-  TIntersected = UnionToIntersection<ExtractObjects<TUnion>>,
-> = [keyof TIntersected] extends [never]
-  ? never
-  : {
-      [TKey in keyof TIntersected]: TUnion extends any
-        ? TUnion[TKey & keyof TUnion]
-        : never
-    }
-
-export type MergeAll<TUnion> =
-  | MergeAllObjects<TUnion>
-  | ExtractPrimitives<TUnion>
-
-export type ValidateJSON<T> = ((...args: Array<any>) => any) extends T
-  ? unknown extends T
-    ? never
-    : 'Function is not serializable'
-  : { [K in keyof T]: ValidateJSON<T[K]> }
-
-export function last<T>(arr: Array<T>) {
-  return arr[arr.length - 1]
-}
-
-function isFunction(d: any): d is Function {
-  return typeof d === 'function'
-}
-
-export function functionalUpdate<TPrevious, TResult = TPrevious>(
-  updater: Updater<TPrevious, TResult> | NonNullableUpdater<TPrevious, TResult>,
-  previous: TPrevious,
-): TResult {
-  if (isFunction(updater)) {
-    return updater(previous)
-  }
-
-  return updater
-}
-
-export function pick<TValue, TKey extends keyof TValue>(
-  parent: TValue,
-  keys: Array<TKey>,
-): Pick<TValue, TKey> {
-  return keys.reduce((obj: any, key: TKey) => {
-    obj[key] = parent[key]
-    return obj
-  }, {} as any)
-}
-
-/**
- * This function returns `prev` if `_next` is deeply equal.
- * If not, it will replace any deeply equal children of `b` with those of `a`.
- * This can be used for structural sharing between immutable JSON values for example.
- * Do not use this with signals
- */
-export function replaceEqualDeep<T>(prev: any, _next: T): T {
-  if (prev === _next) {
-    return prev
-  }
-
-  const next = _next as any
-
-  const array = isPlainArray(prev) && isPlainArray(next)
-
-  if (array || (isPlainObject(prev) && isPlainObject(next))) {
-    const prevItems = array ? prev : Object.keys(prev)
-    const prevSize = prevItems.length
-    const nextItems = array ? next : Object.keys(next)
-    const nextSize = nextItems.length
-    const copy: any = array ? [] : {}
-
-    let equalItems = 0
-
-    for (let i = 0; i < nextSize; i++) {
-      const key = array ? i : (nextItems[i] as any)
-      if (
-        ((!array && prevItems.includes(key)) || array) &&
-        prev[key] === undefined &&
-        next[key] === undefined
-      ) {
-        copy[key] = undefined
-        equalItems++
-      } else {
-        copy[key] = replaceEqualDeep(prev[key], next[key])
-        if (copy[key] === prev[key] && prev[key] !== undefined) {
-          equalItems++
-        }
-      }
-    }
-
-    return prevSize === nextSize && equalItems === prevSize ? prev : copy
-  }
-
-  return next
-}
-
-// Copied from: https://github.com/jonschlinkert/is-plain-object
-export function isPlainObject(o: any) {
-  if (!hasObjectPrototype(o)) {
-    return false
-  }
-
-  // If has modified constructor
-  const ctor = o.constructor
-  if (typeof ctor === 'undefined') {
-    return true
-  }
-
-  // If has modified prototype
-  const prot = ctor.prototype
-  if (!hasObjectPrototype(prot)) {
-    return false
-  }
-
-  // If constructor does not have an Object-specific method
-  if (!prot.hasOwnProperty('isPrototypeOf')) {
-    return false
-  }
-
-  // Most likely a plain Object
-  return true
-}
-
-function hasObjectPrototype(o: any) {
-  return Object.prototype.toString.call(o) === '[object Object]'
-}
-
-export function isPlainArray(value: unknown): value is Array<unknown> {
-  return Array.isArray(value) && value.length === Object.keys(value).length
-}
-
-function getObjectKeys(obj: any, ignoreUndefined: boolean) {
-  let keys = Object.keys(obj)
-  if (ignoreUndefined) {
-    keys = keys.filter((key) => obj[key] !== undefined)
-  }
-  return keys
-}
-
-export function deepEqual(
-  a: any,
-  b: any,
-  opts?: { partial?: boolean; ignoreUndefined?: boolean },
-): boolean {
-  if (a === b) {
-    return true
-  }
-
-  if (typeof a !== typeof b) {
-    return false
-  }
-
-  if (isPlainObject(a) && isPlainObject(b)) {
-    const ignoreUndefined = opts?.ignoreUndefined ?? true
-    const aKeys = getObjectKeys(a, ignoreUndefined)
-    const bKeys = getObjectKeys(b, ignoreUndefined)
-
-    if (!opts?.partial && aKeys.length !== bKeys.length) {
-      return false
-    }
-
-    return bKeys.every((key) => deepEqual(a[key], b[key], opts))
-  }
-
-  if (Array.isArray(a) && Array.isArray(b)) {
-    if (a.length !== b.length) {
-      return false
-    }
-    return !a.some((item, index) => !deepEqual(item, b[index], opts))
-  }
-
-  return false
-}
+import type { ConstrainLiteral } from '@tanstack/router-core'
 
 export function useStableCallback<T extends (...args: Array<any>) => any>(
   fn: T,
@@ -317,42 +13,6 @@ export function useStableCallback<T extends (...args: Array<any>) => any>(
   return ref.current as T
 }
 
-export function shallow<T>(objA: T, objB: T) {
-  if (Object.is(objA, objB)) {
-    return true
-  }
-
-  if (
-    typeof objA !== 'object' ||
-    objA === null ||
-    typeof objB !== 'object' ||
-    objB === null
-  ) {
-    return false
-  }
-
-  const keysA = Object.keys(objA)
-  if (keysA.length !== Object.keys(objB).length) {
-    return false
-  }
-
-  for (const item of keysA) {
-    if (
-      !Object.prototype.hasOwnProperty.call(objB, item) ||
-      !Object.is(objA[item as keyof T], objB[item as keyof T])
-    ) {
-      return false
-    }
-  }
-  return true
-}
-
-export type StringLiteral<T> = T extends string
-  ? string extends T
-    ? string
-    : T
-  : never
-
 export type StrictOrFrom<
   TRouter extends AnyRouter,
   TFrom,
@@ -367,57 +27,9 @@ export type StrictOrFrom<
       strict?: TStrict
     }
 
-export type ThrowOrOptional<T, TThrow extends boolean> = TThrow extends true
-  ? T
-  : T | undefined
-
 export const useLayoutEffect =
   typeof window !== 'undefined' ? React.useLayoutEffect : React.useEffect
 
-/**
- *
- * @deprecated use `jsesc` instead
- */
-export function escapeJSON(jsonString: string) {
-  return jsonString
-    .replace(/\\/g, '\\\\') // Escape backslashes
-    .replace(/'/g, "\\'") // Escape single quotes
-    .replace(/"/g, '\\"') // Escape double quotes
-}
-
-export type ControlledPromise<T> = Promise<T> & {
-  resolve: (value: T) => void
-  reject: (value: any) => void
-  status: 'pending' | 'resolved' | 'rejected'
-  value?: T
-}
-
-export function createControlledPromise<T>(onResolve?: (value: T) => void) {
-  let resolveLoadPromise!: (value: T) => void
-  let rejectLoadPromise!: (value: any) => void
-
-  const controlledPromise = new Promise<T>((resolve, reject) => {
-    resolveLoadPromise = resolve
-    rejectLoadPromise = reject
-  }) as ControlledPromise<T>
-
-  controlledPromise.status = 'pending'
-
-  controlledPromise.resolve = (value: T) => {
-    controlledPromise.status = 'resolved'
-    controlledPromise.value = value
-    resolveLoadPromise(value)
-    onResolve?.(value)
-  }
-
-  controlledPromise.reject = (e) => {
-    controlledPromise.status = 'rejected'
-    rejectLoadPromise(e)
-  }
-
-  return controlledPromise
-}
-
 /**
  * Taken from https://www.developerway.com/posts/implementing-advanced-use-previous-hook#part3
  */