@solidjs/signals 0.10.3 → 0.10.5

package/dist/dev.js

@@ -717,100 +717,67 @@ function notifyStatus(el, status, error, blockStatus, lane) {
     }
   }
 }
-let leafEffectActive = false;
-function effect(compute, effect, error, initialValue, options) {
-  let initialized = false;
-  const node = computed(
-    options?.render ? p => staleValues(() => compute(p)) : compute,
-    initialValue,
-    {
-      ...options,
-      equals: () => {
-        node._modified = !node._error;
-        if (initialized) node._queue.enqueue(node._type, runEffect.bind(node));
-        return false;
-      },
-      lazy: true
+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);
     }
-  );
-  node._prevValue = initialValue;
-  node._effectFn = effect;
-  node._errorFn = error;
-  node._cleanup = undefined;
-  node._type = options?.render ? EFFECT_RENDER : EFFECT_USER;
-  node._notifyStatus = (status, error) => {
-    const actualStatus = status !== undefined ? status : node._statusFlags;
-    const actualError = error !== undefined ? error : node._error;
-    if (actualStatus & STATUS_ERROR) {
-      let err = actualError;
-      node._queue.notify(node, STATUS_PENDING, 0);
-      if (node._type === EFFECT_USER) {
-        try {
-          return node._errorFn
-            ? node._errorFn(err, () => {
-                node._cleanup?.();
-                node._cleanup = undefined;
-              })
-            : console.error(err);
-        } catch (e) {
-          err = e;
-        }
-      }
-      if (!node._queue.notify(node, STATUS_ERROR, STATUS_ERROR)) throw err;
-    } else if (node._type === EFFECT_RENDER)
-      node._queue.notify(node, STATUS_PENDING | STATUS_ERROR, actualStatus, actualError);
-  };
-  recompute(node, true);
-  !options?.defer &&
-    (node._type === EFFECT_USER
-      ? node._queue.enqueue(node._type, runEffect.bind(node))
-      : runEffect.call(node));
-  initialized = true;
-  onCleanup(() => node._cleanup?.());
-  if (!node._parent)
-    console.warn("Effects created outside a reactive context will never be disposed");
+  }
+  return nextDep;
 }
-function runEffect() {
-  if (!this._modified || this._flags & REACTIVE_DISPOSED) return;
-  this._cleanup?.();
-  this._cleanup = undefined;
-  try {
-    this._cleanup = this._effectFn(this._value, this._prevValue);
-  } catch (error) {
-    if (!this._queue.notify(this, STATUS_ERROR, STATUS_ERROR)) throw error;
-  } finally {
-    this._prevValue = this._value;
-    this._modified = false;
+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 trackedEffect(fn, options) {
-  const run = () => {
-    if (!node._modified || node._flags & REACTIVE_DISPOSED) return;
-    node._modified = false;
-    recompute(node);
-  };
-  const node = computed(
-    () => {
-      leafEffectActive = true;
-      try {
-        node._cleanup?.();
-        node._cleanup = undefined;
-        node._cleanup = staleValues(fn) || undefined;
-      } finally {
-        leafEffectActive = false;
-      }
-    },
-    undefined,
-    { ...options, lazy: true, pureWrite: true }
-  );
-  node._cleanup = undefined;
-  node._modified = true;
-  node._type = EFFECT_TRACKED;
-  node._run = run;
-  node._queue.enqueue(EFFECT_USER, run);
-  onCleanup(() => node._cleanup?.());
-  if (!node._parent)
-    console.warn("Effects created outside a reactive context will never be disposed");
+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) {
@@ -875,12 +842,19 @@ function runDisposal(node, zombie) {
   }
   zombie ? (node._pendingDisposal = null) : (node._disposal = null);
 }
-function getNextChildId(owner) {
+function childId(owner, consume) {
   let counter = owner;
   while (counter._transparent && counter._parent) counter = counter._parent;
-  if (counter.id != null) return formatId(counter.id, counter._childCount++);
+  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;
@@ -941,67 +915,100 @@ 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 && unobserved(dep);
+let leafEffectActive = false;
+function effect(compute, effect, error, initialValue, options) {
+  let initialized = false;
+  const node = computed(
+    options?.render ? p => staleValues(() => compute(p)) : compute,
+    initialValue,
+    {
+      ...options,
+      equals: () => {
+        node._modified = !node._error;
+        if (initialized) node._queue.enqueue(node._type, runEffect.bind(node));
+        return false;
+      },
+      lazy: true
     }
-  }
-  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);
+  );
+  node._prevValue = initialValue;
+  node._effectFn = effect;
+  node._errorFn = error;
+  node._cleanup = undefined;
+  node._type = options?.render ? EFFECT_RENDER : EFFECT_USER;
+  node._notifyStatus = (status, error) => {
+    const actualStatus = status !== undefined ? status : node._statusFlags;
+    const actualError = error !== undefined ? error : node._error;
+    if (actualStatus & STATUS_ERROR) {
+      let err = actualError;
+      node._queue.notify(node, STATUS_PENDING, 0);
+      if (node._type === EFFECT_USER) {
+        try {
+          return node._errorFn
+            ? node._errorFn(err, () => {
+                node._cleanup?.();
+                node._cleanup = undefined;
+              })
+            : console.error(err);
+        } catch (e) {
+          err = e;
+        }
+      }
+      if (!node._queue.notify(node, STATUS_ERROR, STATUS_ERROR)) throw err;
+    } else if (node._type === EFFECT_RENDER)
+      node._queue.notify(node, STATUS_PENDING | STATUS_ERROR, actualStatus, actualError);
+  };
+  recompute(node, true);
+  !options?.defer &&
+    (node._type === EFFECT_USER
+      ? node._queue.enqueue(node._type, runEffect.bind(node))
+      : runEffect.call(node));
+  initialized = true;
+  onCleanup(() => node._cleanup?.());
+  if (!node._parent)
+    console.warn("Effects created outside a reactive context will never be disposed");
 }
-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;
-    }
+function runEffect() {
+  if (!this._modified || this._flags & REACTIVE_DISPOSED) return;
+  this._cleanup?.();
+  this._cleanup = undefined;
+  try {
+    this._cleanup = this._effectFn(this._value, this._prevValue);
+  } catch (error) {
+    if (!this._queue.notify(this, STATUS_ERROR, STATUS_ERROR)) throw error;
+  } finally {
+    this._prevValue = this._value;
+    this._modified = false;
   }
-  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;
+function trackedEffect(fn, options) {
+  const run = () => {
+    if (!node._modified || node._flags & REACTIVE_DISPOSED) return;
+    node._modified = false;
+    recompute(node);
+  };
+  const node = computed(
+    () => {
+      leafEffectActive = true;
+      try {
+        node._cleanup?.();
+        node._cleanup = undefined;
+        node._cleanup = staleValues(fn) || undefined;
+      } finally {
+        leafEffectActive = false;
+      }
+    },
+    undefined,
+    { ...options, lazy: true, pureWrite: true }
+  );
+  node._cleanup = undefined;
+  node._modified = true;
+  node._type = EFFECT_TRACKED;
+  node._run = run;
+  node._queue.enqueue(EFFECT_USER, run);
+  onCleanup(() => node._cleanup?.());
+  if (!node._parent)
+    console.warn("Effects created outside a reactive context will never be disposed");
 }
 GlobalQueue._update = recompute;
 GlobalQueue._dispose = disposeChildren;
@@ -2902,6 +2909,7 @@ export {
   omit,
   onCleanup,
   onSettled,
+  peekNextChildId,
   pending,
   reconcile,
   refresh,