@zeix/cause-effect 0.14.0 → 0.14.2

package/test/computed.test.ts

@@ -1,12 +1,11 @@
-import { describe, test, expect } from 'bun:test'
+import { describe, expect, test } from 'bun:test'
 import {
-	state,
-	memo,
-	task,
-	UNSET,
+	computed,
+	effect,
 	isComputed,
 	isState,
-	effect,
+	state,
+	UNSET,
 } from '../index.ts'
 
 /* === Utility Functions === */
@@ -16,40 +15,40 @@ const increment = (n: number) => (Number.isFinite(n) ? n + 1 : UNSET)
 
 /* === Tests === */
 
-describe('Computed', function () {
+describe('Computed', () => {
 	test('should identify computed signals with isComputed()', () => {
 		const count = state(42)
-		const doubled = memo(() => count.get() * 2)
+		const doubled = computed(() => count.get() * 2)
 		expect(isComputed(doubled)).toBe(true)
 		expect(isState(doubled)).toBe(false)
 	})
 
-	test('should compute a function', function () {
-		const derived = memo(() => 1 + 2)
+	test('should compute a 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', () => {
 		const cause = state(42)
-		const derived = memo(() => cause.get() + 1)
+		const derived = computed(() => cause.get() + 1)
 		expect(derived.get()).toBe(43)
 	})
 
-	test('should compute function dependent on an updated signal', function () {
+	test('should compute function dependent on an updated signal', () => {
 		const cause = state(42)
-		const derived = memo(() => cause.get() + 1)
+		const derived = computed(() => cause.get() + 1)
 		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 () => {
 		const status = state('pending')
-		const promised = task(async () => {
+		const promised = computed(async () => {
 			await wait(100)
 			status.set('success')
 			return 42
 		})
-		const derived = memo(() => increment(promised.get()))
+		const derived = computed(() => increment(promised.get()))
 		expect(derived.get()).toBe(UNSET)
 		expect(status.get()).toBe('pending')
 		await wait(110)
@@ -57,16 +56,16 @@ 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 () => {
 		const status = state('pending')
 		const error = state('')
-		const promised = task(async () => {
+		const promised = computed(async () => {
 			await wait(100)
 			status.set('error')
 			error.set('error occurred')
 			return 0
 		})
-		const derived = memo(() => increment(promised.get()))
+		const derived = computed(() => increment(promised.get()))
 		expect(derived.get()).toBe(UNSET)
 		expect(status.get()).toBe('pending')
 		await wait(110)
@@ -74,16 +73,16 @@ describe('Computed', function () {
 		expect(status.get()).toBe('error')
 	})
 
-	test('should compute task signals in parallel without waterfalls', async function () {
-		const a = task(async () => {
+	test('should compute task signals in parallel without waterfalls', async () => {
+		const a = computed(async () => {
 			await wait(100)
 			return 10
 		})
-		const b = task(async () => {
+		const b = computed(async () => {
 			await wait(100)
 			return 20
 		})
-		const c = memo(() => {
+		const c = computed(() => {
 			const aValue = a.get()
 			const bValue = b.get()
 			return aValue === UNSET || bValue === UNSET
@@ -95,31 +94,31 @@ describe('Computed', function () {
 		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', () => {
 		const x = state(42)
-		const a = memo(() => x.get() + 1)
-		const b = memo(() => a.get() * 2)
-		const c = memo(() => b.get() + 1)
+		const a = computed(() => x.get() + 1)
+		const b = computed(() => a.get() * 2)
+		const c = computed(() => b.get() + 1)
 		expect(c.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', () => {
 		const x = state(42)
-		const a = memo(() => x.get() + 1)
-		const b = memo(() => a.get() * 2)
-		const c = memo(() => b.get() + 1)
+		const a = computed(() => x.get() + 1)
+		const b = computed(() => a.get() * 2)
+		const c = computed(() => b.get() + 1)
 		x.set(24)
 		expect(c.get()).toBe(51)
 	})
 
-	test('should drop X->B->X updates', function () {
+	test('should drop X->B->X updates', () => {
 		let count = 0
 		const x = state(2)
-		const a = memo(() => x.get() - 1)
-		const b = memo(() => x.get() + a.get())
-		const c = memo(() => {
+		const a = computed(() => x.get() - 1)
+		const b = computed(() => x.get() + a.get())
+		const c = computed(() => {
 			count++
-			return 'c: ' + b.get()
+			return `c: ${b.get()}`
 		})
 		expect(c.get()).toBe('c: 3')
 		expect(count).toBe(1)
@@ -128,12 +127,12 @@ 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)', () => {
 		let count = 0
 		const x = state('a')
-		const a = memo(() => x.get())
-		const b = memo(() => x.get())
-		const c = memo(() => {
+		const a = computed(() => x.get())
+		const b = computed(() => x.get())
+		const c = computed(() => {
 			count++
 			return a.get() + ' ' + b.get()
 		})
@@ -145,13 +144,13 @@ 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)', () => {
 		let count = 0
 		const x = state('a')
-		const a = memo(() => x.get())
-		const b = memo(() => x.get())
-		const c = memo(() => a.get() + ' ' + b.get())
-		const d = memo(() => {
+		const a = computed(() => x.get())
+		const b = computed(() => x.get())
+		const c = computed(() => `${a.get()} ${b.get()}`)
+		const d = computed(() => {
 			count++
 			return c.get()
 		})
@@ -162,11 +161,11 @@ 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', () => {
 		const a = state(3)
 		const b = state(4)
 		let count = 0
-		const sum = memo(() => {
+		const sum = computed(() => {
 			count++
 			return a.get() + b.get()
 		})
@@ -186,14 +185,14 @@ describe('Computed', function () {
 	 * 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', () => {
 		let count = 0
 		const x = state('a')
-		const a = memo(() => {
+		const a = computed(() => {
 			x.get()
 			return 'foo'
 		})
-		const b = memo(() => {
+		const b = computed(() => {
 			count++
 			return a.get()
 		})
@@ -206,12 +205,12 @@ describe('Computed', function () {
 		expect(count).toBe(2)
 	})
 
-	test('should block if result remains unchanged', function () {
+	test('should block if result remains unchanged', () => {
 		let count = 0
 		const x = state(42)
-		const a = memo(() => x.get() % 2)
-		const b = memo(() => (a.get() ? 'odd' : 'even'))
-		const c = memo(() => {
+		const a = computed(() => x.get() % 2)
+		const b = computed(() => (a.get() ? 'odd' : 'even'))
+		const c = computed(() => {
 			count++
 			return `c: ${b.get()}`
 		})
@@ -224,27 +223,27 @@ 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', () => {
 		const a = state(1)
-		const b = memo(() => c.get() + 1)
-		const c = memo(() => b.get() + a.get())
+		const b = computed(() => c.get() + 1)
+		const c = computed(() => b.get() + a.get())
 		expect(() => {
 			b.get() // This should trigger the circular dependency
-		}).toThrow('Circular dependency in memo detected')
+		}).toThrow('Circular dependency in computed detected')
 		expect(a.get()).toBe(1)
 	})
 
-	test('should propagate error if an error occurred', function () {
+	test('should propagate error if an error occurred', () => {
 		let okCount = 0
 		let errCount = 0
 		const x = state(0)
-		const a = memo(() => {
+		const a = computed(() => {
 			if (x.get() === 1) throw new Error('Calculation error')
 			return 1
 		})
 
 		// Replace matcher with try/catch in a computed
-		const b = memo(() => {
+		const b = computed(() => {
 			try {
 				a.get() // just check if it works
 				return `c: success`
@@ -253,7 +252,7 @@ describe('Computed', function () {
 				return `c: recovered`
 			}
 		})
-		const c = memo(() => {
+		const c = computed(() => {
 			okCount++
 			return b.get()
 		})
@@ -274,9 +273,9 @@ describe('Computed', function () {
 		}
 	})
 
-	test('should create an effect that reacts on async computed changes', async function () {
+	test('should create an effect that reacts on async computed changes', async () => {
 		const cause = state(42)
-		const derived = task(async () => {
+		const derived = computed(async () => {
 			await wait(100)
 			return cause.get() + 1
 		})
@@ -285,11 +284,11 @@ describe('Computed', function () {
 		let result: number = 0
 		effect({
 			signals: [derived],
-			ok: v => {
+			ok: (v): undefined => {
 				result = v
 				okCount++
 			},
-			nil: () => {
+			nil: (): undefined => {
 				nilCount++
 			},
 		})
@@ -304,13 +303,13 @@ 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 () => {
 		const toggleState = state(true)
-		const errorProne = memo(() => {
+		const errorProne = computed(() => {
 			if (toggleState.get()) throw new Error('Intentional error')
 			return 42
 		})
-		const asyncValue = task(async () => {
+		const asyncValue = computed(async () => {
 			await wait(50)
 			return 10
 		})
@@ -319,8 +318,7 @@ describe('Computed', function () {
 		let errCount = 0
 		// let _result: number = 0
 
-		// Replace matcher with try/catch in a computed
-		const complexComputed = memo(() => {
+		const complexComputed = computed(() => {
 			try {
 				const x = errorProne.get()
 				const y = asyncValue.get()
@@ -352,10 +350,10 @@ describe('Computed', function () {
 		expect(errCount).toBeGreaterThan(0)
 	})
 
-	test('should handle signal changes during async computation', async function () {
+	test('should handle signal changes during async computation', async () => {
 		const source = state(1)
 		let computationCount = 0
-		const derived = task(async abort => {
+		const derived = computed(async abort => {
 			computationCount++
 			expect(abort?.aborted).toBe(false)
 			await wait(100)
@@ -373,10 +371,10 @@ 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 () => {
 		const source = state(1)
 		let computationCount = 0
-		const derived = task(async abort => {
+		const derived = computed(async abort => {
 			computationCount++
 			expect(abort?.aborted).toBe(false)
 			await wait(100)
@@ -398,9 +396,9 @@ describe('Computed', function () {
 		expect(computationCount).toBe(1)
 	})
 
-	test('should handle errors in aborted computations', async function () {
+	test('should handle errors in aborted computations', async () => {
 		const source = state(1)
-		const derived = task(async () => {
+		const derived = computed(async () => {
 			await wait(100)
 			const value = source.get()
 			if (value === 2) throw new Error('Intentional error')

package/test/effect.test.ts

@@ -1,5 +1,5 @@
-import { describe, test, expect, mock } from 'bun:test'
-import { state, task, effect, UNSET, memo } from '../'
+import { describe, expect, mock, test } from 'bun:test'
+import { computed, effect, state, UNSET } from '../'
 
 /* === Utility Functions === */
 
@@ -7,11 +7,11 @@ const wait = (ms: number) => new Promise(resolve => setTimeout(resolve, ms))
 
 /* === Tests === */
 
-describe('Effect', function () {
-	test('should be triggered after a state change', function () {
+describe('Effect', () => {
+	test('should be triggered after a state change', () => {
 		const cause = state('foo')
 		let count = 0
-		effect(() => {
+		effect((): undefined => {
 			cause.get()
 			count++
 		})
@@ -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 = task(async () => {
+	test('should be triggered after computed async signals resolve without waterfalls', async () => {
+		const a = computed(async () => {
 			await wait(100)
 			return 10
 		})
-		const b = task(async () => {
+		const b = computed(async () => {
 			await wait(100)
 			return 20
 		})
@@ -33,7 +33,7 @@ describe('Effect', function () {
 		let count = 0
 		effect({
 			signals: [a, b],
-			ok: (aValue, bValue) => {
+			ok: (aValue, bValue): undefined => {
 				result = aValue + bValue
 				count++
 			},
@@ -45,11 +45,11 @@ 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 () => {
 		const cause = state(0)
 		let result = 0
 		let count = 0
-		effect(() => {
+		effect((): undefined => {
 			result = cause.get()
 			count++
 		})
@@ -60,9 +60,9 @@ describe('Effect', function () {
 		}
 	})
 
-	test('should handle errors in effects', function () {
+	test('should handle errors in effects', () => {
 		const a = state(1)
-		const b = memo(() => {
+		const b = computed(() => {
 			const v = a.get()
 			if (v > 5) throw new Error('Value too high')
 			return v * 2
@@ -71,11 +71,11 @@ describe('Effect', function () {
 		let errorCallCount = 0
 		effect({
 			signals: [b],
-			ok: () => {
+			ok: (): undefined => {
 				// console.log('Normal effect:', value)
 				normalCallCount++
 			},
-			err: error => {
+			err: (error: Error): undefined => {
 				// console.log('Error effect:', error)
 				errorCallCount++
 				expect(error.message).toBe('Value too high')
@@ -98,8 +98,8 @@ describe('Effect', function () {
 		expect(errorCallCount).toBe(1)
 	})
 
-	test('should handle UNSET values in effects', async function () {
-		const a = task(async () => {
+	test('should handle UNSET values in effects', async () => {
+		const a = computed(async () => {
 			await wait(100)
 			return 42
 		})
@@ -107,11 +107,11 @@ describe('Effect', function () {
 		let nilCount = 0
 		effect({
 			signals: [a],
-			ok: aValue => {
+			ok: (aValue: number): undefined => {
 				normalCallCount++
 				expect(aValue).toBe(42)
 			},
-			nil: () => {
+			nil: (): undefined => {
 				nilCount++
 			},
 		})
@@ -133,14 +133,14 @@ describe('Effect', function () {
 
 		try {
 			const a = state(1)
-			const b = memo(() => {
+			const b = computed(() => {
 				const v = a.get()
 				if (v > 5) throw new Error('Value too high')
 				return v * 2
 			})
 
 			// Create an effect without explicit error handling
-			effect(() => {
+			effect((): undefined => {
 				b.get()
 			})
 
@@ -164,7 +164,7 @@ describe('Effect', function () {
 		const count = state(42)
 		let received = 0
 
-		const cleanup = effect(() => {
+		const cleanup = effect((): undefined => {
 			received = count.get()
 		})
 
@@ -183,12 +183,12 @@ describe('Effect', function () {
 
 		effect({
 			signals: [count],
-			ok: () => {
+			ok: (): undefined => {
 				okCount++
 				// This effect updates the signal it depends on, creating a circular dependency
 				count.update(v => ++v)
 			},
-			err: e => {
+			err: (e): undefined => {
 				errCount++
 				expect(e).toBeInstanceOf(Error)
 				expect(e.message).toBe('Circular dependency in effect detected')