vite-plugin-react/packages/plugin-rsc/src/react/rsc.node.ts at 3706026cd6b3d41cfbe4008a9ea4f2ebec46cc55 · vitejs/vite-plugin-react · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
import type { Readable } from 'node:stream'
// @ts-ignore
import * as ReactClient from '@vitejs/plugin-rsc/vendor/react-server-dom/client.node'
// @ts-ignore
import * as ReactServer from '@vitejs/plugin-rsc/vendor/react-server-dom/server.node'
import type { ReactFormState } from 'react-dom/client'
import {
  createClientManifest,
  createServerDecodeClientManifest,
  createServerManifest,
} from '../core/rsc'
import type {
  ClientTemporaryReferenceSet,
  DecodeReplyFunction,
  EncodeReplyFunction,
  RenderToReadableStreamOptions,
  ServerTemporaryReferenceSet,
} from '../types'

export { loadServerAction, setRequireModule } from '../core/rsc'

export interface PipeableStream {
  abort(reason: unknown): void
  pipe<Writable extends NodeJS.WritableStream>(destination: Writable): Writable
}

export function renderToPipeableStream<T>(
  data: T,
  options?: RenderToReadableStreamOptions,
  extraOptions?: {
    /**
     * @internal
     */
    onClientReference?: (metadata: { id: string; name: string }) => void
  },
): PipeableStream {
  return ReactServer.renderToPipeableStream(
    data,
    createClientManifest({
      onClientReference: extraOptions?.onClientReference,
    }),
    options,
  )
}

export function renderToReadableStream<T>(
  data: T,
  options?: RenderToReadableStreamOptions,
  extraOptions?: {
    /**
     * @internal
     */
    onClientReference?: (metadata: { id: string; name: string }) => void
  },
): ReadableStream<Uint8Array> {
  return ReactServer.renderToReadableStream(
    data,
    createClientManifest({
      onClientReference: extraOptions?.onClientReference,
    }),
    options,
  )
}

export function createFromReadableStream<T>(
  stream: ReadableStream<Uint8Array>,
  options: object = {},
): Promise<T> {
  return ReactClient.createFromReadableStream(stream, {
    serverConsumerManifest: {
      serverModuleMap: createServerManifest(),
      moduleMap: createServerDecodeClientManifest(),
    },
    ...options,
  })
}

export function createFromNodeStream<T>(
  stream: Readable,
  options: object = {},
): Promise<T> {
  return ReactClient.createFromNodeStream(stream, {
    serverConsumerManifest: {
      serverModuleMap: createServerManifest(),
      moduleMap: createServerDecodeClientManifest(),
    },
    ...options,
  })
}

export function registerClientReference<T>(
  proxy: T,
  id: string,
  name: string,
): T {
  return ReactServer.registerClientReference(proxy, id, name)
}

export const registerServerReference: <T>(
  ref: T,
  id: string,
  name: string,
) => T = ReactServer.registerServerReference

export const decodeReply: DecodeReplyFunction = (body, options) =>
  ReactServer.decodeReply(body, createServerManifest(), options)

export function decodeAction(body: FormData): Promise<() => Promise<void>> {
  return ReactServer.decodeAction(body, createServerManifest())
}

export function decodeFormState(
  actionResult: unknown,
  body: FormData,
): Promise<ReactFormState | undefined> {
  return ReactServer.decodeFormState(actionResult, body, createServerManifest())
}

export const createTemporaryReferenceSet: () => ServerTemporaryReferenceSet =
  ReactServer.createTemporaryReferenceSet

export const encodeReply: EncodeReplyFunction = ReactClient.encodeReply

export const createClientTemporaryReferenceSet: () => ClientTemporaryReferenceSet =
  ReactClient.createTemporaryReferenceSet