@oscarpalmer/mora 0.4.0 → 0.6.0

package/dist/batch.cjs

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const effect = require("./effect.cjs");
+function flushEffects() {
+  while (exports.batchDepth === 0 && effect.dirtyEffects.size > 0) {
+    const effects = [...effect.dirtyEffects];
+    effect.dirtyEffects.clear();
+    for (const effect$1 of effects) {
+      effect.runEffect(effect$1);
+    }
+  }
+}
+function startBatch() {
+  exports.batchDepth += 1;
+}
+function stopBatch() {
+  if (exports.batchDepth > 0) {
+    exports.batchDepth -= 1;
+  }
+  flushEffects();
+}
+exports.batchDepth = 0;
+exports.flushEffects = flushEffects;
+exports.startBatch = startBatch;
+exports.stopBatch = stopBatch;

package/dist/batch.js

@@ -0,0 +1,26 @@
+import { dirtyEffects, runEffect } from "./effect.js";
+function flushEffects() {
+  while (batchDepth === 0 && dirtyEffects.size > 0) {
+    const effects = [...dirtyEffects];
+    dirtyEffects.clear();
+    for (const effect of effects) {
+      runEffect(effect);
+    }
+  }
+}
+function startBatch() {
+  batchDepth += 1;
+}
+function stopBatch() {
+  if (batchDepth > 0) {
+    batchDepth -= 1;
+  }
+  flushEffects();
+}
+let batchDepth = 0;
+export {
+  batchDepth,
+  flushEffects,
+  startBatch,
+  stopBatch
+};

package/dist/computed.cjs

@@ -3,15 +3,15 @@ var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const batch = require("./batch.cjs");
 const effect = require("./effect.cjs");
-const signal = require("./signal.cjs");
 exports.activeComputed = void 0;
 class Computed {
   constructor(callback) {
     __publicField(this, "state");
     this.state = {
-      dirty: true,
       computeds: /* @__PURE__ */ new Set(),
+      dirty: true,
       effect: void 0,
       effects: /* @__PURE__ */ new Set(),
       value: void 0
@@ -26,16 +26,19 @@ class Computed {
           this.state.value = value;
           for (const comp of this.state.computeds) {
             comp.state.dirty = true;
-            signal.dirtyEffects.add(comp.state.effect);
+            effect.dirtyEffects.add(comp.state.effect);
           }
           for (const effect2 of this.state.effects) {
-            signal.dirtyEffects.add(effect2);
+            effect.dirtyEffects.add(effect2);
           }
         }
         this.state.dirty = false;
       }
     });
   }
+  /**
+   * Get the value
+   */
   get() {
     if (exports.activeComputed != null && exports.activeComputed !== this) {
       this.state.computeds.add(exports.activeComputed);
@@ -44,7 +47,11 @@ class Computed {
       this.state.effects.add(effect.activeEffect);
     }
     if (this.state.dirty) {
-      effect.runEffect(this.state.effect);
+      if (batch.batchDepth === 0) {
+        effect.runEffect(this.state.effect);
+      } else {
+        effect.dirtyEffects.add(this.state.effect);
+      }
     }
     return this.state.value;
   }

package/dist/computed.js

@@ -1,15 +1,15 @@
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-import { effect, activeEffect, runEffect } from "./effect.js";
-import { dirtyEffects } from "./signal.js";
+import { batchDepth } from "./batch.js";
+import { effect, dirtyEffects, activeEffect, runEffect } from "./effect.js";
 let activeComputed;
 class Computed {
   constructor(callback) {
     __publicField(this, "state");
     this.state = {
-      dirty: true,
       computeds: /* @__PURE__ */ new Set(),
+      dirty: true,
       effect: void 0,
       effects: /* @__PURE__ */ new Set(),
       value: void 0
@@ -34,6 +34,9 @@ class Computed {
       }
     });
   }
+  /**
+   * Get the value
+   */
   get() {
     if (activeComputed != null && activeComputed !== this) {
       this.state.computeds.add(activeComputed);
@@ -42,7 +45,11 @@ class Computed {
       this.state.effects.add(activeEffect);
     }
     if (this.state.dirty) {
-      runEffect(this.state.effect);
+      if (batchDepth === 0) {
+        runEffect(this.state.effect);
+      } else {
+        dirtyEffects.add(this.state.effect);
+      }
     }
     return this.state.value;
   }

package/dist/effect.cjs

@@ -3,7 +3,6 @@ var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-exports.activeEffect = void 0;
 class Effect {
   constructor(callback) {
     __publicField(this, "state");
@@ -25,6 +24,9 @@ function runEffect(effect2) {
 function effect(callback) {
   return new Effect(callback);
 }
+exports.activeEffect = void 0;
+const dirtyEffects = /* @__PURE__ */ new Set();
 exports.Effect = Effect;
+exports.dirtyEffects = dirtyEffects;
 exports.effect = effect;
 exports.runEffect = runEffect;

package/dist/effect.js

@@ -1,7 +1,6 @@
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-let activeEffect;
 class Effect {
   constructor(callback) {
     __publicField(this, "state");
@@ -23,9 +22,12 @@ function runEffect(effect2) {
 function effect(callback) {
   return new Effect(callback);
 }
+let activeEffect;
+const dirtyEffects = /* @__PURE__ */ new Set();
 export {
   Effect,
   activeEffect,
+  dirtyEffects,
   effect,
   runEffect
 };

package/dist/index.cjs

@@ -1,8 +1,11 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const batch = require("./batch.cjs");
 const computed = require("./computed.cjs");
 const effect = require("./effect.cjs");
 const signal = require("./signal.cjs");
+exports.startBatch = batch.startBatch;
+exports.stopBatch = batch.stopBatch;
 exports.computed = computed.computed;
 exports.effect = effect.effect;
 exports.signal = signal.signal;

package/dist/index.js

@@ -1,8 +1,11 @@
+import { startBatch, stopBatch } from "./batch.js";
 import { computed } from "./computed.js";
 import { effect } from "./effect.js";
 import { signal } from "./signal.js";
 export {
   computed,
   effect,
-  signal
+  signal,
+  startBatch,
+  stopBatch
 };

package/dist/mora.full.js

@@ -0,0 +1,165 @@
+class Effect {
+    state;
+    constructor(callback) {
+        this.state = {
+            callback,
+        };
+        runEffect(this);
+    }
+}
+function runEffect(effect) {
+    const previousEffect = activeEffect;
+    activeEffect = effect;
+    try {
+        effect.state.callback();
+    }
+    finally {
+        activeEffect = previousEffect;
+    }
+}
+/**
+ * Create an effect
+ */
+function effect(callback) {
+    return new Effect(callback);
+}
+let activeEffect;
+const dirtyEffects = new Set();
+
+function flushEffects() {
+    while (batchDepth === 0 && dirtyEffects.size > 0) {
+        const effects = [...dirtyEffects];
+        dirtyEffects.clear();
+        for (const effect of effects) {
+            runEffect(effect);
+        }
+    }
+}
+/**
+ * Start batching effects _(use `stopBatch` to flush and run batched effects)_
+ */
+function startBatch() {
+    batchDepth += 1;
+}
+/**
+ * Stop batching effects and flush _(run)_ them
+ */
+function stopBatch() {
+    if (batchDepth > 0) {
+        batchDepth -= 1;
+    }
+    flushEffects();
+}
+let batchDepth = 0;
+
+let activeComputed;
+class Computed {
+    state;
+    constructor(callback) {
+        this.state = {
+            computeds: new Set(),
+            dirty: true,
+            effect: undefined,
+            effects: new Set(),
+            value: undefined,
+        };
+        this.state.effect = effect(() => {
+            if (this.state.dirty) {
+                const previousComputed = activeComputed;
+                activeComputed = this;
+                const value = callback();
+                activeComputed = previousComputed;
+                if (!Object.is(this.state.value, value)) {
+                    this.state.value = value;
+                    for (const comp of this.state.computeds) {
+                        comp.state.dirty = true;
+                        dirtyEffects.add(comp.state.effect);
+                    }
+                    for (const effect of this.state.effects) {
+                        dirtyEffects.add(effect);
+                    }
+                }
+                this.state.dirty = false;
+            }
+        });
+    }
+    /**
+     * Get the value
+     */
+    get() {
+        if (activeComputed != null && activeComputed !== this) {
+            this.state.computeds.add(activeComputed);
+        }
+        if (activeEffect != null && activeEffect !== this.state.effect) {
+            this.state.effects.add(activeEffect);
+        }
+        if (this.state.dirty) {
+            if (batchDepth === 0) {
+                runEffect(this.state.effect);
+            }
+            else {
+                dirtyEffects.add(this.state.effect);
+            }
+        }
+        return this.state.value;
+    }
+}
+/**
+ * Create a computed value
+ */
+function computed(callback) {
+    return new Computed(callback);
+}
+
+class Signal {
+    state;
+    constructor(value) {
+        this.state = {
+            value,
+            computeds: new Set(),
+            effects: new Set(),
+        };
+    }
+    /**
+     * Get the value
+     */
+    get() {
+        if (activeComputed != null) {
+            this.state.computeds.add(activeComputed);
+        }
+        if (activeEffect != null) {
+            this.state.effects.add(activeEffect);
+        }
+        return this.state.value;
+    }
+    /**
+     * Set the value
+     */
+    set(value) {
+        if (Object.is(this.state.value, value)) {
+            return;
+        }
+        this.state.value = value;
+        for (const comp of this.state.computeds) {
+            comp.state.dirty = true;
+            dirtyEffects.add(comp.state.effect);
+        }
+        for (const effect of this.state.effects) {
+            dirtyEffects.add(effect);
+        }
+        if (batchDepth === 0) {
+            flushEffects();
+        }
+    }
+    /**
+     * Update the value
+     */
+    update(callback) {
+        this.set(callback(this.state.value));
+    }
+}
+function signal(value) {
+    return new Signal(value);
+}
+
+export { computed, effect, signal, startBatch, stopBatch };

package/dist/signal.cjs

@@ -3,9 +3,9 @@ var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const batch = require("./batch.cjs");
 const computed = require("./computed.cjs");
 const effect = require("./effect.cjs");
-const dirtyEffects = /* @__PURE__ */ new Set();
 class Signal {
   constructor(value) {
     __publicField(this, "state");
@@ -15,6 +15,9 @@ class Signal {
       effects: /* @__PURE__ */ new Set()
     };
   }
+  /**
+   * Get the value
+   */
   get() {
     if (computed.activeComputed != null) {
       this.state.computeds.add(computed.activeComputed);
@@ -24,26 +27,28 @@ class Signal {
     }
     return this.state.value;
   }
+  /**
+   * Set the value
+   */
   set(value) {
     if (Object.is(this.state.value, value)) {
       return;
     }
     this.state.value = value;
-    for (const computed2 of this.state.computeds) {
-      computed2.state.dirty = true;
-      dirtyEffects.add(computed2.state.effect);
+    for (const comp of this.state.computeds) {
+      comp.state.dirty = true;
+      effect.dirtyEffects.add(comp.state.effect);
     }
-    for (const effect2 of this.state.effects) {
-      dirtyEffects.add(effect2);
+    for (const effect$1 of this.state.effects) {
+      effect.dirtyEffects.add(effect$1);
     }
-    while (dirtyEffects.size > 0) {
-      const effects = [...dirtyEffects];
-      dirtyEffects.clear();
-      for (const effect$1 of effects) {
-        effect.runEffect(effect$1);
-      }
+    if (batch.batchDepth === 0) {
+      batch.flushEffects();
     }
   }
+  /**
+   * Update the value
+   */
   update(callback) {
     this.set(callback(this.state.value));
   }
@@ -52,5 +57,4 @@ function signal(value) {
   return new Signal(value);
 }
 exports.Signal = Signal;
-exports.dirtyEffects = dirtyEffects;
 exports.signal = signal;

package/dist/signal.js

@@ -1,9 +1,9 @@
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import { flushEffects, batchDepth } from "./batch.js";
 import { activeComputed } from "./computed.js";
-import { activeEffect, runEffect } from "./effect.js";
-const dirtyEffects = /* @__PURE__ */ new Set();
+import { activeEffect, dirtyEffects } from "./effect.js";
 class Signal {
   constructor(value) {
     __publicField(this, "state");
@@ -13,6 +13,9 @@ class Signal {
       effects: /* @__PURE__ */ new Set()
     };
   }
+  /**
+   * Get the value
+   */
   get() {
     if (activeComputed != null) {
       this.state.computeds.add(activeComputed);
@@ -22,26 +25,28 @@ class Signal {
     }
     return this.state.value;
   }
+  /**
+   * Set the value
+   */
   set(value) {
     if (Object.is(this.state.value, value)) {
       return;
     }
     this.state.value = value;
-    for (const computed of this.state.computeds) {
-      computed.state.dirty = true;
-      dirtyEffects.add(computed.state.effect);
+    for (const comp of this.state.computeds) {
+      comp.state.dirty = true;
+      dirtyEffects.add(comp.state.effect);
     }
     for (const effect of this.state.effects) {
       dirtyEffects.add(effect);
     }
-    while (dirtyEffects.size > 0) {
-      const effects = [...dirtyEffects];
-      dirtyEffects.clear();
-      for (const effect of effects) {
-        runEffect(effect);
-      }
+    if (batchDepth === 0) {
+      flushEffects();
     }
   }
+  /**
+   * Update the value
+   */
   update(callback) {
     this.set(callback(this.state.value));
   }
@@ -51,6 +56,5 @@ function signal(value) {
 }
 export {
   Signal,
-  dirtyEffects,
   signal
 };

package/package.json

@@ -6,18 +6,18 @@
 	"description": "Signals and stuff…",
 	"devDependencies": {
 		"@biomejs/biome": "^1.9",
-		"@oscarpalmer/atoms": "^0.82",
+		"@oscarpalmer/atoms": "^0.100",
 		"@rollup/plugin-node-resolve": "^16",
 		"@rollup/plugin-typescript": "^12.1",
-		"@types/node": "^22.13",
-		"@vitest/coverage-istanbul": "^3",
+		"@types/node": "^22.15",
+		"@vitest/coverage-istanbul": "^3.1",
 		"dts-bundle-generator": "^9.5",
 		"glob": "^11",
-		"happy-dom": "^17",
+		"jsdom": "^26.1",
 		"tslib": "^2.8",
-		"typescript": "^5.7",
-		"vite": "^6",
-		"vitest": "^3"
+		"typescript": "^5.8",
+		"vite": "^6.3",
+		"vitest": "^3.1"
 	},
 	"exports": {
 		".": {
@@ -31,16 +31,8 @@
 			}
 		}
 	},
-	"files": [
-		"dist",
-		"src",
-		"types"
-	],
-	"keywords": [
-		"signal",
-		"signals",
-		"reactive"
-	],
+	"files": ["dist", "src", "types"],
+	"keywords": ["signal", "signals", "reactive"],
 	"license": "MIT",
 	"main": "./dist/index.cjs",
 	"module": "./dist/index.js",
@@ -55,10 +47,10 @@
 		"clean": "rm -rf ./dist && rm -rf ./types && rm -f ./tsconfig.tsbuildinfo",
 		"rollup": "npx rollup -c",
 		"test": "npx vitest --coverage",
-		"types": "npx tsc && npx dts-bundle-generator --config ./dts.config.cts",
+		"types": "npx tsc && npx dts-bundle-generator --config ./dts.config.cts --silent",
 		"watch": "npx vite build --watch"
 	},
 	"type": "module",
 	"types": "./types/index.d.ts",
-	"version": "0.4.0"
+	"version": "0.6.0"
 }

package/src/batch.ts

@@ -0,0 +1,33 @@
+import {dirtyEffects, runEffect} from './effect';
+
+export function flushEffects(): void {
+	while (batchDepth === 0 && dirtyEffects.size > 0) {
+		const effects = [...dirtyEffects];
+
+		dirtyEffects.clear();
+
+		for (const effect of effects) {
+			runEffect(effect);
+		}
+	}
+}
+
+/**
+ * Start batching effects _(use `stopBatch` to flush and run batched effects)_
+ */
+export function startBatch(): void {
+	batchDepth += 1;
+}
+
+/**
+ * Stop batching effects and flush _(run)_ them
+ */
+export function stopBatch(): void {
+	if (batchDepth > 0) {
+		batchDepth -= 1;
+	}
+
+	flushEffects();
+}
+
+export let batchDepth = 0;

package/src/computed.ts

@@ -1,23 +1,33 @@
-import {type Effect, activeEffect, effect, runEffect} from './effect';
-import {dirtyEffects} from './signal';
+import {batchDepth} from './batch';
+import {
+	type Effect,
+	activeEffect,
+	dirtyEffects,
+	effect,
+	runEffect,
+} from './effect';
 
 type ComputedState<Value> = {
-	dirty: boolean;
 	computeds: Set<Computed<unknown>>;
+	dirty: boolean;
 	effect: Effect;
 	effects: Set<Effect>;
 	value: Value;
 };
 
+export type InternalComputed = {
+	readonly state: ComputedState<unknown>;
+};
+
 export let activeComputed: Computed<unknown> | undefined;
 
 export class Computed<Value> {
-	readonly state: ComputedState<Value>;
+	private readonly state: ComputedState<Value>;
 
 	constructor(callback: () => Value) {
 		this.state = {
-			dirty: true,
 			computeds: new Set(),
+			dirty: true,
 			effect: undefined as never,
 			effects: new Set(),
 			value: undefined as never,
@@ -52,6 +62,9 @@ export class Computed<Value> {
 		});
 	}
 
+	/**
+	 * Get the value
+	 */
 	get(): Value {
 		if (activeComputed != null && activeComputed !== this) {
 			this.state.computeds.add(activeComputed);
@@ -62,13 +75,20 @@ export class Computed<Value> {
 		}
 
 		if (this.state.dirty) {
-			runEffect(this.state.effect);
+			if (batchDepth === 0) {
+				runEffect(this.state.effect);
+			} else {
+				dirtyEffects.add(this.state.effect);
+			}
 		}
 
 		return this.state.value;
 	}
 }
 
+/**
+ * Create a computed value
+ */
 export function computed<Value>(callback: () => Value): Computed<Value> {
 	return new Computed(callback);
 }

package/src/effect.ts

@@ -4,10 +4,12 @@ type EffectState = {
 	callback: GenericCallback;
 };
 
-export let activeEffect: Effect | undefined;
+type InternalEffect = {
+	state: EffectState;
+};
 
 export class Effect {
-	readonly state: EffectState;
+	private readonly state: EffectState;
 
 	constructor(callback: GenericCallback) {
 		this.state = {
@@ -24,12 +26,19 @@ export function runEffect(effect: Effect): void {
 	activeEffect = effect;
 
 	try {
-		effect.state.callback();
+		(effect as unknown as InternalEffect).state.callback();
 	} finally {
 		activeEffect = previousEffect;
 	}
 }
 
+/**
+ * Create an effect
+ */
 export function effect(callback: GenericCallback): Effect {
 	return new Effect(callback);
 }
+
+export let activeEffect: Effect | undefined;
+
+export const dirtyEffects = new Set<Effect>();

package/src/index.ts

@@ -1,3 +1,4 @@
+export {startBatch, stopBatch} from './batch';
 export {computed, type Computed} from './computed';
 export {effect, type Effect} from './effect';
 export {signal, type Signal} from './signal';

package/src/signal.ts

@@ -1,5 +1,6 @@
-import {type Computed, activeComputed} from './computed';
-import {type Effect, activeEffect, runEffect} from './effect';
+import {batchDepth, flushEffects} from './batch';
+import {type Computed, type InternalComputed, activeComputed} from './computed';
+import {type Effect, activeEffect, dirtyEffects} from './effect';
 
 type SignalState<Value> = {
 	computeds: Set<Computed<unknown>>;
@@ -7,10 +8,8 @@ type SignalState<Value> = {
 	value: Value;
 };
 
-export const dirtyEffects = new Set<Effect>();
-
 export class Signal<Value> {
-	readonly state: SignalState<Value>;
+	private readonly state: SignalState<Value>;
 
 	constructor(value: Value) {
 		this.state = {
@@ -20,6 +19,9 @@ export class Signal<Value> {
 		};
 	}
 
+	/**
+	 * Get the value
+	 */
 	get(): Value {
 		if (activeComputed != null) {
 			this.state.computeds.add(activeComputed);
@@ -32,6 +34,9 @@ export class Signal<Value> {
 		return this.state.value;
 	}
 
+	/**
+	 * Set the value
+	 */
 	set(value: Value): void {
 		if (Object.is(this.state.value, value)) {
 			return;
@@ -39,27 +44,24 @@ export class Signal<Value> {
 
 		this.state.value = value;
 
-		for (const computed of this.state.computeds) {
-			computed.state.dirty = true;
+		for (const comp of this.state.computeds) {
+			(comp as unknown as InternalComputed).state.dirty = true;
 
-			dirtyEffects.add(computed.state.effect);
+			dirtyEffects.add((comp as unknown as InternalComputed).state.effect);
 		}
 
 		for (const effect of this.state.effects) {
 			dirtyEffects.add(effect);
 		}
 
-		while (dirtyEffects.size > 0) {
-			const effects = [...dirtyEffects];
-
-			dirtyEffects.clear();
-
-			for (const effect of effects) {
-				runEffect(effect);
-			}
+		if (batchDepth === 0) {
+			flushEffects();
 		}
 	}
 
+	/**
+	 * Update the value
+	 */
 	update(callback: (value: Value) => Value): void {
 		this.set(callback(this.state.value));
 	}

package/types/batch.d.cts

@@ -0,0 +1,14 @@
+// Generated by dts-bundle-generator v9.5.1
+
+export declare function flushEffects(): void;
+/**
+ * Start batching effects _(use `stopBatch` to flush and run batched effects)_
+ */
+export declare function startBatch(): void;
+/**
+ * Stop batching effects and flush _(run)_ them
+ */
+export declare function stopBatch(): void;
+export declare let batchDepth: number;
+
+export {};

package/types/batch.d.ts

@@ -0,0 +1,10 @@
+export declare function flushEffects(): void;
+/**
+ * Start batching effects _(use `stopBatch` to flush and run batched effects)_
+ */
+export declare function startBatch(): void;
+/**
+ * Stop batching effects and flush _(run)_ them
+ */
+export declare function stopBatch(): void;
+export declare let batchDepth: number;

package/types/computed.d.cts

@@ -1,26 +1,32 @@
 // Generated by dts-bundle-generator v9.5.1
 
 export type GenericCallback = (...args: any[]) => any;
-export type EffectState = {
-	callback: GenericCallback;
-};
 declare class Effect {
-	readonly state: EffectState;
+	private readonly state;
 	constructor(callback: GenericCallback);
 }
 export type ComputedState<Value> = {
-	dirty: boolean;
 	computeds: Set<Computed<unknown>>;
+	dirty: boolean;
 	effect: Effect;
 	effects: Set<Effect>;
 	value: Value;
 };
+export type InternalComputed = {
+	readonly state: ComputedState<unknown>;
+};
 export declare let activeComputed: Computed<unknown> | undefined;
 export declare class Computed<Value> {
-	readonly state: ComputedState<Value>;
+	private readonly state;
 	constructor(callback: () => Value);
+	/**
+	 * Get the value
+	 */
 	get(): Value;
 }
+/**
+ * Create a computed value
+ */
 export declare function computed<Value>(callback: () => Value): Computed<Value>;
 
 export {};

package/types/computed.d.ts

@@ -1,16 +1,25 @@
 import { type Effect } from './effect';
 type ComputedState<Value> = {
-    dirty: boolean;
     computeds: Set<Computed<unknown>>;
+    dirty: boolean;
     effect: Effect;
     effects: Set<Effect>;
     value: Value;
 };
+export type InternalComputed = {
+    readonly state: ComputedState<unknown>;
+};
 export declare let activeComputed: Computed<unknown> | undefined;
 export declare class Computed<Value> {
-    readonly state: ComputedState<Value>;
+    private readonly state;
     constructor(callback: () => Value);
+    /**
+     * Get the value
+     */
     get(): Value;
 }
+/**
+ * Create a computed value
+ */
 export declare function computed<Value>(callback: () => Value): Computed<Value>;
 export {};

package/types/effect.d.cts

@@ -1,15 +1,16 @@
 // Generated by dts-bundle-generator v9.5.1
 
 export type GenericCallback = (...args: any[]) => any;
-export type EffectState = {
-	callback: GenericCallback;
-};
-export declare let activeEffect: Effect | undefined;
 export declare class Effect {
-	readonly state: EffectState;
+	private readonly state;
 	constructor(callback: GenericCallback);
 }
 export declare function runEffect(effect: Effect): void;
+/**
+ * Create an effect
+ */
 export declare function effect(callback: GenericCallback): Effect;
+export declare let activeEffect: Effect | undefined;
+export declare const dirtyEffects: Set<Effect>;
 
 export {};

package/types/effect.d.ts

@@ -1,12 +1,12 @@
 import type { GenericCallback } from '@oscarpalmer/atoms/models';
-type EffectState = {
-    callback: GenericCallback;
-};
-export declare let activeEffect: Effect | undefined;
 export declare class Effect {
-    readonly state: EffectState;
+    private readonly state;
     constructor(callback: GenericCallback);
 }
 export declare function runEffect(effect: Effect): void;
+/**
+ * Create an effect
+ */
 export declare function effect(callback: GenericCallback): Effect;
-export {};
+export declare let activeEffect: Effect | undefined;
+export declare const dirtyEffects: Set<Effect>;

package/types/index.d.cts

@@ -1,39 +1,50 @@
 // Generated by dts-bundle-generator v9.5.1
 
+export declare class Signal<Value> {
+	private readonly state;
+	constructor(value: Value);
+	/**
+	 * Get the value
+	 */
+	get(): Value;
+	/**
+	 * Set the value
+	 */
+	set(value: Value): void;
+	/**
+	 * Update the value
+	 */
+	update(callback: (value: Value) => Value): void;
+}
+export declare function signal<Value>(value: Value): Signal<Value>;
+/**
+ * Start batching effects _(use `stopBatch` to flush and run batched effects)_
+ */
+export declare function startBatch(): void;
+/**
+ * Stop batching effects and flush _(run)_ them
+ */
+export declare function stopBatch(): void;
 export type GenericCallback = (...args: any[]) => any;
-export type EffectState = {
-	callback: GenericCallback;
-};
 export declare class Effect {
-	readonly state: EffectState;
+	private readonly state;
 	constructor(callback: GenericCallback);
 }
+/**
+ * Create an effect
+ */
 export declare function effect(callback: GenericCallback): Effect;
-export type ComputedState<Value> = {
-	dirty: boolean;
-	computeds: Set<Computed<unknown>>;
-	effect: Effect;
-	effects: Set<Effect>;
-	value: Value;
-};
 export declare class Computed<Value> {
-	readonly state: ComputedState<Value>;
+	private readonly state;
 	constructor(callback: () => Value);
+	/**
+	 * Get the value
+	 */
 	get(): Value;
 }
+/**
+ * Create a computed value
+ */
 export declare function computed<Value>(callback: () => Value): Computed<Value>;
-export type SignalState<Value> = {
-	computeds: Set<Computed<unknown>>;
-	effects: Set<Effect>;
-	value: Value;
-};
-export declare class Signal<Value> {
-	readonly state: SignalState<Value>;
-	constructor(value: Value);
-	get(): Value;
-	set(value: Value): void;
-	update(callback: (value: Value) => Value): void;
-}
-export declare function signal<Value>(value: Value): Signal<Value>;
 
 export {};

package/types/index.d.ts

@@ -1,3 +1,4 @@
+export { startBatch, stopBatch } from './batch';
 export { computed, type Computed } from './computed';
 export { effect, type Effect } from './effect';
 export { signal, type Signal } from './signal';

package/types/signal.d.cts

@@ -1,36 +1,19 @@
 // Generated by dts-bundle-generator v9.5.1
 
-export type GenericCallback = (...args: any[]) => any;
-export type EffectState = {
-	callback: GenericCallback;
-};
-declare class Effect {
-	readonly state: EffectState;
-	constructor(callback: GenericCallback);
-}
-export type ComputedState<Value> = {
-	dirty: boolean;
-	computeds: Set<Computed<unknown>>;
-	effect: Effect;
-	effects: Set<Effect>;
-	value: Value;
-};
-declare class Computed<Value> {
-	readonly state: ComputedState<Value>;
-	constructor(callback: () => Value);
-	get(): Value;
-}
-export type SignalState<Value> = {
-	computeds: Set<Computed<unknown>>;
-	effects: Set<Effect>;
-	value: Value;
-};
-export declare const dirtyEffects: Set<Effect>;
 export declare class Signal<Value> {
-	readonly state: SignalState<Value>;
+	private readonly state;
 	constructor(value: Value);
+	/**
+	 * Get the value
+	 */
 	get(): Value;
+	/**
+	 * Set the value
+	 */
 	set(value: Value): void;
+	/**
+	 * Update the value
+	 */
 	update(callback: (value: Value) => Value): void;
 }
 export declare function signal<Value>(value: Value): Signal<Value>;

package/types/signal.d.ts

@@ -1,17 +1,17 @@
-import { type Computed } from './computed';
-import { type Effect } from './effect';
-type SignalState<Value> = {
-    computeds: Set<Computed<unknown>>;
-    effects: Set<Effect>;
-    value: Value;
-};
-export declare const dirtyEffects: Set<Effect>;
 export declare class Signal<Value> {
-    readonly state: SignalState<Value>;
+    private readonly state;
     constructor(value: Value);
+    /**
+     * Get the value
+     */
     get(): Value;
+    /**
+     * Set the value
+     */
     set(value: Value): void;
+    /**
+     * Update the value
+     */
     update(callback: (value: Value) => Value): void;
 }
 export declare function signal<Value>(value: Value): Signal<Value>;
-export {};

package/dist/mora.iife.js

@@ -1,129 +0,0 @@
-var Mora = (function (exports) {
-    'use strict';
-
-    let activeEffect;
-    class Effect {
-        state;
-        constructor(callback) {
-            this.state = {
-                callback,
-            };
-            runEffect(this);
-        }
-    }
-    function runEffect(effect) {
-        const previousEffect = activeEffect;
-        activeEffect = effect;
-        try {
-            effect.state.callback();
-        }
-        finally {
-            activeEffect = previousEffect;
-        }
-    }
-    function effect(callback) {
-        return new Effect(callback);
-    }
-
-    const dirtyEffects = new Set();
-    class Signal {
-        state;
-        constructor(value) {
-            this.state = {
-                value,
-                computeds: new Set(),
-                effects: new Set(),
-            };
-        }
-        get() {
-            if (activeComputed != null) {
-                this.state.computeds.add(activeComputed);
-            }
-            if (activeEffect != null) {
-                this.state.effects.add(activeEffect);
-            }
-            return this.state.value;
-        }
-        set(value) {
-            if (Object.is(this.state.value, value)) {
-                return;
-            }
-            this.state.value = value;
-            for (const computed of this.state.computeds) {
-                computed.state.dirty = true;
-                dirtyEffects.add(computed.state.effect);
-            }
-            for (const effect of this.state.effects) {
-                dirtyEffects.add(effect);
-            }
-            while (dirtyEffects.size > 0) {
-                const effects = [...dirtyEffects];
-                dirtyEffects.clear();
-                for (const effect of effects) {
-                    runEffect(effect);
-                }
-            }
-        }
-        update(callback) {
-            this.set(callback(this.state.value));
-        }
-    }
-    function signal(value) {
-        return new Signal(value);
-    }
-
-    let activeComputed;
-    class Computed {
-        state;
-        constructor(callback) {
-            this.state = {
-                dirty: true,
-                computeds: new Set(),
-                effect: undefined,
-                effects: new Set(),
-                value: undefined,
-            };
-            this.state.effect = effect(() => {
-                if (this.state.dirty) {
-                    const previousComputed = activeComputed;
-                    activeComputed = this;
-                    const value = callback();
-                    activeComputed = previousComputed;
-                    if (!Object.is(this.state.value, value)) {
-                        this.state.value = value;
-                        for (const comp of this.state.computeds) {
-                            comp.state.dirty = true;
-                            dirtyEffects.add(comp.state.effect);
-                        }
-                        for (const effect of this.state.effects) {
-                            dirtyEffects.add(effect);
-                        }
-                    }
-                    this.state.dirty = false;
-                }
-            });
-        }
-        get() {
-            if (activeComputed != null && activeComputed !== this) {
-                this.state.computeds.add(activeComputed);
-            }
-            if (activeEffect != null && activeEffect !== this.state.effect) {
-                this.state.effects.add(activeEffect);
-            }
-            if (this.state.dirty) {
-                runEffect(this.state.effect);
-            }
-            return this.state.value;
-        }
-    }
-    function computed(callback) {
-        return new Computed(callback);
-    }
-
-    exports.computed = computed;
-    exports.effect = effect;
-    exports.signal = signal;
-
-    return exports;
-
-})({});