@solidjs/web 2.0.0-rc.15 → 2.0.0-rc.16
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/README.md +1 -1
- package/dist/server.dev.js +358 -479
- package/dist/server.js +343 -387
- package/dist/server.observe.js +343 -387
- package/dist/web.dev.js +57 -54
- package/dist/web.js +47 -49
- package/dist/web.observe.js +57 -54
- package/frames/dist/client.dev.js +610 -621
- package/frames/dist/client.js +540 -566
- package/frames/dist/client.observe.js +571 -573
- package/frames/dist/regions.js +43 -2
- package/frames/dist/server.dev.js +514 -423
- package/frames/dist/server.js +514 -370
- package/frames/dist/server.observe.js +514 -370
- package/frames/dist/wire.js +371 -6
- package/package.json +11 -11
- package/serialization/dist/decode.js +9 -7
- package/serialization/dist/serialization.js +9 -7
- package/serialization/types/serializer-decode.d.ts +2 -2
- package/server-functions/dist/client.dev.js +3 -1
- package/server-functions/dist/client.js +1 -1
- package/server-functions/dist/client.observe.js +3 -1
- package/server-functions/dist/rich-args.js +33 -1
- package/server-functions/dist/server.dev.js +127 -18
- package/server-functions/dist/server.js +127 -18
- package/server-functions/dist/server.observe.js +127 -18
- package/skills/server-components/SKILL.md +74 -185
- package/types/client.d.ts +15 -5
- package/types/frames/assets-tier.d.ts +2 -2
- package/types/frames/client.d.ts +8 -3
- package/types/frames/frame-client.d.ts +121 -157
- package/types/frames/frame-morph.d.ts +28 -0
- package/types/frames/frame-sink.d.ts +13 -9
- package/types/frames/frame-transport.d.ts +30 -1
- package/types/frames/regions-tier.d.ts +15 -0
- package/types/frames/serializer-decode.d.ts +2 -2
- package/types/frames/server.d.ts +0 -52
- package/types/frames/wire-tier.d.ts +54 -1
- package/types/index.d.ts +2 -2
- package/types/jsx.d.ts +11 -5
- package/types/observe.d.ts +14 -7
- package/types/render.d.ts +3 -1
- package/types/response.d.ts +5 -4
- package/types/serializer-decode.d.ts +2 -2
- package/types/server-functions/argument-codec.d.ts +21 -0
- package/types/server-functions/client.d.ts +14 -5
- package/types/server-functions/server.d.ts +6 -2
- package/types/server-functions/shared.d.ts +19 -0
- package/types/server-observe.d.ts +3 -2
- package/types/server.d.ts +57 -76
- package/frames/dist/bind.dev.js +0 -326
- package/frames/dist/bind.js +0 -295
- package/types/frames/bind-tier.d.ts +0 -60
|
@@ -1,6 +1,6 @@
|
|
|
1
|
-
import { sharedConfig, ssrSanitizeError, creationStamp, ssrHandleError, runInServerComponentScope, shareAsyncIterable, getProjectionTrace } from 'solid-js/internal';
|
|
2
|
-
import { getOwner, NoHydration, runWithOwner, createMemo,
|
|
3
|
-
import { isResponseEnvelope, renderToStream, createLiveHoles
|
|
1
|
+
import { sharedConfig, ssrSanitizeError, creationStamp, ssrHandleError, runInServerComponentScope, trackFillReads, shareAsyncIterable, getProjectionTrace } from 'solid-js/internal';
|
|
2
|
+
import { getOwner, NoHydration, runWithOwner, createMemo, createOwner, Hydration } from 'solid-js';
|
|
3
|
+
import { isResponseEnvelope, 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';
|
|
@@ -207,14 +207,16 @@ function resolveSerializerPlugins(customPlugins) {
|
|
|
207
207
|
}
|
|
208
208
|
const jsonCodecDisabledFeatures = () => Feature.RegExp;
|
|
209
209
|
const JSON_CODEC_DEPTH_LIMIT = 64;
|
|
210
|
-
|
|
211
|
-
|
|
212
|
-
|
|
213
|
-
|
|
214
|
-
|
|
215
|
-
|
|
210
|
+
const RESOLVED_PLUGINS = Symbol.for("solid.codec.resolvedPlugins");
|
|
211
|
+
function resolveCodecOptions(options = {}) {
|
|
212
|
+
const {
|
|
213
|
+
plugins,
|
|
214
|
+
disabledFeatures,
|
|
215
|
+
depthLimit,
|
|
216
|
+
serializeErrorStacks
|
|
217
|
+
} = options;
|
|
216
218
|
return {
|
|
217
|
-
plugins: resolveSerializerPlugins(plugins),
|
|
219
|
+
plugins: options[RESOLVED_PLUGINS] || resolveSerializerPlugins(plugins),
|
|
218
220
|
disabledFeatures: disabledFeatures === undefined ? jsonCodecDisabledFeatures() : disabledFeatures,
|
|
219
221
|
depthLimit: depthLimit === undefined ? JSON_CODEC_DEPTH_LIMIT : depthLimit,
|
|
220
222
|
serializeErrorStacks
|
|
@@ -294,8 +296,17 @@ const RECORDS = Symbol.for("@solidjs/signals/observe/records");
|
|
|
294
296
|
function records() {
|
|
295
297
|
return globalThis[RECORDS];
|
|
296
298
|
}
|
|
297
|
-
function
|
|
298
|
-
|
|
299
|
+
function frameRecordCensus(event, message, own) {
|
|
300
|
+
const r = message.r;
|
|
301
|
+
let counted = !r;
|
|
302
|
+
for (const key in r) {
|
|
303
|
+
if (key === ":complete" || key === ":bound") continue;
|
|
304
|
+
counted = true;
|
|
305
|
+
countEvent(event, key === "" ? "html" : key.endsWith(":error") ? "error" : key.startsWith("slot:") ? "slot" : key.startsWith("seg:") && r[key] && r[key].kind === "html" ? "fragment" : key, own);
|
|
306
|
+
}
|
|
307
|
+
if (counted) event.chunks++;
|
|
308
|
+
}
|
|
309
|
+
function countEvent(event, type, own) {
|
|
299
310
|
switch (type) {
|
|
300
311
|
case "html":
|
|
301
312
|
if (!own) event.regions++;else if (event.shellMs === undefined) event.shellMs = performance.now() - event.at;
|
|
@@ -330,9 +341,8 @@ function observeFrame(frame) {
|
|
|
330
341
|
};
|
|
331
342
|
let settled = false;
|
|
332
343
|
return {
|
|
333
|
-
chunk(
|
|
334
|
-
|
|
335
|
-
frameCensus(event, chunk.type, chunk.id === frame.id);
|
|
344
|
+
chunk(message) {
|
|
345
|
+
frameRecordCensus(event, message, message.id === frame.id);
|
|
336
346
|
},
|
|
337
347
|
settle(outcome, error) {
|
|
338
348
|
if (settled) return;
|
|
@@ -485,14 +495,41 @@ function createFrameSink(write, frame, have, hooks) {
|
|
|
485
495
|
} = frame;
|
|
486
496
|
const tiers = new Set();
|
|
487
497
|
let staged = [];
|
|
488
|
-
const
|
|
489
|
-
if (swept) swept.emitted = true;
|
|
498
|
+
const send = message => {
|
|
490
499
|
if (staged.length) {
|
|
491
|
-
|
|
500
|
+
message.tiers = staged;
|
|
492
501
|
staged = [];
|
|
493
502
|
}
|
|
494
|
-
write(
|
|
503
|
+
write(message);
|
|
504
|
+
};
|
|
505
|
+
let queue = [];
|
|
506
|
+
let open = null;
|
|
507
|
+
let scheduled = false;
|
|
508
|
+
const flush = () => {
|
|
509
|
+
scheduled = false;
|
|
510
|
+
open = null;
|
|
511
|
+
const out = queue;
|
|
512
|
+
queue = [];
|
|
513
|
+
for (const message of out) send(message);
|
|
514
|
+
};
|
|
515
|
+
const put = (fid, r) => {
|
|
516
|
+
if (swept) swept.emitted = true;
|
|
517
|
+
showing(r);
|
|
518
|
+
let merge = open && open.id === fid;
|
|
519
|
+
if (merge) for (const key in r) if (key in open.r) merge = false;
|
|
520
|
+
if (merge) Object.assign(open.r, r);else queue.push(open = {
|
|
521
|
+
id: fid,
|
|
522
|
+
version,
|
|
523
|
+
r
|
|
524
|
+
});
|
|
525
|
+
if (!scheduled) {
|
|
526
|
+
scheduled = true;
|
|
527
|
+
queueMicrotask(flush);
|
|
528
|
+
}
|
|
495
529
|
};
|
|
530
|
+
const putError = (fid, key, error) => put(fid, {
|
|
531
|
+
[key ? `${/^lha?:/.test(key) ? "hole" : "seg"}:${key}:error` : ":error"]: error
|
|
532
|
+
});
|
|
496
533
|
const needs = name => {
|
|
497
534
|
if (!tiers.has(name)) {
|
|
498
535
|
tiers.add(name);
|
|
@@ -502,36 +539,44 @@ function createFrameSink(write, frame, have, hooks) {
|
|
|
502
539
|
let conditional = false;
|
|
503
540
|
const skipped = new Set();
|
|
504
541
|
const attrText = new Map();
|
|
505
|
-
const
|
|
506
|
-
|
|
542
|
+
const holeDigest = new Map();
|
|
543
|
+
if (have) for (const key in have) key.startsWith("lh:") && holeDigest.set(key, have[key]);
|
|
544
|
+
function showing(r) {
|
|
545
|
+
if ("" in r) holeDigest.clear();
|
|
546
|
+
for (const k in r) {
|
|
547
|
+
const record = r[k];
|
|
548
|
+
if (k.startsWith("hole:lh:") && !k.endsWith(":error")) holeDigest.set(k.slice(5), record.digest);
|
|
549
|
+
if (record) for (const key in record.holes) key.startsWith("lh:") && holeDigest.set(key, record.holes[key]);
|
|
550
|
+
}
|
|
551
|
+
}
|
|
552
|
+
const html = (value, digest, holes) => withHoles({
|
|
553
|
+
kind: "html",
|
|
554
|
+
value,
|
|
555
|
+
digest
|
|
556
|
+
}, holes);
|
|
557
|
+
const emitDiffering = source => {
|
|
558
|
+
for (const m of source.matchAll(HOLE_RANGE)) {
|
|
507
559
|
const key = "lh:" + m[1];
|
|
508
560
|
const digest = textDigest(stripHoleMarkers(m[2]));
|
|
509
561
|
if (have[key] === digest) continue;
|
|
510
|
-
|
|
511
|
-
|
|
512
|
-
|
|
513
|
-
version,
|
|
514
|
-
key,
|
|
515
|
-
html: m[2],
|
|
516
|
-
digest
|
|
517
|
-
}, holeDigests(m[2], null)));
|
|
562
|
+
put(id, {
|
|
563
|
+
["hole:" + key]: html(m[2], digest, holeDigests(m[2], null))
|
|
564
|
+
});
|
|
518
565
|
}
|
|
519
|
-
for (const m of
|
|
566
|
+
for (const m of source.matchAll(ATTR_ADDRESS)) {
|
|
520
567
|
const text = attrText.get("lha:" + m[1]);
|
|
521
568
|
if (text === undefined) continue;
|
|
522
569
|
const digest = textDigest(text);
|
|
523
570
|
if (have["lha:" + m[1]] === digest) continue;
|
|
524
|
-
|
|
525
|
-
|
|
526
|
-
|
|
527
|
-
|
|
528
|
-
|
|
529
|
-
|
|
530
|
-
digest
|
|
571
|
+
put(id, {
|
|
572
|
+
["attr:" + m[1]]: {
|
|
573
|
+
kind: "attrs",
|
|
574
|
+
value: text,
|
|
575
|
+
digest
|
|
576
|
+
}
|
|
531
577
|
});
|
|
532
578
|
}
|
|
533
579
|
};
|
|
534
|
-
const styledKeys = new Set();
|
|
535
580
|
const bindings = new Map();
|
|
536
581
|
const sweepMinted = new Set();
|
|
537
582
|
const argRefVersions = new Map();
|
|
@@ -542,34 +587,27 @@ function createFrameSink(write, frame, have, hooks) {
|
|
|
542
587
|
const sweep = () => {
|
|
543
588
|
epoch++;
|
|
544
589
|
const pass = swept = {
|
|
545
|
-
|
|
590
|
+
r: {},
|
|
546
591
|
emitted: false
|
|
547
592
|
};
|
|
548
593
|
try {
|
|
549
|
-
for (const b of [...bindings
|
|
594
|
+
for (const [key, b] of [...bindings]) {
|
|
595
|
+
if (bindings.get(key) !== b) continue;
|
|
550
596
|
try {
|
|
551
597
|
b.sweep();
|
|
552
598
|
} catch (_) {
|
|
553
599
|
}
|
|
554
600
|
}
|
|
555
|
-
|
|
601
|
+
for (const _ in pass.r) {
|
|
602
|
+
put(id, pass.r);
|
|
603
|
+
break;
|
|
604
|
+
}
|
|
605
|
+
flush();
|
|
556
606
|
if (pass.emitted && hooks && hooks.onYield) hooks.onYield();
|
|
557
607
|
} finally {
|
|
558
608
|
swept = null;
|
|
559
609
|
}
|
|
560
610
|
};
|
|
561
|
-
const emitOps = ops => {
|
|
562
|
-
if (ops.length === 1) emit(Object.assign({
|
|
563
|
-
type: ops[0].type,
|
|
564
|
-
id,
|
|
565
|
-
version
|
|
566
|
-
}, ops[0]));else if (ops.length) emit({
|
|
567
|
-
type: "ops",
|
|
568
|
-
id,
|
|
569
|
-
version,
|
|
570
|
-
ops
|
|
571
|
-
});
|
|
572
|
-
};
|
|
573
611
|
const scheduleSweep = () => {
|
|
574
612
|
if (closed || sweepScheduled || !bindings.size) return;
|
|
575
613
|
sweepScheduled = true;
|
|
@@ -584,52 +622,47 @@ function createFrameSink(write, frame, have, hooks) {
|
|
|
584
622
|
tagRegion(key, childId) {
|
|
585
623
|
if (!regionKeys.has(key)) regionKeys.set(key, childId);
|
|
586
624
|
},
|
|
587
|
-
shell(
|
|
588
|
-
const digest = textDigest(frameSkeleton(
|
|
625
|
+
shell(source, meta = {}) {
|
|
626
|
+
const digest = textDigest(frameSkeleton(source));
|
|
589
627
|
if (have && have[""] === digest) {
|
|
590
628
|
conditional = true;
|
|
591
|
-
emitDiffering(
|
|
629
|
+
emitDiffering(source);
|
|
592
630
|
return;
|
|
593
631
|
}
|
|
594
632
|
if (meta.preloads && meta.preloads.size || meta.preloadLinks) {
|
|
595
|
-
const
|
|
596
|
-
type: "assets",
|
|
597
|
-
id,
|
|
598
|
-
version,
|
|
599
|
-
key: ""
|
|
600
|
-
};
|
|
633
|
+
const record = {};
|
|
601
634
|
if (meta.preloads && meta.preloads.size) {
|
|
602
635
|
const styles = [];
|
|
603
636
|
const modules = [];
|
|
604
637
|
for (const url of meta.preloads) {
|
|
605
638
|
(url.endsWith(".css") ? styles : modules).push(url);
|
|
606
639
|
}
|
|
607
|
-
if (styles.length)
|
|
608
|
-
if (modules.length)
|
|
640
|
+
if (styles.length) record.styles = styles;
|
|
641
|
+
if (modules.length) record.modules = modules;
|
|
609
642
|
}
|
|
610
643
|
if (meta.preloadLinks) {
|
|
611
|
-
|
|
644
|
+
record.preloads = [];
|
|
612
645
|
for (const entry of meta.preloadLinks) {
|
|
613
|
-
|
|
646
|
+
record.preloads.push(wirePreload(entry));
|
|
614
647
|
}
|
|
615
648
|
}
|
|
616
649
|
needs("assets");
|
|
617
|
-
|
|
650
|
+
put(id, {
|
|
651
|
+
"seg::assets": record
|
|
652
|
+
});
|
|
618
653
|
}
|
|
619
|
-
|
|
620
|
-
|
|
621
|
-
|
|
622
|
-
version,
|
|
623
|
-
html,
|
|
624
|
-
digest
|
|
625
|
-
}, holeDigests(html, attrText)));
|
|
654
|
+
put(id, {
|
|
655
|
+
"": html(source, digest, holeDigests(source, attrText))
|
|
656
|
+
});
|
|
626
657
|
},
|
|
627
658
|
data(record) {
|
|
628
659
|
if (record && typeof record.key === "string" && (record.key.endsWith("_fr") || /^\d+$/.test(record.key))) {
|
|
629
660
|
return;
|
|
630
661
|
}
|
|
662
|
+
if (swept) swept.emitted = true;
|
|
663
|
+
flush();
|
|
631
664
|
if (typeof record === "string") {
|
|
632
|
-
|
|
665
|
+
send({
|
|
633
666
|
type: "data",
|
|
634
667
|
id,
|
|
635
668
|
version,
|
|
@@ -637,7 +670,7 @@ function createFrameSink(write, frame, have, hooks) {
|
|
|
637
670
|
});
|
|
638
671
|
scheduleSweep();
|
|
639
672
|
} else {
|
|
640
|
-
|
|
673
|
+
send({
|
|
641
674
|
type: "data",
|
|
642
675
|
id,
|
|
643
676
|
version,
|
|
@@ -654,73 +687,40 @@ function createFrameSink(write, frame, have, hooks) {
|
|
|
654
687
|
skipped.add(key);
|
|
655
688
|
scheduleSweep();
|
|
656
689
|
if (meta.error) {
|
|
657
|
-
|
|
658
|
-
|
|
659
|
-
id: fid,
|
|
660
|
-
version,
|
|
661
|
-
key,
|
|
662
|
-
error: {
|
|
663
|
-
message: String(meta.error && meta.error.message || meta.error)
|
|
664
|
-
}
|
|
690
|
+
putError(fid, key, {
|
|
691
|
+
message: String(meta.error && meta.error.message || meta.error)
|
|
665
692
|
});
|
|
666
693
|
} else emitDiffering(value);
|
|
667
694
|
return;
|
|
668
695
|
}
|
|
669
696
|
const links = meta.styles && meta.styles.links || [];
|
|
670
697
|
const inline = meta.styles && meta.styles.inline || [];
|
|
698
|
+
const r = {};
|
|
671
699
|
if (links.length || inline.length) {
|
|
672
|
-
|
|
673
|
-
const chunk = {
|
|
674
|
-
type: "assets",
|
|
675
|
-
id: fid,
|
|
676
|
-
version,
|
|
677
|
-
key
|
|
678
|
-
};
|
|
700
|
+
const record = {};
|
|
679
701
|
if (links.length) {
|
|
680
|
-
|
|
702
|
+
record.styles = links.map(e => typeof e === "string" ? e : e.attrs ? {
|
|
681
703
|
href: e.href,
|
|
682
704
|
attrs: e.attrs
|
|
683
705
|
} : e.href);
|
|
684
706
|
}
|
|
685
707
|
if (inline.length) {
|
|
686
|
-
|
|
708
|
+
record.inlineStyles = inline.map(e => ({
|
|
687
709
|
id: e.id,
|
|
688
710
|
content: e.content,
|
|
689
711
|
attrs: e.attrs
|
|
690
712
|
}));
|
|
691
713
|
}
|
|
692
714
|
needs("assets");
|
|
693
|
-
|
|
715
|
+
r[`seg:${key}:assets`] = record;
|
|
694
716
|
}
|
|
695
|
-
|
|
696
|
-
type: "fragment",
|
|
697
|
-
id: fid,
|
|
698
|
-
version,
|
|
699
|
-
key,
|
|
700
|
-
html: value,
|
|
701
|
-
digest: textDigest(value)
|
|
702
|
-
}, holeDigests(value, attrText)));
|
|
717
|
+
r[`seg:${key}`] = html(value, textDigest(value), holeDigests(value, attrText));
|
|
703
718
|
scheduleSweep();
|
|
704
|
-
if (meta.error) {
|
|
705
|
-
|
|
706
|
-
|
|
707
|
-
|
|
708
|
-
|
|
709
|
-
key,
|
|
710
|
-
error: {
|
|
711
|
-
message: String(meta.error && meta.error.message || meta.error)
|
|
712
|
-
}
|
|
713
|
-
});
|
|
714
|
-
}
|
|
715
|
-
if (!meta.revealGroup) {
|
|
716
|
-
emit({
|
|
717
|
-
type: "reveal",
|
|
718
|
-
id: fid,
|
|
719
|
-
version,
|
|
720
|
-
keys: [key],
|
|
721
|
-
waitForStyles: !!links.length
|
|
722
|
-
});
|
|
723
|
-
}
|
|
719
|
+
if (meta.error) r[`seg:${key}:error`] = {
|
|
720
|
+
message: String(meta.error && meta.error.message || meta.error)
|
|
721
|
+
};
|
|
722
|
+
if (!meta.revealGroup) r[`seg:${key}:reveal`] = true;
|
|
723
|
+
put(fid, r);
|
|
724
724
|
},
|
|
725
725
|
reveal(keys, meta = {}) {
|
|
726
726
|
const byFrame = new Map();
|
|
@@ -731,38 +731,27 @@ function createFrameSink(write, frame, have, hooks) {
|
|
|
731
731
|
if (!group) byFrame.set(fid, group = []);
|
|
732
732
|
group.push(key);
|
|
733
733
|
}
|
|
734
|
+
const gate = meta.fallback ? "fallback" : "reveal";
|
|
734
735
|
for (const [fid, groupKeys] of byFrame) {
|
|
735
|
-
|
|
736
|
-
for (const key of groupKeys)
|
|
737
|
-
|
|
738
|
-
type: "reveal",
|
|
739
|
-
id: fid,
|
|
740
|
-
version,
|
|
741
|
-
keys: groupKeys,
|
|
742
|
-
waitForStyles
|
|
743
|
-
};
|
|
744
|
-
if (meta.fallback) chunk.fallback = true;
|
|
745
|
-
emit(chunk);
|
|
736
|
+
const r = {};
|
|
737
|
+
for (const key of groupKeys) r[`seg:${key}:${gate}`] = true;
|
|
738
|
+
put(fid, r);
|
|
746
739
|
}
|
|
747
740
|
},
|
|
748
741
|
asset(type, value) {
|
|
749
742
|
if (type === "module") {
|
|
750
743
|
needs("assets");
|
|
751
|
-
|
|
752
|
-
|
|
753
|
-
|
|
754
|
-
|
|
755
|
-
key: "",
|
|
756
|
-
modules: [value]
|
|
744
|
+
put(id, {
|
|
745
|
+
"seg::assets": {
|
|
746
|
+
modules: [value]
|
|
747
|
+
}
|
|
757
748
|
});
|
|
758
749
|
} else if (type === "preload") {
|
|
759
750
|
needs("assets");
|
|
760
|
-
|
|
761
|
-
|
|
762
|
-
|
|
763
|
-
|
|
764
|
-
key: "",
|
|
765
|
-
preloads: [wirePreload(value)]
|
|
751
|
+
put(id, {
|
|
752
|
+
"seg::assets": {
|
|
753
|
+
preloads: [wirePreload(value)]
|
|
754
|
+
}
|
|
766
755
|
});
|
|
767
756
|
}
|
|
768
757
|
},
|
|
@@ -770,64 +759,69 @@ function createFrameSink(write, frame, have, hooks) {
|
|
|
770
759
|
if (closed) return;
|
|
771
760
|
if (bindings.size && !swept) sweep();
|
|
772
761
|
closed = true;
|
|
773
|
-
|
|
774
|
-
|
|
775
|
-
|
|
776
|
-
|
|
777
|
-
|
|
778
|
-
|
|
779
|
-
|
|
762
|
+
put(id, bound ? {
|
|
763
|
+
":complete": true,
|
|
764
|
+
":bound": bound
|
|
765
|
+
} : {
|
|
766
|
+
":complete": true
|
|
767
|
+
});
|
|
768
|
+
flush();
|
|
780
769
|
},
|
|
781
770
|
error(errorId, error) {
|
|
782
|
-
|
|
783
|
-
type: "error",
|
|
784
|
-
id,
|
|
785
|
-
version,
|
|
786
|
-
key: errorId,
|
|
787
|
-
error
|
|
788
|
-
});
|
|
771
|
+
putError(id, errorId, error);
|
|
789
772
|
},
|
|
773
|
+
flush,
|
|
790
774
|
slot(key, args) {
|
|
791
|
-
|
|
792
|
-
|
|
793
|
-
|
|
794
|
-
|
|
795
|
-
|
|
796
|
-
args
|
|
775
|
+
put(id, {
|
|
776
|
+
[`slot:${key}`]: {
|
|
777
|
+
kind: "slot",
|
|
778
|
+
args
|
|
779
|
+
}
|
|
797
780
|
});
|
|
798
781
|
},
|
|
799
|
-
region(childId,
|
|
782
|
+
region(childId, value) {
|
|
800
783
|
needs("regions");
|
|
801
|
-
|
|
802
|
-
|
|
803
|
-
|
|
804
|
-
|
|
805
|
-
|
|
784
|
+
put(childId, {
|
|
785
|
+
"": {
|
|
786
|
+
kind: "html",
|
|
787
|
+
value
|
|
788
|
+
}
|
|
806
789
|
});
|
|
807
790
|
},
|
|
808
|
-
hole(key,
|
|
809
|
-
const
|
|
810
|
-
|
|
811
|
-
|
|
812
|
-
|
|
813
|
-
|
|
791
|
+
hole(key, source, rows) {
|
|
792
|
+
const record = {
|
|
793
|
+
kind: "html",
|
|
794
|
+
digest: textDigest(source)
|
|
795
|
+
};
|
|
796
|
+
const base = holeDigest.get(key);
|
|
797
|
+
if (rows && base && hooks && hooks.live) {
|
|
798
|
+
record.rows = rows;
|
|
799
|
+
record.base = base;
|
|
800
|
+
} else record.value = source;
|
|
801
|
+
withHoles(record, holeDigests(record.rows ? rows.r.map(r => r[1]).join("") : source, null));
|
|
802
|
+
const r = {
|
|
803
|
+
["hole:" + key]: record
|
|
814
804
|
};
|
|
815
|
-
|
|
805
|
+
showing(r);
|
|
806
|
+
swept ? Object.assign(swept.r, r) : put(id, r);
|
|
816
807
|
},
|
|
817
808
|
attr(key, attrs, removed) {
|
|
818
|
-
const
|
|
819
|
-
|
|
820
|
-
|
|
821
|
-
attrs,
|
|
809
|
+
const record = {
|
|
810
|
+
kind: "attrs",
|
|
811
|
+
value: attrs,
|
|
822
812
|
digest: textDigest(attrs)
|
|
823
813
|
};
|
|
824
|
-
if (removed && removed.length)
|
|
825
|
-
|
|
814
|
+
if (removed && removed.length) record.removed = removed;
|
|
815
|
+
const r = {
|
|
816
|
+
["attr:" + key]: record
|
|
817
|
+
};
|
|
818
|
+
swept ? Object.assign(swept.r, r) : put(id, r);
|
|
826
819
|
},
|
|
827
820
|
attrBaseline(key, text) {
|
|
828
821
|
attrText.set(key, text);
|
|
829
822
|
},
|
|
830
823
|
openBinding(key, b) {
|
|
824
|
+
if (/^lha?:/.test(key)) needs("wire");
|
|
831
825
|
bindings.set(key, b);
|
|
832
826
|
},
|
|
833
827
|
closeBinding(key) {
|
|
@@ -860,8 +854,9 @@ function renderServerComponent(component, options = {}) {
|
|
|
860
854
|
if (ctx) {
|
|
861
855
|
ctx.commit = sink.commit;
|
|
862
856
|
ctx.commitEpoch = () => sink.epoch;
|
|
863
|
-
|
|
864
|
-
ctx.
|
|
857
|
+
let unsettled = !!options.live;
|
|
858
|
+
if (!unsettled) ctx.unsettled = () => void (unsettled = true);
|
|
859
|
+
ctx.liveHoles = createLiveHoles(sink, false, () => !unsettled, ctx._errorScope);
|
|
865
860
|
}
|
|
866
861
|
return serverComponentScope(() => component(props));
|
|
867
862
|
};
|
|
@@ -894,6 +889,7 @@ function frameStream(makeCode, options) {
|
|
|
894
889
|
function finish() {
|
|
895
890
|
if (ended) return;
|
|
896
891
|
ended = true;
|
|
892
|
+
sink.flush();
|
|
897
893
|
if (timer) clearTimeout(timer);
|
|
898
894
|
if (upstream) upstream.removeEventListener("abort", onSignal);
|
|
899
895
|
w.end && w.end();
|
|
@@ -914,19 +910,20 @@ function frameStream(makeCode, options) {
|
|
|
914
910
|
finish();
|
|
915
911
|
render.abort(upstream.reason);
|
|
916
912
|
}
|
|
917
|
-
const emit =
|
|
918
|
-
if (observation) observation.chunk(
|
|
919
|
-
w.write(
|
|
920
|
-
if (bounded && !flushed &&
|
|
913
|
+
const emit = message => {
|
|
914
|
+
if (observation) observation.chunk(message);
|
|
915
|
+
w.write(message);
|
|
916
|
+
if (bounded && !flushed && message.id === id && message.r && "" in message.r) {
|
|
921
917
|
flushed = true;
|
|
922
918
|
if (maxDurationMs > 0 && maxDurationMs !== Infinity) timer = setTimeout(() => cut("time"), maxDurationMs);
|
|
923
919
|
}
|
|
924
920
|
};
|
|
925
|
-
const sink = createFrameSink(emit, frame, options.resume && options.resume.have,
|
|
926
|
-
|
|
921
|
+
const sink = createFrameSink(emit, frame, options.resume && options.resume.have, {
|
|
922
|
+
live: options.live,
|
|
923
|
+
onYield: bounded ? () => {
|
|
927
924
|
if (flushed && maxYields > 0 && ++yields >= maxYields) cut("yields");
|
|
928
|
-
}
|
|
929
|
-
}
|
|
925
|
+
} : undefined
|
|
926
|
+
});
|
|
930
927
|
if (options.live) sink.needs("wire");
|
|
931
928
|
w.write({
|
|
932
929
|
type: "start",
|
|
@@ -961,6 +958,7 @@ function frameStream(makeCode, options) {
|
|
|
961
958
|
finish();
|
|
962
959
|
}
|
|
963
960
|
if (w[ANNOUNCE]) w[ANNOUNCE](sink.announce());
|
|
961
|
+
sink.flush();
|
|
964
962
|
}
|
|
965
963
|
return {
|
|
966
964
|
pipe: stream,
|
|
@@ -982,56 +980,21 @@ function frameStream(makeCode, options) {
|
|
|
982
980
|
function slotRange(occurrence) {
|
|
983
981
|
return {
|
|
984
982
|
t: `<!--slot:${occurrence}:start--><!--slot:${occurrence}:end-->`,
|
|
985
|
-
$slot: true
|
|
986
|
-
$occurrence: occurrence
|
|
983
|
+
$slot: true
|
|
987
984
|
};
|
|
988
985
|
}
|
|
989
|
-
|
|
990
|
-
|
|
991
|
-
function isRangeKey(key) {
|
|
992
|
-
const c = key.charCodeAt(0);
|
|
993
|
-
return c === 36 || c >= 48 && c <= 57 || RANGE_KEYS.has(key);
|
|
994
|
-
}
|
|
995
|
-
function slotProxy(range, occurrence, face, content, onData, needs) {
|
|
996
|
-
return new Proxy(range, {
|
|
997
|
-
get(target, key, receiver) {
|
|
998
|
-
if (typeof key !== "string" || isRangeKey(key)) return Reflect.get(target, key, receiver);
|
|
999
|
-
if (onData) onData = void onData();
|
|
1000
|
-
if (face !== SLOT_FACE_MARKUP) needs("bind");
|
|
1001
|
-
return slotValue(occurrence, key, content ? content[key] : undefined, face);
|
|
1002
|
-
}
|
|
1003
|
-
});
|
|
986
|
+
function argBorderForm(value, needs) {
|
|
987
|
+
return toBorderForm(noteTraces(value, needs));
|
|
1004
988
|
}
|
|
1005
|
-
function
|
|
1006
|
-
return
|
|
1007
|
-
}
|
|
1008
|
-
function withoutStandIns(value, key, occurrence, needs) {
|
|
1009
|
-
return rewriteTree(value, (v, path) => {
|
|
989
|
+
function noteTraces(value, needs) {
|
|
990
|
+
return rewriteTree(value, v => {
|
|
1010
991
|
if (isContainerTraced(v)) {
|
|
1011
992
|
needs("trace");
|
|
1012
993
|
return v;
|
|
1013
994
|
}
|
|
1014
|
-
if (Object.getPrototypeOf(v) === Object.prototype && isSlotValue(v)) {
|
|
1015
|
-
return undefined;
|
|
1016
|
-
}
|
|
1017
995
|
return DESCEND;
|
|
1018
996
|
}, true);
|
|
1019
997
|
}
|
|
1020
|
-
function slotFace(range, content) {
|
|
1021
|
-
if (content == null) return SLOT_FACE_DATA;
|
|
1022
|
-
if (typeof content !== "object" || Array.isArray(content)) return SLOT_FACE_MARKUP;
|
|
1023
|
-
if (isServerContent(content)) {
|
|
1024
|
-
let data = false;
|
|
1025
|
-
for (const key in content) {
|
|
1026
|
-
if (!NODE_KEYS.has(key)) {
|
|
1027
|
-
data = true;
|
|
1028
|
-
break;
|
|
1029
|
-
}
|
|
1030
|
-
}
|
|
1031
|
-
if (!data) return SLOT_FACE_MARKUP;
|
|
1032
|
-
}
|
|
1033
|
-
return SLOT_FACE_DATA;
|
|
1034
|
-
}
|
|
1035
998
|
const OCCURRENCE_UNSAFE = /[^A-Za-z0-9_.-]/g;
|
|
1036
999
|
function encodeOccurrenceKey(key) {
|
|
1037
1000
|
return String(key).replace(OCCURRENCE_UNSAFE, c => {
|
|
@@ -1086,12 +1049,19 @@ function structuralArgsKey(raw) {
|
|
|
1086
1049
|
};
|
|
1087
1050
|
return walk(raw, true) ? out : undefined;
|
|
1088
1051
|
}
|
|
1089
|
-
function
|
|
1090
|
-
const
|
|
1091
|
-
if (
|
|
1092
|
-
|
|
1093
|
-
|
|
1052
|
+
function argDigest(value) {
|
|
1053
|
+
const t = typeof value;
|
|
1054
|
+
if (value == null || t !== "object" && t !== "function" && value === value) return value;
|
|
1055
|
+
if (isContainerTraced(value)) return value;
|
|
1056
|
+
try {
|
|
1057
|
+
const key = structuralArgsKey([value]);
|
|
1058
|
+
return key === undefined ? value : key;
|
|
1059
|
+
} catch (_) {
|
|
1060
|
+
return value;
|
|
1061
|
+
}
|
|
1094
1062
|
}
|
|
1063
|
+
const PENDING_ARG = {};
|
|
1064
|
+
const noDigest = () => NaN;
|
|
1095
1065
|
function isAsyncValue(v) {
|
|
1096
1066
|
return !!v && typeof v === "object" && (typeof v.then === "function" || typeof v[Symbol.asyncIterator] === "function");
|
|
1097
1067
|
}
|
|
@@ -1107,6 +1077,37 @@ function tapFirstYield(iterable) {
|
|
|
1107
1077
|
rest
|
|
1108
1078
|
};
|
|
1109
1079
|
}
|
|
1080
|
+
function packOccurrences(occs) {
|
|
1081
|
+
const out = [];
|
|
1082
|
+
let prop = "",
|
|
1083
|
+
a = -1,
|
|
1084
|
+
b = -1;
|
|
1085
|
+
const flush = () => a >= 0 && out.push(prop + "#" + (a === b ? a : a + "-" + b));
|
|
1086
|
+
for (const o of occs) {
|
|
1087
|
+
const m = /^(.*)#(\d+)$/.exec(o);
|
|
1088
|
+
if (m && m[1] === prop && +m[2] === b + 1 && a >= 0) {
|
|
1089
|
+
b++;
|
|
1090
|
+
continue;
|
|
1091
|
+
}
|
|
1092
|
+
flush();
|
|
1093
|
+
a = b = -1;
|
|
1094
|
+
if (m) {
|
|
1095
|
+
prop = m[1];
|
|
1096
|
+
a = b = +m[2];
|
|
1097
|
+
} else out.push(o);
|
|
1098
|
+
}
|
|
1099
|
+
flush();
|
|
1100
|
+
return out.join(" ");
|
|
1101
|
+
}
|
|
1102
|
+
function hasAsyncHoles(node, depth = 0) {
|
|
1103
|
+
if (!node || typeof node !== "object" || depth > 64) return false;
|
|
1104
|
+
if (Array.isArray(node)) {
|
|
1105
|
+
for (const n of node) if (hasAsyncHoles(n, depth + 1)) return true;
|
|
1106
|
+
return false;
|
|
1107
|
+
}
|
|
1108
|
+
if (node.h && node.h.length) return true;
|
|
1109
|
+
return false;
|
|
1110
|
+
}
|
|
1110
1111
|
function suppressedFill(render) {
|
|
1111
1112
|
const live = sharedConfig.context && sharedConfig.context.liveHoles;
|
|
1112
1113
|
if (!live) return render();
|
|
@@ -1117,25 +1118,96 @@ function suppressedFill(render) {
|
|
|
1117
1118
|
live.suppressed--;
|
|
1118
1119
|
}
|
|
1119
1120
|
}
|
|
1121
|
+
let parked = null;
|
|
1122
|
+
let parkedIds = 0;
|
|
1123
|
+
const PARKED = /<!--sc-n:(\d+)-->/;
|
|
1124
|
+
function park(render) {
|
|
1125
|
+
if (!parked) return render();
|
|
1126
|
+
const id = ++parkedIds;
|
|
1127
|
+
parked.set(id, {
|
|
1128
|
+
render,
|
|
1129
|
+
out: undefined
|
|
1130
|
+
});
|
|
1131
|
+
return {
|
|
1132
|
+
t: `<!--sc-n:${id}-->`
|
|
1133
|
+
};
|
|
1134
|
+
}
|
|
1135
|
+
const runParked = (entry, owner) => entry.out || (entry.out = entry.render(owner));
|
|
1136
|
+
function placeParked(node, nested, owner) {
|
|
1137
|
+
const out = expandParked(node, nested, owner);
|
|
1138
|
+
for (const entry of nested.values()) runParked(entry, owner);
|
|
1139
|
+
return out;
|
|
1140
|
+
}
|
|
1141
|
+
function expandParked(node, nested, owner) {
|
|
1142
|
+
if (Array.isArray(node)) {
|
|
1143
|
+
const out = node.map(n => expandParked(n, nested, owner));
|
|
1144
|
+
out.$slot = node.$slot;
|
|
1145
|
+
return out;
|
|
1146
|
+
}
|
|
1147
|
+
if (!node || node.t === undefined) return node;
|
|
1148
|
+
if (!node.h) return splitParked(node.t, nested, owner) || node;
|
|
1149
|
+
const out = [];
|
|
1150
|
+
node.t.forEach((t, i) => {
|
|
1151
|
+
out.push(splitParked(t, nested, owner) || {
|
|
1152
|
+
t
|
|
1153
|
+
});
|
|
1154
|
+
if (i < node.h.length) out.push({
|
|
1155
|
+
t: ["", ""],
|
|
1156
|
+
h: [node.h[i]],
|
|
1157
|
+
p: [node.p[i]]
|
|
1158
|
+
});
|
|
1159
|
+
});
|
|
1160
|
+
return out;
|
|
1161
|
+
}
|
|
1162
|
+
function splitParked(t, nested, owner) {
|
|
1163
|
+
const parts = typeof t === "string" ? t.split(PARKED) : [t];
|
|
1164
|
+
return parts.length > 1 ? parts.map((part, i) => i & 1 ? runParked(nested.get(+part), owner) : {
|
|
1165
|
+
t: part
|
|
1166
|
+
}) : undefined;
|
|
1167
|
+
}
|
|
1120
1168
|
function createDocumentSlotProps(clientProps, frameId) {
|
|
1121
1169
|
const counts = Object.create(null);
|
|
1170
|
+
let depsBatch = null;
|
|
1171
|
+
let depsN = 0;
|
|
1172
|
+
let wideSent = 0;
|
|
1173
|
+
const depsContext = sharedConfig.context;
|
|
1174
|
+
const noteDeps = (occurrence, reads, untracked) => {
|
|
1175
|
+
if (!depsContext || !depsContext.serialize || !depsContext.edges) return;
|
|
1176
|
+
const own = `sc-${frameId}-${occurrence}-`;
|
|
1177
|
+
const batch = () => {
|
|
1178
|
+
if (depsBatch) return depsBatch;
|
|
1179
|
+
queueMicrotask(() => {
|
|
1180
|
+
const b = {};
|
|
1181
|
+
for (const sid in depsBatch) b[sid] = packOccurrences(depsBatch[sid]);
|
|
1182
|
+
depsBatch = null;
|
|
1183
|
+
const wide = depsContext.edgeWide?.s || null;
|
|
1184
|
+
if (wide && wide.size > wideSent) {
|
|
1185
|
+
b["*"] = [...wide].slice(wideSent).join(" ");
|
|
1186
|
+
wideSent = wide.size;
|
|
1187
|
+
}
|
|
1188
|
+
if (depsN === 0 || Object.keys(b).length) depsContext.serialize(`sc:deps:${frameId}:${depsN++}`, b);
|
|
1189
|
+
});
|
|
1190
|
+
return depsBatch = Object.create(null);
|
|
1191
|
+
};
|
|
1192
|
+
const b = batch();
|
|
1193
|
+
if (reads) for (const sid of reads) if (!sid.startsWith(own)) (b[sid] ||= []).push(occurrence);
|
|
1194
|
+
if (untracked) (b["!"] ||= []).push(occurrence);
|
|
1195
|
+
};
|
|
1122
1196
|
const getters = new Map();
|
|
1123
1197
|
const repeats = new Map();
|
|
1124
|
-
const range = (occurrence, content) => {
|
|
1198
|
+
const range = (occurrence, content, tail) => {
|
|
1125
1199
|
const r = [{
|
|
1126
1200
|
t: `<!--slot:${occurrence}:start-->`
|
|
1127
|
-
}, content, {
|
|
1201
|
+
}, content, tail, {
|
|
1128
1202
|
t: `<!--slot:${occurrence}:end-->`
|
|
1129
1203
|
}];
|
|
1130
1204
|
r.$slot = true;
|
|
1131
|
-
r
|
|
1132
|
-
const face = slotFace(r, content);
|
|
1133
|
-
r.$face = face;
|
|
1134
|
-
return slotProxy(r, occurrence, face, face === SLOT_FACE_DATA ? content : undefined, undefined, documentNeeds);
|
|
1205
|
+
return r;
|
|
1135
1206
|
};
|
|
1136
1207
|
const zoneOwner = getOwner ? getOwner() : null;
|
|
1137
|
-
const scoped = (occurrence, render) => {
|
|
1208
|
+
const scoped = (occurrence, render, owner) => {
|
|
1138
1209
|
const id = `sc-${frameId}-${occurrence}-`;
|
|
1210
|
+
if (owner) return runWithOwner(owner, () => runWithHydrationScope(id, render));
|
|
1139
1211
|
const run = () => Hydration ? Hydration({
|
|
1140
1212
|
id,
|
|
1141
1213
|
get children() {
|
|
@@ -1155,18 +1227,13 @@ function createDocumentSlotProps(clientProps, frameId) {
|
|
|
1155
1227
|
if (!fn) {
|
|
1156
1228
|
fn = (...callArgs) => {
|
|
1157
1229
|
if (callArgs.length === 0 || callArgs[0] === undefined) {
|
|
1158
|
-
|
|
1159
|
-
const repeat = repeats.get(rk);
|
|
1160
|
-
if (repeat) return repeat;
|
|
1161
|
-
const out = suppressedFill(() => scoped(prop, () => {
|
|
1230
|
+
return park(owner => suppressedFill(() => scoped(prop, () => {
|
|
1162
1231
|
const value = clientProps[prop];
|
|
1163
1232
|
return range(prop, typeof value === "function" ? value() : value);
|
|
1164
|
-
}));
|
|
1165
|
-
if (out.$face === SLOT_FACE_DATA) repeats.set(rk, out);
|
|
1166
|
-
return out;
|
|
1233
|
+
}, owner)));
|
|
1167
1234
|
}
|
|
1168
1235
|
const raw = callArgs[0];
|
|
1169
|
-
const rk =
|
|
1236
|
+
const rk = keyedId(prop, raw);
|
|
1170
1237
|
const repeat = rk !== undefined && repeats.get(rk);
|
|
1171
1238
|
if (repeat) return repeat;
|
|
1172
1239
|
const occurrence = occurrenceId(prop, raw, counts);
|
|
@@ -1174,10 +1241,10 @@ function createDocumentSlotProps(clientProps, frameId) {
|
|
|
1174
1241
|
if (typeof slot !== "function") return range(occurrence, undefined);
|
|
1175
1242
|
const context = sharedConfig.context;
|
|
1176
1243
|
const recordKey = `sc:slot:${frameId}:${occurrence}`;
|
|
1244
|
+
const deferred = !!parked;
|
|
1177
1245
|
let settleRecord;
|
|
1178
|
-
|
|
1179
|
-
|
|
1180
|
-
}
|
|
1246
|
+
const declare = () => context && context.async && context.serialize(recordKey, new Promise(resolve => settleRecord = resolve));
|
|
1247
|
+
deferred || declare();
|
|
1181
1248
|
try {
|
|
1182
1249
|
const resolved = {};
|
|
1183
1250
|
const liveArgs = sharedConfig.context && sharedConfig.context.live && sharedConfig.context.live.args;
|
|
@@ -1185,6 +1252,7 @@ function createDocumentSlotProps(clientProps, frameId) {
|
|
|
1185
1252
|
const evals = {};
|
|
1186
1253
|
const states = {};
|
|
1187
1254
|
const minted = {};
|
|
1255
|
+
const nestedOf = {};
|
|
1188
1256
|
for (const key of Object.keys(raw)) {
|
|
1189
1257
|
if (key === "$key") continue;
|
|
1190
1258
|
const desc = Object.getOwnPropertyDescriptor(raw, key);
|
|
@@ -1203,6 +1271,8 @@ function createDocumentSlotProps(clientProps, frameId) {
|
|
|
1203
1271
|
if (evaluate) {
|
|
1204
1272
|
evals[key] = evaluate;
|
|
1205
1273
|
const stampBefore = scopeStamp();
|
|
1274
|
+
const outer = parked;
|
|
1275
|
+
const nested = nestedOf[key] = parked = new Map();
|
|
1206
1276
|
try {
|
|
1207
1277
|
value = evaluate();
|
|
1208
1278
|
states[key] = {
|
|
@@ -1210,6 +1280,9 @@ function createDocumentSlotProps(clientProps, frameId) {
|
|
|
1210
1280
|
last: value
|
|
1211
1281
|
};
|
|
1212
1282
|
} catch (err) {
|
|
1283
|
+
parked = outer;
|
|
1284
|
+
for (const entry of nested.values()) runParked(entry);
|
|
1285
|
+
nested.clear();
|
|
1213
1286
|
const blocked = ssrHandleError && ssrHandleError(err);
|
|
1214
1287
|
if (!blocked) throw err;
|
|
1215
1288
|
const state = states[key] = {
|
|
@@ -1222,6 +1295,7 @@ function createDocumentSlotProps(clientProps, frameId) {
|
|
|
1222
1295
|
if (liveArgs) liveArgs.commit();
|
|
1223
1296
|
});
|
|
1224
1297
|
}
|
|
1298
|
+
parked = outer;
|
|
1225
1299
|
if (scopeStamp() !== stampBefore) minted[key] = true;
|
|
1226
1300
|
}
|
|
1227
1301
|
vals[key] = value;
|
|
@@ -1238,6 +1312,7 @@ function createDocumentSlotProps(clientProps, frameId) {
|
|
|
1238
1312
|
key,
|
|
1239
1313
|
childId,
|
|
1240
1314
|
value,
|
|
1315
|
+
nested: nestedOf[key],
|
|
1241
1316
|
used: false,
|
|
1242
1317
|
locked: false
|
|
1243
1318
|
};
|
|
@@ -1248,7 +1323,7 @@ function createDocumentSlotProps(clientProps, frameId) {
|
|
|
1248
1323
|
region.used = true;
|
|
1249
1324
|
return [{
|
|
1250
1325
|
t: frameElementOpen(childId)
|
|
1251
|
-
}, value, {
|
|
1326
|
+
}, region.nested && region.nested.size ? placeParked(value, region.nested, getOwner()) : value, {
|
|
1252
1327
|
t: FRAME_ELEMENT_CLOSE
|
|
1253
1328
|
}];
|
|
1254
1329
|
};
|
|
@@ -1269,49 +1344,67 @@ function createDocumentSlotProps(clientProps, frameId) {
|
|
|
1269
1344
|
configurable: true
|
|
1270
1345
|
});
|
|
1271
1346
|
} else {
|
|
1272
|
-
resolved[key] = vals[key] =
|
|
1347
|
+
resolved[key] = vals[key] = noteTraces(value, documentNeeds);
|
|
1273
1348
|
}
|
|
1274
1349
|
}
|
|
1275
|
-
const
|
|
1276
|
-
const
|
|
1277
|
-
|
|
1278
|
-
|
|
1279
|
-
for (const
|
|
1280
|
-
|
|
1281
|
-
const region = regions.find(r => r.key === key);
|
|
1282
|
-
if (region) {
|
|
1283
|
-
args[key] = {
|
|
1284
|
-
$frame: region.childId
|
|
1285
|
-
};
|
|
1286
|
-
continue;
|
|
1287
|
-
}
|
|
1288
|
-
if (!isContainerTraced(value) && isServerContent(value)) continue;
|
|
1289
|
-
args[key] = argBorderForm(value, key, occurrence, documentNeeds);
|
|
1290
|
-
}
|
|
1291
|
-
settleRecord ? settleRecord({
|
|
1292
|
-
...args
|
|
1293
|
-
}) : context.serialize(recordKey, {
|
|
1294
|
-
...args
|
|
1295
|
-
});
|
|
1296
|
-
for (const region of unused) {
|
|
1350
|
+
for (const key in nestedOf) if (!regions.some(r => r.key === key)) for (const entry of nestedOf[key].values()) runParked(entry);
|
|
1351
|
+
const flip = () => {
|
|
1352
|
+
if (flip.done || !context) return;
|
|
1353
|
+
flip.done = true;
|
|
1354
|
+
for (const region of regions) {
|
|
1355
|
+
if (region.used) continue;
|
|
1297
1356
|
region.locked = true;
|
|
1298
|
-
context.serialize(`sc:region:${region.childId}`, resolveRegionHtml(context, region.value));
|
|
1357
|
+
context.serialize(`sc:region:${region.childId}`, resolveRegionHtml(context, region.nested && region.nested.size ? placeParked(region.value, region.nested) : region.value));
|
|
1299
1358
|
}
|
|
1300
|
-
|
|
1301
|
-
|
|
1302
|
-
|
|
1303
|
-
|
|
1304
|
-
|
|
1305
|
-
|
|
1306
|
-
|
|
1307
|
-
|
|
1308
|
-
|
|
1309
|
-
|
|
1359
|
+
};
|
|
1360
|
+
flip.$lhSkip = true;
|
|
1361
|
+
const finish = owner => {
|
|
1362
|
+
if (deferred) declare();
|
|
1363
|
+
try {
|
|
1364
|
+
const tracked = trackFillReads(() => suppressedFill(() => scoped(occurrence, () => range(occurrence, slot(resolved), flip), owner)));
|
|
1365
|
+
const out = tracked.result;
|
|
1366
|
+
noteDeps(occurrence, tracked.reads, tracked.untracked || hasAsyncHoles(out));
|
|
1367
|
+
if (context) {
|
|
1368
|
+
const args = {};
|
|
1369
|
+
for (const key of Object.keys(vals)) {
|
|
1370
|
+
const value = vals[key];
|
|
1371
|
+
const region = regions.find(r => r.key === key);
|
|
1372
|
+
if (region) {
|
|
1373
|
+
args[key] = {
|
|
1374
|
+
$frame: region.childId
|
|
1375
|
+
};
|
|
1376
|
+
continue;
|
|
1377
|
+
}
|
|
1378
|
+
if (!isContainerTraced(value) && isServerContent(value)) continue;
|
|
1379
|
+
args[key] = argBorderForm(value, documentNeeds);
|
|
1380
|
+
}
|
|
1381
|
+
settleRecord ? settleRecord({
|
|
1382
|
+
...args
|
|
1383
|
+
}) : context.serialize(recordKey, {
|
|
1384
|
+
...args
|
|
1310
1385
|
});
|
|
1386
|
+
if (liveArgs) {
|
|
1387
|
+
for (const key of Object.keys(evals)) {
|
|
1388
|
+
if (regions.some(r => r.key === key)) continue;
|
|
1389
|
+
if (minted[key]) continue;
|
|
1390
|
+
const ledgerKey = `${frameId}:${occurrence}:${key}`;
|
|
1391
|
+
openArgBinding(liveArgs, ledgerKey, occurrence, key, evals[key], states[key], value => {
|
|
1392
|
+
args[key] = argBorderForm(value, documentNeeds);
|
|
1393
|
+
liveArgs.slot(frameId, occurrence, {
|
|
1394
|
+
...args
|
|
1395
|
+
});
|
|
1396
|
+
});
|
|
1397
|
+
}
|
|
1398
|
+
}
|
|
1311
1399
|
}
|
|
1400
|
+
return out;
|
|
1401
|
+
} catch (error) {
|
|
1402
|
+
settleRecord && settleRecord(undefined);
|
|
1403
|
+
throw error;
|
|
1312
1404
|
}
|
|
1313
|
-
}
|
|
1314
|
-
|
|
1405
|
+
};
|
|
1406
|
+
const out = park(finish);
|
|
1407
|
+
if (rk !== undefined && rk === occurrence) repeats.has(rk) || repeats.set(rk, out);
|
|
1315
1408
|
return out;
|
|
1316
1409
|
} catch (error) {
|
|
1317
1410
|
settleRecord && settleRecord(undefined);
|
|
@@ -1327,9 +1420,10 @@ function createDocumentSlotProps(clientProps, frameId) {
|
|
|
1327
1420
|
}
|
|
1328
1421
|
const FRAME_TAG = "solid-frame";
|
|
1329
1422
|
const FRAME_ID_ATTR = "data-fid";
|
|
1330
|
-
|
|
1423
|
+
const FRAME_ARGS_ATTR = "data-fa";
|
|
1424
|
+
function frameElementOpen(id, args) {
|
|
1331
1425
|
const escaped = sharedConfig.context ? sharedConfig.context.escape(String(id), true) : String(id);
|
|
1332
|
-
return `<${FRAME_TAG} ${FRAME_ID_ATTR}="${escaped}" style="display:contents">`;
|
|
1426
|
+
return `<${FRAME_TAG} ${FRAME_ID_ATTR}="${escaped}"${args ? ` ${FRAME_ARGS_ATTR}="${args}"` : ""} style="display:contents">`;
|
|
1333
1427
|
}
|
|
1334
1428
|
const DOCUMENT_SITES = Symbol();
|
|
1335
1429
|
function contextSites(ctx) {
|
|
@@ -1381,6 +1475,7 @@ function armDocumentLiveHoles(ctx) {
|
|
|
1381
1475
|
if (live.holes) {
|
|
1382
1476
|
ctx.commit = live.commit;
|
|
1383
1477
|
ctx.commitEpoch = live.commitEpoch;
|
|
1478
|
+
ctx.unsettled = live.unsettled;
|
|
1384
1479
|
}
|
|
1385
1480
|
return;
|
|
1386
1481
|
}
|
|
@@ -1389,6 +1484,7 @@ function armDocumentLiveHoles(ctx) {
|
|
|
1389
1484
|
if (live) live.holes = null;
|
|
1390
1485
|
return;
|
|
1391
1486
|
}
|
|
1487
|
+
let unsettled = false;
|
|
1392
1488
|
const bindings = new Map();
|
|
1393
1489
|
let epoch = 0;
|
|
1394
1490
|
let sweepScheduled = false;
|
|
@@ -1396,7 +1492,7 @@ function armDocumentLiveHoles(ctx) {
|
|
|
1396
1492
|
let swept = null;
|
|
1397
1493
|
const sweep = () => {
|
|
1398
1494
|
epoch++;
|
|
1399
|
-
const
|
|
1495
|
+
const r = swept = {};
|
|
1400
1496
|
try {
|
|
1401
1497
|
for (const b of [...bindings.values()]) {
|
|
1402
1498
|
try {
|
|
@@ -1407,12 +1503,8 @@ function armDocumentLiveHoles(ctx) {
|
|
|
1407
1503
|
} finally {
|
|
1408
1504
|
swept = null;
|
|
1409
1505
|
}
|
|
1410
|
-
|
|
1411
|
-
|
|
1412
|
-
const pushOps = ops => {
|
|
1413
|
-
if (ops.length === 1) push(ops[0]);else if (ops.length) push({
|
|
1414
|
-
type: "ops",
|
|
1415
|
-
ops
|
|
1506
|
+
for (const _ in r) return push({
|
|
1507
|
+
r
|
|
1416
1508
|
});
|
|
1417
1509
|
};
|
|
1418
1510
|
const scheduleSweep = () => {
|
|
@@ -1432,49 +1524,57 @@ function armDocumentLiveHoles(ctx) {
|
|
|
1432
1524
|
closed = true;
|
|
1433
1525
|
}
|
|
1434
1526
|
}));
|
|
1435
|
-
const push =
|
|
1436
|
-
if (!closed) channel.enqueue(
|
|
1527
|
+
const push = batch => {
|
|
1528
|
+
if (!closed) channel.enqueue(batch);
|
|
1437
1529
|
};
|
|
1530
|
+
const write = r => swept ? Object.assign(swept, r) : push({
|
|
1531
|
+
r
|
|
1532
|
+
});
|
|
1438
1533
|
ctx.liveHoles = live.holes = createLiveHoles({
|
|
1439
1534
|
openBinding(key, b) {
|
|
1535
|
+
documentNeeds("wire");
|
|
1440
1536
|
bindings.set(key, b);
|
|
1441
1537
|
},
|
|
1442
1538
|
closeBinding(key) {
|
|
1443
1539
|
bindings.delete(key);
|
|
1444
1540
|
},
|
|
1445
|
-
hole(key,
|
|
1446
|
-
|
|
1447
|
-
|
|
1448
|
-
|
|
1449
|
-
|
|
1450
|
-
|
|
1451
|
-
|
|
1452
|
-
|
|
1541
|
+
hole(key, value) {
|
|
1542
|
+
write({
|
|
1543
|
+
["hole:" + key]: {
|
|
1544
|
+
kind: "html",
|
|
1545
|
+
value,
|
|
1546
|
+
digest: textDigest(value)
|
|
1547
|
+
}
|
|
1548
|
+
});
|
|
1453
1549
|
},
|
|
1454
|
-
attr(key,
|
|
1455
|
-
const
|
|
1456
|
-
|
|
1457
|
-
|
|
1458
|
-
|
|
1459
|
-
digest: textDigest(attrs)
|
|
1550
|
+
attr(key, value, removed) {
|
|
1551
|
+
const record = {
|
|
1552
|
+
kind: "attrs",
|
|
1553
|
+
value,
|
|
1554
|
+
digest: textDigest(value)
|
|
1460
1555
|
};
|
|
1461
|
-
if (removed && removed.length)
|
|
1462
|
-
|
|
1556
|
+
if (removed && removed.length) record.removed = removed;
|
|
1557
|
+
write({
|
|
1558
|
+
["attr:" + key]: record
|
|
1559
|
+
});
|
|
1463
1560
|
},
|
|
1464
1561
|
error(key, error) {
|
|
1465
1562
|
push({
|
|
1466
|
-
|
|
1467
|
-
|
|
1468
|
-
|
|
1563
|
+
r: {
|
|
1564
|
+
[`hole:${key}:error`]: error
|
|
1565
|
+
}
|
|
1469
1566
|
});
|
|
1470
1567
|
},
|
|
1471
1568
|
commit: scheduleSweep,
|
|
1472
1569
|
get epoch() {
|
|
1473
1570
|
return epoch;
|
|
1474
1571
|
}
|
|
1475
|
-
}, true);
|
|
1572
|
+
}, true, () => !unsettled, ctx._errorScope);
|
|
1476
1573
|
ctx.commit = live.commit = scheduleSweep;
|
|
1477
1574
|
ctx.commitEpoch = live.commitEpoch = () => epoch;
|
|
1575
|
+
ctx.unsettled = live.unsettled = () => {
|
|
1576
|
+
unsettled = true;
|
|
1577
|
+
};
|
|
1478
1578
|
live.args = {
|
|
1479
1579
|
openBinding(key, b) {
|
|
1480
1580
|
bindings.set(key, b);
|
|
@@ -1484,19 +1584,23 @@ function armDocumentLiveHoles(ctx) {
|
|
|
1484
1584
|
},
|
|
1485
1585
|
slot(fid, occurrence, args) {
|
|
1486
1586
|
push({
|
|
1487
|
-
|
|
1488
|
-
|
|
1489
|
-
|
|
1490
|
-
|
|
1587
|
+
r: {
|
|
1588
|
+
[`slot:${occurrence}`]: {
|
|
1589
|
+
kind: "slot",
|
|
1590
|
+
args
|
|
1591
|
+
}
|
|
1592
|
+
},
|
|
1593
|
+
fid
|
|
1491
1594
|
});
|
|
1492
1595
|
},
|
|
1493
1596
|
commit: scheduleSweep
|
|
1494
1597
|
};
|
|
1495
1598
|
live.error = (fid, error) => {
|
|
1496
1599
|
push({
|
|
1497
|
-
|
|
1498
|
-
|
|
1499
|
-
|
|
1600
|
+
r: {
|
|
1601
|
+
":error": error
|
|
1602
|
+
},
|
|
1603
|
+
fid
|
|
1500
1604
|
});
|
|
1501
1605
|
};
|
|
1502
1606
|
live.end = () => {
|
|
@@ -1513,17 +1617,17 @@ function frameTransformDirectResult(value, {
|
|
|
1513
1617
|
}) {
|
|
1514
1618
|
if (typeof value !== "function") return value;
|
|
1515
1619
|
const component = value;
|
|
1620
|
+
const address = frameAddress(id, args);
|
|
1516
1621
|
const wrapped = props => {
|
|
1517
1622
|
const siteId = documentSiteId(id);
|
|
1518
1623
|
return [{
|
|
1519
|
-
t: frameElementOpen(siteId)
|
|
1624
|
+
t: frameElementOpen(siteId, address.slice(id.length + 1))
|
|
1520
1625
|
},
|
|
1521
1626
|
serverOwned(() => {
|
|
1522
1627
|
const page = sharedConfig.context;
|
|
1523
1628
|
armDocumentLiveHoles(page);
|
|
1524
1629
|
if (tierUrls && page && page.live && !page.live.tierUrls) page.live.tierUrls = tierUrls;
|
|
1525
1630
|
const ctx = Object.create(page);
|
|
1526
|
-
ctx.claims = CLAIMS_DOCUMENT;
|
|
1527
1631
|
ctx.frameId = siteId;
|
|
1528
1632
|
sharedConfig.context = ctx;
|
|
1529
1633
|
try {
|
|
@@ -1540,7 +1644,7 @@ function frameTransformDirectResult(value, {
|
|
|
1540
1644
|
};
|
|
1541
1645
|
wrapped[SERVER_COMPONENT] = id;
|
|
1542
1646
|
wrapped[SERVER_COMPONENT_SOURCE] = component;
|
|
1543
|
-
wrapped[SERVER_COMPONENT_ADDRESS] =
|
|
1647
|
+
wrapped[SERVER_COMPONENT_ADDRESS] = address;
|
|
1544
1648
|
return wrapped;
|
|
1545
1649
|
}
|
|
1546
1650
|
function resolveRegionHtml(ctx, node) {
|
|
@@ -1643,6 +1747,15 @@ function createSlotProps(sink, frame) {
|
|
|
1643
1747
|
const counts = Object.create(null);
|
|
1644
1748
|
const getters = new Map();
|
|
1645
1749
|
const repeats = new Map();
|
|
1750
|
+
let pass = null;
|
|
1751
|
+
let passRepeats = null;
|
|
1752
|
+
const recs = new Map();
|
|
1753
|
+
const forget = occurrence => {
|
|
1754
|
+
const rec = recs.get(occurrence);
|
|
1755
|
+
if (!rec) return;
|
|
1756
|
+
recs.delete(occurrence);
|
|
1757
|
+
for (const key in rec.vals) sink.closeBinding(`${occurrence}:${key}`);
|
|
1758
|
+
};
|
|
1646
1759
|
const needs = sink.needs || (() => {});
|
|
1647
1760
|
return new Proxy(Object.create(null), {
|
|
1648
1761
|
has() {
|
|
@@ -1655,25 +1768,38 @@ function createSlotProps(sink, frame) {
|
|
|
1655
1768
|
if (!fn) {
|
|
1656
1769
|
fn = (...callArgs) => {
|
|
1657
1770
|
if (callArgs.length === 0 || callArgs[0] === undefined) {
|
|
1658
|
-
return
|
|
1771
|
+
return slotRange(prop);
|
|
1659
1772
|
}
|
|
1660
|
-
const rk = repeatKey(prop, callArgs[0]);
|
|
1661
|
-
const repeat = rk !== undefined && repeats.get(rk);
|
|
1662
|
-
if (repeat) return repeat;
|
|
1663
1773
|
const live = sharedConfig.context && sharedConfig.context.liveHoles;
|
|
1664
|
-
|
|
1665
|
-
|
|
1666
|
-
|
|
1667
|
-
|
|
1668
|
-
|
|
1669
|
-
|
|
1670
|
-
|
|
1671
|
-
|
|
1672
|
-
|
|
1774
|
+
const sweeping = !!live && live.sweeping;
|
|
1775
|
+
let rmap = repeats;
|
|
1776
|
+
if (sweeping) {
|
|
1777
|
+
if (pass !== live.visit) passRepeats = new Map();
|
|
1778
|
+
pass = live.visit;
|
|
1779
|
+
rmap = passRepeats;
|
|
1780
|
+
}
|
|
1781
|
+
const rk = keyedId(prop, callArgs[0]);
|
|
1782
|
+
const repeat = rk !== undefined && rmap.get(rk);
|
|
1783
|
+
if (repeat) return repeat;
|
|
1784
|
+
if (sweeping && !live.scope) {
|
|
1785
|
+
live.gateHit = true;
|
|
1786
|
+
return {
|
|
1787
|
+
t: "",
|
|
1788
|
+
$slot: true
|
|
1789
|
+
};
|
|
1673
1790
|
}
|
|
1674
1791
|
const raw = callArgs[0];
|
|
1675
|
-
|
|
1792
|
+
let occurrence = keyedId(prop, raw);
|
|
1793
|
+
if (occurrence === undefined) {
|
|
1794
|
+
const positional = sweeping ? undefined : occurrenceId(prop, raw, counts);
|
|
1795
|
+
occurrence = live ? live.slotId(prop, positional) : positional;
|
|
1796
|
+
}
|
|
1797
|
+
if (sweeping && live.dry) return slotRange(occurrence);
|
|
1798
|
+
const prev = recs.get(occurrence);
|
|
1799
|
+
let changed = !prev;
|
|
1800
|
+
const digest = live && live.scope ? argDigest : noDigest;
|
|
1676
1801
|
const args = {};
|
|
1802
|
+
const vals = {};
|
|
1677
1803
|
const opened = [];
|
|
1678
1804
|
for (const key of Object.keys(raw)) {
|
|
1679
1805
|
if (key === "$key") continue;
|
|
@@ -1689,6 +1815,7 @@ function createSlotProps(sink, frame) {
|
|
|
1689
1815
|
let evaluate = null;
|
|
1690
1816
|
let value;
|
|
1691
1817
|
let state = null;
|
|
1818
|
+
let pending = false;
|
|
1692
1819
|
const stampBefore = scopeStamp();
|
|
1693
1820
|
try {
|
|
1694
1821
|
if (desc.get) {
|
|
@@ -1710,6 +1837,7 @@ function createSlotProps(sink, frame) {
|
|
|
1710
1837
|
settled: false,
|
|
1711
1838
|
last: undefined
|
|
1712
1839
|
};
|
|
1840
|
+
pending = true;
|
|
1713
1841
|
const pendingState = state;
|
|
1714
1842
|
value = retryArgUntilSettled(evaluate, blocked, key, occurrence, v => {
|
|
1715
1843
|
pendingState.settled = true;
|
|
@@ -1721,6 +1849,7 @@ function createSlotProps(sink, frame) {
|
|
|
1721
1849
|
const t = typeof value;
|
|
1722
1850
|
if (value == null || t === "string" || t === "number" || t === "boolean") {
|
|
1723
1851
|
args[key] = value;
|
|
1852
|
+
vals[key] = digest(value);
|
|
1724
1853
|
if (evaluate) state = {
|
|
1725
1854
|
settled: true,
|
|
1726
1855
|
last: value
|
|
@@ -1730,21 +1859,27 @@ function createSlotProps(sink, frame) {
|
|
|
1730
1859
|
if (resolved.h.length) {
|
|
1731
1860
|
throw new Error("Async server content in a slot arg needs a boundary (arg '" + key + "' of " + occurrence + "). Wrap the async read in a <Suspense>, or move it above the slot.");
|
|
1732
1861
|
}
|
|
1733
|
-
|
|
1862
|
+
vals[key] = "<" + resolved.t[0];
|
|
1863
|
+
if (!prev || prev.vals[key] !== vals[key]) sink.region(childId, resolved.t[0]);
|
|
1734
1864
|
args[key] = {
|
|
1735
1865
|
$frame: childId
|
|
1736
1866
|
};
|
|
1737
1867
|
} else {
|
|
1738
|
-
|
|
1739
|
-
|
|
1740
|
-
|
|
1741
|
-
|
|
1742
|
-
|
|
1868
|
+
vals[key] = pending ? PENDING_ARG : digest(value);
|
|
1869
|
+
if (prev && prev.vals[key] === vals[key]) args[key] = prev.args[key];else {
|
|
1870
|
+
const ref = prev ? `arg:${occurrence}:${key}@${sink.nextArgRef(`${occurrence}:${key}`)}` : `arg:${occurrence}:${key}`;
|
|
1871
|
+
if (prev) sink.mintRef(ref);
|
|
1872
|
+
ctx.serialize(ref, argBorderForm(value, needs));
|
|
1873
|
+
args[key] = {
|
|
1874
|
+
$ref: ref
|
|
1875
|
+
};
|
|
1876
|
+
}
|
|
1743
1877
|
if (evaluate && !state) state = {
|
|
1744
1878
|
settled: true,
|
|
1745
1879
|
last: value
|
|
1746
1880
|
};
|
|
1747
1881
|
}
|
|
1882
|
+
if (prev && prev.vals[key] !== vals[key]) changed = true;
|
|
1748
1883
|
if (evaluate && state && !mintedEval) opened.push({
|
|
1749
1884
|
key,
|
|
1750
1885
|
evaluate,
|
|
@@ -1754,9 +1889,18 @@ function createSlotProps(sink, frame) {
|
|
|
1754
1889
|
ctx.registerFragment = origRegister;
|
|
1755
1890
|
}
|
|
1756
1891
|
}
|
|
1757
|
-
|
|
1758
|
-
|
|
1759
|
-
|
|
1892
|
+
if (prev) for (const key in prev.vals) if (!(key in vals)) changed = true;
|
|
1893
|
+
const rec = changed ? {
|
|
1894
|
+
args,
|
|
1895
|
+
vals
|
|
1896
|
+
} : prev;
|
|
1897
|
+
if (changed) {
|
|
1898
|
+
recs.set(occurrence, rec);
|
|
1899
|
+
sink.slot(occurrence, {
|
|
1900
|
+
...args
|
|
1901
|
+
});
|
|
1902
|
+
}
|
|
1903
|
+
if (live && live.visit) live.seen(occurrence, () => recs.get(occurrence) === rec && forget(occurrence));
|
|
1760
1904
|
const ctx = sharedConfig.context;
|
|
1761
1905
|
for (const b of opened) {
|
|
1762
1906
|
const key = b.key;
|
|
@@ -1764,23 +1908,23 @@ function createSlotProps(sink, frame) {
|
|
|
1764
1908
|
openArgBinding(sink, ledgerKey, occurrence, key, b.evaluate, b.state, value => {
|
|
1765
1909
|
const t = typeof value;
|
|
1766
1910
|
if (value == null || t === "string" || t === "number" || t === "boolean") {
|
|
1767
|
-
args[key] = value;
|
|
1911
|
+
rec.args[key] = value;
|
|
1768
1912
|
} else {
|
|
1769
1913
|
const ref = `arg:${occurrence}:${key}@${sink.nextArgRef(ledgerKey)}`;
|
|
1770
1914
|
sink.mintRef(ref);
|
|
1771
|
-
ctx.serialize(ref, argBorderForm(value,
|
|
1772
|
-
args[key] = {
|
|
1915
|
+
ctx.serialize(ref, argBorderForm(value, needs));
|
|
1916
|
+
rec.args[key] = {
|
|
1773
1917
|
$ref: ref
|
|
1774
1918
|
};
|
|
1775
1919
|
}
|
|
1920
|
+
rec.vals[key] = digest(value);
|
|
1776
1921
|
sink.slot(occurrence, {
|
|
1777
|
-
...args
|
|
1922
|
+
...rec.args
|
|
1778
1923
|
});
|
|
1779
1924
|
});
|
|
1780
1925
|
}
|
|
1781
|
-
const
|
|
1782
|
-
|
|
1783
|
-
if (keyed) repeats.set(rk, out);
|
|
1926
|
+
const out = slotRange(occurrence);
|
|
1927
|
+
if (rk !== undefined && rk === occurrence) rmap.set(rk, out);
|
|
1784
1928
|
return out;
|
|
1785
1929
|
};
|
|
1786
1930
|
fn.$lhSkip = true;
|
|
@@ -1845,11 +1989,11 @@ function serverComponentResponse(component, options = {}, init = {}) {
|
|
|
1845
1989
|
teardown.abort();
|
|
1846
1990
|
});
|
|
1847
1991
|
stream.pipe({
|
|
1848
|
-
write(
|
|
1849
|
-
if (
|
|
1992
|
+
write(message) {
|
|
1993
|
+
if (message.r && ":error" in message.r) failed = true;
|
|
1850
1994
|
if (closed) return;
|
|
1851
1995
|
try {
|
|
1852
|
-
controller.enqueue(frame(JSON.stringify(
|
|
1996
|
+
controller.enqueue(frame(JSON.stringify(message)));
|
|
1853
1997
|
} catch (_) {
|
|
1854
1998
|
closed = true;
|
|
1855
1999
|
}
|
|
@@ -2007,10 +2151,10 @@ function frameFlightResponse({
|
|
|
2007
2151
|
let closed = false;
|
|
2008
2152
|
const body = new ReadableStream({
|
|
2009
2153
|
async start(controller) {
|
|
2010
|
-
const write =
|
|
2154
|
+
const write = message => {
|
|
2011
2155
|
if (closed) return;
|
|
2012
2156
|
try {
|
|
2013
|
-
controller.enqueue(createChunk(JSON.stringify(
|
|
2157
|
+
controller.enqueue(createChunk(JSON.stringify(message)));
|
|
2014
2158
|
} catch (_) {
|
|
2015
2159
|
closed = true;
|
|
2016
2160
|
}
|