@tanstack/react-router 1.20.0 → 1.20.3-alpha.1

package/src/utils.ts

@@ -1,334 +1,119 @@
 import * as React from 'react'
 
-export type NoInfer<T> = [T][T extends any ? 0 : never]
-export type IsAny<T, Y, N = T> = 1 extends 0 & T ? Y : N
-export type PickAsRequired<T, K extends keyof T> = Omit<T, K> &
-  Required<Pick<T, K>>
-
-export type PickRequired<T> = {
-  [K in keyof T as undefined extends T[K] ? never : K]: T[K]
-}
-
-// from https://stackoverflow.com/a/76458160
-export type WithoutEmpty<T> = T extends T ? ({} extends T ? never : T) : never
-
-// export type Expand<T> = T
-export type Expand<T> = T extends object
-  ? T extends infer O
-    ? { [K in keyof O]: O[K] }
-    : never
-  : T
-
-export type UnionToIntersection<U> = (
-  U extends any ? (k: U) => void : never
-) extends (k: infer I) => any
-  ? I
-  : never
-
-export type DeepOptional<T, K extends keyof T> = Pick<DeepPartial<T>, K> &
-  Omit<T, K>
-
-export type DeepPartial<T> = T extends object
-  ? {
-      [P in keyof T]?: DeepPartial<T[P]>
-    }
-  : T
-
-export type MakeDifferenceOptional<T, U> = Omit<U, keyof T> &
-  Partial<Pick<U, keyof T & keyof U>> &
-  PickRequired<Omit<U, keyof PickRequired<T>>>
-
-// from https://stackoverflow.com/a/53955431
-export type IsUnion<T, U extends T = T> = (
-  T extends any ? (U extends T ? false : true) : never
-) extends false
-  ? false
-  : true
-
-// type Compute<T> = { [K in keyof T]: T[K] } | never
-
-// type AllKeys<T> = T extends any ? keyof T : never
-
-// export type MergeUnion<T, Keys extends keyof T = keyof T> = Compute<
-//   {
-//     [K in Keys]: T[Keys]
-//   } & {
-//     [K in AllKeys<T>]?: T extends any
-//       ? K extends keyof T
-//         ? T[K]
-//         : never
-//       : never
-//   }
-// >
-
-export type Assign<Left, Right> = Omit<Left, keyof Right> & Right
-
-export type AssignAll<T extends any[]> = T extends [infer Left, ...infer Right]
-  ? Right extends any[]
-    ? Assign<Left, AssignAll<Right>>
-    : Left
-  : {}
-
-// // Sample types to merge
-// type TypeA = {
-//   shared: string
-//   onlyInA: string
-//   nested: {
-//     shared: string
-//     aProp: string
-//   }
-//   array: string[]
-// }
-
-// type TypeB = {
-//   shared: number
-//   onlyInB: number
-//   nested: {
-//     shared: number
-//     bProp: number
-//   }
-//   array: number[]
-// }
-
-// type TypeC = {
-//   shared: boolean
-//   onlyInC: boolean
-//   nested: {
-//     shared: boolean
-//     cProp: boolean
-//   }
-//   array: boolean[]
-// }
-
-// type Test = Expand<Assign<TypeA, TypeB>>
-
-// // Using DeepMerge to merge TypeA and TypeB
-// type MergedType = Expand<AssignAll<[TypeA, TypeB, TypeC]>>
-
-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)
-
-// from https://github.com/type-challenges/type-challenges/issues/737
-type LastInUnion<U> =
-  UnionToIntersection<U extends unknown ? (x: U) => 0 : never> extends (
-    x: infer L,
-  ) => 0
-    ? L
-    : never
-export type UnionToTuple<U, Last = LastInUnion<U>> = [U] extends [never]
-  ? []
-  : [...UnionToTuple<Exclude<U, Last>>, Last]
-
-//
-
-export const isServer = typeof document === 'undefined'
-
-export function last<T>(arr: T[]) {
-  return arr[arr.length - 1]
-}
-
-function isFunction(d: any): d is Function {
-  return typeof d === 'function'
-}
-
-export function functionalUpdate<TResult>(
-  updater: Updater<TResult> | NonNullableUpdater<TResult>,
-  previous: TResult,
-): TResult {
-  if (isFunction(updater)) {
-    return updater(previous as TResult)
-  }
+export function useStableCallback<T extends (...args: Array<any>) => any>(
+  fn: T,
+): T {
+  const fnRef = React.useRef(fn)
+  fnRef.current = fn
 
-  return updater
+  const ref = React.useRef((...args: Array<any>) => fnRef.current(...args))
+  return ref.current as T
 }
 
-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)
-}
+export const useLayoutEffect =
+  typeof window !== 'undefined' ? React.useLayoutEffect : React.useEffect
 
 /**
- * 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
+ * Taken from https://www.developerway.com/posts/implementing-advanced-use-previous-hook#part3
  */
-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]
-      if (
-        !array &&
-        prev[key] === undefined &&
-        next[key] === undefined &&
-        prevItems.includes(key)
-      ) {
-        copy[key] = undefined
-        equalItems++
-      } else {
-        copy[key] = replaceEqualDeep(prev[key], next[key])
-        if (copy[key] === prev[key] && prev[key] !== undefined) {
-          equalItems++
-        }
-      }
+export function usePrevious<T>(value: T): T | null {
+  // initialise the ref with previous and current values
+  const ref = React.useRef<{ value: T; prev: T | null }>({
+    value: value,
+    prev: null,
+  })
+
+  const current = ref.current.value
+
+  // if the value passed into hook doesn't match what we store as "current"
+  // move the "current" to the "previous"
+  // and store the passed value as "current"
+  if (value !== current) {
+    ref.current = {
+      value: value,
+      prev: current,
     }
-
-    return prevSize === nextSize && equalItems === prevSize ? prev : copy
   }
 
-  return next
+  // return the previous value only
+  return ref.current.prev
 }
 
-// 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) {
-  return Array.isArray(value) && value.length === Object.keys(value).length
-}
-
-export function deepEqual(a: any, b: any, partial: boolean = false): boolean {
-  if (a === b) {
-    return true
-  }
-
-  if (typeof a !== typeof b) {
-    return false
-  }
-
-  if (isPlainObject(a) && isPlainObject(b)) {
-    const aKeys = Object.keys(a)
-    const bKeys = Object.keys(b)
-
-    if (!partial && aKeys.length !== bKeys.length) {
-      return false
-    }
-
-    return !bKeys.some(
-      (key) => !(key in a) || !deepEqual(a[key], b[key], partial),
-    )
-  }
-
-  if (Array.isArray(a) && Array.isArray(b)) {
-    return !a.some((item, index) => !deepEqual(item, b[index], partial))
-  }
-
-  return false
-}
-
-export function useStableCallback<T extends (...args: any[]) => any>(fn: T): T {
-  const fnRef = React.useRef(fn)
-  fnRef.current = fn
-
-  const ref = React.useRef((...args: any[]) => fnRef.current(...args))
-  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 (let i = 0; i < keysA.length; i++) {
+/**
+ * React hook to wrap `IntersectionObserver`.
+ *
+ * This hook will create an `IntersectionObserver` and observe the ref passed to it.
+ *
+ * When the intersection changes, the callback will be called with the `IntersectionObserverEntry`.
+ *
+ * @param ref - The ref to observe
+ * @param intersectionObserverOptions - The options to pass to the IntersectionObserver
+ * @param options - The options to pass to the hook
+ * @param callback - The callback to call when the intersection changes
+ * @returns The IntersectionObserver instance
+ * @example
+ * ```tsx
+ * const MyComponent = () => {
+ * const ref = React.useRef<HTMLDivElement>(null)
+ * useIntersectionObserver(
+ *  ref,
+ *  (entry) => { doSomething(entry) },
+ *  { rootMargin: '10px' },
+ *  { disabled: false }
+ * )
+ * return <div ref={ref} />
+ * ```
+ */
+export function useIntersectionObserver<T extends Element>(
+  ref: React.RefObject<T | null>,
+  callback: (entry: IntersectionObserverEntry | undefined) => void,
+  intersectionObserverOptions: IntersectionObserverInit = {},
+  options: { disabled?: boolean } = {},
+): IntersectionObserver | null {
+  const isIntersectionObserverAvailable = React.useRef(
+    typeof IntersectionObserver === 'function',
+  )
+
+  const observerRef = React.useRef<IntersectionObserver | null>(null)
+
+  React.useEffect(() => {
     if (
-      !Object.prototype.hasOwnProperty.call(objB, keysA[i] as string) ||
-      !Object.is(objA[keysA[i] as keyof T], objB[keysA[i] as keyof T])
+      !ref.current ||
+      !isIntersectionObserverAvailable.current ||
+      options.disabled
     ) {
-      return false
+      return
     }
-  }
-  return true
-}
 
-export type StringLiteral<T> = T extends string
-  ? string extends T
-    ? string
-    : T
-  : never
+    observerRef.current = new IntersectionObserver(([entry]) => {
+      callback(entry)
+    }, intersectionObserverOptions)
 
-export type StrictOrFrom<TFrom, TReturnIntersection extends boolean = false> =
-  | {
-      from: StringLiteral<TFrom> | TFrom
-      strict?: true
-    }
-  | {
-      from?: never
-      strict: false
-      experimental_returnIntersection?: TReturnIntersection
+    observerRef.current.observe(ref.current)
+
+    return () => {
+      observerRef.current?.disconnect()
     }
+  }, [callback, intersectionObserverOptions, options.disabled, ref])
 
-export const useLayoutEffect =
-  typeof window !== 'undefined' ? React.useLayoutEffect : React.useEffect
+  return observerRef.current
+}
 
-export function escapeJSON(jsonString: string) {
-  return jsonString
-    .replace(/\\/g, '\\\\') // Escape backslashes
-    .replace(/'/g, "\\'") // Escape single quotes
-    .replace(/"/g, '\\"') // Escape double quotes
+/**
+ * React hook to take a `React.ForwardedRef` and returns a `ref` that can be used on a DOM element.
+ *
+ * @param ref - The forwarded ref
+ * @returns The inner ref returned by `useRef`
+ * @example
+ * ```tsx
+ * const MyComponent = React.forwardRef((props, ref) => {
+ *  const innerRef = useForwardedRef(ref)
+ *  return <div ref={innerRef} />
+ * })
+ * ```
+ */
+export function useForwardedRef<T>(ref?: React.ForwardedRef<T>) {
+  const innerRef = React.useRef<T>(null)
+  React.useImperativeHandle(ref, () => innerRef.current!, [])
+  return innerRef
 }

package/dist/cjs/createServerFn.cjs

@@ -1,40 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const invariant = require("tiny-invariant");
-const serverFnReturnTypeHeader = "server-fn-return-type";
-const serverFnPayloadTypeHeader = "server-fn-payload-type";
-function createServerFn(method, fn) {
-  const compiledFn = fn;
-  invariant(
-    compiledFn.url,
-    `createServerFn must be called with a function that is marked with the 'use server' pragma.`
-  );
-  return Object.assign(
-    async (payload, opts) => {
-      return compiledFn({
-        method,
-        payload: payload || void 0,
-        requestInit: opts == null ? void 0 : opts.requestInit
-      });
-    },
-    {
-      url: fn.url
-    }
-  );
-}
-function json(payload, opts) {
-  return new Response(JSON.stringify(payload), {
-    status: (opts == null ? void 0 : opts.status) || 200,
-    statusText: (opts == null ? void 0 : opts.statusText) || (opts == null ? void 0 : opts.status) === 200 ? "OK" : "Error",
-    headers: {
-      "Content-Type": "application/json",
-      [serverFnReturnTypeHeader]: "json",
-      ...opts == null ? void 0 : opts.headers
-    }
-  });
-}
-exports.createServerFn = createServerFn;
-exports.json = json;
-exports.serverFnPayloadTypeHeader = serverFnPayloadTypeHeader;
-exports.serverFnReturnTypeHeader = serverFnReturnTypeHeader;
-//# sourceMappingURL=createServerFn.cjs.map

package/dist/cjs/createServerFn.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"createServerFn.cjs","sources":["../../src/createServerFn.ts"],"sourcesContent":["import invariant from 'tiny-invariant'\n\nexport const serverFnReturnTypeHeader = 'server-fn-return-type'\nexport const serverFnPayloadTypeHeader = 'server-fn-payload-type'\n\nexport interface JsonResponse<TData> extends Response {\n  json(): Promise<TData>\n}\n\nexport type FetcherOptionsBase = {\n  method?: 'GET' | 'POST'\n}\n\nexport type FetcherOptions = FetcherOptionsBase & {\n  requestInit?: RequestInit\n}\n\nexport type FetchFnCtx = {\n  method: 'GET' | 'POST'\n  request: Request\n}\n\nexport type FetchFn<TPayload, TResponse> = {\n  (payload: TPayload, ctx: FetchFnCtx): Promise<TResponse> | TResponse\n  url?: string\n}\n\nexport type CompiledFetcherFnOptions<TPayload> = {\n  method: 'GET' | 'POST'\n  payload: TPayload | undefined\n  requestInit?: RequestInit\n}\n\nexport type CompiledFetcherFn<TPayload, TResponse> = {\n  (opts: CompiledFetcherFnOptions<TPayload>): Promise<TResponse>\n  url: string\n}\n\ntype IsPayloadOptional<T> = [T] extends [undefined] ? true : false\n\nexport type Fetcher<TPayload, TResponse> =\n  (IsPayloadOptional<TPayload> extends true\n    ? {\n        (\n          payload?: TPayload,\n          opts?: FetcherOptions,\n        ): Promise<JsonResponseOrPayload<TResponse>>\n      }\n    : {\n        (\n          payload: TPayload,\n          opts?: FetcherOptions,\n        ): Promise<JsonResponseOrPayload<TResponse>>\n      }) & {\n    url: string\n  }\n\nexport type JsonResponseOrPayload<TResponse> =\n  TResponse extends JsonResponse<infer TData> ? TData : TResponse\n\nexport function createServerFn<\n  TPayload extends any = undefined,\n  TResponse = unknown,\n>(\n  method: 'GET' | 'POST',\n  fn: FetchFn<TPayload, TResponse>,\n): Fetcher<TPayload, TResponse> {\n  // Cast the compiled function that will be injected by vinxi\n  const compiledFn = fn as unknown as CompiledFetcherFn<TPayload, TResponse>\n\n  invariant(\n    compiledFn.url,\n    `createServerFn must be called with a function that is marked with the 'use server' pragma.`,\n  )\n\n  return Object.assign(\n    async (payload: TPayload, opts?: FetcherOptions) => {\n      return compiledFn({\n        method,\n        payload: payload || undefined,\n        requestInit: opts?.requestInit,\n      })\n    },\n    {\n      url: fn.url!,\n    },\n  ) as Fetcher<TPayload, TResponse>\n}\n\nexport function json<TData>(\n  payload: TData,\n  opts?: {\n    status?: number\n    statusText?: string\n    headers?: HeadersInit\n  },\n): JsonResponse<TData> {\n  return new Response(JSON.stringify(payload), {\n    status: opts?.status || 200,\n    statusText: opts?.statusText || opts?.status === 200 ? 'OK' : 'Error',\n    headers: {\n      'Content-Type': 'application/json',\n      [serverFnReturnTypeHeader]: 'json',\n      ...opts?.headers,\n    },\n  })\n}\n"],"names":[],"mappings":";;;AAEO,MAAM,2BAA2B;AACjC,MAAM,4BAA4B;AAyDzB,SAAA,eAId,QACA,IAC8B;AAE9B,QAAM,aAAa;AAEnB;AAAA,IACE,WAAW;AAAA,IACX;AAAA,EAAA;AAGF,SAAO,OAAO;AAAA,IACZ,OAAO,SAAmB,SAA0B;AAClD,aAAO,WAAW;AAAA,QAChB;AAAA,QACA,SAAS,WAAW;AAAA,QACpB,aAAa,6BAAM;AAAA,MAAA,CACpB;AAAA,IACH;AAAA,IACA;AAAA,MACE,KAAK,GAAG;AAAA,IACV;AAAA,EAAA;AAEJ;AAEgB,SAAA,KACd,SACA,MAKqB;AACrB,SAAO,IAAI,SAAS,KAAK,UAAU,OAAO,GAAG;AAAA,IAC3C,SAAQ,6BAAM,WAAU;AAAA,IACxB,aAAY,6BAAM,gBAAc,6BAAM,YAAW,MAAM,OAAO;AAAA,IAC9D,SAAS;AAAA,MACP,gBAAgB;AAAA,MAChB,CAAC,wBAAwB,GAAG;AAAA,MAC5B,GAAG,6BAAM;AAAA,IACX;AAAA,EAAA,CACD;AACH;;;;;"}

package/dist/cjs/createServerFn.d.cts

@@ -1,44 +0,0 @@
-export declare const serverFnReturnTypeHeader = "server-fn-return-type";
-export declare const serverFnPayloadTypeHeader = "server-fn-payload-type";
-export interface JsonResponse<TData> extends Response {
-    json(): Promise<TData>;
-}
-export type FetcherOptionsBase = {
-    method?: 'GET' | 'POST';
-};
-export type FetcherOptions = FetcherOptionsBase & {
-    requestInit?: RequestInit;
-};
-export type FetchFnCtx = {
-    method: 'GET' | 'POST';
-    request: Request;
-};
-export type FetchFn<TPayload, TResponse> = {
-    (payload: TPayload, ctx: FetchFnCtx): Promise<TResponse> | TResponse;
-    url?: string;
-};
-export type CompiledFetcherFnOptions<TPayload> = {
-    method: 'GET' | 'POST';
-    payload: TPayload | undefined;
-    requestInit?: RequestInit;
-};
-export type CompiledFetcherFn<TPayload, TResponse> = {
-    (opts: CompiledFetcherFnOptions<TPayload>): Promise<TResponse>;
-    url: string;
-};
-type IsPayloadOptional<T> = [T] extends [undefined] ? true : false;
-export type Fetcher<TPayload, TResponse> = (IsPayloadOptional<TPayload> extends true ? {
-    (payload?: TPayload, opts?: FetcherOptions): Promise<JsonResponseOrPayload<TResponse>>;
-} : {
-    (payload: TPayload, opts?: FetcherOptions): Promise<JsonResponseOrPayload<TResponse>>;
-}) & {
-    url: string;
-};
-export type JsonResponseOrPayload<TResponse> = TResponse extends JsonResponse<infer TData> ? TData : TResponse;
-export declare function createServerFn<TPayload extends any = undefined, TResponse = unknown>(method: 'GET' | 'POST', fn: FetchFn<TPayload, TResponse>): Fetcher<TPayload, TResponse>;
-export declare function json<TData>(payload: TData, opts?: {
-    status?: number;
-    statusText?: string;
-    headers?: HeadersInit;
-}): JsonResponse<TData>;
-export {};

package/dist/cjs/defer.cjs

@@ -1,30 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const router = require("./router.cjs");
-function defer(_promise, options) {
-  const promise = _promise;
-  if (!promise.__deferredState) {
-    promise.__deferredState = {
-      uid: Math.random().toString(36).slice(2),
-      status: "pending"
-    };
-    const state = promise.__deferredState;
-    promise.then((data) => {
-      state.status = "success";
-      state.data = data;
-    }).catch((error) => {
-      state.status = "error";
-      state.error = {
-        data: ((options == null ? void 0 : options.serializeError) ?? router.defaultSerializeError)(error),
-        __isServerError: true
-      };
-    });
-  }
-  return promise;
-}
-function isDehydratedDeferred(obj) {
-  return typeof obj === "object" && obj !== null && !(obj instanceof Promise) && !obj.then && "__deferredState" in obj;
-}
-exports.defer = defer;
-exports.isDehydratedDeferred = isDehydratedDeferred;
-//# sourceMappingURL=defer.cjs.map

package/dist/cjs/defer.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"defer.cjs","sources":["../../src/defer.ts"],"sourcesContent":["import { defaultSerializeError } from './router'\n\nexport type DeferredPromiseState<T> = {\n  uid: string\n  resolve?: () => void\n  promise?: Promise<void>\n  __resolvePromise?: () => void\n} & (\n  | {\n      status: 'pending'\n      data?: T\n      error?: unknown\n    }\n  | {\n      status: 'success'\n      data: T\n    }\n  | {\n      status: 'error'\n      data?: T\n      error: unknown\n    }\n)\n\nexport type DeferredPromise<T> = Promise<T> & {\n  __deferredState: DeferredPromiseState<T>\n}\n\nexport function defer<T>(\n  _promise: Promise<T>,\n  options?: {\n    serializeError?: typeof defaultSerializeError\n  },\n) {\n  const promise = _promise as DeferredPromise<T>\n\n  if (!promise.__deferredState) {\n    promise.__deferredState = {\n      uid: Math.random().toString(36).slice(2),\n      status: 'pending',\n    }\n\n    const state = promise.__deferredState\n\n    promise\n      .then((data) => {\n        state.status = 'success' as any\n        state.data = data\n      })\n      .catch((error) => {\n        state.status = 'error' as any\n        state.error = {\n          data: (options?.serializeError ?? defaultSerializeError)(error),\n          __isServerError: true,\n        }\n      })\n  }\n\n  return promise\n}\n\nexport function isDehydratedDeferred(obj: any): boolean {\n  return (\n    typeof obj === 'object' &&\n    obj !== null &&\n    !(obj instanceof Promise) &&\n    !obj.then &&\n    '__deferredState' in obj\n  )\n}\n"],"names":["defaultSerializeError"],"mappings":";;;AA4BgB,SAAA,MACd,UACA,SAGA;AACA,QAAM,UAAU;AAEZ,MAAA,CAAC,QAAQ,iBAAiB;AAC5B,YAAQ,kBAAkB;AAAA,MACxB,KAAK,KAAK,OAAO,EAAE,SAAS,EAAE,EAAE,MAAM,CAAC;AAAA,MACvC,QAAQ;AAAA,IAAA;AAGV,UAAM,QAAQ,QAAQ;AAGnB,YAAA,KAAK,CAAC,SAAS;AACd,YAAM,SAAS;AACf,YAAM,OAAO;AAAA,IAAA,CACd,EACA,MAAM,CAAC,UAAU;AAChB,YAAM,SAAS;AACf,YAAM,QAAQ;AAAA,QACZ,QAAO,mCAAS,mBAAkBA,OAAAA,uBAAuB,KAAK;AAAA,QAC9D,iBAAiB;AAAA,MAAA;AAAA,IACnB,CACD;AAAA,EACL;AAEO,SAAA;AACT;AAEO,SAAS,qBAAqB,KAAmB;AAEpD,SAAA,OAAO,QAAQ,YACf,QAAQ,QACR,EAAE,eAAe,YACjB,CAAC,IAAI,QACL,qBAAqB;AAEzB;;;"}

package/dist/cjs/defer.d.cts

@@ -1,25 +0,0 @@
-import { defaultSerializeError } from './router.cjs';
-export type DeferredPromiseState<T> = {
-    uid: string;
-    resolve?: () => void;
-    promise?: Promise<void>;
-    __resolvePromise?: () => void;
-} & ({
-    status: 'pending';
-    data?: T;
-    error?: unknown;
-} | {
-    status: 'success';
-    data: T;
-} | {
-    status: 'error';
-    data?: T;
-    error: unknown;
-});
-export type DeferredPromise<T> = Promise<T> & {
-    __deferredState: DeferredPromiseState<T>;
-};
-export declare function defer<T>(_promise: Promise<T>, options?: {
-    serializeError?: typeof defaultSerializeError;
-}): DeferredPromise<T>;
-export declare function isDehydratedDeferred(obj: any): boolean;

package/dist/cjs/location.d.cts

@@ -1,12 +0,0 @@
-import { HistoryState } from '@tanstack/history';
-import { AnySearchSchema } from './route.cjs';
-export interface ParsedLocation<TSearchObj extends AnySearchSchema = {}> {
-    href: string;
-    pathname: string;
-    search: TSearchObj;
-    searchStr: string;
-    state: HistoryState;
-    hash: string;
-    maskedLocation?: ParsedLocation<TSearchObj>;
-    unmaskOnReload?: boolean;
-}