@solidjs/signals 2.0.0-beta.18 → 2.0.0-beta.20

package/dist/prod/core/verdict.js

@@ -0,0 +1,292 @@
+import { NOT_PENDING, REACTIVE_DISPOSED, REACTIVE_DIRTY, REACTIVE_CHECK, unwrapOverride, STATUS_UNINITIALIZED, STATUS_PENDING, REACTIVE_MANUAL_WRITE } from "./constants.js";
+
+import { setSignal, read, context, stale, currentOptimisticLane, prepareComputed, tracking, setLatestReadActive, setContextInternal, optimisticComputed, setPendingCheckActive, latestReadActive, optimisticSignal, pendingCheckActive } from "./core.js";
+
+import { NotReadyError } from "./error.js";
+
+import { link } from "./graph.js";
+
+import { insertIntoHeap, queueFor } from "./heap.js";
+
+import "./invariants.js";
+
+import { findLane, hasActiveOverride } from "./lanes.js";
+
+import { installOptimisticEngine } from "./optimistic.js";
+
+import { GlobalQueue, clock, insertSubs, schedule } from "./scheduler.js";
+
+/**
+ * The isPending()/latest() verdict layer, moved out of core.ts. Importing this
+ * module installs the companion-maintenance hooks on GlobalQueue; apps that
+ * never import isPending/latest never pay for any of it.
+ */
+// Companions (pending signals / latest shadows) are optimistic nodes: their
+// writes go through the optimistic write path and their reversion rides the
+// same lanes, so the verdict layer brings the engine with it.
+installOptimisticEngine();
+
+let pendingProbe = null;
+
+/**
+ * Get or create the pending signal for a node (lazy).
+ * Used by isPending() to track pending state reactively.
+ */ function getPendingSignal(e) {
+    if (!e.ye) {
+        // Start false, write true if pending - ensures reversion returns to false
+        e.ye = optimisticSignal(false, {
+            ownedWrite: true
+        });
+        e.ye.en = e;
+        if (computePendingState(e)) setSignal(e.ye, true);
+    }
+    return e.ye;
+}
+
+function collectPendingSources(e) {
+    if (!pendingProbe) return;
+    pendingProbe.sources.add(e);
+    const t = e.rt || e;
+    if (t !== e) pendingProbe.sources.add(t);
+}
+
+/**
+ * Adds a node to the active isPending() probe without reading it. The store's
+ * untracked-probe fallback (`witnessAffectsMark`) reaches this through
+ * `GlobalQueue._witnessAffects` — its callers guard on `pendingCheckActive`,
+ * which only flips inside `isPending()`, so the hook is always installed by
+ * the time it can fire.
+ */ function witnessAffects(e) {
+    pendingProbe?.sources.add(e);
+}
+
+function quietPending(e) {
+    if (e.m) {
+        for (const t of e.m) if (!t.A) return false;
+        return true;
+    }
+    return e.A;
+}
+
+function newQuestionInFlight(e) {
+    return !!(e.i & STATUS_PENDING) && !(e.i & STATUS_UNINITIALIZED) && !quietPending(e);
+}
+
+function computePendingState(e) {
+    const t = e;
+    if (t.u & REACTIVE_DISPOSED) return false;
+    if (e.M) return true;
+    const n = e.rt;
+    if (e.en) {
+        const t = e.en;
+        if (t.M) return true;
+        const n = t.rt || t;
+        return newQuestionInFlight(n);
+    }
+    if (n && e.ge !== NOT_PENDING && !hasActiveOverride(e)) {
+        return !!(n.u & REACTIVE_MANUAL_WRITE) || !n.Ae && !(n.i & STATUS_PENDING) || !!(n.i & STATUS_PENDING) && quietPending(n);
+    }
+    if (e.ge !== NOT_PENDING && !(t.i & STATUS_UNINITIALIZED)) {
+        if (hasActiveOverride(e)) return !e.Ge || !e.Ge(e.ge, unwrapOverride(e.be));
+        return true;
+    }
+    return newQuestionInFlight(t);
+}
+
+function syncCompanions(e, t) {
+    if (e.ye) updatePendingSignal(e);
+    if (e.pe) setSignal(e.pe, t);
+}
+
+function updatePendingSignal(e) {
+    if (e.ye) {
+        setSignal(e.ye, computePendingState(e));
+    }
+    if (e.pe) updatePendingSignal(e.pe);
+}
+
+function updateChildCompanions(e) {
+    for (let t = e.G; t !== null; t = t.Ne) {
+        if (t.ye || t.pe) updatePendingSignal(t);
+    }
+}
+
+function repollDownstreamVerdicts(e) {
+    const t = new Set;
+    const visit = e => {
+        if (t.has(e)) return;
+        t.add(e);
+        if (e.ye || e.pe) updatePendingSignal(e);
+        for (let t = e.p; t !== null; t = t.de) visit(t.Ee);
+        for (let t = e.G ?? null; t !== null; t = t.Ne) {
+            visit(t);
+        }
+    };
+    visit(e);
+}
+
+function snapCompanionsToState(e) {
+    const t = e.ye;
+    if (t && (t.be === undefined || t.be === NOT_PENDING)) {
+        const n = computePendingState(e);
+        if (t.Ue !== n || t.ge !== NOT_PENDING) {
+            t.Ue = n;
+            t.ge = NOT_PENDING;
+            t.Ie = clock;
+            insertSubs(t);
+            schedule();
+        }
+    }
+    const n = e.pe;
+    if (n && !(n.u & REACTIVE_DISPOSED)) {
+        if ((n.be === undefined || n.be === NOT_PENDING) && n.ge === NOT_PENDING && !Object.is(n.Ue, e.Ue) && !(n.u & (REACTIVE_DIRTY | REACTIVE_CHECK))) {
+            n.u |= REACTIVE_DIRTY;
+            insertIntoHeap(n, queueFor(n));
+            insertSubs(n);
+            schedule();
+        }
+        snapCompanionsToState(n);
+    }
+}
+
+function getLatestValueComputed(e) {
+    if (!e.pe) {
+        const t = latestReadActive;
+        setLatestReadActive(false);
+        const n = pendingCheckActive;
+        setPendingCheckActive(false);
+        const i = context;
+        setContextInternal(null);
+ // Detach from owner so it isn't disposed with effects
+                e.pe = optimisticComputed(() => read(e));
+        e.pe.en = e;
+ // Parent-child lane relationship
+                setContextInternal(i);
+        setPendingCheckActive(n);
+        setLatestReadActive(t);
+    }
+    return e.pe;
+}
+
+/** The latest()-mode read path, installed as GlobalQueue._latestRead. */ function latestRead(e) {
+    const t = getLatestValueComputed(e);
+    const n = latestReadActive;
+    setLatestReadActive(false);
+    const i = e.be !== undefined && e.be !== NOT_PENDING ? unwrapOverride(e.be) : e.Ue;
+    let r;
+    try {
+        r = read(t);
+    } catch (t) {
+        if (t instanceof NotReadyError && (!context || !(e.i & STATUS_UNINITIALIZED))) return i;
+        throw t;
+    } finally {
+        setLatestReadActive(n);
+    }
+    if (t.i & STATUS_PENDING) return i;
+    if (stale && currentOptimisticLane && t.Je) {
+        const e = findLane(t.Je);
+        const n = findLane(currentOptimisticLane);
+        if (e !== n && e.Pe.size > 0) {
+            return i;
+        }
+    }
+    return r;
+}
+
+/** The isPending()-probe read path, installed as GlobalQueue._pendingCheck. */ function pendingCheckRead(e, t, n, i) {
+    setPendingCheckActive(false);
+    if (typeof e.xe === "function") prepareComputed(e, true);
+    const r = n.i;
+    if (t && r & STATUS_PENDING && r & STATUS_UNINITIALIZED) {
+        if (tracking && e !== t) link(e, t);
+        setPendingCheckActive(true);
+        throw n.k;
+    }
+    collectPendingSources(e);
+    if (i) collectPendingSources(i);
+    setPendingCheckActive(true);
+}
+
+function recordFreshRead(e, t) {
+    if (pendingProbe !== null && e.ge !== NOT_PENDING && t === e.ge) pendingProbe.freshReads.add(e);
+}
+
+function applyReask(e, t) {
+    const n = !!(e.i & STATUS_PENDING);
+    const i = t && !(n && !e.A);
+    const r = n && e.A !== i;
+    e.A = i;
+    return r;
+}
+
+function latest(e) {
+    const t = latestReadActive;
+    setLatestReadActive(true);
+    try {
+        return e();
+    } finally {
+        setLatestReadActive(t);
+    }
+}
+
+function isPending(e) {
+    const t = pendingCheckActive;
+    const n = pendingProbe;
+    setPendingCheckActive(true);
+    const i = pendingProbe = {
+        found: false,
+        sources: new Set,
+        freshReads: new Set
+    };
+    const collectPending = () => {
+        setPendingCheckActive(false);
+        try {
+            i.sources.forEach(e => {
+                if (read(getPendingSignal(e)) && !i.freshReads.has(e)) i.found = true;
+            });
+        } finally {
+            setPendingCheckActive(true);
+        }
+    };
+    try {
+        e();
+        collectPending();
+        return i.found;
+    } catch (e) {
+        collectPending();
+        if (e instanceof NotReadyError) {
+            const t = !!(e.source?.i & STATUS_UNINITIALIZED);
+            if (i.found && !t) return true;
+            if (context && t) throw e;
+        }
+        return i.found;
+    } finally {
+        setPendingCheckActive(t);
+        pendingProbe = n;
+    }
+}
+
+// Hook installation (same late-binding pattern as GlobalQueue._update /
+// _propagateAffects): core call sites fire these behind the same guards the
+// direct calls used, so behavior is identical once this module loads.
+GlobalQueue._e = syncCompanions;
+
+GlobalQueue.P = updatePendingSignal;
+
+GlobalQueue.me = updateChildCompanions;
+
+GlobalQueue.R = snapCompanionsToState;
+
+GlobalQueue.Gt = latestRead;
+
+GlobalQueue.Pt = pendingCheckRead;
+
+GlobalQueue.kt = recordFreshRead;
+
+GlobalQueue.tt = applyReask;
+
+GlobalQueue.nt = repollDownstreamVerdicts;
+
+GlobalQueue.wt = witnessAffects;
+
+export { isPending, latest };

package/dist/prod/index.js

@@ -0,0 +1,45 @@
+export { ContextNotFoundError, NoOwnerError, NotReadyError } from "./core/error.js";
+
+export { clearSnapshots, isEqual, markSnapshotScope, refresh, releaseSnapshotScope, runWithOwner, setSnapshotCapture, untrack } from "./core/core.js";
+
+export { enableExternalSource } from "./core/external.js";
+
+export { createOwner, createRoot, getNextChildId, getObserver, getOwner, isDisposed, peekNextChildId } from "./core/owner.js";
+
+export { createContext, getContext, setContext } from "./core/context.js";
+
+export { $REFRESH, SUPPORTS_PROXY } from "./core/constants.js";
+
+import "./core/invariants.js";
+
+export { enforceLoadingBoundary, flush, resetErrorHalt } from "./core/scheduler.js";
+
+export { isPending, latest } from "./core/verdict.js";
+
+import "./core/effect.js";
+
+export { action } from "./core/action.js";
+
+export { createEffect, createMemo, createOptimistic, createReaction, createRenderEffect, createSignal, createTrackedEffect, onCleanup, onSettled, resolve } from "./signals.js";
+
+export { affects } from "./affects.js";
+
+export { mapArray, repeat } from "./map.js";
+
+export { $PROXY, $TARGET, $TRACK, createStore, isWrappable } from "./store/store.js";
+
+export { createProjection } from "./store/projection.js";
+
+export { createOptimisticStore } from "./store/optimistic.js";
+
+export { reconcile } from "./store/reconcile.js";
+
+export { storePath } from "./store/storePath.js";
+
+export { deep, merge, omit, snapshot } from "./store/utils.js";
+
+export { createErrorBoundary, createLoadingBoundary, createRevealOrder, flatten } from "./boundaries.js";
+
+const DEV = undefined;
+
+export { DEV };

package/dist/prod/map.js

@@ -0,0 +1,293 @@
+import { computed, runWithOwner, signal, setSignal } from "./core/core.js";
+
+import { createOwner } from "./core/owner.js";
+
+import "./core/scheduler.js";
+
+import { CONFIG_AUTO_DISPOSE } from "./core/constants.js";
+
+import "./core/invariants.js";
+
+import "./core/verdict.js";
+
+import "./core/effect.js";
+
+import { accessor } from "./signals.js";
+
+import { $TRACK } from "./store/store.js";
+
+function mapArray(t, s, i) {
+    const e = typeof i?.keyed === "function" ? i.keyed : undefined;
+    const r = s.length > 1;
+    const n = s;
+    const h = {
+        jt: createOwner(),
+        Wt: 0,
+        Kt: t,
+        xt: [],
+        $t: n,
+        qt: [],
+        zt: [],
+        Ht: e,
+        Jt: e || i?.keyed === false ? [] : undefined,
+        Xt: r && i?.keyed !== false ? [] : undefined,
+        Yt: i?.keyed === false,
+        Zt: i?.fallback
+    };
+    const o = computed(updateKeyedMap.bind(h));
+    // Untracked reads inside the internal owner resolve via _parentComputed; routing
+    // them through node lets store-proxy lookups see pending writes (not stale _value).
+        h.jt.Ct = o;
+    o.U &= ~CONFIG_AUTO_DISPOSE;
+    return accessor(o);
+}
+
+const pureOptions = {
+    ownedWrite: true
+};
+
+// Exception safety (#2903): a map callback can throw NotReadyError mid-pass
+// (async read), and the computed re-runs the whole pass after settle. Every
+// pass therefore STAGES its work — new rows are created into temp arrays and
+// removals are deferred — and commits to `this` only after every mapper
+// succeeded. An aborted pass disposes just the owners it created and leaves
+// `_items`/`_mappings`/`_nodes`/`_rows`/`_indexes`/`_len` exactly as they
+// were, so the retry diffs against uncorrupted state. Consequence of the
+// strong-abort ordering: removed rows now dispose AFTER the pass's new rows
+// are created (you cannot destroy state before knowing the pass will land).
+function updateKeyedMap() {
+    const t = this.Kt() || [], s = t.length;
+    t[$TRACK];
+ // top level tracking
+        runWithOwner(this.jt, () => {
+        let i, e, r, n, 
+        // Mappers write freshly-created row/index signals into the STAGE
+        // arrays (`rows`/`indexes`), never into `this._rows`/`this._indexes`.
+        h = this.Jt ? this.Yt ? () => {
+            r[e] = signal(t[e], pureOptions);
+            return this.$t(accessor(r[e]), e);
+        } : () => {
+            r[e] = signal(t[e], pureOptions);
+            n && (n[e] = signal(e, pureOptions));
+            return this.$t(accessor(r[e]), n ? accessor(n[e]) : undefined);
+        } : this.Xt ? () => {
+            const s = t[e];
+            n[e] = signal(e, pureOptions);
+            return this.$t(s, accessor(n[e]));
+        } : () => {
+            const s = t[e];
+            return this.$t(s);
+        };
+        // fast path for empty arrays
+                if (s === 0) {
+            if (this.Wt !== 0) {
+                this.jt.dispose(false);
+                this.zt = [];
+                this.xt = [];
+                this.qt = [];
+                this.Wt = 0;
+                this.Jt && (this.Jt = []);
+                this.Xt && (this.Xt = []);
+            }
+            if (this.Zt && !this.qt[0]) {
+                // an aborted fallback attempt leaves an owner without a mapping;
+                // dispose it before re-creating
+                this.zt[0]?.dispose();
+                this.qt[0] = runWithOwner(this.zt[0] = createOwner(), this.Zt);
+            }
+        }
+        // fast path for new create
+         else if (this.Wt === 0) {
+            const o = new Array(s);
+            const c = new Array(s);
+            r = this.Jt && new Array(s);
+            n = this.Xt && new Array(s);
+            try {
+                for (e = 0; e < s; e++) o[e] = runWithOwner(c[e] = createOwner(), h);
+            } catch (t) {
+                for (i = 0; i <= e; i++) c[i]?.dispose();
+                throw t;
+            }
+            // commit
+                        if (this.zt[0]) this.zt[0].dispose();
+ // previous fallback
+                        this.qt = o;
+            this.zt = c;
+            r && (this.Jt = r);
+            n && (this.Xt = n);
+            this.xt = t.slice(0);
+            this.Wt = s;
+        } else {
+            let o, c, a, f, u, p, w, l, d, O = new Array(s), m = new Array(s);
+            r = this.Jt ? new Array(s) : undefined;
+            n = this.Xt ? new Array(s) : undefined;
+            // skip common prefix
+                        for (o = 0, c = Math.min(this.Wt, s); o < c && (this.xt[o] === t[o] || this.Jt && compare(this.Ht, this.xt[o], t[o])); o++) {
+                if (this.Jt) setSignal(this.Jt[o], t[o]);
+            }
+            // common suffix
+                        for (c = this.Wt - 1, a = s - 1; c >= o && a >= o && (this.xt[c] === t[a] || this.Jt && compare(this.Ht, this.xt[c], t[a])); c--, 
+            a--) {
+                O[a] = this.qt[c];
+                m[a] = this.zt[c];
+                r && (r[a] = this.Jt[c]);
+                n && (n[a] = this.Xt[c]);
+            }
+            // 0) prepare a map of all indices in newItems, scanning backwards so we encounter them in natural order
+                        p = new Map;
+            w = new Array(a + 1);
+            for (e = a; e >= o; e--) {
+                f = t[e];
+                u = this.Ht ? this.Ht(f) : f;
+                i = p.get(u);
+                w[e] = i === undefined ? -1 : i;
+                p.set(u, e);
+            }
+            // 1) step through all old items and see if they can be found in the new set; if so, save them in a temp array and mark them moved; if not, queue them for disposal at commit
+                        for (i = o; i <= c; i++) {
+                f = this.xt[i];
+                u = this.Ht ? this.Ht(f) : f;
+                e = p.get(u);
+                if (e !== undefined && e !== -1) {
+                    O[e] = this.qt[i];
+                    m[e] = this.zt[i];
+                    r && (r[e] = this.Jt[i]);
+                    n && (n[e] = this.Xt[i]);
+                    e = w[e];
+                    p.set(u, e);
+                } else (l ??= []).push(this.zt[i]);
+            }
+            // 2) create new rows into the temp arrays; an abort disposes only these
+                        try {
+                for (e = o; e < s; e++) {
+                    if (e in O) continue;
+                    (d ??= []).push(m[e] = createOwner());
+                    O[e] = runWithOwner(m[e], h);
+                }
+            } catch (t) {
+                if (d) for (i = 0; i < d.length; i++) d[i].dispose();
+                throw t;
+            }
+            // 3) commit: land positions, then dispose exited rows
+                        for (e = o; e < s; e++) {
+                this.qt[e] = O[e];
+                this.zt[e] = m[e];
+                if (r) {
+                    this.Jt[e] = r[e];
+                    setSignal(this.Jt[e], t[e]);
+                }
+                if (n) {
+                    this.Xt[e] = n[e];
+                    setSignal(this.Xt[e], e);
+                }
+            }
+            if (l) for (i = 0; i < l.length; i++) l[i].dispose();
+            // 4) in case the new set is shorter than the old, set the length of the mapped array
+                        this.qt = this.qt.slice(0, this.Wt = s);
+            // 5) save a copy of the mapped items for the next update
+                        this.xt = t.slice(0);
+        }
+    });
+    return this.qt;
+}
+
+/**
+ * Reactively renders a callback `count` times, reusing previously-rendered
+ * entries when only the count changes. Underlying helper for `<Repeat>`.
+ *
+ * - `options.from` — start index (default `0`); useful for offset/windowed
+ *   rendering.
+ * - `options.fallback` — accessor returning a value to show when count is `0`.
+ *
+ * @example
+ * ```ts
+ * const view = repeat(count, i => `Item ${i}`, { fallback: () => "empty" });
+ * ```
+ *
+ * @description https://docs.solidjs.com/reference/reactive-utilities/repeat
+ */ function repeat(t, s, i) {
+    const e = s;
+    const r = {
+        jt: createOwner(),
+        Wt: 0,
+        ts: 0,
+        ss: t,
+        $t: e,
+        zt: [],
+        qt: [],
+        es: i?.from,
+        Zt: i?.fallback
+    };
+    const n = computed(updateRepeat.bind(r));
+    // Same as mapArray: untracked reads inside the internal owner resolve via
+    // _parentComputed, so async reads in row callbacks register with the node
+    // (pending tracking + post-settle retry) instead of vanishing.
+        r.jt.Ct = n;
+    n.U &= ~CONFIG_AUTO_DISPOSE;
+    return accessor(n);
+}
+
+// Same staged-commit discipline as `updateKeyedMap` (#2903): the retained
+// window overlap is copied into fresh arrays, missing indexes are created
+// into them, and `this` is only touched — including disposal of rows leaving
+// the window — after every `_map` call succeeded. A NotReadyError mid-pass
+// disposes only the owners this pass created and leaves prior state intact
+// for the post-settle retry. The overlap math also subsumes the previous
+// disjoint-window/front-clear/end-clear/shift special cases.
+function updateRepeat() {
+    const t = this.ss();
+    const s = this.es?.() || 0;
+    runWithOwner(this.jt, () => {
+        if (t === 0) {
+            if (this.Wt !== 0) {
+                this.jt.dispose(false);
+                this.zt = [];
+                this.qt = [];
+                this.Wt = 0;
+                // Reset offset to match the cleared data (#2767, repro 2).
+                                this.ts = 0;
+            }
+            if (this.Zt && !this.qt[0]) {
+                // an aborted fallback attempt leaves an owner without a mapping;
+                // dispose it before re-creating
+                this.zt[0]?.dispose();
+                this.qt[0] = runWithOwner(this.zt[0] = createOwner(), this.Zt);
+            }
+            return;
+        }
+        const i = s + t;
+        const e = this.ts + this.Wt;
+        // Retained overlap [keepStart, keepEnd) in global indexes; empty when the
+        // windows are disjoint or when coming from empty/fallback.
+                const r = Math.max(s, this.ts);
+        const n = Math.min(i, e);
+        const h = new Array(t);
+        const o = new Array(t);
+        for (let t = r; t < n; t++) {
+            o[t - s] = this.zt[t - this.ts];
+            h[t - s] = this.qt[t - this.ts];
+        }
+        try {
+            for (let t = s; t < i; t++) {
+                if (t >= r && t < n) continue;
+                h[t - s] = runWithOwner(o[t - s] = createOwner(), () => this.$t(t));
+            }
+        } catch (t) {
+            for (let t = s; t < i; t++) if ((t < r || t >= n) && o[t - s]) o[t - s].dispose();
+            throw t;
+        }
+        // commit: dispose the previous fallback or the rows leaving the window
+                if (this.Wt === 0) this.zt[0]?.dispose(); else for (let t = this.ts; t < e; t++) if (t < s || t >= i) this.zt[t - this.ts].dispose();
+        this.qt = h;
+        this.zt = o;
+        this.ts = s;
+        this.Wt = t;
+    });
+    return this.qt;
+}
+
+function compare(t, s, i) {
+    return t ? t(s) === t(i) : true;
+}
+
+export { mapArray, repeat };