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

package/src/tests/createServerFn.test-d.ts

@@ -13,7 +13,7 @@ test('createServerFn method with autocomplete', () => {
 test('createServerFn without middleware', () => {
   expectTypeOf(createServerFn()).toHaveProperty('handler')
   expectTypeOf(createServerFn()).toHaveProperty('middleware')
-  expectTypeOf(createServerFn()).toHaveProperty('validator')
+  expectTypeOf(createServerFn()).toHaveProperty('inputValidator')
 
   createServerFn({ method: 'GET' }).handler((options) => {
     expectTypeOf(options).toEqualTypeOf<{
@@ -21,7 +21,6 @@ test('createServerFn without middleware', () => {
       context: undefined
       data: undefined
       signal: AbortSignal
-      response: 'data'
     }>()
   })
 })
@@ -29,13 +28,13 @@ test('createServerFn without middleware', () => {
 test('createServerFn with validator', () => {
   const fnAfterValidator = createServerFn({
     method: 'GET',
-  }).validator((input: { input: string }) => ({
+  }).inputValidator((input: { input: string }) => ({
     a: input.input,
   }))
 
   expectTypeOf(fnAfterValidator).toHaveProperty('handler')
   expectTypeOf(fnAfterValidator).toHaveProperty('middleware')
-  expectTypeOf(fnAfterValidator).not.toHaveProperty('validator')
+  expectTypeOf(fnAfterValidator).not.toHaveProperty('inputValidator')
 
   const fn = fnAfterValidator.handler((options) => {
     expectTypeOf(options).toEqualTypeOf<{
@@ -45,7 +44,6 @@ test('createServerFn with validator', () => {
         a: string
       }
       signal: AbortSignal
-      response: 'data'
     }>()
   })
 
@@ -96,8 +94,7 @@ test('createServerFn with middleware and context', () => {
   ])
 
   expectTypeOf(fnWithMiddleware).toHaveProperty('handler')
-  expectTypeOf(fnWithMiddleware).toHaveProperty('validator')
-  expectTypeOf(fnWithMiddleware).not.toHaveProperty('middleware')
+  expectTypeOf(fnWithMiddleware).toHaveProperty('inputValidator')
 
   fnWithMiddleware.handler((options) => {
     expectTypeOf(options).toEqualTypeOf<{
@@ -110,20 +107,19 @@ test('createServerFn with middleware and context', () => {
       }
       data: undefined
       signal: AbortSignal
-      response: 'data'
     }>()
   })
 })
 
 describe('createServerFn with middleware and validator', () => {
-  const middleware1 = createMiddleware({ type: 'function' }).validator(
+  const middleware1 = createMiddleware({ type: 'function' }).inputValidator(
     (input: { readonly inputA: 'inputA' }) =>
       ({
         outputA: 'outputA',
       }) as const,
   )
 
-  const middleware2 = createMiddleware({ type: 'function' }).validator(
+  const middleware2 = createMiddleware({ type: 'function' }).inputValidator(
     (input: { readonly inputB: 'inputB' }) =>
       ({
         outputB: 'outputB',
@@ -135,10 +131,10 @@ describe('createServerFn with middleware and validator', () => {
     middleware2,
   ])
 
-  test(`response: 'data'`, () => {
-    const fn = createServerFn({ method: 'GET', response: 'data' })
+  test(`response`, () => {
+    const fn = createServerFn({ method: 'GET' })
       .middleware([middleware3])
-      .validator(
+      .inputValidator(
         (input: { readonly inputC: 'inputC' }) =>
           ({
             outputC: 'outputC',
@@ -154,7 +150,6 @@ describe('createServerFn with middleware and validator', () => {
             readonly outputC: 'outputC'
           }
           signal: AbortSignal
-          response: 'data'
         }>()
 
         return 'some-data' as const
@@ -177,57 +172,11 @@ describe('createServerFn with middleware and validator', () => {
       }),
     ).returns.resolves.toEqualTypeOf<'some-data'>()
   })
-
-  test(`response: 'full'`, () => {
-    const fn = createServerFn({ method: 'GET', response: 'full' })
-      .middleware([middleware3])
-      .validator(
-        (input: { readonly inputC: 'inputC' }) =>
-          ({
-            outputC: 'outputC',
-          }) as const,
-      )
-      .handler((options) => {
-        expectTypeOf(options).toEqualTypeOf<{
-          method: 'GET'
-          context: undefined
-          data: {
-            readonly outputA: 'outputA'
-            readonly outputB: 'outputB'
-            readonly outputC: 'outputC'
-          }
-          signal: AbortSignal
-          response: 'full'
-        }>()
-
-        return 'some-data' as const
-      })
-
-    expectTypeOf(fn).parameter(0).toEqualTypeOf<{
-      data: {
-        readonly inputA: 'inputA'
-        readonly inputB: 'inputB'
-        readonly inputC: 'inputC'
-      }
-      headers?: HeadersInit
-      signal?: AbortSignal
-    }>()
-
-    expectTypeOf(() =>
-      fn({
-        data: { inputA: 'inputA', inputB: 'inputB', inputC: 'inputC' },
-      }),
-    ).returns.resolves.toEqualTypeOf<{
-      result: 'some-data'
-      context: undefined
-      error: unknown
-    }>()
-  })
 })
 
 test('createServerFn overrides properties', () => {
   const middleware1 = createMiddleware({ type: 'function' })
-    .validator(
+    .inputValidator(
       () =>
         ({
           input: 'a' as 'a' | 'b' | 'c',
@@ -252,7 +201,7 @@ test('createServerFn overrides properties', () => {
 
   const middleware2 = createMiddleware({ type: 'function' })
     .middleware([middleware1])
-    .validator(
+    .inputValidator(
       () =>
         ({
           input: 'b' as 'b' | 'c',
@@ -275,7 +224,7 @@ test('createServerFn overrides properties', () => {
 
   createServerFn()
     .middleware([middleware2])
-    .validator(
+    .inputValidator(
       () =>
         ({
           input: 'c',
@@ -291,28 +240,26 @@ test('createServerFn overrides properties', () => {
 
 test('createServerFn where validator is a primitive', () => {
   createServerFn({ method: 'GET' })
-    .validator(() => 'c' as const)
+    .inputValidator(() => 'c' as const)
     .handler((options) => {
       expectTypeOf(options).toEqualTypeOf<{
         method: 'GET'
         context: undefined
         data: 'c'
         signal: AbortSignal
-        response: 'data'
       }>()
     })
 })
 
 test('createServerFn where validator is optional if object is optional', () => {
   const fn = createServerFn({ method: 'GET' })
-    .validator((input: 'c' | undefined) => input)
+    .inputValidator((input: 'c' | undefined) => input)
     .handler((options) => {
       expectTypeOf(options).toEqualTypeOf<{
         method: 'GET'
         context: undefined
         data: 'c' | undefined
         signal: AbortSignal
-        response: 'data'
       }>()
     })
 
@@ -335,7 +282,6 @@ test('createServerFn where data is optional if there is no validator', () => {
       context: undefined
       data: undefined
       signal: AbortSignal
-      response: 'data'
     }>()
   })
 
@@ -371,13 +317,14 @@ test('createServerFn cannot return function', () => {
   expectTypeOf(createServerFn().handler<{ func: () => 'func' }>)
     .parameter(0)
     .returns.toEqualTypeOf<
+      | Response
       | { func: 'Function is not serializable' }
       | Promise<{ func: 'Function is not serializable' }>
     >()
 })
 
 test('createServerFn cannot validate function', () => {
-  const validator = createServerFn().validator<
+  const validator = createServerFn().inputValidator<
     (input: { func: () => 'string' }) => { output: 'string' }
   >
 
@@ -392,87 +339,49 @@ test('createServerFn cannot validate function', () => {
 })
 
 test('createServerFn can validate Date', () => {
-  const validator = createServerFn().validator<
+  const validator = createServerFn().inputValidator<
     (input: Date) => { output: 'string' }
   >
 
   expectTypeOf(validator)
     .parameter(0)
     .toEqualTypeOf<
-      ConstrainValidator<Register, (input: Date) => { output: 'string' }>
+      ConstrainValidator<Register, 'GET', (input: Date) => { output: 'string' }>
     >()
 })
 
 test('createServerFn can validate FormData', () => {
-  const validator = createServerFn().validator<
+  const validator = createServerFn({ method: 'POST' }).inputValidator<
+    (input: FormData) => { output: 'string' }
+  >
+
+  expectTypeOf(validator).parameter(0).parameter(0).toEqualTypeOf<FormData>()
+})
+
+test('createServerFn cannot validate FormData for GET', () => {
+  const validator = createServerFn({ method: 'GET' }).inputValidator<
     (input: FormData) => { output: 'string' }
   >
 
   expectTypeOf(validator)
     .parameter(0)
-    .toEqualTypeOf<
-      ConstrainValidator<Register, (input: FormData) => { output: 'string' }>
-    >()
+    .parameter(0)
+    .not.toEqualTypeOf<FormData>()
 })
 
 describe('response', () => {
-  describe('data', () => {
-    test(`response: 'data' is passed into handler without response being set`, () => {
-      createServerFn().handler((options) => {
-        expectTypeOf(options.response).toEqualTypeOf<'data'>()
-      })
-    })
-
-    test(`response: 'data' is passed into handler with explicit response: 'data'`, () => {
-      createServerFn({ response: 'data' }).handler((options) => {
-        expectTypeOf(options.response).toEqualTypeOf<'data'>()
-      })
-    })
-  })
-  describe('full', () => {
-    test(`response: 'full' is passed into handler`, () => {
-      createServerFn({ response: 'full' }).handler((options) => {
-        expectTypeOf(options.response).toEqualTypeOf<'full'>()
-      })
-    })
-  })
-
-  describe('raw', () => {
-    test(`response: 'raw' is passed into handler`, () => {
-      createServerFn({ response: 'raw' }).handler((options) => {
-        expectTypeOf(options.response).toEqualTypeOf<'raw'>()
-        return null
-      })
-    })
-  })
   test(`client receives Response when Response is returned`, () => {
-    const fn = createServerFn({ response: 'raw' }).handler(() => {
+    const fn = createServerFn().handler(() => {
       return new Response('Hello World')
     })
 
     expectTypeOf(fn()).toEqualTypeOf<Promise<Response>>()
   })
-
-  test(`client receives Response when ReadableStream is returned`, () => {
-    const fn = createServerFn({ response: 'raw' }).handler(() => {
-      return new ReadableStream()
-    })
-
-    expectTypeOf(fn()).toEqualTypeOf<Promise<Response>>()
-  })
-
-  test(`client receives Response when string is returned`, () => {
-    const fn = createServerFn({ response: 'raw' }).handler(() => {
-      return 'hello'
-    })
-
-    expectTypeOf(fn()).toEqualTypeOf<Promise<Response>>()
-  })
 })
 
 test('createServerFn can be used as a mutation function', () => {
   const serverFn = createServerFn()
-    .validator((data: number) => data)
+    .inputValidator((data: number) => data)
     .handler(() => 'foo')
 
   type MutationFunction<TData = unknown, TVariables = unknown> = (
@@ -489,7 +398,7 @@ test('createServerFn can be used as a mutation function', () => {
 
 test('createServerFn validator infers unknown for default input type', () => {
   const fn = createServerFn()
-    .validator((input) => {
+    .inputValidator((input) => {
       expectTypeOf(input).toEqualTypeOf<unknown>()
 
       if (typeof input === 'number') return 'success' as const
@@ -513,3 +422,118 @@ test('createServerFn validator infers unknown for default input type', () => {
 
   expectTypeOf(fn()).toEqualTypeOf<Promise<'failed' | 'success'>>()
 })
+
+test('incrementally building createServerFn with multiple middleware calls', () => {
+  const middleware1 = createMiddleware({ type: 'function' }).server(
+    ({ next }) => {
+      return next({ context: { a: 'a' } as const })
+    },
+  )
+
+  const middleware2 = createMiddleware({ type: 'function' }).server(
+    ({ next }) => {
+      return next({ context: { b: 'b' } as const })
+    },
+  )
+
+  const middleware3 = createMiddleware({ type: 'function' }).server(
+    ({ next }) => {
+      return next({ context: { c: 'c' } as const })
+    },
+  )
+
+  const builderWithMw1 = createServerFn({ method: 'GET' }).middleware([
+    middleware1,
+  ])
+
+  expectTypeOf(builderWithMw1).toHaveProperty('handler')
+  expectTypeOf(builderWithMw1).toHaveProperty('inputValidator')
+  expectTypeOf(builderWithMw1).toHaveProperty('middleware')
+
+  builderWithMw1.handler((options) => {
+    expectTypeOf(options).toEqualTypeOf<{
+      method: 'GET'
+      context: {
+        readonly a: 'a'
+      }
+      data: undefined
+      signal: AbortSignal
+    }>()
+  })
+
+  // overrides method
+  const builderWithMw2 = builderWithMw1({ method: 'POST' }).middleware([
+    middleware2,
+  ])
+
+  expectTypeOf(builderWithMw2).toHaveProperty('handler')
+  expectTypeOf(builderWithMw2).toHaveProperty('inputValidator')
+  expectTypeOf(builderWithMw2).toHaveProperty('middleware')
+
+  builderWithMw2.handler((options) => {
+    expectTypeOf(options).toEqualTypeOf<{
+      method: 'POST'
+      context: {
+        readonly a: 'a'
+        readonly b: 'b'
+      }
+      data: undefined
+      signal: AbortSignal
+    }>()
+  })
+
+  // overrides method again
+  const builderWithMw3 = builderWithMw2({ method: 'GET' }).middleware([
+    middleware3,
+  ])
+
+  expectTypeOf(builderWithMw3).toHaveProperty('handler')
+  expectTypeOf(builderWithMw3).toHaveProperty('inputValidator')
+  expectTypeOf(builderWithMw3).toHaveProperty('middleware')
+
+  builderWithMw3.handler((options) => {
+    expectTypeOf(options).toEqualTypeOf<{
+      method: 'GET'
+      context: {
+        readonly a: 'a'
+        readonly b: 'b'
+        readonly c: 'c'
+      }
+      data: undefined
+      signal: AbortSignal
+    }>()
+  })
+})
+
+test('compose middlewares and server function factories', () => {
+  const middleware1 = createMiddleware({ type: 'function' }).server(
+    ({ next }) => {
+      return next({ context: { a: 'a' } as const })
+    },
+  )
+
+  const middleware2 = createMiddleware({ type: 'function' }).server(
+    ({ next }) => {
+      return next({ context: { b: 'b' } as const })
+    },
+  )
+
+  const builderWithMw1 = createServerFn().middleware([middleware1])
+
+  const composedBuilder = createServerFn({ method: 'GET' }).middleware([
+    middleware2,
+    builderWithMw1,
+  ])
+
+  composedBuilder.handler((options) => {
+    expectTypeOf(options).toEqualTypeOf<{
+      method: 'GET'
+      context: {
+        readonly a: 'a'
+        readonly b: 'b'
+      }
+      data: undefined
+      signal: AbortSignal
+    }>()
+  })
+})

package/src/tests/createServerMiddleware.test-d.ts

@@ -9,15 +9,15 @@ test('createServeMiddleware removes middleware after middleware,', () => {
 
   expectTypeOf(middleware).toHaveProperty('middleware')
   expectTypeOf(middleware).toHaveProperty('server')
-  expectTypeOf(middleware).toHaveProperty('validator')
+  expectTypeOf(middleware).toHaveProperty('inputValidator')
 
   const middlewareAfterMiddleware = middleware.middleware([])
 
-  expectTypeOf(middlewareAfterMiddleware).toHaveProperty('validator')
+  expectTypeOf(middlewareAfterMiddleware).toHaveProperty('inputValidator')
   expectTypeOf(middlewareAfterMiddleware).toHaveProperty('server')
   expectTypeOf(middlewareAfterMiddleware).not.toHaveProperty('middleware')
 
-  const middlewareAfterInput = middleware.validator(() => {})
+  const middlewareAfterInput = middleware.inputValidator(() => {})
 
   expectTypeOf(middlewareAfterInput).toHaveProperty('server')
   expectTypeOf(middlewareAfterInput).not.toHaveProperty('middleware')
@@ -252,7 +252,7 @@ test('createMiddleware merges client context and sends to the server', () => {
 
 test('createMiddleware merges input', () => {
   const middleware1 = createMiddleware({ type: 'function' })
-    .validator(() => {
+    .inputValidator(() => {
       return {
         a: 'a',
       } as const
@@ -264,7 +264,7 @@ test('createMiddleware merges input', () => {
 
   const middleware2 = createMiddleware({ type: 'function' })
     .middleware([middleware1])
-    .validator(() => {
+    .inputValidator(() => {
       return {
         b: 'b',
       } as const
@@ -276,7 +276,7 @@ test('createMiddleware merges input', () => {
 
   createMiddleware({ type: 'function' })
     .middleware([middleware2])
-    .validator(() => ({ c: 'c' }) as const)
+    .inputValidator(() => ({ c: 'c' }) as const)
     .server(({ next, data }) => {
       expectTypeOf(data).toEqualTypeOf<{
         readonly a: 'a'
@@ -579,7 +579,7 @@ test('createMiddleware sendContext cannot send a function', () => {
 })
 
 test('createMiddleware cannot validate function', () => {
-  const validator = createMiddleware({ type: 'function' }).validator<
+  const validator = createMiddleware({ type: 'function' }).inputValidator<
     (input: { func: () => 'string' }) => { output: 'string' }
   >
 
@@ -588,37 +588,42 @@ test('createMiddleware cannot validate function', () => {
     .toEqualTypeOf<
       ConstrainValidator<
         Register,
+        'GET',
         (input: { func: () => 'string' }) => { output: 'string' }
       >
     >()
 })
 
 test('createMiddleware can validate Date', () => {
-  const validator = createMiddleware({ type: 'function' }).validator<
+  const validator = createMiddleware({ type: 'function' }).inputValidator<
     (input: Date) => { output: 'string' }
   >
 
   expectTypeOf(validator)
     .parameter(0)
     .toEqualTypeOf<
-      ConstrainValidator<Register, (input: Date) => { output: 'string' }>
+      ConstrainValidator<Register, 'GET', (input: Date) => { output: 'string' }>
     >()
 })
 
 test('createMiddleware can validate FormData', () => {
-  const validator = createMiddleware({ type: 'function' }).validator<
+  const validator = createMiddleware({ type: 'function' }).inputValidator<
     (input: FormData) => { output: 'string' }
   >
 
   expectTypeOf(validator)
     .parameter(0)
     .toEqualTypeOf<
-      ConstrainValidator<Register, (input: FormData) => { output: 'string' }>
+      ConstrainValidator<
+        Register,
+        'GET',
+        (input: FormData) => { output: 'string' }
+      >
     >()
 })
 
 test('createMiddleware merging from parent with undefined validator', () => {
-  const middleware1 = createMiddleware({ type: 'function' }).validator(
+  const middleware1 = createMiddleware({ type: 'function' }).inputValidator(
     (input: { test: string }) => input.test,
   )
 
@@ -633,7 +638,7 @@ test('createMiddleware merging from parent with undefined validator', () => {
 
 test('createMiddleware validator infers unknown for default input type', () => {
   createMiddleware({ type: 'function' })
-    .validator((input) => {
+    .inputValidator((input) => {
       expectTypeOf(input).toEqualTypeOf<unknown>()
 
       if (typeof input === 'number') return 'success' as const
@@ -651,7 +656,7 @@ test('createMiddleware with type request, no middleware or context', () => {
   createMiddleware({ type: 'request' }).server(async (options) => {
     expectTypeOf(options).toEqualTypeOf<{
       request: Request
-      next: RequestServerNextFn<undefined>
+      next: RequestServerNextFn<{}, undefined>
       pathname: string
       context: undefined
     }>()
@@ -673,7 +678,7 @@ test('createMiddleware with type request, no middleware with context', () => {
   createMiddleware({ type: 'request' }).server(async (options) => {
     expectTypeOf(options).toEqualTypeOf<{
       request: Request
-      next: RequestServerNextFn<undefined>
+      next: RequestServerNextFn<{}, undefined>
       pathname: string
       context: undefined
     }>()
@@ -696,7 +701,7 @@ test('createMiddleware with type request, middleware and context', () => {
     async (options) => {
       expectTypeOf(options).toEqualTypeOf<{
         request: Request
-        next: RequestServerNextFn<undefined>
+        next: RequestServerNextFn<{}, undefined>
         pathname: string
         context: undefined
       }>()
@@ -719,7 +724,7 @@ test('createMiddleware with type request, middleware and context', () => {
     .server(async (options) => {
       expectTypeOf(options).toEqualTypeOf<{
         request: Request
-        next: RequestServerNextFn<undefined>
+        next: RequestServerNextFn<{}, undefined>
         pathname: string
         context: { a: string }
       }>()

package/dist/esm/createClientRpc.d.ts

@@ -1,6 +0,0 @@
-import { TSS_SERVER_FUNCTION } from './constants.js';
-export declare const createClientRpc: (functionId: string) => ((...args: Array<any>) => Promise<any>) & {
-    url: string;
-    functionId: string;
-    [TSS_SERVER_FUNCTION]: boolean;
-};

package/dist/esm/createClientRpc.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"createClientRpc.js","sources":["../../src/createClientRpc.ts"],"sourcesContent":["import { TSS_SERVER_FUNCTION } from './constants'\nimport { serverFnFetcher } from './serverFnFetcher'\n\nlet baseUrl: string\nfunction sanitizeBase(base: string) {\n  return base.replace(/^\\/|\\/$/g, '')\n}\n\nexport const createClientRpc = (functionId: string) => {\n  if (!baseUrl) {\n    const sanitizedAppBase = sanitizeBase(process.env.TSS_APP_BASE || '/')\n    const sanitizedServerBase = sanitizeBase(process.env.TSS_SERVER_FN_BASE!)\n    baseUrl = `${sanitizedAppBase ? `/${sanitizedAppBase}` : ''}/${sanitizedServerBase}/`\n  }\n  const url = baseUrl + functionId\n\n  const clientFn = (...args: Array<any>) => {\n    return serverFnFetcher(url, args, fetch)\n  }\n\n  return Object.assign(clientFn, {\n    url,\n    functionId,\n    [TSS_SERVER_FUNCTION]: true,\n  })\n}\n"],"names":[],"mappings":";;AAGA,IAAI;AACJ,SAAS,aAAa,MAAc;AAClC,SAAO,KAAK,QAAQ,YAAY,EAAE;AACpC;AAEO,MAAM,kBAAkB,CAAC,eAAuB;AACrD,MAAI,CAAC,SAAS;AACZ,UAAM,mBAAmB,aAAa,QAAQ,IAAI,gBAAgB,GAAG;AACrE,UAAM,sBAAsB,aAAa,QAAQ,IAAI,kBAAmB;AACxE,cAAU,GAAG,mBAAmB,IAAI,gBAAgB,KAAK,EAAE,IAAI,mBAAmB;AAAA,EACpF;AACA,QAAM,MAAM,UAAU;AAEtB,QAAM,WAAW,IAAI,SAAqB;AACxC,WAAO,gBAAgB,KAAK,MAAM,KAAK;AAAA,EACzC;AAEA,SAAO,OAAO,OAAO,UAAU;AAAA,IAC7B;AAAA,IACA;AAAA,IACA,CAAC,mBAAmB,GAAG;AAAA,EAAA,CACxB;AACH;"}

package/dist/esm/registerGlobalMiddleware.d.ts

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

package/dist/esm/registerGlobalMiddleware.js

@@ -1,9 +0,0 @@
-const globalMiddleware = [];
-function registerGlobalMiddleware(options) {
-  globalMiddleware.push(...options.middleware);
-}
-export {
-  globalMiddleware,
-  registerGlobalMiddleware
-};
-//# sourceMappingURL=registerGlobalMiddleware.js.map

package/dist/esm/registerGlobalMiddleware.js.map

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

package/dist/esm/serializer/ServerFunctionSerializationAdapter.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ServerFunctionSerializationAdapter.js","sources":["../../../src/serializer/ServerFunctionSerializationAdapter.ts"],"sourcesContent":["import { createSerializationAdapter } from '@tanstack/router-core'\nimport { createClientRpc } from '../createClientRpc'\nimport { TSS_SERVER_FUNCTION } from '../constants'\n\nexport const ServerFunctionSerializationAdapter = createSerializationAdapter({\n  key: '$TSS/serverfn',\n  test: (v): v is { functionId: string } => {\n    if (typeof v !== 'object' || v === null) return false\n\n    if (!(TSS_SERVER_FUNCTION in v)) return false\n\n    return !!v[TSS_SERVER_FUNCTION]\n  },\n  toSerializable: ({ functionId }) => ({ functionId }),\n  fromSerializable: ({ functionId }) => createClientRpc(functionId),\n})\n"],"names":[],"mappings":";;;AAIO,MAAM,qCAAqC,2BAA2B;AAAA,EAC3E,KAAK;AAAA,EACL,MAAM,CAAC,MAAmC;AACxC,QAAI,OAAO,MAAM,YAAY,MAAM,KAAM,QAAO;AAEhD,QAAI,EAAE,uBAAuB,GAAI,QAAO;AAExC,WAAO,CAAC,CAAC,EAAE,mBAAmB;AAAA,EAChC;AAAA,EACA,gBAAgB,CAAC,EAAE,kBAAkB,EAAE,WAAA;AAAA,EACvC,kBAAkB,CAAC,EAAE,WAAA,MAAiB,gBAAgB,UAAU;AAClE,CAAC;"}

package/dist/esm/serializer/getClientSerovalPlugins.d.ts

@@ -1,3 +0,0 @@
-export declare function getClientSerovalPlugins(): (import('seroval').Plugin<Error, any> | import('seroval').Plugin<ReadableStream<any>, any> | import('seroval').Plugin<FormData, any> | import('seroval').Plugin<any, import('seroval').SerovalNode> | import('seroval').Plugin<{
-    functionId: string;
-}, import('seroval').SerovalNode>)[];

package/dist/esm/serializer/getClientSerovalPlugins.js

@@ -1,13 +0,0 @@
-import { makeSerovalPlugin } from "@tanstack/router-core";
-import { getDefaultSerovalPlugins } from "./getDefaultSerovalPlugins.js";
-import { ServerFunctionSerializationAdapter } from "./ServerFunctionSerializationAdapter.js";
-function getClientSerovalPlugins() {
-  return [
-    ...getDefaultSerovalPlugins(),
-    makeSerovalPlugin(ServerFunctionSerializationAdapter)
-  ];
-}
-export {
-  getClientSerovalPlugins
-};
-//# sourceMappingURL=getClientSerovalPlugins.js.map

package/dist/esm/serializer/getClientSerovalPlugins.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"getClientSerovalPlugins.js","sources":["../../../src/serializer/getClientSerovalPlugins.ts"],"sourcesContent":["import { makeSerovalPlugin } from '@tanstack/router-core'\nimport { getDefaultSerovalPlugins } from './getDefaultSerovalPlugins'\nimport { ServerFunctionSerializationAdapter } from './ServerFunctionSerializationAdapter'\n\nexport function getClientSerovalPlugins() {\n  return [\n    ...getDefaultSerovalPlugins(),\n    makeSerovalPlugin(ServerFunctionSerializationAdapter),\n  ]\n}\n"],"names":[],"mappings":";;;AAIO,SAAS,0BAA0B;AACxC,SAAO;AAAA,IACL,GAAG,yBAAA;AAAA,IACH,kBAAkB,kCAAkC;AAAA,EAAA;AAExD;"}

package/dist/esm/serializer/getDefaultSerovalPlugins.d.ts

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