@benjavicente/start-client-core 1.167.9

package/src/createStart.ts

@@ -0,0 +1,166 @@
+import { createMiddleware } from './createMiddleware'
+import type { TSS_SERVER_FUNCTION } from './constants'
+import type {
+  AnyFunctionMiddleware,
+  AnyRequestMiddleware,
+  CreateMiddlewareFn,
+} from './createMiddleware'
+import type { CustomFetch } from './createServerFn'
+import type {
+  AnySerializationAdapter,
+  Register,
+  SSROption,
+} from '@benjavicente/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
+  /**
+   * Configuration options for server functions.
+   */
+  serverFns?: {
+    /**
+     * A custom fetch implementation to use for all server function calls.
+     * This can be overridden by middleware or at the call site.
+     *
+     * Precedence (highest to lowest):
+     * 1. Call site: `serverFn({ fetch: customFetch })`
+     * 2. Later middleware: Last middleware in chain that provides `fetch`
+     * 3. Earlier middleware: First middleware in chain that provides `fetch`
+     * 4. createStart: `createStart({ serverFns: { fetch: customFetch } })`
+     * 5. Default: Global `fetch` function
+     *
+     * @note Only applies on the client side. During SSR, server functions are called directly.
+     */
+    fetch?: CustomFetch
+  }
+}
+
+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
+}
+
+function dedupeSerializationAdapters(
+  deduped: Set<AnySerializationAdapter>,
+  serializationAdapters: Array<AnySerializationAdapter>,
+): void {
+  for (let i = 0, len = serializationAdapters.length; i < len; i++) {
+    const current = serializationAdapters[i]!
+    if (!deduped.has(current)) {
+      deduped.add(current)
+      if (current.extends) {
+        dedupeSerializationAdapters(deduped, current.extends)
+      }
+    }
+  }
+}
+
+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()
+      if (options.serializationAdapters) {
+        const deduped = new Set<AnySerializationAdapter>()
+        dedupeSerializationAdapters(
+          deduped,
+          options.serializationAdapters as unknown as Array<AnySerializationAdapter>,
+        )
+        options.serializationAdapters = Array.from(deduped) as any
+      }
+      return options
+    },
+    createMiddleware: createMiddleware,
+  } as StartInstance<
+    TSerializationAdapters,
+    TDefaultSsr,
+    TRequestMiddlewares,
+    TFunctionMiddlewares
+  >
+}
+
+export type AnyStartInstance = StartInstance<any, any, any, any>
+export type AnyStartInstanceOptions = StartInstanceOptions<any, any, any, any>
+
+declare module '@benjavicente/router-core' {
+  interface SerializableExtensions {
+    serverFn: { [TSS_SERVER_FUNCTION]: true }
+  }
+}

package/src/fake-start-entry.ts

@@ -0,0 +1,2 @@
+export const startInstance = undefined
+export const getRouter = () => {}

package/src/getDefaultSerovalPlugins.ts

@@ -0,0 +1,17 @@
+import {
+  makeSerovalPlugin,
+  defaultSerovalPlugins as routerDefaultSerovalPlugins,
+} from '@benjavicente/router-core'
+import { getStartOptions } from './getStartOptions'
+import type { AnySerializationAdapter } from '@benjavicente/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 '@benjavicente/start-storage-context'
+import { createIsomorphicFn } from '@benjavicente/start-fn-stubs'
+import type { AssignAllServerRequestContext } from './createMiddleware'
+import type { Expand, Register } from '@benjavicente/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

@@ -0,0 +1,8 @@
+import { getStartContext } from '@benjavicente/start-storage-context'
+import { createIsomorphicFn } from '@benjavicente/start-fn-stubs'
+import type { Awaitable, RegisteredRouter } from '@benjavicente/router-core'
+
+export const getRouterInstance: () => Awaitable<RegisteredRouter> =
+  createIsomorphicFn()
+    .client(() => window.__TSR_ROUTER__!)
+    .server(() => getStartContext().getRouter())

package/src/getStartContextServerOnly.ts

@@ -0,0 +1,4 @@
+import { getStartContext } from '@benjavicente/start-storage-context'
+import { createServerOnlyFn } from '@benjavicente/start-fn-stubs'
+
+export const getStartContextServerOnly = createServerOnlyFn(getStartContext)

package/src/getStartOptions.ts

@@ -0,0 +1,8 @@
+import { getStartContext } from '@benjavicente/start-storage-context'
+import { createIsomorphicFn } from '@benjavicente/start-fn-stubs'
+import type { AnyStartInstanceOptions } from './createStart'
+
+export const getStartOptions: () => AnyStartInstanceOptions | undefined =
+  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

@@ -0,0 +1,119 @@
+export type { JsonResponse } from '@benjavicente/router-core/ssr/client'
+
+export { hydrate, json, mergeHeaders } from '@benjavicente/router-core/ssr/client'
+
+export { RawStream } from '@benjavicente/router-core'
+export type { OnRawStreamCallback } from '@benjavicente/router-core'
+
+export {
+  createIsomorphicFn,
+  createServerOnlyFn,
+  createClientOnlyFn,
+  type IsomorphicFn,
+  type ServerOnlyFn,
+  type ClientOnlyFn,
+  type IsomorphicFnBase,
+} from '@benjavicente/start-fn-stubs'
+export { createServerFn } from './createServerFn'
+export {
+  createMiddleware,
+  type IntersectAllValidatorInputs,
+  type IntersectAllValidatorOutputs,
+  type FunctionMiddlewareServerFn,
+  type AnyFunctionMiddleware,
+  type FunctionMiddlewareOptions,
+  type FunctionMiddlewareWithTypes,
+  type FunctionMiddlewareValidator,
+  type FunctionMiddlewareServer,
+  type FunctionMiddlewareAfterClient,
+  type FunctionMiddlewareAfterServer,
+  type FunctionMiddleware,
+  type FunctionMiddlewareAfterMiddleware,
+  type FunctionMiddlewareClientFnOptions,
+  type FunctionMiddlewareClientFnResult,
+  type FunctionMiddlewareClientNextFn,
+  type FunctionClientResultWithContext,
+  type AssignAllClientContextBeforeNext,
+  type AssignAllMiddleware,
+  type FunctionMiddlewareAfterValidator,
+  type FunctionMiddlewareClientFn,
+  type FunctionMiddlewareServerFnResult,
+  type FunctionMiddlewareClient,
+  type FunctionMiddlewareServerFnOptions,
+  type FunctionMiddlewareServerNextFn,
+  type FunctionServerResultWithContext,
+  type AnyRequestMiddleware,
+  type RequestMiddlewareOptions,
+  type RequestMiddlewareWithTypes,
+  type RequestMiddlewareServer,
+  type RequestMiddlewareAfterServer,
+  type RequestMiddleware,
+  type RequestMiddlewareAfterMiddleware,
+  type RequestServerFn,
+  type RequestMiddlewareServerFnResult,
+  type RequestServerOptions,
+  type RequestServerNextFn,
+  type RequestServerNextFnOptions,
+  type RequestServerResult,
+} from './createMiddleware'
+export type {
+  CompiledFetcherFnOptions,
+  CompiledFetcherFn,
+  CustomFetch,
+  Fetcher,
+  RscStream,
+  FetcherBaseOptions,
+  ServerFn,
+  ServerFnCtx,
+  MiddlewareFn,
+  ServerFnMiddlewareOptions,
+  ServerFnMiddlewareResult,
+  ServerFnBuilder,
+  ServerFnBaseOptions,
+  NextFn,
+  Method,
+  OptionalFetcher,
+  RequiredFetcher,
+} from './createServerFn'
+export {
+  execValidator,
+  flattenMiddlewares,
+  executeMiddleware,
+} from './createServerFn'
+
+export {
+  TSS_FORMDATA_CONTEXT,
+  TSS_SERVER_FUNCTION,
+  TSS_CONTENT_TYPE_FRAMED,
+  TSS_CONTENT_TYPE_FRAMED_VERSIONED,
+  TSS_FRAMED_PROTOCOL_VERSION,
+  FrameType,
+  FRAME_HEADER_SIZE,
+  X_TSS_SERIALIZED,
+  X_TSS_RAW_RESPONSE,
+  X_TSS_CONTEXT,
+  validateFramedProtocolVersion,
+} from './constants'
+export type {
+  FrameType as FrameTypeValue,
+  ClientFnMeta,
+  ServerFnMeta,
+} from './constants'
+
+export type * from './serverRoute'
+
+export type * from './startEntry'
+
+export { createStart } from './createStart'
+export type {
+  AnyStartInstance,
+  AnyStartInstanceOptions,
+  StartInstance,
+  StartInstanceOptions,
+} from './createStart'
+export type { Register } from '@benjavicente/router-core'
+
+export { getRouterInstance } from './getRouterInstance'
+export { getDefaultSerovalPlugins } from './getDefaultSerovalPlugins'
+export { getGlobalStartContext } from './getGlobalStartContext'
+export { safeObjectMerge, createNullProtoObject } from './safeObjectMerge'

package/src/safeObjectMerge.ts

@@ -0,0 +1,38 @@
+function isSafeKey(key: string): boolean {
+  return key !== '__proto__' && key !== 'constructor' && key !== 'prototype'
+}
+
+/**
+ * Merge target and source into a new null-proto object, filtering dangerous keys.
+ */
+export function safeObjectMerge<T extends Record<string, unknown>>(
+  target: T | undefined,
+  source: Record<string, unknown> | null | undefined,
+): T {
+  const result = Object.create(null) as T
+  if (target) {
+    for (const key of Object.keys(target)) {
+      if (isSafeKey(key)) result[key as keyof T] = target[key] as T[keyof T]
+    }
+  }
+  if (source && typeof source === 'object') {
+    for (const key of Object.keys(source)) {
+      if (isSafeKey(key)) result[key as keyof T] = source[key] as T[keyof T]
+    }
+  }
+  return result
+}
+
+/**
+ * Create a null-prototype object, optionally copying from source.
+ */
+export function createNullProtoObject<T extends object>(
+  source?: T,
+): { [K in keyof T]: T[K] } {
+  if (!source) return Object.create(null)
+  const obj = Object.create(null)
+  for (const key of Object.keys(source)) {
+    if (isSafeKey(key)) obj[key] = (source as Record<string, unknown>)[key]
+  }
+  return obj
+}