@tanstack/start-client-core 1.132.0-alpha.8 → 1.132.0

package/dist/esm/createStart.d.ts

@@ -0,0 +1,27 @@
+import { AnyFunctionMiddleware, AnyRequestMiddleware, CreateMiddlewareFn } from './createMiddleware.js';
+import { AnySerializationAdapter, Register, SSROption } from '@tanstack/router-core';
+export interface StartInstanceOptions<in out TSerializationAdapters, in out TDefaultSsr, in out TRequestMiddlewares, in out TFunctionMiddlewares> {
+    '~types': StartInstanceTypes<TSerializationAdapters, TDefaultSsr, TRequestMiddlewares, TFunctionMiddlewares>;
+    serializationAdapters?: TSerializationAdapters;
+    defaultSsr?: TDefaultSsr;
+    requestMiddleware?: TRequestMiddlewares;
+    functionMiddleware?: TFunctionMiddlewares;
+}
+export interface StartInstance<in out TSerializationAdapters, in out TDefaultSsr, in out TRequestMiddlewares, in out TFunctionMiddlewares> {
+    getOptions: () => Promise<StartInstanceOptions<TSerializationAdapters, TDefaultSsr, TRequestMiddlewares, TFunctionMiddlewares>> | StartInstanceOptions<TSerializationAdapters, TDefaultSsr, TRequestMiddlewares, TFunctionMiddlewares>;
+    createMiddleware: CreateMiddlewareFn<Register>;
+}
+export interface StartInstanceTypes<in out TSerializationAdapters, in out TDefaultSsr, in out TRequestMiddlewares, in out TFunctionMiddlewares> {
+    serializationAdapters: TSerializationAdapters;
+    defaultSsr: TDefaultSsr;
+    requestMiddleware: TRequestMiddlewares;
+    functionMiddleware: TFunctionMiddlewares;
+}
+export declare const createStart: <const TSerializationAdapters extends ReadonlyArray<AnySerializationAdapter> = [], TDefaultSsr extends SSROption = SSROption, const TRequestMiddlewares extends ReadonlyArray<AnyRequestMiddleware> = [], const TFunctionMiddlewares extends ReadonlyArray<AnyFunctionMiddleware> = []>(getOptions: () => Promise<Omit<StartInstanceOptions<TSerializationAdapters, TDefaultSsr, TRequestMiddlewares, TFunctionMiddlewares>, "~types">> | Omit<StartInstanceOptions<TSerializationAdapters, TDefaultSsr, TRequestMiddlewares, TFunctionMiddlewares>, "~types">) => StartInstance<TSerializationAdapters, TDefaultSsr, TRequestMiddlewares, TFunctionMiddlewares>;
+export type AnyStartInstance = StartInstance<any, any, any, any>;
+export type AnyStartInstanceOptions = StartInstanceOptions<any, any, any, any>;
+declare module '@tanstack/router-core' {
+    interface Register {
+        ssr: true;
+    }
+}

package/dist/esm/createStart.js

@@ -0,0 +1,14 @@
+import { createMiddleware } from "./createMiddleware.js";
+const createStart = (getOptions) => {
+  return {
+    getOptions: async () => {
+      const options = await getOptions();
+      return options;
+    },
+    createMiddleware
+  };
+};
+export {
+  createStart
+};
+//# sourceMappingURL=createStart.js.map

package/dist/esm/createStart.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createStart.js","sources":["../../src/createStart.ts"],"sourcesContent":["import { createMiddleware } from './createMiddleware'\nimport type {\n  AnyFunctionMiddleware,\n  AnyRequestMiddleware,\n  CreateMiddlewareFn,\n} from './createMiddleware'\nimport type {\n  AnySerializationAdapter,\n  Register,\n  SSROption,\n} from '@tanstack/router-core'\n\nexport interface StartInstanceOptions<\n  in out TSerializationAdapters,\n  in out TDefaultSsr,\n  in out TRequestMiddlewares,\n  in out TFunctionMiddlewares,\n> {\n  '~types': StartInstanceTypes<\n    TSerializationAdapters,\n    TDefaultSsr,\n    TRequestMiddlewares,\n    TFunctionMiddlewares\n  >\n  serializationAdapters?: TSerializationAdapters\n  defaultSsr?: TDefaultSsr\n  requestMiddleware?: TRequestMiddlewares\n  functionMiddleware?: TFunctionMiddlewares\n}\n\nexport interface StartInstance<\n  in out TSerializationAdapters,\n  in out TDefaultSsr,\n  in out TRequestMiddlewares,\n  in out TFunctionMiddlewares,\n> {\n  getOptions: () =>\n    | Promise<\n        StartInstanceOptions<\n          TSerializationAdapters,\n          TDefaultSsr,\n          TRequestMiddlewares,\n          TFunctionMiddlewares\n        >\n      >\n    | StartInstanceOptions<\n        TSerializationAdapters,\n        TDefaultSsr,\n        TRequestMiddlewares,\n        TFunctionMiddlewares\n      >\n  createMiddleware: CreateMiddlewareFn<Register>\n}\n\nexport interface StartInstanceTypes<\n  in out TSerializationAdapters,\n  in out TDefaultSsr,\n  in out TRequestMiddlewares,\n  in out TFunctionMiddlewares,\n> {\n  serializationAdapters: TSerializationAdapters\n  defaultSsr: TDefaultSsr\n  requestMiddleware: TRequestMiddlewares\n  functionMiddleware: TFunctionMiddlewares\n}\n\nexport const createStart = <\n  const TSerializationAdapters extends\n    ReadonlyArray<AnySerializationAdapter> = [],\n  TDefaultSsr extends SSROption = SSROption,\n  const TRequestMiddlewares extends ReadonlyArray<AnyRequestMiddleware> = [],\n  const TFunctionMiddlewares extends ReadonlyArray<AnyFunctionMiddleware> = [],\n>(\n  getOptions: () =>\n    | Promise<\n        Omit<\n          StartInstanceOptions<\n            TSerializationAdapters,\n            TDefaultSsr,\n            TRequestMiddlewares,\n            TFunctionMiddlewares\n          >,\n          '~types'\n        >\n      >\n    | Omit<\n        StartInstanceOptions<\n          TSerializationAdapters,\n          TDefaultSsr,\n          TRequestMiddlewares,\n          TFunctionMiddlewares\n        >,\n        '~types'\n      >,\n): StartInstance<\n  TSerializationAdapters,\n  TDefaultSsr,\n  TRequestMiddlewares,\n  TFunctionMiddlewares\n> => {\n  return {\n    getOptions: async () => {\n      const options = await getOptions()\n      return options\n    },\n    createMiddleware: createMiddleware as any,\n  } as StartInstance<\n    TSerializationAdapters,\n    TDefaultSsr,\n    TRequestMiddlewares,\n    TFunctionMiddlewares\n  >\n}\n\nexport type AnyStartInstance = StartInstance<any, any, any, any>\nexport type AnyStartInstanceOptions = StartInstanceOptions<any, any, any, any>\n\ndeclare module '@tanstack/router-core' {\n  interface Register {\n    ssr: true\n  }\n}\n"],"names":[],"mappings":";AAkEO,MAAM,cAAc,CAOzB,eA0BG;AACH,SAAO;AAAA,IACL,YAAY,YAAY;AACtB,YAAM,UAAU,MAAM,WAAA;AACtB,aAAO;AAAA,IACT;AAAA,IACA;AAAA,EAAA;AAOJ;"}

package/dist/esm/fake-start-entry.d.ts

@@ -0,0 +1,5 @@
+declare const _default: {
+    startInstance: () => void;
+};
+export default _default;
+export declare const getRouter: () => void;

package/dist/esm/fake-start-entry.js

@@ -0,0 +1,11 @@
+const fakeStartEntry = {
+  startInstance: () => {
+  }
+};
+const getRouter = () => {
+};
+export {
+  fakeStartEntry as default,
+  getRouter
+};
+//# sourceMappingURL=fake-start-entry.js.map

package/dist/esm/fake-start-entry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fake-start-entry.js","sources":["../../src/fake-start-entry.ts"],"sourcesContent":["export default {\n  startInstance: () => {},\n}\nexport const getRouter = () => {}\n"],"names":[],"mappings":"AAAA,MAAA,iBAAe;AAAA,EACb,eAAe,MAAM;AAAA,EAAC;AACxB;AACO,MAAM,YAAY,MAAM;AAAC;"}

package/dist/esm/getDefaultSerovalPlugins.d.ts

@@ -0,0 +1 @@
+export declare function getDefaultSerovalPlugins(): (import('seroval').Plugin<any, import('seroval').SerovalNode> | import('seroval').Plugin<Error, any> | import('seroval').Plugin<ReadableStream<any>, any>)[];

package/dist/esm/getDefaultSerovalPlugins.js

@@ -0,0 +1,14 @@
+import { defaultSerovalPlugins, makeSerovalPlugin } from "@tanstack/router-core";
+import { getStartOptions } from "./getStartOptions.js";
+function getDefaultSerovalPlugins() {
+  const start = getStartOptions();
+  const adapters = start.serializationAdapters;
+  return [
+    ...adapters?.map(makeSerovalPlugin) ?? [],
+    ...defaultSerovalPlugins
+  ];
+}
+export {
+  getDefaultSerovalPlugins
+};
+//# sourceMappingURL=getDefaultSerovalPlugins.js.map

package/dist/esm/getDefaultSerovalPlugins.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getDefaultSerovalPlugins.js","sources":["../../src/getDefaultSerovalPlugins.ts"],"sourcesContent":["import {\n  makeSerovalPlugin,\n  defaultSerovalPlugins as routerDefaultSerovalPlugins,\n} from '@tanstack/router-core'\nimport { getStartOptions } from './getStartOptions'\nimport type { AnySerializationAdapter } from '@tanstack/router-core'\n\nexport function getDefaultSerovalPlugins() {\n  const start = getStartOptions()\n  const adapters = start.serializationAdapters as\n    | Array<AnySerializationAdapter>\n    | undefined\n  return [\n    ...(adapters?.map(makeSerovalPlugin) ?? []),\n    ...routerDefaultSerovalPlugins,\n  ]\n}\n"],"names":["routerDefaultSerovalPlugins"],"mappings":";;AAOO,SAAS,2BAA2B;AACzC,QAAM,QAAQ,gBAAA;AACd,QAAM,WAAW,MAAM;AAGvB,SAAO;AAAA,IACL,GAAI,UAAU,IAAI,iBAAiB,KAAK,CAAA;AAAA,IACxC,GAAGA;AAAAA,EAAA;AAEP;"}

package/dist/esm/getGlobalStartContext.d.ts

@@ -0,0 +1,3 @@
+import { AssignAllServerRequestContext } from './createMiddleware.js';
+import { Expand, Register } from '@tanstack/router-core';
+export declare const getGlobalStartContext: () => Expand<AssignAllServerRequestContext<Register, []>> | undefined;

package/dist/esm/getGlobalStartContext.js

@@ -0,0 +1,15 @@
+import { getStartContext } from "@tanstack/start-storage-context";
+import { createIsomorphicFn } from "./createIsomorphicFn.js";
+const getGlobalStartContext = createIsomorphicFn().client(() => void 0).server(() => {
+  const context = getStartContext().contextAfterGlobalMiddlewares;
+  if (!context) {
+    throw new Error(
+      `Global context not set yet, you are calling getGlobalStartContext() before the global middlewares are applied.`
+    );
+  }
+  return context;
+});
+export {
+  getGlobalStartContext
+};
+//# sourceMappingURL=getGlobalStartContext.js.map

package/dist/esm/getGlobalStartContext.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getGlobalStartContext.js","sources":["../../src/getGlobalStartContext.ts"],"sourcesContent":["import { getStartContext } from '@tanstack/start-storage-context'\nimport { createIsomorphicFn } from './createIsomorphicFn'\nimport type { AssignAllServerRequestContext } from './createMiddleware'\nimport type { Expand, Register } from '@tanstack/router-core'\n\nexport const getGlobalStartContext: () =>\n  | Expand<AssignAllServerRequestContext<Register, []>>\n  | undefined = createIsomorphicFn()\n  .client(() => undefined)\n  .server(() => {\n    const context = getStartContext().contextAfterGlobalMiddlewares\n    if (!context) {\n      throw new Error(\n        `Global context not set yet, you are calling getGlobalStartContext() before the global middlewares are applied.`,\n      )\n    }\n    return context\n  })\n"],"names":[],"mappings":";;AAKO,MAAM,wBAEG,qBACb,OAAO,MAAM,MAAS,EACtB,OAAO,MAAM;AACZ,QAAM,UAAU,kBAAkB;AAClC,MAAI,CAAC,SAAS;AACZ,UAAM,IAAI;AAAA,MACR;AAAA,IAAA;AAAA,EAEJ;AACA,SAAO;AACT,CAAC;"}

package/dist/esm/getRouterInstance.d.ts

@@ -1 +1,2 @@
-export declare const getRouterInstance: import('./createIsomorphicFn.js').IsomorphicFn<[], import('@tanstack/router-core').AnyRouter, import('@tanstack/router-core').AnyRouter>;
+import { Awaitable, RegisteredRouter } from '@tanstack/router-core';
+export declare const getRouterInstance: () => Awaitable<RegisteredRouter>;

package/dist/esm/getRouterInstance.js

@@ -1,6 +1,6 @@
 import { getStartContext } from "@tanstack/start-storage-context";
 import { createIsomorphicFn } from "./createIsomorphicFn.js";
-const getRouterInstance = createIsomorphicFn().client(() => window.__TSR_ROUTER__).server(() => getStartContext().router);
+const getRouterInstance = createIsomorphicFn().client(() => window.__TSR_ROUTER__).server(() => getStartContext().getRouter());
 export {
   getRouterInstance
 };

package/dist/esm/getRouterInstance.js.map

@@ -1 +1 @@
-{"version":3,"file":"getRouterInstance.js","sources":["../../src/getRouterInstance.ts"],"sourcesContent":["import { getStartContext } from '@tanstack/start-storage-context'\nimport { createIsomorphicFn } from './createIsomorphicFn'\n\n// TODO should this be a public API\nexport const getRouterInstance = createIsomorphicFn()\n  .client(() => window.__TSR_ROUTER__!)\n  .server(() => getStartContext().router)\n"],"names":[],"mappings":";;AAIO,MAAM,oBAAoB,qBAC9B,OAAO,MAAM,OAAO,cAAe,EACnC,OAAO,MAAM,gBAAA,EAAkB,MAAM;"}
+{"version":3,"file":"getRouterInstance.js","sources":["../../src/getRouterInstance.ts"],"sourcesContent":["import { getStartContext } from '@tanstack/start-storage-context'\nimport { createIsomorphicFn } from './createIsomorphicFn'\nimport type { Awaitable, RegisteredRouter } from '@tanstack/router-core'\n\nexport const getRouterInstance: () => Awaitable<RegisteredRouter> =\n  createIsomorphicFn()\n    .client(() => window.__TSR_ROUTER__!)\n    .server(() => getStartContext().getRouter())\n"],"names":[],"mappings":";;AAIO,MAAM,oBACX,mBAAA,EACG,OAAO,MAAM,OAAO,cAAe,EACnC,OAAO,MAAM,gBAAA,EAAkB,WAAW;"}

package/dist/esm/getServerContextAfterGlobalMiddlewares.d.ts

@@ -0,0 +1 @@
+export declare const getServerContextAfterGlobalMiddlewares: () => any;

package/dist/esm/getServerContextAfterGlobalMiddlewares.js

@@ -0,0 +1,10 @@
+import { getStartContext } from "@tanstack/start-storage-context";
+import { createServerOnlyFn } from "./envOnly.js";
+const getServerContextAfterGlobalMiddlewares = createServerOnlyFn(() => {
+  const start = getStartContext();
+  return start.contextAfterGlobalMiddlewares;
+});
+export {
+  getServerContextAfterGlobalMiddlewares
+};
+//# sourceMappingURL=getServerContextAfterGlobalMiddlewares.js.map

package/dist/esm/getServerContextAfterGlobalMiddlewares.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getServerContextAfterGlobalMiddlewares.js","sources":["../../src/getServerContextAfterGlobalMiddlewares.ts"],"sourcesContent":["import { getStartContext } from '@tanstack/start-storage-context'\nimport { createServerOnlyFn } from './envOnly'\n\nexport const getServerContextAfterGlobalMiddlewares = createServerOnlyFn(() => {\n  const start = getStartContext()\n  return start.contextAfterGlobalMiddlewares\n})\n"],"names":[],"mappings":";;AAGO,MAAM,yCAAyC,mBAAmB,MAAM;AAC7E,QAAM,QAAQ,gBAAA;AACd,SAAO,MAAM;AACf,CAAC;"}

package/dist/esm/getStartOptions.d.ts

@@ -0,0 +1 @@
+export declare const getStartOptions: import('./createIsomorphicFn.js').IsomorphicFn<[], any, import('./createStart.js').AnyStartInstanceOptions>;

package/dist/esm/getStartOptions.js

@@ -0,0 +1,7 @@
+import { getStartContext } from "@tanstack/start-storage-context";
+import { createIsomorphicFn } from "./createIsomorphicFn.js";
+const getStartOptions = createIsomorphicFn().client(() => window.__TSS_START_OPTIONS__).server(() => getStartContext().startOptions);
+export {
+  getStartOptions
+};
+//# sourceMappingURL=getStartOptions.js.map

package/dist/esm/getStartOptions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getStartOptions.js","sources":["../../src/getStartOptions.ts"],"sourcesContent":["import { getStartContext } from '@tanstack/start-storage-context'\nimport { createIsomorphicFn } from './createIsomorphicFn'\n\nexport const getStartOptions = createIsomorphicFn()\n  .client(() => window.__TSS_START_OPTIONS__!)\n  .server(() => getStartContext().startOptions)\n"],"names":[],"mappings":";;AAGO,MAAM,kBAAkB,qBAC5B,OAAO,MAAM,OAAO,qBAAsB,EAC1C,OAAO,MAAM,gBAAA,EAAkB,YAAY;"}

package/dist/esm/global.d.ts

@@ -0,0 +1,7 @@
+import { AnyStartInstanceOptions } from './createStart.js';
+declare global {
+    interface Window {
+        __TSS_START_OPTIONS__?: AnyStartInstanceOptions;
+    }
+}
+export {};

package/dist/esm/index.d.ts

@@ -3,10 +3,15 @@ export { hydrate, json, mergeHeaders } from '@tanstack/router-core/ssr/client';
 export { createIsomorphicFn, type IsomorphicFn, type ServerOnlyFn, type ClientOnlyFn, type IsomorphicFnBase, } from './createIsomorphicFn.js';
 export { createServerOnlyFn, createClientOnlyFn } from './envOnly.js';
 export { createServerFn } from './createServerFn.js';
-export { createMiddleware, type IntersectAllValidatorInputs, type IntersectAllValidatorOutputs, type FunctionMiddlewareServerFn, type AnyFunctionMiddleware, type FunctionMiddlewareOptions, type FunctionMiddlewareWithTypes, type FunctionMiddlewareValidator, type FunctionMiddlewareServer, type FunctionMiddlewareAfterClient, type FunctionMiddlewareAfterServer, type FunctionMiddleware, type FunctionMiddlewareClientFnOptions, type FunctionMiddlewareClientFnResult, type FunctionMiddlewareClientNextFn, type FunctionClientResultWithContext, type AssignAllClientContextBeforeNext, type AssignAllMiddleware, type AssignAllServerContext, type FunctionMiddlewareAfterValidator, type FunctionMiddlewareClientFn, type FunctionMiddlewareServerFnResult, type FunctionMiddlewareClient, type FunctionMiddlewareServerFnOptions, type FunctionMiddlewareServerNextFn, type FunctionServerResultWithContext, type AnyRequestMiddleware, } from './createMiddleware.js';
-export { registerGlobalMiddleware, globalMiddleware, } from './registerGlobalMiddleware.js';
-export type { CompiledFetcherFnOptions, CompiledFetcherFn, Fetcher, RscStream, FetcherData, FetcherBaseOptions, ServerFn, ServerFnCtx, ServerFnResponseType, MiddlewareFn, ServerFnMiddlewareOptions, ServerFnMiddlewareResult, ServerFnBuilder, ServerFnBaseOptions, NextFn, Method, OptionalFetcher, RequiredFetcher, } from './createServerFn.js';
-export { applyMiddleware, execValidator, serverFnBaseToMiddleware, flattenMiddlewares, executeMiddleware, } from './createServerFn.js';
-export { createClientRpc } from './createClientRpc.js';
-export { getDefaultSerovalPlugins } from './serializer/getDefaultSerovalPlugins.js';
+export { createMiddleware, type IntersectAllValidatorInputs, type IntersectAllValidatorOutputs, type FunctionMiddlewareServerFn, type AnyFunctionMiddleware, type FunctionMiddlewareOptions, type FunctionMiddlewareWithTypes, type FunctionMiddlewareValidator, type FunctionMiddlewareServer, type FunctionMiddlewareAfterClient, type FunctionMiddlewareAfterServer, type FunctionMiddleware, type FunctionMiddlewareClientFnOptions, type FunctionMiddlewareClientFnResult, type FunctionMiddlewareClientNextFn, type FunctionClientResultWithContext, type AssignAllClientContextBeforeNext, type AssignAllMiddleware, type FunctionMiddlewareAfterValidator, type FunctionMiddlewareClientFn, type FunctionMiddlewareServerFnResult, type FunctionMiddlewareClient, type FunctionMiddlewareServerFnOptions, type FunctionMiddlewareServerNextFn, type FunctionServerResultWithContext, type AnyRequestMiddleware, } from './createMiddleware.js';
+export type { CompiledFetcherFnOptions, CompiledFetcherFn, Fetcher, RscStream, FetcherData, FetcherBaseOptions, ServerFn, ServerFnCtx, MiddlewareFn, ServerFnMiddlewareOptions, ServerFnMiddlewareResult, ServerFnBuilder, ServerFnBaseOptions, NextFn, Method, OptionalFetcher, RequiredFetcher, } from './createServerFn.js';
+export { applyMiddleware, execValidator, flattenMiddlewares, executeMiddleware, } from './createServerFn.js';
 export { TSS_FORMDATA_CONTEXT, TSS_SERVER_FUNCTION, X_TSS_SERIALIZED, } from './constants.js';
+export type * from './serverRoute.js';
+export type * from './startEntry.js';
+export { createStart } from './createStart.js';
+export type { AnyStartInstance, AnyStartInstanceOptions } from './createStart.js';
+export type { Register } from '@tanstack/router-core';
+export { getRouterInstance } from './getRouterInstance.js';
+export { getDefaultSerovalPlugins } from './getDefaultSerovalPlugins.js';
+export { getGlobalStartContext } from './getGlobalStartContext.js';

package/dist/esm/index.js

@@ -1,32 +1,32 @@
 import { hydrate, json, mergeHeaders } from "@tanstack/router-core/ssr/client";
 import { createIsomorphicFn } from "./createIsomorphicFn.js";
 import { createClientOnlyFn, createServerOnlyFn } from "./envOnly.js";
-import { applyMiddleware, createServerFn, execValidator, executeMiddleware, flattenMiddlewares, serverFnBaseToMiddleware } from "./createServerFn.js";
+import { applyMiddleware, createServerFn, execValidator, executeMiddleware, flattenMiddlewares } from "./createServerFn.js";
 import { createMiddleware } from "./createMiddleware.js";
-import { globalMiddleware, registerGlobalMiddleware } from "./registerGlobalMiddleware.js";
-import { createClientRpc } from "./createClientRpc.js";
-import { getDefaultSerovalPlugins } from "./serializer/getDefaultSerovalPlugins.js";
 import { TSS_FORMDATA_CONTEXT, TSS_SERVER_FUNCTION, X_TSS_SERIALIZED } from "./constants.js";
+import { createStart } from "./createStart.js";
+import { getRouterInstance } from "./getRouterInstance.js";
+import { getDefaultSerovalPlugins } from "./getDefaultSerovalPlugins.js";
+import { getGlobalStartContext } from "./getGlobalStartContext.js";
 export {
   TSS_FORMDATA_CONTEXT,
   TSS_SERVER_FUNCTION,
   X_TSS_SERIALIZED,
   applyMiddleware,
   createClientOnlyFn,
-  createClientRpc,
   createIsomorphicFn,
   createMiddleware,
   createServerFn,
   createServerOnlyFn,
+  createStart,
   execValidator,
   executeMiddleware,
   flattenMiddlewares,
   getDefaultSerovalPlugins,
-  globalMiddleware,
+  getGlobalStartContext,
+  getRouterInstance,
   hydrate,
   json,
-  mergeHeaders,
-  registerGlobalMiddleware,
-  serverFnBaseToMiddleware
+  mergeHeaders
 };
 //# sourceMappingURL=index.js.map

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/serverRoute.d.ts

@@ -0,0 +1,66 @@
+import { AnyContext, AnyRoute, Assign, Constrain, Expand, ResolveParams, UnionToIntersection } from '@tanstack/router-core';
+import { AnyRequestMiddleware, AssignAllServerRequestContext } from './createMiddleware.js';
+declare module '@tanstack/router-core' {
+    interface FilebaseRouteOptionsInterface<TRegister, TParentRoute extends AnyRoute = AnyRoute, TId extends string = string, TPath extends string = string, TSearchValidator = undefined, TParams = {}, TLoaderDeps extends Record<string, any> = {}, TLoaderFn = undefined, TRouterContext = {}, TRouteContextFn = AnyContext, TBeforeLoadFn = AnyContext, TRemountDepsFn = AnyContext, TSSR = unknown, TServerMiddlewares = unknown, THandlers = undefined> {
+        server?: RouteServerOptions<TRegister, AnyRoute, TPath, TParams, TLoaderDeps, TLoaderFn, TRouterContext, TRouteContextFn, TBeforeLoadFn, TServerMiddlewares, THandlers>;
+    }
+    interface RouteTypes<in out TRegister, in out TParentRoute extends AnyRoute, in out TPath extends string, in out TFullPath extends string, in out TCustomId extends string, in out TId extends string, in out TSearchValidator, in out TParams, in out TRouterContext, in out TRouteContextFn, in out TBeforeLoadFn, in out TLoaderDeps, in out TLoaderFn, in out TChildren, in out TFileRouteTypes, in out TSSR, in out TServerMiddlewares, in out THandlers> {
+        middleware: TServerMiddlewares;
+        allServerContext: ResolveAllServerContext<TRegister, TParentRoute, TServerMiddlewares>;
+    }
+    interface BeforeLoadContextOptions<in out TRegister, in out TParentRoute extends AnyRoute, in out TSearchValidator, in out TParams, in out TRouterContext, in out TRouteContextFn, in out TServerMiddlewares, in out THandlers> {
+        serverContext?: Expand<Assign<ResolveAllServerContext<TRegister, TParentRoute, TServerMiddlewares>, ExtractHandlersContext<THandlers>>>;
+    }
+    interface LoaderFnContext<in out TRegister, in out TParentRoute extends AnyRoute = AnyRoute, in out TId extends string = string, in out TParams = {}, in out TLoaderDeps = {}, in out TRouterContext = {}, in out TRouteContextFn = AnyContext, in out TBeforeLoadFn = AnyContext, in out TServerMiddlewares = unknown, in out THandlers = undefined> {
+        serverContext?: Expand<Assign<ResolveAllServerContext<TRegister, TParentRoute, TServerMiddlewares>, ExtractHandlersContext<THandlers>>>;
+    }
+}
+type ExtractHandlersContext<THandlers> = THandlers extends (...args: any) => CustomHandlerFunctionsRecord<any, any, any, any, any, infer TServerContext> ? UnionToIntersection<TServerContext> : THandlers extends Record<string, RouteMethodHandler<any, any, any, any, any, infer TServerContext>> ? UnionToIntersection<TServerContext> : undefined;
+export interface RouteServerOptions<TRegister, TParentRoute extends AnyRoute, TPath extends string, TParams, TLoaderDeps, TLoaderFn, TRouterContext, TRouteContextFn, TBeforeLoadFn, TServerMiddlewares, THandlers> {
+    middleware?: Constrain<TServerMiddlewares, ReadonlyArray<AnyRequestMiddleware>>;
+    handlers?: Constrain<THandlers, Partial<Record<RouteMethod, RouteMethodHandlerFn<TRegister, TParentRoute, TPath, TServerMiddlewares, any, any>>> | ((opts: HandlersFnOpts<TRegister, TParentRoute, TPath, TServerMiddlewares>) => CustomHandlerFunctionsRecord<TRegister, TParentRoute, TPath, TServerMiddlewares, any, any>)>;
+    test?: (test: Expand<ExtractHandlersContext<THandlers>>) => void;
+}
+declare const createHandlersSymbol: unique symbol;
+type CustomHandlerFunctionsRecord<TRegister, TParentRoute extends AnyRoute, TPath extends string, TServerMiddlewares, TMethodMiddlewares, TServerContext> = {
+    [createHandlersSymbol]: true;
+} & Partial<Record<RouteMethod, RouteMethodHandler<TRegister, TParentRoute, TPath, TServerMiddlewares, TMethodMiddlewares, TServerContext>>>;
+export interface HandlersFnOpts<TRegister, TParentRoute extends AnyRoute, TPath extends string, TServerMiddlewares> {
+    createHandlers: CreateHandlersFn<TRegister, TParentRoute, TPath, TServerMiddlewares>;
+}
+export type CreateHandlersFn<TRegister, TParentRoute extends AnyRoute, TPath extends string, TServerMiddlewares> = <const TMethodAllMiddlewares, const TMethodGetMiddlewares, const TMethodPostMiddlewares, const TMethodPutMiddlewares, const TMethodPatchMiddlewares, const TMethodDeleteMiddlewares, const TMethodOptionsMiddlewares, const TMethodHeadMiddlewares, TServerContext>(opts: CreateMethodFnOpts<TRegister, TParentRoute, TPath, TServerMiddlewares, TMethodAllMiddlewares, TMethodGetMiddlewares, TMethodPostMiddlewares, TMethodPutMiddlewares, TMethodPatchMiddlewares, TMethodDeleteMiddlewares, TMethodOptionsMiddlewares, TMethodHeadMiddlewares, TServerContext>) => CustomHandlerFunctionsRecord<TRegister, TParentRoute, TPath, TServerMiddlewares, any, TServerContext>;
+export interface CreateMethodFnOpts<TRegister, TParentRoute extends AnyRoute, TPath extends string, TServerMiddlewares, TMethodAllMiddlewares, TMethodGetMiddlewares, TMethodPostMiddlewares, TMethodPutMiddlewares, TMethodPatchMiddlewares, TMethodDeleteMiddlewares, TMethodOptionsMiddlewares, TMethodHeadMiddlewares, TServerContext> {
+    ALL?: RouteMethodHandler<TRegister, TParentRoute, TPath, TServerMiddlewares, TMethodAllMiddlewares, TServerContext>;
+    GET?: RouteMethodHandler<TRegister, TParentRoute, TPath, TServerMiddlewares, TMethodGetMiddlewares, TServerContext>;
+    POST?: RouteMethodHandler<TRegister, TParentRoute, TPath, TServerMiddlewares, TMethodPostMiddlewares, TServerContext>;
+    PUT?: RouteMethodHandler<TRegister, TParentRoute, TPath, TServerMiddlewares, TMethodPutMiddlewares, TServerContext>;
+    PATCH?: RouteMethodHandler<TRegister, TParentRoute, TPath, TServerMiddlewares, TMethodPatchMiddlewares, TServerContext>;
+    DELETE?: RouteMethodHandler<TRegister, TParentRoute, TPath, TServerMiddlewares, TMethodDeleteMiddlewares, TServerContext>;
+    OPTIONS?: RouteMethodHandler<TRegister, TParentRoute, TPath, TServerMiddlewares, TMethodOptionsMiddlewares, TServerContext>;
+    HEAD?: RouteMethodHandler<TRegister, TParentRoute, TPath, TServerMiddlewares, TMethodHeadMiddlewares, TServerContext>;
+}
+export type RouteMethodHandler<TRegister, TParentRoute extends AnyRoute, TPath extends string, TServerMiddlewares, TMethodMiddlewares, TServerContext> = RouteMethodHandlerFn<TRegister, TParentRoute, TPath, TServerMiddlewares, TMethodMiddlewares, TServerContext> | RouteMethodBuilderOptions<TRegister, TParentRoute, TPath, TServerMiddlewares, TMethodMiddlewares, TServerContext>;
+export interface RouteMethodBuilderOptions<TRegister, TParentRoute extends AnyRoute, TFullPath extends string, TServerMiddlewares, TMethodMiddlewares, TResponse> {
+    handler?: RouteMethodHandlerFn<TRegister, TParentRoute, TFullPath, TServerMiddlewares, TMethodMiddlewares, TResponse>;
+    middleware?: Constrain<TMethodMiddlewares, ReadonlyArray<AnyRequestMiddleware>>;
+}
+export type ResolveAllServerContext<TRegister, TParentRoute extends AnyRoute, TServerMiddlewares> = unknown extends TParentRoute ? AssignAllServerRequestContext<TRegister, TServerMiddlewares, {}> : Assign<TParentRoute['types']['allServerContext'], AssignAllServerRequestContext<TRegister, TServerMiddlewares, {}>>;
+export type RouteMethod = 'ALL' | 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'OPTIONS' | 'HEAD';
+export type RouteMethodHandlerFn<TRegister, TParentRoute extends AnyRoute, TFullPath extends string, TServerMiddlewares, TMethodMiddlewares, TServerContext> = (ctx: RouteMethodHandlerCtx<TRegister, TParentRoute, TFullPath, TServerMiddlewares, TMethodMiddlewares>) => RouteMethodResult<TServerContext> | Promise<RouteMethodResult<TServerContext>>;
+export type RouteMethodResult<TContext> = Response | undefined | RouteMethodNextResult<TContext>;
+export type RouteMethodNextResult<TContext> = {
+    isNext: true;
+    context: TContext;
+};
+export interface RouteMethodHandlerCtx<in out TRegister, in out TParentRoute extends AnyRoute, in out TFullPath extends string, in out TServerMiddlewares, in out TMethodMiddlewares> {
+    context: Expand<AssignAllMethodContext<TRegister, TParentRoute, TServerMiddlewares, TMethodMiddlewares>>;
+    request: Request;
+    params: Expand<ResolveParams<TFullPath>>;
+    pathname: TFullPath;
+    next: <TContext = undefined>(options?: {
+        context?: TContext;
+    }) => RouteMethodNextResult<TContext>;
+}
+export type MergeMethodMiddlewares<TServerMiddlewares, TMethodMiddlewares> = TServerMiddlewares extends ReadonlyArray<any> ? TMethodMiddlewares extends ReadonlyArray<any> ? readonly [...TServerMiddlewares, ...TMethodMiddlewares] : TServerMiddlewares : TMethodMiddlewares;
+export type AssignAllMethodContext<TRegister, TParentRoute extends AnyRoute, TServerMiddlewares, TMethodMiddlewares> = ResolveAllServerContext<TRegister, TParentRoute, MergeMethodMiddlewares<TServerMiddlewares, TMethodMiddlewares>>;
+export {};

package/dist/esm/startEntry.d.ts

@@ -0,0 +1,8 @@
+import { AnyRouter, Awaitable } from '@tanstack/router-core';
+import { AnyStartInstance } from './createStart.js';
+export interface StartEntry {
+    startInstance: AnyStartInstance | undefined;
+}
+export interface RouterEntry {
+    getRouter: () => Awaitable<AnyRouter>;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/start-client-core",
-  "version": "1.132.0-alpha.8",
+  "version": "1.132.0",
   "description": "Modern and scalable routing for React applications",
   "author": "Tanner Linsley",
   "license": "MIT",
@@ -32,24 +32,37 @@
         "default": "./dist/esm/index.js"
       }
     },
+    "./client": {
+      "import": {
+        "types": "./dist/esm/client/index.d.ts",
+        "default": "./dist/esm/client/index.js"
+      }
+    },
     "./package.json": "./package.json"
   },
+  "imports": {
+    "#tanstack-start-entry": {
+      "default": "./dist/esm/fake-start-entry.js"
+    },
+    "#tanstack-router-entry": {
+      "default": "./dist/esm/fake-start-entry.js"
+    }
+  },
   "sideEffects": false,
   "files": [
     "dist",
     "src"
   ],
   "engines": {
-    "node": ">=12"
+    "node": ">=22.12.0"
   },
   "dependencies": {
     "cookie-es": "^1.2.2",
     "seroval": "^1.3.2",
-    "seroval-plugins": "^1.3.2",
     "tiny-invariant": "^1.3.3",
     "tiny-warning": "^1.0.3",
-    "@tanstack/router-core": "1.132.0-alpha.8",
-    "@tanstack/start-storage-context": "1.132.0-alpha.8"
+    "@tanstack/router-core": "1.132.0",
+    "@tanstack/start-storage-context": "1.132.0"
   },
   "scripts": {}
 }

package/src/{serializer → client}/ServerFunctionSerializationAdapter.ts

@@ -1,11 +1,11 @@
 import { createSerializationAdapter } from '@tanstack/router-core'
-import { createClientRpc } from '../createClientRpc'
 import { TSS_SERVER_FUNCTION } from '../constants'
+import { createClientRpc } from './createClientRpc'
 
 export const ServerFunctionSerializationAdapter = createSerializationAdapter({
   key: '$TSS/serverfn',
   test: (v): v is { functionId: string } => {
-    if (typeof v !== 'object' || v === null) return false
+    if (typeof v !== 'function') return false
 
     if (!(TSS_SERVER_FUNCTION in v)) return false
 

package/src/{createClientRpc.ts → client/createClientRpc.ts}

@@ -1,12 +1,14 @@
-import { TSS_SERVER_FUNCTION } from './constants'
+import { TSS_SERVER_FUNCTION } from '../constants'
 import { serverFnFetcher } from './serverFnFetcher'
 
-let baseUrl: string
+// make sure this get's hoisted
+// eslint-disable-next-line no-var
+var baseUrl: string
 function sanitizeBase(base: string) {
   return base.replace(/^\/|\/$/g, '')
 }
 
-export const createClientRpc = (functionId: string) => {
+export function createClientRpc(functionId: string) {
   if (!baseUrl) {
     const sanitizedAppBase = sanitizeBase(process.env.TSS_APP_BASE || '/')
     const sanitizedServerBase = sanitizeBase(process.env.TSS_SERVER_FN_BASE!)

package/src/client/hydrateStart.ts

@@ -0,0 +1,33 @@
+import { hydrate } from '@tanstack/router-core/ssr/client'
+
+import { ServerFunctionSerializationAdapter } from './ServerFunctionSerializationAdapter'
+import type { AnyStartInstanceOptions } from '../createStart'
+import type { AnyRouter, AnySerializationAdapter } from '@tanstack/router-core'
+import * as startEntry from '#tanstack-start-entry'
+import { getRouter } from '#tanstack-router-entry'
+
+export async function hydrateStart(): Promise<AnyRouter> {
+  const router = await getRouter()
+
+  let serializationAdapters: Array<AnySerializationAdapter>
+  if (startEntry.startInstance) {
+    const startOptions = await startEntry.startInstance.getOptions()
+    window.__TSS_START_OPTIONS__ = startOptions as AnyStartInstanceOptions
+    serializationAdapters = startOptions.serializationAdapters
+    router.options.defaultSsr = startOptions.defaultSsr
+  } else {
+    serializationAdapters = []
+    window.__TSS_START_OPTIONS__ = {
+      serializationAdapters,
+    } as AnyStartInstanceOptions
+  }
+
+  serializationAdapters.push(ServerFunctionSerializationAdapter)
+  router.options.serializationAdapters = serializationAdapters
+
+  if (!router.state.matches.length) {
+    await hydrate(router)
+  }
+
+  return router
+}

package/src/client/index.ts

@@ -0,0 +1,3 @@
+export { createClientRpc } from './createClientRpc'
+
+export { hydrateStart } from './hydrateStart'

package/src/{serverFnFetcher.ts → client/serverFnFetcher.ts}

@@ -6,9 +6,9 @@ import {
 } from '@tanstack/router-core'
 import { fromCrossJSON, toJSONAsync } from 'seroval'
 import invariant from 'tiny-invariant'
-import { getClientSerovalPlugins } from './serializer/getClientSerovalPlugins'
-import { TSS_FORMDATA_CONTEXT, X_TSS_SERIALIZED } from './constants'
-import type { FunctionMiddlewareClientFnOptions } from './createMiddleware'
+import { getDefaultSerovalPlugins } from '../getDefaultSerovalPlugins'
+import { TSS_FORMDATA_CONTEXT, X_TSS_SERIALIZED } from '../constants'
+import type { FunctionMiddlewareClientFnOptions } from '../createMiddleware'
 import type { Plugin as SerovalPlugin } from 'seroval'
 
 let serovalPlugins: Array<SerovalPlugin<any, any>> | null = null
@@ -19,20 +19,14 @@ export async function serverFnFetcher(
   handler: (url: string, requestInit: RequestInit) => Promise<Response>,
 ) {
   if (!serovalPlugins) {
-    serovalPlugins = getClientSerovalPlugins()
+    serovalPlugins = getDefaultSerovalPlugins()
   }
   const _first = args[0]
 
   // If createServerFn was used to wrap the fetcher,
   // We need to handle the arguments differently
   if (isPlainObject(_first) && _first.method) {
-    const first = _first as FunctionMiddlewareClientFnOptions<
-      any,
-      any,
-      any,
-      any,
-      any
-    > & {
+    const first = _first as FunctionMiddlewareClientFnOptions<any, any, any> & {
       headers: HeadersInit
     }
     const type = first.data instanceof FormData ? 'formData' : 'payload'
@@ -53,6 +47,9 @@ export async function serverFnFetcher(
 
     // If the method is GET, we need to move the payload to the query string
     if (first.method === 'GET') {
+      if (type === 'formData') {
+        throw new Error('FormData is not supported with GET requests')
+      }
       const encodedPayload = encode({
         payload: await serializePayload(first),
       })
@@ -71,9 +68,6 @@ export async function serverFnFetcher(
     } else {
       url += `?createServerFn`
     }
-    if (first.response === 'raw') {
-      url += `&raw`
-    }
 
     return await getResponse(async () =>
       handler(url, {
@@ -101,12 +95,13 @@ export async function serverFnFetcher(
 }
 
 async function serializePayload(
-  opts: FunctionMiddlewareClientFnOptions<any, any, any, any, any>,
+  opts: FunctionMiddlewareClientFnOptions<any, any, any>,
 ) {
   const payloadToSerialize: any = {}
   if (opts.data) {
     payloadToSerialize['data'] = opts.data
   }
+
   // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
   if (opts.context && Object.keys(opts.context).length > 0) {
     payloadToSerialize['context'] = opts.context
@@ -122,7 +117,7 @@ async function serialize(data: any) {
 }
 
 async function getFetcherRequestOptions(
-  opts: FunctionMiddlewareClientFnOptions<any, any, any, any, any>,
+  opts: FunctionMiddlewareClientFnOptions<any, any, any>,
 ) {
   if (opts.method === 'POST') {
     if (opts.data instanceof FormData) {

package/src/constants.ts

@@ -1,5 +1,8 @@
 export const TSS_FORMDATA_CONTEXT = '__TSS_CONTEXT'
 export const TSS_SERVER_FUNCTION = Symbol.for('TSS_SERVER_FUNCTION')
+export const TSS_SERVER_FUNCTION_FACTORY = Symbol.for(
+  'TSS_SERVER_FUNCTION_FACTORY',
+)
 
 export const X_TSS_SERIALIZED = 'x-tss-serialized'
 export {}