@solidjs/signals 0.13.8 → 0.13.10

package/dist/dev.js

@@ -144,6 +144,59 @@ function adjustHeight(el, heap) {
     }
   }
 }
+const hooks = {};
+const DEV = {
+  hooks: hooks,
+  getChildren: getChildren,
+  getSignals: getSignals,
+  getParent: getParent,
+  getSources: getSources,
+  getObservers: getObservers
+};
+function registerGraph(value, owner) {
+  value._owner = owner;
+  if (owner) {
+    if (!owner._signals) owner._signals = [];
+    owner._signals.push(value);
+  }
+  DEV.hooks.onGraph?.(value, owner);
+}
+function clearSignals(node) {
+  node._signals = undefined;
+}
+function getChildren(owner) {
+  const children = [];
+  let child = owner._firstChild;
+  while (child) {
+    children.push(child);
+    child = child._nextSibling;
+  }
+  return children;
+}
+function getSignals(owner) {
+  return owner._signals ? [...owner._signals] : [];
+}
+function getParent(owner) {
+  return owner._parent;
+}
+function getSources(computation) {
+  const sources = [];
+  let link = computation._deps;
+  while (link) {
+    sources.push(link._dep);
+    link = link._nextDep;
+  }
+  return sources;
+}
+function getObservers(node) {
+  const observers = [];
+  let link = node._subs;
+  while (link) {
+    observers.push(link._sub);
+    link = link._nextSub;
+  }
+  return observers;
+}
 const transitions = new Set();
 const dirtyQueue = { _heap: new Array(2e3).fill(undefined), _marked: false, _min: 0, _max: 0 };
 const zombieQueue = { _heap: new Array(2e3).fill(undefined), _marked: false, _min: 0, _max: 0 };
@@ -371,6 +424,7 @@ class GlobalQueue extends Queue {
       this.run(EFFECT_RENDER);
       runLaneEffects(EFFECT_USER);
       this.run(EFFECT_USER);
+      if (true) DEV.hooks.onUpdate?.();
     } finally {
       this._running = false;
     }
@@ -742,6 +796,7 @@ function dispose(node) {
 function disposeChildren(node, self = false, zombie) {
   if (node._flags & REACTIVE_DISPOSED) return;
   if (self) node._flags = REACTIVE_DISPOSED;
+  if (self && true) clearSignals(node);
   if (self && node._fn) node._inFlight = null;
   let child = zombie ? node._pendingFirstChild : node._firstChild;
   while (child) {
@@ -852,6 +907,7 @@ function createOwner(options) {
       parent._firstChild = owner;
     }
   }
+  DEV.hooks.onOwner?.(owner);
   return owner;
 }
 function createRoot(init, options) {
@@ -1240,6 +1296,7 @@ function recompute(el, create = false) {
       el._disposal = null;
       el._firstChild = null;
       el._childCount = 0;
+      clearSignals(el);
     }
   }
   const isOptimisticDirty = !!(el._flags & REACTIVE_OPTIMISTIC_DIRTY);
@@ -1361,7 +1418,7 @@ function updateIfNecessary(el) {
   ) {
     recompute(el);
   }
-  el._flags = REACTIVE_NONE | (el._flags & REACTIVE_SNAPSHOT_STALE);
+  el._flags = el._flags & (REACTIVE_SNAPSHOT_STALE | REACTIVE_IN_HEAP | REACTIVE_IN_HEAP_HEIGHT);
 }
 function computed(fn, initialValue, options) {
   const transparent = options?.transparent ?? false;
@@ -1416,6 +1473,7 @@ function computed(fn, initialValue, options) {
       context._firstChild = self;
     }
   }
+  DEV.hooks.onOwner?.(self);
   if (parent) self._height = parent._height + 1;
   if (snapshotCaptureActive && ownerInSnapshotScope(context)) self._inSnapshotScope = true;
   if (externalSourceConfig) {
@@ -1452,7 +1510,10 @@ function signal(v, options, firewall = null) {
     _nextChild: firewall?._child || null,
     _pendingValue: NOT_PENDING
   };
-  s._name = options?.name ?? "signal";
+  {
+    s._name = options?.name ?? "signal";
+    s._internal = !!firewall;
+  }
   firewall && (firewall._child = s);
   if (
     snapshotCaptureActive &&
@@ -1606,7 +1667,7 @@ function read(el) {
   }
   if (el._fn && el._statusFlags & STATUS_ERROR) {
     if (el._time < clock) {
-      recompute(el, true);
+      recompute(el);
       return read(el);
     } else throw el._error;
   }
@@ -2042,6 +2103,7 @@ function createSignal(first, second, third) {
     return [accessor(node), setSignal.bind(null, node)];
   }
   const node = signal(first, second);
+  registerGraph(node, getOwner());
   return [accessor(node), setSignal.bind(null, node)];
 }
 function createMemo(compute, value, options) {
@@ -2110,10 +2172,12 @@ function resolve(fn) {
   });
 }
 function createOptimistic(first, second, third) {
-  const node =
-    typeof first === "function"
-      ? optimisticComputed(first, second, third)
-      : optimisticSignal(first, second);
+  if (typeof first === "function") {
+    const node = optimisticComputed(first, second, third);
+    return [accessor(node), setSignal.bind(null, node)];
+  }
+  const node = optimisticSignal(first, second);
+  registerGraph(node, getOwner());
   return [accessor(node), setSignal.bind(null, node)];
 }
 function onSettled(callback) {
@@ -2639,6 +2703,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);
       });
     }
     return true;
@@ -2733,6 +2798,7 @@ function storeSetter(store, fn) {
 function createStore(first, second, options) {
   const derived = typeof first === "function",
     wrappedStore = derived ? createProjectionInternal(first, second, options).store : wrap(first);
+  registerGraph(wrappedStore, getOwner());
   return [wrappedStore, fn => storeSetter(wrappedStore, fn)];
 }
 function createOptimisticStore(first, second, options) {
@@ -3340,10 +3406,100 @@ function createBoundChildren(owner, fn, queue, mask) {
   });
 }
 const ON_INIT = Symbol();
+const RevealControllerContext = createContext(null);
+let _revealUsed = false;
+const FALSE_ACCESSOR = () => false;
+function isRevealController(slot) {
+  return slot instanceof RevealController;
+}
+function isSlotReady(slot) {
+  return isRevealController(slot) ? slot.isReady() : slot._sources.size === 0 && !slot._pending;
+}
+function setSlotState(slot, controller, disabled, collapsed) {
+  setSignal(slot._disabled, disabled);
+  setSignal(slot._collapsed, collapsed);
+  if (isRevealController(slot)) {
+    if (!disabled && slot._parentController === controller) slot._parentController = undefined;
+    return slot.evaluate(disabled, collapsed);
+  }
+  if (!disabled && slot._revealController === controller && slot._initialized)
+    slot._revealController = undefined;
+}
+class RevealController {
+  _togetherAccessor;
+  _collapsedAccessor;
+  _slots = [];
+  _parentController;
+  _disabled = signal(false, { pureWrite: true, _noSnapshot: true });
+  _collapsed = signal(false, { pureWrite: true, _noSnapshot: true });
+  _ready = true;
+  _evaluating = false;
+  constructor(together, collapsed) {
+    this._togetherAccessor = together;
+    this._collapsedAccessor = collapsed;
+  }
+  _forEachOwnedSlot(fn) {
+    for (let i = 0; i < this._slots.length; i++) {
+      const slot = this._slots[i];
+      if ((isRevealController(slot) ? slot._parentController : slot._revealController) !== this)
+        continue;
+      if (fn(slot) === false) return false;
+    }
+    return true;
+  }
+  isReady() {
+    return this._forEachOwnedSlot(isSlotReady);
+  }
+  register(slot) {
+    if (this._slots.includes(slot)) return;
+    this._slots.push(slot);
+    const together = !!untrack(this._togetherAccessor);
+    setSignal(slot._disabled, true),
+      setSignal(slot._collapsed, together ? false : !!untrack(this._collapsedAccessor));
+    untrack(() => this.evaluate());
+  }
+  unregister(slot) {
+    const index = this._slots.indexOf(slot);
+    if (index >= 0) this._slots.splice(index, 1);
+    untrack(() => this.evaluate());
+  }
+  evaluate(disabledOverride, collapsedOverride) {
+    if (this._evaluating) return;
+    this._evaluating = true;
+    const wasReady = this._ready;
+    try {
+      const disabled = disabledOverride ?? read(this._disabled),
+        collapseTail = !!untrack(this._collapsedAccessor),
+        collapsed = collapsedOverride ?? collapseTail;
+      if (disabled && collapsed)
+        this._forEachOwnedSlot(slot => setSlotState(slot, this, true, true));
+      else if (!!untrack(this._togetherAccessor)) {
+        const ready = this.isReady();
+        this._forEachOwnedSlot(slot => setSlotState(slot, this, !ready, false));
+      } else {
+        let pendingSeen = false;
+        this._forEachOwnedSlot(slot => {
+          if (pendingSeen) return setSlotState(slot, this, true, collapseTail);
+          if (isSlotReady(slot)) return setSlotState(slot, this, false, false);
+          pendingSeen = true;
+          setSlotState(slot, this, true, false);
+        });
+      }
+    } finally {
+      this._ready = this.isReady();
+      this._evaluating = false;
+    }
+    if (this._parentController && wasReady !== this._ready) this._parentController.evaluate();
+  }
+}
 class CollectionQueue extends Queue {
   _collectionType;
   _sources = new Set();
+  _tree;
+  _pending = true;
   _disabled = signal(false, { pureWrite: true, _noSnapshot: true });
+  _collapsed = signal(false, { pureWrite: true, _noSnapshot: true });
+  _revealController;
   _initialized = false;
   _onFn;
   _prevOn = ON_INIT;
@@ -3352,7 +3508,7 @@ class CollectionQueue extends Queue {
     this._collectionType = type;
   }
   run(type) {
-    if (!type || read(this._disabled)) return;
+    if (!type || (read(this._disabled) && (!_revealUsed || read(this._collapsed)))) return;
     return super.run(type);
   }
   notify(node, type, flags, error) {
@@ -3377,6 +3533,7 @@ class CollectionQueue extends Queue {
       return super.notify(node, STATUS_ERROR, flags, error);
     }
     if (flags & this._collectionType) {
+      this._pending = true;
       const source = error?.source || node._error?.source;
       if (source) {
         const wasEmpty = this._sources.size === 0;
@@ -3397,30 +3554,60 @@ class CollectionQueue extends Queue {
         this._sources.delete(source);
     }
     if (!this._sources.size) {
-      setSignal(this._disabled, false);
-      if (this._onFn) {
-        try {
-          this._prevOn = untrack(() => this._onFn());
-        } catch {}
+      if (
+        this._collectionType & STATUS_PENDING &&
+        this._pending &&
+        !this._initialized &&
+        this._tree
+      ) {
+        this._pending = !!(this._tree._statusFlags & this._collectionType);
+      } else {
+        this._pending = false;
+      }
+      if (!this._pending) {
+        setSignal(this._disabled, false);
+        if (this._onFn) {
+          try {
+            this._prevOn = untrack(() => this._onFn());
+          } catch {}
+        }
       }
     }
+    if (_revealUsed) this._revealController?.evaluate();
   }
 }
 function createCollectionBoundary(type, fn, fallback, onFn) {
   if (!getOwner())
     console.warn("Boundaries created outside a reactive context will never be disposed.");
   const owner = createOwner();
+  if (_revealUsed) setContext(RevealControllerContext, null, owner);
   const queue = new CollectionQueue(type);
   if (onFn) queue._onFn = onFn;
-  const tree = createBoundChildren(owner, fn, queue, type);
+  const tree = (queue._tree = createBoundChildren(owner, fn, queue, type));
+  untrack(() => {
+    let pending = false;
+    try {
+      read(tree);
+    } catch (e) {
+      if (e instanceof NotReadyError) pending = true;
+      else throw e;
+    }
+    queue._pending =
+      pending || !!(tree._statusFlags & type) || tree._error instanceof NotReadyError;
+  });
+  const controller =
+    _revealUsed && type === STATUS_PENDING ? getContext(RevealControllerContext) : null;
+  if (controller) {
+    queue._revealController = controller;
+    controller.register(queue);
+    cleanup(() => controller.unregister(queue));
+  }
   const decision = computed(() => {
     if (!read(queue._disabled)) {
       const resolved = read(tree);
-      if (!untrack(() => read(queue._disabled))) {
-        queue._initialized = true;
-        return resolved;
-      }
+      if (!untrack(() => read(queue._disabled))) return (queue._initialized = true), resolved;
     }
+    if (_revealUsed && read(queue._collapsed)) return undefined;
     return fallback(queue);
   });
   return accessor(decision);
@@ -3438,6 +3625,29 @@ function createErrorBoundary(fn, fallback) {
     });
   });
 }
+function createRevealOrder(fn, options) {
+  _revealUsed = true;
+  const owner = createOwner();
+  const parentController = getContext(RevealControllerContext);
+  const together = options?.together || FALSE_ACCESSOR,
+    collapsed = options?.collapsed || FALSE_ACCESSOR;
+  const controller = new RevealController(together, collapsed);
+  setContext(RevealControllerContext, controller, owner);
+  return runWithOwner(owner, () => {
+    const value = fn();
+    computed(() => {
+      together();
+      collapsed();
+      controller.evaluate();
+    });
+    if (parentController) {
+      controller._parentController = parentController;
+      parentController.register(controller);
+      cleanup(() => parentController.unregister(controller));
+    }
+    return value;
+  });
+}
 function flatten(children, options) {
   if (typeof children === "function" && !children.length) {
     if (options?.doNotUnwrap) return children;
@@ -3500,6 +3710,7 @@ export {
   $TARGET,
   $TRACK,
   ContextNotFoundError,
+  DEV,
   NoOwnerError,
   NotReadyError,
   SUPPORTS_PROXY,
@@ -3516,6 +3727,7 @@ export {
   createProjection,
   createReaction,
   createRenderEffect,
+  createRevealOrder,
   createRoot,
   createSignal,
   createStore,