@tanstack/react-router 1.97.20 → 1.97.23

package/src/qss.ts

@@ -1,91 +0,0 @@
-/**
- * Program uses a modified version of the `qss` package:
- * Copyright (c) Luke Edwards luke.edwards05@gmail.com, MIT License
- * https://github.com/lukeed/qss/blob/master/license.md
- */
-
-/**
- * Encodes an object into a query string.
- * @param obj - The object to encode into a query string.
- * @param [pfx] - An optional prefix to add before the query string.
- * @returns The encoded query string.
- * @example
- * ```
- * // Example input: encode({ token: 'foo', key: 'value' })
- * // Expected output: "token=foo&key=value"
- * ```
- */
-export function encode(obj: any, pfx?: string) {
-  let k,
-    i,
-    tmp,
-    str = ''
-
-  for (k in obj) {
-    if ((tmp = obj[k]) !== void 0) {
-      if (Array.isArray(tmp)) {
-        for (i = 0; i < tmp.length; i++) {
-          str && (str += '&')
-          str += encodeURIComponent(k) + '=' + encodeURIComponent(tmp[i])
-        }
-      } else {
-        str && (str += '&')
-        str += encodeURIComponent(k) + '=' + encodeURIComponent(tmp)
-      }
-    }
-  }
-
-  return (pfx || '') + str
-}
-
-/**
- * Converts a string value to its appropriate type (string, number, boolean).
- * @param mix - The string value to convert.
- * @returns The converted value.
- * @example
- * // Example input: toValue("123")
- * // Expected output: 123
- */
-function toValue(mix: any) {
-  if (!mix) return ''
-  const str = decodeURIComponent(mix)
-  if (str === 'false') return false
-  if (str === 'true') return true
-  return +str * 0 === 0 && +str + '' === str ? +str : str
-}
-
-/**
- * Decodes a query string into an object.
- * @param str - The query string to decode.
- * @param [pfx] - An optional prefix to filter out from the query string.
- * @returns The decoded key-value pairs in an object format.
- * @example
- * // Example input: decode("token=foo&key=value")
- * // Expected output: { "token": "foo", "key": "value" }
- */
-export function decode(str: any, pfx?: string) {
-  let tmp, k
-  const out: any = {},
-    arr = (pfx ? str.substr(pfx.length) : str).split('&')
-
-  while ((tmp = arr.shift())) {
-    const equalIndex = tmp.indexOf('=')
-    if (equalIndex !== -1) {
-      k = tmp.slice(0, equalIndex)
-      k = decodeURIComponent(k)
-      const value = tmp.slice(equalIndex + 1)
-      if (out[k] !== void 0) {
-        // @ts-expect-error
-        out[k] = [].concat(out[k], toValue(value))
-      } else {
-        out[k] = toValue(value)
-      }
-    } else {
-      k = tmp
-      k = decodeURIComponent(k)
-      out[k] = ''
-    }
-  }
-
-  return out
-}

package/src/root.ts

@@ -1,2 +0,0 @@
-export const rootRouteId = '__root__'
-export type RootRouteId = typeof rootRouteId

package/src/searchMiddleware.ts

@@ -1,54 +0,0 @@
-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,77 +0,0 @@
-import { decode, encode } from './qss'
-import type { AnySchema } from './validators'
-
-export const defaultParseSearch = parseSearchWith(JSON.parse)
-export const defaultStringifySearch = stringifySearchWith(
-  JSON.stringify,
-  JSON.parse,
-)
-
-export function parseSearchWith(parser: (str: string) => any) {
-  return (searchStr: string): AnySchema => {
-    if (searchStr.substring(0, 1) === '?') {
-      searchStr = searchStr.substring(1)
-    }
-
-    const query: Record<string, unknown> = decode(searchStr)
-
-    // Try to parse any query params that might be json
-    for (const key in query) {
-      const value = query[key]
-      if (typeof value === 'string') {
-        try {
-          query[key] = parser(value)
-        } catch (err) {
-          //
-        }
-      }
-    }
-
-    return query
-  }
-}
-
-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 }
-
-    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

@@ -1,24 +0,0 @@
-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/validators.ts

@@ -1,121 +0,0 @@
-import type { SearchSchemaInput } from './route'
-
-export interface StandardSchemaValidatorProps<TInput, TOutput> {
-  readonly types?: StandardSchemaValidatorTypes<TInput, TOutput> | undefined
-  readonly validate: AnyStandardSchemaValidate
-}
-
-export interface StandardSchemaValidator<TInput, TOutput> {
-  readonly '~standard': StandardSchemaValidatorProps<TInput, TOutput>
-}
-
-export type AnyStandardSchemaValidator = StandardSchemaValidator<any, any>
-
-export interface StandardSchemaValidatorTypes<TInput, TOutput> {
-  readonly input: TInput
-  readonly output: TOutput
-}
-
-export interface AnyStandardSchemaValidateSuccess {
-  readonly value: any
-  readonly issues?: undefined
-}
-
-export interface AnyStandardSchemaValidateFailure {
-  readonly issues: ReadonlyArray<AnyStandardSchemaValidateIssue>
-}
-
-export interface AnyStandardSchemaValidateIssue {
-  readonly message: string
-}
-
-export interface AnyStandardSchemaValidateInput {
-  readonly value: any
-}
-
-export type AnyStandardSchemaValidate = (
-  value: unknown,
-) =>
-  | (AnyStandardSchemaValidateSuccess | AnyStandardSchemaValidateFailure)
-  | Promise<AnyStandardSchemaValidateSuccess | AnyStandardSchemaValidateFailure>
-
-export interface ValidatorObj<TInput, TOutput> {
-  parse: ValidatorFn<TInput, TOutput>
-}
-
-export type AnyValidatorObj = ValidatorObj<any, any>
-
-export interface ValidatorAdapter<TInput, TOutput> {
-  types: {
-    input: TInput
-    output: TOutput
-  }
-  parse: (input: unknown) => TOutput
-}
-
-export type AnyValidatorAdapter = ValidatorAdapter<any, any>
-
-export type AnyValidatorFn = ValidatorFn<any, any>
-
-export type ValidatorFn<TInput, TOutput> = (input: TInput) => TOutput
-
-export type Validator<TInput, TOutput> =
-  | ValidatorObj<TInput, TOutput>
-  | ValidatorFn<TInput, TOutput>
-  | ValidatorAdapter<TInput, TOutput>
-  | StandardSchemaValidator<TInput, TOutput>
-  | undefined
-
-export type AnyValidator = Validator<any, any>
-
-export type AnySchema = {}
-
-export type DefaultValidator = Validator<Record<string, unknown>, AnySchema>
-
-export type ResolveSearchValidatorInputFn<TValidator> = TValidator extends (
-  input: infer TSchemaInput,
-) => any
-  ? TSchemaInput extends SearchSchemaInput
-    ? Omit<TSchemaInput, keyof SearchSchemaInput>
-    : ResolveValidatorOutputFn<TValidator>
-  : AnySchema
-
-export type ResolveSearchValidatorInput<TValidator> =
-  TValidator extends AnyStandardSchemaValidator
-    ? NonNullable<TValidator['~standard']['types']>['input']
-    : TValidator extends AnyValidatorAdapter
-      ? TValidator['types']['input']
-      : TValidator extends AnyValidatorObj
-        ? ResolveSearchValidatorInputFn<TValidator['parse']>
-        : ResolveSearchValidatorInputFn<TValidator>
-
-export type ResolveValidatorInputFn<TValidator> = TValidator extends (
-  input: infer TInput,
-) => any
-  ? TInput
-  : undefined
-
-export type ResolveValidatorInput<TValidator> =
-  TValidator extends AnyStandardSchemaValidator
-    ? NonNullable<TValidator['~standard']['types']>['input']
-    : TValidator extends AnyValidatorAdapter
-      ? TValidator['types']['input']
-      : TValidator extends AnyValidatorObj
-        ? ResolveValidatorInputFn<TValidator['parse']>
-        : ResolveValidatorInputFn<TValidator>
-
-export type ResolveValidatorOutputFn<TValidator> = TValidator extends (
-  ...args: any
-) => infer TSchema
-  ? TSchema
-  : AnySchema
-
-export type ResolveValidatorOutput<TValidator> = unknown extends TValidator
-  ? TValidator
-  : TValidator extends AnyStandardSchemaValidator
-    ? NonNullable<TValidator['~standard']['types']>['output']
-    : TValidator extends AnyValidatorAdapter
-      ? TValidator['types']['output']
-      : TValidator extends AnyValidatorObj
-        ? ResolveValidatorOutputFn<TValidator['parse']>
-        : ResolveValidatorOutputFn<TValidator>