@zeix/cause-effect 0.14.1 → 0.14.2

package/test/effect.test.ts

@@ -1,5 +1,5 @@
-import { describe, test, expect, mock } from 'bun:test'
-import { state, computed, effect, UNSET } from '../'
+import { describe, expect, mock, test } from 'bun:test'
+import { computed, effect, state, UNSET } from '../'
 
 /* === Utility Functions === */
 
@@ -7,11 +7,11 @@ const wait = (ms: number) => new Promise(resolve => setTimeout(resolve, ms))
 
 /* === Tests === */
 
-describe('Effect', function () {
-	test('should be triggered after a state change', function () {
+describe('Effect', () => {
+	test('should be triggered after a state change', () => {
 		const cause = state('foo')
 		let count = 0
-		effect(() => {
+		effect((): undefined => {
 			cause.get()
 			count++
 		})
@@ -20,7 +20,7 @@ describe('Effect', function () {
 		expect(count).toBe(2)
 	})
 
-	test('should be triggered after computed async signals resolve without waterfalls', async function () {
+	test('should be triggered after computed async signals resolve without waterfalls', async () => {
 		const a = computed(async () => {
 			await wait(100)
 			return 10
@@ -33,7 +33,7 @@ describe('Effect', function () {
 		let count = 0
 		effect({
 			signals: [a, b],
-			ok: (aValue, bValue) => {
+			ok: (aValue, bValue): undefined => {
 				result = aValue + bValue
 				count++
 			},
@@ -45,11 +45,11 @@ describe('Effect', function () {
 		expect(count).toBe(1)
 	})
 
-	test('should be triggered repeatedly after repeated state change', async function () {
+	test('should be triggered repeatedly after repeated state change', async () => {
 		const cause = state(0)
 		let result = 0
 		let count = 0
-		effect(() => {
+		effect((): undefined => {
 			result = cause.get()
 			count++
 		})
@@ -60,7 +60,7 @@ describe('Effect', function () {
 		}
 	})
 
-	test('should handle errors in effects', function () {
+	test('should handle errors in effects', () => {
 		const a = state(1)
 		const b = computed(() => {
 			const v = a.get()
@@ -71,11 +71,11 @@ describe('Effect', function () {
 		let errorCallCount = 0
 		effect({
 			signals: [b],
-			ok: () => {
+			ok: (): undefined => {
 				// console.log('Normal effect:', value)
 				normalCallCount++
 			},
-			err: error => {
+			err: (error: Error): undefined => {
 				// console.log('Error effect:', error)
 				errorCallCount++
 				expect(error.message).toBe('Value too high')
@@ -98,7 +98,7 @@ describe('Effect', function () {
 		expect(errorCallCount).toBe(1)
 	})
 
-	test('should handle UNSET values in effects', async function () {
+	test('should handle UNSET values in effects', async () => {
 		const a = computed(async () => {
 			await wait(100)
 			return 42
@@ -107,11 +107,11 @@ describe('Effect', function () {
 		let nilCount = 0
 		effect({
 			signals: [a],
-			ok: aValue => {
+			ok: (aValue: number): undefined => {
 				normalCallCount++
 				expect(aValue).toBe(42)
 			},
-			nil: () => {
+			nil: (): undefined => {
 				nilCount++
 			},
 		})
@@ -140,7 +140,7 @@ describe('Effect', function () {
 			})
 
 			// Create an effect without explicit error handling
-			effect(() => {
+			effect((): undefined => {
 				b.get()
 			})
 
@@ -164,7 +164,7 @@ describe('Effect', function () {
 		const count = state(42)
 		let received = 0
 
-		const cleanup = effect(() => {
+		const cleanup = effect((): undefined => {
 			received = count.get()
 		})
 
@@ -183,12 +183,12 @@ describe('Effect', function () {
 
 		effect({
 			signals: [count],
-			ok: () => {
+			ok: (): undefined => {
 				okCount++
 				// This effect updates the signal it depends on, creating a circular dependency
 				count.update(v => ++v)
 			},
-			err: e => {
+			err: (e): undefined => {
 				errCount++
 				expect(e).toBeInstanceOf(Error)
 				expect(e.message).toBe('Circular dependency in effect detected')

package/test/state.test.ts

@@ -1,9 +1,9 @@
-import { describe, test, expect } from 'bun:test'
+import { describe, expect, test } from 'bun:test'
 import { isComputed, isState, state } from '../'
 
 /* === Tests === */
 
-describe('State', function () {
+describe('State', () => {
 	describe('State type guard', () => {
 		test('isState identifies state signals', () => {
 			const count = state(42)
@@ -12,108 +12,108 @@ describe('State', function () {
 		})
 	})
 
-	describe('Boolean cause', function () {
-		test('should be boolean', function () {
+	describe('Boolean cause', () => {
+		test('should be boolean', () => {
 			const cause = state(false)
 			expect(typeof cause.get()).toBe('boolean')
 		})
 
-		test('should set initial value to false', function () {
+		test('should set initial value to false', () => {
 			const cause = state(false)
 			expect(cause.get()).toBe(false)
 		})
 
-		test('should set initial value to true', function () {
+		test('should set initial value to true', () => {
 			const cause = state(true)
 			expect(cause.get()).toBe(true)
 		})
 
-		test('should set new value with .set(true)', function () {
+		test('should set new value with .set(true)', () => {
 			const cause = state(false)
 			cause.set(true)
 			expect(cause.get()).toBe(true)
 		})
 
-		test('should toggle initial value with .set(v => !v)', function () {
+		test('should toggle initial value with .set(v => !v)', () => {
 			const cause = state(false)
 			cause.update(v => !v)
 			expect(cause.get()).toBe(true)
 		})
 	})
 
-	describe('Number cause', function () {
-		test('should be number', function () {
+	describe('Number cause', () => {
+		test('should be number', () => {
 			const cause = state(0)
 			expect(typeof cause.get()).toBe('number')
 		})
 
-		test('should set initial value to 0', function () {
+		test('should set initial value to 0', () => {
 			const cause = state(0)
 			expect(cause.get()).toBe(0)
 		})
 
-		test('should set new value with .set(42)', function () {
+		test('should set new value with .set(42)', () => {
 			const cause = state(0)
 			cause.set(42)
 			expect(cause.get()).toBe(42)
 		})
 
-		test('should increment value with .set(v => ++v)', function () {
+		test('should increment value with .set(v => ++v)', () => {
 			const cause = state(0)
 			cause.update(v => ++v)
 			expect(cause.get()).toBe(1)
 		})
 	})
 
-	describe('String cause', function () {
-		test('should be string', function () {
+	describe('String cause', () => {
+		test('should be string', () => {
 			const cause = state('foo')
 			expect(typeof cause.get()).toBe('string')
 		})
 
-		test('should set initial value to "foo"', function () {
+		test('should set initial value to "foo"', () => {
 			const cause = state('foo')
 			expect(cause.get()).toBe('foo')
 		})
 
-		test('should set new value with .set("bar")', function () {
+		test('should set new value with .set("bar")', () => {
 			const cause = state('foo')
 			cause.set('bar')
 			expect(cause.get()).toBe('bar')
 		})
 
-		test('should upper case value with .set(v => v.toUpperCase())', function () {
+		test('should upper case value with .set(v => v.toUpperCase())', () => {
 			const cause = state('foo')
 			cause.update(v => (v ? v.toUpperCase() : ''))
 			expect(cause.get()).toBe('FOO')
 		})
 	})
 
-	describe('Array cause', function () {
-		test('should be array', function () {
+	describe('Array cause', () => {
+		test('should be array', () => {
 			const cause = state([1, 2, 3])
 			expect(Array.isArray(cause.get())).toBe(true)
 		})
 
-		test('should set initial value to [1, 2, 3]', function () {
+		test('should set initial value to [1, 2, 3]', () => {
 			const cause = state([1, 2, 3])
 			expect(cause.get()).toEqual([1, 2, 3])
 		})
 
-		test('should set new value with .set([4, 5, 6])', function () {
+		test('should set new value with .set([4, 5, 6])', () => {
 			const cause = state([1, 2, 3])
 			cause.set([4, 5, 6])
 			expect(cause.get()).toEqual([4, 5, 6])
 		})
 
-		test('should reflect current value of array after modification', function () {
+		test('should reflect current value of array after modification', () => {
 			const array = [1, 2, 3]
 			const cause = state(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])', function () {
+		test('should set new value with .set([...array, 4])', () => {
 			const array = [1, 2, 3]
 			const cause = state(array)
 			cause.set([...array, 4]) // use destructuring instead!
@@ -121,34 +121,34 @@ describe('State', function () {
 		})
 	})
 
-	describe('Object cause', function () {
-		test('should be object', function () {
+	describe('Object cause', () => {
+		test('should be object', () => {
 			const cause = state({ a: 'a', b: 1 })
 			expect(typeof cause.get()).toBe('object')
 		})
 
-		test('should set initial value to { a: "a", b: 1 }', function () {
+		test('should set initial value to { a: "a", b: 1 }', () => {
 			const cause = state({ a: 'a', b: 1 })
 			expect(cause.get()).toEqual({ a: 'a', b: 1 })
 		})
 
-		test('should set new value with .set({ c: true })', function () {
-			const cause = state<Record<string, any>>({ a: 'a', b: 1 })
+		test('should set new value with .set({ c: true })', () => {
+			const cause = state<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', function () {
+		test('should reflect current value of object after modification', () => {
 			const obj = { a: 'a', b: 1 }
-			const cause = state<Record<string, any>>(obj)
+			const cause = state<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 })
 		})
 
-		test('should set new value with .set({...obj, c: true})', function () {
+		test('should set new value with .set({...obj, c: true})', () => {
 			const obj = { a: 'a', b: 1 }
-			const cause = state<Record<string, any>>(obj)
+			const cause = state<Record<string, unknown>>(obj)
 			cause.set({ ...obj, c: true }) // use destructuring instead!
 			expect(cause.get()).toEqual({ a: 'a', b: 1, c: true })
 		})

package/test/util/framework-types.ts

@@ -1,5 +1,5 @@
-import { TestResult } from './perf-tests'
-import { ReactiveFramework } from './reactive-framework'
+import type { TestResult } from './perf-tests'
+import type { ReactiveFramework } from './reactive-framework'
 
 /** Parameters for a running a performance benchmark test
  *

package/test/util/perf-tests.ts

@@ -1,4 +1,4 @@
-import { FrameworkInfo, TestConfig } from './framework-types'
+import type { FrameworkInfo, TestConfig } from './framework-types'
 
 export interface TestResult {
 	sum: number
@@ -25,7 +25,7 @@ export function verifyBenchResult(
 
 	if (expected.sum) {
 		console.assert(
-			result.sum == expected.sum,
+			result.sum === expected.sum,
 			`sum ${framework.name} ${config.name} result:${result.sum} expected:${expected.sum}`,
 		)
 	}

package/test/util/reactive-framework.ts

@@ -6,7 +6,7 @@ export interface ReactiveFramework {
 	name: string
 	signal<T>(initialValue: T): Signal<T>
 	computed<T>(fn: () => T): Computed<T>
-	effect(fn: () => void): void
+	effect(fn: () => undefined): void
 	withBatch<T>(fn: () => T): void
 	withBuild<T>(fn: () => T): T
 }