@zeix/cause-effect 0.13.0 → 0.13.2

package/test/computed.test.ts

@@ -4,12 +4,11 @@ import { state, computed, UNSET, isComputed, isState } from '../index.ts'
 /* === Utility Functions === */
 
 const wait = (ms: number) => new Promise(resolve => setTimeout(resolve, ms))
-const increment = (n: number) => Number.isFinite(n) ? n + 1 : UNSET
+const increment = (n: number) => (Number.isFinite(n) ? n + 1 : UNSET)
 
 /* === Tests === */
 
 describe('Computed', function () {
-
 	test('should identify computed signals with isComputed()', () => {
 		const count = state(42)
 		const doubled = count.map(v => v * 2)
@@ -17,24 +16,24 @@ describe('Computed', function () {
 		expect(isState(doubled)).toBe(false)
 	})
 
-	test('should compute a function', function() {
+	test('should compute a function', function () {
 		const derived = computed(() => 1 + 2)
 		expect(derived.get()).toBe(3)
 	})
 
-	test('should compute function dependent on a signal', function() {
+	test('should compute function dependent on a signal', function () {
 		const derived = state(42).map(v => ++v)
 		expect(derived.get()).toBe(43)
 	})
 
-	test('should compute function dependent on an updated signal', function() {
+	test('should compute function dependent on an updated signal', function () {
 		const cause = state(42)
 		const derived = cause.map(v => ++v)
 		cause.set(24)
 		expect(derived.get()).toBe(25)
 	})
 
-	test('should compute function dependent on an async signal', async function() {
+	test('should compute function dependent on an async signal', async function () {
 		const status = state('pending')
 		const promised = computed(async () => {
 			await wait(100)
@@ -49,7 +48,7 @@ describe('Computed', function () {
 		expect(status.get()).toBe('success')
 	})
 
-	test('should handle errors from an async signal gracefully', async function() {
+	test('should handle errors from an async signal gracefully', async function () {
 		const status = state('pending')
 		const error = state('')
 		const promised = computed(async () => {
@@ -66,7 +65,7 @@ describe('Computed', function () {
 		expect(status.get()).toBe('error')
 	})
 
-	test('should compute async signals in parallel without waterfalls', async function() {
+	test('should compute async signals in parallel without waterfalls', async function () {
 		const a = computed(async () => {
 			await wait(100)
 			return 10
@@ -77,14 +76,14 @@ describe('Computed', function () {
 		})
 		const c = computed({
 			signals: [a, b],
-			ok: (aValue, bValue) => aValue + bValue
+			ok: (aValue, bValue) => aValue + bValue,
 		})
 		expect(c.get()).toBe(UNSET)
 		await wait(110)
 		expect(c.get()).toBe(30)
 	})
 
-	test('should compute function dependent on a chain of computed states dependent on a signal', function() {
+	test('should compute function dependent on a chain of computed states dependent on a signal', function () {
 		const derived = state(42)
 			.map(v => ++v)
 			.map(v => v * 2)
@@ -92,7 +91,7 @@ describe('Computed', function () {
 		expect(derived.get()).toBe(87)
 	})
 
-	test('should compute function dependent on a chain of computed states dependent on an updated signal', function() {
+	test('should compute function dependent on a chain of computed states dependent on an updated signal', function () {
 		const cause = state(42)
 		const derived = cause
 			.map(v => ++v)
@@ -118,7 +117,7 @@ describe('Computed', function () {
 		expect(count).toBe(2)
 	})
 
-	test('should only update every signal once (diamond graph)', function() {
+	test('should only update every signal once (diamond graph)', function () {
 		let count = 0
 		const x = state('a')
 		const a = x.map(v => v)
@@ -135,7 +134,7 @@ describe('Computed', function () {
 		expect(count).toBe(2)
 	})
 
-	test('should only update every signal once (diamond graph + tail)', function() {
+	test('should only update every signal once (diamond graph + tail)', function () {
 		let count = 0
 		const x = state('a')
 		const a = x.map(v => v)
@@ -152,7 +151,7 @@ describe('Computed', function () {
 		expect(count).toBe(2)
 	})
 
-	test('should update multiple times after multiple state changes', function() {
+	test('should update multiple times after multiple state changes', function () {
 		const a = state(3)
 		const b = state(4)
 		let count = 0
@@ -170,19 +169,21 @@ describe('Computed', function () {
 
 	/*
 	 * Note for the next two tests:
-	 * 
+	 *
 	 * Due to the lazy evaluation strategy, unchanged computed signals may propagate
 	 * change notifications one additional time before stabilizing. This is a
 	 * one-time performance cost that allows for efficient memoization and
 	 * error handling in most cases.
 	 */
-	test('should bail out if result is the same', function() {
+	test('should bail out if result is the same', function () {
 		let count = 0
 		const x = state('a')
-		const b = x.map(() => 'foo').map(v => {
-			count++
-			return v
-		})
+		const b = x
+			.map(() => 'foo')
+			.map(v => {
+				count++
+				return v
+			})
 		expect(b.get()).toBe('foo')
 		expect(count).toBe(1)
 		x.set('aa')
@@ -192,11 +193,12 @@ describe('Computed', function () {
 		expect(count).toBe(2)
 	})
 
-	test('should block if result remains unchanged', function() {
+	test('should block if result remains unchanged', function () {
 		let count = 0
 		const x = state(42)
-		const c = x.map(v => v % 2)
-			.map(v => v ? 'odd' : 'even')
+		const c = x
+			.map(v => v % 2)
+			.map(v => (v ? 'odd' : 'even'))
 			.map(v => {
 				count++
 				return `c: ${v}`
@@ -210,7 +212,7 @@ describe('Computed', function () {
 		expect(count).toBe(2)
 	})
 
-	test('should detect and throw error for circular dependencies', function() {
+	test('should detect and throw error for circular dependencies', function () {
 		const a = state(1)
 		const b = computed(() => c.get() + 1)
 		const c = computed(() => b.get() + a.get())
@@ -220,7 +222,7 @@ describe('Computed', function () {
 		expect(a.get()).toBe(1)
 	})
 
-	test('should propagate error if an error occurred', function() {
+	test('should propagate error if an error occurred', function () {
 		let okCount = 0
 		let errCount = 0
 		const x = state(0)
@@ -230,7 +232,7 @@ describe('Computed', function () {
 		})
 		const c = computed({
 			signals: [a],
-			ok: v => v ? 'success' : 'failure',
+			ok: v => (v ? 'success' : 'failure'),
 			err: () => {
 				errCount++
 				return 'recovered'
@@ -245,7 +247,7 @@ describe('Computed', function () {
 		try {
 			x.set(1)
 			expect(a.get()).toBe(1)
-			expect(true).toBe(false); // This line should not be reached
+			expect(true).toBe(false) // This line should not be reached
 		} catch (error) {
 			expect(error.message).toBe('Calculation error')
 		} finally {
@@ -255,7 +257,7 @@ describe('Computed', function () {
 		}
 	})
 
-	test('should return a computed signal with .map()', function() {
+	test('should return a computed signal with .map()', function () {
 		const cause = state(42)
 		const derived = cause.map(v => ++v)
 		const double = derived.map(v => v * 2)
@@ -263,7 +265,7 @@ describe('Computed', function () {
 		expect(double.get()).toBe(86)
 	})
 
-	test('should create an effect that reacts on async computed changes with .tap()', async function() {
+	test('should create an effect that reacts on async computed changes with .tap()', async function () {
 		const cause = state(42)
 		const derived = computed(async () => {
 			await wait(100)
@@ -279,7 +281,7 @@ describe('Computed', function () {
 			},
 			nil: () => {
 				nilCount++
-			}
+			},
 		})
 		cause.set(43)
 		expect(okCount).toBe(0)
@@ -292,7 +294,7 @@ describe('Computed', function () {
 		expect(result).toBe(44)
 	})
 
-	test('should handle complex computed signal with error and async dependencies', async function() {
+	test('should handle complex computed signal with error and async dependencies', async function () {
 		const toggleState = state(true)
 		const errorProne = toggleState.map(v => {
 			if (v) throw new Error('Intentional error')
@@ -319,9 +321,9 @@ describe('Computed', function () {
 			err: () => {
 				errCount++
 				return -1
-			}
+			},
 		})
-		
+
 		/* computed(() => {
 			try {
 				const x = errorProne.get()
@@ -338,21 +340,21 @@ describe('Computed', function () {
 				return -1
 			}
 		}) */
-	
+
 		for (let i = 0; i < 10; i++) {
 			toggleState.set(!!(i % 2))
 			await wait(10)
 			result = complexComputed.get()
 			// console.log(`i: ${i}, result: ${result}`)
 		}
-	
+
 		expect(nilCount).toBeGreaterThanOrEqual(5)
 		expect(okCount).toBeGreaterThanOrEqual(2)
 		expect(errCount).toBeGreaterThanOrEqual(3)
 		expect(okCount + errCount + nilCount).toBe(10)
 	})
 
-	test('should handle signal changes during async computation', async function() {
+	test('should handle signal changes during async computation', async function () {
 		const source = state(1)
 		let computationCount = 0
 		const derived = computed(async abort => {
@@ -373,7 +375,7 @@ describe('Computed', function () {
 		expect(computationCount).toBe(1)
 	})
 
-	test('should handle multiple rapid changes during async computation', async function() {
+	test('should handle multiple rapid changes during async computation', async function () {
 		const source = state(1)
 		let computationCount = 0
 		const derived = computed(async abort => {
@@ -398,7 +400,7 @@ describe('Computed', function () {
 		expect(computationCount).toBe(1)
 	})
 
-	test('should handle errors in aborted computations', async function() {
+	test('should handle errors in aborted computations', async function () {
 		// const startTime = performance.now()
 		const source = state(1)
 		const derived = computed(async () => {
@@ -407,7 +409,7 @@ describe('Computed', function () {
 			if (value === 2) throw new Error('Intentional error')
 			return value
 		})
-		
+
 		/* derived.tap({
 			ok: v => {
 				console.log(`ok: ${v}, time: ${performance.now() - startTime}ms`)
@@ -427,11 +429,10 @@ describe('Computed', function () {
 		source.set(2)
 		await wait(110)
 		expect(() => derived.get()).toThrow('Intentional error')
-		
+
 		// Change to normal state before second computation completes
 		source.set(3)
 		await wait(100)
 		expect(derived.get()).toBe(3)
-		
 	})
-})
+})

package/test/effect.test.ts

@@ -8,8 +8,7 @@ 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(() => {
@@ -20,7 +19,7 @@ describe('Effect', function () {
 		expect(count).toBe(2)
 	})
 
-	test('should be triggered after computed async signals resolve without waterfalls', async function() {
+	test('should be triggered after computed async signals resolve without waterfalls', async function () {
 		const a = computed(async () => {
 			await wait(100)
 			return 10
@@ -36,7 +35,7 @@ describe('Effect', function () {
 			ok: (aValue, bValue) => {
 				result = aValue + bValue
 				count++
-			}
+			},
 		})
 		expect(result).toBe(0)
 		expect(count).toBe(0)
@@ -45,7 +44,7 @@ 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
@@ -56,11 +55,11 @@ describe('Effect', function () {
 		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 => {
 			if (v > 5) throw new Error('Value too high')
@@ -77,26 +76,26 @@ 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() {
+	test('should handle UNSET values in effects', async function () {
 		const a = computed(async () => {
 			await wait(100)
 			return 42
@@ -110,7 +109,7 @@ describe('Effect', function () {
 			},
 			nil: () => {
 				nilCount++
-			}
+			},
 		})
 
 		expect(normalCallCount).toBe(0)
@@ -142,14 +141,12 @@ describe('Effect', function () {
 			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
@@ -176,7 +173,7 @@ describe('Effect', function () {
 		let okCount = 0
 		let errCount = 0
 		const count = state(0)
-		
+
 		count.tap({
 			ok: () => {
 				okCount++
@@ -187,9 +184,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

@@ -8,9 +8,8 @@ const wait = (ms: number) => new Promise(resolve => setTimeout(resolve, ms))
 /* === 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 +17,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 +40,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 +67,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 +88,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 +113,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')
@@ -156,29 +146,27 @@ describe('State', 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
+			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() {
+		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() {
+		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)
@@ -189,12 +177,10 @@ describe('State', function () {
 			await wait(110)
 			expect(asyncDouble.get()).toBe(84)
 		})
-
 	})
 
 	describe('Tap method', function () {
-
-		test('should create an effect that reacts on signal changes', function() {
+		test('should create an effect that reacts on signal changes', function () {
 			const cause = state(42)
 			let okCount = 0
 			let nilCount = 0
@@ -206,10 +192,10 @@ describe('State', function () {
 				},
 				nil: () => {
 					nilCount++
-				}
+				},
 			})
 			cause.set(43)
-			expect(okCount).toBe(2); // + 1 for effect initialization 
+			expect(okCount).toBe(2) // + 1 for effect initialization
 			expect(nilCount).toBe(0)
 			expect(result).toBe(43)
 
@@ -217,7 +203,5 @@ describe('State', function () {
 			expect(okCount).toBe(2)
 			expect(nilCount).toBe(1)
 		})
-
 	})
-
-});
+})