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

package/README.md

@@ -107,8 +107,8 @@ const data = createMemo(async () => {
   return response.json();
 });
 
-// Check async state
-isPending(data); // true while loading
+// Check async state for this read
+isPending(data); // true while this read touches pending async work
 latest(data); // last resolved value
 ```
 
@@ -183,7 +183,7 @@ import { createErrorBoundary, createLoadingBoundary } from "@solidjs/signals";
 
 createErrorBoundary(
   () => riskyComputation(),
-  (error, reset) => handleError(error)
+  (error, reset) => handleError(error())
 );
 
 createLoadingBoundary(
@@ -223,7 +223,7 @@ createRoot(dispose => {
 | ------------------------ | ------------------------------------------------------------------ |
 | `flush()`                | Process all pending updates                                        |
 | `untrack(fn)`            | Run `fn` without tracking dependencies                             |
-| `isPending(accessor)`    | Check if an async accessor is loading                              |
+| `isPending(accessor)`    | Check if an async accessor is revalidating stale data              |
 | `latest(accessor)`       | Get the last resolved value of an async accessor                   |
 | `refresh(accessor)`      | Re-trigger an async computation                                    |
 | `isRefreshing(accessor)` | Check if an async accessor is refreshing                           |

package/dist/dev.js

@@ -1469,6 +1469,7 @@ let foundPending = false;
 let latestReadActive = false;
 let context = null;
 let currentOptimisticLane = null;
+let pendingCheckSources = null;
 let snapshotCaptureActive = false;
 let snapshotSources = null;
 function ownerInSnapshotScope(owner) {
@@ -1930,6 +1931,26 @@ 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;
+    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;
+    }
     if (firewall && el._overrideValue !== undefined) {
       if (
         el._overrideValue !== NOT_PENDING &&
@@ -1937,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;
@@ -2223,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);
   }
@@ -2299,16 +2328,38 @@ function latest(fn) {
 function isPending(fn) {
   const prevPendingCheck = pendingCheckActive;
   const prevFoundPending = foundPending;
+  const prevPendingCheckSources = pendingCheckSources;
   pendingCheckActive = true;
   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 {
+  } catch (e) {
+    collectPending();
+    if (e instanceof NotReadyError) {
+      if (foundPending && !(e.source?._statusFlags & STATUS_UNINITIALIZED)) return true;
+      if (context) throw e;
+    }
     return foundPending;
   } finally {
     pendingCheckActive = prevPendingCheck;
     foundPending = prevFoundPending;
+    pendingCheckSources = prevPendingCheckSources;
   }
 }
 function refresh(target) {
@@ -3141,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) {
@@ -3332,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
@@ -3409,6 +3482,7 @@ const storeTraps = {
     return has;
   },
   set(target, property, rawValue) {
+    if (property === "__proto__") return true;
     const store = target[$PROXY];
     if (writeOnly(store)) {
       untrack(() => {
@@ -3470,6 +3544,7 @@ const storeTraps = {
     return true;
   },
   defineProperty(target, property, descriptor) {
+    if (property === "__proto__") return true;
     const store = target[$PROXY];
     if (writeOnly(store)) {
       untrack(() => {
@@ -3496,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) {
@@ -4207,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();
@@ -4356,6 +4432,7 @@ class CollectionQueue extends Queue {
   _tree;
   _pending = true;
   _disabled = signal(false, { ownedWrite: true, _noSnapshot: true });
+  _error;
   _collapsed = signal(false, { ownedWrite: true, _noSnapshot: true });
   _revealController;
   _initialized = false;
@@ -4397,6 +4474,9 @@ class CollectionQueue extends Queue {
         const wasEmpty = this._sources.size === 0;
         this._sources.add(source);
         if (wasEmpty) setSignal(this._disabled, true);
+        if (this._collectionType & STATUS_ERROR) {
+          setSignal(this._error, source._error?.cause ?? source._error);
+        }
       }
     }
     type &= ~this._collectionType;
@@ -4450,6 +4530,8 @@ function createCollectionBoundary(type, fn, fallback, onFn) {
   const owner = createOwner();
   if (_revealUsed) setContext(RevealControllerContext, null, owner);
   const queue = new CollectionQueue(type);
+  if (type === STATUS_ERROR)
+    queue._error = signal(undefined, { ownedWrite: true, _noSnapshot: true });
   if (onFn) queue._onFn = onFn;
   const tree = (queue._tree = createBoundChildren(owner, fn, queue, type));
   untrack(() => {
@@ -4485,14 +4567,12 @@ function createLoadingBoundary(fn, fallback, options) {
   return createCollectionBoundary(STATUS_PENDING, fn, () => fallback(), options?.on);
 }
 function createErrorBoundary(fn, fallback) {
-  return createCollectionBoundary(STATUS_ERROR, fn, queue => {
-    let source = queue._sources.values().next().value;
-    const error = source._error?.cause ?? source._error;
-    return fallback(error, () => {
+  return createCollectionBoundary(STATUS_ERROR, fn, queue =>
+    fallback(accessor(queue._error), () => {
       for (const source of queue._sources) recompute(source);
       schedule();
-    });
-  });
+    })
+  );
 }
 function createRevealOrder(fn, options) {
   _revealUsed = true;