@solidjs/signals 0.13.5 → 0.13.7

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;
 }
@@ -642,6 +655,209 @@ function assignOrMergeLane(el, sourceLane) {
   }
   el._optimisticLane = sourceLane;
 }
+function unlinkSubs(link) {
+  const dep = link._dep;
+  const nextDep = link._nextDep;
+  const nextSub = link._nextSub;
+  const prevSub = link._prevSub;
+  if (nextSub !== null) nextSub._prevSub = prevSub;
+  else dep._subsTail = prevSub;
+  if (prevSub !== null) prevSub._nextSub = nextSub;
+  else {
+    dep._subs = nextSub;
+    if (nextSub === null) {
+      dep._unobserved?.();
+      dep._fn && !dep._preventAutoDisposal && !(dep._flags & REACTIVE_ZOMBIE) && unobserved(dep);
+    }
+  }
+  return nextDep;
+}
+function unobserved(el) {
+  deleteFromHeap(el, el._flags & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
+  let dep = el._deps;
+  while (dep !== null) {
+    dep = unlinkSubs(dep);
+  }
+  el._deps = null;
+  disposeChildren(el, true);
+}
+function link(dep, sub) {
+  const prevDep = sub._depsTail;
+  if (prevDep !== null && prevDep._dep === dep) return;
+  let nextDep = null;
+  const isRecomputing = sub._flags & REACTIVE_RECOMPUTING_DEPS;
+  if (isRecomputing) {
+    nextDep = prevDep !== null ? prevDep._nextDep : sub._deps;
+    if (nextDep !== null && nextDep._dep === dep) {
+      sub._depsTail = nextDep;
+      return;
+    }
+  }
+  const prevSub = dep._subsTail;
+  if (prevSub !== null && prevSub._sub === sub && (!isRecomputing || isValidLink(prevSub, sub)))
+    return;
+  const newLink =
+    (sub._depsTail =
+    dep._subsTail =
+      { _dep: dep, _sub: sub, _nextDep: nextDep, _prevSub: prevSub, _nextSub: null });
+  if (prevDep !== null) prevDep._nextDep = newLink;
+  else sub._deps = newLink;
+  if (prevSub !== null) prevSub._nextSub = newLink;
+  else dep._subs = newLink;
+}
+function isValidLink(checkLink, sub) {
+  const depsTail = sub._depsTail;
+  if (depsTail !== null) {
+    let link = sub._deps;
+    do {
+      if (link === checkLink) return true;
+      if (link === depsTail) break;
+      link = link._nextDep;
+    } while (link !== null);
+  }
+  return false;
+}
+const PENDING_OWNER = {};
+function markDisposal(el) {
+  let child = el._firstChild;
+  while (child) {
+    child._flags |= REACTIVE_ZOMBIE;
+    if (child._flags & REACTIVE_IN_HEAP) {
+      deleteFromHeap(child, dirtyQueue);
+      insertIntoHeap(child, zombieQueue);
+    }
+    markDisposal(child);
+    child = child._nextSibling;
+  }
+}
+function dispose(node) {
+  let toRemove = node._deps || null;
+  do {
+    toRemove = unlinkSubs(toRemove);
+  } while (toRemove !== null);
+  node._deps = null;
+  node._depsTail = null;
+  disposeChildren(node, true);
+}
+function disposeChildren(node, self = false, zombie) {
+  if (node._flags & REACTIVE_DISPOSED) return;
+  if (self) node._flags = REACTIVE_DISPOSED;
+  if (self && node._fn) node._inFlight = null;
+  let child = zombie ? node._pendingFirstChild : node._firstChild;
+  while (child) {
+    const nextChild = child._nextSibling;
+    if (child._deps) {
+      const n = child;
+      deleteFromHeap(n, n._flags & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
+      let toRemove = n._deps;
+      do {
+        toRemove = unlinkSubs(toRemove);
+      } while (toRemove !== null);
+      n._deps = null;
+      n._depsTail = null;
+    }
+    disposeChildren(child, true);
+    child = nextChild;
+  }
+  if (zombie) {
+    node._pendingFirstChild = null;
+  } else {
+    node._firstChild = null;
+    node._childCount = 0;
+  }
+  runDisposal(node, zombie);
+}
+function runDisposal(node, zombie) {
+  let disposal = zombie ? node._pendingDisposal : node._disposal;
+  if (!disposal) return;
+  if (Array.isArray(disposal)) {
+    for (let i = 0; i < disposal.length; i++) {
+      const callable = disposal[i];
+      callable.call(callable);
+    }
+  } else {
+    disposal.call(disposal);
+  }
+  zombie ? (node._pendingDisposal = null) : (node._disposal = null);
+}
+function childId(owner, consume) {
+  let counter = owner;
+  while (counter._transparent && counter._parent) counter = counter._parent;
+  if (counter.id != null)
+    return formatId(counter.id, consume ? counter._childCount++ : counter._childCount);
+  throw new Error("Cannot get child id from owner without an id");
+}
+function getNextChildId(owner) {
+  return childId(owner, true);
+}
+function peekNextChildId(owner) {
+  return childId(owner, false);
+}
+function formatId(prefix, id) {
+  const num = id.toString(36),
+    len = num.length - 1;
+  return prefix + (len ? String.fromCharCode(64 + len) : "") + num;
+}
+function getObserver() {
+  if (pendingCheckActive || latestReadActive) return PENDING_OWNER;
+  return tracking ? context : null;
+}
+function getOwner() {
+  return context;
+}
+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];
+  return fn;
+}
+function isDisposed(node) {
+  return !!(node._flags & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE));
+}
+function createOwner(options) {
+  const parent = context;
+  const transparent = options?.transparent ?? false;
+  const owner = {
+    id:
+      options?.id ??
+      (transparent ? parent?.id : parent?.id != null ? getNextChildId(parent) : undefined),
+    _transparent: transparent || undefined,
+    _root: true,
+    _parentComputed: parent?._root ? parent._parentComputed : parent,
+    _firstChild: null,
+    _nextSibling: null,
+    _disposal: null,
+    _queue: parent?._queue ?? globalQueue,
+    _context: parent?._context || defaultContext,
+    _childCount: 0,
+    _pendingDisposal: null,
+    _pendingFirstChild: null,
+    _parent: parent,
+    dispose(self = true) {
+      disposeChildren(owner, self);
+    }
+  };
+  if (parent?._childrenForbidden) {
+    throw new Error(
+      "Cannot create reactive primitives inside createTrackedEffect or owner-backed onSettled"
+    );
+  }
+  if (parent) {
+    const lastChild = parent._firstChild;
+    if (lastChild === null) {
+      parent._firstChild = owner;
+    } else {
+      owner._nextSibling = lastChild;
+      parent._firstChild = owner;
+    }
+  }
+  return owner;
+}
+function createRoot(init, options) {
+  const owner = createOwner(options);
+  return runWithOwner(owner, () => init(owner.dispose));
+}
 function addPendingSource(el, source) {
   if (el._pendingSource === source || el._pendingSources?.has(source)) return false;
   if (!el._pendingSource) {
@@ -806,6 +1022,17 @@ function handleAsync(el, result, setter) {
   if (iterator) {
     const it = result[Symbol.asyncIterator]();
     let hadSyncValue = false;
+    let completed = false;
+    cleanup(() => {
+      if (completed) return;
+      completed = true;
+      try {
+        const returned = it.return?.();
+        if (returned && typeof returned.then === "function") {
+          returned.then(undefined, () => {});
+        }
+      } catch {}
+    });
     const iterate = () => {
       let syncResult,
         resolved = false,
@@ -815,14 +1042,21 @@ function handleAsync(el, result, setter) {
           if (isSync) {
             syncResult = r;
             resolved = true;
+            if (r.done) completed = true;
+          } else if (el._inFlight !== result) {
+            return;
           } else if (!r.done) asyncWrite(r.value, iterate);
           else {
+            completed = true;
             schedule();
             flush();
           }
         },
         e => {
-          if (!isSync) handleError(e);
+          if (!isSync && el._inFlight === result) {
+            completed = true;
+            handleError(e);
+          }
         }
       );
       isSync = false;
@@ -843,7 +1077,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 +1100,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 +1115,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 +1135,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);
     }
   });
@@ -929,208 +1163,6 @@ function enableExternalSource(config) {
     externalSourceConfig = { factory: factory, untrack: untrackFn };
   }
 }
-const PENDING_OWNER = {};
-function markDisposal(el) {
-  let child = el._firstChild;
-  while (child) {
-    child._flags |= REACTIVE_ZOMBIE;
-    if (child._flags & REACTIVE_IN_HEAP) {
-      deleteFromHeap(child, dirtyQueue);
-      insertIntoHeap(child, zombieQueue);
-    }
-    markDisposal(child);
-    child = child._nextSibling;
-  }
-}
-function dispose(node) {
-  let toRemove = node._deps || null;
-  do {
-    toRemove = unlinkSubs(toRemove);
-  } while (toRemove !== null);
-  node._deps = null;
-  node._depsTail = null;
-  disposeChildren(node, true);
-}
-function disposeChildren(node, self = false, zombie) {
-  if (node._flags & REACTIVE_DISPOSED) return;
-  if (self) node._flags = REACTIVE_DISPOSED;
-  let child = zombie ? node._pendingFirstChild : node._firstChild;
-  while (child) {
-    const nextChild = child._nextSibling;
-    if (child._deps) {
-      const n = child;
-      deleteFromHeap(n, n._flags & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
-      let toRemove = n._deps;
-      do {
-        toRemove = unlinkSubs(toRemove);
-      } while (toRemove !== null);
-      n._deps = null;
-      n._depsTail = null;
-    }
-    disposeChildren(child, true);
-    child = nextChild;
-  }
-  if (zombie) {
-    node._pendingFirstChild = null;
-  } else {
-    node._firstChild = null;
-    node._childCount = 0;
-  }
-  runDisposal(node, zombie);
-}
-function runDisposal(node, zombie) {
-  let disposal = zombie ? node._pendingDisposal : node._disposal;
-  if (!disposal) return;
-  if (Array.isArray(disposal)) {
-    for (let i = 0; i < disposal.length; i++) {
-      const callable = disposal[i];
-      callable.call(callable);
-    }
-  } else {
-    disposal.call(disposal);
-  }
-  zombie ? (node._pendingDisposal = null) : (node._disposal = null);
-}
-function childId(owner, consume) {
-  let counter = owner;
-  while (counter._transparent && counter._parent) counter = counter._parent;
-  if (counter.id != null)
-    return formatId(counter.id, consume ? counter._childCount++ : counter._childCount);
-  throw new Error("Cannot get child id from owner without an id");
-}
-function getNextChildId(owner) {
-  return childId(owner, true);
-}
-function peekNextChildId(owner) {
-  return childId(owner, false);
-}
-function formatId(prefix, id) {
-  const num = id.toString(36),
-    len = num.length - 1;
-  return prefix + (len ? String.fromCharCode(64 + len) : "") + num;
-}
-function getObserver() {
-  if (pendingCheckActive || latestReadActive) return PENDING_OWNER;
-  return tracking ? context : null;
-}
-function getOwner() {
-  return context;
-}
-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];
-  return fn;
-}
-function isDisposed(node) {
-  return !!(node._flags & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE));
-}
-function createOwner(options) {
-  const parent = context;
-  const transparent = options?.transparent ?? false;
-  const owner = {
-    id:
-      options?.id ??
-      (transparent ? parent?.id : parent?.id != null ? getNextChildId(parent) : undefined),
-    _transparent: transparent || undefined,
-    _root: true,
-    _parentComputed: parent?._root ? parent._parentComputed : parent,
-    _firstChild: null,
-    _nextSibling: null,
-    _disposal: null,
-    _queue: parent?._queue ?? globalQueue,
-    _context: parent?._context || defaultContext,
-    _childCount: 0,
-    _pendingDisposal: null,
-    _pendingFirstChild: null,
-    _parent: parent,
-    dispose(self = true) {
-      disposeChildren(owner, self);
-    }
-  };
-  if (parent?._childrenForbidden) {
-    throw new Error(
-      "Cannot create reactive primitives inside createTrackedEffect or owner-backed onSettled"
-    );
-  }
-  if (parent) {
-    const lastChild = parent._firstChild;
-    if (lastChild === null) {
-      parent._firstChild = owner;
-    } else {
-      owner._nextSibling = lastChild;
-      parent._firstChild = owner;
-    }
-  }
-  return owner;
-}
-function createRoot(init, options) {
-  const owner = createOwner(options);
-  return runWithOwner(owner, () => init(owner.dispose));
-}
-function unlinkSubs(link) {
-  const dep = link._dep;
-  const nextDep = link._nextDep;
-  const nextSub = link._nextSub;
-  const prevSub = link._prevSub;
-  if (nextSub !== null) nextSub._prevSub = prevSub;
-  else dep._subsTail = prevSub;
-  if (prevSub !== null) prevSub._nextSub = nextSub;
-  else {
-    dep._subs = nextSub;
-    if (nextSub === null) {
-      dep._unobserved?.();
-      dep._fn && !dep._preventAutoDisposal && !(dep._flags & REACTIVE_ZOMBIE) && unobserved(dep);
-    }
-  }
-  return nextDep;
-}
-function unobserved(el) {
-  deleteFromHeap(el, el._flags & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
-  let dep = el._deps;
-  while (dep !== null) {
-    dep = unlinkSubs(dep);
-  }
-  el._deps = null;
-  disposeChildren(el, true);
-}
-function link(dep, sub) {
-  const prevDep = sub._depsTail;
-  if (prevDep !== null && prevDep._dep === dep) return;
-  let nextDep = null;
-  const isRecomputing = sub._flags & REACTIVE_RECOMPUTING_DEPS;
-  if (isRecomputing) {
-    nextDep = prevDep !== null ? prevDep._nextDep : sub._deps;
-    if (nextDep !== null && nextDep._dep === dep) {
-      sub._depsTail = nextDep;
-      return;
-    }
-  }
-  const prevSub = dep._subsTail;
-  if (prevSub !== null && prevSub._sub === sub && (!isRecomputing || isValidLink(prevSub, sub)))
-    return;
-  const newLink =
-    (sub._depsTail =
-    dep._subsTail =
-      { _dep: dep, _sub: sub, _nextDep: nextDep, _prevSub: prevSub, _nextSub: null });
-  if (prevDep !== null) prevDep._nextDep = newLink;
-  else sub._deps = newLink;
-  if (prevSub !== null) prevSub._nextSub = newLink;
-  else dep._subs = newLink;
-}
-function isValidLink(checkLink, sub) {
-  const depsTail = sub._depsTail;
-  if (depsTail !== null) {
-    let link = sub._deps;
-    do {
-      if (link === checkLink) return true;
-      if (link === depsTail) break;
-      link = link._nextDep;
-    } while (link !== null);
-  }
-  return false;
-}
 GlobalQueue._update = recompute;
 GlobalQueue._dispose = disposeChildren;
 let tracking = false;
@@ -1199,6 +1231,7 @@ function recompute(el, create = false) {
     if (el._transition && (!isEffect || activeTransition) && activeTransition !== el._transition)
       globalQueue.initTransition(el._transition);
     deleteFromHeap(el, el._flags & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
+    el._inFlight = null;
     if (el._transition || isEffect === EFFECT_TRACKED) disposeChildren(el);
     else {
       markDisposal(el);
@@ -1503,6 +1536,11 @@ function read(el) {
       ) {
         foundPending = true;
       }
+      let c = context;
+      if (c?._root) c = c._parentComputed;
+      if (c && tracking) link(el, c);
+      read(getPendingSignal(el));
+      read(getPendingSignal(firewall));
     } else {
       if (read(getPendingSignal(el))) foundPending = true;
       if (firewall && read(getPendingSignal(firewall))) foundPending = true;
@@ -1559,6 +1597,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;
     }
@@ -1874,7 +1915,13 @@ function runEffect() {
   this._cleanup?.();
   this._cleanup = undefined;
   try {
-    this._cleanup = this._effectFn(this._value, this._prevValue);
+    const cleanup = this._effectFn(this._value, this._prevValue);
+    if (true && cleanup !== undefined && typeof cleanup !== "function") {
+      throw new Error(
+        `${this._name || "effect"} callback returned an invalid cleanup value. Return a cleanup function or undefined.`
+      );
+    }
+    this._cleanup = cleanup;
   } catch (error) {
     this._error = new StatusError(this, error);
     this._statusFlags |= STATUS_ERROR;
@@ -1888,14 +1935,25 @@ 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(
     () => {
       node._cleanup?.();
       node._cleanup = undefined;
-      node._cleanup = staleValues(fn) || undefined;
+      const cleanup = staleValues(fn);
+      if (cleanup !== undefined && typeof cleanup !== "function") {
+        throw new Error(
+          `${node._name || "trackedEffect"} callback returned an invalid cleanup value. Return a cleanup function or undefined.`
+        );
+      }
+      node._cleanup = cleanup;
     },
     undefined,
     { ...options, lazy: true }
@@ -2015,7 +2073,13 @@ function createReaction(effectFn, options) {
         () => (tracking(), getOwner()),
         node => {
           cl?.();
-          cl = (effectFn.effect || effectFn)?.();
+          const cleanup = (effectFn.effect || effectFn)?.();
+          if (true && cleanup !== undefined && typeof cleanup !== "function") {
+            throw new Error(
+              "Reaction callback returned an invalid cleanup value. Return a cleanup function or undefined."
+            );
+          }
+          cl = cleanup;
           dispose(node);
         },
         effectFn.error,
@@ -2055,9 +2119,14 @@ function createOptimistic(first, second, third) {
 function onSettled(callback) {
   const owner = getOwner();
   owner && !owner._childrenForbidden
-    ? createTrackedEffect(() => untrack(callback))
+    ? createTrackedEffect(() => untrack(callback), { name: "onSettled" })
     : globalQueue.enqueue(EFFECT_USER, () => {
         const cleanup = callback();
+        if (cleanup !== undefined && typeof cleanup !== "function") {
+          throw new Error(
+            "onSettled callback returned an invalid cleanup value. Return a cleanup function or undefined."
+          );
+        }
         cleanup?.();
       });
 }