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

package/dist/prod/store/projection.js

@@ -0,0 +1,184 @@
+import { computed } from "../core/core.js";
+
+import { getOwner } from "../core/owner.js";
+
+import { setProjectionWriteActive } from "../core/scheduler.js";
+
+import { handleAsync } from "../core/async.js";
+
+import "../core/verdict.js";
+
+import "../core/effect.js";
+
+import { CONFIG_AUTO_DISPOSE } from "../core/constants.js";
+
+import { reconcile } from "./reconcile.js";
+
+import { storeSetter, $TARGET, STORE_WRAP, createStoreProxy, storeTraps, setWriteOverride, STORE_LOOKUP, STORE_FIREWALL } from "./store.js";
+
+function createProjectionInternal(e, r, t) {
+    let o;
+    const i = new WeakMap;
+    const wrapper = e => {
+        e[STORE_WRAP] = wrapProjection;
+        e[STORE_LOOKUP] = i;
+        Object.defineProperty(e, STORE_FIREWALL, {
+            get() {
+                return o;
+            },
+            configurable: true
+        });
+    };
+    const wrapProjection = e => {
+        if (i.has(e)) return i.get(e);
+        if (e[$TARGET]?.[STORE_WRAP] === wrapProjection) return e;
+        const r = createStoreProxy(e, storeTraps, wrapper);
+        i.set(e, r);
+        return r;
+    };
+    const n = wrapProjection(r);
+    o = computed(() => {
+        if (!o) o = getOwner();
+        runProjectionComputed(n, e, t?.key || "id");
+    }, undefined);
+    o.U &= ~CONFIG_AUTO_DISPOSE;
+    return {
+        store: n,
+        node: o
+    };
+}
+
+/**
+ * Creates a derived (projected) store. Like `createMemo` but for stores: the
+ * derive function receives a mutable draft and either mutates it in place
+ * (canonical) or returns a new value. Either way the result is reconciled
+ * against the previous draft by `options.key` (default `"id"`), so surviving
+ * items keep their proxy identity — only added/removed items are
+ * created/disposed.
+ *
+ * Returns the projected store directly (no setter — reads only).
+ *
+ * Use this when you want the structural-sharing / per-property tracking
+ * behaviour of a store on top of a derived computation. For simple read-only
+ * derivations, `createMemo` is lighter.
+ *
+ * @param fn receives the current draft; mutate it in place or return new
+ *   data. Return is convenient for filter/derive shapes where mutation is
+ *   awkward.
+ * @param seed the backing store value to wrap and reconcile into
+ * @param options `ProjectionOptions` — `name`, `key`. `key` defaults to
+ *   `"id"`; specify it only when your data uses a different identity field
+ *   (e.g. `{ key: "uuid" }` or `{ key: u => u.slug }`).
+ *
+ * @example
+ * ```ts
+ * // Mutation form — update individual fields on the draft.
+ * const summary = createProjection<{ total: number; active: number }>(
+ *   draft => {
+ *     draft.total = users().length;
+ *     draft.active = users().filter(u => u.active).length;
+ *   },
+ *   { total: 0, active: 0 }
+ * );
+ *
+ * // Return form — produce a derived collection. Reconciled by `id` so each
+ * // surviving user keeps the same store identity across recomputes.
+ * const activeUsers = createProjection<User[]>(
+ *   () => allUsers().filter(u => u.active),
+ *   []
+ * );
+ * ```
+ *
+ * @see {@link https://github.com/solidjs/x-reactivity#createprojection}
+ */ function createProjection(e, r, t) {
+    return createProjectionInternal(e, r, t).store;
+}
+
+/**
+ * Shared projection computed body used by both `createProjection` and the derived
+ * form of `createOptimisticStore`. Encapsulates the write-trap draft, `storeSetter`
+ * wrapping, the `handleAsync` subscription with a setter callback, and the commit
+ * path (which must always go through `storeSetter` so the `writeOnly` guard is
+ * engaged during `reconcile`'s property reads).
+ *
+ * `wrapCommit` is invoked for every commit (sync return and each async yield) and
+ * lets callers layer extra context around the write — e.g. the optimistic store
+ * re-enters `setProjectionWriteActive` so reconciles target `STORE_OVERRIDE`
+ * instead of `STORE_OPTIMISTIC_OVERRIDE` even when an async yield fires outside
+ * the outer `setProjectionWriteActive` scope.
+ */ function runProjectionComputed(e, r, t, o, i) {
+    const n = getOwner();
+    let c = false;
+    let s;
+    const u = new Proxy(e, createWriteTraps(() => !c || n.Ae === s, i));
+    storeSetter(u, i => {
+        s = r(i);
+        c = true;
+        const commit = r => {
+            if (r === i || r === undefined) return;
+            const write = () => storeSetter(e, reconcile(r, t));
+            o ? o(write) : write();
+        };
+        commit(handleAsync(n, s, commit));
+    });
+    return n;
+}
+
+function createWriteTraps(e, r) {
+    const t = {
+        get(e, r) {
+            let o;
+            setWriteOverride(true);
+            setProjectionWriteActive(true);
+            try {
+                o = e[r];
+            } finally {
+                setWriteOverride(false);
+                setProjectionWriteActive(false);
+            }
+            if (r === $TARGET) return o;
+            return typeof o === "object" && o !== null ? new Proxy(o, t) : o;
+        },
+        has(e, r) {
+            let t;
+            setWriteOverride(true);
+            setProjectionWriteActive(true);
+            try {
+                t = r in e;
+            } finally {
+                setWriteOverride(false);
+                setProjectionWriteActive(false);
+            }
+            return t;
+        },
+        set(t, o, i) {
+            if (e && !e()) return true;
+            setWriteOverride(true);
+            setProjectionWriteActive(true);
+            try {
+                t[o] = i;
+                r?.();
+            } finally {
+                setWriteOverride(false);
+                setProjectionWriteActive(false);
+            }
+            return true;
+        },
+        deleteProperty(t, o) {
+            if (e && !e()) return true;
+            setWriteOverride(true);
+            setProjectionWriteActive(true);
+            try {
+                delete t[o];
+                r?.();
+            } finally {
+                setWriteOverride(false);
+                setProjectionWriteActive(false);
+            }
+            return true;
+        }
+    };
+    return t;
+}
+
+export { createProjection, createProjectionInternal, createWriteTraps, runProjectionComputed };

package/dist/prod/store/reconcile.js

@@ -0,0 +1,426 @@
+import { setSignal, untrack } from "../core/core.js";
+
+import "../core/scheduler.js";
+
+import "../core/invariants.js";
+
+import "../core/verdict.js";
+
+import "../core/effect.js";
+
+import { $TARGET, STORE_OVERRIDE, STORE_OPTIMISTIC_OVERRIDE, STORE_VALUE, STORE_NODE, storeLookup, STORE_LOOKUP, $PROXY, isWrappable, wrap, notifySelf, $TRACK, STORE_DESC, STORE_HAS, getKeys, $DELETED, symbolKeyedRecords, getStoreSymbols } from "./store.js";
+
+// Enumerate a node record's keys. Keeps the common string-key path on the
+// `Object.keys` fast path; only records currently holding a user symbol node
+// (marked by `getNode`) pay for symbol enumeration. `$TRACK` is the only
+// internal symbol a node record can hold and callers handle it separately.
+function nodeKeys(e) {
+    const t = Object.keys(e);
+    if (symbolKeyedRecords.has(e)) {
+        const r = Object.getOwnPropertySymbols(e);
+        for (let e = 0, n = r.length; e < n; e++) {
+            if (r[e] !== $TRACK) t.push(r[e]);
+        }
+    }
+    return t;
+}
+
+function unwrap(e) {
+    // Primitives can't be store proxies; skip the symbol lookups (which box the
+    // primitive) for the common leaf case.
+    if (e === null || typeof e !== "object") return e;
+    return e[$TARGET]?.[STORE_VALUE] ?? e;
+}
+
+function getOverrideValue(e, t, r, n) {
+    if (n && r in n) return n[r];
+    return t && r in t ? t[r] : e[r];
+}
+
+// Append `o`'s *enumerable* own symbol keys from a pre-fetched symbol list.
+function addEnumSymbols(e, t, r) {
+    for (let n = 0, a = t.length; n < a; n++) {
+        if (Object.prototype.propertyIsEnumerable.call(e, t[n])) r.add(t[n]);
+    }
+}
+
+function getAllKeys(e, t, r) {
+    // Symbols are merged explicitly below; keep the common string-key path on
+    // Object.keys() and avoid reflecting the base symbols twice.
+    const n = getKeys(e, t);
+    const a = Object.keys(r);
+    // `value` can be a wrapped store (store-in-store) whose ownKeys trap tracks;
+    // mirror `getKeys` and enumerate its symbols untracked in that case.
+        const i = e[$TARGET] ? untrack(() => Object.getOwnPropertySymbols(e)) : Object.getOwnPropertySymbols(e);
+    const o = Object.getOwnPropertySymbols(r);
+    // Symbol-free diff (the overwhelmingly common case) stays on the exact
+    // pre-#2851 path, including the identical-key-sets fast path from #2756.
+        if (i.length === 0 && o.length === 0) {
+        if (n.length === a.length) {
+            let e = true;
+            for (let t = 0; t < n.length; t++) {
+                if (n[t] !== a[t]) {
+                    e = false;
+                    break;
+                }
+            }
+            if (e) return n;
+        }
+        const e = new Set(n);
+        for (let t = 0; t < a.length; t++) e.add(a[t]);
+        return Array.from(e);
+    }
+    // Symbol-aware diff (#2851): base symbols join the set, then override
+    // adds/deletes are re-applied so a `$DELETED` symbol stays deleted, then
+    // `next`'s keys (a key present in next is never deleted by the diff).
+        const l = new Set(n);
+    addEnumSymbols(e, i, l);
+    if (t) {
+        for (const e of Reflect.ownKeys(t)) {
+            t[e] === $DELETED ? l.delete(e) : l.add(e);
+        }
+    }
+    for (let e = 0; e < a.length; e++) l.add(a[e]);
+    addEnumSymbols(r, o, l);
+    return Array.from(l);
+}
+
+// Array entries can be `null`/`undefined`/primitives, not just keyed objects.
+// These helpers keep the keyed paths from passing a non-object to `keyFn` (which
+// assumes an object) or to `wrap()` (which assumes a wrappable value).
+function wrapValue(e, t) {
+    return isWrappable(e) ? wrap(e, t) : e;
+}
+
+function itemKey(e, t) {
+    return isWrappable(e) ? t(e) : e;
+}
+
+function keyedMatch(e, t, r) {
+    return e === t || isWrappable(e) && isWrappable(t) && r(e) === r(t);
+}
+
+// Array reconciliation updates the slots it visits, then swaps STORE_VALUE.
+// Previously tracked keys that are absent from `next` still need invalidating,
+// and `in` dependencies should follow the new value's membership. Use
+// membership rather than length arithmetic so sparse arrays and named array
+// props behave like normal property reads.
+function syncArrayNodeMembership(e, t) {
+    let r = e[STORE_NODE];
+    if (r) {
+        const e = nodeKeys(r);
+        for (let n = 0, a = e.length; n < a; n++) {
+            const a = e[n];
+            a in t || setSignal(r[a], undefined);
+        }
+    }
+    if (r = e[STORE_HAS]) {
+        const e = nodeKeys(r);
+        for (let n = 0, a = e.length; n < a; n++) {
+            const a = e[n];
+            setSignal(r[a], a in t);
+        }
+    }
+}
+
+// Reconcile a single array slot: recurse into a wrappable pair, otherwise replace
+// the node's value outright (covers object→primitive and primitive→object).
+function applyArrayItem(e, t, r, n, a) {
+    if (isWrappable(e) && isWrappable(t)) {
+        const i = wrap(t, r);
+        n && setSignal(n, i);
+        applyState(e, i, a);
+    } else n && setSignal(n, wrapValue(e, r));
+}
+
+/**
+ * The captured-proxy half of the object diff (#2902): descend into keyed-
+ * matching children that have NO node at this level but shelter subscribers
+ * somewhere below (their target's sticky `STORE_DESC` flag, bubbled up by
+ * `getNode`). Without this, a proxy captured through untracked reads — a
+ * `<For>` row handed to a child component — detaches from the diff the
+ * moment no intermediate level happens to be tracked, and its live
+ * subscribers go permanently stale. Never-subscribed branches have no flag
+ * and stay pruned exactly as before; keys the main loop already visited
+ * (node present) are skipped. Callers gate on the parent's own flag and on
+ * `$TRACK` absence (an enumeration-tracked record already diffs every key).
+ */ function applyDescendants(e, t, r, n, a, i, o) {
+    const l = r[STORE_LOOKUP] || storeLookup;
+    const s = (i ? getKeys(e, i) : Object.keys(e)).concat(getStoreSymbols(e, i));
+    for (let p = 0, f = s.length; p < f; p++) {
+        const f = s[p];
+        if (n?.[f]) continue;
+ // main loop already diffed this slot
+                const c = unwrap(i ? getOverrideValue(e, i, f, o) : e[f]);
+        if (!isWrappable(c)) continue;
+        const u = (l.get(c) ?? storeLookup.get(c))?.[$TARGET];
+        if (!u?.[STORE_DESC]) continue;
+        const S = unwrap(t[f]);
+        if (c === S || !isWrappable(S) || Array.isArray(c) !== Array.isArray(S) || a(c) != null && a(c) !== a(S)) continue;
+        applyState(S, wrap(c, r), a);
+    }
+}
+
+// Dispatcher: every applyState call (including recursion) checks for the
+// presence of override / optimistic-override slots once and routes to the
+// appropriate body. The fast body never calls `getOverrideValue` and never
+// branches on a `fastPath` boolean, so V8 sees a tighter, more inlinable
+// shape for the overwhelmingly common case of plain stores.
+function applyState(e, t, r) {
+    // Array items and root calls can pass a store proxy as `next`; normalize to
+    // its raw value or the swap would set a store's STORE_VALUE to its own proxy.
+    e = unwrap(e);
+    const n = t?.[$TARGET];
+    if (!n) return;
+    if (n[STORE_OVERRIDE] || n[STORE_OPTIMISTIC_OVERRIDE]) {
+        applyStateSlow(e, n, r);
+    } else {
+        applyStateFast(e, n, r);
+    }
+}
+
+function applyStateFast(e, t, r) {
+    const n = t[STORE_VALUE];
+    if (e === n) return;
+    const a = t[STORE_NODE];
+    // swap
+        (t[STORE_LOOKUP] || storeLookup).set(e, t[$PROXY]);
+    t[STORE_VALUE] = e;
+    // merge
+        if (Array.isArray(n)) {
+        let i = false;
+        const o = n.length;
+        if (e.length && o && isWrappable(e[0]) && r(e[0]) != null) {
+            let l, s, p, f, c, u, S, y;
+            for (p = 0, f = Math.min(o, e.length); p < f && keyedMatch(u = n[p], e[p], r); p++) {
+                isWrappable(u) && isWrappable(e[p]) && applyState(e[p], wrap(u, t), r);
+            }
+            const E = new Array(e.length), O = new Map;
+            for (f = o - 1, c = e.length - 1; f >= p && c >= p && keyedMatch(u = n[f], e[c], r); f--, 
+            c--) {
+                E[c] = u;
+            }
+            if (p > c || p > f) {
+                for (s = p; s <= c; s++) {
+                    i = true;
+                    a?.[s] && setSignal(a[s], wrapValue(e[s], t));
+                }
+                for (;s < e.length; s++) {
+                    i = true;
+                    applyArrayItem(e[s], E[s], t, a?.[s], r);
+                }
+                syncArrayNodeMembership(t, e);
+                (i || o !== e.length) && notifySelf(t);
+                o !== e.length && a?.length && setSignal(a.length, e.length);
+                return;
+            }
+            S = new Array(c + 1);
+            for (s = c; s >= p; s--) {
+                u = e[s];
+                y = itemKey(u, r);
+                l = O.get(y);
+                S[s] = l === undefined ? -1 : l;
+                O.set(y, s);
+            }
+            for (l = p; l <= f; l++) {
+                u = n[l];
+                y = itemKey(u, r);
+                s = O.get(y);
+                if (s !== undefined && s !== -1) {
+                    E[s] = u;
+                    s = S[s];
+                    O.set(y, s);
+                }
+            }
+            for (s = p; s < e.length; s++) {
+                if (s in E) {
+                    applyArrayItem(e[s], E[s], t, a?.[s], r);
+                } else a?.[s] && setSignal(a[s], wrapValue(e[s], t));
+            }
+            if (p < e.length) i = true;
+        } else if (e.length) {
+            for (let o = 0, l = e.length; o < l; o++) {
+                const l = n[o];
+                if (isWrappable(l) && isWrappable(e[o])) applyState(e[o], wrap(l, t), r); else {
+                    if (l !== e[o]) i = true;
+                    a?.[o] && setSignal(a[o], wrapValue(e[o], t));
+                }
+            }
+        }
+        syncArrayNodeMembership(t, e);
+        if (o !== e.length) {
+            i = true;
+            a?.length && setSignal(a.length, e.length);
+        }
+        i && notifySelf(t);
+        return;
+    }
+    // values
+        let i = t[STORE_NODE];
+    let o;
+    if (i) {
+        o = i[$TRACK];
+        const a = o ? getAllKeys(n, undefined, e) : nodeKeys(i);
+        for (let l = 0, s = a.length; l < s; l++) {
+            const s = a[l];
+            const p = i[s];
+            const f = unwrap(n[s]);
+            let c = unwrap(e[s]);
+            if (f === c) continue;
+            if (!f || !isWrappable(f) || !isWrappable(c) || Array.isArray(f) !== Array.isArray(c) || r(f) != null && r(f) !== r(c)) {
+                o && setSignal(o, void 0);
+                p && setSignal(p, isWrappable(c) ? wrap(c, t) : c);
+            } else applyState(c, wrap(f, t), r);
+        }
+    }
+    if (!o && t[STORE_DESC]) applyDescendants(n, e, t, i, r);
+    // has
+        if (i = t[STORE_HAS]) {
+        const t = nodeKeys(i);
+        for (let r = 0, n = t.length; r < n; r++) {
+            const n = t[r];
+            setSignal(i[n], n in e);
+        }
+    }
+}
+
+function applyStateSlow(e, t, r) {
+    const n = t[STORE_VALUE];
+    const a = t[STORE_OVERRIDE];
+    const i = t[STORE_OPTIMISTIC_OVERRIDE];
+    let o = t[STORE_NODE];
+    // swap
+        (t[STORE_LOOKUP] || storeLookup).set(e, t[$PROXY]);
+    t[STORE_VALUE] = e;
+    t[STORE_OVERRIDE] = undefined;
+    // merge
+        if (Array.isArray(n)) {
+        let l = false;
+        const s = getOverrideValue(n, a, "length", i);
+        if (e.length && s && isWrappable(e[0]) && r(e[0]) != null) {
+            let p, f, c, u, S, y, E, O;
+            for (c = 0, u = Math.min(s, e.length); c < u && keyedMatch(y = getOverrideValue(n, a, c, i), e[c], r); c++) {
+                isWrappable(y) && isWrappable(e[c]) && applyState(e[c], wrap(y, t), r);
+            }
+            const R = new Array(e.length), d = new Map;
+            for (u = s - 1, S = e.length - 1; u >= c && S >= c && keyedMatch(y = getOverrideValue(n, a, u, i), e[S], r); u--, 
+            S--) {
+                R[S] = y;
+            }
+            if (c > S || c > u) {
+                for (f = c; f <= S; f++) {
+                    l = true;
+                    o?.[f] && setSignal(o[f], wrapValue(e[f], t));
+                }
+                for (;f < e.length; f++) {
+                    l = true;
+                    applyArrayItem(e[f], R[f], t, o?.[f], r);
+                }
+                const n = e.length;
+                syncArrayNodeMembership(t, e);
+                (l || s !== n) && notifySelf(t);
+                s !== n && o?.length && setSignal(o.length, n);
+                return;
+            }
+            E = new Array(S + 1);
+            for (f = S; f >= c; f--) {
+                y = e[f];
+                O = itemKey(y, r);
+                p = d.get(O);
+                E[f] = p === undefined ? -1 : p;
+                d.set(O, f);
+            }
+            for (p = c; p <= u; p++) {
+                y = getOverrideValue(n, a, p, i);
+                O = itemKey(y, r);
+                f = d.get(O);
+                if (f !== undefined && f !== -1) {
+                    R[f] = y;
+                    f = E[f];
+                    d.set(O, f);
+                }
+            }
+            for (f = c; f < e.length; f++) {
+                if (f in R) {
+                    applyArrayItem(e[f], R[f], t, o?.[f], r);
+                } else o?.[f] && setSignal(o[f], wrapValue(e[f], t));
+            }
+            if (c < e.length) l = true;
+        } else if (e.length) {
+            for (let s = 0, p = e.length; s < p; s++) {
+                const p = getOverrideValue(n, a, s, i);
+                if (isWrappable(p) && isWrappable(e[s])) applyState(e[s], wrap(p, t), r); else {
+                    if (p !== e[s]) l = true;
+                    o?.[s] && setSignal(o[s], wrapValue(e[s], t));
+                }
+            }
+        }
+        const p = e.length;
+        syncArrayNodeMembership(t, e);
+        if (s !== p) {
+            l = true;
+            o?.length && setSignal(o.length, p);
+        }
+        l && notifySelf(t);
+        return;
+    }
+    // values
+        let l;
+    if (o) {
+        l = o[$TRACK];
+        const s = l ? getAllKeys(n, a, e) : nodeKeys(o);
+        for (let p = 0, f = s.length; p < f; p++) {
+            const f = s[p];
+            const c = o[f];
+            const u = unwrap(getOverrideValue(n, a, f, i));
+            let S = unwrap(e[f]);
+            if (u === S) continue;
+            if (!u || !isWrappable(u) || !isWrappable(S) || Array.isArray(u) !== Array.isArray(S) || r(u) != null && r(u) !== r(S)) {
+                l && setSignal(l, void 0);
+                c && setSignal(c, isWrappable(S) ? wrap(S, t) : S);
+            } else applyState(S, wrap(u, t), r);
+        }
+    }
+    if (!l && t[STORE_DESC]) applyDescendants(n, e, t, o, r, a, i);
+    // has
+        if (o = t[STORE_HAS]) {
+        const t = nodeKeys(o);
+        for (let r = 0, n = t.length; r < n; r++) {
+            const n = t[r];
+            setSignal(o[n], n in e);
+        }
+    }
+}
+
+/**
+ * Returns a draft-mutating function that smart-merges `value` into a store,
+ * preserving the identity of items whose `key` field matches between old and
+ * new states. Useful when applying server payloads or full-replacement data
+ * onto an existing store without losing fine-grained reactivity.
+ *
+ * Items with the same key are updated in place (only changed properties
+ * trigger updates). Items added or removed update the corresponding signals.
+ *
+ * @param value the next state to merge in
+ * @param key property name (string) or extractor function for stable identity
+ *
+ * @example
+ * ```ts
+ * const [todos, setTodos] = createStore<Todo[]>([]);
+ *
+ * async function refresh() {
+ *   const fresh = await api.getTodos();
+ *   setTodos(reconcile(fresh, "id")); // diff-merge by `id`
+ * }
+ * ```
+ */ function reconcile(e, t) {
+    return r => {
+        if (r == null) throw new Error("");
+        const n = typeof t === "string" ? e => e[t] : t;
+        const a = n(r);
+        if (a !== undefined && n(e) !== a) throw new Error("");
+        applyState(e, r, n);
+    };
+}
+
+export { reconcile };