@getforma/core 1.0.10 → 1.1.0

package/dist/formajs.global.js

@@ -348,6 +348,9 @@ var FormaJS = (() => {
       }
     }
   });
+  function getActiveSub() {
+    return activeSub;
+  }
   function setActiveSub(sub) {
     const prevSub = activeSub;
     activeSub = sub;
@@ -593,16 +596,47 @@ var FormaJS = (() => {
     }
   }
 
+  // src/reactive/dev.ts
+  function isDev() {
+    if (typeof process !== "undefined") {
+      return process.env?.NODE_ENV !== "production";
+    }
+    return typeof __FORMA_DEV__ !== "undefined" ? !!__FORMA_DEV__ : false;
+  }
+  var __DEV__ = isDev();
+  var _errorHandlers = /* @__PURE__ */ new Set();
+  function onError(handler) {
+    _errorHandlers.add(handler);
+    return () => {
+      _errorHandlers.delete(handler);
+    };
+  }
+  function reportError(error, source) {
+    for (const handler of _errorHandlers) {
+      try {
+        handler(error, source ? { source } : {});
+      } catch {
+      }
+    }
+    if (isDev()) {
+      console.error(`[forma] ${source ?? "Unknown"} error:`, error);
+    }
+  }
+
   // src/reactive/signal.ts
+  var signalNames = /* @__PURE__ */ new WeakMap();
   function applySignalSet(s, v, equals) {
     if (typeof v !== "function") {
-      if (equals) {
-        const prevSub2 = setActiveSub(void 0);
-        const prev2 = s();
-        setActiveSub(prevSub2);
-        if (equals(prev2, v)) return;
+      if (!equals) {
+        s(v);
+        return;
       }
+      const prevSub2 = setActiveSub(void 0);
+      const prev2 = s();
+      setActiveSub(prevSub2);
+      if (equals(prev2, v)) return;
       s(v);
+      if (Object.is(prev2, v)) forceNotify(s);
       return;
     }
     const prevSub = setActiveSub(void 0);
@@ -611,10 +645,19 @@ var FormaJS = (() => {
     const next = v(prev);
     if (equals && equals(prev, next)) return;
     s(next);
+    if (equals && Object.is(prev, next)) forceNotify(s);
+  }
+  function forceNotify(s) {
+    trigger(() => {
+      s();
+    });
   }
   function createSignal(initialValue, options) {
     const s = signal(initialValue);
     const getter = s;
+    if (__DEV__ && options?.name) {
+      signalNames.set(getter, options.name);
+    }
     const eq = options?.equals;
     const setter = (v) => applySignalSet(s, v, eq);
     return [getter, setter];
@@ -623,29 +666,73 @@ var FormaJS = (() => {
   // src/reactive/root.ts
   var currentRoot = null;
   var rootStack = [];
+  var currentOwner = null;
+  function getOwner() {
+    return currentOwner;
+  }
+  function runWithOwner(owner, fn) {
+    const prev = currentOwner;
+    currentOwner = owner;
+    try {
+      return fn();
+    } finally {
+      currentOwner = prev;
+    }
+  }
+  function registerOwnerDisposer(owner, dispose) {
+    owner.disposers.push(dispose);
+  }
+  function createChildOwner() {
+    return { disposers: [] };
+  }
+  function disposeOwner(owner) {
+    const ds = owner.disposers;
+    for (const d of ds) {
+      try {
+        d();
+      } catch {
+      }
+    }
+    ds.length = 0;
+  }
   function createRootImpl(fn, owned) {
     const scope = { disposers: [], scopeDispose: null };
     const parentRoot = owned ? currentRoot : null;
     rootStack.push(currentRoot);
     currentRoot = scope;
+    const prevOwner = currentOwner;
+    currentOwner = scope;
     let disposed = false;
-    const dispose = () => {
-      if (disposed) return;
-      disposed = true;
-      if (scope.scopeDispose) {
+    let setupComplete = false;
+    let disposeRequestedDuringSetup = false;
+    const runDisposers = () => {
+      for (const d of scope.disposers) {
         try {
-          scope.scopeDispose();
+          d();
         } catch {
         }
-        scope.scopeDispose = null;
       }
-      for (const d of scope.disposers) {
+      scope.disposers.length = 0;
+    };
+    const runTeardown = () => {
+      if (scope.scopeDispose) {
         try {
-          d();
+          scope.scopeDispose();
         } catch {
         }
+        scope.scopeDispose = null;
       }
-      scope.disposers.length = 0;
+      runDisposers();
+    };
+    const dispose = () => {
+      if (disposed) return;
+      disposed = true;
+      if (!setupComplete) {
+        disposeRequestedDuringSetup = true;
+        runDisposers();
+        return;
+      }
+      runTeardown();
     };
     if (parentRoot) {
       parentRoot.disposers.push(dispose);
@@ -666,8 +753,13 @@ var FormaJS = (() => {
           setActiveSub(prevSub);
         }
       }
+      setupComplete = true;
+      if (disposeRequestedDuringSetup) {
+        runTeardown();
+      }
     } finally {
       currentRoot = rootStack.pop() ?? null;
+      currentOwner = prevOwner;
     }
     return result;
   }
@@ -678,12 +770,12 @@ var FormaJS = (() => {
     return createRootImpl(fn, false);
   }
   function registerDisposer(dispose) {
-    if (currentRoot) {
-      currentRoot.disposers.push(dispose);
+    if (currentOwner) {
+      currentOwner.disposers.push(dispose);
     }
   }
   function hasActiveRoot() {
-    return currentRoot !== null;
+    return currentOwner !== null;
   }
 
   // src/reactive/cleanup.ts
@@ -697,30 +789,13 @@ var FormaJS = (() => {
     return prev;
   }
 
-  // src/reactive/dev.ts
-  var __DEV__ = typeof process !== "undefined" ? process.env?.NODE_ENV !== "production" : true;
-  var _errorHandler = null;
-  function onError(handler) {
-    _errorHandler = handler;
-  }
-  function reportError(error, source) {
-    if (_errorHandler) {
-      try {
-        _errorHandler(error, source ? { source } : {});
-      } catch {
-      }
-    }
-    if (__DEV__) {
-      console.error(`[forma] ${source ?? "Unknown"} error:`, error);
-    }
-  }
-
   // src/reactive/effect.ts
   var POOL_SIZE = 32;
   var MAX_REENTRANT_RUNS = 100;
   var pool = [];
   for (let i = 0; i < POOL_SIZE; i++) pool.push([]);
   var poolIdx = POOL_SIZE;
+  var PENDING = 32;
   function acquireArray() {
     if (poolIdx > 0) {
       const arr = pool[--poolIdx];
@@ -761,7 +836,8 @@ var FormaJS = (() => {
     return dispose;
   }
   function createEffect(fn) {
-    const shouldRegister = hasActiveRoot();
+    const ownerAtCreate = getOwner();
+    const childOwner = createChildOwner();
     let cleanup2;
     let cleanupBag;
     let nextCleanup;
@@ -780,11 +856,8 @@ var FormaJS = (() => {
       }
       nextCleanup = cb;
     };
-    let skipCleanupInfra = false;
-    let firstRun = true;
-    let running = false;
-    let rerunRequested = false;
     const runOnce = () => {
+      disposeOwner(childOwner);
       if (cleanup2 !== void 0) {
         runCleanup(cleanup2);
         cleanup2 = void 0;
@@ -794,68 +867,46 @@ var FormaJS = (() => {
         releaseArray(cleanupBag);
         cleanupBag = void 0;
       }
-      if (skipCleanupInfra) {
-        try {
-          fn();
-        } catch (e) {
-          reportError(e, "effect");
-        }
-        return;
-      }
       nextCleanup = void 0;
       nextCleanupBag = void 0;
       const prevCollector = setCleanupCollector(addCleanup);
       try {
-        const result = fn();
+        const result = runWithOwner(childOwner, fn);
         if (typeof result === "function") {
           addCleanup(result);
         }
-        if (nextCleanup === void 0 && nextCleanupBag === void 0) {
-          if (firstRun) skipCleanupInfra = true;
-          return;
-        }
         if (nextCleanupBag !== void 0) {
           cleanupBag = nextCleanupBag;
-        } else {
+        } else if (nextCleanup !== void 0) {
           cleanup2 = nextCleanup;
         }
       } catch (e) {
         reportError(e, "effect");
         if (nextCleanupBag !== void 0) {
           cleanupBag = nextCleanupBag;
-        } else {
+        } else if (nextCleanup !== void 0) {
           cleanup2 = nextCleanup;
         }
       } finally {
         setCleanupCollector(prevCollector);
-        firstRun = false;
       }
     };
     const safeFn = () => {
-      if (running) {
-        rerunRequested = true;
-        return;
-      }
-      running = true;
-      try {
-        let reentrantRuns = 0;
-        do {
-          rerunRequested = false;
-          runOnce();
-          if (rerunRequested) {
-            reentrantRuns++;
-            if (reentrantRuns >= MAX_REENTRANT_RUNS) {
-              reportError(
-                new Error(`createEffect exceeded ${MAX_REENTRANT_RUNS} re-entrant runs`),
-                "effect"
-              );
-              rerunRequested = false;
-            }
-          }
-        } while (rerunRequested);
-      } finally {
-        running = false;
-      }
+      const node = getActiveSub();
+      let reentrantRuns = 0;
+      do {
+        if (node) node.flags &= ~PENDING;
+        runOnce();
+        if (node === void 0 || (node.flags & PENDING) === 0) break;
+        if (++reentrantRuns >= MAX_REENTRANT_RUNS) {
+          node.flags &= ~PENDING;
+          reportError(
+            new Error(`createEffect exceeded ${MAX_REENTRANT_RUNS} self-triggered re-runs (cycle?)`),
+            "effect"
+          );
+          break;
+        }
+      } while (true);
     };
     const dispose = effect(safeFn);
     let disposed = false;
@@ -863,6 +914,7 @@ var FormaJS = (() => {
       if (disposed) return;
       disposed = true;
       dispose();
+      disposeOwner(childOwner);
       if (cleanup2 !== void 0) {
         runCleanup(cleanup2);
         cleanup2 = void 0;
@@ -873,15 +925,42 @@ var FormaJS = (() => {
         cleanupBag = void 0;
       }
     };
-    if (shouldRegister) {
-      registerDisposer(wrappedDispose);
+    if (ownerAtCreate) {
+      registerOwnerDisposer(ownerAtCreate, wrappedDispose);
     }
     return wrappedDispose;
   }
 
   // src/reactive/computed.ts
+  var ERR = /* @__PURE__ */ Symbol("formaComputedError");
+  function isErrBox(v) {
+    return typeof v === "object" && v !== null && ERR in v;
+  }
   function createComputed(fn) {
-    return computed(fn);
+    let errored = false;
+    let error;
+    let lastGood;
+    const raw = computed(() => {
+      try {
+        const v = fn(lastGood);
+        errored = false;
+        error = void 0;
+        lastGood = v;
+        return v;
+      } catch (e) {
+        errored = true;
+        error = e;
+        reportError(e, "computed");
+        return { [ERR]: e };
+      }
+    });
+    const reader = () => {
+      const v = raw();
+      if (errored || isErrBox(v)) throw error;
+      return v;
+    };
+    Object.defineProperty(reader, "name", { value: raw.name, configurable: true });
+    return reader;
   }
 
   // src/reactive/memo.ts
@@ -974,25 +1053,34 @@ var FormaJS = (() => {
         suspenseCtx.increment();
         suspensePending = true;
       }
-      setLoading(true);
-      setError(void 0);
-      Promise.resolve(fetcher(sourceValue)).then((result) => {
+      batch(() => {
+        setLoading(true);
+        setError(void 0);
+      });
+      let promise;
+      try {
+        promise = Promise.resolve(fetcher(sourceValue, { signal: controller.signal }));
+      } catch (err) {
+        promise = Promise.reject(err);
+      }
+      promise.then((result) => {
         if (isLatest() && !controller.signal.aborted) {
-          setData(() => result);
+          batch(() => {
+            setData(() => result);
+            setLoading(false);
+          });
         }
       }).catch((err) => {
-        if (isLatest() && !controller.signal.aborted) {
-          if (err?.name !== "AbortError") {
+        if (isLatest() && !controller.signal.aborted && err?.name !== "AbortError") {
+          batch(() => {
             setError(err);
-          }
+            setLoading(false);
+          });
         }
       }).finally(() => {
         if (suspensePending) suspenseCtx?.decrement();
-        if (isLatest()) {
-          setLoading(false);
-          if (abortController === controller) {
-            abortController = null;
-          }
+        if (isLatest() && abortController === controller) {
+          abortController = null;
         }
       });
     };
@@ -1000,6 +1088,15 @@ var FormaJS = (() => {
       source();
       doFetch();
     });
+    if (hasActiveRoot()) {
+      registerDisposer(() => {
+        fetchVersion++;
+        if (abortController) {
+          abortController.abort();
+          abortController = null;
+        }
+      });
+    }
     const resource = (() => data());
     resource.loading = loading;
     resource.error = error;