UNPKG

6.16 kBJavaScriptView Raw
1/**
2 * react-router v8.5.2
3 *
4 * Copyright (c) Remix Software Inc.
5 *
6 * This source code is licensed under the MIT license found in the
7 * LICENSE.md file in the root directory of this source tree.
8 *
9 * @license MIT
10 */
11import "../../lib/router/utils.js";
12import { Deferred, createLineSplittingTransform } from "./utils.js";
13import { flatten } from "./flatten.js";
14import { unflatten } from "./unflatten.js";
15//#region vendor/turbo-stream-v2/turbo-stream.ts
16async function decode(readable, options) {
17 const { plugins } = options ?? {};
18 const done = new Deferred();
19 const reader = readable.pipeThrough(createLineSplittingTransform()).getReader();
20 const decoder = {
21 values: [],
22 hydrated: [],
23 deferred: {},
24 plugins
25 };
26 const decoded = await decodeInitial.call(decoder, reader);
27 let donePromise = done.promise;
28 if (decoded.done) done.resolve();
29 else donePromise = decodeDeferred.call(decoder, reader).then(done.resolve).catch((reason) => {
30 for (const deferred of Object.values(decoder.deferred)) deferred.reject(reason);
31 done.reject(reason);
32 });
33 return {
34 done: donePromise.then(() => reader.closed),
35 value: decoded.value
36 };
37}
38async function decodeInitial(reader) {
39 const read = await reader.read();
40 if (!read.value) throw new SyntaxError();
41 let line;
42 try {
43 line = JSON.parse(read.value);
44 } catch {
45 throw new SyntaxError();
46 }
47 return {
48 done: read.done,
49 value: unflatten.call(this, line)
50 };
51}
52async function decodeDeferred(reader) {
53 let read = await reader.read();
54 while (!read.done) {
55 if (!read.value) continue;
56 const line = read.value;
57 switch (line[0]) {
58 case "P": {
59 const colonIndex = line.indexOf(":");
60 const deferredId = Number(line.slice(1, colonIndex));
61 const deferred = this.deferred[deferredId];
62 if (!deferred) throw new Error(`Deferred ID ${deferredId} not found in stream`);
63 const lineData = line.slice(colonIndex + 1);
64 let jsonLine;
65 try {
66 jsonLine = JSON.parse(lineData);
67 } catch {
68 throw new SyntaxError();
69 }
70 const value = unflatten.call(this, jsonLine);
71 deferred.resolve(value);
72 break;
73 }
74 case "E": {
75 const colonIndex = line.indexOf(":");
76 const deferredId = Number(line.slice(1, colonIndex));
77 const deferred = this.deferred[deferredId];
78 if (!deferred) throw new Error(`Deferred ID ${deferredId} not found in stream`);
79 const lineData = line.slice(colonIndex + 1);
80 let jsonLine;
81 try {
82 jsonLine = JSON.parse(lineData);
83 } catch {
84 throw new SyntaxError();
85 }
86 const value = unflatten.call(this, jsonLine);
87 deferred.reject(value);
88 break;
89 }
90 default: throw new SyntaxError();
91 }
92 read = await reader.read();
93 }
94}
95function encode(input, options) {
96 const { onComplete, plugins, postPlugins, signal } = options ?? {};
97 const encoder = {
98 deferred: {},
99 index: 0,
100 indices: /* @__PURE__ */ new Map(),
101 stringified: [],
102 plugins,
103 postPlugins,
104 signal
105 };
106 const textEncoder = new TextEncoder();
107 let lastSentIndex = 0;
108 let cancelled = false;
109 return new ReadableStream({
110 async start(controller) {
111 const enqueue = (chunk) => {
112 if (!cancelled) controller.enqueue(chunk);
113 };
114 const id = await flatten.call(encoder, input);
115 if (Array.isArray(id)) throw new Error("This should never happen");
116 if (id < 0) enqueue(textEncoder.encode(`${id}\n`));
117 else {
118 enqueue(textEncoder.encode(`[${encoder.stringified.join(",")}]\n`));
119 lastSentIndex = encoder.stringified.length - 1;
120 }
121 const seenPromises = /* @__PURE__ */ new WeakSet();
122 let processingChain = Promise.resolve();
123 if (Object.keys(encoder.deferred).length) {
124 let raceDone;
125 const racePromise = new Promise((resolve, reject) => {
126 raceDone = resolve;
127 if (signal) {
128 const rejectPromise = () => reject(signal.reason || /* @__PURE__ */ new Error("Signal was aborted."));
129 if (signal.aborted) rejectPromise();
130 else signal.addEventListener("abort", (event) => {
131 rejectPromise();
132 });
133 }
134 });
135 while (Object.keys(encoder.deferred).length > 0) {
136 for (const [deferredId, deferred] of Object.entries(encoder.deferred)) {
137 if (seenPromises.has(deferred)) continue;
138 seenPromises.add(encoder.deferred[Number(deferredId)] = Promise.race([racePromise, deferred]).then((resolved) => {
139 processingChain = processingChain.then(async () => {
140 const id = await flatten.call(encoder, resolved);
141 if (Array.isArray(id)) {
142 enqueue(textEncoder.encode(`P${deferredId}:[["Z",${id[0]}]]\n`));
143 encoder.index++;
144 lastSentIndex++;
145 } else if (id < 0) enqueue(textEncoder.encode(`P${deferredId}:${id}\n`));
146 else {
147 const values = encoder.stringified.slice(lastSentIndex + 1).join(",");
148 enqueue(textEncoder.encode(`P${deferredId}:[${values}]\n`));
149 lastSentIndex = encoder.stringified.length - 1;
150 }
151 });
152 return processingChain;
153 }, (reason) => {
154 processingChain = processingChain.then(async () => {
155 if (!reason || typeof reason !== "object" || !(reason instanceof Error)) reason = /* @__PURE__ */ new Error("An unknown error occurred");
156 const id = await flatten.call(encoder, reason);
157 if (Array.isArray(id)) {
158 enqueue(textEncoder.encode(`E${deferredId}:[["Z",${id[0]}]]\n`));
159 encoder.index++;
160 lastSentIndex++;
161 } else if (id < 0) enqueue(textEncoder.encode(`E${deferredId}:${id}\n`));
162 else {
163 const values = encoder.stringified.slice(lastSentIndex + 1).join(",");
164 enqueue(textEncoder.encode(`E${deferredId}:[${values}]\n`));
165 lastSentIndex = encoder.stringified.length - 1;
166 }
167 });
168 return processingChain;
169 }).finally(() => {
170 delete encoder.deferred[Number(deferredId)];
171 }));
172 }
173 await Promise.race(Object.values(encoder.deferred));
174 }
175 raceDone();
176 }
177 await Promise.all(Object.values(encoder.deferred));
178 await processingChain;
179 if (!cancelled) controller.close();
180 onComplete?.();
181 },
182 cancel() {
183 cancelled = true;
184 }
185 });
186}
187//#endregion
188export { decode, encode };