@zeix/cause-effect 0.12.3 → 0.13.0

package/test/effect.test.ts

@@ -10,157 +10,174 @@ const wait = (ms: number) => new Promise(resolve => setTimeout(resolve, ms))
 describe('Effect', function () {
 
 	test('should be triggered after a state change', function() {
-		const cause = state('foo');
-		let count = 0;
-		effect((_value) => {
-			count++;
-		}, cause);
-		expect(count).toBe(1);
-		cause.set('bar');
-		expect(count).toBe(2);
-	});
+		const cause = state('foo')
+		let count = 0
+		cause.tap(() => {
+			count++
+		})
+		expect(count).toBe(1)
+		cause.set('bar')
+		expect(count).toBe(2)
+	})
 
 	test('should be triggered after computed async signals resolve without waterfalls', async function() {
 		const a = computed(async () => {
-			await wait(100);
-			return 10;
-		});
+			await wait(100)
+			return 10
+		})
 		const b = computed(async () => {
-			await wait(100);
-			return 20;
-		});
-		let result = 0;
-		let count = 0;
-		effect((aValue, bValue) => {
-			result = aValue + bValue;
-			count++;
-		}, a, b);
-		expect(result).toBe(0);
-		expect(count).toBe(0);
-		await wait(110);
-		expect(result).toBe(30);
-		expect(count).toBe(1);
-	});
+			await wait(100)
+			return 20
+		})
+		let result = 0
+		let count = 0
+		effect({
+			signals: [a, b],
+			ok: (aValue, bValue) => {
+				result = aValue + bValue
+				count++
+			}
+		})
+		expect(result).toBe(0)
+		expect(count).toBe(0)
+		await wait(110)
+		expect(result).toBe(30)
+		expect(count).toBe(1)
+	})
 
 	test('should be triggered repeatedly after repeated state change', async function() {
-		const cause = state(0);
-		let result = 0;
-		let count = 0;
-		effect((res) => {
-			result = res;
-			count++;
-		}, cause);
+		const cause = state(0)
+		let result = 0
+		let count = 0
+		cause.tap(res => {
+			result = res
+			count++
+		})
 		for (let i = 0; i < 10; i++) {
-			cause.set(i);
-			expect(result).toBe(i);
+			cause.set(i)
+			expect(result).toBe(i)
 			expect(count).toBe(i + 1); // + 1 for effect initialization
 		}
-	});
+	})
 
 	test('should handle errors in effects', function() {
-		const a = state(1);
-		const b = computed(() => {
-			if (a.get() > 5) throw new Error('Value too high');
-			return a.get() * 2;
-		});
-		let normalCallCount = 0;
-		let errorCallCount = 0;
-		effect({
-			ok: (_bValue) => {
-				// console.log('Normal effect:', _bValue);
-				normalCallCount++;
+		const a = state(1)
+		const b = a.map(v => {
+			if (v > 5) throw new Error('Value too high')
+			return v * 2
+		})
+		let normalCallCount = 0
+		let errorCallCount = 0
+		b.tap({
+			ok: () => {
+				// console.log('Normal effect:', value)
+				normalCallCount++
 			},
-			err: (error) => {
-				// console.log('Error effect:', error);
-				errorCallCount++;
-				expect(error.message).toBe('Value too high');
+			err: error => {
+				// console.log('Error effect:', error)
+				errorCallCount++
+				expect(error.message).toBe('Value too high')
 			}
-		}, b);
+		})
 	
 		// Normal case
-		a.set(2);
-		expect(normalCallCount).toBe(2);
-		expect(errorCallCount).toBe(0);
+		a.set(2)
+		expect(normalCallCount).toBe(2)
+		expect(errorCallCount).toBe(0)
 	
 		// Error case
-		a.set(6);
-		expect(normalCallCount).toBe(2);
-		expect(errorCallCount).toBe(1);
+		a.set(6)
+		expect(normalCallCount).toBe(2)
+		expect(errorCallCount).toBe(1)
 	
 		// Back to normal
-		a.set(3);
-		expect(normalCallCount).toBe(3);
-		expect(errorCallCount).toBe(1);
-	});
+		a.set(3)
+		expect(normalCallCount).toBe(3)
+		expect(errorCallCount).toBe(1)
+	})
 
 	test('should handle UNSET values in effects', async function() {
 		const a = computed(async () => {
-			await wait(100);
-			return 42;
-		});
-		let normalCallCount = 0;
-		let nilCount = 0;
-		effect({
-			ok: (aValue) => {
-				normalCallCount++;
-				expect(aValue).toBe(42);
+			await wait(100)
+			return 42
+		})
+		let normalCallCount = 0
+		let nilCount = 0
+		a.tap({
+			ok: aValue => {
+				normalCallCount++
+				expect(aValue).toBe(42)
 			},
 			nil: () => {
 				nilCount++
 			}
-		}, a);
-
-		expect(normalCallCount).toBe(0);
-		expect(nilCount).toBe(1);
-		expect(a.get()).toBe(UNSET);
-		await wait(110);
-		expect(normalCallCount).toBe(2); // + 1 for effect initialization
-		expect(a.get()).toBe(42);
-	});
+		})
+
+		expect(normalCallCount).toBe(0)
+		expect(nilCount).toBe(1)
+		expect(a.get()).toBe(UNSET)
+		await wait(110)
+		expect(normalCallCount).toBe(1)
+		expect(nilCount).toBe(1)
+		expect(a.get()).toBe(42)
+	})
 
 	test('should log error to console when error is not handled', () => {
-        // Mock console.error
-        const originalConsoleError = console.error;
-        const mockConsoleError = mock((message: string, error: Error) => {});
-        console.error = mockConsoleError;
-
-        try {
-            const a = state(1);
-            const b = computed(() => {
-                if (a.get() > 5) throw new Error('Value too high');
-                return a.get() * 2;
-            });
-
-            // Create an effect without explicit error handling
-            effect(() => {
-                b.get();
-            });
-
-            // This should trigger the error
-            a.set(6);
-
-            // Check if console.error was called with the expected message
-            expect(mockConsoleError).toHaveBeenCalledWith(
-                'Unhandled error in effect:',
-                expect.any(Error)
-            );
-
-            // Check the error message
-            const [, error] = mockConsoleError.mock.calls[0];
-            expect(error.message).toBe('Value too high');
-
-        } finally {
-            // Restore the original console.error
-            console.error = originalConsoleError;
-        }
-    });
+		// Mock console.error
+		const originalConsoleError = console.error
+		const mockConsoleError = mock(() => {})
+		console.error = mockConsoleError
+
+		try {
+			const a = state(1)
+			const b = a.map(v => {
+				if (v > 5) throw new Error('Value too high')
+				return v * 2
+			})
+
+			// Create an effect without explicit error handling
+			b.tap(() => {})
+
+			// This should trigger the error
+			a.set(6)
+
+			// Check if console.error was called with the error
+			expect(mockConsoleError).toHaveBeenCalledWith(
+				expect.any(Error)
+			)
+
+			// Check the error message
+			const error = (mockConsoleError as ReturnType<typeof mock>).mock.calls[0][0] as Error
+			expect(error.message).toBe('Value too high')
+
+		} finally {
+			// Restore the original console.error
+			console.error = originalConsoleError
+		}
+	})
+
+	test('should clean up subscriptions when disposed', () => {
+		const count = state(42)
+		let received = 0
+
+		const cleanup = count.tap(value => {
+			received = value
+		})
+
+		count.set(43)
+		expect(received).toBe(43)
+
+		cleanup()
+		count.set(44)
+		expect(received).toBe(43) // Should not update after dispose
+	})
 
 	test('should detect and throw error for circular dependencies in effects', () => {
 		let okCount = 0
 		let errCount = 0
 		const count = state(0)
 		
-		effect({
+		count.tap({
 			ok: () => {
 				okCount++
 				// This effect updates the signal it depends on, creating a circular dependency
@@ -171,11 +188,11 @@ describe('Effect', function () {
 				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,5 +1,5 @@
 import { describe, test, expect } from 'bun:test'
-import { state, isComputed, UNSET } from '../'
+import { isComputed, isState, state, UNSET } from '../'
 
 /* === Utility Functions === */
 
@@ -9,207 +9,215 @@ const wait = (ms: number) => new Promise(resolve => setTimeout(resolve, ms))
 
 describe('State', function () {
 
+	describe("State type guard", () => {
+		test("isState identifies state signals", () => {
+			const count = state(42)
+			expect(isState(count)).toBe(true)
+			expect(isComputed(count)).toBe(false)
+		})
+	})
+
 	describe('Boolean cause', function () {
 
 		test('should be boolean', function () {
-			const cause = state(false);
-			expect(typeof cause.get()).toBe('boolean');
-		});
+			const cause = state(false)
+			expect(typeof cause.get()).toBe('boolean')
+		})
 
 		test('should set initial value to false', function () {
-			const cause = state(false);
-			expect(cause.get()).toBe(false);
-		});
+			const cause = state(false)
+			expect(cause.get()).toBe(false)
+		})
 
 		test('should set initial value to true', function () {
-			const cause = state(true);
-			expect(cause.get()).toBe(true);
-		});
+			const cause = state(true)
+			expect(cause.get()).toBe(true)
+		})
 
 		test('should set new value with .set(true)', function () {
-			const cause = state(false);
-			cause.set(true);
-			expect(cause.get()).toBe(true);
-		});
+			const cause = state(false)
+			cause.set(true)
+			expect(cause.get()).toBe(true)
+		})
 
 		test('should toggle initial value with .set(v => !v)', function () {
-			const cause = state(false);
-			cause.update((v) => !v);
-			expect(cause.get()).toBe(true);
-		});
+			const cause = state(false)
+			cause.update((v) => !v)
+			expect(cause.get()).toBe(true)
+		})
 
-	});
+	})
 
 	describe('Number cause', function () {
 
 		test('should be number', function () {
-			const cause = state(0);
-			expect(typeof cause.get()).toBe('number');
-		});
+			const cause = state(0)
+			expect(typeof cause.get()).toBe('number')
+		})
 
 		test('should set initial value to 0', function () {
-			const cause = state(0);
-			expect(cause.get()).toBe(0);
-		});
+			const cause = state(0)
+			expect(cause.get()).toBe(0)
+		})
 
 		test('should set new value with .set(42)', function () {
-			const cause = state(0);
-			cause.set(42);
-			expect(cause.get()).toBe(42);
-		});
+			const cause = state(0)
+			cause.set(42)
+			expect(cause.get()).toBe(42)
+		})
 
 		test('should increment value with .set(v => ++v)', function () {
-			const cause = state(0);
-			cause.update(v => ++v);
-			expect(cause.get()).toBe(1);
-		});
+			const cause = state(0)
+			cause.update(v => ++v)
+			expect(cause.get()).toBe(1)
+		})
 
-	});
+	})
 
 	describe('String cause', function () {
 
 		test('should be string', function () {
-			const cause = state('foo');
-			expect(typeof cause.get()).toBe('string');
-		});
+			const cause = state('foo')
+			expect(typeof cause.get()).toBe('string')
+		})
 
 		test('should set initial value to "foo"', function () {
-			const cause = state('foo');
-			expect(cause.get()).toBe('foo');
-		});
+			const cause = state('foo')
+			expect(cause.get()).toBe('foo')
+		})
 
 		test('should set new value with .set("bar")', function () {
-			const cause = state('foo');
-			cause.set('bar');
-			expect(cause.get()).toBe('bar');
-		});
+			const cause = state('foo')
+			cause.set('bar')
+			expect(cause.get()).toBe('bar')
+		})
 
 		test('should upper case value with .set(v => v.toUpperCase())', function () {
-			const cause = state('foo');
-			cause.update(v => v ? v.toUpperCase() : '');
-			expect(cause.get()).toBe("FOO");
-		});
+			const cause = state('foo')
+			cause.update(v => v ? v.toUpperCase() : '')
+			expect(cause.get()).toBe("FOO")
+		})
 
-	});
+	})
 
 	describe('Array cause', function () {
 
 		test('should be array', function () {
-			const cause = state([1, 2, 3]);
-			expect(Array.isArray(cause.get())).toBe(true);
-		});
+			const cause = state([1, 2, 3])
+			expect(Array.isArray(cause.get())).toBe(true)
+		})
 
 		test('should set initial value to [1, 2, 3]', function () {
-			const cause = state([1, 2, 3]);
-			expect(cause.get()).toEqual([1, 2, 3]);
-		});
+			const cause = state([1, 2, 3])
+			expect(cause.get()).toEqual([1, 2, 3])
+		})
 
 		test('should set new value with .set([4, 5, 6])', function () {
-			const cause = state([1, 2, 3]);
-			cause.set([4, 5, 6]);
-			expect(cause.get()).toEqual([4, 5, 6]);
-		});
+			const cause = state([1, 2, 3])
+			cause.set([4, 5, 6])
+			expect(cause.get()).toEqual([4, 5, 6])
+		})
 
 		test('should reflect current value of array after modification', function () {
-			const array = [1, 2, 3];
-			const cause = state(array);
+			const array = [1, 2, 3]
+			const cause = state(array)
 			array.push(4); // don't do this! the result will be correct, but we can't trigger effects
-			expect(cause.get()).toEqual([1, 2, 3, 4]);
-		});
+			expect(cause.get()).toEqual([1, 2, 3, 4])
+		})
 
 		test('should set new value with .set([...array, 4])', function () {
-			const array = [1, 2, 3];
-			const cause = state(array);
+			const array = [1, 2, 3]
+			const cause = state(array)
 			cause.set([...array, 4]); // use destructuring instead!
-			expect(cause.get()).toEqual([1, 2, 3, 4]);
-		});
+			expect(cause.get()).toEqual([1, 2, 3, 4])
+		})
 
-	});
+	})
 
 	describe('Object cause', function () {
 
 		test('should be object', function () {
-			const cause = state({ a: 'a', b: 1 });
-			expect(typeof cause.get()).toBe('object');
-		});
+			const cause = state({ a: 'a', b: 1 })
+			expect(typeof cause.get()).toBe('object')
+		})
 
 		test('should set initial value to { a: "a", b: 1 }', function () {
-			const cause = state({ a: 'a', b: 1 });
-			expect(cause.get()).toEqual({ a: 'a', b: 1 });
-		});
+			const cause = state({ a: 'a', b: 1 })
+			expect(cause.get()).toEqual({ a: 'a', b: 1 })
+		})
 
 		test('should set new value with .set({ c: true })', function () {
-			const cause = state<Record<string, any>>({ a: 'a', b: 1 });
-			cause.set({ c: true });
-			expect(cause.get()).toEqual({ c: true });
-		});
+			const cause = state<Record<string, any>>({ a: 'a', b: 1 })
+			cause.set({ c: true })
+			expect(cause.get()).toEqual({ c: true })
+		})
 
 		test('should reflect current value of object after modification', function () {
-			const obj = { a: 'a', b: 1 };
-			const cause = state<Record<string, any>>(obj);
+			const obj = { a: 'a', b: 1 }
+			const cause = state<Record<string, any>>(obj)
 			// @ts-expect-error
 			obj.c = true; // don't do this! the result will be correct, but we can't trigger effects
-			expect(cause.get()).toEqual({ a: 'a', b: 1, c: true });
-		});
+			expect(cause.get()).toEqual({ a: 'a', b: 1, c: true })
+		})
 
 		test('should set new value with .set({...obj, c: true})', function () {
-			const obj = { a: 'a', b: 1 };
-			const cause = state<Record<string, any>>(obj);
+			const obj = { a: 'a', b: 1 }
+			const cause = state<Record<string, any>>(obj)
 			cause.set({...obj, c: true}); // use destructuring instead!
-			expect(cause.get()).toEqual({ a: 'a', b: 1, c: true });
-		});
+			expect(cause.get()).toEqual({ a: 'a', b: 1, c: true })
+		})
 
-	});
+	})
 
 	describe('Map method', function () {
 
 		test('should return a computed signal', function() {
-			const cause = state(42);
-			const double = cause.map(v => v * 2);
-			expect(isComputed(double)).toBe(true);
-			expect(double.get()).toBe(84);
-		});
+			const cause = state(42)
+			const double = cause.map(v => v * 2)
+			expect(isComputed(double)).toBe(true)
+			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);
-		});
+			const cause = state(42)
+			const asyncDouble = cause.map(async value => {
+				await wait(100)
+				return value * 2
+			})
+			expect(isComputed(asyncDouble)).toBe(true)
+			expect(asyncDouble.get()).toBe(UNSET)
+			await wait(110)
+			expect(asyncDouble.get()).toBe(84)
+		})
 
-	});
+	})
 
-	describe('Match method', function () {
+	describe('Tap method', function () {
 
 		test('should create an effect that reacts on signal changes', function() {
-			const cause = state(42);
-			let okCount = 0;
-			let nilCount = 0;
-			let result = 0;
-			cause.match({
+			const cause = state(42)
+			let okCount = 0
+			let nilCount = 0
+			let result = 0
+			cause.tap({
 				ok: v => {
-					result = v;
+					result = v
 					okCount++
 				},
 				nil: () => {
 					nilCount++
 				}
 			})
-			cause.set(43);
+			cause.set(43)
 			expect(okCount).toBe(2); // + 1 for effect initialization 
-			expect(nilCount).toBe(0);
-			expect(result).toBe(43);
+			expect(nilCount).toBe(0)
+			expect(result).toBe(43)
 
-			cause.set(UNSET);
-			expect(okCount).toBe(2);
-			expect(nilCount).toBe(1);
-		});
+			cause.set(UNSET)
+			expect(okCount).toBe(2)
+			expect(nilCount).toBe(1)
+		})
 
-	});
+	})
 
 });