@solidjs/signals 0.8.2 → 0.8.3

package/dist/dev.js

@@ -129,8 +129,8 @@ function adjustHeight(el, heap) {
   let newHeight = el._height;
   for (let d = el._deps; d; d = d._nextDep) {
     const dep1 = d._dep;
-    const dep = "_owner" in dep1 ? dep1._owner : dep1;
-    if ("_fn" in dep) {
+    const dep = dep1._firewall || dep1;
+    if (dep._fn) {
       if (dep._height >= newHeight) {
         newHeight = dep._height + 1;
       }
@@ -147,7 +147,6 @@ function adjustHeight(el, heap) {
 // src/core/scheduler.ts
 var clock = 0;
 var activeTransition = null;
-var unobserved = [];
 var transitions = /* @__PURE__ */ new Set();
 var scheduled = false;
 function schedule() {
@@ -276,7 +275,6 @@ var GlobalQueue = class _GlobalQueue extends Queue {
       this.run(2 /* User */);
     } finally {
       this._running = false;
-      unobserved.length && notifyUnobserved();
     }
   }
   notify(node, mask, flags) {
@@ -346,14 +344,6 @@ function transitionComplete(transition) {
   }
   return done;
 }
-function notifyUnobserved() {
-  for (let i = 0; i < unobserved.length; i++) {
-    const source = unobserved[i];
-    if (!source._subs)
-      unobserved[i]._unobserved?.();
-  }
-  unobserved = [];
-}
 
 // src/core/core.ts
 GlobalQueue._update = recompute;
@@ -454,8 +444,8 @@ function updateIfNecessary(el) {
   if (el._flags & 1 /* Check */) {
     for (let d = el._deps; d; d = d._nextDep) {
       const dep1 = d._dep;
-      const dep = "_owner" in dep1 ? dep1._owner : dep1;
-      if ("_fn" in dep) {
+      const dep = dep1._firewall || dep1;
+      if (dep._fn) {
         updateIfNecessary(dep);
       }
       if (el._flags & 2 /* Dirty */) {
@@ -482,9 +472,22 @@ function unlinkSubs(link2) {
     prevSub._nextSub = nextSub;
   } else {
     dep._subs = nextSub;
+    if (nextSub === null) {
+      dep._unobserved?.();
+      dep._fn && unobserved(dep);
+    }
   }
   return nextDep;
 }
+function unobserved(el) {
+  deleteFromHeap(el, el._flags & 32 /* Zombie */ ? zombieQueue : dirtyQueue);
+  let dep = el._deps;
+  while (dep !== null) {
+    dep = unlinkSubs(dep);
+  }
+  el._deps = null;
+  runDisposal(el);
+}
 function link(dep, sub) {
   const prevDep = sub._depsTail;
   if (prevDep !== null && prevDep._dep === dep) {
@@ -560,6 +563,15 @@ function markDisposal(el) {
     child = child._nextSibling;
   }
 }
+function dispose(node) {
+  let toRemove = node._deps || null;
+  do {
+    toRemove = unlinkSubs(toRemove);
+  } while (toRemove !== null);
+  node._deps = null;
+  node._depsTail = null;
+  disposeChildren(node, true);
+}
 function disposeChildren(node, self = false, zombie) {
   if (node._flags & 64 /* Disposed */)
     return;
@@ -738,7 +750,7 @@ function signal(v, options, firewall = null) {
         _value: v,
         _subs: null,
         _subsTail: null,
-        _owner: firewall,
+        _firewall: firewall,
         _nextChild: firewall._child,
         _statusFlags: 0 /* None */,
         _time: clock,
@@ -779,8 +791,8 @@ function read(el) {
     c = c._parentComputed;
   if (c && tracking) {
     link(el, c);
-    const owner = "_owner" in el ? el._owner : el;
-    if ("_fn" in owner) {
+    const owner = el._firewall || el;
+    if (owner._fn) {
       const isZombie = el._flags & 32 /* Zombie */;
       if (owner._height >= (isZombie ? zombieQueue._min : dirtyQueue._min)) {
         markNode(c);
@@ -843,7 +855,7 @@ function read(el) {
   return !c || el._pendingValue === NOT_PENDING || stale && !pendingCheck && el._transition && activeTransition !== el._transition ? el._value : el._pendingValue;
 }
 function setSignal(el, v) {
-  if (!el._pureWrite && context && !context.firewall)
+  if (!el._pureWrite && context && el._firewall !== context)
     console.warn("A Signal was written to in an owned scope.");
   if (typeof v === "function") {
     v = v(
@@ -1113,11 +1125,29 @@ function createRenderEffect(compute, effectFn, value, options) {
 }
 function createTrackedEffect(compute, options) {
 }
-function createReaction(effect2, options) {
+function createReaction(effectFn, options) {
+  let cleanup = void 0;
+  onCleanup(() => cleanup?.());
+  return (tracking2) => {
+    effect(
+      () => (tracking2(), getOwner()),
+      (node) => {
+        cleanup?.();
+        cleanup = (effectFn.effect || effectFn)?.();
+        dispose(node);
+      },
+      effectFn.error,
+      void 0,
+      {
+        defer: true,
+        ...{ ...options, name: options?.name ?? "effect" } 
+      }
+    );
+  };
 }
 function resolve(fn) {
   return new Promise((res, rej) => {
-    createRoot((dispose) => {
+    createRoot((dispose2) => {
       computed(() => {
         try {
           res(fn());
@@ -1126,7 +1156,7 @@ function resolve(fn) {
             throw err;
           rej(err);
         }
-        dispose();
+        dispose2();
       });
     });
   });
@@ -1135,6 +1165,14 @@ function createOptimistic(first, second, third) {
   return {};
 }
 function onSettled(callback) {
+  let cleanup;
+  const o = getOwner();
+  if (o)
+    onCleanup(() => cleanup?.());
+  globalQueue.enqueue(2 /* User */, () => {
+    cleanup = callback();
+    !o && cleanup?.();
+  });
 }
 
 // src/store/reconcile.ts
@@ -1270,23 +1308,17 @@ function reconcile(value, key, all = false) {
 function createProjectionInternal(fn, initialValue = {}, options) {
   let node;
   const wrappedMap = /* @__PURE__ */ new WeakMap();
-  const traps = {
-    ...storeTraps,
-    get(target, property, receiver) {
-      const o = getOwner();
-      const n = node;
-      (!o || o !== n) && n && read(n);
-      return storeTraps.get(target, property, receiver);
-    }
-  };
   const wrapProjection = (source) => {
     if (wrappedMap.has(source))
       return wrappedMap.get(source);
     if (source[$TARGET]?.[STORE_WRAP] === wrapProjection)
       return source;
-    const wrapped = createStoreProxy(source, traps, {
+    const wrapped = createStoreProxy(source, storeTraps, {
       [STORE_WRAP]: wrapProjection,
-      [STORE_LOOKUP]: wrappedMap
+      [STORE_LOOKUP]: wrappedMap,
+      [STORE_FIREWALL]() {
+        return node;
+      }
     });
     wrappedMap.set(source, wrapped);
     return wrapped;
@@ -1319,6 +1351,7 @@ var STORE_NODE = "n";
 var STORE_HAS = "h";
 var STORE_WRAP = "w";
 var STORE_LOOKUP = "l";
+var STORE_FIREWALL = "f";
 function createStoreProxy(value, traps = storeTraps, extend) {
   let newTarget;
   if (Array.isArray(value)) {
@@ -1347,18 +1380,24 @@ function getNodes(target, type) {
     target[type] = nodes = /* @__PURE__ */ Object.create(null);
   return nodes;
 }
-function getNode(nodes, property, value, equals = isEqual) {
+function getNode(nodes, property, value, firewall, equals = isEqual) {
   if (nodes[property])
     return nodes[property];
-  return nodes[property] = signal(value, {
-    equals,
-    unobserved() {
-      delete nodes[property];
-    }
-  });
+  return nodes[property] = signal(
+    value,
+    {
+      equals,
+      unobserved() {
+        delete nodes[property];
+      }
+    },
+    firewall
+  );
 }
 function trackSelf(target, symbol = $TRACK) {
-  getObserver() && read(getNode(getNodes(target, STORE_NODE), symbol, void 0, false));
+  getObserver() && read(
+    getNode(getNodes(target, STORE_NODE), symbol, void 0, target[STORE_FIREWALL]?.(), false)
+  );
 }
 function getKeys(source, override, enumerable = true) {
   const baseKeys = untrack(() => enumerable ? Object.keys(source) : Reflect.ownKeys(source));
@@ -1421,7 +1460,14 @@ var storeTraps = {
         let proto;
         return !Array.isArray(target[STORE_VALUE]) && (proto = Object.getPrototypeOf(target[STORE_VALUE])) && proto !== Object.prototype ? value.bind(storeValue) : value;
       } else if (getObserver()) {
-        return read(getNode(nodes, property, isWrappable(value) ? wrap(value, target) : value));
+        return read(
+          getNode(
+            nodes,
+            property,
+            isWrappable(value) ? wrap(value, target) : value,
+            target[STORE_FIREWALL]?.()
+          )
+        );
       }
     }
     return isWrappable(value) ? wrap(value, target) : value;
@@ -1430,7 +1476,7 @@ var storeTraps = {
     if (property === $PROXY || property === $TRACK || property === "__proto__")
       return true;
     const has = target[STORE_OVERRIDE] && property in target[STORE_OVERRIDE] ? target[STORE_OVERRIDE][property] !== $DELETED : property in target[STORE_VALUE];
-    getObserver() && read(getNode(getNodes(target, STORE_HAS), property, has));
+    getObserver() && read(getNode(getNodes(target, STORE_HAS), property, has, target[STORE_FIREWALL]?.()));
     return has;
   },
   set(target, property, rawValue) {