octane 0.6.0 → 0.6.2
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/cjs/dom-binding-handoff.cjs +26 -12
- package/dist/cjs/dom-binding-protocol.cjs +42 -21
- package/dist/cjs/dom-binding-styles.cjs +68 -55
- package/dist/cjs/dom-bindings.cjs +308 -227
- package/dist/cjs/error-codes.client.generated.cjs +829 -0
- package/dist/cjs/error-codes.server.generated.cjs +565 -0
- package/dist/cjs/hydration/event-capture.cjs +81 -44
- package/dist/cjs/independent-hydration-protocol.cjs +19 -9
- package/dist/cjs/runtime.cjs +222 -52
- package/dist/cjs/runtime.server.cjs +45 -1
- package/dist/cjs/server/streamed-signals.cjs +2 -4
- package/dist/cjs/signals/actions.cjs +31 -34
- package/dist/cjs/signals/computations.cjs +10 -13
- package/dist/cjs/signals/control-binding.cjs +120 -101
- package/dist/cjs/signals/derived-facade.cjs +9 -10
- package/dist/cjs/signals/document-owner.cjs +13 -9
- package/dist/cjs/signals/engine.cjs +29 -42
- package/dist/cjs/signals/errors.cjs +6 -5
- package/dist/cjs/signals/facade.cjs +91 -87
- package/dist/cjs/signals/graph.cjs +138 -78
- package/dist/cjs/signals/native-read-client.cjs +77 -37
- package/dist/cjs/signals/native-read-seeds.cjs +21 -28
- package/dist/cjs/signals/owner-context.cjs +19 -9
- package/dist/cjs/signals/query-attempt-observer.cjs +9 -9
- package/dist/cjs/signals/query-facade.cjs +8 -15
- package/dist/cjs/signals/read-protocol.cjs +2 -1
- package/dist/cjs/signals/requests.cjs +13 -18
- package/dist/cjs/signals/scalar-computations.cjs +6 -2
- package/dist/cjs/signals/transition-action.cjs +187 -116
- package/dist/cjs/signals/transition-candidate.cjs +29 -16
- package/dist/cjs/version.cjs +1 -1
- package/dist/compiler/native-read-codegen.js +4 -0
- package/dist/dom-binding-classes.js +45 -23
- package/dist/dom-binding-handoff.js +26 -12
- package/dist/dom-binding-program.js +356 -393
- package/dist/dom-binding-projections.js +58 -42
- package/dist/dom-binding-protocol.js +43 -28
- package/dist/dom-binding-signals.js +38 -42
- package/dist/dom-binding-styles.js +69 -62
- package/dist/dom-bindings.js +309 -231
- package/dist/error-codes.client.generated.d.ts +251 -0
- package/dist/error-codes.client.generated.js +829 -0
- package/dist/error-codes.server.generated.d.ts +191 -0
- package/dist/error-codes.server.generated.js +565 -0
- package/dist/hydration/document-lifecycle.js +14 -6
- package/dist/hydration/event-capture.js +85 -67
- package/dist/hydration/independent-island.js +155 -150
- package/dist/hydration/stream-delivery.js +83 -79
- package/dist/hydration/stream-receiver.js +12 -26
- package/dist/hydration/stream-result-receiver.js +60 -47
- package/dist/hydration/streamed-signals.js +51 -54
- package/dist/independent-hydration-protocol.js +19 -9
- package/dist/index.d.ts +1 -1
- package/dist/react/react-compat-server.js +1 -0
- package/dist/react/react-compat.js +1 -0
- package/dist/runtime.d.ts +30 -9
- package/dist/runtime.js +222 -52
- package/dist/runtime.server.d.ts +2 -1
- package/dist/runtime.server.js +45 -1
- package/dist/server/streamed-signals.js +2 -4
- package/dist/signals/actions.js +31 -34
- package/dist/signals/computations.js +10 -13
- package/dist/signals/control-binding.js +125 -125
- package/dist/signals/derived-facade.js +9 -10
- package/dist/signals/document-owner.js +13 -9
- package/dist/signals/engine.js +29 -42
- package/dist/signals/errors.js +6 -5
- package/dist/signals/facade.js +94 -108
- package/dist/signals/graph.js +143 -116
- package/dist/signals/native-read-client.js +78 -41
- package/dist/signals/native-read-seeds.js +21 -28
- package/dist/signals/owner-context.js +19 -9
- package/dist/signals/query-attempt-observer.js +9 -9
- package/dist/signals/query-facade.js +9 -18
- package/dist/signals/read-protocol.js +2 -1
- package/dist/signals/requests.js +13 -18
- package/dist/signals/scalar-computations.js +7 -11
- package/dist/signals/transition-action.js +189 -132
- package/dist/signals/transition-candidate.js +30 -19
- package/dist/universal-core.d.ts +1 -1
- package/dist/universal-core.js +2 -0
- package/dist/version.js +1 -1
- package/package.json +1 -1
package/dist/signals/graph.js
CHANGED
|
@@ -1,43 +1,13 @@
|
|
|
1
|
-
import {
|
|
2
|
-
activeCandidate,
|
|
3
|
-
candidateWriteCount,
|
|
4
|
-
deferCandidateInvalidation,
|
|
5
|
-
recordCandidateUrgentWrite,
|
|
6
|
-
registerCandidateGraph,
|
|
7
|
-
registerSignalActionFrameFactory,
|
|
8
|
-
registerSignalTransitionCoordinatorFactory,
|
|
9
|
-
withoutSignalCandidate
|
|
10
|
-
} from "./transition-state.js";
|
|
1
|
+
import { activeCandidate, candidateWriteCount, deferCandidateInvalidation, recordCandidateUrgentWrite, registerCandidateGraph, registerSignalActionFrameFactory, registerSignalTransitionCoordinatorFactory, withoutSignalCandidate } from "./transition-state.js";
|
|
11
2
|
import { SignalActionFrame } from "./transition-action.js";
|
|
12
3
|
import { createSignalTransitionCoordinator } from "./transition-coordinator.js";
|
|
13
|
-
import {
|
|
14
|
-
|
|
15
|
-
} from "
|
|
16
|
-
import {
|
|
17
|
-
|
|
18
|
-
|
|
19
|
-
|
|
20
|
-
SignalIdleError,
|
|
21
|
-
SignalWriteError
|
|
22
|
-
} from "./errors.js";
|
|
23
|
-
import {
|
|
24
|
-
NativeAdoptionMiss,
|
|
25
|
-
NATIVE_DOM_VALUE,
|
|
26
|
-
getNativeCandidate,
|
|
27
|
-
forwardNativeTransitionConsumer,
|
|
28
|
-
getNativeReadObserver,
|
|
29
|
-
getNativeAdoptionResolver,
|
|
30
|
-
isNativeWriteGuarded,
|
|
31
|
-
reportNativeRead,
|
|
32
|
-
setNativeAdoptionResolver,
|
|
33
|
-
setNativeReadObserver
|
|
34
|
-
} from "./read-protocol.js";
|
|
35
|
-
import {
|
|
36
|
-
SIGNAL_BINDING_READ,
|
|
37
|
-
SIGNAL_BINDING_SUBSCRIBE,
|
|
38
|
-
SIGNAL_BINDING_IDENTITY,
|
|
39
|
-
SIGNAL_HANDLE
|
|
40
|
-
} from "./types.js";
|
|
4
|
+
import { createReactiveSystem } from "alien-signals/system";
|
|
5
|
+
import { ScopeDisposedError, SignalCycleError, SignalFrameError, SignalIdleError, SignalWriteError } from "./errors.js";
|
|
6
|
+
import { NativeAdoptionMiss, NATIVE_DOM_VALUE, getNativeCandidate, forwardNativeTransitionConsumer, getNativeReadObserver, getNativeAdoptionResolver, isNativeWriteGuarded, reportNativeRead, setNativeAdoptionResolver, setNativeReadObserver } from "./read-protocol.js";
|
|
7
|
+
import { SIGNAL_BINDING_READ, SIGNAL_BINDING_SUBSCRIBE, SIGNAL_BINDING_IDENTITY, SIGNAL_HANDLE } from "./types.js";
|
|
8
|
+
function __octaneNoArgError(code) {
|
|
9
|
+
return "Minified Octane error #" + code + "; visit https://octanejs.dev/errors/" + code + " for the full message or use a development build for full errors and additional helpful warnings.";
|
|
10
|
+
}
|
|
41
11
|
import { CandidateUnsupportedError } from "./transition-state.js";
|
|
42
12
|
const ReactiveFlags = {
|
|
43
13
|
None: 0,
|
|
@@ -81,11 +51,14 @@ const graph = createReactiveSystem({
|
|
|
81
51
|
if (deferCandidateInvalidation) {
|
|
82
52
|
const invalidate = node.invalidateAttempt;
|
|
83
53
|
queued.add(() => {
|
|
84
|
-
if (node.invalidateAttempt === invalidate)
|
|
54
|
+
if (node.invalidateAttempt === invalidate)
|
|
55
|
+
invalidate();
|
|
85
56
|
});
|
|
86
|
-
} else
|
|
57
|
+
} else
|
|
58
|
+
node.invalidateAttempt();
|
|
59
|
+
queued.add(node);
|
|
60
|
+
} else if (node.kind === "async")
|
|
87
61
|
queued.add(node);
|
|
88
|
-
} else if (node.kind === "async") queued.add(node);
|
|
89
62
|
} else {
|
|
90
63
|
queued.add(node);
|
|
91
64
|
}
|
|
@@ -100,7 +73,8 @@ function isThenable(value) {
|
|
|
100
73
|
return value !== null && (typeof value === "object" || typeof value === "function") && typeof value.then === "function";
|
|
101
74
|
}
|
|
102
75
|
function assertWritable() {
|
|
103
|
-
if (pureDepth || isNativeWriteGuarded())
|
|
76
|
+
if (pureDepth || isNativeWriteGuarded())
|
|
77
|
+
throw new SignalWriteError();
|
|
104
78
|
}
|
|
105
79
|
function setHistoricalReader(read) {
|
|
106
80
|
const previous = historicalReader;
|
|
@@ -133,7 +107,8 @@ function startSignalBatch() {
|
|
|
133
107
|
batchDepth++;
|
|
134
108
|
}
|
|
135
109
|
function endSignalBatch() {
|
|
136
|
-
if (--batchDepth === 0)
|
|
110
|
+
if (--batchDepth === 0)
|
|
111
|
+
flush();
|
|
137
112
|
}
|
|
138
113
|
function signalBatch(run) {
|
|
139
114
|
startSignalBatch();
|
|
@@ -144,7 +119,8 @@ function signalBatch(run) {
|
|
|
144
119
|
}
|
|
145
120
|
}
|
|
146
121
|
function flush() {
|
|
147
|
-
if (flushing)
|
|
122
|
+
if (flushing)
|
|
123
|
+
return;
|
|
148
124
|
flushing = true;
|
|
149
125
|
let firstError;
|
|
150
126
|
let failed = false;
|
|
@@ -155,19 +131,22 @@ function flush() {
|
|
|
155
131
|
if (typeof work === "function") {
|
|
156
132
|
untrack(work);
|
|
157
133
|
} else if (work instanceof ScopedNode) {
|
|
158
|
-
if (!work.owner.retired)
|
|
134
|
+
if (!work.owner.retired)
|
|
135
|
+
refreshNode(work);
|
|
159
136
|
} else {
|
|
160
137
|
runObserver(work);
|
|
161
138
|
}
|
|
162
139
|
} catch (error) {
|
|
163
|
-
if (!failed)
|
|
140
|
+
if (!failed)
|
|
141
|
+
firstError = error;
|
|
164
142
|
failed = true;
|
|
165
143
|
}
|
|
166
144
|
}
|
|
167
145
|
} finally {
|
|
168
146
|
flushing = false;
|
|
169
147
|
}
|
|
170
|
-
if (failed)
|
|
148
|
+
if (failed)
|
|
149
|
+
throw firstError;
|
|
171
150
|
}
|
|
172
151
|
function readyState(value, activity = noActivity) {
|
|
173
152
|
return {
|
|
@@ -217,15 +196,20 @@ function idleState() {
|
|
|
217
196
|
};
|
|
218
197
|
}
|
|
219
198
|
function sameOwners(a, b) {
|
|
220
|
-
if (a.owners === b.owners)
|
|
221
|
-
|
|
199
|
+
if (a.owners === b.owners)
|
|
200
|
+
return true;
|
|
201
|
+
if ((a.owners?.size ?? 0) !== (b.owners?.size ?? 0))
|
|
202
|
+
return false;
|
|
222
203
|
if (a.owners) {
|
|
223
|
-
for (const owner of a.owners)
|
|
204
|
+
for (const owner of a.owners)
|
|
205
|
+
if (!b.owners?.has(owner))
|
|
206
|
+
return false;
|
|
224
207
|
}
|
|
225
208
|
return true;
|
|
226
209
|
}
|
|
227
210
|
function sameState(a, b) {
|
|
228
|
-
if (!a)
|
|
211
|
+
if (!a)
|
|
212
|
+
return false;
|
|
229
213
|
const left = a.snapshot;
|
|
230
214
|
const right = b.snapshot;
|
|
231
215
|
if (left.status !== right.status || left.refreshing !== right.refreshing || left.connection !== right.connection || left.complete !== right.complete || left.requestKey !== right.requestKey) {
|
|
@@ -244,50 +228,60 @@ function withOwners(state, owners) {
|
|
|
244
228
|
}
|
|
245
229
|
function recordOwners(node, state) {
|
|
246
230
|
const consumer = activeNode;
|
|
247
|
-
if (!consumer)
|
|
248
|
-
|
|
231
|
+
if (!consumer)
|
|
232
|
+
return;
|
|
233
|
+
if (node.owner !== consumer.owner)
|
|
234
|
+
(activeOwners ??= /* @__PURE__ */ new Set()).add(node.owner);
|
|
249
235
|
if (state.owners) {
|
|
250
236
|
for (const owner of state.owners) {
|
|
251
|
-
if (owner !== consumer.owner)
|
|
237
|
+
if (owner !== consumer.owner)
|
|
238
|
+
(activeOwners ??= /* @__PURE__ */ new Set()).add(owner);
|
|
252
239
|
}
|
|
253
240
|
}
|
|
254
241
|
}
|
|
255
242
|
function releaseRetainedOwners(node) {
|
|
256
243
|
const owners = retainedOwners.get(node);
|
|
257
|
-
if (!owners)
|
|
244
|
+
if (!owners)
|
|
245
|
+
return;
|
|
258
246
|
retainedOwners.delete(node);
|
|
259
247
|
for (const owner of owners) {
|
|
260
248
|
const nodes = retainedNodes.get(owner);
|
|
261
249
|
nodes?.delete(node);
|
|
262
|
-
if (!nodes?.size)
|
|
250
|
+
if (!nodes?.size)
|
|
251
|
+
retainedNodes.delete(owner);
|
|
263
252
|
}
|
|
264
253
|
}
|
|
265
254
|
function releaseRetention(node) {
|
|
266
|
-
if (node.lastState?.owners)
|
|
255
|
+
if (node.lastState?.owners)
|
|
256
|
+
releaseRetainedOwners(node);
|
|
267
257
|
node.last = void 0;
|
|
268
258
|
node.lastState = void 0;
|
|
269
259
|
node.hasLast = false;
|
|
270
260
|
}
|
|
271
261
|
function retainOwners(node) {
|
|
272
262
|
const owners = node.lastState?.owners;
|
|
273
|
-
if (!owners || retainedOwners.get(node) === owners)
|
|
263
|
+
if (!owners || retainedOwners.get(node) === owners)
|
|
264
|
+
return;
|
|
274
265
|
releaseRetainedOwners(node);
|
|
275
266
|
retainedOwners.set(node, owners);
|
|
276
267
|
for (const owner of owners) {
|
|
277
268
|
let nodes = retainedNodes.get(owner);
|
|
278
|
-
if (!nodes)
|
|
269
|
+
if (!nodes)
|
|
270
|
+
retainedNodes.set(owner, nodes = /* @__PURE__ */ new Set());
|
|
279
271
|
nodes.add(node);
|
|
280
272
|
}
|
|
281
273
|
}
|
|
282
274
|
function revokeRetainedValues(owner, error) {
|
|
283
275
|
const nodes = retainedNodes.get(owner);
|
|
284
|
-
if (!nodes)
|
|
276
|
+
if (!nodes)
|
|
277
|
+
return;
|
|
285
278
|
for (const node of nodes) {
|
|
286
279
|
const origins = node.state?.owners;
|
|
287
280
|
let surviving;
|
|
288
281
|
if (origins) {
|
|
289
282
|
for (const origin of origins) {
|
|
290
|
-
if (!origin.retired)
|
|
283
|
+
if (!origin.retired)
|
|
284
|
+
(surviving ??= /* @__PURE__ */ new Set()).add(origin);
|
|
291
285
|
}
|
|
292
286
|
}
|
|
293
287
|
commitState(node, withOwners(errorState(error), surviving));
|
|
@@ -337,7 +331,7 @@ class ScopedNode {
|
|
|
337
331
|
nativeSnapshotSource;
|
|
338
332
|
retry(_options) {
|
|
339
333
|
assertAlive(this.owner);
|
|
340
|
-
throw new TypeError("Only an async signal can be retried.");
|
|
334
|
+
throw new TypeError(process.env.NODE_ENV !== "production" ? "Only an async signal can be retried." : __octaneNoArgError(163));
|
|
341
335
|
}
|
|
342
336
|
get() {
|
|
343
337
|
return strictValue(readNode(this), this.key);
|
|
@@ -347,14 +341,7 @@ class ScopedNode {
|
|
|
347
341
|
}
|
|
348
342
|
[SIGNAL_BINDING_SUBSCRIBE](notify, onRetire) {
|
|
349
343
|
assertAlive(this.owner);
|
|
350
|
-
return attachObserver(
|
|
351
|
-
this,
|
|
352
|
-
onRetire === void 0 ? notify : forwardNativeTransitionConsumer(
|
|
353
|
-
notify,
|
|
354
|
-
() => this.owner.retired ? onRetire() : notify()
|
|
355
|
-
),
|
|
356
|
-
true
|
|
357
|
-
);
|
|
344
|
+
return attachObserver(this, onRetire === void 0 ? notify : forwardNativeTransitionConsumer(notify, () => this.owner.retired ? onRetire() : notify()), true);
|
|
358
345
|
}
|
|
359
346
|
[SIGNAL_BINDING_IDENTITY]() {
|
|
360
347
|
return { scope: "instance", nodeKey: this.key };
|
|
@@ -365,7 +352,8 @@ class ScopedNode {
|
|
|
365
352
|
set(value) {
|
|
366
353
|
assertAlive(this.owner);
|
|
367
354
|
assertWritable();
|
|
368
|
-
if (this.kind !== "signal")
|
|
355
|
+
if (this.kind !== "signal")
|
|
356
|
+
throw new TypeError(process.env.NODE_ENV !== "production" ? "Only a writable signal accepts set()." : __octaneNoArgError(164));
|
|
369
357
|
const candidate = activeCandidate ?? getNativeCandidate();
|
|
370
358
|
if (candidate) {
|
|
371
359
|
candidate.run(() => candidate.write(this, value));
|
|
@@ -381,13 +369,16 @@ class ScopedNode {
|
|
|
381
369
|
this.owner.trace("write", this);
|
|
382
370
|
}
|
|
383
371
|
} finally {
|
|
384
|
-
if (releases)
|
|
372
|
+
if (releases)
|
|
373
|
+
for (const release of releases)
|
|
374
|
+
release();
|
|
385
375
|
}
|
|
386
376
|
});
|
|
387
377
|
}
|
|
388
378
|
latest(fallback) {
|
|
389
379
|
const state = readNode(this, "latest");
|
|
390
|
-
if (state.snapshot.status === "ready")
|
|
380
|
+
if (state.snapshot.status === "ready")
|
|
381
|
+
return state.snapshot.value;
|
|
391
382
|
if (state.snapshot.status === "error" && (state.snapshot.error instanceof ScopeDisposedError || state.snapshot.error instanceof SignalFrameError || state.snapshot.error instanceof NativeAdoptionMiss)) {
|
|
392
383
|
throw state.snapshot.error;
|
|
393
384
|
}
|
|
@@ -400,13 +391,14 @@ class ScopedNode {
|
|
|
400
391
|
assertAlive(this.owner);
|
|
401
392
|
assertWritable();
|
|
402
393
|
if (typeof notify !== "function")
|
|
403
|
-
throw new TypeError("A signal subscriber must be a function.");
|
|
394
|
+
throw new TypeError(process.env.NODE_ENV !== "production" ? "A signal subscriber must be a function." : __octaneNoArgError(165));
|
|
404
395
|
const state = untrack(() => refreshNode(this));
|
|
405
396
|
return attachObserver(this, notify, false, state);
|
|
406
397
|
}
|
|
407
398
|
}
|
|
408
399
|
function assertAlive(owner) {
|
|
409
|
-
if (owner.retired)
|
|
400
|
+
if (owner.retired)
|
|
401
|
+
throw new ScopeDisposedError(owner.scopeKey);
|
|
410
402
|
}
|
|
411
403
|
function inspectNativeNode(node, read) {
|
|
412
404
|
const dependencies = [];
|
|
@@ -446,33 +438,40 @@ function createNativeSource(node, read) {
|
|
|
446
438
|
function readNode(node, read = "value") {
|
|
447
439
|
assertAlive(node.owner);
|
|
448
440
|
const candidate = activeCandidate;
|
|
449
|
-
if (candidate)
|
|
441
|
+
if (candidate)
|
|
442
|
+
node = candidate.resolve(node);
|
|
450
443
|
const historical = historicalReader?.(node, read);
|
|
451
|
-
if (historical)
|
|
444
|
+
if (historical)
|
|
445
|
+
return historical;
|
|
452
446
|
if (!historicalReader && node.owner.seedable) {
|
|
453
447
|
const frame = getNativeAdoptionResolver()?.(node.owner);
|
|
454
|
-
if (frame)
|
|
448
|
+
if (frame)
|
|
449
|
+
return frame.run(() => readNode(node, read));
|
|
455
450
|
}
|
|
456
451
|
const state = refreshNode(node);
|
|
457
452
|
const observed = read === "latest" && state.snapshot.status !== "ready" ? node.lastState ?? state : state;
|
|
458
|
-
if (activeNode)
|
|
453
|
+
if (activeNode)
|
|
454
|
+
graph.link(node, activeNode, trackingCycle);
|
|
459
455
|
if (getNativeReadObserver()) {
|
|
460
456
|
const field = read === "value" ? "nativeSource" : read === "latest" ? "nativeLatestSource" : "nativeSnapshotSource";
|
|
461
457
|
const source = node[field] ??= createNativeSource(node, read);
|
|
462
|
-
reportNativeRead(
|
|
463
|
-
candidate ? candidate.nativeSource(node, read, source) : source,
|
|
464
|
-
node.revision
|
|
465
|
-
);
|
|
458
|
+
reportNativeRead(candidate ? candidate.nativeSource(node, read, source) : source, node.revision);
|
|
466
459
|
}
|
|
467
|
-
if (observed.owners)
|
|
468
|
-
|
|
460
|
+
if (observed.owners)
|
|
461
|
+
for (const owner of observed.owners)
|
|
462
|
+
assertAlive(owner);
|
|
463
|
+
if (activeNode)
|
|
464
|
+
recordOwners(node, observed);
|
|
469
465
|
return observed;
|
|
470
466
|
}
|
|
471
467
|
function strictValue(state, key = "idle") {
|
|
472
468
|
const snapshot = state.snapshot;
|
|
473
|
-
if (snapshot.status === "ready")
|
|
474
|
-
|
|
475
|
-
if (snapshot.status === "
|
|
469
|
+
if (snapshot.status === "ready")
|
|
470
|
+
return snapshot.value;
|
|
471
|
+
if (snapshot.status === "error")
|
|
472
|
+
throw snapshot.error;
|
|
473
|
+
if (snapshot.status === "idle")
|
|
474
|
+
throw new SignalIdleError(key);
|
|
476
475
|
throw state.waiting;
|
|
477
476
|
}
|
|
478
477
|
function readSignalBinding(handle$) {
|
|
@@ -489,17 +488,22 @@ function readSignalBinding(handle$) {
|
|
|
489
488
|
}
|
|
490
489
|
function refreshNode(node) {
|
|
491
490
|
assertAlive(node.owner);
|
|
492
|
-
if (node.evaluating)
|
|
491
|
+
if (node.evaluating)
|
|
492
|
+
throw new SignalCycleError(node.key);
|
|
493
493
|
const guarded = node.kind === "derived";
|
|
494
|
-
if (guarded)
|
|
494
|
+
if (guarded)
|
|
495
|
+
pureDepth++;
|
|
495
496
|
try {
|
|
496
497
|
let iterations = 0;
|
|
497
498
|
while (true) {
|
|
498
499
|
const flags = node.flags;
|
|
499
500
|
if (flags & ReactiveFlags.Dirty || flags & ReactiveFlags.Pending && (!node.deps || graph.checkDirty(node.deps, node))) {
|
|
500
|
-
if (++iterations > 100)
|
|
501
|
-
|
|
502
|
-
if (node
|
|
501
|
+
if (++iterations > 100)
|
|
502
|
+
throw new SignalCycleError(node.key);
|
|
503
|
+
if (evaluate(node) && node.subs)
|
|
504
|
+
graph.shallowPropagate(node.subs);
|
|
505
|
+
if (node.flags & (ReactiveFlags.Dirty | ReactiveFlags.Pending))
|
|
506
|
+
continue;
|
|
503
507
|
} else {
|
|
504
508
|
node.flags &= ~ReactiveFlags.Pending;
|
|
505
509
|
}
|
|
@@ -508,7 +512,8 @@ function refreshNode(node) {
|
|
|
508
512
|
}
|
|
509
513
|
return node.state;
|
|
510
514
|
} finally {
|
|
511
|
-
if (guarded)
|
|
515
|
+
if (guarded)
|
|
516
|
+
pureDepth--;
|
|
512
517
|
}
|
|
513
518
|
}
|
|
514
519
|
function evaluate(node) {
|
|
@@ -516,7 +521,8 @@ function evaluate(node) {
|
|
|
516
521
|
node.flags = ReactiveFlags.Mutable | ReactiveFlags.Watching;
|
|
517
522
|
return true;
|
|
518
523
|
}
|
|
519
|
-
if (historicalReader || getNativeAdoptionResolver())
|
|
524
|
+
if (historicalReader || getNativeAdoptionResolver())
|
|
525
|
+
return evaluateLiveNode(node);
|
|
520
526
|
const previousNode = activeNode;
|
|
521
527
|
const previousOwners = activeOwners;
|
|
522
528
|
const previousObserver = setNativeReadObserver(null);
|
|
@@ -549,13 +555,15 @@ function evaluate(node) {
|
|
|
549
555
|
node.flags &= ~ReactiveFlags.RecursedCheck;
|
|
550
556
|
const tail = node.depsTail;
|
|
551
557
|
let obsolete = tail ? tail.nextDep : node.deps;
|
|
552
|
-
while (obsolete)
|
|
558
|
+
while (obsolete)
|
|
559
|
+
obsolete = graph.unlink(obsolete, node);
|
|
553
560
|
}
|
|
554
561
|
next = withOwners(next, owners);
|
|
555
562
|
if (next.snapshot.status !== "ready" && node.state?.snapshot.status === "error" && node.state.snapshot.error instanceof ScopeDisposedError) {
|
|
556
563
|
next = withOwners(errorState(node.state.snapshot.error), next.owners);
|
|
557
564
|
}
|
|
558
|
-
if (sameState(node.state, next))
|
|
565
|
+
if (sameState(node.state, next))
|
|
566
|
+
return false;
|
|
559
567
|
commitState(node, next);
|
|
560
568
|
return true;
|
|
561
569
|
}
|
|
@@ -591,8 +599,10 @@ function commitState(node, next) {
|
|
|
591
599
|
}
|
|
592
600
|
}
|
|
593
601
|
function publishNode(node, next) {
|
|
594
|
-
if (node.kind === "async" && node.state?.owners)
|
|
595
|
-
|
|
602
|
+
if (node.kind === "async" && node.state?.owners)
|
|
603
|
+
next = withOwners(next, node.state.owners);
|
|
604
|
+
if (sameState(node.state, next))
|
|
605
|
+
return;
|
|
596
606
|
commitState(node, next);
|
|
597
607
|
if (node.subs) {
|
|
598
608
|
graph.propagate(node.subs, executionDepth !== 0);
|
|
@@ -604,11 +614,13 @@ function invalidateNode(node) {
|
|
|
604
614
|
node.revision++;
|
|
605
615
|
node.wakeup?.resolve();
|
|
606
616
|
node.wakeup = void 0;
|
|
607
|
-
if (node.subs)
|
|
617
|
+
if (node.subs)
|
|
618
|
+
graph.propagate(node.subs, executionDepth !== 0);
|
|
608
619
|
}
|
|
609
620
|
function derivedState(node, read) {
|
|
610
621
|
const value = pure(read);
|
|
611
|
-
if (isThenable(value))
|
|
622
|
+
if (isThenable(value))
|
|
623
|
+
throw new TypeError(process.env.NODE_ENV !== "production" ? "derived$ requires a synchronous computation." : __octaneNoArgError(166));
|
|
612
624
|
return derivedValueState(node, value);
|
|
613
625
|
}
|
|
614
626
|
function derivedValueState(node, value, activity, additionalDependencies) {
|
|
@@ -625,23 +637,29 @@ function derivedValueState(node, value, activity, additionalDependencies) {
|
|
|
625
637
|
if (dependency) {
|
|
626
638
|
refreshing ||= dependency.refreshing;
|
|
627
639
|
complete &&= dependency.complete;
|
|
628
|
-
if (dependency.connection === "open")
|
|
640
|
+
if (dependency.connection === "open")
|
|
641
|
+
connection = "open";
|
|
629
642
|
else if (connection !== "open" && dependency.connection === "connecting")
|
|
630
643
|
connection = "connecting";
|
|
631
|
-
else if (connection === "none" && dependency.connection === "closed")
|
|
644
|
+
else if (connection === "none" && dependency.connection === "closed")
|
|
645
|
+
connection = "closed";
|
|
632
646
|
}
|
|
633
|
-
if (link === node.depsTail)
|
|
647
|
+
if (link === node.depsTail)
|
|
648
|
+
break;
|
|
634
649
|
}
|
|
635
650
|
if (additionalDependencies) {
|
|
636
651
|
for (const node2 of additionalDependencies) {
|
|
637
652
|
const dependency = node2.state?.snapshot;
|
|
638
|
-
if (!dependency)
|
|
653
|
+
if (!dependency)
|
|
654
|
+
continue;
|
|
639
655
|
refreshing ||= dependency.refreshing;
|
|
640
656
|
complete &&= dependency.complete;
|
|
641
|
-
if (dependency.connection === "open")
|
|
657
|
+
if (dependency.connection === "open")
|
|
658
|
+
connection = "open";
|
|
642
659
|
else if (connection !== "open" && dependency.connection === "connecting")
|
|
643
660
|
connection = "connecting";
|
|
644
|
-
else if (connection === "none" && dependency.connection === "closed")
|
|
661
|
+
else if (connection === "none" && dependency.connection === "closed")
|
|
662
|
+
connection = "closed";
|
|
645
663
|
}
|
|
646
664
|
}
|
|
647
665
|
return readyState(value, { refreshing, complete, connection });
|
|
@@ -673,31 +691,37 @@ function subscribeNode(node, notify) {
|
|
|
673
691
|
}
|
|
674
692
|
function runObserver(observer) {
|
|
675
693
|
const node = observer.node;
|
|
676
|
-
if (!node || !observer.flags)
|
|
694
|
+
if (!node || !observer.flags)
|
|
695
|
+
return;
|
|
677
696
|
observer.flags = ReactiveFlags.Watching;
|
|
678
697
|
if (!observer.native) {
|
|
679
698
|
const state = untrack(() => refreshNode(node));
|
|
680
|
-
if (sameState(observer.previous, state))
|
|
699
|
+
if (sameState(observer.previous, state))
|
|
700
|
+
return;
|
|
681
701
|
observer.previous = state;
|
|
682
702
|
}
|
|
683
|
-
if (observer.notify)
|
|
703
|
+
if (observer.notify)
|
|
704
|
+
untrack(observer.notify);
|
|
684
705
|
}
|
|
685
706
|
function stopObserver(observer) {
|
|
686
|
-
if (!observer.node)
|
|
707
|
+
if (!observer.node)
|
|
708
|
+
return;
|
|
687
709
|
queued.delete(observer);
|
|
688
710
|
observer.flags = ReactiveFlags.None;
|
|
689
711
|
observer.node.owner.observers.delete(observer);
|
|
690
712
|
observer.node = void 0;
|
|
691
713
|
observer.notify = void 0;
|
|
692
714
|
observer.previous = void 0;
|
|
693
|
-
while (observer.deps)
|
|
715
|
+
while (observer.deps)
|
|
716
|
+
graph.unlink(observer.deps, observer);
|
|
694
717
|
}
|
|
695
718
|
function retireGraph(owner, nodes) {
|
|
696
719
|
const previousError = retirementError;
|
|
697
720
|
retirementError = new ScopeDisposedError(owner.scopeKey);
|
|
698
721
|
try {
|
|
699
722
|
for (const observer of owner.observers) {
|
|
700
|
-
if (observer.native && observer.notify)
|
|
723
|
+
if (observer.native && observer.notify)
|
|
724
|
+
queued.add(observer.notify);
|
|
701
725
|
stopObserver(observer);
|
|
702
726
|
}
|
|
703
727
|
revokeRetainedValues(owner, retirementError);
|
|
@@ -711,13 +735,16 @@ function retireGraph(owner, nodes) {
|
|
|
711
735
|
releaseRetention(node);
|
|
712
736
|
node.compute = void 0;
|
|
713
737
|
node.invalidateAttempt = void 0;
|
|
714
|
-
if (node.kind === "async")
|
|
738
|
+
if (node.kind === "async")
|
|
739
|
+
node.retry = ScopedNode.prototype.retry;
|
|
715
740
|
if (node.subs) {
|
|
716
741
|
graph.propagate(node.subs, executionDepth !== 0);
|
|
717
742
|
graph.shallowPropagate(node.subs);
|
|
718
743
|
}
|
|
719
|
-
while (node.deps)
|
|
720
|
-
|
|
744
|
+
while (node.deps)
|
|
745
|
+
graph.unlink(node.deps, node);
|
|
746
|
+
while (node.subs)
|
|
747
|
+
graph.unlink(node.subs);
|
|
721
748
|
node.flags = ReactiveFlags.None;
|
|
722
749
|
}
|
|
723
750
|
} finally {
|