@solidjs/signals 0.10.4 → 0.10.6

package/dist/dev.js

@@ -33,6 +33,7 @@ const REACTIVE_IN_HEAP_HEIGHT = 1 << 4;
 const REACTIVE_ZOMBIE = 1 << 5;
 const REACTIVE_DISPOSED = 1 << 6;
 const REACTIVE_OPTIMISTIC_DIRTY = 1 << 7;
+const REACTIVE_SNAPSHOT_STALE = 1 << 8;
 const STATUS_PENDING = 1 << 0;
 const STATUS_ERROR = 1 << 1;
 const STATUS_UNINITIALIZED = 1 << 2;
@@ -40,6 +41,8 @@ const EFFECT_RENDER = 1;
 const EFFECT_USER = 2;
 const EFFECT_TRACKED = 3;
 const NOT_PENDING = {};
+const NO_SNAPSHOT = {};
+const STORE_SNAPSHOT_PROPS = "sp";
 const SUPPORTS_PROXY = typeof Proxy === "function";
 const defaultContext = {};
 const $REFRESH = Symbol("refresh");
@@ -350,7 +353,12 @@ class GlobalQueue extends Queue {
 }
 function insertSubs(node, optimistic = false) {
   const sourceLane = node._optimisticLane || currentOptimisticLane;
+  const hasSnapshot = node._snapshotValue !== undefined;
   for (let s = node._subs; s !== null; s = s._nextSub) {
+    if (hasSnapshot && s._sub._inSnapshotScope) {
+      s._sub._flags |= REACTIVE_SNAPSHOT_STALE;
+      continue;
+    }
     if (optimistic && sourceLane) {
       s._sub._flags |= REACTIVE_OPTIMISTIC_DIRTY;
       assignOrMergeLane(s._sub, sourceLane);
@@ -729,7 +737,7 @@ function unlinkSubs(link) {
     dep._subs = nextSub;
     if (nextSub === null) {
       dep._unobserved?.();
-      dep._fn && !dep._preventAutoDisposal && unobserved(dep);
+      dep._fn && !dep._preventAutoDisposal && !(dep._flags & REACTIVE_ZOMBIE) && unobserved(dep);
     }
   }
   return nextDep;
@@ -874,6 +882,9 @@ function onCleanup(fn) {
   else context._disposal = [context._disposal, fn];
   return fn;
 }
+function isDisposed(node) {
+  return !!(node._flags & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE));
+}
 function createOwner(options) {
   const parent = context;
   const transparent = options?.transparent ?? false;
@@ -1020,6 +1031,58 @@ let foundPending = false;
 let pendingReadActive = false;
 let context = null;
 let currentOptimisticLane = null;
+let snapshotCaptureActive = false;
+let snapshotSources = null;
+function ownerInSnapshotScope(owner) {
+  while (owner) {
+    if (owner._snapshotScope) return true;
+    owner = owner._parent;
+  }
+  return false;
+}
+function setSnapshotCapture(active) {
+  snapshotCaptureActive = active;
+  if (active && !snapshotSources) snapshotSources = new Set();
+}
+function markSnapshotScope(owner) {
+  owner._snapshotScope = true;
+}
+function releaseSnapshotScope(owner) {
+  owner._snapshotScope = false;
+  releaseSubtree(owner);
+  schedule();
+}
+function releaseSubtree(owner) {
+  let child = owner._firstChild;
+  while (child) {
+    if (child._snapshotScope) {
+      child = child._nextSibling;
+      continue;
+    }
+    if (child._fn) {
+      const comp = child;
+      comp._inSnapshotScope = false;
+      if (comp._flags & REACTIVE_SNAPSHOT_STALE) {
+        comp._flags &= ~REACTIVE_SNAPSHOT_STALE;
+        comp._flags |= REACTIVE_DIRTY;
+        if (dirtyQueue._min > comp._height) dirtyQueue._min = comp._height;
+        insertIntoHeap(comp, dirtyQueue);
+      }
+    }
+    releaseSubtree(child);
+    child = child._nextSibling;
+  }
+}
+function clearSnapshots() {
+  if (snapshotSources) {
+    for (const source of snapshotSources) {
+      delete source._snapshotValue;
+      delete source[STORE_SNAPSHOT_PROPS];
+    }
+    snapshotSources = null;
+  }
+  snapshotCaptureActive = false;
+}
 function recompute(el, create = false) {
   const isEffect = el._type;
   if (!create) {
@@ -1079,7 +1142,7 @@ function recompute(el, create = false) {
     );
   } finally {
     tracking = prevTracking;
-    el._flags = REACTIVE_NONE;
+    el._flags = REACTIVE_NONE | (create ? el._flags & REACTIVE_SNAPSHOT_STALE : 0);
     context = oldcontext;
   }
   if (!el._error) {
@@ -1145,7 +1208,7 @@ function updateIfNecessary(el) {
   if (el._flags & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY) || (el._error && el._time < clock)) {
     recompute(el);
   }
-  el._flags = REACTIVE_NONE;
+  el._flags = REACTIVE_NONE | (el._flags & REACTIVE_SNAPSHOT_STALE);
 }
 function computed(fn, initialValue, options) {
   const transparent = options?.transparent ?? false;
@@ -1199,7 +1262,14 @@ function computed(fn, initialValue, options) {
     }
   }
   if (parent) self._height = parent._height + 1;
+  if (snapshotCaptureActive && ownerInSnapshotScope(context)) self._inSnapshotScope = true;
   !options?.lazy && recompute(self, true);
+  if (snapshotCaptureActive && !options?.lazy) {
+    if (!(self._statusFlags & STATUS_PENDING)) {
+      self._snapshotValue = self._value === undefined ? NO_SNAPSHOT : self._value;
+      snapshotSources.add(self);
+    }
+  }
   return self;
 }
 function signal(v, options, firewall = null) {
@@ -1217,6 +1287,10 @@ function signal(v, options, firewall = null) {
   };
   s._name = options?.name ?? "signal";
   firewall && (firewall._child = s);
+  if (snapshotCaptureActive) {
+    s._snapshotValue = v === undefined ? NO_SNAPSHOT : v;
+    snapshotSources.add(s);
+  }
   return s;
 }
 function optimisticSignal(v, options) {
@@ -1246,8 +1320,15 @@ function read(el) {
     const pendingComputed = getPendingValueComputed(el);
     const prevPending = pendingReadActive;
     pendingReadActive = false;
-    const value = read(pendingComputed);
-    pendingReadActive = prevPending;
+    let value;
+    try {
+      value = read(pendingComputed);
+    } catch (e) {
+      if (!context && e instanceof NotReadyError) return el._value;
+      throw e;
+    } finally {
+      pendingReadActive = prevPending;
+    }
     if (pendingComputed._statusFlags & STATUS_PENDING) return el._value;
     if (stale && currentOptimisticLane && pendingComputed._optimisticLane) {
       const pcLane = findLane(pendingComputed._optimisticLane);
@@ -1290,20 +1371,23 @@ function read(el) {
     }
   }
   const asyncCompute = el._firewall || el;
-  if (
-    c &&
-    asyncCompute._statusFlags & STATUS_PENDING &&
-    !(stale && asyncCompute._transition && activeTransition !== asyncCompute._transition)
-  ) {
-    if (currentOptimisticLane) {
-      const pendingLane = asyncCompute._optimisticLane;
-      const lane = findLane(currentOptimisticLane);
-      if (pendingLane && findLane(pendingLane) === lane && !hasActiveOverride(asyncCompute)) {
+  if (asyncCompute._statusFlags & STATUS_PENDING) {
+    if (
+      c &&
+      !(stale && asyncCompute._transition && activeTransition !== asyncCompute._transition)
+    ) {
+      if (currentOptimisticLane) {
+        const pendingLane = asyncCompute._optimisticLane;
+        const lane = findLane(currentOptimisticLane);
+        if (pendingLane && findLane(pendingLane) === lane && !hasActiveOverride(asyncCompute)) {
+          if (!tracking) link(el, c);
+          throw asyncCompute._error;
+        }
+      } else {
         if (!tracking) link(el, c);
         throw asyncCompute._error;
       }
-    } else {
-      if (!tracking) link(el, c);
+    } else if (!c && asyncCompute._statusFlags & STATUS_UNINITIALIZED) {
       throw asyncCompute._error;
     }
   }
@@ -1313,6 +1397,15 @@ function read(el) {
       return read(el);
     } else throw el._error;
   }
+  if (snapshotCaptureActive && c && c._inSnapshotScope) {
+    const sv = el._snapshotValue;
+    if (sv !== undefined) {
+      const snapshot = sv === NO_SNAPSHOT ? undefined : sv;
+      const current = el._pendingValue !== NOT_PENDING ? el._pendingValue : el._value;
+      if (current !== snapshot) c._flags |= REACTIVE_SNAPSHOT_STALE;
+      return snapshot;
+    }
+  }
   return !c ||
     currentOptimisticLane !== null ||
     el._pendingValue === NOT_PENDING ||
@@ -1907,7 +2000,7 @@ function getNodes(target, type) {
   if (!nodes) target[type] = nodes = Object.create(null);
   return nodes;
 }
-function getNode(nodes, property, value, firewall, equals = isEqual, optimistic) {
+function getNode(nodes, property, value, firewall, equals = isEqual, optimistic, snapshotProps) {
   if (nodes[property]) return nodes[property];
   const s = signal(
     value,
@@ -1920,6 +2013,11 @@ function getNode(nodes, property, value, firewall, equals = isEqual, optimistic)
     firewall
   );
   if (optimistic) s._optimistic = true;
+  if (snapshotProps && property in snapshotProps) {
+    const sv = snapshotProps[property];
+    s._snapshotValue = sv === undefined ? NO_SNAPSHOT : sv;
+    snapshotSources?.add(s);
+  }
   return (nodes[property] = s);
 }
 function trackSelf(target, symbol = $TRACK) {
@@ -2017,7 +2115,8 @@ const storeTraps = {
             isWrappable(value) ? wrap(value, target) : value,
             target[STORE_FIREWALL],
             isEqual,
-            target[STORE_OPTIMISTIC]
+            target[STORE_OPTIMISTIC],
+            target[STORE_SNAPSHOT_PROPS]
           )
         );
       }
@@ -2057,6 +2156,15 @@ const storeTraps = {
       untrack(() => {
         const state = target[STORE_VALUE];
         const base = state[property];
+        if (snapshotCaptureActive && typeof property !== "symbol") {
+          if (!target[STORE_SNAPSHOT_PROPS]) {
+            target[STORE_SNAPSHOT_PROPS] = Object.create(null);
+            snapshotSources?.add(target);
+          }
+          if (!(property in target[STORE_SNAPSHOT_PROPS])) {
+            target[STORE_SNAPSHOT_PROPS][property] = base;
+          }
+        }
         const useOptimistic = target[STORE_OPTIMISTIC] && !projectionWriteActive;
         const overrideKey = useOptimistic ? STORE_OPTIMISTIC_OVERRIDE : STORE_OVERRIDE;
         if (useOptimistic) trackOptimisticStore(store);
@@ -2878,6 +2986,7 @@ export {
   NotReadyError,
   SUPPORTS_PROXY,
   action,
+  clearSnapshots,
   createContext,
   createEffect,
   createErrorBoundary,
@@ -2900,11 +3009,13 @@ export {
   getNextChildId,
   getObserver,
   getOwner,
+  isDisposed,
   isEqual,
   isPending,
   isRefreshing,
   isWrappable,
   mapArray,
+  markSnapshotScope,
   merge,
   omit,
   onCleanup,
@@ -2913,10 +3024,12 @@ export {
   pending,
   reconcile,
   refresh,
+  releaseSnapshotScope,
   repeat,
   resolve,
   runWithOwner,
   setContext,
+  setSnapshotCapture,
   snapshot,
   untrack
 };