@solidjs/signals 0.4.8 → 0.4.9

package/dist/dev.js

@@ -101,13 +101,19 @@ var Queue = class {
     }
   }
   addChild(child) {
+    if (ActiveTransition && ActiveTransition._clonedQueues.has(this))
+      return ActiveTransition._clonedQueues.get(this).addChild(child);
     this._children.push(child);
     child._parent = this;
   }
   removeChild(child) {
+    if (ActiveTransition && ActiveTransition._clonedQueues.has(this))
+      return ActiveTransition._clonedQueues.get(this).removeChild(child);
     const index = this._children.indexOf(child);
-    if (index >= 0)
+    if (index >= 0) {
       this._children.splice(index, 1);
+      child._parent = null;
+    }
   }
   notify(...args) {
     if (ActiveTransition && ActiveTransition._clonedQueues.has(this))
@@ -137,6 +143,21 @@ function flush() {
     globalQueue.flush();
   }
 }
+function removeSourceObservers(node, index) {
+  let source;
+  let swap;
+  for (let i = index; i < node._sources.length; i++) {
+    source = getTransitionSource(node._sources[i]);
+    if (source._observers) {
+      if ((swap = source._observers.indexOf(node)) !== -1) {
+        source._observers[swap] = source._observers[source._observers.length - 1];
+        source._observers.pop();
+      }
+      if (!source._observers.length)
+        Unobserved.push(source);
+    }
+  }
+}
 function runQueue(queue, type) {
   for (let i = 0; i < queue.length; i++)
     queue[i](type);
@@ -154,6 +175,7 @@ var Transition = class _Transition {
   _parent = null;
   _running = false;
   _scheduled = false;
+  _cloned = globalQueue;
   created = clock;
   constructor() {
     this._clonedQueues.set(globalQueue, this);
@@ -292,8 +314,6 @@ function cloneGraph(node) {
     _sources: node._sources ? [...node._sources] : null,
     _cloned: node
   });
-  if (clone._compute)
-    clone._stateFlags |= UNINITIALIZED_BIT;
   ActiveTransition._sources.set(node, clone);
   node._transition = ActiveTransition;
   if (node._sources) {
@@ -378,25 +398,51 @@ function mergeTransitions(t1, t2) {
   t1.merge(t2);
   t2._done = t1;
 }
+function getTransitionSource(input) {
+  return ActiveTransition && ActiveTransition._sources.get(input) || input;
+}
+function initialDispose(node) {
+  let current = node._nextSibling;
+  while (current !== null && current._parent === node) {
+    initialDispose(current);
+    const clone = ActiveTransition._sources.get(current);
+    if (clone && !clone._updated)
+      clone.dispose(true);
+    current = current._nextSibling;
+  }
+}
 function finishTransition(transition2) {
   if (transition2._done || transition2._scheduled || transition2._promises.size || transition2._pendingNodes.size)
     return;
+  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);
   for (const [source, clone] of transition2._sources) {
-    if (source === clone || source._transition !== transition2)
+    if (source === clone || source._transition !== transition2) {
+      delete source._transition;
       continue;
+    }
     if (clone._sources)
       replaceSourceObservers(clone, transition2);
-    if (!(clone._stateFlags === UNINITIALIZED_BIT)) {
-      source.dispose(false);
+    if (clone._updated || clone._state === STATE_DISPOSED) {
+      source.dispose(clone._state === STATE_DISPOSED);
       source.emptyDisposal();
-      Object.assign(source, clone);
-      delete source._cloned;
+      delete clone._updated;
+    } else {
+      delete clone._nextSibling;
+      delete clone._disposal;
+    }
+    Object.assign(source, clone);
+    delete source._cloned;
+    let current = clone._nextSibling;
+    if (current?._prevSibling === clone)
+      current._prevSibling = source;
+    while (current?._parent === clone) {
+      current._parent = source;
+      current = current._nextSibling;
     }
     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;
   for (const reset of transition2._optimistic) {
     delete reset._transition;
@@ -456,7 +502,6 @@ var Owner = class {
     let head = self ? this._prevSibling || this._parent : this, current = this._nextSibling, next = null;
     while (current && current._parent === this) {
       current.dispose(true);
-      current._disposeNode();
       next = current._nextSibling;
       current._nextSibling = null;
       current = next;
@@ -609,7 +654,7 @@ var Computation = class extends Owner {
    * Automatically re-executes the surrounding computation when the value changes
    */
   read() {
-    if (ActiveTransition && (ActiveTransition._sources.has(this) || !this._cloned && this._stateFlags & UNINITIALIZED_BIT)) {
+    if (ActiveTransition && (ActiveTransition._sources.has(this) || !this._cloned && this._stateFlags & UNINITIALIZED_BIT | ERROR_BIT)) {
       const clone = ActiveTransition._sources.get(this) || cloneGraph(this);
       if (clone !== this)
         return clone.read();
@@ -751,7 +796,7 @@ var Computation = class extends Owner {
     let observerFlags = 0;
     if (this._state === STATE_CHECK) {
       for (let i = 0; i < this._sources.length; i++) {
-        const source = ActiveTransition && ActiveTransition._sources.get(this._sources[i]) || this._sources[i];
+        const source = getTransitionSource(this._sources[i]);
         source._updateIfNecessary();
         observerFlags |= source._stateFlags & ~UNINITIALIZED_BIT;
         if (this._state === STATE_DIRTY) {
@@ -799,6 +844,10 @@ function update(node) {
   newSourcesIndex = 0;
   newFlags = 0;
   try {
+    if (ActiveTransition && node._cloned && !node._updated) {
+      initialDispose(node._cloned);
+      node._updated = true;
+    }
     node.dispose(false);
     node.emptyDisposal();
     const result = compute(node, node._compute, node);
@@ -823,7 +872,7 @@ function update(node) {
       }
       let source;
       for (let i = newSourcesIndex; i < node._sources.length; i++) {
-        source = ActiveTransition && ActiveTransition._sources.get(node._sources[i]) || node._sources[i];
+        source = getTransitionSource(node._sources[i]);
         if (!source._observers)
           source._observers = [node];
         else
@@ -840,21 +889,6 @@ function update(node) {
     node._state = STATE_CLEAN;
   }
 }
-function removeSourceObservers(node, index) {
-  let source;
-  let swap;
-  for (let i = index; i < node._sources.length; i++) {
-    source = ActiveTransition && ActiveTransition._sources.get(node._sources[i]) || node._sources[i];
-    if (source._observers) {
-      if ((swap = source._observers.indexOf(node)) !== -1) {
-        source._observers[swap] = source._observers[source._observers.length - 1];
-        source._observers.pop();
-      }
-      if (!source._observers.length)
-        Unobserved.push(source);
-    }
-  }
-}
 function isEqual(a, b) {
   return a === b;
 }
@@ -1110,6 +1144,8 @@ var FirewallComputation = class extends Computation {
 function runTop(node) {
   const ancestors = [];
   for (let current = node; current !== null; current = current._parent) {
+    if (ActiveTransition && current._transition)
+      current = ActiveTransition._sources.get(current);
     if (current._state !== STATE_CLEAN) {
       ancestors.push(current);
     }
@@ -2252,7 +2288,7 @@ var CollectionQueue = class extends Queue {
       this._nodes.add(node);
       if (this._nodes.size === 1)
         this._disabled.write(true);
-    } else {
+    } else if (this._nodes.size > 0) {
       this._nodes.delete(node);
       if (this._nodes.size === 0)
         this._disabled.write(false);
@@ -2302,8 +2338,7 @@ function createSuspense(fn, fallback) {
 }
 function createErrorBoundary(fn, fallback) {
   return createCollectionBoundary(ERROR_BIT, fn, (queue) => {
-    let node = queue._nodes.values().next().value;
-    ActiveTransition && ActiveTransition._sources.has(node) && (node = ActiveTransition._sources.get(node));
+    let node = getTransitionSource(queue._nodes.values().next().value);
     return fallback(node._error, () => {
       incrementClock();
       for (let node2 of queue._nodes) {