@solidjs/signals 2.0.0-beta.17 → 2.0.0-beta.19

package/dist/prod/core/verdict.js

@@ -0,0 +1,293 @@
+import { STATUS_UNINITIALIZED, REACTIVE_DISPOSED, NOT_PENDING, REACTIVE_MANUAL_WRITE, STATUS_PENDING, REACTIVE_DIRTY, REACTIVE_CHECK } from "./constants.js";
+
+import { context, setPendingCheckActive, read, optimisticSignal, setSignal, setLatestReadActive, pendingCheckActive, latestReadActive, stale, currentOptimisticLane, prepareComputed, tracking, setContextInternal, optimisticComputed } from "./core.js";
+
+import { NotReadyError } from "./error.js";
+
+import { link } from "./graph.js";
+
+import { insertIntoHeap, queueFor } from "./heap.js";
+
+import "./invariants.js";
+
+import { hasActiveOverride, findLane } 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;
+    }
+    if (e.m) return e.m.A;
+    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.P) return true;
+    const n = e.rt;
+    if (e.en) {
+        const t = e.en;
+        if (t.P) 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, 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 ? 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._ = updatePendingSignal;
+
+GlobalQueue.me = updateChildCompanions;
+
+GlobalQueue.R = snapCompanionsToState;
+
+GlobalQueue.Gt = latestRead;
+
+GlobalQueue.Pt = pendingCheckRead;
+
+GlobalQueue.vt = recordFreshRead;
+
+GlobalQueue.tt = applyReask;
+
+GlobalQueue.nt = repollDownstreamVerdicts;
+
+GlobalQueue.Zt = 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,264 @@
+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 h = s.length > 1;
+    const r = s;
+    const n = {
+        $t: createOwner(),
+        Xt: 0,
+        ts: t,
+        ss: [],
+        es: r,
+        hs: [],
+        rs: [],
+        ns: e,
+        cs: e || i?.keyed === false ? [] : undefined,
+        fs: h && i?.keyed !== false ? [] : undefined,
+        us: i?.keyed === false,
+        ps: i?.fallback
+    };
+    const o = computed(updateKeyedMap.bind(n));
+    // Untracked reads inside the internal owner resolve via _parentComputed; routing
+    // them through node lets store-proxy lookups see pending writes (not stale _value).
+        n.$t.Ct = o;
+    o.U &= ~CONFIG_AUTO_DISPOSE;
+    return accessor(o);
+}
+
+const pureOptions = {
+    ownedWrite: true
+};
+
+function updateKeyedMap() {
+    const t = this.ts() || [], s = t.length;
+    t[$TRACK];
+ // top level tracking
+        runWithOwner(this.$t, () => {
+        let i, e, h = this.cs ? this.us ? () => {
+            this.cs[e] = signal(t[e], pureOptions);
+            return this.es(accessor(this.cs[e]), e);
+        } : () => {
+            this.cs[e] = signal(t[e], pureOptions);
+            this.fs && (this.fs[e] = signal(e, pureOptions));
+            return this.es(accessor(this.cs[e]), this.fs ? accessor(this.fs[e]) : undefined);
+        } : this.fs ? () => {
+            const s = t[e];
+            this.fs[e] = signal(e, pureOptions);
+            return this.es(s, accessor(this.fs[e]));
+        } : () => {
+            const s = t[e];
+            return this.es(s);
+        };
+        // fast path for empty arrays
+                if (s === 0) {
+            if (this.Xt !== 0) {
+                this.$t.dispose(false);
+                this.rs = [];
+                this.ss = [];
+                this.hs = [];
+                this.Xt = 0;
+                this.cs && (this.cs = []);
+                this.fs && (this.fs = []);
+            }
+            if (this.ps && !this.hs[0]) {
+                // create fallback
+                this.hs[0] = runWithOwner(this.rs[0] = createOwner(), this.ps);
+            }
+        }
+        // fast path for new create
+         else if (this.Xt === 0) {
+            // dispose previous fallback
+            if (this.rs[0]) this.rs[0].dispose();
+            this.hs = new Array(s);
+            for (e = 0; e < s; e++) {
+                this.ss[e] = t[e];
+                this.hs[e] = runWithOwner(this.rs[e] = createOwner(), h);
+            }
+            this.Xt = s;
+        } else {
+            let r, n, o, a, c, f, u, p = new Array(s), l = new Array(s), w = this.cs ? new Array(s) : undefined, O = this.fs ? new Array(s) : undefined;
+            // skip common prefix
+                        for (r = 0, n = Math.min(this.Xt, s); r < n && (this.ss[r] === t[r] || this.cs && compare(this.ns, this.ss[r], t[r])); r++) {
+                if (this.cs) setSignal(this.cs[r], t[r]);
+            }
+            // common suffix
+                        for (n = this.Xt - 1, o = s - 1; n >= r && o >= r && (this.ss[n] === t[o] || this.cs && compare(this.ns, this.ss[n], t[o])); n--, 
+            o--) {
+                p[o] = this.hs[n];
+                l[o] = this.rs[n];
+                w && (w[o] = this.cs[n]);
+                O && (O[o] = this.fs[n]);
+            }
+            // 0) prepare a map of all indices in newItems, scanning backwards so we encounter them in natural order
+                        f = new Map;
+            u = new Array(o + 1);
+            for (e = o; e >= r; e--) {
+                a = t[e];
+                c = this.ns ? this.ns(a) : a;
+                i = f.get(c);
+                u[e] = i === undefined ? -1 : i;
+                f.set(c, 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, exit them
+                        for (i = r; i <= n; i++) {
+                a = this.ss[i];
+                c = this.ns ? this.ns(a) : a;
+                e = f.get(c);
+                if (e !== undefined && e !== -1) {
+                    p[e] = this.hs[i];
+                    l[e] = this.rs[i];
+                    w && (w[e] = this.cs[i]);
+                    O && (O[e] = this.fs[i]);
+                    e = u[e];
+                    f.set(c, e);
+                } else this.rs[i].dispose();
+            }
+            // 2) set all the new values, pulling from the temp array if copied, otherwise entering the new value
+                        for (e = r; e < s; e++) {
+                if (e in p) {
+                    this.hs[e] = p[e];
+                    this.rs[e] = l[e];
+                    if (w) {
+                        this.cs[e] = w[e];
+                        setSignal(this.cs[e], t[e]);
+                    }
+                    if (O) {
+                        this.fs[e] = O[e];
+                        setSignal(this.fs[e], e);
+                    }
+                } else {
+                    this.hs[e] = runWithOwner(this.rs[e] = createOwner(), h);
+                }
+            }
+            // 3) in case the new set is shorter than the old, set the length of the mapped array
+                        this.hs = this.hs.slice(0, this.Xt = s);
+            // 4) save a copy of the mapped items for the next update
+                        this.ss = t.slice(0);
+        }
+    });
+    return this.hs;
+}
+
+/**
+ * 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 h = computed(updateRepeat.bind({
+        $t: createOwner(),
+        Xt: 0,
+        ls: 0,
+        ws: t,
+        es: e,
+        rs: [],
+        hs: [],
+        Os: i?.from,
+        ps: i?.fallback
+    }));
+    h.U &= ~CONFIG_AUTO_DISPOSE;
+    return accessor(h);
+}
+
+function updateRepeat() {
+    const t = this.ws();
+    const s = this.Os?.() || 0;
+    runWithOwner(this.$t, () => {
+        if (t === 0) {
+            if (this.Xt !== 0) {
+                this.$t.dispose(false);
+                this.rs = [];
+                this.hs = [];
+                this.Xt = 0;
+                // Reset offset to match the cleared data. Without this, a subsequent
+                // nonzero render with a smaller `from` would enter the end-clear loop
+                // with `prevTo = stale_offset + 0` > `to` and dispose `_nodes[-1]`
+                // (#2767, repro 2).
+                                this.ls = 0;
+            }
+            if (this.ps && !this.hs[0]) {
+                // create fallback
+                this.hs[0] = runWithOwner(this.rs[0] = createOwner(), this.ps);
+            }
+            return;
+        }
+        const i = s + t;
+        const e = this.ls + this.Xt;
+        // remove fallback
+                if (this.Xt === 0 && this.rs[0]) this.rs[0].dispose();
+        // Disjoint windows have no rows to retain; replace them wholesale.
+                if (s >= e || i <= this.ls) {
+            for (let t = 0; t < this.Xt; t++) this.rs[t].dispose();
+            this.rs = new Array(t);
+            this.hs = new Array(t);
+            for (let i = 0; i < t; i++) this.hs[i] = runWithOwner(this.rs[i] = createOwner(), () => this.es(s + i));
+            this.ls = s;
+            this.Xt = t;
+            return;
+        }
+        // clear the end
+                for (let t = i; t < e; t++) this.rs[t - this.ls].dispose();
+        if (this.ls < s) {
+            // clear beginning — `_nodes` is local-indexed, so the rows leaving the
+            // front sit at local positions 0..(from - _offset), clamped to old len.
+            const t = s - this.ls;
+            for (let s = 0; s < t && s < this.Xt; s++) this.rs[s].dispose();
+            // shift indexes
+                        this.rs.splice(0, t);
+            this.hs.splice(0, t);
+        } else if (this.ls > s) {
+            // shift indexes
+            let i = e - this.ls - 1;
+            let h = this.ls - s;
+            this.rs.length = this.hs.length = t;
+            while (i >= h) {
+                this.rs[i] = this.rs[i - h];
+                this.hs[i] = this.hs[i - h];
+                i--;
+            }
+            for (let t = 0; t < h; t++) {
+                this.hs[t] = runWithOwner(this.rs[t] = createOwner(), () => this.es(t + s));
+            }
+        }
+        for (let t = e; t < i; t++) {
+            this.hs[t - s] = runWithOwner(this.rs[t - s] = createOwner(), () => this.es(t));
+        }
+        this.hs = this.hs.slice(0, t);
+        this.ls = s;
+        this.Xt = t;
+    });
+    return this.hs;
+}
+
+function compare(t, s, i) {
+    return t ? t(s) === t(i) : true;
+}
+
+export { mapArray, repeat };