@zeix/cause-effect 0.15.1 → 0.15.2

package/src/util.ts

@@ -1,3 +1,8 @@
+/* === Constants === */
+
+// biome-ignore lint/suspicious/noExplicitAny: Deliberately using any to be used as a placeholder value in any signal
+const UNSET: any = Symbol()
+
 /* === Utility Functions === */
 
 const isString = /*#__PURE__*/ (value: unknown): value is string =>
@@ -6,6 +11,9 @@ const isString = /*#__PURE__*/ (value: unknown): value is string =>
 const isNumber = /*#__PURE__*/ (value: unknown): value is number =>
 	typeof value === 'number'
 
+const isSymbol = /*#__PURE__*/ (value: unknown): value is symbol =>
+	typeof value === 'symbol'
+
 const isFunction = /*#__PURE__*/ <T>(
 	fn: unknown,
 ): fn is (...args: unknown[]) => T => typeof fn === 'function'
@@ -15,6 +23,10 @@ const isAsyncFunction = /*#__PURE__*/ <T>(
 ): fn is (...args: unknown[]) => Promise<T> =>
 	isFunction(fn) && fn.constructor.name === 'AsyncFunction'
 
+const isDefinedObject = /*#__PURE__*/ (
+	value: unknown,
+): value is Record<string, unknown> => !!value && typeof value === 'object'
+
 const isObjectOfType = /*#__PURE__*/ <T>(
 	value: unknown,
 	type: string,
@@ -24,6 +36,12 @@ const isRecord = /*#__PURE__*/ <T extends Record<string, unknown>>(
 	value: unknown,
 ): value is T => isObjectOfType(value, 'Object')
 
+const isRecordOrArray = /*#__PURE__*/ <
+	T extends Record<string | number, unknown> | ReadonlyArray<unknown>,
+>(
+	value: unknown,
+): value is T => isRecord(value) || Array.isArray(value)
+
 const validArrayIndexes = /*#__PURE__*/ (
 	keys: Array<PropertyKey>,
 ): number[] | null => {
@@ -50,25 +68,51 @@ const isAbortError = /*#__PURE__*/ (error: unknown): boolean =>
 const toError = /*#__PURE__*/ (reason: unknown): Error =>
 	reason instanceof Error ? reason : Error(String(reason))
 
-class CircularDependencyError extends Error {
-	constructor(where: string) {
-		super(`Circular dependency in ${where} detected`)
-		this.name = 'CircularDependencyError'
+const arrayToRecord = /*#__PURE__*/ <T>(array: T[]): Record<string, T> => {
+	const record: Record<string, T> = {}
+	for (let i = 0; i < array.length; i++) {
+		record[String(i)] = array[i]
+	}
+	return record
+}
+
+const recordToArray = /*#__PURE__*/ <T>(
+	record: Record<string | number, T>,
+): Record<string, T> | T[] => {
+	const indexes = validArrayIndexes(Object.keys(record))
+	if (indexes === null) return record
+
+	const array: T[] = []
+	for (const index of indexes) {
+		array.push(record[String(index)])
 	}
+	return array
 }
 
+const valueString = /*#__PURE__*/ (value: unknown): string =>
+	isString(value)
+		? `"${value}"`
+		: isDefinedObject(value)
+			? JSON.stringify(value)
+			: String(value)
+
 /* === Exports === */
 
 export {
+	UNSET,
 	isString,
 	isNumber,
+	isSymbol,
 	isFunction,
 	isAsyncFunction,
+	isDefinedObject,
 	isObjectOfType,
 	isRecord,
-	validArrayIndexes,
+	isRecordOrArray,
 	hasMethod,
 	isAbortError,
 	toError,
-	CircularDependencyError,
+	arrayToRecord,
+	recordToArray,
+	valueString,
 }

package/test/computed.test.ts

@@ -231,7 +231,7 @@ describe('Computed', () => {
 		const c = computed(() => b.get() + a.get())
 		expect(() => {
 			b.get() // This should trigger the circular dependency
-		}).toThrow('Circular dependency in computed detected')
+		}).toThrow('Circular dependency detected in computed')
 		expect(a.get()).toBe(1)
 	})
 

package/test/diff.test.ts

@@ -23,7 +23,7 @@ describe('diff', () => {
 		test('should detect additions', () => {
 			const obj1 = { a: 1 }
 			const obj2 = { a: 1, b: 'new' }
-			const result = diff(obj1 as UnknownRecord, obj2 as UnknownRecord)
+			const result = diff<{ a: number; b?: string }>(obj1, obj2)
 
 			expect(result.changed).toBe(true)
 			expect(result.add).toEqual({ b: 'new' })
@@ -34,7 +34,7 @@ describe('diff', () => {
 		test('should detect removals', () => {
 			const obj1 = { a: 1, b: 'hello' }
 			const obj2 = { a: 1 }
-			const result = diff(obj1 as UnknownRecord, obj2 as UnknownRecord)
+			const result = diff<{ a: number; b?: string }>(obj1, obj2)
 
 			expect(result.changed).toBe(true)
 			expect(Object.keys(result.add)).toHaveLength(0)
@@ -56,7 +56,12 @@ describe('diff', () => {
 		test('should detect multiple changes', () => {
 			const obj1 = { a: 1, b: 'hello', c: true }
 			const obj2 = { a: 2, d: 'new', c: true }
-			const result = diff(obj1 as UnknownRecord, obj2 as UnknownRecord)
+			const result = diff<{
+				a: number
+				b?: string
+				c: boolean
+				d?: string
+			}>(obj1, obj2)
 
 			expect(result.changed).toBe(true)
 			expect(result.add).toEqual({ d: 'new' })
@@ -212,7 +217,10 @@ describe('diff', () => {
 		test('should handle changes from primitive to object', () => {
 			const obj1 = { value: 'string' }
 			const obj2 = { value: { type: 'object' } }
-			const result = diff(obj1 as UnknownRecord, obj2 as UnknownRecord)
+			const result = diff<{ value: string | { type: string } }>(
+				obj1,
+				obj2,
+			)
 
 			expect(result.changed).toBe(true)
 			expect(result.change).toEqual({ value: { type: 'object' } })
@@ -635,4 +643,313 @@ describe('diff', () => {
 			})
 		})
 	})
+
+	describe('non-plain object type safety', () => {
+		test('should handle Symbol objects without throwing TypeError', () => {
+			const symbol = Symbol('test')
+			const obj = { a: 1 }
+
+			// These should not throw after we fix the bug
+			// @ts-expect-error Testing runtime behavior with non-plain object types
+			expect(() => diff(symbol, obj)).not.toThrow()
+			// @ts-expect-error Testing runtime behavior with non-plain object types
+			expect(() => diff(obj, symbol)).not.toThrow()
+			// @ts-expect-error Testing runtime behavior with non-plain object types
+			expect(() => isEqual(symbol, obj)).not.toThrow()
+		})
+
+		test('should report additions when diffing from Symbol to valid object', () => {
+			const symbol = Symbol('test')
+			const obj = { a: 1, b: 'hello' }
+
+			// @ts-expect-error Testing runtime behavior with non-plain object types
+			const result = diff(symbol, obj)
+
+			expect(result.changed).toBe(true)
+			expect(result.add).toEqual({ a: 1, b: 'hello' })
+			expect(result.change).toEqual({})
+			expect(result.remove).toEqual({})
+		})
+
+		test('should report removals when diffing from valid object to Symbol', () => {
+			const obj = { a: 1, b: 'hello' }
+			const symbol = Symbol('test')
+
+			// @ts-expect-error Testing runtime behavior with non-plain object types
+			const result = diff(obj, symbol)
+
+			expect(result.changed).toBe(true)
+			expect(result.add).toEqual({})
+			expect(result.change).toEqual({})
+			expect(result.remove).toEqual({ a: 1, b: 'hello' })
+		})
+
+		test('should handle Symbol to Symbol diff with no changes', () => {
+			const symbol = Symbol('test')
+
+			// @ts-expect-error Testing runtime behavior with non-plain object types
+			const result = diff(symbol, symbol)
+
+			expect(result.changed).toBe(false)
+			expect(result.add).toEqual({})
+			expect(result.change).toEqual({})
+			expect(result.remove).toEqual({})
+		})
+
+		test('should handle different Symbols as changed', () => {
+			const symbol1 = Symbol('test1')
+			const symbol2 = Symbol('test2')
+
+			// @ts-expect-error Testing runtime behavior with non-plain object types
+			const result = diff(symbol1, symbol2)
+
+			expect(result.changed).toBe(true)
+			expect(result.add).toEqual({})
+			expect(result.change).toEqual({})
+			expect(result.remove).toEqual({})
+		})
+
+		test('should handle Date objects without throwing TypeError', () => {
+			const date = new Date('2023-01-01')
+			const obj = { a: 1 }
+
+			// @ts-expect-error Testing runtime behavior with non-plain object types
+			expect(() => diff(date, obj)).not.toThrow()
+			// @ts-expect-error Testing runtime behavior with non-plain object types
+			expect(() => diff(obj, date)).not.toThrow()
+			// @ts-expect-error Testing runtime behavior with non-plain object types
+			expect(() => isEqual(date, obj)).not.toThrow()
+		})
+
+		test('should report additions when diffing from Date to valid object', () => {
+			const date = new Date('2023-01-01')
+			const obj = { a: 1, b: 'hello' }
+
+			// @ts-expect-error Testing runtime behavior with non-plain object types
+			const result = diff(date, obj)
+
+			expect(result.changed).toBe(true)
+			expect(result.add).toEqual({ a: 1, b: 'hello' })
+			expect(result.change).toEqual({})
+			expect(result.remove).toEqual({})
+		})
+
+		test('should report removals when diffing from valid object to Date', () => {
+			const obj = { a: 1, b: 'hello' }
+			const date = new Date('2023-01-01')
+
+			// @ts-expect-error Testing runtime behavior with non-plain object types
+			const result = diff(obj, date)
+
+			expect(result.changed).toBe(true)
+			expect(result.add).toEqual({})
+			expect(result.change).toEqual({})
+			expect(result.remove).toEqual({ a: 1, b: 'hello' })
+		})
+
+		test('should handle Map objects without throwing TypeError', () => {
+			const map = new Map([['key', 'value']])
+			const obj = { a: 1 }
+
+			// @ts-expect-error Testing runtime behavior with non-plain object types
+			expect(() => diff(map, obj)).not.toThrow()
+			// @ts-expect-error Testing runtime behavior with non-plain object types
+			expect(() => diff(obj, map)).not.toThrow()
+			// @ts-expect-error Testing runtime behavior with non-plain object types
+			expect(() => isEqual(map, obj)).not.toThrow()
+		})
+
+		test('should report additions when diffing from Map to valid object', () => {
+			const map = new Map([['key', 'value']])
+			const obj = { x: 10, y: 20 }
+
+			// @ts-expect-error Testing runtime behavior with non-plain object types
+			const result = diff(map, obj)
+
+			expect(result.changed).toBe(true)
+			expect(result.add).toEqual({ x: 10, y: 20 })
+			expect(result.change).toEqual({})
+			expect(result.remove).toEqual({})
+		})
+
+		test('should handle Set objects without throwing TypeError', () => {
+			const set = new Set([1, 2, 3])
+			const obj = { a: 1 }
+
+			// @ts-expect-error Testing runtime behavior with non-plain object types
+			expect(() => diff(set, obj)).not.toThrow()
+			// @ts-expect-error Testing runtime behavior with non-plain object types
+			expect(() => diff(obj, set)).not.toThrow()
+			// @ts-expect-error Testing runtime behavior with non-plain object types
+			expect(() => isEqual(set, obj)).not.toThrow()
+		})
+
+		test('should handle Promise objects without throwing TypeError', () => {
+			const promise = Promise.resolve('test')
+			const obj = { a: 1 }
+
+			// @ts-expect-error Testing runtime behavior with non-plain object types
+			expect(() => diff(promise, obj)).not.toThrow()
+			// @ts-expect-error Testing runtime behavior with non-plain object types
+			expect(() => diff(obj, promise)).not.toThrow()
+			// @ts-expect-error Testing runtime behavior with non-plain object types
+			expect(() => isEqual(promise, obj)).not.toThrow()
+		})
+
+		test('should handle RegExp objects without throwing TypeError', () => {
+			const regex = /test/g
+			const obj = { a: 1 }
+
+			// @ts-expect-error Testing runtime behavior with non-plain object types
+			expect(() => diff(regex, obj)).not.toThrow()
+			// @ts-expect-error Testing runtime behavior with non-plain object types
+			expect(() => diff(obj, regex)).not.toThrow()
+			// @ts-expect-error Testing runtime behavior with non-plain object types
+			expect(() => isEqual(regex, obj)).not.toThrow()
+		})
+
+		test('should handle Function objects without throwing TypeError', () => {
+			const func = () => 'test'
+			const obj = { a: 1 }
+
+			// @ts-expect-error Testing runtime behavior with non-plain object types
+			expect(() => diff(func, obj)).not.toThrow()
+			// @ts-expect-error Testing runtime behavior with non-plain object types
+			expect(() => diff(obj, func)).not.toThrow()
+			// @ts-expect-error Testing runtime behavior with non-plain object types
+			expect(() => isEqual(func, obj)).not.toThrow()
+		})
+
+		test('should handle Error objects without throwing TypeError', () => {
+			const error = new Error('test error')
+			const obj = { a: 1 }
+
+			// @ts-expect-error Testing runtime behavior with non-plain object types
+			expect(() => diff(error, obj)).not.toThrow()
+			// @ts-expect-error Testing runtime behavior with non-plain object types
+			expect(() => diff(obj, error)).not.toThrow()
+			// @ts-expect-error Testing runtime behavior with non-plain object types
+			expect(() => isEqual(error, obj)).not.toThrow()
+		})
+
+		test('should handle WeakMap objects without throwing TypeError', () => {
+			const weakMap = new WeakMap()
+			const obj = { a: 1 }
+
+			// @ts-expect-error Testing runtime behavior with non-plain object types
+			expect(() => diff(weakMap, obj)).not.toThrow()
+			// @ts-expect-error Testing runtime behavior with non-plain object types
+			expect(() => diff(obj, weakMap)).not.toThrow()
+			// @ts-expect-error Testing runtime behavior with non-plain object types
+			expect(() => isEqual(weakMap, obj)).not.toThrow()
+		})
+
+		test('should handle WeakSet objects without throwing TypeError', () => {
+			const weakSet = new WeakSet()
+			const obj = { a: 1 }
+
+			// @ts-expect-error Testing runtime behavior with non-plain object types
+			expect(() => diff(weakSet, obj)).not.toThrow()
+			// @ts-expect-error Testing runtime behavior with non-plain object types
+			expect(() => diff(obj, weakSet)).not.toThrow()
+			// @ts-expect-error Testing runtime behavior with non-plain object types
+			expect(() => isEqual(weakSet, obj)).not.toThrow()
+		})
+
+		test('should handle ArrayBuffer objects without throwing TypeError', () => {
+			const buffer = new ArrayBuffer(8)
+			const obj = { a: 1 }
+
+			// @ts-expect-error Testing runtime behavior with non-plain object types
+			expect(() => diff(buffer, obj)).not.toThrow()
+			// @ts-expect-error Testing runtime behavior with non-plain object types
+			expect(() => diff(obj, buffer)).not.toThrow()
+			// @ts-expect-error Testing runtime behavior with non-plain object types
+			expect(() => isEqual(buffer, obj)).not.toThrow()
+		})
+
+		test('should handle class instances without throwing TypeError', () => {
+			class TestClass {
+				constructor(public value: string) {}
+			}
+			const instance = new TestClass('test')
+			const obj = { a: 1 }
+
+			// @ts-expect-error Testing runtime behavior with non-plain object types
+			expect(() => diff(instance, obj)).not.toThrow()
+			// @ts-expect-error Testing runtime behavior with non-plain object types
+			expect(() => diff(obj, instance)).not.toThrow()
+			// @ts-expect-error Testing runtime behavior with non-plain object types
+			expect(() => isEqual(instance, obj)).not.toThrow()
+		})
+
+		test('should report additions/removals with mixed valid and invalid objects', () => {
+			const func = () => 'test'
+			const obj1 = { a: 1 }
+			const obj2 = { b: 2 }
+
+			// @ts-expect-error Testing runtime behavior with non-plain object types
+			const result1 = diff(func, obj1)
+			expect(result1.changed).toBe(true)
+			expect(result1.add).toEqual({ a: 1 })
+			expect(result1.remove).toEqual({})
+
+			// @ts-expect-error Testing runtime behavior with non-plain object types
+			const result2 = diff(obj2, func)
+			expect(result2.changed).toBe(true)
+			expect(result2.add).toEqual({})
+			expect(result2.remove).toEqual({ b: 2 })
+
+			// @ts-expect-error Testing runtime behavior with non-plain object types
+			const result3 = diff(func, func)
+			expect(result3.changed).toBe(false)
+			expect(result3.add).toEqual({})
+			expect(result3.remove).toEqual({})
+		})
+	})
+})
+
+describe('sparse array handling', () => {
+	test('should properly diff sparse array representations', () => {
+		// Simulate what happens in store: sparse array [10, 30, 50] with keys ["0", "2", "4"]
+		// is represented as a regular array [10, 30, 50] when passed to diff()
+		const oldSparseArray: Record<number, number> = [10, 30, 50] // What current() returns for sparse store
+		const newDenseArray: Record<number, number> = [100, 200, 300] // What user wants to set
+
+		const result = diff(oldSparseArray, newDenseArray)
+
+		// The problem: diff sees this as simple value changes at indices 0, 1, 2
+		// But the store actually has sparse keys "0", "2", "4"
+		// So when reconcile tries to apply changes, only indices 0 and 2 work
+		expect(result.change).toEqual({
+			'0': 100, // This works (key "0" exists)
+			'1': 200, // This fails (key "1" doesn't exist in sparse structure)
+			'2': 300, // This works (key "2" exists)
+		})
+		expect(result.add).toEqual({})
+		expect(result.remove).toEqual({})
+		expect(result.changed).toBe(true)
+	})
+
+	test('should handle array-to-object conversion when context suggests sparse structure', () => {
+		// This test demonstrates the core issue: we need context about the original structure
+		// to properly handle sparse array replacement
+		const oldSparseAsObject = { '0': 10, '2': 30, '4': 50 } // Actual sparse structure
+		const newDenseArray: Record<number, number> = [100, 200, 300] // User input
+
+		const result = diff(oldSparseAsObject, newDenseArray)
+
+		// This should remove old sparse keys and add new dense keys
+		expect(result.remove).toEqual({
+			'4': UNSET, // Key "4" should be removed (key "2" gets reused)
+		})
+		expect(result.add).toEqual({
+			'1': 200, // Key "1" should be added
+		})
+		expect(result.change).toEqual({
+			'0': 100, // Key "0" changes value from 10 to 100
+			'2': 300, // Key "2" changes value from 30 to 300
+		})
+		expect(result.changed).toBe(true)
+	})
 })

package/test/effect.test.ts

@@ -264,7 +264,7 @@ describe('Effect', () => {
 					errCount++
 					expect(errors[0]).toBeInstanceOf(Error)
 					expect(errors[0].message).toBe(
-						'Circular dependency in effect detected',
+						'Circular dependency detected in effect',
 					)
 				},
 			})

package/test/match.test.ts

@@ -77,13 +77,17 @@ describe('Match Function', () => {
 		expect((errValue as unknown as Error).message).toBe('Test error')
 	})
 
-	test('should handle missing handlers gracefully', () => {
+	test('should handle missing optional handlers gracefully', () => {
 		const a = state(10)
 		const result = resolve({ a })
 
-		// Should not throw even with no handlers
+		// Should not throw even with only required ok handler (err and nil are optional)
 		expect(() => {
-			match(result, {})
+			match(result, {
+				ok: () => {
+					// This handler is required, but err and nil are optional
+				},
+			})
 		}).not.toThrow()
 	})
 
@@ -139,6 +143,9 @@ describe('Match Function', () => {
 		let allErrors: readonly Error[] | null = null
 
 		match(resolve({ a }), {
+			ok: () => {
+				// This won't be called since there are errors, but it's required
+			},
 			err: errors => {
 				// First call with signal error
 				if (errors.length === 1) {
@@ -216,6 +223,9 @@ describe('Match Function', () => {
 		let errorMessages: string[] = []
 
 		match(resolve({ error1, error2 }), {
+			ok: () => {
+				// This won't be called since there are errors, but it's required
+			},
 			err: errors => {
 				errorMessages = errors.map(e => e.message)
 			},