@solidjs/web 2.0.0-rc.16 → 2.0.0-rc.18
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/server.dev.js +195 -35
- package/dist/server.js +190 -35
- package/dist/server.observe.js +190 -35
- package/dist/web.dev.js +53 -1
- package/dist/web.js +4 -1
- package/dist/web.observe.js +4 -1
- package/frames/dist/server.dev.js +356 -43
- package/frames/dist/server.js +355 -43
- package/frames/dist/server.observe.js +355 -43
- package/frames/dist/wire.js +110 -14
- package/package.json +4 -4
- package/serialization/dist/decode.js +10 -5
- package/serialization/dist/serialization.js +121 -61
- package/serialization/types/index.d.ts +12 -4
- package/serialization/types/serializer.d.ts +12 -4
- package/server-functions/dist/client.dev.js +10 -21
- package/server-functions/dist/client.js +10 -21
- package/server-functions/dist/client.observe.js +10 -21
- package/server-functions/dist/rich-args.js +54 -3
- package/server-functions/dist/server.dev.js +313 -11
- package/server-functions/dist/server.js +313 -11
- package/server-functions/dist/server.observe.js +313 -11
- package/types/client.d.ts +12 -0
- package/types/diagnostics.d.ts +16 -0
- package/types/frames/frame-morph.d.ts +1 -0
- package/types/frames/serializer.d.ts +12 -4
- package/types/serializer.d.ts +12 -4
- package/types/server-functions/argument-codec.d.ts +11 -2
- package/types/server-functions/client.d.ts +13 -4
- package/types/server-functions/server.d.ts +33 -0
- package/types/server-functions/shared.d.ts +9 -0
- package/types/server-functions/uploads.d.ts +50 -0
- package/types/server.d.ts +1 -1
package/frames/dist/server.js
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
import { sharedConfig, ssrSanitizeError, creationStamp, ssrHandleError, runInServerComponentScope, trackFillReads, shareAsyncIterable, getProjectionTrace } from 'solid-js/internal';
|
|
2
2
|
import { getOwner, NoHydration, runWithOwner, createMemo, createOwner, Hydration } from 'solid-js';
|
|
3
|
-
import { isResponseEnvelope, renderToStream, createLiveHoles } from '@solidjs/web';
|
|
3
|
+
import { isResponseEnvelope, RequestContext, renderToStream, createLiveHoles } from '@solidjs/web';
|
|
4
4
|
import { Feature, createStream, toCrossJSONStream } from 'seroval';
|
|
5
5
|
import { AbortSignalPlugin, CustomEventPlugin, DOMExceptionPlugin, EventPlugin, FormDataPlugin, HeadersPlugin, ReadableStreamPlugin, RequestPlugin, ResponsePlugin, URLSearchParamsPlugin, URLPlugin } from 'seroval-plugins/web';
|
|
6
6
|
import { frameAddress, getEventServerFunctionInvocation, ChunkReader, serializeStream, guardFailures, armLiveBody, createEventChunk, createChunk, textDigest } from '@solidjs/web/server-functions/server';
|
|
@@ -224,26 +224,12 @@ function resolveCodecOptions(options = {}) {
|
|
|
224
224
|
}
|
|
225
225
|
|
|
226
226
|
const serializeOnlyDisabledFeatures = serializeErrorStacks => (serializeErrorStacks === undefined ? process.env.NODE_ENV === "development" : serializeErrorStacks) ? 0 : Feature.ErrorPrototypeStack;
|
|
227
|
-
function
|
|
228
|
-
onData,
|
|
229
|
-
onDone,
|
|
230
|
-
onError,
|
|
231
|
-
plugins,
|
|
232
|
-
disabledFeatures,
|
|
233
|
-
depthLimit,
|
|
234
|
-
serializeErrorStacks
|
|
235
|
-
}) {
|
|
236
|
-
const resolved = resolveCodecOptions({
|
|
237
|
-
plugins,
|
|
238
|
-
disabledFeatures,
|
|
239
|
-
depthLimit,
|
|
240
|
-
serializeErrorStacks
|
|
241
|
-
});
|
|
242
|
-
const refs = new Map();
|
|
227
|
+
function createKeyedSerializer(serialize, onError, onDone) {
|
|
243
228
|
const cancels = new Set();
|
|
244
229
|
let pendingWrites = 0;
|
|
245
230
|
let flushed = false;
|
|
246
231
|
let done = false;
|
|
232
|
+
let closed = false;
|
|
247
233
|
const maybeDone = () => {
|
|
248
234
|
if (flushed && pendingWrites === 0 && !done) {
|
|
249
235
|
done = true;
|
|
@@ -255,42 +241,90 @@ function createJSONSerializer({
|
|
|
255
241
|
if (flushed) return;
|
|
256
242
|
pendingWrites++;
|
|
257
243
|
let settled = false;
|
|
244
|
+
let failed = false;
|
|
245
|
+
let started = false;
|
|
258
246
|
let cancel = null;
|
|
259
|
-
const
|
|
260
|
-
|
|
261
|
-
|
|
262
|
-
|
|
263
|
-
|
|
264
|
-
|
|
265
|
-
|
|
266
|
-
|
|
267
|
-
|
|
268
|
-
|
|
269
|
-
|
|
270
|
-
|
|
271
|
-
|
|
272
|
-
|
|
273
|
-
|
|
274
|
-
|
|
275
|
-
|
|
276
|
-
|
|
277
|
-
|
|
278
|
-
|
|
279
|
-
|
|
280
|
-
|
|
247
|
+
const settle = () => {
|
|
248
|
+
if (settled) return;
|
|
249
|
+
settled = true;
|
|
250
|
+
if (cancel) cancels.delete(cancel);
|
|
251
|
+
pendingWrites--;
|
|
252
|
+
maybeDone();
|
|
253
|
+
};
|
|
254
|
+
let stream;
|
|
255
|
+
try {
|
|
256
|
+
stream = serialize(key, value, {
|
|
257
|
+
onError: onError && (err => {
|
|
258
|
+
failed = true;
|
|
259
|
+
onError(err);
|
|
260
|
+
if (cancel) {
|
|
261
|
+
cancel();
|
|
262
|
+
settle();
|
|
263
|
+
}
|
|
264
|
+
}),
|
|
265
|
+
onDone: settle
|
|
266
|
+
}, initial => {
|
|
267
|
+
if (initial) started = true;
|
|
268
|
+
return !closed;
|
|
269
|
+
});
|
|
270
|
+
} catch (err) {
|
|
271
|
+
settle();
|
|
272
|
+
throw err;
|
|
281
273
|
}
|
|
274
|
+
if (settled) return;
|
|
275
|
+
if (closed || failed) {
|
|
276
|
+
stream();
|
|
277
|
+
settle();
|
|
278
|
+
return;
|
|
279
|
+
}
|
|
280
|
+
cancel = stream;
|
|
281
|
+
cancels.add(cancel);
|
|
282
282
|
},
|
|
283
283
|
flush() {
|
|
284
284
|
flushed = true;
|
|
285
285
|
maybeDone();
|
|
286
286
|
},
|
|
287
287
|
close() {
|
|
288
|
-
flushed = true;
|
|
288
|
+
closed = flushed = true;
|
|
289
289
|
for (const cancel of cancels) cancel();
|
|
290
290
|
cancels.clear();
|
|
291
|
+
if (!done) {
|
|
292
|
+
done = true;
|
|
293
|
+
onDone && onDone();
|
|
294
|
+
}
|
|
291
295
|
}
|
|
292
296
|
};
|
|
293
297
|
}
|
|
298
|
+
function createJSONSerializer({
|
|
299
|
+
onData,
|
|
300
|
+
onDone,
|
|
301
|
+
onError,
|
|
302
|
+
plugins,
|
|
303
|
+
disabledFeatures,
|
|
304
|
+
depthLimit,
|
|
305
|
+
serializeErrorStacks
|
|
306
|
+
}) {
|
|
307
|
+
const resolved = resolveCodecOptions({
|
|
308
|
+
plugins,
|
|
309
|
+
disabledFeatures,
|
|
310
|
+
depthLimit,
|
|
311
|
+
serializeErrorStacks
|
|
312
|
+
});
|
|
313
|
+
const refs = new Map();
|
|
314
|
+
return createKeyedSerializer((key, value, callbacks, live) => toCrossJSONStream(value, {
|
|
315
|
+
refs,
|
|
316
|
+
plugins: resolved.plugins,
|
|
317
|
+
disabledFeatures: resolved.disabledFeatures | serializeOnlyDisabledFeatures(resolved.serializeErrorStacks),
|
|
318
|
+
onParse(node, initial) {
|
|
319
|
+
if (live(initial)) onData({
|
|
320
|
+
key,
|
|
321
|
+
node,
|
|
322
|
+
initial
|
|
323
|
+
});
|
|
324
|
+
},
|
|
325
|
+
...callbacks
|
|
326
|
+
}), onError, onDone);
|
|
327
|
+
}
|
|
294
328
|
|
|
295
329
|
function records() {
|
|
296
330
|
return undefined;
|
|
@@ -466,6 +500,7 @@ const stripHoleMarkers = html => html.replace(/<!--lh:\/?\d+-->/g, "");
|
|
|
466
500
|
function frameSkeleton(html) {
|
|
467
501
|
return html.replace(HOLE_RANGE, "<!--lh:$1--><!--lh:/$1-->").replace(SLOT_RANGE, "<!--slot:$1:start--><!--slot:$1:end-->");
|
|
468
502
|
}
|
|
503
|
+
const ROW_HTML = Symbol.for("solid.rowHtml");
|
|
469
504
|
function holeDigests(html, attrText, into = {}) {
|
|
470
505
|
for (const m of html.matchAll(HOLE_RANGE)) {
|
|
471
506
|
into["lh:" + m[1]] = textDigest(stripHoleMarkers(m[2]));
|
|
@@ -771,12 +806,13 @@ function createFrameSink(write, frame, have, hooks) {
|
|
|
771
806
|
},
|
|
772
807
|
flush,
|
|
773
808
|
slot(key, args) {
|
|
774
|
-
|
|
809
|
+
const r = {
|
|
775
810
|
[`slot:${key}`]: {
|
|
776
811
|
kind: "slot",
|
|
777
812
|
args
|
|
778
813
|
}
|
|
779
|
-
}
|
|
814
|
+
};
|
|
815
|
+
swept ? Object.assign(swept.r, r) : put(id, r);
|
|
780
816
|
},
|
|
781
817
|
region(childId, value) {
|
|
782
818
|
needs("regions");
|
|
@@ -797,7 +833,12 @@ function createFrameSink(write, frame, have, hooks) {
|
|
|
797
833
|
record.rows = rows;
|
|
798
834
|
record.base = base;
|
|
799
835
|
} else record.value = source;
|
|
800
|
-
withHoles(record, holeDigests(record.rows ? rows.r.map(r => r[1]).join("") : source, null));
|
|
836
|
+
withHoles(record, holeDigests(record.rows ? (rows[ROW_HTML] || rows.r.map(r => r[1])).join("") : source, null));
|
|
837
|
+
if (record.rows && hooks && hooks.retain) record[HOLE_SOURCE] = withHoles({
|
|
838
|
+
kind: "html",
|
|
839
|
+
value: source,
|
|
840
|
+
digest: record.digest
|
|
841
|
+
}, holeDigests(source, null));
|
|
801
842
|
const r = {
|
|
802
843
|
["hole:" + key]: record
|
|
803
844
|
};
|
|
@@ -818,6 +859,7 @@ function createFrameSink(write, frame, have, hooks) {
|
|
|
818
859
|
},
|
|
819
860
|
attrBaseline(key, text) {
|
|
820
861
|
attrText.set(key, text);
|
|
862
|
+
if (hooks && hooks.retain) hooks.retain(key, text);
|
|
821
863
|
},
|
|
822
864
|
openBinding(key, b) {
|
|
823
865
|
if (/^lha?:/.test(key)) needs("wire");
|
|
@@ -919,6 +961,7 @@ function frameStream(makeCode, options) {
|
|
|
919
961
|
};
|
|
920
962
|
const sink = createFrameSink(emit, frame, options.resume && options.resume.have, {
|
|
921
963
|
live: options.live,
|
|
964
|
+
retain: options.broadcast,
|
|
922
965
|
onYield: bounded ? () => {
|
|
923
966
|
if (flushed && maxYields > 0 && ++yields >= maxYields) cut("yields");
|
|
924
967
|
} : undefined
|
|
@@ -2055,6 +2098,12 @@ function frameTransformResult(event, result, context) {
|
|
|
2055
2098
|
const invocation = getEventServerFunctionInvocation(event);
|
|
2056
2099
|
const live = !!(invocation && invocation.live);
|
|
2057
2100
|
const have = live ? decodeHaveList(requestHeader(event, FRAME_HAVE_HEADER)) : undefined;
|
|
2101
|
+
if (live && invocation.broadcast && invocation.shareKey !== undefined) return broadcastResponse(invocation.id + "\0" + invocation.shareKey, result, {
|
|
2102
|
+
frame: {
|
|
2103
|
+
id: invocation.id || ""
|
|
2104
|
+
},
|
|
2105
|
+
live: true
|
|
2106
|
+
}, requestSignal(event), have, init);
|
|
2058
2107
|
return serverComponentResponse(result, {
|
|
2059
2108
|
frame: {
|
|
2060
2109
|
id: invocation && invocation.id || ""
|
|
@@ -2066,6 +2115,269 @@ function frameTransformResult(event, result, context) {
|
|
|
2066
2115
|
}
|
|
2067
2116
|
}, init);
|
|
2068
2117
|
}
|
|
2118
|
+
const HOLE_SOURCE = Symbol("solid.frames.holeSource");
|
|
2119
|
+
const BROADCASTS = new Map();
|
|
2120
|
+
function broadcastResponse(key, component, options, signal, have, init) {
|
|
2121
|
+
let shared = BROADCASTS.get(key);
|
|
2122
|
+
if (!shared || shared.ended) shared = startBroadcast(key, component, options);
|
|
2123
|
+
return tapResponse(shared, signal, have, init);
|
|
2124
|
+
}
|
|
2125
|
+
function startBroadcast(key, component, options) {
|
|
2126
|
+
const shared = {
|
|
2127
|
+
key,
|
|
2128
|
+
id: options.frame.id,
|
|
2129
|
+
start: null,
|
|
2130
|
+
taps: new Set(),
|
|
2131
|
+
records: new Map(),
|
|
2132
|
+
data: [],
|
|
2133
|
+
kept: 0,
|
|
2134
|
+
attrs: new Map(),
|
|
2135
|
+
tiers: new Set(["wire"]),
|
|
2136
|
+
failed: false,
|
|
2137
|
+
ended: false,
|
|
2138
|
+
teardown: new AbortController()
|
|
2139
|
+
};
|
|
2140
|
+
BROADCASTS.set(key, shared);
|
|
2141
|
+
const stream = renderServerComponent(component, {
|
|
2142
|
+
...options,
|
|
2143
|
+
broadcast: (key, text) => shared.attrs.set(key, text),
|
|
2144
|
+
signal: shared.teardown.signal
|
|
2145
|
+
});
|
|
2146
|
+
const run = () => stream.pipe({
|
|
2147
|
+
write(message) {
|
|
2148
|
+
const bytes = createEventChunk(JSON.stringify(message));
|
|
2149
|
+
if (message.type === "start") return void (shared.start = bytes);
|
|
2150
|
+
retain(shared, message);
|
|
2151
|
+
for (const tap of shared.taps) tap.write(bytes);
|
|
2152
|
+
},
|
|
2153
|
+
end() {
|
|
2154
|
+
shared.ended = true;
|
|
2155
|
+
if (BROADCASTS.get(key) === shared) BROADCASTS.delete(key);
|
|
2156
|
+
for (const tap of [...shared.taps]) tap.end();
|
|
2157
|
+
},
|
|
2158
|
+
[ANNOUNCE](tiers) {
|
|
2159
|
+
for (const tier of tiers) shared.tiers.add(tier);
|
|
2160
|
+
}
|
|
2161
|
+
});
|
|
2162
|
+
const store = globalThis[RequestContext];
|
|
2163
|
+
store ? store.run(broadcastEvent(), run) : run();
|
|
2164
|
+
return shared;
|
|
2165
|
+
}
|
|
2166
|
+
function broadcastEvent() {
|
|
2167
|
+
const event = {
|
|
2168
|
+
broadcast: true
|
|
2169
|
+
};
|
|
2170
|
+
for (const name of ["request", "locals", "clientAddress", "nativeEvent"]) Object.defineProperty(event, name, {
|
|
2171
|
+
get() {
|
|
2172
|
+
return undefined;
|
|
2173
|
+
}
|
|
2174
|
+
});
|
|
2175
|
+
return event;
|
|
2176
|
+
}
|
|
2177
|
+
function retain(shared, message) {
|
|
2178
|
+
if (message.tiers) for (const tier of message.tiers) shared.tiers.add(tier);
|
|
2179
|
+
if (!message.r) {
|
|
2180
|
+
shared.data.push(message);
|
|
2181
|
+
if (shared.data.length > 64 && shared.data.length > 2 * shared.kept) shared.kept = (shared.data = referencedData(shared)).length;
|
|
2182
|
+
return;
|
|
2183
|
+
}
|
|
2184
|
+
const {
|
|
2185
|
+
id,
|
|
2186
|
+
version
|
|
2187
|
+
} = message;
|
|
2188
|
+
for (const k in message.r) {
|
|
2189
|
+
let record = message.r[k];
|
|
2190
|
+
if (k === ":error") shared.failed = true;
|
|
2191
|
+
if (k === "") for (const [rk, e] of shared.records) if (e.id === id) shared.records.delete(rk);
|
|
2192
|
+
if (record && record[HOLE_SOURCE]) record = record[HOLE_SOURCE];
|
|
2193
|
+
const rk = id + "\0" + k;
|
|
2194
|
+
const prev = shared.records.get(rk);
|
|
2195
|
+
if (prev && record && record.kind === "attrs" && prev.record.removed) {
|
|
2196
|
+
const removed = new Set(prev.record.removed);
|
|
2197
|
+
if (record.removed) for (const name of record.removed) removed.add(name);
|
|
2198
|
+
record = {
|
|
2199
|
+
...record,
|
|
2200
|
+
removed: [...removed]
|
|
2201
|
+
};
|
|
2202
|
+
}
|
|
2203
|
+
shared.records.delete(rk);
|
|
2204
|
+
shared.records.set(rk, {
|
|
2205
|
+
id,
|
|
2206
|
+
version,
|
|
2207
|
+
k,
|
|
2208
|
+
record
|
|
2209
|
+
});
|
|
2210
|
+
}
|
|
2211
|
+
}
|
|
2212
|
+
function referencedData(shared) {
|
|
2213
|
+
const refs = new Set();
|
|
2214
|
+
for (const {
|
|
2215
|
+
record
|
|
2216
|
+
} of shared.records.values()) if (record && typeof record === "object") for (const m of JSON.stringify(record).matchAll(/"\$ref":"((?:[^"\\]|\\.)*)"/g)) refs.add(JSON.parse(`"${m[1]}"`));
|
|
2217
|
+
return shared.data.filter(m => typeof m.key !== "string" || refs.has(m.key));
|
|
2218
|
+
}
|
|
2219
|
+
function snapshot(shared, have) {
|
|
2220
|
+
const out = referencedData(shared);
|
|
2221
|
+
const root = shared.records.get(shared.id + "\0");
|
|
2222
|
+
const conditional = !!(have && root && root.record && have[""] === root.record.digest);
|
|
2223
|
+
let open = null;
|
|
2224
|
+
const put = (id, version, k, record) => {
|
|
2225
|
+
if (!open || open.id !== id) out.push(open = {
|
|
2226
|
+
id,
|
|
2227
|
+
version,
|
|
2228
|
+
r: {}
|
|
2229
|
+
});
|
|
2230
|
+
open.r[k] = record;
|
|
2231
|
+
};
|
|
2232
|
+
if (!conditional) {
|
|
2233
|
+
for (const {
|
|
2234
|
+
id,
|
|
2235
|
+
version,
|
|
2236
|
+
k,
|
|
2237
|
+
record
|
|
2238
|
+
} of shared.records.values()) put(id, version, k, record);
|
|
2239
|
+
return out;
|
|
2240
|
+
}
|
|
2241
|
+
const containers = [];
|
|
2242
|
+
for (const e of shared.records.values()) if (e.id === shared.id && (e.k === "" || /^seg:[^:]+$/.test(e.k)) && e.record) containers.push({
|
|
2243
|
+
e,
|
|
2244
|
+
value: e.record.value
|
|
2245
|
+
});
|
|
2246
|
+
for (const {
|
|
2247
|
+
k,
|
|
2248
|
+
record
|
|
2249
|
+
} of shared.records.values()) {
|
|
2250
|
+
if (!k.startsWith("hole:lh:") || k.endsWith(":error") || !record || record.value == null) continue;
|
|
2251
|
+
const n = k.slice(8);
|
|
2252
|
+
const startMark = `<!--lh:${n}-->`;
|
|
2253
|
+
const endMark = `<!--lh:/${n}-->`;
|
|
2254
|
+
for (const c of containers) {
|
|
2255
|
+
const start = c.value.indexOf(startMark);
|
|
2256
|
+
if (start < 0) continue;
|
|
2257
|
+
const end = c.value.indexOf(endMark, start);
|
|
2258
|
+
if (end < 0) continue;
|
|
2259
|
+
c.value = c.value.slice(0, start + startMark.length) + record.value + c.value.slice(end);
|
|
2260
|
+
break;
|
|
2261
|
+
}
|
|
2262
|
+
}
|
|
2263
|
+
for (const e of shared.records.values()) {
|
|
2264
|
+
const {
|
|
2265
|
+
id,
|
|
2266
|
+
version,
|
|
2267
|
+
k,
|
|
2268
|
+
record
|
|
2269
|
+
} = e;
|
|
2270
|
+
if (id !== shared.id) {
|
|
2271
|
+
put(id, version, k, record);
|
|
2272
|
+
continue;
|
|
2273
|
+
}
|
|
2274
|
+
if (k === "" || k === "seg::assets" || k.startsWith("hole:lh:") && !k.endsWith(":error")) continue;
|
|
2275
|
+
const seg = /^seg:([^:]+)(?::(.*))?$/.exec(k);
|
|
2276
|
+
if (seg && have[seg[1]] !== undefined && seg[2] !== "error") continue;
|
|
2277
|
+
if (seg && seg[2] === undefined) {
|
|
2278
|
+
const c = containers.find(c => c.e === e);
|
|
2279
|
+
if (c && c.value !== record.value) {
|
|
2280
|
+
put(id, version, k, withHoles({
|
|
2281
|
+
...record,
|
|
2282
|
+
value: c.value,
|
|
2283
|
+
digest: textDigest(c.value)
|
|
2284
|
+
}, holeDigests(c.value, null)));
|
|
2285
|
+
continue;
|
|
2286
|
+
}
|
|
2287
|
+
}
|
|
2288
|
+
if (k.startsWith("attr:")) continue;
|
|
2289
|
+
put(id, version, k, record);
|
|
2290
|
+
}
|
|
2291
|
+
for (const c of containers) {
|
|
2292
|
+
const seg = c.e.k && /^seg:([^:]+)$/.exec(c.e.k);
|
|
2293
|
+
if (seg && have[seg[1]] === undefined) continue;
|
|
2294
|
+
for (const m of c.value.matchAll(HOLE_RANGE)) {
|
|
2295
|
+
const key = "lh:" + m[1];
|
|
2296
|
+
const digest = textDigest(stripHoleMarkers(m[2]));
|
|
2297
|
+
if (have[key] === digest) continue;
|
|
2298
|
+
put(shared.id, c.e.version, "hole:" + key, withHoles({
|
|
2299
|
+
kind: "html",
|
|
2300
|
+
value: m[2],
|
|
2301
|
+
digest
|
|
2302
|
+
}, holeDigests(m[2], null)));
|
|
2303
|
+
}
|
|
2304
|
+
for (const m of c.value.matchAll(ATTR_ADDRESS)) {
|
|
2305
|
+
const latest = shared.records.get(shared.id + "\0attr:" + m[1]);
|
|
2306
|
+
const text = latest ? latest.record.value : shared.attrs.get("lha:" + m[1]);
|
|
2307
|
+
if (text === undefined) continue;
|
|
2308
|
+
const digest = latest ? latest.record.digest : textDigest(text);
|
|
2309
|
+
if (have["lha:" + m[1]] === digest) continue;
|
|
2310
|
+
put(shared.id, c.e.version, "attr:" + m[1], latest ? latest.record : {
|
|
2311
|
+
kind: "attrs",
|
|
2312
|
+
value: text,
|
|
2313
|
+
digest
|
|
2314
|
+
});
|
|
2315
|
+
}
|
|
2316
|
+
}
|
|
2317
|
+
return out;
|
|
2318
|
+
}
|
|
2319
|
+
function tapResponse(shared, signal, have, init = {}) {
|
|
2320
|
+
const headers = copyInitHeaders(init.headers);
|
|
2321
|
+
headers.set(FRAME_STREAM_HEADER, shared.id);
|
|
2322
|
+
headers.set("X-Content-Raw", "1");
|
|
2323
|
+
headers.set("Content-Type", "text/event-stream");
|
|
2324
|
+
headers.set("Cache-Control", "no-store");
|
|
2325
|
+
headers.set("X-Accel-Buffering", "no");
|
|
2326
|
+
headers.set(FRAME_TIERS_HEADER, [...shared.tiers].join(","));
|
|
2327
|
+
let closed = false;
|
|
2328
|
+
let stopLive = null;
|
|
2329
|
+
let tap = null;
|
|
2330
|
+
const leave = () => {
|
|
2331
|
+
if (closed) return;
|
|
2332
|
+
closed = true;
|
|
2333
|
+
if (stopLive) stopLive();
|
|
2334
|
+
if (signal) signal.removeEventListener("abort", leave);
|
|
2335
|
+
shared.taps.delete(tap);
|
|
2336
|
+
if (!shared.taps.size && !shared.ended) {
|
|
2337
|
+
shared.ended = true;
|
|
2338
|
+
if (BROADCASTS.get(shared.key) === shared) BROADCASTS.delete(shared.key);
|
|
2339
|
+
shared.teardown.abort({
|
|
2340
|
+
[DISCONNECTED]: true
|
|
2341
|
+
});
|
|
2342
|
+
}
|
|
2343
|
+
};
|
|
2344
|
+
const body = new ReadableStream({
|
|
2345
|
+
start(controller) {
|
|
2346
|
+
tap = {
|
|
2347
|
+
write(bytes) {
|
|
2348
|
+
if (closed) return;
|
|
2349
|
+
try {
|
|
2350
|
+
controller.enqueue(bytes);
|
|
2351
|
+
} catch (_) {
|
|
2352
|
+
leave();
|
|
2353
|
+
}
|
|
2354
|
+
},
|
|
2355
|
+
end() {
|
|
2356
|
+
leave();
|
|
2357
|
+
try {
|
|
2358
|
+
controller.close();
|
|
2359
|
+
} catch (_) {}
|
|
2360
|
+
}
|
|
2361
|
+
};
|
|
2362
|
+
if (shared.start) controller.enqueue(shared.start);
|
|
2363
|
+
for (const message of snapshot(shared, have)) controller.enqueue(createEventChunk(JSON.stringify(message)));
|
|
2364
|
+
if (shared.ended || signal && signal.aborted) return tap.end();
|
|
2365
|
+
shared.taps.add(tap);
|
|
2366
|
+
stopLive = armLiveBody(controller, leave);
|
|
2367
|
+
if (signal) signal.addEventListener("abort", leave, {
|
|
2368
|
+
once: true
|
|
2369
|
+
});
|
|
2370
|
+
},
|
|
2371
|
+
cancel() {
|
|
2372
|
+
leave();
|
|
2373
|
+
}
|
|
2374
|
+
});
|
|
2375
|
+
if (shared.failed) headers.set("Cache-Control", "no-store");
|
|
2376
|
+
return new Response(body, {
|
|
2377
|
+
status: init.status || 200,
|
|
2378
|
+
headers
|
|
2379
|
+
});
|
|
2380
|
+
}
|
|
2069
2381
|
function requestSignal(event) {
|
|
2070
2382
|
const request = event && event.request;
|
|
2071
2383
|
return request && request.signal instanceof AbortSignal ? request.signal : undefined;
|