@zeix/cause-effect 0.13.1 → 0.14.0

package/test/effect.test.ts

@@ -1,5 +1,5 @@
 import { describe, test, expect, mock } from 'bun:test'
-import { state, computed, effect, UNSET } from '../'
+import { state, task, effect, UNSET, memo } from '../'
 
 /* === Utility Functions === */
 
@@ -8,11 +8,11 @@ const wait = (ms: number) => new Promise(resolve => setTimeout(resolve, ms))
 /* === Tests === */
 
 describe('Effect', function () {
-
-	test('should be triggered after a state change', function() {
+	test('should be triggered after a state change', function () {
 		const cause = state('foo')
 		let count = 0
-		cause.tap(() => {
+		effect(() => {
+			cause.get()
 			count++
 		})
 		expect(count).toBe(1)
@@ -20,12 +20,12 @@ describe('Effect', function () {
 		expect(count).toBe(2)
 	})
 
-	test('should be triggered after computed async signals resolve without waterfalls', async function() {
-		const a = computed(async () => {
+	test('should be triggered after computed async signals resolve without waterfalls', async function () {
+		const a = task(async () => {
 			await wait(100)
 			return 10
 		})
-		const b = computed(async () => {
+		const b = task(async () => {
 			await wait(100)
 			return 20
 		})
@@ -36,7 +36,7 @@ describe('Effect', function () {
 			ok: (aValue, bValue) => {
 				result = aValue + bValue
 				count++
-			}
+			},
 		})
 		expect(result).toBe(0)
 		expect(count).toBe(0)
@@ -45,30 +45,32 @@ describe('Effect', function () {
 		expect(count).toBe(1)
 	})
 
-	test('should be triggered repeatedly after repeated state change', async function() {
+	test('should be triggered repeatedly after repeated state change', async function () {
 		const cause = state(0)
 		let result = 0
 		let count = 0
-		cause.tap(res => {
-			result = res
+		effect(() => {
+			result = cause.get()
 			count++
 		})
 		for (let i = 0; i < 10; i++) {
 			cause.set(i)
 			expect(result).toBe(i)
-			expect(count).toBe(i + 1); // + 1 for effect initialization
+			expect(count).toBe(i + 1) // + 1 for effect initialization
 		}
 	})
 
-	test('should handle errors in effects', function() {
+	test('should handle errors in effects', function () {
 		const a = state(1)
-		const b = a.map(v => {
+		const b = memo(() => {
+			const v = a.get()
 			if (v > 5) throw new Error('Value too high')
 			return v * 2
 		})
 		let normalCallCount = 0
 		let errorCallCount = 0
-		b.tap({
+		effect({
+			signals: [b],
 			ok: () => {
 				// console.log('Normal effect:', value)
 				normalCallCount++
@@ -77,47 +79,48 @@ describe('Effect', function () {
 				// console.log('Error effect:', error)
 				errorCallCount++
 				expect(error.message).toBe('Value too high')
-			}
+			},
 		})
-	
+
 		// Normal case
 		a.set(2)
 		expect(normalCallCount).toBe(2)
 		expect(errorCallCount).toBe(0)
-	
+
 		// Error case
 		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)
 	})
 
-	test('should handle UNSET values in effects', async function() {
-		const a = computed(async () => {
+	test('should handle UNSET values in effects', async function () {
+		const a = task(async () => {
 			await wait(100)
 			return 42
 		})
 		let normalCallCount = 0
 		let nilCount = 0
-		a.tap({
+		effect({
+			signals: [a],
 			ok: aValue => {
 				normalCallCount++
 				expect(aValue).toBe(42)
 			},
 			nil: () => {
 				nilCount++
-			}
+			},
 		})
 
 		expect(normalCallCount).toBe(0)
 		expect(nilCount).toBe(1)
 		expect(a.get()).toBe(UNSET)
 		await wait(110)
-		expect(normalCallCount).toBe(1)
+		expect(normalCallCount).toBeGreaterThan(0)
 		expect(nilCount).toBe(1)
 		expect(a.get()).toBe(42)
 	})
@@ -130,26 +133,27 @@ describe('Effect', function () {
 
 		try {
 			const a = state(1)
-			const b = a.map(v => {
+			const b = memo(() => {
+				const v = a.get()
 				if (v > 5) throw new Error('Value too high')
 				return v * 2
 			})
 
 			// Create an effect without explicit error handling
-			b.tap(() => {})
+			effect(() => {
+				b.get()
+			})
 
 			// This should trigger the error
 			a.set(6)
 
 			// Check if console.error was called with the error
-			expect(mockConsoleError).toHaveBeenCalledWith(
-				expect.any(Error)
-			)
+			expect(mockConsoleError).toHaveBeenCalledWith(expect.any(Error))
 
 			// Check the error message
-			const error = (mockConsoleError as ReturnType<typeof mock>).mock.calls[0][0] as Error
+			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
@@ -160,8 +164,8 @@ describe('Effect', function () {
 		const count = state(42)
 		let received = 0
 
-		const cleanup = count.tap(value => {
-			received = value
+		const cleanup = effect(() => {
+			received = count.get()
 		})
 
 		count.set(43)
@@ -176,8 +180,9 @@ describe('Effect', function () {
 		let okCount = 0
 		let errCount = 0
 		const count = state(0)
-		
-		count.tap({
+
+		effect({
+			signals: [count],
 			ok: () => {
 				okCount++
 				// This effect updates the signal it depends on, creating a circular dependency
@@ -187,9 +192,9 @@ describe('Effect', function () {
 				errCount++
 				expect(e).toBeInstanceOf(Error)
 				expect(e.message).toBe('Circular dependency in effect detected')
-			}
+			},
 		})
-	  
+
 		// Verify that the count was changed only once due to the circular dependency error
 		expect(count.get()).toBe(1)
 		expect(okCount).toBe(1)

package/test/state.test.ts

@@ -1,16 +1,11 @@
 import { describe, test, expect } from 'bun:test'
-import { isComputed, isState, state, UNSET } from '../'
-
-/* === Utility Functions === */
-
-const wait = (ms: number) => new Promise(resolve => setTimeout(resolve, ms))
+import { isComputed, isState, state } from '../'
 
 /* === Tests === */
 
 describe('State', function () {
-
-	describe("State type guard", () => {
-		test("isState identifies state signals", () => {
+	describe('State type guard', () => {
+		test('isState identifies state signals', () => {
 			const count = state(42)
 			expect(isState(count)).toBe(true)
 			expect(isComputed(count)).toBe(false)
@@ -18,7 +13,6 @@ describe('State', function () {
 	})
 
 	describe('Boolean cause', function () {
-
 		test('should be boolean', function () {
 			const cause = state(false)
 			expect(typeof cause.get()).toBe('boolean')
@@ -42,14 +36,12 @@ describe('State', function () {
 
 		test('should toggle initial value with .set(v => !v)', function () {
 			const cause = state(false)
-			cause.update((v) => !v)
+			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')
@@ -71,11 +63,9 @@ describe('State', function () {
 			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')
@@ -94,14 +84,12 @@ describe('State', function () {
 
 		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")
+			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)
@@ -121,21 +109,19 @@ describe('State', function () {
 		test('should reflect current value of array after modification', function () {
 			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
+			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])
 		})
 
 		test('should set new value with .set([...array, 4])', function () {
 			const array = [1, 2, 3]
 			const cause = state(array)
-			cause.set([...array, 4]); // use destructuring instead!
+			cause.set([...array, 4]) // use destructuring instead!
 			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')
@@ -155,69 +141,16 @@ describe('State', function () {
 		test('should reflect current value of object after modification', function () {
 			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
+			// @ts-expect-error Property 'c' does not exist on type '{ a: string; b: number; }'. (ts 2339)
+			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 })
 		})
 
 		test('should set new value with .set({...obj, c: true})', function () {
 			const obj = { a: 'a', b: 1 }
 			const cause = state<Record<string, any>>(obj)
-			cause.set({...obj, c: true}); // use destructuring instead!
+			cause.set({ ...obj, c: true }) // use destructuring instead!
 			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)
-		})
-
-		test('should return a computed signal for an async function', async function() {
-			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('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.tap({
-				ok: v => {
-					result = v
-					okCount++
-				},
-				nil: () => {
-					nilCount++
-				}
-			})
-			cause.set(43)
-			expect(okCount).toBe(2); // + 1 for effect initialization 
-			expect(nilCount).toBe(0)
-			expect(result).toBe(43)
-
-			cause.set(UNSET)
-			expect(okCount).toBe(2)
-			expect(nilCount).toBe(1)
-		})
-
-	})
-
-});
+})