@solidjs/signals 2.0.0-rc.13 → 2.0.0-rc.15

package/dist/prod/store/affects.js

@@ -0,0 +1,142 @@
+import { GlobalQueue } from "../core/scheduler.js";
+
+import { optHooks, installAffectsHooks } from "./hooks.js";
+
+import { lookupTarget, $OWNER } from "./target.js";
+
+import { $TARGET } from "./types.js";
+
+/**
+ * Store — the store half of `affects()` (plan sec. 29, plan sec. 37; A24 (4), #2882,
+ * #2893, #2904).
+ *
+ * A mark on a store is a mark on nodes (affects.ts: a count on the node, a
+ * dependency walk at probe time): `affects(record, key)` marks the slot's
+ * leaf; `affects(record)` marks a carrier (the record's `$AFFECTS` leaf)
+ * and every live node in the record's subtree — the edges existing readers
+ * subscribed through. Coverage is by RAW IDENTITY, not read path (#2882: a
+ * captured row proxy, a derived store sharing the source's raw, never read
+ * through the declaration's proxy): the identities reachable at the
+ * declaration are the mark's `scope`, so a node born inside the window on
+ * a covered record inherits the mark (released with the carrier's last),
+ * and an untracked probe through a record with no nodes is witnessed into
+ * the verdict. A mark declared on a draft (inside a setter) or over an
+ * optimistic family walks the view the writer sees.
+ *
+ * Imported by `affects()`, which installs it on its first store target
+ * (#3891, after #3912): a program with stores that never declares a mark
+ * carries none of it. It never imports store.ts — the engine's top level —
+ * so a program declaring marks without stores carries this module alone:
+ * the store's nodes and its wrappability test come through `GlobalQueue`
+ * (`_storeNode`, `_storeWrappable`), and node birth and the untracked traps
+ * reach back through `affectsHooks` (hooks.ts).
+ */
+/** The keyless mark's carrier key: a leaf of the record no read serves. */ const $AFFECTS = Symbol(0);
+
+const scopes = new Map;
+
+function scopeOf(e, o) {
+    let n = scopes.get(e);
+    if (n === undefined) scopes.set(e, n = {
+        eo: new Set,
+        oo: [],
+        ot: o
+    });
+    return n;
+}
+
+/** The nodes an `affects(store[, key])` declaration marks (affects.ts
+ * registers each). */ function storeMarks(e, o) {
+    const n = GlobalQueue.no(e, o === undefined ? $AFFECTS : o);
+    const t = scopeOf(n, o);
+    if (o === undefined) {
+        const o = [ n ];
+        walk(e.px, t, o, e.fam, new Set);
+        return o;
+    }
+    t.eo.add(e.v);
+    if (e.pb !== null) t.eo.add(e.pb);
+    return [ n ];
+}
+
+/** The identities reachable from `value` into the scope (the draft's and
+ * the committed backing both, when a draft is open; an optimistic family's
+ * view), every live node under each record into `found`. Untracked by
+ * construction: raws, never traps. */ function walk(e, o, n, t, s) {
+    if (!GlobalQueue.so(e)) return;
+    const f = e[$TARGET] ?? lookupTarget(e, t);
+    let r = f !== undefined ? f.pb ?? f.v : e;
+    if (s.has(r)) return;
+    s.add(r);
+    o.eo.add(r);
+    if (f !== undefined) {
+        if (f.pb !== null) o.eo.add(f.v);
+        // The writer's view: the tick's own unflushed guesses are in motion too.
+                if (f.fam?.opt === true) r = optHooks.view(f, r, true);
+        const e = f.n;
+        if (e !== null) for (const o of Reflect.ownKeys(e)) 
+        // Another mark's carrier is its own channel: counting it here would
+        // extend that scope's lifetime to this declaration's.
+        if (o !== $AFFECTS) n.push(e[o]);
+        const s = f.h;
+        if (s !== null) for (const e of Reflect.ownKeys(s)) n.push(s[e]);
+        if (f.k !== null) n.push(f.k);
+        if (f.dk !== null) n.push(f.dk);
+        t = f.fam ?? t;
+    }
+    for (const e of Reflect.ownKeys(r)) if (e !== $OWNER) {
+        const f = Object.getOwnPropertyDescriptor(r, e);
+        if (f.get === undefined) walk(f.value, o, n, t, s);
+    }
+}
+
+/** A live scope covering `t`'s identity (keyed: for `key`). Chained
+ * backings (§7b): a view's backing is another store's proxy — marks cover
+ * the BASE raw, so every identity along the chain is checked. */ function covering(e, o, n) {
+    for (const [t, s] of scopes) {
+        if (t === n || s.ot !== undefined && s.ot !== o) continue;
+        for (let o = e.v; ;) {
+            if (s.eo.has(o)) return t;
+            const e = o?.[$TARGET];
+            if (e === undefined) break;
+            const n = e.pb ?? e.v;
+            if (n === o) break;
+            o = n;
+        }
+    }
+    return null;
+}
+
+/** The store's side: node birth and the untracked traps call it (store.ts,
+ * through `affectsHooks`) — with no live mark too: an empty scope map is
+ * no work. */ const hooks = {
+    // A node born on a record a live mark covers inherits it (released with
+    // the carrier's last registration).
+    fo(e, o, n) {
+        if (scopes.size === 0 || n === $AFFECTS) return;
+        const t = covering(e, n, o);
+        if (!t) return;
+        GlobalQueue.O(o);
+        scopes.get(t).oo.push(o);
+    },
+    // An untracked probe (`isPending(() => s.x)` with no observer) reading a
+    // record a live mark covers: no node carries the mark for it — the
+    // verdict is told directly.
+    ro(e, o) {
+        if (e.n?.[$AFFECTS]?.m?.T || covering(e, o)) GlobalQueue.ct();
+    }
+};
+
+/** `affects()` calls it before a store-targeted declaration (idempotent). */ function installStoreAffects() {
+    installAffectsHooks(hooks);
+}
+
+/** The carrier's last mark released (affects.ts): its scope dies, and the
+ * nodes that inherited the mark release theirs. */ function releaseMarkScope(e) {
+    const o = scopes.get(e);
+    if (o === undefined) return;
+    scopes.delete(e);
+    GlobalQueue.k(o.oo);
+}
+
+export { installStoreAffects, releaseMarkScope, storeMarks };

package/dist/prod/store/hooks.js

@@ -0,0 +1,13 @@
+let optHooks = null;
+
+function installOptHooks(o) {
+    optHooks = o;
+}
+
+let affectsHooks = null;
+
+function installAffectsHooks(o) {
+    affectsHooks = o;
+}
+
+export { affectsHooks, installAffectsHooks, installOptHooks, optHooks };

package/dist/prod/store/index.js

@@ -1,38 +1,45 @@
-import "../core/core.js";
+import { createStore as createStore$1, deep as deep$1, snapshot as snapshot$1 } from "./store.js";
 
-import "../core/scheduler.js";
+export { storeHasFamily, storeHasOptimisticFamily, storeIsShallow } from "./store.js";
 
-import "../core/invariants.js";
+export { createOptimisticStore } from "./optimistic.js";
 
-import "../core/verdict.js";
+import { createStoreDerived } from "./projection.js";
 
-import "../core/effect.js";
+export { createProjection } from "./projection.js";
 
-import { createStoreNext, deepNext, snapshotNext } from "./next/store.js";
+import { reconcileState } from "./reconcile.js";
 
-export { storeHasFamily, storeHasOptimisticFamily, storeIsShallow } from "./next/store.js";
+import "../core/verdict.js";
 
-import { reconcileNextState } from "./next/reconcile.js";
+import "../core/core.js";
+
+import "../core/scheduler.js";
 
-import { createStoreDerivedNext } from "./next/projection.js";
+import "../core/effect.js";
 
-export { createProjectionNext as createProjection } from "./next/projection.js";
+import "../core/lanes.js";
 
-function createStore(e, t, r) {
-    if (typeof e === "function") return createStoreDerivedNext(e, t, r);
-    return createStoreNext(e, !!t?.shallow);
+function createStore(e, r, t) {
+    if (typeof e === "function") return createStoreDerived(e, r, t);
+    return createStore$1(e, r);
 }
 
-function reconcile(e, t = "id") {
-    return r => reconcileNextState(e, r, t);
+/**
+ * A setter transform that reconciles `value` into the store by key
+ * (`"id"` by default; `null` positional), preserving store identity for
+ * surviving rows.
+ */ function reconcile(e, r = "id") {
+    return t => reconcileState(e, t, r);
 }
 
-function snapshot(e) {
-    return snapshotNext(e);
+/** Non-tracking snapshot of a store's current value (source identity for
+ * unmodified subtrees). */ function snapshot(e) {
+    return snapshot$1(e);
 }
 
-function deep(e) {
-    return deepNext(e);
+/** Tracking snapshot: subscribes to every reachable record. */ function deep(e) {
+    return deep$1(e);
 }
 
 export { createStore, deep, reconcile, snapshot };