@zeix/cause-effect 0.14.0 → 0.14.1

package/src/effect.ts

@@ -1,21 +1,12 @@
-import { type Signal, UNSET } from './signal'
-import {
-	CircularDependencyError,
-	isFunction,
-	toError,
-	isAbortError,
-} from './util'
-import { watch, type Cleanup, type Watcher } from './scheduler'
+import { type Signal, type SignalValues, UNSET } from './signal'
+import { CircularDependencyError, isFunction, toError } from './util'
+import { type Cleanup, watch, observe } from './scheduler'
 
 /* === Types === */
 
 type EffectMatcher<S extends Signal<{}>[]> = {
 	signals: S
-	ok: (
-		...values: {
-			[K in keyof S]: S[K] extends Signal<infer T> ? T : never
-		}
-	) => void | Cleanup
+	ok: (...values: SignalValues<S>) => void | Cleanup
 	err?: (...errors: Error[]) => void | Cleanup
 	nil?: () => void | Cleanup
 }
@@ -40,54 +31,46 @@ function effect<S extends Signal<{}>[]>(
 	} = isFunction(matcher)
 		? { signals: [] as unknown as S, ok: matcher }
 		: matcher
+
 	let running = false
-	const run = (() =>
-		watch(() => {
+	const run = watch(() =>
+		observe(() => {
 			if (running) throw new CircularDependencyError('effect')
 			running = true
-			let cleanup: void | Cleanup = undefined
-			try {
-				const errors: Error[] = []
-				let suspense = false
-				const values = signals.map(signal => {
-					try {
-						const value = signal.get()
-						if (value === UNSET) suspense = true
-						return value
-					} catch (e) {
-						if (isAbortError(e)) throw e
-						errors.push(toError(e))
-						return UNSET
-					}
-				}) as {
-					[K in keyof S]: S[K] extends Signal<infer T extends {}>
-						? T
-						: never
-				}
 
+			// Pure part
+			const errors: Error[] = []
+			let pending = false
+			const values = signals.map(signal => {
 				try {
-					cleanup = suspense
-						? nil()
-						: errors.length
-							? err(...errors)
-							: ok(...values)
+					const value = signal.get()
+					if (value === UNSET) pending = true
+					return value
 				} catch (e) {
-					if (isAbortError(e)) throw e
-					const error = toError(e)
-					cleanup = err(error)
+					errors.push(toError(e))
+					return UNSET
 				}
+			}) as SignalValues<S>
+
+			// Effectful part
+			let cleanup: void | Cleanup = undefined
+			try {
+				cleanup = pending
+					? nil()
+					: errors.length
+						? err(...errors)
+						: ok(...values)
 			} catch (e) {
-				err(toError(e))
+				cleanup = err(toError(e))
+			} finally {
+				if (isFunction(cleanup)) run.off(cleanup)
 			}
-			if (isFunction(cleanup)) run.cleanups.add(cleanup)
+
 			running = false
-		}, run)) as Watcher
-	run.cleanups = new Set<Cleanup>()
+		}, run),
+	)
 	run()
-	return () => {
-		run.cleanups.forEach(fn => fn())
-		run.cleanups.clear()
-	}
+	return () => run.cleanup()
 }
 
 /* === Exports === */

package/src/scheduler.d.ts

@@ -1,9 +1,18 @@
 type Cleanup = () => void;
 type Watcher = {
     (): void;
-    cleanups: Set<Cleanup>;
+    off(cleanup: Cleanup): void;
+    cleanup(): void;
 };
 type Updater = <T>() => T | boolean | void;
+/**
+ * Create a watcher that can be used to observe changes to a signal
+ *
+ * @since 0.14.1
+ * @param {() => void} notice - function to be called when the state changes
+ * @returns {Watcher} - watcher object with off and cleanup methods
+ */
+declare const watch: (notice: () => void) => Watcher;
 /**
  * Add active watcher to the Set of watchers
  *
@@ -30,9 +39,9 @@ declare const batch: (fn: () => void) => void;
  * Run a function in a reactive context
  *
  * @param {() => void} run - function to run the computation or effect
- * @param {Watcher} mark - function to be called when the state changes or undefined for temporary unwatching while inserting auto-hydrating DOM nodes that might read signals (e.g., web components)
+ * @param {Watcher} watcher - function to be called when the state changes or undefined for temporary unwatching while inserting auto-hydrating DOM nodes that might read signals (e.g., web components)
  */
-declare const watch: (run: () => void, mark?: Watcher) => void;
+declare const observe: (run: () => void, watcher?: Watcher) => void;
 /**
  * Enqueue a function to be executed on the next animation frame
  *
@@ -43,4 +52,4 @@ declare const watch: (run: () => void, mark?: Watcher) => void;
  * @param {symbol} dedupe - Symbol for deduplication; if not provided, a unique Symbol is created ensuring the update is always executed
  */
 declare const enqueue: <T>(fn: Updater, dedupe?: symbol) => Promise<boolean | void | T>;
-export { type Cleanup, type Watcher, type Updater, subscribe, notify, flush, batch, watch, enqueue, };
+export { type Cleanup, type Watcher, type Updater, subscribe, notify, flush, batch, watch, observe, enqueue, };

package/src/scheduler.ts

@@ -4,7 +4,8 @@ type Cleanup = () => void
 
 type Watcher = {
 	(): void
-	cleanups: Set<Cleanup>
+	off(cleanup: Cleanup): void
+	cleanup(): void
 }
 
 type Updater = <T>() => T | boolean | void
@@ -26,8 +27,8 @@ const updateDOM = () => {
 	requestId = undefined
 	const updates = Array.from(updateMap.values())
 	updateMap.clear()
-	for (const fn of updates) {
-		fn()
+	for (const update of updates) {
+		update()
 	}
 }
 
@@ -41,17 +42,38 @@ queueMicrotask(updateDOM)
 
 /* === Functions === */
 
+/**
+ * Create a watcher that can be used to observe changes to a signal
+ *
+ * @since 0.14.1
+ * @param {() => void} notice - function to be called when the state changes
+ * @returns {Watcher} - watcher object with off and cleanup methods
+ */
+const watch = (notice: () => void): Watcher => {
+	const cleanups = new Set<Cleanup>()
+	const w = notice as Partial<Watcher>
+	w.off = (on: Cleanup) => {
+		cleanups.add(on)
+	}
+	w.cleanup = () => {
+		for (const cleanup of cleanups) {
+			cleanup()
+		}
+		cleanups.clear()
+	}
+	return w as Watcher
+}
+
 /**
  * Add active watcher to the Set of watchers
  *
  * @param {Set<Watcher>} watchers - watchers of the signal
  */
 const subscribe = (watchers: Set<Watcher>) => {
-	// if (!active) console.warn('Calling .get() outside of a reactive context')
 	if (active && !watchers.has(active)) {
 		const watcher = active
 		watchers.add(watcher)
-		active.cleanups.add(() => {
+		active.off(() => {
 			watchers.delete(watcher)
 		})
 	}
@@ -63,9 +85,9 @@ const subscribe = (watchers: Set<Watcher>) => {
  * @param {Set<Watcher>} watchers - watchers of the signal
  */
 const notify = (watchers: Set<Watcher>) => {
-	for (const mark of watchers) {
-		if (batchDepth) pending.add(mark)
-		else mark()
+	for (const watcher of watchers) {
+		if (batchDepth) pending.add(watcher)
+		else watcher()
 	}
 }
 
@@ -76,8 +98,8 @@ const flush = () => {
 	while (pending.size) {
 		const watchers = Array.from(pending)
 		pending.clear()
-		for (const mark of watchers) {
-			mark()
+		for (const watcher of watchers) {
+			watcher()
 		}
 	}
 }
@@ -101,11 +123,11 @@ const batch = (fn: () => void) => {
  * Run a function in a reactive context
  *
  * @param {() => void} run - function to run the computation or effect
- * @param {Watcher} mark - function to be called when the state changes or undefined for temporary unwatching while inserting auto-hydrating DOM nodes that might read signals (e.g., web components)
+ * @param {Watcher} watcher - function to be called when the state changes or undefined for temporary unwatching while inserting auto-hydrating DOM nodes that might read signals (e.g., web components)
  */
-const watch = (run: () => void, mark?: Watcher): void => {
+const observe = (run: () => void, watcher?: Watcher): void => {
 	const prev = active
-	active = mark
+	active = watcher
 	try {
 		run()
 	} finally {
@@ -145,5 +167,6 @@ export {
 	flush,
 	batch,
 	watch,
+	observe,
 	enqueue,
 }

package/src/signal.d.ts

@@ -1,8 +1,11 @@
-import { type ComputedCallback } from './computed';
+import { type ComputedCallback, isComputedCallback } from './computed';
 type Signal<T extends {}> = {
     get(): T;
 };
 type MaybeSignal<T extends {}> = T | Signal<T> | ComputedCallback<T>;
+type SignalValues<S extends Signal<{}>[]> = {
+    [K in keyof S]: S[K] extends Signal<infer T> ? T : never;
+};
 declare const UNSET: any;
 /**
  * Check whether a value is a Signal or not
@@ -12,14 +15,6 @@ declare const UNSET: any;
  * @returns {boolean} - true if value is a Signal, false otherwise
  */
 declare const isSignal: <T extends {}>(value: unknown) => value is Signal<T>;
-/**
- * Check if the provided value is a callback that may be used as input for toSignal() to derive a computed state
- *
- * @since 0.12.0
- * @param {unknown} value - value to check
- * @returns {boolean} - true if value is a callback or callbacks object, false otherwise
- */
-declare const isComputedCallback: <T extends {}>(value: unknown) => value is ComputedCallback<T>;
 /**
  * Convert a value to a Signal if it's not already a Signal
  *
@@ -28,4 +23,4 @@ declare const isComputedCallback: <T extends {}>(value: unknown) => value is Com
  * @returns {Signal<T>} - converted Signal
  */
 declare const toSignal: <T extends {}>(value: MaybeSignal<T>) => Signal<T>;
-export { type Signal, type MaybeSignal, UNSET, isSignal, isComputedCallback, toSignal, };
+export { type Signal, type MaybeSignal, type SignalValues, UNSET, isSignal, isComputedCallback, toSignal, };

package/src/signal.ts

@@ -2,9 +2,9 @@ import { isState, state } from './state'
 import {
 	type ComputedCallback,
 	isComputed,
+	isComputedCallback,
 	computed,
 } from './computed'
-import { isFunction } from './util'
 
 /* === Types === */
 
@@ -13,11 +13,15 @@ type Signal<T extends {}> = {
 }
 type MaybeSignal<T extends {}> = T | Signal<T> | ComputedCallback<T>
 
+type SignalValues<S extends Signal<{}>[]> = {
+	[K in keyof S]: S[K] extends Signal<infer T> ? T : never
+}
+
 /* === Constants === */
 
 const UNSET: any = Symbol()
 
-/* === Exported Functions === */
+/* === Functions === */
 
 /**
  * Check whether a value is a Signal or not
@@ -30,17 +34,6 @@ const isSignal = /*#__PURE__*/ <T extends {}>(
 	value: unknown,
 ): value is Signal<T> => isState(value) || isComputed(value)
 
-/**
- * Check if the provided value is a callback that may be used as input for toSignal() to derive a computed state
- *
- * @since 0.12.0
- * @param {unknown} value - value to check
- * @returns {boolean} - true if value is a callback or callbacks object, false otherwise
- */
-const isComputedCallback = /*#__PURE__*/ <T extends {}>(
-	value: unknown,
-): value is ComputedCallback<T> => isFunction(value) && value.length < 2
-
 /**
  * Convert a value to a Signal if it's not already a Signal
  *
@@ -62,6 +55,7 @@ const toSignal = /*#__PURE__*/ <T extends {}>(
 export {
 	type Signal,
 	type MaybeSignal,
+	type SignalValues,
 	UNSET,
 	isSignal,
 	isComputedCallback,

package/src/state.d.ts

@@ -4,6 +4,7 @@ type State<T extends {}> = {
     set(v: T): void;
     update(fn: (v: T) => T): void;
 };
+declare const TYPE_STATE = "State";
 /**
  * Create a new state signal
  *
@@ -20,4 +21,4 @@ declare const state: <T extends {}>(initialValue: T) => State<T>;
  * @returns {boolean} - true if the value is a State instance, false otherwise
  */
 declare const isState: <T extends {}>(value: unknown) => value is State<T>;
-export { type State, state, isState };
+export { type State, TYPE_STATE, state, isState };

package/src/state.ts

@@ -86,4 +86,4 @@ const isState = /*#__PURE__*/ <T extends {}>(
 
 /* === Exports === */
 
-export { type State, state, isState }
+export { type State, TYPE_STATE, state, isState }

package/src/util.d.ts

@@ -1,11 +1,7 @@
 declare const isFunction: <T>(value: unknown) => value is (...args: unknown[]) => T;
-declare const isAsyncFunction: <T>(value: unknown) => value is (...args: unknown[]) => Promise<T>;
 declare const isObjectOfType: <T>(value: unknown, type: string) => value is T;
-declare const isError: (value: unknown) => value is Error;
-declare const isAbortError: (value: unknown) => value is DOMException;
-declare const isPromise: <T>(value: unknown) => value is Promise<T>;
 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, isObjectOfType, toError, CircularDependencyError };

package/src/util.ts

@@ -4,24 +4,13 @@ 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> =>
-	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 isError = /*#__PURE__*/ (value: unknown): value is Error =>
-	value instanceof Error
-const isAbortError = /*#__PURE__*/ (value: unknown): value is DOMException =>
-	value instanceof DOMException && value.name === 'AbortError'
-const isPromise = /*#__PURE__*/ <T>(value: unknown): value is Promise<T> =>
-	value instanceof Promise
 const toError = (reason: unknown): Error =>
-	isError(reason) ? reason : Error(String(reason))
+	reason instanceof Error ? reason : Error(String(reason))
 
 class CircularDependencyError extends Error {
 	constructor(where: string) {
@@ -32,13 +21,4 @@ class CircularDependencyError extends Error {
 
 /* === Exports === */
 
-export {
-	isFunction,
-	isAsyncFunction,
-	isObjectOfType,
-	isError,
-	isAbortError,
-	isPromise,
-	toError,
-	CircularDependencyError,
-}
+export { isFunction, isObjectOfType, toError, CircularDependencyError }

package/test/batch.test.ts

@@ -1,5 +1,5 @@
 import { describe, test, expect } from 'bun:test'
-import { state, memo, batch, effect } from '../'
+import { state, computed, batch, effect } from '../'
 
 /* === Tests === */
 
@@ -25,7 +25,7 @@ describe('Batch', function () {
 		const a = state(3)
 		const b = state(4)
 		const c = state(5)
-		const sum = memo(() => a.get() + b.get() + c.get())
+		const sum = computed(() => a.get() + b.get() + c.get())
 		let result = 0
 		let count = 0
 		effect({
@@ -50,7 +50,7 @@ describe('Batch', function () {
 		const signals = [state(2), state(3), state(5)]
 
 		// Computed: derive a calculation ...
-		const sum = memo(() => {
+		const sum = computed(() => {
 			const v = signals.reduce((total, v) => total + v.get(), 0)
 			if (!Number.isFinite(v)) throw new Error('Invalid value')
 			return v

package/test/benchmark.test.ts

@@ -1,5 +1,5 @@
 import { describe, test, expect, mock } from 'bun:test'
-import { state, memo, effect, batch } from '../'
+import { state, computed, effect, batch } from '../'
 import { makeGraph, runGraph, Counter } from './util/dependency-graph'
 import {
 	type ReactiveFramework,
@@ -25,7 +25,7 @@ const framework = {
 		}
 	},
 	computed: <T extends {}>(fn: () => T) => {
-		const c = memo(fn)
+		const c = computed(fn)
 		return {
 			read: () => c.get(),
 		}