@zeix/cause-effect 0.16.1 → 0.17.1

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/ref.test.ts

@@ -0,0 +1,227 @@
+import { expect, mock, test } from 'bun:test'
+import { isRef, Ref } from '../src/classes/ref'
+import { createEffect } from '../src/effect'
+
+test('Ref - basic functionality', () => {
+	const obj = { name: 'test', value: 42 }
+	const ref = new Ref(obj)
+
+	expect(ref.get()).toBe(obj)
+	expect(ref[Symbol.toStringTag]).toBe('Ref')
+})
+
+test('Ref - isRef type guard', () => {
+	const ref = new Ref({ test: true })
+	const notRef = { test: true }
+
+	expect(isRef(ref)).toBe(true)
+	expect(isRef(notRef)).toBe(false)
+	expect(isRef(null)).toBe(false)
+	expect(isRef(undefined)).toBe(false)
+})
+
+test('Ref - validation with guard function', () => {
+	const isConfig = (
+		value: unknown,
+	): value is { host: string; port: number } =>
+		typeof value === 'object' &&
+		value !== null &&
+		'host' in value &&
+		'port' in value &&
+		typeof value.host === 'string' &&
+		typeof value.port === 'number'
+
+	const validConfig = { host: 'localhost', port: 3000 }
+	const invalidConfig = { host: 'localhost' } // missing port
+
+	expect(() => new Ref(validConfig, isConfig)).not.toThrow()
+	expect(() => new Ref(invalidConfig, isConfig)).toThrow()
+})
+
+test('Ref - reactive subscriptions', () => {
+	const server = { status: 'offline', connections: 0 }
+	const ref = new Ref(server)
+
+	let effectRunCount = 0
+	let lastStatus: string = ''
+
+	createEffect(() => {
+		const current = ref.get()
+		lastStatus = current.status
+		effectRunCount++
+	})
+
+	expect(effectRunCount).toBe(1)
+	expect(lastStatus).toBe('offline')
+
+	// Simulate external change without going through reactive system
+	server.status = 'online'
+	server.connections = 5
+
+	// Effect shouldn't re-run yet (reference hasn't changed)
+	expect(effectRunCount).toBe(1)
+
+	// Notify that the external object has changed
+	ref.notify()
+
+	expect(effectRunCount).toBe(2)
+	expect(lastStatus).toBe('online')
+})
+
+test('Ref - notify triggers watchers even with same reference', () => {
+	const fileObj = { path: '/test.txt', size: 100, modified: Date.now() }
+	const ref = new Ref(fileObj)
+
+	const mockCallback = mock(() => {})
+
+	createEffect(() => {
+		ref.get()
+		mockCallback()
+	})
+
+	expect(mockCallback).toHaveBeenCalledTimes(1)
+
+	// Simulate file modification (same object reference, different content)
+	fileObj.size = 200
+	fileObj.modified = Date.now()
+
+	// Notify about external change
+	ref.notify()
+
+	expect(mockCallback).toHaveBeenCalledTimes(2)
+
+	// Multiple notifies should trigger multiple times
+	ref.notify()
+	expect(mockCallback).toHaveBeenCalledTimes(3)
+})
+
+test('Ref - multiple effects with same ref', () => {
+	const database = { connected: false, queries: 0 }
+	const ref = new Ref(database)
+
+	const effect1Mock = mock(() => {})
+	const effect2Mock = mock((_connected: boolean) => {})
+
+	createEffect(() => {
+		ref.get()
+		effect1Mock()
+	})
+
+	createEffect(() => {
+		const db = ref.get()
+		effect2Mock(db.connected)
+	})
+
+	expect(effect1Mock).toHaveBeenCalledTimes(1)
+	expect(effect2Mock).toHaveBeenCalledTimes(1)
+	expect(effect2Mock).toHaveBeenCalledWith(false)
+
+	// Simulate database connection change
+	database.connected = true
+	database.queries = 10
+	ref.notify()
+
+	expect(effect1Mock).toHaveBeenCalledTimes(2)
+	expect(effect2Mock).toHaveBeenCalledTimes(2)
+	expect(effect2Mock).toHaveBeenLastCalledWith(true)
+})
+
+test('Ref - with Bun.file() scenario', () => {
+	// Mock a file-like object that could change externally
+	const fileRef = {
+		name: 'config.json',
+		size: 1024,
+		lastModified: Date.now(),
+		// Simulate file methods
+		exists: () => true,
+		text: () => Promise.resolve('{"version": "1.0"}'),
+	}
+
+	const ref = new Ref(fileRef)
+
+	let sizeChanges = 0
+	createEffect(() => {
+		const file = ref.get()
+		if (file.size > 1000) sizeChanges++
+	})
+
+	expect(sizeChanges).toBe(1) // Initial run
+
+	// Simulate file growing (external change)
+	fileRef.size = 2048
+	fileRef.lastModified = Date.now()
+	ref.notify()
+
+	expect(sizeChanges).toBe(2) // Effect re-ran and condition still met
+
+	// Simulate file shrinking
+	fileRef.size = 500
+	ref.notify()
+
+	expect(sizeChanges).toBe(2) // Effect re-ran but condition no longer met
+})
+
+test('Ref - validation errors', () => {
+	// @ts-expect-error deliberatly provoked error
+	expect(() => new Ref(null)).toThrow()
+	// @ts-expect-error deliberatly provoked error
+	expect(() => new Ref(undefined)).toThrow()
+})
+
+test('Ref - server config object scenario', () => {
+	const config = {
+		host: 'localhost',
+		port: 3000,
+		ssl: false,
+		maxConnections: 100,
+	}
+
+	const configRef = new Ref(config)
+	const connectionAttempts: string[] = []
+
+	createEffect(() => {
+		const cfg = configRef.get()
+		const protocol = cfg.ssl ? 'https' : 'http'
+		connectionAttempts.push(`${protocol}://${cfg.host}:${cfg.port}`)
+	})
+
+	expect(connectionAttempts).toEqual(['http://localhost:3000'])
+
+	// Simulate config reload from file/environment
+	config.ssl = true
+	config.port = 8443
+	configRef.notify()
+
+	expect(connectionAttempts).toEqual([
+		'http://localhost:3000',
+		'https://localhost:8443',
+	])
+})
+
+test('Ref - handles complex nested objects', () => {
+	const apiResponse = {
+		status: 200,
+		data: {
+			users: [{ id: 1, name: 'Alice' }],
+			pagination: { page: 1, total: 1 },
+		},
+		headers: { 'content-type': 'application/json' },
+	}
+
+	const ref = new Ref(apiResponse)
+	let userCount = 0
+
+	createEffect(() => {
+		const response = ref.get()
+		userCount = response.data.users.length
+	})
+
+	expect(userCount).toBe(1)
+
+	// Simulate API response update
+	apiResponse.data.users.push({ id: 2, name: 'Bob' })
+	apiResponse.data.pagination.total = 2
+	ref.notify()
+
+	expect(userCount).toBe(2)
+})

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')
 		})