@zeix/cause-effect 0.17.3 → 0.18.0

package/test/signal.test.ts

@@ -1,274 +1,281 @@
 import { describe, expect, test } from 'bun:test'
 import {
-	type Computed,
+	createComputed,
+	createList,
+	createMemo,
+	createMutableSignal,
+	createScope,
 	createSignal,
+	createState,
+	createStore,
+	createTask,
+	InvalidSignalValueError,
 	isComputed,
 	isList,
+	isMemo,
+	isMutableSignal,
+	isSignal,
 	isState,
 	isStore,
+	isTask,
 	type List,
+	type Memo,
 	type Signal,
-	State,
+	type State,
 	type Store,
-	type UnknownRecord,
+	type Task,
 } from '../index.ts'
 
 /* === Tests === */
 
-describe('createSignal', () => {
-	describe('type inference and runtime behavior', () => {
-		test('converts array to List<T>', () => {
-			const result = createSignal([
-				{ id: 1, name: 'Alice' },
-				{ id: 2, name: 'Bob' },
-			])
-
-			// Runtime behavior
-			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 List<{ id: number; name: string }>
-			const typedResult: List<{ id: number; name: string }> = result
-			expect(typedResult).toBeDefined()
-		})
+describe('createComputed', () => {
+	test('creates a Memo from a sync callback', () => {
+		const count = createState(2)
+		const doubled = createComputed(() => count.get() * 2)
+		expect(isMemo(doubled)).toBe(true)
+		expect(doubled.get()).toBe(4)
+
+		const typedResult: Memo<number> = doubled
+		expect(typedResult).toBeDefined()
+	})
 
-		test('converts empty array to ArrayStore<never[]>', () => {
-			const result = createSignal([])
+	test('creates a Task from an async callback', () => {
+		const cleanup = createScope(() => {
+			const result = createComputed(async () => 'hello')
+			expect(isTask(result)).toBe(true)
 
-			// Runtime behavior
-			expect(isList(result)).toBe(true)
-			expect(result.length).toBe(0)
-			expect(Object.keys(result).length).toBe(0)
+			const typedResult: Task<string> = result
+			expect(typedResult).toBeDefined()
 		})
+		cleanup()
+	})
+})
 
-		test('converts record to Store<T>', () => {
-			const record = { name: 'Alice', age: 30 }
-			const result = createSignal(record)
+describe('createSignal', () => {
+	test('converts a primitive to State', () => {
+		const result = createSignal(42)
+		expect(isState(result)).toBe(true)
+		expect(result.get()).toBe(42)
 
-			// Runtime behavior
-			expect(isStore(result)).toBe(true)
-			expect(result.name.get()).toBe('Alice')
-			expect(result.age.get()).toBe(30)
+		const typedResult: State<number> = result
+		expect(typedResult).toBeDefined()
+	})
 
-			// Type inference test - should be Store<{name: string, age: number}>
-			const typedResult: Store<{ name: string; age: number }> = result
-			expect(typedResult).toBeDefined()
-		})
+	test('converts a non-plain object to State', () => {
+		const date = new Date('2024-01-01')
+		const result = createSignal(date)
+		expect(isState(result)).toBe(true)
+		expect(result.get()).toBe(date)
 
-		test('converts function to Computed<T>', () => {
-			const fn = () => Math.random()
-			const result = createSignal(fn)
+		const typedResult: State<Date> = result
+		expect(typedResult).toBeDefined()
+	})
 
-			// Runtime behavior - functions are correctly converted to Computed
-			expect(isComputed(result)).toBe(true)
-			expect(typeof result.get()).toBe('number')
+	test('converts a record to Store', () => {
+		const result = createSignal({ name: 'Alice', age: 30 })
+		expect(isStore(result)).toBe(true)
+		expect(result.name.get()).toBe('Alice')
+		expect(result.age.get()).toBe(30)
 
-			// Type inference test - should be Computed<number>
-			const typedResult: Computed<number> = result
-			expect(typedResult).toBeDefined()
-		})
+		const typedResult: Store<{ name: string; age: number }> = result
+		expect(typedResult).toBeDefined()
+	})
 
-		test('converts primitive to State<T>', () => {
-			const num = 42
-			const result = createSignal(num)
+	test('converts an array to List', () => {
+		const result = createSignal([
+			{ id: 1, name: 'Alice' },
+			{ 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' })
+
+		const typedResult: List<{ id: number; name: string }> = result
+		expect(typedResult).toBeDefined()
+	})
 
-			// Runtime behavior - primitives are correctly converted to State
-			expect(isState(result)).toBe(true)
-			expect(result.get()).toBe(42)
+	test('converts an empty array to List', () => {
+		const result = createSignal([])
+		expect(isList(result)).toBe(true)
+		expect(result.length).toBe(0)
+	})
 
-			// Type inference test - should be State<number>
-			const typedResult: State<number> = result
-			expect(typedResult).toBeDefined()
-		})
+	test('converts a sync function to Memo', () => {
+		const result = createSignal(() => Math.random())
+		expect(isMemo(result)).toBe(true)
+		expect(typeof result.get()).toBe('number')
 
-		test('converts object to State<T>', () => {
-			const obj = new Date('2024-01-01')
-			const result = createSignal(obj)
+		const typedResult: Memo<number> = result
+		expect(typedResult).toBeDefined()
+	})
 
-			// Runtime behavior - objects are correctly converted to State
-			expect(isState(result)).toBe(true)
-			expect(result.get()).toBe(obj)
+	test('converts an async function to Task', () => {
+		const cleanup = createScope(() => {
+			const result = createSignal(async () => 'hello')
+			expect(isTask(result)).toBe(true)
 
-			// Type inference test - should be State<Date>
-			const typedResult: State<Date> = result
+			const typedResult: Task<string> = result
 			expect(typedResult).toBeDefined()
 		})
+		cleanup()
 	})
 
-	describe('edge cases', () => {
-		test('handles nested arrays', () => {
-			const result = createSignal([
-				[1, 2],
-				[3, 4],
-			])
-
-			expect(isList(result)).toBe(true)
-			// With the fixed behavior, nested arrays should be recovered as arrays
-			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])
-			expect(secondElement).toEqual([3, 4])
-		})
+	test('passes through an existing signal without wrapping', () => {
+		const state = createState(42)
+		expect(createSignal(state)).toBe(state)
 
-		test('handles arrays with mixed types', () => {
-			const mixedArr = [1, 'hello', { key: 'value' }]
-			const result = createSignal(mixedArr)
+		const memo = createMemo(() => 'hello')
+		expect(createSignal(memo)).toBe(memo)
 
-			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' })
-		})
+		const store = createStore({ a: 1 })
+		expect(createSignal(store)).toBe(store)
+
+		const list = createList([1, 2, 3])
+		expect(createSignal(list)).toBe(list)
 	})
-})
 
-describe('Signal compatibility', () => {
-	test('all results implement Signal<T> interface', () => {
-		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')
-		expect(typeof recordSignal.get).toBe('function')
-		expect(typeof primitiveSignal.get).toBe('function')
-		expect(typeof functionSignal.get).toBe('function')
-		expect(typeof stateSignal.get).toBe('function')
-
-		// All should be assignable to Signal<T>
-		const signals: Signal<unknown & {}>[] = [
-			arraySignal,
-			recordSignal,
-			primitiveSignal,
-			functionSignal,
-			stateSignal,
-		]
-		expect(signals.length).toBe(5)
+	test('throws InvalidSignalValueError for null', () => {
+		// biome-ignore lint/suspicious/noExplicitAny: testing invalid input
+		expect(() => createSignal(null as any)).toThrow(InvalidSignalValueError)
+	})
+
+	test('throws InvalidSignalValueError for undefined', () => {
+		// biome-ignore lint/suspicious/noExplicitAny: testing invalid input
+		expect(() => createSignal(undefined as any)).toThrow(
+			InvalidSignalValueError,
+		)
 	})
 })
 
-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 = createSignal(stringArray)
+describe('createMutableSignal', () => {
+	test('converts a primitive to State', () => {
+		const result = createMutableSignal(42)
+		expect(isState(result)).toBe(true)
+		expect(result.get()).toBe(42)
+	})
+
+	test('converts a record to Store', () => {
+		const result = createMutableSignal({ name: 'Alice' })
+		expect(isStore(result)).toBe(true)
+	})
+
+	test('converts an array to List', () => {
+		const result = createMutableSignal([1, 2, 3])
+		expect(isList(result)).toBe(true)
+	})
 
-		// Should be List<string>
-		expect(stringArraySignal.at(0)?.get()).toBe('a')
+	test('passes through an existing mutable signal without wrapping', () => {
+		const state = createState(42)
+		expect(createMutableSignal(state)).toBe(state)
 
-		const numberArray = [1, 2, 3]
-		const numberArraySignal = createSignal(numberArray)
+		const store = createStore({ a: 1 })
+		expect(createMutableSignal(store)).toBe(store)
 
-		// Should be List<number>
-		expect(typeof numberArraySignal.at(0)?.get()).toBe('number')
+		const list = createList([1, 2, 3])
+		expect(createMutableSignal(list)).toBe(list)
 	})
 
-	test('complex object arrays maintain precise typing', () => {
-		interface User {
-			id: number
-			name: string
-			email: string
-		}
-
-		const users: User[] = [
-			{ id: 1, name: 'Alice', email: 'alice@example.com' },
-			{ id: 2, name: 'Bob', email: 'bob@example.com' },
-		]
-
-		const usersSignal = createSignal(users)
-
-		// Should maintain User type for each element
-		const firstUser = usersSignal.at(0)?.get()
-		expect(firstUser?.id).toBe(1)
-		expect(firstUser?.name).toBe('Alice')
-		expect(firstUser?.email).toBe('alice@example.com')
+	test('throws InvalidSignalValueError for null', () => {
+		// biome-ignore lint/suspicious/noExplicitAny: testing invalid input
+		expect(() => createMutableSignal(null as any)).toThrow(
+			InvalidSignalValueError,
+		)
 	})
 
-	describe('Type inference issues', () => {
-		test('demonstrates current type inference problem', () => {
-			const result = createSignal([{ id: 1 }, { id: 2 }])
+	test('throws InvalidSignalValueError for a function', () => {
+		// biome-ignore lint/suspicious/noExplicitAny: testing invalid input
+		expect(() => createMutableSignal((() => 42) as any)).toThrow(
+			InvalidSignalValueError,
+		)
+	})
 
-			// Let's verify the actual behavior
-			expect(isList(result)).toBe(true)
-			expect(result.at(0)?.get()).toEqual({ id: 1 })
-			expect(result.at(1)?.get()).toEqual({ id: 2 })
+	test('throws InvalidSignalValueError for a read-only signal', () => {
+		const memo = createMemo(() => 42)
+		// biome-ignore lint/suspicious/noExplicitAny: testing invalid input
+		expect(() => createMutableSignal(memo as any)).toThrow(
+			InvalidSignalValueError,
+		)
+	})
+})
 
-			// Type assertion test - this should now work with correct typing
-			const typedResult: List<{ id: number }> = result
-			expect(typedResult).toBeDefined()
+describe('isComputed', () => {
+	test('returns true for Memo', () => {
+		expect(isComputed(createMemo(() => 42))).toBe(true)
+	})
 
-			// 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
-			}
+	test('returns true for Task', () => {
+		const cleanup = createScope(() => {
+			expect(isComputed(createTask(async () => 42))).toBe(true)
+		})
+		cleanup()
+	})
 
-			// This should work if types are correct
-			const processor: ExternalLibraryConstraint<
-				Record<string, { id: number }>
-			> = {
-				process: <K extends keyof Record<string, { id: number }>>(
-					signal: Signal<Record<string, { id: number }>[K] & {}>,
-				) => {
-					// Process the signal
-					const value = signal.get()
-					expect(value).toHaveProperty('id')
-				},
-			}
+	test('returns false for State', () => {
+		expect(isComputed(createState(42))).toBe(false)
+	})
+
+	test('returns false for non-signals', () => {
+		expect(isComputed(42)).toBe(false)
+		expect(isComputed('hello')).toBe(false)
+		expect(isComputed(null)).toBe(false)
+	})
+})
 
-			// This call should work without type errors
-			const item = result.at(0)
-			if (item) processor.process(item)
+describe('isSignal', () => {
+	test('returns true for all signal types', () => {
+		const cleanup = createScope(() => {
+			expect(isSignal(createState(42))).toBe(true)
+			expect(isSignal(createMemo(() => 42))).toBe(true)
+			expect(isSignal(createTask(async () => 42))).toBe(true)
+			expect(isSignal(createStore({ a: 1 }))).toBe(true)
+			expect(isSignal(createList([1, 2, 3]))).toBe(true)
 		})
+		cleanup()
+	})
 
-		test('verifies fixed type inference for external library compatibility', () => {
-			const items = [
-				{ id: 1, name: 'Alice' },
-				{ id: 2, name: 'Bob' },
-			]
-			const signal = createSignal(items)
-			const firstItemSignal = signal.at(0)
-			const secondItemSignal = signal.at(1)
-
-			// Runtime behavior works correctly
-			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: 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 Record<string, object>> {
-				process<K extends keyof P>(
-					key: K,
-					signal: Signal<P[K] & object>,
-				): P[K]
-			}
+	test('returns false for non-signals', () => {
+		expect(isSignal(42)).toBe(false)
+		expect(isSignal('hello')).toBe(false)
+		expect(isSignal({ get: () => 42 })).toBe(false)
+		expect(isSignal(null)).toBe(false)
+		expect(isSignal(undefined)).toBe(false)
+	})
+})
 
-			const api: ExternalAPI<
-				Record<string, { id: number; name: string }>
-			> = {
-				process: (_key, signal) => signal.get(),
-			}
+describe('isMutableSignal', () => {
+	test('returns true for State, Store, and List', () => {
+		expect(isMutableSignal(createState(42))).toBe(true)
+		expect(isMutableSignal(createStore({ a: 1 }))).toBe(true)
+		expect(isMutableSignal(createList([1, 2, 3]))).toBe(true)
+	})
 
-			// These calls should work with proper typing now
-			const result1 = firstItemSignal && api.process('0', firstItemSignal)
-			const result2 =
-				secondItemSignal && api.process('1', secondItemSignal)
+	test('returns false for read-only signals', () => {
+		const cleanup = createScope(() => {
+			expect(isMutableSignal(createMemo(() => 42))).toBe(false)
+			expect(isMutableSignal(createTask(async () => 42))).toBe(false)
+		})
+		cleanup()
+	})
 
-			expect(result1).toEqual({ id: 1, name: 'Alice' })
-			expect(result2).toEqual({ id: 2, name: 'Bob' })
+	test('returns false for non-signals', () => {
+		expect(isMutableSignal(42)).toBe(false)
+		expect(isMutableSignal(null)).toBe(false)
+	})
+})
 
-			// Verify the types are precise
-			expect(typeof result1?.id).toBe('number')
-			expect(typeof result1?.name).toBe('string')
+describe('Signal compatibility', () => {
+	test('all signal factory results implement Signal<T>', () => {
+		const cleanup = createScope(() => {
+			const signals: Signal<unknown & {}>[] = [
+				createSignal(42),
+				createSignal({ a: 1 }),
+				createSignal([1, 2, 3]),
+				createSignal(() => 'hello'),
+			]
+			for (const signal of signals) {
+				expect(typeof signal.get).toBe('function')
+			}
 		})
+		cleanup()
 	})
 })