createInvokeableTransport() — vite Function Reference

Architecture documentation for the createInvokeableTransport() function in moduleRunnerTransport.ts from the vite codebase.

Function typescript HMRClient WebSocketTransport calls 1 called by 1

Entity Profile

HMRClient→ WebSocketTransport→ createInvokeableTransport() — vite Function Reference

Dependency Diagram

graph TD
  9eeb38dd_72eb_bc2e_d762_af3b2d96d316["createInvokeableTransport()"]
  a469d907_868c_e1c2_3f7a_7aaf42cc6a7a["moduleRunnerTransport.ts"]
  9eeb38dd_72eb_bc2e_d762_af3b2d96d316 -->|defined in| a469d907_868c_e1c2_3f7a_7aaf42cc6a7a
  f9bbebfe_9cba_07d9_a804_95e8776eaea9["normalizeModuleRunnerTransport()"]
  f9bbebfe_9cba_07d9_a804_95e8776eaea9 -->|calls| 9eeb38dd_72eb_bc2e_d762_af3b2d96d316
  9ae531a9_6ee6_b0c4_a90a_22ecf638ca87["reviveInvokeError()"]
  9eeb38dd_72eb_bc2e_d762_af3b2d96d316 -->|calls| 9ae531a9_6ee6_b0c4_a90a_22ecf638ca87
  style 9eeb38dd_72eb_bc2e_d762_af3b2d96d316 fill:#6366f1,stroke:#818cf8,color:#fff

Relationship Graph

Source Code

packages/vite/src/shared/moduleRunnerTransport.ts lines 43–175

const createInvokeableTransport = (
  transport: ModuleRunnerTransport,
): InvokeableModuleRunnerTransport => {
  if (transport.invoke) {
    return {
      ...transport,
      async invoke(name, data) {
        const result = await transport.invoke!({
          type: 'custom',
          event: 'vite:invoke',
          data: {
            id: 'send',
            name,
            data,
          } satisfies InvokeSendData,
        } satisfies CustomPayload)
        if ('error' in result) {
          throw reviveInvokeError(result.error)
        }
        return result.result
      },
    }
  }

  if (!transport.send || !transport.connect) {
    throw new Error(
      'transport must implement send and connect when invoke is not implemented',
    )
  }

  const rpcPromises = new Map<
    string,
    {
      resolve: (data: any) => void
      reject: (data: any) => void
      name: string
      timeoutId?: ReturnType<typeof setTimeout>
    }
  >()

  return {
    ...transport,
    connect({ onMessage, onDisconnection }) {
      return transport.connect!({
        onMessage(payload) {
          if (payload.type === 'custom' && payload.event === 'vite:invoke') {
            const data = payload.data as InvokeResponseData
            if (data.id.startsWith('response:')) {
              const invokeId = data.id.slice('response:'.length)
              const promise = rpcPromises.get(invokeId)
              if (!promise) return

              if (promise.timeoutId) clearTimeout(promise.timeoutId)

              rpcPromises.delete(invokeId)

              const { error, result } = data.data
              if (error) {
                promise.reject(error)
              } else {
                promise.resolve(result)
              }
              return
            }
          }
          onMessage(payload)
        },
        onDisconnection,
      })
    },
    disconnect() {
      rpcPromises.forEach((promise) => {
        promise.reject(
          new Error(
            `transport was disconnected, cannot call ${JSON.stringify(promise.name)}`,
          ),
        )
      })
      rpcPromises.clear()
      return transport.disconnect?.()
    },