@tanstack/start-client-core 1.114.4 → 1.114.5

package/src/index.tsx

@@ -11,3 +11,76 @@ export {
   type ResolvePromiseState,
   hydrate,
 } from './ssr-client'
+export {
+  createIsomorphicFn,
+  type IsomorphicFn,
+  type ServerOnlyFn,
+  type ClientOnlyFn,
+  type IsomorphicFnBase,
+} from './createIsomorphicFn'
+export { serverOnly, clientOnly } from './envOnly'
+export { type JsonResponse } from './createServerFn'
+export { json } from './json'
+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'
+export {
+  registerGlobalMiddleware,
+  globalMiddleware,
+} from './registerGlobalMiddleware'
+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'
+export {
+  applyMiddleware,
+  execValidator,
+  serverFnBaseToMiddleware,
+  extractFormDataContext,
+  flattenMiddlewares,
+  serverFnStaticCache,
+} from './createServerFn'

package/src/json.ts

@@ -0,0 +1,15 @@
+import { mergeHeaders } from './headers'
+import type { JsonResponse } from './createServerFn'
+
+export function json<TData>(
+  payload: TData,
+  init?: ResponseInit,
+): JsonResponse<TData> {
+  return new Response(JSON.stringify(payload), {
+    ...init,
+    headers: mergeHeaders(
+      { 'content-type': 'application/json' },
+      init?.headers,
+    ),
+  })
+}

package/src/registerGlobalMiddleware.ts

@@ -0,0 +1,9 @@
+import type { AnyMiddleware } from './createMiddleware'
+
+export const globalMiddleware: Array<AnyMiddleware> = []
+
+export function registerGlobalMiddleware(options: {
+  middleware: Array<AnyMiddleware>
+}) {
+  globalMiddleware.push(...options.middleware)
+}

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

@@ -0,0 +1,72 @@
+import { expectTypeOf, test } from 'vitest'
+import { createIsomorphicFn } from '../createIsomorphicFn'
+
+test('createIsomorphicFn with no implementations', () => {
+  const fn = createIsomorphicFn()
+
+  expectTypeOf(fn).toBeCallableWith()
+  expectTypeOf(fn).returns.toBeUndefined()
+
+  expectTypeOf(fn).toHaveProperty('server')
+  expectTypeOf(fn).toHaveProperty('client')
+})
+
+test('createIsomorphicFn with server implementation', () => {
+  const fn = createIsomorphicFn().server(() => 'data')
+
+  expectTypeOf(fn).toBeCallableWith()
+  expectTypeOf(fn).returns.toEqualTypeOf<string | undefined>()
+
+  expectTypeOf(fn).toHaveProperty('client')
+  expectTypeOf(fn).not.toHaveProperty('server')
+})
+
+test('createIsomorphicFn with client implementation', () => {
+  const fn = createIsomorphicFn().client(() => 'data')
+
+  expectTypeOf(fn).toBeCallableWith()
+  expectTypeOf(fn).returns.toEqualTypeOf<string | undefined>()
+
+  expectTypeOf(fn).toHaveProperty('server')
+  expectTypeOf(fn).not.toHaveProperty('client')
+})
+
+test('createIsomorphicFn with server and client implementation', () => {
+  const fn = createIsomorphicFn()
+    .server(() => 'data')
+    .client(() => 'data')
+
+  expectTypeOf(fn).toBeCallableWith()
+  expectTypeOf(fn).returns.toEqualTypeOf<string>()
+
+  expectTypeOf(fn).not.toHaveProperty('server')
+  expectTypeOf(fn).not.toHaveProperty('client')
+})
+
+test('createIsomorphicFn with varying returns', () => {
+  const fn = createIsomorphicFn()
+    .server(() => 'data')
+    .client(() => 1)
+  expectTypeOf(fn).toBeCallableWith()
+  expectTypeOf(fn).returns.toEqualTypeOf<string | number>()
+})
+
+test('createIsomorphicFn with arguments', () => {
+  const fn = createIsomorphicFn()
+    .server((a: number, b: string) => 'data')
+    .client((...args) => {
+      expectTypeOf(args).toEqualTypeOf<[number, string]>()
+      return 1
+    })
+  expectTypeOf(fn).toBeCallableWith(1, 'a')
+  expectTypeOf(fn).returns.toEqualTypeOf<string | number>()
+
+  const fn2 = createIsomorphicFn()
+    .client((a: number, b: string) => 'data')
+    .server((...args) => {
+      expectTypeOf(args).toEqualTypeOf<[number, string]>()
+      return 1
+    })
+  expectTypeOf(fn2).toBeCallableWith(1, 'a')
+  expectTypeOf(fn2).returns.toEqualTypeOf<string | number>()
+})