@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
  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
- put(id, {
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;