@solidjs/signals 0.8.1 → 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() {
@@ -205,6 +204,30 @@ var Queue = class {
       this._queues[type - 1].push(fn);
     schedule();
   }
+  stashQueues(stub) {
+    stub._queues[0].push(...this._queues[0]);
+    stub._queues[1].push(...this._queues[1]);
+    this._queues = [[], []];
+    for (let i = 0; i < this._children.length; i++) {
+      let child = this._children[i];
+      let childStub = stub._children[i];
+      if (!childStub) {
+        childStub = { _queues: [[], []], _children: [] };
+        stub._children[i] = childStub;
+      }
+      child.stashQueues(childStub);
+    }
+  }
+  restoreQueues(stub) {
+    this._queues[0].push(...stub._queues[0]);
+    this._queues[1].push(...stub._queues[1]);
+    for (let i = 0; i < stub._children.length; i++) {
+      const childStub = stub._children[i];
+      let child = this._children[i];
+      if (child)
+        child.restoreQueues(childStub);
+    }
+  }
 };
 var GlobalQueue = class _GlobalQueue extends Queue {
   _running = false;
@@ -221,9 +244,7 @@ var GlobalQueue = class _GlobalQueue extends Queue {
         if (!transitionComplete(activeTransition)) {
           runHeap(zombieQueue, _GlobalQueue._update);
           globalQueue._pendingNodes = [];
-          activeTransition.queues[0].push(...globalQueue._queues[0]);
-          activeTransition.queues[1].push(...globalQueue._queues[1]);
-          globalQueue._queues = [[], []];
+          globalQueue.stashQueues(activeTransition.queueStash);
           clock++;
           scheduled = false;
           runPending(activeTransition.pendingNodes, true);
@@ -231,8 +252,7 @@ var GlobalQueue = class _GlobalQueue extends Queue {
           return;
         }
         globalQueue._pendingNodes.push(...activeTransition.pendingNodes);
-        globalQueue._queues[0].push(...activeTransition.queues[0]);
-        globalQueue._queues[1].push(...activeTransition.queues[1]);
+        globalQueue.restoreQueues(activeTransition.queueStash);
         transitions.delete(activeTransition);
         activeTransition = null;
         if (runPending(globalQueue._pendingNodes, false))
@@ -255,7 +275,6 @@ var GlobalQueue = class _GlobalQueue extends Queue {
       this.run(2 /* User */);
     } finally {
       this._running = false;
-      unobserved.length && notifyUnobserved();
     }
   }
   notify(node, mask, flags) {
@@ -276,7 +295,7 @@ var GlobalQueue = class _GlobalQueue extends Queue {
         time: clock,
         pendingNodes: [],
         asyncNodes: [],
-        queues: [[], []]
+        queueStash: { _queues: [[], []], _children: [] }
       };
     }
     transitions.add(activeTransition);
@@ -325,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;
@@ -343,6 +354,14 @@ var pendingValueCheck = false;
 var pendingCheck = null;
 var context = null;
 var defaultContext = {};
+function notifySubs(node) {
+  for (let s = node._subs; s !== null; s = s._nextSub) {
+    const queue = s._sub._flags & 32 /* Zombie */ ? zombieQueue : dirtyQueue;
+    if (queue._min > s._sub._height)
+      queue._min = s._sub._height;
+    insertIntoHeap(s._sub, queue);
+  }
+}
 function recompute(el, create = false) {
   deleteFromHeap(el, el._flags & 32 /* Zombie */ ? zombieQueue : dirtyQueue);
   if (el._pendingValue !== NOT_PENDING || el._pendingFirstChild || el._pendingDisposal)
@@ -425,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 */) {
@@ -453,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) {
@@ -513,7 +545,7 @@ function setStatusFlags(signal2, flags, error = null) {
   signal2._error = error;
 }
 function setError(signal2, error) {
-  setStatusFlags(signal2, 2 /* Error */ | 4 /* Uninitialized */, error);
+  setStatusFlags(signal2, 2 /* Error */, error);
 }
 function clearStatusFlags(signal2) {
   setStatusFlags(signal2, 0 /* None */);
@@ -531,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;
@@ -664,6 +705,9 @@ function asyncComputed(asyncFn, initialValue, options) {
           return;
         globalQueue.initTransition(self);
         setError(self, e);
+        self._time = clock;
+        notifySubs(self);
+        schedule();
         flush();
       });
     } else {
@@ -681,6 +725,9 @@ function asyncComputed(asyncFn, initialValue, options) {
             return;
           globalQueue.initTransition(self);
           setError(self, error);
+          self._time = clock;
+          notifySubs(self);
+          schedule();
           flush();
         }
       })();
@@ -703,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,
@@ -744,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);
@@ -808,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(
@@ -831,12 +878,7 @@ function setSignal(el, v) {
   }
   clearStatusFlags(el);
   el._time = clock;
-  for (let s = el._subs; s !== null; s = s._nextSub) {
-    const queue = s._sub._flags & 32 /* Zombie */ ? zombieQueue : dirtyQueue;
-    if (queue._min > s._sub._height)
-      queue._min = s._sub._height;
-    insertIntoHeap(s._sub, queue);
-  }
+  notifySubs(el);
   schedule();
   return v;
 }
@@ -1013,9 +1055,8 @@ function effect(compute, effect2, error, initialValue, options) {
     }
   });
   initialized = true;
-  if (node._type === 1 /* Render */) {
-    node._fn = (p) => !(node._statusFlags & 2 /* Error */) ? staleValues(() => compute(p)) : compute(p);
-  }
+  if (node._type === 1 /* Render */)
+    node._fn = (p) => staleValues(() => compute(p));
   !options?.defer && !(node._statusFlags & (2 /* Error */ | 1 /* Pending */)) && (node._type === 2 /* User */ ? node._queue.enqueue(node._type, runEffect.bind(node)) : runEffect.call(node));
   onCleanup(() => node._cleanup?.());
   if (!node._parent)
@@ -1084,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());
@@ -1097,7 +1156,7 @@ function resolve(fn) {
             throw err;
           rej(err);
         }
-        dispose();
+        dispose2();
       });
     });
   });
@@ -1106,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
@@ -1241,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;
@@ -1290,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)) {
@@ -1318,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));
@@ -1392,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;
@@ -1401,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) {
@@ -2045,12 +2120,6 @@ var CollectionQueue = class extends Queue {
       return;
     return super.run(type);
   }
-  enqueue(type, fn) {
-    if (this._collectionType & 1 /* Pending */ && this._initialized) {
-      return this._parent?.enqueue(type, fn);
-    }
-    return super.enqueue(type, fn);
-  }
   notify(node, type, flags) {
     if (!(type & this._collectionType) || this._collectionType & 1 /* Pending */ && this._initialized)
       return super.notify(node, type, flags);