@solidjs/signals 0.8.6 → 0.9.0

package/dist/dev.js

@@ -328,6 +328,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 +365,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) {
@@ -413,15 +414,59 @@ function recompute(el, create = false) {
       insertIntoHeapHeight(s._sub, s._sub._flags & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
     }
   }
-  if (
-    (!create || el._statusFlags & STATUS_PENDING) &&
-    !el._optimistic &&
-    !honoraryOptimistic &&
-    !el._transition
-  )
+  if ((!create || el._statusFlags & STATUS_PENDING) && !el._optimistic && !el._transition)
     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) {
@@ -605,6 +650,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);
@@ -624,67 +670,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),
@@ -719,6 +704,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);
@@ -900,6 +886,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 };
 }
@@ -1009,12 +1011,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,
@@ -1237,11 +1233,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 };
@@ -2154,7 +2153,6 @@ export {
   NoOwnerError,
   NotReadyError,
   SUPPORTS_PROXY,
-  createAsync,
   createBoundary,
   createContext,
   createEffect,
@@ -2179,6 +2177,7 @@ export {
   getOwner,
   isEqual,
   isPending,
+  isRefreshing,
   isWrappable,
   mapArray,
   merge,
@@ -2187,6 +2186,7 @@ export {
   onSettled,
   pending,
   reconcile,
+  refresh,
   repeat,
   resolve,
   runWithOwner,