@zeix/cause-effect 0.12.0 → 0.12.2

package/README.md

@@ -1,6 +1,6 @@
 # Cause & Effect
 
-Version 0.12.0
+Version 0.12.2
 
 **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.
 
@@ -108,14 +108,14 @@ document.querySelector('.increment').addEventListener('click', () => {
 
 Async computed signals are as straight forward as their sync counterparts. Just create the computed signal with an async function.
 
-**Caution**: You can't use the `.map()` method to create an async computed signal. And async computed signals will return a Symbol `UNSET` until the Promise is resolved.
+**Caution**: Async computed signals will return a Symbol `UNSET` until the Promise is resolved.
 
 ```js
-import { state, computed, effect } from '@zeix/cause-effect'
+import { state, effect } from '@zeix/cause-effect'
 
 const entryId = state(42)
-const entryData = computed(async () => {
-    const response = await fetch(`/api/entry/${entryId.get()}`)
+const entryData = entryId.map(async id => {
+    const response = await fetch(`/api/entry/${id}`)
     if (!response.ok) return new Error(`Failed to fetch data: ${response.statusText}`)
     return response.json()
 })

package/index.d.ts

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

package/index.js

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

package/index.ts

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

package/lib/computed.d.ts

@@ -1,29 +1,19 @@
-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>;
-};
+import { type MaybeSignal, type EffectCallbacks, type ComputedCallbacks } from './signal';
 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;
+    map: <U extends {}>(cb: ComputedCallbacks<U, [Computed<T>]>) => Computed<U>;
+    match: (cb: EffectCallbacks<[Computed<T>]>) => void;
 };
 /**
- * Create a derived state from existing states
+ * Create a derived signal from existing signals
  *
  * @since 0.9.0
- * @param {() => T} callbacksOrFn - compute function to derive state
- * @returns {Computed<T>} result of derived state
+ * @param {() => T} cb - compute callback or object of ok, nil, err callbacks to derive state
+ * @param {U} maybeSignals - signals of functions using signals this values depends on
+ * @returns {Computed<T>} - Computed signal
  */
-export declare const computed: <T extends {}, U extends UnknownSignal[]>(callbacksOrFn: ComputedCallbacks<T, U> | ComputedOkCallback<T, U>, ...signals: U) => Computed<T>;
+export declare const computed: <T extends {}, U extends MaybeSignal<{}>[]>(cb: ComputedCallbacks<T, U>, ...maybeSignals: U) => Computed<T>;
 /**
  * Check if a value is a computed state
  *

package/lib/computed.ts

@@ -1,47 +1,48 @@
-import { resolveSignals, UNSET, type SignalValue, type UnknownSignal } from './signal'
-import { isEquivalentError, isError, isFunction, isObjectOfType, isPromise, toError } from './util'
+import {
+	type MaybeSignal, type EffectCallbacks, type ComputedCallbacks,
+	resolve, UNSET
+} from './signal'
+import { isError, isObjectOfType, isPromise, toError } from './util'
 import { type Watcher, flush, notify, subscribe, watch } from './scheduler'
-import { type EffectCallbacks, effect } from './effect'
+import { effect } from './effect'
 
 /* === Types === */
 
-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
+    map: <U extends {}>(cb: ComputedCallbacks<U, [Computed<T>]>) => Computed<U>
+	match: (cb: EffectCallbacks<[Computed<T>]>) => void
 }
 
 /* === Constants === */
 
 const TYPE_COMPUTED = 'Computed'
 
+/* === Private Functions === */
+
+const isEquivalentError = /*#__PURE__*/ (
+	error1: Error,
+	error2: Error | undefined
+): boolean => {
+    if (!error2) return false
+    return error1.name === error2.name && error1.message === error2.message
+}
+
 /* === Computed Factory === */
 
 /**
- * Create a derived state from existing states
+ * Create a derived signal from existing signals
  * 
  * @since 0.9.0
- * @param {() => T} callbacksOrFn - compute function to derive state
- * @returns {Computed<T>} result of derived state
+ * @param {() => T} cb - compute callback or object of ok, nil, err callbacks to derive state
+ * @param {U} maybeSignals - signals of functions using signals this values depends on
+ * @returns {Computed<T>} - Computed signal
  */
-export const computed = <T extends {}, U extends UnknownSignal[]>(
-	callbacksOrFn: ComputedCallbacks<T, U> | ComputedOkCallback<T, U>,
-	...signals: U
+export const computed = <T extends {}, U extends MaybeSignal<{}>[]>(
+	cb: ComputedCallbacks<T, U>,
+	...maybeSignals: U
 ): Computed<T> => {
-	const callbacks = isFunction(callbacksOrFn)
-		? { ok: callbacksOrFn }
-		: callbacksOrFn
 	const watchers: Watcher[] = []
 	let value: T = UNSET
 	let error: Error | undefined
@@ -78,10 +79,10 @@ export const computed = <T extends {}, U extends UnknownSignal[]>(
 
 	// Called when requested by dependencies (pull)
 	const compute = () => watch(() => {
-		if (computing) throw new Error('Circular dependency detected')
+		if (computing) throw new Error('Circular dependency in computed detected')
 		unchanged = true
 		computing = true
-		const result = resolveSignals(signals, callbacks as ComputedCallbacks<T, U>)
+		const result = resolve(maybeSignals, cb)
 		if (isPromise(result)) {
 			nil() // sync
 			result.then(v => {
@@ -101,7 +102,6 @@ export const computed = <T extends {}, U extends UnknownSignal[]>(
 		 * Get the current value of the computed
 		 * 
 		 * @since 0.9.0
-		 * @method of Computed<T>
 		 * @returns {T} - current value of the computed
 		 */
 		get: (): T => {
@@ -116,23 +116,21 @@ export const computed = <T extends {}, U extends UnknownSignal[]>(
 		 * 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
+		 * @param {ComputedCallbacks<U, [Computed<T>]>} cb - compute callback or object of ok, nil, err callbacks to map this value to new computed
+		 * @returns {Computed<U>} - computed signal
 		 */
-		map: <R extends {}>(fn: (value: T) => R): Computed<R> =>
-			computed(() => fn(c.get())),
+		map: <U extends {}>(cb: ComputedCallbacks<U, [Computed<T>]>): Computed<U> =>
+			computed(cb, c),
 
 		/**
 		 * Case matching for the computed signal with effect callbacks
 		 * 
 		 * @since 0.12.0
-		 * @method of Computed<T>
-		 * @param {EffectCallbacks[<T>]} callbacks 
+		 * @param {EffectCallbacks[Computed<T>]} cb - effect callback or object of ok, nil, err callbacks to be executed when the computed changes
 		 * @returns {Computed<T>} - self, for chaining effect callbacks
 		 */
-		match: (callbacks: EffectCallbacks<[Computed<T>]>): Computed<T> => {
-			effect(callbacks, c)
+		match: (cb: EffectCallbacks<[Computed<T>]>): Computed<T> => {
+			effect(cb, c)
 			return c
 		}
 	}

package/lib/effect.d.ts

@@ -1,18 +1,9 @@
-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;
-};
+import { type EffectCallbacks, type MaybeSignal } from './signal';
 /**
  * Define what happens when a reactive state changes
  *
  * @since 0.1.0
- * @param {() => void} callbacksOrFn - callback function to be executed when a state changes
+ * @param {() => void} cb - effect callback or object of ok, nil, err callbacks to be executed when a state changes
+ * @param {U} maybeSignals - signals of functions using signals that should trigger the effect
  */
-export declare function effect<T extends UnknownSignal[]>(callbacksOrFn: EffectCallbacks<T> | EffectOkCallback<T>, ...signals: T): void;
+export declare function effect<U extends MaybeSignal<{}>[]>(cb: EffectCallbacks<U>, ...maybeSignals: U): void;

package/lib/effect.ts

@@ -1,40 +1,29 @@
 
-import { resolveSignals, type SignalValue, type UnknownSignal } from './signal'
-import { isError, isFunction } from './util'
+import { type EffectCallbacks, type MaybeSignal, resolve } from './signal'
+import { isError } from './util'
 import { watch } from './scheduler'
 
-/* === Types === */
-
-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
-}
-
 /* === Exported Function === */
 
 /**
  * Define what happens when a reactive state changes
  * 
  * @since 0.1.0
- * @param {() => void} callbacksOrFn - callback function to be executed when a state changes
+ * @param {() => void} cb - effect callback or object of ok, nil, err callbacks to be executed when a state changes
+ * @param {U} maybeSignals - signals of functions using signals that should trigger the effect
  */
-export function effect<T extends UnknownSignal[]>(
-	callbacksOrFn: EffectCallbacks<T> | EffectOkCallback<T>,
-	...signals: T
+export function effect<U extends MaybeSignal<{}>[]>(
+	cb: EffectCallbacks<U>,
+	...maybeSignals: U
 ): void {
-	const callbacks = isFunction(callbacksOrFn)
-        ? { ok: callbacksOrFn }
-        : callbacksOrFn
-
+	let running = false
 	const run = () => watch(() => {
-		const result = resolveSignals(signals, callbacks as EffectCallbacks<T>)
+		if (running) throw new Error('Circular dependency in effect detected')
+		running = true
+		const result = resolve(maybeSignals, cb)
 		if (isError(result))
 			console.error('Unhandled error in effect:', result)
+		running = false
     }, run)
 	run()
 }

package/lib/signal.d.ts

@@ -1,10 +1,25 @@
 import { type State } from "./state";
 import { type Computed } from "./computed";
 type Signal<T extends {}> = State<T> | Computed<T>;
-type UnknownSignal = Signal<{}>;
-type MaybeSignal<T extends {}> = Signal<T> | T | (() => T);
-type SignalValue<T> = T extends Signal<infer U> ? U : never;
-export declare const UNSET: any;
+type MaybeSignal<T extends {}> = Signal<T> | T | (() => T | Promise<T>);
+type InferMaybeSignalType<T> = T extends Signal<infer U> ? U : T extends (() => infer U) ? U : T;
+type OkCallback<T, U extends MaybeSignal<{}>[]> = (...values: {
+    [K in keyof U]: InferMaybeSignalType<U[K]>;
+}) => T | Promise<T> | Error;
+type NilCallback<T> = () => T | Promise<T> | Error;
+type ErrCallback<T> = (...errors: Error[]) => T | Promise<T> | Error;
+type ComputedCallbacks<T extends {}, U extends MaybeSignal<{}>[]> = OkCallback<T, U> | {
+    ok: OkCallback<T, U>;
+    nil?: NilCallback<T>;
+    err?: ErrCallback<T>;
+};
+type EffectCallbacks<U extends MaybeSignal<{}>[]> = OkCallback<void, U> | {
+    ok: OkCallback<void, U>;
+    nil?: NilCallback<void>;
+    err?: ErrCallback<void>;
+};
+type CallbackReturnType<T> = T | Promise<T> | Error | void;
+declare const UNSET: any;
 /**
  * Check whether a value is a Signal or not
  *
@@ -21,18 +36,18 @@ declare const isSignal: <T extends {}>(value: any) => value is Signal<T>;
  * @param memo
  * @returns {Signal<T>} - converted Signal
  */
-declare const toSignal: <T extends {}>(value: MaybeSignal<T>) => Signal<T>;
+declare const toSignal: <T extends {}>(value: MaybeSignal<T> | ComputedCallbacks<T, []>) => Signal<T>;
 /**
- * Resolve signals and apply callbacks based on the results
+ * Resolve signals or functions using signals and apply callbacks based on the results
  *
  * @since 0.12.0
- * @param {U} signals - dependency signals
- * @param {Record<string, (...args) => T | Promise<T> | Error | void>} callbacks - ok, nil, err callbacks
- * @returns {T | Promise<T> | Error | void} - result of chosen callback
+ * @param {U} maybeSignals - dependency signals (or functions using signals)
+ * @param {Record<string, (...args) => CallbackReturnType<T>} cb - object of ok, nil, err callbacks or just ok callback
+ * @returns {CallbackReturnType<T>} - result of chosen callback
  */
-declare const resolveSignals: <T extends {}, U extends UnknownSignal[]>(signals: U, callbacks: {
-    ok: (...values: { [K in keyof U]: SignalValue<U[K]>; }) => T | Promise<T> | Error | void;
-    nil?: () => T | Promise<T> | Error | void;
-    err?: (...errors: Error[]) => T | Promise<T> | Error | void;
-}) => T | Promise<T> | Error | void;
-export { type Signal, type UnknownSignal, type SignalValue, type MaybeSignal, isSignal, toSignal, resolveSignals, };
+declare const resolve: <T, U extends MaybeSignal<{}>[]>(maybeSignals: U, cb: OkCallback<T | Promise<T>, U> | {
+    ok: OkCallback<T | Promise<T>, U>;
+    nil?: NilCallback<T>;
+    err?: ErrCallback<T>;
+}) => CallbackReturnType<T>;
+export { type Signal, type MaybeSignal, type InferMaybeSignalType, type EffectCallbacks, type ComputedCallbacks, type CallbackReturnType, UNSET, isSignal, toSignal, resolve, };

package/lib/signal.ts

@@ -1,18 +1,44 @@
 import { type State, isState, state } from "./state"
-import { computed, type Computed, isComputed } from "./computed"
-import { isComputeFunction, toError } from "./util"
+import { type Computed, computed, isComputed } from "./computed"
+import { isFunction, toError } from "./util"
 
 /* === Types === */
 
 type Signal<T extends {}> = State<T> | Computed<T>
-type UnknownSignal = Signal<{}>
-type MaybeSignal<T extends {}> = Signal<T> | T | (() => T)
+type MaybeSignal<T extends {}> = Signal<T> | T | (() => T | Promise<T>)
+type InferMaybeSignalType<T> = T extends Signal<infer U> ? U :
+	T extends (() => infer U) ? U :
+	T
 
-type SignalValue<T> = T extends Signal<infer U> ? U : never
+type OkCallback<T, U extends MaybeSignal<{}>[]> = (...values: {
+	[K in keyof U]: InferMaybeSignalType<U[K]>
+}) => T | Promise<T> | Error
+type NilCallback<T> = () => T | Promise<T> | Error
+type ErrCallback<T> = (...errors: Error[]) => T | Promise<T> | Error
+
+type ComputedCallbacks<T extends {}, U extends MaybeSignal<{}>[]> = OkCallback<T, U> | {
+	ok: OkCallback<T, U>,
+    nil?: NilCallback<T>,
+    err?: ErrCallback<T>
+}
+
+type EffectCallbacks<U extends MaybeSignal<{}>[]> = OkCallback<void, U> | {
+	ok: OkCallback<void, U>,
+	nil?: NilCallback<void>,
+	err?: ErrCallback<void>
+}
+
+type CallbackReturnType<T> = T | Promise<T> | Error | void
 
 /* === Constants === */
 
-export const UNSET: any = Symbol()
+const UNSET: any = Symbol()
+
+/* === Private Functions === */
+
+const isComputedCallbacks = /*#__PURE__*/ <T extends {}>(value: unknown): value is ComputedCallbacks<T, []> =>
+	(isFunction(value) && !value.length)
+		|| (typeof value === 'object' && value !== null && 'ok' in value && isFunction(value.ok))
 
 /* === Exported Functions === */
 
@@ -35,58 +61,67 @@ const isSignal = /*#__PURE__*/ <T extends {}>(value: any): value is Signal<T> =>
  * @returns {Signal<T>} - converted Signal
  */
 const toSignal = /*#__PURE__*/ <T extends {}>(
-	value: MaybeSignal<T>
+	value: MaybeSignal<T> | ComputedCallbacks<T, []>
 ): Signal<T> =>
 	isSignal<T>(value) ? value
-		: isComputeFunction<T>(value) ? computed(value)
-		: state(value)
+		: isComputedCallbacks<T>(value) ? computed(value)
+		: state(value as T)
 
 
 /**
- * Resolve signals and apply callbacks based on the results
+ * Resolve signals or functions using signals and apply callbacks based on the results
  * 
  * @since 0.12.0
- * @param {U} signals - dependency signals
- * @param {Record<string, (...args) => T | Promise<T> | Error | void>} callbacks - ok, nil, err callbacks
- * @returns {T | Promise<T> | Error | void} - result of chosen callback
+ * @param {U} maybeSignals - dependency signals (or functions using signals)
+ * @param {Record<string, (...args) => CallbackReturnType<T>} cb - object of ok, nil, err callbacks or just ok callback
+ * @returns {CallbackReturnType<T>} - result of chosen callback
  */
-const resolveSignals = <T extends {}, U extends UnknownSignal[]>(
-	signals: U,
-	callbacks: {
-		ok: (...values: { [K in keyof U]: SignalValue<U[K]> }) => T | Promise<T> | Error | void
-		nil?: () => T | Promise<T> | Error | void
-		err?: (...errors: Error[]) => T | Promise<T> | Error | void
+const resolve = <T, U extends MaybeSignal<{}>[]>(
+	maybeSignals: U,
+	cb: OkCallback<T | Promise<T>, U> | {
+		ok: OkCallback<T | Promise<T>, U>
+		nil?: NilCallback<T>
+		err?: ErrCallback<T>
+	}
+): CallbackReturnType<T> => {
+	const { ok, nil, err } = isFunction(cb)
+		? { ok: cb }
+		: cb as {
+			ok: OkCallback<T | Promise<T>, U>
+			nil?: NilCallback<T>
+			err?: ErrCallback<T>
+		}
+	const values = [] as {
+		[K in keyof U]: InferMaybeSignalType<U[K]>
 	}
-): T | Promise<T> | Error | void => {
-	const { ok, nil, err  } = callbacks
-	const values = [] as { [K in keyof U]: SignalValue<U[K]> }
     const errors: Error[] = []
     let hasUnset = false
 
-    for (const signal of signals) {
+    for (let i = 0; i < maybeSignals.length; i++) {
+		const s = maybeSignals[i]
 		try {
-			const value = signal.get()
+			const value = isSignal(s) ? s.get() : isFunction(s) ? s() : s
 			if (value === UNSET) hasUnset = true
-			values.push(value)
+			values[i] = value as InferMaybeSignalType<typeof s>
 		} catch (e) {
 			errors.push(toError(e))
 		}
     }
 
-	let result: T | Promise<T> | Error | void = undefined
+	let result: CallbackReturnType<T> = undefined
     try {
 		if (hasUnset && nil) result = nil()
 		else if (errors.length) result = err ? err(...errors) : errors[0]
-		else if (!hasUnset) result = ok(...values)
+		else if (!hasUnset) result = ok(...values) as CallbackReturnType<T>
     } catch (e) {
 		result = toError(e)
 		if (err) result = err(result)
-    } finally {
-		return result
-	}
+    }
+	return result
 }
 
 export {
-	type Signal, type UnknownSignal, type SignalValue, type MaybeSignal,
-    isSignal, toSignal, resolveSignals,
+	type Signal, type MaybeSignal, type InferMaybeSignalType,
+	type EffectCallbacks, type ComputedCallbacks, type CallbackReturnType,
+    UNSET, isSignal, toSignal, resolve,
 }

package/lib/state.d.ts

@@ -1,12 +1,12 @@
+import { type ComputedCallbacks, type EffectCallbacks } from './signal';
 import { type Computed } from './computed';
-import { type EffectCallbacks } from './effect';
 export type State<T extends {}> = {
     [Symbol.toStringTag]: 'State';
     get(): T;
-    set(value: T): void;
-    update(fn: (value: T) => T): void;
-    map<U extends {}>(fn: (value: T) => U): Computed<U>;
-    match: (callbacks: EffectCallbacks<[State<T>]>) => void;
+    set(v: T): void;
+    update(fn: (v: T) => T): void;
+    map<U extends {}>(cb: ComputedCallbacks<U, [State<T>]>): Computed<U>;
+    match: (cb: EffectCallbacks<[State<T>]>) => void;
 };
 /**
  * Create a new state signal
@@ -15,7 +15,7 @@ export type State<T extends {}> = {
  * @param {T} initialValue - initial value of the state
  * @returns {State<T>} - new state signal
  */
-export declare const state: <T extends {}>(v: T) => State<T>;
+export declare const state: <T extends {}>(initialValue: T) => State<T>;
 /**
  * Check if the provided value is a State instance
  *

package/lib/state.ts

@@ -1,18 +1,18 @@
-import { UNSET } from './signal'
+import { UNSET, type ComputedCallbacks, type EffectCallbacks } from './signal'
 import { type Computed, computed } from './computed'
 import { isObjectOfType } from './util';
 import { type Watcher, notify, subscribe } from './scheduler'
-import { type EffectCallbacks, effect } from './effect';
+import { effect } from './effect';
 
 /* === Types === */
 
 export type State<T extends {}> = {
     [Symbol.toStringTag]: 'State';
     get(): T;
-    set(value: T): void;
-    update(fn: (value: T) => T): void;
-    map<U extends {}>(fn: (value: T) => U): Computed<U>;
-	match: (callbacks: EffectCallbacks<[State<T>]>) => void
+    set(v: T): void;
+    update(fn: (v: T) => T): void;
+    map<U extends {}>(cb: ComputedCallbacks<U, [State<T>]>): Computed<U>;
+	match: (cb: EffectCallbacks<[State<T>]>) => void
 }
 
 /* === Constants === */
@@ -28,9 +28,9 @@ const TYPE_STATE = 'State'
  * @param {T} initialValue - initial value of the state
  * @returns {State<T>} - new state signal
  */
-export const state = /*#__PURE__*/ <T extends {}>(v: T): State<T> => {
+export const state = /*#__PURE__*/ <T extends {}>(initialValue: T): State<T> => {
 	const watchers: Watcher[] = []
-	let value: T = v
+	let value: T = initialValue
 
 	const s: State<T> = {
 		[Symbol.toStringTag]: TYPE_STATE,
@@ -39,7 +39,6 @@ export const state = /*#__PURE__*/ <T extends {}>(v: T): State<T> => {
 		 * Get the current value of the state
 		 * 
 		 * @since 0.9.0
-		 * @method of State<T>
 		 * @returns {T} - current value of the state
 		 */
         get: (): T => {
@@ -51,7 +50,6 @@ export const state = /*#__PURE__*/ <T extends {}>(v: T): State<T> => {
 		 * Set a new value of the state
 		 * 
 		 * @since 0.9.0
-		 * @method of State<T>
 		 * @param {T} v
 		 * @returns {void}
 		 */
@@ -68,8 +66,7 @@ export const state = /*#__PURE__*/ <T extends {}>(v: T): State<T> => {
 		 * Update the state with a new value using a function
 		 * 
 		 * @since 0.10.0
-		 * @method of State<T>
-		 * @param {(v: T) => T} fn
+		 * @param {(v: T) => T} fn - function to update the state
 		 * @returns {void} - updates the state with the result of the function
 		 */
         update: (fn: (v: T) => T): void => {
@@ -80,23 +77,22 @@ export const state = /*#__PURE__*/ <T extends {}>(v: T): State<T> => {
 		 * Create a computed signal from the current state signal
 		 * 
 		 * @since 0.9.0
-		 * @method of State<T>
-		 * @param {(v: T) => R} fn
-		 * @returns {Computed<R>} - computed signal
+		 * @param {ComputedCallbacks<U, [State<T>]>} cb - compute callback or object of ok, nil, err callbacks to map this value to new computed
+		 * @returns {Computed<U>} - computed signal
 		 */
-        map: <R extends {}>(fn: (v: T) => R): Computed<R> =>
-            computed(() => fn(s.get())),
+        map: <U extends {}>(cb: ComputedCallbacks<U, [State<T>]>): Computed<U> =>
+            computed(cb, s),
 
 		/**
 		 * Case matching for the state signal with effect callbacks
 		 * 
 		 * @since 0.12.0
 		 * @method of State<T>
-		 * @param {EffectCallbacks[<T>]} callbacks 
+		 * @param {EffectCallbacks<[State<T>]>} cb - effect callback or object of ok, nil, err callbacks to be executed when the state changes
 		 * @returns {State<T>} - self, for chaining effect callbacks
 		 */
-		match: (callbacks: EffectCallbacks<[State<T>]>): State<T> => {
-			effect(callbacks, s)
+		match: (cb: EffectCallbacks<[State<T>]>): State<T> => {
+			effect(cb, s)
 			return s
 		}
 	}

package/lib/util.d.ts

@@ -1,10 +1,8 @@
 declare const isFunction: <T>(value: unknown) => value is (...args: unknown[]) => T;
 declare const isAsyncFunction: <T>(value: unknown) => value is (...args: unknown[]) => Promise<T> | PromiseLike<T>;
-declare const isComputeFunction: <T>(value: unknown) => value is ((old?: T) => T);
 declare const isObjectOfType: <T>(value: unknown, type: string) => value is T;
 declare const isInstanceOf: <T>(type: new (...args: any[]) => T) => (value: unknown) => value is T;
 declare const isError: (value: unknown) => value is Error;
 declare const isPromise: (value: unknown) => value is Promise<unknown>;
 declare const toError: (value: unknown) => Error;
-declare const isEquivalentError: (error1: Error, error2: Error | undefined) => boolean;
-export { isFunction, isAsyncFunction, isComputeFunction, isObjectOfType, isInstanceOf, isError, isPromise, toError, isEquivalentError };
+export { isFunction, isAsyncFunction, isObjectOfType, isInstanceOf, isError, isPromise, toError };

package/lib/util.ts

@@ -6,10 +6,7 @@ const isFunction = /*#__PURE__*/ <T>(value: unknown): value is (...args: unknown
 const isAsyncFunction = /*#__PURE__*/ <T>(value: unknown): value is (...args: unknown[]) => Promise<T> | PromiseLike<T> =>
 	isFunction(value) && /^async\s+/.test(value.toString())
 
-const isComputeFunction = /*#__PURE__*/ <T>(value: unknown): value is ((old?: T) => T) =>
-	isFunction(value) && value.length < 2
-
-const isObjectOfType = <T>(value: unknown, type: string): value is T =>
+const isObjectOfType = /*#__PURE__*/ <T>(value: unknown, type: string): value is T =>
 	Object.prototype.toString.call(value) === `[object ${type}]`
 
 const isInstanceOf = /*#__PURE__*/ <T>(type: new (...args: any[]) => T) =>
@@ -22,15 +19,7 @@ const isPromise = /*#__PURE__*/ isInstanceOf(Promise)
 const toError = (value: unknown): Error =>
 	isError(value) ? value : new Error(String(value))
 
-const isEquivalentError = /*#__PURE__*/ (
-	error1: Error,
-	error2: Error | undefined
-): boolean => {
-    if (!error2) return false
-    return error1.name === error2.name && error1.message === error2.message
-}
-
 export {
-	isFunction, isAsyncFunction, isComputeFunction,
-	isObjectOfType, isInstanceOf, isError, isPromise, toError, isEquivalentError
+	isFunction, isAsyncFunction,
+	isObjectOfType, isInstanceOf, isError, isPromise, toError
 }

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "@zeix/cause-effect",
-  "version": "0.12.0",
+  "version": "0.12.2",
   "author": "Esther Brunner",
   "main": "index.js",
   "module": "index.ts",
   "devDependencies": {
-    "@types/bun": "latest"
+    "@types/bun": "latest",
+    "random": "^5.3.0"
   },
   "peerDependencies": {
     "typescript": "^5.6.3"
@@ -26,8 +27,5 @@
     "test": "bun test"
   },
   "type": "module",
-  "types": "index.d.ts",
-  "dependencies": {
-    "random": "^5.3.0"
-  }
+  "types": "index.d.ts"
 }

package/test/computed.test.ts

@@ -216,36 +216,45 @@ describe('Computed', function () {
 		const c = computed(() => b.get() + a.get());
 		expect(() => {
 			b.get(); // This should trigger the circular dependency
-		}).toThrow('Circular dependency detected');
+		}).toThrow('Circular dependency in computed detected');
 		expect(a.get()).toBe(1);
 	});
 
-	/* test('should propagate error if an error occurred', function() {
-		let count = 0;
+	test('should propagate error if an error occurred', function() {
+		let okCount = 0;
+		let errCount = 0;
 		const x = state(0);
-		const a = computed(() => {
-			if (x.get() === 1) throw new Error('Calculation error');
+		const a = x.map(v => {
+			if (v === 1) throw new Error('Calculation error');
 			return 1;
 		});
-		const b = a.map(v => v ? 'success' : 'pending');
-		const c = computed(() => {
-			count++;
-			return `c: ${b.get()}`;
+		const b = a.map({
+			ok: v => v ? 'success' : 'failure',
+			err: _e => {
+				errCount++;
+                // console.error(e);
+				return `recovered`;
+			}
+		});
+		const c = b.map(v => {
+			okCount++;
+			return `c: ${v}`;
 		});
 		expect(a.get()).toBe(1);
 		expect(c.get()).toBe('c: success');
-		expect(count).toBe(1);
-		x.set(1)
+		expect(okCount).toBe(1);
 		try {
+			x.set(1)
 			expect(a.get()).toBe(1);
 			expect(true).toBe(false); // This line should not be reached
 		} catch (error) {
 			expect(error.message).toBe('Calculation error');
 		} finally {
-			expect(c.get()).toBe('c: success');
-			expect(count).toBe(2);
+			expect(c.get()).toBe('c: recovered');
+			expect(okCount).toBe(2);
+			expect(errCount).toBe(1);
 		}
-	}); */
+	});
 
 	test('should return a computed signal with .map()', function() {
 		const cause = state(42);
@@ -308,7 +317,7 @@ describe('Computed', function () {
 				return 0
 			},
 			err: (_e) => { // error path
-				console.error('Error:', _e);
+				// console.error('Error:', _e);
 				errCount++;
 				return -1
 			},
@@ -318,7 +327,7 @@ describe('Computed', function () {
 			toggleState.set(!!(i % 2));
 			await wait(10);
 			result = complexComputed.get();
-			console.log(`i: ${i}, result: ${result}`);
+			// console.log(`i: ${i}, result: ${result}`);
 		}
 	
 		expect(nilCount).toBeGreaterThanOrEqual(4);

package/test/effect.test.ts

@@ -154,4 +154,28 @@ describe('Effect', function () {
             console.error = originalConsoleError;
         }
     });
+
+	test('should detect and throw error for circular dependencies in effects', () => {
+		let okCount = 0
+		let errCount = 0
+		const count = state(0)
+		
+		effect({
+			ok: () => {
+				okCount++
+				// This effect updates the signal it depends on, creating a circular dependency
+				count.update(v => ++v)
+			},
+			err: e => {
+				errCount++
+				expect(e).toBeInstanceOf(Error)
+				expect(e.message).toBe('Circular dependency in effect detected')
+			}
+		}, count)
+	  
+		// Verify that the count was changed only once due to the circular dependency error
+		expect(count.get()).toBe(1)
+		expect(okCount).toBe(1)
+		expect(errCount).toBe(1)
+	})
 });

package/test/state.test.ts

@@ -1,6 +1,10 @@
 import { describe, test, expect } from 'bun:test'
 import { state, isComputed, UNSET } from '../'
 
+/* === Utility Functions === */
+
+const wait = (ms: number) => new Promise(resolve => setTimeout(resolve, ms))
+
 /* === Tests === */
 
 describe('State', function () {
@@ -166,6 +170,18 @@ describe('State', function () {
 			expect(double.get()).toBe(84);
 		});
 
+		test('should return a computed signal for an async function', async function() {
+			const cause = state(42);
+			const asyncDouble = cause.map(async v => {
+				await wait(100);
+				return v * 2;
+			});
+			expect(isComputed(asyncDouble)).toBe(true);
+			expect(asyncDouble.get()).toBe(UNSET);
+			await wait(110);
+			expect(asyncDouble.get()).toBe(84);
+		});
+
 	});
 
 	describe('Match method', function () {
@@ -174,7 +190,7 @@ describe('State', function () {
 			const cause = state(42);
 			let okCount = 0;
 			let nilCount = 0;
-			let result: number = 0;
+			let result = 0;
 			cause.match({
 				ok: v => {
 					result = v;