@solidjs/signals 0.0.8 → 0.0.9

package/dist/dev.js

@@ -27,8 +27,7 @@ var EffectError = class extends Error {
 var STATE_CLEAN = 0;
 var STATE_CHECK = 1;
 var STATE_DIRTY = 2;
-var STATE_UNINITIALIZED = 3;
-var STATE_DISPOSED = 4;
+var STATE_DISPOSED = 3;
 var EFFECT_PURE = 0;
 var EFFECT_RENDER = 1;
 var EFFECT_USER = 2;
@@ -237,6 +236,8 @@ var ERROR_OFFSET = 0;
 var ERROR_BIT = 1 << ERROR_OFFSET;
 var LOADING_OFFSET = 1;
 var LOADING_BIT = 1 << LOADING_OFFSET;
+var UNINITIALIZED_OFFSET = 2;
+var UNINITIALIZED_BIT = 1 << UNINITIALIZED_OFFSET;
 var DEFAULT_FLAGS = ERROR_BIT;
 
 // src/core/core.ts
@@ -246,8 +247,9 @@ var newSources = null;
 var newSourcesIndex = 0;
 var newFlags = 0;
 var clock = 0;
-var syncResolve = false;
+var notStale = false;
 var updateCheck = null;
+var staleCheck = null;
 function getObserver() {
   return currentObserver;
 }
@@ -262,6 +264,7 @@ var Computation = class extends Owner {
   _sources = null;
   _observers = null;
   _value;
+  _error;
   _compute;
   // Used in __DEV__ mode, hopefully removed in production
   _name;
@@ -279,7 +282,8 @@ var Computation = class extends Owner {
   constructor(initialValue, compute2, options) {
     super(compute2 === null);
     this._compute = compute2;
-    this._state = compute2 ? STATE_UNINITIALIZED : STATE_CLEAN;
+    this._state = compute2 ? STATE_DIRTY : STATE_CLEAN;
+    this._stateFlags = compute2 && initialValue === void 0 ? UNINITIALIZED_BIT : 0;
     this._value = initialValue;
     this._name = options?.name ?? (this._compute ? "computed" : "signal");
     if (options?.equals !== void 0)
@@ -294,7 +298,7 @@ var Computation = class extends Owner {
       track(this);
     newFlags |= this._stateFlags & ~currentMask;
     if (this._stateFlags & ERROR_BIT) {
-      throw this._value;
+      throw this._error;
     } else {
       return this._value;
     }
@@ -317,9 +321,11 @@ var Computation = class extends Owner {
     if (this._compute && this._stateFlags & ERROR_BIT && this._time <= clock) {
       update(this);
     }
-    if (!syncResolve && this.loading()) {
+    if ((notStale || this._stateFlags & UNINITIALIZED_BIT) && this.loading()) {
       throw new NotReadyError();
     }
+    if (staleCheck && this._stateFlags & LOADING_BIT)
+      staleCheck._value = true;
     return this._read();
   }
   /**
@@ -338,9 +344,11 @@ var Computation = class extends Owner {
   /** Update the computation with a new value. */
   write(value, flags = 0, raw = false) {
     const newValue = !raw && typeof value === "function" ? value(this._value) : value;
-    const valueChanged = newValue !== UNCHANGED && (!!(flags & ERROR_BIT) || this._state === STATE_UNINITIALIZED || this._equals === false || !this._equals(this._value, newValue));
-    if (valueChanged)
+    const valueChanged = newValue !== UNCHANGED && (!!(this._stateFlags & UNINITIALIZED_BIT) || this._equals === false || !this._equals(this._value, newValue));
+    if (valueChanged) {
       this._value = newValue;
+      this._error = void 0;
+    }
     const changedFlagsMask = this._stateFlags ^ flags, changedFlags = changedFlagsMask & flags;
     this._stateFlags = flags;
     this._time = clock + 1;
@@ -398,7 +406,8 @@ var Computation = class extends Owner {
     }
   }
   _setError(error) {
-    this.write(error, this._stateFlags & ~LOADING_BIT | ERROR_BIT);
+    this._error = error;
+    this.write(UNCHANGED, this._stateFlags & ~LOADING_BIT | ERROR_BIT | UNINITIALIZED_BIT);
   }
   /**
    * This is the core part of the reactivity system, which makes sure that the values are updated
@@ -424,7 +433,7 @@ var Computation = class extends Owner {
         }
       }
     }
-    if (this._state === STATE_DIRTY || this._state === STATE_UNINITIALIZED) {
+    if (this._state === STATE_DIRTY) {
       update(this);
     } else {
       this.write(UNCHANGED, observerFlags);
@@ -484,7 +493,7 @@ function update(node) {
     node.write(result, newFlags, true);
   } catch (error) {
     if (error instanceof NotReadyError) {
-      node.write(UNCHANGED, newFlags | LOADING_BIT);
+      node.write(UNCHANGED, newFlags | LOADING_BIT | node._stateFlags & UNINITIALIZED_BIT);
     } else {
       node._setError(error);
     }
@@ -551,23 +560,27 @@ function hasUpdated(fn) {
     updateCheck = current;
   }
 }
-function isPending(fn) {
+function isStale(fn) {
+  const current = staleCheck;
+  staleCheck = { _value: false };
   try {
-    fn();
-    return false;
-  } catch (e) {
-    return e instanceof NotReadyError;
+    latest(fn);
+    return staleCheck._value;
+  } catch {
+  } finally {
+    staleCheck = current;
   }
+  return false;
 }
-function resolveSync(fn) {
+function latest(fn) {
   const prevFlags = newFlags;
-  syncResolve = true;
+  const prevNotStale = notStale;
+  notStale = false;
   try {
     return fn();
-  } catch {
   } finally {
     newFlags = prevFlags;
-    syncResolve = false;
+    notStale = prevNotStale;
   }
 }
 function catchError(fn) {
@@ -579,16 +592,18 @@ function catchError(fn) {
     return e;
   }
 }
-function compute(owner, compute2, observer) {
-  const prevOwner = setOwner(owner), prevObserver = currentObserver, prevMask = currentMask;
+function compute(owner, fn, observer) {
+  const prevOwner = setOwner(owner), prevObserver = currentObserver, prevMask = currentMask, prevNotStale = notStale;
   currentObserver = observer;
   currentMask = observer?._handlerMask ?? DEFAULT_FLAGS;
+  notStale = true;
   try {
-    return compute2(observer ? observer._value : void 0);
+    return fn(observer ? observer._value : void 0);
   } finally {
     setOwner(prevOwner);
     currentObserver = prevObserver;
     currentMask = prevMask;
+    notStale = prevNotStale;
   }
 }
 
@@ -695,7 +710,7 @@ function runEffectQueue(queue) {
 // src/core/effect.ts
 var Effect = class extends Computation {
   _effect;
-  _error;
+  _onerror;
   _cleanup;
   _modified = false;
   _prevValue;
@@ -704,9 +719,12 @@ var Effect = class extends Computation {
   constructor(initialValue, compute2, effect, error, options) {
     super(initialValue, compute2, options);
     this._effect = effect;
-    this._error = error;
+    this._onerror = error;
     this._prevValue = initialValue;
     this._type = options?.render ? EFFECT_RENDER : EFFECT_USER;
+    if (this._type === EFFECT_RENDER) {
+      this._compute = (p) => latest(() => compute2(p));
+    }
     this._queue = getOwner()?._queue || globalQueue;
     if (!options?.defer) {
       this._updateIfNecessary();
@@ -716,10 +734,12 @@ var Effect = class extends Computation {
       console.warn("Effects created outside a reactive context will never be disposed");
   }
   write(value, flags = 0) {
-    const currentFlags = this._stateFlags;
-    this._stateFlags = flags;
-    if (this._type === EFFECT_RENDER && (flags & LOADING_BIT) !== (currentFlags & LOADING_BIT)) {
-      this._queue._update?.(this);
+    if (this._state == STATE_DIRTY) {
+      const currentFlags = this._stateFlags;
+      this._stateFlags = flags;
+      if (this._type === EFFECT_RENDER && (flags & LOADING_BIT) !== (currentFlags & LOADING_BIT)) {
+        this._queue._update?.(this);
+      }
     }
     if (value === UNCHANGED)
       return this._value;
@@ -742,7 +762,7 @@ var Effect = class extends Computation {
     }
     if (this._type === EFFECT_USER) {
       try {
-        return this._error ? this._cleanup = this._error(error) : console.error(new EffectError(this._effect, error));
+        return this._onerror ? this._cleanup = this._onerror(error) : console.error(new EffectError(this._effect, error));
       } catch (e) {
         error = e;
       }
@@ -754,7 +774,7 @@ var Effect = class extends Computation {
       return;
     this._effect = void 0;
     this._prevValue = void 0;
-    this._error = void 0;
+    this._onerror = void 0;
     this._cleanup?.();
     this._cleanup = void 0;
     super._disposeNode();
@@ -790,6 +810,22 @@ var EagerComputation = class extends Computation {
     super._notify(state, skipQueue);
   }
 };
+var ProjectionComputation = class extends Computation {
+  _queue;
+  constructor(compute2) {
+    super(null, compute2);
+    this._queue = getOwner()?._queue || globalQueue;
+    if (!this._parent)
+      console.warn("Eager Computations created outside a reactive context will never be disposed");
+  }
+  _notify(state, skipQueue) {
+    if (this._state >= state && !this._forceNotify)
+      return;
+    if (this._state === STATE_CLEAN && !skipQueue)
+      this._queue.enqueue(EFFECT_PURE, this);
+    super._notify(state, true);
+  }
+};
 
 // src/core/suspense.ts
 var SuspenseQueue = class extends Queue {
@@ -869,13 +905,14 @@ function createMemo(compute2, value, options) {
         node = void 0;
       } else if (!node._parent && !node._observers?.length) {
         node.dispose();
-        node._state = STATE_UNINITIALIZED;
+        node._state = STATE_DIRTY;
       }
     }
     return resolvedValue;
   };
 }
 function createAsync(compute2, value, options) {
+  let uninitialized = value === void 0;
   const lhs = new EagerComputation(
     {
       _value: value
@@ -902,14 +939,16 @@ function createAsync(compute2, value, options) {
         }
         return w.call(this);
       };
-      signal.write(UNCHANGED, LOADING_BIT);
+      signal.write(UNCHANGED, LOADING_BIT | (uninitialized ? UNINITIALIZED_BIT : 0));
       if (isPromise) {
         source.then(
           (value3) => {
+            uninitialized = false;
             signal.write(value3, 0, true);
           },
           (error) => {
-            signal.write(error, ERROR_BIT);
+            uninitialized = true;
+            signal._setError(error);
           }
         );
       } else {
@@ -1019,18 +1058,9 @@ function createReaction(effect, error, options) {
 }
 
 // src/store/projection.ts
-var ProjectionComputation = class extends EagerComputation {
-  _notify(state, skipQueue) {
-    if (this._state >= state && !this._forceNotify)
-      return;
-    if (this._state === STATE_CLEAN && !skipQueue)
-      this._queue.enqueue(EFFECT_PURE, this);
-    super._notify(state, true);
-  }
-};
 function createProjection(fn, initialValue = {}) {
   const [store, setStore] = createStore(initialValue);
-  const node = new ProjectionComputation(void 0, () => {
+  const node = new ProjectionComputation(() => {
     setStore(fn);
   });
   const wrapped = /* @__PURE__ */ new WeakMap();
@@ -1676,4 +1706,4 @@ function compare(key, a, b) {
   return key ? key(a) === key(b) : true;
 }
 
-export { $PROXY, $RAW, $TARGET, $TRACK, Computation, ContextNotFoundError, NoOwnerError, NotReadyError, Owner, Queue, SUPPORTS_PROXY, catchError, createAsync, createBoundary, createContext, createEffect, createErrorBoundary, createMemo, createProjection, createReaction, createRenderEffect, createRoot, createSignal, createStore, createSuspense, flatten, flushSync, getContext, getObserver, getOwner, hasContext, hasUpdated, isEqual, isPending, isWrappable, mapArray, merge, omit, onCleanup, reconcile, repeat, resolve, resolveSync, runWithOwner, setContext, untrack, unwrap };
+export { $PROXY, $RAW, $TARGET, $TRACK, Computation, ContextNotFoundError, NoOwnerError, NotReadyError, Owner, Queue, SUPPORTS_PROXY, catchError, createAsync, createBoundary, createContext, createEffect, createErrorBoundary, createMemo, createProjection, createReaction, createRenderEffect, createRoot, createSignal, createStore, createSuspense, flatten, flushSync, getContext, getObserver, getOwner, hasContext, hasUpdated, isEqual, isStale, isWrappable, latest, mapArray, merge, omit, onCleanup, reconcile, repeat, resolve, runWithOwner, setContext, untrack, unwrap };