@solidjs/signals 0.13.10 → 0.13.12

package/dist/dev.js

@@ -145,21 +145,53 @@ function adjustHeight(el, heap) {
   }
 }
 const hooks = {};
-const DEV = {
+const diagnosticListeners = new Set();
+const diagnosticCaptures = new Set();
+let diagnosticSequence = 0;
+const diagnostics = {
+  subscribe(listener) {
+    diagnosticListeners.add(listener);
+    return () => diagnosticListeners.delete(listener);
+  },
+  capture() {
+    const events = [];
+    diagnosticCaptures.add(events);
+    return {
+      get events() {
+        return events;
+      },
+      clear() {
+        events.length = 0;
+      },
+      stop() {
+        diagnosticCaptures.delete(events);
+        return [...events];
+      }
+    };
+  }
+};
+const DEV$1 = {
   hooks: hooks,
+  diagnostics: diagnostics,
   getChildren: getChildren,
   getSignals: getSignals,
   getParent: getParent,
   getSources: getSources,
   getObservers: getObservers
 };
+function emitDiagnostic(event) {
+  const entry = { sequence: ++diagnosticSequence, ...event };
+  for (const listener of diagnosticListeners) listener(entry);
+  for (const capture of diagnosticCaptures) capture.push(entry);
+  return entry;
+}
 function registerGraph(value, owner) {
   value._owner = owner;
   if (owner) {
     if (!owner._signals) owner._signals = [];
     owner._signals.push(value);
   }
-  DEV.hooks.onGraph?.(value, owner);
+  DEV$1.hooks.onGraph?.(value, owner);
 }
 function clearSignals(node) {
   node._signals = undefined;
@@ -252,13 +284,13 @@ function setTrackedQueueCallback(value) {
 function mergeTransitionState(target, outgoing) {
   outgoing._done = target;
   target._actions.push(...outgoing._actions);
-  for (const lane of activeLanes) {
-    if (lane._transition === outgoing) lane._transition = target;
-  }
+  for (const lane of activeLanes) if (lane._transition === outgoing) lane._transition = target;
   target._optimisticNodes.push(...outgoing._optimisticNodes);
   for (const store of outgoing._optimisticStores) target._optimisticStores.add(store);
-  for (const node of outgoing._asyncNodes) {
-    if (!target._asyncNodes.includes(node)) target._asyncNodes.push(node);
+  for (const [source, reporters] of outgoing._asyncReporters) {
+    let targetReporters = target._asyncReporters.get(source);
+    if (!targetReporters) target._asyncReporters.set(source, (targetReporters = new Set()));
+    for (const reporter of reporters) targetReporters.add(reporter);
   }
 }
 function resolveOptimisticNodes(nodes) {
@@ -424,7 +456,7 @@ class GlobalQueue extends Queue {
       this.run(EFFECT_RENDER);
       runLaneEffects(EFFECT_USER);
       this.run(EFFECT_USER);
-      if (true) DEV.hooks.onUpdate?.();
+      if (true) DEV$1.hooks.onUpdate?.();
     } finally {
       this._running = false;
     }
@@ -435,10 +467,11 @@ class GlobalQueue extends Queue {
         const actualError = error !== undefined ? error : node._error;
         if (activeTransition && actualError) {
           const source = actualError.source;
-          if (!activeTransition._asyncNodes.includes(source)) {
-            activeTransition._asyncNodes.push(source);
-            schedule();
-          }
+          let reporters = activeTransition._asyncReporters.get(source);
+          if (!reporters) activeTransition._asyncReporters.set(source, (reporters = new Set()));
+          const prevSize = reporters.size;
+          reporters.add(node);
+          if (reporters.size !== prevSize) schedule();
         }
         if (_enforceLoadingBoundary) _hitUnhandledAsync = true;
       }
@@ -454,7 +487,7 @@ class GlobalQueue extends Queue {
       activeTransition = transition ?? {
         _time: clock,
         _pendingNodes: [],
-        _asyncNodes: [],
+        _asyncReporters: new Map(),
         _optimisticNodes: [],
         _optimisticStores: new Set(),
         _actions: [],
@@ -593,13 +626,37 @@ function flush() {
 function runQueue(queue, type) {
   for (let i = 0; i < queue.length; i++) queue[i](type);
 }
+function reporterBlocksSource(reporter, source) {
+  if (reporter._flags & (REACTIVE_ZOMBIE | REACTIVE_DISPOSED)) return false;
+  if (reporter._pendingSource === source || reporter._pendingSources?.has(source)) return true;
+  for (let dep = reporter._deps; dep; dep = dep._nextDep) {
+    let current = dep._dep;
+    while (current) {
+      if (current === source || current._firewall === source) return true;
+      current = current._parentSource;
+    }
+  }
+  return !!(
+    reporter._statusFlags & STATUS_PENDING &&
+    reporter._error instanceof NotReadyError &&
+    reporter._error.source === source
+  );
+}
 function transitionComplete(transition) {
   if (transition._done) return true;
   if (transition._actions.length) return false;
   let done = true;
-  for (let i = 0; i < transition._asyncNodes.length; i++) {
-    const node = transition._asyncNodes[i];
-    if (node._statusFlags & STATUS_PENDING && node._error?.source === node) {
+  for (const [source, reporters] of transition._asyncReporters) {
+    let hasLive = false;
+    for (const reporter of reporters) {
+      if (reporterBlocksSource(reporter, source)) {
+        hasLive = true;
+        break;
+      }
+      reporters.delete(reporter);
+    }
+    if (!hasLive) transition._asyncReporters.delete(source);
+    else if (source._statusFlags & STATUS_PENDING && source._error?.source === source) {
       done = false;
       break;
     }
@@ -907,7 +964,7 @@ function createOwner(options) {
       parent._firstChild = owner;
     }
   }
-  DEV.hooks.onOwner?.(owner);
+  DEV$1.hooks.onOwner?.(owner);
   return owner;
 }
 function createRoot(init, options) {
@@ -1473,7 +1530,7 @@ function computed(fn, initialValue, options) {
       context._firstChild = self;
     }
   }
-  DEV.hooks.onOwner?.(self);
+  DEV$1.hooks.onOwner?.(self);
   if (parent) self._height = parent._height + 1;
   if (snapshotCaptureActive && ownerInSnapshotScope(context)) self._inSnapshotScope = true;
   if (externalSourceConfig) {
@@ -1618,10 +1675,20 @@ function read(el) {
   }
   const owner = el._firewall || el;
   if (strictRead && owner._statusFlags & STATUS_PENDING) {
-    throw new Error(
+    const message =
       `Reading a pending async value directly in ${strictRead}. ` +
-        `Async values must be read within a tracking scope (JSX, a memo, or an effect's compute function).`
-    );
+      `Async values must be read within a tracking scope (JSX, a memo, or an effect's compute function).`;
+    emitDiagnostic({
+      code: "PENDING_ASYNC_UNTRACKED_READ",
+      kind: "async",
+      severity: "error",
+      message: message,
+      ownerId: c?.id,
+      ownerName: c?._name,
+      nodeName: owner?._name,
+      data: { strictRead: strictRead }
+    });
+    throw new Error(message);
   }
   if (c && tracking) {
     if (el._fn && el._flags & REACTIVE_DISPOSED) recompute(el);
@@ -1642,10 +1709,19 @@ function read(el) {
   if (owner._statusFlags & STATUS_PENDING) {
     if (c && !(stale && owner._transition && activeTransition !== owner._transition)) {
       if (c?._childrenForbidden) {
-        console.warn(
+        const message =
           "Reading a pending async value inside createTrackedEffect or onSettled will throw. " +
-            "Use createEffect instead which supports async-aware reactivity."
-        );
+          "Use createEffect instead which supports async-aware reactivity.";
+        emitDiagnostic({
+          code: "PENDING_ASYNC_FORBIDDEN_SCOPE",
+          kind: "async",
+          severity: "warn",
+          message: message,
+          ownerId: c.id,
+          ownerName: c._name,
+          nodeName: owner?._name
+        });
+        console.warn(message);
       }
       if (currentOptimisticLane) {
         const pendingLane = owner._optimisticLane;
@@ -1680,11 +1756,22 @@ function read(el) {
       return snapshot;
     }
   }
-  if (strictRead)
-    console.warn(
+  if (strictRead) {
+    const message =
       `Reactive value read directly in ${strictRead} will not update. ` +
-        `Move it into a tracking scope (JSX, a memo, or an effect's compute function).`
-    );
+      `Move it into a tracking scope (JSX, a memo, or an effect's compute function).`;
+    emitDiagnostic({
+      code: "STRICT_READ_UNTRACKED",
+      kind: "strict-read",
+      severity: "warn",
+      message: message,
+      ownerId: c?.id,
+      ownerName: c?._name,
+      nodeName: owner?._name,
+      data: { strictRead: strictRead }
+    });
+    console.warn(message);
+  }
   if (el._overrideValue !== undefined && el._overrideValue !== NOT_PENDING) {
     if (c && stale && shouldReadStashedOptimisticValue(el)) return el._value;
     return el._overrideValue;
@@ -1701,8 +1788,21 @@ function read(el) {
     : el._pendingValue;
 }
 function setSignal(el, v) {
-  if (!el._pureWrite && !context?._childrenForbidden && context && el._firewall !== context)
-    console.warn("A Signal was written to in an owned scope.");
+  if (!el._pureWrite && !context?._childrenForbidden && context && el._firewall !== context) {
+    const message =
+      "Writing to a Signal inside an owned scope (component, computation) is not allowed. " +
+      "Move the write outside or set the `pureWrite` option if this is intentional.";
+    emitDiagnostic({
+      code: "SIGNAL_WRITE_IN_OWNED_SCOPE",
+      kind: "write",
+      severity: "error",
+      message: message,
+      ownerId: context.id,
+      ownerName: context._name,
+      nodeName: el._name
+    });
+    throw new Error(message);
+  }
   if (el._transition && activeTransition !== el._transition)
     globalQueue.initTransition(el._transition);
   const isOptimistic = el._overrideValue !== undefined && !projectionWriteActive;
@@ -1749,10 +1849,19 @@ function setSignal(el, v) {
   return v;
 }
 function runWithOwner(owner, fn) {
-  if (owner && owner._flags & REACTIVE_DISPOSED)
-    console.warn(
-      "runWithOwner called with a disposed owner. Children created inside will never be disposed."
-    );
+  if (owner && owner._flags & REACTIVE_DISPOSED) {
+    const message =
+      "runWithOwner called with a disposed owner. Children created inside will never be disposed.";
+    emitDiagnostic({
+      code: "RUN_WITH_DISPOSED_OWNER",
+      kind: "owner",
+      severity: "warn",
+      message: message,
+      ownerId: owner.id,
+      ownerName: owner._name
+    });
+    console.warn(message);
+  }
   const oldContext = context;
   const prevTracking = tracking;
   context = owner;
@@ -1953,6 +2062,14 @@ function effect(compute, effect, error, initialValue, options) {
       if (_hitUnhandledAsync) {
         resetUnhandledAsync();
         const err = new Error("An async value must be rendered inside a Loading boundary.");
+        emitDiagnostic({
+          code: "ASYNC_OUTSIDE_LOADING_BOUNDARY",
+          kind: "async",
+          severity: "error",
+          message: err.message,
+          ownerId: node.id,
+          ownerName: node._name
+        });
         if (!node._queue.notify(node, STATUS_ERROR, STATUS_ERROR)) throw err;
       }
     }
@@ -1964,8 +2081,19 @@ function effect(compute, effect, error, initialValue, options) {
       : runEffect.call(node));
   initialized = true;
   cleanup(() => node._cleanup?.());
-  if (!node._parent)
-    console.warn("Effects created outside a reactive context will never be disposed");
+  if (!node._parent) {
+    const message = "Effects created outside a reactive context will never be disposed";
+    emitDiagnostic({
+      code: "NO_OWNER_EFFECT",
+      kind: "lifecycle",
+      severity: "warn",
+      message: message,
+      ownerId: node.id,
+      ownerName: node._name,
+      data: { effectType: "effect" }
+    });
+    console.warn(message);
+  }
 }
 function runEffect() {
   if (!this._modified || this._flags & REACTIVE_DISPOSED) return;
@@ -2034,8 +2162,19 @@ function trackedEffect(fn, options) {
   node._run = run;
   node._queue.enqueue(EFFECT_USER, run);
   cleanup(() => node._cleanup?.());
-  if (!node._parent)
-    console.warn("Effects created outside a reactive context will never be disposed");
+  if (!node._parent) {
+    const message = "Effects created outside a reactive context will never be disposed";
+    emitDiagnostic({
+      code: "NO_OWNER_EFFECT",
+      kind: "lifecycle",
+      severity: "warn",
+      message: message,
+      ownerId: node.id,
+      ownerName: node._name,
+      data: { effectType: "trackedEffect" }
+    });
+    console.warn(message);
+  }
 }
 function restoreTransition(transition, fn) {
   globalQueue.initTransition(transition);
@@ -2084,11 +2223,28 @@ function action(genFn) {
 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"
-      );
+    if (!owner) {
+      const message = "onCleanup called outside a reactive context will never be run";
+      emitDiagnostic({
+        code: "NO_OWNER_CLEANUP",
+        kind: "lifecycle",
+        severity: "warn",
+        message: message
+      });
+      console.warn(message);
+    } else if (owner._childrenForbidden) {
+      const message =
+        "Cannot use onCleanup inside createTrackedEffect or onSettled; return a cleanup function instead";
+      emitDiagnostic({
+        code: "CLEANUP_IN_FORBIDDEN_SCOPE",
+        kind: "lifecycle",
+        severity: "error",
+        message: message,
+        ownerId: owner.id,
+        ownerName: owner._name
+      });
+      throw new Error(message);
+    }
   }
   return cleanup(fn);
 }
@@ -2610,11 +2766,20 @@ const storeTraps = {
         );
       }
     }
-    if (strictRead && typeof property === "string")
-      console.warn(
+    if (strictRead && typeof property === "string") {
+      const message =
         `Reactive value read directly in ${strictRead} will not update. ` +
-          `Move it into a tracking scope (JSX, a memo, or an effect's compute function).`
-      );
+        `Move it into a tracking scope (JSX, a memo, or an effect's compute function).`;
+      emitDiagnostic({
+        code: "STRICT_READ_UNTRACKED",
+        kind: "strict-read",
+        severity: "warn",
+        message: message,
+        nodeName: String(property),
+        data: { strictRead: strictRead, property: String(property), source: "store" }
+      });
+      console.warn(message);
+    }
     return isWrappable(value) ? wrap(value, target) : value;
   },
   has(target, property) {
@@ -2703,7 +2868,7 @@ const storeTraps = {
           lengthValue !== undefined && nodes.length && setSignal(nodes.length, lengthValue);
         }
         nodes[$TRACK] && setSignal(nodes[$TRACK], undefined);
-        if (true) DEV.hooks.onStoreNodeUpdate?.(target[$PROXY], property, value, prev);
+        if (true) DEV$1.hooks.onStoreNodeUpdate?.(target[$PROXY], property, value, prev);
       });
     }
     return true;
@@ -3577,8 +3742,17 @@ class CollectionQueue extends Queue {
   }
 }
 function createCollectionBoundary(type, fn, fallback, onFn) {
-  if (!getOwner())
-    console.warn("Boundaries created outside a reactive context will never be disposed.");
+  if (!getOwner()) {
+    const message = "Boundaries created outside a reactive context will never be disposed.";
+    emitDiagnostic({
+      code: "NO_OWNER_BOUNDARY",
+      kind: "lifecycle",
+      severity: "warn",
+      message: message,
+      data: { boundaryType: type === STATUS_PENDING ? "loading" : "error" }
+    });
+    console.warn(message);
+  }
   const owner = createOwner();
   if (_revealUsed) setContext(RevealControllerContext, null, owner);
   const queue = new CollectionQueue(type);
@@ -3704,6 +3878,7 @@ function flattenArray(children, results = [], options) {
   if (notReady) throw notReady;
   return needsUnwrap;
 }
+const DEV = DEV$1;
 export {
   $PROXY,
   $REFRESH,