@solidjs/signals 0.0.9 → 0.0.10

package/dist/dev.js

@@ -33,6 +33,106 @@ 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";
@@ -114,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);
@@ -182,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;
@@ -246,19 +346,12 @@ var currentMask = DEFAULT_FLAGS;
 var newSources = null;
 var newSourcesIndex = 0;
 var newFlags = 0;
-var clock = 0;
 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;
@@ -292,8 +385,12 @@ 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;
@@ -318,7 +415,7 @@ 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 ((notStale || this._stateFlags & UNINITIALIZED_BIT) && this.loading()) {
@@ -351,7 +448,7 @@ var Computation = class extends Owner {
     }
     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) {
@@ -524,7 +621,7 @@ function update(node) {
     newSources = prevSources;
     newSourcesIndex = prevSourcesIndex;
     newFlags = prevFlags;
-    node._time = clock + 1;
+    node._time = getClock() + 1;
     node._state = STATE_CLEAN;
   }
 }
@@ -606,106 +703,13 @@ function compute(owner, fn, observer) {
     notStale = prevNotStale;
   }
 }
-
-// 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();
-  }
-}
 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 {
@@ -715,7 +719,6 @@ var Effect = class extends Computation {
   _modified = false;
   _prevValue;
   _type;
-  _queue;
   constructor(initialValue, compute2, effect, error, options) {
     super(initialValue, compute2, options);
     this._effect = effect;
@@ -725,7 +728,6 @@ var Effect = class extends Computation {
     if (this._type === EFFECT_RENDER) {
       this._compute = (p) => latest(() => compute2(p));
     }
-    this._queue = getOwner()?._queue || globalQueue;
     if (!options?.defer) {
       this._updateIfNecessary();
       this._type === EFFECT_USER ? this._queue.enqueue(this._type, this) : this._runEffect();
@@ -794,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");
   }
@@ -811,10 +811,8 @@ var EagerComputation = class extends Computation {
   }
 };
 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");
   }
@@ -856,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;
@@ -1000,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);
       };
@@ -1023,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();
+      });
     });
   });
 }