@solidjs/signals 0.4.2 → 0.4.4

package/dist/dev.js

@@ -64,8 +64,8 @@ var Queue = class {
   _children = [];
   created = clock;
   enqueue(type, fn) {
-    if (ActiveTransition)
-      return ActiveTransition.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);
@@ -110,10 +110,23 @@ var Queue = class {
       this._children.splice(index, 1);
   }
   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;
   }
+  merge(queue) {
+    this._queues[0].push.apply(this._queues[0], queue._queues[0]);
+    this._queues[1].push.apply(this._queues[1], queue._queues[1]);
+    for (let i = 0; i < queue._children.length; i++) {
+      const og = this._children.find((c) => c._cloned === queue._children[i]._cloned);
+      if (og)
+        og.merge(queue._children[i]);
+      else
+        this.addChild(queue._children[i]);
+    }
+  }
 };
 var globalQueue = new Queue();
 function flush() {
@@ -135,12 +148,19 @@ var Transition = class _Transition {
   _optimistic = /* @__PURE__ */ new Set();
   _done = false;
   _queues = [[], []];
+  _clonedQueues = /* @__PURE__ */ new Map();
   _pureQueue = [];
   _children = [];
   _parent = null;
   _running = false;
   _scheduled = false;
   created = clock;
+  constructor() {
+    this._clonedQueues.set(globalQueue, this);
+    for (const child of globalQueue._children) {
+      cloneQueue(child, this, this._clonedQueues);
+    }
+  }
   enqueue(type, fn) {
     this._pureQueue.push(fn);
     if (type)
@@ -197,6 +217,18 @@ var Transition = class _Transition {
     }
     return true;
   }
+  merge(queue) {
+    this._queues[0].push.apply(this._queues[0], queue._queues[0]);
+    this._queues[1].push.apply(this._queues[1], queue._queues[1]);
+    this._pureQueue.push.apply(this._pureQueue, queue._pureQueue);
+    for (let i = 0; i < queue._children.length; i++) {
+      const og = this._children.find((c) => c._cloned === queue._children[i]._cloned);
+      if (og)
+        og.merge(queue._children[i]);
+      else
+        this.addChild(queue._children[i]);
+    }
+  }
   schedule() {
     if (this._scheduled)
       return;
@@ -240,10 +272,8 @@ var Transition = class _Transition {
     this._optimistic.add(fn);
   }
 };
-var Transitions = /* @__PURE__ */ new Set();
 function transition(fn) {
   let t = new Transition();
-  Transitions.add(t);
   queueMicrotask(() => t.runTransition(() => fn((fn2) => t.runTransition(fn2))));
 }
 function cloneGraph(node) {
@@ -281,6 +311,49 @@ function removeSourceObservers(node, index) {
     }
   }
 }
+function cloneQueue(queue, parent, clonedQueues) {
+  const clone = Object.create(Object.getPrototypeOf(queue));
+  Object.assign(clone, queue, {
+    _cloned: queue,
+    _parent: parent,
+    _children: [],
+    enqueue(type, fn) {
+      ActiveTransition?.enqueue(type, fn);
+    },
+    notify(node, type, flags) {
+      node = node._cloned || node;
+      if (!clone._collectionType || type & LOADING_BIT) {
+        type &= ~LOADING_BIT;
+        ActiveTransition?.notify(node, LOADING_BIT, flags);
+        if (!type)
+          return true;
+      }
+      return queue.notify.call(this, node, type, flags);
+    }
+  });
+  parent._children.push(clone);
+  clonedQueues.set(queue, clone);
+  for (const child of queue._children) {
+    cloneQueue(child, clone, clonedQueues);
+  }
+}
+function resolveQueues(children) {
+  for (const child of children) {
+    const og = child._cloned;
+    if (og) {
+      const clonedChildren = child._children;
+      delete child.enqueue;
+      delete child.notify;
+      delete child._parent;
+      delete child._children;
+      Object.assign(og, child);
+      delete og._cloned;
+      resolveQueues(clonedChildren);
+    } else if (child._parent._cloned) {
+      child._parent._cloned.addChild(child);
+    }
+  }
+}
 function mergeTransitions(t1, t2) {
   t2._sources.forEach((value, key) => {
     key._transition = t1;
@@ -292,12 +365,8 @@ function mergeTransitions(t1, t2) {
   });
   t2._promises.forEach((p) => t1._promises.add(p));
   t2._pendingNodes.forEach((n) => t1._pendingNodes.add(n));
-  t2._queues[0].forEach((f) => t1._queues[0].push(f));
-  t2._queues[1].forEach((f) => t1._queues[1].push(f));
-  t2._pureQueue.forEach((f) => t1._pureQueue.push(f));
-  t2._children.forEach((c) => t1.addChild(c));
+  t1.merge(t2);
   t2._done = t1;
-  Transitions.delete(t2);
 }
 function finishTransition(transition2) {
   if (transition2._done || transition2._scheduled || transition2._promises.size || transition2._pendingNodes.size)
@@ -313,10 +382,11 @@ function finishTransition(transition2) {
     delete source._cloned;
     delete source._transition;
   }
+  globalQueue._queues[0].push.apply(globalQueue._queues[0], transition2._queues[0]);
+  globalQueue._queues[1].push.apply(globalQueue._queues[1], transition2._queues[1]);
+  resolveQueues(transition2._children);
   transition2._done = true;
-  Transitions.delete(transition2);
-  transition2.run(EFFECT_RENDER);
-  transition2.run(EFFECT_USER);
+  globalQueue.flush();
   for (const reset of transition2._optimistic) {
     delete reset._transition;
     reset();
@@ -572,7 +642,8 @@ var Computation = class extends Owner {
   write(value, flags = 0, raw = false) {
     if (ActiveTransition && !this._cloned) {
       const clone = cloneGraph(this);
-      return clone.write(value, flags, raw);
+      if (clone !== this)
+        return clone.write(value, flags, raw);
     }
     if (!this._compute && !this._pureWrite && getOwner() && !getOwner().firewall)
       console.warn("A Signal was written to in an owned scope.");
@@ -645,6 +716,11 @@ var Computation = class extends Owner {
     }
   }
   _setError(error) {
+    if (ActiveTransition && !this._cloned) {
+      const clone = cloneGraph(this);
+      if (clone !== this)
+        return clone._setError(error);
+    }
     this._error = error;
     this.write(UNCHANGED, this._stateFlags & ~LOADING_BIT | ERROR_BIT | UNINITIALIZED_BIT);
   }
@@ -887,15 +963,15 @@ var Effect = class extends Computation {
       this._compute = (p) => !ActiveTransition && clock > this._queue.created && !(this._stateFlags & ERROR_BIT) ? latest(() => compute2(p)) : compute2(p);
     }
     this._updateIfNecessary();
-    !options?.defer && (this._type === EFFECT_USER ? (ActiveTransition || this._queue).enqueue(this._type, this._run.bind(this)) : this._run(this._type));
+    !options?.defer && (this._type === EFFECT_USER ? this._queue.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");
   }
   write(value, flags = 0) {
-    if (this._state == STATE_DIRTY || flags !== this._stateFlags) {
+    if (this._state == STATE_DIRTY) {
       this._stateFlags = flags;
       if (this._type === EFFECT_RENDER) {
-        (ActiveTransition || this._queue).notify(this, LOADING_BIT | ERROR_BIT, flags);
+        this._queue.notify(this, LOADING_BIT | ERROR_BIT, flags);
       }
     }
     if (value === UNCHANGED)
@@ -911,7 +987,7 @@ var Effect = class extends Computation {
     if (this._state >= state || skipQueue)
       return;
     if (this._state === STATE_CLEAN)
-      (ActiveTransition || this._queue).enqueue(this._type, this._run.bind(this));
+      this._queue.enqueue(this._type, this._run.bind(this));
     this._state = state;
   }
   _notifyFlags(mask, newFlags2) {
@@ -927,7 +1003,7 @@ var Effect = class extends Computation {
   }
   _setError(error) {
     this._error = error;
-    (ActiveTransition || this._queue).notify(this, LOADING_BIT, 0);
+    this._queue.notify(this, LOADING_BIT, 0);
     this._stateFlags = ERROR_BIT;
     if (this._type === EFFECT_USER) {
       try {
@@ -939,7 +1015,7 @@ var Effect = class extends Computation {
         error = e;
       }
     }
-    if (!(ActiveTransition || this._queue).notify(this, ERROR_BIT, ERROR_BIT))
+    if (!this._queue.notify(this, ERROR_BIT, ERROR_BIT))
       throw error;
   }
   _disposeNode() {
@@ -954,16 +1030,17 @@ var Effect = class extends Computation {
   }
   _run(type) {
     if (type) {
-      if (this._modified && this._state !== STATE_DISPOSED) {
-        this._cleanup?.();
+      const effect = this._cloned || this;
+      if (effect._modified && effect._state !== STATE_DISPOSED) {
+        effect._cleanup?.();
         try {
-          this._cleanup = this._effect(this._value, this._prevValue);
+          effect._cleanup = effect._effect(effect._value, effect._prevValue);
         } catch (e) {
-          if (!(ActiveTransition || this._queue).notify(this, ERROR_BIT, ERROR_BIT))
+          if (!effect._queue.notify(effect, ERROR_BIT, ERROR_BIT))
             throw e;
         } finally {
-          this._prevValue = this._value;
-          this._modified = false;
+          effect._prevValue = effect._value;
+          effect._modified = false;
         }
       }
     } else
@@ -984,7 +1061,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))
-      (ActiveTransition || this._queue).enqueue(EFFECT_PURE, this._run.bind(this));
+      this._queue.enqueue(EFFECT_PURE, this._run.bind(this));
     super._notify(state, skipQueue);
   }
   _run() {
@@ -1005,7 +1082,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))
-      (ActiveTransition || this._queue).enqueue(EFFECT_PURE, this._run.bind(this));
+      this._queue.enqueue(EFFECT_PURE, this._run.bind(this));
     super._notify(state, true);
     this._forceNotify = !!skipQueue;
   }
@@ -2104,6 +2181,8 @@ var ConditionalQueue = class extends Queue {
     return super.run(type);
   }
   notify(node, type, flags) {
+    if (ActiveTransition && ActiveTransition._clonedQueues.has(this))
+      return ActiveTransition._clonedQueues.get(this).notify(node, type, flags);
     if (this._disabled.read()) {
       if (type & LOADING_BIT) {
         if (flags & LOADING_BIT) {
@@ -2122,6 +2201,11 @@ var ConditionalQueue = class extends Queue {
     }
     return type ? super.notify(node, type, flags) : true;
   }
+  merge(queue) {
+    queue._pendingNodes.forEach((n) => this.notify(n, LOADING_BIT, LOADING_BIT));
+    queue._errorNodes.forEach((n) => this.notify(n, ERROR_BIT, ERROR_BIT));
+    super.merge(queue);
+  }
 };
 var CollectionQueue = class extends Queue {
   _collectionType;
@@ -2137,6 +2221,8 @@ var CollectionQueue = class extends Queue {
     return super.run(type);
   }
   notify(node, type, flags) {
+    if (ActiveTransition && ActiveTransition._clonedQueues.has(this))
+      return ActiveTransition._clonedQueues.get(this).notify(node, type, flags);
     if (!(type & this._collectionType))
       return super.notify(node, type, flags);
     if (flags & this._collectionType) {
@@ -2151,6 +2237,10 @@ var CollectionQueue = class extends Queue {
     type &= ~this._collectionType;
     return type ? super.notify(node, type, flags) : true;
   }
+  merge(queue) {
+    queue._nodes.forEach((n) => this.notify(n, this._collectionType, this._collectionType));
+    super.merge(queue);
+  }
 };
 function createBoundary(fn, condition) {
   const owner = new Owner();
@@ -2188,17 +2278,17 @@ function createSuspense(fn, fallback) {
   return createCollectionBoundary(LOADING_BIT, fn, () => fallback());
 }
 function createErrorBoundary(fn, fallback) {
-  return createCollectionBoundary(
-    ERROR_BIT,
-    fn,
-    (queue) => fallback(queue._nodes.values().next().value._error, () => {
+  return createCollectionBoundary(ERROR_BIT, fn, (queue) => {
+    let node = queue._nodes.values().next().value;
+    ActiveTransition && ActiveTransition._sources.has(node) && (node = ActiveTransition._sources.get(node));
+    return fallback(node._error, () => {
       incrementClock();
-      for (let node of queue._nodes) {
-        node._state = STATE_DIRTY;
-        node._queue?.enqueue(node._type, node._run.bind(node));
+      for (let node2 of queue._nodes) {
+        node2._state = STATE_DIRTY;
+        node2._queue?.enqueue(node2._type, node2._run.bind(node2));
       }
-    })
-  );
+    });
+  });
 }
 function flatten(children, options) {
   if (typeof children === "function" && !children.length) {