@zeix/cause-effect 0.14.1 → 0.14.2

package/README.md

@@ -1,6 +1,6 @@
 # Cause & Effect
 
-Version 0.14.1
+Version 0.14.2
 
 **Cause & Effect** is a lightweight, reactive state management library for JavaScript applications. It uses fine-grained reactivity with signals to create predictable and efficient data flow in your app.
 

package/biome.json

@@ -0,0 +1,35 @@
+{
+	"$schema": "https://biomejs.dev/schemas/2.1.4/schema.json",
+	"vcs": {
+		"enabled": false,
+		"clientKind": "git",
+		"useIgnoreFile": false
+	},
+	"files": {
+		"ignoreUnknown": false,
+		"includes": ["**", "!index.js", "!index.dev.js", "!**/*.d.ts"]
+	},
+	"formatter": {
+		"enabled": true,
+		"indentStyle": "tab"
+	},
+	"linter": {
+		"enabled": true,
+		"rules": {
+			"recommended": true
+		}
+	},
+	"javascript": {
+		"formatter": {
+			"quoteStyle": "double"
+		}
+	},
+	"assist": {
+		"enabled": true,
+		"actions": {
+			"source": {
+				"organizeImports": "on"
+			}
+		}
+	}
+}

package/index.d.ts

@@ -1,11 +1,11 @@
 /**
  * @name Cause & Effect
- * @version 0.14.1
+ * @version 0.14.2
  * @author Esther Brunner
  */
-export { isFunction, CircularDependencyError } from './src/util';
-export { type Signal, type MaybeSignal, type SignalValues, UNSET, isSignal, isComputedCallback, toSignal, } from './src/signal';
-export { type State, TYPE_STATE, state, isState } from './src/state';
-export { type Computed, type ComputedCallback, TYPE_COMPUTED, computed, isComputed, } from './src/computed';
+export { type Computed, type ComputedCallback, computed, isComputed, TYPE_COMPUTED, } from './src/computed';
 export { type EffectMatcher, effect } from './src/effect';
-export { type Watcher, type Cleanup, type Updater, watch, subscribe, notify, flush, batch, observe, enqueue, } from './src/scheduler';
+export { batch, type Cleanup, enqueue, flush, notify, observe, subscribe, type Updater, type Watcher, watch, } from './src/scheduler';
+export { isComputedCallback, isSignal, type MaybeSignal, type Signal, type SignalValues, toSignal, UNSET, } from './src/signal';
+export { isState, type State, state, TYPE_STATE } from './src/state';
+export { CircularDependencyError, isFunction } from './src/util';

package/index.dev.js

@@ -0,0 +1,294 @@
+// src/scheduler.ts
+var active;
+var pending = new Set;
+var batchDepth = 0;
+var updateMap = new Map;
+var requestId;
+var updateDOM = () => {
+  requestId = undefined;
+  const updates = Array.from(updateMap.values());
+  updateMap.clear();
+  for (const update of updates) {
+    update();
+  }
+};
+var requestTick = () => {
+  if (requestId)
+    cancelAnimationFrame(requestId);
+  requestId = requestAnimationFrame(updateDOM);
+};
+queueMicrotask(updateDOM);
+var watch = (notice) => {
+  const cleanups = new Set;
+  const w = notice;
+  w.off = (on) => {
+    cleanups.add(on);
+  };
+  w.cleanup = () => {
+    for (const cleanup of cleanups) {
+      cleanup();
+    }
+    cleanups.clear();
+  };
+  return w;
+};
+var subscribe = (watchers) => {
+  if (active && !watchers.has(active)) {
+    const watcher = active;
+    watchers.add(watcher);
+    active.off(() => {
+      watchers.delete(watcher);
+    });
+  }
+};
+var notify = (watchers) => {
+  for (const watcher of watchers) {
+    if (batchDepth)
+      pending.add(watcher);
+    else
+      watcher();
+  }
+};
+var flush = () => {
+  while (pending.size) {
+    const watchers = Array.from(pending);
+    pending.clear();
+    for (const watcher of watchers) {
+      watcher();
+    }
+  }
+};
+var batch = (fn) => {
+  batchDepth++;
+  try {
+    fn();
+  } finally {
+    flush();
+    batchDepth--;
+  }
+};
+var observe = (run, watcher) => {
+  const prev = active;
+  active = watcher;
+  try {
+    run();
+  } finally {
+    active = prev;
+  }
+};
+var enqueue = (fn, dedupe) => new Promise((resolve, reject) => {
+  updateMap.set(dedupe || Symbol(), () => {
+    try {
+      resolve(fn());
+    } catch (error) {
+      reject(error);
+    }
+  });
+  requestTick();
+});
+
+// src/util.ts
+var isFunction = (value) => typeof value === "function";
+var isObjectOfType = (value, type) => Object.prototype.toString.call(value) === `[object ${type}]`;
+var toError = (reason) => reason instanceof Error ? reason : Error(String(reason));
+
+class CircularDependencyError extends Error {
+  constructor(where) {
+    super(`Circular dependency in ${where} detected`);
+    this.name = "CircularDependencyError";
+  }
+}
+
+// src/state.ts
+var TYPE_STATE = "State";
+var state = (initialValue) => {
+  const watchers = new Set;
+  let value = initialValue;
+  const s = {
+    [Symbol.toStringTag]: TYPE_STATE,
+    get: () => {
+      subscribe(watchers);
+      return value;
+    },
+    set: (v) => {
+      if (Object.is(value, v))
+        return;
+      value = v;
+      notify(watchers);
+      if (UNSET === value)
+        watchers.clear();
+    },
+    update: (fn) => {
+      s.set(fn(value));
+    }
+  };
+  return s;
+};
+var isState = (value) => isObjectOfType(value, TYPE_STATE);
+
+// src/signal.ts
+var UNSET = Symbol();
+var isSignal = (value) => isState(value) || isComputed(value);
+var toSignal = (value) => isSignal(value) ? value : isComputedCallback(value) ? computed(value) : state(value);
+
+// src/computed.ts
+var TYPE_COMPUTED = "Computed";
+var computed = (fn) => {
+  const watchers = new Set;
+  let value = UNSET;
+  let error;
+  let controller;
+  let dirty = true;
+  let changed = false;
+  let computing = false;
+  const ok = (v) => {
+    if (!Object.is(v, value)) {
+      value = v;
+      changed = true;
+    }
+    error = undefined;
+    dirty = false;
+  };
+  const nil = () => {
+    changed = UNSET !== value;
+    value = UNSET;
+    error = undefined;
+  };
+  const err = (e) => {
+    const newError = toError(e);
+    changed = !error || newError.name !== error.name || newError.message !== error.message;
+    value = UNSET;
+    error = newError;
+  };
+  const settle = (settleFn) => (arg) => {
+    computing = false;
+    controller = undefined;
+    settleFn(arg);
+    if (changed)
+      notify(watchers);
+  };
+  const mark = watch(() => {
+    dirty = true;
+    controller?.abort("Aborted because source signal changed");
+    if (watchers.size)
+      notify(watchers);
+    else
+      mark.cleanup();
+  });
+  const compute = () => observe(() => {
+    if (computing)
+      throw new CircularDependencyError("computed");
+    changed = false;
+    if (isFunction(fn) && fn.constructor.name === "AsyncFunction") {
+      if (controller)
+        return value;
+      controller = new AbortController;
+      controller.signal.addEventListener("abort", () => {
+        computing = false;
+        controller = undefined;
+        compute();
+      }, {
+        once: true
+      });
+    }
+    let result;
+    computing = true;
+    try {
+      result = controller ? fn(controller.signal) : fn();
+    } catch (e) {
+      if (e instanceof DOMException && e.name === "AbortError")
+        nil();
+      else
+        err(e);
+      computing = false;
+      return;
+    }
+    if (result instanceof Promise)
+      result.then(settle(ok), settle(err));
+    else if (result == null || UNSET === result)
+      nil();
+    else
+      ok(result);
+    computing = false;
+  }, mark);
+  const c = {
+    [Symbol.toStringTag]: TYPE_COMPUTED,
+    get: () => {
+      subscribe(watchers);
+      flush();
+      if (dirty)
+        compute();
+      if (error)
+        throw error;
+      return value;
+    }
+  };
+  return c;
+};
+var isComputed = (value) => isObjectOfType(value, TYPE_COMPUTED);
+var isComputedCallback = (value) => isFunction(value) && value.length < 2;
+// src/effect.ts
+function effect(matcher) {
+  const {
+    signals,
+    ok,
+    err = (error) => {
+      console.error(error);
+    },
+    nil = () => {
+    }
+  } = isFunction(matcher) ? { signals: [], ok: matcher } : matcher;
+  let running = false;
+  const run = watch(() => observe(() => {
+    if (running)
+      throw new CircularDependencyError("effect");
+    running = true;
+    const errors = [];
+    let pending2 = false;
+    const values = signals.map((signal) => {
+      try {
+        const value = signal.get();
+        if (value === UNSET)
+          pending2 = true;
+        return value;
+      } catch (e) {
+        errors.push(toError(e));
+        return UNSET;
+      }
+    });
+    let cleanup;
+    try {
+      cleanup = pending2 ? nil() : errors.length ? err(...errors) : ok(...values);
+    } catch (e) {
+      cleanup = err(toError(e));
+    } finally {
+      if (isFunction(cleanup))
+        run.off(cleanup);
+    }
+    running = false;
+  }, run));
+  run();
+  return () => run.cleanup();
+}
+export {
+  watch,
+  toSignal,
+  subscribe,
+  state,
+  observe,
+  notify,
+  isState,
+  isSignal,
+  isFunction,
+  isComputedCallback,
+  isComputed,
+  flush,
+  enqueue,
+  effect,
+  computed,
+  batch,
+  UNSET,
+  TYPE_STATE,
+  TYPE_COMPUTED,
+  CircularDependencyError
+};

package/index.js

@@ -1 +1 @@
-var j=($)=>typeof $==="function",M=($,B)=>Object.prototype.toString.call($)===`[object ${B}]`,Y=($)=>$ instanceof Error?$:Error(String($));class F extends Error{constructor($){super(`Circular dependency in ${$} detected`);return this}}var y,N=new Set,U=0,k=new Map,D,f=()=>{D=void 0;let $=Array.from(k.values());k.clear();for(let B of $)B()},d=()=>{if(D)cancelAnimationFrame(D);D=requestAnimationFrame(f)};queueMicrotask(f);var I=($)=>{let B=new Set,W=$;return W.off=(z)=>{B.add(z)},W.cleanup=()=>{for(let z of B)z();B.clear()},W},O=($)=>{if(y&&!$.has(y)){let B=y;$.add(B),y.off(()=>{$.delete(B)})}},R=($)=>{for(let B of $)if(U)N.add(B);else B()},P=()=>{while(N.size){let $=Array.from(N);N.clear();for(let B of $)B()}},h=($)=>{U++;try{$()}finally{P(),U--}},q=($,B)=>{let W=y;y=B;try{$()}finally{y=W}},v=($,B)=>new Promise((W,z)=>{k.set(B||Symbol(),()=>{try{W($())}catch(G){z(G)}}),d()});var _="State",S=($)=>{let B=new Set,W=$,z={[Symbol.toStringTag]:_,get:()=>{return O(B),W},set:(G)=>{if(Object.is(W,G))return;if(W=G,R(B),J===W)B.clear()},update:(G)=>{z.set(G(W))}};return z},T=($)=>M($,_);var b="Computed",E=($)=>{let B=new Set,W=J,z,G,X=!0,K=!1,L=!1,x=(H)=>{if(!Object.is(H,W))W=H,K=!0;z=void 0,X=!1},C=()=>{K=J!==W,W=J,z=void 0},Z=(H)=>{let Q=Y(H);K=!z||Q.name!==z.name||Q.message!==z.message,W=J,z=Q},A=(H)=>(Q)=>{if(L=!1,G=void 0,H(Q),K)R(B)},V=I(()=>{if(X=!0,G?.abort("Aborted because source signal changed"),B.size)R(B);else V.cleanup()}),w=()=>q(()=>{if(L)throw new F("computed");if(K=!1,j($)&&$.constructor.name==="AsyncFunction"){if(G)return W;G=new AbortController,G.signal.addEventListener("abort",()=>{L=!1,G=void 0,w()},{once:!0})}let H;L=!0;try{H=G?$(G.signal):$()}catch(Q){if(Q instanceof DOMException&&Q.name==="AbortError")C();else Z(Q);L=!1;return}if(H instanceof Promise)H.then(A(x),A(Z));else if(H==null||J===H)C();else x(H);L=!1},V);return{[Symbol.toStringTag]:b,get:()=>{if(O(B),P(),X)w();if(z)throw z;return W}}},g=($)=>M($,b),m=($)=>j($)&&$.length<2;var J=Symbol(),p=($)=>T($)||g($),o=($)=>p($)?$:m($)?E($):S($);function s($){let{signals:B,ok:W,err:z=console.error,nil:G=()=>{}}=j($)?{signals:[],ok:$}:$,X=!1,K=I(()=>q(()=>{if(X)throw new F("effect");X=!0;let L=[],x=!1,C=B.map((A)=>{try{let V=A.get();if(V===J)x=!0;return V}catch(V){return L.push(Y(V)),J}}),Z=void 0;try{Z=x?G():L.length?z(...L):W(...C)}catch(A){Z=z(Y(A))}finally{if(j(Z))K.off(Z)}X=!1},K));return K(),()=>K.cleanup()}export{I as watch,o as toSignal,O as subscribe,S as state,q as observe,R as notify,T as isState,p as isSignal,j as isFunction,m as isComputedCallback,g as isComputed,P as flush,v as enqueue,s as effect,E as computed,h as batch,J as UNSET,_ as TYPE_STATE,b as TYPE_COMPUTED,F as CircularDependencyError};
+var V,M=new Set,U=0,k=new Map,D,f=()=>{D=void 0;let $=Array.from(k.values());k.clear();for(let B of $)B()},d=()=>{if(D)cancelAnimationFrame(D);D=requestAnimationFrame(f)};queueMicrotask(f);var Y=($)=>{let B=new Set,W=$;return W.off=(z)=>{B.add(z)},W.cleanup=()=>{for(let z of B)z();B.clear()},W},I=($)=>{if(V&&!$.has(V)){let B=V;$.add(B),V.off(()=>{$.delete(B)})}},F=($)=>{for(let B of $)if(U)M.add(B);else B()},N=()=>{while(M.size){let $=Array.from(M);M.clear();for(let B of $)B()}},h=($)=>{U++;try{$()}finally{N(),U--}},O=($,B)=>{let W=V;V=B;try{$()}finally{V=W}},v=($,B)=>new Promise((W,z)=>{k.set(B||Symbol(),()=>{try{W($())}catch(G){z(G)}}),d()});var j=($)=>typeof $==="function",P=($,B)=>Object.prototype.toString.call($)===`[object ${B}]`,C=($)=>$ instanceof Error?$:Error(String($));class R extends Error{constructor($){super(`Circular dependency in ${$} detected`);this.name="CircularDependencyError"}}var _="State",S=($)=>{let B=new Set,W=$,z={[Symbol.toStringTag]:_,get:()=>{return I(B),W},set:(G)=>{if(Object.is(W,G))return;if(W=G,F(B),K===W)B.clear()},update:(G)=>{z.set(G(W))}};return z},T=($)=>P($,_);var K=Symbol(),p=($)=>T($)||b($),o=($)=>p($)?$:g($)?E($):S($);var m="Computed",E=($)=>{let B=new Set,W=K,z,G,X=!0,L=!1,J=!1,x=(H)=>{if(!Object.is(H,W))W=H,L=!0;z=void 0,X=!1},q=()=>{L=K!==W,W=K,z=void 0},Z=(H)=>{let Q=C(H);L=!z||Q.name!==z.name||Q.message!==z.message,W=K,z=Q},A=(H)=>(Q)=>{if(J=!1,G=void 0,H(Q),L)F(B)},y=Y(()=>{if(X=!0,G?.abort("Aborted because source signal changed"),B.size)F(B);else y.cleanup()}),w=()=>O(()=>{if(J)throw new R("computed");if(L=!1,j($)&&$.constructor.name==="AsyncFunction"){if(G)return W;G=new AbortController,G.signal.addEventListener("abort",()=>{J=!1,G=void 0,w()},{once:!0})}let H;J=!0;try{H=G?$(G.signal):$()}catch(Q){if(Q instanceof DOMException&&Q.name==="AbortError")q();else Z(Q);J=!1;return}if(H instanceof Promise)H.then(A(x),A(Z));else if(H==null||K===H)q();else x(H);J=!1},y);return{[Symbol.toStringTag]:m,get:()=>{if(I(B),N(),X)w();if(z)throw z;return W}}},b=($)=>P($,m),g=($)=>j($)&&$.length<2;function s($){let{signals:B,ok:W,err:z=(J)=>{console.error(J)},nil:G=()=>{}}=j($)?{signals:[],ok:$}:$,X=!1,L=Y(()=>O(()=>{if(X)throw new R("effect");X=!0;let J=[],x=!1,q=B.map((A)=>{try{let y=A.get();if(y===K)x=!0;return y}catch(y){return J.push(C(y)),K}}),Z;try{Z=x?G():J.length?z(...J):W(...q)}catch(A){Z=z(C(A))}finally{if(j(Z))L.off(Z)}X=!1},L));return L(),()=>L.cleanup()}export{Y as watch,o as toSignal,I as subscribe,S as state,O as observe,F as notify,T as isState,p as isSignal,j as isFunction,g as isComputedCallback,b as isComputed,N as flush,v as enqueue,s as effect,E as computed,h as batch,K as UNSET,_ as TYPE_STATE,m as TYPE_COMPUTED,R as CircularDependencyError};

package/index.ts

@@ -1,36 +1,37 @@
 /**
  * @name Cause & Effect
- * @version 0.14.1
+ * @version 0.14.2
  * @author Esther Brunner
  */
-export { isFunction, CircularDependencyError } from './src/util'
-export {
-	type Signal,
-	type MaybeSignal,
-	type SignalValues,
-	UNSET,
-	isSignal,
-	isComputedCallback,
-	toSignal,
-} from './src/signal'
-export { type State, TYPE_STATE, state, isState } from './src/state'
+
 export {
 	type Computed,
 	type ComputedCallback,
-	TYPE_COMPUTED,
 	computed,
 	isComputed,
+	TYPE_COMPUTED,
 } from './src/computed'
 export { type EffectMatcher, effect } from './src/effect'
 export {
-	type Watcher,
+	batch,
 	type Cleanup,
-	type Updater,
-	watch,
-	subscribe,
-	notify,
+	enqueue,
 	flush,
-	batch,
+	notify,
 	observe,
-	enqueue,
+	subscribe,
+	type Updater,
+	type Watcher,
+	watch,
 } from './src/scheduler'
+export {
+	isComputedCallback,
+	isSignal,
+	type MaybeSignal,
+	type Signal,
+	type SignalValues,
+	toSignal,
+	UNSET,
+} from './src/signal'
+export { isState, type State, state, TYPE_STATE } from './src/state'
+export { CircularDependencyError, isFunction } from './src/util'

package/package.json

@@ -1,14 +1,13 @@
 {
 	"name": "@zeix/cause-effect",
-	"version": "0.14.1",
+	"version": "0.14.2",
 	"author": "Esther Brunner",
 	"main": "index.js",
 	"module": "index.ts",
 	"devDependencies": {
+		"@biomejs/biome": "2.1.4",
 		"@types/bun": "latest",
-		"eslint": "^9.27.0",
-		"random": "^5.4.0",
-		"typescript-eslint": "^8.32.1"
+		"random": "^5.4.1"
 	},
 	"peerDependencies": {
 		"typescript": "^5.6.3"
@@ -25,9 +24,9 @@
 		"access": "public"
 	},
 	"scripts": {
-		"build": "bun build index.ts --outdir ./ --minify && bunx tsc",
+		"build": "bunx tsc && bun build index.ts --outdir ./ --minify && bun build index.ts --outfile index.dev.js",
 		"test": "bun test",
-		"lint": "bunx eslint src/"
+		"lint": "bunx biome lint --write"
 	},
 	"type": "module",
 	"types": "index.d.ts"

package/src/computed.d.ts

@@ -3,7 +3,7 @@ type Computed<T extends {}> = {
     get(): T;
 };
 type ComputedCallback<T extends {} & {
-    then?: void;
+    then?: undefined;
 }> = ((abort: AbortSignal) => Promise<T>) | (() => T);
 declare const TYPE_COMPUTED = "Computed";
 /**
@@ -30,4 +30,4 @@ declare const isComputed: <T extends {}>(value: unknown) => value is Computed<T>
  * @returns {boolean} - true if value is a callback or callbacks object, false otherwise
  */
 declare const isComputedCallback: <T extends {}>(value: unknown) => value is ComputedCallback<T>;
-export { type Computed, type ComputedCallback, TYPE_COMPUTED, computed, isComputed, isComputedCallback, };
+export { TYPE_COMPUTED, computed, isComputed, isComputedCallback, type Computed, type ComputedCallback, };

package/src/computed.ts

@@ -1,18 +1,18 @@
+import {
+	flush,
+	notify,
+	observe,
+	subscribe,
+	type Watcher,
+	watch,
+} from './scheduler'
+import { UNSET } from './signal'
 import {
 	CircularDependencyError,
 	isFunction,
 	isObjectOfType,
 	toError,
 } from './util'
-import {
-	type Watcher,
-	watch,
-	subscribe,
-	notify,
-	flush,
-	observe,
-} from './scheduler'
-import { UNSET } from './signal'
 
 /* === Types === */
 
@@ -20,7 +20,7 @@ type Computed<T extends {}> = {
 	[Symbol.toStringTag]: 'Computed'
 	get(): T
 }
-type ComputedCallback<T extends {} & { then?: void }> =
+type ComputedCallback<T extends {} & { then?: undefined }> =
 	| ((abort: AbortSignal) => Promise<T>)
 	| (() => T)
 
@@ -49,7 +49,7 @@ const computed = <T extends {}>(fn: ComputedCallback<T>): Computed<T> => {
 	let computing = false
 
 	// Functions to update internal state
-	const ok = (v: T) => {
+	const ok = (v: T): undefined => {
 		if (!Object.is(v, value)) {
 			value = v
 			changed = true
@@ -57,12 +57,12 @@ const computed = <T extends {}>(fn: ComputedCallback<T>): Computed<T> => {
 		error = undefined
 		dirty = false
 	}
-	const nil = () => {
+	const nil = (): undefined => {
 		changed = UNSET !== value
 		value = UNSET
 		error = undefined
 	}
-	const err = (e: unknown) => {
+	const err = (e: unknown): undefined => {
 		const newError = toError(e)
 		changed =
 			!error ||
@@ -169,10 +169,10 @@ const isComputedCallback = /*#__PURE__*/ <T extends {}>(
 /* === Exports === */
 
 export {
-	type Computed,
-	type ComputedCallback,
 	TYPE_COMPUTED,
 	computed,
 	isComputed,
 	isComputedCallback,
+	type Computed,
+	type ComputedCallback,
 }

package/src/effect.d.ts

@@ -1,17 +1,17 @@
-import { type Signal, type SignalValues } from './signal';
 import { type Cleanup } from './scheduler';
-type EffectMatcher<S extends Signal<{}>[]> = {
+import { type Signal, type SignalValues } from './signal';
+type EffectMatcher<S extends Signal<unknown & {}>[]> = {
     signals: S;
-    ok: (...values: SignalValues<S>) => void | Cleanup;
-    err?: (...errors: Error[]) => void | Cleanup;
-    nil?: () => void | Cleanup;
+    ok: (...values: SignalValues<S>) => Cleanup | undefined;
+    err?: (...errors: Error[]) => Cleanup | undefined;
+    nil?: () => Cleanup | undefined;
 };
 /**
  * Define what happens when a reactive state changes
  *
  * @since 0.1.0
- * @param {EffectMatcher<S> | (() => void | Cleanup)} matcher - effect matcher or callback
+ * @param {EffectMatcher<S> | (() => Cleanup | undefined)} matcher - effect matcher or callback
  * @returns {Cleanup} - cleanup function for the effect
  */
-declare function effect<S extends Signal<{}>[]>(matcher: EffectMatcher<S> | (() => void | Cleanup)): Cleanup;
+declare function effect<S extends Signal<unknown & {}>[]>(matcher: EffectMatcher<S> | (() => Cleanup | undefined)): Cleanup;
 export { type EffectMatcher, effect };

package/src/effect.ts

@@ -1,14 +1,14 @@
+import { type Cleanup, observe, watch } from './scheduler'
 import { type Signal, type SignalValues, UNSET } from './signal'
 import { CircularDependencyError, isFunction, toError } from './util'
-import { type Cleanup, watch, observe } from './scheduler'
 
 /* === Types === */
 
-type EffectMatcher<S extends Signal<{}>[]> = {
+type EffectMatcher<S extends Signal<unknown & {}>[]> = {
 	signals: S
-	ok: (...values: SignalValues<S>) => void | Cleanup
-	err?: (...errors: Error[]) => void | Cleanup
-	nil?: () => void | Cleanup
+	ok: (...values: SignalValues<S>) => Cleanup | undefined
+	err?: (...errors: Error[]) => Cleanup | undefined
+	nil?: () => Cleanup | undefined
 }
 
 /* === Functions === */
@@ -17,17 +17,19 @@ type EffectMatcher<S extends Signal<{}>[]> = {
  * Define what happens when a reactive state changes
  *
  * @since 0.1.0
- * @param {EffectMatcher<S> | (() => void | Cleanup)} matcher - effect matcher or callback
+ * @param {EffectMatcher<S> | (() => Cleanup | undefined)} matcher - effect matcher or callback
  * @returns {Cleanup} - cleanup function for the effect
  */
-function effect<S extends Signal<{}>[]>(
-	matcher: EffectMatcher<S> | (() => void | Cleanup),
+function effect<S extends Signal<unknown & {}>[]>(
+	matcher: EffectMatcher<S> | (() => Cleanup | undefined),
 ): Cleanup {
 	const {
 		signals,
 		ok,
-		err = console.error,
-		nil = () => {},
+		err = (error: Error): undefined => {
+			console.error(error)
+		},
+		nil = (): undefined => {},
 	} = isFunction(matcher)
 		? { signals: [] as unknown as S, ok: matcher }
 		: matcher
@@ -53,7 +55,7 @@ function effect<S extends Signal<{}>[]>(
 			}) as SignalValues<S>
 
 			// Effectful part
-			let cleanup: void | Cleanup = undefined
+			let cleanup: Cleanup | undefined
 			try {
 				cleanup = pending
 					? nil()

package/src/scheduler.d.ts

@@ -4,7 +4,7 @@ type Watcher = {
     off(cleanup: Cleanup): void;
     cleanup(): void;
 };
-type Updater = <T>() => T | boolean | void;
+type Updater = <T>() => T | boolean | undefined;
 /**
  * Create a watcher that can be used to observe changes to a signal
  *
@@ -51,5 +51,5 @@ declare const observe: (run: () => void, watcher?: Watcher) => void;
  * @param {Updater} fn - function to be executed on the next animation frame; can return updated value <T>, success <boolean> or void
  * @param {symbol} dedupe - Symbol for deduplication; if not provided, a unique Symbol is created ensuring the update is always executed
  */
-declare const enqueue: <T>(fn: Updater, dedupe?: symbol) => Promise<boolean | void | T>;
+declare const enqueue: <T>(fn: Updater, dedupe?: symbol) => Promise<boolean | T | undefined>;
 export { type Cleanup, type Watcher, type Updater, subscribe, notify, flush, batch, watch, observe, enqueue, };

package/src/scheduler.ts

@@ -8,7 +8,7 @@ type Watcher = {
 	cleanup(): void
 }
 
-type Updater = <T>() => T | boolean | void
+type Updater = <T>() => T | boolean | undefined
 
 /* === Internal === */
 
@@ -145,8 +145,8 @@ const observe = (run: () => void, watcher?: Watcher): void => {
  * @param {symbol} dedupe - Symbol for deduplication; if not provided, a unique Symbol is created ensuring the update is always executed
  */
 const enqueue = <T>(fn: Updater, dedupe?: symbol) =>
-	new Promise<T | boolean | void>((resolve, reject) => {
-		updateMap.set(dedupe || Symbol(), () => {
+	new Promise<T | boolean | undefined>((resolve, reject) => {
+		updateMap.set(dedupe || Symbol(), (): undefined => {
 			try {
 				resolve(fn())
 			} catch (error) {

package/src/signal.d.ts

@@ -3,7 +3,7 @@ type Signal<T extends {}> = {
     get(): T;
 };
 type MaybeSignal<T extends {}> = T | Signal<T> | ComputedCallback<T>;
-type SignalValues<S extends Signal<{}>[]> = {
+type SignalValues<S extends Signal<unknown & {}>[]> = {
     [K in keyof S]: S[K] extends Signal<infer T> ? T : never;
 };
 declare const UNSET: any;