@tanstack/react-start-client 1.111.10

package/dist/esm/StartClient.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"StartClient.js","sources":["../../src/StartClient.tsx"],"sourcesContent":["import { Await, RouterProvider } from '@tanstack/react-router'\nimport { hydrate } from './ssr-client'\nimport type { AnyRouter } from '@tanstack/react-router'\n\nlet hydrationPromise: Promise<void | Array<Array<void>>> | undefined\n\nexport function StartClient(props: { router: AnyRouter }) {\n  if (!hydrationPromise) {\n    if (!props.router.state.matches.length) {\n      hydrationPromise = hydrate(props.router)\n    } else {\n      hydrationPromise = Promise.resolve()\n    }\n  }\n  return (\n    <Await\n      promise={hydrationPromise}\n      children={() => <RouterProvider router={props.router} />}\n    />\n  )\n}\n"],"names":[],"mappings":";;;AAIA,IAAI;AAEG,SAAS,YAAY,OAA8B;AACxD,MAAI,CAAC,kBAAkB;AACrB,QAAI,CAAC,MAAM,OAAO,MAAM,QAAQ,QAAQ;AACnB,yBAAA,QAAQ,MAAM,MAAM;AAAA,IAAA,OAClC;AACL,yBAAmB,QAAQ,QAAQ;AAAA,IAAA;AAAA,EACrC;AAGA,SAAA;AAAA,IAAC;AAAA,IAAA;AAAA,MACC,SAAS;AAAA,MACT,UAAU,MAAM,oBAAC,gBAAe,EAAA,QAAQ,MAAM,OAAQ,CAAA;AAAA,IAAA;AAAA,EACxD;AAEJ;"}

package/dist/esm/createIsomorphicFn.d.ts

@@ -0,0 +1,12 @@
+export type IsomorphicFn<TArgs extends Array<any> = [], TServer = undefined, TClient = undefined> = (...args: TArgs) => TServer | TClient;
+export interface ServerOnlyFn<TArgs extends Array<any>, TServer> extends IsomorphicFn<TArgs, TServer> {
+    client: <TClient>(clientImpl: (...args: TArgs) => TClient) => IsomorphicFn<TArgs, TServer, TClient>;
+}
+export interface ClientOnlyFn<TArgs extends Array<any>, TClient> extends IsomorphicFn<TArgs, undefined, TClient> {
+    server: <TServer>(serverImpl: (...args: TArgs) => TServer) => IsomorphicFn<TArgs, TServer, TClient>;
+}
+export interface IsomorphicFnBase extends IsomorphicFn {
+    server: <TArgs extends Array<any>, TServer>(serverImpl: (...args: TArgs) => TServer) => ServerOnlyFn<TArgs, TServer>;
+    client: <TArgs extends Array<any>, TClient>(clientImpl: (...args: TArgs) => TClient) => ClientOnlyFn<TArgs, TClient>;
+}
+export declare function createIsomorphicFn(): IsomorphicFnBase;

package/dist/esm/createIsomorphicFn.js

@@ -0,0 +1,7 @@
+function createIsomorphicFn() {
+  return null;
+}
+export {
+  createIsomorphicFn
+};
+//# sourceMappingURL=createIsomorphicFn.js.map

package/dist/esm/createIsomorphicFn.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createIsomorphicFn.js","sources":["../../src/createIsomorphicFn.ts"],"sourcesContent":["// a function that can have different implementations on the client and server.\n// implementations not provided will default to a no-op function.\n\nexport type IsomorphicFn<\n  TArgs extends Array<any> = [],\n  TServer = undefined,\n  TClient = undefined,\n> = (...args: TArgs) => TServer | TClient\n\nexport interface ServerOnlyFn<TArgs extends Array<any>, TServer>\n  extends IsomorphicFn<TArgs, TServer> {\n  client: <TClient>(\n    clientImpl: (...args: TArgs) => TClient,\n  ) => IsomorphicFn<TArgs, TServer, TClient>\n}\n\nexport interface ClientOnlyFn<TArgs extends Array<any>, TClient>\n  extends IsomorphicFn<TArgs, undefined, TClient> {\n  server: <TServer>(\n    serverImpl: (...args: TArgs) => TServer,\n  ) => IsomorphicFn<TArgs, TServer, TClient>\n}\n\nexport interface IsomorphicFnBase extends IsomorphicFn {\n  server: <TArgs extends Array<any>, TServer>(\n    serverImpl: (...args: TArgs) => TServer,\n  ) => ServerOnlyFn<TArgs, TServer>\n  client: <TArgs extends Array<any>, TClient>(\n    clientImpl: (...args: TArgs) => TClient,\n  ) => ClientOnlyFn<TArgs, TClient>\n}\n\n// this is a dummy function, it will be replaced by the transformer\nexport function createIsomorphicFn(): IsomorphicFnBase {\n  return null!\n}\n"],"names":[],"mappings":"AAiCO,SAAS,qBAAuC;AAC9C,SAAA;AACT;"}

package/dist/esm/createMiddleware.d.ts

@@ -0,0 +1,129 @@
+import { ConstrainValidator, Method, ServerFnTypeOrTypeFn } from './createServerFn.js';
+import { Assign, Constrain, Expand, IntersectAssign, ResolveValidatorInput, ResolveValidatorOutput, SerializerStringify } from '@tanstack/router-core';
+export type AssignAllMiddleware<TMiddlewares, TType extends keyof AnyMiddleware['_types'], TAcc = undefined> = TMiddlewares extends readonly [
+    infer TMiddleware extends AnyMiddleware,
+    ...infer TRest
+] ? AssignAllMiddleware<TRest, TType, Assign<TAcc, TMiddleware['_types'][TType]>> : TAcc;
+/**
+ * Recursively resolve the client context type produced by a sequence of middleware
+ */
+export type AssignAllClientContextBeforeNext<TMiddlewares, TClientContext = undefined> = unknown extends TClientContext ? TClientContext : Assign<AssignAllMiddleware<TMiddlewares, 'allClientContextBeforeNext'>, TClientContext>;
+export type AssignAllClientSendContext<TMiddlewares, TSendContext = undefined> = unknown extends TSendContext ? TSendContext : Assign<AssignAllMiddleware<TMiddlewares, 'allClientSendContext'>, TSendContext>;
+export type AssignAllClientContextAfterNext<TMiddlewares, TClientContext = undefined, TSendContext = undefined> = unknown extends TClientContext ? Assign<TClientContext, TSendContext> : Assign<AssignAllMiddleware<TMiddlewares, 'allClientContextAfterNext'>, Assign<TClientContext, TSendContext>>;
+/**
+ * Recursively resolve the server context type produced by a sequence of middleware
+ */
+export type AssignAllServerContext<TMiddlewares, TSendContext = undefined, TServerContext = undefined> = unknown extends TSendContext ? Assign<TSendContext, TServerContext> : Assign<AssignAllMiddleware<TMiddlewares, 'allServerContext'>, Assign<TSendContext, TServerContext>>;
+export type AssignAllServerSendContext<TMiddlewares, TSendContext = undefined> = unknown extends TSendContext ? TSendContext : Assign<AssignAllMiddleware<TMiddlewares, 'allServerSendContext'>, TSendContext>;
+export type IntersectAllMiddleware<TMiddlewares, TType extends keyof AnyMiddleware['_types'], TAcc = undefined> = TMiddlewares extends readonly [
+    infer TMiddleware extends AnyMiddleware,
+    ...infer TRest
+] ? IntersectAllMiddleware<TRest, TType, IntersectAssign<TAcc, TMiddleware['_types'][TType]>> : TAcc;
+/**
+ * Recursively resolve the input type produced by a sequence of middleware
+ */
+export type IntersectAllValidatorInputs<TMiddlewares, TValidator> = unknown extends TValidator ? TValidator : IntersectAssign<IntersectAllMiddleware<TMiddlewares, 'allInput'>, TValidator extends undefined ? undefined : ResolveValidatorInput<TValidator>>;
+/**
+ * Recursively merge the output type produced by a sequence of middleware
+ */
+export type IntersectAllValidatorOutputs<TMiddlewares, TValidator> = unknown extends TValidator ? TValidator : IntersectAssign<IntersectAllMiddleware<TMiddlewares, 'allOutput'>, TValidator extends undefined ? undefined : ResolveValidatorOutput<TValidator>>;
+export interface MiddlewareOptions<in out TMiddlewares, in out TValidator, in out TServerContext, in out TClientContext> {
+    validateClient?: boolean;
+    middleware?: TMiddlewares;
+    validator?: ConstrainValidator<TValidator>;
+    client?: MiddlewareClientFn<TMiddlewares, TValidator, TServerContext, TClientContext>;
+    server?: MiddlewareServerFn<TMiddlewares, TValidator, TServerContext, unknown, unknown>;
+}
+export type MiddlewareServerNextFn<TMiddlewares, TServerSendContext> = <TNewServerContext = undefined, TSendContext = undefined>(ctx?: {
+    context?: TNewServerContext;
+    sendContext?: SerializerStringify<TSendContext>;
+}) => Promise<ServerResultWithContext<TMiddlewares, TServerSendContext, TNewServerContext, TSendContext>>;
+export interface MiddlewareServerFnOptions<in out TMiddlewares, in out TValidator, in out TServerSendContext> {
+    data: Expand<IntersectAllValidatorOutputs<TMiddlewares, TValidator>>;
+    context: Expand<AssignAllServerContext<TMiddlewares, TServerSendContext>>;
+    next: MiddlewareServerNextFn<TMiddlewares, TServerSendContext>;
+    method: Method;
+    filename: string;
+    functionId: string;
+    signal: AbortSignal;
+}
+export type MiddlewareServerFn<TMiddlewares, TValidator, TServerSendContext, TNewServerContext, TSendContext> = (options: MiddlewareServerFnOptions<TMiddlewares, TValidator, TServerSendContext>) => MiddlewareServerFnResult<TMiddlewares, TServerSendContext, TNewServerContext, TSendContext>;
+export type MiddlewareServerFnResult<TMiddlewares, TServerSendContext, TServerContext, TSendContext> = Promise<ServerResultWithContext<TMiddlewares, TServerSendContext, TServerContext, TSendContext>> | ServerResultWithContext<TMiddlewares, TServerSendContext, TServerContext, TSendContext>;
+export type MiddlewareClientNextFn<TMiddlewares> = <TSendContext = undefined, TNewClientContext = undefined>(ctx?: {
+    context?: TNewClientContext;
+    sendContext?: SerializerStringify<TSendContext>;
+    headers?: HeadersInit;
+}) => Promise<ClientResultWithContext<TMiddlewares, TSendContext, TNewClientContext>>;
+export interface MiddlewareClientFnOptions<in out TMiddlewares, in out TValidator> {
+    data: Expand<IntersectAllValidatorInputs<TMiddlewares, TValidator>>;
+    context: Expand<AssignAllClientContextBeforeNext<TMiddlewares>>;
+    sendContext: Expand<AssignAllServerSendContext<TMiddlewares>>;
+    method: Method;
+    signal: AbortSignal;
+    next: MiddlewareClientNextFn<TMiddlewares>;
+    filename: string;
+    functionId: string;
+    type: ServerFnTypeOrTypeFn<Method, TMiddlewares, TValidator>;
+}
+export type MiddlewareClientFn<TMiddlewares, TValidator, TSendContext, TClientContext> = (options: MiddlewareClientFnOptions<TMiddlewares, TValidator>) => MiddlewareClientFnResult<TMiddlewares, TSendContext, TClientContext>;
+export type MiddlewareClientFnResult<TMiddlewares, TSendContext, TClientContext> = Promise<ClientResultWithContext<TMiddlewares, TSendContext, TClientContext>> | ClientResultWithContext<TMiddlewares, TSendContext, TClientContext>;
+export type ServerResultWithContext<in out TMiddlewares, in out TServerSendContext, in out TServerContext, in out TSendContext> = {
+    'use functions must return the result of next()': true;
+    _types: {
+        context: TServerContext;
+        sendContext: TSendContext;
+    };
+    context: Expand<AssignAllServerContext<TMiddlewares, TServerSendContext, TServerContext>>;
+    sendContext: Expand<AssignAllClientSendContext<TMiddlewares, TSendContext>>;
+};
+export type ClientResultWithContext<in out TMiddlewares, in out TSendContext, in out TClientContext> = {
+    'use functions must return the result of next()': true;
+    context: Expand<AssignAllClientContextAfterNext<TMiddlewares, TClientContext>>;
+    sendContext: Expand<AssignAllServerSendContext<TMiddlewares, TSendContext>>;
+    headers: HeadersInit;
+};
+export type AnyMiddleware = MiddlewareWithTypes<any, any, any, any, any, any>;
+export interface MiddlewareTypes<in out TMiddlewares, in out TValidator, in out TServerContext, in out TServerSendContext, in out TClientContext, in out TClientSendContext> {
+    middlewares: TMiddlewares;
+    input: ResolveValidatorInput<TValidator>;
+    allInput: IntersectAllValidatorInputs<TMiddlewares, TValidator>;
+    output: ResolveValidatorOutput<TValidator>;
+    allOutput: IntersectAllValidatorOutputs<TMiddlewares, TValidator>;
+    clientContext: TClientContext;
+    allClientContextBeforeNext: AssignAllClientContextBeforeNext<TMiddlewares, TClientContext>;
+    allClientContextAfterNext: AssignAllClientContextAfterNext<TMiddlewares, TClientContext, TClientSendContext>;
+    serverContext: TServerContext;
+    serverSendContext: TServerSendContext;
+    allServerSendContext: AssignAllServerSendContext<TMiddlewares, TServerSendContext>;
+    allServerContext: AssignAllServerContext<TMiddlewares, TServerSendContext, TServerContext>;
+    clientSendContext: TClientSendContext;
+    allClientSendContext: AssignAllClientSendContext<TMiddlewares, TClientSendContext>;
+    validator: TValidator;
+}
+export interface MiddlewareWithTypes<TMiddlewares, TValidator, TServerContext, TServerSendContext, TClientContext, TClientSendContext> {
+    _types: MiddlewareTypes<TMiddlewares, TValidator, TServerContext, TServerSendContext, TClientContext, TClientSendContext>;
+    options: MiddlewareOptions<TMiddlewares, TValidator, TServerContext, TClientContext>;
+}
+export interface MiddlewareAfterValidator<TMiddlewares, TValidator> extends MiddlewareWithTypes<TMiddlewares, TValidator, undefined, undefined, undefined, undefined>, MiddlewareServer<TMiddlewares, TValidator, undefined, undefined>, MiddlewareClient<TMiddlewares, TValidator> {
+}
+export interface MiddlewareValidator<TMiddlewares> {
+    validator: <TNewValidator>(input: ConstrainValidator<TNewValidator>) => MiddlewareAfterValidator<TMiddlewares, TNewValidator>;
+}
+export interface MiddlewareAfterServer<TMiddlewares, TValidator, TServerContext, TServerSendContext, TClientContext, TClientSendContext> extends MiddlewareWithTypes<TMiddlewares, TValidator, TServerContext, TServerSendContext, TClientContext, TClientSendContext> {
+}
+export interface MiddlewareServer<TMiddlewares, TValidator, TServerSendContext, TClientContext> {
+    server: <TNewServerContext = undefined, TSendContext = undefined>(server: MiddlewareServerFn<TMiddlewares, TValidator, TServerSendContext, TNewServerContext, TSendContext>) => MiddlewareAfterServer<TMiddlewares, TValidator, TNewServerContext, TServerSendContext, TClientContext, TSendContext>;
+}
+export interface MiddlewareAfterClient<TMiddlewares, TValidator, TServerSendContext, TClientContext> extends MiddlewareWithTypes<TMiddlewares, TValidator, undefined, TServerSendContext, TClientContext, undefined>, MiddlewareServer<TMiddlewares, TValidator, TServerSendContext, TClientContext> {
+}
+export interface MiddlewareClient<TMiddlewares, TValidator> {
+    client: <TSendServerContext = undefined, TNewClientContext = undefined>(client: MiddlewareClientFn<TMiddlewares, TValidator, TSendServerContext, TNewClientContext>) => MiddlewareAfterClient<TMiddlewares, TValidator, TSendServerContext, TNewClientContext>;
+}
+export interface MiddlewareAfterMiddleware<TMiddlewares> extends MiddlewareWithTypes<TMiddlewares, undefined, undefined, undefined, undefined, undefined>, MiddlewareServer<TMiddlewares, undefined, undefined, undefined>, MiddlewareClient<TMiddlewares, undefined>, MiddlewareValidator<TMiddlewares> {
+}
+export interface Middleware extends MiddlewareAfterMiddleware<unknown> {
+    middleware: <const TNewMiddlewares = undefined>(middlewares: Constrain<TNewMiddlewares, ReadonlyArray<AnyMiddleware>>) => MiddlewareAfterMiddleware<TNewMiddlewares>;
+}
+export declare function createMiddleware(options?: {
+    validateClient?: boolean;
+}, __opts?: MiddlewareOptions<unknown, undefined, undefined, undefined>): Middleware;

package/dist/esm/createMiddleware.js

@@ -0,0 +1,34 @@
+function createMiddleware(options, __opts) {
+  const resolvedOptions = __opts || (options || {});
+  return {
+    options: resolvedOptions,
+    middleware: (middleware) => {
+      return createMiddleware(
+        void 0,
+        Object.assign(resolvedOptions, { middleware })
+      );
+    },
+    validator: (validator) => {
+      return createMiddleware(
+        void 0,
+        Object.assign(resolvedOptions, { validator })
+      );
+    },
+    client: (client) => {
+      return createMiddleware(
+        void 0,
+        Object.assign(resolvedOptions, { client })
+      );
+    },
+    server: (server) => {
+      return createMiddleware(
+        void 0,
+        Object.assign(resolvedOptions, { server })
+      );
+    }
+  };
+}
+export {
+  createMiddleware
+};
+//# sourceMappingURL=createMiddleware.js.map

package/dist/esm/createMiddleware.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createMiddleware.js","sources":["../../src/createMiddleware.ts"],"sourcesContent":["import type {\n  ConstrainValidator,\n  Method,\n  ServerFnTypeOrTypeFn,\n} from './createServerFn'\nimport type {\n  Assign,\n  Constrain,\n  Expand,\n  IntersectAssign,\n  ResolveValidatorInput,\n  ResolveValidatorOutput,\n  SerializerStringify,\n} from '@tanstack/router-core'\n\nexport type AssignAllMiddleware<\n  TMiddlewares,\n  TType extends keyof AnyMiddleware['_types'],\n  TAcc = undefined,\n> = TMiddlewares extends readonly [\n  infer TMiddleware extends AnyMiddleware,\n  ...infer TRest,\n]\n  ? AssignAllMiddleware<\n      TRest,\n      TType,\n      Assign<TAcc, TMiddleware['_types'][TType]>\n    >\n  : TAcc\n\n/**\n * Recursively resolve the client context type produced by a sequence of middleware\n */\nexport type AssignAllClientContextBeforeNext<\n  TMiddlewares,\n  TClientContext = undefined,\n> = unknown extends TClientContext\n  ? TClientContext\n  : Assign<\n      AssignAllMiddleware<TMiddlewares, 'allClientContextBeforeNext'>,\n      TClientContext\n    >\n\nexport type AssignAllClientSendContext<\n  TMiddlewares,\n  TSendContext = undefined,\n> = unknown extends TSendContext\n  ? TSendContext\n  : Assign<\n      AssignAllMiddleware<TMiddlewares, 'allClientSendContext'>,\n      TSendContext\n    >\n\nexport type AssignAllClientContextAfterNext<\n  TMiddlewares,\n  TClientContext = undefined,\n  TSendContext = undefined,\n> = unknown extends TClientContext\n  ? Assign<TClientContext, TSendContext>\n  : Assign<\n      AssignAllMiddleware<TMiddlewares, 'allClientContextAfterNext'>,\n      Assign<TClientContext, TSendContext>\n    >\n\n/**\n * Recursively resolve the server context type produced by a sequence of middleware\n */\nexport type AssignAllServerContext<\n  TMiddlewares,\n  TSendContext = undefined,\n  TServerContext = undefined,\n> = unknown extends TSendContext\n  ? Assign<TSendContext, TServerContext>\n  : Assign<\n      AssignAllMiddleware<TMiddlewares, 'allServerContext'>,\n      Assign<TSendContext, TServerContext>\n    >\n\nexport type AssignAllServerSendContext<\n  TMiddlewares,\n  TSendContext = undefined,\n> = unknown extends TSendContext\n  ? TSendContext\n  : Assign<\n      AssignAllMiddleware<TMiddlewares, 'allServerSendContext'>,\n      TSendContext\n    >\n\nexport type IntersectAllMiddleware<\n  TMiddlewares,\n  TType extends keyof AnyMiddleware['_types'],\n  TAcc = undefined,\n> = TMiddlewares extends readonly [\n  infer TMiddleware extends AnyMiddleware,\n  ...infer TRest,\n]\n  ? IntersectAllMiddleware<\n      TRest,\n      TType,\n      IntersectAssign<TAcc, TMiddleware['_types'][TType]>\n    >\n  : TAcc\n\n/**\n * Recursively resolve the input type produced by a sequence of middleware\n */\nexport type IntersectAllValidatorInputs<TMiddlewares, TValidator> =\n  unknown extends TValidator\n    ? TValidator\n    : IntersectAssign<\n        IntersectAllMiddleware<TMiddlewares, 'allInput'>,\n        TValidator extends undefined\n          ? undefined\n          : ResolveValidatorInput<TValidator>\n      >\n/**\n * Recursively merge the output type produced by a sequence of middleware\n */\nexport type IntersectAllValidatorOutputs<TMiddlewares, TValidator> =\n  unknown extends TValidator\n    ? TValidator\n    : IntersectAssign<\n        IntersectAllMiddleware<TMiddlewares, 'allOutput'>,\n        TValidator extends undefined\n          ? undefined\n          : ResolveValidatorOutput<TValidator>\n      >\n\nexport interface MiddlewareOptions<\n  in out TMiddlewares,\n  in out TValidator,\n  in out TServerContext,\n  in out TClientContext,\n> {\n  validateClient?: boolean\n  middleware?: TMiddlewares\n  validator?: ConstrainValidator<TValidator>\n  client?: MiddlewareClientFn<\n    TMiddlewares,\n    TValidator,\n    TServerContext,\n    TClientContext\n  >\n  server?: MiddlewareServerFn<\n    TMiddlewares,\n    TValidator,\n    TServerContext,\n    unknown,\n    unknown\n  >\n}\n\nexport type MiddlewareServerNextFn<TMiddlewares, TServerSendContext> = <\n  TNewServerContext = undefined,\n  TSendContext = undefined,\n>(ctx?: {\n  context?: TNewServerContext\n  sendContext?: SerializerStringify<TSendContext>\n}) => Promise<\n  ServerResultWithContext<\n    TMiddlewares,\n    TServerSendContext,\n    TNewServerContext,\n    TSendContext\n  >\n>\n\nexport interface MiddlewareServerFnOptions<\n  in out TMiddlewares,\n  in out TValidator,\n  in out TServerSendContext,\n> {\n  data: Expand<IntersectAllValidatorOutputs<TMiddlewares, TValidator>>\n  context: Expand<AssignAllServerContext<TMiddlewares, TServerSendContext>>\n  next: MiddlewareServerNextFn<TMiddlewares, TServerSendContext>\n  method: Method\n  filename: string\n  functionId: string\n  signal: AbortSignal\n}\n\nexport type MiddlewareServerFn<\n  TMiddlewares,\n  TValidator,\n  TServerSendContext,\n  TNewServerContext,\n  TSendContext,\n> = (\n  options: MiddlewareServerFnOptions<\n    TMiddlewares,\n    TValidator,\n    TServerSendContext\n  >,\n) => MiddlewareServerFnResult<\n  TMiddlewares,\n  TServerSendContext,\n  TNewServerContext,\n  TSendContext\n>\n\nexport type MiddlewareServerFnResult<\n  TMiddlewares,\n  TServerSendContext,\n  TServerContext,\n  TSendContext,\n> =\n  | Promise<\n      ServerResultWithContext<\n        TMiddlewares,\n        TServerSendContext,\n        TServerContext,\n        TSendContext\n      >\n    >\n  | ServerResultWithContext<\n      TMiddlewares,\n      TServerSendContext,\n      TServerContext,\n      TSendContext\n    >\n\nexport type MiddlewareClientNextFn<TMiddlewares> = <\n  TSendContext = undefined,\n  TNewClientContext = undefined,\n>(ctx?: {\n  context?: TNewClientContext\n  sendContext?: SerializerStringify<TSendContext>\n  headers?: HeadersInit\n}) => Promise<\n  ClientResultWithContext<TMiddlewares, TSendContext, TNewClientContext>\n>\n\nexport interface MiddlewareClientFnOptions<\n  in out TMiddlewares,\n  in out TValidator,\n> {\n  data: Expand<IntersectAllValidatorInputs<TMiddlewares, TValidator>>\n  context: Expand<AssignAllClientContextBeforeNext<TMiddlewares>>\n  sendContext: Expand<AssignAllServerSendContext<TMiddlewares>>\n  method: Method\n  signal: AbortSignal\n  next: MiddlewareClientNextFn<TMiddlewares>\n  filename: string\n  functionId: string\n  type: ServerFnTypeOrTypeFn<Method, TMiddlewares, TValidator>\n}\n\nexport type MiddlewareClientFn<\n  TMiddlewares,\n  TValidator,\n  TSendContext,\n  TClientContext,\n> = (\n  options: MiddlewareClientFnOptions<TMiddlewares, TValidator>,\n) => MiddlewareClientFnResult<TMiddlewares, TSendContext, TClientContext>\n\nexport type MiddlewareClientFnResult<\n  TMiddlewares,\n  TSendContext,\n  TClientContext,\n> =\n  | Promise<ClientResultWithContext<TMiddlewares, TSendContext, TClientContext>>\n  | ClientResultWithContext<TMiddlewares, TSendContext, TClientContext>\n\nexport type ServerResultWithContext<\n  in out TMiddlewares,\n  in out TServerSendContext,\n  in out TServerContext,\n  in out TSendContext,\n> = {\n  'use functions must return the result of next()': true\n  _types: {\n    context: TServerContext\n    sendContext: TSendContext\n  }\n  context: Expand<\n    AssignAllServerContext<TMiddlewares, TServerSendContext, TServerContext>\n  >\n  sendContext: Expand<AssignAllClientSendContext<TMiddlewares, TSendContext>>\n}\n\nexport type ClientResultWithContext<\n  in out TMiddlewares,\n  in out TSendContext,\n  in out TClientContext,\n> = {\n  'use functions must return the result of next()': true\n  context: Expand<AssignAllClientContextAfterNext<TMiddlewares, TClientContext>>\n  sendContext: Expand<AssignAllServerSendContext<TMiddlewares, TSendContext>>\n  headers: HeadersInit\n}\n\nexport type AnyMiddleware = MiddlewareWithTypes<any, any, any, any, any, any>\n\nexport interface MiddlewareTypes<\n  in out TMiddlewares,\n  in out TValidator,\n  in out TServerContext,\n  in out TServerSendContext,\n  in out TClientContext,\n  in out TClientSendContext,\n> {\n  middlewares: TMiddlewares\n  input: ResolveValidatorInput<TValidator>\n  allInput: IntersectAllValidatorInputs<TMiddlewares, TValidator>\n  output: ResolveValidatorOutput<TValidator>\n  allOutput: IntersectAllValidatorOutputs<TMiddlewares, TValidator>\n  clientContext: TClientContext\n  allClientContextBeforeNext: AssignAllClientContextBeforeNext<\n    TMiddlewares,\n    TClientContext\n  >\n  allClientContextAfterNext: AssignAllClientContextAfterNext<\n    TMiddlewares,\n    TClientContext,\n    TClientSendContext\n  >\n  serverContext: TServerContext\n  serverSendContext: TServerSendContext\n  allServerSendContext: AssignAllServerSendContext<\n    TMiddlewares,\n    TServerSendContext\n  >\n  allServerContext: AssignAllServerContext<\n    TMiddlewares,\n    TServerSendContext,\n    TServerContext\n  >\n  clientSendContext: TClientSendContext\n  allClientSendContext: AssignAllClientSendContext<\n    TMiddlewares,\n    TClientSendContext\n  >\n  validator: TValidator\n}\n\nexport interface MiddlewareWithTypes<\n  TMiddlewares,\n  TValidator,\n  TServerContext,\n  TServerSendContext,\n  TClientContext,\n  TClientSendContext,\n> {\n  _types: MiddlewareTypes<\n    TMiddlewares,\n    TValidator,\n    TServerContext,\n    TServerSendContext,\n    TClientContext,\n    TClientSendContext\n  >\n  options: MiddlewareOptions<\n    TMiddlewares,\n    TValidator,\n    TServerContext,\n    TClientContext\n  >\n}\n\nexport interface MiddlewareAfterValidator<TMiddlewares, TValidator>\n  extends MiddlewareWithTypes<\n      TMiddlewares,\n      TValidator,\n      undefined,\n      undefined,\n      undefined,\n      undefined\n    >,\n    MiddlewareServer<TMiddlewares, TValidator, undefined, undefined>,\n    MiddlewareClient<TMiddlewares, TValidator> {}\n\nexport interface MiddlewareValidator<TMiddlewares> {\n  validator: <TNewValidator>(\n    input: ConstrainValidator<TNewValidator>,\n  ) => MiddlewareAfterValidator<TMiddlewares, TNewValidator>\n}\n\nexport interface MiddlewareAfterServer<\n  TMiddlewares,\n  TValidator,\n  TServerContext,\n  TServerSendContext,\n  TClientContext,\n  TClientSendContext,\n> extends MiddlewareWithTypes<\n    TMiddlewares,\n    TValidator,\n    TServerContext,\n    TServerSendContext,\n    TClientContext,\n    TClientSendContext\n  > {}\n\nexport interface MiddlewareServer<\n  TMiddlewares,\n  TValidator,\n  TServerSendContext,\n  TClientContext,\n> {\n  server: <TNewServerContext = undefined, TSendContext = undefined>(\n    server: MiddlewareServerFn<\n      TMiddlewares,\n      TValidator,\n      TServerSendContext,\n      TNewServerContext,\n      TSendContext\n    >,\n  ) => MiddlewareAfterServer<\n    TMiddlewares,\n    TValidator,\n    TNewServerContext,\n    TServerSendContext,\n    TClientContext,\n    TSendContext\n  >\n}\n\nexport interface MiddlewareAfterClient<\n  TMiddlewares,\n  TValidator,\n  TServerSendContext,\n  TClientContext,\n> extends MiddlewareWithTypes<\n      TMiddlewares,\n      TValidator,\n      undefined,\n      TServerSendContext,\n      TClientContext,\n      undefined\n    >,\n    MiddlewareServer<\n      TMiddlewares,\n      TValidator,\n      TServerSendContext,\n      TClientContext\n    > {}\n\nexport interface MiddlewareClient<TMiddlewares, TValidator> {\n  client: <TSendServerContext = undefined, TNewClientContext = undefined>(\n    client: MiddlewareClientFn<\n      TMiddlewares,\n      TValidator,\n      TSendServerContext,\n      TNewClientContext\n    >,\n  ) => MiddlewareAfterClient<\n    TMiddlewares,\n    TValidator,\n    TSendServerContext,\n    TNewClientContext\n  >\n}\n\nexport interface MiddlewareAfterMiddleware<TMiddlewares>\n  extends MiddlewareWithTypes<\n      TMiddlewares,\n      undefined,\n      undefined,\n      undefined,\n      undefined,\n      undefined\n    >,\n    MiddlewareServer<TMiddlewares, undefined, undefined, undefined>,\n    MiddlewareClient<TMiddlewares, undefined>,\n    MiddlewareValidator<TMiddlewares> {}\n\nexport interface Middleware extends MiddlewareAfterMiddleware<unknown> {\n  middleware: <const TNewMiddlewares = undefined>(\n    middlewares: Constrain<TNewMiddlewares, ReadonlyArray<AnyMiddleware>>,\n  ) => MiddlewareAfterMiddleware<TNewMiddlewares>\n}\n\nexport function createMiddleware(\n  options?: {\n    validateClient?: boolean\n  },\n  __opts?: MiddlewareOptions<unknown, undefined, undefined, undefined>,\n): Middleware {\n  // const resolvedOptions = (__opts || options) as MiddlewareOptions<\n  const resolvedOptions =\n    __opts ||\n    ((options || {}) as MiddlewareOptions<\n      unknown,\n      undefined,\n      undefined,\n      undefined\n    >)\n\n  return {\n    options: resolvedOptions as any,\n    middleware: (middleware: any) => {\n      return createMiddleware(\n        undefined,\n        Object.assign(resolvedOptions, { middleware }),\n      ) as any\n    },\n    validator: (validator: any) => {\n      return createMiddleware(\n        undefined,\n        Object.assign(resolvedOptions, { validator }),\n      ) as any\n    },\n    client: (client: any) => {\n      return createMiddleware(\n        undefined,\n        Object.assign(resolvedOptions, { client }),\n      ) as any\n    },\n    server: (server: any) => {\n      return createMiddleware(\n        undefined,\n        Object.assign(resolvedOptions, { server }),\n      ) as any\n    },\n  } as unknown as Middleware\n}\n"],"names":[],"mappings":"AAydgB,SAAA,iBACd,SAGA,QACY;AAEN,QAAA,kBACJ,WACE,WAAW;AAOR,SAAA;AAAA,IACL,SAAS;AAAA,IACT,YAAY,CAAC,eAAoB;AACxB,aAAA;AAAA,QACL;AAAA,QACA,OAAO,OAAO,iBAAiB,EAAE,WAAY,CAAA;AAAA,MAC/C;AAAA,IACF;AAAA,IACA,WAAW,CAAC,cAAmB;AACtB,aAAA;AAAA,QACL;AAAA,QACA,OAAO,OAAO,iBAAiB,EAAE,UAAW,CAAA;AAAA,MAC9C;AAAA,IACF;AAAA,IACA,QAAQ,CAAC,WAAgB;AAChB,aAAA;AAAA,QACL;AAAA,QACA,OAAO,OAAO,iBAAiB,EAAE,OAAQ,CAAA;AAAA,MAC3C;AAAA,IACF;AAAA,IACA,QAAQ,CAAC,WAAgB;AAChB,aAAA;AAAA,QACL;AAAA,QACA,OAAO,OAAO,iBAAiB,EAAE,OAAQ,CAAA;AAAA,MAC3C;AAAA,IAAA;AAAA,EAEJ;AACF;"}

package/dist/esm/createServerFn.d.ts

@@ -0,0 +1,137 @@
+import { AnyValidator, Constrain, Expand, ResolveValidatorInput, SerializerParse, SerializerStringify, SerializerStringifyBy, Validator } from '@tanstack/router-core';
+import { AnyMiddleware, AssignAllClientSendContext, AssignAllServerContext, IntersectAllValidatorInputs, IntersectAllValidatorOutputs } from './createMiddleware.js';
+export interface JsonResponse<TData> extends Response {
+    json: () => Promise<TData>;
+}
+export type CompiledFetcherFnOptions = {
+    method: Method;
+    data: unknown;
+    headers?: HeadersInit;
+    signal?: AbortSignal;
+    context?: any;
+};
+export type Fetcher<TMiddlewares, TValidator, TResponse> = undefined extends IntersectAllValidatorInputs<TMiddlewares, TValidator> ? OptionalFetcher<TMiddlewares, TValidator, TResponse> : RequiredFetcher<TMiddlewares, TValidator, TResponse>;
+export interface FetcherBase {
+    url: string;
+    __executeServer: (opts: {
+        method: Method;
+        data: unknown;
+        headers?: HeadersInit;
+        context?: any;
+        signal: AbortSignal;
+    }) => Promise<unknown>;
+}
+export type FetchResult<TMiddlewares, TResponse, TFullResponse extends boolean> = false extends TFullResponse ? Promise<FetcherData<TResponse>> : Promise<FullFetcherData<TMiddlewares, TResponse>>;
+export interface OptionalFetcher<TMiddlewares, TValidator, TResponse> extends FetcherBase {
+    <TFullResponse extends boolean>(options?: OptionalFetcherDataOptions<TMiddlewares, TValidator, TFullResponse>): FetchResult<TMiddlewares, TResponse, TFullResponse>;
+}
+export interface RequiredFetcher<TMiddlewares, TValidator, TResponse> extends FetcherBase {
+    <TFullResponse extends boolean>(opts: RequiredFetcherDataOptions<TMiddlewares, TValidator, TFullResponse>): FetchResult<TMiddlewares, TResponse, TFullResponse>;
+}
+export type FetcherBaseOptions<TFullResponse extends boolean = false> = {
+    headers?: HeadersInit;
+    type?: ServerFnType;
+    signal?: AbortSignal;
+    fullResponse?: TFullResponse;
+};
+export type ServerFnType = 'static' | 'dynamic';
+export interface OptionalFetcherDataOptions<TMiddlewares, TValidator, TFullResponse extends boolean> extends FetcherBaseOptions<TFullResponse> {
+    data?: Expand<IntersectAllValidatorInputs<TMiddlewares, TValidator>>;
+}
+export interface RequiredFetcherDataOptions<TMiddlewares, TValidator, TFullResponse extends boolean> extends FetcherBaseOptions<TFullResponse> {
+    data: Expand<IntersectAllValidatorInputs<TMiddlewares, TValidator>>;
+}
+export interface FullFetcherData<TMiddlewares, TResponse> {
+    error: unknown;
+    result: FetcherData<TResponse>;
+    context: AssignAllClientSendContext<TMiddlewares>;
+}
+export type FetcherData<TResponse> = TResponse extends JsonResponse<any> ? SerializerParse<ReturnType<TResponse['json']>> : SerializerParse<TResponse>;
+export type RscStream<T> = {
+    __cacheState: T;
+};
+export type Method = 'GET' | 'POST';
+export type ServerFn<TMethod, TMiddlewares, TValidator, TResponse> = (ctx: ServerFnCtx<TMethod, TMiddlewares, TValidator>) => Promise<SerializerStringify<TResponse>> | SerializerStringify<TResponse>;
+export interface ServerFnCtx<TMethod, TMiddlewares, TValidator> {
+    method: TMethod;
+    data: Expand<IntersectAllValidatorOutputs<TMiddlewares, TValidator>>;
+    context: Expand<AssignAllServerContext<TMiddlewares>>;
+    signal: AbortSignal;
+}
+export type CompiledFetcherFn<TResponse> = {
+    (opts: CompiledFetcherFnOptions & ServerFnBaseOptions<Method>): Promise<TResponse>;
+    url: string;
+};
+type ServerFnBaseOptions<TMethod extends Method = 'GET', TResponse = unknown, TMiddlewares = unknown, TInput = unknown> = {
+    method: TMethod;
+    validateClient?: boolean;
+    middleware?: Constrain<TMiddlewares, ReadonlyArray<AnyMiddleware>>;
+    validator?: ConstrainValidator<TInput>;
+    extractedFn?: CompiledFetcherFn<TResponse>;
+    serverFn?: ServerFn<TMethod, TMiddlewares, TInput, TResponse>;
+    functionId: string;
+    type: ServerFnTypeOrTypeFn<TMethod, TMiddlewares, AnyValidator>;
+};
+export type ValidatorSerializerStringify<TValidator> = Validator<SerializerStringifyBy<ResolveValidatorInput<TValidator>, Date | undefined | FormData>, any>;
+export type ConstrainValidator<TValidator> = unknown extends TValidator ? TValidator : Constrain<TValidator, ValidatorSerializerStringify<TValidator>>;
+export interface ServerFnMiddleware<TMethod extends Method, TValidator> {
+    middleware: <const TNewMiddlewares = undefined>(middlewares: Constrain<TNewMiddlewares, ReadonlyArray<AnyMiddleware>>) => ServerFnAfterMiddleware<TMethod, TNewMiddlewares, TValidator>;
+}
+export interface ServerFnAfterMiddleware<TMethod extends Method, TMiddlewares, TValidator> extends ServerFnValidator<TMethod, TMiddlewares>, ServerFnTyper<TMethod, TMiddlewares, TValidator>, ServerFnHandler<TMethod, TMiddlewares, TValidator> {
+}
+export type ValidatorFn<TMethod extends Method, TMiddlewares> = <TValidator>(validator: ConstrainValidator<TValidator>) => ServerFnAfterValidator<TMethod, TMiddlewares, TValidator>;
+export interface ServerFnValidator<TMethod extends Method, TMiddlewares> {
+    validator: ValidatorFn<TMethod, TMiddlewares>;
+}
+export interface ServerFnAfterValidator<TMethod extends Method, TMiddlewares, TValidator> extends ServerFnMiddleware<TMethod, TValidator>, ServerFnTyper<TMethod, TMiddlewares, TValidator>, ServerFnHandler<TMethod, TMiddlewares, TValidator> {
+}
+export interface ServerFnTyper<TMethod extends Method, TMiddlewares, TValidator> {
+    type: (typer: ServerFnTypeOrTypeFn<TMethod, TMiddlewares, TValidator>) => ServerFnAfterTyper<TMethod, TMiddlewares, TValidator>;
+}
+export type ServerFnTypeOrTypeFn<TMethod extends Method, TMiddlewares, TValidator> = ServerFnType | ((ctx: ServerFnCtx<TMethod, TMiddlewares, TValidator>) => ServerFnType);
+export interface ServerFnAfterTyper<TMethod extends Method, TMiddlewares, TValidator> extends ServerFnHandler<TMethod, TMiddlewares, TValidator> {
+}
+export interface ServerFnHandler<TMethod extends Method, TMiddlewares, TValidator> {
+    handler: <TNewResponse>(fn?: ServerFn<TMethod, TMiddlewares, TValidator, TNewResponse>) => Fetcher<TMiddlewares, TValidator, TNewResponse>;
+}
+export interface ServerFnBuilder<TMethod extends Method = 'GET'> extends ServerFnMiddleware<TMethod, undefined>, ServerFnValidator<TMethod, undefined>, ServerFnTyper<TMethod, undefined, undefined>, ServerFnHandler<TMethod, undefined, undefined> {
+    options: ServerFnBaseOptions<TMethod, unknown, undefined, undefined>;
+}
+type StaticCachedResult = {
+    ctx?: {
+        result: any;
+        context: any;
+    };
+    error?: any;
+};
+export type ServerFnStaticCache = {
+    getItem: (ctx: MiddlewareResult) => StaticCachedResult | Promise<StaticCachedResult | undefined>;
+    setItem: (ctx: MiddlewareResult, response: StaticCachedResult) => Promise<void>;
+    fetchItem: (ctx: MiddlewareResult) => StaticCachedResult | Promise<StaticCachedResult | undefined>;
+};
+export declare function setServerFnStaticCache(cache?: ServerFnStaticCache | (() => ServerFnStaticCache | undefined)): () => void;
+export declare function createServerFnStaticCache(serverFnStaticCache: ServerFnStaticCache): ServerFnStaticCache;
+export declare function createServerFn<TMethod extends Method, TResponse = unknown, TMiddlewares = undefined, TValidator = undefined>(options?: {
+    method?: TMethod;
+    type?: ServerFnType;
+}, __opts?: ServerFnBaseOptions<TMethod, TResponse, TMiddlewares, TValidator>): ServerFnBuilder<TMethod>;
+export type MiddlewareOptions = {
+    method: Method;
+    data: any;
+    headers?: HeadersInit;
+    signal?: AbortSignal;
+    sendContext?: any;
+    context?: any;
+    type: ServerFnTypeOrTypeFn<any, any, any>;
+    functionId: string;
+};
+export type MiddlewareResult = MiddlewareOptions & {
+    result?: unknown;
+    error?: unknown;
+    type: ServerFnTypeOrTypeFn<any, any, any>;
+};
+export type NextFn = (ctx: MiddlewareResult) => Promise<MiddlewareResult>;
+export type MiddlewareFn = (ctx: MiddlewareOptions & {
+    next: NextFn;
+}) => Promise<MiddlewareResult>;
+export {};