@tanstack/start-client-core 1.131.6 → 1.132.0-alpha.0

package/dist/cjs/createIsomorphicFn.d.cts

@@ -1,12 +0,0 @@
-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/cjs/createMiddleware.cjs

@@ -1,37 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-function createMiddleware(options, __opts) {
-  const resolvedOptions = {
-    type: "function",
-    ...__opts || options
-  };
-  return {
-    options: resolvedOptions,
-    middleware: (middleware) => {
-      return createMiddleware(
-        {},
-        Object.assign(resolvedOptions, { middleware })
-      );
-    },
-    validator: (validator) => {
-      return createMiddleware(
-        {},
-        Object.assign(resolvedOptions, { validator })
-      );
-    },
-    client: (client) => {
-      return createMiddleware(
-        {},
-        Object.assign(resolvedOptions, { client })
-      );
-    },
-    server: (server) => {
-      return createMiddleware(
-        {},
-        Object.assign(resolvedOptions, { server })
-      );
-    }
-  };
-}
-exports.createMiddleware = createMiddleware;
-//# sourceMappingURL=createMiddleware.cjs.map

package/dist/cjs/createMiddleware.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"createMiddleware.cjs","sources":["../../src/createMiddleware.ts"],"sourcesContent":["import type {\n  ConstrainValidator,\n  Method,\n  ServerFnResponseType,\n  ServerFnTypeOrTypeFn,\n} from './createServerFn'\nimport type {\n  AnyRouter,\n  Assign,\n  Constrain,\n  Expand,\n  IntersectAssign,\n  RegisteredRouter,\n  ResolveValidatorInput,\n  ResolveValidatorOutput,\n} from '@tanstack/router-core'\nimport type { SerializerStringify } from './serializer'\n\nexport function createMiddleware<TType extends MiddlewareType>(\n  options: {\n    type: TType\n    validateClient?: boolean\n  },\n  __opts?: FunctionMiddlewareOptions<\n    unknown,\n    undefined,\n    undefined,\n    undefined,\n    ServerFnResponseType\n  >,\n): CreateMiddlewareResult<TType> {\n  // const resolvedOptions = (__opts || options) as MiddlewareOptions<\n  const resolvedOptions = {\n    type: 'function',\n    ...(__opts ||\n      (options as FunctionMiddlewareOptions<\n        unknown,\n        undefined,\n        undefined,\n        undefined,\n        ServerFnResponseType\n      >)),\n  }\n\n  return {\n    options: resolvedOptions,\n    middleware: (middleware: any) => {\n      return createMiddleware(\n        {} as any,\n        Object.assign(resolvedOptions, { middleware }),\n      ) as any\n    },\n    validator: (validator: any) => {\n      return createMiddleware(\n        {} as any,\n        Object.assign(resolvedOptions, { validator }),\n      ) as any\n    },\n    client: (client: any) => {\n      return createMiddleware(\n        {} as any,\n        Object.assign(resolvedOptions, { client }),\n      ) as any\n    },\n    server: (server: any) => {\n      return createMiddleware(\n        {} as any,\n        Object.assign(resolvedOptions, { server }),\n      ) as any\n    },\n  } as unknown as CreateMiddlewareResult<TType>\n}\n\nexport type MiddlewareType = 'request' | 'function'\n\nexport type CreateMiddlewareResult<TType extends MiddlewareType> =\n  'function' extends TType\n    ? FunctionMiddleware<ServerFnResponseType>\n    : RequestMiddleware\n\nexport interface FunctionMiddleware<\n  TServerFnResponseType extends ServerFnResponseType,\n> extends FunctionMiddlewareAfterMiddleware<unknown, TServerFnResponseType> {\n  middleware: <const TNewMiddlewares = undefined>(\n    middlewares: Constrain<\n      TNewMiddlewares,\n      ReadonlyArray<AnyFunctionMiddleware>\n    >,\n  ) => FunctionMiddlewareAfterMiddleware<TNewMiddlewares, TServerFnResponseType>\n}\n\nexport interface FunctionMiddlewareAfterMiddleware<\n  TMiddlewares,\n  TServerFnResponseType extends ServerFnResponseType,\n> extends FunctionMiddlewareWithTypes<\n      TMiddlewares,\n      undefined,\n      undefined,\n      undefined,\n      undefined,\n      undefined,\n      TServerFnResponseType\n    >,\n    FunctionMiddlewareServer<\n      TMiddlewares,\n      undefined,\n      undefined,\n      undefined,\n      TServerFnResponseType\n    >,\n    FunctionMiddlewareClient<TMiddlewares, undefined, TServerFnResponseType>,\n    FunctionMiddlewareValidator<TMiddlewares, TServerFnResponseType> {}\n\nexport interface FunctionMiddlewareWithTypes<\n  TMiddlewares,\n  TValidator,\n  TServerContext,\n  TServerSendContext,\n  TClientContext,\n  TClientSendContext,\n  TServerFnResponseType extends ServerFnResponseType,\n> {\n  _types: FunctionMiddlewareTypes<\n    TMiddlewares,\n    TValidator,\n    TServerContext,\n    TServerSendContext,\n    TClientContext,\n    TClientSendContext\n  >\n  options: FunctionMiddlewareOptions<\n    TMiddlewares,\n    TValidator,\n    TServerContext,\n    TClientContext,\n    TServerFnResponseType\n  >\n}\n\nexport interface FunctionMiddlewareTypes<\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  type: 'function'\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\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    : TValidator extends undefined\n      ? IntersectAllMiddleware<TMiddlewares, 'allInput'>\n      : IntersectAssign<\n          IntersectAllMiddleware<TMiddlewares, 'allInput'>,\n          ResolveValidatorInput<TValidator>\n        >\n\nexport type IntersectAllMiddleware<\n  TMiddlewares,\n  TType extends\n    | keyof AnyFunctionMiddleware['_types']\n    | keyof AnyRequestMiddleware['_types'],\n  TAcc = undefined,\n> = TMiddlewares extends readonly [infer TMiddleware, ...infer TRest]\n  ? TMiddleware extends AnyFunctionMiddleware | AnyRequestMiddleware\n    ? IntersectAllMiddleware<\n        TRest,\n        TType,\n        IntersectAssign<\n          TAcc,\n          TMiddleware['_types'][TType & keyof TMiddleware['_types']]\n        >\n      >\n    : TAcc\n  : TAcc\n\nexport type AnyFunctionMiddleware = FunctionMiddlewareWithTypes<\n  any,\n  any,\n  any,\n  any,\n  any,\n  any,\n  any\n>\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    : TValidator extends undefined\n      ? IntersectAllMiddleware<TMiddlewares, 'allOutput'>\n      : IntersectAssign<\n          IntersectAllMiddleware<TMiddlewares, 'allOutput'>,\n          ResolveValidatorOutput<TValidator>\n        >\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 AssignAllMiddleware<\n  TMiddlewares,\n  TType extends\n    | keyof AnyFunctionMiddleware['_types']\n    | keyof AnyRequestMiddleware['_types'],\n  TAcc = undefined,\n> = TMiddlewares extends readonly [infer TMiddleware, ...infer TRest]\n  ? TMiddleware extends AnyFunctionMiddleware | AnyRequestMiddleware\n    ? AssignAllMiddleware<\n        TRest,\n        TType,\n        Assign<TAcc, TMiddleware['_types'][TType & keyof TMiddleware['_types']]>\n      >\n    : TAcc\n  : TAcc\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\nexport type AssignAllServerSendContext<\n  TMiddlewares,\n  TSendContext = undefined,\n> = unknown extends TSendContext\n  ? TSendContext\n  : Assign<\n      AssignAllMiddleware<TMiddlewares, 'allServerSendContext'>,\n      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 AssignAllClientSendContext<\n  TMiddlewares,\n  TSendContext = undefined,\n> = unknown extends TSendContext\n  ? TSendContext\n  : Assign<\n      AssignAllMiddleware<TMiddlewares, 'allClientSendContext'>,\n      TSendContext\n    >\n\nexport interface FunctionMiddlewareOptions<\n  in out TMiddlewares,\n  in out TValidator,\n  in out TServerContext,\n  in out TClientContext,\n  in out TServerFnResponseType extends ServerFnResponseType,\n> {\n  validateClient?: boolean\n  middleware?: TMiddlewares\n  validator?: ConstrainValidator<TValidator>\n  client?: FunctionMiddlewareClientFn<\n    TMiddlewares,\n    TValidator,\n    TServerContext,\n    TClientContext,\n    TServerFnResponseType\n  >\n  server?: FunctionMiddlewareServerFn<\n    TMiddlewares,\n    TValidator,\n    TServerContext,\n    unknown,\n    unknown,\n    TServerFnResponseType\n  >\n}\n\nexport type FunctionMiddlewareClientNextFn<TMiddlewares> = <\n  TSendContext = undefined,\n  TNewClientContext = undefined,\n>(ctx?: {\n  context?: TNewClientContext\n  sendContext?: SerializerStringify<TSendContext>\n  headers?: HeadersInit\n}) => Promise<\n  FunctionClientResultWithContext<TMiddlewares, TSendContext, TNewClientContext>\n>\n\nexport interface FunctionMiddlewareServer<\n  TMiddlewares,\n  TValidator,\n  TServerSendContext,\n  TClientContext,\n  TServerFnResponseType extends ServerFnResponseType,\n> {\n  server: <TNewServerContext = undefined, TSendContext = undefined>(\n    server: FunctionMiddlewareServerFn<\n      TMiddlewares,\n      TValidator,\n      TServerSendContext,\n      TNewServerContext,\n      TSendContext,\n      TServerFnResponseType\n    >,\n  ) => FunctionMiddlewareAfterServer<\n    TMiddlewares,\n    TValidator,\n    TNewServerContext,\n    TServerSendContext,\n    TClientContext,\n    TSendContext,\n    ServerFnResponseType\n  >\n}\nexport type FunctionMiddlewareServerFn<\n  TMiddlewares,\n  TValidator,\n  TServerSendContext,\n  TNewServerContext,\n  TSendContext,\n  TServerFnResponseType extends ServerFnResponseType,\n> = (\n  options: FunctionMiddlewareServerFnOptions<\n    TMiddlewares,\n    TValidator,\n    TServerSendContext,\n    TServerFnResponseType\n  >,\n) => FunctionMiddlewareServerFnResult<\n  TMiddlewares,\n  TServerSendContext,\n  TNewServerContext,\n  TSendContext\n>\n\nexport interface RequestMiddlewareServerFnOptions<\n  in out TMiddlewares,\n  in out TServerSendContext,\n> {\n  request: Request\n  context: Expand<AssignAllServerContext<TMiddlewares, TServerSendContext>>\n  next: FunctionMiddlewareServerNextFn<TMiddlewares, TServerSendContext>\n  response: Response\n  method: Method\n  signal: AbortSignal\n}\n\nexport type FunctionMiddlewareServerNextFn<TMiddlewares, TServerSendContext> = <\n  TNewServerContext = undefined,\n  TSendContext = undefined,\n>(ctx?: {\n  context?: TNewServerContext\n  sendContext?: SerializerStringify<TSendContext>\n}) => Promise<\n  FunctionServerResultWithContext<\n    TMiddlewares,\n    TServerSendContext,\n    TNewServerContext,\n    TSendContext\n  >\n>\n\nexport type FunctionServerResultWithContext<\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 interface FunctionMiddlewareServerFnOptions<\n  in out TMiddlewares,\n  in out TValidator,\n  in out TServerSendContext,\n  in out TServerFnResponseType,\n> {\n  data: Expand<IntersectAllValidatorOutputs<TMiddlewares, TValidator>>\n  context: Expand<AssignAllServerContext<TMiddlewares, TServerSendContext>>\n  next: FunctionMiddlewareServerNextFn<TMiddlewares, TServerSendContext>\n  response: TServerFnResponseType\n  method: Method\n  filename: string\n  functionId: string\n  signal: AbortSignal\n}\n\nexport type FunctionMiddlewareServerFnResult<\n  TMiddlewares,\n  TServerSendContext,\n  TServerContext,\n  TSendContext,\n> =\n  | Promise<\n      FunctionServerResultWithContext<\n        TMiddlewares,\n        TServerSendContext,\n        TServerContext,\n        TSendContext\n      >\n    >\n  | FunctionServerResultWithContext<\n      TMiddlewares,\n      TServerSendContext,\n      TServerContext,\n      TSendContext\n    >\n\nexport interface FunctionMiddlewareAfterServer<\n  TMiddlewares,\n  TValidator,\n  TServerContext,\n  TServerSendContext,\n  TClientContext,\n  TClientSendContext,\n  TServerFnResponseType extends ServerFnResponseType,\n> extends FunctionMiddlewareWithTypes<\n    TMiddlewares,\n    TValidator,\n    TServerContext,\n    TServerSendContext,\n    TClientContext,\n    TClientSendContext,\n    TServerFnResponseType\n  > {}\n\nexport interface FunctionMiddlewareClient<\n  TMiddlewares,\n  TValidator,\n  TServerFnResponseType extends ServerFnResponseType,\n  TRouter extends AnyRouter = RegisteredRouter,\n> {\n  client: <TSendServerContext = undefined, TNewClientContext = undefined>(\n    client: FunctionMiddlewareClientFn<\n      TMiddlewares,\n      TValidator,\n      TSendServerContext,\n      TNewClientContext,\n      TServerFnResponseType,\n      TRouter\n    >,\n  ) => FunctionMiddlewareAfterClient<\n    TMiddlewares,\n    TValidator,\n    TSendServerContext,\n    TNewClientContext,\n    ServerFnResponseType\n  >\n}\n\nexport type FunctionMiddlewareClientFn<\n  TMiddlewares,\n  TValidator,\n  TSendContext,\n  TClientContext,\n  TServerFnResponseType extends ServerFnResponseType,\n  TRouter extends AnyRouter = RegisteredRouter,\n> = (\n  options: FunctionMiddlewareClientFnOptions<\n    TMiddlewares,\n    TValidator,\n    TServerFnResponseType,\n    TRouter\n  >,\n) => FunctionMiddlewareClientFnResult<\n  TMiddlewares,\n  TSendContext,\n  TClientContext\n>\n\nexport interface FunctionMiddlewareClientFnOptions<\n  in out TMiddlewares,\n  in out TValidator,\n  in out TServerFnResponseType extends ServerFnResponseType,\n  in out TRouter extends AnyRouter,\n> {\n  data: Expand<IntersectAllValidatorInputs<TMiddlewares, TValidator>>\n  context: Expand<AssignAllClientContextBeforeNext<TMiddlewares>>\n  sendContext: Expand<AssignAllServerSendContext<TMiddlewares>>\n  method: Method\n  response: TServerFnResponseType\n  signal: AbortSignal\n  next: FunctionMiddlewareClientNextFn<TMiddlewares>\n  filename: string\n  functionId: string\n  type: ServerFnTypeOrTypeFn<\n    Method,\n    TServerFnResponseType,\n    TMiddlewares,\n    TValidator\n  >\n  router: TRouter\n}\n\nexport type FunctionMiddlewareClientFnResult<\n  TMiddlewares,\n  TSendContext,\n  TClientContext,\n> =\n  | Promise<\n      FunctionClientResultWithContext<\n        TMiddlewares,\n        TSendContext,\n        TClientContext\n      >\n    >\n  | FunctionClientResultWithContext<TMiddlewares, TSendContext, TClientContext>\n\nexport type FunctionClientResultWithContext<\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 interface FunctionMiddlewareAfterClient<\n  TMiddlewares,\n  TValidator,\n  TServerSendContext,\n  TClientContext,\n  TServerFnResponseType extends ServerFnResponseType,\n> extends FunctionMiddlewareWithTypes<\n      TMiddlewares,\n      TValidator,\n      undefined,\n      TServerSendContext,\n      TClientContext,\n      undefined,\n      TServerFnResponseType\n    >,\n    FunctionMiddlewareServer<\n      TMiddlewares,\n      TValidator,\n      TServerSendContext,\n      TClientContext,\n      TServerFnResponseType\n    > {}\n\nexport interface FunctionMiddlewareValidator<\n  TMiddlewares,\n  TServerFnResponseType extends ServerFnResponseType,\n> {\n  validator: <TNewValidator>(\n    input: ConstrainValidator<TNewValidator>,\n  ) => FunctionMiddlewareAfterValidator<\n    TMiddlewares,\n    TNewValidator,\n    TServerFnResponseType\n  >\n}\n\nexport interface FunctionMiddlewareAfterValidator<\n  TMiddlewares,\n  TValidator,\n  TServerFnResponseType extends ServerFnResponseType,\n> extends FunctionMiddlewareWithTypes<\n      TMiddlewares,\n      TValidator,\n      undefined,\n      undefined,\n      undefined,\n      undefined,\n      ServerFnResponseType\n    >,\n    FunctionMiddlewareServer<\n      TMiddlewares,\n      TValidator,\n      undefined,\n      undefined,\n      TServerFnResponseType\n    >,\n    FunctionMiddlewareClient<TMiddlewares, TValidator, ServerFnResponseType> {}\n\nexport interface RequestMiddleware\n  extends RequestMiddlewareAfterMiddleware<undefined> {\n  middleware: <const TMiddlewares = undefined>(\n    middlewares: Constrain<TMiddlewares, ReadonlyArray<AnyRequestMiddleware>>,\n  ) => RequestMiddlewareAfterMiddleware<TMiddlewares>\n}\n\nexport type AnyRequestMiddleware = RequestMiddlewareWithTypes<any, any>\n\nexport interface RequestMiddlewareWithTypes<TMiddlewares, TServerContext> {\n  _types: RequestMiddlewareTypes<TMiddlewares, TServerContext>\n}\n\nexport interface RequestMiddlewareTypes<TMiddlewares, TServerContext> {\n  type: 'request'\n  middlewares: TMiddlewares\n  serverContext: TServerContext\n  allServerContext: AssignAllServerContext<\n    TMiddlewares,\n    undefined,\n    TServerContext\n  >\n}\n\nexport interface RequestMiddlewareAfterMiddleware<TMiddlewares>\n  extends RequestMiddlewareWithTypes<TMiddlewares, undefined>,\n    RequestMiddlewareServer<TMiddlewares> {}\n\nexport interface RequestMiddlewareServer<TMiddlewares> {\n  server: <TServerContext = undefined>(\n    fn: RequestServerFn<TMiddlewares, TServerContext>,\n  ) => RequestMiddlewareAfterServer<TMiddlewares, TServerContext>\n}\n\nexport type RequestServerFn<TMiddlewares, TServerContext> = (\n  options: RequestServerOptions<TMiddlewares>,\n) => RequestMiddlewareServerFnResult<TMiddlewares, TServerContext>\n\nexport interface RequestServerOptions<TMiddlewares> {\n  request: Request\n  pathname: string\n  context: AssignAllServerContext<TMiddlewares>\n  next: RequestServerNextFn<TMiddlewares>\n}\n\nexport type RequestServerNextFn<TMiddlewares> = <TServerContext = undefined>(\n  options?: RequestServerNextFnOptions<TServerContext>,\n) => RequestMiddlewareServerFnResult<TMiddlewares, TServerContext>\n\nexport interface RequestServerNextFnOptions<TServerContext> {\n  context?: TServerContext\n}\n\nexport type RequestMiddlewareServerFnResult<TMiddlewares, TServerContext> =\n  | Promise<RequestServerResult<TMiddlewares, TServerContext>>\n  | RequestServerResult<TMiddlewares, TServerContext>\n\nexport interface RequestServerResult<TMiddlewares, TServerContext> {\n  request: Request\n  pathname: string\n  context: Expand<\n    AssignAllServerContext<TMiddlewares, undefined, TServerContext>\n  >\n  response: Response\n}\n\nexport interface RequestMiddlewareAfterServer<TMiddlewares, TServerContext>\n  extends RequestMiddlewareWithTypes<TMiddlewares, TServerContext> {}\n"],"names":[],"mappings":";;AAkBgB,SAAA,iBACd,SAIA,QAO+B;AAE/B,QAAM,kBAAkB;AAAA,IACtB,MAAM;AAAA,IACN,GAAI,UACD;AAAA,EAOL;AAEO,SAAA;AAAA,IACL,SAAS;AAAA,IACT,YAAY,CAAC,eAAoB;AACxB,aAAA;AAAA,QACL,CAAC;AAAA,QACD,OAAO,OAAO,iBAAiB,EAAE,WAAY,CAAA;AAAA,MAC/C;AAAA,IACF;AAAA,IACA,WAAW,CAAC,cAAmB;AACtB,aAAA;AAAA,QACL,CAAC;AAAA,QACD,OAAO,OAAO,iBAAiB,EAAE,UAAW,CAAA;AAAA,MAC9C;AAAA,IACF;AAAA,IACA,QAAQ,CAAC,WAAgB;AAChB,aAAA;AAAA,QACL,CAAC;AAAA,QACD,OAAO,OAAO,iBAAiB,EAAE,OAAQ,CAAA;AAAA,MAC3C;AAAA,IACF;AAAA,IACA,QAAQ,CAAC,WAAgB;AAChB,aAAA;AAAA,QACL,CAAC;AAAA,QACD,OAAO,OAAO,iBAAiB,EAAE,OAAQ,CAAA;AAAA,MAC3C;AAAA,IAAA;AAAA,EAEJ;AACF;;"}

package/dist/cjs/createMiddleware.d.cts

@@ -1,177 +0,0 @@
-import { ConstrainValidator, Method, ServerFnResponseType, ServerFnTypeOrTypeFn } from './createServerFn.cjs';
-import { AnyRouter, Assign, Constrain, Expand, IntersectAssign, RegisteredRouter, ResolveValidatorInput, ResolveValidatorOutput } from '@tanstack/router-core';
-import { SerializerStringify } from './serializer.cjs';
-export declare function createMiddleware<TType extends MiddlewareType>(options: {
-    type: TType;
-    validateClient?: boolean;
-}, __opts?: FunctionMiddlewareOptions<unknown, undefined, undefined, undefined, ServerFnResponseType>): CreateMiddlewareResult<TType>;
-export type MiddlewareType = 'request' | 'function';
-export type CreateMiddlewareResult<TType extends MiddlewareType> = 'function' extends TType ? FunctionMiddleware<ServerFnResponseType> : RequestMiddleware;
-export interface FunctionMiddleware<TServerFnResponseType extends ServerFnResponseType> extends FunctionMiddlewareAfterMiddleware<unknown, TServerFnResponseType> {
-    middleware: <const TNewMiddlewares = undefined>(middlewares: Constrain<TNewMiddlewares, ReadonlyArray<AnyFunctionMiddleware>>) => FunctionMiddlewareAfterMiddleware<TNewMiddlewares, TServerFnResponseType>;
-}
-export interface FunctionMiddlewareAfterMiddleware<TMiddlewares, TServerFnResponseType extends ServerFnResponseType> extends FunctionMiddlewareWithTypes<TMiddlewares, undefined, undefined, undefined, undefined, undefined, TServerFnResponseType>, FunctionMiddlewareServer<TMiddlewares, undefined, undefined, undefined, TServerFnResponseType>, FunctionMiddlewareClient<TMiddlewares, undefined, TServerFnResponseType>, FunctionMiddlewareValidator<TMiddlewares, TServerFnResponseType> {
-}
-export interface FunctionMiddlewareWithTypes<TMiddlewares, TValidator, TServerContext, TServerSendContext, TClientContext, TClientSendContext, TServerFnResponseType extends ServerFnResponseType> {
-    _types: FunctionMiddlewareTypes<TMiddlewares, TValidator, TServerContext, TServerSendContext, TClientContext, TClientSendContext>;
-    options: FunctionMiddlewareOptions<TMiddlewares, TValidator, TServerContext, TClientContext, TServerFnResponseType>;
-}
-export interface FunctionMiddlewareTypes<in out TMiddlewares, in out TValidator, in out TServerContext, in out TServerSendContext, in out TClientContext, in out TClientSendContext> {
-    type: 'function';
-    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;
-}
-/**
- * Recursively resolve the input type produced by a sequence of middleware
- */
-export type IntersectAllValidatorInputs<TMiddlewares, TValidator> = unknown extends TValidator ? TValidator : TValidator extends undefined ? IntersectAllMiddleware<TMiddlewares, 'allInput'> : IntersectAssign<IntersectAllMiddleware<TMiddlewares, 'allInput'>, ResolveValidatorInput<TValidator>>;
-export type IntersectAllMiddleware<TMiddlewares, TType extends keyof AnyFunctionMiddleware['_types'] | keyof AnyRequestMiddleware['_types'], TAcc = undefined> = TMiddlewares extends readonly [infer TMiddleware, ...infer TRest] ? TMiddleware extends AnyFunctionMiddleware | AnyRequestMiddleware ? IntersectAllMiddleware<TRest, TType, IntersectAssign<TAcc, TMiddleware['_types'][TType & keyof TMiddleware['_types']]>> : TAcc : TAcc;
-export type AnyFunctionMiddleware = FunctionMiddlewareWithTypes<any, any, any, any, any, any, any>;
-/**
- * Recursively merge the output type produced by a sequence of middleware
- */
-export type IntersectAllValidatorOutputs<TMiddlewares, TValidator> = unknown extends TValidator ? TValidator : TValidator extends undefined ? IntersectAllMiddleware<TMiddlewares, 'allOutput'> : IntersectAssign<IntersectAllMiddleware<TMiddlewares, 'allOutput'>, ResolveValidatorOutput<TValidator>>;
-/**
- * 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 AssignAllMiddleware<TMiddlewares, TType extends keyof AnyFunctionMiddleware['_types'] | keyof AnyRequestMiddleware['_types'], TAcc = undefined> = TMiddlewares extends readonly [infer TMiddleware, ...infer TRest] ? TMiddleware extends AnyFunctionMiddleware | AnyRequestMiddleware ? AssignAllMiddleware<TRest, TType, Assign<TAcc, TMiddleware['_types'][TType & keyof TMiddleware['_types']]>> : TAcc : TAcc;
-export type AssignAllClientContextAfterNext<TMiddlewares, TClientContext = undefined, TSendContext = undefined> = unknown extends TClientContext ? Assign<TClientContext, TSendContext> : Assign<AssignAllMiddleware<TMiddlewares, 'allClientContextAfterNext'>, Assign<TClientContext, TSendContext>>;
-export type AssignAllServerSendContext<TMiddlewares, TSendContext = undefined> = unknown extends TSendContext ? TSendContext : Assign<AssignAllMiddleware<TMiddlewares, 'allServerSendContext'>, 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 AssignAllClientSendContext<TMiddlewares, TSendContext = undefined> = unknown extends TSendContext ? TSendContext : Assign<AssignAllMiddleware<TMiddlewares, 'allClientSendContext'>, TSendContext>;
-export interface FunctionMiddlewareOptions<in out TMiddlewares, in out TValidator, in out TServerContext, in out TClientContext, in out TServerFnResponseType extends ServerFnResponseType> {
-    validateClient?: boolean;
-    middleware?: TMiddlewares;
-    validator?: ConstrainValidator<TValidator>;
-    client?: FunctionMiddlewareClientFn<TMiddlewares, TValidator, TServerContext, TClientContext, TServerFnResponseType>;
-    server?: FunctionMiddlewareServerFn<TMiddlewares, TValidator, TServerContext, unknown, unknown, TServerFnResponseType>;
-}
-export type FunctionMiddlewareClientNextFn<TMiddlewares> = <TSendContext = undefined, TNewClientContext = undefined>(ctx?: {
-    context?: TNewClientContext;
-    sendContext?: SerializerStringify<TSendContext>;
-    headers?: HeadersInit;
-}) => Promise<FunctionClientResultWithContext<TMiddlewares, TSendContext, TNewClientContext>>;
-export interface FunctionMiddlewareServer<TMiddlewares, TValidator, TServerSendContext, TClientContext, TServerFnResponseType extends ServerFnResponseType> {
-    server: <TNewServerContext = undefined, TSendContext = undefined>(server: FunctionMiddlewareServerFn<TMiddlewares, TValidator, TServerSendContext, TNewServerContext, TSendContext, TServerFnResponseType>) => FunctionMiddlewareAfterServer<TMiddlewares, TValidator, TNewServerContext, TServerSendContext, TClientContext, TSendContext, ServerFnResponseType>;
-}
-export type FunctionMiddlewareServerFn<TMiddlewares, TValidator, TServerSendContext, TNewServerContext, TSendContext, TServerFnResponseType extends ServerFnResponseType> = (options: FunctionMiddlewareServerFnOptions<TMiddlewares, TValidator, TServerSendContext, TServerFnResponseType>) => FunctionMiddlewareServerFnResult<TMiddlewares, TServerSendContext, TNewServerContext, TSendContext>;
-export interface RequestMiddlewareServerFnOptions<in out TMiddlewares, in out TServerSendContext> {
-    request: Request;
-    context: Expand<AssignAllServerContext<TMiddlewares, TServerSendContext>>;
-    next: FunctionMiddlewareServerNextFn<TMiddlewares, TServerSendContext>;
-    response: Response;
-    method: Method;
-    signal: AbortSignal;
-}
-export type FunctionMiddlewareServerNextFn<TMiddlewares, TServerSendContext> = <TNewServerContext = undefined, TSendContext = undefined>(ctx?: {
-    context?: TNewServerContext;
-    sendContext?: SerializerStringify<TSendContext>;
-}) => Promise<FunctionServerResultWithContext<TMiddlewares, TServerSendContext, TNewServerContext, TSendContext>>;
-export type FunctionServerResultWithContext<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 interface FunctionMiddlewareServerFnOptions<in out TMiddlewares, in out TValidator, in out TServerSendContext, in out TServerFnResponseType> {
-    data: Expand<IntersectAllValidatorOutputs<TMiddlewares, TValidator>>;
-    context: Expand<AssignAllServerContext<TMiddlewares, TServerSendContext>>;
-    next: FunctionMiddlewareServerNextFn<TMiddlewares, TServerSendContext>;
-    response: TServerFnResponseType;
-    method: Method;
-    filename: string;
-    functionId: string;
-    signal: AbortSignal;
-}
-export type FunctionMiddlewareServerFnResult<TMiddlewares, TServerSendContext, TServerContext, TSendContext> = Promise<FunctionServerResultWithContext<TMiddlewares, TServerSendContext, TServerContext, TSendContext>> | FunctionServerResultWithContext<TMiddlewares, TServerSendContext, TServerContext, TSendContext>;
-export interface FunctionMiddlewareAfterServer<TMiddlewares, TValidator, TServerContext, TServerSendContext, TClientContext, TClientSendContext, TServerFnResponseType extends ServerFnResponseType> extends FunctionMiddlewareWithTypes<TMiddlewares, TValidator, TServerContext, TServerSendContext, TClientContext, TClientSendContext, TServerFnResponseType> {
-}
-export interface FunctionMiddlewareClient<TMiddlewares, TValidator, TServerFnResponseType extends ServerFnResponseType, TRouter extends AnyRouter = RegisteredRouter> {
-    client: <TSendServerContext = undefined, TNewClientContext = undefined>(client: FunctionMiddlewareClientFn<TMiddlewares, TValidator, TSendServerContext, TNewClientContext, TServerFnResponseType, TRouter>) => FunctionMiddlewareAfterClient<TMiddlewares, TValidator, TSendServerContext, TNewClientContext, ServerFnResponseType>;
-}
-export type FunctionMiddlewareClientFn<TMiddlewares, TValidator, TSendContext, TClientContext, TServerFnResponseType extends ServerFnResponseType, TRouter extends AnyRouter = RegisteredRouter> = (options: FunctionMiddlewareClientFnOptions<TMiddlewares, TValidator, TServerFnResponseType, TRouter>) => FunctionMiddlewareClientFnResult<TMiddlewares, TSendContext, TClientContext>;
-export interface FunctionMiddlewareClientFnOptions<in out TMiddlewares, in out TValidator, in out TServerFnResponseType extends ServerFnResponseType, in out TRouter extends AnyRouter> {
-    data: Expand<IntersectAllValidatorInputs<TMiddlewares, TValidator>>;
-    context: Expand<AssignAllClientContextBeforeNext<TMiddlewares>>;
-    sendContext: Expand<AssignAllServerSendContext<TMiddlewares>>;
-    method: Method;
-    response: TServerFnResponseType;
-    signal: AbortSignal;
-    next: FunctionMiddlewareClientNextFn<TMiddlewares>;
-    filename: string;
-    functionId: string;
-    type: ServerFnTypeOrTypeFn<Method, TServerFnResponseType, TMiddlewares, TValidator>;
-    router: TRouter;
-}
-export type FunctionMiddlewareClientFnResult<TMiddlewares, TSendContext, TClientContext> = Promise<FunctionClientResultWithContext<TMiddlewares, TSendContext, TClientContext>> | FunctionClientResultWithContext<TMiddlewares, TSendContext, TClientContext>;
-export type FunctionClientResultWithContext<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 interface FunctionMiddlewareAfterClient<TMiddlewares, TValidator, TServerSendContext, TClientContext, TServerFnResponseType extends ServerFnResponseType> extends FunctionMiddlewareWithTypes<TMiddlewares, TValidator, undefined, TServerSendContext, TClientContext, undefined, TServerFnResponseType>, FunctionMiddlewareServer<TMiddlewares, TValidator, TServerSendContext, TClientContext, TServerFnResponseType> {
-}
-export interface FunctionMiddlewareValidator<TMiddlewares, TServerFnResponseType extends ServerFnResponseType> {
-    validator: <TNewValidator>(input: ConstrainValidator<TNewValidator>) => FunctionMiddlewareAfterValidator<TMiddlewares, TNewValidator, TServerFnResponseType>;
-}
-export interface FunctionMiddlewareAfterValidator<TMiddlewares, TValidator, TServerFnResponseType extends ServerFnResponseType> extends FunctionMiddlewareWithTypes<TMiddlewares, TValidator, undefined, undefined, undefined, undefined, ServerFnResponseType>, FunctionMiddlewareServer<TMiddlewares, TValidator, undefined, undefined, TServerFnResponseType>, FunctionMiddlewareClient<TMiddlewares, TValidator, ServerFnResponseType> {
-}
-export interface RequestMiddleware extends RequestMiddlewareAfterMiddleware<undefined> {
-    middleware: <const TMiddlewares = undefined>(middlewares: Constrain<TMiddlewares, ReadonlyArray<AnyRequestMiddleware>>) => RequestMiddlewareAfterMiddleware<TMiddlewares>;
-}
-export type AnyRequestMiddleware = RequestMiddlewareWithTypes<any, any>;
-export interface RequestMiddlewareWithTypes<TMiddlewares, TServerContext> {
-    _types: RequestMiddlewareTypes<TMiddlewares, TServerContext>;
-}
-export interface RequestMiddlewareTypes<TMiddlewares, TServerContext> {
-    type: 'request';
-    middlewares: TMiddlewares;
-    serverContext: TServerContext;
-    allServerContext: AssignAllServerContext<TMiddlewares, undefined, TServerContext>;
-}
-export interface RequestMiddlewareAfterMiddleware<TMiddlewares> extends RequestMiddlewareWithTypes<TMiddlewares, undefined>, RequestMiddlewareServer<TMiddlewares> {
-}
-export interface RequestMiddlewareServer<TMiddlewares> {
-    server: <TServerContext = undefined>(fn: RequestServerFn<TMiddlewares, TServerContext>) => RequestMiddlewareAfterServer<TMiddlewares, TServerContext>;
-}
-export type RequestServerFn<TMiddlewares, TServerContext> = (options: RequestServerOptions<TMiddlewares>) => RequestMiddlewareServerFnResult<TMiddlewares, TServerContext>;
-export interface RequestServerOptions<TMiddlewares> {
-    request: Request;
-    pathname: string;
-    context: AssignAllServerContext<TMiddlewares>;
-    next: RequestServerNextFn<TMiddlewares>;
-}
-export type RequestServerNextFn<TMiddlewares> = <TServerContext = undefined>(options?: RequestServerNextFnOptions<TServerContext>) => RequestMiddlewareServerFnResult<TMiddlewares, TServerContext>;
-export interface RequestServerNextFnOptions<TServerContext> {
-    context?: TServerContext;
-}
-export type RequestMiddlewareServerFnResult<TMiddlewares, TServerContext> = Promise<RequestServerResult<TMiddlewares, TServerContext>> | RequestServerResult<TMiddlewares, TServerContext>;
-export interface RequestServerResult<TMiddlewares, TServerContext> {
-    request: Request;
-    pathname: string;
-    context: Expand<AssignAllServerContext<TMiddlewares, undefined, TServerContext>>;
-    response: Response;
-}
-export interface RequestMiddlewareAfterServer<TMiddlewares, TServerContext> extends RequestMiddlewareWithTypes<TMiddlewares, TServerContext> {
-}

package/dist/cjs/createServerFn.cjs

@@ -1,385 +0,0 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const invariant = require("tiny-invariant");
-const warning = require("tiny-warning");
-const routerCore = require("@tanstack/router-core");
-const client = require("@tanstack/router-core/ssr/client");
-const startStorageContext = require("@tanstack/start-storage-context");
-const registerGlobalMiddleware = require("./registerGlobalMiddleware.cjs");
-const serializer = require("./serializer.cjs");
-const createIsomorphicFn = require("./createIsomorphicFn.cjs");
-const getRouterInstance = createIsomorphicFn.createIsomorphicFn().client(() => window.__TSR_ROUTER__).server(() => {
-  var _a;
-  return (_a = startStorageContext.getStartContext({ throwIfNotFound: false })) == null ? void 0 : _a.router;
-});
-function createServerFn(options, __opts) {
-  const resolvedOptions = __opts || options || {};
-  if (typeof resolvedOptions.method === "undefined") {
-    resolvedOptions.method = "GET";
-  }
-  return {
-    options: resolvedOptions,
-    middleware: (middleware) => {
-      return createServerFn(void 0, Object.assign(resolvedOptions, { middleware }));
-    },
-    validator: (validator) => {
-      return createServerFn(void 0, Object.assign(resolvedOptions, { validator }));
-    },
-    type: (type) => {
-      return createServerFn(void 0, Object.assign(resolvedOptions, { type }));
-    },
-    handler: (...args) => {
-      const [extractedFn, serverFn] = args;
-      Object.assign(resolvedOptions, {
-        ...extractedFn,
-        extractedFn,
-        serverFn
-      });
-      const resolvedMiddleware = [
-        ...resolvedOptions.middleware || [],
-        serverFnBaseToMiddleware(resolvedOptions)
-      ];
-      return Object.assign(
-        async (opts) => {
-          return executeMiddleware(resolvedMiddleware, "client", {
-            ...extractedFn,
-            ...resolvedOptions,
-            data: opts == null ? void 0 : opts.data,
-            headers: opts == null ? void 0 : opts.headers,
-            signal: opts == null ? void 0 : opts.signal,
-            context: {},
-            router: getRouterInstance()
-          }).then((d) => {
-            if (resolvedOptions.response === "full") {
-              return d;
-            }
-            if (d.error) throw d.error;
-            return d.result;
-          });
-        },
-        {
-          // This copies over the URL, function ID
-          ...extractedFn,
-          // The extracted function on the server-side calls
-          // this function
-          __executeServer: async (opts_, signal) => {
-            var _a, _b;
-            const opts = opts_ instanceof FormData ? extractFormDataContext(opts_) : opts_;
-            opts.type = typeof resolvedOptions.type === "function" ? resolvedOptions.type(opts) : resolvedOptions.type;
-            const ctx = {
-              ...extractedFn,
-              ...opts,
-              signal
-            };
-            const run = () => executeMiddleware(resolvedMiddleware, "server", ctx).then(
-              (d) => ({
-                // Only send the result and sendContext back to the client
-                result: d.result,
-                error: d.error,
-                context: d.sendContext
-              })
-            );
-            if (ctx.type === "static") {
-              let response;
-              if ((_a = exports.serverFnStaticCache) == null ? void 0 : _a.getItem) {
-                response = await exports.serverFnStaticCache.getItem(ctx);
-              }
-              if (!response) {
-                response = await run().then((d) => {
-                  return {
-                    ctx: d,
-                    error: null
-                  };
-                }).catch((e) => {
-                  return {
-                    ctx: void 0,
-                    error: e
-                  };
-                });
-                if ((_b = exports.serverFnStaticCache) == null ? void 0 : _b.setItem) {
-                  await exports.serverFnStaticCache.setItem(ctx, response);
-                }
-              }
-              invariant(
-                response,
-                "No response from both server and static cache!"
-              );
-              if (response.error) {
-                throw response.error;
-              }
-              return response.ctx;
-            }
-            return run();
-          }
-        }
-      );
-    }
-  };
-}
-async function executeMiddleware(middlewares, env, opts) {
-  const flattenedMiddlewares = flattenMiddlewares([
-    ...registerGlobalMiddleware.globalMiddleware,
-    ...middlewares
-  ]);
-  const next = async (ctx) => {
-    const nextMiddleware = flattenedMiddlewares.shift();
-    if (!nextMiddleware) {
-      return ctx;
-    }
-    if (nextMiddleware.options.validator && (env === "client" ? nextMiddleware.options.validateClient : true)) {
-      ctx.data = await execValidator(nextMiddleware.options.validator, ctx.data);
-    }
-    const middlewareFn = env === "client" ? nextMiddleware.options.client : nextMiddleware.options.server;
-    if (middlewareFn) {
-      return applyMiddleware(middlewareFn, ctx, async (newCtx) => {
-        return next(newCtx).catch((error) => {
-          if (routerCore.isRedirect(error) || routerCore.isNotFound(error)) {
-            return {
-              ...newCtx,
-              error
-            };
-          }
-          throw error;
-        });
-      });
-    }
-    return next(ctx);
-  };
-  return next({
-    ...opts,
-    headers: opts.headers || {},
-    sendContext: opts.sendContext || {},
-    context: opts.context || {}
-  });
-}
-exports.serverFnStaticCache = void 0;
-function setServerFnStaticCache(cache) {
-  const previousCache = exports.serverFnStaticCache;
-  exports.serverFnStaticCache = typeof cache === "function" ? cache() : cache;
-  return () => {
-    exports.serverFnStaticCache = previousCache;
-  };
-}
-function createServerFnStaticCache(serverFnStaticCache2) {
-  return serverFnStaticCache2;
-}
-async function sha1Hash(message) {
-  const msgBuffer = new TextEncoder().encode(message);
-  const hashBuffer = await crypto.subtle.digest("SHA-1", msgBuffer);
-  const hashArray = Array.from(new Uint8Array(hashBuffer));
-  const hashHex = hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
-  return hashHex;
-}
-setServerFnStaticCache(() => {
-  const getStaticCacheUrl = async (options, hash) => {
-    const filename = await sha1Hash(`${options.functionId}__${hash}`);
-    return `/__tsr/staticServerFnCache/${filename}.json`;
-  };
-  const jsonToFilenameSafeString = (json) => {
-    const sortedKeysReplacer = (key, value) => value && typeof value === "object" && !Array.isArray(value) ? Object.keys(value).sort().reduce((acc, curr) => {
-      acc[curr] = value[curr];
-      return acc;
-    }, {}) : value;
-    const jsonString = JSON.stringify(json ?? "", sortedKeysReplacer);
-    return jsonString.replace(/[/\\?%*:|"<>]/g, "-").replace(/\s+/g, "_");
-  };
-  const staticClientCache = typeof document !== "undefined" ? /* @__PURE__ */ new Map() : null;
-  return createServerFnStaticCache({
-    getItem: async (ctx) => {
-      if (typeof document === "undefined") {
-        const hash = jsonToFilenameSafeString(ctx.data);
-        const url = await getStaticCacheUrl(ctx, hash);
-        const publicUrl = process.env.TSS_OUTPUT_PUBLIC_DIR;
-        const { promises: fs } = await import("node:fs");
-        const path = await import("node:path");
-        const filePath = path.join(publicUrl, url);
-        const [cachedResult, readError] = await fs.readFile(filePath, "utf-8").then((c) => [
-          serializer.startSerializer.parse(c),
-          null
-        ]).catch((e) => [null, e]);
-        if (readError && readError.code !== "ENOENT") {
-          throw readError;
-        }
-        return cachedResult;
-      }
-      return void 0;
-    },
-    setItem: async (ctx, response) => {
-      const { promises: fs } = await import("node:fs");
-      const path = await import("node:path");
-      const hash = jsonToFilenameSafeString(ctx.data);
-      const url = await getStaticCacheUrl(ctx, hash);
-      const publicUrl = process.env.TSS_OUTPUT_PUBLIC_DIR;
-      const filePath = path.join(publicUrl, url);
-      await fs.mkdir(path.dirname(filePath), { recursive: true });
-      await fs.writeFile(filePath, serializer.startSerializer.stringify(response));
-    },
-    fetchItem: async (ctx) => {
-      const hash = jsonToFilenameSafeString(ctx.data);
-      const url = await getStaticCacheUrl(ctx, hash);
-      let result = staticClientCache == null ? void 0 : staticClientCache.get(url);
-      if (!result) {
-        result = await fetch(url, {
-          method: "GET"
-        }).then((r) => r.text()).then((d) => serializer.startSerializer.parse(d));
-        staticClientCache == null ? void 0 : staticClientCache.set(url, result);
-      }
-      return result;
-    }
-  });
-});
-function extractFormDataContext(formData) {
-  const serializedContext = formData.get("__TSR_CONTEXT");
-  formData.delete("__TSR_CONTEXT");
-  if (typeof serializedContext !== "string") {
-    return {
-      context: {},
-      data: formData
-    };
-  }
-  try {
-    const context = serializer.startSerializer.parse(serializedContext);
-    return {
-      context,
-      data: formData
-    };
-  } catch {
-    return {
-      data: formData
-    };
-  }
-}
-function flattenMiddlewares(middlewares) {
-  const seen = /* @__PURE__ */ new Set();
-  const flattened = [];
-  const recurse = (middleware) => {
-    middleware.forEach((m) => {
-      if (m.options.middleware) {
-        recurse(m.options.middleware);
-      }
-      if (!seen.has(m)) {
-        seen.add(m);
-        flattened.push(m);
-      }
-    });
-  };
-  recurse(middlewares);
-  return flattened;
-}
-const applyMiddleware = async (middlewareFn, ctx, nextFn) => {
-  return middlewareFn({
-    ...ctx,
-    next: async (userCtx = {}) => {
-      return nextFn({
-        ...ctx,
-        ...userCtx,
-        context: {
-          ...ctx.context,
-          ...userCtx.context
-        },
-        sendContext: {
-          ...ctx.sendContext,
-          ...userCtx.sendContext ?? {}
-        },
-        headers: client.mergeHeaders(ctx.headers, userCtx.headers),
-        result: userCtx.result !== void 0 ? userCtx.result : ctx.response === "raw" ? userCtx : ctx.result,
-        error: userCtx.error ?? ctx.error
-      });
-    }
-  });
-};
-function execValidator(validator, input) {
-  if (validator == null) return {};
-  if ("~standard" in validator) {
-    const result = validator["~standard"].validate(input);
-    if (result instanceof Promise)
-      throw new Error("Async validation not supported");
-    if (result.issues)
-      throw new Error(JSON.stringify(result.issues, void 0, 2));
-    return result.value;
-  }
-  if ("parse" in validator) {
-    return validator.parse(input);
-  }
-  if (typeof validator === "function") {
-    return validator(input);
-  }
-  throw new Error("Invalid validator type!");
-}
-function serverFnBaseToMiddleware(options) {
-  return {
-    _types: void 0,
-    options: {
-      validator: options.validator,
-      validateClient: options.validateClient,
-      client: async ({ next, sendContext, ...ctx }) => {
-        var _a;
-        const payload = {
-          ...ctx,
-          // switch the sendContext over to context
-          context: sendContext,
-          type: typeof ctx.type === "function" ? ctx.type(ctx) : ctx.type
-        };
-        if (ctx.type === "static" && process.env.NODE_ENV === "production" && typeof document !== "undefined") {
-          invariant(
-            exports.serverFnStaticCache,
-            "serverFnStaticCache.fetchItem is not available!"
-          );
-          const result = await exports.serverFnStaticCache.fetchItem(payload);
-          if (result) {
-            if (result.error) {
-              throw result.error;
-            }
-            return next(result.ctx);
-          }
-          warning(
-            result,
-            `No static cache item found for ${payload.functionId}__${JSON.stringify(payload.data)}, falling back to server function...`
-          );
-        }
-        const res = await ((_a = options.extractedFn) == null ? void 0 : _a.call(options, payload));
-        return next(res);
-      },
-      server: async ({ next, ...ctx }) => {
-        var _a;
-        const result = await ((_a = options.serverFn) == null ? void 0 : _a.call(options, ctx));
-        return next({
-          ...ctx,
-          result
-        });
-      }
-    }
-  };
-}
-exports.applyMiddleware = applyMiddleware;
-exports.createServerFn = createServerFn;
-exports.createServerFnStaticCache = createServerFnStaticCache;
-exports.execValidator = execValidator;
-exports.executeMiddleware = executeMiddleware;
-exports.extractFormDataContext = extractFormDataContext;
-exports.flattenMiddlewares = flattenMiddlewares;
-exports.serverFnBaseToMiddleware = serverFnBaseToMiddleware;
-exports.setServerFnStaticCache = setServerFnStaticCache;
-//# sourceMappingURL=createServerFn.cjs.map