@solidjs/signals 0.7.1 → 0.7.3

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,11 @@ 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) {
+    ActiveTransition.addOptimistic(node._optimistic);
+    return node;
+  }
   if (node._transition) {
     if (node._transition !== ActiveTransition) {
       mergeTransitions(node._transition, ActiveTransition);
@@ -330,20 +338,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 +462,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();
@@ -659,7 +660,7 @@ var Computation = class extends Owner {
   _forceNotify = false;
   _transition;
   _cloned;
-  _optimistic = false;
+  _optimistic;
   constructor(initialValue, compute2, options) {
     super(options?.id, compute2 === null);
     this._compute = compute2;
@@ -750,7 +751,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 +770,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 +785,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;
     }
@@ -964,7 +965,7 @@ function isPending(fn, loadingValue) {
     return pendingCheck(fn, loadingValue);
   const c = new Computation(void 0, () => pendingCheck(fn, loadingValue));
   c._handlerMask |= LOADING_BIT;
-  return c.read();
+  return c.wait();
 }
 function latest(fn, fallback) {
   const argLength = arguments.length;
@@ -1167,7 +1168,13 @@ 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 || this._stateFlags !== this._optimistic.flags)) {
+      getQueue(this).notify(this, LOADING_BIT | ERROR_BIT, this._stateFlags);
+      this._optimistic.flags = this._stateFlags;
+      this._stateFlags = prevFlags;
+    }
   }
 };
 function runTop(node) {
@@ -1362,15 +1369,19 @@ function resolve(fn) {
   });
 }
 function createOptimistic(first, second, third) {
-  const node = typeof first === "function" ? new Computation(second, first, third) : new Computation(first, null, second);
-  const reset = () => node.write(first);
+  const node = typeof first === "function" ? new Computation(second, (prev) => {
+    const res = first(prev);
+    if (node._optimistic._transition)
+      return prev;
+    return res;
+  }, third) : new Computation(first, null, second);
+  node._optimistic = () => 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);
+    ActiveTransition.addOptimistic(node._optimistic);
     queueMicrotask(() => {
-      if (reset._transition) {
+      if (node._optimistic._transition) {
         node._updateIfNecessary();
         node.write(v);
       }
@@ -1847,7 +1858,12 @@ 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);
   const reset = () => storeSetter(
     store,
@@ -1861,9 +1877,9 @@ 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));
   };
+  node._optimistic = reset;
   return [store, write];
 }