@solidjs/signals 0.0.6 → 0.0.8

package/dist/dev.js

@@ -13,6 +13,15 @@ var ContextNotFoundError = class extends Error {
     );
   }
 };
+var EffectError = class extends Error {
+  constructor(effect, cause) {
+    super(`Uncaught error while running effect:
+
+  ${effect.toString()}
+` );
+    this.cause = cause;
+  }
+};
 
 // src/core/constants.ts
 var STATE_CLEAN = 0;
@@ -242,6 +251,9 @@ var updateCheck = null;
 function getObserver() {
   return currentObserver;
 }
+function getClock() {
+  return clock;
+}
 function incrementClock() {
   clock++;
 }
@@ -261,9 +273,9 @@ var Computation = class extends Owner {
   _stateFlags = 0;
   /** Which flags raised by sources are handled, vs. being passed through. */
   _handlerMask = DEFAULT_FLAGS;
-  _error = null;
   _loading = null;
   _time = -1;
+  _forceNotify = false;
   constructor(initialValue, compute2, options) {
     super(compute2 === null);
     this._compute = compute2;
@@ -302,6 +314,9 @@ var Computation = class extends Owner {
    * before continuing
    */
   wait() {
+    if (this._compute && this._stateFlags & ERROR_BIT && this._time <= clock) {
+      update(this);
+    }
     if (!syncResolve && this.loading()) {
       throw new NotReadyError();
     }
@@ -320,16 +335,6 @@ var Computation = class extends Owner {
     }
     return this._loading.read();
   }
-  /**
-   * Return true if the computation is the computation threw an error
-   * Triggers re-execution of the computation when the error state changes
-   */
-  error() {
-    if (this._error === null) {
-      this._error = errorState(this);
-    }
-    return this._error.read();
-  }
   /** Update the computation with a new value. */
   write(value, flags = 0, raw = false) {
     const newValue = !raw && typeof value === "function" ? value(this._value) : value;
@@ -353,13 +358,14 @@ var Computation = class extends Owner {
   /**
    * Set the current node's state, and recursively mark all of this node's observers as STATE_CHECK
    */
-  _notify(state) {
-    if (this._state >= state)
+  _notify(state, skipQueue) {
+    if (this._state >= state && !this._forceNotify)
       return;
+    this._forceNotify = !!skipQueue;
     this._state = state;
     if (this._observers) {
       for (let i = 0; i < this._observers.length; i++) {
-        this._observers[i]._notify(STATE_CHECK);
+        this._observers[i]._notify(STATE_CHECK, skipQueue);
       }
     }
   }
@@ -392,7 +398,7 @@ var Computation = class extends Owner {
     }
   }
   _setError(error) {
-    this.write(error, this._stateFlags | ERROR_BIT);
+    this.write(error, this._stateFlags & ~LOADING_BIT | ERROR_BIT);
   }
   /**
    * This is the core part of the reactivity system, which makes sure that the values are updated
@@ -452,22 +458,6 @@ function loadingState(node) {
   setOwner(prevOwner);
   return computation;
 }
-function errorState(node) {
-  const prevOwner = setOwner(node._parent);
-  const options = { name: node._name ? `error ${node._name}` : "error" } ;
-  const computation = new Computation(
-    void 0,
-    () => {
-      track(node);
-      node._updateIfNecessary();
-      return !!(node._stateFlags & ERROR_BIT);
-    },
-    options
-  );
-  computation._handlerMask = ERROR_BIT;
-  setOwner(prevOwner);
-  return computation;
-}
 function track(computation) {
   if (currentObserver) {
     if (!newSources && currentObserver._sources && currentObserver._sources[newSourcesIndex] === computation) {
@@ -525,6 +515,7 @@ function update(node) {
     newSources = prevSources;
     newSourcesIndex = prevSourcesIndex;
     newFlags = prevFlags;
+    node._time = clock + 1;
     node._state = STATE_CLEAN;
   }
 }
@@ -568,7 +559,7 @@ function isPending(fn) {
     return e instanceof NotReadyError;
   }
 }
-function latest(fn) {
+function resolveSync(fn) {
   const prevFlags = newFlags;
   syncResolve = true;
   try {
@@ -579,6 +570,15 @@ function latest(fn) {
     syncResolve = false;
   }
 }
+function catchError(fn) {
+  try {
+    fn();
+  } catch (e) {
+    if (e instanceof NotReadyError)
+      throw e;
+    return e;
+  }
+}
 function compute(owner, compute2, observer) {
   const prevOwner = setOwner(owner), prevObserver = currentObserver, prevMask = currentMask;
   currentObserver = observer;
@@ -622,16 +622,20 @@ var Queue = class {
         runEffectQueue(effects);
       }
     }
+    let rerun = false;
     for (let i = 0; i < this._children.length; i++) {
-      this._children[i].run(type);
+      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 {
-      this.run(EFFECT_PURE);
+      while (this.run(EFFECT_PURE)) {
+      }
       incrementClock();
       scheduled = false;
       this.run(EFFECT_RENDER);
@@ -650,22 +654,14 @@ var Queue = class {
   }
 };
 var globalQueue = new Queue();
-var globalTasks = [];
 function flushSync() {
   let count = 0;
   while (scheduled) {
     if (++count === 1e5)
       throw new Error("Potential Infinite Loop Detected.");
     globalQueue.flush();
-    for (let i = 0; i < globalTasks.length; i++)
-      globalTasks[i]();
-    globalTasks.length = 0;
   }
 }
-function queueTask(fn) {
-  globalTasks.push(fn);
-  schedule();
-}
 function createBoundary(fn, queue) {
   const owner = new Owner();
   const parentQueue = owner._queue || globalQueue;
@@ -699,18 +695,23 @@ function runEffectQueue(queue) {
 // src/core/effect.ts
 var Effect = class extends Computation {
   _effect;
+  _error;
+  _cleanup;
   _modified = false;
   _prevValue;
   _type;
   _queue;
-  constructor(initialValue, compute2, effect, options) {
+  constructor(initialValue, compute2, effect, error, options) {
     super(initialValue, compute2, options);
     this._effect = effect;
+    this._error = error;
     this._prevValue = initialValue;
     this._type = options?.render ? EFFECT_RENDER : EFFECT_USER;
     this._queue = getOwner()?._queue || globalQueue;
-    this._updateIfNecessary();
-    this._type === EFFECT_USER ? this._queue.enqueue(this._type, this) : this._runEffect();
+    if (!options?.defer) {
+      this._updateIfNecessary();
+      this._type === EFFECT_USER ? this._queue.enqueue(this._type, this) : this._runEffect();
+    }
     if (!this._parent)
       console.warn("Effects created outside a reactive context will never be disposed");
   }
@@ -726,26 +727,49 @@ var Effect = class extends Computation {
     this._modified = true;
     return value;
   }
-  _notify(state) {
-    if (this._state >= state)
+  _notify(state, skipQueue) {
+    if (this._state >= state || skipQueue)
       return;
     if (this._state === STATE_CLEAN)
       this._queue.enqueue(this._type, this);
     this._state = state;
   }
   _setError(error) {
+    this._cleanup?.();
+    if (this._stateFlags & LOADING_BIT) {
+      this._stateFlags = 0;
+      this._queue._update?.(this);
+    }
+    if (this._type === EFFECT_USER) {
+      try {
+        return this._error ? this._cleanup = this._error(error) : console.error(new EffectError(this._effect, error));
+      } catch (e) {
+        error = e;
+      }
+    }
     this.handleError(error);
   }
   _disposeNode() {
+    if (this._state === STATE_DISPOSED)
+      return;
     this._effect = void 0;
     this._prevValue = void 0;
+    this._error = void 0;
+    this._cleanup?.();
+    this._cleanup = void 0;
     super._disposeNode();
   }
   _runEffect() {
     if (this._modified && this._state !== STATE_DISPOSED) {
-      this._effect(this._value, this._prevValue);
-      this._prevValue = this._value;
-      this._modified = false;
+      this._cleanup?.();
+      try {
+        this._cleanup = this._effect(this._value, this._prevValue);
+      } catch (e) {
+        this.handleError(e);
+      } finally {
+        this._prevValue = this._value;
+        this._modified = false;
+      }
     }
   }
 };
@@ -758,12 +782,12 @@ var EagerComputation = class extends Computation {
     if (!this._parent)
       console.warn("Eager Computations created outside a reactive context will never be disposed");
   }
-  _notify(state) {
-    if (this._state >= state)
+  _notify(state, skipQueue) {
+    if (this._state >= state && !this._forceNotify)
       return;
-    if (this._state === STATE_CLEAN)
+    if (this._state === STATE_CLEAN && !skipQueue)
       this._queue.enqueue(EFFECT_PURE, this);
-    super._notify(state);
+    super._notify(state, skipQueue);
   }
 };
 
@@ -775,20 +799,20 @@ var SuspenseQueue = class extends Queue {
   run(type) {
     if (type && this._fallback)
       return;
-    super.run(type);
+    return super.run(type);
   }
   _update(node) {
     if (node._stateFlags & LOADING_BIT) {
       this._nodes.add(node);
       if (!this._fallback) {
         this._fallback = true;
-        queueTask(() => this._signal.write(true));
+        this._signal.write(true);
       }
     } else {
       this._nodes.delete(node);
       if (this._nodes.size === 0) {
         this._fallback = false;
-        queueTask(() => this._signal.write(false));
+        this._signal.write(false);
       }
     }
   }
@@ -870,6 +894,14 @@ function createAsync(compute2, value, options) {
         };
       }
       const signal = new Computation(value2, null, options);
+      const w = signal.wait;
+      signal.wait = function() {
+        if (signal._stateFlags & ERROR_BIT && signal._time <= getClock()) {
+          lhs._notify(STATE_DIRTY);
+          throw new NotReadyError();
+        }
+        return w.call(this);
+      };
       signal.write(UNCHANGED, LOADING_BIT);
       if (isPromise) {
         source.then(
@@ -900,16 +932,17 @@ function createAsync(compute2, value, options) {
   );
   return () => lhs.wait().wait();
 }
-function createEffect(compute2, effect, value, options) {
+function createEffect(compute2, effect, error, value, options) {
   void new Effect(
     value,
     compute2,
     effect,
+    error,
     { name: options?.name ?? "effect" } 
   );
 }
 function createRenderEffect(compute2, effect, value, options) {
-  void new Effect(value, compute2, effect, {
+  void new Effect(value, compute2, effect, void 0, {
     render: true,
     ...{ name: options?.name ?? "effect" } 
   });
@@ -957,6 +990,71 @@ function createErrorBoundary(fn, fallback) {
   });
   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);
+    });
+  });
+}
+function createReaction(effect, error, options) {
+  const node = new Effect(void 0, () => {
+  }, effect, error, {
+    defer: true,
+    ...{ name: options?.name ?? "reaction" } 
+  });
+  return (tracking) => {
+    node._compute = tracking;
+    node._state = STATE_DIRTY;
+    node._updateIfNecessary();
+    node._compute = null;
+  };
+}
+
+// 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, () => {
+    setStore(fn);
+  });
+  const wrapped = /* @__PURE__ */ new WeakMap();
+  return wrap(store, node, wrapped);
+}
+function wrap(source, node, wrapped) {
+  if (wrapped.has(source))
+    return wrapped.get(source);
+  const wrap3 = new Proxy(source, {
+    get(target, property) {
+      node.read();
+      const v = target[property];
+      return isWrappable(v) ? wrap3(v, node, wrapped) : v;
+    },
+    set() {
+      throw new Error("Projections are readonly");
+    },
+    deleteProperty() {
+      throw new Error("Projections are readonly");
+    }
+  });
+  wrapped.set(source, wrap3);
+  return wrap3;
+}
 
 // src/store/store.ts
 var $RAW = Symbol("STORE_RAW" );
@@ -966,7 +1064,7 @@ var $PROXY = Symbol("STORE_PROXY" );
 var STORE_VALUE = "v";
 var STORE_NODE = "n";
 var STORE_HAS = "h";
-function wrap(value) {
+function wrap2(value) {
   let p = value[$PROXY];
   if (!p) {
     let target;
@@ -1075,7 +1173,7 @@ var proxyTraps = {
     }
     if (Writing.has(storeValue)) {
       const value2 = tracked ? tracked._value : storeValue[property];
-      return isWrappable(value2) ? (Writing.add(value2[$RAW] || value2), wrap(value2)) : value2;
+      return isWrappable(value2) ? (Writing.add(value2[$RAW] || value2), wrap2(value2)) : value2;
     }
     let value = tracked ? nodes[property].read() : storeValue[property];
     if (!tracked) {
@@ -1083,10 +1181,10 @@ var proxyTraps = {
         let proto;
         return !Array.isArray(storeValue) && (proto = Object.getPrototypeOf(storeValue)) && proto !== Object.prototype ? value.bind(storeValue) : value;
       } else if (getObserver()) {
-        value = getNode(nodes, property, isWrappable(value) ? wrap(value) : value).read();
+        value = getNode(nodes, property, isWrappable(value) ? wrap2(value) : value).read();
       }
     }
-    return isWrappable(value) ? wrap(value) : value;
+    return isWrappable(value) ? wrap2(value) : value;
   },
   has(target, property) {
     if (property === $RAW || property === $PROXY || property === $TRACK || property === "__proto__")
@@ -1128,13 +1226,16 @@ function setProperty(state, property, value, deleting = false) {
   const nodes = getNodes(target, STORE_NODE);
   let node;
   if (node = nodes[property])
-    node.write(isWrappable(value) ? wrap(value) : value);
+    node.write(isWrappable(value) ? wrap2(value) : value);
   Array.isArray(state) && state.length !== len && (node = nodes.length) && node.write(state.length);
   (node = nodes[$TRACK]) && node.write(void 0);
 }
 function createStore(first, second) {
-  const derived = typeof first === "function", store = derived ? second : first, unwrappedStore = unwrap(store, false);
-  const wrappedStore = wrap(unwrappedStore);
+  const derived = typeof first === "function", store = derived ? second : first;
+  if (derived)
+    return createProjection(first, store);
+  const unwrappedStore = unwrap(store, false);
+  const wrappedStore = wrap2(unwrappedStore);
   const setStore = (fn) => {
     try {
       Writing.add(unwrappedStore);
@@ -1143,15 +1244,8 @@ function createStore(first, second) {
       Writing.clear();
     }
   };
-  if (derived) {
-    new EagerComputation(void 0, () => setStore(first));
-  }
   return [wrappedStore, setStore];
 }
-function createProjection(fn, initialValue = {}) {
-  const [store] = createStore(fn, initialValue);
-  return store;
-}
 
 // src/store/reconcile.ts
 function applyState(next, state, keyFn) {
@@ -1172,7 +1266,7 @@ function applyState(next, state, keyFn) {
     if (next.length && previous.length && next[0] && keyFn(next[0]) != null) {
       let i, j, start, end, newEnd, item, newIndicesNext, keyVal;
       for (start = 0, end = Math.min(previous.length, next.length); start < end && (previous[start] === next[start] || previous[start] && next[start] && keyFn(previous[start]) === keyFn(next[start])); start++) {
-        applyState(next[start], wrap(previous[start]), keyFn);
+        applyState(next[start], wrap2(previous[start]), keyFn);
       }
       const temp = new Array(next.length), newIndices = /* @__PURE__ */ new Map();
       for (end = previous.length - 1, newEnd = next.length - 1; end >= start && newEnd >= start && (previous[end] === next[newEnd] || previous[end] && next[newEnd] && keyFn(previous[end]) === keyFn(next[newEnd])); end--, newEnd--) {
@@ -1181,11 +1275,11 @@ function applyState(next, state, keyFn) {
       if (start > newEnd || start > end) {
         for (j = start; j <= newEnd; j++) {
           changed = true;
-          target[STORE_NODE][j]?.write(wrap(next[j]));
+          target[STORE_NODE][j]?.write(wrap2(next[j]));
         }
         for (; j < next.length; j++) {
           changed = true;
-          const wrapped = wrap(temp[j]);
+          const wrapped = wrap2(temp[j]);
           target[STORE_NODE][j]?.write(wrapped);
           applyState(next[j], wrapped, keyFn);
         }
@@ -1213,17 +1307,17 @@ function applyState(next, state, keyFn) {
       }
       for (j = start; j < next.length; j++) {
         if (j in temp) {
-          const wrapped = wrap(temp[j]);
+          const wrapped = wrap2(temp[j]);
           target[STORE_NODE][j]?.write(wrapped);
           applyState(next[j], wrapped, keyFn);
         } else
-          target[STORE_NODE][j]?.write(wrap(next[j]));
+          target[STORE_NODE][j]?.write(wrap2(next[j]));
       }
       if (start < next.length)
         changed = true;
     } else if (previous.length && next.length) {
       for (let i = 0, len = next.length; i < len; i++) {
-        isWrappable(previous[i]) && applyState(next[i], wrap(previous[i]), keyFn);
+        isWrappable(previous[i]) && applyState(next[i], wrap2(previous[i]), keyFn);
       }
     }
     if (previous.length !== next.length) {
@@ -1243,9 +1337,9 @@ function applyState(next, state, keyFn) {
       if (previousValue === nextValue)
         continue;
       if (!previousValue || !isWrappable(previousValue) || keyFn(previousValue) != null && keyFn(previousValue) !== keyFn(nextValue))
-        node.write(isWrappable(nextValue) ? wrap(nextValue) : nextValue);
+        node.write(isWrappable(nextValue) ? wrap2(nextValue) : nextValue);
       else
-        applyState(nextValue, wrap(previousValue), keyFn);
+        applyState(nextValue, wrap2(previousValue), keyFn);
     }
   }
   if (nodes = target[STORE_HAS]) {
@@ -1532,8 +1626,54 @@ function updateKeyedMap() {
   });
   return this._mappings;
 }
+function repeat(count, map, options) {
+  return updateRepeat.bind({
+    _owner: new Owner(),
+    _len: 0,
+    _count: count,
+    _map: map,
+    _nodes: [],
+    _mappings: [],
+    _fallback: options?.fallback
+  });
+}
+function updateRepeat() {
+  const newLen = this._count();
+  runWithOwner(this._owner, () => {
+    if (newLen === 0) {
+      if (this._len !== 0) {
+        this._owner.dispose(false);
+        this._nodes = [];
+        this._mappings = [];
+        this._len = 0;
+      }
+      if (this._fallback && !this._mappings[0]) {
+        this._mappings[0] = compute(
+          this._nodes[0] = new Owner(),
+          this._fallback,
+          null
+        );
+      }
+    } else {
+      if (this._len === 0 && this._nodes[0])
+        this._nodes[0].dispose();
+      for (let i = this._len; i < newLen; i++) {
+        this._mappings[i] = compute(
+          this._nodes[i] = new Owner(),
+          () => this._map(i),
+          null
+        );
+      }
+      for (let i = newLen; i < this._len; i++)
+        this._nodes[i].dispose();
+      this._mappings = this._mappings.slice(0, newLen);
+      this._len = newLen;
+    }
+  });
+  return this._mappings;
+}
 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, createBoundary, createContext, createEffect, createErrorBoundary, createMemo, createProjection, createRenderEffect, createRoot, createSignal, createStore, createSuspense, flatten, flushSync, getContext, getObserver, getOwner, hasContext, hasUpdated, isEqual, isPending, isWrappable, latest, mapArray, merge, omit, onCleanup, reconcile, 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, isPending, isWrappable, mapArray, merge, omit, onCleanup, reconcile, repeat, resolve, resolveSync, runWithOwner, setContext, untrack, unwrap };