@solidjs/signals 0.13.4 → 0.13.5

package/dist/dev.js

@@ -1016,16 +1016,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 +1390,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 +1496,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;
   }
@@ -1686,6 +1687,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 +1861,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");
 }
@@ -1910,7 +1914,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 +1962,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 +2006,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 +2229,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 +2252,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 +2702,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 +3238,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);