@solidjs/signals 0.7.2 → 0.7.4

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,14 @@ 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)
+  if (node._optimistic) {
+    if (node._state !== STATE_DISPOSED) {
+      node._optimistic._init?.();
+      ActiveTransition.addOptimistic(node._optimistic);
+    }
     return node;
+  }
   if (node._transition) {
     if (node._transition !== ActiveTransition) {
       mergeTransitions(node._transition, ActiveTransition);
@@ -484,6 +492,7 @@ function finishTransition(transition2) {
     delete reset._transition;
     reset();
   }
+  transition2._signal.write(true);
   globalQueue.flush();
 }
 
@@ -658,7 +667,7 @@ var Computation = class extends Owner {
   _forceNotify = false;
   _transition;
   _cloned;
-  _optimistic = false;
+  _optimistic;
   constructor(initialValue, compute2, options) {
     super(options?.id, compute2 === null);
     this._compute = compute2;
@@ -722,11 +731,11 @@ var Computation = class extends Owner {
         this._updateIfNecessary();
     }
     if ((notStale || this._stateFlags & UNINITIALIZED_BIT) && this._stateFlags & LOADING_BIT) {
-      track(this);
-      throw new NotReadyError();
+      throw new NotReadyError(this);
     }
-    if (staleCheck && this._stateFlags & LOADING_BIT) {
+    if (staleCheck && (this._stateFlags & LOADING_BIT || this._transition)) {
       staleCheck._value = true;
+      this._transition?._signal.read();
     }
     return this._read();
   }
@@ -889,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);
@@ -962,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.read();
+  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;
@@ -1103,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");
@@ -1168,8 +1196,11 @@ var FirewallComputation = class extends Computation {
   _run() {
     const prevFlags = this._stateFlags;
     this._state !== STATE_CLEAN && runTop(this);
-    if (ActiveTransition && this._optimistic && this._stateFlags !== prevFlags)
+    if (ActiveTransition && this._optimistic && (this._stateFlags !== prevFlags || this._stateFlags !== this._optimistic.flags)) {
       getQueue(this).notify(this, LOADING_BIT | ERROR_BIT, this._stateFlags);
+      this._optimistic.flags = this._stateFlags;
+      this._stateFlags = prevFlags;
+    }
   }
 };
 function runTop(node) {
@@ -1191,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;
@@ -1286,7 +1320,7 @@ function createAsync(compute2, value, options) {
           }
         })();
       }
-      throw new NotReadyError();
+      throw new NotReadyError(getOwner());
     },
     options
   );
@@ -1364,26 +1398,33 @@ function resolve(fn) {
   });
 }
 function createOptimistic(first, second, third) {
-  const node = typeof first === "function" ? new Computation(second, (prev) => {
-    const res = first(prev);
-    if (reset._transition)
-      return prev;
-    return res;
-  }, third) : new Computation(first, null, second);
-  node._optimistic = true;
-  const reset = () => node.write(first);
+  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);
+  node._optimistic = () => node.write(first);
   function write(v) {
     if (!ActiveTransition)
       throw new Error("createOptimistic can only be updated inside a transition");
-    ActiveTransition.addOptimistic(reset);
+    ActiveTransition.addOptimistic(node._optimistic);
     queueMicrotask(() => {
-      if (reset._transition) {
+      if (node._optimistic._transition) {
         node._updateIfNecessary();
         node.write(v);
       }
     });
   }
-  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);
@@ -1854,21 +1895,20 @@ 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) => {
+      const res = first(draft);
+      if (reset._transition)
+        return draft;
+      return res;
+    },
+    second,
+    options
+  ) : createProjectionInternal(() => {
   }, first);
-  node._optimistic = true;
   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)
@@ -1876,6 +1916,7 @@ function createOptimisticStore(first, second, options) {
     ActiveTransition.addOptimistic(reset);
     queueMicrotask(() => reset._transition && storeSetter(store, v));
   };
+  node._optimistic = reset;
   return [store, write];
 }
 
@@ -2302,7 +2343,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
   );