@solidjs/web 2.0.0-rc.14 → 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 +475 -591
- package/dist/server.js +459 -489
- package/dist/server.observe.js +459 -498
- package/dist/web.dev.js +206 -220
- package/dist/web.js +196 -208
- package/dist/web.observe.js +206 -213
- package/frames/dist/client.dev.js +664 -643
- package/frames/dist/client.js +593 -582
- package/frames/dist/client.observe.js +624 -589
- package/frames/dist/regions.js +43 -2
- package/frames/dist/server.dev.js +578 -450
- package/frames/dist/server.js +578 -397
- package/frames/dist/server.observe.js +578 -397
- package/frames/dist/trace.js +4 -1
- package/frames/dist/wire.js +371 -6
- package/package.json +13 -13
- package/serialization/dist/decode.js +11 -9
- package/serialization/dist/serialization.js +11 -9
- package/serialization/types/serializer-decode.d.ts +2 -2
- package/server-functions/dist/client.dev.js +5 -2
- package/server-functions/dist/client.js +3 -2
- package/server-functions/dist/client.observe.js +5 -2
- package/server-functions/dist/rich-args.js +33 -1
- package/server-functions/dist/server.dev.js +218 -35
- package/server-functions/dist/server.js +218 -35
- package/server-functions/dist/server.observe.js +218 -35
- package/skills/server-components/SKILL.md +74 -185
- package/types/client.d.ts +112 -10
- package/types/constants.d.ts +2 -1
- 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 +1 -53
- package/types/frames/wire-tier.d.ts +54 -1
- package/types/head.d.ts +1 -0
- package/types/index.d.ts +57 -50
- package/types/index.server.d.ts +3 -27
- package/types/jsx.d.ts +14 -17
- package/types/observe.d.ts +14 -7
- package/types/render.d.ts +3 -1
- package/types/response.d.ts +31 -8
- 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 +18 -5
- package/types/server-functions/server.d.ts +6 -2
- package/types/server-functions/shared.d.ts +19 -0
- package/types/server-mock.d.ts +9 -2
- package/types/server-observe.d.ts +3 -2
- package/types/server.d.ts +124 -67
- 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,9 +1,9 @@
|
|
|
1
|
-
import { sharedConfig, ssrSanitizeError, creationStamp, ssrHandleError, runInServerComponentScope, shareAsyncIterable, getProjectionTrace } from 'solid-js/internal';
|
|
2
|
-
import {
|
|
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
|
-
import {
|
|
6
|
+
import { frameAddress, getEventServerFunctionInvocation, ChunkReader, serializeStream, guardFailures, armLiveBody, createEventChunk, createChunk, textDigest } from '@solidjs/web/server-functions/server';
|
|
7
7
|
|
|
8
8
|
const DESCEND = Symbol("descend");
|
|
9
9
|
const CYCLE = {};
|
|
@@ -132,9 +132,7 @@ function toBorderForm(value, envelopeContainers) {
|
|
|
132
132
|
}
|
|
133
133
|
function isShareableIterable(value) {
|
|
134
134
|
try {
|
|
135
|
-
|
|
136
|
-
if (typeof ReadableStream !== "undefined" && value instanceof ReadableStream) return false;
|
|
137
|
-
return typeof value[Symbol.asyncIterator] === "function";
|
|
135
|
+
return typeof value[Symbol.asyncIterator] === "function" && !(typeof ReadableStream !== "undefined" && value instanceof ReadableStream);
|
|
138
136
|
} catch {
|
|
139
137
|
return false;
|
|
140
138
|
}
|
|
@@ -209,14 +207,16 @@ function resolveSerializerPlugins(customPlugins) {
|
|
|
209
207
|
}
|
|
210
208
|
const jsonCodecDisabledFeatures = () => Feature.RegExp;
|
|
211
209
|
const JSON_CODEC_DEPTH_LIMIT = 64;
|
|
212
|
-
|
|
213
|
-
|
|
214
|
-
|
|
215
|
-
|
|
216
|
-
|
|
217
|
-
|
|
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;
|
|
218
218
|
return {
|
|
219
|
-
plugins: resolveSerializerPlugins(plugins),
|
|
219
|
+
plugins: options[RESOLVED_PLUGINS] || resolveSerializerPlugins(plugins),
|
|
220
220
|
disabledFeatures: disabledFeatures === undefined ? jsonCodecDisabledFeatures() : disabledFeatures,
|
|
221
221
|
depthLimit: depthLimit === undefined ? JSON_CODEC_DEPTH_LIMIT : depthLimit,
|
|
222
222
|
serializeErrorStacks
|
|
@@ -296,8 +296,17 @@ const RECORDS = Symbol.for("@solidjs/signals/observe/records");
|
|
|
296
296
|
function records() {
|
|
297
297
|
return globalThis[RECORDS];
|
|
298
298
|
}
|
|
299
|
-
function
|
|
300
|
-
|
|
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) {
|
|
301
310
|
switch (type) {
|
|
302
311
|
case "html":
|
|
303
312
|
if (!own) event.regions++;else if (event.shellMs === undefined) event.shellMs = performance.now() - event.at;
|
|
@@ -332,9 +341,8 @@ function observeFrame(frame) {
|
|
|
332
341
|
};
|
|
333
342
|
let settled = false;
|
|
334
343
|
return {
|
|
335
|
-
chunk(
|
|
336
|
-
|
|
337
|
-
frameCensus(event, chunk.type, chunk.id === frame.id);
|
|
344
|
+
chunk(message) {
|
|
345
|
+
frameRecordCensus(event, message, message.id === frame.id);
|
|
338
346
|
},
|
|
339
347
|
settle(outcome, error) {
|
|
340
348
|
if (settled) return;
|
|
@@ -487,14 +495,41 @@ function createFrameSink(write, frame, have, hooks) {
|
|
|
487
495
|
} = frame;
|
|
488
496
|
const tiers = new Set();
|
|
489
497
|
let staged = [];
|
|
490
|
-
const
|
|
491
|
-
if (swept) swept.emitted = true;
|
|
498
|
+
const send = message => {
|
|
492
499
|
if (staged.length) {
|
|
493
|
-
|
|
500
|
+
message.tiers = staged;
|
|
494
501
|
staged = [];
|
|
495
502
|
}
|
|
496
|
-
write(
|
|
503
|
+
write(message);
|
|
497
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
|
+
}
|
|
529
|
+
};
|
|
530
|
+
const putError = (fid, key, error) => put(fid, {
|
|
531
|
+
[key ? `${/^lha?:/.test(key) ? "hole" : "seg"}:${key}:error` : ":error"]: error
|
|
532
|
+
});
|
|
498
533
|
const needs = name => {
|
|
499
534
|
if (!tiers.has(name)) {
|
|
500
535
|
tiers.add(name);
|
|
@@ -504,36 +539,44 @@ function createFrameSink(write, frame, have, hooks) {
|
|
|
504
539
|
let conditional = false;
|
|
505
540
|
const skipped = new Set();
|
|
506
541
|
const attrText = new Map();
|
|
507
|
-
const
|
|
508
|
-
|
|
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)) {
|
|
509
559
|
const key = "lh:" + m[1];
|
|
510
560
|
const digest = textDigest(stripHoleMarkers(m[2]));
|
|
511
561
|
if (have[key] === digest) continue;
|
|
512
|
-
|
|
513
|
-
|
|
514
|
-
|
|
515
|
-
version,
|
|
516
|
-
key,
|
|
517
|
-
html: m[2],
|
|
518
|
-
digest
|
|
519
|
-
}, holeDigests(m[2], null)));
|
|
562
|
+
put(id, {
|
|
563
|
+
["hole:" + key]: html(m[2], digest, holeDigests(m[2], null))
|
|
564
|
+
});
|
|
520
565
|
}
|
|
521
|
-
for (const m of
|
|
566
|
+
for (const m of source.matchAll(ATTR_ADDRESS)) {
|
|
522
567
|
const text = attrText.get("lha:" + m[1]);
|
|
523
568
|
if (text === undefined) continue;
|
|
524
569
|
const digest = textDigest(text);
|
|
525
570
|
if (have["lha:" + m[1]] === digest) continue;
|
|
526
|
-
|
|
527
|
-
|
|
528
|
-
|
|
529
|
-
|
|
530
|
-
|
|
531
|
-
|
|
532
|
-
digest
|
|
571
|
+
put(id, {
|
|
572
|
+
["attr:" + m[1]]: {
|
|
573
|
+
kind: "attrs",
|
|
574
|
+
value: text,
|
|
575
|
+
digest
|
|
576
|
+
}
|
|
533
577
|
});
|
|
534
578
|
}
|
|
535
579
|
};
|
|
536
|
-
const styledKeys = new Set();
|
|
537
580
|
const bindings = new Map();
|
|
538
581
|
const sweepMinted = new Set();
|
|
539
582
|
const argRefVersions = new Map();
|
|
@@ -544,34 +587,27 @@ function createFrameSink(write, frame, have, hooks) {
|
|
|
544
587
|
const sweep = () => {
|
|
545
588
|
epoch++;
|
|
546
589
|
const pass = swept = {
|
|
547
|
-
|
|
590
|
+
r: {},
|
|
548
591
|
emitted: false
|
|
549
592
|
};
|
|
550
593
|
try {
|
|
551
|
-
for (const b of [...bindings
|
|
594
|
+
for (const [key, b] of [...bindings]) {
|
|
595
|
+
if (bindings.get(key) !== b) continue;
|
|
552
596
|
try {
|
|
553
597
|
b.sweep();
|
|
554
598
|
} catch (_) {
|
|
555
599
|
}
|
|
556
600
|
}
|
|
557
|
-
|
|
601
|
+
for (const _ in pass.r) {
|
|
602
|
+
put(id, pass.r);
|
|
603
|
+
break;
|
|
604
|
+
}
|
|
605
|
+
flush();
|
|
558
606
|
if (pass.emitted && hooks && hooks.onYield) hooks.onYield();
|
|
559
607
|
} finally {
|
|
560
608
|
swept = null;
|
|
561
609
|
}
|
|
562
610
|
};
|
|
563
|
-
const emitOps = ops => {
|
|
564
|
-
if (ops.length === 1) emit(Object.assign({
|
|
565
|
-
type: ops[0].type,
|
|
566
|
-
id,
|
|
567
|
-
version
|
|
568
|
-
}, ops[0]));else if (ops.length) emit({
|
|
569
|
-
type: "ops",
|
|
570
|
-
id,
|
|
571
|
-
version,
|
|
572
|
-
ops
|
|
573
|
-
});
|
|
574
|
-
};
|
|
575
611
|
const scheduleSweep = () => {
|
|
576
612
|
if (closed || sweepScheduled || !bindings.size) return;
|
|
577
613
|
sweepScheduled = true;
|
|
@@ -586,52 +622,47 @@ function createFrameSink(write, frame, have, hooks) {
|
|
|
586
622
|
tagRegion(key, childId) {
|
|
587
623
|
if (!regionKeys.has(key)) regionKeys.set(key, childId);
|
|
588
624
|
},
|
|
589
|
-
shell(
|
|
590
|
-
const digest = textDigest(frameSkeleton(
|
|
625
|
+
shell(source, meta = {}) {
|
|
626
|
+
const digest = textDigest(frameSkeleton(source));
|
|
591
627
|
if (have && have[""] === digest) {
|
|
592
628
|
conditional = true;
|
|
593
|
-
emitDiffering(
|
|
629
|
+
emitDiffering(source);
|
|
594
630
|
return;
|
|
595
631
|
}
|
|
596
632
|
if (meta.preloads && meta.preloads.size || meta.preloadLinks) {
|
|
597
|
-
const
|
|
598
|
-
type: "assets",
|
|
599
|
-
id,
|
|
600
|
-
version,
|
|
601
|
-
key: ""
|
|
602
|
-
};
|
|
633
|
+
const record = {};
|
|
603
634
|
if (meta.preloads && meta.preloads.size) {
|
|
604
635
|
const styles = [];
|
|
605
636
|
const modules = [];
|
|
606
637
|
for (const url of meta.preloads) {
|
|
607
638
|
(url.endsWith(".css") ? styles : modules).push(url);
|
|
608
639
|
}
|
|
609
|
-
if (styles.length)
|
|
610
|
-
if (modules.length)
|
|
640
|
+
if (styles.length) record.styles = styles;
|
|
641
|
+
if (modules.length) record.modules = modules;
|
|
611
642
|
}
|
|
612
643
|
if (meta.preloadLinks) {
|
|
613
|
-
|
|
644
|
+
record.preloads = [];
|
|
614
645
|
for (const entry of meta.preloadLinks) {
|
|
615
|
-
|
|
646
|
+
record.preloads.push(wirePreload(entry));
|
|
616
647
|
}
|
|
617
648
|
}
|
|
618
649
|
needs("assets");
|
|
619
|
-
|
|
650
|
+
put(id, {
|
|
651
|
+
"seg::assets": record
|
|
652
|
+
});
|
|
620
653
|
}
|
|
621
|
-
|
|
622
|
-
|
|
623
|
-
|
|
624
|
-
version,
|
|
625
|
-
html,
|
|
626
|
-
digest
|
|
627
|
-
}, holeDigests(html, attrText)));
|
|
654
|
+
put(id, {
|
|
655
|
+
"": html(source, digest, holeDigests(source, attrText))
|
|
656
|
+
});
|
|
628
657
|
},
|
|
629
658
|
data(record) {
|
|
630
659
|
if (record && typeof record.key === "string" && (record.key.endsWith("_fr") || /^\d+$/.test(record.key))) {
|
|
631
660
|
return;
|
|
632
661
|
}
|
|
662
|
+
if (swept) swept.emitted = true;
|
|
663
|
+
flush();
|
|
633
664
|
if (typeof record === "string") {
|
|
634
|
-
|
|
665
|
+
send({
|
|
635
666
|
type: "data",
|
|
636
667
|
id,
|
|
637
668
|
version,
|
|
@@ -639,7 +670,7 @@ function createFrameSink(write, frame, have, hooks) {
|
|
|
639
670
|
});
|
|
640
671
|
scheduleSweep();
|
|
641
672
|
} else {
|
|
642
|
-
|
|
673
|
+
send({
|
|
643
674
|
type: "data",
|
|
644
675
|
id,
|
|
645
676
|
version,
|
|
@@ -656,73 +687,40 @@ function createFrameSink(write, frame, have, hooks) {
|
|
|
656
687
|
skipped.add(key);
|
|
657
688
|
scheduleSweep();
|
|
658
689
|
if (meta.error) {
|
|
659
|
-
|
|
660
|
-
|
|
661
|
-
id: fid,
|
|
662
|
-
version,
|
|
663
|
-
key,
|
|
664
|
-
error: {
|
|
665
|
-
message: String(meta.error && meta.error.message || meta.error)
|
|
666
|
-
}
|
|
690
|
+
putError(fid, key, {
|
|
691
|
+
message: String(meta.error && meta.error.message || meta.error)
|
|
667
692
|
});
|
|
668
693
|
} else emitDiffering(value);
|
|
669
694
|
return;
|
|
670
695
|
}
|
|
671
696
|
const links = meta.styles && meta.styles.links || [];
|
|
672
697
|
const inline = meta.styles && meta.styles.inline || [];
|
|
698
|
+
const r = {};
|
|
673
699
|
if (links.length || inline.length) {
|
|
674
|
-
|
|
675
|
-
const chunk = {
|
|
676
|
-
type: "assets",
|
|
677
|
-
id: fid,
|
|
678
|
-
version,
|
|
679
|
-
key
|
|
680
|
-
};
|
|
700
|
+
const record = {};
|
|
681
701
|
if (links.length) {
|
|
682
|
-
|
|
702
|
+
record.styles = links.map(e => typeof e === "string" ? e : e.attrs ? {
|
|
683
703
|
href: e.href,
|
|
684
704
|
attrs: e.attrs
|
|
685
705
|
} : e.href);
|
|
686
706
|
}
|
|
687
707
|
if (inline.length) {
|
|
688
|
-
|
|
708
|
+
record.inlineStyles = inline.map(e => ({
|
|
689
709
|
id: e.id,
|
|
690
710
|
content: e.content,
|
|
691
711
|
attrs: e.attrs
|
|
692
712
|
}));
|
|
693
713
|
}
|
|
694
714
|
needs("assets");
|
|
695
|
-
|
|
715
|
+
r[`seg:${key}:assets`] = record;
|
|
696
716
|
}
|
|
697
|
-
|
|
698
|
-
type: "fragment",
|
|
699
|
-
id: fid,
|
|
700
|
-
version,
|
|
701
|
-
key,
|
|
702
|
-
html: value,
|
|
703
|
-
digest: textDigest(value)
|
|
704
|
-
}, holeDigests(value, attrText)));
|
|
717
|
+
r[`seg:${key}`] = html(value, textDigest(value), holeDigests(value, attrText));
|
|
705
718
|
scheduleSweep();
|
|
706
|
-
if (meta.error) {
|
|
707
|
-
|
|
708
|
-
|
|
709
|
-
|
|
710
|
-
|
|
711
|
-
key,
|
|
712
|
-
error: {
|
|
713
|
-
message: String(meta.error && meta.error.message || meta.error)
|
|
714
|
-
}
|
|
715
|
-
});
|
|
716
|
-
}
|
|
717
|
-
if (!meta.revealGroup) {
|
|
718
|
-
emit({
|
|
719
|
-
type: "reveal",
|
|
720
|
-
id: fid,
|
|
721
|
-
version,
|
|
722
|
-
keys: [key],
|
|
723
|
-
waitForStyles: !!links.length
|
|
724
|
-
});
|
|
725
|
-
}
|
|
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);
|
|
726
724
|
},
|
|
727
725
|
reveal(keys, meta = {}) {
|
|
728
726
|
const byFrame = new Map();
|
|
@@ -733,38 +731,27 @@ function createFrameSink(write, frame, have, hooks) {
|
|
|
733
731
|
if (!group) byFrame.set(fid, group = []);
|
|
734
732
|
group.push(key);
|
|
735
733
|
}
|
|
734
|
+
const gate = meta.fallback ? "fallback" : "reveal";
|
|
736
735
|
for (const [fid, groupKeys] of byFrame) {
|
|
737
|
-
|
|
738
|
-
for (const key of groupKeys)
|
|
739
|
-
|
|
740
|
-
type: "reveal",
|
|
741
|
-
id: fid,
|
|
742
|
-
version,
|
|
743
|
-
keys: groupKeys,
|
|
744
|
-
waitForStyles
|
|
745
|
-
};
|
|
746
|
-
if (meta.fallback) chunk.fallback = true;
|
|
747
|
-
emit(chunk);
|
|
736
|
+
const r = {};
|
|
737
|
+
for (const key of groupKeys) r[`seg:${key}:${gate}`] = true;
|
|
738
|
+
put(fid, r);
|
|
748
739
|
}
|
|
749
740
|
},
|
|
750
741
|
asset(type, value) {
|
|
751
742
|
if (type === "module") {
|
|
752
743
|
needs("assets");
|
|
753
|
-
|
|
754
|
-
|
|
755
|
-
|
|
756
|
-
|
|
757
|
-
key: "",
|
|
758
|
-
modules: [value]
|
|
744
|
+
put(id, {
|
|
745
|
+
"seg::assets": {
|
|
746
|
+
modules: [value]
|
|
747
|
+
}
|
|
759
748
|
});
|
|
760
749
|
} else if (type === "preload") {
|
|
761
750
|
needs("assets");
|
|
762
|
-
|
|
763
|
-
|
|
764
|
-
|
|
765
|
-
|
|
766
|
-
key: "",
|
|
767
|
-
preloads: [wirePreload(value)]
|
|
751
|
+
put(id, {
|
|
752
|
+
"seg::assets": {
|
|
753
|
+
preloads: [wirePreload(value)]
|
|
754
|
+
}
|
|
768
755
|
});
|
|
769
756
|
}
|
|
770
757
|
},
|
|
@@ -772,64 +759,69 @@ function createFrameSink(write, frame, have, hooks) {
|
|
|
772
759
|
if (closed) return;
|
|
773
760
|
if (bindings.size && !swept) sweep();
|
|
774
761
|
closed = true;
|
|
775
|
-
|
|
776
|
-
|
|
777
|
-
|
|
778
|
-
|
|
779
|
-
|
|
780
|
-
|
|
781
|
-
|
|
762
|
+
put(id, bound ? {
|
|
763
|
+
":complete": true,
|
|
764
|
+
":bound": bound
|
|
765
|
+
} : {
|
|
766
|
+
":complete": true
|
|
767
|
+
});
|
|
768
|
+
flush();
|
|
782
769
|
},
|
|
783
770
|
error(errorId, error) {
|
|
784
|
-
|
|
785
|
-
type: "error",
|
|
786
|
-
id,
|
|
787
|
-
version,
|
|
788
|
-
key: errorId,
|
|
789
|
-
error
|
|
790
|
-
});
|
|
771
|
+
putError(id, errorId, error);
|
|
791
772
|
},
|
|
773
|
+
flush,
|
|
792
774
|
slot(key, args) {
|
|
793
|
-
|
|
794
|
-
|
|
795
|
-
|
|
796
|
-
|
|
797
|
-
|
|
798
|
-
args
|
|
775
|
+
put(id, {
|
|
776
|
+
[`slot:${key}`]: {
|
|
777
|
+
kind: "slot",
|
|
778
|
+
args
|
|
779
|
+
}
|
|
799
780
|
});
|
|
800
781
|
},
|
|
801
|
-
region(childId,
|
|
782
|
+
region(childId, value) {
|
|
802
783
|
needs("regions");
|
|
803
|
-
|
|
804
|
-
|
|
805
|
-
|
|
806
|
-
|
|
807
|
-
|
|
784
|
+
put(childId, {
|
|
785
|
+
"": {
|
|
786
|
+
kind: "html",
|
|
787
|
+
value
|
|
788
|
+
}
|
|
808
789
|
});
|
|
809
790
|
},
|
|
810
|
-
hole(key,
|
|
811
|
-
const
|
|
812
|
-
|
|
813
|
-
|
|
814
|
-
html,
|
|
815
|
-
digest: textDigest(html)
|
|
791
|
+
hole(key, source, rows) {
|
|
792
|
+
const record = {
|
|
793
|
+
kind: "html",
|
|
794
|
+
digest: textDigest(source)
|
|
816
795
|
};
|
|
817
|
-
|
|
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
|
|
804
|
+
};
|
|
805
|
+
showing(r);
|
|
806
|
+
swept ? Object.assign(swept.r, r) : put(id, r);
|
|
818
807
|
},
|
|
819
808
|
attr(key, attrs, removed) {
|
|
820
|
-
const
|
|
821
|
-
|
|
822
|
-
|
|
823
|
-
attrs,
|
|
809
|
+
const record = {
|
|
810
|
+
kind: "attrs",
|
|
811
|
+
value: attrs,
|
|
824
812
|
digest: textDigest(attrs)
|
|
825
813
|
};
|
|
826
|
-
if (removed && removed.length)
|
|
827
|
-
|
|
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);
|
|
828
819
|
},
|
|
829
820
|
attrBaseline(key, text) {
|
|
830
821
|
attrText.set(key, text);
|
|
831
822
|
},
|
|
832
823
|
openBinding(key, b) {
|
|
824
|
+
if (/^lha?:/.test(key)) needs("wire");
|
|
833
825
|
bindings.set(key, b);
|
|
834
826
|
},
|
|
835
827
|
closeBinding(key) {
|
|
@@ -854,9 +846,6 @@ function createFrameSink(write, frame, have, hooks) {
|
|
|
854
846
|
}
|
|
855
847
|
};
|
|
856
848
|
}
|
|
857
|
-
function renderToFrameStream(code, options = {}) {
|
|
858
|
-
return frameStream(() => code, options);
|
|
859
|
-
}
|
|
860
849
|
function renderServerComponent(component, options = {}) {
|
|
861
850
|
return frameStream((sink, frame) => {
|
|
862
851
|
const props = createSlotProps(sink, frame);
|
|
@@ -865,8 +854,9 @@ function renderServerComponent(component, options = {}) {
|
|
|
865
854
|
if (ctx) {
|
|
866
855
|
ctx.commit = sink.commit;
|
|
867
856
|
ctx.commitEpoch = () => sink.epoch;
|
|
868
|
-
|
|
869
|
-
ctx.
|
|
857
|
+
let unsettled = !!options.live;
|
|
858
|
+
if (!unsettled) ctx.unsettled = () => void (unsettled = true);
|
|
859
|
+
ctx.liveHoles = createLiveHoles(sink, false, () => !unsettled, ctx._errorScope);
|
|
870
860
|
}
|
|
871
861
|
return serverComponentScope(() => component(props));
|
|
872
862
|
};
|
|
@@ -899,6 +889,7 @@ function frameStream(makeCode, options) {
|
|
|
899
889
|
function finish() {
|
|
900
890
|
if (ended) return;
|
|
901
891
|
ended = true;
|
|
892
|
+
sink.flush();
|
|
902
893
|
if (timer) clearTimeout(timer);
|
|
903
894
|
if (upstream) upstream.removeEventListener("abort", onSignal);
|
|
904
895
|
w.end && w.end();
|
|
@@ -919,19 +910,20 @@ function frameStream(makeCode, options) {
|
|
|
919
910
|
finish();
|
|
920
911
|
render.abort(upstream.reason);
|
|
921
912
|
}
|
|
922
|
-
const emit =
|
|
923
|
-
if (observation) observation.chunk(
|
|
924
|
-
w.write(
|
|
925
|
-
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) {
|
|
926
917
|
flushed = true;
|
|
927
918
|
if (maxDurationMs > 0 && maxDurationMs !== Infinity) timer = setTimeout(() => cut("time"), maxDurationMs);
|
|
928
919
|
}
|
|
929
920
|
};
|
|
930
|
-
const sink = createFrameSink(emit, frame, options.resume && options.resume.have,
|
|
931
|
-
|
|
921
|
+
const sink = createFrameSink(emit, frame, options.resume && options.resume.have, {
|
|
922
|
+
live: options.live,
|
|
923
|
+
onYield: bounded ? () => {
|
|
932
924
|
if (flushed && maxYields > 0 && ++yields >= maxYields) cut("yields");
|
|
933
|
-
}
|
|
934
|
-
}
|
|
925
|
+
} : undefined
|
|
926
|
+
});
|
|
935
927
|
if (options.live) sink.needs("wire");
|
|
936
928
|
w.write({
|
|
937
929
|
type: "start",
|
|
@@ -966,6 +958,7 @@ function frameStream(makeCode, options) {
|
|
|
966
958
|
finish();
|
|
967
959
|
}
|
|
968
960
|
if (w[ANNOUNCE]) w[ANNOUNCE](sink.announce());
|
|
961
|
+
sink.flush();
|
|
969
962
|
}
|
|
970
963
|
return {
|
|
971
964
|
pipe: stream,
|
|
@@ -987,56 +980,21 @@ function frameStream(makeCode, options) {
|
|
|
987
980
|
function slotRange(occurrence) {
|
|
988
981
|
return {
|
|
989
982
|
t: `<!--slot:${occurrence}:start--><!--slot:${occurrence}:end-->`,
|
|
990
|
-
$slot: true
|
|
991
|
-
$occurrence: occurrence
|
|
983
|
+
$slot: true
|
|
992
984
|
};
|
|
993
985
|
}
|
|
994
|
-
|
|
995
|
-
|
|
996
|
-
function isRangeKey(key) {
|
|
997
|
-
const c = key.charCodeAt(0);
|
|
998
|
-
return c === 36 || c >= 48 && c <= 57 || RANGE_KEYS.has(key);
|
|
999
|
-
}
|
|
1000
|
-
function slotProxy(range, occurrence, face, content, onData, needs) {
|
|
1001
|
-
return new Proxy(range, {
|
|
1002
|
-
get(target, key, receiver) {
|
|
1003
|
-
if (typeof key !== "string" || isRangeKey(key)) return Reflect.get(target, key, receiver);
|
|
1004
|
-
if (onData) onData = void onData();
|
|
1005
|
-
if (face !== SLOT_FACE_MARKUP) needs("bind");
|
|
1006
|
-
return slotValue(occurrence, key, content ? content[key] : undefined, face);
|
|
1007
|
-
}
|
|
1008
|
-
});
|
|
1009
|
-
}
|
|
1010
|
-
function argBorderForm(value, key, occurrence, needs) {
|
|
1011
|
-
return toBorderForm(withoutStandIns(value, key, occurrence, needs));
|
|
986
|
+
function argBorderForm(value, needs) {
|
|
987
|
+
return toBorderForm(noteTraces(value, needs));
|
|
1012
988
|
}
|
|
1013
|
-
function
|
|
1014
|
-
return rewriteTree(value,
|
|
989
|
+
function noteTraces(value, needs) {
|
|
990
|
+
return rewriteTree(value, v => {
|
|
1015
991
|
if (isContainerTraced(v)) {
|
|
1016
992
|
needs("trace");
|
|
1017
993
|
return v;
|
|
1018
994
|
}
|
|
1019
|
-
if (Object.getPrototypeOf(v) === Object.prototype && isSlotValue(v)) {
|
|
1020
|
-
return undefined;
|
|
1021
|
-
}
|
|
1022
995
|
return DESCEND;
|
|
1023
996
|
}, true);
|
|
1024
997
|
}
|
|
1025
|
-
function slotFace(range, content) {
|
|
1026
|
-
if (content == null) return SLOT_FACE_DATA;
|
|
1027
|
-
if (typeof content !== "object" || Array.isArray(content)) return SLOT_FACE_MARKUP;
|
|
1028
|
-
if (isServerContent(content)) {
|
|
1029
|
-
let data = false;
|
|
1030
|
-
for (const key in content) {
|
|
1031
|
-
if (!NODE_KEYS.has(key)) {
|
|
1032
|
-
data = true;
|
|
1033
|
-
break;
|
|
1034
|
-
}
|
|
1035
|
-
}
|
|
1036
|
-
if (!data) return SLOT_FACE_MARKUP;
|
|
1037
|
-
}
|
|
1038
|
-
return SLOT_FACE_DATA;
|
|
1039
|
-
}
|
|
1040
998
|
const OCCURRENCE_UNSAFE = /[^A-Za-z0-9_.-]/g;
|
|
1041
999
|
function encodeOccurrenceKey(key) {
|
|
1042
1000
|
return String(key).replace(OCCURRENCE_UNSAFE, c => {
|
|
@@ -1091,12 +1049,19 @@ function structuralArgsKey(raw) {
|
|
|
1091
1049
|
};
|
|
1092
1050
|
return walk(raw, true) ? out : undefined;
|
|
1093
1051
|
}
|
|
1094
|
-
function
|
|
1095
|
-
const
|
|
1096
|
-
if (
|
|
1097
|
-
|
|
1098
|
-
|
|
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
|
+
}
|
|
1099
1062
|
}
|
|
1063
|
+
const PENDING_ARG = {};
|
|
1064
|
+
const noDigest = () => NaN;
|
|
1100
1065
|
function isAsyncValue(v) {
|
|
1101
1066
|
return !!v && typeof v === "object" && (typeof v.then === "function" || typeof v[Symbol.asyncIterator] === "function");
|
|
1102
1067
|
}
|
|
@@ -1112,6 +1077,37 @@ function tapFirstYield(iterable) {
|
|
|
1112
1077
|
rest
|
|
1113
1078
|
};
|
|
1114
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
|
+
}
|
|
1115
1111
|
function suppressedFill(render) {
|
|
1116
1112
|
const live = sharedConfig.context && sharedConfig.context.liveHoles;
|
|
1117
1113
|
if (!live) return render();
|
|
@@ -1122,25 +1118,96 @@ function suppressedFill(render) {
|
|
|
1122
1118
|
live.suppressed--;
|
|
1123
1119
|
}
|
|
1124
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
|
+
}
|
|
1125
1168
|
function createDocumentSlotProps(clientProps, frameId) {
|
|
1126
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
|
+
};
|
|
1127
1196
|
const getters = new Map();
|
|
1128
1197
|
const repeats = new Map();
|
|
1129
|
-
const range = (occurrence, content) => {
|
|
1198
|
+
const range = (occurrence, content, tail) => {
|
|
1130
1199
|
const r = [{
|
|
1131
1200
|
t: `<!--slot:${occurrence}:start-->`
|
|
1132
|
-
}, content, {
|
|
1201
|
+
}, content, tail, {
|
|
1133
1202
|
t: `<!--slot:${occurrence}:end-->`
|
|
1134
1203
|
}];
|
|
1135
1204
|
r.$slot = true;
|
|
1136
|
-
r
|
|
1137
|
-
const face = slotFace(r, content);
|
|
1138
|
-
r.$face = face;
|
|
1139
|
-
return slotProxy(r, occurrence, face, face === SLOT_FACE_DATA ? content : undefined, undefined, documentNeeds);
|
|
1205
|
+
return r;
|
|
1140
1206
|
};
|
|
1141
1207
|
const zoneOwner = getOwner ? getOwner() : null;
|
|
1142
|
-
const scoped = (occurrence, render) => {
|
|
1208
|
+
const scoped = (occurrence, render, owner) => {
|
|
1143
1209
|
const id = `sc-${frameId}-${occurrence}-`;
|
|
1210
|
+
if (owner) return runWithOwner(owner, () => runWithHydrationScope(id, render));
|
|
1144
1211
|
const run = () => Hydration ? Hydration({
|
|
1145
1212
|
id,
|
|
1146
1213
|
get children() {
|
|
@@ -1160,18 +1227,13 @@ function createDocumentSlotProps(clientProps, frameId) {
|
|
|
1160
1227
|
if (!fn) {
|
|
1161
1228
|
fn = (...callArgs) => {
|
|
1162
1229
|
if (callArgs.length === 0 || callArgs[0] === undefined) {
|
|
1163
|
-
|
|
1164
|
-
const repeat = repeats.get(rk);
|
|
1165
|
-
if (repeat) return repeat;
|
|
1166
|
-
const out = suppressedFill(() => scoped(prop, () => {
|
|
1230
|
+
return park(owner => suppressedFill(() => scoped(prop, () => {
|
|
1167
1231
|
const value = clientProps[prop];
|
|
1168
1232
|
return range(prop, typeof value === "function" ? value() : value);
|
|
1169
|
-
}));
|
|
1170
|
-
if (out.$face === SLOT_FACE_DATA) repeats.set(rk, out);
|
|
1171
|
-
return out;
|
|
1233
|
+
}, owner)));
|
|
1172
1234
|
}
|
|
1173
1235
|
const raw = callArgs[0];
|
|
1174
|
-
const rk =
|
|
1236
|
+
const rk = keyedId(prop, raw);
|
|
1175
1237
|
const repeat = rk !== undefined && repeats.get(rk);
|
|
1176
1238
|
if (repeat) return repeat;
|
|
1177
1239
|
const occurrence = occurrenceId(prop, raw, counts);
|
|
@@ -1179,10 +1241,10 @@ function createDocumentSlotProps(clientProps, frameId) {
|
|
|
1179
1241
|
if (typeof slot !== "function") return range(occurrence, undefined);
|
|
1180
1242
|
const context = sharedConfig.context;
|
|
1181
1243
|
const recordKey = `sc:slot:${frameId}:${occurrence}`;
|
|
1244
|
+
const deferred = !!parked;
|
|
1182
1245
|
let settleRecord;
|
|
1183
|
-
|
|
1184
|
-
|
|
1185
|
-
}
|
|
1246
|
+
const declare = () => context && context.async && context.serialize(recordKey, new Promise(resolve => settleRecord = resolve));
|
|
1247
|
+
deferred || declare();
|
|
1186
1248
|
try {
|
|
1187
1249
|
const resolved = {};
|
|
1188
1250
|
const liveArgs = sharedConfig.context && sharedConfig.context.live && sharedConfig.context.live.args;
|
|
@@ -1190,6 +1252,7 @@ function createDocumentSlotProps(clientProps, frameId) {
|
|
|
1190
1252
|
const evals = {};
|
|
1191
1253
|
const states = {};
|
|
1192
1254
|
const minted = {};
|
|
1255
|
+
const nestedOf = {};
|
|
1193
1256
|
for (const key of Object.keys(raw)) {
|
|
1194
1257
|
if (key === "$key") continue;
|
|
1195
1258
|
const desc = Object.getOwnPropertyDescriptor(raw, key);
|
|
@@ -1208,6 +1271,8 @@ function createDocumentSlotProps(clientProps, frameId) {
|
|
|
1208
1271
|
if (evaluate) {
|
|
1209
1272
|
evals[key] = evaluate;
|
|
1210
1273
|
const stampBefore = scopeStamp();
|
|
1274
|
+
const outer = parked;
|
|
1275
|
+
const nested = nestedOf[key] = parked = new Map();
|
|
1211
1276
|
try {
|
|
1212
1277
|
value = evaluate();
|
|
1213
1278
|
states[key] = {
|
|
@@ -1215,6 +1280,9 @@ function createDocumentSlotProps(clientProps, frameId) {
|
|
|
1215
1280
|
last: value
|
|
1216
1281
|
};
|
|
1217
1282
|
} catch (err) {
|
|
1283
|
+
parked = outer;
|
|
1284
|
+
for (const entry of nested.values()) runParked(entry);
|
|
1285
|
+
nested.clear();
|
|
1218
1286
|
const blocked = ssrHandleError && ssrHandleError(err);
|
|
1219
1287
|
if (!blocked) throw err;
|
|
1220
1288
|
const state = states[key] = {
|
|
@@ -1227,6 +1295,7 @@ function createDocumentSlotProps(clientProps, frameId) {
|
|
|
1227
1295
|
if (liveArgs) liveArgs.commit();
|
|
1228
1296
|
});
|
|
1229
1297
|
}
|
|
1298
|
+
parked = outer;
|
|
1230
1299
|
if (scopeStamp() !== stampBefore) minted[key] = true;
|
|
1231
1300
|
}
|
|
1232
1301
|
vals[key] = value;
|
|
@@ -1243,6 +1312,7 @@ function createDocumentSlotProps(clientProps, frameId) {
|
|
|
1243
1312
|
key,
|
|
1244
1313
|
childId,
|
|
1245
1314
|
value,
|
|
1315
|
+
nested: nestedOf[key],
|
|
1246
1316
|
used: false,
|
|
1247
1317
|
locked: false
|
|
1248
1318
|
};
|
|
@@ -1253,7 +1323,7 @@ function createDocumentSlotProps(clientProps, frameId) {
|
|
|
1253
1323
|
region.used = true;
|
|
1254
1324
|
return [{
|
|
1255
1325
|
t: frameElementOpen(childId)
|
|
1256
|
-
}, value, {
|
|
1326
|
+
}, region.nested && region.nested.size ? placeParked(value, region.nested, getOwner()) : value, {
|
|
1257
1327
|
t: FRAME_ELEMENT_CLOSE
|
|
1258
1328
|
}];
|
|
1259
1329
|
};
|
|
@@ -1274,49 +1344,67 @@ function createDocumentSlotProps(clientProps, frameId) {
|
|
|
1274
1344
|
configurable: true
|
|
1275
1345
|
});
|
|
1276
1346
|
} else {
|
|
1277
|
-
resolved[key] = vals[key] =
|
|
1347
|
+
resolved[key] = vals[key] = noteTraces(value, documentNeeds);
|
|
1278
1348
|
}
|
|
1279
1349
|
}
|
|
1280
|
-
const
|
|
1281
|
-
const
|
|
1282
|
-
|
|
1283
|
-
|
|
1284
|
-
for (const
|
|
1285
|
-
|
|
1286
|
-
const region = regions.find(r => r.key === key);
|
|
1287
|
-
if (region) {
|
|
1288
|
-
args[key] = {
|
|
1289
|
-
$frame: region.childId
|
|
1290
|
-
};
|
|
1291
|
-
continue;
|
|
1292
|
-
}
|
|
1293
|
-
if (!isContainerTraced(value) && isServerContent(value)) continue;
|
|
1294
|
-
args[key] = argBorderForm(value, key, occurrence, documentNeeds);
|
|
1295
|
-
}
|
|
1296
|
-
settleRecord ? settleRecord({
|
|
1297
|
-
...args
|
|
1298
|
-
}) : context.serialize(recordKey, {
|
|
1299
|
-
...args
|
|
1300
|
-
});
|
|
1301
|
-
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;
|
|
1302
1356
|
region.locked = true;
|
|
1303
|
-
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));
|
|
1304
1358
|
}
|
|
1305
|
-
|
|
1306
|
-
|
|
1307
|
-
|
|
1308
|
-
|
|
1309
|
-
|
|
1310
|
-
|
|
1311
|
-
|
|
1312
|
-
|
|
1313
|
-
|
|
1314
|
-
|
|
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
|
|
1315
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
|
+
}
|
|
1316
1399
|
}
|
|
1400
|
+
return out;
|
|
1401
|
+
} catch (error) {
|
|
1402
|
+
settleRecord && settleRecord(undefined);
|
|
1403
|
+
throw error;
|
|
1317
1404
|
}
|
|
1318
|
-
}
|
|
1319
|
-
|
|
1405
|
+
};
|
|
1406
|
+
const out = park(finish);
|
|
1407
|
+
if (rk !== undefined && rk === occurrence) repeats.has(rk) || repeats.set(rk, out);
|
|
1320
1408
|
return out;
|
|
1321
1409
|
} catch (error) {
|
|
1322
1410
|
settleRecord && settleRecord(undefined);
|
|
@@ -1332,9 +1420,40 @@ function createDocumentSlotProps(clientProps, frameId) {
|
|
|
1332
1420
|
}
|
|
1333
1421
|
const FRAME_TAG = "solid-frame";
|
|
1334
1422
|
const FRAME_ID_ATTR = "data-fid";
|
|
1335
|
-
|
|
1423
|
+
const FRAME_ARGS_ATTR = "data-fa";
|
|
1424
|
+
function frameElementOpen(id, args) {
|
|
1336
1425
|
const escaped = sharedConfig.context ? sharedConfig.context.escape(String(id), true) : String(id);
|
|
1337
|
-
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">`;
|
|
1427
|
+
}
|
|
1428
|
+
const DOCUMENT_SITES = Symbol();
|
|
1429
|
+
function contextSites(ctx) {
|
|
1430
|
+
if (ctx[DOCUMENT_SITES]) return ctx[DOCUMENT_SITES];
|
|
1431
|
+
const proto = Object.getPrototypeOf(ctx);
|
|
1432
|
+
if (proto && proto[DOCUMENT_SITES]) return ctx[DOCUMENT_SITES] = proto[DOCUMENT_SITES];
|
|
1433
|
+
if (proto && typeof proto.escape === "function") return ctx[DOCUMENT_SITES] = contextSites(proto);
|
|
1434
|
+
return ctx[DOCUMENT_SITES] = {
|
|
1435
|
+
byOwner: new Map(),
|
|
1436
|
+
counts: Object.create(null)
|
|
1437
|
+
};
|
|
1438
|
+
}
|
|
1439
|
+
function mintSiteId(sites, fnId) {
|
|
1440
|
+
const n = sites.counts[fnId] || 0;
|
|
1441
|
+
sites.counts[fnId] = n + 1;
|
|
1442
|
+
return n === 0 ? fnId : fnId + "~" + (n + 1);
|
|
1443
|
+
}
|
|
1444
|
+
function documentSiteId(fnId) {
|
|
1445
|
+
const ctx = sharedConfig.context;
|
|
1446
|
+
if (!ctx) return fnId;
|
|
1447
|
+
const sites = contextSites(ctx);
|
|
1448
|
+
const owner = getOwner ? getOwner() : null;
|
|
1449
|
+
if (!owner) return mintSiteId(sites, fnId);
|
|
1450
|
+
let byFn = sites.byOwner.get(owner);
|
|
1451
|
+
if (!byFn) sites.byOwner.set(owner, byFn = new Map());
|
|
1452
|
+
const prev = byFn.get(fnId);
|
|
1453
|
+
if (prev) return prev;
|
|
1454
|
+
const siteId = mintSiteId(sites, fnId);
|
|
1455
|
+
byFn.set(fnId, siteId);
|
|
1456
|
+
return siteId;
|
|
1338
1457
|
}
|
|
1339
1458
|
const FRAME_ELEMENT_CLOSE = `</${FRAME_TAG}>`;
|
|
1340
1459
|
function documentNeeds(name) {
|
|
@@ -1356,6 +1475,7 @@ function armDocumentLiveHoles(ctx) {
|
|
|
1356
1475
|
if (live.holes) {
|
|
1357
1476
|
ctx.commit = live.commit;
|
|
1358
1477
|
ctx.commitEpoch = live.commitEpoch;
|
|
1478
|
+
ctx.unsettled = live.unsettled;
|
|
1359
1479
|
}
|
|
1360
1480
|
return;
|
|
1361
1481
|
}
|
|
@@ -1364,6 +1484,7 @@ function armDocumentLiveHoles(ctx) {
|
|
|
1364
1484
|
if (live) live.holes = null;
|
|
1365
1485
|
return;
|
|
1366
1486
|
}
|
|
1487
|
+
let unsettled = false;
|
|
1367
1488
|
const bindings = new Map();
|
|
1368
1489
|
let epoch = 0;
|
|
1369
1490
|
let sweepScheduled = false;
|
|
@@ -1371,7 +1492,7 @@ function armDocumentLiveHoles(ctx) {
|
|
|
1371
1492
|
let swept = null;
|
|
1372
1493
|
const sweep = () => {
|
|
1373
1494
|
epoch++;
|
|
1374
|
-
const
|
|
1495
|
+
const r = swept = {};
|
|
1375
1496
|
try {
|
|
1376
1497
|
for (const b of [...bindings.values()]) {
|
|
1377
1498
|
try {
|
|
@@ -1382,12 +1503,8 @@ function armDocumentLiveHoles(ctx) {
|
|
|
1382
1503
|
} finally {
|
|
1383
1504
|
swept = null;
|
|
1384
1505
|
}
|
|
1385
|
-
|
|
1386
|
-
|
|
1387
|
-
const pushOps = ops => {
|
|
1388
|
-
if (ops.length === 1) push(ops[0]);else if (ops.length) push({
|
|
1389
|
-
type: "ops",
|
|
1390
|
-
ops
|
|
1506
|
+
for (const _ in r) return push({
|
|
1507
|
+
r
|
|
1391
1508
|
});
|
|
1392
1509
|
};
|
|
1393
1510
|
const scheduleSweep = () => {
|
|
@@ -1402,51 +1519,62 @@ function armDocumentLiveHoles(ctx) {
|
|
|
1402
1519
|
ctx.serialize("sc:live", new ReadableStream({
|
|
1403
1520
|
start(c) {
|
|
1404
1521
|
channel = c;
|
|
1522
|
+
},
|
|
1523
|
+
cancel() {
|
|
1524
|
+
closed = true;
|
|
1405
1525
|
}
|
|
1406
1526
|
}));
|
|
1407
|
-
const push =
|
|
1408
|
-
if (!closed) channel.enqueue(
|
|
1527
|
+
const push = batch => {
|
|
1528
|
+
if (!closed) channel.enqueue(batch);
|
|
1409
1529
|
};
|
|
1530
|
+
const write = r => swept ? Object.assign(swept, r) : push({
|
|
1531
|
+
r
|
|
1532
|
+
});
|
|
1410
1533
|
ctx.liveHoles = live.holes = createLiveHoles({
|
|
1411
1534
|
openBinding(key, b) {
|
|
1535
|
+
documentNeeds("wire");
|
|
1412
1536
|
bindings.set(key, b);
|
|
1413
1537
|
},
|
|
1414
1538
|
closeBinding(key) {
|
|
1415
1539
|
bindings.delete(key);
|
|
1416
1540
|
},
|
|
1417
|
-
hole(key,
|
|
1418
|
-
|
|
1419
|
-
|
|
1420
|
-
|
|
1421
|
-
|
|
1422
|
-
|
|
1423
|
-
|
|
1424
|
-
|
|
1541
|
+
hole(key, value) {
|
|
1542
|
+
write({
|
|
1543
|
+
["hole:" + key]: {
|
|
1544
|
+
kind: "html",
|
|
1545
|
+
value,
|
|
1546
|
+
digest: textDigest(value)
|
|
1547
|
+
}
|
|
1548
|
+
});
|
|
1425
1549
|
},
|
|
1426
|
-
attr(key,
|
|
1427
|
-
const
|
|
1428
|
-
|
|
1429
|
-
|
|
1430
|
-
|
|
1431
|
-
digest: textDigest(attrs)
|
|
1550
|
+
attr(key, value, removed) {
|
|
1551
|
+
const record = {
|
|
1552
|
+
kind: "attrs",
|
|
1553
|
+
value,
|
|
1554
|
+
digest: textDigest(value)
|
|
1432
1555
|
};
|
|
1433
|
-
if (removed && removed.length)
|
|
1434
|
-
|
|
1556
|
+
if (removed && removed.length) record.removed = removed;
|
|
1557
|
+
write({
|
|
1558
|
+
["attr:" + key]: record
|
|
1559
|
+
});
|
|
1435
1560
|
},
|
|
1436
1561
|
error(key, error) {
|
|
1437
1562
|
push({
|
|
1438
|
-
|
|
1439
|
-
|
|
1440
|
-
|
|
1563
|
+
r: {
|
|
1564
|
+
[`hole:${key}:error`]: error
|
|
1565
|
+
}
|
|
1441
1566
|
});
|
|
1442
1567
|
},
|
|
1443
1568
|
commit: scheduleSweep,
|
|
1444
1569
|
get epoch() {
|
|
1445
1570
|
return epoch;
|
|
1446
1571
|
}
|
|
1447
|
-
}, true);
|
|
1572
|
+
}, true, () => !unsettled, ctx._errorScope);
|
|
1448
1573
|
ctx.commit = live.commit = scheduleSweep;
|
|
1449
1574
|
ctx.commitEpoch = live.commitEpoch = () => epoch;
|
|
1575
|
+
ctx.unsettled = live.unsettled = () => {
|
|
1576
|
+
unsettled = true;
|
|
1577
|
+
};
|
|
1450
1578
|
live.args = {
|
|
1451
1579
|
openBinding(key, b) {
|
|
1452
1580
|
bindings.set(key, b);
|
|
@@ -1456,19 +1584,23 @@ function armDocumentLiveHoles(ctx) {
|
|
|
1456
1584
|
},
|
|
1457
1585
|
slot(fid, occurrence, args) {
|
|
1458
1586
|
push({
|
|
1459
|
-
|
|
1460
|
-
|
|
1461
|
-
|
|
1462
|
-
|
|
1587
|
+
r: {
|
|
1588
|
+
[`slot:${occurrence}`]: {
|
|
1589
|
+
kind: "slot",
|
|
1590
|
+
args
|
|
1591
|
+
}
|
|
1592
|
+
},
|
|
1593
|
+
fid
|
|
1463
1594
|
});
|
|
1464
1595
|
},
|
|
1465
1596
|
commit: scheduleSweep
|
|
1466
1597
|
};
|
|
1467
1598
|
live.error = (fid, error) => {
|
|
1468
1599
|
push({
|
|
1469
|
-
|
|
1470
|
-
|
|
1471
|
-
|
|
1600
|
+
r: {
|
|
1601
|
+
":error": error
|
|
1602
|
+
},
|
|
1603
|
+
fid
|
|
1472
1604
|
});
|
|
1473
1605
|
};
|
|
1474
1606
|
live.end = () => {
|
|
@@ -1485,31 +1617,34 @@ function frameTransformDirectResult(value, {
|
|
|
1485
1617
|
}) {
|
|
1486
1618
|
if (typeof value !== "function") return value;
|
|
1487
1619
|
const component = value;
|
|
1488
|
-
const
|
|
1489
|
-
|
|
1490
|
-
|
|
1491
|
-
|
|
1492
|
-
|
|
1493
|
-
|
|
1494
|
-
|
|
1495
|
-
|
|
1496
|
-
|
|
1497
|
-
|
|
1498
|
-
|
|
1499
|
-
|
|
1500
|
-
|
|
1501
|
-
|
|
1502
|
-
|
|
1503
|
-
|
|
1504
|
-
|
|
1505
|
-
|
|
1506
|
-
|
|
1507
|
-
|
|
1508
|
-
|
|
1509
|
-
|
|
1620
|
+
const address = frameAddress(id, args);
|
|
1621
|
+
const wrapped = props => {
|
|
1622
|
+
const siteId = documentSiteId(id);
|
|
1623
|
+
return [{
|
|
1624
|
+
t: frameElementOpen(siteId, address.slice(id.length + 1))
|
|
1625
|
+
},
|
|
1626
|
+
serverOwned(() => {
|
|
1627
|
+
const page = sharedConfig.context;
|
|
1628
|
+
armDocumentLiveHoles(page);
|
|
1629
|
+
if (tierUrls && page && page.live && !page.live.tierUrls) page.live.tierUrls = tierUrls;
|
|
1630
|
+
const ctx = Object.create(page);
|
|
1631
|
+
ctx.frameId = siteId;
|
|
1632
|
+
sharedConfig.context = ctx;
|
|
1633
|
+
try {
|
|
1634
|
+
const slotProps = createDocumentSlotProps(props, siteId);
|
|
1635
|
+
const live = !!wrapped[LIVE_SOURCE];
|
|
1636
|
+
if (live) documentNeeds("wire");
|
|
1637
|
+
return serverComponentScope(() => component(slotProps), live);
|
|
1638
|
+
} finally {
|
|
1639
|
+
sharedConfig.context = page;
|
|
1640
|
+
}
|
|
1641
|
+
}), {
|
|
1642
|
+
t: FRAME_ELEMENT_CLOSE
|
|
1643
|
+
}];
|
|
1644
|
+
};
|
|
1510
1645
|
wrapped[SERVER_COMPONENT] = id;
|
|
1511
1646
|
wrapped[SERVER_COMPONENT_SOURCE] = component;
|
|
1512
|
-
wrapped[SERVER_COMPONENT_ADDRESS] =
|
|
1647
|
+
wrapped[SERVER_COMPONENT_ADDRESS] = address;
|
|
1513
1648
|
return wrapped;
|
|
1514
1649
|
}
|
|
1515
1650
|
function resolveRegionHtml(ctx, node) {
|
|
@@ -1612,6 +1747,15 @@ function createSlotProps(sink, frame) {
|
|
|
1612
1747
|
const counts = Object.create(null);
|
|
1613
1748
|
const getters = new Map();
|
|
1614
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
|
+
};
|
|
1615
1759
|
const needs = sink.needs || (() => {});
|
|
1616
1760
|
return new Proxy(Object.create(null), {
|
|
1617
1761
|
has() {
|
|
@@ -1624,25 +1768,38 @@ function createSlotProps(sink, frame) {
|
|
|
1624
1768
|
if (!fn) {
|
|
1625
1769
|
fn = (...callArgs) => {
|
|
1626
1770
|
if (callArgs.length === 0 || callArgs[0] === undefined) {
|
|
1627
|
-
return
|
|
1771
|
+
return slotRange(prop);
|
|
1628
1772
|
}
|
|
1629
|
-
const rk = repeatKey(prop, callArgs[0]);
|
|
1630
|
-
const repeat = rk !== undefined && repeats.get(rk);
|
|
1631
|
-
if (repeat) return repeat;
|
|
1632
1773
|
const live = sharedConfig.context && sharedConfig.context.liveHoles;
|
|
1633
|
-
|
|
1634
|
-
|
|
1635
|
-
|
|
1636
|
-
|
|
1637
|
-
|
|
1638
|
-
|
|
1639
|
-
|
|
1640
|
-
|
|
1641
|
-
|
|
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
|
+
};
|
|
1642
1790
|
}
|
|
1643
1791
|
const raw = callArgs[0];
|
|
1644
|
-
|
|
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;
|
|
1645
1801
|
const args = {};
|
|
1802
|
+
const vals = {};
|
|
1646
1803
|
const opened = [];
|
|
1647
1804
|
for (const key of Object.keys(raw)) {
|
|
1648
1805
|
if (key === "$key") continue;
|
|
@@ -1658,6 +1815,7 @@ function createSlotProps(sink, frame) {
|
|
|
1658
1815
|
let evaluate = null;
|
|
1659
1816
|
let value;
|
|
1660
1817
|
let state = null;
|
|
1818
|
+
let pending = false;
|
|
1661
1819
|
const stampBefore = scopeStamp();
|
|
1662
1820
|
try {
|
|
1663
1821
|
if (desc.get) {
|
|
@@ -1679,6 +1837,7 @@ function createSlotProps(sink, frame) {
|
|
|
1679
1837
|
settled: false,
|
|
1680
1838
|
last: undefined
|
|
1681
1839
|
};
|
|
1840
|
+
pending = true;
|
|
1682
1841
|
const pendingState = state;
|
|
1683
1842
|
value = retryArgUntilSettled(evaluate, blocked, key, occurrence, v => {
|
|
1684
1843
|
pendingState.settled = true;
|
|
@@ -1690,6 +1849,7 @@ function createSlotProps(sink, frame) {
|
|
|
1690
1849
|
const t = typeof value;
|
|
1691
1850
|
if (value == null || t === "string" || t === "number" || t === "boolean") {
|
|
1692
1851
|
args[key] = value;
|
|
1852
|
+
vals[key] = digest(value);
|
|
1693
1853
|
if (evaluate) state = {
|
|
1694
1854
|
settled: true,
|
|
1695
1855
|
last: value
|
|
@@ -1699,21 +1859,27 @@ function createSlotProps(sink, frame) {
|
|
|
1699
1859
|
if (resolved.h.length) {
|
|
1700
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.");
|
|
1701
1861
|
}
|
|
1702
|
-
|
|
1862
|
+
vals[key] = "<" + resolved.t[0];
|
|
1863
|
+
if (!prev || prev.vals[key] !== vals[key]) sink.region(childId, resolved.t[0]);
|
|
1703
1864
|
args[key] = {
|
|
1704
1865
|
$frame: childId
|
|
1705
1866
|
};
|
|
1706
1867
|
} else {
|
|
1707
|
-
|
|
1708
|
-
|
|
1709
|
-
|
|
1710
|
-
|
|
1711
|
-
|
|
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
|
+
}
|
|
1712
1877
|
if (evaluate && !state) state = {
|
|
1713
1878
|
settled: true,
|
|
1714
1879
|
last: value
|
|
1715
1880
|
};
|
|
1716
1881
|
}
|
|
1882
|
+
if (prev && prev.vals[key] !== vals[key]) changed = true;
|
|
1717
1883
|
if (evaluate && state && !mintedEval) opened.push({
|
|
1718
1884
|
key,
|
|
1719
1885
|
evaluate,
|
|
@@ -1723,9 +1889,18 @@ function createSlotProps(sink, frame) {
|
|
|
1723
1889
|
ctx.registerFragment = origRegister;
|
|
1724
1890
|
}
|
|
1725
1891
|
}
|
|
1726
|
-
|
|
1727
|
-
|
|
1728
|
-
|
|
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));
|
|
1729
1904
|
const ctx = sharedConfig.context;
|
|
1730
1905
|
for (const b of opened) {
|
|
1731
1906
|
const key = b.key;
|
|
@@ -1733,23 +1908,23 @@ function createSlotProps(sink, frame) {
|
|
|
1733
1908
|
openArgBinding(sink, ledgerKey, occurrence, key, b.evaluate, b.state, value => {
|
|
1734
1909
|
const t = typeof value;
|
|
1735
1910
|
if (value == null || t === "string" || t === "number" || t === "boolean") {
|
|
1736
|
-
args[key] = value;
|
|
1911
|
+
rec.args[key] = value;
|
|
1737
1912
|
} else {
|
|
1738
1913
|
const ref = `arg:${occurrence}:${key}@${sink.nextArgRef(ledgerKey)}`;
|
|
1739
1914
|
sink.mintRef(ref);
|
|
1740
|
-
ctx.serialize(ref, argBorderForm(value,
|
|
1741
|
-
args[key] = {
|
|
1915
|
+
ctx.serialize(ref, argBorderForm(value, needs));
|
|
1916
|
+
rec.args[key] = {
|
|
1742
1917
|
$ref: ref
|
|
1743
1918
|
};
|
|
1744
1919
|
}
|
|
1920
|
+
rec.vals[key] = digest(value);
|
|
1745
1921
|
sink.slot(occurrence, {
|
|
1746
|
-
...args
|
|
1922
|
+
...rec.args
|
|
1747
1923
|
});
|
|
1748
1924
|
});
|
|
1749
1925
|
}
|
|
1750
|
-
const
|
|
1751
|
-
|
|
1752
|
-
if (keyed) repeats.set(rk, out);
|
|
1926
|
+
const out = slotRange(occurrence);
|
|
1927
|
+
if (rk !== undefined && rk === occurrence) rmap.set(rk, out);
|
|
1753
1928
|
return out;
|
|
1754
1929
|
};
|
|
1755
1930
|
fn.$lhSkip = true;
|
|
@@ -1795,6 +1970,7 @@ function serverComponentResponse(component, options = {}, init = {}) {
|
|
|
1795
1970
|
});
|
|
1796
1971
|
let closed = false;
|
|
1797
1972
|
let stopLive = null;
|
|
1973
|
+
let failed = false;
|
|
1798
1974
|
const body = new ReadableStream({
|
|
1799
1975
|
start(controller) {
|
|
1800
1976
|
const end = () => {
|
|
@@ -1813,10 +1989,11 @@ function serverComponentResponse(component, options = {}, init = {}) {
|
|
|
1813
1989
|
teardown.abort();
|
|
1814
1990
|
});
|
|
1815
1991
|
stream.pipe({
|
|
1816
|
-
write(
|
|
1992
|
+
write(message) {
|
|
1993
|
+
if (message.r && ":error" in message.r) failed = true;
|
|
1817
1994
|
if (closed) return;
|
|
1818
1995
|
try {
|
|
1819
|
-
controller.enqueue(frame(JSON.stringify(
|
|
1996
|
+
controller.enqueue(frame(JSON.stringify(message)));
|
|
1820
1997
|
} catch (_) {
|
|
1821
1998
|
closed = true;
|
|
1822
1999
|
}
|
|
@@ -1836,6 +2013,10 @@ function serverComponentResponse(component, options = {}, init = {}) {
|
|
|
1836
2013
|
});
|
|
1837
2014
|
}
|
|
1838
2015
|
});
|
|
2016
|
+
if (failed) {
|
|
2017
|
+
headers.set("Cache-Control", "no-store");
|
|
2018
|
+
for (const name of [...headers.keys()]) if (name === "surrogate-control" || name.endsWith("cdn-cache-control")) headers.delete(name);
|
|
2019
|
+
}
|
|
1839
2020
|
return new Response(body, {
|
|
1840
2021
|
status: init.status || 200,
|
|
1841
2022
|
headers
|
|
@@ -1970,10 +2151,10 @@ function frameFlightResponse({
|
|
|
1970
2151
|
let closed = false;
|
|
1971
2152
|
const body = new ReadableStream({
|
|
1972
2153
|
async start(controller) {
|
|
1973
|
-
const write =
|
|
2154
|
+
const write = message => {
|
|
1974
2155
|
if (closed) return;
|
|
1975
2156
|
try {
|
|
1976
|
-
controller.enqueue(createChunk(JSON.stringify(
|
|
2157
|
+
controller.enqueue(createChunk(JSON.stringify(message)));
|
|
1977
2158
|
} catch (_) {
|
|
1978
2159
|
closed = true;
|
|
1979
2160
|
}
|
|
@@ -2052,4 +2233,4 @@ function asyncArg(value) {
|
|
|
2052
2233
|
return value;
|
|
2053
2234
|
}
|
|
2054
2235
|
|
|
2055
|
-
export { FRAME_HAVE_BUDGET, FRAME_HAVE_HEADER, FRAME_STREAM_HEADER, FRAME_TIERS_HEADER, SERVER_COMPONENT_BOOTSTRAP, ServerComponentPlugin, asyncArg,
|
|
2236
|
+
export { FRAME_HAVE_BUDGET, FRAME_HAVE_HEADER, FRAME_STREAM_HEADER, FRAME_TIERS_HEADER, SERVER_COMPONENT_BOOTSTRAP, ServerComponentPlugin, asyncArg, frameTransformDirectResult, frameTransformFlightResult, frameTransformResult, isFrameStreamResponse };
|