@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
|
@@ -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
|
const RECORDS = Symbol.for("@solidjs/signals/observe/records");
|
|
296
330
|
function records() {
|
|
@@ -467,6 +501,7 @@ const stripHoleMarkers = html => html.replace(/<!--lh:\/?\d+-->/g, "");
|
|
|
467
501
|
function frameSkeleton(html) {
|
|
468
502
|
return html.replace(HOLE_RANGE, "<!--lh:$1--><!--lh:/$1-->").replace(SLOT_RANGE, "<!--slot:$1:start--><!--slot:$1:end-->");
|
|
469
503
|
}
|
|
504
|
+
const ROW_HTML = Symbol.for("solid.rowHtml");
|
|
470
505
|
function holeDigests(html, attrText, into = {}) {
|
|
471
506
|
for (const m of html.matchAll(HOLE_RANGE)) {
|
|
472
507
|
into["lh:" + m[1]] = textDigest(stripHoleMarkers(m[2]));
|
|
@@ -772,12 +807,13 @@ function createFrameSink(write, frame, have, hooks) {
|
|
|
772
807
|
},
|
|
773
808
|
flush,
|
|
774
809
|
slot(key, args) {
|
|
775
|
-
|
|
810
|
+
const r = {
|
|
776
811
|
[`slot:${key}`]: {
|
|
777
812
|
kind: "slot",
|
|
778
813
|
args
|
|
779
814
|
}
|
|
780
|
-
}
|
|
815
|
+
};
|
|
816
|
+
swept ? Object.assign(swept.r, r) : put(id, r);
|
|
781
817
|
},
|
|
782
818
|
region(childId, value) {
|
|
783
819
|
needs("regions");
|
|
@@ -798,7 +834,12 @@ function createFrameSink(write, frame, have, hooks) {
|
|
|
798
834
|
record.rows = rows;
|
|
799
835
|
record.base = base;
|
|
800
836
|
} else record.value = source;
|
|
801
|
-
withHoles(record, holeDigests(record.rows ? rows.r.map(r => r[1]).join("") : source, null));
|
|
837
|
+
withHoles(record, holeDigests(record.rows ? (rows[ROW_HTML] || rows.r.map(r => r[1])).join("") : source, null));
|
|
838
|
+
if (record.rows && hooks && hooks.retain) record[HOLE_SOURCE] = withHoles({
|
|
839
|
+
kind: "html",
|
|
840
|
+
value: source,
|
|
841
|
+
digest: record.digest
|
|
842
|
+
}, holeDigests(source, null));
|
|
802
843
|
const r = {
|
|
803
844
|
["hole:" + key]: record
|
|
804
845
|
};
|
|
@@ -819,6 +860,7 @@ function createFrameSink(write, frame, have, hooks) {
|
|
|
819
860
|
},
|
|
820
861
|
attrBaseline(key, text) {
|
|
821
862
|
attrText.set(key, text);
|
|
863
|
+
if (hooks && hooks.retain) hooks.retain(key, text);
|
|
822
864
|
},
|
|
823
865
|
openBinding(key, b) {
|
|
824
866
|
if (/^lha?:/.test(key)) needs("wire");
|
|
@@ -920,6 +962,7 @@ function frameStream(makeCode, options) {
|
|
|
920
962
|
};
|
|
921
963
|
const sink = createFrameSink(emit, frame, options.resume && options.resume.have, {
|
|
922
964
|
live: options.live,
|
|
965
|
+
retain: options.broadcast,
|
|
923
966
|
onYield: bounded ? () => {
|
|
924
967
|
if (flushed && maxYields > 0 && ++yields >= maxYields) cut("yields");
|
|
925
968
|
} : undefined
|
|
@@ -2056,6 +2099,12 @@ function frameTransformResult(event, result, context) {
|
|
|
2056
2099
|
const invocation = getEventServerFunctionInvocation(event);
|
|
2057
2100
|
const live = !!(invocation && invocation.live);
|
|
2058
2101
|
const have = live ? decodeHaveList(requestHeader(event, FRAME_HAVE_HEADER)) : undefined;
|
|
2102
|
+
if (live && invocation.broadcast && invocation.shareKey !== undefined) return broadcastResponse(invocation.id + "\0" + invocation.shareKey, result, {
|
|
2103
|
+
frame: {
|
|
2104
|
+
id: invocation.id || ""
|
|
2105
|
+
},
|
|
2106
|
+
live: true
|
|
2107
|
+
}, requestSignal(event), have, init);
|
|
2059
2108
|
return serverComponentResponse(result, {
|
|
2060
2109
|
frame: {
|
|
2061
2110
|
id: invocation && invocation.id || ""
|
|
@@ -2067,6 +2116,270 @@ function frameTransformResult(event, result, context) {
|
|
|
2067
2116
|
}
|
|
2068
2117
|
}, init);
|
|
2069
2118
|
}
|
|
2119
|
+
const HOLE_SOURCE = Symbol("solid.frames.holeSource");
|
|
2120
|
+
const BROADCASTS = new Map();
|
|
2121
|
+
function broadcastResponse(key, component, options, signal, have, init) {
|
|
2122
|
+
let shared = BROADCASTS.get(key);
|
|
2123
|
+
if (!shared || shared.ended) shared = startBroadcast(key, component, options);
|
|
2124
|
+
return tapResponse(shared, signal, have, init);
|
|
2125
|
+
}
|
|
2126
|
+
function startBroadcast(key, component, options) {
|
|
2127
|
+
const shared = {
|
|
2128
|
+
key,
|
|
2129
|
+
id: options.frame.id,
|
|
2130
|
+
start: null,
|
|
2131
|
+
taps: new Set(),
|
|
2132
|
+
records: new Map(),
|
|
2133
|
+
data: [],
|
|
2134
|
+
kept: 0,
|
|
2135
|
+
attrs: new Map(),
|
|
2136
|
+
tiers: new Set(["wire"]),
|
|
2137
|
+
failed: false,
|
|
2138
|
+
ended: false,
|
|
2139
|
+
teardown: new AbortController()
|
|
2140
|
+
};
|
|
2141
|
+
BROADCASTS.set(key, shared);
|
|
2142
|
+
const stream = renderServerComponent(component, {
|
|
2143
|
+
...options,
|
|
2144
|
+
broadcast: (key, text) => shared.attrs.set(key, text),
|
|
2145
|
+
signal: shared.teardown.signal
|
|
2146
|
+
});
|
|
2147
|
+
const run = () => stream.pipe({
|
|
2148
|
+
write(message) {
|
|
2149
|
+
const bytes = createEventChunk(JSON.stringify(message));
|
|
2150
|
+
if (message.type === "start") return void (shared.start = bytes);
|
|
2151
|
+
retain(shared, message);
|
|
2152
|
+
for (const tap of shared.taps) tap.write(bytes);
|
|
2153
|
+
},
|
|
2154
|
+
end() {
|
|
2155
|
+
shared.ended = true;
|
|
2156
|
+
if (BROADCASTS.get(key) === shared) BROADCASTS.delete(key);
|
|
2157
|
+
for (const tap of [...shared.taps]) tap.end();
|
|
2158
|
+
},
|
|
2159
|
+
[ANNOUNCE](tiers) {
|
|
2160
|
+
for (const tier of tiers) shared.tiers.add(tier);
|
|
2161
|
+
}
|
|
2162
|
+
});
|
|
2163
|
+
const store = globalThis[RequestContext];
|
|
2164
|
+
store ? store.run(broadcastEvent(), run) : run();
|
|
2165
|
+
return shared;
|
|
2166
|
+
}
|
|
2167
|
+
function broadcastEvent() {
|
|
2168
|
+
const event = {
|
|
2169
|
+
broadcast: true
|
|
2170
|
+
};
|
|
2171
|
+
for (const name of ["request", "locals", "clientAddress", "nativeEvent"]) Object.defineProperty(event, name, {
|
|
2172
|
+
get() {
|
|
2173
|
+
console.warn(`A broadcast server component read the request (\`event.${name}\`). Its answer is ` + "shared by every viewer; read per-viewer state in the server function body instead.");
|
|
2174
|
+
return undefined;
|
|
2175
|
+
}
|
|
2176
|
+
});
|
|
2177
|
+
return event;
|
|
2178
|
+
}
|
|
2179
|
+
function retain(shared, message) {
|
|
2180
|
+
if (message.tiers) for (const tier of message.tiers) shared.tiers.add(tier);
|
|
2181
|
+
if (!message.r) {
|
|
2182
|
+
shared.data.push(message);
|
|
2183
|
+
if (shared.data.length > 64 && shared.data.length > 2 * shared.kept) shared.kept = (shared.data = referencedData(shared)).length;
|
|
2184
|
+
return;
|
|
2185
|
+
}
|
|
2186
|
+
const {
|
|
2187
|
+
id,
|
|
2188
|
+
version
|
|
2189
|
+
} = message;
|
|
2190
|
+
for (const k in message.r) {
|
|
2191
|
+
let record = message.r[k];
|
|
2192
|
+
if (k === ":error") shared.failed = true;
|
|
2193
|
+
if (k === "") for (const [rk, e] of shared.records) if (e.id === id) shared.records.delete(rk);
|
|
2194
|
+
if (record && record[HOLE_SOURCE]) record = record[HOLE_SOURCE];
|
|
2195
|
+
const rk = id + "\0" + k;
|
|
2196
|
+
const prev = shared.records.get(rk);
|
|
2197
|
+
if (prev && record && record.kind === "attrs" && prev.record.removed) {
|
|
2198
|
+
const removed = new Set(prev.record.removed);
|
|
2199
|
+
if (record.removed) for (const name of record.removed) removed.add(name);
|
|
2200
|
+
record = {
|
|
2201
|
+
...record,
|
|
2202
|
+
removed: [...removed]
|
|
2203
|
+
};
|
|
2204
|
+
}
|
|
2205
|
+
shared.records.delete(rk);
|
|
2206
|
+
shared.records.set(rk, {
|
|
2207
|
+
id,
|
|
2208
|
+
version,
|
|
2209
|
+
k,
|
|
2210
|
+
record
|
|
2211
|
+
});
|
|
2212
|
+
}
|
|
2213
|
+
}
|
|
2214
|
+
function referencedData(shared) {
|
|
2215
|
+
const refs = new Set();
|
|
2216
|
+
for (const {
|
|
2217
|
+
record
|
|
2218
|
+
} 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]}"`));
|
|
2219
|
+
return shared.data.filter(m => typeof m.key !== "string" || refs.has(m.key));
|
|
2220
|
+
}
|
|
2221
|
+
function snapshot(shared, have) {
|
|
2222
|
+
const out = referencedData(shared);
|
|
2223
|
+
const root = shared.records.get(shared.id + "\0");
|
|
2224
|
+
const conditional = !!(have && root && root.record && have[""] === root.record.digest);
|
|
2225
|
+
let open = null;
|
|
2226
|
+
const put = (id, version, k, record) => {
|
|
2227
|
+
if (!open || open.id !== id) out.push(open = {
|
|
2228
|
+
id,
|
|
2229
|
+
version,
|
|
2230
|
+
r: {}
|
|
2231
|
+
});
|
|
2232
|
+
open.r[k] = record;
|
|
2233
|
+
};
|
|
2234
|
+
if (!conditional) {
|
|
2235
|
+
for (const {
|
|
2236
|
+
id,
|
|
2237
|
+
version,
|
|
2238
|
+
k,
|
|
2239
|
+
record
|
|
2240
|
+
} of shared.records.values()) put(id, version, k, record);
|
|
2241
|
+
return out;
|
|
2242
|
+
}
|
|
2243
|
+
const containers = [];
|
|
2244
|
+
for (const e of shared.records.values()) if (e.id === shared.id && (e.k === "" || /^seg:[^:]+$/.test(e.k)) && e.record) containers.push({
|
|
2245
|
+
e,
|
|
2246
|
+
value: e.record.value
|
|
2247
|
+
});
|
|
2248
|
+
for (const {
|
|
2249
|
+
k,
|
|
2250
|
+
record
|
|
2251
|
+
} of shared.records.values()) {
|
|
2252
|
+
if (!k.startsWith("hole:lh:") || k.endsWith(":error") || !record || record.value == null) continue;
|
|
2253
|
+
const n = k.slice(8);
|
|
2254
|
+
const startMark = `<!--lh:${n}-->`;
|
|
2255
|
+
const endMark = `<!--lh:/${n}-->`;
|
|
2256
|
+
for (const c of containers) {
|
|
2257
|
+
const start = c.value.indexOf(startMark);
|
|
2258
|
+
if (start < 0) continue;
|
|
2259
|
+
const end = c.value.indexOf(endMark, start);
|
|
2260
|
+
if (end < 0) continue;
|
|
2261
|
+
c.value = c.value.slice(0, start + startMark.length) + record.value + c.value.slice(end);
|
|
2262
|
+
break;
|
|
2263
|
+
}
|
|
2264
|
+
}
|
|
2265
|
+
for (const e of shared.records.values()) {
|
|
2266
|
+
const {
|
|
2267
|
+
id,
|
|
2268
|
+
version,
|
|
2269
|
+
k,
|
|
2270
|
+
record
|
|
2271
|
+
} = e;
|
|
2272
|
+
if (id !== shared.id) {
|
|
2273
|
+
put(id, version, k, record);
|
|
2274
|
+
continue;
|
|
2275
|
+
}
|
|
2276
|
+
if (k === "" || k === "seg::assets" || k.startsWith("hole:lh:") && !k.endsWith(":error")) continue;
|
|
2277
|
+
const seg = /^seg:([^:]+)(?::(.*))?$/.exec(k);
|
|
2278
|
+
if (seg && have[seg[1]] !== undefined && seg[2] !== "error") continue;
|
|
2279
|
+
if (seg && seg[2] === undefined) {
|
|
2280
|
+
const c = containers.find(c => c.e === e);
|
|
2281
|
+
if (c && c.value !== record.value) {
|
|
2282
|
+
put(id, version, k, withHoles({
|
|
2283
|
+
...record,
|
|
2284
|
+
value: c.value,
|
|
2285
|
+
digest: textDigest(c.value)
|
|
2286
|
+
}, holeDigests(c.value, null)));
|
|
2287
|
+
continue;
|
|
2288
|
+
}
|
|
2289
|
+
}
|
|
2290
|
+
if (k.startsWith("attr:")) continue;
|
|
2291
|
+
put(id, version, k, record);
|
|
2292
|
+
}
|
|
2293
|
+
for (const c of containers) {
|
|
2294
|
+
const seg = c.e.k && /^seg:([^:]+)$/.exec(c.e.k);
|
|
2295
|
+
if (seg && have[seg[1]] === undefined) continue;
|
|
2296
|
+
for (const m of c.value.matchAll(HOLE_RANGE)) {
|
|
2297
|
+
const key = "lh:" + m[1];
|
|
2298
|
+
const digest = textDigest(stripHoleMarkers(m[2]));
|
|
2299
|
+
if (have[key] === digest) continue;
|
|
2300
|
+
put(shared.id, c.e.version, "hole:" + key, withHoles({
|
|
2301
|
+
kind: "html",
|
|
2302
|
+
value: m[2],
|
|
2303
|
+
digest
|
|
2304
|
+
}, holeDigests(m[2], null)));
|
|
2305
|
+
}
|
|
2306
|
+
for (const m of c.value.matchAll(ATTR_ADDRESS)) {
|
|
2307
|
+
const latest = shared.records.get(shared.id + "\0attr:" + m[1]);
|
|
2308
|
+
const text = latest ? latest.record.value : shared.attrs.get("lha:" + m[1]);
|
|
2309
|
+
if (text === undefined) continue;
|
|
2310
|
+
const digest = latest ? latest.record.digest : textDigest(text);
|
|
2311
|
+
if (have["lha:" + m[1]] === digest) continue;
|
|
2312
|
+
put(shared.id, c.e.version, "attr:" + m[1], latest ? latest.record : {
|
|
2313
|
+
kind: "attrs",
|
|
2314
|
+
value: text,
|
|
2315
|
+
digest
|
|
2316
|
+
});
|
|
2317
|
+
}
|
|
2318
|
+
}
|
|
2319
|
+
return out;
|
|
2320
|
+
}
|
|
2321
|
+
function tapResponse(shared, signal, have, init = {}) {
|
|
2322
|
+
const headers = copyInitHeaders(init.headers);
|
|
2323
|
+
headers.set(FRAME_STREAM_HEADER, shared.id);
|
|
2324
|
+
headers.set("X-Content-Raw", "1");
|
|
2325
|
+
headers.set("Content-Type", "text/event-stream");
|
|
2326
|
+
headers.set("Cache-Control", "no-store");
|
|
2327
|
+
headers.set("X-Accel-Buffering", "no");
|
|
2328
|
+
headers.set(FRAME_TIERS_HEADER, [...shared.tiers].join(","));
|
|
2329
|
+
let closed = false;
|
|
2330
|
+
let stopLive = null;
|
|
2331
|
+
let tap = null;
|
|
2332
|
+
const leave = () => {
|
|
2333
|
+
if (closed) return;
|
|
2334
|
+
closed = true;
|
|
2335
|
+
if (stopLive) stopLive();
|
|
2336
|
+
if (signal) signal.removeEventListener("abort", leave);
|
|
2337
|
+
shared.taps.delete(tap);
|
|
2338
|
+
if (!shared.taps.size && !shared.ended) {
|
|
2339
|
+
shared.ended = true;
|
|
2340
|
+
if (BROADCASTS.get(shared.key) === shared) BROADCASTS.delete(shared.key);
|
|
2341
|
+
shared.teardown.abort({
|
|
2342
|
+
[DISCONNECTED]: true
|
|
2343
|
+
});
|
|
2344
|
+
}
|
|
2345
|
+
};
|
|
2346
|
+
const body = new ReadableStream({
|
|
2347
|
+
start(controller) {
|
|
2348
|
+
tap = {
|
|
2349
|
+
write(bytes) {
|
|
2350
|
+
if (closed) return;
|
|
2351
|
+
try {
|
|
2352
|
+
controller.enqueue(bytes);
|
|
2353
|
+
} catch (_) {
|
|
2354
|
+
leave();
|
|
2355
|
+
}
|
|
2356
|
+
},
|
|
2357
|
+
end() {
|
|
2358
|
+
leave();
|
|
2359
|
+
try {
|
|
2360
|
+
controller.close();
|
|
2361
|
+
} catch (_) {}
|
|
2362
|
+
}
|
|
2363
|
+
};
|
|
2364
|
+
if (shared.start) controller.enqueue(shared.start);
|
|
2365
|
+
for (const message of snapshot(shared, have)) controller.enqueue(createEventChunk(JSON.stringify(message)));
|
|
2366
|
+
if (shared.ended || signal && signal.aborted) return tap.end();
|
|
2367
|
+
shared.taps.add(tap);
|
|
2368
|
+
stopLive = armLiveBody(controller, leave);
|
|
2369
|
+
if (signal) signal.addEventListener("abort", leave, {
|
|
2370
|
+
once: true
|
|
2371
|
+
});
|
|
2372
|
+
},
|
|
2373
|
+
cancel() {
|
|
2374
|
+
leave();
|
|
2375
|
+
}
|
|
2376
|
+
});
|
|
2377
|
+
if (shared.failed) headers.set("Cache-Control", "no-store");
|
|
2378
|
+
return new Response(body, {
|
|
2379
|
+
status: init.status || 200,
|
|
2380
|
+
headers
|
|
2381
|
+
});
|
|
2382
|
+
}
|
|
2070
2383
|
function requestSignal(event) {
|
|
2071
2384
|
const request = event && event.request;
|
|
2072
2385
|
return request && request.signal instanceof AbortSignal ? request.signal : undefined;
|