@zeix/cause-effect 0.15.1 → 0.16.0

package/test/signal.test.ts

@@ -1,16 +1,15 @@
 import { describe, expect, test } from 'bun:test'
 import {
 	type Computed,
-	computed,
+	createComputed,
+	createState,
+	createStore,
 	isComputed,
 	isState,
 	isStore,
 	type Signal,
 	type State,
 	type Store,
-	state,
-	store,
-	toMutableSignal,
 	toSignal,
 	type UnknownRecord,
 } from '..'
@@ -20,31 +19,28 @@ import {
 describe('toSignal', () => {
 	describe('type inference and runtime behavior', () => {
 		test('converts array to Store<Record<string, T>>', () => {
-			const arr = [
+			const result = toSignal([
 				{ id: 1, name: 'Alice' },
 				{ id: 2, name: 'Bob' },
-			]
-			const result = toSignal(arr)
+			])
 
 			// 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' })
 
-			// Type inference test - now correctly returns Store<Record<string, {id: number, name: string}>>
-			const typedResult: Store<
-				Record<string, { id: number; name: string }>
-			> = result
+			// Type inference test - now correctly returns Store<Record<number, {id: number, name: string}>>
+			const typedResult: Store<{ id: number; name: string }[]> = result
 			expect(typedResult).toBeDefined()
 		})
 
 		test('converts empty array to Store<Record<string, never>>', () => {
-			const arr: never[] = []
-			const result = toSignal(arr)
+			const result = toSignal([])
 
 			// Runtime behavior
 			expect(isStore(result)).toBe(true)
-			expect(Object.keys(result).length).toBe(0)
+			expect(result.length).toBe(0)
+			expect(Object.keys(result).length).toBe(1) // length property
 		})
 
 		test('converts record to Store<T>', () => {
@@ -62,7 +58,7 @@ describe('toSignal', () => {
 		})
 
 		test('passes through existing Store unchanged', () => {
-			const originalStore = store({ count: 5 })
+			const originalStore = createStore({ count: 5 })
 			const result = toSignal(originalStore)
 
 			// Runtime behavior
@@ -76,7 +72,7 @@ describe('toSignal', () => {
 		})
 
 		test('passes through existing State unchanged', () => {
-			const originalState = state(42)
+			const originalState = createState(42)
 			const result = toSignal(originalState)
 
 			// Runtime behavior
@@ -90,7 +86,7 @@ describe('toSignal', () => {
 		})
 
 		test('passes through existing Computed unchanged', () => {
-			const originalComputed = computed(() => 'hello world')
+			const originalComputed = createComputed(() => 'hello world')
 			const result = toSignal(originalComputed)
 
 			// Runtime behavior
@@ -145,11 +141,10 @@ describe('toSignal', () => {
 
 	describe('edge cases', () => {
 		test('handles nested arrays', () => {
-			const nestedArr = [
+			const result = toSignal([
 				[1, 2],
 				[3, 4],
-			]
-			const result = toSignal(nestedArr)
+			])
 
 			expect(isStore(result)).toBe(true)
 			// With the fixed behavior, nested arrays should be recovered as arrays
@@ -184,119 +179,13 @@ describe('toSignal', () => {
 	})
 })
 
-describe('toMutableSignal', () => {
-	describe('type inference and runtime behavior', () => {
-		test('converts array to Store<Record<string, T>>', () => {
-			const arr = [
-				{ id: 1, name: 'Alice' },
-				{ id: 2, name: 'Bob' },
-			]
-			const result = toMutableSignal(arr)
-
-			// 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' })
-
-			// Type inference test - now correctly returns Store<Record<string, {id: number, name: string}>>
-			const typedResult: Store<
-				Record<string, { id: number; name: string }>
-			> = result
-			expect(typedResult).toBeDefined()
-		})
-
-		test('converts record to Store<T>', () => {
-			const record = { name: 'Alice', age: 30 }
-			const result = toMutableSignal(record)
-
-			// Runtime behavior
-			expect(isStore(result)).toBe(true)
-			expect(result.name.get()).toBe('Alice')
-			expect(result.age.get()).toBe(30)
-
-			// Type inference test - should be Store<{name: string, age: number}>
-			const typedResult: Store<{ name: string; age: number }> = result
-			expect(typedResult).toBeDefined()
-		})
-
-		test('passes through existing Store unchanged', () => {
-			const originalStore = store({ count: 5 })
-			const result = toMutableSignal(originalStore)
-
-			// Runtime behavior
-			expect(result).toBe(originalStore) // Should be the same instance
-			expect(isStore(result)).toBe(true)
-			expect(result.count.get()).toBe(5)
-		})
-
-		test('passes through existing State unchanged', () => {
-			const originalState = state(42)
-			const result = toMutableSignal(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 be State<number>
-			const typedResult: State<number> = result
-			expect(typedResult).toBeDefined()
-		})
-
-		test('converts primitive to State<T>', () => {
-			const num = 42
-			const result = toMutableSignal(num)
-
-			// Runtime behavior - primitives are correctly converted to State
-			expect(isState(result)).toBe(true)
-			expect(result.get()).toBe(42)
-		})
-
-		test('converts object to State<T> (not Store)', () => {
-			const obj = new Date('2024-01-01')
-			const result = toMutableSignal(obj)
-
-			// Runtime behavior - objects are correctly converted to State
-			expect(isState(result)).toBe(true)
-			expect(result.get()).toBe(obj)
-
-			// Type inference test - should be State<Date>
-			const typedResult: State<Date> = result
-			expect(typedResult).toBeDefined()
-		})
-	})
-
-	describe('differences from toSignal', () => {
-		test('does not accept functions (only mutable signals)', () => {
-			// toMutableSignal should not have a function overload
-			// This test documents the expected behavior difference
-			const fn = () => 'test'
-			const result = toMutableSignal(fn)
-
-			// Should treat function as a regular value and create State
-			expect(isState(result)).toBe(true)
-			expect(result.get()).toBe(fn)
-		})
-
-		test('does not accept Computed signals', () => {
-			// toMutableSignal should not accept Computed signals
-			const comp = computed(() => 'computed value')
-			const result = toMutableSignal(comp)
-
-			// Should treat Computed as a regular object and create State
-			expect(isState(result)).toBe(true)
-			expect(result.get()).toBe(comp)
-		})
-	})
-})
-
 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(state(true))
+		const stateSignal = toSignal(createState(true))
 
 		// All should have get() method
 		expect(typeof arraySignal.get).toBe('function')
@@ -356,14 +245,7 @@ describe('Type precision tests', () => {
 
 	describe('Type inference issues', () => {
 		test('demonstrates current type inference problem', () => {
-			// Current issue: when passing an array, T is inferred as the array type
-			// instead of the element type, causing type compatibility problems
-			const items = [{ id: 1 }, { id: 2 }]
-			const result = toSignal(items)
-
-			// This should work but may have type issues in external libraries
-			// The return type should be Store<Record<string, {id: number}>>
-			// But currently it might be inferred as Store<Record<string, {id: number}[]>>
+			const result = toSignal([{ id: 1 }, { id: 2 }])
 
 			// Let's verify the actual behavior
 			expect(isStore(result)).toBe(true)
@@ -371,7 +253,7 @@ describe('Type precision tests', () => {
 			expect(result['1'].get()).toEqual({ id: 2 })
 
 			// Type assertion test - this should now work with correct typing
-			const typedResult: Store<Record<string, { id: number }>> = result
+			const typedResult: Store<{ id: number }[]> = result
 			expect(typedResult).toBeDefined()
 
 			// Simulate external library usage where P[K] represents element type
@@ -397,19 +279,11 @@ describe('Type precision tests', () => {
 		})
 
 		test('verifies fixed type inference for external library compatibility', () => {
-			// This test ensures the fix for the type inference issue works
-			// Fixed: toSignal<T extends unknown & {}>(value: T[]): Store<Record<string, T>>
-			// Now T = {id: number} (element type), T[] = {id: number}[] (array of elements)
-			// Return type: Store<Record<string, {id: number}>> (correct)
-
 			const items = [
 				{ id: 1, name: 'Alice' },
 				{ id: 2, name: 'Bob' },
 			]
 			const signal = toSignal(items)
-
-			// Type should be Store<Record<string, {id: number, name: string}>>
-			// Each property signal should be Signal<{id: number, name: string}>
 			const firstItemSignal = signal['0']
 			const secondItemSignal = signal['1']
 
@@ -419,9 +293,7 @@ describe('Type precision tests', () => {
 			expect(secondItemSignal.get()).toEqual({ id: 2, name: 'Bob' })
 
 			// Type inference should now work correctly:
-			const properlyTyped: Store<
-				Record<string, { id: number; name: string }>
-			> = signal
+			const properlyTyped: Store<{ id: number; name: string }[]> = signal
 			expect(properlyTyped).toBeDefined()
 
 			// These should work without type errors in external libraries

package/test/state.test.ts

@@ -1,12 +1,12 @@
 import { describe, expect, test } from 'bun:test'
-import { isComputed, isState, state } from '../'
+import { createState, isComputed, isState } from '../'
 
 /* === Tests === */
 
 describe('State', () => {
 	describe('State type guard', () => {
 		test('isState identifies state signals', () => {
-			const count = state(42)
+			const count = createState(42)
 			expect(isState(count)).toBe(true)
 			expect(isComputed(count)).toBe(false)
 		})
@@ -14,28 +14,28 @@ describe('State', () => {
 
 	describe('Boolean cause', () => {
 		test('should be boolean', () => {
-			const cause = state(false)
+			const cause = createState(false)
 			expect(typeof cause.get()).toBe('boolean')
 		})
 
 		test('should set initial value to false', () => {
-			const cause = state(false)
+			const cause = createState(false)
 			expect(cause.get()).toBe(false)
 		})
 
 		test('should set initial value to true', () => {
-			const cause = state(true)
+			const cause = createState(true)
 			expect(cause.get()).toBe(true)
 		})
 
 		test('should set new value with .set(true)', () => {
-			const cause = state(false)
+			const cause = createState(false)
 			cause.set(true)
 			expect(cause.get()).toBe(true)
 		})
 
 		test('should toggle initial value with .set(v => !v)', () => {
-			const cause = state(false)
+			const cause = createState(false)
 			cause.update(v => !v)
 			expect(cause.get()).toBe(true)
 		})
@@ -43,23 +43,23 @@ describe('State', () => {
 
 	describe('Number cause', () => {
 		test('should be number', () => {
-			const cause = state(0)
+			const cause = createState(0)
 			expect(typeof cause.get()).toBe('number')
 		})
 
 		test('should set initial value to 0', () => {
-			const cause = state(0)
+			const cause = createState(0)
 			expect(cause.get()).toBe(0)
 		})
 
 		test('should set new value with .set(42)', () => {
-			const cause = state(0)
+			const cause = createState(0)
 			cause.set(42)
 			expect(cause.get()).toBe(42)
 		})
 
 		test('should increment value with .set(v => ++v)', () => {
-			const cause = state(0)
+			const cause = createState(0)
 			cause.update(v => ++v)
 			expect(cause.get()).toBe(1)
 		})
@@ -67,23 +67,23 @@ describe('State', () => {
 
 	describe('String cause', () => {
 		test('should be string', () => {
-			const cause = state('foo')
+			const cause = createState('foo')
 			expect(typeof cause.get()).toBe('string')
 		})
 
 		test('should set initial value to "foo"', () => {
-			const cause = state('foo')
+			const cause = createState('foo')
 			expect(cause.get()).toBe('foo')
 		})
 
 		test('should set new value with .set("bar")', () => {
-			const cause = state('foo')
+			const cause = createState('foo')
 			cause.set('bar')
 			expect(cause.get()).toBe('bar')
 		})
 
 		test('should upper case value with .set(v => v.toUpperCase())', () => {
-			const cause = state('foo')
+			const cause = createState('foo')
 			cause.update(v => (v ? v.toUpperCase() : ''))
 			expect(cause.get()).toBe('FOO')
 		})
@@ -91,56 +91,243 @@ describe('State', () => {
 
 	describe('Array cause', () => {
 		test('should be array', () => {
-			const cause = state([1, 2, 3])
+			const cause = createState([1, 2, 3])
 			expect(Array.isArray(cause.get())).toBe(true)
 		})
 
 		test('should set initial value to [1, 2, 3]', () => {
-			const cause = state([1, 2, 3])
+			const cause = createState([1, 2, 3])
 			expect(cause.get()).toEqual([1, 2, 3])
 		})
 
 		test('should set new value with .set([4, 5, 6])', () => {
-			const cause = state([1, 2, 3])
+			const cause = createState([1, 2, 3])
 			cause.set([4, 5, 6])
 			expect(cause.get()).toEqual([4, 5, 6])
 		})
 
 		test('should reflect current value of array after modification', () => {
 			const array = [1, 2, 3]
-			const cause = state(array)
+			const cause = createState(array)
 			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])', () => {
 			const array = [1, 2, 3]
-			const cause = state(array)
+			const cause = createState(array)
 			cause.set([...array, 4]) // use destructuring instead!
 			expect(cause.get()).toEqual([1, 2, 3, 4])
 		})
+
+		describe('Input Validation', () => {
+			test('should throw NullishSignalValueError when initialValue is nullish', () => {
+				expect(() => {
+					// @ts-expect-error - Testing invalid input
+					createState(null)
+				}).toThrow('Nullish signal values are not allowed in state')
+
+				expect(() => {
+					// @ts-expect-error - Testing invalid input
+					createState(undefined)
+				}).toThrow('Nullish signal values are not allowed in state')
+			})
+
+			test('should throw NullishSignalValueError when newValue is nullish in set()', () => {
+				const state = createState(42)
+
+				expect(() => {
+					// @ts-expect-error - Testing invalid input
+					state.set(null)
+				}).toThrow('Nullish signal values are not allowed in state')
+
+				expect(() => {
+					// @ts-expect-error - Testing invalid input
+					state.set(undefined)
+				}).toThrow('Nullish signal values are not allowed in state')
+			})
+
+			test('should throw specific error types for nullish values', () => {
+				try {
+					// @ts-expect-error - Testing invalid input
+					createState(null)
+					expect(true).toBe(false) // Should not reach here
+				} catch (error) {
+					expect(error).toBeInstanceOf(TypeError)
+					expect(error.name).toBe('NullishSignalValueError')
+					expect(error.message).toBe(
+						'Nullish signal values are not allowed in state',
+					)
+				}
+
+				const state = createState(42)
+				try {
+					// @ts-expect-error - Testing invalid input
+					state.set(null)
+					expect(true).toBe(false) // Should not reach here
+				} catch (error) {
+					expect(error).toBeInstanceOf(TypeError)
+					expect(error.name).toBe('NullishSignalValueError')
+					expect(error.message).toBe(
+						'Nullish signal values are not allowed in state',
+					)
+				}
+			})
+
+			test('should allow valid non-nullish values', () => {
+				// These should not throw
+				expect(() => {
+					createState(0)
+				}).not.toThrow()
+
+				expect(() => {
+					createState('')
+				}).not.toThrow()
+
+				expect(() => {
+					createState(false)
+				}).not.toThrow()
+
+				expect(() => {
+					createState({})
+				}).not.toThrow()
+
+				expect(() => {
+					createState([])
+				}).not.toThrow()
+
+				const state = createState(42)
+				expect(() => {
+					state.set(0)
+				}).not.toThrow()
+
+				expect(() => {
+					// @ts-expect-error - Testing valid input of invalid type
+					state.set('')
+				}).not.toThrow()
+			})
+
+			test('should throw InvalidCallbackError for non-function updater in update()', () => {
+				const state = createState(42)
+
+				expect(() => {
+					// @ts-expect-error - Testing invalid input
+					state.update(null)
+				}).toThrow('Invalid state update callback null')
+
+				expect(() => {
+					// @ts-expect-error - Testing invalid input
+					state.update(undefined)
+				}).toThrow('Invalid state update callback undefined')
+
+				expect(() => {
+					// @ts-expect-error - Testing invalid input
+					state.update('not a function')
+				}).toThrow('Invalid state update callback "not a function"')
+
+				expect(() => {
+					// @ts-expect-error - Testing invalid input
+					state.update(42)
+				}).toThrow('Invalid state update callback 42')
+			})
+
+			test('should throw specific error type for non-function updater', () => {
+				const state = createState(42)
+
+				try {
+					// @ts-expect-error - Testing invalid input
+					state.update(null)
+					expect(true).toBe(false) // Should not reach here
+				} catch (error) {
+					expect(error).toBeInstanceOf(TypeError)
+					expect(error.name).toBe('InvalidCallbackError')
+					expect(error.message).toBe(
+						'Invalid state update callback null',
+					)
+				}
+			})
+
+			test('should handle updater function that throws an error', () => {
+				const state = createState(42)
+
+				expect(() => {
+					state.update(() => {
+						throw new Error('Updater error')
+					})
+				}).toThrow('Updater error')
+
+				// State should remain unchanged after error
+				expect(state.get()).toBe(42)
+			})
+
+			test('should handle updater function that returns nullish value', () => {
+				const state = createState(42)
+
+				expect(() => {
+					// @ts-expect-error - Testing invalid return value
+					state.update(() => null)
+				}).toThrow('Nullish signal values are not allowed in state')
+
+				expect(() => {
+					// @ts-expect-error - Testing invalid return value
+					state.update(() => undefined)
+				}).toThrow('Nullish signal values are not allowed in state')
+
+				// State should remain unchanged after error
+				expect(state.get()).toBe(42)
+			})
+
+			test('should handle valid updater functions', () => {
+				const numberState = createState(10)
+				expect(() => {
+					numberState.update(x => x + 5)
+				}).not.toThrow()
+				expect(numberState.get()).toBe(15)
+
+				const stringState = createState('hello')
+				expect(() => {
+					stringState.update(x => x.toUpperCase())
+				}).not.toThrow()
+				expect(stringState.get()).toBe('HELLO')
+
+				const arrayState = createState([1, 2, 3])
+				expect(() => {
+					arrayState.update(arr => [...arr, 4])
+				}).not.toThrow()
+				expect(arrayState.get()).toEqual([1, 2, 3, 4])
+
+				const objectState = createState({ count: 0 })
+				expect(() => {
+					objectState.update(obj => ({
+						...obj,
+						count: obj.count + 1,
+					}))
+				}).not.toThrow()
+				expect(objectState.get()).toEqual({ count: 1 })
+			})
+		})
 	})
 
 	describe('Object cause', () => {
 		test('should be object', () => {
-			const cause = state({ a: 'a', b: 1 })
+			const cause = createState({ a: 'a', b: 1 })
 			expect(typeof cause.get()).toBe('object')
 		})
 
 		test('should set initial value to { a: "a", b: 1 }', () => {
-			const cause = state({ a: 'a', b: 1 })
+			const cause = createState({ a: 'a', b: 1 })
 			expect(cause.get()).toEqual({ a: 'a', b: 1 })
 		})
 
 		test('should set new value with .set({ c: true })', () => {
-			const cause = state<Record<string, unknown>>({ a: 'a', b: 1 })
+			const cause = createState<Record<string, unknown>>({ a: 'a', b: 1 })
 			cause.set({ c: true })
 			expect(cause.get()).toEqual({ c: true })
 		})
 
 		test('should reflect current value of object after modification', () => {
 			const obj = { a: 'a', b: 1 }
-			const cause = state<Record<string, unknown>>(obj)
+			const cause = createState<Record<string, unknown>>(obj)
 			// @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 })
@@ -148,7 +335,7 @@ describe('State', () => {
 
 		test('should set new value with .set({...obj, c: true})', () => {
 			const obj = { a: 'a', b: 1 }
-			const cause = state<Record<string, unknown>>(obj)
+			const cause = createState<Record<string, unknown>>(obj)
 			cause.set({ ...obj, c: true }) // use destructuring instead!
 			expect(cause.get()).toEqual({ a: 'a', b: 1, c: true })
 		})