@zeix/cause-effect 0.14.0 → 0.14.2

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
 }

package/src/memo.d.ts

@@ -1,13 +0,0 @@
-import { type Computed } from './computed';
-type MemoCallback<T extends {} & {
-    then?: void;
-}> = () => T;
-/**
- * Create a derived signal for synchronous computations
- *
- * @since 0.14.0
- * @param {MemoCallback<T>} fn - synchronous computation callback
- * @returns {Computed<T>} - Computed signal
- */
-declare const memo: <T extends {}>(fn: MemoCallback<T>) => Computed<T>;
-export { type MemoCallback, memo };

package/src/memo.ts

@@ -1,91 +0,0 @@
-import { UNSET } from './signal'
-import { CircularDependencyError } from './util'
-import {
-	type Cleanup,
-	type Watcher,
-	flush,
-	notify,
-	subscribe,
-	watch,
-} from './scheduler'
-import { type Computed, TYPE_COMPUTED } from './computed'
-
-/* === Types === */
-
-type MemoCallback<T extends {} & { then?: void }> = () => T
-
-/* === Functions === */
-
-/**
- * Create a derived signal for synchronous computations
- *
- * @since 0.14.0
- * @param {MemoCallback<T>} fn - synchronous computation callback
- * @returns {Computed<T>} - Computed signal
- */
-const memo = <T extends {}>(fn: MemoCallback<T>): Computed<T> => {
-	const watchers: Set<Watcher> = new Set()
-
-	// Internal state - simplified for sync only
-	let value: T = UNSET
-	let error: Error | undefined
-	let dirty = true
-	let computing = false
-
-	// Called when notified from sources (push)
-	const mark = (() => {
-		dirty = true
-		if (watchers.size) {
-			notify(watchers)
-		} else {
-			mark.cleanups.forEach(fn => fn())
-			mark.cleanups.clear()
-		}
-	}) as Watcher
-	mark.cleanups = new Set<Cleanup>()
-
-	// Called when requested by dependencies (pull)
-	const compute = () =>
-		watch(() => {
-			if (computing) throw new CircularDependencyError('memo')
-			computing = true
-			try {
-				const result = fn()
-				if (null == result || UNSET === result) {
-					value = UNSET
-					error = undefined
-				} else {
-					value = result
-					dirty = false
-					error = undefined
-				}
-			} catch (e) {
-				value = UNSET
-				error = e instanceof Error ? e : new Error(String(e))
-			} finally {
-				computing = false
-			}
-		}, mark)
-
-	const c: Computed<T> = {
-		[Symbol.toStringTag]: TYPE_COMPUTED,
-
-		/**
-		 * Get the current value of the computed
-		 *
-		 * @returns {T} - current value of the computed
-		 */
-		get: (): T => {
-			subscribe(watchers)
-			flush()
-			if (dirty) compute()
-			if (error) throw error
-			return value
-		},
-	}
-	return c
-}
-
-/* === Exports === */
-
-export { type MemoCallback, memo }

package/src/task.d.ts

@@ -1,17 +0,0 @@
-import { type Computed } from './computed';
-/**
- * Callback for async computation tasks
- * This explicitly returns a Promise<T> to differentiate from MemoCallback
- *
- * @since 0.14.0
- */
-type TaskCallback<T extends {}> = (abort: AbortSignal) => Promise<T>;
-/**
- * Create a derived signal that supports asynchronous computations
- *
- * @since 0.14.0
- * @param {TaskCallback<T>} fn - async computation callback
- * @returns {Computed<T>} - Computed signal
- */
-declare const task: <T extends {}>(fn: TaskCallback<T>) => Computed<T>;
-export { type TaskCallback, task };

package/src/task.ts

@@ -1,153 +0,0 @@
-import { UNSET } from './signal'
-import {
-	CircularDependencyError,
-	isAbortError,
-	isPromise,
-	toError,
-} from './util'
-import {
-	type Cleanup,
-	type Watcher,
-	flush,
-	notify,
-	subscribe,
-	watch,
-} from './scheduler'
-import {
-	type Computed,
-	TYPE_COMPUTED,
-} from './computed'
-
-/* === Types === */
-
-/**
- * Callback for async computation tasks
- * This explicitly returns a Promise<T> to differentiate from MemoCallback
- * 
- * @since 0.14.0
- */
-type TaskCallback<T extends {}> = (abort: AbortSignal) => Promise<T>
-
-/* === Function === */
-
-/**
- * Create a derived signal that supports asynchronous computations
- *
- * @since 0.14.0
- * @param {TaskCallback<T>} fn - async computation callback
- * @returns {Computed<T>} - Computed signal
- */
-const task = <T extends {}>(fn: TaskCallback<T>): Computed<T> => {
-	const watchers: Set<Watcher> = new Set()
-
-	// Internal state
-	let value: T = UNSET
-	let error: Error | undefined
-	let dirty = true
-	let changed = false
-	let computing = false
-	let controller: AbortController | undefined
-
-	// Functions to update internal state
-	const ok = (v: T) => {
-		if (!Object.is(v, value)) {
-			value = v
-			dirty = false
-			error = undefined
-			changed = true
-		}
-	}
-	const nil = () => {
-		changed = UNSET !== value
-		value = UNSET
-		error = undefined
-	}
-	const err = (e: unknown) => {
-		const newError = toError(e)
-		changed = !(
-			error &&
-			newError.name === error.name &&
-			newError.message === error.message
-		)
-		value = UNSET
-		error = newError
-	}
-	const resolve = (v: T) => {
-		computing = false
-		controller = undefined
-		ok(v)
-		if (changed) notify(watchers)
-	}
-	const reject = (e: unknown) => {
-		computing = false
-		controller = undefined
-		err(e)
-		if (changed) notify(watchers)
-	}
-	const abort = () => {
-		computing = false
-		controller = undefined
-		compute() // retry
-	}
-
-	// Called when notified from sources (push)
-	const mark = (() => {
-		dirty = true
-		controller?.abort('Aborted because source signal changed')
-		if (watchers.size) {
-			notify(watchers)
-		} else {
-			mark.cleanups.forEach(fn => fn())
-			mark.cleanups.clear()
-		}
-	}) as Watcher
-	mark.cleanups = new Set<Cleanup>()
-
-	// Called when requested by dependencies (pull)
-	const compute = () =>
-		watch(() => {
-			if (computing) throw new CircularDependencyError('task')
-			changed = false
-			controller = new AbortController()
-			controller.signal.addEventListener('abort', abort, {
-				once: true,
-			})
-
-			let result: T | Promise<T>
-			computing = true
-			try {
-				result = fn(controller.signal)
-			} catch (e) {
-				if (isAbortError(e)) nil()
-				else err(e)
-				computing = false
-				return
-			}
-			if (isPromise(result)) result.then(resolve, reject)
-			else if (null == result || UNSET === result) nil()
-			else ok(result)
-			computing = false
-		}, mark)
-
-	const c: Computed<T> = {
-		[Symbol.toStringTag]: TYPE_COMPUTED,
-
-		/**
-		 * Get the current value of the computed
-		 *
-		 * @returns {T} - current value of the computed
-		 */
-		get: (): T => {
-			subscribe(watchers)
-			flush()
-			if (dirty) compute()
-			if (error) throw error
-			return value
-		},
-	}
-	return c
-}
-
-/* === Exports === */
-
-export { type TaskCallback, task }