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

package/src/createStart.ts

@@ -0,0 +1,122 @@
+import { createMiddleware } from './createMiddleware'
+import type {
+  AnyFunctionMiddleware,
+  AnyRequestMiddleware,
+  CreateMiddlewareFn,
+} from './createMiddleware'
+import type {
+  AnySerializationAdapter,
+  Register,
+  SSROption,
+} from '@tanstack/router-core'
+
+export interface StartInstanceOptions<
+  in out TSerializationAdapters,
+  in out TDefaultSsr,
+  in out TRequestMiddlewares,
+  in out TFunctionMiddlewares,
+> {
+  '~types': StartInstanceTypes<
+    TSerializationAdapters,
+    TDefaultSsr,
+    TRequestMiddlewares,
+    TFunctionMiddlewares
+  >
+  serializationAdapters?: TSerializationAdapters
+  defaultSsr?: TDefaultSsr
+  requestMiddleware?: TRequestMiddlewares
+  functionMiddleware?: TFunctionMiddlewares
+}
+
+export interface StartInstance<
+  in out TSerializationAdapters,
+  in out TDefaultSsr,
+  in out TRequestMiddlewares,
+  in out TFunctionMiddlewares,
+> {
+  getOptions: () =>
+    | Promise<
+        StartInstanceOptions<
+          TSerializationAdapters,
+          TDefaultSsr,
+          TRequestMiddlewares,
+          TFunctionMiddlewares
+        >
+      >
+    | StartInstanceOptions<
+        TSerializationAdapters,
+        TDefaultSsr,
+        TRequestMiddlewares,
+        TFunctionMiddlewares
+      >
+  createMiddleware: CreateMiddlewareFn<Register>
+}
+
+export interface StartInstanceTypes<
+  in out TSerializationAdapters,
+  in out TDefaultSsr,
+  in out TRequestMiddlewares,
+  in out TFunctionMiddlewares,
+> {
+  serializationAdapters: TSerializationAdapters
+  defaultSsr: TDefaultSsr
+  requestMiddleware: TRequestMiddlewares
+  functionMiddleware: TFunctionMiddlewares
+}
+
+export const createStart = <
+  const TSerializationAdapters extends
+    ReadonlyArray<AnySerializationAdapter> = [],
+  TDefaultSsr extends SSROption = SSROption,
+  const TRequestMiddlewares extends ReadonlyArray<AnyRequestMiddleware> = [],
+  const TFunctionMiddlewares extends ReadonlyArray<AnyFunctionMiddleware> = [],
+>(
+  getOptions: () =>
+    | Promise<
+        Omit<
+          StartInstanceOptions<
+            TSerializationAdapters,
+            TDefaultSsr,
+            TRequestMiddlewares,
+            TFunctionMiddlewares
+          >,
+          '~types'
+        >
+      >
+    | Omit<
+        StartInstanceOptions<
+          TSerializationAdapters,
+          TDefaultSsr,
+          TRequestMiddlewares,
+          TFunctionMiddlewares
+        >,
+        '~types'
+      >,
+): StartInstance<
+  TSerializationAdapters,
+  TDefaultSsr,
+  TRequestMiddlewares,
+  TFunctionMiddlewares
+> => {
+  return {
+    getOptions: async () => {
+      const options = await getOptions()
+      return options
+    },
+    createMiddleware: createMiddleware as any,
+  } as StartInstance<
+    TSerializationAdapters,
+    TDefaultSsr,
+    TRequestMiddlewares,
+    TFunctionMiddlewares
+  >
+}
+
+export type AnyStartInstance = StartInstance<any, any, any, any>
+export type AnyStartInstanceOptions = StartInstanceOptions<any, any, any, any>
+
+declare module '@tanstack/router-core' {
+  interface Register {
+    ssr: true
+  }
+}

package/src/fake-start-entry.ts

@@ -0,0 +1,4 @@
+export default {
+  startInstance: () => {},
+}
+export const getRouter = () => {}

package/src/getDefaultSerovalPlugins.ts

@@ -0,0 +1,17 @@
+import {
+  makeSerovalPlugin,
+  defaultSerovalPlugins as routerDefaultSerovalPlugins,
+} from '@tanstack/router-core'
+import { getStartOptions } from './getStartOptions'
+import type { AnySerializationAdapter } from '@tanstack/router-core'
+
+export function getDefaultSerovalPlugins() {
+  const start = getStartOptions()
+  const adapters = start.serializationAdapters as
+    | Array<AnySerializationAdapter>
+    | undefined
+  return [
+    ...(adapters?.map(makeSerovalPlugin) ?? []),
+    ...routerDefaultSerovalPlugins,
+  ]
+}

package/src/getGlobalStartContext.ts

@@ -0,0 +1,18 @@
+import { getStartContext } from '@tanstack/start-storage-context'
+import { createIsomorphicFn } from './createIsomorphicFn'
+import type { AssignAllServerRequestContext } from './createMiddleware'
+import type { Expand, Register } from '@tanstack/router-core'
+
+export const getGlobalStartContext: () =>
+  | Expand<AssignAllServerRequestContext<Register, []>>
+  | undefined = createIsomorphicFn()
+  .client(() => undefined)
+  .server(() => {
+    const context = getStartContext().contextAfterGlobalMiddlewares
+    if (!context) {
+      throw new Error(
+        `Global context not set yet, you are calling getGlobalStartContext() before the global middlewares are applied.`,
+      )
+    }
+    return context
+  })

package/src/getRouterInstance.ts

@@ -1,7 +1,8 @@
 import { getStartContext } from '@tanstack/start-storage-context'
 import { createIsomorphicFn } from './createIsomorphicFn'
+import type { Awaitable, RegisteredRouter } from '@tanstack/router-core'
 
-// TODO should this be a public API
-export const getRouterInstance = createIsomorphicFn()
-  .client(() => window.__TSR_ROUTER__!)
-  .server(() => getStartContext().router)
+export const getRouterInstance: () => Awaitable<RegisteredRouter> =
+  createIsomorphicFn()
+    .client(() => window.__TSR_ROUTER__!)
+    .server(() => getStartContext().getRouter())

package/src/getServerContextAfterGlobalMiddlewares.ts

@@ -0,0 +1,7 @@
+import { getStartContext } from '@tanstack/start-storage-context'
+import { createServerOnlyFn } from './envOnly'
+
+export const getServerContextAfterGlobalMiddlewares = createServerOnlyFn(() => {
+  const start = getStartContext()
+  return start.contextAfterGlobalMiddlewares
+})

package/src/getStartOptions.ts

@@ -0,0 +1,6 @@
+import { getStartContext } from '@tanstack/start-storage-context'
+import { createIsomorphicFn } from './createIsomorphicFn'
+
+export const getStartOptions = createIsomorphicFn()
+  .client(() => window.__TSS_START_OPTIONS__!)
+  .server(() => getStartContext().startOptions)

package/src/global.ts

@@ -0,0 +1,9 @@
+import type { AnyStartInstanceOptions } from './createStart'
+
+declare global {
+  interface Window {
+    __TSS_START_OPTIONS__?: AnyStartInstanceOptions
+  }
+}
+
+export {}

package/src/index.tsx

@@ -33,7 +33,6 @@ export {
   type FunctionClientResultWithContext,
   type AssignAllClientContextBeforeNext,
   type AssignAllMiddleware,
-  type AssignAllServerContext,
   type FunctionMiddlewareAfterValidator,
   type FunctionMiddlewareClientFn,
   type FunctionMiddlewareServerFnResult,
@@ -43,10 +42,6 @@ export {
   type FunctionServerResultWithContext,
   type AnyRequestMiddleware,
 } from './createMiddleware'
-export {
-  registerGlobalMiddleware,
-  globalMiddleware,
-} from './registerGlobalMiddleware'
 export type {
   CompiledFetcherFnOptions,
   CompiledFetcherFn,
@@ -56,7 +51,6 @@ export type {
   FetcherBaseOptions,
   ServerFn,
   ServerFnCtx,
-  ServerFnResponseType,
   MiddlewareFn,
   ServerFnMiddlewareOptions,
   ServerFnMiddlewareResult,
@@ -70,17 +64,24 @@ export type {
 export {
   applyMiddleware,
   execValidator,
-  serverFnBaseToMiddleware,
   flattenMiddlewares,
   executeMiddleware,
 } from './createServerFn'
 
-export { createClientRpc } from './createClientRpc'
-
-export { getDefaultSerovalPlugins } from './serializer/getDefaultSerovalPlugins'
-
 export {
   TSS_FORMDATA_CONTEXT,
   TSS_SERVER_FUNCTION,
   X_TSS_SERIALIZED,
 } from './constants'
+
+export type * from './serverRoute'
+
+export type * from './startEntry'
+
+export { createStart } from './createStart'
+export type { AnyStartInstance, AnyStartInstanceOptions } from './createStart'
+export type { Register } from '@tanstack/router-core'
+
+export { getRouterInstance } from './getRouterInstance'
+export { getDefaultSerovalPlugins } from './getDefaultSerovalPlugins'
+export { getGlobalStartContext } from './getGlobalStartContext'