@zeix/cause-effect 0.16.1 → 0.17.0

package/test/match.test.ts

@@ -1,12 +1,12 @@
 import { describe, expect, test } from 'bun:test'
-import { createComputed, createState, match, resolve, UNSET } from '..'
+import { Memo, match, resolve, State, Task, UNSET } from '../index.ts'
 
 /* === Tests === */
 
 describe('Match Function', () => {
 	test('should call ok handler for successful resolution', () => {
-		const a = createState(10)
-		const b = createState('hello')
+		const a = new State(10)
+		const b = new State('hello')
 		let okCalled = false
 		let okValues: { a: number; b: string } | null = null
 
@@ -32,8 +32,8 @@ describe('Match Function', () => {
 	})
 
 	test('should call nil handler for pending signals', () => {
-		const a = createState(10)
-		const b = createState(UNSET)
+		const a = new State(10)
+		const b = new State(UNSET)
 		let nilCalled = false
 
 		match(resolve({ a, b }), {
@@ -52,8 +52,8 @@ describe('Match Function', () => {
 	})
 
 	test('should call error handler for error signals', () => {
-		const a = createState(10)
-		const b = createComputed(() => {
+		const a = new State(10)
+		const b = new Memo(() => {
 			throw new Error('Test error')
 		})
 		let errCalled = false
@@ -78,7 +78,7 @@ describe('Match Function', () => {
 	})
 
 	test('should handle missing optional handlers gracefully', () => {
-		const a = createState(10)
+		const a = new State(10)
 		const result = resolve({ a })
 
 		// Should not throw even with only required ok handler (err and nil are optional)
@@ -92,7 +92,7 @@ describe('Match Function', () => {
 	})
 
 	test('should return void always', () => {
-		const a = createState(42)
+		const a = new State(42)
 
 		const returnValue = match(resolve({ a }), {
 			ok: () => {
@@ -105,7 +105,7 @@ describe('Match Function', () => {
 	})
 
 	test('should handle handler errors by calling error handler', () => {
-		const a = createState(10)
+		const a = new State(10)
 		let handlerErrorCalled = false
 		let handlerError: Error | null = null
 
@@ -125,7 +125,7 @@ describe('Match Function', () => {
 	})
 
 	test('should rethrow handler errors if no error handler available', () => {
-		const a = createState(10)
+		const a = new State(10)
 
 		expect(() => {
 			match(resolve({ a }), {
@@ -137,7 +137,7 @@ describe('Match Function', () => {
 	})
 
 	test('should combine existing errors with handler errors', () => {
-		const a = createComputed(() => {
+		const a = new Memo(() => {
 			throw new Error('Signal error')
 		})
 		let allErrors: readonly Error[] | null = null
@@ -167,9 +167,9 @@ describe('Match Function', () => {
 	})
 
 	test('should work with complex type inference', () => {
-		const user = createState({ id: 1, name: 'Alice' })
-		const posts = createState([{ id: 1, title: 'Hello' }])
-		const settings = createState({ theme: 'dark' })
+		const user = new State({ id: 1, name: 'Alice' })
+		const posts = new State([{ id: 1, title: 'Hello' }])
+		const settings = new State({ theme: 'dark' })
 
 		let typeTestPassed = false
 
@@ -194,8 +194,8 @@ describe('Match Function', () => {
 	})
 
 	test('should handle side effects only pattern', () => {
-		const count = createState(5)
-		const name = createState('test')
+		const count = new State(5)
+		const name = new State('test')
 		let sideEffectExecuted = false
 		let capturedData = ''
 
@@ -214,10 +214,10 @@ describe('Match Function', () => {
 	})
 
 	test('should handle multiple error types correctly', () => {
-		const error1 = createComputed(() => {
+		const error1 = new Memo(() => {
 			throw new Error('First error')
 		})
-		const error2 = createComputed(() => {
+		const error2 = new Memo(() => {
 			throw new Error('Second error')
 		})
 		let errorMessages: string[] = []
@@ -240,7 +240,7 @@ describe('Match Function', () => {
 		const wait = (ms: number) =>
 			new Promise(resolve => setTimeout(resolve, ms))
 
-		const asyncSignal = createComputed(async () => {
+		const asyncSignal = new Task(async () => {
 			await wait(10)
 			return 'async result'
 		})
@@ -280,7 +280,7 @@ describe('Match Function', () => {
 	})
 
 	test('should maintain referential transparency', () => {
-		const a = createState(42)
+		const a = new State(42)
 		const result = resolve({ a })
 		let callCount = 0
 
@@ -303,7 +303,7 @@ describe('Match Function', () => {
 
 describe('Match Function Integration', () => {
 	test('should work seamlessly with resolve', () => {
-		const data = createState({ id: 1, value: 'test' })
+		const data = new State({ id: 1, value: 'test' })
 		let processed = false
 		let processedValue = ''
 
@@ -322,12 +322,12 @@ describe('Match Function Integration', () => {
 		const wait = (ms: number) =>
 			new Promise(resolve => setTimeout(resolve, ms))
 
-		const syncData = createState('available')
-		const asyncData = createComputed(async () => {
+		const syncData = new State('available')
+		const asyncData = new Task(async () => {
 			await wait(10)
 			return 'loaded'
 		})
-		const errorData = createComputed(() => {
+		const errorData = new Memo(() => {
 			throw new Error('Failed to load')
 		})
 

package/test/resolve.test.ts

@@ -1,12 +1,12 @@
 import { describe, expect, test } from 'bun:test'
-import { createComputed, createState, resolve, UNSET } from '..'
+import { Memo, resolve, State, Task, UNSET } from '../index.ts'
 
 /* === Tests === */
 
 describe('Resolve Function', () => {
 	test('should return discriminated union for successful resolution', () => {
-		const a = createState(10)
-		const b = createState('hello')
+		const a = new State(10)
+		const b = new State('hello')
 
 		const result = resolve({ a, b })
 
@@ -20,8 +20,8 @@ describe('Resolve Function', () => {
 	})
 
 	test('should return discriminated union for pending signals', () => {
-		const a = createState(10)
-		const b = createState(UNSET)
+		const a = new State(10)
+		const b = new State(UNSET)
 
 		const result = resolve({ a, b })
 
@@ -32,8 +32,8 @@ describe('Resolve Function', () => {
 	})
 
 	test('should return discriminated union for error signals', () => {
-		const a = createState(10)
-		const b = createComputed(() => {
+		const a = new State(10)
+		const b = new Memo(() => {
 			throw new Error('Test error')
 		})
 
@@ -49,11 +49,11 @@ describe('Resolve Function', () => {
 	})
 
 	test('should handle mixed error and valid signals', () => {
-		const valid = createState('valid')
-		const error1 = createComputed(() => {
+		const valid = new State('valid')
+		const error1 = new Memo(() => {
 			throw new Error('Error 1')
 		})
-		const error2 = createComputed(() => {
+		const error2 = new Memo(() => {
 			throw new Error('Error 2')
 		})
 
@@ -69,8 +69,8 @@ describe('Resolve Function', () => {
 	})
 
 	test('should prioritize pending over errors', () => {
-		const pending = createState(UNSET)
-		const error = createComputed(() => {
+		const pending = new State(UNSET)
+		const error = new Memo(() => {
 			throw new Error('Test error')
 		})
 
@@ -91,8 +91,8 @@ describe('Resolve Function', () => {
 	})
 
 	test('should handle complex nested object signals', () => {
-		const user = createState({ name: 'Alice', age: 25 })
-		const settings = createState({ theme: 'dark', lang: 'en' })
+		const user = new State({ name: 'Alice', age: 25 })
+		const settings = new State({ theme: 'dark', lang: 'en' })
 
 		const result = resolve({ user, settings })
 
@@ -109,7 +109,7 @@ describe('Resolve Function', () => {
 		const wait = (ms: number) =>
 			new Promise(resolve => setTimeout(resolve, ms))
 
-		const asyncSignal = createComputed(async () => {
+		const asyncSignal = new Task(async () => {
 			await wait(10)
 			return 'async result'
 		})
@@ -124,16 +124,14 @@ describe('Resolve Function', () => {
 
 		result = resolve({ asyncSignal })
 		expect(result.ok).toBe(true)
-		if (result.ok) {
-			expect(result.values.asyncSignal).toBe('async result')
-		}
+		if (result.ok) expect(result.values.asyncSignal).toBe('async result')
 	})
 
 	test('should handle async computed signals that error', async () => {
 		const wait = (ms: number) =>
 			new Promise(resolve => setTimeout(resolve, ms))
 
-		const asyncError = createComputed(async () => {
+		const asyncError = new Task(async () => {
 			await wait(10)
 			throw new Error('Async error')
 		})

package/test/signal.test.ts

@@ -1,51 +1,50 @@
 import { describe, expect, test } from 'bun:test'
 import {
 	type Computed,
-	createComputed,
-	createState,
-	createStore,
+	createSignal,
 	isComputed,
+	isList,
 	isState,
 	isStore,
+	type List,
 	type Signal,
-	type State,
+	State,
 	type Store,
-	toSignal,
 	type UnknownRecord,
-} from '..'
+} from '../index.ts'
 
 /* === Tests === */
 
-describe('toSignal', () => {
+describe('createSignal', () => {
 	describe('type inference and runtime behavior', () => {
-		test('converts array to Store<Record<string, T>>', () => {
-			const result = toSignal([
+		test('converts array to List<T>', () => {
+			const result = createSignal([
 				{ id: 1, name: 'Alice' },
 				{ id: 2, name: 'Bob' },
 			])
 
 			// Runtime behavior
-			expect(isStore(result)).toBe(true)
-			expect(result['0'].get()).toEqual({ id: 1, name: 'Alice' })
-			expect(result['1'].get()).toEqual({ id: 2, name: 'Bob' })
+			expect(isList(result)).toBe(true)
+			expect(result.at(0)?.get()).toEqual({ id: 1, name: 'Alice' })
+			expect(result.at(1)?.get()).toEqual({ id: 2, name: 'Bob' })
 
-			// Type inference test - now correctly returns Store<Record<number, {id: number, name: string}>>
-			const typedResult: Store<{ id: number; name: string }[]> = result
+			// Type inference test - now correctly returns List<{ id: number; name: string }>
+			const typedResult: List<{ id: number; name: string }> = result
 			expect(typedResult).toBeDefined()
 		})
 
 		test('converts empty array to ArrayStore<never[]>', () => {
-			const result = toSignal([])
+			const result = createSignal([])
 
 			// Runtime behavior
-			expect(isStore(result)).toBe(true)
+			expect(isList(result)).toBe(true)
 			expect(result.length).toBe(0)
 			expect(Object.keys(result).length).toBe(0)
 		})
 
 		test('converts record to Store<T>', () => {
 			const record = { name: 'Alice', age: 30 }
-			const result = toSignal(record)
+			const result = createSignal(record)
 
 			// Runtime behavior
 			expect(isStore(result)).toBe(true)
@@ -57,51 +56,9 @@ describe('toSignal', () => {
 			expect(typedResult).toBeDefined()
 		})
 
-		test('passes through existing Store unchanged', () => {
-			const originalStore = createStore({ count: 5 })
-			const result = toSignal(originalStore)
-
-			// Runtime behavior
-			expect(result).toBe(originalStore) // Should be the same instance
-			expect(isStore(result)).toBe(true)
-			expect(result.count.get()).toBe(5)
-
-			// Type inference test - should remain Store<{count: number}>
-			const typedResult: Store<{ count: number }> = result
-			expect(typedResult).toBeDefined()
-		})
-
-		test('passes through existing State unchanged', () => {
-			const originalState = createState(42)
-			const result = toSignal(originalState)
-
-			// Runtime behavior
-			expect(result).toBe(originalState) // Should be the same instance
-			expect(isState(result)).toBe(true)
-			expect(result.get()).toBe(42)
-
-			// Type inference test - should remain State<number>
-			const typedResult: State<number> = result
-			expect(typedResult).toBeDefined()
-		})
-
-		test('passes through existing Computed unchanged', () => {
-			const originalComputed = createComputed(() => 'hello world')
-			const result = toSignal(originalComputed)
-
-			// Runtime behavior
-			expect(result).toBe(originalComputed) // Should be the same instance
-			expect(isComputed(result)).toBe(true)
-			expect(result.get()).toBe('hello world')
-
-			// Type inference test - should remain Computed<string>
-			const typedResult: Computed<string> = result
-			expect(typedResult).toBeDefined()
-		})
-
 		test('converts function to Computed<T>', () => {
 			const fn = () => Math.random()
-			const result = toSignal(fn)
+			const result = createSignal(fn)
 
 			// Runtime behavior - functions are correctly converted to Computed
 			expect(isComputed(result)).toBe(true)
@@ -114,7 +71,7 @@ describe('toSignal', () => {
 
 		test('converts primitive to State<T>', () => {
 			const num = 42
-			const result = toSignal(num)
+			const result = createSignal(num)
 
 			// Runtime behavior - primitives are correctly converted to State
 			expect(isState(result)).toBe(true)
@@ -127,7 +84,7 @@ describe('toSignal', () => {
 
 		test('converts object to State<T>', () => {
 			const obj = new Date('2024-01-01')
-			const result = toSignal(obj)
+			const result = createSignal(obj)
 
 			// Runtime behavior - objects are correctly converted to State
 			expect(isState(result)).toBe(true)
@@ -141,15 +98,15 @@ describe('toSignal', () => {
 
 	describe('edge cases', () => {
 		test('handles nested arrays', () => {
-			const result = toSignal([
+			const result = createSignal([
 				[1, 2],
 				[3, 4],
 			])
 
-			expect(isStore(result)).toBe(true)
+			expect(isList(result)).toBe(true)
 			// With the fixed behavior, nested arrays should be recovered as arrays
-			const firstElement = result[0].get()
-			const secondElement = result[1].get()
+			const firstElement = result.at(0)?.get()
+			const secondElement = result.at(1)?.get()
 
 			// The expected behavior - nested arrays are recovered as arrays
 			expect(firstElement).toEqual([1, 2])
@@ -158,34 +115,23 @@ describe('toSignal', () => {
 
 		test('handles arrays with mixed types', () => {
 			const mixedArr = [1, 'hello', { key: 'value' }]
-			const result = toSignal(mixedArr)
-
-			expect(isStore(result)).toBe(true)
-			expect(result['0'].get()).toBe(1)
-			expect(result['1'].get()).toBe('hello')
-			expect(result['2'].get()).toEqual({ key: 'value' })
-		})
-
-		test('handles sparse arrays', () => {
-			const sparseArr = new Array(3)
-			sparseArr[1] = 'middle'
-			const result = toSignal(sparseArr)
+			const result = createSignal(mixedArr)
 
-			expect(isStore(result)).toBe(true)
-			expect('0' in result).toBe(false)
-			expect(result['1'].get()).toBe('middle')
-			expect('2' in result).toBe(false)
+			expect(isList(result)).toBe(true)
+			expect(result.at(0)?.get()).toBe(1)
+			expect(result.at(1)?.get()).toBe('hello')
+			expect(result.at(2)?.get()).toEqual({ key: 'value' })
 		})
 	})
 })
 
 describe('Signal compatibility', () => {
 	test('all results implement Signal<T> interface', () => {
-		const arraySignal = toSignal([1, 2, 3])
-		const recordSignal = toSignal({ a: 1, b: 2 })
-		const primitiveSignal = toSignal(42)
-		const functionSignal = toSignal(() => 'hello')
-		const stateSignal = toSignal(createState(true))
+		const arraySignal = createSignal([1, 2, 3])
+		const recordSignal = createSignal({ a: 1, b: 2 })
+		const primitiveSignal = createSignal(42)
+		const functionSignal = createSignal(() => 'hello')
+		const stateSignal = createSignal(new State(true))
 
 		// All should have get() method
 		expect(typeof arraySignal.get).toBe('function')
@@ -210,16 +156,16 @@ describe('Type precision tests', () => {
 	test('array type should infer element type correctly', () => {
 		// Test that arrays infer the correct element type
 		const stringArray = ['a', 'b', 'c']
-		const stringArraySignal = toSignal(stringArray)
+		const stringArraySignal = createSignal(stringArray)
 
-		// Should be Store<Record<string, string>>
-		expect(stringArraySignal['0'].get()).toBe('a')
+		// Should be List<string>
+		expect(stringArraySignal.at(0)?.get()).toBe('a')
 
 		const numberArray = [1, 2, 3]
-		const numberArraySignal = toSignal(numberArray)
+		const numberArraySignal = createSignal(numberArray)
 
-		// Should be Store<Record<string, number>>
-		expect(typeof numberArraySignal['0'].get()).toBe('number')
+		// Should be List<number>
+		expect(typeof numberArraySignal.at(0)?.get()).toBe('number')
 	})
 
 	test('complex object arrays maintain precise typing', () => {
@@ -234,31 +180,31 @@ describe('Type precision tests', () => {
 			{ id: 2, name: 'Bob', email: 'bob@example.com' },
 		]
 
-		const usersSignal = toSignal(users)
+		const usersSignal = createSignal(users)
 
 		// Should maintain User type for each element
-		const firstUser = usersSignal['0'].get()
-		expect(firstUser.id).toBe(1)
-		expect(firstUser.name).toBe('Alice')
-		expect(firstUser.email).toBe('alice@example.com')
+		const firstUser = usersSignal.at(0)?.get()
+		expect(firstUser?.id).toBe(1)
+		expect(firstUser?.name).toBe('Alice')
+		expect(firstUser?.email).toBe('alice@example.com')
 	})
 
 	describe('Type inference issues', () => {
 		test('demonstrates current type inference problem', () => {
-			const result = toSignal([{ id: 1 }, { id: 2 }])
+			const result = createSignal([{ id: 1 }, { id: 2 }])
 
 			// Let's verify the actual behavior
-			expect(isStore(result)).toBe(true)
-			expect(result['0'].get()).toEqual({ id: 1 })
-			expect(result['1'].get()).toEqual({ id: 2 })
+			expect(isList(result)).toBe(true)
+			expect(result.at(0)?.get()).toEqual({ id: 1 })
+			expect(result.at(1)?.get()).toEqual({ id: 2 })
 
 			// Type assertion test - this should now work with correct typing
-			const typedResult: Store<{ id: number }[]> = result
+			const typedResult: List<{ id: number }> = result
 			expect(typedResult).toBeDefined()
 
 			// Simulate external library usage where P[K] represents element type
 			interface ExternalLibraryConstraint<P extends UnknownRecord> {
-				process<K extends keyof P>(signal: Signal<P[K]>): void
+				process<K extends keyof P>(signal: Signal<P[K] & {}>): void
 			}
 
 			// This should work if types are correct
@@ -266,7 +212,7 @@ describe('Type precision tests', () => {
 				Record<string, { id: number }>
 			> = {
 				process: <K extends keyof Record<string, { id: number }>>(
-					signal: Signal<Record<string, { id: number }>[K]>,
+					signal: Signal<Record<string, { id: number }>[K] & {}>,
 				) => {
 					// Process the signal
 					const value = signal.get()
@@ -275,7 +221,8 @@ describe('Type precision tests', () => {
 			}
 
 			// This call should work without type errors
-			processor.process(result['0'])
+			const item = result.at(0)
+			if (item) processor.process(item)
 		})
 
 		test('verifies fixed type inference for external library compatibility', () => {
@@ -283,23 +230,26 @@ describe('Type precision tests', () => {
 				{ id: 1, name: 'Alice' },
 				{ id: 2, name: 'Bob' },
 			]
-			const signal = toSignal(items)
-			const firstItemSignal = signal['0']
-			const secondItemSignal = signal['1']
+			const signal = createSignal(items)
+			const firstItemSignal = signal.at(0)
+			const secondItemSignal = signal.at(1)
 
 			// Runtime behavior works correctly
-			expect(isStore(signal)).toBe(true)
-			expect(firstItemSignal.get()).toEqual({ id: 1, name: 'Alice' })
-			expect(secondItemSignal.get()).toEqual({ id: 2, name: 'Bob' })
+			expect(isList(signal)).toBe(true)
+			expect(firstItemSignal?.get()).toEqual({ id: 1, name: 'Alice' })
+			expect(secondItemSignal?.get()).toEqual({ id: 2, name: 'Bob' })
 
 			// Type inference should now work correctly:
-			const properlyTyped: Store<{ id: number; name: string }[]> = signal
+			const properlyTyped: List<{ id: number; name: string }> = signal
 			expect(properlyTyped).toBeDefined()
 
 			// These should work without type errors in external libraries
 			// that expect Signal<P[K]> where P[K] is the individual element type
-			interface ExternalAPI<P extends UnknownRecord> {
-				process<K extends keyof P>(key: K, signal: Signal<P[K]>): P[K]
+			interface ExternalAPI<P extends Record<string, object>> {
+				process<K extends keyof P>(
+					key: K,
+					signal: Signal<P[K] & object>,
+				): P[K]
 			}
 
 			const api: ExternalAPI<
@@ -309,15 +259,16 @@ describe('Type precision tests', () => {
 			}
 
 			// These calls should work with proper typing now
-			const result1 = api.process('0', firstItemSignal)
-			const result2 = api.process('1', secondItemSignal)
+			const result1 = firstItemSignal && api.process('0', firstItemSignal)
+			const result2 =
+				secondItemSignal && api.process('1', secondItemSignal)
 
 			expect(result1).toEqual({ id: 1, name: 'Alice' })
 			expect(result2).toEqual({ id: 2, name: 'Bob' })
 
 			// Verify the types are precise
-			expect(typeof result1.id).toBe('number')
-			expect(typeof result1.name).toBe('string')
+			expect(typeof result1?.id).toBe('number')
+			expect(typeof result1?.name).toBe('string')
 		})
 	})
 })