@solidjs/signals 0.4.4 → 0.4.6

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 {
@@ -97,7 +97,7 @@ var Queue = class {
       this.run(EFFECT_USER);
     } finally {
       this._running = false;
-      unobserved.length && notifyUnobserved();
+      Unobserved.length && notifyUnobserved();
     }
   }
   addChild(child) {
@@ -285,29 +285,37 @@ 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();
-      }
-      if (!source._observers.length)
-        unobserved.push(source);
+  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();
     }
   }
 }
@@ -375,7 +383,7 @@ 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);
@@ -386,11 +394,11 @@ function finishTransition(transition2) {
   globalQueue._queues[1].push.apply(globalQueue._queues[1], transition2._queues[1]);
   resolveQueues(transition2._children);
   transition2._done = true;
-  globalQueue.flush();
   for (const reset of transition2._optimistic) {
     delete reset._transition;
     reset();
   }
+  globalQueue.flush();
 }
 
 // src/core/owner.ts
@@ -597,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();
     }
@@ -618,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();
     }
@@ -672,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;
@@ -746,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;
         }
@@ -816,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
@@ -833,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;
 }
@@ -936,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;
@@ -960,7 +978,9 @@ 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 ? this._queue.enqueue(this._type, this._run.bind(this)) : this._run(this._type));
@@ -971,19 +991,17 @@ 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, 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)
@@ -991,8 +1009,8 @@ var Effect = class extends Computation {
     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);
@@ -1026,6 +1044,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);
     super._disposeNode();
   }
   _run(type) {
@@ -1055,9 +1074,6 @@ 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))
@@ -1076,9 +1092,6 @@ 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))
@@ -1524,6 +1537,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))
@@ -1768,7 +1783,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;
       }
@@ -1829,9 +1844,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;
 }
@@ -1912,7 +1931,7 @@ function createOptimistic(initial, compute2, key) {
       (s) => {
         const value = initial();
         if (!ActiveTransition)
-          s.value = value;
+          reconcile({ value }, key)(s);
       },
       { value: void 0 }
     );
@@ -1920,9 +1939,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) {
@@ -2284,6 +2303,8 @@ function createErrorBoundary(fn, fallback) {
     return fallback(node._error, () => {
       incrementClock();
       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));
       }