@solidjs/web 2.0.0-rc.11 → 2.0.0-rc.14
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/server.dev.js +705 -151
- package/dist/server.js +604 -123
- package/dist/server.observe.js +617 -124
- package/dist/web.dev.js +102 -41
- package/dist/web.js +75 -37
- package/dist/web.observe.js +75 -39
- package/frames/dist/assets.js +92 -0
- package/frames/dist/bind.dev.js +326 -0
- package/frames/dist/bind.js +295 -0
- package/frames/dist/client.dev.js +693 -919
- package/frames/dist/client.js +636 -917
- package/frames/dist/client.observe.js +637 -917
- package/frames/dist/regions.js +130 -0
- package/frames/dist/server.dev.js +607 -212
- package/frames/dist/server.js +554 -212
- package/frames/dist/server.observe.js +554 -212
- package/frames/dist/trace.js +42 -0
- package/frames/dist/wire.js +133 -0
- package/package.json +30 -3
- package/performance-tracks/dist/performance-tracks.dev.js +2 -1
- package/performance-tracks/dist/performance-tracks.observe.js +2 -1
- package/performance-tracks/types/index.d.ts +8 -6
- package/serialization/dist/decode.js +37 -8
- package/serialization/dist/serialization.js +39 -10
- package/serialization/types/serializer-decode.d.ts +24 -2
- package/server-functions/dist/client.dev.js +178 -72
- package/server-functions/dist/client.js +99 -61
- package/server-functions/dist/client.observe.js +178 -72
- package/server-functions/dist/server.dev.js +117 -56
- package/server-functions/dist/server.js +117 -56
- package/server-functions/dist/server.observe.js +117 -56
- package/skills/server-components/SKILL.md +228 -0
- package/types/client.d.ts +37 -2
- package/types/constants.d.ts +2 -1
- package/types/diagnostics.d.ts +8 -0
- package/types/frames/assets-tier.d.ts +78 -0
- package/types/frames/bind-tier.d.ts +60 -0
- package/types/frames/client.d.ts +37 -3
- package/types/frames/frame-client.d.ts +249 -96
- package/types/frames/frame-container-plugin.d.ts +2 -10
- package/types/frames/frame-sink.d.ts +33 -0
- package/types/frames/frame-transport.d.ts +66 -18
- package/types/frames/regions-tier.d.ts +45 -0
- package/types/frames/serializer-decode.d.ts +24 -2
- package/types/frames/server.d.ts +53 -1
- package/types/frames/trace-tier.d.ts +2 -0
- package/types/frames/tree-rewrite.d.ts +39 -0
- package/types/frames/wire-tier.d.ts +116 -0
- package/types/index.d.ts +38 -0
- package/types/index.server.d.ts +10 -1
- package/types/jsx.d.ts +11 -1
- package/types/observe.d.ts +182 -12
- package/types/request-error-hook.d.ts +5 -0
- package/types/serializer-decode.d.ts +24 -2
- package/types/server-functions/client.d.ts +26 -0
- package/types/server-functions/registry.d.ts +4 -1
- package/types/server-functions/shared.d.ts +12 -8
- package/types/server-mock.d.ts +13 -1
- package/types/server-observe.d.ts +8 -0
- package/types/server.d.ts +125 -12
|
@@ -1,7 +1,7 @@
|
|
|
1
1
|
import * as core from 'solid-js';
|
|
2
|
-
import { getOwner, onCleanup, createMemo, runWithOwner,
|
|
3
|
-
import {
|
|
4
|
-
import { frameAddress, SINGLE_FLIGHT_HEADER, LIVE_WIRE, deserializeStream, getServerFunctionsCodec, createChunk, deliverFlightData, ERROR_HEADER, hasFlightMetadata,
|
|
2
|
+
import { getOwner, onCleanup, createMemo, runWithOwner, untrack, createRenderEffect, createSignal, createOwner } from 'solid-js';
|
|
3
|
+
import { insert } from '@solidjs/web';
|
|
4
|
+
import { frameAddress, SINGLE_FLIGHT_HEADER, LIVE_WIRE, deserializeStream, getServerFunctionsCodec, createChunk, deliverFlightData, ERROR_HEADER, hasFlightMetadata, ChunkReader, configureServerFunctionsClient } from '@solidjs/web/server-functions/client';
|
|
5
5
|
|
|
6
6
|
const ELEMENT_NODE = 1;
|
|
7
7
|
const TEXT_NODE = 3;
|
|
@@ -16,71 +16,6 @@ function claimNode(handlers, el) {
|
|
|
16
16
|
for (let i = 0; i < handlers.length; i++) handlers[i](el);
|
|
17
17
|
}
|
|
18
18
|
const claimedAttr = name => name === "href" || name === "action";
|
|
19
|
-
const BOUND_SEAM = Symbol.for("solid.bnd");
|
|
20
|
-
const boundSeam = globalThis[BOUND_SEAM] || (globalThis[BOUND_SEAM] = {});
|
|
21
|
-
const BND_ATTR = "_bnd";
|
|
22
|
-
const BND_SELECTOR = "[_bnd]";
|
|
23
|
-
function bndMap(el) {
|
|
24
|
-
const s = el.getAttribute(BND_ATTR);
|
|
25
|
-
if (!s) return undefined;
|
|
26
|
-
const map = {};
|
|
27
|
-
for (const entry of s.split(",")) {
|
|
28
|
-
const eq = entry.indexOf("=");
|
|
29
|
-
if (eq < 1) continue;
|
|
30
|
-
const pos = entry.slice(0, eq);
|
|
31
|
-
const prop = decodeURIComponent(entry.slice(eq + 1));
|
|
32
|
-
const prev = map[pos];
|
|
33
|
-
if (prev === undefined) map[pos] = prop;else if (Array.isArray(prev)) prev.push(prop);else map[pos] = [prev, prop];
|
|
34
|
-
}
|
|
35
|
-
return map;
|
|
36
|
-
}
|
|
37
|
-
boundSeam.resolve = (el, type) => {
|
|
38
|
-
const frame = el._$bndFrame;
|
|
39
|
-
if (!frame) return undefined;
|
|
40
|
-
const map = bndMap(el);
|
|
41
|
-
const prop = map && map[type];
|
|
42
|
-
if (typeof prop !== "string") return undefined;
|
|
43
|
-
return claimFn(frame, type, prop);
|
|
44
|
-
};
|
|
45
|
-
function claimFn(frame, pos, prop) {
|
|
46
|
-
const fn = frame.clientProp(prop);
|
|
47
|
-
if (typeof fn === "function") return fn;
|
|
48
|
-
return undefined;
|
|
49
|
-
}
|
|
50
|
-
function sweepBound(root, frame, delegate, scope) {
|
|
51
|
-
const isElement = root.nodeType === ELEMENT_NODE;
|
|
52
|
-
if (!isElement && root.nodeType !== 11 ) return;
|
|
53
|
-
let els;
|
|
54
|
-
if (isElement && root.hasAttribute(BND_ATTR)) (els = []).push(root);
|
|
55
|
-
const found = root.querySelectorAll(BND_SELECTOR);
|
|
56
|
-
if (found.length) {
|
|
57
|
-
els || (els = []);
|
|
58
|
-
for (let i = 0; i < found.length; i++) els.push(found[i]);
|
|
59
|
-
}
|
|
60
|
-
if (!els) return;
|
|
61
|
-
const run = () => {
|
|
62
|
-
let types;
|
|
63
|
-
for (const el of els) {
|
|
64
|
-
el._$bndFrame = frame;
|
|
65
|
-
const map = bndMap(el);
|
|
66
|
-
if (!map) continue;
|
|
67
|
-
for (const pos in map) {
|
|
68
|
-
if (pos === "ref") fireRefs(frame, el, map.ref);else (types || (types = [])).push(pos);
|
|
69
|
-
}
|
|
70
|
-
}
|
|
71
|
-
if (types && delegate) delegate(types);
|
|
72
|
-
};
|
|
73
|
-
scope ? scope(run) : run();
|
|
74
|
-
}
|
|
75
|
-
function fireRefs(frame, el, prop) {
|
|
76
|
-
const fired = el._$bndFired || (el._$bndFired = new Set());
|
|
77
|
-
for (const p of Array.isArray(prop) ? prop : [prop]) {
|
|
78
|
-
if (fired.has(p)) continue;
|
|
79
|
-
fired.add(p);
|
|
80
|
-
const fn = claimFn(frame, "ref", p);
|
|
81
|
-
if (fn) fn(el);
|
|
82
|
-
}
|
|
83
|
-
}
|
|
84
19
|
function claimTree(handlers, root) {
|
|
85
20
|
const isElement = root.nodeType === ELEMENT_NODE;
|
|
86
21
|
if (!isElement && root.nodeType !== 11 ) return;
|
|
@@ -92,6 +27,18 @@ const placeholderId = name => `pl-${name}`;
|
|
|
92
27
|
const SLOT_START = /^slot:(.+):start$/;
|
|
93
28
|
const SLOT_END = /^slot:(.+):end$/;
|
|
94
29
|
const slotEnd = id => `slot:${id}:end`;
|
|
30
|
+
const SLOT_MARKER = "_s:";
|
|
31
|
+
const SLOT_TEXT = SLOT_MARKER + "t=";
|
|
32
|
+
const SLOT_TEXT_END = "/" + SLOT_MARKER + "t";
|
|
33
|
+
const isTextStart = n => n.nodeType === COMMENT_NODE && n.data.startsWith(SLOT_TEXT);
|
|
34
|
+
function hasSlotMarker(el) {
|
|
35
|
+
const attrs = el.attributes;
|
|
36
|
+
for (let i = 0; i < attrs.length; i++) if (attrs[i].name.startsWith(SLOT_MARKER)) return true;
|
|
37
|
+
return false;
|
|
38
|
+
}
|
|
39
|
+
function isAsyncValue(v) {
|
|
40
|
+
return v !== null && typeof v === "object" && (typeof v.then === "function" || typeof v[Symbol.asyncIterator] === "function");
|
|
41
|
+
}
|
|
95
42
|
function chunkToRecords(chunk) {
|
|
96
43
|
switch (chunk.type) {
|
|
97
44
|
case "start":
|
|
@@ -151,9 +98,12 @@ function chunkToRecords(chunk) {
|
|
|
151
98
|
digest: chunk.digest
|
|
152
99
|
}
|
|
153
100
|
};
|
|
101
|
+
case "ops":
|
|
102
|
+
return Object.assign({}, ...chunk.ops.map(chunkToRecords));
|
|
154
103
|
case "complete":
|
|
155
104
|
return {
|
|
156
|
-
":complete": true
|
|
105
|
+
":complete": true,
|
|
106
|
+
":bound": chunk.bound
|
|
157
107
|
};
|
|
158
108
|
case "error":
|
|
159
109
|
if (!chunk.key) return {
|
|
@@ -177,11 +127,20 @@ function createFrameHost(options = {}) {
|
|
|
177
127
|
});
|
|
178
128
|
return store;
|
|
179
129
|
};
|
|
130
|
+
const landings = new Map();
|
|
131
|
+
const lands = records => "" in records || ":error" in records || ":complete" in records;
|
|
132
|
+
const applyTo = (id, version, r) => {
|
|
133
|
+
const set = frames.get(id);
|
|
134
|
+
if (set) for (const frame of set) frame.apply({
|
|
135
|
+
version,
|
|
136
|
+
r
|
|
137
|
+
});
|
|
138
|
+
};
|
|
180
139
|
const write = (store, version, records) => {
|
|
181
140
|
if (store.version !== undefined && version < store.version) return false;
|
|
182
141
|
if (store.version === undefined || version > store.version) {
|
|
183
142
|
store.version = version;
|
|
184
|
-
|
|
143
|
+
store.records = {};
|
|
185
144
|
}
|
|
186
145
|
const assets = records["seg::assets"];
|
|
187
146
|
const previous = assets && store.records["seg::assets"];
|
|
@@ -197,19 +156,47 @@ function createFrameHost(options = {}) {
|
|
|
197
156
|
}
|
|
198
157
|
return true;
|
|
199
158
|
};
|
|
159
|
+
const settleArgs = (store, recordKey, record, chunk) => {
|
|
160
|
+
const args = record.args;
|
|
161
|
+
const out = {};
|
|
162
|
+
let regions, decoded;
|
|
163
|
+
const settle = () => {
|
|
164
|
+
if (! --record.pending && store.records[recordKey] === record) applyTo(chunk.id, store.version, {
|
|
165
|
+
[recordKey]: record
|
|
166
|
+
});
|
|
167
|
+
};
|
|
168
|
+
for (const key in args) {
|
|
169
|
+
const value = args[key];
|
|
170
|
+
if (value && typeof value.$ref === "string") {
|
|
171
|
+
const resolved = out[key] = options.resolve && options.resolve(value, chunk.id, chunk.version, store.version);
|
|
172
|
+
(decoded ??= {})[key] = true;
|
|
173
|
+
if (resolved instanceof Promise && resolved.s === 0) {
|
|
174
|
+
record.pending = (record.pending || 0) + 1;
|
|
175
|
+
resolved.c.push(settle);
|
|
176
|
+
}
|
|
177
|
+
} else {
|
|
178
|
+
if (value && typeof value.$frame === "string") (regions ??= {})[key] = value.$frame;
|
|
179
|
+
out[key] = value;
|
|
180
|
+
}
|
|
181
|
+
}
|
|
182
|
+
record.args = out;
|
|
183
|
+
record.regions = regions;
|
|
184
|
+
record.decoded = decoded;
|
|
185
|
+
};
|
|
200
186
|
return {
|
|
201
|
-
delegate: options.delegate,
|
|
202
187
|
register(id, frame) {
|
|
203
188
|
let set = frames.get(id);
|
|
204
189
|
if (!set) frames.set(id, set = new Set());
|
|
205
190
|
set.add(frame);
|
|
206
191
|
const store = stores.get(id);
|
|
207
192
|
if (store && store.version !== undefined) {
|
|
208
|
-
frame.apply({
|
|
193
|
+
if (!store.open) frame.apply({
|
|
209
194
|
version: store.version,
|
|
210
195
|
r: store.records
|
|
196
|
+
});else if (store.shown) frame.apply({
|
|
197
|
+
version: store.shownVersion,
|
|
198
|
+
r: store.shown
|
|
211
199
|
});
|
|
212
|
-
frame.rebase && frame.rebase();
|
|
213
200
|
}
|
|
214
201
|
},
|
|
215
202
|
unregister(id, frame) {
|
|
@@ -227,26 +214,65 @@ function createFrameHost(options = {}) {
|
|
|
227
214
|
value: html
|
|
228
215
|
};
|
|
229
216
|
if (store.version === undefined) store.version = 0;
|
|
217
|
+
store.shown = store.records;
|
|
218
|
+
store.shownVersion = store.version;
|
|
230
219
|
}
|
|
231
220
|
}
|
|
232
221
|
}
|
|
233
222
|
}
|
|
234
|
-
if (!frame)
|
|
223
|
+
if (!frame) {
|
|
224
|
+
stores.delete(id);
|
|
225
|
+
landings.delete(id);
|
|
226
|
+
}
|
|
235
227
|
},
|
|
236
228
|
apply(chunk) {
|
|
237
229
|
if (chunk.type === "data") {
|
|
238
|
-
|
|
230
|
+
const store = stores.get(chunk.id);
|
|
231
|
+
const current = store && store.version;
|
|
232
|
+
if (store && chunk.version < current) return;
|
|
233
|
+
options.applyData && options.applyData(chunk, current);
|
|
239
234
|
return;
|
|
240
235
|
}
|
|
241
236
|
const records = chunkToRecords(chunk);
|
|
242
|
-
|
|
243
|
-
|
|
244
|
-
if (
|
|
245
|
-
|
|
246
|
-
|
|
247
|
-
|
|
248
|
-
|
|
237
|
+
const store = storeFor(chunk.id);
|
|
238
|
+
if (!write(store, chunk.version, records)) return;
|
|
239
|
+
if (chunk.type === "slot") {
|
|
240
|
+
const key = `slot:${chunk.key}`;
|
|
241
|
+
settleArgs(store, key, records[key], chunk);
|
|
242
|
+
}
|
|
243
|
+
let r = records;
|
|
244
|
+
if (chunk.type === "start") store.open = true;else if (lands(records)) {
|
|
245
|
+
store.open = false;
|
|
246
|
+
store.shown = r = store.records;
|
|
247
|
+
store.shownVersion = chunk.version;
|
|
248
|
+
const landed = landings.get(chunk.id);
|
|
249
|
+
if (landed && !(":complete" in records && ":error" in r)) {
|
|
250
|
+
landings.delete(chunk.id);
|
|
251
|
+
":error" in records ? landed.j(records[":error"]) : landed.r();
|
|
252
|
+
}
|
|
253
|
+
}
|
|
254
|
+
applyTo(chunk.id, chunk.version, r);
|
|
255
|
+
if (":complete" in records || ":error" in records) options.closeData && options.closeData(chunk.id, chunk.version, records[":error"]);
|
|
256
|
+
},
|
|
257
|
+
landing(id) {
|
|
258
|
+
const store = stores.get(id);
|
|
259
|
+
if (!store || !store.open && !store.shown) return undefined;
|
|
260
|
+
if (store.shown && !(":error" in store.shown)) return undefined;
|
|
261
|
+
let wait = landings.get(id);
|
|
262
|
+
if (!wait) {
|
|
263
|
+
landings.set(id, wait = {});
|
|
264
|
+
wait.p = new Promise((r, j) => (wait.r = r, wait.j = j));
|
|
249
265
|
}
|
|
266
|
+
return wait.p;
|
|
267
|
+
},
|
|
268
|
+
preview(chunk) {
|
|
269
|
+
if (chunk.type !== "slot") return;
|
|
270
|
+
const set = frames.get(chunk.id);
|
|
271
|
+
if (!set) return;
|
|
272
|
+
const records = chunkToRecords(chunk);
|
|
273
|
+
const key = `slot:${chunk.key}`;
|
|
274
|
+
settleArgs(storeFor(chunk.id), key, records[key], chunk);
|
|
275
|
+
for (const frame of set) frame.preview && frame.preview(records);
|
|
250
276
|
},
|
|
251
277
|
get(id) {
|
|
252
278
|
const set = frames.get(id);
|
|
@@ -256,66 +282,66 @@ function createFrameHost(options = {}) {
|
|
|
256
282
|
if (!options.serialize) throw new Error("host has no serializer");
|
|
257
283
|
return options.serialize(value);
|
|
258
284
|
},
|
|
259
|
-
resolve(ref, frameId) {
|
|
260
|
-
return options.resolve ? options.resolve(ref, frameId) : undefined;
|
|
261
|
-
},
|
|
262
285
|
revive: options.revive,
|
|
263
|
-
isContainer: options.isContainer,
|
|
264
286
|
prepareData: options.prepareData
|
|
265
287
|
};
|
|
266
288
|
}
|
|
267
289
|
const FRAME_APPLIED_EVENT = "frame:applied";
|
|
290
|
+
const tierLoaders = {};
|
|
291
|
+
const tierLoads = {};
|
|
292
|
+
const liveFrames = new Set();
|
|
293
|
+
function prepareTier(name) {
|
|
294
|
+
let load = tierLoads[name];
|
|
295
|
+
if (!load) {
|
|
296
|
+
const loader = tierLoaders[name];
|
|
297
|
+
tierLoads[name] = load = loader ? loader().then(module => {
|
|
298
|
+
load.r = module;
|
|
299
|
+
module.install?.();
|
|
300
|
+
for (const frame of liveFrames) frame.apply({
|
|
301
|
+
version: frame.version,
|
|
302
|
+
r: {}
|
|
303
|
+
});
|
|
304
|
+
}) : Promise.resolve();
|
|
305
|
+
}
|
|
306
|
+
return load;
|
|
307
|
+
}
|
|
308
|
+
const tierReady = name => !tierLoaders[name] || prepareTier(name).r;
|
|
309
|
+
const needsRegions = record => record.regions && !tierReady("regions");
|
|
310
|
+
const carriesTrace = value => value != null && typeof value === "object" && (value.$tr != null || Object.values(value).some(carriesTrace));
|
|
311
|
+
const needsTrace = args => !tierLoads.trace?.r && carriesTrace(args) && !tierReady("trace");
|
|
268
312
|
class FrameImpl {
|
|
269
313
|
#element;
|
|
270
|
-
#start;
|
|
271
|
-
#end;
|
|
272
314
|
#options;
|
|
315
|
+
#outer;
|
|
273
316
|
#version;
|
|
274
317
|
#store = Object.create(null);
|
|
275
|
-
#
|
|
318
|
+
#appliedRoot;
|
|
319
|
+
#appliedError;
|
|
276
320
|
#hasContent = false;
|
|
277
|
-
#errorNotified = false;
|
|
278
|
-
#revealed = new Set();
|
|
279
|
-
#fallbackShown = new Set();
|
|
280
321
|
#appliedHoles = new Map();
|
|
281
|
-
#have;
|
|
282
322
|
#slots;
|
|
283
323
|
#mountedSlots = new Set();
|
|
284
324
|
#slotCleanups = new Map();
|
|
285
325
|
#slotArgs = new Map();
|
|
286
326
|
#slotUpdaters = new Map();
|
|
287
|
-
#
|
|
288
|
-
#
|
|
289
|
-
#slotNodes = new Map();
|
|
290
|
-
#processedAssets = new WeakSet();
|
|
291
|
-
#recordRefresh = null;
|
|
327
|
+
#hold;
|
|
328
|
+
#heldRecords = new Map();
|
|
292
329
|
#disposed = false;
|
|
293
|
-
#styleFlush = () => {
|
|
294
|
-
if (!this.#disposed) this.#flush();
|
|
295
|
-
};
|
|
296
330
|
#claimTree = (node, direct) => {
|
|
297
|
-
if (!direct && node.nodeType !== TEXT_NODE && node.nodeType !== COMMENT_NODE) {
|
|
298
|
-
const o = this.#options;
|
|
299
|
-
sweepBound(node, this, o.delegate || o.host && o.host.delegate, o.ownerScope);
|
|
300
|
-
}
|
|
301
331
|
const handlers = claimHandlers();
|
|
302
332
|
if (!handlers) return;
|
|
303
333
|
this.#scoped(() => direct ? claimNode(handlers, node) : claimTree(handlers, node));
|
|
304
334
|
};
|
|
305
|
-
clientProp(name) {
|
|
306
|
-
const props = this.#options.props;
|
|
307
|
-
return props ? props[name] : undefined;
|
|
308
|
-
}
|
|
309
335
|
#scoped(fn) {
|
|
310
336
|
const scope = this.#options.ownerScope;
|
|
311
337
|
return scope ? scope(fn) : fn();
|
|
312
338
|
}
|
|
313
|
-
constructor(element,
|
|
339
|
+
constructor(element, options = {}) {
|
|
314
340
|
this.#element = element;
|
|
315
|
-
this.#start = start;
|
|
316
|
-
this.#end = end;
|
|
317
341
|
this.#options = options;
|
|
318
342
|
this.#slots = options.slots;
|
|
343
|
+
this.#outer = options.parent;
|
|
344
|
+
liveFrames.add(this);
|
|
319
345
|
if (options.adopt) {
|
|
320
346
|
this.#hasContent = true;
|
|
321
347
|
this.#claimContent();
|
|
@@ -325,15 +351,12 @@ class FrameImpl {
|
|
|
325
351
|
}
|
|
326
352
|
if (options.adopt && this.#version === undefined) this.#syncSlots();
|
|
327
353
|
}
|
|
328
|
-
#parent() {
|
|
329
|
-
return this.#element ?? this.#start.parentNode;
|
|
330
|
-
}
|
|
331
354
|
#applied(version, reason) {
|
|
332
355
|
this.#options.onApply?.({
|
|
333
356
|
version,
|
|
334
357
|
reason
|
|
335
358
|
});
|
|
336
|
-
const parent = this.#
|
|
359
|
+
const parent = this.#element;
|
|
337
360
|
const Ev = parent && (parent.ownerDocument || parent).defaultView?.CustomEvent;
|
|
338
361
|
if (Ev) {
|
|
339
362
|
parent.dispatchEvent(new Ev(FRAME_APPLIED_EVENT, {
|
|
@@ -346,18 +369,12 @@ class FrameImpl {
|
|
|
346
369
|
}));
|
|
347
370
|
}
|
|
348
371
|
}
|
|
349
|
-
#firstContent() {
|
|
350
|
-
return this.#start ? this.#start.nextSibling : this.#parent().firstChild;
|
|
351
|
-
}
|
|
352
372
|
get version() {
|
|
353
373
|
return this.#version;
|
|
354
374
|
}
|
|
355
375
|
get store() {
|
|
356
376
|
return this.#store;
|
|
357
377
|
}
|
|
358
|
-
isRevealed(segment) {
|
|
359
|
-
return this.#revealed.has(segment);
|
|
360
|
-
}
|
|
361
378
|
get error() {
|
|
362
379
|
return this.#store[":error"];
|
|
363
380
|
}
|
|
@@ -372,68 +389,59 @@ class FrameImpl {
|
|
|
372
389
|
this.#version = v;
|
|
373
390
|
this.#resetStreamState();
|
|
374
391
|
}
|
|
375
|
-
for (const key in write.r)
|
|
376
|
-
const incoming = write.r[key];
|
|
377
|
-
if (incoming && incoming.kind === "slot" && key.charCodeAt(0) === 115 && key.startsWith("slot:")) {
|
|
378
|
-
const existing = this.#store[key];
|
|
379
|
-
if (existing && existing.kind === "slot" && argsEquivalent(existing.args, incoming.args)) {
|
|
380
|
-
continue;
|
|
381
|
-
}
|
|
382
|
-
}
|
|
383
|
-
this.#store[key] = incoming;
|
|
384
|
-
}
|
|
392
|
+
for (const key in write.r) this.#store[key] = write.r[key];
|
|
385
393
|
this.#flush();
|
|
386
394
|
}
|
|
387
|
-
|
|
388
|
-
|
|
389
|
-
this.#
|
|
395
|
+
preview(records, inherited) {
|
|
396
|
+
const adopted = new Set();
|
|
397
|
+
if (this.#disposed) return adopted;
|
|
398
|
+
const R = tierLoads.regions?.r;
|
|
399
|
+
for (const key in records) {
|
|
400
|
+
const record = records[key];
|
|
401
|
+
if (!record || record.kind !== "slot" || !key.startsWith("slot:")) continue;
|
|
402
|
+
if (inherited && key in this.#store) continue;
|
|
403
|
+
const occurrence = key.slice(5);
|
|
404
|
+
const update = this.#mountedSlots.has(occurrence) && this.#slotUpdaters.get(occurrence);
|
|
405
|
+
if (!update || (R ? R.changed(this, occurrence, record) : record.regions)) continue;
|
|
406
|
+
this.#slotArgs.set(occurrence, record);
|
|
407
|
+
adopted.add(key);
|
|
408
|
+
update(this.#resolveArgs(occurrence, record));
|
|
409
|
+
}
|
|
410
|
+
if (R) for (const frame of R.frames(this)) for (const key of frame.preview(records, true)) adopted.add(key);
|
|
411
|
+
if (!inherited) for (const key of adopted) this.#store[key] = records[key];
|
|
412
|
+
return adopted;
|
|
413
|
+
}
|
|
414
|
+
#resetStreamState() {
|
|
415
|
+
this.#store = Object.create(null);
|
|
416
|
+
this.#appliedRoot = this.#appliedError = undefined;
|
|
390
417
|
this.#appliedHoles.clear();
|
|
391
|
-
this.#processedAssets = new WeakSet();
|
|
392
|
-
this.#errorNotified = false;
|
|
393
|
-
clearStreamRecords(this.#store, root);
|
|
394
418
|
}
|
|
395
419
|
#flush() {
|
|
396
420
|
if (this.#disposed) return;
|
|
397
421
|
const version = this.#version;
|
|
398
422
|
const root = this.#store[""];
|
|
399
|
-
if (root && root.kind === "html" && root
|
|
423
|
+
if (root && root.kind === "html" && root !== this.#appliedRoot) {
|
|
400
424
|
const reason = this.#hasContent ? "morph" : "materialize";
|
|
401
425
|
this.#applyRoot(root.value);
|
|
402
|
-
this.#
|
|
403
|
-
this.#
|
|
404
|
-
"": root.digest,
|
|
405
|
-
...root.holes
|
|
406
|
-
};
|
|
426
|
+
this.#appliedRoot = root;
|
|
427
|
+
this.#recordHave("", root);
|
|
407
428
|
this.#applied(version, reason);
|
|
408
429
|
}
|
|
409
|
-
|
|
410
|
-
|
|
430
|
+
const error = this.#store[":error"];
|
|
431
|
+
if (error && error !== this.#appliedError) {
|
|
432
|
+
this.#appliedError = error;
|
|
411
433
|
this.#applied(version, "error");
|
|
412
434
|
}
|
|
413
|
-
|
|
414
|
-
|
|
415
|
-
|
|
416
|
-
|
|
417
|
-
|
|
418
|
-
|
|
419
|
-
|
|
420
|
-
|
|
421
|
-
|
|
422
|
-
|
|
423
|
-
}
|
|
424
|
-
}
|
|
425
|
-
for (const key in this.#store) {
|
|
426
|
-
const m = /^seg:([^:]+):fallback$/.exec(key);
|
|
427
|
-
if (!m) continue;
|
|
428
|
-
const name = m[1];
|
|
429
|
-
if (this.#revealed.has(name) || this.#fallbackShown.has(name)) continue;
|
|
430
|
-
if (this.#showFallback(name)) {
|
|
431
|
-
this.#fallbackShown.add(name);
|
|
432
|
-
this.#applied(version, "reveal");
|
|
433
|
-
progressed = true;
|
|
434
|
-
}
|
|
435
|
-
}
|
|
436
|
-
}
|
|
435
|
+
for (const key in this.#store) {
|
|
436
|
+
const record = this.#store[key];
|
|
437
|
+
if (!key.endsWith(":assets") || !record || this.#appliedHoles.get(key) === record) continue;
|
|
438
|
+
const tier = tierReady("assets");
|
|
439
|
+
if (!tier) break;
|
|
440
|
+
this.#appliedHoles.set(key, record);
|
|
441
|
+
tier.apply(record);
|
|
442
|
+
}
|
|
443
|
+
this.#revealSegments();
|
|
444
|
+
let morphed = false;
|
|
437
445
|
for (const key in this.#store) {
|
|
438
446
|
const record = this.#store[key];
|
|
439
447
|
if (!record || this.#appliedHoles.get(key) === record) continue;
|
|
@@ -443,110 +451,102 @@ class FrameImpl {
|
|
|
443
451
|
} else if (this.#applyHole(key.slice(5), record.value)) {
|
|
444
452
|
this.#appliedHoles.set(key, record);
|
|
445
453
|
this.#recordHave(key.slice(5), record);
|
|
446
|
-
|
|
454
|
+
morphed = true;
|
|
447
455
|
}
|
|
448
456
|
} else if (key.startsWith("attr:")) {
|
|
449
457
|
if (this.#applyAttrs(key.slice(5), record.value, record.removed)) {
|
|
450
458
|
this.#appliedHoles.set(key, record);
|
|
451
459
|
this.#recordHave("lha:" + key.slice(5), record);
|
|
452
|
-
|
|
460
|
+
morphed = true;
|
|
453
461
|
}
|
|
454
462
|
}
|
|
455
463
|
}
|
|
456
|
-
|
|
457
|
-
const record = this.#store[key];
|
|
458
|
-
if (!key.endsWith(":assets") || !record || this.#processedAssets.has(record)) {
|
|
459
|
-
continue;
|
|
460
|
-
}
|
|
461
|
-
this.#processedAssets.add(record);
|
|
462
|
-
if (record.modules) {
|
|
463
|
-
for (const href of record.modules) ensureModulePreload(href);
|
|
464
|
-
}
|
|
465
|
-
if (record.preloads) {
|
|
466
|
-
for (const entry of record.preloads) ensurePreload(entry);
|
|
467
|
-
}
|
|
468
|
-
}
|
|
464
|
+
if (morphed) this.#applied(version, "morph");
|
|
469
465
|
this.#syncSlots();
|
|
470
466
|
}
|
|
471
467
|
#resolveSlot(prop) {
|
|
472
|
-
return this.#slots?.[prop] ?? this.#
|
|
468
|
+
return this.#slots?.[prop] ?? (this.#outer && this.#outer.#resolveSlot(prop));
|
|
473
469
|
}
|
|
474
470
|
#resolveSlotRecord(occurrence) {
|
|
475
471
|
const record = this.#store[`slot:${occurrence}`];
|
|
476
472
|
if (record !== undefined) return record;
|
|
477
|
-
return this.#
|
|
473
|
+
return this.#outer && this.#outer.#resolveSlotRecord(occurrence);
|
|
478
474
|
}
|
|
479
475
|
#removeSlotRecord(occurrence) {
|
|
480
476
|
const key = `slot:${occurrence}`;
|
|
481
477
|
if (key in this.#store) {
|
|
482
478
|
if (!this.#mountedSlots.has(occurrence)) delete this.#store[key];
|
|
483
|
-
} else this.#
|
|
479
|
+
} else this.#outer && this.#outer.#removeSlotRecord(occurrence);
|
|
484
480
|
}
|
|
485
481
|
#syncSlots(root) {
|
|
486
|
-
if (!this.#slots && !this.#
|
|
482
|
+
if (!this.#slots && !this.#outer) return;
|
|
487
483
|
const found = new Map();
|
|
488
|
-
if (root) collectSlots(root.firstChild, null, found);else this.#collectSlots(found);
|
|
484
|
+
if (root) collectSlots(root.firstChild, null, found, found);else this.#collectSlots(found, found);
|
|
485
|
+
let waiting = false;
|
|
486
|
+
const R = tierLoads.regions?.r;
|
|
487
|
+
const B = tierLoads.bind?.r;
|
|
489
488
|
for (const [occurrence, start] of found) {
|
|
490
489
|
const callback = this.#resolveSlot(propOf(occurrence));
|
|
491
|
-
|
|
490
|
+
const consumers = Array.isArray(start) ? start : null;
|
|
491
|
+
if (!callback) {
|
|
492
|
+
continue;
|
|
493
|
+
}
|
|
492
494
|
const record = this.#resolveSlotRecord(occurrence);
|
|
493
|
-
|
|
494
|
-
|
|
495
|
-
|
|
496
|
-
|
|
497
|
-
if (zombie) {
|
|
498
|
-
this.#mountedSlots.delete(occurrence);
|
|
499
|
-
this.#runSlotCleanups(occurrence);
|
|
495
|
+
const mounted = this.#mountedSlots.has(occurrence);
|
|
496
|
+
if (record === undefined && isCalled(occurrence)) {
|
|
497
|
+
waiting ||= !mounted;
|
|
498
|
+
continue;
|
|
500
499
|
}
|
|
501
|
-
if (!
|
|
502
|
-
|
|
503
|
-
|
|
504
|
-
|
|
505
|
-
|
|
506
|
-
|
|
507
|
-
|
|
508
|
-
|
|
509
|
-
|
|
510
|
-
|
|
511
|
-
if (
|
|
512
|
-
const nodes = this.#invokeSlot(occurrence, callback, record, start, this.#options.adopt);
|
|
513
|
-
if (nodes) this.#replaceRange(occurrence, start, nodes);
|
|
514
|
-
this.#slotNodes.set(occurrence, nodes);
|
|
500
|
+
if (!mounted && record && (record.pending || needsRegions(record) || needsTrace(record.args))) {
|
|
501
|
+
waiting = true;
|
|
502
|
+
if (this.#options.adopt && !consumers) this.#heldRecords.has(occurrence) || this.#heldRecords.set(occurrence, record);
|
|
503
|
+
continue;
|
|
504
|
+
}
|
|
505
|
+
if (!mounted) {
|
|
506
|
+
const held = this.#heldRecords.get(occurrence);
|
|
507
|
+
this.#heldRecords.delete(occurrence);
|
|
508
|
+
const mountRecord = held || record;
|
|
509
|
+
this.#invokeSlot(occurrence, callback, mountRecord, start, this.#options.adopt);
|
|
510
|
+
if (consumers) B.sync(this, occurrence, consumers);
|
|
515
511
|
this.#mountedSlots.add(occurrence);
|
|
516
|
-
|
|
517
|
-
|
|
518
|
-
}
|
|
519
|
-
|
|
520
|
-
|
|
521
|
-
|
|
522
|
-
continue;
|
|
523
|
-
}
|
|
512
|
+
R?.bind(this, occurrence);
|
|
513
|
+
if (mountRecord === record || !record || record.kind !== "slot") continue;
|
|
514
|
+
}
|
|
515
|
+
if (consumers) B.sync(this, occurrence, consumers);
|
|
516
|
+
if (record !== this.#slotArgs.get(occurrence)) {
|
|
517
|
+
if (needsRegions(record) || needsTrace(record.args)) continue;
|
|
524
518
|
const update = this.#slotUpdaters.get(occurrence);
|
|
525
519
|
if (update) {
|
|
526
|
-
const props = this.#resolveArgs(occurrence, record
|
|
520
|
+
const props = this.#resolveArgs(occurrence, record);
|
|
527
521
|
this.#slotArgs.set(occurrence, record);
|
|
528
522
|
update(props);
|
|
529
|
-
this
|
|
523
|
+
R?.bind(this, occurrence);
|
|
530
524
|
continue;
|
|
531
525
|
}
|
|
532
|
-
|
|
533
|
-
|
|
534
|
-
this.#slotNodes.set(occurrence, nodes);
|
|
535
|
-
this.#bindRegions(occurrence);
|
|
526
|
+
this.#invokeSlot(occurrence, callback, record, start);
|
|
527
|
+
R?.bind(this, occurrence);
|
|
536
528
|
}
|
|
537
529
|
}
|
|
530
|
+
if (found.b && !tierReady("bind")) waiting = true;
|
|
538
531
|
if (!root) {
|
|
539
532
|
for (const occurrence of [...this.#mountedSlots]) {
|
|
540
533
|
if (!found.has(occurrence)) this.#unmountSlot(occurrence);
|
|
541
534
|
}
|
|
535
|
+
if (waiting && !this.#hold) this.#hold = this.#options.hold?.();else if (!waiting && this.#hold) this.#releaseHold();
|
|
542
536
|
}
|
|
543
537
|
}
|
|
538
|
+
#releaseHold() {
|
|
539
|
+
const release = this.#hold;
|
|
540
|
+
this.#hold = undefined;
|
|
541
|
+
release && release();
|
|
542
|
+
}
|
|
544
543
|
#invokeSlot(occurrence, callback, record, start, adopted) {
|
|
545
544
|
this.#slotUpdaters.delete(occurrence);
|
|
546
545
|
const cleanups = this.#slotCleanups.get(occurrence) ?? [];
|
|
547
546
|
let existing = [];
|
|
548
547
|
let end = null;
|
|
549
|
-
|
|
548
|
+
const positions = Array.isArray(start) ? start : undefined;
|
|
549
|
+
if (start && !positions) end = eachInRange(start, occurrence, n => existing.push(n));
|
|
550
550
|
const ctx = {
|
|
551
551
|
frame: this.#options.claimScope ?? this.#options.id,
|
|
552
552
|
key: occurrence,
|
|
@@ -558,33 +558,24 @@ class FrameImpl {
|
|
|
558
558
|
range: end ? {
|
|
559
559
|
start,
|
|
560
560
|
end
|
|
561
|
-
} : undefined
|
|
561
|
+
} : undefined,
|
|
562
|
+
positions,
|
|
563
|
+
onRebind: positions ? fn => tierLoads.bind.r.rebinder(this, occurrence, fn) : undefined
|
|
562
564
|
};
|
|
563
|
-
const props = record && record.kind === "slot" ? this.#resolveArgs(occurrence, record
|
|
564
|
-
|
|
565
|
+
const props = record && record.kind === "slot" ? this.#resolveArgs(occurrence, record, adopted, start) : {};
|
|
566
|
+
this.#scoped(() => callback(props, ctx));
|
|
565
567
|
this.#slotArgs.set(occurrence, record);
|
|
566
568
|
if (cleanups.length) this.#slotCleanups.set(occurrence, cleanups);
|
|
567
|
-
if (content == null) return null;
|
|
568
|
-
return Array.isArray(content) ? content : [content];
|
|
569
|
-
}
|
|
570
|
-
#replaceRange(key, start, nodes) {
|
|
571
|
-
const parent = start.parentNode;
|
|
572
|
-
const end = eachInRange(start, key, n => parent.removeChild(n));
|
|
573
|
-
for (const node of nodes) parent.insertBefore(node, end);
|
|
574
569
|
}
|
|
575
570
|
#unmountSlot(key) {
|
|
576
571
|
this.#mountedSlots.delete(key);
|
|
577
|
-
this.#slotNodes.delete(key);
|
|
578
572
|
this.#slotArgs.delete(key);
|
|
579
573
|
this.#slotUpdaters.delete(key);
|
|
580
|
-
this.#
|
|
574
|
+
this.#heldRecords.delete(key);
|
|
581
575
|
this.#removeSlotRecord(key);
|
|
582
576
|
this.#runSlotCleanups(key);
|
|
583
|
-
|
|
584
|
-
|
|
585
|
-
disposeRegions(regions);
|
|
586
|
-
this.#slotRegions.delete(key);
|
|
587
|
-
}
|
|
577
|
+
tierLoads.regions?.r?.unmount(this, key);
|
|
578
|
+
tierLoads.bind?.r?.unmount(this, key);
|
|
588
579
|
}
|
|
589
580
|
#runSlotCleanups(key) {
|
|
590
581
|
const cleanups = this.#slotCleanups.get(key);
|
|
@@ -592,129 +583,33 @@ class FrameImpl {
|
|
|
592
583
|
this.#slotCleanups.delete(key);
|
|
593
584
|
for (const fn of cleanups) fn();
|
|
594
585
|
}
|
|
595
|
-
|
|
596
|
-
|
|
597
|
-
host,
|
|
598
|
-
id
|
|
599
|
-
} = this.#options;
|
|
600
|
-
if (host) for (const key in args) {
|
|
601
|
-
if (isDataRef(args[key]) && host.resolve(args[key], id) === undefined) return true;
|
|
602
|
-
}
|
|
603
|
-
return false;
|
|
604
|
-
}
|
|
605
|
-
#regionsFor(slotKey) {
|
|
606
|
-
let regions = this.#slotRegions.get(slotKey);
|
|
607
|
-
if (!regions) this.#slotRegions.set(slotKey, regions = new Map());
|
|
608
|
-
return regions;
|
|
586
|
+
get options() {
|
|
587
|
+
return this.#options;
|
|
609
588
|
}
|
|
610
|
-
#resolveArgs(slotKey,
|
|
611
|
-
const
|
|
612
|
-
|
|
589
|
+
#resolveArgs(slotKey, record, claiming, start) {
|
|
590
|
+
const {
|
|
591
|
+
args,
|
|
592
|
+
regions,
|
|
593
|
+
decoded
|
|
594
|
+
} = record;
|
|
595
|
+
const revive = this.#options.host && this.#options.host.revive;
|
|
613
596
|
const props = {};
|
|
614
597
|
for (const key in args) {
|
|
598
|
+
if (regions && key in regions) continue;
|
|
615
599
|
const value = args[key];
|
|
616
|
-
|
|
617
|
-
const resolved = host ? host.resolve(value, this.#options.id) : undefined;
|
|
618
|
-
let cache = this.#slotResolvedRefs.get(slotKey);
|
|
619
|
-
if (!cache) this.#slotResolvedRefs.set(slotKey, cache = {});
|
|
620
|
-
cache[key] = resolved;
|
|
621
|
-
props[key] = resolved;
|
|
622
|
-
} else if (isFrameRef(value)) {
|
|
623
|
-
let entry = regions.get(key);
|
|
624
|
-
if (!entry) {
|
|
625
|
-
const element = makeFrameElement(value.$frame);
|
|
626
|
-
entry = {
|
|
627
|
-
childId: value.$frame,
|
|
628
|
-
element,
|
|
629
|
-
frame: undefined
|
|
630
|
-
};
|
|
631
|
-
regions.set(key, entry);
|
|
632
|
-
} else if (entry.childId !== value.$frame) {
|
|
633
|
-
renameRegion(entry, value.$frame);
|
|
634
|
-
}
|
|
635
|
-
props[key] = entry.element;
|
|
636
|
-
} else {
|
|
637
|
-
props[key] = host && host.revive ? host.revive(value) : value;
|
|
638
|
-
}
|
|
600
|
+
props[key] = revive && !(decoded && key in decoded) ? revive(value, claiming) : value;
|
|
639
601
|
}
|
|
602
|
+
if (regions) tierLoads.regions.r.resolve(this, slotKey, regions, props, claiming && start);
|
|
640
603
|
return props;
|
|
641
604
|
}
|
|
642
|
-
#
|
|
643
|
-
|
|
644
|
-
const regions = this.#regionsFor(slotKey);
|
|
645
|
-
eachInRange(start, slotKey, n => collectRegionElements(n, regions));
|
|
646
|
-
}
|
|
647
|
-
#refArgsUnchanged(occurrence, record) {
|
|
648
|
-
const old = this.#slotArgs.get(occurrence);
|
|
649
|
-
if (!record || record.kind !== "slot") return false;
|
|
650
|
-
if (old && old.kind !== "slot") return false;
|
|
651
|
-
const a = old && old.args || {};
|
|
652
|
-
const b = record.args || {};
|
|
653
|
-
const ka = Object.keys(a);
|
|
654
|
-
const kb = Object.keys(b);
|
|
655
|
-
if (kb.length !== ka.length) return false;
|
|
656
|
-
const cache = this.#slotResolvedRefs.get(occurrence);
|
|
657
|
-
for (const key of ka) {
|
|
658
|
-
const va = a[key];
|
|
659
|
-
const vb = b[key];
|
|
660
|
-
if (va === vb) continue;
|
|
661
|
-
if (isFrameRef(va) && isFrameRef(vb)) continue;
|
|
662
|
-
if (isDataRef(va) && isDataRef(vb) && cache && key in cache) {
|
|
663
|
-
const host = this.#options.host;
|
|
664
|
-
const next = host ? host.resolve(vb, this.#options.id) : undefined;
|
|
665
|
-
if (host && host.isContainer && (host.isContainer(next) || host.isContainer(cache[key]))) {
|
|
666
|
-
if (next === cache[key]) continue;
|
|
667
|
-
return false;
|
|
668
|
-
}
|
|
669
|
-
if (isAsyncLike(next) || isAsyncLike(cache[key])) return false;
|
|
670
|
-
try {
|
|
671
|
-
if (JSON.stringify(next) === JSON.stringify(cache[key])) continue;
|
|
672
|
-
} catch (e) {
|
|
673
|
-
return false;
|
|
674
|
-
}
|
|
675
|
-
}
|
|
676
|
-
return false;
|
|
677
|
-
}
|
|
678
|
-
return true;
|
|
605
|
+
#collectSlots(found, elements) {
|
|
606
|
+
collectSlots(this.#element.firstChild, null, found, elements);
|
|
679
607
|
}
|
|
680
|
-
#
|
|
681
|
-
|
|
682
|
-
if (!args) return;
|
|
683
|
-
const regions = this.#slotRegions.get(occurrence);
|
|
684
|
-
if (!regions) return;
|
|
685
|
-
for (const key in args) {
|
|
686
|
-
const value = args[key];
|
|
687
|
-
if (!isFrameRef(value)) continue;
|
|
688
|
-
const entry = regions.get(key);
|
|
689
|
-
if (entry && entry.childId !== value.$frame) renameRegion(entry, value.$frame);
|
|
690
|
-
}
|
|
691
|
-
}
|
|
692
|
-
#bindRegions(slotKey) {
|
|
693
|
-
const regions = this.#slotRegions.get(slotKey);
|
|
694
|
-
if (!regions) return;
|
|
695
|
-
for (const entry of regions.values()) {
|
|
696
|
-
if (!entry.frame) {
|
|
697
|
-
entry.frame = new FrameImpl(entry.element, null, null, {
|
|
698
|
-
id: entry.childId,
|
|
699
|
-
host: this.#options.host,
|
|
700
|
-
adopt: entry.adopt,
|
|
701
|
-
claimScope: this.#options.claimScope ?? this.#options.id,
|
|
702
|
-
ownerScope: this.#options.ownerScope,
|
|
703
|
-
resolveSlot: prop => this.#resolveSlot(prop),
|
|
704
|
-
resolveSlotRecord: occurrence => this.#resolveSlotRecord(occurrence),
|
|
705
|
-
removeSlotRecord: occurrence => this.#removeSlotRecord(occurrence)
|
|
706
|
-
});
|
|
707
|
-
}
|
|
708
|
-
}
|
|
709
|
-
}
|
|
710
|
-
#collectSlots(found) {
|
|
711
|
-
collectSlots(this.#firstContent(), this.#end, found);
|
|
712
|
-
}
|
|
713
|
-
#findPlaceholder(name) {
|
|
714
|
-
return findPlaceholder(this.#firstContent(), this.#end, placeholderId(name));
|
|
608
|
+
#findPlaceholder(name, root) {
|
|
609
|
+
return findPlaceholder((root || this.#element).firstChild, null, placeholderId(name));
|
|
715
610
|
}
|
|
716
611
|
contentHTML() {
|
|
717
|
-
if (this.#disposed || !this.#
|
|
612
|
+
if (this.#disposed || !this.#hasContent) return null;
|
|
718
613
|
return this.#element.innerHTML;
|
|
719
614
|
}
|
|
720
615
|
rebind(id) {
|
|
@@ -732,20 +627,11 @@ class FrameImpl {
|
|
|
732
627
|
this.#element.setAttribute(FRAME_ID_ATTR, id);
|
|
733
628
|
}
|
|
734
629
|
this.#version = undefined;
|
|
735
|
-
this.#
|
|
736
|
-
this.#resetStreamState(true);
|
|
630
|
+
this.#resetStreamState();
|
|
737
631
|
if (host) host.register(id, this);
|
|
738
632
|
}
|
|
739
|
-
rebase() {
|
|
740
|
-
this.#version = undefined;
|
|
741
|
-
}
|
|
742
|
-
have() {
|
|
743
|
-
return this.#have;
|
|
744
|
-
}
|
|
745
633
|
#recordHave(key, record) {
|
|
746
|
-
|
|
747
|
-
this.#have[key] = record.digest;
|
|
748
|
-
if (record.holes) Object.assign(this.#have, record.holes);
|
|
634
|
+
tierLoads.wire?.r?.have(this, key, record);
|
|
749
635
|
}
|
|
750
636
|
dispose() {
|
|
751
637
|
if (this.#disposed) return;
|
|
@@ -755,36 +641,33 @@ class FrameImpl {
|
|
|
755
641
|
} = this.#options;
|
|
756
642
|
if (host && id !== undefined) host.unregister(id, this);
|
|
757
643
|
this.#disposed = true;
|
|
758
|
-
|
|
759
|
-
|
|
760
|
-
this.#recordRefresh = null;
|
|
761
|
-
}
|
|
644
|
+
liveFrames.delete(this);
|
|
645
|
+
this.#releaseHold();
|
|
762
646
|
for (const key of [...this.#slotCleanups.keys()]) this.#runSlotCleanups(key);
|
|
763
647
|
for (const key of this.#mountedSlots) this.#removeSlotRecord(key);
|
|
764
|
-
|
|
765
|
-
this.#slotRegions.clear();
|
|
648
|
+
tierLoads.regions?.r?.unmount(this);
|
|
766
649
|
this.#mountedSlots.clear();
|
|
767
650
|
}
|
|
768
651
|
#applyRoot(html) {
|
|
769
652
|
const fragment = parseFragment(html);
|
|
770
|
-
const parent = this.#
|
|
653
|
+
const parent = this.#element;
|
|
771
654
|
if (!this.#hasContent) {
|
|
772
|
-
|
|
655
|
+
parent.textContent = "";
|
|
773
656
|
this.#claimTree(fragment);
|
|
774
|
-
parent.
|
|
657
|
+
parent.appendChild(fragment);
|
|
775
658
|
this.#hasContent = true;
|
|
776
659
|
} else {
|
|
777
660
|
const claim = this.#claimTree;
|
|
778
661
|
const ranges = new Map();
|
|
779
662
|
this.#collectSlots(ranges);
|
|
780
663
|
const grafts = [];
|
|
781
|
-
reconcileChildren(parent, fragment,
|
|
664
|
+
reconcileChildren(parent, fragment, null, null, claim, ranges, grafts);
|
|
782
665
|
if (ranges.size) for (const root of grafts) flushGrafts(root, ranges);
|
|
783
666
|
}
|
|
784
667
|
}
|
|
785
668
|
#applyHole(marker, html) {
|
|
786
669
|
if (!this.#hasContent) return false;
|
|
787
|
-
const open = findLiveTarget(this.#
|
|
670
|
+
const open = findLiveTarget(this.#element.firstChild, null, n => n.nodeType === COMMENT_NODE && n.data === marker);
|
|
788
671
|
if (!open) return false;
|
|
789
672
|
const close = rangeClose(open, "lh:/" + marker.slice(3));
|
|
790
673
|
if (!close) {
|
|
@@ -795,15 +678,19 @@ class FrameImpl {
|
|
|
795
678
|
}
|
|
796
679
|
#applyAttrs(addr, text, removed) {
|
|
797
680
|
if (!this.#hasContent) return false;
|
|
798
|
-
const el = findLiveTarget(this.#
|
|
681
|
+
const el = findLiveTarget(this.#element.firstChild, null, n => n.nodeType === ELEMENT_NODE && n.getAttribute("data-lha") === addr);
|
|
799
682
|
if (!el) return false;
|
|
800
683
|
const parsed = parseFragment(`<i${text}></i>`).firstChild;
|
|
801
684
|
const keepOpen = preservesOpen(el);
|
|
685
|
+
const owned = parsed ? ownedPositions(parsed) : null;
|
|
802
686
|
const current = el.attributes;
|
|
803
687
|
for (let i = current.length - 1; i >= 0; i--) {
|
|
804
688
|
const name = current[i].name;
|
|
805
689
|
if (name === "data-lha" || keepOpen && name === "open") continue;
|
|
806
|
-
if (!parsed || !parsed.hasAttribute(name))
|
|
690
|
+
if (!parsed || !parsed.hasAttribute(name)) {
|
|
691
|
+
if (applyOwned(el, name, "", owned) !== undefined) continue;
|
|
692
|
+
el.removeAttribute(name);
|
|
693
|
+
}
|
|
807
694
|
}
|
|
808
695
|
if (parsed) {
|
|
809
696
|
for (let i = 0; i < parsed.attributes.length; i++) {
|
|
@@ -812,72 +699,76 @@ class FrameImpl {
|
|
|
812
699
|
value
|
|
813
700
|
} = parsed.attributes[i];
|
|
814
701
|
if (keepOpen && name === "open") continue;
|
|
702
|
+
if (applyOwned(el, name, value, owned) !== undefined) continue;
|
|
815
703
|
if (el.getAttribute(name) !== value) el.setAttribute(name, value);
|
|
816
704
|
}
|
|
817
705
|
}
|
|
818
|
-
if (removed) for (const name of removed)
|
|
706
|
+
if (removed) for (const name of removed) {
|
|
707
|
+
if (keepOpen && name === "open") continue;
|
|
708
|
+
if (applyOwned(el, name, "", owned) !== undefined) continue;
|
|
709
|
+
el.removeAttribute(name);
|
|
710
|
+
}
|
|
819
711
|
return true;
|
|
820
712
|
}
|
|
821
|
-
#clearContent() {
|
|
822
|
-
removeUntil(this.#parent(), this.#firstContent(), this.#end);
|
|
823
|
-
}
|
|
824
713
|
#claimContent() {
|
|
825
|
-
let n = this.#
|
|
826
|
-
|
|
827
|
-
|
|
828
|
-
|
|
714
|
+
for (let n = this.#element.firstChild; n; n = n.nextSibling) this.#claimTree(n);
|
|
715
|
+
}
|
|
716
|
+
#revealSegments(root) {
|
|
717
|
+
const version = this.#version;
|
|
718
|
+
for (const key in this.#store) {
|
|
719
|
+
const record = this.#store[key];
|
|
720
|
+
const name = segmentName(key);
|
|
721
|
+
if (name === null || !record || this.#appliedHoles.get(key) === record) continue;
|
|
722
|
+
if (this.#segmentReady(name, root)) {
|
|
723
|
+
this.#appliedHoles.set(key, record);
|
|
724
|
+
this.#revealSegment(name, root);
|
|
725
|
+
this.#applied(version, "reveal");
|
|
726
|
+
}
|
|
727
|
+
}
|
|
728
|
+
for (const key in this.#store) {
|
|
729
|
+
const m = /^seg:([^:]+):fallback$/.exec(key);
|
|
730
|
+
if (!m || this.#appliedHoles.has(key) || this.#appliedHoles.has(`seg:${m[1]}`)) continue;
|
|
731
|
+
if (this.#showFallback(m[1], root)) {
|
|
732
|
+
this.#appliedHoles.set(key, this.#store[key]);
|
|
733
|
+
this.#applied(version, "reveal");
|
|
734
|
+
}
|
|
829
735
|
}
|
|
830
736
|
}
|
|
831
|
-
#segmentReady(name) {
|
|
737
|
+
#segmentReady(name, root) {
|
|
832
738
|
const content = this.#store[`seg:${name}`];
|
|
833
739
|
if (!content || content.kind !== "html") return false;
|
|
834
740
|
if (!this.#store[`seg:${name}:reveal`]) return false;
|
|
835
741
|
const assets = this.#store[`seg:${name}:assets`];
|
|
836
|
-
if (assets && assets.styles)
|
|
837
|
-
|
|
838
|
-
for (const entry of assets.styles) ready = ensureStylesheet(entry, this.#styleFlush) && ready;
|
|
839
|
-
if (!ready) return false;
|
|
840
|
-
}
|
|
841
|
-
if (!this.#findPlaceholder(name)) return false;
|
|
842
|
-
return true;
|
|
742
|
+
if (assets && (assets.styles || assets.inlineStyles) && !tierReady("assets")?.gate(assets.styles || [], this)) return false;
|
|
743
|
+
return !!this.#findPlaceholder(name, root);
|
|
843
744
|
}
|
|
844
|
-
#revealSegment(name) {
|
|
845
|
-
const tpl = this.#findPlaceholder(name);
|
|
745
|
+
#revealSegment(name, root) {
|
|
746
|
+
const tpl = this.#findPlaceholder(name, root);
|
|
846
747
|
if (!tpl) return;
|
|
847
|
-
const assets = this.#store[`seg:${name}:assets`];
|
|
848
|
-
if (assets && assets.inlineStyles) applyInlineStyles(assets.inlineStyles);
|
|
849
748
|
const content = this.#store[`seg:${name}`];
|
|
850
749
|
const closing = rangeClose(tpl, placeholderId(name));
|
|
851
|
-
|
|
852
|
-
removeUntil(parent, tpl.nextSibling, closing);
|
|
853
|
-
if (this.#options.reveal) {
|
|
854
|
-
const fallbackFrag = tpl.content.cloneNode(true);
|
|
855
|
-
this.#claimTree(fallbackFrag);
|
|
856
|
-
this.#options.reveal({
|
|
857
|
-
before: closing,
|
|
858
|
-
fallback: [...fallbackFrag.childNodes],
|
|
859
|
-
content: () => {
|
|
860
|
-
const materialized = this.#materialize(content);
|
|
861
|
-
this.#syncSlots(materialized);
|
|
862
|
-
this.#claimTree(materialized);
|
|
863
|
-
return materialized;
|
|
864
|
-
}
|
|
865
|
-
});
|
|
866
|
-
tpl.remove();
|
|
867
|
-
this.#revealed.add(name);
|
|
868
|
-
this.#recordHave(name, content);
|
|
750
|
+
if (!closing) {
|
|
869
751
|
return;
|
|
870
752
|
}
|
|
871
|
-
|
|
872
|
-
|
|
873
|
-
|
|
753
|
+
removeUntil(tpl.parentNode, tpl.nextSibling, closing);
|
|
754
|
+
const fallbackFrag = tpl.content.cloneNode(true);
|
|
755
|
+
this.#claimTree(fallbackFrag);
|
|
756
|
+
(this.#options.reveal || revealAtOnce)({
|
|
757
|
+
before: closing,
|
|
758
|
+
fallback: [...fallbackFrag.childNodes],
|
|
759
|
+
content: () => {
|
|
760
|
+
const materialized = this.#materialize(content);
|
|
761
|
+
this.#syncSlots(materialized);
|
|
762
|
+
this.#claimTree(materialized);
|
|
763
|
+
this.#revealSegments(materialized);
|
|
764
|
+
return materialized;
|
|
765
|
+
}
|
|
766
|
+
});
|
|
874
767
|
tpl.remove();
|
|
875
|
-
closing && closing.remove();
|
|
876
|
-
this.#revealed.add(name);
|
|
877
768
|
this.#recordHave(name, content);
|
|
878
769
|
}
|
|
879
|
-
#showFallback(name) {
|
|
880
|
-
const tpl = this.#findPlaceholder(name);
|
|
770
|
+
#showFallback(name, root) {
|
|
771
|
+
const tpl = this.#findPlaceholder(name, root);
|
|
881
772
|
if (!tpl) return false;
|
|
882
773
|
const closing = rangeClose(tpl, placeholderId(name));
|
|
883
774
|
if (!closing) return false;
|
|
@@ -891,13 +782,13 @@ class FrameImpl {
|
|
|
891
782
|
}
|
|
892
783
|
}
|
|
893
784
|
function createFrame(boundary, options) {
|
|
894
|
-
return new FrameImpl(boundary,
|
|
785
|
+
return new FrameImpl(boundary, options);
|
|
895
786
|
}
|
|
896
787
|
const FRAME_TAG = "solid-frame";
|
|
897
788
|
const FRAME_ID_ATTR = "data-fid";
|
|
898
789
|
function createFrameElement(options) {
|
|
899
790
|
const el = makeFrameElement(options.id);
|
|
900
|
-
const frame = new FrameImpl(el,
|
|
791
|
+
const frame = new FrameImpl(el, options);
|
|
901
792
|
return {
|
|
902
793
|
element: el,
|
|
903
794
|
frame,
|
|
@@ -920,23 +811,16 @@ function segmentName(key) {
|
|
|
920
811
|
const m = /^seg:([^:]+)$/.exec(key);
|
|
921
812
|
return m ? m[1] : null;
|
|
922
813
|
}
|
|
923
|
-
function isAsyncLike(v) {
|
|
924
|
-
return !!v && (typeof v.then === "function" || typeof v[Symbol.asyncIterator] === "function");
|
|
925
|
-
}
|
|
926
814
|
function propOf(occurrence) {
|
|
927
815
|
const hash = occurrence.indexOf("#");
|
|
928
816
|
return hash === -1 ? occurrence : occurrence.slice(0, hash);
|
|
929
817
|
}
|
|
930
|
-
function
|
|
931
|
-
return
|
|
818
|
+
function isCalled(occurrence) {
|
|
819
|
+
return occurrence.indexOf("#") !== -1;
|
|
932
820
|
}
|
|
933
|
-
function
|
|
934
|
-
|
|
935
|
-
|
|
936
|
-
function disposeRegions(regions) {
|
|
937
|
-
for (const {
|
|
938
|
-
frame
|
|
939
|
-
} of regions.values()) frame?.dispose();
|
|
821
|
+
function revealAtOnce(seam) {
|
|
822
|
+
seam.before.parentNode.insertBefore(seam.content(), seam.before);
|
|
823
|
+
seam.before.remove();
|
|
940
824
|
}
|
|
941
825
|
function removeUntil(parent, n, stop) {
|
|
942
826
|
while (n && n !== stop) {
|
|
@@ -950,80 +834,6 @@ function parseFragment(html) {
|
|
|
950
834
|
template.innerHTML = html;
|
|
951
835
|
return template.content;
|
|
952
836
|
}
|
|
953
|
-
const PRELOAD_QUALIFIERS = ["as", "crossorigin", "type", "media", "imagesrcset", "imagesizes"];
|
|
954
|
-
function qualifierValue(name, value) {
|
|
955
|
-
if (value == null) return null;
|
|
956
|
-
if (name === "imagesrcset" || name === "imagesizes") return value === "" ? null : value;
|
|
957
|
-
if (name === "as") return value.replace(/[A-Z]/g, c => String.fromCharCode(c.charCodeAt(0) + 32));
|
|
958
|
-
if (name !== "crossorigin") return value;
|
|
959
|
-
return value.length === 15 && value.toLowerCase() === "use-credentials" ? "use-credentials" : "anonymous";
|
|
960
|
-
}
|
|
961
|
-
function findHeadElement(selector, attr, value, qualifiers) {
|
|
962
|
-
candidate: for (const node of document.head.querySelectorAll(selector)) {
|
|
963
|
-
if (node.getAttribute(attr) !== value) continue;
|
|
964
|
-
if (!qualifiers) return node;
|
|
965
|
-
for (let i = 0; i < PRELOAD_QUALIFIERS.length; i++) {
|
|
966
|
-
const name = PRELOAD_QUALIFIERS[i];
|
|
967
|
-
if (qualifierValue(name, node.getAttribute(name)) !== qualifierValue(name, qualifiers[name] ?? null)) continue candidate;
|
|
968
|
-
}
|
|
969
|
-
return node;
|
|
970
|
-
}
|
|
971
|
-
return null;
|
|
972
|
-
}
|
|
973
|
-
function ensurePreload(entry) {
|
|
974
|
-
const attrs = entry.attrs;
|
|
975
|
-
const href = entry.href;
|
|
976
|
-
if (findHeadElement('link[rel="preload"]', "href", href || null, attrs)) return;
|
|
977
|
-
const link = document.createElement("link");
|
|
978
|
-
link.rel = "preload";
|
|
979
|
-
for (const name in attrs) link.setAttribute(name, attrs[name]);
|
|
980
|
-
if (href) link.setAttribute("href", href);
|
|
981
|
-
document.head.appendChild(link);
|
|
982
|
-
}
|
|
983
|
-
function ensureStylesheet(entry, onSettle) {
|
|
984
|
-
const href = typeof entry === "string" ? entry : entry.href;
|
|
985
|
-
let link = findHeadElement('link[rel="stylesheet"]', "href", href);
|
|
986
|
-
if (!link) {
|
|
987
|
-
link = document.createElement("link");
|
|
988
|
-
link.rel = "stylesheet";
|
|
989
|
-
if (typeof entry !== "string" && entry.attrs) {
|
|
990
|
-
for (const name in entry.attrs) link.setAttribute(name, entry.attrs[name]);
|
|
991
|
-
}
|
|
992
|
-
link.href = href;
|
|
993
|
-
const waiters = new Set();
|
|
994
|
-
link._$frWaiters = waiters;
|
|
995
|
-
const settle = () => {
|
|
996
|
-
link._$frWaiters = null;
|
|
997
|
-
for (const fn of waiters) fn();
|
|
998
|
-
};
|
|
999
|
-
link.addEventListener("load", settle);
|
|
1000
|
-
link.addEventListener("error", settle);
|
|
1001
|
-
document.head.appendChild(link);
|
|
1002
|
-
}
|
|
1003
|
-
const waiters = link._$frWaiters;
|
|
1004
|
-
if (waiters == null) return true;
|
|
1005
|
-
waiters.add(onSettle);
|
|
1006
|
-
return false;
|
|
1007
|
-
}
|
|
1008
|
-
function ensureModulePreload(href) {
|
|
1009
|
-
if (findHeadElement('link[rel="modulepreload"]', "href", href)) return;
|
|
1010
|
-
const link = document.createElement("link");
|
|
1011
|
-
link.rel = "modulepreload";
|
|
1012
|
-
link.href = href;
|
|
1013
|
-
document.head.appendChild(link);
|
|
1014
|
-
}
|
|
1015
|
-
function applyInlineStyles(inlineStyles) {
|
|
1016
|
-
for (const entry of inlineStyles) {
|
|
1017
|
-
if (findHeadElement("style[data-asset]", "data-asset", entry.id)) continue;
|
|
1018
|
-
const el = document.createElement("style");
|
|
1019
|
-
el.setAttribute("data-asset", entry.id);
|
|
1020
|
-
if (entry.attrs) {
|
|
1021
|
-
for (const name in entry.attrs) el.setAttribute(name, entry.attrs[name]);
|
|
1022
|
-
}
|
|
1023
|
-
el.textContent = entry.content || "";
|
|
1024
|
-
document.head.appendChild(el);
|
|
1025
|
-
}
|
|
1026
|
-
}
|
|
1027
837
|
function isPlaceholderStart(node, id) {
|
|
1028
838
|
return node.tagName === "TEMPLATE" && node.id === id;
|
|
1029
839
|
}
|
|
@@ -1060,7 +870,7 @@ function findPlaceholder(n, end, id) {
|
|
|
1060
870
|
}
|
|
1061
871
|
return null;
|
|
1062
872
|
}
|
|
1063
|
-
function collectSlots(n, end, out) {
|
|
873
|
+
function collectSlots(n, end, out, elements) {
|
|
1064
874
|
while (n && n !== end) {
|
|
1065
875
|
const id = slotStartId(n);
|
|
1066
876
|
if (id !== null) {
|
|
@@ -1068,32 +878,19 @@ function collectSlots(n, end, out) {
|
|
|
1068
878
|
n = afterRange(n, id);
|
|
1069
879
|
continue;
|
|
1070
880
|
}
|
|
1071
|
-
if (
|
|
1072
|
-
|
|
1073
|
-
|
|
1074
|
-
}
|
|
1075
|
-
|
|
1076
|
-
|
|
1077
|
-
|
|
1078
|
-
|
|
1079
|
-
if (childId && childId.includes(".")) {
|
|
1080
|
-
const argKey = childId.slice(childId.lastIndexOf(".") + 1);
|
|
1081
|
-
if (!regions.has(argKey)) {
|
|
1082
|
-
regions.set(argKey, {
|
|
1083
|
-
childId,
|
|
1084
|
-
element: node,
|
|
1085
|
-
frame: undefined,
|
|
1086
|
-
adopt: true
|
|
1087
|
-
});
|
|
881
|
+
if (elements !== undefined && isTextStart(n)) {
|
|
882
|
+
const B = tierLoads.bind?.r;
|
|
883
|
+
B ? B.text(n, elements) : elements.b = true;
|
|
884
|
+
}
|
|
885
|
+
if (n.nodeType === ELEMENT_NODE && !isFrameElement(n)) {
|
|
886
|
+
if (elements !== undefined && n.hasAttributes()) {
|
|
887
|
+
const B = tierLoads.bind?.r;
|
|
888
|
+
B ? B.positions(n, elements) : hasSlotMarker(n) && (elements.b = true);
|
|
1088
889
|
}
|
|
890
|
+
collectSlots(n.firstChild, null, out, elements);
|
|
1089
891
|
}
|
|
1090
|
-
|
|
892
|
+
n = n.nextSibling;
|
|
1091
893
|
}
|
|
1092
|
-
for (let c = node.firstChild; c; c = c.nextSibling) collectRegionElements(c, regions);
|
|
1093
|
-
}
|
|
1094
|
-
function renameRegion(entry, childId) {
|
|
1095
|
-
entry.childId = childId;
|
|
1096
|
-
if (entry.frame) entry.frame.rebind(childId);else entry.element.setAttribute(FRAME_ID_ATTR, childId);
|
|
1097
894
|
}
|
|
1098
895
|
function eachInRange(start, key, cb) {
|
|
1099
896
|
const end = slotEnd(key);
|
|
@@ -1105,28 +902,6 @@ function eachInRange(start, key, cb) {
|
|
|
1105
902
|
}
|
|
1106
903
|
return n;
|
|
1107
904
|
}
|
|
1108
|
-
function clearStreamRecords(records, root) {
|
|
1109
|
-
for (const key in records) {
|
|
1110
|
-
if (/^(seg|hole|attr):/.test(key) || key === ":error" || root && key === "") {
|
|
1111
|
-
delete records[key];
|
|
1112
|
-
}
|
|
1113
|
-
}
|
|
1114
|
-
}
|
|
1115
|
-
function argsEquivalent(a, b) {
|
|
1116
|
-
if (a === b) return true;
|
|
1117
|
-
if (!a || !b) return false;
|
|
1118
|
-
const ka = Object.keys(a);
|
|
1119
|
-
const kb = Object.keys(b);
|
|
1120
|
-
if (ka.length !== kb.length) return false;
|
|
1121
|
-
for (const key of ka) {
|
|
1122
|
-
const va = a[key];
|
|
1123
|
-
const vb = b[key];
|
|
1124
|
-
if (va === vb) continue;
|
|
1125
|
-
if (isFrameRef(va) && va.$frame === vb?.$frame) continue;
|
|
1126
|
-
return false;
|
|
1127
|
-
}
|
|
1128
|
-
return true;
|
|
1129
|
-
}
|
|
1130
905
|
function slotStartId(node) {
|
|
1131
906
|
if (node.nodeType !== COMMENT_NODE) return null;
|
|
1132
907
|
const m = SLOT_START.exec(node.data);
|
|
@@ -1146,15 +921,26 @@ function preservesOpen(el) {
|
|
|
1146
921
|
const t = el.tagName;
|
|
1147
922
|
return t === "DETAILS" || t === "DIALOG";
|
|
1148
923
|
}
|
|
924
|
+
const ownedPositions = el => {
|
|
925
|
+
const B = tierLoads.bind?.r;
|
|
926
|
+
return B ? B.owned(el) : null;
|
|
927
|
+
};
|
|
928
|
+
const applyOwned = (oldEl, name, value, owned) => owned === null ? undefined : tierLoads.bind.r.apply(oldEl, name, value, owned);
|
|
1149
929
|
function morphAttributes(oldEl, newEl, claim) {
|
|
1150
930
|
let reclaim = false;
|
|
1151
931
|
let changed = false;
|
|
1152
932
|
const keepOpen = preservesOpen(oldEl);
|
|
933
|
+
const owned = ownedPositions(newEl);
|
|
1153
934
|
const oldAttrs = oldEl.attributes;
|
|
1154
935
|
for (let i = oldAttrs.length - 1; i >= 0; i--) {
|
|
1155
936
|
const name = oldAttrs[i].name;
|
|
1156
937
|
if (keepOpen && name === "open") continue;
|
|
1157
938
|
if (!newEl.hasAttribute(name)) {
|
|
939
|
+
const handled = applyOwned(oldEl, name, "", owned);
|
|
940
|
+
if (handled !== undefined) {
|
|
941
|
+
changed = handled || changed;
|
|
942
|
+
continue;
|
|
943
|
+
}
|
|
1158
944
|
oldEl.removeAttribute(name);
|
|
1159
945
|
changed = true;
|
|
1160
946
|
reclaim ||= claimedAttr(name);
|
|
@@ -1163,11 +949,17 @@ function morphAttributes(oldEl, newEl, claim) {
|
|
|
1163
949
|
const newAttrs = newEl.attributes;
|
|
1164
950
|
for (let i = 0; i < newAttrs.length; i++) {
|
|
1165
951
|
const attr = newAttrs[i];
|
|
1166
|
-
|
|
1167
|
-
if (
|
|
1168
|
-
|
|
952
|
+
const name = attr.name;
|
|
953
|
+
if (keepOpen && name === "open") continue;
|
|
954
|
+
const handled = applyOwned(oldEl, name, attr.value, owned);
|
|
955
|
+
if (handled !== undefined) {
|
|
956
|
+
changed = handled || changed;
|
|
957
|
+
continue;
|
|
958
|
+
}
|
|
959
|
+
if (oldEl.getAttribute(name) !== attr.value) {
|
|
960
|
+
oldEl.setAttribute(name, attr.value);
|
|
1169
961
|
changed = true;
|
|
1170
|
-
reclaim ||= claimedAttr(
|
|
962
|
+
reclaim ||= claimedAttr(name);
|
|
1171
963
|
}
|
|
1172
964
|
}
|
|
1173
965
|
if (claim && (reclaim || changed && oldEl.matches(CLAIMED_ELEMENTS))) claim(oldEl, true);
|
|
@@ -1181,8 +973,9 @@ function morphNode(oldNode, newNode, claim, ranges, grafts) {
|
|
|
1181
973
|
oldNode.data = newNode.data;
|
|
1182
974
|
}
|
|
1183
975
|
}
|
|
1184
|
-
|
|
1185
|
-
|
|
976
|
+
const afterRange = (start, id) => afterMarker(start, slotEnd(id));
|
|
977
|
+
const afterText = start => afterMarker(start, SLOT_TEXT_END);
|
|
978
|
+
function afterMarker(start, end) {
|
|
1186
979
|
let n = start.nextSibling;
|
|
1187
980
|
while (n) {
|
|
1188
981
|
if (n.nodeType === COMMENT_NODE && n.data === end) return n.nextSibling;
|
|
@@ -1241,6 +1034,11 @@ function reconcileChildren(parent, source, boundStart = null, boundEnd = null, c
|
|
|
1241
1034
|
const nextNew = newChild.nextSibling;
|
|
1242
1035
|
const pid = slotStartId(newChild);
|
|
1243
1036
|
const old = oldChild === boundEnd ? null : oldChild;
|
|
1037
|
+
if (old && isTextStart(newChild) && old.nodeType === COMMENT_NODE && old.data === newChild.data) {
|
|
1038
|
+
oldChild = afterText(old);
|
|
1039
|
+
newChild = afterText(newChild);
|
|
1040
|
+
continue;
|
|
1041
|
+
}
|
|
1244
1042
|
if (pid !== null) {
|
|
1245
1043
|
if (old && slotStartId(old) === pid) {
|
|
1246
1044
|
oldChild = afterRange(old, pid);
|
|
@@ -1417,18 +1215,7 @@ function observeFrameApply(response) {
|
|
|
1417
1215
|
}
|
|
1418
1216
|
|
|
1419
1217
|
const FRAME_STREAM_HEADER = "X-Frame-Stream";
|
|
1420
|
-
const
|
|
1421
|
-
const FRAME_HAVE_BUDGET = 4096;
|
|
1422
|
-
function encodeHaveList(have) {
|
|
1423
|
-
let out = "";
|
|
1424
|
-
for (const key in have) {
|
|
1425
|
-
const digest = have[key];
|
|
1426
|
-
if (typeof digest !== "string") continue;
|
|
1427
|
-
out += (out ? "," : "") + key + "=" + digest;
|
|
1428
|
-
if (out.length > FRAME_HAVE_BUDGET) return undefined;
|
|
1429
|
-
}
|
|
1430
|
-
return out || undefined;
|
|
1431
|
-
}
|
|
1218
|
+
const FRAME_TIERS_HEADER = "X-Frame-Tiers";
|
|
1432
1219
|
function isFrameStreamResponse(response) {
|
|
1433
1220
|
return response.headers.has(FRAME_STREAM_HEADER);
|
|
1434
1221
|
}
|
|
@@ -1448,26 +1235,12 @@ async function observedApplyFrameResponse(response, host, options = {}) {
|
|
|
1448
1235
|
}
|
|
1449
1236
|
function applyFrames(response, host, options = {}, observation) {
|
|
1450
1237
|
const rootId = response.headers.get(FRAME_STREAM_HEADER) ?? "";
|
|
1238
|
+
response.headers.get(FRAME_TIERS_HEADER)?.split(",").forEach(prepareTier);
|
|
1451
1239
|
const as = options.as;
|
|
1452
1240
|
const version = options.version;
|
|
1453
1241
|
const perFrame = typeof version === "function" ? new Map() : null;
|
|
1454
|
-
const
|
|
1455
|
-
const connection = wire && wire.connection;
|
|
1456
|
-
const reader = wire && isEventStream(response) ? wire.open(response.body) : new ChunkReader(response.body);
|
|
1242
|
+
const reader = options[LIVE_WIRE] || new ChunkReader(response.body);
|
|
1457
1243
|
const open = new Map();
|
|
1458
|
-
let cancelled;
|
|
1459
|
-
let resolveEnd;
|
|
1460
|
-
if (connection) {
|
|
1461
|
-
connection.ended = new Promise(resolve => resolveEnd = resolve);
|
|
1462
|
-
connection.cancel = reason => {
|
|
1463
|
-
if (cancelled !== undefined) return;
|
|
1464
|
-
cancelled = reason;
|
|
1465
|
-
try {
|
|
1466
|
-
const r = reader.cancel && reader.cancel(reason);
|
|
1467
|
-
if (r && typeof r.then === "function") r.then(undefined, () => {});
|
|
1468
|
-
} catch {}
|
|
1469
|
-
};
|
|
1470
|
-
}
|
|
1471
1244
|
const errorRecord = (id, error) => ({
|
|
1472
1245
|
type: "error",
|
|
1473
1246
|
id,
|
|
@@ -1492,26 +1265,15 @@ function applyFrames(response, host, options = {}, observation) {
|
|
|
1492
1265
|
} else if (version !== undefined) chunk.version = version;
|
|
1493
1266
|
if (chunk.type === "start") open.set(chunk.id, chunk.version);else if (chunk.type === "complete" || chunk.type === "error" && !chunk.key) open.delete(chunk.id);
|
|
1494
1267
|
if (observation) observation.chunk(chunk, wireId);
|
|
1495
|
-
|
|
1268
|
+
const needs = chunk.tiers?.map(prepareTier) || [];
|
|
1269
|
+
if (chunk.type === "data" || chunk.type === "slot" && Object.values(chunk.args).some(v => v && v.$ref)) await Promise.all([host.prepareData?.(), ...needs]);
|
|
1496
1270
|
host.apply(chunk);
|
|
1497
1271
|
}
|
|
1498
1272
|
result = await reader.next();
|
|
1499
1273
|
}
|
|
1500
1274
|
};
|
|
1501
1275
|
const end = error => {
|
|
1502
|
-
|
|
1503
|
-
const sweep = () => {
|
|
1504
|
-
for (const id of open.keys()) host.apply(errorRecord(id, dead));
|
|
1505
|
-
};
|
|
1506
|
-
if (connection) {
|
|
1507
|
-
connection.done = true;
|
|
1508
|
-
resolveEnd({
|
|
1509
|
-
open: open.size,
|
|
1510
|
-
error: dead,
|
|
1511
|
-
sweep,
|
|
1512
|
-
close: () => {}
|
|
1513
|
-
});
|
|
1514
|
-
} else if (error === undefined) sweep();
|
|
1276
|
+
if (error === undefined) for (const id of open.keys()) host.apply(errorRecord(id, new Error("Frame stream ended before the frame completed.")));
|
|
1515
1277
|
};
|
|
1516
1278
|
return drain().then(() => {
|
|
1517
1279
|
end(undefined);
|
|
@@ -1524,7 +1286,19 @@ function applyFrames(response, host, options = {}, observation) {
|
|
|
1524
1286
|
const SERVER_COMPONENT = /*#__PURE__*/Symbol.for("solid.server-component");
|
|
1525
1287
|
const SERVER_COMPONENT_ADDRESS = /*#__PURE__*/Symbol.for("solid.server-component-address");
|
|
1526
1288
|
const COMPONENT_BINDING = /*#__PURE__*/Symbol.for("solid.component-binding");
|
|
1289
|
+
const CONTENT_TOKEN = "\u0000";
|
|
1290
|
+
function contentAddress(token) {
|
|
1291
|
+
return token.split(CONTENT_TOKEN)[0];
|
|
1292
|
+
}
|
|
1293
|
+
const stagedContent = {
|
|
1294
|
+
preview() {},
|
|
1295
|
+
commit() {}
|
|
1296
|
+
};
|
|
1527
1297
|
let resolveServerComponent;
|
|
1298
|
+
const calls = new Map();
|
|
1299
|
+
function callFor(address) {
|
|
1300
|
+
return calls.get(address);
|
|
1301
|
+
}
|
|
1528
1302
|
function parseServerComponent(value, ctx) {
|
|
1529
1303
|
return {
|
|
1530
1304
|
id: ctx.parse(value[SERVER_COMPONENT]),
|
|
@@ -1570,7 +1344,6 @@ function flightCodec(codec) {
|
|
|
1570
1344
|
function createServerComponentHandler({
|
|
1571
1345
|
host,
|
|
1572
1346
|
component,
|
|
1573
|
-
onStream,
|
|
1574
1347
|
intercept
|
|
1575
1348
|
}) {
|
|
1576
1349
|
const byFn = new Map();
|
|
@@ -1593,46 +1366,78 @@ function createServerComponentHandler({
|
|
|
1593
1366
|
}
|
|
1594
1367
|
return binding;
|
|
1595
1368
|
};
|
|
1596
|
-
|
|
1369
|
+
const staged = new Map();
|
|
1370
|
+
const latest = new Map();
|
|
1371
|
+
const stage = (address, base, version) => {
|
|
1372
|
+
if (!base) return undefined;
|
|
1373
|
+
let committed = false;
|
|
1374
|
+
const chunks = [];
|
|
1375
|
+
const token = address + CONTENT_TOKEN + version;
|
|
1376
|
+
const entry = {
|
|
1377
|
+
token,
|
|
1378
|
+
prepareData: host.prepareData,
|
|
1379
|
+
apply(chunk) {
|
|
1380
|
+
if (committed || chunk.type === "data") host.apply(chunk);else chunks.push(chunk);
|
|
1381
|
+
},
|
|
1382
|
+
preview() {
|
|
1383
|
+
if (host.preview) for (const chunk of chunks) host.preview(chunk);
|
|
1384
|
+
},
|
|
1385
|
+
commit() {
|
|
1386
|
+
committed = true;
|
|
1387
|
+
staged.delete(address);
|
|
1388
|
+
for (const chunk of chunks) host.apply(chunk);
|
|
1389
|
+
}
|
|
1390
|
+
};
|
|
1391
|
+
staged.set(address, entry);
|
|
1392
|
+
const comp = base[COMPONENT_BINDING].component;
|
|
1393
|
+
const binding = props => comp(props, () => token);
|
|
1394
|
+
binding[COMPONENT_BINDING] = {
|
|
1395
|
+
component: comp,
|
|
1396
|
+
address: token
|
|
1397
|
+
};
|
|
1398
|
+
latest.set(address, binding);
|
|
1399
|
+
return entry;
|
|
1400
|
+
};
|
|
1401
|
+
const settled = (address, binding) => latest.get(address) || binding;
|
|
1402
|
+
const showing = address => {
|
|
1403
|
+
const frame = host.get(address);
|
|
1404
|
+
return frame !== undefined && frame.error === undefined;
|
|
1405
|
+
};
|
|
1406
|
+
const named = (token, half) => {
|
|
1407
|
+
const entry = staged.get(contentAddress(token));
|
|
1408
|
+
if (entry && entry.token === token) entry[half]();
|
|
1409
|
+
};
|
|
1410
|
+
stagedContent.preview = token => named(token, "preview");
|
|
1411
|
+
stagedContent.commit = token => named(token, "commit");
|
|
1412
|
+
resolveServerComponent = (id, address) => settled(address, bindingFor(address, id));
|
|
1597
1413
|
const versions = new Map();
|
|
1598
|
-
const connections = new Map();
|
|
1599
1414
|
const bump = address => {
|
|
1600
1415
|
const version = (versions.get(address) || 0) + 1;
|
|
1601
1416
|
versions.set(address, version);
|
|
1602
|
-
|
|
1603
|
-
|
|
1604
|
-
connections.delete(address);
|
|
1605
|
-
connection.cancel(new Error("Superseded by a newer response for the address."));
|
|
1606
|
-
}
|
|
1417
|
+
staged.delete(address);
|
|
1418
|
+
tierLoads.wire?.r?.cancel(host, address);
|
|
1607
1419
|
return version;
|
|
1608
1420
|
};
|
|
1609
|
-
const
|
|
1610
|
-
|
|
1611
|
-
|
|
1612
|
-
|
|
1613
|
-
|
|
1614
|
-
};
|
|
1421
|
+
const begin = (address, version) => host.apply({
|
|
1422
|
+
type: "start",
|
|
1423
|
+
id: address,
|
|
1424
|
+
version
|
|
1425
|
+
});
|
|
1615
1426
|
return {
|
|
1616
1427
|
intercept: intercept && (info => {
|
|
1617
1428
|
const hit = intercept(info);
|
|
1618
1429
|
if (hit === undefined) return undefined;
|
|
1619
|
-
const
|
|
1430
|
+
const address = frameAddress(info.id, info.args);
|
|
1431
|
+
if (!info.meta?.live) calls.set(address, info);
|
|
1432
|
+
const binding = () => bindingFor(address, info.id);
|
|
1620
1433
|
if (typeof hit.then === "function") return hit.then(landed => landed ? binding() : undefined);
|
|
1621
1434
|
return binding();
|
|
1622
1435
|
}),
|
|
1436
|
+
onLive() {
|
|
1437
|
+
prepareTier("wire");
|
|
1438
|
+
},
|
|
1623
1439
|
resume(info) {
|
|
1624
|
-
|
|
1625
|
-
const version = versions.get(address);
|
|
1626
|
-
const frame = host.get(address);
|
|
1627
|
-
const have = frame && frame.have ? frame.have() : undefined;
|
|
1628
|
-
if (version === undefined && !have) return undefined;
|
|
1629
|
-
const encoded = have && encodeHaveList(have);
|
|
1630
|
-
return {
|
|
1631
|
-
position: String(version || 0),
|
|
1632
|
-
headers: encoded ? {
|
|
1633
|
-
[FRAME_HAVE_HEADER]: encoded
|
|
1634
|
-
} : undefined
|
|
1635
|
-
};
|
|
1440
|
+
return tierLoads.wire?.r?.resume(host, info, versions);
|
|
1636
1441
|
},
|
|
1637
1442
|
handle(response, ctx) {
|
|
1638
1443
|
if (!isFrameStreamResponse(response)) return undefined;
|
|
@@ -1642,31 +1447,16 @@ function createServerComponentHandler({
|
|
|
1642
1447
|
return applyFlightResponse(response, address, binding);
|
|
1643
1448
|
}
|
|
1644
1449
|
const wire = ctx[LIVE_WIRE];
|
|
1645
|
-
|
|
1646
|
-
|
|
1647
|
-
const current = connections.get(address);
|
|
1648
|
-
if (current && !current.done) {
|
|
1649
|
-
connection.ended = current.ended;
|
|
1650
|
-
const body = response.body;
|
|
1651
|
-
if (body) body.cancel().catch(() => {});
|
|
1652
|
-
return binding;
|
|
1653
|
-
}
|
|
1654
|
-
const version = bump(address);
|
|
1655
|
-
if (onStream) onStream(address, version, response);
|
|
1656
|
-
applyFrameResponse(response, host, {
|
|
1657
|
-
as: address,
|
|
1658
|
-
version,
|
|
1659
|
-
[LIVE_WIRE]: wire
|
|
1660
|
-
}).catch(() => {});
|
|
1661
|
-
hold(address, connection);
|
|
1662
|
-
return binding;
|
|
1663
|
-
}
|
|
1450
|
+
if (wire) return prepareTier("wire").then(() => tierLoads.wire.r.connect(response, wire, address, binding, host, bump, begin));
|
|
1451
|
+
calls.set(address, ctx);
|
|
1664
1452
|
const version = bump(address);
|
|
1665
|
-
|
|
1666
|
-
|
|
1453
|
+
const entry = showing(address) ? stage(address, binding, version) : undefined;
|
|
1454
|
+
if (!entry) begin(address, version);
|
|
1455
|
+
const target = entry || host;
|
|
1456
|
+
const applied = applyFrameResponse(response, target, {
|
|
1667
1457
|
as: address,
|
|
1668
1458
|
version
|
|
1669
|
-
}).catch(err =>
|
|
1459
|
+
}).catch(err => target.apply({
|
|
1670
1460
|
type: "error",
|
|
1671
1461
|
id: address,
|
|
1672
1462
|
version,
|
|
@@ -1674,17 +1464,10 @@ function createServerComponentHandler({
|
|
|
1674
1464
|
message: String(err && err.message)
|
|
1675
1465
|
}
|
|
1676
1466
|
}));
|
|
1677
|
-
return binding;
|
|
1467
|
+
return entry ? applied.then(() => settled(address, binding)) : binding;
|
|
1678
1468
|
},
|
|
1679
1469
|
showing(address, functionId) {
|
|
1680
1470
|
bindingFor(address, functionId);
|
|
1681
|
-
const comp = componentFor(functionId);
|
|
1682
|
-
if (comp && (typeof comp === "function" || typeof comp === "object") && !comp[COMPONENT_BINDING]) {
|
|
1683
|
-
comp[COMPONENT_BINDING] = {
|
|
1684
|
-
component: comp,
|
|
1685
|
-
address
|
|
1686
|
-
};
|
|
1687
|
-
}
|
|
1688
1471
|
}
|
|
1689
1472
|
};
|
|
1690
1473
|
async function applyFlightResponse(response, address, binding) {
|
|
@@ -1698,11 +1481,26 @@ function createServerComponentHandler({
|
|
|
1698
1481
|
});
|
|
1699
1482
|
const payload = deserializeStream(new Response(source), flightCodec(getServerFunctionsCodec()));
|
|
1700
1483
|
let carried = false;
|
|
1701
|
-
|
|
1484
|
+
const regions = new Map();
|
|
1485
|
+
const regionOf = id => {
|
|
1486
|
+
for (const [root, entry] of regions) if (id === root || id.startsWith(root + ".")) return entry;
|
|
1487
|
+
};
|
|
1488
|
+
const target = {
|
|
1489
|
+
apply: chunk => {
|
|
1490
|
+
const entry = regionOf(chunk.id);
|
|
1491
|
+
if (entry) entry.apply(chunk);else host.apply(chunk);
|
|
1492
|
+
},
|
|
1493
|
+
prepareData: host.prepareData
|
|
1494
|
+
};
|
|
1495
|
+
await applyFrameResponse(response, target, {
|
|
1702
1496
|
as,
|
|
1703
1497
|
version: frameId => {
|
|
1704
1498
|
const version = bump(frameId);
|
|
1705
|
-
|
|
1499
|
+
let entry = regionOf(frameId);
|
|
1500
|
+
if (!entry && showing(frameId)) {
|
|
1501
|
+
entry = stage(frameId, frameId === as ? binding : byAddress.get(frameId), version);
|
|
1502
|
+
if (entry) regions.set(frameId, entry);
|
|
1503
|
+
}
|
|
1706
1504
|
return version;
|
|
1707
1505
|
},
|
|
1708
1506
|
onOutcome: text => {
|
|
@@ -1717,49 +1515,19 @@ function createServerComponentHandler({
|
|
|
1717
1515
|
if (response.headers.has(ERROR_HEADER) && !hasFlightMetadata(response)) {
|
|
1718
1516
|
throw envelope.value;
|
|
1719
1517
|
}
|
|
1720
|
-
return rootId ? binding : envelope.value;
|
|
1518
|
+
return rootId ? settled(address, binding) : envelope.value;
|
|
1721
1519
|
}
|
|
1722
1520
|
}
|
|
1723
1521
|
|
|
1724
|
-
const
|
|
1725
|
-
const
|
|
1726
|
-
materialized: new WeakMap(),
|
|
1727
|
-
materializedValues: new WeakSet()
|
|
1728
|
-
});
|
|
1729
|
-
function setContainerTraceMaterializer(fn) {
|
|
1730
|
-
state.materializeTrace = fn;
|
|
1731
|
-
}
|
|
1732
|
-
function materialize(marker) {
|
|
1733
|
-
let value = state.materialized.get(marker.$tr);
|
|
1734
|
-
if (value === undefined) {
|
|
1735
|
-
value = state.materializeTrace(marker);
|
|
1736
|
-
state.materialized.set(marker.$tr, value);
|
|
1737
|
-
if (value !== null && typeof value === "object") state.materializedValues.add(value);
|
|
1738
|
-
}
|
|
1739
|
-
return value;
|
|
1740
|
-
}
|
|
1741
|
-
function isMaterializedContainer(value) {
|
|
1742
|
-
return value !== null && typeof value === "object" && state.materializedValues.has(value);
|
|
1743
|
-
}
|
|
1744
|
-
function isContainerTraceMarker(value) {
|
|
1745
|
-
if (value == null || typeof value !== "object" || value.$tr == null) return false;
|
|
1746
|
-
const tr = value.$tr;
|
|
1747
|
-
return tr.__SEROVAL_STREAM__ === true || typeof tr[Symbol.asyncIterator] === "function";
|
|
1748
|
-
}
|
|
1749
|
-
function reviveContainerTraces(value) {
|
|
1750
|
-
if (!state.materializeTrace || value == null || typeof value !== "object") return value;
|
|
1751
|
-
if (isContainerTraceMarker(value)) return materialize(value);
|
|
1752
|
-
if (Array.isArray(value)) {
|
|
1753
|
-
for (let i = 0; i < value.length; i++) value[i] = reviveContainerTraces(value[i]);
|
|
1754
|
-
} else if (Object.getPrototypeOf(value) === Object.prototype) {
|
|
1755
|
-
for (const key of Object.keys(value)) value[key] = reviveContainerTraces(value[key]);
|
|
1756
|
-
}
|
|
1757
|
-
return value;
|
|
1758
|
-
}
|
|
1522
|
+
const createLoadingBoundary = core.createLoadingBoundary;
|
|
1523
|
+
const sharedConfig = core.sharedConfig;
|
|
1759
1524
|
|
|
1760
|
-
const
|
|
1761
|
-
|
|
1762
|
-
|
|
1525
|
+
const TRACE_STATE = Symbol.for("solid.container-trace-state");
|
|
1526
|
+
tierLoaders.trace = () => import('@solidjs/web/frames/trace');
|
|
1527
|
+
tierLoaders.regions = () => import('@solidjs/web/frames/regions');
|
|
1528
|
+
tierLoaders.assets = () => import('@solidjs/web/frames/assets');
|
|
1529
|
+
tierLoaders.bind = () => import('@solidjs/web/frames/bind');
|
|
1530
|
+
tierLoaders.wire = () => import('@solidjs/web/frames/wire');
|
|
1763
1531
|
function asyncArg(value) {
|
|
1764
1532
|
return value;
|
|
1765
1533
|
}
|
|
@@ -1772,117 +1540,119 @@ function loadCodec() {
|
|
|
1772
1540
|
});
|
|
1773
1541
|
}
|
|
1774
1542
|
const tables = new Map();
|
|
1775
|
-
function
|
|
1776
|
-
let
|
|
1777
|
-
if (!
|
|
1778
|
-
|
|
1543
|
+
function tableFor(id, version, current) {
|
|
1544
|
+
let byVersion = tables.get(id);
|
|
1545
|
+
if (!byVersion) tables.set(id, byVersion = new Map());else for (const v of byVersion.keys()) if (v < current) byVersion.delete(v);
|
|
1546
|
+
let t = byVersion.get(version);
|
|
1547
|
+
if (!t && codec) byVersion.set(version, t = codec.createJSONDataTable());
|
|
1548
|
+
return t;
|
|
1549
|
+
}
|
|
1550
|
+
function followAddress(host, frame, binding) {
|
|
1551
|
+
createRenderEffect(() => {
|
|
1552
|
+
const token = binding();
|
|
1553
|
+
stagedContent.preview(token);
|
|
1554
|
+
return token;
|
|
1555
|
+
}, token => {
|
|
1556
|
+
stagedContent.commit(token);
|
|
1557
|
+
frame.rebind(contentAddress(token));
|
|
1558
|
+
});
|
|
1559
|
+
}
|
|
1560
|
+
function landing(host, address, value, failed) {
|
|
1561
|
+
let thrown = host.get(address)?.error;
|
|
1562
|
+
return createMemo(() => {
|
|
1563
|
+
failed();
|
|
1564
|
+
const error = host.get(address)?.error;
|
|
1565
|
+
if (error !== undefined && error !== thrown) {
|
|
1566
|
+
thrown = error;
|
|
1567
|
+
throw error;
|
|
1568
|
+
}
|
|
1569
|
+
const wait = host.landing(address);
|
|
1570
|
+
if (!wait) return value;
|
|
1571
|
+
const asked = error !== undefined ? reask(address) : undefined;
|
|
1572
|
+
return (asked ? asked.then(() => wait) : wait).then(() => value);
|
|
1573
|
+
});
|
|
1779
1574
|
}
|
|
1780
|
-
function
|
|
1781
|
-
|
|
1782
|
-
|
|
1783
|
-
return undefined;
|
|
1575
|
+
function reask(address) {
|
|
1576
|
+
const call = callFor(address);
|
|
1577
|
+
return call && call.retry();
|
|
1784
1578
|
}
|
|
1785
|
-
function
|
|
1786
|
-
|
|
1579
|
+
function failing() {
|
|
1580
|
+
const [failed, setFailed] = createSignal(0, {
|
|
1581
|
+
ownedWrite: true
|
|
1582
|
+
});
|
|
1583
|
+
return [failed, info => info.reason === "error" && setFailed(n => n + 1)];
|
|
1787
1584
|
}
|
|
1788
1585
|
function getFrameHost() {
|
|
1789
1586
|
if (!sharedHost) {
|
|
1790
1587
|
sharedHost = createFrameHost({
|
|
1791
1588
|
prepareData: loadCodec,
|
|
1792
|
-
applyData: c => tableFor(c.id)?.apply(c),
|
|
1793
|
-
resolve: (ref, id) => tableFor(id)?.resolve(ref),
|
|
1794
|
-
|
|
1795
|
-
isContainer: isMaterializedContainer,
|
|
1796
|
-
delegate: delegateEvents
|
|
1589
|
+
applyData: (c, current) => tableFor(c.id, c.version, current)?.apply(c),
|
|
1590
|
+
resolve: (ref, id, version, current) => tableFor(id, version, current)?.resolve(ref),
|
|
1591
|
+
closeData: (id, version, error) => tables.get(id)?.get(version)?.close(error)
|
|
1797
1592
|
});
|
|
1798
1593
|
}
|
|
1799
1594
|
return sharedHost;
|
|
1800
1595
|
}
|
|
1801
|
-
function
|
|
1802
|
-
while (typeof value === "function") value = value();
|
|
1803
|
-
if (Array.isArray(value)) {
|
|
1804
|
-
const out = [];
|
|
1805
|
-
for (const v of value) {
|
|
1806
|
-
const n = normalizeSlotContent(v);
|
|
1807
|
-
Array.isArray(n) ? out.push(...n) : out.push(n);
|
|
1808
|
-
}
|
|
1809
|
-
return out;
|
|
1810
|
-
}
|
|
1811
|
-
if (value == null || typeof value === "boolean") return document.createTextNode("");
|
|
1812
|
-
return value instanceof Node ? value : document.createTextNode(String(value));
|
|
1813
|
-
}
|
|
1814
|
-
function gatherClaims(el, registry) {
|
|
1815
|
-
if (el.hasAttribute("_hk")) registry.set(el.getAttribute("_hk"), el);
|
|
1816
|
-
if (el.hasAttribute(FRAME_ID_ATTR)) return;
|
|
1817
|
-
for (let c = el.firstElementChild; c; c = c.nextElementSibling) gatherClaims(c, registry);
|
|
1818
|
-
}
|
|
1819
|
-
function hasPendingFragment(existing) {
|
|
1820
|
-
for (const n of existing) {
|
|
1821
|
-
if (n.nodeType !== 1) continue;
|
|
1822
|
-
const el = n;
|
|
1823
|
-
if (el.tagName === "TEMPLATE" && el.id.startsWith("pl-")) return true;
|
|
1824
|
-
if (el.querySelector?.('template[id^="pl-"]')) return true;
|
|
1825
|
-
}
|
|
1826
|
-
return false;
|
|
1827
|
-
}
|
|
1828
|
-
function claimRender(prefix, existing, render) {
|
|
1596
|
+
function claimRender(prefix, existing, render, scope, bound) {
|
|
1829
1597
|
const sc = sharedConfig;
|
|
1830
|
-
if (!sc.
|
|
1831
|
-
const
|
|
1832
|
-
for (const n of existing) {
|
|
1833
|
-
if (n.nodeType !== 1) continue;
|
|
1834
|
-
gatherClaims(n, registry);
|
|
1835
|
-
}
|
|
1836
|
-
if (!registry.size && !hasPendingFragment(existing)) return render();
|
|
1837
|
-
const prevRegistry = sc.registry;
|
|
1838
|
-
const prevHydrating = sc.hydrating;
|
|
1839
|
-
const prevClaimRoots = sc.claimRoots;
|
|
1840
|
-
if (prevRegistry) for (const key of registry.keys()) prevRegistry.delete(key);
|
|
1841
|
-
sc.registry = registry;
|
|
1842
|
-
sc.hydrating = true;
|
|
1598
|
+
if (!sc.hydrateWindow || !sc.registry) return render();
|
|
1599
|
+
const prevRoots = sc.claimRoots;
|
|
1843
1600
|
sc.claimRoots = existing;
|
|
1844
1601
|
try {
|
|
1845
1602
|
return runWithOwner(createOwner({
|
|
1846
1603
|
id: prefix
|
|
1847
|
-
}), render);
|
|
1604
|
+
}), () => sc.hydrateWindow(bound ? undefined : prefix, render, scope));
|
|
1848
1605
|
} finally {
|
|
1849
|
-
sc.
|
|
1850
|
-
sc.hydrating = prevHydrating;
|
|
1851
|
-
sc.claimRoots = prevClaimRoots;
|
|
1606
|
+
sc.claimRoots = prevRoots;
|
|
1852
1607
|
}
|
|
1853
1608
|
}
|
|
1854
1609
|
function liveSlotProps(initial, ctx) {
|
|
1855
|
-
const [args, setArgs] = createSignal(initial
|
|
1610
|
+
const [args, setArgs] = createSignal(initial, {
|
|
1611
|
+
ownedWrite: true
|
|
1612
|
+
});
|
|
1856
1613
|
ctx.onUpdate(next => setArgs(() => next));
|
|
1857
1614
|
return slotArgsProxy(args);
|
|
1858
1615
|
}
|
|
1859
|
-
function
|
|
1860
|
-
|
|
1616
|
+
function sameArg(a, b) {
|
|
1617
|
+
if (a === b) return true;
|
|
1618
|
+
if (!a || !b || typeof a !== "object" || typeof b !== "object") return false;
|
|
1619
|
+
if (a instanceof Boxed || b instanceof Boxed) return a instanceof Boxed && b instanceof Boxed && a.c === b.c;
|
|
1620
|
+
if (isAsyncValue(a) || isAsyncValue(b) || a instanceof Node || b instanceof Node) return false;
|
|
1621
|
+
try {
|
|
1622
|
+
return JSON.stringify(a) === JSON.stringify(b);
|
|
1623
|
+
} catch {
|
|
1624
|
+
return false;
|
|
1625
|
+
}
|
|
1626
|
+
}
|
|
1627
|
+
class Boxed {
|
|
1628
|
+
constructor(c) {
|
|
1629
|
+
this.c = c;
|
|
1630
|
+
}
|
|
1861
1631
|
}
|
|
1862
1632
|
function slotArgsProxy(args) {
|
|
1863
1633
|
const owner = getOwner();
|
|
1864
|
-
const
|
|
1634
|
+
const reads = new Map();
|
|
1865
1635
|
return new Proxy({}, {
|
|
1866
1636
|
get: (_, key) => {
|
|
1867
|
-
|
|
1868
|
-
if (isMaterializedContainer(v)) return v;
|
|
1869
|
-
if (!isAsyncValue(v)) return v;
|
|
1870
|
-
let read = asyncReads.get(key);
|
|
1637
|
+
let read = reads.get(key);
|
|
1871
1638
|
if (!read) {
|
|
1872
1639
|
const make = () => createMemo(() => {
|
|
1873
1640
|
const raw = args()[key];
|
|
1641
|
+
if (globalThis[TRACE_STATE]?.materializedValues.has(raw)) return new Boxed(raw);
|
|
1874
1642
|
if (raw != null && typeof raw.then === "function") {
|
|
1875
1643
|
if (raw.s === 1) return raw.v;
|
|
1876
1644
|
if (raw.s === 2) throw raw.v;
|
|
1877
1645
|
}
|
|
1878
1646
|
return raw;
|
|
1879
1647
|
}, {
|
|
1880
|
-
transparent: true
|
|
1648
|
+
transparent: true,
|
|
1649
|
+
equals: sameArg
|
|
1881
1650
|
});
|
|
1882
1651
|
read = owner ? runWithOwner(owner, make) : make();
|
|
1883
|
-
|
|
1652
|
+
reads.set(key, read);
|
|
1884
1653
|
}
|
|
1885
|
-
|
|
1654
|
+
const v = read();
|
|
1655
|
+
return v instanceof Boxed ? v.c : v;
|
|
1886
1656
|
},
|
|
1887
1657
|
has: (_, key) => key in args(),
|
|
1888
1658
|
ownKeys: () => Reflect.ownKeys(args()),
|
|
@@ -1892,31 +1662,37 @@ function slotArgsProxy(args) {
|
|
|
1892
1662
|
} : undefined
|
|
1893
1663
|
});
|
|
1894
1664
|
}
|
|
1895
|
-
function
|
|
1896
|
-
if (typeof value === "function") return true;
|
|
1897
|
-
if (Array.isArray(value)) {
|
|
1898
|
-
for (const v of value) if (isReactiveContent(v)) return true;
|
|
1899
|
-
}
|
|
1900
|
-
return false;
|
|
1901
|
-
}
|
|
1902
|
-
function slotsFor(props) {
|
|
1903
|
-
const bindings = new Map();
|
|
1665
|
+
function slotsFor(props, scope) {
|
|
1904
1666
|
const fillScopes = new Map();
|
|
1905
1667
|
return new Proxy({}, {
|
|
1906
1668
|
get(_, prop) {
|
|
1907
1669
|
if (typeof prop !== "string" || !(prop in props)) return undefined;
|
|
1908
1670
|
return (slotProps, ctx) => {
|
|
1909
1671
|
const key = ctx && ctx.key;
|
|
1910
|
-
const prev = key !== undefined && bindings.get(key);
|
|
1911
|
-
if (prev) {
|
|
1912
|
-
bindings.delete(key);
|
|
1913
|
-
prev.dispose();
|
|
1914
|
-
}
|
|
1915
1672
|
const prevFill = key !== undefined && fillScopes.get(key);
|
|
1916
1673
|
if (prevFill) {
|
|
1917
1674
|
fillScopes.delete(key);
|
|
1918
1675
|
prevFill.dispose();
|
|
1919
1676
|
}
|
|
1677
|
+
if (ctx && ctx.positions) {
|
|
1678
|
+
const fill = props[prop];
|
|
1679
|
+
if (typeof fill !== "function") {
|
|
1680
|
+
return undefined;
|
|
1681
|
+
}
|
|
1682
|
+
const owner = createOwner();
|
|
1683
|
+
fillScopes.set(key, owner);
|
|
1684
|
+
ctx.onCleanup(() => {
|
|
1685
|
+
if (fillScopes.get(key) === owner) fillScopes.delete(key);
|
|
1686
|
+
owner.dispose();
|
|
1687
|
+
});
|
|
1688
|
+
runWithOwner(owner, () => {
|
|
1689
|
+
const args = ctx.onUpdate ? liveSlotProps(slotProps, ctx) : slotArgsProxy(() => slotProps);
|
|
1690
|
+
tierLoads.bind.r.bind(fill, args, ctx, undefined);
|
|
1691
|
+
});
|
|
1692
|
+
return undefined;
|
|
1693
|
+
}
|
|
1694
|
+
const range = ctx && ctx.range;
|
|
1695
|
+
if (!range) return undefined;
|
|
1920
1696
|
const fillOwner = streamInvoke ? createOwner() : null;
|
|
1921
1697
|
if (fillOwner && key !== undefined && ctx) {
|
|
1922
1698
|
fillScopes.set(key, fillOwner);
|
|
@@ -1925,42 +1701,31 @@ function slotsFor(props) {
|
|
|
1925
1701
|
fillOwner.dispose();
|
|
1926
1702
|
});
|
|
1927
1703
|
}
|
|
1928
|
-
const settle = out => {
|
|
1929
|
-
const existing = ctx && ctx.existing || [];
|
|
1930
|
-
if (existing.length) {
|
|
1931
|
-
const list = Array.isArray(out) ? out : [out];
|
|
1932
|
-
const inPlace = list.every(n => existing.some(e => e === n || e.nodeType === 1 && e.contains(n)));
|
|
1933
|
-
if (inPlace) return undefined;
|
|
1934
|
-
}
|
|
1935
|
-
return out;
|
|
1936
|
-
};
|
|
1937
1704
|
const evaluate = () => {
|
|
1938
1705
|
const v = props[prop];
|
|
1939
1706
|
if (typeof v === "function" && ctx && ctx.invoked) {
|
|
1940
|
-
|
|
1707
|
+
const fillProps = ctx.onUpdate ? liveSlotProps(slotProps, ctx) : slotArgsProxy(() => slotProps);
|
|
1708
|
+
return untrack(() => v(fillProps), undefined);
|
|
1941
1709
|
}
|
|
1942
1710
|
return v;
|
|
1943
1711
|
};
|
|
1944
1712
|
const adopted = !!(ctx && ctx.frame && ctx.adopted && ctx.existing && ctx.existing.length);
|
|
1945
1713
|
const prefix = ctx && ctx.frame ? `sc-${ctx.frame}-${ctx.key}-` : "";
|
|
1946
|
-
const value = fillOwner ? runWithOwner(fillOwner, () => adopted ? claimRender(prefix, ctx.existing, evaluate) : evaluate()) : adopted ? claimRender(prefix, ctx.existing, evaluate) : evaluate();
|
|
1947
|
-
|
|
1948
|
-
|
|
1949
|
-
}
|
|
1950
|
-
if (
|
|
1951
|
-
|
|
1952
|
-
const owner = createOwner();
|
|
1953
|
-
bindings.set(key, owner);
|
|
1714
|
+
const value = fillOwner ? runWithOwner(fillOwner, () => adopted ? claimRender(prefix, ctx.existing, evaluate, scope) : evaluate()) : adopted ? claimRender(prefix, ctx.existing, evaluate, scope) : evaluate();
|
|
1715
|
+
const owner = fillOwner || createOwner({
|
|
1716
|
+
transparent: true
|
|
1717
|
+
});
|
|
1718
|
+
if (!fillOwner) {
|
|
1719
|
+
fillScopes.set(key, owner);
|
|
1954
1720
|
ctx.onCleanup(() => {
|
|
1955
|
-
if (
|
|
1721
|
+
if (fillScopes.get(key) === owner) fillScopes.delete(key);
|
|
1956
1722
|
owner.dispose();
|
|
1957
1723
|
});
|
|
1958
|
-
const end = ctx.range.end;
|
|
1959
|
-
const bind = () => insert(end.parentNode, () => typeof source === "function" ? source() : source, end, [...ctx.existing]);
|
|
1960
|
-
runWithOwner(owner, () => adopted ? claimRender(prefix, ctx.existing, bind) : bind());
|
|
1961
|
-
return undefined;
|
|
1962
1724
|
}
|
|
1963
|
-
|
|
1725
|
+
const end = range.end;
|
|
1726
|
+
const bind = () => insert(end.parentNode, value, end, [...ctx.existing]);
|
|
1727
|
+
runWithOwner(owner, () => adopted ? claimRender(prefix, ctx.existing, bind, scope, true) : bind());
|
|
1728
|
+
return undefined;
|
|
1964
1729
|
};
|
|
1965
1730
|
}
|
|
1966
1731
|
});
|
|
@@ -1983,12 +1748,8 @@ function boundaryScope(owner) {
|
|
|
1983
1748
|
function boundaryComponent(host, fnId) {
|
|
1984
1749
|
return (props, binding) => {
|
|
1985
1750
|
const owner = getOwner();
|
|
1986
|
-
const id = binding ? binding() : fnId;
|
|
1987
|
-
|
|
1988
|
-
let release;
|
|
1989
|
-
const arm = () => new Promise(r => release = r);
|
|
1990
|
-
const mountGate = applied ? undefined : arm();
|
|
1991
|
-
let setGate;
|
|
1751
|
+
const id = binding ? contentAddress(binding()) : fnId;
|
|
1752
|
+
const [failed, onApply] = failing();
|
|
1992
1753
|
const {
|
|
1993
1754
|
element,
|
|
1994
1755
|
frame,
|
|
@@ -1997,33 +1758,14 @@ function boundaryComponent(host, fnId) {
|
|
|
1997
1758
|
host,
|
|
1998
1759
|
id,
|
|
1999
1760
|
slots: slotsFor(props),
|
|
2000
|
-
props,
|
|
2001
1761
|
ownerScope: boundaryScope(owner),
|
|
2002
1762
|
reveal: revealSeam(owner),
|
|
2003
|
-
onApply
|
|
2004
|
-
applied = true;
|
|
2005
|
-
if (release) {
|
|
2006
|
-
release();
|
|
2007
|
-
release = undefined;
|
|
2008
|
-
}
|
|
2009
|
-
setGate && setGate(undefined);
|
|
2010
|
-
}
|
|
1763
|
+
onApply
|
|
2011
1764
|
});
|
|
2012
|
-
const [gatePromise, setGatePromise] = createSignal(applied ? undefined : mountGate);
|
|
2013
|
-
setGate = setGatePromise;
|
|
2014
|
-
if (binding) {
|
|
2015
|
-
createRenderEffect(binding, (address, prev) => {
|
|
2016
|
-
if (prev !== undefined && address !== prev && tables.has(address)) {
|
|
2017
|
-
applied = false;
|
|
2018
|
-
setGatePromise(arm());
|
|
2019
|
-
}
|
|
2020
|
-
frame.rebind(address);
|
|
2021
|
-
});
|
|
2022
|
-
}
|
|
2023
1765
|
onCleanup(dispose);
|
|
2024
|
-
if (
|
|
2025
|
-
|
|
2026
|
-
return createMemo(() => (
|
|
1766
|
+
if (!binding) return landing(host, id, element, failed);
|
|
1767
|
+
followAddress(host, frame, binding);
|
|
1768
|
+
return createMemo(() => landing(host, contentAddress(binding()), element, failed));
|
|
2027
1769
|
};
|
|
2028
1770
|
}
|
|
2029
1771
|
const claimedBoundaries = new Set();
|
|
@@ -2038,7 +1780,7 @@ function pumpLiveChannel() {
|
|
|
2038
1780
|
const pump = () => reader.read().then(r => {
|
|
2039
1781
|
if (r.done) return;
|
|
2040
1782
|
const op = r.value;
|
|
2041
|
-
liveOps.set(`${
|
|
1783
|
+
for (const m of op.type === "ops" ? op.ops : [op]) liveOps.set(`${m.type}:${m.fid || ""}:${m.key || ""}`, m);
|
|
2042
1784
|
for (const apply of liveAppliers) apply(op);
|
|
2043
1785
|
return pump();
|
|
2044
1786
|
});
|
|
@@ -2048,7 +1790,7 @@ function pumpLiveChannel() {
|
|
|
2048
1790
|
let boundaryIndex = null;
|
|
2049
1791
|
const isBoundaryId = id => !id.includes(".");
|
|
2050
1792
|
function indexBoundaries(root) {
|
|
2051
|
-
root.querySelectorAll(
|
|
1793
|
+
root.querySelectorAll(FRAME_SELECTOR).forEach(el => {
|
|
2052
1794
|
const key = el.getAttribute(FRAME_ID_ATTR);
|
|
2053
1795
|
if (key && isBoundaryId(key) && !boundaryIndex.has(key)) boundaryIndex.set(key, el);
|
|
2054
1796
|
});
|
|
@@ -2060,8 +1802,9 @@ function findBoundaryElement(id) {
|
|
|
2060
1802
|
}
|
|
2061
1803
|
return boundaryIndex.get(id);
|
|
2062
1804
|
}
|
|
2063
|
-
const boundaryWaiters = new Map();
|
|
2064
1805
|
const arrivals = new Map();
|
|
1806
|
+
const FRAME_SELECTOR = `[${FRAME_ID_ATTR}]`;
|
|
1807
|
+
const disposedFrames = new WeakSet();
|
|
2065
1808
|
function awaitBoundary(id) {
|
|
2066
1809
|
let arrival = arrivals.get(id);
|
|
2067
1810
|
if (!arrival) {
|
|
@@ -2083,18 +1826,16 @@ function installRevealHook() {
|
|
|
2083
1826
|
const hy = globalThis._$HY;
|
|
2084
1827
|
if (!hy || hy.$sc || !hy.fr) return;
|
|
2085
1828
|
hy.$sc = true;
|
|
1829
|
+
hy.fa = pl => {
|
|
1830
|
+
const el = pl.closest(FRAME_SELECTOR);
|
|
1831
|
+
return !!el && !disposedFrames.has(el);
|
|
1832
|
+
};
|
|
2086
1833
|
hy.fr.subscribe((_id, parent) => {
|
|
2087
1834
|
if (!boundaryIndex) return;
|
|
2088
1835
|
const root = parent || (typeof document !== "undefined" ? document.body : null);
|
|
2089
1836
|
if (root) indexBoundaries(root);
|
|
2090
|
-
if (!
|
|
1837
|
+
if (!arrivals.size) return;
|
|
2091
1838
|
const exhausted = hy.done && !hy.fr.pending();
|
|
2092
|
-
for (const [id, notify] of boundaryWaiters) {
|
|
2093
|
-
const el = boundaryIndex && boundaryIndex.get(id);
|
|
2094
|
-
if (!el && !exhausted) continue;
|
|
2095
|
-
boundaryWaiters.delete(id);
|
|
2096
|
-
notify(el);
|
|
2097
|
-
}
|
|
2098
1839
|
for (const [id, arrival] of arrivals) {
|
|
2099
1840
|
const el = boundaryIndex && boundaryIndex.get(id);
|
|
2100
1841
|
if (!el && !exhausted) continue;
|
|
@@ -2108,37 +1849,21 @@ function documentBoundary(host, id, props, binding) {
|
|
|
2108
1849
|
const claimed = claimedBoundaries.has(id);
|
|
2109
1850
|
const el = !claimed ? findBoundaryElement(id) : undefined;
|
|
2110
1851
|
if (el) return adoptBoundary(host, id, el, props, binding);
|
|
2111
|
-
if (!claimed &&
|
|
1852
|
+
if (!claimed && boundaryMayArrive()) {
|
|
2112
1853
|
const owner = getOwner();
|
|
2113
|
-
|
|
2114
|
-
onCleanup(() =>
|
|
2115
|
-
return createMemo(() =>
|
|
2116
|
-
|
|
1854
|
+
let live = true;
|
|
1855
|
+
onCleanup(() => live = false);
|
|
1856
|
+
return createMemo(() => awaitBoundary(id).then(() => live && runWithOwner(owner, () => {
|
|
1857
|
+
const node = claimedBoundaries.has(id) ? undefined : findBoundaryElement(id);
|
|
1858
|
+
return node ? adoptBoundary(host, id, node, props, binding) : boundaryComponent(host, id)(props, binding);
|
|
1859
|
+
})));
|
|
2117
1860
|
}
|
|
2118
1861
|
return boundaryComponent(host, id)(props, binding);
|
|
2119
1862
|
}
|
|
2120
|
-
function documentAddress(id) {
|
|
2121
|
-
const records = globalThis._$SC?.a;
|
|
2122
|
-
if (records) {
|
|
2123
|
-
for (const address in records) if (records[address] === id) return address;
|
|
2124
|
-
}
|
|
2125
|
-
return id;
|
|
2126
|
-
}
|
|
2127
1863
|
function adoptBoundary(host, id, el, props, binding) {
|
|
2128
1864
|
claimedBoundaries.add(id);
|
|
2129
|
-
const address = binding ? binding() :
|
|
1865
|
+
const address = binding ? contentAddress(binding()) : id;
|
|
2130
1866
|
const appliedRecords = new Set();
|
|
2131
|
-
const claimedFragments = new Set();
|
|
2132
|
-
const claimRegionFragments = root => {
|
|
2133
|
-
const fr = globalThis._$HY?.fr;
|
|
2134
|
-
if (!fr || !fr.claim) return;
|
|
2135
|
-
root.querySelectorAll('template[id^="pl-"]').forEach(tpl => {
|
|
2136
|
-
const fragId = tpl.id.slice(3);
|
|
2137
|
-
if (claimedFragments.has(fragId)) return;
|
|
2138
|
-
claimedFragments.add(fragId);
|
|
2139
|
-
fr.claim(fragId);
|
|
2140
|
-
});
|
|
2141
|
-
};
|
|
2142
1867
|
const drainRecords = () => {
|
|
2143
1868
|
const hy = globalThis._$HY;
|
|
2144
1869
|
if (!hy || !hy.r) return;
|
|
@@ -2148,13 +1873,17 @@ function adoptBoundary(host, id, el, props, binding) {
|
|
|
2148
1873
|
if (appliedRecords.has(key)) continue;
|
|
2149
1874
|
if (key.startsWith(slotPrefix)) {
|
|
2150
1875
|
appliedRecords.add(key);
|
|
2151
|
-
host.apply({
|
|
1876
|
+
const apply = args => host.apply({
|
|
2152
1877
|
type: "slot",
|
|
2153
1878
|
id: address,
|
|
2154
1879
|
version: 0,
|
|
2155
1880
|
key: key.slice(slotPrefix.length),
|
|
2156
|
-
args
|
|
1881
|
+
args
|
|
2157
1882
|
});
|
|
1883
|
+
const value = hy.r[key];
|
|
1884
|
+
if (value && typeof value.then === "function") {
|
|
1885
|
+
if (value.s === 1) apply(value.v);else if (value.s === 2) value.then(undefined, () => {});else value.then(apply, () => {});
|
|
1886
|
+
} else apply(value);
|
|
2158
1887
|
} else if (key.startsWith("sc:region:")) {
|
|
2159
1888
|
const childId = key.slice("sc:region:".length);
|
|
2160
1889
|
if (childId.startsWith(id + ".")) {
|
|
@@ -2171,14 +1900,18 @@ function adoptBoundary(host, id, el, props, binding) {
|
|
|
2171
1900
|
}
|
|
2172
1901
|
}
|
|
2173
1902
|
};
|
|
2174
|
-
claimRegionFragments(el);
|
|
2175
1903
|
const fr = globalThis._$HY?.fr;
|
|
1904
|
+
let frame;
|
|
2176
1905
|
const unsubscribe = fr ? fr.subscribe((_fragId, parent) => {
|
|
2177
|
-
|
|
1906
|
+
const inside = !!parent && el.contains(parent);
|
|
2178
1907
|
drainRecords();
|
|
1908
|
+
if (inside && frame) frame.apply({
|
|
1909
|
+
version: frame.version ?? 0,
|
|
1910
|
+
r: {}
|
|
1911
|
+
});
|
|
2179
1912
|
}) : undefined;
|
|
2180
1913
|
const applyLiveOp = op => {
|
|
2181
|
-
if (op.
|
|
1914
|
+
if (op.fid && op.fid !== id) return;
|
|
2182
1915
|
host.apply({
|
|
2183
1916
|
...op,
|
|
2184
1917
|
id: address,
|
|
@@ -2189,56 +1922,44 @@ function adoptBoundary(host, id, el, props, binding) {
|
|
|
2189
1922
|
onCleanup(() => {
|
|
2190
1923
|
liveAppliers.delete(applyLiveOp);
|
|
2191
1924
|
unsubscribe && unsubscribe();
|
|
2192
|
-
if (fr && fr.release) for (const fragId of claimedFragments) fr.release(fragId);
|
|
2193
1925
|
});
|
|
2194
1926
|
drainRecords();
|
|
2195
1927
|
for (const op of liveOps.values()) applyLiveOp(op);
|
|
2196
1928
|
const owner = getOwner();
|
|
2197
|
-
|
|
2198
|
-
|
|
2199
|
-
|
|
1929
|
+
const sc = sharedConfig;
|
|
1930
|
+
const [failed, onApply] = failing();
|
|
1931
|
+
frame = createFrame(el, {
|
|
2200
1932
|
adopt: true,
|
|
2201
1933
|
host,
|
|
2202
1934
|
id: address,
|
|
2203
|
-
slots: slotsFor(props
|
|
2204
|
-
|
|
1935
|
+
slots: slotsFor(props, {
|
|
1936
|
+
registry: sc.registry,
|
|
1937
|
+
gather: sc.gather
|
|
1938
|
+
}),
|
|
2205
1939
|
ownerScope: boundaryScope(owner),
|
|
2206
1940
|
reveal: revealSeam(owner),
|
|
2207
|
-
onApply
|
|
2208
|
-
|
|
2209
|
-
release();
|
|
2210
|
-
release = undefined;
|
|
2211
|
-
}
|
|
2212
|
-
setGate && setGate(undefined);
|
|
2213
|
-
},
|
|
1941
|
+
onApply,
|
|
1942
|
+
hold: () => sc.isHydrationInProgress?.() ? runWithOwner(owner, () => untrack(() => sc.holdBoundary("sc:" + id))) : () => {},
|
|
2214
1943
|
...{
|
|
2215
|
-
recordsPending: () => {
|
|
2216
|
-
if (document.readyState === "loading") return true;
|
|
2217
|
-
const hy = globalThis._$HY;
|
|
2218
|
-
return !!(hy && hy.fr && hy.fr.pending());
|
|
2219
|
-
},
|
|
2220
|
-
drainRecords,
|
|
2221
1944
|
claimScope: id
|
|
2222
1945
|
}
|
|
2223
1946
|
});
|
|
2224
1947
|
if (binding) {
|
|
2225
|
-
|
|
2226
|
-
const
|
|
2227
|
-
|
|
2228
|
-
const gate = createMemo(() => gatePromise());
|
|
2229
|
-
createRenderEffect(binding, (address, prev) => {
|
|
2230
|
-
if (prev !== undefined && address !== prev && tables.has(address)) {
|
|
2231
|
-
setGatePromise(arm());
|
|
2232
|
-
}
|
|
2233
|
-
frame.rebind(address);
|
|
2234
|
-
});
|
|
2235
|
-
createRenderEffect(() => (gate(), undefined), () => {});
|
|
1948
|
+
followAddress(host, frame, binding);
|
|
1949
|
+
const source = createMemo(() => landing(host, contentAddress(binding()), true, failed));
|
|
1950
|
+
createRenderEffect(() => source()(), () => {});
|
|
2236
1951
|
}
|
|
2237
|
-
onCleanup(() =>
|
|
1952
|
+
onCleanup(() => {
|
|
1953
|
+
frame.dispose();
|
|
1954
|
+
disposedFrames.add(el);
|
|
1955
|
+
el.querySelectorAll(FRAME_SELECTOR).forEach(e => disposedFrames.add(e));
|
|
1956
|
+
});
|
|
2238
1957
|
return el;
|
|
2239
1958
|
}
|
|
2240
|
-
function installServerComponents(host = getFrameHost()) {
|
|
1959
|
+
function installServerComponents(host = getFrameHost(), options) {
|
|
2241
1960
|
const g = globalThis;
|
|
1961
|
+
Object.assign(tierLoaders, options?.tiers);
|
|
1962
|
+
g._$HY?.r?.["sc:tiers"]?.forEach(prepareTier);
|
|
2242
1963
|
if (!g._$SC) {
|
|
2243
1964
|
g._$SC = {
|
|
2244
1965
|
c: {},
|
|
@@ -2263,7 +1984,6 @@ function installServerComponents(host = getFrameHost()) {
|
|
|
2263
1984
|
const handler = createServerComponentHandler({
|
|
2264
1985
|
host,
|
|
2265
1986
|
component: fnId => g._$SC.r(fnId),
|
|
2266
|
-
onStream: address => beginStream(address),
|
|
2267
1987
|
intercept: ({
|
|
2268
1988
|
id
|
|
2269
1989
|
}) => {
|
|
@@ -2283,4 +2003,4 @@ function installServerComponents(host = getFrameHost()) {
|
|
|
2283
2003
|
});
|
|
2284
2004
|
}
|
|
2285
2005
|
|
|
2286
|
-
export { FRAME_APPLIED_EVENT,
|
|
2006
|
+
export { FRAME_APPLIED_EVENT, FRAME_STREAM_HEADER, applyFrameResponse, asyncArg, createFrame, createFrameElement, createFrameHost, createServerComponentHandler, getFrameHost, installServerComponents, isAsyncValue, isFrameStreamResponse };
|