@solidjs/signals 0.0.8 → 0.0.10

package/dist/dev.js

@@ -27,13 +27,112 @@ 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;
 var SUPPORTS_PROXY = typeof Proxy === "function";
 
+// src/core/scheduler.ts
+var clock = 0;
+function getClock() {
+  return clock;
+}
+function incrementClock() {
+  clock++;
+}
+var scheduled = false;
+function schedule() {
+  if (scheduled)
+    return;
+  scheduled = true;
+  if (!globalQueue._running)
+    queueMicrotask(flushSync);
+}
+var Queue = class {
+  _running = false;
+  _queues = [[], [], []];
+  _children = [];
+  enqueue(type, node) {
+    this._queues[0].push(node);
+    if (type)
+      this._queues[type].push(node);
+    schedule();
+  }
+  run(type) {
+    if (this._queues[type].length) {
+      if (type === EFFECT_PURE) {
+        runPureQueue(this._queues[type]);
+        this._queues[type] = [];
+      } else {
+        const effects = this._queues[type];
+        this._queues[type] = [];
+        runEffectQueue(effects);
+      }
+    }
+    let rerun = false;
+    for (let i = 0; i < this._children.length; i++) {
+      rerun = this._children[i].run(type) || rerun;
+    }
+    if (type === EFFECT_PURE && this._queues[type].length)
+      return true;
+  }
+  flush() {
+    if (this._running)
+      return;
+    this._running = true;
+    try {
+      while (this.run(EFFECT_PURE)) {
+      }
+      incrementClock();
+      scheduled = false;
+      this.run(EFFECT_RENDER);
+      this.run(EFFECT_USER);
+    } finally {
+      this._running = false;
+    }
+  }
+  addChild(child) {
+    this._children.push(child);
+  }
+  removeChild(child) {
+    const index = this._children.indexOf(child);
+    if (index >= 0)
+      this._children.splice(index, 1);
+  }
+};
+var globalQueue = new Queue();
+function flushSync() {
+  let count = 0;
+  while (scheduled) {
+    if (++count === 1e5)
+      throw new Error("Potential Infinite Loop Detected.");
+    globalQueue.flush();
+  }
+}
+function runTop(node) {
+  const ancestors = [];
+  for (let current = node; current !== null; current = current._parent) {
+    if (current._state !== STATE_CLEAN) {
+      ancestors.push(current);
+    }
+  }
+  for (let i = ancestors.length - 1; i >= 0; i--) {
+    if (ancestors[i]._state !== STATE_DISPOSED)
+      ancestors[i]._updateIfNecessary();
+  }
+}
+function runPureQueue(queue) {
+  for (let i = 0; i < queue.length; i++) {
+    if (queue[i]._state !== STATE_CLEAN)
+      runTop(queue[i]);
+  }
+}
+function runEffectQueue(queue) {
+  for (let i = 0; i < queue.length; i++)
+    queue[i]._runEffect();
+}
+
 // src/core/utils.ts
 function isUndefined(value) {
   return typeof value === "undefined";
@@ -115,7 +214,7 @@ var Owner = class {
   _disposal = null;
   _context = defaultContext;
   _handlers = null;
-  _queue = null;
+  _queue = globalQueue;
   constructor(signal = false) {
     if (currentOwner && !signal)
       currentOwner.append(this);
@@ -183,7 +282,7 @@ var Owner = class {
     let i = 0, len = this._handlers.length;
     for (i = 0; i < len; i++) {
       try {
-        this._handlers[i](error);
+        this._handlers[i](error, this);
         break;
       } catch (e) {
         error = e;
@@ -237,6 +336,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
@@ -245,23 +346,18 @@ var currentMask = DEFAULT_FLAGS;
 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;
 }
-function getClock() {
-  return clock;
-}
-function incrementClock() {
-  clock++;
-}
 var UNCHANGED = Symbol("unchanged" );
 var Computation = class extends Owner {
   _sources = null;
   _observers = null;
   _value;
+  _error;
   _compute;
   // Used in __DEV__ mode, hopefully removed in production
   _name;
@@ -279,7 +375,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)
@@ -288,13 +385,17 @@ var Computation = class extends Owner {
       this._unobserved = options?.unobserved;
   }
   _read() {
-    if (this._compute)
-      this._updateIfNecessary();
+    if (this._compute) {
+      if (this._stateFlags & ERROR_BIT && this._time <= getClock())
+        update(this);
+      else
+        this._updateIfNecessary();
+    }
     if (!this._compute || this._sources?.length)
       track(this);
     newFlags |= this._stateFlags & ~currentMask;
     if (this._stateFlags & ERROR_BIT) {
-      throw this._value;
+      throw this._error;
     } else {
       return this._value;
     }
@@ -314,12 +415,14 @@ var Computation = class extends Owner {
    * before continuing
    */
   wait() {
-    if (this._compute && this._stateFlags & ERROR_BIT && this._time <= clock) {
+    if (this._compute && this._stateFlags & ERROR_BIT && this._time <= getClock()) {
       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,12 +441,14 @@ 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;
+    this._time = getClock() + 1;
     if (this._observers) {
       for (let i = 0; i < this._observers.length; i++) {
         if (valueChanged) {
@@ -398,7 +503,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 +530,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 +590,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);
     }
@@ -515,7 +621,7 @@ function update(node) {
     newSources = prevSources;
     newSourcesIndex = prevSourcesIndex;
     newFlags = prevFlags;
-    node._time = clock + 1;
+    node._time = getClock() + 1;
     node._state = STATE_CLEAN;
   }
 }
@@ -551,23 +657,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,135 +689,45 @@ 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;
-  }
-}
-
-// src/core/scheduler.ts
-var scheduled = false;
-function schedule() {
-  if (scheduled)
-    return;
-  scheduled = true;
-  if (!globalQueue._running)
-    queueMicrotask(flushSync);
-}
-var Queue = class {
-  _running = false;
-  _queues = [[], [], []];
-  _children = [];
-  enqueue(type, node) {
-    this._queues[0].push(node);
-    if (type)
-      this._queues[type].push(node);
-    schedule();
-  }
-  run(type) {
-    if (this._queues[type].length) {
-      if (type === EFFECT_PURE) {
-        runPureQueue(this._queues[type]);
-        this._queues[type] = [];
-      } else {
-        const effects = this._queues[type];
-        this._queues[type] = [];
-        runEffectQueue(effects);
-      }
-    }
-    let rerun = false;
-    for (let i = 0; i < this._children.length; i++) {
-      rerun = this._children[i].run(type) || rerun;
-    }
-    if (type === EFFECT_PURE && this._queues[type].length)
-      return true;
-  }
-  flush() {
-    if (this._running)
-      return;
-    this._running = true;
-    try {
-      while (this.run(EFFECT_PURE)) {
-      }
-      incrementClock();
-      scheduled = false;
-      this.run(EFFECT_RENDER);
-      this.run(EFFECT_USER);
-    } finally {
-      this._running = false;
-    }
-  }
-  addChild(child) {
-    this._children.push(child);
-  }
-  removeChild(child) {
-    const index = this._children.indexOf(child);
-    if (index >= 0)
-      this._children.splice(index, 1);
-  }
-};
-var globalQueue = new Queue();
-function flushSync() {
-  let count = 0;
-  while (scheduled) {
-    if (++count === 1e5)
-      throw new Error("Potential Infinite Loop Detected.");
-    globalQueue.flush();
+    notStale = prevNotStale;
   }
 }
 function createBoundary(fn, queue) {
   const owner = new Owner();
-  const parentQueue = owner._queue || globalQueue;
+  const parentQueue = owner._queue;
   parentQueue.addChild(owner._queue = queue);
   onCleanup(() => parentQueue.removeChild(owner._queue));
   return compute(owner, fn, null);
 }
-function runTop(node) {
-  const ancestors = [];
-  for (let current = node; current !== null; current = current._parent) {
-    if (current._state !== STATE_CLEAN) {
-      ancestors.push(current);
-    }
-  }
-  for (let i = ancestors.length - 1; i >= 0; i--) {
-    if (ancestors[i]._state !== STATE_DISPOSED)
-      ancestors[i]._updateIfNecessary();
-  }
-}
-function runPureQueue(queue) {
-  for (let i = 0; i < queue.length; i++) {
-    if (queue[i]._state !== STATE_CLEAN)
-      runTop(queue[i]);
-  }
-}
-function runEffectQueue(queue) {
-  for (let i = 0; i < queue.length; i++)
-    queue[i]._runEffect();
-}
 
 // src/core/effect.ts
 var Effect = class extends Computation {
   _effect;
-  _error;
+  _onerror;
   _cleanup;
   _modified = false;
   _prevValue;
   _type;
-  _queue;
   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;
-    this._queue = getOwner()?._queue || globalQueue;
+    if (this._type === EFFECT_RENDER) {
+      this._compute = (p) => latest(() => compute2(p));
+    }
     if (!options?.defer) {
       this._updateIfNecessary();
       this._type === EFFECT_USER ? this._queue.enqueue(this._type, this) : this._runEffect();
@@ -716,10 +736,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 +764,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 +776,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();
@@ -774,11 +796,9 @@ var Effect = class extends Computation {
   }
 };
 var EagerComputation = class extends Computation {
-  _queue;
   constructor(initialValue, compute2, options) {
     super(initialValue, compute2, options);
-    this._queue = getOwner()?._queue || globalQueue;
-    this._updateIfNecessary();
+    !options?.defer && this._updateIfNecessary();
     if (!this._parent)
       console.warn("Eager Computations created outside a reactive context will never be disposed");
   }
@@ -790,6 +810,20 @@ var EagerComputation = class extends Computation {
     super._notify(state, skipQueue);
   }
 };
+var ProjectionComputation = class extends Computation {
+  constructor(compute2) {
+    super(null, compute2);
+    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 {
@@ -820,8 +854,9 @@ var SuspenseQueue = class extends Queue {
 var LiveComputation = class extends EagerComputation {
   write(value, flags = 0) {
     const currentFlags = this._stateFlags;
+    const dirty = this._state === STATE_DIRTY;
     super.write(value, flags);
-    if ((flags & LOADING_BIT) !== (currentFlags & LOADING_BIT)) {
+    if (dirty && (flags & LOADING_BIT) !== (currentFlags & LOADING_BIT)) {
       this._queue._update?.(this);
     }
     return this._value;
@@ -869,13 +904,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 +938,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 {
@@ -961,15 +999,30 @@ function runWithOwner(owner, run) {
 }
 function createErrorBoundary(fn, fallback) {
   const owner = new Owner();
-  const error = new Computation(null, null);
-  const reset = new Computation(null, null, { equals: false });
-  const handler = (err) => error.write({ _error: err });
+  const error = new Computation(void 0, null);
+  const nodes = /* @__PURE__ */ new Set();
+  function handler(err, node) {
+    if (nodes.has(node))
+      return;
+    compute(
+      node,
+      () => onCleanup(() => {
+        nodes.delete(node);
+        if (!nodes.size)
+          error.write(void 0);
+      }),
+      null
+    );
+    nodes.add(node);
+    if (nodes.size === 1)
+      error.write({ _error: err });
+  }
   owner._handlers = owner._handlers ? [handler, ...owner._handlers] : [handler];
   const guarded = compute(
     owner,
     () => {
-      const c = new Computation(null, () => (reset.read(), fn()));
-      const f = new Computation(null, () => flatten(c.read()));
+      const c = new Computation(void 0, fn);
+      const f = new EagerComputation(void 0, () => flatten(c.read()), { defer: true });
       f._setError = function(error2) {
         this.handleError(error2);
       };
@@ -984,23 +1037,28 @@ function createErrorBoundary(fn, fallback) {
         return resolved;
     }
     return fallback(error.read()._error, () => {
-      error.write(null);
-      reset.write(null);
+      incrementClock();
+      for (let node of nodes) {
+        node._state = STATE_DIRTY;
+        node._queue?.enqueue(node._type, node);
+      }
     });
   });
   return decision.read.bind(decision);
 }
 function resolve(fn) {
   return new Promise((res, rej) => {
-    let node = new EagerComputation(void 0, () => {
-      try {
-        res(fn());
-      } catch (err) {
-        if (err instanceof NotReadyError)
-          throw err;
-        rej(err);
-      }
-      node.dispose(true);
+    createRoot((dispose) => {
+      new EagerComputation(void 0, () => {
+        try {
+          res(fn());
+        } catch (err) {
+          if (err instanceof NotReadyError)
+            throw err;
+          rej(err);
+        }
+        dispose();
+      });
     });
   });
 }
@@ -1019,18 +1077,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 +1725,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 };