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

package/README.md

@@ -107,8 +107,9 @@ const data = createMemo(async () => {
   return response.json();
 });
 
-// Check async state
-isPending(data); // true while loading
+// 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
 latest(data); // last resolved value
 ```
 
@@ -183,7 +184,7 @@ import { createErrorBoundary, createLoadingBoundary } from "@solidjs/signals";
 
 createErrorBoundary(
   () => riskyComputation(),
-  (error, reset) => handleError(error)
+  (error, reset) => handleError(error())
 );
 
 createLoadingBoundary(
@@ -223,7 +224,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 pendingCheckLoadingPath = false;
 let snapshotCaptureActive = false;
 let snapshotSources = null;
 function ownerInSnapshotScope(owner) {
@@ -1930,6 +1931,18 @@ function read(el) {
     const firewall = el._firewall;
     const prevCheck = pendingCheckActive;
     pendingCheckActive = false;
+    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);
+      pendingCheckActive = prevCheck;
+      throw owner._error;
+    }
     if (firewall && el._overrideValue !== undefined) {
       if (
         el._overrideValue !== NOT_PENDING &&
@@ -2296,18 +2309,23 @@ function latest(fn) {
     latestReadActive = prevLatest;
   }
 }
-function isPending(fn) {
+function isPending(fn, loading) {
   const prevPendingCheck = pendingCheckActive;
+  const prevPendingCheckLoadingPath = pendingCheckLoadingPath;
   const prevFoundPending = foundPending;
+  const checkLoading = loading === true;
   pendingCheckActive = true;
+  pendingCheckLoadingPath = checkLoading;
   foundPending = false;
   try {
     fn();
     return foundPending;
-  } catch {
+  } catch (e) {
+    if (checkLoading && e instanceof NotReadyError) throw e;
     return foundPending;
   } finally {
     pendingCheckActive = prevPendingCheck;
+    pendingCheckLoadingPath = prevPendingCheckLoadingPath;
     foundPending = prevFoundPending;
   }
 }
@@ -3967,7 +3985,8 @@ function mapArray(list, map, options) {
     _nodes: [],
     _key: keyFn,
     _rows: keyFn || options?.keyed === false ? [] : undefined,
-    _indexes: indexes ? [] : undefined,
+    _indexes: indexes && options?.keyed !== false ? [] : undefined,
+    _byIndex: options?.keyed === false,
     _fallback: options?.fallback
   };
   const node = computed(updateKeyedMap.bind(data));
@@ -3984,23 +4003,28 @@ function updateKeyedMap() {
     let i,
       j,
       mapper = this._rows
-        ? () => {
-            this._rows[j] = signal(newItems[j], pureOptions);
-            this._indexes && (this._indexes[j] = signal(j, pureOptions));
-            return this._map(
-              accessor(this._rows[j]),
-              this._indexes ? accessor(this._indexes[j]) : undefined
-            );
-          }
+        ? this._byIndex
+          ? () => {
+              this._rows[j] = signal(newItems[j], pureOptions);
+              return this._map(accessor(this._rows[j]), j);
+            }
+          : () => {
+              this._rows[j] = signal(newItems[j], pureOptions);
+              this._indexes && (this._indexes[j] = signal(j, pureOptions));
+              return this._map(
+                accessor(this._rows[j]),
+                this._indexes ? accessor(this._indexes[j]) : undefined
+              );
+            }
         : this._indexes
           ? () => {
               const item = newItems[j];
               this._indexes[j] = signal(j, pureOptions);
-              return this._map(() => item, accessor(this._indexes[j]));
+              return this._map(item, accessor(this._indexes[j]));
             }
           : () => {
               const item = newItems[j];
-              return this._map(() => item);
+              return this._map(item);
             };
     if (newLen === 0) {
       if (this._len !== 0) {
@@ -4350,6 +4374,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;
@@ -4391,6 +4416,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;
@@ -4444,6 +4472,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(() => {
@@ -4479,14 +4509,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;