@solidjs/signals 0.6.0 → 0.6.2

package/dist/dev.js

@@ -64,8 +64,6 @@ var Queue = class {
   _children = [];
   created = clock;
   enqueue(type, fn) {
-    if (ActiveTransition && ActiveTransition._clonedQueues.has(this))
-      return ActiveTransition._clonedQueues.get(this).enqueue(type, fn);
     pureQueue.push(fn);
     if (type)
       this._queues[type - 1].push(fn);
@@ -116,8 +114,6 @@ var Queue = class {
     }
   }
   notify(...args) {
-    if (ActiveTransition && ActiveTransition._clonedQueues.has(this))
-      return ActiveTransition._clonedQueues.get(this).notify(...args);
     if (this._parent)
       return this._parent.notify(...args);
     return false;
@@ -288,6 +284,7 @@ var Transition = class _Transition {
             } else
               value = temp.value;
           }
+          ActiveTransition = null;
           finishTransition(transition2);
         })();
       }
@@ -297,6 +294,7 @@ var Transition = class _Transition {
           while (transition2._done instanceof _Transition)
             transition2 = transition2._done;
           transition2._promises.delete(result);
+          ActiveTransition = null;
           finishTransition(transition2);
         });
       }
@@ -422,6 +420,10 @@ function mergeTransitions(t1, t2) {
 function getTransitionSource(input) {
   return ActiveTransition && ActiveTransition._sources.get(input) || input;
 }
+function getQueue(node) {
+  const transition2 = node._cloned?._transition;
+  return transition2 && transition2._clonedQueues.get(node._queue) || node._queue;
+}
 function initialDispose(node) {
   let current = node._nextSibling;
   while (current !== null && current._parent === node) {
@@ -773,7 +775,7 @@ var Computation = class extends Owner {
       this._notify(STATE_DIRTY);
       return;
     }
-    if (this._state >= STATE_CHECK)
+    if (this._state >= STATE_CHECK && !this._forceNotify)
       return;
     const prevFlags = this._stateFlags & mask;
     const deltaFlags = prevFlags ^ newFlags2;
@@ -1042,7 +1044,7 @@ var Effect = class extends Computation {
       };
     }
     this._updateIfNecessary();
-    !options?.defer && (this._type === EFFECT_USER ? this._queue.enqueue(this._type, this._run.bind(this)) : this._run(this._type));
+    !options?.defer && (this._type === EFFECT_USER ? getQueue(this).enqueue(this._type, this._run.bind(this)) : this._run(this._type));
     if (!this._parent)
       console.warn("Effects created outside a reactive context will never be disposed");
   }
@@ -1050,7 +1052,7 @@ var Effect = class extends Computation {
     if (this._state == STATE_DIRTY) {
       this._stateFlags = flags;
       if (this._type === EFFECT_RENDER) {
-        this._queue.notify(this, LOADING_BIT | ERROR_BIT, this._stateFlags);
+        getQueue(this).notify(this, LOADING_BIT | ERROR_BIT, this._stateFlags);
       }
     }
     if (value === UNCHANGED)
@@ -1064,7 +1066,7 @@ var Effect = class extends Computation {
     if (this._state >= state || skipQueue)
       return;
     if (this._state === STATE_CLEAN)
-      this._queue.enqueue(this._type, this._run.bind(this));
+      getQueue(this).enqueue(this._type, this._run.bind(this));
     this._state = state;
   }
   _notifyFlags(mask, newFlags2) {
@@ -1080,7 +1082,7 @@ var Effect = class extends Computation {
   }
   _setError(error) {
     this._error = error;
-    this._queue.notify(this, LOADING_BIT, 0);
+    getQueue(this).notify(this, LOADING_BIT, 0);
     this._stateFlags = ERROR_BIT;
     if (this._type === EFFECT_USER) {
       try {
@@ -1092,7 +1094,7 @@ var Effect = class extends Computation {
         error = e;
       }
     }
-    if (!this._queue.notify(this, ERROR_BIT, ERROR_BIT))
+    if (!getQueue(this).notify(this, ERROR_BIT, ERROR_BIT))
       throw error;
   }
   _disposeNode() {
@@ -1103,7 +1105,7 @@ var Effect = class extends Computation {
     this._onerror = void 0;
     this._cleanup?.();
     this._cleanup = void 0;
-    this._queue.notify(this, ERROR_BIT | LOADING_BIT, 0);
+    getQueue(this).notify(this, ERROR_BIT | LOADING_BIT, 0);
     super._disposeNode();
   }
   _run(type) {
@@ -1114,7 +1116,7 @@ var Effect = class extends Computation {
         try {
           effect._cleanup = effect._effect(effect._value, effect._prevValue);
         } catch (e) {
-          if (!effect._queue.notify(effect, ERROR_BIT, ERROR_BIT))
+          if (!getQueue(effect).notify(effect, ERROR_BIT, ERROR_BIT))
             throw e;
         } finally {
           effect._prevValue = effect._value;
@@ -1136,7 +1138,7 @@ var EagerComputation = class extends Computation {
     if (this._state >= state && !this._forceNotify)
       return;
     if (!skipQueue && (this._state === STATE_CLEAN || this._state === STATE_CHECK && this._forceNotify))
-      this._queue.enqueue(EFFECT_PURE, this._run.bind(this));
+      getQueue(this).enqueue(EFFECT_PURE, this._run.bind(this));
     super._notify(state, skipQueue);
   }
   _run() {
@@ -1154,7 +1156,7 @@ var FirewallComputation = class extends Computation {
     if (this._state >= state && !this._forceNotify)
       return;
     if (!skipQueue && (this._state === STATE_CLEAN || this._state === STATE_CHECK && this._forceNotify))
-      this._queue.enqueue(EFFECT_PURE, this._run.bind(this));
+      getQueue(this).enqueue(EFFECT_PURE, this._run.bind(this));
     super._notify(state, true);
     this._forceNotify = !!skipQueue;
   }
@@ -1989,15 +1991,15 @@ function resolve(fn) {
 function createPending() {
   const node = new Computation(false, null);
   const reset = () => node.write(false);
-  function write(v) {
+  function write() {
     if (!ActiveTransition)
-      return v;
+      return false;
     ActiveTransition.addOptimistic(reset);
-    queueMicrotask(() => reset._transition && node.write(v));
+    queueMicrotask(() => reset._transition && node.write(true));
   }
   function read() {
-    node.read();
-    return !ActiveTransition;
+    const v = node.read();
+    return ActiveTransition ? false : v;
   }
   return [read, write];
 }
@@ -2023,11 +2025,11 @@ function createOptimistic(first, second, options) {
   } else
     [store, setStore] = createStore(first);
   const reset = () => setStore(
-    (s) => reconcile(
-      { value: typeof first === "function" ? first(second) : first },
+    reconcile(
+      typeof first === "function" ? first(second) : first,
       options?.key || "id",
       options?.all
-    )(s)
+    )
   );
   function write(v) {
     if (!ActiveTransition)
@@ -2249,7 +2251,7 @@ var BoundaryComputation = class extends EagerComputation {
     if (this._propagationMask & LOADING_BIT && !(this._stateFlags & UNINITIALIZED_BIT || ActiveTransition)) {
       flags &= ~LOADING_BIT;
     }
-    this._queue.notify(this, this._propagationMask, flags);
+    getQueue(this).notify(this, this._propagationMask, flags);
     return this._value;
   }
 };
@@ -2385,7 +2387,7 @@ function createErrorBoundary(fn, fallback) {
         if (ActiveTransition && !node2._cloned)
           node2 = cloneGraph(node2);
         node2._state = STATE_DIRTY;
-        node2._queue?.enqueue(node2._type, node2._run.bind(node2));
+        getQueue(node2).enqueue(node2._type, node2._run.bind(node2));
       }
     });
   });