@solidjs/signals 0.8.7 → 0.9.1

package/dist/dev.js

@@ -217,7 +217,7 @@ class GlobalQueue extends Queue {
           this.stashQueues(activeTransition.queueStash);
           clock++;
           scheduled = false;
-          runPending(activeTransition.pendingNodes, true);
+          runTransitionPending(activeTransition.pendingNodes, true);
           activeTransition = null;
           return;
         }
@@ -225,18 +225,14 @@ class GlobalQueue extends Queue {
         this.restoreQueues(activeTransition.queueStash);
         transitions.delete(activeTransition);
         activeTransition = null;
-        if (runPending(this._pendingNodes, false)) runHeap(dirtyQueue, GlobalQueue._update);
+        runTransitionPending(this._pendingNodes, false);
+        dirtyQueue._max >= dirtyQueue._min && runHeap(dirtyQueue, GlobalQueue._update);
       } else if (transitions.size) runHeap(zombieQueue, GlobalQueue._update);
-      for (let i = 0; i < this._pendingNodes.length; i++) {
-        const n = this._pendingNodes[i];
-        if (n._pendingValue !== NOT_PENDING) {
-          n._value = n._pendingValue;
-          n._pendingValue = NOT_PENDING;
-          if (n._type) n._modified = true;
-        }
-        if (n._fn) GlobalQueue._dispose(n, false, true);
+      runPending(this._pendingNodes);
+      while (dirtyQueue._max >= dirtyQueue._min) {
+        runHeap(dirtyQueue, GlobalQueue._update);
+        runPending(this._pendingNodes);
       }
-      this._pendingNodes.length = 0;
       clock++;
       scheduled = false;
       this.run(EFFECT_RENDER);
@@ -277,23 +273,31 @@ class GlobalQueue extends Queue {
     this._pendingNodes = activeTransition.pendingNodes;
   }
 }
-function runPending(pendingNodes, value) {
-  let needsReset = false;
+function runPending(pendingNodes) {
+  for (let i = 0; i < pendingNodes.length; i++) {
+    const n = pendingNodes[i];
+    if (n._pendingValue !== NOT_PENDING) {
+      n._value = n._pendingValue;
+      n._pendingValue = NOT_PENDING;
+      if (n._type) n._modified = true;
+    }
+    if (n._pendingSignal && n._pendingSignal._pendingValue !== NOT_PENDING)
+      n._pendingSignal._set(n._pendingSignal._pendingValue);
+    if (n._fn) GlobalQueue._dispose(n, false, true);
+  }
+  pendingNodes.length = 0;
+}
+function runTransitionPending(pendingNodes, value) {
   const p = pendingNodes.slice();
   for (let i = 0; i < p.length; i++) {
     const n = p[i];
     n._transition = activeTransition;
-    if (n._pendingCheck) {
-      n._pendingCheck._set(value);
-      needsReset = true;
-    }
+    if (n._pendingCheck) n._pendingCheck._set(value);
     if (n._pendingSignal && n._pendingSignal._pendingValue !== NOT_PENDING) {
       n._pendingSignal._set(n._pendingSignal._pendingValue);
       n._pendingSignal._pendingValue = NOT_PENDING;
-      needsReset = true;
     }
   }
-  return needsReset;
 }
 const globalQueue = new GlobalQueue();
 function flush() {
@@ -328,6 +332,7 @@ let tracking = false;
 let stale = false;
 let pendingValueCheck = false;
 let pendingCheck = null;
+let refreshing = false;
 let context = null;
 function notifySubs(node) {
   for (let s = node._subs; s !== null; s = s._nextSub) {
@@ -364,7 +369,7 @@ function recompute(el, create = false) {
   setStatusFlags(el, STATUS_NONE | (prevStatusFlags & STATUS_UNINITIALIZED));
   tracking = true;
   try {
-    value = el._fn(value);
+    value = handleAsync(el, el._fn(value));
     el._statusFlags &= ~STATUS_UNINITIALIZED;
   } catch (e) {
     if (e instanceof NotReadyError) {
@@ -417,6 +422,55 @@ function recompute(el, create = false) {
     globalQueue._pendingNodes.push(el);
   if (el._transition && honoraryOptimistic) runInTransition(el, recompute);
 }
+function handleAsync(el, result, setter) {
+  const isObject = typeof result === "object" && result !== null;
+  const isPromise = isObject && result instanceof Promise;
+  const iterator = isObject && untrack(() => result[Symbol.asyncIterator]);
+  if (!isPromise && !iterator) {
+    el._inFlight = null;
+    return result;
+  }
+  el._inFlight = result;
+  if (isPromise) {
+    result
+      .then(value => {
+        if (el._inFlight !== result) return;
+        globalQueue.initTransition(el);
+        setter?.(value) ?? setSignal(el, () => value);
+        flush();
+      })
+      .catch(e => {
+        if (el._inFlight !== result) return;
+        globalQueue.initTransition(el);
+        setStatusFlags(el, STATUS_ERROR, e);
+        el._time = clock;
+        notifySubs(el);
+        schedule();
+        flush();
+      });
+  } else {
+    (async () => {
+      try {
+        for await (let value of result) {
+          if (el._inFlight !== result) return;
+          globalQueue.initTransition(el);
+          setter?.(value) ?? setSignal(el, () => value);
+          flush();
+        }
+      } catch (error) {
+        if (el._inFlight !== result) return;
+        globalQueue.initTransition(el);
+        setStatusFlags(el, STATUS_ERROR, error);
+        el._time = clock;
+        notifySubs(el);
+        schedule();
+        flush();
+      }
+    })();
+  }
+  globalQueue.initTransition(el);
+  throw new NotReadyError(context);
+}
 function updateIfNecessary(el) {
   if (el._flags & REACTIVE_CHECK) {
     for (let d = el._deps; d; d = d._nextDep) {
@@ -600,6 +654,7 @@ function computed(fn, initialValue, options) {
     _pendingValue: NOT_PENDING,
     _pendingDisposal: null,
     _pendingFirstChild: null,
+    _inFlight: null,
     _transition: null
   };
   if (options?._internal) Object.assign(self, options._internal);
@@ -619,67 +674,6 @@ function computed(fn, initialValue, options) {
   recompute(self, true);
   return self;
 }
-function asyncComputed(asyncFn, initialValue, options) {
-  let lastResult = undefined;
-  let refreshing = false;
-  const fn = prev => {
-    const result = asyncFn(prev, refreshing);
-    refreshing = false;
-    lastResult = result;
-    const isPromise = result instanceof Promise;
-    const iterator = result[Symbol.asyncIterator];
-    if (!isPromise && !iterator) {
-      return result;
-    }
-    if (isPromise) {
-      result
-        .then(v => {
-          if (lastResult !== result) return;
-          globalQueue.initTransition(self);
-          setSignal(self, () => v);
-          flush();
-        })
-        .catch(e => {
-          if (lastResult !== result) return;
-          globalQueue.initTransition(self);
-          setStatusFlags(self, STATUS_ERROR, e);
-          self._time = clock;
-          notifySubs(self);
-          schedule();
-          flush();
-        });
-    } else {
-      (async () => {
-        try {
-          for await (let value of result) {
-            if (lastResult !== result) return;
-            globalQueue.initTransition(self);
-            setSignal(self, () => value);
-            flush();
-          }
-        } catch (error) {
-          if (lastResult !== result) return;
-          globalQueue.initTransition(self);
-          setStatusFlags(self, STATUS_ERROR, error);
-          self._time = clock;
-          notifySubs(self);
-          schedule();
-          flush();
-        }
-      })();
-    }
-    globalQueue.initTransition(context);
-    throw new NotReadyError(context);
-  };
-  const self = computed(fn, initialValue, options);
-  self._refresh = () => {
-    refreshing = true;
-    recompute(self);
-    schedule();
-    flush();
-  };
-  return self;
-}
 function signal(v, options, firewall = null) {
   const s = {
     id: options?.id ?? (context?.id != null ? getNextChildId(context) : undefined),
@@ -714,6 +708,7 @@ function untrack(fn) {
 function read(el) {
   let c = context;
   if (c?._root) c = c._parentComputed;
+  if (refreshing && el._fn) recompute(el);
   if (c && tracking && !pendingCheck && !pendingValueCheck) {
     if (el._fn && el._flags & REACTIVE_DISPOSED) recompute(el);
     link(el, c);
@@ -895,6 +890,22 @@ function isPending(fn) {
     pendingCheck = current;
   }
 }
+function refresh(fn) {
+  let prevRefreshing = refreshing;
+  refreshing = true;
+  try {
+    return untrack(fn);
+  } finally {
+    refreshing = prevRefreshing;
+    if (!prevRefreshing) {
+      schedule();
+      flush();
+    }
+  }
+}
+function isRefreshing() {
+  return refreshing;
+}
 function createContext(defaultValue, description) {
   return { id: Symbol(description), defaultValue: defaultValue };
 }
@@ -1004,12 +1015,6 @@ function createMemo(compute, value, options) {
   let node = computed(compute, value, options);
   return read.bind(null, node);
 }
-function createAsync(compute, value, options) {
-  const node = asyncComputed(compute, value, options);
-  const ret = read.bind(null, node);
-  ret.refresh = node._refresh;
-  return ret;
-}
 function createEffect(compute, effectFn, value, options) {
   void effect(compute, effectFn.effect || effectFn, effectFn.error, value, {
     ...options,
@@ -1232,11 +1237,14 @@ function createProjectionInternal(fn, initialValue = {}, options) {
   };
   const wrappedStore = wrapProjection(initialValue);
   node = computed(() => {
+    const owner = node || getOwner();
     storeSetter(wrappedStore, s => {
-      const value = fn(s);
-      if (value !== s && value !== undefined) {
-        reconcile(value, options?.key || "id", options?.all)(s);
-      }
+      const value = handleAsync(owner, fn(s), value => {
+        value !== s &&
+          value !== undefined &&
+          storeSetter(wrappedStore, reconcile(value, options?.key || "id", options?.all));
+      });
+      value !== s && value !== undefined && reconcile(value, options?.key || "id", options?.all)(s);
     });
   });
   return { store: wrappedStore, node: node };
@@ -2149,7 +2157,6 @@ export {
   NoOwnerError,
   NotReadyError,
   SUPPORTS_PROXY,
-  createAsync,
   createBoundary,
   createContext,
   createEffect,
@@ -2174,6 +2181,7 @@ export {
   getOwner,
   isEqual,
   isPending,
+  isRefreshing,
   isWrappable,
   mapArray,
   merge,
@@ -2182,6 +2190,7 @@ export {
   onSettled,
   pending,
   reconcile,
+  refresh,
   repeat,
   resolve,
   runWithOwner,