@solidjs/signals 2.0.0-rc.2 → 2.0.0-rc.20

package/dist/prod/store/storePath.js

@@ -1,4 +1,4 @@
-import { isWrappable, ownEnumerableKeys } from "./store.js";
+import { isWrappable, ownEnumerableKeys } from "./types.js";
 
 const DELETE = Symbol(0);
 

package/dist/prod/store/target.js

@@ -0,0 +1,43 @@
+/**
+ * Ownership stamp (#3360): every backing the store ALLOCATES (CoW clones,
+ * privatized committed backings) carries its owning target under this
+ * enumerable symbol. One property write replaces the two weak-collection
+ * registrations (ownership set + raw→target map) a fresh object used to pay
+ * per draft — V8's identity-hash + ephemeron cost dominated the one-key
+ * write floor. Enumerable so a spread copy (the plain-data clone path) stays
+ * on the fast path and carries the stamp along.
+ *
+ * Owned backings are never user-reachable (`snapshot` copies them, the traps
+ * hide the key), so every raw key walk in the store must skip `$OWNER`, and
+ * ownership is answered by `isOwned` — a user object never carries it.
+ * Overlay drafts (`Object.create(v)` over an owned `v`) inherit the stamp.
+ */
+const $OWNER = Symbol(0);
+
+/** raw → target for plain (family-less) stores. Family stores use their own
+ * map so one raw can wrap once per family (§7b). */ const storeLookup = new WeakMap;
+
+function setLookup(o, e) {
+    (e.fam?.map ?? storeLookup).set(o, e);
+}
+
+function isOwned(o) {
+    return o[$OWNER] !== undefined;
+}
+
+/** The target wrapping `raw` in `fam` (or the plain lookup). An owned raw
+ * answers from its stamp; a user raw from the map. */ function lookupTarget(o, e) {
+    const n = o[$OWNER];
+    return n !== undefined && n.fam === e ? n : (e?.map ?? storeLookup).get(o);
+}
+
+/** Sticky descendants flag up the parent chain (§6d): adoption descends
+ * into a changed child pair only where a target with nodes exists below. */ function markDescendants(o) {
+    let e = o;
+    while (e && !e.d) {
+        e.d = true;
+        e = e.u;
+    }
+}
+
+export { $OWNER, isOwned, lookupTarget, markDescendants, setLookup, storeLookup };

package/dist/prod/store/types.js

@@ -0,0 +1,83 @@
+/** Brand keys the proxy answers directly (never user data). */
+const $TRACK = Symbol(0), $TARGET = Symbol(0), $PROXY = Symbol(0), $RECORD = Symbol(0);
+
+// ---------------------------------------------------------------------------
+// raw marking (R42 / RUL-12: a value is never both wrapped and raw)
+const rawValues = new WeakSet;
+
+let rawValuesUsed = false;
+
+function isRawValue(e) {
+    return rawValuesUsed && rawValues.has(e);
+}
+
+/** Mark a value so no store ever wraps it (sticky; it reads as a leaf). */ function markRaw(e) {
+    if (isWrappable(e)) {
+        rawValuesUsed = true;
+        rawValues.add(e);
+    }
+    return e;
+}
+
+/** A shallow store's ingested record: raw by contract (values served
+ * verbatim, slots replaced by reference). */ function markRawOne(e) {
+    if (isWrappable(e)) {
+        if (e[$TARGET] !== undefined) return;
+        rawValuesUsed = true;
+        rawValues.add(e);
+    }
+}
+
+function markRawIngest(e) {
+    if (Array.isArray(e)) {
+        for (let r = 0, a = e.length; r < a; r++) markRawOne(e[r]);
+    } else {
+        for (const r in e) markRawOne(e[r]);
+    }
+}
+
+// ---------------------------------------------------------------------------
+// wrappability
+const OBJECT_PROTO = Object.prototype;
+
+const wrappableProtos = new WeakMap;
+
+function isWrappable(e) {
+    if (e == null || typeof e !== "object" || Object.isFrozen(e)) return false;
+    const r = Object.getPrototypeOf(e);
+    if (r === OBJECT_PROTO || r === null) return true;
+    if (Array.isArray(e)) return true;
+    let a = wrappableProtos.get(r);
+    if (a === undefined) {
+        a = Object.prototype.toString.call(e) === "[object Object]" && (typeof Node === "undefined" || !(e instanceof Node));
+        wrappableProtos.set(r, a);
+    }
+    return a;
+}
+
+function ownEnumerableKeys(e) {
+    return Reflect.ownKeys(e).filter(r => Object.prototype.propertyIsEnumerable.call(e, r));
+}
+
+// ---------------------------------------------------------------------------
+// write override: a projection's draft ops carry it (the derive is the
+// author — its writes must land outside the sync setter scope too, in a
+// continuation after an `await`/`yield`). Projections return in S3; the
+// traps already honour it.
+let writeOverride = false;
+
+function setWriteOverride(e) {
+    writeOverride = e;
+}
+
+/** The list driver's view of a shallow store (map.ts): the backing a read of
+ * every slot serves this reader, or `undefined` when the list is no shallow
+ * store or a slot read could differ from it. Installed by store.ts's top
+ * level, so a `<For>` in an app without stores carries none of it; it lives
+ * beside `$TRACK` so map.ts reaches no other store module. */ let shallowView = null;
+
+function installShallowView(e) {
+    shallowView = e;
+}
+
+export { $PROXY, $RECORD, $TARGET, $TRACK, installShallowView, isRawValue, isWrappable, markRaw, markRawIngest, markRawOne, ownEnumerableKeys, rawValuesUsed, setWriteOverride, shallowView, writeOverride };