@praxisjs/core 1.0.0 → 1.1.0

package/src/signal/batch.ts

@@ -2,13 +2,26 @@ import type { Effect } from "./effect";
 
 let batchQueue: Set<Effect> | null = null;
 
+export function isBatching(): boolean {
+  return batchQueue !== null;
+}
+
+export function enqueueEffect(effect: Effect): void {
+  batchQueue?.add(effect);
+}
+
 export function batch(fn: () => void) {
-  batchQueue = new Set();
+  const isOuter = batchQueue === null;
+  if (isOuter) {
+    batchQueue = new Set();
+  }
   try {
     fn();
   } finally {
-    const effectsToRun = batchQueue;
-    batchQueue = null;
-    effectsToRun.forEach((eff) => { eff(); });
+    if (isOuter) {
+      const effectsToRun = batchQueue ?? new Set<Effect>();
+      batchQueue = null;
+      effectsToRun.forEach((eff) => { eff(); });
+    }
   }
 }

package/src/signal/computed.ts

@@ -22,9 +22,12 @@ export function computed<T>(computeFn: () => T): Computed<T> {
     if (dirty) {
       const prevEffect = activeEffect;
       runEffect(recompute);
-      cachedValue = computeFn();
-      dirty = false;
-      runEffect(prevEffect);
+      try {
+        cachedValue = computeFn();
+        dirty = false;
+      } finally {
+        runEffect(prevEffect);
+      }
     }
 
     return cachedValue;

package/src/signal/signal.ts

@@ -1,5 +1,6 @@
 import type { Signal } from "@praxisjs/shared";
 
+import { isBatching, enqueueEffect } from "./batch";
 import { activeEffect, type Effect } from "./effect";
 
 export function signal<T>(initialValue: T): Signal<T> {
@@ -16,9 +17,19 @@ export function signal<T>(initialValue: T): Signal<T> {
   function set(newValue: T) {
     if (Object.is(value, newValue)) return;
     value = newValue;
+    if (isBatching()) {
+      [...subscribers].forEach((sub) => { enqueueEffect(sub); });
+      return;
+    }
+    const errors: unknown[] = [];
     [...subscribers].forEach((sub) => {
-      sub();
+      try {
+        sub();
+      } catch (e) {
+        errors.push(e);
+      }
     });
+    if (errors.length > 0) throw errors[errors.length - 1];
   }
 
   function update(fn: (prev: T) => T) {