@zeix/cause-effect 0.11.0 → 0.12.0

package/README.md

@@ -1,6 +1,6 @@
 # Cause & Effect
 
-Version 0.11.0
+Version 0.12.0
 
 **Cause & Effect** is a lightweight, reactive state management library for JavaScript applications. It uses the concept of signals to create a predictable and efficient data flow in your app.
 
@@ -14,7 +14,7 @@ Version 0.11.0
 - **Performance**: Efficient updates that only recompute what's necessary.
 - **Type Safety**: Full TypeScript support for robust applications.
 - **Flexibility**: Works well with any UI framework or vanilla JavaScript.
-- **Lightweight**: Around 1kB gzipped over the wire.
+- **Lightweight**: Dependency-free, only 1kB gzipped over the wire.
 
 ## Key Features
 
@@ -27,18 +27,18 @@ Version 0.11.0
 ## Quick Example
 
 ```js
-import { state, computed, effect } from '@zeix/cause-effect'
+import { state, effect } from '@zeix/cause-effect'
 
 // Create a state signal
 const count = state(0)
 
 // Create a computed signal
-const doubleCount = computed(() => count.get() * 2)
+const doubleCount = count.map(v => v * 2)
 
 // Create an effect
-effect(() => {
-    console.log(`Count: ${count.get()}, Double: ${doubleCount.get()}`)
-})
+effect((c, d) => {
+    console.log(`Count: ${c}, Double: ${d}`)
+}, count, doubleCount)
 
 // Update the state
 count.set(5) // Logs: "Count: 5, Double: 10"
@@ -66,8 +66,9 @@ import { state, effect } from '@zeix/cause-effect'
 const count = state(42)
 effect(() => console.log(count.get())) // logs '42'
 count.set(24) // logs '24'
-document.querySelector('button.increment')
-    .addEventListener('click', () => count.update(v => ++v))
+document.querySelector('.increment').addEventListener('click', () => {
+	count.update(v => ++v)
+})
 // Click on button logs '25', '26', and so on
 ```
 
@@ -82,8 +83,9 @@ const count = state(42)
 const isOdd = computed(() => count.get() % 2)
 effect(() => console.log(isOdd.get())) // logs 'false'
 count.set(24) // logs nothing because 24 is also an even number
-document.querySelector('button.increment')
-    .addEventListener('click', () => count.update(v => ++v))
+document.querySelector('button.increment').addEventListener('click', () => {
+	count.update(v => ++v)
+})
 // Click on button logs 'true', 'false', and so on
 ```
 
@@ -96,8 +98,9 @@ const count = state(42)
 const isOdd = count.map(v => v % 2)
 effect(() => console.log(isOdd.get())) // logs 'false'
 count.set(24) // logs nothing because 24 is also an even number
-document.querySelector('button.increment')
-    .addEventListener('click', () => count.set(v => ++v))
+document.querySelector('.increment').addEventListener('click', () => {
+	count.update(v => ++v)
+})
 // Click on button logs 'true', 'false', and so on
 ```
 
@@ -154,23 +157,60 @@ effect({
 
 Instead of a single callback function, provide an object with `ok` (required), `err` and `nil` keys (both optional) and Cause & Effect will take care of anything that might go wrong with the listed signals in the rest parameters of `effect()`.
 
+If you want an effect based on a single signal, there's a shorthand too: The `.match()` method on either `State` or `Computed`. You can use it for easy debugging, for example:
+
+```js
+signal.match({
+	ok: v => console.log('Value:', v),
+	nil: () => console.warn('Not ready'),
+	err: e => console.error('Error:', e)
+})
+```
+
 ### Effects and Batching
 
 Effects run synchronously as soon as source signals update. If you need to set multiple signals you can batch them together to ensure dependents are executed only once.
 
 ```js
-import { state, computed, effect, batch } from '@zeix/cause-effect'
-
-const a = state(3)
-const b = state(4)
-const sum = computed(() => a.get() + b.get())
-effect(() => console.log(sum.get())) // logs '7'
-document.querySelector('button.double-all')
-    .addEventListener('click', () =>
-        batch(() => {
-            a.update(v => v * 2)
-            b.update(v => v * 2)
-        }
-    ))
-// Click on button logs '14' only once (instead of first '10' and then '14' without batch)
-```
+import { state, computed, batch } from '@zeix/cause-effect'
+
+// State: define an array of State<number>
+const signals = [state(2), state(3), state(5)]
+
+// Computed: derive a calculation ...
+const sum = computed(
+	(...values) => values.reduce((total, v) => total + v, 0),
+	...signals
+).map(v => { // ... perform validation and handle errors
+	if (!Number.isFinite(v)) throw new Error('Invalid value')
+	return v
+})
+
+// Effect: switch cases for the result
+sum.match({
+	ok: v => console.log('Sum:', v),
+	err: error => console.error('Error:', error)
+})
+
+// Batch: apply changes to all signals in a single transaction
+document.querySelector('.double-all').addEventListener('click', () => {
+	batch(() => {
+		signals.forEach(signal => signal.update(v => v * 2))
+	})
+})
+// Click on button logs '20' only once
+// (instead of first '12', then '15' and then '20' without batch)
+
+// Provoke an error - but no worries: it will be handled fine
+signals[0].set(NaN)
+```
+
+This example showcases several powerful features of Cause & Effect:
+
+1. **Composability and Declarative Computations**: Easily compose multiple signals into a single computed value, declaring how values should be calculated based on other signals.
+2. **Automatic Dependency Tracking and Efficient Updates**: The library tracks dependencies between signals and computed values, ensuring efficient propagation of changes.
+3. **Robust Error Handling**: Built-in error handling at computation level and reactive error management allow for graceful handling of unexpected situations.
+4. **Performance Optimization through Batching**: Group multiple state changes to ensure dependent computations and effects run only once after all changes are applied.
+5. **Flexibility and Integration**: Seamlessly integrates with DOM manipulation and event listeners, fitting into any JavaScript application or framework.
+
+These principles enable developers to create complex, reactive applications with clear data flow, efficient updates, and robust error handling, while promoting code reuse and modularity.

package/index.d.ts

@@ -1,9 +1,10 @@
 /**
  * @name Cause & Effect
- * @version 0.11.0
+ * @version 0.12.0
  * @author Esther Brunner
  */
-export { State, state, isState } from './lib/state';
+export { type Signal, type MaybeSignal, UNSET, isSignal, toSignal } from './lib/signal';
+export { type State, state, isState } from './lib/state';
 export { type Computed, computed, isComputed } from './lib/computed';
-export { type Signal, type MaybeSignal, UNSET, isSignal, toSignal, batch } from './lib/signal';
-export { effect } from './lib/effect';
+export { type EffectOkCallback, type EffectCallbacks, effect } from './lib/effect';
+export { type EnqueueDedupe, batch, watch, enqueue } from './lib/scheduler';

package/index.js

@@ -1 +1 @@
-var N=(x)=>typeof x==="function";var U=(x)=>N(x)&&x.length<2,O=(x)=>(y)=>y instanceof x,o=O(Error),g=O(Promise),$=(x)=>o(x)?x:new Error(String(x));var w="Computed",f=1000,V=(x)=>{let y=[],j=B,z=null,G=!0,q=!1,H=!1,X=0,J=()=>{if(G=!0,!q)C(y)},Z=()=>I(()=>{if(!G||H)return;let T=(L)=>{if(!Object.is(L,j))j=L,G=!1,z=null,q=!1;else q=!0},E=(L)=>{let Y=$(L);q=Object.is(Y,z),z=Y};H=!0;try{let L=x(j);g(L)?L.then((Y)=>{T(Y),C(y)}).catch(E):T(L)}catch(L){E(L)}finally{H=!1}},J),K={[Symbol.toStringTag]:w,get:()=>{if(X++>=f)throw new Error(`Circular dependency detected: exceeded ${f} iterations`);if(A(y),Z(),z)throw z;return j},map:(T)=>V(()=>T(K.get()))};return K},R=(x)=>!!x&&typeof x==="object"&&x[Symbol.toStringTag]===w;var W,M=0,P=new Set,S=new Set,p=()=>{while(P.size||S.size)P.forEach((x)=>x()),P.clear(),S.forEach((x)=>x()),S.clear()},B=Symbol(),_=(x)=>Q(x)||R(x),d=(x)=>_(x)?x:U(x)?V(x):D(x),A=(x)=>{if(W&&!x.includes(W))x.push(W)},C=(x)=>{x.forEach((y)=>M?P.add(y):y())},I=(x,y)=>{let j=W;W=y,x(),W=j},m=(x)=>{if(M++,x(),M--,!M)p()};class F{x;watchers=[];constructor(x){this.value=x}get(){return A(this.watchers),this.value}set(x){if(Object.is(this.value,x))return;if(this.value=x,C(this.watchers),B===x)this.watchers=[]}update(x){this.set(x(this.value))}map(x){return V(()=>x(this.get()))}}var D=(x)=>new F(x),Q=(x)=>x instanceof F;function b(x,...y){let j=N(x)?{ok:x}:x,{ok:z,nil:G,err:q}=j,H=()=>I(()=>{let X=[],J=[],Z=!1;for(let K of y)try{let T=K.get();if(T===B)Z=!0;X.push(T)}catch(T){J.push($(T))}try{if(!Z&&!J.length)z(...X);else if(J.length&&q)q(...J);else if(Z&&G)G()}catch(K){q?.($(K))}},H);H()}export{d as toSignal,D as state,Q as isState,_ as isSignal,R as isComputed,b as effect,V as computed,m as batch,B as UNSET,F as State};
+var j=(y)=>typeof y==="function";var O=(y)=>j(y)&&y.length<2,D=(y,x)=>Object.prototype.toString.call(y)===`[object ${x}]`,g=(y)=>(x)=>x instanceof y,A=g(Error),o=g(Promise),C=(y)=>A(y)?y:new Error(String(y)),k=(y,x)=>{if(!x)return!1;return y.name===x.name&&y.message===x.message};var X,P=new Set,_=0,S=new Map,M,b=()=>{M=void 0;for(let y of S.values()){for(let x of y.values())x();y.clear()}},v=()=>{if(M)cancelAnimationFrame(M);M=requestAnimationFrame(b)};queueMicrotask(b);var T=(y)=>{if(X&&!y.includes(X))y.push(X)},I=(y)=>{for(let x of y)_?P.add(x):x()},U=()=>{while(P.size){let y=Array.from(P);P.clear();for(let x of y)x()}},t=(y)=>{_++,y(),U(),_--},q=(y,x)=>{let z=X;X=x,y(),X=z},u=(y,x)=>new Promise((z,L)=>{let B=()=>{try{z(y())}catch(G){L(G)}};if(x){let[G,J]=x;if(!S.has(G))S.set(G,new Map);S.get(G).set(J,B)}v()});function R(y,...x){let z=j(y)?{ok:y}:y,L=()=>q(()=>{let B=F(x,z);if(A(B))console.error("Unhandled error in effect:",B)},L);L()}var p="Computed",Z=(y,...x)=>{let z=j(y)?{ok:y}:y,L=[],B=Q,G,J=!0,K=!1,H=!1,W=($)=>{if(!Object.is($,B))B=$,J=!1,G=void 0,K=!1},V=()=>{K=Q===B,B=Q,G=void 0},m=($)=>{let N=C($);K=k(N,G),B=Q,G=N},n=()=>{if(J=!0,!K)I(L)},i=()=>q(()=>{if(H)throw new Error("Circular dependency detected");K=!0,H=!0;let $=F(x,z);if(o($))V(),$.then((N)=>{W(N),I(L)}).catch(m);else if($==null||Q===$)V();else if(A($))m($);else W($);H=!1},n),Y={[Symbol.toStringTag]:p,get:()=>{if(T(L),U(),J)i();if(G)throw G;return B},map:($)=>Z(()=>$(Y.get())),match:($)=>{return R($,Y),Y}};return Y},f=(y)=>D(y,p);var h="State",w=(y)=>{let x=[],z=y,L={[Symbol.toStringTag]:h,get:()=>{return T(x),z},set:(B)=>{if(Object.is(z,B))return;if(z=B,I(x),Q===z)x.length=0},update:(B)=>{L.set(B(z))},map:(B)=>Z(()=>B(L.get())),match:(B)=>{return R(B,L),L}};return L},E=(y)=>D(y,h);var Q=Symbol(),d=(y)=>E(y)||f(y),c=(y)=>d(y)?y:O(y)?Z(y):w(y),F=(y,x)=>{let{ok:z,nil:L,err:B}=x,G=[],J=[],K=!1;for(let W of y)try{let V=W.get();if(V===Q)K=!0;G.push(V)}catch(V){J.push(C(V))}let H=void 0;try{if(K&&L)H=L();else if(J.length)H=B?B(...J):J[0];else if(!K)H=z(...G)}catch(W){if(H=C(W),B)H=B(H)}finally{return H}};export{q as watch,c as toSignal,w as state,E as isState,d as isSignal,f as isComputed,u as enqueue,R as effect,Z as computed,t as batch,Q as UNSET};

package/index.ts

@@ -1,12 +1,10 @@
 /**
  * @name Cause & Effect
- * @version 0.11.0
+ * @version 0.12.0
  * @author Esther Brunner
  */
-export { State, state, isState } from './lib/state'
+export { type Signal, type MaybeSignal, UNSET, isSignal, toSignal } from './lib/signal'
+export { type State, state, isState } from './lib/state'
 export { type Computed, computed, isComputed } from './lib/computed'
-export {
-	type Signal, type MaybeSignal,
-	UNSET, isSignal, toSignal, batch
-} from './lib/signal'
-export { effect } from './lib/effect'
+export { type EffectOkCallback, type EffectCallbacks, effect } from './lib/effect'
+export { type EnqueueDedupe, batch, watch, enqueue } from './lib/scheduler'

package/lib/computed.d.ts

@@ -1,16 +1,29 @@
-export type Computed<T> = {
-    [Symbol.toStringTag]: "Computed";
+import { type SignalValue, type UnknownSignal } from './signal';
+import { type EffectCallbacks } from './effect';
+export type ComputedOkCallback<T extends {}, U extends UnknownSignal[]> = (...values: {
+    [K in keyof U]: SignalValue<U[K]>;
+}) => T | Promise<T>;
+export type ComputedCallbacks<T extends {}, U extends UnknownSignal[]> = {
+    ok: (...values: {
+        [K in keyof U]: SignalValue<U[K]>;
+    }) => T | Promise<T>;
+    nil?: () => T | Promise<T>;
+    err?: (...errors: Error[]) => T | Promise<T>;
+};
+export type Computed<T extends {}> = {
+    [Symbol.toStringTag]: 'Computed';
     get: () => T;
     map: <U extends {}>(fn: (value: T) => U) => Computed<U>;
+    match: (callbacks: EffectCallbacks<[Computed<T>]>) => void;
 };
 /**
  * Create a derived state from existing states
  *
  * @since 0.9.0
- * @param {() => T} fn - compute function to derive state
+ * @param {() => T} callbacksOrFn - compute function to derive state
  * @returns {Computed<T>} result of derived state
  */
-export declare const computed: <T extends {}>(fn: (v?: T) => T | Promise<T>) => Computed<T>;
+export declare const computed: <T extends {}, U extends UnknownSignal[]>(callbacksOrFn: ComputedCallbacks<T, U> | ComputedOkCallback<T, U>, ...signals: U) => Computed<T>;
 /**
  * Check if a value is a computed state
  *
@@ -18,4 +31,4 @@ export declare const computed: <T extends {}>(fn: (v?: T) => T | Promise<T>) =>
  * @param {unknown} value - value to check
  * @returns {boolean} - true if value is a computed state, false otherwise
  */
-export declare const isComputed: <T>(value: unknown) => value is Computed<T>;
+export declare const isComputed: <T extends {}>(value: unknown) => value is Computed<T>;

package/lib/computed.ts

@@ -1,92 +1,140 @@
-import { type Watcher, subscribe, notify, watch, UNSET } from "./signal"
-import { isPromise, toError } from "./util"
+import { resolveSignals, UNSET, type SignalValue, type UnknownSignal } from './signal'
+import { isEquivalentError, isError, isFunction, isObjectOfType, isPromise, toError } from './util'
+import { type Watcher, flush, notify, subscribe, watch } from './scheduler'
+import { type EffectCallbacks, effect } from './effect'
 
 /* === Types === */
 
-export type Computed<T> = {
-    [Symbol.toStringTag]: "Computed"
+export type ComputedOkCallback<T extends {}, U extends UnknownSignal[]> = (
+	...values: { [K in keyof U]: SignalValue<U[K]> }
+) => T | Promise<T>
+
+export type ComputedCallbacks<T extends {}, U extends UnknownSignal[]> = {
+	ok: (...values: { [K in keyof U]: SignalValue<U[K]> }) => T | Promise<T>
+	nil?: () => T | Promise<T>
+	err?: (...errors: Error[]) => T | Promise<T>
+}
+
+export type Computed<T extends {}> = {
+    [Symbol.toStringTag]: 'Computed'
     get: () => T
     map: <U extends {}>(fn: (value: T) => U) => Computed<U>
+	match: (callbacks: EffectCallbacks<[Computed<T>]>) => void
 }
 
 /* === Constants === */
 
 const TYPE_COMPUTED = 'Computed'
-const MAX_ITERATIONS = 1000;
 
-/* === Namespace Computed === */
+/* === Computed Factory === */
 
 /**
  * Create a derived state from existing states
  * 
  * @since 0.9.0
- * @param {() => T} fn - compute function to derive state
+ * @param {() => T} callbacksOrFn - compute function to derive state
  * @returns {Computed<T>} result of derived state
  */
-export const computed =  /*#__PURE__*/ <T extends {}>(
-	fn: (v?: T) => T | Promise<T>,
+export const computed = <T extends {}, U extends UnknownSignal[]>(
+	callbacksOrFn: ComputedCallbacks<T, U> | ComputedOkCallback<T, U>,
+	...signals: U
 ): Computed<T> => {
+	const callbacks = isFunction(callbacksOrFn)
+		? { ok: callbacksOrFn }
+		: callbacksOrFn
 	const watchers: Watcher[] = []
 	let value: T = UNSET
-	let error: Error | null = null
+	let error: Error | undefined
 	let dirty = true
 	let unchanged = false
 	let computing = false
-	let iterations = 0
 
-	const mark: Watcher = () => {
+	// Functions to update internal state
+	const ok = (v: T) => {
+		if (!Object.is(v, value)) {
+			value = v
+			dirty = false
+			error = undefined
+			unchanged = false
+		}
+	}
+	const nil = () => {
+		unchanged = (UNSET === value)
+		value = UNSET
+		error = undefined
+	}
+	const err = (e: unknown) => {
+		const newError = toError(e)
+		unchanged = isEquivalentError(newError, error)
+		value = UNSET
+		error = newError
+	}
+
+	// Called when notified from sources (push)
+	const mark = () => {
 		dirty = true
 		if (!unchanged) notify(watchers)
 	}
 
+	// Called when requested by dependencies (pull)
 	const compute = () => watch(() => {
-		if (!dirty || computing) return
-
-		const ok = (v: T) => {
-			if (!Object.is(v, value)) {
-				value = v
-				dirty = false
-				error = null
-				unchanged = false
-			} else {
-				unchanged = true
-			}
-		}
-		const err = (e: unknown) => {
-			const newError = toError(e)
-			unchanged = Object.is(newError, error)
-			error = newError
-		}
-		
+		if (computing) throw new Error('Circular dependency detected')
+		unchanged = true
 		computing = true
-		try {
-			const res = fn(value)
-			isPromise(res)
-				? res.then(v => {
-					ok(v)
-					notify(watchers)
-				}).catch(err)
-				: ok(res)
-		} catch (e) {
-			err(e)
-		} finally {
-			computing = false
-		}
+		const result = resolveSignals(signals, callbacks as ComputedCallbacks<T, U>)
+		if (isPromise(result)) {
+			nil() // sync
+			result.then(v => {
+				ok(v) // async
+                notify(watchers)
+			}).catch(err)
+		} else if (null == result || UNSET === result) nil()
+		else if (isError(result)) err(result)
+		else ok(result)
+		computing = false
 	}, mark)
 
 	const c: Computed<T> = {
 		[Symbol.toStringTag]: TYPE_COMPUTED,
-		get: () => {
-			if (iterations++ >= MAX_ITERATIONS) {
-                throw new Error(`Circular dependency detected: exceeded ${MAX_ITERATIONS} iterations`)
-            }
+
+		/**
+		 * Get the current value of the computed
+		 * 
+		 * @since 0.9.0
+		 * @method of Computed<T>
+		 * @returns {T} - current value of the computed
+		 */
+		get: (): T => {
 			subscribe(watchers)
-			compute()
+			flush()
+			if (dirty) compute()
 			if (error) throw error
 			return value
 		},
-		map: <U extends {}>(fn: (value: T) => U): Computed<U> =>
+
+		/**
+		 * Create a computed signal from the current computed signal
+		 * 
+		 * @since 0.9.0
+		 * @method of Computed<T>
+		 * @param {(value: T) => R} fn
+		 * @returns {Computed<R>} - computed signal
+		 */
+		map: <R extends {}>(fn: (value: T) => R): Computed<R> =>
 			computed(() => fn(c.get())),
+
+		/**
+		 * Case matching for the computed signal with effect callbacks
+		 * 
+		 * @since 0.12.0
+		 * @method of Computed<T>
+		 * @param {EffectCallbacks[<T>]} callbacks 
+		 * @returns {Computed<T>} - self, for chaining effect callbacks
+		 */
+		match: (callbacks: EffectCallbacks<[Computed<T>]>): Computed<T> => {
+			effect(callbacks, c)
+			return c
+		}
 	}
 	return c
 }
@@ -100,6 +148,5 @@ export const computed =  /*#__PURE__*/ <T extends {}>(
  * @param {unknown} value - value to check
  * @returns {boolean} - true if value is a computed state, false otherwise
  */
-export const isComputed = /*#__PURE__*/ <T>(value: unknown): value is Computed<T> =>
-	!!value && typeof value === 'object'
-		&& (value as { [key in typeof Symbol.toStringTag]: string })[Symbol.toStringTag] === TYPE_COMPUTED
+export const isComputed = /*#__PURE__*/ <T extends {}>(value: unknown): value is Computed<T> =>
+	isObjectOfType(value, TYPE_COMPUTED)

package/lib/effect.d.ts

@@ -1,7 +1,11 @@
-import { type Signal } from "./signal";
-export type EffectOkCallback<T extends {}[]> = (...values: T) => void;
-export type EffectCallbacks<T extends {}[]> = {
-    ok: EffectOkCallback<T>;
+import { type SignalValue, type UnknownSignal } from './signal';
+export type EffectOkCallback<T extends UnknownSignal[]> = (...values: {
+    [K in keyof T]: SignalValue<T[K]>;
+}) => void;
+export type EffectCallbacks<T extends UnknownSignal[]> = {
+    ok: (...values: {
+        [K in keyof T]: SignalValue<T[K]>;
+    }) => void;
     nil?: () => void;
     err?: (...errors: Error[]) => void;
 };
@@ -9,7 +13,6 @@ export type EffectCallbacks<T extends {}[]> = {
  * Define what happens when a reactive state changes
  *
  * @since 0.1.0
- * @param {() => void} fn - callback function to be executed when a state changes
+ * @param {() => void} callbacksOrFn - callback function to be executed when a state changes
  */
-export declare function effect<T extends {}>(ok: EffectOkCallback<T[]>, ...signals: Signal<T>[]): void;
-export declare function effect<T extends {}>(callbacks: EffectCallbacks<T[]>, ...signals: Signal<T>[]): void;
+export declare function effect<T extends UnknownSignal[]>(callbacksOrFn: EffectCallbacks<T> | EffectOkCallback<T>, ...signals: T): void;

package/lib/effect.ts

@@ -1,13 +1,16 @@
 
-import { type Signal, UNSET, type Watcher, watch } from "./signal"
-import { isFunction, toError } from "./util"
+import { resolveSignals, type SignalValue, type UnknownSignal } from './signal'
+import { isError, isFunction } from './util'
+import { watch } from './scheduler'
 
 /* === Types === */
 
-export type EffectOkCallback<T extends {}[]> = (...values: T) => void
+export type EffectOkCallback<T extends UnknownSignal[]> = (
+	...values: { [K in keyof T]: SignalValue<T[K]> }
+) => void
 
-export type EffectCallbacks<T extends {}[]> = {
-	ok: EffectOkCallback<T>
+export type EffectCallbacks<T extends UnknownSignal[]> = {
+	ok: (...values: { [K in keyof T]: SignalValue<T[K]> }) => void
 	nil?: () => void
 	err?: (...errors: Error[]) => void
 }
@@ -18,48 +21,20 @@ export type EffectCallbacks<T extends {}[]> = {
  * Define what happens when a reactive state changes
  * 
  * @since 0.1.0
- * @param {() => void} fn - callback function to be executed when a state changes
+ * @param {() => void} callbacksOrFn - callback function to be executed when a state changes
  */
-
-export function effect<T extends {}>(
-    ok: EffectOkCallback<T[]>,
-    ...signals: Signal<T>[]
-): void
-export function effect<T extends {}>(
-    callbacks: EffectCallbacks<T[]>,
-    ...signals: Signal<T>[]
-): void
-export function effect<T extends {}>(
-	callbacksOrFn: EffectCallbacks<T[]> | EffectOkCallback<T[]>,
-	...signals: Signal<T>[]
+export function effect<T extends UnknownSignal[]>(
+	callbacksOrFn: EffectCallbacks<T> | EffectOkCallback<T>,
+	...signals: T
 ): void {
 	const callbacks = isFunction(callbacksOrFn)
         ? { ok: callbacksOrFn }
-        : callbacksOrFn as EffectCallbacks<T[]>
-
-    const { ok, nil, err } = callbacks
-
-	const run: Watcher = () => watch(() => {
-		const values: T[] = []
-		const errors: Error[] = []
-		let hasUnset = false
+        : callbacksOrFn
 
-		for (const signal of signals) {
-			try {
-				const value = signal.get()
-				if (value === UNSET) hasUnset = true
-				values.push(value)
-			} catch (error) {
-				errors.push(toError(error))
-			}
-		}
-		try {
-			if (!hasUnset && !errors.length) ok(...values)
-			else if (errors.length && err) err(...errors)
-		    else if (hasUnset && nil) nil()
-		} catch (error) {
-            err?.(toError(error))
-		}
+	const run = () => watch(() => {
+		const result = resolveSignals(signals, callbacks as EffectCallbacks<T>)
+		if (isError(result))
+			console.error('Unhandled error in effect:', result)
     }, run)
 	run()
 }

package/lib/scheduler.d.ts

@@ -0,0 +1,40 @@
+export type EnqueueDedupe = [Element, string];
+export type Watcher = () => void;
+export type Updater = <T>() => T;
+/**
+ * Add active watcher to the array of watchers
+ *
+ * @param {Watcher[]} watchers - watchers of the signal
+ */
+export declare const subscribe: (watchers: Watcher[]) => void;
+/**
+ * Add watchers to the pending set of change notifications
+ *
+ * @param {Watcher[]} watchers - watchers of the signal
+ */
+export declare const notify: (watchers: Watcher[]) => void;
+/**
+ * Flush all pending changes to notify watchers
+ */
+export declare const flush: () => void;
+/**
+ * Batch multiple changes in a single signal graph and DOM update cycle
+ *
+ * @param {() => void} fn - function with multiple signal writes to be batched
+ */
+export declare const batch: (fn: () => void) => void;
+/**
+ * Run a function in a reactive context
+ *
+ * @param {() => void} run - function to run the computation or effect
+ * @param {Watcher} mark - function to be called when the state changes
+ */
+export declare const watch: (run: () => void, mark: Watcher) => void;
+/**
+ * Enqueue a function to be executed on the next animation frame
+ *
+ * @param callback
+ * @param dedupe
+ * @returns
+ */
+export declare const enqueue: <T>(update: Updater, dedupe?: EnqueueDedupe) => Promise<T>;