@solidjs/signals 2.0.0-beta.24 → 2.0.0-beta.26

package/dist/prod/store/projection.js

@@ -14,14 +14,21 @@ 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";
+import { storeSetter, $TARGET, STORE_WRAP, createStoreProxy, storeTraps, setWriteOverride, STORE_LOOKUP, STORE_SHALLOW, markRawIngest, STORE_VALUE, STORE_FIREWALL } from "./store.js";
 
 function createProjectionInternal(e, r, t) {
     let o;
-    const i = new WeakMap;
+    const n = new WeakMap;
+    // A shallow projection's children are raw and never wrapped, so the
+    // wrapper only ever runs for the root — flagging unconditionally is safe.
+        const i = !!t?.shallow;
     const wrapper = e => {
         e[STORE_WRAP] = wrapProjection;
-        e[STORE_LOOKUP] = i;
+        e[STORE_LOOKUP] = n;
+        if (i) {
+            e[STORE_SHALLOW] = true;
+            markRawIngest(e[STORE_VALUE]);
+        }
         Object.defineProperty(e, STORE_FIREWALL, {
             get() {
                 return o;
@@ -30,20 +37,20 @@ function createProjectionInternal(e, r, t) {
         });
     };
     const wrapProjection = e => {
-        if (i.has(e)) return i.get(e);
+        if (n.has(e)) return n.get(e);
         if (e[$TARGET]?.[STORE_WRAP] === wrapProjection) return e;
         const r = createStoreProxy(e, storeTraps, wrapper);
-        i.set(e, r);
+        n.set(e, r);
         return r;
     };
-    const n = wrapProjection(r);
+    const c = wrapProjection(r);
     o = computed(() => {
         if (!o) o = getOwner();
-        runProjectionComputed(n, e, t?.key || "id");
+        runProjectionComputed(c, e, t?.key || "id");
     }, undefined);
     o.T &= ~CONFIG_AUTO_DISPOSE;
     return {
-        store: n,
+        store: c,
         node: o
     };
 }
@@ -106,22 +113,22 @@ function createProjectionInternal(e, r, t) {
  * 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();
+ */ function runProjectionComputed(e, r, t, o, n) {
+    const i = getOwner();
     let c = false;
     let s;
-    const u = new Proxy(e, createWriteTraps(() => !c || n.Te === s, i));
-    storeSetter(u, i => {
-        s = r(i);
+    const u = new Proxy(e, createWriteTraps(() => !c || i.Te === s, n));
+    storeSetter(u, n => {
+        s = r(n);
         c = true;
         const commit = r => {
-            if (r === i || r === undefined) return;
+            if (r === n || r === undefined) return;
             const write = () => storeSetter(e, reconcile(r, t));
             o ? o(write) : write();
         };
-        commit(handleAsync(n, s, commit));
+        commit(handleAsync(i, s, commit));
     });
-    return n;
+    return i;
 }
 
 function createWriteTraps(e, r) {
@@ -151,12 +158,12 @@ function createWriteTraps(e, r) {
             }
             return t;
         },
-        set(t, o, i) {
+        set(t, o, n) {
             if (e && !e()) return true;
             setWriteOverride(true);
             setProjectionWriteActive(true);
             try {
-                t[o] = i;
+                t[o] = n;
                 r?.();
             } finally {
                 setWriteOverride(false);