@zeix/cause-effect 0.9.7 → 0.10.1

package/README.md

@@ -1,6 +1,6 @@
 # Cause & Effect
 
-Version 0.9.7
+Version 0.10.1
 
 **Cause & Effect** - efficient state management with signals that sync instantly and reactively across your application.
 
@@ -24,7 +24,7 @@ bun add @zeix/cause-effect
 
 ### Single State Signal
 
-`state()` creates a new state signal. To access the current value of the signal use the `.get()` method. To update the value of the signal use the `.set()` method with a new value or an updater function of the form `(v: T) => T`.
+`state()` creates a new state signal. To access the current value of the signal use the `.get()` method. To update the value of the signal use the `.set()` method with a new value or `.update()` with an updater function of the form `(v: T) => T`.
 
 ```js
 import { state, effect } from '@zeix/cause-effect'
@@ -33,7 +33,7 @@ const count = state(42)
 effect(() => console.log(count.get())) // logs '42'
 count.set(24) // logs '24'
 document.querySelector('button.increment')
-    .addEventListener('click', () => count.set(v => ++v))
+    .addEventListener('click', () => count.update(v => ++v))
 // Click on button logs '25', '26', and so on
 ```
 
@@ -49,7 +49,7 @@ const isOdd = computed(() => count.get() % 2)
 effect(() => console.log(isOdd.get())) // logs 'false'
 count.set(24) // logs nothing because 24 is also an even number
 document.querySelector('button.increment')
-    .addEventListener('click', () => count.set(v => ++v))
+    .addEventListener('click', () => count.update(v => ++v))
 // Click on button logs 'true', 'false', and so on
 ```
 
@@ -96,7 +96,7 @@ effect(() => {
 })
 // Updates h1 and p of the entry as soon as fetched data for entry becomes available
 document.querySelector('button.next')
-    .addEventListener('click', () => entryId.set(v => ++v))
+    .addEventListener('click', () => entryId.update(v => ++v))
 // Click on button updates h1 and p of the entry as soon as fetched data for the next entry is loaded
 ```
 
@@ -114,8 +114,8 @@ effect(() => console.log(sum.get())) // logs '7'
 document.querySelector('button.double-all')
     .addEventListener('click', () =>
         batch(() => {
-            a.set(v => v * 2)
-            b.set(v => v * 2)
+            a.update(v => v * 2)
+            b.update(v => v * 2)
         }
     ))
 // Click on button logs '14' only once (instead of first '10' and then '14' without batch)

package/index.d.ts

@@ -1,9 +1,9 @@
 /**
  * @name Cause & Effect
- * @version 0.9.7
+ * @version 0.10.1
  * @author Esther Brunner
  */
 export { UNSET, State, state, isState } from './lib/state';
 export { type Computed, computed, isComputed } from './lib/computed';
-export { type Signal, isSignal, toSignal, batch } from './lib/signal';
+export { type Signal, type MaybeSignal, isSignal, toSignal, batch } from './lib/signal';
 export { effect } from './lib/effect';

package/index.js

@@ -1 +1 @@
-var A=(y)=>typeof y==="function",D=(y)=>A(y)&&/^async\s+/.test(y.toString()),G=(y)=>(x)=>x instanceof y,X=G(Error),O=G(Promise);var R="Computed",q=(y,x)=>{x=x??D(y);let j=[],Q,B=null,W=!0,S=()=>{if(W=!0,x)I(j)},Y={[Symbol.toStringTag]:R,get:()=>{if(x)H(j);if(!x||W)J(()=>{let F=(L)=>{Q=L,W=!1,B=null},C=(L)=>{B=X(L)?L:new Error(`Computed function failed: ${L}`)};try{let L=y(Q);O(L)?L.then(F).catch(C):F(L)}catch(L){C(L)}},S);if(X(B))throw B;return Q},map:(F)=>q(()=>F(Y.get()))};return Y},Z=(y)=>!!y&&typeof y==="object"&&y[Symbol.toStringTag]===R;var z,$=!1,N=[],P=(y)=>M(y)||Z(y),U=(y,x=!1)=>P(y)?y:A(y)?q(y,x):k(y),H=(y)=>{if(z&&!y.includes(z))y.push(z)},I=(y)=>y.forEach((x)=>$?N.push(x):x()),J=(y,x)=>{let j=z;z=x,y(),z=j},T=(y)=>{$=!0,y(),$=!1,N.forEach((x)=>x()),N.length=0};var V=Symbol();class K{y;watchers=[];constructor(y){this.value=y}get(){return H(this.watchers),this.value}set(y){if(V!==y){let x=A(y)?y(this.value):y;if(Object.is(this.value,x))return;this.value=x}if(I(this.watchers),V===y)this.watchers=[]}map(y){return q(()=>y(this.get()))}}var k=(y)=>new K(y),M=G(K);var p=(y)=>{let x=()=>J(()=>{try{y()}catch(j){console.error(j)}},x);x()};export{U as toSignal,k as state,M as isState,P as isSignal,Z as isComputed,p as effect,q as computed,T as batch,V as UNSET,K as State};
+var M=(T)=>typeof T==="function",C=(T)=>M(T)&&/^async\s+/.test(T.toString()),R=(T)=>M(T)&&T.length<2,Y=(T)=>(y)=>y instanceof T,K=Y(Error),D=Y(Promise);var O="Computed",I=(T,y)=>{y=y??C(T);let F=[],H,j=null,J=!0,U=()=>{if(J=!0,y)A(F)},Z={[Symbol.toStringTag]:O,get:()=>{if(y)z(F);if(!y||J)B(()=>{let q=(x)=>{H=x,J=!1,j=null},$=(x)=>{j=K(x)?x:new Error(`Computed function failed: ${x}`)};try{let x=T(H);D(x)?x.then(q).catch($):q(x)}catch(x){$(x)}},U);if(K(j))throw j;return H},map:(q)=>I(()=>q(Z.get()))};return Z},N=(T)=>!!T&&typeof T==="object"&&T[Symbol.toStringTag]===O;var L,Q=!1,V=[],P=(T)=>X(T)||N(T),k=(T,y=!1)=>P(T)?T:R(T)?I(T,y):W(T),z=(T)=>{if(L&&!T.includes(L))T.push(L)},A=(T)=>T.forEach((y)=>Q?V.push(y):y()),B=(T,y)=>{let F=L;L=y,T(),L=F},E=(T)=>{Q=!0,T(),Q=!1,V.forEach((y)=>y()),V.length=0};var S=Symbol();class G{T;watchers=[];constructor(T){this.value=T}get(){return z(this.watchers),this.value}set(T){if(Object.is(this.value,T))return;if(this.value=T,A(this.watchers),S===T)this.watchers=[]}update(T){this.set(T(this.value))}map(T){return I(()=>T(this.get()))}}var W=(T)=>new G(T),X=(T)=>T instanceof G;var g=(T)=>{let y=()=>B(()=>{try{T()}catch(F){console.error(F)}},y);y()};export{k as toSignal,W as state,X as isState,P as isSignal,N as isComputed,g as effect,I as computed,E as batch,S as UNSET,G as State};

package/index.ts

@@ -1,9 +1,9 @@
 /**
  * @name Cause & Effect
- * @version 0.9.7
+ * @version 0.10.1
  * @author Esther Brunner
  */
 export { UNSET, State, state, isState } from './lib/state'
 export { type Computed, computed, isComputed } from './lib/computed'
-export { type Signal, isSignal, toSignal, batch } from './lib/signal'
+export { type Signal, type MaybeSignal, isSignal, toSignal, batch } from './lib/signal'
 export { effect } from './lib/effect'

package/lib/computed.d.ts

@@ -1,7 +1,7 @@
 export type Computed<T> = {
     [Symbol.toStringTag]: "Computed";
     get: () => T;
-    map: <U>(fn: (value: T) => U) => Computed<U>;
+    map: <U extends {}>(fn: (value: T) => U) => Computed<U>;
 };
 /**
  * Create a derived state from existing states
@@ -10,5 +10,12 @@ export type Computed<T> = {
  * @param {() => T} fn - compute function to derive state
  * @returns {Computed<T>} result of derived state
  */
-export declare const computed: <T>(fn: (v?: T) => T | Promise<T>, memo?: boolean) => Computed<T>;
+export declare const computed: <T extends {}>(fn: (v?: T) => T | Promise<T>, memo?: boolean) => Computed<T>;
+/**
+ * Check if a value is a computed state
+ *
+ * @since 0.9.0
+ * @param {unknown} value - value to check
+ * @returns {boolean} - true if value is a computed state, false otherwise
+ */
 export declare const isComputed: <T>(value: unknown) => value is Computed<T>;

package/lib/computed.ts

@@ -6,7 +6,7 @@ import { isAsyncFunction, isError, isPromise } from "./util"
 export type Computed<T> = {
     [Symbol.toStringTag]: "Computed"
     get: () => T
-    map: <U>(fn: (value: T) => U) => Computed<U>
+    map: <U extends {}>(fn: (value: T) => U) => Computed<U>
 }
 
 /* === Constants === */
@@ -22,7 +22,7 @@ const TYPE_COMPUTED = 'Computed'
  * @param {() => T} fn - compute function to derive state
  * @returns {Computed<T>} result of derived state
  */
-export const computed =  /*#__PURE__*/ <T>(
+export const computed =  /*#__PURE__*/ <T extends {}>(
 	fn: (v?: T) => T | Promise<T>,
 	memo?: boolean
 ): Computed<T> => {
@@ -64,12 +64,21 @@ export const computed =  /*#__PURE__*/ <T>(
 			if (isError(error)) throw error
 			return value
 		},
-		map: <U>(fn: (value: T) => U): Computed<U> =>
+		map: <U extends {}>(fn: (value: T) => U): Computed<U> =>
 			computed(() => fn(c.get())),
 	}
 	return c
 }
 
+/* === Helper Functions === */
+
+/**
+ * Check if a value is a computed state
+ * 
+ * @since 0.9.0
+ * @param {unknown} value - value to check
+ * @returns {boolean} - true if value is a computed state, false otherwise
+ */
 export const isComputed = /*#__PURE__*/ <T>(value: unknown): value is Computed<T> =>
 	!!value && typeof value === 'object'
 		&& (value as { [key in typeof Symbol.toStringTag]: string })[Symbol.toStringTag] === TYPE_COMPUTED

package/lib/signal.d.ts

@@ -1,7 +1,7 @@
 import { type State } from "./state";
 import { type Computed } from "./computed";
-type Signal<T> = State<T> | Computed<T>;
-type MaybeSignal<T> = State<T> | Computed<T> | T;
+type Signal<T extends {}> = State<T> | Computed<T>;
+type MaybeSignal<T extends {}> = State<T> | Computed<T> | T | ((old?: T) => T);
 type Watcher = () => void;
 /**
  * Check whether a value is a Signal or not
@@ -10,7 +10,7 @@ type Watcher = () => void;
  * @param {any} value - value to check
  * @returns {boolean} - true if value is a Signal, false otherwise
  */
-declare const isSignal: <T>(value: any) => value is Signal<T>;
+declare const isSignal: <T extends {}>(value: any) => value is Signal<T>;
 /**
  * Convert a value to a Signal if it's not already a Signal
  *
@@ -19,7 +19,7 @@ declare const isSignal: <T>(value: any) => value is Signal<T>;
  * @param memo
  * @returns {Signal<T>} - converted Signal
  */
-declare const toSignal: <T>(value: MaybeSignal<T>, memo?: boolean) => Signal<T>;
+declare const toSignal: <T extends {}>(value: MaybeSignal<T>, memo?: boolean) => Signal<T>;
 /**
  * Add notify function of active watchers to the set of watchers
  *
@@ -45,4 +45,4 @@ declare const watch: (run: () => void, mark: Watcher) => void;
  * @param {() => void} run - function to run the batch of state changes
  */
 declare const batch: (run: () => void) => void;
-export { type Signal, type Watcher, isSignal, toSignal, subscribe, notify, watch, batch };
+export { type Signal, type MaybeSignal, type Watcher, isSignal, toSignal, subscribe, notify, watch, batch };

package/lib/signal.ts

@@ -1,12 +1,12 @@
 import { type State, isState, state } from "./state"
 import { computed, type Computed, isComputed } from "./computed"
-import { isFunction } from "./util"
+import { isComputeFunction } from "./util"
 
 /* === Types === */
 
-type Signal<T> = State<T> | Computed<T>
+type Signal<T extends {}> = State<T> | Computed<T>
 
-type MaybeSignal<T> = State<T> | Computed<T> | T
+type MaybeSignal<T extends {}> = State<T> | Computed<T> | T | ((old?: T) => T)
 
 type Watcher = () => void
 
@@ -30,7 +30,7 @@ const pending: Watcher[] = []
  * @param {any} value - value to check
  * @returns {boolean} - true if value is a Signal, false otherwise
  */
-const isSignal = /*#__PURE__*/ <T>(value: any): value is Signal<T> =>
+const isSignal = /*#__PURE__*/ <T extends {}>(value: any): value is Signal<T> =>
 	isState(value) || isComputed(value)
 
 /**
@@ -41,12 +41,12 @@ const isSignal = /*#__PURE__*/ <T>(value: any): value is Signal<T> =>
  * @param memo 
  * @returns {Signal<T>} - converted Signal
  */
-const toSignal = /*#__PURE__*/ <T>(
+const toSignal = /*#__PURE__*/ <T extends {}>(
 	value: MaybeSignal<T>,
 	memo: boolean = false
 ): Signal<T> =>
 	isSignal<T>(value) ? value
-		: isFunction(value) ? computed(value, memo)
+		: isComputeFunction<T>(value) ? computed(value, memo)
 		: state(value)
 
 /**
@@ -93,6 +93,6 @@ const batch = (run: () => void): void => {
 }
 
 export {
-	type Signal, type Watcher,
+	type Signal, type MaybeSignal, type Watcher,
     isSignal, toSignal, subscribe, notify, watch, batch
 }

package/lib/state.d.ts

@@ -6,13 +6,14 @@ export declare const UNSET: any;
  * @since 0.9.0
  * @class State
  */
-export declare class State<T> {
+export declare class State<T extends {}> {
     private value;
     private watchers;
     constructor(value: T);
     /**
      * Get the current value of the state
      *
+     * @since 0.9.0
      * @method of State<T>
      * @returns {T} - current value of the state
      */
@@ -20,19 +21,44 @@ export declare class State<T> {
     /**
      * Set a new value of the state
      *
+     * @since 0.9.0
      * @method of State<T>
-     * @param {T | ((v: T) => T)} value
+     * @param {T} value
      * @returns {void}
      */
-    set(value: T | ((v: T) => T)): void;
-    map<U>(fn: (value: T) => U): Computed<U>;
+    set(value: T): void;
+    /**
+     * Update the state with a new value using a function
+     *
+     * @since 0.10.0
+     * @method of State<T>
+     * @param {(value: T) => T} fn
+     * @returns {void} - updates the state with the result of the function
+     */
+    update(fn: (value: T) => T): void;
+    /**
+     * Create a derived state from an existing state
+     *
+     * @since 0.9.0
+     * @method of State<T>
+     * @param {(value: T) => U} fn
+     * @returns {Computed<U>} - derived state
+     */
+    map<U extends {}>(fn: (value: T) => U): Computed<U>;
 }
 /**
  * Create a new state signal
  *
- * @static method of State<T>
+ * @since 0.9.0
  * @param {T} value - initial value of the state
  * @returns {State<T>} - new state signal
  */
-export declare const state: <T>(value: T) => State<T>;
-export declare const isState: (value: unknown) => value is State<any>;
+export declare const state: <T extends {}>(value: T) => State<T>;
+/**
+ * Check if the provided value is a State instance
+ *
+ * @since 0.9.0
+ * @param {unknown} value - value to check
+ * @returns {boolean} - true if the value is a State instance, false otherwise
+ */
+export declare const isState: <T extends {}>(value: unknown) => value is State<T>;

package/lib/state.ts

@@ -1,4 +1,3 @@
-import { isFunction, isInstanceOf } from "./util"
 import { type Watcher, subscribe, notify } from "./signal"
 import { type Computed, computed } from "./computed"
 
@@ -14,7 +13,7 @@ export const UNSET: any = Symbol()
  * @since 0.9.0
  * @class State
  */
-export class State<T> {
+export class State<T extends {}> {
     private watchers: Watcher[] = []
 
     constructor(private value: T) {}
@@ -22,6 +21,7 @@ export class State<T> {
 	/**
 	 * Get the current value of the state
 	 * 
+	 * @since 0.9.0
 	 * @method of State<T>
 	 * @returns {T} - current value of the state
 	 */
@@ -33,35 +33,63 @@ export class State<T> {
 	/**
 	 * Set a new value of the state
 	 * 
+	 * @since 0.9.0
 	 * @method of State<T>
-	 * @param {T | ((v: T) => T)} value
+	 * @param {T} value
 	 * @returns {void}
 	 */
-    set(value: T | ((v: T) => T)): void {
-		if (UNSET !== value) {
-			const newValue = isFunction(value) ? value(this.value) : value
-			if (Object.is(this.value, newValue)) return
-			this.value = newValue
-		}
+    set(value: T): void {
+		if (Object.is(this.value, value)) return
+		this.value = value
 		notify(this.watchers)
 
-		// Setting to null clears the watchers so the signal can be garbage collected
+		// Setting to UNSET clears the watchers so the signal can be garbage collected
 		if (UNSET === value) this.watchers = []
     }
 
-    map<U>(fn: (value: T) => U): Computed<U> {
+	/**
+	 * Update the state with a new value using a function
+	 * 
+	 * @since 0.10.0
+	 * @method of State<T>
+	 * @param {(value: T) => T} fn
+	 * @returns {void} - updates the state with the result of the function
+	 */
+	update(fn: (value: T) => T): void {
+		this.set(fn(this.value))
+    }
+
+	/**
+	 * Create a derived state from an existing state
+	 * 
+	 * @since 0.9.0
+	 * @method of State<T>
+	 * @param {(value: T) => U} fn
+	 * @returns {Computed<U>} - derived state
+	 */
+    map<U extends {}>(fn: (value: T) => U): Computed<U> {
         return computed<U>(() => fn(this.get()))
     }
 }
 
+/* === Helper Functions === */
+
 /**
  * Create a new state signal
  * 
- * @static method of State<T>
+ * @since 0.9.0
  * @param {T} value - initial value of the state
  * @returns {State<T>} - new state signal
  */
-export const state = /*#__PURE__*/ <T>(value: T): State<T> =>
+export const state = /*#__PURE__*/ <T extends {}>(value: T): State<T> =>
 	new State(value)
 
-export const isState = /*#__PURE__*/ isInstanceOf(State)
+/**
+ * Check if the provided value is a State instance
+ * 
+ * @since 0.9.0
+ * @param {unknown} value - value to check
+ * @returns {boolean} - true if the value is a State instance, false otherwise
+ */
+export const isState = /*#__PURE__*/ <T extends {}>(value: unknown): value is State<T> =>
+	value instanceof State

package/lib/util.d.ts

@@ -1,6 +1,7 @@
-declare const isFunction: (value: unknown) => value is (...args: any[]) => any;
-declare const isAsyncFunction: (value: unknown) => value is (...args: any[]) => Promise<any> | PromiseLike<any>;
+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 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>;
-export { isFunction, isAsyncFunction, isInstanceOf, isError, isPromise };
+export { isFunction, isAsyncFunction, isComputeFunction, isInstanceOf, isError, isPromise };

package/lib/util.ts

@@ -1,11 +1,14 @@
 /* === Utility Functions === */
 
-const isFunction = /*#__PURE__*/ (value: unknown): value is (...args: any[]) => any =>
+const isFunction = /*#__PURE__*/ <T>(value: unknown): value is (...args: unknown[]) => T =>
     typeof value === 'function'
 
-const isAsyncFunction = /*#__PURE__*/ (value: unknown): value is (...args: any[]) => Promise<any> | PromiseLike<any> =>
+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 isInstanceOf = /*#__PURE__*/ <T>(type: new (...args: any[]) => T) =>
 	(value: unknown): value is T =>
 		value instanceof type
@@ -13,4 +16,4 @@ const isInstanceOf = /*#__PURE__*/ <T>(type: new (...args: any[]) => T) =>
 const isError = /*#__PURE__*/ isInstanceOf(Error)
 const isPromise = /*#__PURE__*/ isInstanceOf(Promise)
 
-export { isFunction, isAsyncFunction, isInstanceOf, isError, isPromise }
+export { isFunction, isAsyncFunction, isComputeFunction, isInstanceOf, isError, isPromise }

package/package.json

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

package/test/cause-effect.test.ts

@@ -11,15 +11,6 @@ const decrement = (n: number | void) => (n ?? 0) - 1;
 
 describe('State', function () {
 
-	describe('Empty cause', function () {
-
-		test('should be undefined', function () {
-			const cause = state(undefined);
-			expect(cause.get()).toBeUndefined();
-		});
-
-	});
-
 	describe('Boolean cause', function () {
 
 		test('should be boolean', function () {
@@ -45,7 +36,7 @@ describe('State', function () {
 
 		test('should toggle initial value with .set(v => !v)', function () {
 			const cause = state(false);
-			cause.set((v) => !v);
+			cause.update((v) => !v);
 			expect(cause.get()).toBe(true);
 		});
 
@@ -71,7 +62,7 @@ describe('State', function () {
 
 		test('should increment value with .set(v => ++v)', function () {
 			const cause = state(0);
-			cause.set(v => ++v);
+			cause.update(v => ++v);
 			expect(cause.get()).toBe(1);
 		});
 
@@ -97,7 +88,7 @@ describe('State', function () {
 
 		test('should upper case value with .set(v => v.toUpperCase())', function () {
 			const cause = state('foo');
-			cause.set(v => v ? v.toUpperCase() : '');
+			cause.update(v => v ? v.toUpperCase() : '');
 			expect(cause.get()).toBe("FOO");
 		});