@solidjs/signals 0.9.9 → 0.9.11

package/dist/dev.js

@@ -158,12 +158,15 @@ function getOrCreateLane(signal) {
   if (lane) {
     return findLane(lane);
   }
+  const parentSource = signal._parentSource;
+  const parentLane = parentSource?._optimisticLane ? findLane(parentSource._optimisticLane) : null;
   lane = {
     _source: signal,
     _pendingAsync: new Set(),
     _effectQueues: [[], []],
     _mergedInto: null,
-    _transition: activeTransition
+    _transition: activeTransition,
+    _parentLane: parentLane
   };
   signalLanes.set(signal, lane);
   activeLanes.add(lane);
@@ -209,7 +212,10 @@ function assignOrMergeLane(el, sourceLane) {
     const existingRoot = findLane(existing);
     if (activeLanes.has(existingRoot)) {
       if (existingRoot !== sourceRoot && !hasActiveOverride(el)) {
-        mergeLanes(sourceRoot, existingRoot);
+        if (sourceRoot._parentLane && findLane(sourceRoot._parentLane) === existingRoot) {
+          el._optimisticLane = sourceLane;
+        } else if (existingRoot._parentLane && findLane(existingRoot._parentLane) === sourceRoot);
+        else mergeLanes(sourceRoot, existingRoot);
       }
       return;
     }
@@ -531,7 +537,8 @@ function transitionComplete(transition) {
   if (transition._actions.length) return false;
   let done = true;
   for (let i = 0; i < transition._asyncNodes.length; i++) {
-    if (transition._asyncNodes[i]._statusFlags & STATUS_PENDING) {
+    const node = transition._asyncNodes[i];
+    if (node._statusFlags & STATUS_PENDING && node._error?._source === node) {
       done = false;
       break;
     }
@@ -645,13 +652,17 @@ function recompute(el, create = false) {
     value = handleAsync(el, el._fn(value));
     clearStatus(el);
     const resolvedLane = resolveLane(el);
-    if (resolvedLane) resolvedLane._pendingAsync.delete(el);
+    if (resolvedLane) {
+      resolvedLane._pendingAsync.delete(el);
+      updatePendingSignal(resolvedLane._source);
+    }
   } catch (e) {
     if (e instanceof NotReadyError && currentOptimisticLane) {
       const lane = findLane(currentOptimisticLane);
       if (lane._source !== el) {
         lane._pendingAsync.add(el);
         el._optimisticLane = lane;
+        updatePendingSignal(lane._source);
       }
     }
     notifyStatus(
@@ -1106,12 +1117,24 @@ function optimisticComputed(fn, initialValue, options) {
 function getPendingSignal(el) {
   if (!el._pendingSignal) {
     el._pendingSignal = optimisticSignal(false, { pureWrite: true });
+    if (el._parentSource) {
+      el._pendingSignal._parentSource = el;
+    }
     if (computePendingState(el)) setSignal(el._pendingSignal, true);
   }
   return el._pendingSignal;
 }
 function computePendingState(el) {
   const comp = el;
+  if (el._optimistic && el._pendingValue !== NOT_PENDING) {
+    if (comp._statusFlags & STATUS_PENDING && !(comp._statusFlags & STATUS_UNINITIALIZED))
+      return true;
+    if (el._parentSource) {
+      const lane = el._optimisticLane ? findLane(el._optimisticLane) : null;
+      return !!(lane && lane._pendingAsync.size > 0);
+    }
+    return true;
+  }
   if (el._pendingValue !== NOT_PENDING && !(comp._statusFlags & STATUS_UNINITIALIZED)) return true;
   return !!(comp._statusFlags & STATUS_PENDING && !(comp._statusFlags & STATUS_UNINITIALIZED));
 }
@@ -1119,10 +1142,14 @@ function getPendingValueComputed(el) {
   if (!el._pendingValueComputed) {
     const prevPending = pendingReadActive;
     pendingReadActive = false;
+    const prevCheck = pendingCheckActive;
+    pendingCheckActive = false;
     const prevContext = context;
     context = null;
     el._pendingValueComputed = optimisticComputed(() => read(el));
+    el._pendingValueComputed._parentSource = el;
     context = prevContext;
+    pendingCheckActive = prevCheck;
     pendingReadActive = prevPending;
   }
   return el._pendingValueComputed;
@@ -1158,6 +1185,22 @@ function untrack(fn) {
   }
 }
 function read(el) {
+  if (pendingReadActive) {
+    const pendingComputed = getPendingValueComputed(el);
+    const prevPending = pendingReadActive;
+    pendingReadActive = false;
+    const value = read(pendingComputed);
+    pendingReadActive = prevPending;
+    if (pendingComputed._statusFlags & STATUS_PENDING) return el._value;
+    if (stale && currentOptimisticLane && pendingComputed._optimisticLane) {
+      const pcLane = findLane(pendingComputed._optimisticLane);
+      const curLane = findLane(currentOptimisticLane);
+      if (pcLane !== curLane && pcLane._pendingAsync.size > 0) {
+        return el._value;
+      }
+    }
+    return value;
+  }
   if (pendingCheckActive) {
     const target = el._firewall || el;
     const pendingSig = getPendingSignal(target);
@@ -1169,15 +1212,6 @@ function read(el) {
     pendingCheckActive = prevCheck;
     return el._value;
   }
-  if (pendingReadActive) {
-    const pendingComputed = getPendingValueComputed(el);
-    const prevPending = pendingReadActive;
-    pendingReadActive = false;
-    const value = read(pendingComputed);
-    pendingReadActive = prevPending;
-    if (pendingComputed._statusFlags & STATUS_PENDING) return el._value;
-    return value;
-  }
   let c = context;
   if (c?._root) c = c._parentComputed;
   if (refreshing && el._fn) recompute(el);
@@ -1709,6 +1743,7 @@ function applyState(next, state, keyFn, all) {
       if (
         !previousValue ||
         !isWrappable(previousValue) ||
+        !isWrappable(nextValue) ||
         (keyFn(previousValue) != null && keyFn(previousValue) !== keyFn(nextValue))
       ) {
         tracked && setSignal(tracked, void 0);