@solidjs/signals 0.4.3 → 0.4.5

package/dist/dev.js

@@ -39,7 +39,7 @@ function incrementClock() {
   clock++;
 }
 var ActiveTransition = null;
-var unobserved = [];
+var Unobserved = [];
 var scheduled = false;
 function schedule() {
   if (scheduled)
@@ -49,12 +49,12 @@ function schedule() {
     queueMicrotask(flush);
 }
 function notifyUnobserved() {
-  for (let i = 0; i < unobserved.length; i++) {
-    const source = unobserved[i];
+  for (let i = 0; i < Unobserved.length; i++) {
+    const source = Unobserved[i];
     if (!source._observers || !source._observers.length)
-      unobserved[i]._unobserved?.();
+      Unobserved[i]._unobserved?.();
   }
-  unobserved = [];
+  Unobserved = [];
 }
 var pureQueue = [];
 var Queue = class {
@@ -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);
@@ -97,7 +97,7 @@ var Queue = class {
       this.run(EFFECT_USER);
     } finally {
       this._running = false;
-      unobserved.length && notifyUnobserved();
+      Unobserved.length && notifyUnobserved();
     }
   }
   addChild(child) {
@@ -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) {
@@ -255,29 +285,80 @@ function cloneGraph(node) {
     return node._transition._sources.get(node);
   }
   const clone = Object.create(Object.getPrototypeOf(node));
-  Object.assign(clone, node, { _disposal: null, _nextSibling: null, _cloned: node });
+  Object.assign(clone, node, {
+    _disposal: null,
+    _nextSibling: null,
+    _observers: null,
+    _sources: node._sources ? [...node._sources] : null,
+    _cloned: node
+  });
   ActiveTransition._sources.set(node, clone);
   node._transition = ActiveTransition;
+  if (node._sources) {
+    for (let i = 0; i < node._sources.length; i++)
+      node._sources[i]._observers.push(clone);
+  }
   if (node._observers) {
+    clone._observers = [];
     for (let i = 0, length = node._observers.length; i < length; i++) {
-      const o = node._observers[i];
-      node._observers.push(cloneGraph(o));
+      !node._observers[i]._cloned && clone._observers.push(cloneGraph(node._observers[i]));
     }
   }
   return clone;
 }
-function removeSourceObservers(node, index) {
+function replaceSourceObservers(node, transition2) {
   let source;
+  let transitionSource;
   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();
+  for (let i = 0; i < node._sources.length; i++) {
+    transitionSource = transition2._sources.get(node._sources[i]);
+    source = transitionSource || node._sources[i];
+    if (source._observers && (swap = source._observers.indexOf(node)) !== -1) {
+      source._observers[swap] = transitionSource ? node._cloned : source._observers[source._observers.length - 1];
+      !transitionSource && source._observers.pop();
+    }
+  }
+}
+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;
       }
-      if (!source._observers.length)
-        unobserved.push(source);
+      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);
     }
   }
 }
@@ -292,12 +373,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)
@@ -306,21 +383,22 @@ function finishTransition(transition2) {
     if (source === clone || source._transition !== transition2)
       continue;
     if (clone._sources)
-      removeSourceObservers(clone, 0);
+      replaceSourceObservers(clone, transition2);
     source.dispose(false);
     source.emptyDisposal();
     Object.assign(source, clone);
     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);
   for (const reset of transition2._optimistic) {
     delete reset._transition;
     reset();
   }
+  globalQueue.flush();
 }
 
 // src/core/owner.ts
@@ -527,8 +605,8 @@ var Computation = class extends Owner {
    * Automatically re-executes the surrounding computation when the value changes
    */
   read() {
-    if (ActiveTransition && ActiveTransition._sources.has(this)) {
-      const clone = ActiveTransition._sources.get(this);
+    if (ActiveTransition && (ActiveTransition._sources.has(this) || !this._cloned && this._stateFlags & UNINITIALIZED_BIT)) {
+      const clone = ActiveTransition._sources.get(this) || cloneGraph(this);
       if (clone !== this)
         return clone.read();
     }
@@ -548,8 +626,8 @@ var Computation = class extends Owner {
    * before continuing
    */
   wait() {
-    if (ActiveTransition && ActiveTransition._sources.has(this)) {
-      const clone = ActiveTransition._sources.get(this);
+    if (ActiveTransition && (ActiveTransition._sources.has(this) || !this._cloned && this._stateFlags & UNINITIALIZED_BIT)) {
+      const clone = ActiveTransition._sources.get(this) || cloneGraph(this);
       if (clone !== this)
         return clone.wait();
     }
@@ -572,7 +650,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.");
@@ -601,11 +680,6 @@ var Computation = class extends Owner {
    * Set the current node's state, and recursively mark all of this node's observers as STATE_CHECK
    */
   _notify(state, skipQueue) {
-    if (ActiveTransition && ActiveTransition._sources.has(this)) {
-      const clone = ActiveTransition._sources.get(this);
-      if (clone !== this)
-        return clone._notify(state, skipQueue);
-    }
     if (this._state >= state && !this._forceNotify)
       return;
     this._forceNotify = !!skipQueue;
@@ -645,6 +719,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);
   }
@@ -670,7 +749,7 @@ var Computation = class extends Owner {
       for (let i = 0; i < this._sources.length; i++) {
         const source = ActiveTransition && ActiveTransition._sources.get(this._sources[i]) || this._sources[i];
         source._updateIfNecessary();
-        observerFlags |= source._stateFlags;
+        observerFlags |= source._stateFlags & ~UNINITIALIZED_BIT;
         if (this._state === STATE_DIRTY) {
           break;
         }
@@ -740,7 +819,7 @@ function update(node) {
       }
       let source;
       for (let i = newSourcesIndex; i < node._sources.length; i++) {
-        source = node._sources[i];
+        source = ActiveTransition && ActiveTransition._sources.get(node._sources[i]) || node._sources[i];
         if (!source._observers)
           source._observers = [node];
         else
@@ -757,6 +836,21 @@ 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;
 }
@@ -860,7 +954,7 @@ function compute(owner, fn, observer) {
   currentMask = observer?._handlerMask ?? DEFAULT_FLAGS;
   notStale = true;
   try {
-    return fn(observer ? observer._value : void 0);
+    return fn.call(observer, observer ? observer._value : void 0);
   } finally {
     setOwner(prevOwner);
     currentObserver = prevObserver;
@@ -884,10 +978,12 @@ var Effect = class extends Computation {
     this._prevValue = initialValue;
     this._type = options?.render ? EFFECT_RENDER : EFFECT_USER;
     if (this._type === EFFECT_RENDER) {
-      this._compute = (p) => !ActiveTransition && clock > this._queue.created && !(this._stateFlags & ERROR_BIT) ? latest(() => compute2(p)) : compute2(p);
+      this._compute = function(p) {
+        return !this._cloned && 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");
   }
@@ -895,28 +991,26 @@ var Effect = class extends Computation {
     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, this._stateFlags);
       }
     }
     if (value === UNCHANGED)
       return this._value;
     this._value = value;
     this._modified = true;
+    this._error = void 0;
     return value;
   }
   _notify(state, skipQueue) {
-    if (ActiveTransition && ActiveTransition._sources.has(this)) {
-      return ActiveTransition._sources.get(this)._notify(state, skipQueue);
-    }
     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) {
-    if (ActiveTransition && ActiveTransition._sources.has(this)) {
-      if (this._state >= STATE_CHECK)
+    if (this._cloned) {
+      if (this._state >= STATE_DIRTY)
         return;
       if (mask & 3) {
         this._notify(STATE_DIRTY);
@@ -927,7 +1021,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 +1033,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 +1048,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
@@ -978,13 +1073,10 @@ var EagerComputation = class extends Computation {
       console.warn("Eager Computations created outside a reactive context will never be disposed");
   }
   _notify(state, skipQueue) {
-    if (ActiveTransition && ActiveTransition._sources.has(this)) {
-      return ActiveTransition._sources.get(this)._notify(state, skipQueue);
-    }
     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() {
@@ -999,13 +1091,10 @@ var FirewallComputation = class extends Computation {
       console.warn("Eager Computations created outside a reactive context will never be disposed");
   }
   _notify(state, skipQueue) {
-    if (ActiveTransition && ActiveTransition._sources.has(this)) {
-      return ActiveTransition._sources.get(this)._notify(state, skipQueue);
-    }
     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;
   }
@@ -1447,6 +1536,8 @@ function applyState(next, state, keyFn, all) {
 }
 function reconcile(value, key, all = false) {
   return (state) => {
+    if (state == null)
+      throw new Error("Cannot reconcile null or undefined state");
     const keyFn = typeof key === "string" ? (item) => item[key] : key;
     const eq = keyFn(state);
     if (eq !== void 0 && keyFn(value) !== keyFn(state))
@@ -1691,7 +1782,7 @@ function createMemo(compute2, value, options) {
         return resolvedValue;
       }
       resolvedValue = node.wait();
-      if (!node._sources?.length && node._nextSibling?._parent !== node) {
+      if (!node._sources?.length && node._nextSibling?._parent !== node && !(node._stateFlags & UNINITIALIZED_BIT)) {
         node.dispose();
         node = void 0;
       }
@@ -1752,9 +1843,13 @@ function createAsync(compute2, value, options) {
   );
   const read = node.wait.bind(node);
   read.refresh = () => {
-    node._state = STATE_DIRTY;
+    let n = node;
+    if (ActiveTransition && !node._cloned) {
+      n = cloneGraph(node);
+    }
+    n._state = STATE_DIRTY;
     refreshing = true;
-    node._updateIfNecessary();
+    n._updateIfNecessary();
   };
   return read;
 }
@@ -1835,7 +1930,7 @@ function createOptimistic(initial, compute2, key) {
       (s) => {
         const value = initial();
         if (!ActiveTransition)
-          s.value = value;
+          reconcile({ value }, key)(s);
       },
       { value: void 0 }
     );
@@ -1843,9 +1938,9 @@ function createOptimistic(initial, compute2, key) {
     [store, setStore] = createStore({ value: initial });
   const reset = () => setStore(
     (s) => reconcile(
-      typeof initial === "function" ? initial() : initial,
+      { value: typeof initial === "function" ? initial() : initial },
       key
-    )(s.value)
+    )(s)
   );
   let lastChange = void 0;
   function write(v) {
@@ -2104,6 +2199,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 +2219,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 +2239,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 +2255,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 +2296,19 @@ 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) {
+        if (ActiveTransition && !node2._cloned)
+          node2 = cloneGraph(node2);
+        node2._state = STATE_DIRTY;
+        node2._queue?.enqueue(node2._type, node2._run.bind(node2));
       }
-    })
-  );
+    });
+  });
 }
 function flatten(children, options) {
   if (typeof children === "function" && !children.length) {