@solidjs/signals 0.7.0 → 0.7.2

package/dist/dev.js

@@ -200,7 +200,7 @@ var Transition = class _Transition {
     }
   }
   flush() {
-    if (this._running)
+    if (this._running || this._done)
       return;
     this._running = true;
     let currentTransition = ActiveTransition;
@@ -239,6 +239,9 @@ var Transition = class _Transition {
     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);
+    queue._queues[0].length = 0;
+    queue._queues[1].length = 0;
+    queue._pureQueue.length = 0;
     for (let i = 0; i < queue._children.length; i++) {
       const og = this._children.find((c) => c._cloned === queue._children[i]._cloned);
       if (og)
@@ -271,6 +274,7 @@ var Transition = class _Transition {
         (async function() {
           let temp, value;
           while (!(temp = result.next(value)).done) {
+            transition2 = ActiveTransition;
             if (temp.value instanceof Promise) {
               transition2._promises.add(temp.value);
               try {
@@ -316,7 +320,9 @@ function transition(fn) {
   let t = new Transition();
   queueMicrotask(() => t.runTransition(() => fn((fn2) => t.runTransition(fn2))));
 }
-function cloneGraph(node, optimistic) {
+function cloneGraph(node) {
+  if (node._optimistic)
+    return node;
   if (node._transition) {
     if (node._transition !== ActiveTransition) {
       mergeTransitions(node._transition, ActiveTransition);
@@ -330,20 +336,19 @@ function cloneGraph(node, optimistic) {
     _nextSibling: null,
     _observers: null,
     _sources: node._sources ? [...node._sources] : null,
-    _cloned: node,
-    _optimistic: !!optimistic
+    _cloned: node
   });
   delete clone._prevValue;
   ActiveTransition._sources.set(node, clone);
   node._transition = ActiveTransition;
-  if (!optimistic && node._sources) {
+  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++) {
-      !node._observers[i]._cloned && clone._observers.push(cloneGraph(node._observers[i], optimistic));
+      !node._observers[i]._cloned && clone._observers.push(cloneGraph(node._observers[i]));
     }
   }
   return clone;
@@ -455,12 +460,6 @@ function finishTransition(transition2) {
     }
     if (clone._sources)
       replaceSourceObservers(clone, transition2);
-    if (clone._optimistic) {
-      clone.dispose();
-      clone.emptyDisposal();
-      delete source._transition;
-      continue;
-    }
     if (clone._updated || clone._state === STATE_DISPOSED) {
       source.dispose(clone._state === STATE_DISPOSED);
       source.emptyDisposal();
@@ -750,7 +749,7 @@ var Computation = class extends Owner {
     const changedFlagsMask = this._stateFlags ^ flags, changedFlags = changedFlagsMask & flags;
     this._stateFlags = flags;
     this._time = clock + 1;
-    if (this._observers) {
+    if (this._observers && !(this._optimistic && ActiveTransition)) {
       for (let i = 0; i < this._observers.length; i++) {
         if (valueChanged) {
           this._observers[i]._notify(STATE_DIRTY);
@@ -769,7 +768,7 @@ var Computation = class extends Owner {
       return;
     this._forceNotify = !!skipQueue;
     this._state = state;
-    if (this._observers) {
+    if (this._observers && !(this._optimistic && ActiveTransition)) {
       for (let i = 0; i < this._observers.length; i++) {
         this._observers[i]._notify(STATE_CHECK, skipQueue);
       }
@@ -784,7 +783,7 @@ var Computation = class extends Owner {
   _notifyFlags(mask, newFlags2) {
     if (this._state >= STATE_DIRTY)
       return;
-    if (mask & this._handlerMask) {
+    if (mask & this._handlerMask || this._optimistic && ActiveTransition) {
       this._notify(STATE_DIRTY);
       return;
     }
@@ -1167,7 +1166,10 @@ var FirewallComputation = class extends Computation {
     this._forceNotify = !!skipQueue;
   }
   _run() {
+    const prevFlags = this._stateFlags;
     this._state !== STATE_CLEAN && runTop(this);
+    if (ActiveTransition && this._optimistic && this._stateFlags !== prevFlags)
+      getQueue(this).notify(this, LOADING_BIT | ERROR_BIT, this._stateFlags);
   }
 };
 function runTop(node) {
@@ -1189,7 +1191,10 @@ function runTop(node) {
 function createSignal(first, second, third) {
   if (typeof first === "function") {
     const node2 = new Computation(second, first, third);
-    return [node2.read.bind(node2), node2.write.bind(node2)];
+    return [node2.read.bind(node2), (v) => {
+      node2._updateIfNecessary();
+      return node2.write(v);
+    }];
   }
   const o = getOwner();
   const needsId = o?.id != null;
@@ -1359,14 +1364,24 @@ function resolve(fn) {
   });
 }
 function createOptimistic(first, second, third) {
-  const node = typeof first === "function" ? new Computation(second, first, third) : new Computation(first, null, second);
+  const node = typeof first === "function" ? new Computation(second, (prev) => {
+    const res = first(prev);
+    if (reset._transition)
+      return prev;
+    return res;
+  }, third) : new Computation(first, null, second);
+  node._optimistic = true;
   const reset = () => node.write(first);
   function write(v) {
     if (!ActiveTransition)
       throw new Error("createOptimistic can only be updated inside a transition");
     ActiveTransition.addOptimistic(reset);
-    cloneGraph(node, true);
-    queueMicrotask(() => reset._transition && node.write(v));
+    queueMicrotask(() => {
+      if (reset._transition) {
+        node._updateIfNecessary();
+        node.write(v);
+      }
+    });
   }
   return [node.read.bind(node), write];
 }
@@ -1839,8 +1854,14 @@ function deep(store) {
 // src/store/optimistic.ts
 function createOptimisticStore(first, second, options) {
   const derived = typeof first === "function";
-  const { store, node } = derived ? createProjectionInternal(first, second, options) : createProjectionInternal(() => {
+  const { store, node } = derived ? createProjectionInternal((draft) => {
+    const res = first(draft);
+    if (reset._transition)
+      return draft;
+    return res;
+  }, second, options) : createProjectionInternal(() => {
   }, first);
+  node._optimistic = true;
   const reset = () => storeSetter(
     store,
     reconcile(
@@ -1853,7 +1874,6 @@ function createOptimisticStore(first, second, options) {
     if (!ActiveTransition)
       throw new Error("createOptimisticStore can only be updated inside a transition");
     ActiveTransition.addOptimistic(reset);
-    cloneGraph(node, true);
     queueMicrotask(() => reset._transition && storeSetter(store, v));
   };
   return [store, write];