@zeix/cause-effect 0.12.2 → 0.12.4

package/README.md

@@ -1,6 +1,6 @@
 # Cause & Effect
 
-Version 0.12.2
+Version 0.12.4
 
 **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.
 
@@ -54,7 +54,7 @@ npm install @zeix/cause-effect
 bun add @zeix/cause-effect
 ```
 
-## Basic Usage
+## Usage
 
 ### Single State Signal
 
@@ -214,3 +214,45 @@ This example showcases several powerful features of Cause & Effect:
 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.
+
+### Effects and DOM Updates
+
+The `enqueue()` function allows you to schedule DOM updates to be executed on the next animation frame. This function returns a `Promise`, which makes it easy to detect when updates are applied or if they fail.
+
+```js
+import { enqueue } from '@zeix/cause-effect'
+
+// Schedule a DOM update
+enqueue(() => {
+  document.getElementById('myElement').textContent = 'Updated content'
+})
+  .then(() => console.log('Update applied successfully'))
+  .catch(error => console.error('Update failed:', error))
+```
+
+You can also use the deduplication feature to ensure that only the latest update for a specific element and operation is applied:
+
+```js
+import { state, effect, enqueue } from '@zeix/cause-effect'
+
+// Define a signal and update it in an event handler
+const name = state('')
+document.querySelector('input[name="name"]').addEventListener('input', e => {
+	state.set(e.target.value) // Triggers an update on every keystroke
+})
+
+// Define an effect to react to signal changes
+effect(text => {
+	const nameSpan = document.querySelector('.greeting .name')
+	enqueue(() => {
+		nameSpan.textContent = text
+		return text
+	}, [nameSpan, 'setName']) // For deduplication
+		.then(result => console.log(`Name was updated to ${result}`))
+		.catch(error => console.error('Failed to update name:', error))
+}, name)
+```
+
+In this example, as the user types in the input field only 'Jane' will be applied to the DOM. 'J', 'Ja', 'Jan' were superseded by more recent updates and deduplicated (if typing was fast enough).
+
+When multiple `enqueue` calls are made with the same deduplication key before the next animation frame, only the last call will be executed. Previous calls are superseded and their Promises will not be resolved or rejected. This "last-write-wins" behavior ensures that only the most recent update is applied, which is typically desirable for UI updates and state changes.

package/index.d.ts

@@ -1,9 +1,9 @@
 /**
  * @name Cause & Effect
- * @version 0.12.2
+ * @version 0.12.4
  * @author Esther Brunner
  */
-export { type Signal, type MaybeSignal, type InferMaybeSignalType, type ComputedCallbacks, type EffectCallbacks, UNSET, isSignal, toSignal } from './lib/signal';
+export { type Signal, type MaybeSignal, type InferSignalType, type ComputedCallbacks, type EffectCallbacks, UNSET, isSignal, isComputedCallbacks, toSignal } from './lib/signal';
 export { type State, state, isState } from './lib/state';
 export { type Computed, computed, isComputed } from './lib/computed';
 export { effect } from './lib/effect';

package/index.js

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

package/index.ts

@@ -1,12 +1,12 @@
 /**
  * @name Cause & Effect
- * @version 0.12.2
+ * @version 0.12.4
  * @author Esther Brunner
  */
 export {
-	type Signal, type MaybeSignal, type InferMaybeSignalType,
+	type Signal, type MaybeSignal, type InferSignalType,
 	type ComputedCallbacks, type EffectCallbacks,
-	UNSET, isSignal, toSignal
+	UNSET, isSignal, isComputedCallbacks, toSignal
 } from './lib/signal'
 
 export { type State, state, isState } from './lib/state'

package/lib/computed.d.ts

@@ -1,4 +1,4 @@
-import { type MaybeSignal, type EffectCallbacks, type ComputedCallbacks } from './signal';
+import { type Signal, type EffectCallbacks, type ComputedCallbacks } from './signal';
 export type Computed<T extends {}> = {
     [Symbol.toStringTag]: 'Computed';
     get: () => T;
@@ -13,7 +13,7 @@ export type Computed<T extends {}> = {
  * @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 MaybeSignal<{}>[]>(cb: ComputedCallbacks<T, U>, ...maybeSignals: U) => Computed<T>;
+export declare const computed: <T extends {}, U extends Signal<{}>[]>(cb: ComputedCallbacks<T, U>, ...maybeSignals: U) => Computed<T>;
 /**
  * Check if a value is a computed state
  *

package/lib/computed.ts

@@ -1,5 +1,5 @@
 import {
-	type MaybeSignal, type EffectCallbacks, type ComputedCallbacks,
+	type Signal, type EffectCallbacks, type ComputedCallbacks,
 	resolve, UNSET
 } from './signal'
 import { isError, isObjectOfType, isPromise, toError } from './util'
@@ -39,7 +39,7 @@ const isEquivalentError = /*#__PURE__*/ (
  * @param {U} maybeSignals - signals of functions using signals this values depends on
  * @returns {Computed<T>} - Computed signal
  */
-export const computed = <T extends {}, U extends MaybeSignal<{}>[]>(
+export const computed = <T extends {}, U extends Signal<{}>[]>(
 	cb: ComputedCallbacks<T, U>,
 	...maybeSignals: U
 ): Computed<T> => {

package/lib/effect.d.ts

@@ -1,4 +1,4 @@
-import { type EffectCallbacks, type MaybeSignal } from './signal';
+import { type EffectCallbacks, type Signal } from './signal';
 /**
  * Define what happens when a reactive state changes
  *
@@ -6,4 +6,4 @@ import { type EffectCallbacks, type MaybeSignal } from './signal';
  * @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<U extends MaybeSignal<{}>[]>(cb: EffectCallbacks<U>, ...maybeSignals: U): void;
+export declare function effect<U extends Signal<{}>[]>(cb: EffectCallbacks<U>, ...maybeSignals: U): void;

package/lib/effect.ts

@@ -1,5 +1,5 @@
 
-import { type EffectCallbacks, type MaybeSignal, resolve } from './signal'
+import { type EffectCallbacks, type Signal, resolve } from './signal'
 import { isError } from './util'
 import { watch } from './scheduler'
 
@@ -12,7 +12,7 @@ import { watch } from './scheduler'
  * @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<U extends MaybeSignal<{}>[]>(
+export function effect<U extends Signal<{}>[]>(
 	cb: EffectCallbacks<U>,
 	...maybeSignals: U
 ): void {

package/lib/scheduler.d.ts

@@ -1,6 +1,6 @@
 export type EnqueueDedupe = [Element, string];
 export type Watcher = () => void;
-export type Updater = <T>() => T;
+export type Updater = <T>() => T | boolean | void;
 /**
  * Add active watcher to the array of watchers
  *
@@ -27,14 +27,13 @@ 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
+ * @param {Watcher} mark - function to be called when the state changes or undefined for temporary unwatching while inserting auto-hydrating DOM nodes that might read signals (e.g., web components)
  */
-export declare const watch: (run: () => void, mark: Watcher) => void;
+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
+ * @param {Updater} fn - function to be executed on the next animation frame; can return updated value <T>, success <boolean> or void
+ * @param {EnqueueDedupe} dedupe - [element, operation] pair for deduplication
  */
-export declare const enqueue: <T>(update: Updater, dedupe?: EnqueueDedupe) => Promise<T>;
+export declare const enqueue: <T>(fn: Updater, dedupe?: EnqueueDedupe) => Promise<boolean | void | T>;

package/lib/scheduler.ts

@@ -3,7 +3,7 @@
 export type EnqueueDedupe = [Element, string]
 
 export type Watcher = () => void
-export type Updater = <T>() => T
+export type Updater = <T>() => T | boolean | void
 
 /* === Internal === */
 
@@ -15,16 +15,15 @@ const pending = new Set<Watcher>()
 let batchDepth = 0
 
 // Map of DOM elements to update functions
-const updateMap = new Map<Element, Map<string, () => void>>()
+const updateMap = new Map<EnqueueDedupe, () => void>()
 let requestId: number | undefined
 
 const updateDOM = () => {
 	requestId = undefined
-	for (const elementMap of updateMap.values()) {
-		for (const fn of elementMap.values()) {
-			fn()
-		}
-		elementMap.clear()
+	const updates = Array.from(updateMap.values())
+	updateMap.clear()
+	for (const fn of updates) {
+		fn()
 	}
 }
 
@@ -57,7 +56,8 @@ export const subscribe = (watchers: Watcher[]) => {
  */
 export const notify = (watchers: Watcher[]) => {
 	for (const mark of watchers) {
-        batchDepth ? pending.add(mark) : mark()
+        if (batchDepth) pending.add(mark)
+		else mark()
     }
 }
 
@@ -81,47 +81,49 @@ export const flush = () => {
  */
 export const batch = (fn: () => void) => {
 	batchDepth++
-    fn()
-	flush()
-	batchDepth--
+	try {
+		fn()
+	} finally {
+		flush()
+        batchDepth--
+    }
 }
 
 /**
  * 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
+ * @param {Watcher} mark - function to be called when the state changes or undefined for temporary unwatching while inserting auto-hydrating DOM nodes that might read signals (e.g., web components)
  */
-export const watch = (run: () => void, mark: Watcher): void => {
+export const watch = (run: () => void, mark?: Watcher): void => {
 	const prev = active
 	active = mark
-	run()
-	active = prev
+	try {
+		run()
+	} finally {
+		active = prev
+	}
 }
 
 /**
  * Enqueue a function to be executed on the next animation frame
  * 
- * @param callback 
- * @param dedupe 
- * @returns 
+ * @param {Updater} fn - function to be executed on the next animation frame; can return updated value <T>, success <boolean> or void
+ * @param {EnqueueDedupe} dedupe - [element, operation] pair for deduplication
  */
 export const enqueue = <T>(
-    update: Updater,
+    fn: Updater,
     dedupe?: EnqueueDedupe
-) => new Promise<T>((resolve, reject) => {
+) => new Promise<T | boolean | void>((resolve, reject) => {
     const wrappedCallback = () => {
         try {
-            resolve(update())
+            resolve(fn())
         } catch (error) {
             reject(error)
         }
     }
     if (dedupe) {
-        const [el, op] = dedupe
-        if (!updateMap.has(el)) updateMap.set(el, new Map())
-        const elementMap = updateMap.get(el)!
-        elementMap.set(op, wrappedCallback)
+        updateMap.set(dedupe, wrappedCallback)
     }
     requestTick()
 })

package/lib/signal.d.ts

@@ -2,18 +2,18 @@ import { type State } from "./state";
 import { type Computed } from "./computed";
 type Signal<T extends {}> = State<T> | Computed<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 OkCallback<T, U extends MaybeSignal<{}>[]> = (...values: {
-    [K in keyof U]: InferMaybeSignalType<U[K]>;
+type InferSignalType<T> = T extends Signal<infer U> ? U : never;
+type OkCallback<T, U extends Signal<{}>[]> = (...values: {
+    [K in keyof U]: InferSignalType<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> | {
+type ComputedCallbacks<T extends {}, U extends Signal<{}>[]> = OkCallback<T, U> | {
     ok: OkCallback<T, U>;
     nil?: NilCallback<T>;
     err?: ErrCallback<T>;
 };
-type EffectCallbacks<U extends MaybeSignal<{}>[]> = OkCallback<void, U> | {
+type EffectCallbacks<U extends Signal<{}>[]> = OkCallback<void, U> | {
     ok: OkCallback<void, U>;
     nil?: NilCallback<void>;
     err?: ErrCallback<void>;
@@ -24,10 +24,18 @@ declare const UNSET: any;
  * Check whether a value is a Signal or not
  *
  * @since 0.9.0
- * @param {any} value - value to check
+ * @param {unknown} value - value to check
  * @returns {boolean} - true if value is a Signal, false otherwise
  */
 declare const isSignal: <T extends {}>(value: any) => value is Signal<T>;
+/**
+ * Check if the provided value is a callback or callbacks object of { ok, nil?, err? } that may be used as input for toSignal() to derive a computed state
+ *
+ * @since 0.12.4
+ * @param {unknown} value - value to check
+ * @returns {boolean} - true if value is a callback or callbacks object, false otherwise
+ */
+declare const isComputedCallbacks: <T extends {}>(value: unknown) => value is ComputedCallbacks<T, []>;
 /**
  * Convert a value to a Signal if it's not already a Signal
  *
@@ -45,9 +53,9 @@ declare const toSignal: <T extends {}>(value: MaybeSignal<T> | ComputedCallbacks
  * @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 resolve: <T, U extends MaybeSignal<{}>[]>(maybeSignals: U, cb: OkCallback<T | Promise<T>, U> | {
+declare const resolve: <T, U extends Signal<{}>[]>(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, };
+export { type Signal, type MaybeSignal, type InferSignalType, type EffectCallbacks, type ComputedCallbacks, type CallbackReturnType, UNSET, isSignal, isComputedCallbacks, toSignal, resolve, };

package/lib/signal.ts

@@ -6,23 +6,21 @@ import { isFunction, toError } from "./util"
 
 type Signal<T extends {}> = State<T> | Computed<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 InferSignalType<T> = T extends Signal<infer U> ? U : never
 
-type OkCallback<T, U extends MaybeSignal<{}>[]> = (...values: {
-	[K in keyof U]: InferMaybeSignalType<U[K]>
+type OkCallback<T, U extends Signal<{}>[]> = (...values: {
+	[K in keyof U]: InferSignalType<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> | {
+type ComputedCallbacks<T extends {}, U extends Signal<{}>[]> = OkCallback<T, U> | {
 	ok: OkCallback<T, U>,
     nil?: NilCallback<T>,
     err?: ErrCallback<T>
 }
 
-type EffectCallbacks<U extends MaybeSignal<{}>[]> = OkCallback<void, U> | {
+type EffectCallbacks<U extends Signal<{}>[]> = OkCallback<void, U> | {
 	ok: OkCallback<void, U>,
 	nil?: NilCallback<void>,
 	err?: ErrCallback<void>
@@ -34,24 +32,29 @@ type CallbackReturnType<T> = T | Promise<T> | Error | void
 
 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 === */
 
 /**
  * Check whether a value is a Signal or not
  * 
  * @since 0.9.0
- * @param {any} value - value to check
+ * @param {unknown} value - value to check
  * @returns {boolean} - true if value is a Signal, false otherwise
  */
 const isSignal = /*#__PURE__*/ <T extends {}>(value: any): value is Signal<T> =>
 	isState(value) || isComputed(value)
 
+/**
+ * Check if the provided value is a callback or callbacks object of { ok, nil?, err? } that may be used as input for toSignal() to derive a computed state
+ * 
+ * @since 0.12.4
+ * @param {unknown} value - value to check
+ * @returns {boolean} - true if value is a callback or callbacks object, false otherwise
+ */
+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))
+
 /**
  * Convert a value to a Signal if it's not already a Signal
  * 
@@ -76,7 +79,7 @@ const toSignal = /*#__PURE__*/ <T extends {}>(
  * @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 resolve = <T, U extends MaybeSignal<{}>[]>(
+const resolve = <T, U extends Signal<{}>[]>(
 	maybeSignals: U,
 	cb: OkCallback<T | Promise<T>, U> | {
 		ok: OkCallback<T | Promise<T>, U>
@@ -92,7 +95,7 @@ const resolve = <T, U extends MaybeSignal<{}>[]>(
 			err?: ErrCallback<T>
 		}
 	const values = [] as {
-		[K in keyof U]: InferMaybeSignalType<U[K]>
+		[K in keyof U]: InferSignalType<U[K]>
 	}
     const errors: Error[] = []
     let hasUnset = false
@@ -100,9 +103,9 @@ const resolve = <T, U extends MaybeSignal<{}>[]>(
     for (let i = 0; i < maybeSignals.length; i++) {
 		const s = maybeSignals[i]
 		try {
-			const value = isSignal(s) ? s.get() : isFunction(s) ? s() : s
+			const value = s.get()
 			if (value === UNSET) hasUnset = true
-			values[i] = value as InferMaybeSignalType<typeof s>
+			values[i] = value as InferSignalType<typeof s>
 		} catch (e) {
 			errors.push(toError(e))
 		}
@@ -121,7 +124,7 @@ const resolve = <T, U extends MaybeSignal<{}>[]>(
 }
 
 export {
-	type Signal, type MaybeSignal, type InferMaybeSignalType,
+	type Signal, type MaybeSignal, type InferSignalType,
 	type EffectCallbacks, type ComputedCallbacks, type CallbackReturnType,
-    UNSET, isSignal, toSignal, resolve,
+    UNSET, isSignal, isComputedCallbacks, toSignal, resolve,
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zeix/cause-effect",
-  "version": "0.12.2",
+  "version": "0.12.4",
   "author": "Esther Brunner",
   "main": "index.js",
   "module": "index.ts",