@solidjs/signals 0.3.0 → 0.3.1

package/dist/dev.js

@@ -50,6 +50,7 @@ function schedule() {
     queueMicrotask(flushSync);
 }
 var Queue = class {
+  _parent = null;
   _running = false;
   _queues = [[], [], []];
   _children = [];
@@ -95,12 +96,18 @@ var Queue = class {
   }
   addChild(child) {
     this._children.push(child);
+    child._parent = this;
   }
   removeChild(child) {
     const index = this._children.indexOf(child);
     if (index >= 0)
       this._children.splice(index, 1);
   }
+  notify(...args) {
+    if (this._parent)
+      return this._parent.notify(...args);
+    return false;
+  }
 };
 var globalQueue = new Queue();
 function flushSync() {
@@ -184,23 +191,20 @@ var Owner = class {
   _state = STATE_CLEAN;
   _disposal = null;
   _context = defaultContext;
-  _handlers = null;
   _queue = globalQueue;
-  _siblingCount = null;
   _childCount = 0;
   id = null;
   constructor(id = null, skipAppend = false) {
     this.id = id;
-    if (currentOwner && !skipAppend)
-      currentOwner.append(this);
+    if (currentOwner) {
+      if (!id && currentOwner.id)
+        this.id = currentOwner.getNextChildId();
+      !skipAppend && currentOwner.append(this);
+    }
   }
   append(child) {
     child._parent = this;
     child._prevSibling = this;
-    if (this.id) {
-      child._siblingCount = this._nextSibling ? this._nextSibling._siblingCount + 1 : 0;
-      child.id = formatId(this.id, child._siblingCount);
-    }
     if (this._nextSibling)
       this._nextSibling._prevSibling = child;
     child._nextSibling = this._nextSibling;
@@ -208,9 +212,6 @@ var Owner = class {
     if (child._context !== this._context) {
       child._context = { ...this._context, ...child._context };
     }
-    if (this._handlers) {
-      child._handlers = !child._handlers ? this._handlers : [...child._handlers, ...this._handlers];
-    }
     if (this._queue)
       child._queue = this._queue;
   }
@@ -225,6 +226,7 @@ var Owner = class {
       current._nextSibling = null;
       current = next;
     }
+    this._childCount = 0;
     if (self)
       this._disposeNode();
     if (current)
@@ -238,7 +240,6 @@ var Owner = class {
     this._parent = null;
     this._prevSibling = null;
     this._context = defaultContext;
-    this._handlers = null;
     this._state = STATE_DISPOSED;
     this.emptyDisposal();
   }
@@ -255,27 +256,9 @@ var Owner = class {
     }
     this._disposal = null;
   }
-  addErrorHandler(handler) {
-    this._handlers = this._handlers ? [handler, ...this._handlers] : [handler];
-  }
-  handleError(error) {
-    if (!this._handlers)
-      throw error;
-    let i = 0, len = this._handlers.length;
-    for (i = 0; i < len; i++) {
-      try {
-        this._handlers[i](error, this);
-        break;
-      } catch (e) {
-        error = e;
-      }
-    }
-    if (i === len)
-      throw error;
-  }
   getNextChildId() {
     if (this.id)
-      return formatId(this.id + "-", this._childCount++);
+      return formatId(this.id, this._childCount++);
     throw new Error("Cannot get child id from owner without an id");
   }
 };
@@ -800,10 +783,10 @@ var Effect = class extends Computation {
   }
   write(value, flags = 0) {
     if (this._state == STATE_DIRTY) {
-      const currentFlags = this._stateFlags;
+      this._stateFlags;
       this._stateFlags = flags;
-      if (this._type === EFFECT_RENDER && (flags & LOADING_BIT) !== (currentFlags & LOADING_BIT)) {
-        this._queue._update?.(this);
+      if (this._type === EFFECT_RENDER) {
+        this._queue.notify(this, LOADING_BIT | ERROR_BIT, flags);
       }
     }
     if (value === UNCHANGED)
@@ -820,10 +803,9 @@ var Effect = class extends Computation {
     this._state = state;
   }
   _setError(error) {
+    this._error = error;
     this._cleanup?.();
-    if (this._stateFlags & LOADING_BIT) {
-      this._queue._update?.(this);
-    }
+    this._queue.notify(this, LOADING_BIT, 0);
     this._stateFlags = ERROR_BIT;
     if (this._type === EFFECT_USER) {
       try {
@@ -832,7 +814,8 @@ var Effect = class extends Computation {
         error = e;
       }
     }
-    this.handleError(error);
+    if (!this._queue.notify(this, ERROR_BIT, ERROR_BIT))
+      throw error;
   }
   _disposeNode() {
     if (this._state === STATE_DISPOSED)
@@ -850,7 +833,8 @@ var Effect = class extends Computation {
       try {
         this._cleanup = this._effect(this._value, this._prevValue);
       } catch (e) {
-        this.handleError(e);
+        if (!this._queue.notify(this, ERROR_BIT, ERROR_BIT))
+          throw e;
       } finally {
         this._prevValue = this._value;
         this._modified = false;
@@ -882,104 +866,132 @@ var ProjectionComputation = class extends Computation {
   _notify(state, skipQueue) {
     if (this._state >= state && !this._forceNotify)
       return;
-    if (this._state === STATE_CLEAN && !skipQueue)
+    if (!skipQueue && (this._state === STATE_CLEAN || this._state === STATE_CHECK && this._forceNotify))
       this._queue.enqueue(EFFECT_PURE, this);
     super._notify(state, true);
+    this._forceNotify = !!skipQueue;
   }
 };
 
 // src/core/boundaries.ts
-function createBoundary(owner, fn, queue) {
-  if (queue) {
-    const parentQueue = owner._queue;
-    parentQueue.addChild(owner._queue = queue);
-    onCleanup(() => parentQueue.removeChild(owner._queue));
+var BoundaryComputation = class extends EagerComputation {
+  _propagationMask;
+  constructor(compute2, propagationMask) {
+    super(void 0, compute2, { defer: true });
+    this._propagationMask = propagationMask;
+  }
+  write(value, flags) {
+    super.write(value, flags & ~this._propagationMask);
+    if (this._propagationMask & LOADING_BIT && !(this._stateFlags & UNINITIALIZED_BIT)) {
+      flags &= ~LOADING_BIT;
+    }
+    this._queue.notify(this, this._propagationMask, flags);
+    return this._value;
   }
+};
+function createBoundChildren(owner, fn, queue, mask) {
+  const parentQueue = owner._queue;
+  parentQueue.addChild(owner._queue = queue);
+  onCleanup(() => parentQueue.removeChild(owner._queue));
   return compute(
     owner,
     () => {
       const c = new Computation(void 0, fn);
-      return new EagerComputation(void 0, () => flatten(c.wait()), { defer: true });
+      return new BoundaryComputation(() => flatten(c.wait()), mask);
     },
     null
   );
 }
-function createDecision(main, condition, fallback) {
-  const decision = new Computation(void 0, () => {
-    if (!condition.read()) {
-      const resolved = main.read();
-      if (!condition.read())
-        return resolved;
-    }
-    return fallback();
-  });
-  return decision.read.bind(decision);
-}
-var SuspenseQueue = class extends Queue {
-  _nodes = /* @__PURE__ */ new Set();
-  _fallback = new Computation(false, null);
+var ConditionalQueue = class extends Queue {
+  _disabled;
+  _errorNodes = /* @__PURE__ */ new Set();
+  _pendingNodes = /* @__PURE__ */ new Set();
+  constructor(disabled) {
+    super();
+    this._disabled = disabled;
+  }
   run(type) {
-    if (type && this._fallback.read())
+    if (type && this._disabled.read())
       return;
     return super.run(type);
   }
-  _update(node) {
-    if (node._stateFlags & LOADING_BIT) {
+  notify(node, type, flags) {
+    if (this._disabled.read()) {
+      if (type === LOADING_BIT) {
+        flags & LOADING_BIT ? this._pendingNodes.add(node) : this._pendingNodes.delete(node);
+      }
+      if (type === ERROR_BIT) {
+        flags & ERROR_BIT ? this._errorNodes.add(node) : this._errorNodes.delete(node);
+      }
+      return true;
+    }
+    return super.notify(node, type, flags);
+  }
+};
+var CollectionQueue = class extends Queue {
+  _collectionType;
+  _nodes = /* @__PURE__ */ new Set();
+  _disabled = new Computation(false, null);
+  constructor(type) {
+    super();
+    this._collectionType = type;
+  }
+  notify(node, type, flags) {
+    if (!(type & this._collectionType))
+      return super.notify(node, type, flags);
+    if (flags & this._collectionType) {
       this._nodes.add(node);
       if (this._nodes.size === 1)
-        this._fallback.write(true);
+        this._disabled.write(true);
     } else {
       this._nodes.delete(node);
       if (this._nodes.size === 0)
-        this._fallback.write(false);
+        this._disabled.write(false);
     }
+    type &= ~this._collectionType;
+    return type ? super.notify(node, type, flags) : true;
   }
 };
-function createSuspense(fn, fallback) {
+function createBoundary(fn, condition) {
   const owner = new Owner();
-  const queue = new SuspenseQueue();
-  const tree = createBoundary(owner, fn, queue);
-  const ogWrite = tree.write;
-  tree.write = function(value, flags = 0) {
-    const currentFlags = this._stateFlags;
-    const dirty = this._state === STATE_DIRTY;
-    ogWrite.call(this, value, flags);
-    if (dirty && (flags & LOADING_BIT) !== (currentFlags & LOADING_BIT)) {
-      this._queue._update?.(this);
+  const queue = new ConditionalQueue(new Computation(void 0, () => condition() === "hidden" /* HIDDEN */));
+  const tree = createBoundChildren(owner, fn, queue, 0);
+  new EagerComputation(void 0, () => {
+    const disabled = queue._disabled.read();
+    tree._propagationMask = disabled ? ERROR_BIT | LOADING_BIT : 0;
+    if (!disabled) {
+      queue._pendingNodes.forEach((node) => queue.notify(node, LOADING_BIT, LOADING_BIT));
+      queue._errorNodes.forEach((node) => queue.notify(node, ERROR_BIT, ERROR_BIT));
+      queue._pendingNodes.clear();
+      queue._errorNodes.clear();
     }
-    return this._value;
-  };
-  return createDecision(tree, queue._fallback, fallback);
+  });
+  return () => queue._disabled.read() ? void 0 : tree.read();
 }
-function createErrorBoundary(fn, fallback) {
+function createCollectionBoundary(type, fn, fallback) {
   const owner = new Owner();
-  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.addErrorHandler(handler);
-  const tree = createBoundary(owner, fn);
-  tree._setError = tree.handleError;
-  return createDecision(
-    tree,
-    error,
-    () => fallback(error.read()._error, () => {
+  const queue = new CollectionQueue(type);
+  const tree = createBoundChildren(owner, fn, queue, type);
+  const decision = new Computation(void 0, () => {
+    if (!queue._disabled.read()) {
+      const resolved = tree.read();
+      if (!queue._disabled.read())
+        return resolved;
+    }
+    return fallback(queue);
+  });
+  return decision.read.bind(decision);
+}
+function createSuspense(fn, fallback) {
+  return createCollectionBoundary(LOADING_BIT, fn, () => fallback());
+}
+function createErrorBoundary(fn, fallback) {
+  return createCollectionBoundary(
+    ERROR_BIT,
+    fn,
+    (queue) => fallback(queue._nodes.values().next().value._error, () => {
       incrementClock();
-      for (let node of nodes) {
+      for (let node of queue._nodes) {
         node._state = STATE_DIRTY;
         node._queue?.enqueue(node._type, node);
       }
@@ -1238,7 +1250,7 @@ function ownKeys(target) {
   trackSelf(target);
   return Reflect.ownKeys(target[STORE_VALUE]);
 }
-var Writing = /* @__PURE__ */ new Set();
+var Writing = null;
 var proxyTraps = {
   get(target, property, receiver) {
     if (property === $TARGET)
@@ -1259,7 +1271,7 @@ var proxyTraps = {
       if (desc && desc.get)
         return desc.get.call(receiver);
     }
-    if (Writing.has(storeValue)) {
+    if (Writing?.has(storeValue)) {
       const value2 = tracked ? tracked._value : storeValue[property];
       return isWrappable(value2) ? (Writing.add(value2[$RAW] || value2), wrap2(value2)) : value2;
     }
@@ -1282,11 +1294,11 @@ var proxyTraps = {
     return has;
   },
   set(target, property, value) {
-    Writing.has(target[STORE_VALUE]) && setProperty(target[STORE_VALUE], property, unwrap(value, false));
+    Writing?.has(target[STORE_VALUE]) && setProperty(target[STORE_VALUE], property, unwrap(value, false));
     return true;
   },
   deleteProperty(target, property) {
-    Writing.has(target[STORE_VALUE]) && setProperty(target[STORE_VALUE], property, void 0, true);
+    Writing?.has(target[STORE_VALUE]) && setProperty(target[STORE_VALUE], property, void 0, true);
     return true;
   },
   ownKeys,
@@ -1369,11 +1381,14 @@ function createStore(first, second) {
   const unwrappedStore = unwrap(store);
   let wrappedStore = wrap2(unwrappedStore);
   const setStore = (fn) => {
+    const prevWriting = Writing;
+    Writing = /* @__PURE__ */ new Set();
+    Writing.add(unwrappedStore);
     try {
-      Writing.add(unwrappedStore);
       fn(wrappedStore);
     } finally {
       Writing.clear();
+      Writing = prevWriting;
     }
   };
   if (derived)
@@ -1843,4 +1858,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, createAsync, createContext, createEffect, createErrorBoundary, createMemo, createProjection, createRenderEffect, createRoot, createSignal, createStore, createSuspense, deep, flatten, flushSync, getContext, getObserver, getOwner, hasContext, hasUpdated, isEqual, isPending, isWrappable, latest, mapArray, merge, omit, onCleanup, reconcile, repeat, resolve, runWithObserver, runWithOwner, setContext, tryCatch, untrack, unwrap };
+export { $PROXY, $RAW, $TARGET, $TRACK, Computation, ContextNotFoundError, NoOwnerError, NotReadyError, Owner, Queue, SUPPORTS_PROXY, createAsync, createBoundary, createContext, createEffect, createErrorBoundary, createMemo, createProjection, createRenderEffect, createRoot, createSignal, createStore, createSuspense, deep, flatten, flushSync, getContext, getObserver, getOwner, hasContext, hasUpdated, isEqual, isPending, isWrappable, latest, mapArray, merge, omit, onCleanup, reconcile, repeat, resolve, runWithObserver, runWithOwner, setContext, tryCatch, untrack, unwrap };