@tanstack/react-router 1.97.14 → 1.97.16

package/dist/esm/awaited.js

@@ -1,36 +1,15 @@
 import { jsx } from "react/jsx-runtime";
 import * as React from "react";
-import warning from "tiny-warning";
-import { useRouter } from "./useRouter.js";
-import { defaultSerializeError } from "./router.js";
 import { defer, TSR_DEFERRED_PROMISE } from "./defer.js";
-import { isServerSideError, defaultDeserializeError } from "./isServerSideError.js";
 function useAwaited({
   promise: _promise
 }) {
-  var _a, _b;
-  const router = useRouter();
   const promise = defer(_promise);
   if (promise[TSR_DEFERRED_PROMISE].status === "pending") {
     throw promise;
   }
   if (promise[TSR_DEFERRED_PROMISE].status === "error") {
-    if (typeof document !== "undefined") {
-      if (isServerSideError(promise[TSR_DEFERRED_PROMISE].error)) {
-        throw (((_a = router.options.errorSerializer) == null ? void 0 : _a.deserialize) ?? defaultDeserializeError)(promise[TSR_DEFERRED_PROMISE].error.data);
-      } else {
-        warning(
-          false,
-          "Encountered a server-side error that doesn't fit the expected shape"
-        );
-        throw promise[TSR_DEFERRED_PROMISE].error;
-      }
-    } else {
-      throw {
-        data: (((_b = router.options.errorSerializer) == null ? void 0 : _b.serialize) ?? defaultSerializeError)(promise[TSR_DEFERRED_PROMISE].error),
-        __isServerError: true
-      };
-    }
+    throw promise[TSR_DEFERRED_PROMISE].error;
   }
   return [promise[TSR_DEFERRED_PROMISE].data, promise];
 }

package/dist/esm/awaited.js.map

@@ -1 +1 @@
-{"version":3,"file":"awaited.js","sources":["../../src/awaited.tsx"],"sourcesContent":["import * as React from 'react'\nimport warning from 'tiny-warning'\nimport { useRouter } from './useRouter'\nimport { defaultSerializeError } from './router'\nimport { TSR_DEFERRED_PROMISE, defer } from './defer'\nimport { defaultDeserializeError, isServerSideError } from './isServerSideError'\nimport type { DeferredPromise } from './defer'\n\nexport type AwaitOptions<T> = {\n  promise: Promise<T>\n}\n\nexport function useAwaited<T>({\n  promise: _promise,\n}: AwaitOptions<T>): [T, DeferredPromise<T>] {\n  const router = useRouter()\n  const promise = defer(_promise)\n\n  if (promise[TSR_DEFERRED_PROMISE].status === 'pending') {\n    throw promise\n  }\n\n  if (promise[TSR_DEFERRED_PROMISE].status === 'error') {\n    if (typeof document !== 'undefined') {\n      if (isServerSideError(promise[TSR_DEFERRED_PROMISE].error)) {\n        throw (\n          router.options.errorSerializer?.deserialize ?? defaultDeserializeError\n        )(promise[TSR_DEFERRED_PROMISE].error.data as any)\n      } else {\n        warning(\n          false,\n          \"Encountered a server-side error that doesn't fit the expected shape\",\n        )\n        throw promise[TSR_DEFERRED_PROMISE].error\n      }\n    } else {\n      throw {\n        data: (\n          router.options.errorSerializer?.serialize ?? defaultSerializeError\n        )(promise[TSR_DEFERRED_PROMISE].error),\n        __isServerError: true,\n      }\n    }\n  }\n  return [promise[TSR_DEFERRED_PROMISE].data, promise]\n}\n\nexport function Await<T>(\n  props: AwaitOptions<T> & {\n    fallback?: React.ReactNode\n    children: (result: T) => React.ReactNode\n  },\n) {\n  const inner = <AwaitInner {...props} />\n  if (props.fallback) {\n    return <React.Suspense fallback={props.fallback}>{inner}</React.Suspense>\n  }\n  return inner\n}\n\nfunction AwaitInner<T>(\n  props: AwaitOptions<T> & {\n    fallback?: React.ReactNode\n    children: (result: T) => React.ReactNode\n  },\n): React.JSX.Element {\n  const [data] = useAwaited(props)\n\n  return props.children(data) as React.JSX.Element\n}\n"],"names":[],"mappings":";;;;;;;AAYO,SAAS,WAAc;AAAA,EAC5B,SAAS;AACX,GAA6C;;AAC3C,QAAM,SAAS,UAAU;AACnB,QAAA,UAAU,MAAM,QAAQ;AAE9B,MAAI,QAAQ,oBAAoB,EAAE,WAAW,WAAW;AAChD,UAAA;AAAA,EAAA;AAGR,MAAI,QAAQ,oBAAoB,EAAE,WAAW,SAAS;AAChD,QAAA,OAAO,aAAa,aAAa;AACnC,UAAI,kBAAkB,QAAQ,oBAAoB,EAAE,KAAK,GAAG;AAExD,iBAAA,YAAO,QAAQ,oBAAf,mBAAgC,gBAAe,yBAC/C,QAAQ,oBAAoB,EAAE,MAAM,IAAW;AAAA,MAAA,OAC5C;AACL;AAAA,UACE;AAAA,UACA;AAAA,QACF;AACM,cAAA,QAAQ,oBAAoB,EAAE;AAAA,MAAA;AAAA,IACtC,OACK;AACC,YAAA;AAAA,QACJ,SACE,YAAO,QAAQ,oBAAf,mBAAgC,cAAa,uBAC7C,QAAQ,oBAAoB,EAAE,KAAK;AAAA,QACrC,iBAAiB;AAAA,MACnB;AAAA,IAAA;AAAA,EACF;AAEF,SAAO,CAAC,QAAQ,oBAAoB,EAAE,MAAM,OAAO;AACrD;AAEO,SAAS,MACd,OAIA;AACA,QAAM,QAAQ,oBAAC,YAAY,EAAA,GAAG,MAAO,CAAA;AACrC,MAAI,MAAM,UAAU;AAClB,+BAAQ,MAAM,UAAN,EAAe,UAAU,MAAM,UAAW,UAAM,OAAA;AAAA,EAAA;AAEnD,SAAA;AACT;AAEA,SAAS,WACP,OAImB;AACnB,QAAM,CAAC,IAAI,IAAI,WAAW,KAAK;AAExB,SAAA,MAAM,SAAS,IAAI;AAC5B;"}
+{"version":3,"file":"awaited.js","sources":["../../src/awaited.tsx"],"sourcesContent":["import * as React from 'react'\n\nimport { TSR_DEFERRED_PROMISE, defer } from './defer'\nimport type { DeferredPromise } from './defer'\n\nexport type AwaitOptions<T> = {\n  promise: Promise<T>\n}\n\nexport function useAwaited<T>({\n  promise: _promise,\n}: AwaitOptions<T>): [T, DeferredPromise<T>] {\n  const promise = defer(_promise)\n\n  if (promise[TSR_DEFERRED_PROMISE].status === 'pending') {\n    throw promise\n  }\n\n  if (promise[TSR_DEFERRED_PROMISE].status === 'error') {\n    throw promise[TSR_DEFERRED_PROMISE].error\n  }\n\n  return [promise[TSR_DEFERRED_PROMISE].data, promise]\n}\n\nexport function Await<T>(\n  props: AwaitOptions<T> & {\n    fallback?: React.ReactNode\n    children: (result: T) => React.ReactNode\n  },\n) {\n  const inner = <AwaitInner {...props} />\n  if (props.fallback) {\n    return <React.Suspense fallback={props.fallback}>{inner}</React.Suspense>\n  }\n  return inner\n}\n\nfunction AwaitInner<T>(\n  props: AwaitOptions<T> & {\n    fallback?: React.ReactNode\n    children: (result: T) => React.ReactNode\n  },\n): React.JSX.Element {\n  const [data] = useAwaited(props)\n\n  return props.children(data) as React.JSX.Element\n}\n"],"names":[],"mappings":";;;AASO,SAAS,WAAc;AAAA,EAC5B,SAAS;AACX,GAA6C;AACrC,QAAA,UAAU,MAAM,QAAQ;AAE9B,MAAI,QAAQ,oBAAoB,EAAE,WAAW,WAAW;AAChD,UAAA;AAAA,EAAA;AAGR,MAAI,QAAQ,oBAAoB,EAAE,WAAW,SAAS;AAC9C,UAAA,QAAQ,oBAAoB,EAAE;AAAA,EAAA;AAGtC,SAAO,CAAC,QAAQ,oBAAoB,EAAE,MAAM,OAAO;AACrD;AAEO,SAAS,MACd,OAIA;AACA,QAAM,QAAQ,oBAAC,YAAY,EAAA,GAAG,MAAO,CAAA;AACrC,MAAI,MAAM,UAAU;AAClB,+BAAQ,MAAM,UAAN,EAAe,UAAU,MAAM,UAAW,UAAM,OAAA;AAAA,EAAA;AAEnD,SAAA;AACT;AAEA,SAAS,WACP,OAImB;AACnB,QAAM,CAAC,IAAI,IAAI,WAAW,KAAK;AAExB,SAAA,MAAM,SAAS,IAAI;AAC5B;"}

package/dist/esm/index.d.ts

@@ -4,7 +4,6 @@ export { default as invariant } from 'tiny-invariant';
 export { default as warning } from 'tiny-warning';
 export { useAwaited, Await } from './awaited.js';
 export type { AwaitOptions } from './awaited.js';
-export { ScriptOnce } from './ScriptOnce.js';
 export { defer, TSR_DEFERRED_PROMISE } from './defer.js';
 export type { DeferredPromiseState, DeferredPromise } from './defer.js';
 export { CatchBoundary, ErrorComponent } from './CatchBoundary.js';
@@ -19,7 +18,6 @@ export { Matches, useMatchRoute, MatchRoute, useMatches, useParentMatches, useCh
 export type { RouteMatch, AnyRouteMatch, MatchRouteOptions, UseMatchRouteOptions, MakeMatchRouteOptions, MakeRouteMatch, MakeRouteMatchUnion, } from './Matches.js';
 export { matchContext } from './matchContext.js';
 export { Match, Outlet } from './Match.js';
-export { isServerSideError, defaultDeserializeError } from './isServerSideError.js';
 export { useMatch } from './useMatch.js';
 export { useLoaderDeps } from './useLoaderDeps.js';
 export { useLoaderData } from './useLoaderData.js';
@@ -34,15 +32,14 @@ export { RouteApi, getRouteApi, Route, createRoute, RootRoute, rootRouteWithCont
 export type { AnyPathParams, ResolveParams, SearchSchemaInput, AnyContext, RouteContext, PreloadableObj, RoutePathOptions, StaticDataRouteOption, RoutePathOptionsIntersection, RouteOptions, FileBaseRouteOptions, BaseRouteOptions, UpdatableRouteOptions, UpdatableStaticRouteOption, MetaDescriptor, RouteLinkEntry, ParseParamsFn, RouteLoaderFn, LoaderFnContext, SearchFilter, ResolveId, InferFullSearchSchema, InferFullSearchSchemaInput, ResolveFullSearchSchema, ResolveFullSearchSchemaInput, AnyRoute, RouteConstraints, AnyRootRoute, ResolveFullPath, RouteMask, ErrorRouteProps, ErrorComponentProps, NotFoundRouteProps, ReactNode, SyncRouteComponent, AsyncRouteComponent, RouteComponent, ErrorRouteComponent, NotFoundRouteComponent, TrimPath, TrimPathLeft, TrimPathRight, RootRouteOptions, AnyRouteWithContext, ParseSplatParams, SplatParams, StringifyParamsFn, ParamsOptions, FullSearchSchemaOption, RouteContextFn, RouteContextOptions, BeforeLoadFn, BeforeLoadContextOptions, ContextOptions, InferAllParams, InferAllContext, LooseReturnType, LooseAsyncReturnType, ContextReturnType, ContextAsyncReturnType, RouteContextParameter, BeforeLoadContextParameter, ResolveAllContext, ResolveLoaderData, ResolveAllParamsFromParent, ResolveRouteContext, } from './route.js';
 export type { ParseRoute, RoutesById, RouteById, RouteIds, RoutesByPath, RouteByPath, RoutePaths, FullSearchSchema, AllParams, AllLoaderData, FullSearchSchemaInput, AllContext, } from './routeInfo.js';
 export { componentTypes, createRouter, Router, lazyFn, SearchParamError, PathParamError, getInitialRouterState, defaultSerializeError, } from './router.js';
-export type { Register, AnyRouter, RegisteredRouter, HydrationCtx, RouterContextOptions, TrailingSlashOption, RouterOptions, RouterErrorSerializer, RouterState, ListenerFn, BuildNextOptions, DehydratedRouterState, DehydratedRouteMatch, DehydratedRouter, RouterConstructorOptions, RouterEvents, RouterEvent, RouterListener, AnyRouterWithContext, ClientExtractedBaseEntry, ClientExtractedEntry, ClientExtractedPromise, ControllablePromise, StreamState, TSRGlobal, TSRGlobalMatch, } from './router.js';
+export type { Register, AnyRouter, RegisteredRouter, RouterContextOptions, TrailingSlashOption, RouterOptions, RouterErrorSerializer, RouterState, ListenerFn, BuildNextOptions, RouterConstructorOptions, RouterEvents, RouterEvent, RouterListener, AnyRouterWithContext, ControllablePromise, InjectedHtmlEntry, } from './router.js';
+export type { StartSerializer, Serializable, SerializerParse, SerializerParseBy, SerializerStringify, SerializerStringifyBy, } from './serializer.js';
 export { RouterProvider, RouterContextProvider } from './RouterProvider.js';
-export type { RouterProps, CommitLocationOptions, MatchLocation, NavigateFn, BuildLocationFn, InjectedHtmlEntry, } from './RouterProvider.js';
+export type { RouterProps, CommitLocationOptions, MatchLocation, NavigateFn, BuildLocationFn, } from './RouterProvider.js';
 export { useScrollRestoration, useElementScrollRestoration, ScrollRestoration, } from './scroll-restoration.js';
 export type { ScrollRestorationOptions } from './scroll-restoration.js';
 export { defaultParseSearch, defaultStringifySearch, parseSearchWith, stringifySearchWith, } from './searchParams.js';
 export type { SearchSerializer, SearchParser } from './searchParams.js';
-export { defaultTransformer } from './transformer.js';
-export type { RouterTransformer, TransformerParse, TransformerStringify, DefaultSerializable, DefaultTransformerParse, DefaultTransformerStringify, } from './transformer.js';
 export type { UseBlockerOpts, ShouldBlockFn } from './useBlocker.js';
 export { useBlocker, Block } from './useBlocker.js';
 export { useNavigate, Navigate } from './useNavigate.js';
@@ -66,3 +63,4 @@ export type { ControlledPromise, Constrain, Expand, MergeAll, Assign, } from './
 export type { ResolveValidatorInput, ResolveValidatorOutput, AnyValidator, DefaultValidator, ValidatorFn, AnySchema, AnyValidatorAdapter, AnyValidatorFn, AnyValidatorObj, ResolveValidatorInputFn, ResolveValidatorOutputFn, ResolveSearchValidatorInput, ResolveSearchValidatorInputFn, Validator, ValidatorAdapter, ValidatorObj, } from './validators.js';
 export { retainSearchParams, stripSearchParams } from './searchMiddleware.js';
 export * from './typePrimitives.js';
+export { ScriptOnce } from './ScriptOnce.js';

package/dist/esm/index.js

@@ -2,7 +2,6 @@ import { createBrowserHistory, createHashHistory, createHistory, createMemoryHis
 import { default as default2 } from "tiny-invariant";
 import { default as default3 } from "tiny-warning";
 import { Await, useAwaited } from "./awaited.js";
-import { ScriptOnce } from "./ScriptOnce.js";
 import { TSR_DEFERRED_PROMISE, defer } from "./defer.js";
 import { CatchBoundary, ErrorComponent } from "./CatchBoundary.js";
 import { FileRoute, FileRouteLoader, LazyRoute, createFileRoute, createLazyFileRoute, createLazyRoute } from "./fileRoute.js";
@@ -11,7 +10,6 @@ import { Link, createLink, linkOptions, useLinkProps } from "./link.js";
 import { MatchRoute, Matches, isMatch, useChildMatches, useMatchRoute, useMatches, useParentMatches } from "./Matches.js";
 import { matchContext } from "./matchContext.js";
 import { Match, Outlet } from "./Match.js";
-import { defaultDeserializeError, isServerSideError } from "./isServerSideError.js";
 import { useMatch } from "./useMatch.js";
 import { useLoaderDeps } from "./useLoaderDeps.js";
 import { useLoaderData } from "./useLoaderData.js";
@@ -24,7 +22,6 @@ import { PathParamError, Router, SearchParamError, componentTypes, createRouter,
 import { RouterContextProvider, RouterProvider } from "./RouterProvider.js";
 import { ScrollRestoration, useElementScrollRestoration, useScrollRestoration } from "./scroll-restoration.js";
 import { defaultParseSearch, defaultStringifySearch, parseSearchWith, stringifySearchWith } from "./searchParams.js";
-import { defaultTransformer } from "./transformer.js";
 import { Block, useBlocker } from "./useBlocker.js";
 import { Navigate, useNavigate } from "./useNavigate.js";
 import { useParams } from "./useParams.js";
@@ -38,6 +35,7 @@ import { useCanGoBack } from "./useCanGoBack.js";
 import { createControlledPromise, deepEqual, escapeJSON, functionalUpdate, isPlainArray, isPlainObject, pick, replaceEqualDeep, shallow, useLayoutEffect, useStableCallback } from "./utils.js";
 import { CatchNotFound, DefaultGlobalNotFound, isNotFound, notFound } from "./not-found.js";
 import { retainSearchParams, stripSearchParams } from "./searchMiddleware.js";
+import { ScriptOnce } from "./ScriptOnce.js";
 export {
   Await,
   Block,
@@ -84,11 +82,9 @@ export {
   createRouter,
   decode,
   deepEqual,
-  defaultDeserializeError,
   defaultParseSearch,
   defaultSerializeError,
   defaultStringifySearch,
-  defaultTransformer,
   defer,
   encode,
   escapeJSON,
@@ -103,7 +99,6 @@ export {
   isPlainArray,
   isPlainObject,
   isRedirect,
-  isServerSideError,
   joinPaths,
   lazyFn,
   lazyRouteComponent,

package/dist/esm/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/esm/router.d.ts

@@ -1,4 +1,5 @@
 import { Store, NoInfer } from '@tanstack/react-store';
+import { StartSerializer } from './serializer.js';
 import { HistoryLocation, HistoryState, ParsedHistoryState, RouterHistory } from '@tanstack/history';
 import { Manifest } from './manifest.js';
 import { AnyContext, AnyRoute, AnyRouteWithContext, ErrorRouteComponent, NotFoundRouteComponent, RootRoute, RouteComponent, RouteMask } from './route.js';
@@ -11,33 +12,13 @@ import { BuildLocationFn, CommitLocationOptions, NavigateFn } from './RouterProv
 import { AnyRedirect, ResolvedRedirect } from './redirects.js';
 import { NotFoundError } from './not-found.js';
 import { NavigateOptions, ResolveRelativePath, ToOptions } from './link.js';
-import { RouterTransformer } from './transformer.js';
 import { AnySchema } from './validators.js';
 import type * as React from 'react';
-export interface TSRGlobalMatch {
-    index: number;
-    __beforeLoadContext?: string;
-    loaderData?: string;
-    extracted: Record<string, ClientExtractedEntry>;
-}
-export interface TSRGlobal {
-    matches: Array<TSRGlobalMatch>;
-    streamedValues: Record<string, {
-        value: any;
-        parsed: any;
-    }>;
-    cleanScripts: () => void;
-    dehydrated?: any;
-}
 declare global {
     interface Window {
-        __TSR__?: RegisteredTSRGlobal;
-        __TSR_ROUTER_CONTEXT__?: React.Context<Router<any, any, any>>;
+        __TSR_ROUTER__?: AnyRouter;
     }
 }
-type RegisteredTSRGlobal = Register extends {
-    __TSR__: infer TTSR extends TSRGlobal;
-} ? TTSR : TSRGlobal;
 export interface Register {
 }
 export type AnyRouter = Router<any, any, any, any, any, any>;
@@ -45,40 +26,19 @@ export type AnyRouterWithContext<TContext> = Router<AnyRouteWithContext<TContext
 export type RegisteredRouter = Register extends {
     router: infer TRouter extends AnyRouter;
 } ? TRouter : AnyRouter;
-export type HydrationCtx = {
-    router: DehydratedRouter;
-    payload: Record<string, any>;
-};
 export type InferRouterContext<TRouteTree extends AnyRoute> = TRouteTree extends RootRoute<any, infer TRouterContext extends AnyContext, any, any, any, any, any, any> ? TRouterContext : AnyContext;
-export interface ClientExtractedBaseEntry {
-    type: string;
-    path: Array<string>;
-}
 export type ControllablePromise<T = any> = Promise<T> & {
     resolve: (value: T) => void;
     reject: (value?: any) => void;
 };
-export interface ClientExtractedPromise extends ClientExtractedBaseEntry {
-    type: 'promise';
-    value?: ControllablePromise<any>;
-}
-export interface ClientExtractedStream extends ClientExtractedBaseEntry {
-    type: 'stream';
-    value?: ReadableStream & {
-        controller?: ReadableStreamDefaultController;
-    };
-}
-export type ClientExtractedEntry = ClientExtractedStream | ClientExtractedPromise;
-export type StreamState = {
-    promises: Array<ControlledPromise<string | null>>;
-};
 export type RouterContextOptions<TRouteTree extends AnyRoute> = AnyContext extends InferRouterContext<TRouteTree> ? {
     context?: InferRouterContext<TRouteTree>;
 } : {
     context: InferRouterContext<TRouteTree>;
 };
 export type TrailingSlashOption = 'always' | 'never' | 'preserve';
-export interface RouterOptions<TRouteTree extends AnyRoute, TTrailingSlashOption extends TrailingSlashOption, TDefaultStructuralSharingOption extends boolean = false, TRouterHistory extends RouterHistory = RouterHistory, TDehydrated extends Record<string, any> = Record<string, any>, TSerializedError extends Record<string, any> = Record<string, any>> {
+export type InjectedHtmlEntry = Promise<string>;
+export interface RouterOptions<TRouteTree extends AnyRoute, TTrailingSlashOption extends TrailingSlashOption, TDefaultStructuralSharingOption extends boolean = false, TRouterHistory extends RouterHistory = RouterHistory, TDehydrated extends Record<string, any> = Record<string, any>> {
     /**
      * The history object that will be used to manage the browser history.
      *
@@ -336,19 +296,6 @@ export interface RouterOptions<TRouteTree extends AnyRoute, TTrailingSlashOption
      * @link [Guide](https://tanstack.com/router/latest/docs/framework/react/guide/not-found-errors#default-router-wide-not-found-handling)
      */
     defaultNotFoundComponent?: NotFoundRouteComponent;
-    /**
-     * The transformer that will be used when sending data between the server and the client during SSR.
-     *
-     * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/RouterOptionsType#transformer-property)
-     * @link [Guide](https://tanstack.com/router/latest/docs/framework/react/guide/ssr#data-transformers)
-     */
-    transformer?: RouterTransformer;
-    /**
-     * The serializer object that will be used to determine how errors are serialized and deserialized between the server and the client.
-     *
-     * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/RouterOptionsType#errorserializer-property)
-     */
-    errorSerializer?: RouterErrorSerializer<TSerializedError>;
     /**
      * Configures how trailing slashes are treated.
      *
@@ -431,18 +378,10 @@ export interface MatchedRoutesResult {
     matchedRoutes: Array<AnyRoute>;
     routeParams: Record<string, string>;
 }
-export interface DehydratedRouterState {
-    dehydratedMatches: Array<DehydratedRouteMatch>;
-}
-export type DehydratedRouteMatch = Pick<MakeRouteMatch, 'id' | 'status' | 'updatedAt' | 'loaderData'>;
-export interface DehydratedRouter {
-    state: DehydratedRouterState;
-    manifest?: Manifest;
-}
 export interface ViewTransitionOptions {
     types: Array<string>;
 }
-export type RouterConstructorOptions<TRouteTree extends AnyRoute, TTrailingSlashOption extends TrailingSlashOption, TDefaultStructuralSharingOption extends boolean, TRouterHistory extends RouterHistory, TDehydrated extends Record<string, any>, TSerializedError extends Record<string, any>> = Omit<RouterOptions<TRouteTree, TTrailingSlashOption, TDefaultStructuralSharingOption, TRouterHistory, TDehydrated, TSerializedError>, 'context'> & RouterContextOptions<TRouteTree>;
+export type RouterConstructorOptions<TRouteTree extends AnyRoute, TTrailingSlashOption extends TrailingSlashOption, TDefaultStructuralSharingOption extends boolean, TRouterHistory extends RouterHistory, TDehydrated extends Record<string, any>> = Omit<RouterOptions<TRouteTree, TTrailingSlashOption, TDefaultStructuralSharingOption, TRouterHistory, TDehydrated>, 'context'> & RouterContextOptions<TRouteTree>;
 export declare const componentTypes: readonly ["component", "errorComponent", "pendingComponent", "notFoundComponent"];
 export type RouterEvents = {
     onBeforeNavigate: {
@@ -480,13 +419,17 @@ export type RouterEvents = {
         pathChanged: boolean;
         hrefChanged: boolean;
     };
+    onInjectedHtml: {
+        type: 'onInjectedHtml';
+        promise: Promise<string>;
+    };
 };
 export type RouterEvent = RouterEvents[keyof RouterEvents];
 export type RouterListener<TRouterEvent extends RouterEvent> = {
     eventType: TRouterEvent['type'];
     fn: ListenerFn<TRouterEvent>;
 };
-export declare function createRouter<TRouteTree extends AnyRoute, TTrailingSlashOption extends TrailingSlashOption, TDefaultStructuralSharingOption extends boolean, TRouterHistory extends RouterHistory = RouterHistory, TDehydrated extends Record<string, any> = Record<string, any>, TSerializedError extends Record<string, any> = Record<string, any>>(options: undefined extends number ? 'strictNullChecks must be enabled in tsconfig.json' : RouterConstructorOptions<TRouteTree, TTrailingSlashOption, TDefaultStructuralSharingOption, TRouterHistory, TDehydrated, TSerializedError>): Router<TRouteTree, TTrailingSlashOption, TDefaultStructuralSharingOption, TRouterHistory, TDehydrated, TSerializedError>;
+export declare function createRouter<TRouteTree extends AnyRoute, TTrailingSlashOption extends TrailingSlashOption, TDefaultStructuralSharingOption extends boolean, TRouterHistory extends RouterHistory = RouterHistory, TDehydrated extends Record<string, any> = Record<string, any>, TSerializedError extends Record<string, any> = Record<string, any>>(options: undefined extends number ? 'strictNullChecks must be enabled in tsconfig.json' : RouterConstructorOptions<TRouteTree, TTrailingSlashOption, TDefaultStructuralSharingOption, TRouterHistory, TDehydrated>): Router<TRouteTree, TTrailingSlashOption, TDefaultStructuralSharingOption, TRouterHistory, TDehydrated, TSerializedError>;
 type MatchRoutesOpts = {
     preload?: boolean;
     throwOnError?: boolean;
@@ -499,22 +442,9 @@ export declare class Router<in out TRouteTree extends AnyRoute, in out TTrailing
     shouldViewTransition?: boolean | ViewTransitionOptions;
     isViewTransitionTypesSupported?: boolean;
     subscribers: Set<RouterListener<RouterEvent>>;
-    dehydratedData?: TDehydrated;
     viewTransitionPromise?: ControlledPromise<true>;
-    manifest?: Manifest;
-    AfterEachMatch?: (props: {
-        match: Pick<AnyRouteMatch, 'id' | 'status' | 'error' | 'loadPromise' | 'minPendingPromise'>;
-        matchIndex: number;
-    }) => any;
-    serializeLoaderData?: (type: '__beforeLoadContext' | 'loaderData', loaderData: any, ctx: {
-        router: AnyRouter;
-        match: AnyRouteMatch;
-    }) => any;
-    serializer?: (data: any) => string;
     __store: Store<RouterState<TRouteTree>>;
-    options: PickAsRequired<Omit<RouterOptions<TRouteTree, TTrailingSlashOption, TDefaultStructuralSharingOption, TRouterHistory, TDehydrated, TSerializedError>, 'transformer'> & {
-        transformer: RouterTransformer;
-    }, 'stringifySearch' | 'parseSearch' | 'context'>;
+    options: PickAsRequired<RouterOptions<TRouteTree, TTrailingSlashOption, TDefaultStructuralSharingOption, TRouterHistory, TDehydrated>, 'stringifySearch' | 'parseSearch' | 'context'>;
     history: TRouterHistory;
     latestLocation: ParsedLocation<FullSearchSchema<TRouteTree>>;
     basepath: string;
@@ -527,9 +457,9 @@ export declare class Router<in out TRouteTree extends AnyRoute, in out TTrailing
     /**
      * @deprecated Use the `createRouter` function instead
      */
-    constructor(options: RouterConstructorOptions<TRouteTree, TTrailingSlashOption, TDefaultStructuralSharingOption, TRouterHistory, TDehydrated, TSerializedError>);
+    constructor(options: RouterConstructorOptions<TRouteTree, TTrailingSlashOption, TDefaultStructuralSharingOption, TRouterHistory, TDehydrated>);
     startReactTransition: (fn: () => void) => void;
-    update: (newOptions: RouterConstructorOptions<TRouteTree, TTrailingSlashOption, TDefaultStructuralSharingOption, TRouterHistory, TDehydrated, TSerializedError>) => void;
+    update: (newOptions: RouterConstructorOptions<TRouteTree, TTrailingSlashOption, TDefaultStructuralSharingOption, TRouterHistory, TDehydrated>) => void;
     get state(): RouterState<TRouteTree, import('./Matches.js').RouteMatch<any, any, any, any, any, any, any>>;
     buildRouteTree: () => void;
     subscribe: <TType extends keyof RouterEvents>(eventType: TType, fn: ListenerFn<RouterEvents[TType]>) => () => void;
@@ -589,16 +519,26 @@ export declare class Router<in out TRouteTree extends AnyRoute, in out TTrailing
     loadRouteChunk: (route: AnyRoute) => Promise<void[]>;
     preloadRoute: <TFrom extends RoutePaths<TRouteTree> | string = string, TTo extends string | undefined = undefined, TMaskFrom extends RoutePaths<TRouteTree> | string = TFrom, TMaskTo extends string = "">(opts: NavigateOptions<Router<TRouteTree, TTrailingSlashOption, TDefaultStructuralSharingOption, TRouterHistory, TDehydrated, TSerializedError>, TFrom, TTo, TMaskFrom, TMaskTo>) => Promise<Array<AnyRouteMatch> | undefined>;
     matchRoute: <TFrom extends RoutePaths<TRouteTree> = "/", TTo extends string | undefined = undefined, TResolved = ResolveRelativePath<TFrom, NoInfer<TTo>>>(location: ToOptions<Router<TRouteTree, TTrailingSlashOption, TDefaultStructuralSharingOption, TRouterHistory, TDehydrated, TSerializedError>, TFrom, TTo>, opts?: MatchRouteOptions) => false | RouteById<TRouteTree, TResolved>["types"]["allParams"];
-    dehydrate: () => DehydratedRouter;
-    hydrate: () => void;
-    injectedHtml: Array<() => string>;
-    injectHtml: (html: string) => void;
-    injectScript: (script: string, opts?: {
-        logScript?: boolean;
-    }) => void;
-    streamedKeys: Set<string>;
-    getStreamedValue: <T>(key: string) => T | undefined;
-    streamValue: (key: string, value: any) => void;
+    ssr?: {
+        manifest: Manifest | undefined;
+        serializer: StartSerializer;
+    };
+    serverSsr?: {
+        injectedHtml: Array<InjectedHtmlEntry>;
+        injectHtml: (getHtml: () => string | Promise<string>) => Promise<void>;
+        injectScript: (getScript: () => string | Promise<string>, opts?: {
+            logScript?: boolean;
+        }) => Promise<void>;
+        streamValue: (key: string, value: any) => void;
+        streamedKeys: Set<string>;
+        onMatchSettled: (opts: {
+            router: AnyRouter;
+            match: AnyRouteMatch;
+        }) => any;
+    };
+    clientSsr?: {
+        getStreamedValue: <T>(key: string) => T | undefined;
+    };
     _handleNotFound: (matches: Array<AnyRouteMatch>, err: NotFoundError, { updateMatch, }?: {
         updateMatch?: (id: string, updater: (match: AnyRouteMatch) => AnyRouteMatch) => void;
     }) => void;

package/dist/esm/router.js

@@ -1,15 +1,12 @@
 import { createMemoryHistory, createBrowserHistory, parseHref } from "@tanstack/history";
 import { Store, batch } from "@tanstack/react-store";
 import invariant from "tiny-invariant";
-import warning from "tiny-warning";
-import jsesc from "jsesc";
 import { rootRouteId } from "./root.js";
 import { defaultStringifySearch, defaultParseSearch } from "./searchParams.js";
 import { pick, createControlledPromise, deepEqual, replaceEqualDeep, last, functionalUpdate } from "./utils.js";
 import { trimPath, trimPathLeft, parsePathname, resolvePath, cleanPath, trimPathRight, matchPathname, interpolatePath, joinPaths } from "./path.js";
 import { isResolvedRedirect, isRedirect } from "./redirects.js";
 import { isNotFound } from "./not-found.js";
-import { defaultTransformer } from "./transformer.js";
 const componentTypes = [
   "component",
   "errorComponent",
@@ -374,7 +371,7 @@ class Router {
                   }) ?? {}
                 };
               }
-            } catch (e) {
+            } catch {
             }
           });
           search = validatedSearch;
@@ -423,7 +420,7 @@ class Router {
                       ) ?? {}
                     };
                     return validatedSearch;
-                  } catch (e) {
+                  } catch {
                   }
                 };
                 middlewares.push(validate);
@@ -964,17 +961,7 @@ class Router {
                       cause: preload ? "preload" : cause,
                       matches
                     };
-                    let beforeLoadContext = await ((_c = (_b = route.options).beforeLoad) == null ? void 0 : _c.call(_b, beforeLoadFnContext)) ?? {};
-                    if (this.serializeLoaderData) {
-                      beforeLoadContext = this.serializeLoaderData(
-                        "__beforeLoadContext",
-                        beforeLoadContext,
-                        {
-                          router: this,
-                          match: this.getMatch(matchId)
-                        }
-                      );
-                    }
+                    const beforeLoadContext = await ((_c = (_b = route.options).beforeLoad) == null ? void 0 : _c.call(_b, beforeLoadFnContext)) ?? {};
                     if (isRedirect(beforeLoadContext) || isNotFound(beforeLoadContext)) {
                       handleSerialError(index, beforeLoadContext, "BEFORE_LOAD");
                     }
@@ -1054,7 +1041,7 @@ class Router {
                         preload: !!preload && !this.state.matches.find((d) => d.id === matchId)
                       }));
                       const runLoader = async () => {
-                        var _a2, _b2, _c2, _d, _e, _f, _g, _h;
+                        var _a2, _b2, _c2, _d, _e, _f, _g, _h, _i;
                         try {
                           const potentialPendingMinPromise = async () => {
                             const latestMatch = this.getMatch(matchId);
@@ -1068,17 +1055,7 @@ class Router {
                               ...prev,
                               isFetching: "loader"
                             }));
-                            let loaderData = await ((_b2 = (_a2 = route.options).loader) == null ? void 0 : _b2.call(_a2, getLoaderContext()));
-                            if (this.serializeLoaderData) {
-                              loaderData = this.serializeLoaderData(
-                                "loaderData",
-                                loaderData,
-                                {
-                                  router: this,
-                                  match: this.getMatch(matchId)
-                                }
-                              );
-                            }
+                            const loaderData = await ((_b2 = (_a2 = route.options).loader) == null ? void 0 : _b2.call(_a2, getLoaderContext()));
                             handleRedirectAndNotFound(
                               this.getMatch(matchId),
                               loaderData
@@ -1129,6 +1106,10 @@ class Router {
                               isFetching: false
                             }));
                           }
+                          (_i = this.serverSsr) == null ? void 0 : _i.onMatchSettled({
+                            router: this,
+                            match: this.getMatch(matchId)
+                          });
                           await route._componentsPromise;
                         } catch (err) {
                           updateMatch(matchId, (prev) => ({
@@ -1369,104 +1350,6 @@ class Router {
       }
       return match;
     };
-    this.dehydrate = () => {
-      var _a;
-      const pickError = ((_a = this.options.errorSerializer) == null ? void 0 : _a.serialize) ?? defaultSerializeError;
-      return {
-        state: {
-          dehydratedMatches: this.state.matches.map((d) => {
-            return {
-              ...pick(d, ["id", "status", "updatedAt"]),
-              // If an error occurs server-side during SSRing,
-              // send a small subset of the error to the client
-              error: d.error ? {
-                data: pickError(d.error),
-                __isServerError: true
-              } : void 0
-              // NOTE: We don't send the loader data here, because
-              // there is a potential that it needs to be streamed.
-              // Instead, we render it next to the route match in the HTML
-              // which gives us the potential to stream it via suspense.
-            };
-          })
-        },
-        manifest: this.manifest
-      };
-    };
-    this.hydrate = () => {
-      var _a, _b, _c;
-      let ctx;
-      if (typeof document !== "undefined") {
-        ctx = this.options.transformer.parse((_a = window.__TSR__) == null ? void 0 : _a.dehydrated);
-      }
-      invariant(
-        ctx,
-        "Expected to find a dehydrated data on window.__TSR__.dehydrated... but we did not. Please file an issue!"
-      );
-      this.dehydratedData = ctx.payload;
-      (_c = (_b = this.options).hydrate) == null ? void 0 : _c.call(_b, ctx.payload);
-      const dehydratedState = ctx.router.state;
-      const matches = this.matchRoutes(this.state.location).map((match) => {
-        const dehydratedMatch = dehydratedState.dehydratedMatches.find(
-          (d) => d.id === match.id
-        );
-        invariant(
-          dehydratedMatch,
-          `Could not find a client-side match for dehydrated match with id: ${match.id}!`
-        );
-        return {
-          ...match,
-          ...dehydratedMatch
-        };
-      });
-      this.__store.setState((s) => {
-        return {
-          ...s,
-          matches
-        };
-      });
-      this.manifest = ctx.router.manifest;
-    };
-    this.injectedHtml = [];
-    this.injectHtml = (html) => {
-      const cb = () => {
-        this.injectedHtml = this.injectedHtml.filter((d) => d !== cb);
-        return html;
-      };
-      this.injectedHtml.push(cb);
-    };
-    this.injectScript = (script, opts) => {
-      this.injectHtml(
-        `<script class='tsr-once'>${script}${process.env.NODE_ENV === "development" && ((opts == null ? void 0 : opts.logScript) ?? true) ? `; console.info(\`Injected From Server:
-${jsesc(script, { quotes: "backtick" })}\`)` : ""}; if (typeof __TSR__ !== 'undefined') __TSR__.cleanScripts()<\/script>`
-      );
-    };
-    this.streamedKeys = /* @__PURE__ */ new Set();
-    this.getStreamedValue = (key) => {
-      var _a;
-      if (this.isServer) {
-        return void 0;
-      }
-      const streamedValue = (_a = window.__TSR__) == null ? void 0 : _a.streamedValues[key];
-      if (!streamedValue) {
-        return;
-      }
-      if (!streamedValue.parsed) {
-        streamedValue.parsed = this.options.transformer.parse(streamedValue.value);
-      }
-      return streamedValue.parsed;
-    };
-    this.streamValue = (key, value) => {
-      var _a;
-      warning(
-        !this.streamedKeys.has(key),
-        "Key has already been streamed: " + key
-      );
-      this.streamedKeys.add(key);
-      this.injectScript(
-        `__TSR__.streamedValues['${key}'] = { value: ${(_a = this.serializer) == null ? void 0 : _a.call(this, this.options.transformer.stringify(value))}}`
-      );
-    };
     this._handleNotFound = (matches, err, {
       updateMatch = this.updateMatch
     } = {}) => {
@@ -1510,11 +1393,10 @@ ${jsesc(script, { quotes: "backtick" })}\`)` : ""}; if (typeof __TSR__ !== 'unde
       caseSensitive: options.caseSensitive ?? false,
       notFoundMode: options.notFoundMode ?? "fuzzy",
       stringifySearch: options.stringifySearch ?? defaultStringifySearch,
-      parseSearch: options.parseSearch ?? defaultParseSearch,
-      transformer: options.transformer ?? defaultTransformer
+      parseSearch: options.parseSearch ?? defaultParseSearch
     });
     if (typeof document !== "undefined") {
-      window.__TSR__ROUTER__ = this;
+      window.__TSR_ROUTER__ = this;
     }
   }
   get state() {