@solidjs/signals 0.1.0 → 0.2.1

package/dist/dev.js

@@ -658,24 +658,32 @@ function hasUpdated(fn) {
     updateCheck = current;
   }
 }
-function isStale(fn) {
+function isPending(fn, loadingValue) {
+  const argLength = arguments.length;
   const current = staleCheck;
   staleCheck = { _value: false };
   try {
     latest(fn);
     return staleCheck._value;
-  } catch {
+  } catch (err) {
+    if (argLength > 1 && err instanceof NotReadyError)
+      return !!loadingValue;
+    throw err;
   } finally {
     staleCheck = current;
   }
-  return false;
 }
-function latest(fn) {
+function latest(fn, fallback) {
+  const argLength = arguments.length;
   const prevFlags = newFlags;
   const prevNotStale = notStale;
   notStale = false;
   try {
     return fn();
+  } catch (err) {
+    if (argLength > 1 && err instanceof NotReadyError)
+      return fallback;
+    throw err;
   } finally {
     newFlags = prevFlags;
     notStale = prevNotStale;
@@ -690,6 +698,46 @@ function catchError(fn) {
     return e;
   }
 }
+function runWithObserver(observer, run) {
+  const prevSources = newSources, prevSourcesIndex = newSourcesIndex, prevFlags = newFlags;
+  newSources = null;
+  newSourcesIndex = observer._sources ? observer._sources.length : 0;
+  newFlags = 0;
+  try {
+    return compute(observer, run, observer);
+  } catch (error) {
+    if (error instanceof NotReadyError) {
+      observer.write(
+        UNCHANGED,
+        newFlags | LOADING_BIT | observer._stateFlags & UNINITIALIZED_BIT
+      );
+    } else {
+      observer._setError(error);
+    }
+  } finally {
+    if (newSources) {
+      if (newSourcesIndex > 0) {
+        observer._sources.length = newSourcesIndex + newSources.length;
+        for (let i = 0; i < newSources.length; i++) {
+          observer._sources[newSourcesIndex + i] = newSources[i];
+        }
+      } else {
+        observer._sources = newSources;
+      }
+      let source;
+      for (let i = newSourcesIndex; i < observer._sources.length; i++) {
+        source = observer._sources[i];
+        if (!source._observers)
+          source._observers = [observer];
+        else
+          source._observers.push(observer);
+      }
+    }
+    newSources = prevSources;
+    newSourcesIndex = prevSourcesIndex;
+    newFlags = prevFlags;
+  }
+}
 function compute(owner, fn, observer) {
   const prevOwner = setOwner(owner), prevObserver = currentObserver, prevMask = currentMask, prevNotStale = notStale;
   currentObserver = observer;
@@ -729,10 +777,8 @@ var Effect = class extends Computation {
     if (this._type === EFFECT_RENDER) {
       this._compute = (p) => getClock() > this._queue.created ? latest(() => compute2(p)) : compute2(p);
     }
-    if (!options?.defer) {
-      this._updateIfNecessary();
-      this._type === EFFECT_USER ? this._queue.enqueue(this._type, this) : this._runEffect();
-    }
+    this._updateIfNecessary();
+    !options?.defer && (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");
   }
@@ -977,13 +1023,13 @@ function createEffect(compute2, effect, error, value, options) {
     compute2,
     effect,
     error,
-    { name: options?.name ?? "effect" } 
+    { ...options, name: options?.name ?? "effect" } 
   );
 }
 function createRenderEffect(compute2, effect, value, options) {
   void new Effect(value, compute2, effect, void 0, {
     render: true,
-    ...{ name: options?.name ?? "effect" } 
+    ...{ ...options, name: options?.name ?? "effect" } 
   });
 }
 function createRoot(init) {
@@ -991,12 +1037,7 @@ function createRoot(init) {
   return compute(owner, !init.length ? init : () => init(() => owner.dispose()), null);
 }
 function runWithOwner(owner, run) {
-  try {
-    return compute(owner, run, null);
-  } catch (error) {
-    owner?.handleError(error);
-    return void 0;
-  }
+  return compute(owner, run, null);
 }
 function createErrorBoundary(fn, fallback) {
   const owner = new Owner();
@@ -1063,19 +1104,6 @@ function resolve(fn) {
     });
   });
 }
-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
 function createProjection(fn, initialValue = {}) {
@@ -1726,4 +1754,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, isStale, isWrappable, latest, mapArray, merge, omit, onCleanup, reconcile, repeat, resolve, 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, createRenderEffect, createRoot, createSignal, createStore, createSuspense, flatten, flushSync, getContext, getObserver, getOwner, hasContext, hasUpdated, isEqual, isPending, isWrappable, latest, mapArray, merge, omit, onCleanup, reconcile, repeat, resolve, runWithObserver, runWithOwner, setContext, untrack, unwrap };