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

package/src/searchMiddleware.ts

@@ -0,0 +1,54 @@
+import { deepEqual } from './utils'
+import type { NoInfer, PickOptional } from './utils'
+import type { SearchMiddleware } from './route'
+import type { IsRequiredParams } from './link'
+
+export function retainSearchParams<TSearchSchema extends object>(
+  keys: Array<keyof TSearchSchema> | true,
+): SearchMiddleware<TSearchSchema> {
+  return ({ search, next }) => {
+    const result = next(search)
+    if (keys === true) {
+      return { ...search, ...result }
+    }
+    // add missing keys from search to result
+    keys.forEach((key) => {
+      if (!(key in result)) {
+        result[key] = search[key]
+      }
+    })
+    return result
+  }
+}
+
+export function stripSearchParams<
+  TSearchSchema,
+  TOptionalProps = PickOptional<NoInfer<TSearchSchema>>,
+  const TValues =
+    | Partial<NoInfer<TOptionalProps>>
+    | Array<keyof TOptionalProps>,
+  const TInput = IsRequiredParams<TSearchSchema> extends never
+    ? TValues | true
+    : TValues,
+>(input: NoInfer<TInput>): SearchMiddleware<TSearchSchema> {
+  return ({ search, next }) => {
+    if (input === true) {
+      return {}
+    }
+    const result = next(search) as Record<string, unknown>
+    if (Array.isArray(input)) {
+      input.forEach((key) => {
+        delete result[key]
+      })
+    } else {
+      Object.entries(input as Record<string, unknown>).forEach(
+        ([key, value]) => {
+          if (deepEqual(result[key], value)) {
+            delete result[key]
+          }
+        },
+      )
+    }
+    return result as any
+  }
+}

package/src/searchParams.ts

@@ -1,19 +1,22 @@
 import { decode, encode } from './qss'
-import { AnySearchSchema } from './routeConfig'
+import type { AnySchema } from './validators'
 
 export const defaultParseSearch = parseSearchWith(JSON.parse)
-export const defaultStringifySearch = stringifySearchWith(JSON.stringify)
+export const defaultStringifySearch = stringifySearchWith(
+  JSON.stringify,
+  JSON.parse,
+)
 
 export function parseSearchWith(parser: (str: string) => any) {
-  return (searchStr: string): AnySearchSchema => {
+  return (searchStr: string): AnySchema => {
     if (searchStr.substring(0, 1) === '?') {
       searchStr = searchStr.substring(1)
     }
 
-    let query: Record<string, unknown> = decode(searchStr)
+    const query: Record<string, unknown> = decode(searchStr)
 
     // Try to parse any query params that might be json
-    for (let key in query) {
+    for (const key in query) {
       const value = query[key]
       if (typeof value === 'string') {
         try {
@@ -28,27 +31,47 @@ export function parseSearchWith(parser: (str: string) => any) {
   }
 }
 
-export function stringifySearchWith(stringify: (search: any) => string) {
+export function stringifySearchWith(
+  stringify: (search: any) => string,
+  parser?: (str: string) => any,
+) {
+  function stringifyValue(val: any) {
+    if (typeof val === 'object' && val !== null) {
+      try {
+        return stringify(val)
+      } catch (err) {
+        // silent
+      }
+    } else if (typeof val === 'string' && typeof parser === 'function') {
+      try {
+        // Check if it's a valid parseable string.
+        // If it is, then stringify it again.
+        parser(val)
+        return stringify(val)
+      } catch (err) {
+        // silent
+      }
+    }
+    return val
+  }
+
   return (search: Record<string, any>) => {
     search = { ...search }
 
-    if (search) {
-      Object.keys(search).forEach((key) => {
-        const val = search[key]
-        if (typeof val === 'undefined' || val === undefined) {
-          delete search[key]
-        } else if (val && typeof val === 'object' && val !== null) {
-          try {
-            search[key] = stringify(val)
-          } catch (err) {
-            // silent
-          }
-        }
-      })
-    }
+    Object.keys(search).forEach((key) => {
+      const val = search[key]
+      if (typeof val === 'undefined' || val === undefined) {
+        delete search[key]
+      } else {
+        search[key] = stringifyValue(val)
+      }
+    })
 
     const searchStr = encode(search as Record<string, string>).toString()
 
     return searchStr ? `?${searchStr}` : ''
   }
 }
+
+export type SearchSerializer = (searchObj: Record<string, any>) => string
+export type SearchParser = (searchStr: string) => Record<string, any>

package/src/serializer.ts

@@ -0,0 +1,24 @@
+export interface StartSerializer {
+  stringify: (obj: unknown) => string
+  parse: (str: string) => unknown
+  encode: <T>(value: T) => T
+  decode: <T>(value: T) => T
+}
+
+export type SerializerStringifyBy<T, TSerializable> = T extends TSerializable
+  ? T
+  : T extends (...args: Array<any>) => any
+    ? 'Function is not serializable'
+    : { [K in keyof T]: SerializerStringifyBy<T[K], TSerializable> }
+
+export type SerializerParseBy<T, TSerializable> = T extends TSerializable
+  ? T
+  : T extends React.JSX.Element
+    ? ReadableStream
+    : { [K in keyof T]: SerializerParseBy<T[K], TSerializable> }
+
+export type Serializable = Date | undefined | Error | FormData
+
+export type SerializerStringify<T> = SerializerStringifyBy<T, Serializable>
+
+export type SerializerParse<T> = SerializerParseBy<T, Serializable>

package/src/structuralSharing.ts

@@ -0,0 +1,7 @@
+import type { Constrain } from './utils'
+
+export interface OptionalStructuralSharing<TStructuralSharing, TConstraint> {
+  readonly structuralSharing?:
+    | Constrain<TStructuralSharing, TConstraint>
+    | undefined
+}

package/src/utils.ts

@@ -1,50 +1,81 @@
 export type NoInfer<T> = [T][T extends any ? 0 : never]
-export type IsAny<T, Y, N> = 1 extends 0 & T ? Y : N
-export type IsAnyBoolean<T> = 1 extends 0 & T ? true : false
-export type IsKnown<T, Y, N> = unknown extends T ? N : Y
-export type PickAsRequired<T, K extends keyof T> = Omit<T, K> &
-  Required<Pick<T, K>>
-export type PickAsPartial<T, K extends keyof T> = Omit<T, K> &
-  Partial<Pick<T, K>>
-export type PickUnsafe<T, K> = K extends keyof T ? Pick<T, K> : never
-export type PickExtra<T, K> = Expand<{
-  [TKey in keyof K as string extends TKey
-    ? never
-    : TKey extends keyof T
-    ? never
-    : TKey]: K[TKey]
-}>
+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 extends object
   ? T extends infer O
-    ? { [K in keyof O]: O[K] }
+    ? O extends Function
+      ? O
+      : { [K in keyof O]: O[K] }
     : never
   : T
 
-// type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (
-//   k: infer I,
-// ) => any
-//   ? I
-//   : never
+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]
+}
 
-export type Values<O> = O[ValueKeys<O>]
-export type ValueKeys<O> = Extract<keyof O, PropertyKey>
+// 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 DeepAwaited<T> = T extends Promise<infer A>
-  ? DeepAwaited<A>
-  : T extends Record<infer A, Promise<infer B>>
-  ? { [K in A]: DeepAwaited<B> }
-  : T
+export type IsNonEmptyObject<T> = T extends object
+  ? keyof T extends never
+    ? false
+    : true
+  : false
 
-export type PathParamMask<TRoutePath extends string> =
-  TRoutePath extends `${infer L}/:${infer C}/${infer R}`
-    ? PathParamMask<`${L}/${string}/${R}`>
-    : TRoutePath extends `${infer L}/:${infer C}`
-    ? PathParamMask<`${L}/${string}`>
-    : TRoutePath
+export type Assign<TLeft, TRight> = TLeft extends any
+  ? TRight extends any
+    ? IsNonEmptyObject<TLeft> extends false
+      ? TRight
+      : IsNonEmptyObject<TRight> extends false
+        ? TLeft
+        : keyof TLeft & keyof TRight extends never
+          ? TLeft & TRight
+          : Omit<TLeft, keyof TRight> & TRight
+    : never
+  : never
+
+export type IntersectAssign<TLeft, TRight> = TLeft extends any
+  ? TRight extends any
+    ? IsNonEmptyObject<TLeft> extends false
+      ? TRight
+      : IsNonEmptyObject<TRight> extends false
+        ? TLeft
+        : TRight & TLeft
+    : never
+  : never
 
 export type Timeout = ReturnType<typeof setTimeout>
 
@@ -52,50 +83,165 @@ export type Updater<TPrevious, TResult = TPrevious> =
   | TResult
   | ((prev?: TPrevious) => TResult)
 
-export type PickExtract<T, U> = {
-  [K in keyof T as T[K] extends U ? K : never]: T[K]
+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 type PickExclude<T, U> = {
-  [K in keyof T as T[K] extends U ? never : K]: T[K]
+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 `a` if `b` is deeply equal.
+ * 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 JSON values for example.
+ * This can be used for structural sharing between immutable JSON values for example.
+ * Do not use this with signals
  */
-export function replaceEqualDeep(prev: any, next: any) {
-  if (prev === next) {
+export function replaceEqualDeep<T>(prev: any, _next: T): T {
+  if (prev === _next) {
     return prev
   }
 
-  const array = Array.isArray(prev) && Array.isArray(next)
+  const next = _next as any
+
+  const array = isPlainArray(prev) && isPlainArray(next)
 
   if (array || (isPlainObject(prev) && isPlainObject(next))) {
-    const aSize = array ? prev.length : Object.keys(prev).length
-    const bItems = array ? next : Object.keys(next)
-    const bSize = bItems.length
+    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 < bSize; i++) {
-      const key = array ? i : bItems[i]
-      copy[key] = replaceEqualDeep(prev[key], next[key])
-      if (copy[key] === prev[key]) {
+    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 aSize === bSize && equalItems === aSize ? prev : copy
+    return prevSize === nextSize && equalItems === prevSize ? prev : copy
   }
 
   return next
 }
 
 // Copied from: https://github.com/jonschlinkert/is-plain-object
-function isPlainObject(o: any) {
+export function isPlainObject(o: any) {
   if (!hasObjectPrototype(o)) {
     return false
   }
@@ -125,40 +271,133 @@ function hasObjectPrototype(o: any) {
   return Object.prototype.toString.call(o) === '[object Object]'
 }
 
-export function last<T>(arr: T[]) {
-  return arr[arr.length - 1]
+export function isPlainArray(value: unknown): value is Array<unknown> {
+  return Array.isArray(value) && value.length === Object.keys(value).length
 }
 
-export function warning(cond: any, message: string): cond is true {
-  if (cond) {
-    if (typeof console !== 'undefined') console.warn(message)
+function getObjectKeys(obj: any, ignoreUndefined: boolean) {
+  let keys = Object.keys(obj)
+  if (ignoreUndefined) {
+    keys = keys.filter((key) => obj[key] !== undefined)
+  }
+  return keys
+}
 
-    try {
-      throw new Error(message)
-    } catch {}
+export function deepEqual(
+  a: any,
+  b: any,
+  opts?: { partial?: boolean; ignoreUndefined?: boolean },
+): boolean {
+  if (a === b) {
+    return true
   }
 
-  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
 }
 
-function isFunction(d: any): d is Function {
-  return typeof d === 'function'
+export type StringLiteral<T> = T extends string
+  ? string extends T
+    ? string
+    : T
+  : never
+
+export type ThrowOrOptional<T, TThrow extends boolean> = TThrow extends true
+  ? T
+  : T | undefined
+
+export type ControlledPromise<T> = Promise<T> & {
+  resolve: (value: T) => void
+  reject: (value: any) => void
+  status: 'pending' | 'resolved' | 'rejected'
+  value?: T
 }
 
-export function functionalUpdate<TResult>(
-  updater: Updater<TResult>,
-  previous: TResult,
-) {
-  if (isFunction(updater)) {
-    return updater(previous as TResult)
+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)
   }
 
-  return updater
+  controlledPromise.reject = (e) => {
+    controlledPromise.status = 'rejected'
+    rejectLoadPromise(e)
+  }
+
+  return controlledPromise
 }
 
-export function pick<T, K extends keyof T>(parent: T, keys: K[]): Pick<T, K> {
-  return keys.reduce((obj: any, key: K) => {
-    obj[key] = parent[key]
-    return obj
-  }, {} as any)
+/**
+ *
+ * @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 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
 }