@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.
@@ -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 createJSONSerializer({
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 stream = toCrossJSONStream(value, {
260
- refs,
261
- plugins: resolved.plugins,
262
- disabledFeatures: resolved.disabledFeatures | serializeOnlyDisabledFeatures(resolved.serializeErrorStacks),
263
- onParse(node, initial) {
264
- onData({
265
- key,
266
- node,
267
- initial
268
- });
269
- },
270
- onError,
271
- onDone() {
272
- settled = true;
273
- if (cancel) cancels.delete(cancel);
274
- pendingWrites--;
275
- maybeDone();
276
- }
277
- });
278
- if (!settled) {
279
- cancel = stream;
280
- cancels.add(cancel);
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
- put(id, {
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;