@solidjs/signals 2.0.0-beta.13 → 2.0.0-beta.14

package/README.md

@@ -107,9 +107,8 @@ const data = createMemo(async () => {
   return response.json();
 });
 
-// Check async state during revalidation
-isPending(data); // true while stale data is visible and newer data is pending
-isPending(data, true); // follows the Loading path for render guards
+// Check async state for this read
+isPending(data); // true while this read touches pending async work
 latest(data); // last resolved value
 ```
 

package/dist/dev.js

@@ -1469,7 +1469,7 @@ let foundPending = false;
 let latestReadActive = false;
 let context = null;
 let currentOptimisticLane = null;
-let pendingCheckLoadingPath = false;
+let pendingCheckSources = null;
 let snapshotCaptureActive = false;
 let snapshotSources = null;
 function ownerInSnapshotScope(owner) {
@@ -1931,15 +1931,23 @@ function read(el) {
     const firewall = el._firewall;
     const prevCheck = pendingCheckActive;
     pendingCheckActive = false;
+    let c = context;
+    if (c?._root) c = c._parentComputed;
     const owner = firewall || el;
-    if (
-      pendingCheckLoadingPath &&
-      owner._statusFlags & STATUS_PENDING &&
-      owner._statusFlags & STATUS_UNINITIALIZED
-    ) {
-      let c = context;
-      if (c?._root) c = c._parentComputed;
-      if (c && tracking) link(el, c);
+    const pendingComputed = el;
+    if (typeof pendingComputed._fn === "function") {
+      const comp = el;
+      if (comp._flags & REACTIVE_LAZY) {
+        comp._flags &= ~REACTIVE_LAZY;
+        recompute(comp, true);
+      } else if (comp._flags & REACTIVE_DISPOSED) {
+        recompute(comp, true);
+      } else {
+        updateIfNecessary(comp);
+      }
+    }
+    if (c && owner._statusFlags & STATUS_PENDING && owner._statusFlags & STATUS_UNINITIALIZED) {
+      if (tracking && el !== c) link(el, c);
       pendingCheckActive = prevCheck;
       throw owner._error;
     }
@@ -1950,17 +1958,14 @@ function read(el) {
       ) {
         foundPending = true;
       }
-      let c = context;
-      if (c?._root) c = c._parentComputed;
+      collectPendingSources(el);
+      collectPendingSources(firewall);
       if (c && tracking) link(el, c);
-      read(getPendingSignal(el));
-      read(getPendingSignal(firewall));
     } else {
-      if (read(getPendingSignal(el))) foundPending = true;
-      if (firewall && read(getPendingSignal(firewall))) foundPending = true;
+      collectPendingSources(el);
+      if (firewall) collectPendingSources(firewall);
     }
     pendingCheckActive = prevCheck;
-    return el._value;
   }
   let c = context;
   if (c?._root) c = c._parentComputed;
@@ -2236,9 +2241,20 @@ function getPendingSignal(el) {
   }
   return el._pendingSignal;
 }
+function collectPendingSources(el) {
+  pendingCheckSources?.add(el);
+  const owner = el._firewall || el;
+  if (owner !== el) pendingCheckSources?.add(owner);
+}
 function computePendingState(el) {
   const comp = el;
   const firewall = el._firewall;
+  if (el._parentSource) {
+    const parent = el._parentSource;
+    if (parent._statusFlags & STATUS_PENDING && !(parent._statusFlags & STATUS_UNINITIALIZED))
+      return true;
+    return el._pendingValue !== NOT_PENDING && !(comp._statusFlags & STATUS_UNINITIALIZED);
+  }
   if (firewall && el._pendingValue !== NOT_PENDING) {
     return !firewall._inFlight && !(firewall._statusFlags & STATUS_PENDING);
   }
@@ -2309,24 +2325,41 @@ function latest(fn) {
     latestReadActive = prevLatest;
   }
 }
-function isPending(fn, loading) {
+function isPending(fn) {
   const prevPendingCheck = pendingCheckActive;
-  const prevPendingCheckLoadingPath = pendingCheckLoadingPath;
   const prevFoundPending = foundPending;
-  const checkLoading = loading === true;
+  const prevPendingCheckSources = pendingCheckSources;
   pendingCheckActive = true;
-  pendingCheckLoadingPath = checkLoading;
   foundPending = false;
+  pendingCheckSources = new Set();
+  const collectPending = () => {
+    pendingCheckActive = false;
+    const prevStrictRead = strictRead;
+    strictRead = false;
+    try {
+      pendingCheckSources.forEach(source => {
+        if (read(getPendingSignal(source))) foundPending = true;
+      });
+    } finally {
+      strictRead = prevStrictRead;
+      pendingCheckActive = true;
+    }
+  };
   try {
     fn();
+    collectPending();
     return foundPending;
   } catch (e) {
-    if (checkLoading && e instanceof NotReadyError) throw e;
+    collectPending();
+    if (e instanceof NotReadyError) {
+      if (foundPending && !(e.source?._statusFlags & STATUS_UNINITIALIZED)) return true;
+      if (context) throw e;
+    }
     return foundPending;
   } finally {
     pendingCheckActive = prevPendingCheck;
-    pendingCheckLoadingPath = prevPendingCheckLoadingPath;
     foundPending = prevFoundPending;
+    pendingCheckSources = prevPendingCheckSources;
   }
 }
 function refresh(target) {
@@ -3159,6 +3192,26 @@ function writeOnly(proxy) {
 function unwrapStoreValue(value) {
   return value?.[$TARGET]?.[STORE_VALUE] ?? value;
 }
+function isPrototypePollutionKey$1(property) {
+  return property === "__proto__" || property === "constructor" || property === "prototype";
+}
+function hasOwnStoreProperty(target, property) {
+  const optimisticOverride = target[STORE_OPTIMISTIC_OVERRIDE];
+  if (
+    optimisticOverride &&
+    Object.prototype.hasOwnProperty.call(optimisticOverride, property) &&
+    optimisticOverride[property] !== $DELETED
+  )
+    return true;
+  const override = target[STORE_OVERRIDE];
+  if (
+    override &&
+    Object.prototype.hasOwnProperty.call(override, property) &&
+    override[property] !== $DELETED
+  )
+    return true;
+  return Object.prototype.hasOwnProperty.call(unwrapStoreValue(target[STORE_VALUE]), property);
+}
 function hasInheritedAccessor(source, property) {
   let current = Object.getPrototypeOf(source);
   while (current && current !== Object.prototype) {
@@ -3350,6 +3403,8 @@ const storeTraps = {
       }
     }
     if (writeOnly(receiver)) {
+      if (isPrototypePollutionKey$1(property) && !hasOwnStoreProperty(target, property))
+        return undefined;
       let value =
         tracked && (overridden || !proxySource)
           ? tracked._overrideValue !== undefined && tracked._overrideValue !== NOT_PENDING
@@ -3427,6 +3482,7 @@ const storeTraps = {
     return has;
   },
   set(target, property, rawValue) {
+    if (property === "__proto__") return true;
     const store = target[$PROXY];
     if (writeOnly(store)) {
       untrack(() => {
@@ -3488,6 +3544,7 @@ const storeTraps = {
     return true;
   },
   defineProperty(target, property, descriptor) {
+    if (property === "__proto__") return true;
     const store = target[$PROXY];
     if (writeOnly(store)) {
       untrack(() => {
@@ -3514,6 +3571,7 @@ const storeTraps = {
     return true;
   },
   deleteProperty(target, property) {
+    if (property === "__proto__") return true;
     const optDeleted = target[STORE_OPTIMISTIC_OVERRIDE]?.[property] === $DELETED;
     const regDeleted = target[STORE_OVERRIDE]?.[property] === $DELETED;
     if (writeOnly(target[$PROXY]) && !optDeleted && !regDeleted) {
@@ -4225,7 +4283,7 @@ function createBoundChildren(owner, fn, queue, mask) {
   cleanup(() => parentQueue.removeChild(owner._queue));
   return runWithOwner(owner, () => {
     const c = computed(fn);
-    return boundaryComputed(() => staleValues(() => flatten(read(c))), mask);
+    return boundaryComputed(() => flatten(read(c)), mask);
   });
 }
 const ON_INIT = Symbol();