@solidjs/signals 0.7.3 → 0.7.5

package/dist/dev.js

@@ -1,5 +1,9 @@
 // src/core/error.ts
 var NotReadyError = class extends Error {
+  constructor(node) {
+    super();
+    this.cause = node;
+  }
 };
 var NoOwnerError = class extends Error {
   constructor() {
@@ -172,8 +176,10 @@ var Transition = class _Transition {
   _running = false;
   _scheduled = false;
   _cloned = globalQueue;
+  _signal;
   created = clock;
-  constructor() {
+  constructor(signal) {
+    this._signal = signal;
     this._clonedQueues.set(globalQueue, this);
     for (const child of globalQueue._children) {
       cloneQueue(child, this, this);
@@ -202,6 +208,7 @@ var Transition = class _Transition {
   flush() {
     if (this._running || this._done)
       return;
+    globalQueue.flush();
     this._running = true;
     let currentTransition = ActiveTransition;
     ActiveTransition = this;
@@ -316,13 +323,12 @@ var Transition = class _Transition {
     this._optimistic.add(fn);
   }
 };
-function transition(fn) {
-  let t = new Transition();
-  queueMicrotask(() => t.runTransition(() => fn((fn2) => t.runTransition(fn2))));
-}
 function cloneGraph(node) {
   if (node._optimistic) {
-    ActiveTransition.addOptimistic(node._optimistic);
+    if (node._state !== STATE_DISPOSED) {
+      !node._transition && node._optimistic._init?.();
+      ActiveTransition.addOptimistic(node._optimistic);
+    }
     return node;
   }
   if (node._transition) {
@@ -486,6 +492,7 @@ function finishTransition(transition2) {
     delete reset._transition;
     reset();
   }
+  transition2._signal.write(true);
   globalQueue.flush();
 }
 
@@ -678,6 +685,10 @@ var Computation = class extends Owner {
     }
   }
   _read() {
+    if (staleCheck && (this._stateFlags & LOADING_BIT || this._transition)) {
+      staleCheck._value = true;
+      this._transition?._signal.read();
+    }
     track(this);
     newFlags |= this._stateFlags & ~currentMask;
     if (this._stateFlags & ERROR_BIT) {
@@ -724,11 +735,7 @@ var Computation = class extends Owner {
         this._updateIfNecessary();
     }
     if ((notStale || this._stateFlags & UNINITIALIZED_BIT) && this._stateFlags & LOADING_BIT) {
-      track(this);
-      throw new NotReadyError();
-    }
-    if (staleCheck && this._stateFlags & LOADING_BIT) {
-      staleCheck._value = true;
+      throw new NotReadyError(this);
     }
     return this._read();
   }
@@ -891,6 +898,12 @@ function update(node) {
     node.write(result, newFlags, true);
   } catch (error) {
     if (error instanceof NotReadyError) {
+      if (error.cause !== node)
+        compute(
+          node,
+          () => track(error.cause),
+          node
+        );
       node.write(UNCHANGED, newFlags | LOADING_BIT | node._stateFlags & UNINITIALIZED_BIT);
     } else {
       node._setError(error);
@@ -964,8 +977,17 @@ function isPending(fn, loadingValue) {
   if (!currentObserver)
     return pendingCheck(fn, loadingValue);
   const c = new Computation(void 0, () => pendingCheck(fn, loadingValue));
+  c._optimistic = () => c.write(false);
+  c._optimistic._init = () => globalQueue.enqueue(0, () => c._optimistic._transition && c.write(true));
   c._handlerMask |= LOADING_BIT;
-  return c.wait();
+  const res = c.wait();
+  c._disposal = () => {
+    if (c._optimistic._transition) {
+      c._optimistic._transition._optimistic.delete(c._optimistic);
+      delete c._optimistic._transition;
+    }
+  };
+  return res;
 }
 function latest(fn, fallback) {
   const argLength = arguments.length;
@@ -1105,11 +1127,15 @@ var TrackedEffect = class extends Computation {
   _type = EFFECT_USER;
   _cleanup;
   constructor(compute2, options) {
-    super(void 0, () => {
-      this._cleanup?.();
-      this._cleanup = latest(compute2);
-      return void 0;
-    }, options);
+    super(
+      void 0,
+      () => {
+        this._cleanup?.();
+        this._cleanup = latest(compute2);
+        return void 0;
+      },
+      options
+    );
     getQueue(this).enqueue(this._type, this._run.bind(this));
     if (!this._parent)
       console.warn("Effects created outside a reactive context will never be disposed");
@@ -1196,10 +1222,13 @@ function runTop(node) {
 function createSignal(first, second, third) {
   if (typeof first === "function") {
     const node2 = new Computation(second, first, third);
-    return [node2.read.bind(node2), (v) => {
-      node2._updateIfNecessary();
-      return node2.write(v);
-    }];
+    return [
+      node2.wait.bind(node2),
+      (v) => {
+        node2._updateIfNecessary();
+        return node2.write(v);
+      }
+    ];
   }
   const o = getOwner();
   const needsId = o?.id != null;
@@ -1291,7 +1320,7 @@ function createAsync(compute2, value, options) {
           }
         })();
       }
-      throw new NotReadyError();
+      throw new NotReadyError(getOwner());
     },
     options
   );
@@ -1369,12 +1398,17 @@ function resolve(fn) {
   });
 }
 function createOptimistic(first, second, third) {
-  const node = typeof first === "function" ? new Computation(second, (prev) => {
-    const res = first(prev);
-    if (node._optimistic._transition)
-      return prev;
-    return res;
-  }, third) : new Computation(first, null, second);
+  const node = typeof first === "function" ? new Computation(
+    second,
+    (prev) => {
+      if (node._optimistic._transition) {
+        latest(() => first(prev));
+        return prev;
+      }
+      return first(prev);
+    },
+    third
+  ) : new Computation(first, null, second);
   node._optimistic = () => node.write(first);
   function write(v) {
     if (!ActiveTransition)
@@ -1387,7 +1421,11 @@ function createOptimistic(first, second, third) {
       }
     });
   }
-  return [node.read.bind(node), write];
+  return [node.wait.bind(node), write];
+}
+function transition(fn) {
+  let t = new Transition(new Computation(void 0, null));
+  queueMicrotask(() => t.runTransition(() => fn((fn2) => t.runTransition(fn2))));
 }
 function useTransition() {
   const [pending, setPending] = createOptimistic(false);
@@ -1858,20 +1896,21 @@ function deep(store) {
 // src/store/optimistic.ts
 function createOptimisticStore(first, second, options) {
   const derived = typeof first === "function";
-  const { store, node } = derived ? createProjectionInternal((draft) => {
-    const res = first(draft);
-    if (reset._transition)
-      return draft;
-    return res;
-  }, second, options) : createProjectionInternal(() => {
+  const { store, node } = derived ? createProjectionInternal(
+    (draft) => {
+      if (reset._transition) {
+        latest(() => first(draft));
+        return draft;
+      }
+      return first(draft);
+    },
+    second,
+    options
+  ) : createProjectionInternal(() => {
   }, first);
   const reset = () => storeSetter(
     store,
-    reconcile(
-      derived ? first(store) || store : first,
-      options?.key || "id",
-      options?.all
-    )
+    reconcile(derived ? first(store) || store : first, options?.key || "id", options?.all)
   );
   const write = (v) => {
     if (!ActiveTransition)
@@ -2306,7 +2345,7 @@ function createBoundChildren(owner, fn, queue, mask) {
     owner,
     () => {
       const c = new Computation(void 0, fn);
-      return new BoundaryComputation(() => flatten(c.wait()), mask);
+      return new BoundaryComputation(() => latest(() => flatten(c.wait())), mask);
     },
     null
   );