@tanstack/start-client-core 1.114.4 → 1.114.5

package/dist/cjs/createServerFn.d.cts

@@ -0,0 +1,152 @@
+import { Readable } from 'node:stream';
+import { AnyValidator, Constrain, Expand, ResolveValidatorInput, SerializerParse, SerializerStringify, SerializerStringifyBy, Validator } from '@tanstack/router-core';
+import { AnyMiddleware, AssignAllClientSendContext, AssignAllServerContext, IntersectAllValidatorInputs, IntersectAllValidatorOutputs } from './createMiddleware.cjs';
+export interface JsonResponse<TData> extends Response {
+    json: () => Promise<TData>;
+}
+export type CompiledFetcherFnOptions = {
+    method: Method;
+    data: unknown;
+    response?: ServerFnResponseType;
+    headers?: HeadersInit;
+    signal?: AbortSignal;
+    context?: any;
+};
+export type Fetcher<TMiddlewares, TValidator, TResponse, TServerFnResponseType extends ServerFnResponseType> = undefined extends IntersectAllValidatorInputs<TMiddlewares, TValidator> ? OptionalFetcher<TMiddlewares, TValidator, TResponse, TServerFnResponseType> : RequiredFetcher<TMiddlewares, TValidator, TResponse, TServerFnResponseType>;
+export interface FetcherBase {
+    url: string;
+    __executeServer: (opts: {
+        method: Method;
+        response?: ServerFnResponseType;
+        data: unknown;
+        headers?: HeadersInit;
+        context?: any;
+        signal: AbortSignal;
+    }) => Promise<unknown>;
+}
+export type FetchResult<TMiddlewares, TResponse, TServerFnResponseType extends ServerFnResponseType> = TServerFnResponseType extends 'raw' ? Promise<Response> : TServerFnResponseType extends 'full' ? Promise<FullFetcherData<TMiddlewares, TResponse>> : Promise<FetcherData<TResponse>>;
+export interface OptionalFetcher<TMiddlewares, TValidator, TResponse, TServerFnResponseType extends ServerFnResponseType> extends FetcherBase {
+    (options?: OptionalFetcherDataOptions<TMiddlewares, TValidator>): FetchResult<TMiddlewares, TResponse, TServerFnResponseType>;
+}
+export interface RequiredFetcher<TMiddlewares, TValidator, TResponse, TServerFnResponseType extends ServerFnResponseType> extends FetcherBase {
+    (opts: RequiredFetcherDataOptions<TMiddlewares, TValidator>): FetchResult<TMiddlewares, TResponse, TServerFnResponseType>;
+}
+export type FetcherBaseOptions = {
+    headers?: HeadersInit;
+    type?: ServerFnType;
+    signal?: AbortSignal;
+};
+export type ServerFnType = 'static' | 'dynamic';
+export interface OptionalFetcherDataOptions<TMiddlewares, TValidator> extends FetcherBaseOptions {
+    data?: Expand<IntersectAllValidatorInputs<TMiddlewares, TValidator>>;
+}
+export interface RequiredFetcherDataOptions<TMiddlewares, TValidator> extends FetcherBaseOptions {
+    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 ServerFnResponseType = 'data' | 'full' | 'raw';
+export type RawResponse = Response | ReadableStream | Readable | null | string;
+export type ServerFnReturnType<TServerFnResponseType extends ServerFnResponseType, TResponse> = TServerFnResponseType extends 'raw' ? RawResponse | Promise<RawResponse> : Promise<SerializerStringify<TResponse>> | SerializerStringify<TResponse>;
+export type ServerFn<TMethod, TServerFnResponseType extends ServerFnResponseType, TMiddlewares, TValidator, TResponse> = (ctx: ServerFnCtx<TMethod, TServerFnResponseType, TMiddlewares, TValidator>) => ServerFnReturnType<TServerFnResponseType, TResponse>;
+export interface ServerFnCtx<TMethod, TServerFnResponseType extends ServerFnResponseType, TMiddlewares, TValidator> {
+    method: TMethod;
+    response: TServerFnResponseType;
+    data: Expand<IntersectAllValidatorOutputs<TMiddlewares, TValidator>>;
+    context: Expand<AssignAllServerContext<TMiddlewares>>;
+    signal: AbortSignal;
+}
+export type CompiledFetcherFn<TResponse, TServerFnResponseType extends ServerFnResponseType> = {
+    (opts: CompiledFetcherFnOptions & ServerFnBaseOptions<Method, TServerFnResponseType>): Promise<TResponse>;
+    url: string;
+};
+export type ServerFnBaseOptions<TMethod extends Method = 'GET', TServerFnResponseType extends ServerFnResponseType = 'data', TResponse = unknown, TMiddlewares = unknown, TInput = unknown> = {
+    method: TMethod;
+    response?: TServerFnResponseType;
+    validateClient?: boolean;
+    middleware?: Constrain<TMiddlewares, ReadonlyArray<AnyMiddleware>>;
+    validator?: ConstrainValidator<TInput>;
+    extractedFn?: CompiledFetcherFn<TResponse, TServerFnResponseType>;
+    serverFn?: ServerFn<TMethod, TServerFnResponseType, TMiddlewares, TInput, TResponse>;
+    functionId: string;
+    type: ServerFnTypeOrTypeFn<TMethod, TServerFnResponseType, 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, TServerFnResponseType extends ServerFnResponseType, TValidator> {
+    middleware: <const TNewMiddlewares = undefined>(middlewares: Constrain<TNewMiddlewares, ReadonlyArray<AnyMiddleware>>) => ServerFnAfterMiddleware<TMethod, TServerFnResponseType, TNewMiddlewares, TValidator>;
+}
+export interface ServerFnAfterMiddleware<TMethod extends Method, TServerFnResponseType extends ServerFnResponseType, TMiddlewares, TValidator> extends ServerFnValidator<TMethod, TServerFnResponseType, TMiddlewares>, ServerFnTyper<TMethod, TServerFnResponseType, TMiddlewares, TValidator>, ServerFnHandler<TMethod, TServerFnResponseType, TMiddlewares, TValidator> {
+}
+export type ValidatorFn<TMethod extends Method, TServerFnResponseType extends ServerFnResponseType, TMiddlewares> = <TValidator>(validator: ConstrainValidator<TValidator>) => ServerFnAfterValidator<TMethod, TServerFnResponseType, TMiddlewares, TValidator>;
+export interface ServerFnValidator<TMethod extends Method, TServerFnResponseType extends ServerFnResponseType, TMiddlewares> {
+    validator: ValidatorFn<TMethod, TServerFnResponseType, TMiddlewares>;
+}
+export interface ServerFnAfterValidator<TMethod extends Method, TServerFnResponseType extends ServerFnResponseType, TMiddlewares, TValidator> extends ServerFnMiddleware<TMethod, TServerFnResponseType, TValidator>, ServerFnTyper<TMethod, TServerFnResponseType, TMiddlewares, TValidator>, ServerFnHandler<TMethod, TServerFnResponseType, TMiddlewares, TValidator> {
+}
+export interface ServerFnTyper<TMethod extends Method, TServerFnResponseType extends ServerFnResponseType, TMiddlewares, TValidator> {
+    type: (typer: ServerFnTypeOrTypeFn<TMethod, TServerFnResponseType, TMiddlewares, TValidator>) => ServerFnAfterTyper<TMethod, TServerFnResponseType, TMiddlewares, TValidator>;
+}
+export type ServerFnTypeOrTypeFn<TMethod extends Method, TServerFnResponseType extends ServerFnResponseType, TMiddlewares, TValidator> = ServerFnType | ((ctx: ServerFnCtx<TMethod, TServerFnResponseType, TMiddlewares, TValidator>) => ServerFnType);
+export interface ServerFnAfterTyper<TMethod extends Method, TServerFnResponseType extends ServerFnResponseType, TMiddlewares, TValidator> extends ServerFnHandler<TMethod, TServerFnResponseType, TMiddlewares, TValidator> {
+}
+export interface ServerFnHandler<TMethod extends Method, TServerFnResponseType extends ServerFnResponseType, TMiddlewares, TValidator> {
+    handler: <TNewResponse>(fn?: ServerFn<TMethod, TServerFnResponseType, TMiddlewares, TValidator, TNewResponse>) => Fetcher<TMiddlewares, TValidator, TNewResponse, TServerFnResponseType>;
+}
+export interface ServerFnBuilder<TMethod extends Method = 'GET', TServerFnResponseType extends ServerFnResponseType = 'data'> extends ServerFnMiddleware<TMethod, TServerFnResponseType, undefined>, ServerFnValidator<TMethod, TServerFnResponseType, undefined>, ServerFnTyper<TMethod, TServerFnResponseType, undefined, undefined>, ServerFnHandler<TMethod, TServerFnResponseType, undefined, undefined> {
+    options: ServerFnBaseOptions<TMethod, TServerFnResponseType, unknown, undefined, undefined>;
+}
+export type StaticCachedResult = {
+    ctx?: {
+        result: any;
+        context: any;
+    };
+    error?: any;
+};
+export type ServerFnStaticCache = {
+    getItem: (ctx: ServerFnMiddlewareResult) => StaticCachedResult | Promise<StaticCachedResult | undefined>;
+    setItem: (ctx: ServerFnMiddlewareResult, response: StaticCachedResult) => Promise<void>;
+    fetchItem: (ctx: ServerFnMiddlewareResult) => StaticCachedResult | Promise<StaticCachedResult | undefined>;
+};
+export declare let serverFnStaticCache: ServerFnStaticCache | undefined;
+export declare function setServerFnStaticCache(cache?: ServerFnStaticCache | (() => ServerFnStaticCache | undefined)): () => void;
+export declare function createServerFnStaticCache(serverFnStaticCache: ServerFnStaticCache): ServerFnStaticCache;
+export declare function extractFormDataContext(formData: FormData): {
+    context: unknown;
+    data: FormData;
+} | {
+    data: FormData;
+    context?: undefined;
+};
+export declare function flattenMiddlewares(middlewares: Array<AnyMiddleware>): Array<AnyMiddleware>;
+export type ServerFnMiddlewareOptions = {
+    method: Method;
+    response?: ServerFnResponseType;
+    data: any;
+    headers?: HeadersInit;
+    signal?: AbortSignal;
+    sendContext?: any;
+    context?: any;
+    type: ServerFnTypeOrTypeFn<any, any, any, any>;
+    functionId: string;
+};
+export type ServerFnMiddlewareResult = ServerFnMiddlewareOptions & {
+    result?: unknown;
+    error?: unknown;
+    type: ServerFnTypeOrTypeFn<any, any, any, any>;
+};
+export type NextFn = (ctx: ServerFnMiddlewareResult) => Promise<ServerFnMiddlewareResult>;
+export type MiddlewareFn = (ctx: ServerFnMiddlewareOptions & {
+    next: NextFn;
+}) => Promise<ServerFnMiddlewareResult>;
+export declare const applyMiddleware: (middlewareFn: MiddlewareFn, ctx: ServerFnMiddlewareOptions, nextFn: NextFn) => Promise<ServerFnMiddlewareResult>;
+export declare function execValidator(validator: AnyValidator, input: unknown): unknown;
+export declare function serverFnBaseToMiddleware(options: ServerFnBaseOptions<any, any, any, any, any>): AnyMiddleware;

package/dist/cjs/envOnly.cjs

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const serverOnly = (fn) => fn;
+const clientOnly = (fn) => fn;
+exports.clientOnly = clientOnly;
+exports.serverOnly = serverOnly;
+//# sourceMappingURL=envOnly.cjs.map

package/dist/cjs/envOnly.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"envOnly.cjs","sources":["../../src/envOnly.ts"],"sourcesContent":["type EnvOnlyFn = <TFn extends (...args: Array<any>) => any>(fn: TFn) => TFn\n\n// A function that will only be available in the server build\n// If called on the client, it will throw an error\nexport const serverOnly: EnvOnlyFn = (fn) => fn\n\n// A function that will only be available in the client build\n// If called on the server, it will throw an error\nexport const clientOnly: EnvOnlyFn = (fn) => fn\n"],"names":[],"mappings":";;AAIa,MAAA,aAAwB,CAAC,OAAO;AAIhC,MAAA,aAAwB,CAAC,OAAO;;;"}

package/dist/cjs/envOnly.d.cts

@@ -0,0 +1,4 @@
+type EnvOnlyFn = <TFn extends (...args: Array<any>) => any>(fn: TFn) => TFn;
+export declare const serverOnly: EnvOnlyFn;
+export declare const clientOnly: EnvOnlyFn;
+export {};

package/dist/cjs/index.cjs

@@ -3,7 +3,29 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const headers = require("./headers.cjs");
 const serializer = require("./serializer.cjs");
 const ssrClient = require("./ssr-client.cjs");
+const createIsomorphicFn = require("./createIsomorphicFn.cjs");
+const envOnly = require("./envOnly.cjs");
+const json = require("./json.cjs");
+const createMiddleware = require("./createMiddleware.cjs");
+const registerGlobalMiddleware = require("./registerGlobalMiddleware.cjs");
+const createServerFn = require("./createServerFn.cjs");
 exports.mergeHeaders = headers.mergeHeaders;
 exports.startSerializer = serializer.startSerializer;
 exports.hydrate = ssrClient.hydrate;
+exports.createIsomorphicFn = createIsomorphicFn.createIsomorphicFn;
+exports.clientOnly = envOnly.clientOnly;
+exports.serverOnly = envOnly.serverOnly;
+exports.json = json.json;
+exports.createMiddleware = createMiddleware.createMiddleware;
+exports.globalMiddleware = registerGlobalMiddleware.globalMiddleware;
+exports.registerGlobalMiddleware = registerGlobalMiddleware.registerGlobalMiddleware;
+exports.applyMiddleware = createServerFn.applyMiddleware;
+exports.execValidator = createServerFn.execValidator;
+exports.extractFormDataContext = createServerFn.extractFormDataContext;
+exports.flattenMiddlewares = createServerFn.flattenMiddlewares;
+exports.serverFnBaseToMiddleware = createServerFn.serverFnBaseToMiddleware;
+Object.defineProperty(exports, "serverFnStaticCache", {
+  enumerable: true,
+  get: () => createServerFn.serverFnStaticCache
+});
 //# sourceMappingURL=index.cjs.map

package/dist/cjs/index.cjs.map

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

package/dist/cjs/index.d.cts

@@ -1,3 +1,11 @@
 export { mergeHeaders } from './headers.cjs';
 export { startSerializer } from './serializer.cjs';
 export { type DehydratedRouter, type ClientExtractedBaseEntry, type StartSsrGlobal, type ClientExtractedEntry, type SsrMatch, type ClientExtractedPromise, type ClientExtractedStream, type ResolvePromiseState, hydrate, } from './ssr-client.cjs';
+export { createIsomorphicFn, type IsomorphicFn, type ServerOnlyFn, type ClientOnlyFn, type IsomorphicFnBase, } from './createIsomorphicFn.cjs';
+export { serverOnly, clientOnly } from './envOnly.cjs';
+export { type JsonResponse } from './createServerFn.cjs';
+export { json } from './json.cjs';
+export { createMiddleware, type IntersectAllValidatorInputs, type IntersectAllValidatorOutputs, type MiddlewareServerFn, type AnyMiddleware, type MiddlewareOptions, type MiddlewareWithTypes, type MiddlewareValidator, type MiddlewareServer, type MiddlewareAfterClient, type MiddlewareAfterMiddleware, type MiddlewareAfterServer, type Middleware, type MiddlewareClientFnOptions, type MiddlewareClientFnResult, type MiddlewareClientNextFn, type ClientResultWithContext, type AssignAllClientContextBeforeNext, type AssignAllMiddleware, type AssignAllServerContext, type MiddlewareAfterValidator, type MiddlewareClientFn, type MiddlewareServerFnResult, type MiddlewareClient, type MiddlewareServerFnOptions, type MiddlewareServerNextFn, type ServerResultWithContext, } from './createMiddleware.cjs';
+export { registerGlobalMiddleware, globalMiddleware, } from './registerGlobalMiddleware.cjs';
+export type { ServerFn as FetchFn, ServerFnCtx as FetchFnCtx, CompiledFetcherFnOptions, CompiledFetcherFn, Fetcher, RscStream, FetcherData, FetcherBaseOptions, ServerFn, ServerFnCtx, ServerFnResponseType, MiddlewareFn, ServerFnMiddlewareOptions, ServerFnMiddlewareResult, ServerFnBuilder, ServerFnType, ServerFnBaseOptions, NextFn, Method, StaticCachedResult, } from './createServerFn.cjs';
+export { applyMiddleware, execValidator, serverFnBaseToMiddleware, extractFormDataContext, flattenMiddlewares, serverFnStaticCache, } from './createServerFn.cjs';

package/dist/cjs/json.cjs

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const headers = require("./headers.cjs");
+function json(payload, init) {
+  return new Response(JSON.stringify(payload), {
+    ...init,
+    headers: headers.mergeHeaders(
+      { "content-type": "application/json" },
+      init == null ? void 0 : init.headers
+    )
+  });
+}
+exports.json = json;
+//# sourceMappingURL=json.cjs.map

package/dist/cjs/json.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"json.cjs","sources":["../../src/json.ts"],"sourcesContent":["import { mergeHeaders } from './headers'\nimport type { JsonResponse } from './createServerFn'\n\nexport function json<TData>(\n  payload: TData,\n  init?: ResponseInit,\n): JsonResponse<TData> {\n  return new Response(JSON.stringify(payload), {\n    ...init,\n    headers: mergeHeaders(\n      { 'content-type': 'application/json' },\n      init?.headers,\n    ),\n  })\n}\n"],"names":["mergeHeaders"],"mappings":";;;AAGgB,SAAA,KACd,SACA,MACqB;AACrB,SAAO,IAAI,SAAS,KAAK,UAAU,OAAO,GAAG;AAAA,IAC3C,GAAG;AAAA,IACH,SAASA,QAAA;AAAA,MACP,EAAE,gBAAgB,mBAAmB;AAAA,MACrC,6BAAM;AAAA,IAAA;AAAA,EACR,CACD;AACH;;"}

package/dist/cjs/json.d.cts

@@ -0,0 +1,2 @@
+import { JsonResponse } from './createServerFn.cjs';
+export declare function json<TData>(payload: TData, init?: ResponseInit): JsonResponse<TData>;

package/dist/cjs/registerGlobalMiddleware.cjs

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const globalMiddleware = [];
+function registerGlobalMiddleware(options) {
+  globalMiddleware.push(...options.middleware);
+}
+exports.globalMiddleware = globalMiddleware;
+exports.registerGlobalMiddleware = registerGlobalMiddleware;
+//# sourceMappingURL=registerGlobalMiddleware.cjs.map

package/dist/cjs/registerGlobalMiddleware.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"registerGlobalMiddleware.cjs","sources":["../../src/registerGlobalMiddleware.ts"],"sourcesContent":["import type { AnyMiddleware } from './createMiddleware'\n\nexport const globalMiddleware: Array<AnyMiddleware> = []\n\nexport function registerGlobalMiddleware(options: {\n  middleware: Array<AnyMiddleware>\n}) {\n  globalMiddleware.push(...options.middleware)\n}\n"],"names":[],"mappings":";;AAEO,MAAM,mBAAyC,CAAA;AAE/C,SAAS,yBAAyB,SAEtC;AACgB,mBAAA,KAAK,GAAG,QAAQ,UAAU;AAC7C;;;"}

package/dist/cjs/registerGlobalMiddleware.d.cts

@@ -0,0 +1,5 @@
+import { AnyMiddleware } from './createMiddleware.cjs';
+export declare const globalMiddleware: Array<AnyMiddleware>;
+export declare function registerGlobalMiddleware(options: {
+    middleware: Array<AnyMiddleware>;
+}): void;

package/dist/cjs/tests/createIsomorphicFn.test-d.d.cts

@@ -0,0 +1 @@
+export {};

package/dist/cjs/tests/createServerMiddleware.test-d.d.cts

@@ -0,0 +1 @@
+export {};

package/dist/cjs/tests/envOnly.test-d.d.cts

@@ -0,0 +1 @@
+export {};

package/dist/cjs/tests/json.test.d.cts

@@ -0,0 +1 @@
+export {};

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,131 @@
+import { ConstrainValidator, Method, ServerFnResponseType, 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, in out TServerFnResponseType extends ServerFnResponseType> {
+    validateClient?: boolean;
+    middleware?: TMiddlewares;
+    validator?: ConstrainValidator<TValidator>;
+    client?: MiddlewareClientFn<TMiddlewares, TValidator, TServerContext, TClientContext, TServerFnResponseType>;
+    server?: MiddlewareServerFn<TMiddlewares, TValidator, TServerContext, unknown, unknown, TServerFnResponseType>;
+}
+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, in out TServerFnResponseType> {
+    data: Expand<IntersectAllValidatorOutputs<TMiddlewares, TValidator>>;
+    context: Expand<AssignAllServerContext<TMiddlewares, TServerSendContext>>;
+    next: MiddlewareServerNextFn<TMiddlewares, TServerSendContext>;
+    response: TServerFnResponseType;
+    method: Method;
+    filename: string;
+    functionId: string;
+    signal: AbortSignal;
+}
+export type MiddlewareServerFn<TMiddlewares, TValidator, TServerSendContext, TNewServerContext, TSendContext, TServerFnResponseType extends ServerFnResponseType> = (options: MiddlewareServerFnOptions<TMiddlewares, TValidator, TServerSendContext, TServerFnResponseType>) => 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, in out TServerFnResponseType extends ServerFnResponseType> {
+    data: Expand<IntersectAllValidatorInputs<TMiddlewares, TValidator>>;
+    context: Expand<AssignAllClientContextBeforeNext<TMiddlewares>>;
+    sendContext: Expand<AssignAllServerSendContext<TMiddlewares>>;
+    method: Method;
+    response: TServerFnResponseType;
+    signal: AbortSignal;
+    next: MiddlewareClientNextFn<TMiddlewares>;
+    filename: string;
+    functionId: string;
+    type: ServerFnTypeOrTypeFn<Method, TServerFnResponseType, TMiddlewares, TValidator>;
+}
+export type MiddlewareClientFn<TMiddlewares, TValidator, TSendContext, TClientContext, TServerFnResponseType extends ServerFnResponseType> = (options: MiddlewareClientFnOptions<TMiddlewares, TValidator, TServerFnResponseType>) => 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, 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, TServerFnResponseType extends ServerFnResponseType> {
+    _types: MiddlewareTypes<TMiddlewares, TValidator, TServerContext, TServerSendContext, TClientContext, TClientSendContext>;
+    options: MiddlewareOptions<TMiddlewares, TValidator, TServerContext, TClientContext, TServerFnResponseType>;
+}
+export interface MiddlewareAfterValidator<TMiddlewares, TValidator, TServerFnResponseType extends ServerFnResponseType> extends MiddlewareWithTypes<TMiddlewares, TValidator, undefined, undefined, undefined, undefined, ServerFnResponseType>, MiddlewareServer<TMiddlewares, TValidator, undefined, undefined, TServerFnResponseType>, MiddlewareClient<TMiddlewares, TValidator, ServerFnResponseType> {
+}
+export interface MiddlewareValidator<TMiddlewares, TServerFnResponseType extends ServerFnResponseType> {
+    validator: <TNewValidator>(input: ConstrainValidator<TNewValidator>) => MiddlewareAfterValidator<TMiddlewares, TNewValidator, TServerFnResponseType>;
+}
+export interface MiddlewareAfterServer<TMiddlewares, TValidator, TServerContext, TServerSendContext, TClientContext, TClientSendContext, TServerFnResponseType extends ServerFnResponseType> extends MiddlewareWithTypes<TMiddlewares, TValidator, TServerContext, TServerSendContext, TClientContext, TClientSendContext, TServerFnResponseType> {
+}
+export interface MiddlewareServer<TMiddlewares, TValidator, TServerSendContext, TClientContext, TServerFnResponseType extends ServerFnResponseType> {
+    server: <TNewServerContext = undefined, TSendContext = undefined>(server: MiddlewareServerFn<TMiddlewares, TValidator, TServerSendContext, TNewServerContext, TSendContext, TServerFnResponseType>) => MiddlewareAfterServer<TMiddlewares, TValidator, TNewServerContext, TServerSendContext, TClientContext, TSendContext, ServerFnResponseType>;
+}
+export interface MiddlewareAfterClient<TMiddlewares, TValidator, TServerSendContext, TClientContext, TServerFnResponseType extends ServerFnResponseType> extends MiddlewareWithTypes<TMiddlewares, TValidator, undefined, TServerSendContext, TClientContext, undefined, TServerFnResponseType>, MiddlewareServer<TMiddlewares, TValidator, TServerSendContext, TClientContext, TServerFnResponseType> {
+}
+export interface MiddlewareClient<TMiddlewares, TValidator, TServerFnResponseType extends ServerFnResponseType> {
+    client: <TSendServerContext = undefined, TNewClientContext = undefined>(client: MiddlewareClientFn<TMiddlewares, TValidator, TSendServerContext, TNewClientContext, TServerFnResponseType>) => MiddlewareAfterClient<TMiddlewares, TValidator, TSendServerContext, TNewClientContext, ServerFnResponseType>;
+}
+export interface MiddlewareAfterMiddleware<TMiddlewares, TServerFnResponseType extends ServerFnResponseType> extends MiddlewareWithTypes<TMiddlewares, undefined, undefined, undefined, undefined, undefined, TServerFnResponseType>, MiddlewareServer<TMiddlewares, undefined, undefined, undefined, TServerFnResponseType>, MiddlewareClient<TMiddlewares, undefined, TServerFnResponseType>, MiddlewareValidator<TMiddlewares, TServerFnResponseType> {
+}
+export interface Middleware<TServerFnResponseType extends ServerFnResponseType> extends MiddlewareAfterMiddleware<unknown, TServerFnResponseType> {
+    middleware: <const TNewMiddlewares = undefined>(middlewares: Constrain<TNewMiddlewares, ReadonlyArray<AnyMiddleware>>) => MiddlewareAfterMiddleware<TNewMiddlewares, TServerFnResponseType>;
+}
+export declare function createMiddleware(options?: {
+    validateClient?: boolean;
+}, __opts?: MiddlewareOptions<unknown, undefined, undefined, undefined, ServerFnResponseType>): Middleware<ServerFnResponseType>;

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  ServerFnResponseType,\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  in out TServerFnResponseType extends ServerFnResponseType,\n> {\n  validateClient?: boolean\n  middleware?: TMiddlewares\n  validator?: ConstrainValidator<TValidator>\n  client?: MiddlewareClientFn<\n    TMiddlewares,\n    TValidator,\n    TServerContext,\n    TClientContext,\n    TServerFnResponseType\n  >\n  server?: MiddlewareServerFn<\n    TMiddlewares,\n    TValidator,\n    TServerContext,\n    unknown,\n    unknown,\n    TServerFnResponseType\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  in out TServerFnResponseType,\n> {\n  data: Expand<IntersectAllValidatorOutputs<TMiddlewares, TValidator>>\n  context: Expand<AssignAllServerContext<TMiddlewares, TServerSendContext>>\n  next: MiddlewareServerNextFn<TMiddlewares, TServerSendContext>\n  response: TServerFnResponseType\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  TServerFnResponseType extends ServerFnResponseType,\n> = (\n  options: MiddlewareServerFnOptions<\n    TMiddlewares,\n    TValidator,\n    TServerSendContext,\n    TServerFnResponseType\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  in out TServerFnResponseType extends ServerFnResponseType,\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: MiddlewareClientNextFn<TMiddlewares>\n  filename: string\n  functionId: string\n  type: ServerFnTypeOrTypeFn<\n    Method,\n    TServerFnResponseType,\n    TMiddlewares,\n    TValidator\n  >\n}\n\nexport type MiddlewareClientFn<\n  TMiddlewares,\n  TValidator,\n  TSendContext,\n  TClientContext,\n  TServerFnResponseType extends ServerFnResponseType,\n> = (\n  options: MiddlewareClientFnOptions<\n    TMiddlewares,\n    TValidator,\n    TServerFnResponseType\n  >,\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<\n  any,\n  any,\n  any,\n  any,\n  any,\n  any,\n  any\n>\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  TServerFnResponseType extends ServerFnResponseType,\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    TServerFnResponseType\n  >\n}\n\nexport interface MiddlewareAfterValidator<\n  TMiddlewares,\n  TValidator,\n  TServerFnResponseType extends ServerFnResponseType,\n> extends MiddlewareWithTypes<\n      TMiddlewares,\n      TValidator,\n      undefined,\n      undefined,\n      undefined,\n      undefined,\n      ServerFnResponseType\n    >,\n    MiddlewareServer<\n      TMiddlewares,\n      TValidator,\n      undefined,\n      undefined,\n      TServerFnResponseType\n    >,\n    MiddlewareClient<TMiddlewares, TValidator, ServerFnResponseType> {}\n\nexport interface MiddlewareValidator<\n  TMiddlewares,\n  TServerFnResponseType extends ServerFnResponseType,\n> {\n  validator: <TNewValidator>(\n    input: ConstrainValidator<TNewValidator>,\n  ) => MiddlewareAfterValidator<\n    TMiddlewares,\n    TNewValidator,\n    TServerFnResponseType\n  >\n}\n\nexport interface MiddlewareAfterServer<\n  TMiddlewares,\n  TValidator,\n  TServerContext,\n  TServerSendContext,\n  TClientContext,\n  TClientSendContext,\n  TServerFnResponseType extends ServerFnResponseType,\n> extends MiddlewareWithTypes<\n    TMiddlewares,\n    TValidator,\n    TServerContext,\n    TServerSendContext,\n    TClientContext,\n    TClientSendContext,\n    TServerFnResponseType\n  > {}\n\nexport interface MiddlewareServer<\n  TMiddlewares,\n  TValidator,\n  TServerSendContext,\n  TClientContext,\n  TServerFnResponseType extends ServerFnResponseType,\n> {\n  server: <TNewServerContext = undefined, TSendContext = undefined>(\n    server: MiddlewareServerFn<\n      TMiddlewares,\n      TValidator,\n      TServerSendContext,\n      TNewServerContext,\n      TSendContext,\n      TServerFnResponseType\n    >,\n  ) => MiddlewareAfterServer<\n    TMiddlewares,\n    TValidator,\n    TNewServerContext,\n    TServerSendContext,\n    TClientContext,\n    TSendContext,\n    ServerFnResponseType\n  >\n}\n\nexport interface MiddlewareAfterClient<\n  TMiddlewares,\n  TValidator,\n  TServerSendContext,\n  TClientContext,\n  TServerFnResponseType extends ServerFnResponseType,\n> extends MiddlewareWithTypes<\n      TMiddlewares,\n      TValidator,\n      undefined,\n      TServerSendContext,\n      TClientContext,\n      undefined,\n      TServerFnResponseType\n    >,\n    MiddlewareServer<\n      TMiddlewares,\n      TValidator,\n      TServerSendContext,\n      TClientContext,\n      TServerFnResponseType\n    > {}\n\nexport interface MiddlewareClient<\n  TMiddlewares,\n  TValidator,\n  TServerFnResponseType extends ServerFnResponseType,\n> {\n  client: <TSendServerContext = undefined, TNewClientContext = undefined>(\n    client: MiddlewareClientFn<\n      TMiddlewares,\n      TValidator,\n      TSendServerContext,\n      TNewClientContext,\n      TServerFnResponseType\n    >,\n  ) => MiddlewareAfterClient<\n    TMiddlewares,\n    TValidator,\n    TSendServerContext,\n    TNewClientContext,\n    ServerFnResponseType\n  >\n}\n\nexport interface MiddlewareAfterMiddleware<\n  TMiddlewares,\n  TServerFnResponseType extends ServerFnResponseType,\n> extends MiddlewareWithTypes<\n      TMiddlewares,\n      undefined,\n      undefined,\n      undefined,\n      undefined,\n      undefined,\n      TServerFnResponseType\n    >,\n    MiddlewareServer<\n      TMiddlewares,\n      undefined,\n      undefined,\n      undefined,\n      TServerFnResponseType\n    >,\n    MiddlewareClient<TMiddlewares, undefined, TServerFnResponseType>,\n    MiddlewareValidator<TMiddlewares, TServerFnResponseType> {}\n\nexport interface Middleware<TServerFnResponseType extends ServerFnResponseType>\n  extends MiddlewareAfterMiddleware<unknown, TServerFnResponseType> {\n  middleware: <const TNewMiddlewares = undefined>(\n    middlewares: Constrain<TNewMiddlewares, ReadonlyArray<AnyMiddleware>>,\n  ) => MiddlewareAfterMiddleware<TNewMiddlewares, TServerFnResponseType>\n}\n\nexport function createMiddleware(\n  options?: {\n    validateClient?: boolean\n  },\n  __opts?: MiddlewareOptions<\n    unknown,\n    undefined,\n    undefined,\n    undefined,\n    ServerFnResponseType\n  >,\n): Middleware<ServerFnResponseType> {\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      ServerFnResponseType\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<ServerFnResponseType>\n}\n"],"names":[],"mappings":"AAgiBgB,SAAA,iBACd,SAGA,QAOkC;AAE5B,QAAA,kBACJ,WACE,WAAW;AAQR,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;"}