@solidjs/signals 0.9.3 → 0.9.5

package/dist/dev.js

@@ -226,7 +226,8 @@ class GlobalQueue extends Queue {
           runOptimistic(t);
           return;
         }
-        this._pendingNodes.push(...activeTransition.pendingNodes);
+        this._pendingNodes !== activeTransition.pendingNodes &&
+          this._pendingNodes.push(...activeTransition.pendingNodes);
         this._optimisticNodes !== activeTransition.optimisticNodes &&
           this._optimisticNodes.push(...activeTransition.optimisticNodes);
         this.restoreQueues(activeTransition.queueStash);
@@ -255,10 +256,12 @@ class GlobalQueue extends Queue {
     }
     return false;
   }
-  initTransition(node) {
-    if (activeTransition && activeTransition.time === clock) return;
+  initTransition(transition) {
+    if (transition) transition = currentTransition(transition);
+    if (transition && transition === activeTransition) return;
+    if (!transition && activeTransition && activeTransition.time === clock) return;
     if (!activeTransition) {
-      activeTransition = node?._transition ?? {
+      activeTransition = transition ?? {
         time: clock,
         pendingNodes: [],
         asyncNodes: [],
@@ -267,6 +270,11 @@ class GlobalQueue extends Queue {
         queueStash: { _queues: [[], []], _children: [] },
         done: false
       };
+    } else if (transition) {
+      activeTransition.done = transition;
+      transition.actions.push(...activeTransition.actions);
+      transitions.delete(activeTransition);
+      activeTransition = transition;
     }
     transitions.add(activeTransition);
     activeTransition.time = clock;
@@ -333,7 +341,10 @@ function runTransitionPending(pendingNodes, value) {
   for (let i = 0; i < p.length; i++) {
     const n = p[i];
     n._transition = activeTransition;
-    if (n._pendingCheck) n._pendingCheck._set(value);
+    if (n._pendingCheck) {
+      n._pendingCheck._transition = activeTransition;
+      n._pendingCheck._set(value);
+    }
   }
 }
 const globalQueue = new GlobalQueue();
@@ -360,10 +371,15 @@ function transitionComplete(transition) {
   done && (transition.done = true);
   return done;
 }
+function currentTransition(transition) {
+  while (transition.done && typeof transition.done === "object") transition = transition.done;
+  return transition;
+}
 function runInTransition(transition, fn) {
   const prevTransition = activeTransition;
+  activeTransition = null;
   try {
-    activeTransition = transition;
+    activeTransition = currentTransition(transition);
     return fn();
   } finally {
     activeTransition = prevTransition;
@@ -382,6 +398,7 @@ function action(genFn) {
     };
     const process = result => {
       if (result.done) {
+        ctx = currentTransition(ctx);
         ctx.actions.splice(ctx.actions.indexOf(iterator), 1);
         activeTransition = ctx;
         schedule();
@@ -389,7 +406,7 @@ function action(genFn) {
         return;
       }
       const yielded = result.value;
-      if (yielded instanceof Promise) return yielded.then(step);
+      if (yielded instanceof Promise) return yielded.then(v => runInTransition(ctx, () => step(v)));
       runInTransition(ctx, () => step(yielded));
     };
     runInTransition(ctx, () => step());
@@ -407,7 +424,7 @@ function recompute(el, create = false) {
   const honoraryOptimistic = el._type && el._transition != activeTransition;
   if (!create) {
     if (el._transition && activeTransition !== el._transition && !honoraryOptimistic)
-      globalQueue.initTransition(el);
+      globalQueue.initTransition(el._transition);
     deleteFromHeap(el, el._flags & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
     if (el._transition) disposeChildren(el);
     else {
@@ -466,6 +483,8 @@ function recompute(el, create = false) {
       value
     );
   const statusFlagsChanged = el._statusFlags !== prevStatusFlags || el._error !== prevError;
+  if (el._child && el._statusFlags & STATUS_PENDING && activeTransition)
+    activeTransition.asyncNodes.push(el);
   el._notifyQueue?.(statusFlagsChanged, prevStatusFlags);
   if (valueChanged || statusFlagsChanged) {
     if (valueChanged) {
@@ -498,13 +517,13 @@ function handleAsync(el, result, setter) {
     result
       .then(value => {
         if (el._inFlight !== result) return;
-        globalQueue.initTransition(el);
-        setter?.(value) ?? setSignal(el, () => value);
+        globalQueue.initTransition(el._transition);
+        setter ? setter(value) : setSignal(el, () => value);
         flush();
       })
       .catch(e => {
         if (el._inFlight !== result) return;
-        globalQueue.initTransition(el);
+        globalQueue.initTransition(el._transition);
         setStatusFlags(el, STATUS_ERROR, e);
         el._time = clock;
         notifySubs(el);
@@ -516,13 +535,13 @@ function handleAsync(el, result, setter) {
       try {
         for await (let value of result) {
           if (el._inFlight !== result) return;
-          globalQueue.initTransition(el);
-          setter?.(value) ?? setSignal(el, () => value);
+          globalQueue.initTransition(el._transition);
+          setter ? setter(value) : setSignal(el, () => value);
           flush();
         }
       } catch (error) {
         if (el._inFlight !== result) return;
-        globalQueue.initTransition(el);
+        globalQueue.initTransition(el._transition);
         setStatusFlags(el, STATUS_ERROR, error);
         el._time = clock;
         notifySubs(el);
@@ -531,7 +550,7 @@ function handleAsync(el, result, setter) {
       }
     })();
   }
-  globalQueue.initTransition(el);
+  globalQueue.initTransition(el._transition);
   throw new NotReadyError(context);
 }
 function updateIfNecessary(el) {
@@ -840,6 +859,8 @@ function read(el) {
 function setSignal(el, v) {
   if (!el._pureWrite && context && el._firewall !== context)
     console.warn("A Signal was written to in an owned scope.");
+  if (el._transition && activeTransition !== el._transition)
+    globalQueue.initTransition(el._transition);
   if (typeof v === "function") {
     v = v(
       el._pendingValue === NOT_PENDING || (el._optimistic && el._transition)
@@ -924,11 +945,14 @@ function createRoot(init, options) {
 }
 function runWithOwner(owner, fn) {
   const oldContext = context;
+  const prevTracking = tracking;
   context = owner;
+  tracking = false;
   try {
     return fn();
   } finally {
     context = oldContext;
+    tracking = prevTracking;
   }
 }
 function staleValues(fn, set = true) {
@@ -1082,9 +1106,7 @@ function createSignal(first, second, third) {
     const node = computed(first, second, third);
     return [read.bind(null, node), setSignal.bind(null, node)];
   }
-  const o = getOwner();
-  const needsId = o?.id != null;
-  const node = signal(first, needsId ? { id: getNextChildId(o), ...second } : second);
+  const node = signal(first, second);
   return [read.bind(null, node), setSignal.bind(null, node)];
 }
 function createMemo(compute, value, options) {
@@ -1143,8 +1165,10 @@ function createOptimistic(first, second, third) {
   if (typeof first === "function") {
     const node = computed(
       prev => {
-        let n = node || getOwner();
-        n._pendingValue = first(prev);
+        const n = getOwner();
+        const value = first(prev);
+        if (n._statusFlags & STATUS_UNINITIALIZED) return value;
+        n._pendingValue = value;
         return prev;
       },
       second,
@@ -1153,9 +1177,7 @@ function createOptimistic(first, second, third) {
     node._optimistic = true;
     return [read.bind(null, node), setSignal.bind(null, node)];
   }
-  const o = getOwner();
-  const needsId = o?.id != null;
-  const node = signal(first, needsId ? { id: getNextChildId(o), ...second } : second);
+  const node = signal(first, second);
   node._optimistic = true;
   return [
     read.bind(null, node),
@@ -1338,13 +1360,13 @@ function createProjectionInternal(fn, initialValue = {}, options) {
   };
   const wrappedStore = wrapProjection(initialValue);
   node = computed(() => {
-    const owner = node || getOwner();
+    const owner = getOwner();
     storeSetter(new Proxy(wrappedStore, writeTraps), s => {
       const value = handleAsync(owner, fn(s), value => {
         value !== wrappedStore &&
           value !== undefined &&
           storeSetter(wrappedStore, reconcile(value, options?.key || "id", options?.all));
-        setSignal(node, undefined);
+        setSignal(owner, undefined);
       });
       value !== wrappedStore &&
         value !== undefined &&