@solidjs/signals 0.6.4 → 0.7.1

package/dist/dev.js

@@ -982,46 +982,6 @@ function latest(fn, fallback) {
     notStale = prevNotStale;
   }
 }
-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;
@@ -1140,6 +1100,39 @@ var Effect = class extends Computation {
       this._state !== STATE_CLEAN && runTop(this);
   }
 };
+var TrackedEffect = class extends Computation {
+  _type = EFFECT_USER;
+  _cleanup;
+  constructor(compute2, options) {
+    super(void 0, () => {
+      this._cleanup?.();
+      this._cleanup = latest(compute2);
+      return void 0;
+    }, options);
+    getQueue(this).enqueue(this._type, this._run.bind(this));
+    if (!this._parent)
+      console.warn("Effects created outside a reactive context will never be disposed");
+  }
+  _notify(state, skipQueue) {
+    if (this._state >= state || skipQueue)
+      return;
+    if (this._state === STATE_CLEAN || this._cloned && !ActiveTransition)
+      getQueue(this).enqueue(this._type, this._run.bind(this));
+    this._state = state;
+  }
+  _disposeNode() {
+    if (this._state === STATE_DISPOSED)
+      return;
+    this._cleanup?.();
+    this._cleanup = void 0;
+    getQueue(this).notify(this, ERROR_BIT | LOADING_BIT, 0);
+    super._disposeNode();
+  }
+  _run(type) {
+    if (type)
+      this._state !== STATE_CLEAN && runTop(this);
+  }
+};
 var EagerComputation = class extends Computation {
   constructor(initialValue, compute2, options) {
     super(initialValue, compute2, options);
@@ -1195,15 +1188,11 @@ function runTop(node) {
 // src/signals.ts
 function createSignal(first, second, third) {
   if (typeof first === "function") {
-    const memo = createMemo((p) => {
-      const node2 = new Computation(
-        first(p ? untrack(p[0]) : second),
-        null,
-        third
-      );
-      return [node2.read.bind(node2), node2.write.bind(node2)];
-    });
-    return [() => memo()[0](), (value) => memo()[1](value)];
+    const node2 = new Computation(second, first, third);
+    return [node2.read.bind(node2), (v) => {
+      node2._updateIfNecessary();
+      return node2.write(v);
+    }];
   }
   const o = getOwner();
   const needsId = o?.id != null;
@@ -1315,7 +1304,7 @@ function createEffect(compute2, effect, value, options) {
   void new Effect(
     value,
     compute2,
-    effect.effect ? effect.effect : effect,
+    effect.effect || effect,
     effect.error,
     { ...options, name: options?.name ?? "effect" } 
   );
@@ -1326,6 +1315,29 @@ function createRenderEffect(compute2, effect, value, options) {
     ...{ ...options, name: options?.name ?? "effect" } 
   });
 }
+function createTrackedEffect(compute2, options) {
+  void new TrackedEffect(compute2, options);
+}
+function createReaction(effect, options) {
+  let cleanup = void 0;
+  onCleanup(() => cleanup?.());
+  return (tracking) => {
+    const node = new Effect(
+      void 0,
+      tracking,
+      () => {
+        cleanup?.();
+        cleanup = (effect.effect || effect)?.();
+        node.dispose(true);
+      },
+      effect.error,
+      {
+        defer: true,
+        ...{ ...options, name: options?.name ?? "effect" } 
+      }
+    );
+  };
+}
 function createRoot(init, options) {
   const owner = new Owner(options?.id);
   return compute(owner, !init.length ? init : () => init(() => owner.dispose()), null);
@@ -1349,23 +1361,25 @@ function resolve(fn) {
     });
   });
 }
-function createPending() {
-  const node = new Computation(false, null);
-  const reset = () => node.write(false);
-  function write() {
+function createOptimistic(first, second, third) {
+  const node = typeof first === "function" ? new Computation(second, first, third) : new Computation(first, null, second);
+  const reset = () => node.write(first);
+  function write(v) {
     if (!ActiveTransition)
-      return false;
+      throw new Error("createOptimistic can only be updated inside a transition");
     ActiveTransition.addOptimistic(reset);
-    queueMicrotask(() => reset._transition && node.write(true));
-  }
-  function read() {
-    const v = node.read();
-    return ActiveTransition ? false : v;
+    cloneGraph(node, true);
+    queueMicrotask(() => {
+      if (reset._transition) {
+        node._updateIfNecessary();
+        node.write(v);
+      }
+    });
   }
-  return [read, write];
+  return [node.read.bind(node), write];
 }
 function useTransition() {
-  const [pending, setPending] = createPending();
+  const [pending, setPending] = createOptimistic(false);
   function start(fn) {
     transition((resume) => {
       setPending(true);
@@ -1831,7 +1845,7 @@ function deep(store) {
 }
 
 // src/store/optimistic.ts
-function createOptimistic(first, second, options) {
+function createOptimisticStore(first, second, options) {
   const derived = typeof first === "function";
   const { store, node } = derived ? createProjectionInternal(first, second, options) : createProjectionInternal(() => {
   }, first);
@@ -1845,7 +1859,7 @@ function createOptimistic(first, second, options) {
   );
   const write = (v) => {
     if (!ActiveTransition)
-      throw new Error("createOptimistic can only be updated inside a transition");
+      throw new Error("createOptimisticStore can only be updated inside a transition");
     ActiveTransition.addOptimistic(reset);
     cloneGraph(node, true);
     queueMicrotask(() => reset._transition && storeSetter(store, v));
@@ -2456,4 +2470,4 @@ function flattenArray(children, results = [], options) {
   return needsUnwrap;
 }
 
-export { $PROXY, $TARGET, $TRACK, Computation, ContextNotFoundError, NoOwnerError, NotReadyError, Owner, Queue, SUPPORTS_PROXY, createAsync, createBoundary, createContext, createEffect, createErrorBoundary, createMemo, createOptimistic, createProjection, createRenderEffect, createRoot, createSignal, createStore, createSuspense, deep, flatten, flush, getContext, getObserver, getOwner, hasContext, hasUpdated, isEqual, isPending, isWrappable, latest, mapArray, merge, omit, onCleanup, reconcile, repeat, resolve, runWithObserver, runWithOwner, setContext, snapshot, transition, untrack, useTransition };
+export { $PROXY, $TARGET, $TRACK, Computation, ContextNotFoundError, NoOwnerError, NotReadyError, Owner, Queue, SUPPORTS_PROXY, createAsync, createBoundary, createContext, createEffect, createErrorBoundary, createMemo, createOptimistic, createOptimisticStore, createProjection, createReaction, createRenderEffect, createRoot, createSignal, createStore, createSuspense, createTrackedEffect, deep, flatten, flush, getContext, getObserver, getOwner, hasContext, hasUpdated, isEqual, isPending, isWrappable, latest, mapArray, merge, omit, onCleanup, reconcile, repeat, resolve, runWithOwner, setContext, snapshot, transition, untrack, useTransition };