@zeix/cause-effect 0.13.1 → 0.13.2

package/{lib → src}/signal.ts

@@ -21,7 +21,7 @@ const UNSET: any = Symbol()
  * @param {unknown} value - value to check
  * @returns {boolean} - true if value is a Signal, false otherwise
  */
-const isSignal = /*#__PURE__*/ <T extends {}>(value: any): value is Signal<T> =>
+const isSignal = /*#__PURE__*/ <T extends {}>(value: unknown): value is Signal<T> =>
 	isState(value) || isComputed(value)
 
 /**

package/{lib → src}/state.ts

@@ -7,10 +7,10 @@ import { type TapMatcher, type EffectMatcher, effect } from './effect'
 /* === Types === */
 
 export type State<T extends {}> = {
-    [Symbol.toStringTag]: 'State'
-    get(): T
-    set(v: T): void
-    update(fn: (v: T) => T): void
+	[Symbol.toStringTag]: 'State'
+	get(): T
+	set(v: T): void
+	update(fn: (v: T) => T): void
 	map<U extends {}>(fn: (v: T) => U | Promise<U>): Computed<U>
 	tap(matcher: TapMatcher<T> | ((v: T) => void | (() => void))): () => void
 }
@@ -23,12 +23,14 @@ const TYPE_STATE = 'State'
 
 /**
  * Create a new state signal
- * 
+ *
  * @since 0.9.0
  * @param {T} initialValue - initial value of the state
  * @returns {State<T>} - new state signal
  */
-export const state = /*#__PURE__*/ <T extends {}>(initialValue: T): State<T> => {
+export const state = /*#__PURE__*/ <T extends {}>(
+	initialValue: T,
+): State<T> => {
 	const watchers: Set<Watcher> = new Set()
 	let value: T = initialValue
 
@@ -37,71 +39,69 @@ export const state = /*#__PURE__*/ <T extends {}>(initialValue: T): State<T> =>
 
 		/**
 		 * Get the current value of the state
-		 * 
+		 *
 		 * @since 0.9.0
 		 * @returns {T} - current value of the state
 		 */
-        get: (): T => {
+		get: (): T => {
 			subscribe(watchers)
-        	return value
+			return value
 		},
 
 		/**
 		 * Set a new value of the state
-		 * 
+		 *
 		 * @since 0.9.0
 		 * @param {T} v
 		 * @returns {void}
 		 */
-        set: (v: T): void => {
-            if (Object.is(value, v)) return
-            value = v
-            notify(watchers)
+		set: (v: T): void => {
+			if (Object.is(value, v)) return
+			value = v
+			notify(watchers)
 
-            // Setting to UNSET clears the watchers so the signal can be garbage collected
-            if (UNSET === value) watchers.clear()
-        },
+			// Setting to UNSET clears the watchers so the signal can be garbage collected
+			if (UNSET === value) watchers.clear()
+		},
 
 		/**
 		 * Update the state with a new value using a function
-		 * 
+		 *
 		 * @since 0.10.0
 		 * @param {(v: T) => T} fn - function to update the state
 		 * @returns {void} - updates the state with the result of the function
 		 */
-        update: (fn: (v: T) => T): void => {
-            s.set(fn(value))
-        },
+		update: (fn: (v: T) => T): void => {
+			s.set(fn(value))
+		},
 
 		/**
 		 * Create a computed signal from the current state signal
-		 * 
+		 *
 		 * @since 0.9.0
 		 * @param {(v: T) => U | Promise<U>} fn - computed callback
 		 * @returns {Computed<U>} - computed signal
 		 */
-		map: <U extends {}>(
-			fn: (v: T) => U | Promise<U>
-		): Computed<U> => 
+		map: <U extends {}>(fn: (v: T) => U | Promise<U>): Computed<U> =>
 			computed({
 				signals: [s],
-				ok: fn
+				ok: fn,
 			}),
 
 		/**
 		 * Case matching for the state signal with effect callbacks
-		 * 
+		 *
 		 * @since 0.13.0
 		 * @param {TapMatcher<T> | ((v: T) => void | (() => void))} matcher - tap matcher or effect callback
 		 * @returns {() => void} - cleanup function for the effect
 		 */
 		tap: (
-			matcher: TapMatcher<T> | ((v: T) => void | (() => void))
-		): () => void =>
+			matcher: TapMatcher<T> | ((v: T) => void | (() => void)),
+		): (() => void) =>
 			effect({
 				signals: [s],
-				...(isFunction(matcher) ? { ok: matcher } : matcher)
-			} as EffectMatcher<[State<T>]>)
+				...(isFunction(matcher) ? { ok: matcher } : matcher),
+			} as EffectMatcher<[State<T>]>),
 	}
 
 	return s
@@ -109,10 +109,11 @@ export const state = /*#__PURE__*/ <T extends {}>(initialValue: T): State<T> =>
 
 /**
  * Check if the provided value is a State instance
- * 
+ *
  * @since 0.9.0
  * @param {unknown} value - value to check
  * @returns {boolean} - true if the value is a State instance, false otherwise
  */
-export const isState = /*#__PURE__*/ <T extends {}>(value: unknown): value is State<T> =>
-	isObjectOfType(value, TYPE_STATE)
+export const isState = /*#__PURE__*/ <T extends {}>(
+	value: unknown,
+): value is State<T> => isObjectOfType(value, TYPE_STATE)

package/{lib → src}/util.d.ts

@@ -8,4 +8,4 @@ declare const toError: (reason: unknown) => Error;
 declare class CircularDependencyError extends Error {
     constructor(where: string);
 }
-export { isFunction, isAsyncFunction, isObjectOfType, isError, isAbortError, isPromise, toError, CircularDependencyError };
+export { isFunction, isAsyncFunction, isObjectOfType, isError, isAbortError, isPromise, toError, CircularDependencyError, };

package/{lib → src}/util.ts

@@ -1,13 +1,18 @@
 /* === Utility Functions === */
 
-const isFunction = /*#__PURE__*/ <T>(value: unknown): value is (...args: unknown[]) => T =>
-    typeof value === 'function'
+const isFunction = /*#__PURE__*/ <T>(
+	value: unknown,
+): value is (...args: unknown[]) => T => typeof value === 'function'
 
-const isAsyncFunction = /*#__PURE__*/ <T>(value: unknown): value is (...args: unknown[]) => Promise<T> =>
+const isAsyncFunction = /*#__PURE__*/ <T>(
+	value: unknown,
+): value is (...args: unknown[]) => Promise<T> =>
 	isFunction(value) && value.constructor.name === 'AsyncFunction'
 
-const isObjectOfType = /*#__PURE__*/ <T>(value: unknown, type: string): value is T =>
-	Object.prototype.toString.call(value) === `[object ${type}]`
+const isObjectOfType = /*#__PURE__*/ <T>(
+	value: unknown,
+	type: string,
+): value is T => Object.prototype.toString.call(value) === `[object ${type}]`
 
 const isError = /*#__PURE__*/ (value: unknown): value is Error =>
 	value instanceof Error
@@ -20,13 +25,18 @@ const toError = (reason: unknown): Error =>
 
 class CircularDependencyError extends Error {
 	constructor(where: string) {
-        super(`Circular dependency in ${where} detected`)
+		super(`Circular dependency in ${where} detected`)
 		return this
-    }
+	}
 }
 
 export {
-	isFunction, isAsyncFunction,
-	isObjectOfType, isError, isAbortError, isPromise, toError,
-	CircularDependencyError
-}
+	isFunction,
+	isAsyncFunction,
+	isObjectOfType,
+	isError,
+	isAbortError,
+	isPromise,
+	toError,
+	CircularDependencyError,
+}

package/test/batch.test.ts

@@ -1,5 +1,5 @@
 import { describe, test, expect } from 'bun:test'
-import { state, computed, effect, batch } from '../'
+import { state, computed, batch } from '../'
 
 /* === Utility Functions === */
 
@@ -8,8 +8,7 @@ const wait = (ms: number) => new Promise(resolve => setTimeout(resolve, ms))
 /* === Tests === */
 
 describe('Batch', function () {
-
-	test('should be triggered only once after repeated state change', function() {
+	test('should be triggered only once after repeated state change', function () {
 		const cause = state(0)
 		let result = 0
 		let count = 0
@@ -23,10 +22,10 @@ describe('Batch', function () {
 			}
 		})
 		expect(result).toBe(10)
-		expect(count).toBe(2); // + 1 for effect initialization
+		expect(count).toBe(2) // + 1 for effect initialization
 	})
 
-	test('should be triggered only once when multiple signals are set', function() {
+	test('should be triggered only once when multiple signals are set', function () {
 		const a = state(3)
 		const b = state(4)
 		const c = state(5)
@@ -46,25 +45,26 @@ describe('Batch', function () {
 			c.set(10)
 		})
 		expect(result).toBe(24)
-		expect(count).toBe(2); // + 1 for effect initialization
+		expect(count).toBe(2) // + 1 for effect initialization
 	})
 
-	test('should prove example from README works', function() {
-
+	test('should prove example from README works', function () {
 		// State: define an array of Signal<number>
 		const signals = [state(2), state(3), state(5)]
 
 		// Computed: derive a calculation ...
-		const sum = computed(() => signals.reduce((total, v) => total + v.get(), 0))
-			.map(v => { // ... perform validation and handle errors
-				if (!Number.isFinite(v)) throw new Error('Invalid value')
-				return v
-			})
+		const sum = computed(() =>
+			signals.reduce((total, v) => total + v.get(), 0),
+		).map(v => {
+			// ... perform validation and handle errors
+			if (!Number.isFinite(v)) throw new Error('Invalid value')
+			return v
+		})
 
 		let result = 0
 		let okCount = 0
 		let errCount = 0
-		
+
 		// Effect: switch cases for the result
 		sum.tap({
 			ok: v => {
@@ -75,7 +75,7 @@ describe('Batch', function () {
 			err: _error => {
 				errCount++
 				// console.error('Error:', error)
-			}
+			},
 		})
 
 		expect(okCount).toBe(1)
@@ -92,9 +92,8 @@ describe('Batch', function () {
 		// Provoke an error
 		signals[0].set(NaN)
 
-        expect(errCount).toBe(1)
-		expect(okCount).toBe(2); // should not have changed due to error
-        expect(result).toBe(20); // should not have changed due to error
+		expect(errCount).toBe(1)
+		expect(okCount).toBe(2) // should not have changed due to error
+		expect(result).toBe(20) // should not have changed due to error
 	})
-
 })

package/test/benchmark.test.ts

@@ -1,6 +1,6 @@
 import { describe, test, expect, mock } from 'bun:test'
 import { state, computed, effect, batch } from '../'
-import { makeGraph, runGraph, Counter } from "./util/dependency-graph"
+import { makeGraph, runGraph, Counter } from './util/dependency-graph'
 
 /* === Utility Functions === */
 
@@ -12,7 +12,7 @@ const busy = () => {
 }
 
 const framework = {
-	name: "Cause & Effect",
+	name: 'Cause & Effect',
 	signal: <T extends {}>(initialValue: T) => {
 		const s = state<T>(initialValue)
 		return {
@@ -45,7 +45,7 @@ function makeConfig() {
 }
 
 /* === Test functions === */
-	 
+
 /** some basic tests to validate the reactive framework
  * wrapper works and can run performance tests.
  */
@@ -55,24 +55,24 @@ describe('Basic test', function () {
 		framework.withBuild(() => {
 			const s = framework.signal(2)
 			const c = framework.computed(() => s.read() * 2)
-		
+
 			expect(c.read()).toEqual(4)
 		})
 	})
-	
+
 	test(`${name} | simple write`, () => {
 		framework.withBuild(() => {
 			const s = framework.signal(2)
 			const c = framework.computed(() => s.read() * 2)
 			expect(s.read()).toEqual(2)
 			expect(c.read()).toEqual(4)
-		
+
 			s.write(3)
 			expect(s.read()).toEqual(3)
 			expect(c.read()).toEqual(6)
 		})
 	})
-	
+
 	test(`${name} | static graph`, () => {
 		const config = makeConfig()
 		const counter = new Counter()
@@ -87,7 +87,7 @@ describe('Basic test', function () {
 			expect(counter.count).toBeGreaterThanOrEqual(11)
 		}
 	})
-	
+
 	test(`${name} | static graph, read 2/3 of leaves`, () => {
 		framework.withBuild(() => {
 			const config = makeConfig()
@@ -98,7 +98,7 @@ describe('Basic test', function () {
 			const graph = makeGraph(framework, config, counter)
 			// @ts-expect-error
 			const sum = runGraph(graph, 10, 2 / 3, framework)
-		
+
 			expect(sum).toEqual(71)
 			if (testPullCounts) {
 				expect(counter.count).toEqual(41)
@@ -107,7 +107,7 @@ describe('Basic test', function () {
 			}
 		})
 	})
-	
+
 	test(`${name} | dynamic graph`, () => {
 		framework.withBuild(() => {
 			const config = makeConfig()
@@ -119,7 +119,7 @@ describe('Basic test', function () {
 			const graph = makeGraph(framework, config, counter)
 			// @ts-expect-error
 			const sum = runGraph(graph, 10, 1, framework)
-		
+
 			expect(sum).toEqual(72)
 			if (testPullCounts) {
 				expect(counter.count).toEqual(22)
@@ -128,38 +128,38 @@ describe('Basic test', function () {
 			}
 		})
 	})
-	
+
 	test(`${name} | withBuild`, () => {
 		const r = framework.withBuild(() => {
 			const s = framework.signal(2)
 			const c = framework.computed(() => s.read() * 2)
-		
+
 			expect(c.read()).toEqual(4)
 			return c.read()
 		})
-	
+
 		// @ts-expect-error
 		expect(r).toEqual(4)
 	})
-	
+
 	test(`${name} | effect`, () => {
-		const spy = (_v) => {}
-    	const spyMock = mock(spy)
-	
+		const spy = _v => {}
+		const spyMock = mock(spy)
+
 		const s = framework.signal(2)
 		let c: any
-	
+
 		framework.withBuild(() => {
-		  c = framework.computed(() => s.read() * 2)
-	
-		  framework.effect(() => {
-			spyMock(c.read())
-		  })
+			c = framework.computed(() => s.read() * 2)
+
+			framework.effect(() => {
+				spyMock(c.read())
+			})
 		})
 		expect(spyMock.mock.calls.length).toBe(1)
-	
+
 		framework.withBatch(() => {
-		  s.write(3)
+			s.write(3)
 		})
 		expect(s.read()).toEqual(3)
 		expect(c.read()).toEqual(6)
@@ -174,12 +174,14 @@ describe('Kairo tests', function () {
 		const head = framework.signal(0)
 		const computed1 = framework.computed(() => head.read())
 		const computed2 = framework.computed(() => (computed1.read(), 0))
-		const computed3 = framework.computed(() => (busy(), computed2.read()! + 1)); // heavy computation
+		const computed3 = framework.computed(
+			() => (busy(), computed2.read()! + 1),
+		) // heavy computation
 		const computed4 = framework.computed(() => computed3.read()! + 2)
 		const computed5 = framework.computed(() => computed4.read()! + 3)
 		framework.effect(() => {
 			computed5.read()
-			busy(); // heavy side effect
+			busy() // heavy side effect
 		})
 
 		return () => {
@@ -268,9 +270,7 @@ describe('Kairo tests', function () {
 		const head = framework.signal(0)
 		let current: { read(): number }[] = []
 		for (let i = 0; i < width; i++) {
-			current.push(
-				framework.computed(() => head.read() + 1)
-			)
+			current.push(framework.computed(() => head.read() + 1))
 		}
 		let sum = framework.computed(() => {
 			return current.map(x => x.read()).reduce((a, b) => a + b, 0)
@@ -299,15 +299,15 @@ describe('Kairo tests', function () {
 	})
 
 	test(`${name} | mux`, function () {
-		let heads = new Array(100).fill(null).map((_) => framework.signal(0))
+		let heads = new Array(100).fill(null).map(_ => framework.signal(0))
 		const mux = framework.computed(() => {
-			return Object.fromEntries(heads.map((h) => h.read()).entries())
+			return Object.fromEntries(heads.map(h => h.read()).entries())
 		})
 		const splited = heads
 			.map((_, index) => framework.computed(() => mux.read()[index]))
-			.map((x) => framework.computed(() => x.read() + 1))
+			.map(x => framework.computed(() => x.read() + 1))
 
-		splited.forEach((x) => {
+		splited.forEach(x => {
 			framework.effect(() => x.read())
 		})
 
@@ -373,7 +373,7 @@ describe('Kairo tests', function () {
 			})
 		}
 		let sum = framework.computed(() => {
-			return list.map((x) => x.read()).reduce((a, b) => a + b, 0)
+			return list.map(x => x.read()).reduce((a, b) => a + b, 0)
 		})
 		let callCounter = new Counter()
 		framework.effect(() => {