@solidjs/signals 0.13.4 → 0.13.6

package/dist/dev.js

@@ -151,6 +151,7 @@ let clock = 0;
 let activeTransition = null;
 let scheduled = false;
 let projectionWriteActive = false;
+let inTrackedQueueCallback = false;
 let _enforceLoadingBoundary = false;
 let _hitUnhandledAsync = false;
 let stashedOptimisticReads = null;
@@ -192,6 +193,9 @@ function queueStashedOptimisticEffects(node) {
 function setProjectionWriteActive(value) {
   projectionWriteActive = value;
 }
+function setTrackedQueueCallback(value) {
+  inTrackedQueueCallback = value;
+}
 function mergeTransitionState(target, outgoing) {
   outgoing._done = target;
   target._actions.push(...outgoing._actions);
@@ -242,20 +246,6 @@ function schedule() {
   scheduled = true;
   if (!globalQueue._running && !projectionWriteActive) queueMicrotask(flush);
 }
-function addTransitionBlocker(node) {
-  if (activeTransition && !activeTransition._asyncNodes.includes(node)) {
-    activeTransition._asyncNodes.push(node);
-  }
-}
-function removeTransitionBlocker(node) {
-  const remove = list => {
-    if (!list) return;
-    const index = list.indexOf(node);
-    if (index >= 0) list.splice(index, 1);
-  };
-  remove(node._transition?._asyncNodes);
-  remove(activeTransition?._asyncNodes);
-}
 class Queue {
   _parent = null;
   _queues = [[], []];
@@ -532,6 +522,14 @@ function reassignPendingTransition(pendingNodes) {
 }
 const globalQueue = new GlobalQueue();
 function flush() {
+  if (globalQueue._running) {
+    if (inTrackedQueueCallback) {
+      throw new Error(
+        "Cannot call flush() from inside onSettled or createTrackedEffect. flush() is not reentrant there."
+      );
+    }
+    return;
+  }
   let count = 0;
   while (scheduled || activeTransition) {
     if (++count === 1e5) throw new Error("Potential Infinite Loop Detected.");
@@ -552,6 +550,21 @@ function transitionComplete(transition) {
       break;
     }
   }
+  if (done) {
+    for (let i = 0; i < transition._optimisticNodes.length; i++) {
+      const node = transition._optimisticNodes[i];
+      if (
+        hasActiveOverride(node) &&
+        "_statusFlags" in node &&
+        node._statusFlags & STATUS_PENDING &&
+        node._error instanceof NotReadyError &&
+        node._error.source !== node
+      ) {
+        done = false;
+        break;
+      }
+    }
+  }
   done && (transition._done = true);
   return done;
 }
@@ -843,7 +856,6 @@ function handleAsync(el, result, setter) {
 }
 function clearStatus(el, clearUninitialized = false) {
   clearPendingSources(el);
-  removeTransitionBlocker(el);
   el._blocked = false;
   el._statusFlags = clearUninitialized ? 0 : el._statusFlags & STATUS_UNINITIALIZED;
   setPendingError(el);
@@ -867,11 +879,9 @@ function notifyStatus(el, status, error, blockStatus, lane) {
     if (status === STATUS_PENDING && pendingSource) {
       addPendingSource(el, pendingSource);
       el._statusFlags = STATUS_PENDING | (el._statusFlags & STATUS_UNINITIALIZED);
-      setPendingError(el, el._pendingSource ?? el._pendingSources?.values().next().value, error);
-      if (pendingSource === el) addTransitionBlocker(el);
+      setPendingError(el, pendingSource, error);
     } else {
       clearPendingSources(el);
-      removeTransitionBlocker(el);
       el._statusFlags =
         status | (status !== STATUS_ERROR ? el._statusFlags & STATUS_UNINITIALIZED : 0);
       el._error = error;
@@ -884,6 +894,9 @@ function notifyStatus(el, status, error, blockStatus, lane) {
   const downstreamBlockStatus = blockStatus || startsBlocking;
   const downstreamLane = blockStatus || isOptimisticBoundary ? undefined : lane;
   if (el._notifyStatus) {
+    if (blockStatus && status === STATUS_PENDING) {
+      return;
+    }
     if (downstreamBlockStatus) {
       el._notifyStatus(status, error);
     } else {
@@ -901,7 +914,7 @@ function notifyStatus(el, status, error, blockStatus, lane) {
       (status !== STATUS_PENDING &&
         (sub._error !== error || sub._pendingSource || sub._pendingSources))
     ) {
-      !sub._transition && globalQueue._pendingNodes.push(sub);
+      if (!downstreamBlockStatus && !sub._transition) globalQueue._pendingNodes.push(sub);
       notifyStatus(sub, status, error, downstreamBlockStatus, downstreamLane);
     }
   });
@@ -1016,16 +1029,8 @@ function getObserver() {
 function getOwner() {
   return context;
 }
-function onCleanup(fn) {
-  if (!context) {
-    console.warn("onCleanup called outside a reactive context will never be run");
-    return fn;
-  }
-  if (context._childrenForbidden) {
-    throw new Error(
-      "Cannot use onCleanup inside createTrackedEffect or onSettled; return a cleanup function instead"
-    );
-  }
+function cleanup(fn) {
+  if (!context) return fn;
   if (!context._disposal) context._disposal = fn;
   else if (Array.isArray(context._disposal)) context._disposal.push(fn);
   else context._disposal = [context._disposal, fn];
@@ -1398,7 +1403,7 @@ function computed(fn, initialValue, options) {
     const source = externalSourceConfig.factory(self._fn, () => {
       setSignal(bridgeSignal, undefined);
     });
-    onCleanup(() => source.dispose());
+    cleanup(() => source.dispose());
     self._fn = prev => {
       read(bridgeSignal);
       return source.track(prev);
@@ -1504,8 +1509,17 @@ function read(el) {
     const firewall = el._firewall;
     const prevCheck = pendingCheckActive;
     pendingCheckActive = false;
-    if (read(getPendingSignal(el))) foundPending = true;
-    if (firewall && read(getPendingSignal(firewall))) foundPending = true;
+    if (firewall && el._overrideValue !== undefined) {
+      if (
+        el._overrideValue !== NOT_PENDING &&
+        (firewall._inFlight || !!(firewall._statusFlags & STATUS_PENDING))
+      ) {
+        foundPending = true;
+      }
+    } else {
+      if (read(getPendingSignal(el))) foundPending = true;
+      if (firewall && read(getPendingSignal(firewall))) foundPending = true;
+    }
     pendingCheckActive = prevCheck;
     return el._value;
   }
@@ -1558,6 +1572,9 @@ function read(el) {
         if (!tracking && el !== c) link(el, c);
         throw owner._error;
       }
+    } else if (c && owner !== el && owner._statusFlags & STATUS_UNINITIALIZED) {
+      if (!tracking && el !== c) link(el, c);
+      throw owner._error;
     } else if (!c && owner._statusFlags & STATUS_UNINITIALIZED) {
       throw owner._error;
     }
@@ -1686,6 +1703,9 @@ function computePendingState(el) {
     }
     return true;
   }
+  if (el._overrideValue !== undefined && el._overrideValue === NOT_PENDING && !el._parentSource) {
+    return false;
+  }
   if (el._pendingValue !== NOT_PENDING && !(comp._statusFlags & STATUS_UNINITIALIZED)) return true;
   return !!(comp._statusFlags & STATUS_PENDING && !(comp._statusFlags & STATUS_UNINITIALIZED));
 }
@@ -1857,7 +1877,7 @@ function effect(compute, effect, error, initialValue, options) {
       ? node._queue.enqueue(node._type, runEffect.bind(node))
       : runEffect.call(node));
   initialized = true;
-  onCleanup(() => node._cleanup?.());
+  cleanup(() => node._cleanup?.());
   if (!node._parent)
     console.warn("Effects created outside a reactive context will never be disposed");
 }
@@ -1884,8 +1904,13 @@ function runEffect() {
 function trackedEffect(fn, options) {
   const run = () => {
     if (!node._modified || node._flags & REACTIVE_DISPOSED) return;
-    node._modified = false;
-    recompute(node);
+    setTrackedQueueCallback(true);
+    try {
+      node._modified = false;
+      recompute(node);
+    } finally {
+      setTrackedQueueCallback(false);
+    }
   };
   const node = computed(
     () => {
@@ -1910,7 +1935,7 @@ function trackedEffect(fn, options) {
   };
   node._run = run;
   node._queue.enqueue(EFFECT_USER, run);
-  onCleanup(() => node._cleanup?.());
+  cleanup(() => node._cleanup?.());
   if (!node._parent)
     console.warn("Effects created outside a reactive context will never be disposed");
 }
@@ -1958,6 +1983,17 @@ function action(genFn) {
       step();
     });
 }
+function onCleanup(fn) {
+  {
+    const owner = getOwner();
+    if (!owner) console.warn("onCleanup called outside a reactive context will never be run");
+    else if (owner._childrenForbidden)
+      throw new Error(
+        "Cannot use onCleanup inside createTrackedEffect or onSettled; return a cleanup function instead"
+      );
+  }
+  return cleanup(fn);
+}
 function accessor(node) {
   const fn = read.bind(null, node);
   fn.$r = true;
@@ -1991,16 +2027,16 @@ function createTrackedEffect(compute, options) {
   trackedEffect(compute, { ...options, name: options?.name ?? "trackedEffect" });
 }
 function createReaction(effectFn, options) {
-  let cleanup = undefined;
-  onCleanup(() => cleanup?.());
+  let cl = undefined;
+  cleanup(() => cl?.());
   const owner = getOwner();
   return tracking => {
     runWithOwner(owner, () => {
       effect(
         () => (tracking(), getOwner()),
         node => {
-          cleanup?.();
-          cleanup = (effectFn.effect || effectFn)?.();
+          cl?.();
+          cl = (effectFn.effect || effectFn)?.();
           dispose(node);
         },
         effectFn.error,
@@ -2214,8 +2250,16 @@ function createProjectionInternal(fn, initialValue = {}, options) {
   const wrappedStore = wrapProjection(initialValue);
   node = computed(() => {
     const owner = getOwner();
-    storeSetter(new Proxy(wrappedStore, writeTraps), s => {
-      const value = handleAsync(owner, fn(s), value => {
+    let settled = false;
+    let result;
+    const draft = new Proxy(
+      wrappedStore,
+      createWriteTraps(() => !settled || owner._inFlight === result)
+    );
+    storeSetter(draft, s => {
+      result = fn(s);
+      settled = true;
+      const value = handleAsync(owner, result, value => {
         value !== s &&
           value !== undefined &&
           storeSetter(wrappedStore, reconcile(value, options?.key || "id"));
@@ -2229,42 +2273,47 @@ function createProjectionInternal(fn, initialValue = {}, options) {
 function createProjection(fn, initialValue = {}, options) {
   return createProjectionInternal(fn, initialValue, options).store;
 }
-const writeTraps = {
-  get(_, prop) {
-    let value;
-    setWriteOverride(true);
-    setProjectionWriteActive(true);
-    try {
-      value = _[prop];
-    } finally {
-      setWriteOverride(false);
-      setProjectionWriteActive(false);
-    }
-    return typeof value === "object" && value !== null ? new Proxy(value, writeTraps) : value;
-  },
-  set(_, prop, value) {
-    setWriteOverride(true);
-    setProjectionWriteActive(true);
-    try {
-      _[prop] = value;
-    } finally {
-      setWriteOverride(false);
-      setProjectionWriteActive(false);
-    }
-    return true;
-  },
-  deleteProperty(_, prop) {
-    setWriteOverride(true);
-    setProjectionWriteActive(true);
-    try {
-      delete _[prop];
-    } finally {
-      setWriteOverride(false);
-      setProjectionWriteActive(false);
+function createWriteTraps(isActive) {
+  const traps = {
+    get(_, prop) {
+      let value;
+      setWriteOverride(true);
+      setProjectionWriteActive(true);
+      try {
+        value = _[prop];
+      } finally {
+        setWriteOverride(false);
+        setProjectionWriteActive(false);
+      }
+      return typeof value === "object" && value !== null ? new Proxy(value, traps) : value;
+    },
+    set(_, prop, value) {
+      if (isActive && !isActive()) return true;
+      setWriteOverride(true);
+      setProjectionWriteActive(true);
+      try {
+        _[prop] = value;
+      } finally {
+        setWriteOverride(false);
+        setProjectionWriteActive(false);
+      }
+      return true;
+    },
+    deleteProperty(_, prop) {
+      if (isActive && !isActive()) return true;
+      setWriteOverride(true);
+      setProjectionWriteActive(true);
+      try {
+        delete _[prop];
+      } finally {
+        setWriteOverride(false);
+        setProjectionWriteActive(false);
+      }
+      return true;
     }
-    return true;
-  }
-};
+  };
+  return traps;
+}
 const $TRACK = Symbol("STORE_TRACK"),
   $TARGET = Symbol("STORE_TARGET"),
   $PROXY = Symbol("STORE_PROXY"),
@@ -2674,10 +2723,18 @@ function createOptimisticProjectionInternal(fn, initialValue = {}, options) {
   if (fn) {
     node = computed(() => {
       const owner = getOwner();
+      let settled = false;
+      let result;
+      const draft = new Proxy(
+        wrappedStore,
+        createWriteTraps(() => !settled || owner._inFlight === result)
+      );
       setProjectionWriteActive(true);
       try {
-        storeSetter(new Proxy(wrappedStore, writeTraps), s => {
-          const value = handleAsync(owner, fn(s), value => {
+        storeSetter(draft, s => {
+          result = fn(s);
+          settled = true;
+          const value = handleAsync(owner, result, value => {
             setProjectionWriteActive(true);
             try {
               value !== s &&
@@ -3202,7 +3259,7 @@ function boundaryComputed(fn, propagationMask) {
 function createBoundChildren(owner, fn, queue, mask) {
   const parentQueue = owner._queue;
   parentQueue.addChild((owner._queue = queue));
-  onCleanup(() => parentQueue.removeChild(owner._queue));
+  cleanup(() => parentQueue.removeChild(owner._queue));
   return runWithOwner(owner, () => {
     const c = computed(fn);
     return boundaryComputed(() => staleValues(() => flatten(read(c))), mask);