@zeix/cause-effect 0.12.3 → 0.12.4

package/README.md

@@ -1,6 +1,6 @@
 # Cause & Effect
 
-Version 0.12.3
+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.
 
@@ -233,7 +233,7 @@ enqueue(() => {
 You can also use the deduplication feature to ensure that only the latest update for a specific element and operation is applied:
 
 ```js
-import { enqueue } from '@zeix/cause-effect'
+import { state, effect, enqueue } from '@zeix/cause-effect'
 
 // Define a signal and update it in an event handler
 const name = state('')

package/index.d.ts

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

@@ -56,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()
     }
 }
 

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.3",
+  "version": "0.12.4",
   "author": "Esther Brunner",
   "main": "index.js",
   "module": "index.ts",