@solidjs/signals 0.9.0 → 0.9.2

package/dist/dev.js

@@ -132,6 +132,7 @@ function adjustHeight(el, heap) {
   }
 }
 const transitions = new Set();
+let optimisticRun = false;
 const dirtyQueue = { _heap: new Array(2e3).fill(undefined), _marked: false, _min: 0, _max: 0 };
 const zombieQueue = { _heap: new Array(2e3).fill(undefined), _marked: false, _min: 0, _max: 0 };
 let clock = 0;
@@ -203,6 +204,7 @@ class Queue {
 class GlobalQueue extends Queue {
   _running = false;
   _pendingNodes = [];
+  _optimisticNodes = [];
   static _update;
   static _dispose;
   flush() {
@@ -212,31 +214,24 @@ class GlobalQueue extends Queue {
       runHeap(dirtyQueue, GlobalQueue._update);
       if (activeTransition) {
         if (!transitionComplete(activeTransition)) {
+          let t = activeTransition;
           runHeap(zombieQueue, GlobalQueue._update);
           this._pendingNodes = [];
           this.stashQueues(activeTransition.queueStash);
           clock++;
           scheduled = false;
-          runPending(activeTransition.pendingNodes, true);
+          runTransitionPending(activeTransition.pendingNodes, true);
           activeTransition = null;
+          runOptimistic(t);
           return;
         }
         this._pendingNodes.push(...activeTransition.pendingNodes);
         this.restoreQueues(activeTransition.queueStash);
         transitions.delete(activeTransition);
         activeTransition = null;
-        if (runPending(this._pendingNodes, false)) runHeap(dirtyQueue, GlobalQueue._update);
+        runTransitionPending(this._pendingNodes, false);
       } else if (transitions.size) runHeap(zombieQueue, GlobalQueue._update);
-      for (let i = 0; i < this._pendingNodes.length; i++) {
-        const n = this._pendingNodes[i];
-        if (n._pendingValue !== NOT_PENDING) {
-          n._value = n._pendingValue;
-          n._pendingValue = NOT_PENDING;
-          if (n._type) n._modified = true;
-        }
-        if (n._fn) GlobalQueue._dispose(n, false, true);
-      }
-      this._pendingNodes.length = 0;
+      runOptimistic();
       clock++;
       scheduled = false;
       this.run(EFFECT_RENDER);
@@ -264,7 +259,9 @@ class GlobalQueue extends Queue {
         time: clock,
         pendingNodes: [],
         asyncNodes: [],
-        queueStash: { _queues: [[], []], _children: [] }
+        optimisticNodes: [],
+        queueStash: { _queues: [[], []], _children: [] },
+        done: false
       };
     }
     transitions.add(activeTransition);
@@ -274,26 +271,66 @@ class GlobalQueue extends Queue {
       n._transition = activeTransition;
       activeTransition.pendingNodes.push(n);
     }
+    for (let i = 0; i < this._optimisticNodes.length; i++) {
+      const n = this._optimisticNodes[i];
+      n._transition = activeTransition;
+      activeTransition.optimisticNodes.push(n);
+    }
     this._pendingNodes = activeTransition.pendingNodes;
+    this._optimisticNodes = activeTransition.optimisticNodes;
+  }
+}
+function notifySubs(node) {
+  for (let s = node._subs; s !== null; s = s._nextSub) {
+    const queue = s._sub._flags & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue;
+    if (queue._min > s._sub._height) queue._min = s._sub._height;
+    insertIntoHeap(s._sub, queue);
   }
 }
-function runPending(pendingNodes, value) {
-  let needsReset = false;
+function runOptimistic(activeTransition = null) {
+  let resolvePending = !activeTransition;
+  const optimisticNodes = globalQueue._optimisticNodes;
+  optimisticRun = true;
+  for (let i = 0; i < optimisticNodes.length; i++) {
+    const n = optimisticNodes[i];
+    if (
+      !activeTransition &&
+      (!n._transition || n._transition.done) &&
+      n._pendingValue !== NOT_PENDING
+    ) {
+      n._value = n._pendingValue;
+      n._pendingValue = NOT_PENDING;
+    }
+    n._transition = activeTransition;
+    notifySubs(n);
+  }
+  globalQueue._optimisticNodes = [];
+  if (dirtyQueue._max >= dirtyQueue._min) {
+    resolvePending = true;
+    runHeap(dirtyQueue, GlobalQueue._update);
+  }
+  optimisticRun = false;
+  resolvePending && runPending(globalQueue._pendingNodes);
+}
+function runPending(pendingNodes) {
+  for (let i = 0; i < pendingNodes.length; i++) {
+    const n = pendingNodes[i];
+    if (n._pendingValue !== NOT_PENDING) {
+      n._value = n._pendingValue;
+      n._pendingValue = NOT_PENDING;
+      if (n._type) n._modified = true;
+    }
+    if (n._fn) GlobalQueue._dispose(n, false, true);
+  }
+  pendingNodes.length = 0;
+}
+function runTransitionPending(pendingNodes, value) {
   const p = pendingNodes.slice();
   for (let i = 0; i < p.length; i++) {
     const n = p[i];
     n._transition = activeTransition;
-    if (n._pendingCheck) {
-      n._pendingCheck._set(value);
-      needsReset = true;
-    }
-    if (n._pendingSignal && n._pendingSignal._pendingValue !== NOT_PENDING) {
-      n._pendingSignal._set(n._pendingSignal._pendingValue);
-      n._pendingSignal._pendingValue = NOT_PENDING;
-      needsReset = true;
-    }
+    if (n._pendingCheck) n._pendingCheck._set(value);
   }
-  return needsReset;
 }
 const globalQueue = new GlobalQueue();
 function flush() {
@@ -307,6 +344,7 @@ function runQueue(queue, type) {
   for (let i = 0; i < queue.length; i++) queue[i](type);
 }
 function transitionComplete(transition) {
+  if (transition.done) return true;
   let done = true;
   for (let i = 0; i < transition.asyncNodes.length; i++) {
     if (transition.asyncNodes[i]._statusFlags & STATUS_PENDING) {
@@ -314,6 +352,7 @@ function transitionComplete(transition) {
       break;
     }
   }
+  done && (transition.done = true);
   return done;
 }
 function runInTransition(el, recompute) {
@@ -330,13 +369,6 @@ let pendingValueCheck = false;
 let pendingCheck = null;
 let refreshing = false;
 let context = null;
-function notifySubs(node) {
-  for (let s = node._subs; s !== null; s = s._nextSub) {
-    const queue = s._sub._flags & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue;
-    if (queue._min > s._sub._height) queue._min = s._sub._height;
-    insertIntoHeap(s._sub, queue);
-  }
-}
 function recompute(el, create = false) {
   const honoraryOptimistic = el._type && el._transition != activeTransition;
   if (!create) {
@@ -357,7 +389,10 @@ function recompute(el, create = false) {
   el._depsTail = null;
   el._flags = REACTIVE_RECOMPUTING_DEPS;
   el._time = clock;
-  let value = el._pendingValue === NOT_PENDING ? el._value : el._pendingValue;
+  let value =
+    el._pendingValue === NOT_PENDING || (el._optimistic && el._transition)
+      ? el._value
+      : el._pendingValue;
   let oldHeight = el._height;
   let prevStatusFlags = el._statusFlags;
   let prevError = el._error;
@@ -402,21 +437,19 @@ function recompute(el, create = false) {
     if (valueChanged) {
       if (create || el._optimistic || honoraryOptimistic) el._value = value;
       else el._pendingValue = value;
-      if (el._pendingSignal) el._pendingSignal._pendingValue = value;
-    }
-    for (let s = el._subs; s !== null; s = s._nextSub) {
-      const queue = s._sub._flags & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue;
-      if (s._sub._height < el._height && queue._min > s._sub._height) queue._min = s._sub._height;
-      insertIntoHeap(s._sub, queue);
+      if (el._pendingSignal) setSignal(el._pendingSignal, value);
     }
+    (!el._optimistic || optimisticRun) && notifySubs(el);
   } else if (el._height != oldHeight) {
     for (let s = el._subs; s !== null; s = s._nextSub) {
       insertIntoHeapHeight(s._sub, s._sub._flags & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
     }
   }
-  if ((!create || el._statusFlags & STATUS_PENDING) && !el._optimistic && !el._transition)
+  el._optimistic && !optimisticRun && globalQueue._optimisticNodes.push(el);
+  (!create || el._statusFlags & STATUS_PENDING) &&
+    !el._transition &&
     globalQueue._pendingNodes.push(el);
-  if (el._transition && honoraryOptimistic) runInTransition(el, recompute);
+  el._transition && honoraryOptimistic && runInTransition(el, recompute);
 }
 function handleAsync(el, result, setter) {
   const isObject = typeof result === "object" && result !== null;
@@ -667,7 +700,7 @@ function computed(fn, initialValue, options) {
     }
   }
   if (parent) self._height = parent._height + 1;
-  recompute(self, true);
+  !options?.lazy && recompute(self, true);
   return self;
 }
 function signal(v, options, firewall = null) {
@@ -737,7 +770,6 @@ function read(el) {
     if (!el._pendingSignal) {
       el._pendingSignal = signal(el._value);
       el._pendingSignal._optimistic = true;
-      el._pendingSignal._set = v => setSignal(el._pendingSignal, v);
     }
     pendingValueCheck = false;
     try {
@@ -763,7 +795,9 @@ function read(el) {
   return !c ||
     el._optimistic ||
     el._pendingValue === NOT_PENDING ||
-    (stale && !pendingCheck && el._transition && activeTransition !== el._transition)
+    (stale &&
+      !pendingCheck &&
+      (c._optimistic || (el._transition && activeTransition !== el._transition)))
     ? el._value
     : el._pendingValue;
 }
@@ -771,7 +805,11 @@ function setSignal(el, v) {
   if (!el._pureWrite && context && el._firewall !== context)
     console.warn("A Signal was written to in an owned scope.");
   if (typeof v === "function") {
-    v = v(el._pendingValue === NOT_PENDING ? el._value : el._pendingValue);
+    v = v(
+      el._pendingValue === NOT_PENDING || (el._optimistic && el._transition)
+        ? el._value
+        : el._pendingValue
+    );
   }
   const valueChanged =
     !el._equals ||
@@ -786,11 +824,11 @@ function setSignal(el, v) {
       if (el._pendingValue === NOT_PENDING) globalQueue._pendingNodes.push(el);
       el._pendingValue = v;
     }
-    if (el._pendingSignal) el._pendingSignal._pendingValue = v;
+    if (el._pendingSignal) setSignal(el._pendingSignal, v);
   }
   setStatusFlags(el, STATUS_NONE);
   el._time = clock;
-  notifySubs(el);
+  el._optimistic && !optimisticRun ? globalQueue._optimisticNodes.push(el) : notifySubs(el);
   schedule();
   return v;
 }
@@ -1060,7 +1098,30 @@ function resolve(fn) {
   });
 }
 function createOptimistic(first, second, third) {
-  return {};
+  if (typeof first === "function") {
+    const node = computed(
+      prev => {
+        let n = node || getOwner();
+        n._pendingValue = first(prev);
+        return prev;
+      },
+      second,
+      third
+    );
+    node._optimistic = true;
+    return [read.bind(null, node), setSignal.bind(null, node)];
+  }
+  const o = getOwner();
+  const needsId = o?.id != null;
+  const node = signal(first, needsId ? { id: getNextChildId(o), ...second } : second);
+  node._optimistic = true;
+  return [
+    read.bind(null, node),
+    v => {
+      node._pendingValue = first;
+      return setSignal(node, v);
+    }
+  ];
 }
 function onSettled(callback) {
   let cleanup;