@zeix/cause-effect 0.12.4 → 0.13.1

package/lib/state.ts

@@ -1,18 +1,18 @@
-import { UNSET, type ComputedCallbacks, type EffectCallbacks } from './signal'
+import { UNSET } from './signal'
 import { type Computed, computed } from './computed'
-import { isObjectOfType } from './util';
+import { isFunction, isObjectOfType } from './util'
 import { type Watcher, notify, subscribe } from './scheduler'
-import { effect } from './effect';
+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;
-    map<U extends {}>(cb: ComputedCallbacks<U, [State<T>]>): Computed<U>;
-	match: (cb: EffectCallbacks<[State<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
 }
 
 /* === Constants === */
@@ -29,7 +29,7 @@ const TYPE_STATE = 'State'
  * @returns {State<T>} - new state signal
  */
 export const state = /*#__PURE__*/ <T extends {}>(initialValue: T): State<T> => {
-	const watchers: Watcher[] = []
+	const watchers: Set<Watcher> = new Set()
 	let value: T = initialValue
 
 	const s: State<T> = {
@@ -59,7 +59,7 @@ export const state = /*#__PURE__*/ <T extends {}>(initialValue: T): State<T> =>
             notify(watchers)
 
             // Setting to UNSET clears the watchers so the signal can be garbage collected
-            if (UNSET === value) watchers.length = 0 // head = tail = undefined
+            if (UNSET === value) watchers.clear()
         },
 
 		/**
@@ -77,24 +77,31 @@ export const state = /*#__PURE__*/ <T extends {}>(initialValue: T): State<T> =>
 		 * Create a computed signal from the current state signal
 		 * 
 		 * @since 0.9.0
-		 * @param {ComputedCallbacks<U, [State<T>]>} cb - compute callback or object of ok, nil, err callbacks to map this value to new computed
+		 * @param {(v: T) => U | Promise<U>} fn - computed callback
 		 * @returns {Computed<U>} - computed signal
 		 */
-        map: <U extends {}>(cb: ComputedCallbacks<U, [State<T>]>): Computed<U> =>
-            computed(cb, s),
+		map: <U extends {}>(
+			fn: (v: T) => U | Promise<U>
+		): Computed<U> => 
+			computed({
+				signals: [s],
+				ok: fn
+			}),
 
 		/**
 		 * Case matching for the state signal with effect callbacks
 		 * 
-		 * @since 0.12.0
-		 * @method of State<T>
-		 * @param {EffectCallbacks<[State<T>]>} cb - effect callback or object of ok, nil, err callbacks to be executed when the state changes
-		 * @returns {State<T>} - self, for chaining 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
 		 */
-		match: (cb: EffectCallbacks<[State<T>]>): State<T> => {
-			effect(cb, s)
-			return s
-		}
+		tap: (
+			matcher: TapMatcher<T> | ((v: T) => void | (() => void))
+		): () => void =>
+			effect({
+				signals: [s],
+				...(isFunction(matcher) ? { ok: matcher } : matcher)
+			} as EffectMatcher<[State<T>]>)
 	}
 
 	return s

package/lib/util.d.ts

@@ -1,8 +1,11 @@
 declare const isFunction: <T>(value: unknown) => value is (...args: unknown[]) => T;
-declare const isAsyncFunction: <T>(value: unknown) => value is (...args: unknown[]) => Promise<T> | PromiseLike<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 isInstanceOf: <T>(type: new (...args: any[]) => T) => (value: unknown) => value is T;
 declare const isError: (value: unknown) => value is Error;
-declare const isPromise: (value: unknown) => value is Promise<unknown>;
-declare const toError: (value: unknown) => Error;
-export { isFunction, isAsyncFunction, isObjectOfType, isInstanceOf, isError, isPromise, toError };
+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 };

package/lib/util.ts

@@ -3,23 +3,30 @@
 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> | PromiseLike<T> =>
-	isFunction(value) && /^async\s+/.test(value.toString())
+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 isInstanceOf = /*#__PURE__*/ <T>(type: new (...args: any[]) => T) =>
-	(value: unknown): value is T =>
-		value instanceof 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))
 
-const isError = /*#__PURE__*/ isInstanceOf(Error)
-const isPromise = /*#__PURE__*/ isInstanceOf(Promise)
-
-const toError = (value: unknown): Error =>
-	isError(value) ? value : new Error(String(value))
+class CircularDependencyError extends Error {
+	constructor(where: string) {
+        super(`Circular dependency in ${where} detected`)
+		return this
+    }
+}
 
 export {
 	isFunction, isAsyncFunction,
-	isObjectOfType, isInstanceOf, isError, isPromise, toError
+	isObjectOfType, isError, isAbortError, isPromise, toError,
+	CircularDependencyError
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zeix/cause-effect",
-  "version": "0.12.4",
+  "version": "0.13.1",
   "author": "Esther Brunner",
   "main": "index.js",
   "module": "index.ts",
@@ -28,4 +28,4 @@
   },
   "type": "module",
   "types": "index.d.ts"
-}
+}

package/test/batch.test.ts

@@ -10,41 +10,44 @@ const wait = (ms: number) => new Promise(resolve => setTimeout(resolve, ms))
 describe('Batch', function () {
 
 	test('should be triggered only once after repeated state change', function() {
-		const cause = state(0);
-		let result = 0;
-		let count = 0;
-		effect((res) => {
-			result = res;
-			count++;
-		}, cause);
+		const cause = state(0)
+		let result = 0
+		let count = 0
+		cause.tap(res => {
+			result = res
+			count++
+		})
 		batch(() => {
 			for (let i = 1; i <= 10; i++) {
-				cause.set(i);
+				cause.set(i)
 			}
-		});
-		expect(result).toBe(10);
+		})
+		expect(result).toBe(10)
 		expect(count).toBe(2); // + 1 for effect initialization
-	});
+	})
 
 	test('should be triggered only once when multiple signals are set', function() {
-		const a = state(3);
-		const b = state(4);
-		const c = state(5);
-		const sum = computed(() => a.get() + b.get() + c.get());
-		let result = 0;
-		let count = 0;
-		effect((res) => {
-			result = res;
-			count++;
-		}, sum);
+		const a = state(3)
+		const b = state(4)
+		const c = state(5)
+		const sum = computed(() => a.get() + b.get() + c.get())
+		let result = 0
+		let count = 0
+		sum.tap({
+			ok: res => {
+				result = res
+				count++
+			},
+			err: () => {},
+		})
 		batch(() => {
-			a.set(6);
-			b.set(8);
-			c.set(10);
-		});
-		expect(result).toBe(24);
+			a.set(6)
+			b.set(8)
+			c.set(10)
+		})
+		expect(result).toBe(24)
 		expect(count).toBe(2); // + 1 for effect initialization
-	});
+	})
 
 	test('should prove example from README works', function() {
 
@@ -52,20 +55,18 @@ describe('Batch', function () {
 		const signals = [state(2), state(3), state(5)]
 
 		// Computed: derive a calculation ...
-		const sum = computed(
-			(...values) => values.reduce((total, v) => total + v, 0),
-			...signals
-		).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.match({
+		sum.tap({
 			ok: v => {
 				result = v
 				okCount++
@@ -77,23 +78,23 @@ describe('Batch', function () {
 			}
 		})
 
-		expect(okCount).toBe(1);
-		expect(result).toBe(10);
+		expect(okCount).toBe(1)
+		expect(result).toBe(10)
 
 		// Batch: apply changes to all signals in a single transaction
 		batch(() => {
 			signals.forEach(signal => signal.update(v => v * 2))
 		})
 
-		expect(okCount).toBe(2);
-		expect(result).toBe(20);
+		expect(okCount).toBe(2)
+		expect(result).toBe(20)
 
 		// Provoke an error
 		signals[0].set(NaN)
 
-        expect(errCount).toBe(1);
+        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
-	});
+	})
 
-});
+})