@zeix/cause-effect 0.17.2 → 0.17.3

package/test/store.test.ts

@@ -8,7 +8,6 @@ import {
 	State,
 	UNSET,
 } from '../index.ts'
-import { HOOK_WATCH } from '../src/system'
 
 describe('store', () => {
 	describe('creation and basic operations', () => {
@@ -226,114 +225,6 @@ describe('store', () => {
 		})
 	})
 
-	describe('Hooks', () => {
-		test('triggers HOOK_ADD when properties are added', () => {
-			let addedKeys: readonly string[] | undefined
-			const user = createStore<{ name: string; email?: string }>({
-				name: 'John',
-			})
-			user.on('add', add => {
-				addedKeys = add
-			})
-			user.add('email', 'john@example.com')
-			expect(addedKeys).toContain('email')
-		})
-
-		test('triggers HOOK_CHANGE when properties are modified', () => {
-			const user = createStore({ name: 'John' })
-			let changedKeys: readonly string[] | undefined
-			user.on('change', change => {
-				changedKeys = change
-			})
-			user.name.set('Jane')
-			expect(changedKeys).toContain('name')
-		})
-
-		test('triggers HOOK_CHANGE for nested property changes', () => {
-			const user = createStore({
-				preferences: {
-					theme: 'light',
-				},
-			})
-			let changedKeys: readonly string[] | undefined
-			user.on('change', change => {
-				changedKeys = change
-			})
-			user.preferences.theme.set('dark')
-			expect(changedKeys).toContain('preferences')
-		})
-
-		test('triggers HOOK_REMOVE when properties are removed', () => {
-			const user = createStore({
-				name: 'John',
-				email: 'john@example.com',
-			})
-			let removedKeys: readonly string[] | undefined
-			user.on('remove', remove => {
-				removedKeys = remove
-			})
-			user.remove('email')
-			expect(removedKeys).toContain('email')
-		})
-
-		test('set() correctly handles mixed changes, additions, and removals', () => {
-			const user = createStore<{
-				name: string
-				email?: string
-				preferences: { theme?: string }
-				age?: number
-			}>({
-				name: 'John',
-				email: 'john@example.com',
-				preferences: {
-					theme: 'light',
-				},
-			})
-
-			let changedKeys: readonly string[] | undefined
-			let addedKeys: readonly string[] | undefined
-			let removedKeys: readonly string[] | undefined
-
-			user.on('change', change => {
-				changedKeys = change
-			})
-			user.on('add', add => {
-				addedKeys = add
-			})
-			user.on('remove', remove => {
-				removedKeys = remove
-			})
-
-			user.set({
-				name: 'Jane',
-				preferences: {
-					theme: 'dark',
-				},
-				age: 30,
-			})
-
-			expect(changedKeys).toContain('name')
-			expect(changedKeys).toContain('preferences')
-			expect(addedKeys).toContain('age')
-			expect(removedKeys).toContain('email')
-		})
-
-		test('hooks can be removed', () => {
-			const user = createStore({ name: 'John' })
-			let notificationCount = 0
-			const listener = () => {
-				notificationCount++
-			}
-			const off = user.on('change', listener)
-			user.name.set('Jane')
-			expect(notificationCount).toBe(1)
-
-			off()
-			user.name.set('Bob')
-			expect(notificationCount).toBe(1)
-		})
-	})
-
 	describe('reactivity', () => {
 		test('store-level get() is reactive', () => {
 			const user = createStore({
@@ -662,173 +553,39 @@ describe('store', () => {
 		})
 	})
 
-	describe('HOOK_WATCH - Store Hierarchy Resource Management', () => {
-		test('Store HOOK_WATCH triggers for all nested stores when accessing parent', async () => {
-			const store = createStore({
-				app: {
-					database: {
-						host: 'localhost',
-						port: 5432,
-					},
-					cache: {
-						ttl: 3600,
-					},
-				},
-			})
-
-			let appCounter = 0
-			let databaseCounter = 0
-			let cacheCounter = 0
-
-			const appCleanup = store.app.on(HOOK_WATCH, () => {
-				appCounter++
-				return () => {
-					appCounter--
-				}
-			})
-
-			const databaseCleanup = store.app.database.on(HOOK_WATCH, () => {
-				databaseCounter++
-				return () => {
-					databaseCounter--
-				}
-			})
-
-			const cacheCleanup = store.app.cache.on(HOOK_WATCH, () => {
-				cacheCounter++
-				return () => {
-					cacheCounter--
-				}
-			})
-
-			// Initially no watchers
-			expect(appCounter).toBe(0)
-			expect(databaseCounter).toBe(0)
-			expect(cacheCounter).toBe(0)
-
-			// Access app store - should trigger ALL nested HOOK_WATCH callbacks
-			const appEffect = createEffect(() => {
-				store.app.get()
-			})
-
-			expect(appCounter).toBe(1)
-			expect(databaseCounter).toBe(1)
-			expect(cacheCounter).toBe(1)
-
-			// Cleanup should reset all counters
-			appEffect()
-			expect(appCounter).toBe(0)
-			expect(databaseCounter).toBe(0)
-			expect(cacheCounter).toBe(0)
-
-			appCleanup()
-			databaseCleanup()
-			cacheCleanup()
-		})
-
-		test('Nested store cleanup only happens when all levels are unwatched', async () => {
-			const store = createStore({
-				user: {
-					profile: {
-						settings: {
-							theme: 'dark',
+	describe('Watch Callbacks', () => {
+		test('Root store watched callback triggered only by direct store access', async () => {
+			let rootStoreCounter = 0
+			let intervalId: Timer | undefined
+			const store = createStore(
+				{
+					user: {
+						name: 'John',
+						profile: {
+							email: 'john@example.com',
 						},
 					},
 				},
-			})
-
-			let counter = 0
-			let intervalId: Timer | undefined
-
-			// Add HOOK_WATCH to deepest nested store
-			const settingsCleanup = store.user.profile.settings.on(
-				HOOK_WATCH,
-				() => {
-					intervalId = setInterval(() => {
-						counter++
-					}, 10)
-
-					return () => {
+				{
+					watched: () => {
+						intervalId = setInterval(() => {
+							rootStoreCounter++
+						}, 10)
+					},
+					unwatched: () => {
 						if (intervalId) {
 							clearInterval(intervalId)
 							intervalId = undefined
 						}
-					}
-				},
-			)
-
-			expect(counter).toBe(0)
-
-			// Access parent store - should trigger settings HOOK_WATCH
-			const parentEffect = createEffect(() => {
-				store.user.get()
-			})
-
-			await new Promise(resolve => setTimeout(resolve, 50))
-			expect(counter).toBeGreaterThan(0)
-			expect(intervalId).toBeDefined()
-
-			// Access intermediate store - settings should still be active
-			const profileEffect = createEffect(() => {
-				store.user.profile.get()
-			})
-
-			const counterAfterProfile = counter
-			await new Promise(resolve => setTimeout(resolve, 50))
-			expect(counter).toBeGreaterThan(counterAfterProfile)
-			expect(intervalId).toBeDefined()
-
-			// Remove parent watcher, but profile watcher still active
-			parentEffect()
-
-			const counterAfterParentRemoval = counter
-			await new Promise(resolve => setTimeout(resolve, 50))
-			expect(counter).toBeGreaterThan(counterAfterParentRemoval)
-			expect(intervalId).toBeDefined() // Still running
-
-			// Remove profile watcher - now should cleanup
-			profileEffect()
-
-			const counterAfterAllRemoval = counter
-			await new Promise(resolve => setTimeout(resolve, 50))
-			expect(counter).toBe(counterAfterAllRemoval) // Stopped
-			expect(intervalId).toBeUndefined()
-
-			settingsCleanup()
-		})
-
-		test('Root store HOOK_WATCH triggered only by direct store access', async () => {
-			const store = createStore({
-				user: {
-					name: 'John',
-					profile: {
-						email: 'john@example.com',
 					},
 				},
-			})
-
-			let rootStoreCounter = 0
-			let intervalId: Timer | undefined
-
-			// Add HOOK_WATCH callback to root store
-			const cleanupHookCallback = store.on(HOOK_WATCH, () => {
-				intervalId = setInterval(() => {
-					rootStoreCounter++
-				}, 10)
-
-				return () => {
-					if (intervalId) {
-						clearInterval(intervalId)
-						intervalId = undefined
-					}
-				}
-			})
+			)
 
 			expect(rootStoreCounter).toBe(0)
 			await new Promise(resolve => setTimeout(resolve, 50))
 			expect(rootStoreCounter).toBe(0)
 
-			// Access nested property directly - should NOT trigger root HOOK_WATCH
+			// Access nested property directly - should NOT trigger root watched callback
 			const nestedEffectCleanup = createEffect(() => {
 				store.user.name.get()
 			})
@@ -837,7 +594,7 @@ describe('store', () => {
 			expect(rootStoreCounter).toBe(0) // Still 0 - nested access doesn't trigger root
 			expect(intervalId).toBeUndefined()
 
-			// Access root store directly - should trigger HOOK_WATCH
+			// Access root store directly - should trigger watched callback
 			const rootEffectCleanup = createEffect(() => {
 				store.get()
 			})
@@ -851,169 +608,37 @@ describe('store', () => {
 			nestedEffectCleanup()
 			await new Promise(resolve => setTimeout(resolve, 50))
 			expect(intervalId).toBeUndefined()
-
-			cleanupHookCallback()
 		})
 
-		test('Each store level manages its own HOOK_WATCH independently', async () => {
-			const store = createStore({
-				config: {
-					database: {
-						host: 'localhost',
-						port: 5432,
-					},
+		test('Store property addition/removal affects store watched callback', async () => {
+			let usersStoreCounter = 0
+			const store = createStore(
+				{
+					users: {} as Record<string, { name: string }>,
 				},
-			})
-
-			let rootCounter = 0
-			let configCounter = 0
-			let databaseCounter = 0
-
-			// Add HOOK_WATCH to each level
-			const rootCleanup = store.on(HOOK_WATCH, () => {
-				rootCounter++
-				return () => {
-					rootCounter--
-				}
-			})
-
-			const configCleanup = store.config.on(HOOK_WATCH, () => {
-				configCounter++
-				return () => {
-					configCounter--
-				}
-			})
-
-			const databaseCleanup = store.config.database.on(HOOK_WATCH, () => {
-				databaseCounter++
-				return () => {
-					databaseCounter--
-				}
-			})
-
-			// All should start at 0
-			expect(rootCounter).toBe(0)
-			expect(configCounter).toBe(0)
-			expect(databaseCounter).toBe(0)
-
-			// Access deepest level - should NOT trigger any store HOOK_WATCH
-			// because we're only accessing the State signal, not calling .get() on stores
-			const deepEffectCleanup = createEffect(() => {
-				store.config.database.host.get()
-			})
-
-			expect(rootCounter).toBe(0)
-			expect(configCounter).toBe(0)
-			expect(databaseCounter).toBe(0)
-
-			// Access config level - should trigger config AND database HOOK_WATCH
-			const configEffectCleanup = createEffect(() => {
-				store.config.get()
-			})
-
-			expect(rootCounter).toBe(0)
-			expect(configCounter).toBe(1)
-			expect(databaseCounter).toBe(1) // Triggered by parent access
-
-			// Access root level - should trigger root HOOK_WATCH (config/database already active)
-			const rootEffectCleanup = createEffect(() => {
-				store.get()
-			})
-
-			expect(rootCounter).toBe(1)
-			expect(configCounter).toBe(1)
-			expect(databaseCounter).toBe(1)
-
-			// Cleanup in reverse order - database should stay active until config is cleaned up
-			rootEffectCleanup()
-			expect(rootCounter).toBe(0)
-			expect(configCounter).toBe(1)
-			expect(databaseCounter).toBe(1) // Still active due to config watcher
-
-			configEffectCleanup()
-			expect(rootCounter).toBe(0)
-			expect(configCounter).toBe(0)
-			expect(databaseCounter).toBe(0) // Now cleaned up
-
-			deepEffectCleanup()
-			expect(rootCounter).toBe(0)
-			expect(configCounter).toBe(0)
-			expect(databaseCounter).toBe(0)
-
-			// Cleanup hooks
-			rootCleanup()
-			configCleanup()
-			databaseCleanup()
-		})
-
-		test('Store HOOK_WATCH with multiple watchers at same level', async () => {
-			const store = createStore({
-				data: {
-					items: [] as string[],
-					count: 0,
+				{
+					watched: () => {
+						usersStoreCounter++
+					},
+					unwatched: () => {
+						usersStoreCounter--
+					},
 				},
-			})
-
-			let dataStoreCounter = 0
-
-			const dataCleanup = store.data.on(HOOK_WATCH, () => {
-				dataStoreCounter++
-				return () => {
-					dataStoreCounter--
-				}
-			})
-
-			expect(dataStoreCounter).toBe(0)
-
-			// Create multiple effects watching the data store
-			const effect1 = createEffect(() => {
-				store.data.get()
-			})
-			const effect2 = createEffect(() => {
-				store.data.get()
-			})
-
-			// Should only trigger once (shared resources)
-			expect(dataStoreCounter).toBe(1)
-
-			// Stop one effect
-			effect1()
-			expect(dataStoreCounter).toBe(1) // Still active
-
-			// Stop second effect
-			effect2()
-			expect(dataStoreCounter).toBe(0) // Now cleaned up
-
-			dataCleanup()
-		})
-
-		test('Store property addition/removal affects individual store HOOK_WATCH', async () => {
-			const store = createStore({
-				users: {} as Record<string, { name: string }>,
-			})
-
-			let usersStoreCounter = 0
-
-			const usersCleanup = store.users.on(HOOK_WATCH, () => {
-				usersStoreCounter++
-				return () => {
-					usersStoreCounter--
-				}
-			})
+			)
 
 			expect(usersStoreCounter).toBe(0)
 
-			// Watch the users store
+			// Watch the entire store
 			const usersEffect = createEffect(() => {
-				store.users.get()
+				store.get()
 			})
 			expect(usersStoreCounter).toBe(1)
 
-			// Add a user - this modifies the users store content but doesn't affect HOOK_WATCH
+			// Add a user - this modifies the users store content but doesn't affect watched callback
 			store.users.add('user1', { name: 'Alice' })
 			expect(usersStoreCounter).toBe(1) // Still 1
 
-			// Watch a specific user property - this doesn't trigger users store HOOK_WATCH
+			// Watch a specific user property - this doesn't trigger users store watched callback
 			const userEffect = createEffect(() => {
 				store.users.user1?.name.get()
 			})
@@ -1026,83 +651,6 @@ describe('store', () => {
 			// Cleanup users effect
 			usersEffect()
 			expect(usersStoreCounter).toBe(0) // Now cleaned up
-
-			usersCleanup()
-		})
-
-		test('Exception handling in store HOOK_WATCH callbacks', async () => {
-			const store = createStore({
-				config: { theme: 'dark' },
-			})
-
-			let successfulCallbackCalled = false
-			let throwingCallbackCalled = false
-
-			// Add throwing callback
-			const cleanup1 = store.on(HOOK_WATCH, () => {
-				throwingCallbackCalled = true
-				throw new Error('Test error in store HOOK_WATCH')
-			})
-
-			// Add successful callback
-			const cleanup2 = store.on(HOOK_WATCH, () => {
-				successfulCallbackCalled = true
-				return () => {
-					// cleanup
-				}
-			})
-
-			// Trigger callbacks through direct store access - should throw
-			expect(() => store.get()).toThrow('Test error in store HOOK_WATCH')
-
-			// Both callbacks should have been called
-			expect(throwingCallbackCalled).toBe(true)
-			expect(successfulCallbackCalled).toBe(true)
-
-			cleanup1()
-			cleanup2()
-		})
-
-		test('Nested store HOOK_WATCH with computed signals', async () => {
-			const store = createStore({
-				user: {
-					firstName: 'John',
-					lastName: 'Doe',
-				},
-			})
-
-			let userStoreCounter = 0
-
-			const userCleanup = store.user.on(HOOK_WATCH, () => {
-				userStoreCounter++
-				return () => {
-					userStoreCounter--
-				}
-			})
-
-			expect(userStoreCounter).toBe(0)
-
-			// Access user store directly - should trigger user store HOOK_WATCH
-			const userEffect = createEffect(() => {
-				store.user.get()
-			})
-			expect(userStoreCounter).toBe(1)
-
-			// Access individual properties - should NOT trigger user store HOOK_WATCH again
-			const nameEffect = createEffect(() => {
-				store.user.firstName.get()
-			})
-			expect(userStoreCounter).toBe(1) // Still 1
-
-			// Cleanup individual property effect first
-			nameEffect()
-			expect(userStoreCounter).toBe(1) // Still active due to user store effect
-
-			// Cleanup user store effect - now should be cleaned up
-			userEffect()
-			expect(userStoreCounter).toBe(0) // Now cleaned up
-
-			userCleanup()
 		})
 	})
 })

package/test/util/dependency-graph.ts

@@ -124,7 +124,7 @@ function makeDependentRows(
 ): Computed<number>[][] {
 	let prevRow = sources
 	const rand = new Random('seed')
-	const rows = []
+	const rows: Computed<number>[][] = []
 	for (let l = 0; l < numRows; l++) {
 		const row = makeRow(
 			prevRow,
@@ -135,7 +135,7 @@ function makeDependentRows(
 			l,
 			rand,
 		)
-		rows.push(row as never)
+		rows.push(row)
 		prevRow = row
 	}
 	return rows

package/tsconfig.build.json

@@ -0,0 +1,11 @@
+{
+	"extends": "./tsconfig.json",
+	"compilerOptions": {
+		"noEmit": false,
+		"declaration": true,
+		"declarationDir": "./types",
+		"emitDeclarationOnly": true,
+	},
+	"include": ["./index.ts", "./src/**/*.ts"],
+	"exclude": ["node_modules", "types", "test", "archive"],
+}

package/tsconfig.json

@@ -13,6 +13,9 @@
 		"allowImportingTsExtensions": true,
 		"verbatimModuleSyntax": true,
 
+		// Editor-only mode - no emit
+		"noEmit": true,
+
 		// Best practices
 		"strict": true,
 		"skipLibCheck": true,
@@ -22,12 +25,7 @@
 		"noUnusedLocals": false,
 		"noUnusedParameters": false,
 		"noPropertyAccessFromIndexSignature": false,
-
-		// Declarations
-		"declaration": true,
-		"declarationDir": "./types",
-		"emitDeclarationOnly": true
 	},
-	"include": ["./*.ts", "./src/*.ts"],
-	"exclude": ["node_modules", "test", "types"]
+	"include": ["./**/*.ts"],
+	"exclude": ["node_modules", "types"],
 }

package/types/index.d.ts

@@ -1,6 +1,6 @@
 /**
  * @name Cause & Effect
- * @version 0.17.2
+ * @version 0.17.3
  * @author Esther Brunner
  */
 export { type Collection, type CollectionCallback, type CollectionSource, DerivedCollection, isCollection, TYPE_COLLECTION, } from './src/classes/collection';
@@ -15,5 +15,5 @@ export { CircularDependencyError, createError, DuplicateKeyError, type Guard, gu
 export { type MatchHandlers, match } from './src/match';
 export { type ResolveResult, resolve } from './src/resolve';
 export { createSignal, isMutableSignal, isSignal, type Signal, type SignalValues, type UnknownSignalRecord, } from './src/signal';
-export { batchSignalWrites, type Cleanup, createWatcher, flushPendingReactions, HOOK_ADD, HOOK_CHANGE, HOOK_CLEANUP, HOOK_REMOVE, HOOK_SORT, HOOK_WATCH, type Hook, type CleanupHook, type WatchHook, type HookCallback, type HookCallbacks, isHandledHook, notifyWatchers, subscribeActiveWatcher, trackSignalReads, triggerHook, UNSET, type Watcher, } from './src/system';
+export { batch, type Cleanup, createWatcher, flush, notifyOf, type SignalOptions, subscribeTo, track, UNSET, untrack, type Watcher, } from './src/system';
 export { isAbortError, isAsyncFunction, isFunction, isNumber, isObjectOfType, isRecord, isRecordOrArray, isString, isSymbol, valueString, } from './src/util';

package/types/src/classes/collection.d.ts

@@ -1,5 +1,5 @@
 import type { Signal } from '../signal';
-import { type Cleanup, type Hook, type HookCallback } from '../system';
+import { type SignalOptions } from '../system';
 import { type Computed } from './computed';
 import { type List } from './list';
 type CollectionSource<T extends {}> = List<T> | Collection<T>;
@@ -14,14 +14,13 @@ type Collection<T extends {}> = {
     byKey: (key: string) => Signal<T> | undefined;
     keyAt: (index: number) => string | undefined;
     indexOfKey: (key: string) => number | undefined;
-    on: <K extends Hook>(type: K, callback: HookCallback) => Cleanup;
     deriveCollection: <R extends {}>(callback: CollectionCallback<R, T>) => DerivedCollection<R, T>;
     readonly length: number;
 };
 declare const TYPE_COLLECTION: "Collection";
 declare class DerivedCollection<T extends {}, U extends {}> implements Collection<T> {
     #private;
-    constructor(source: CollectionSource<U> | (() => CollectionSource<U>), callback: CollectionCallback<T, U>);
+    constructor(source: CollectionSource<U> | (() => CollectionSource<U>), callback: CollectionCallback<T, U>, options?: SignalOptions<T[]>);
     get [Symbol.toStringTag](): 'Collection';
     get [Symbol.isConcatSpreadable](): true;
     [Symbol.iterator](): IterableIterator<Computed<T>>;
@@ -31,9 +30,8 @@ declare class DerivedCollection<T extends {}, U extends {}> implements Collectio
     byKey(key: string): Computed<T> | undefined;
     keyAt(index: number): string | undefined;
     indexOfKey(key: string): number;
-    on(type: Hook, callback: HookCallback): Cleanup;
-    deriveCollection<R extends {}>(callback: (sourceValue: T) => R): DerivedCollection<R, T>;
-    deriveCollection<R extends {}>(callback: (sourceValue: T, abort: AbortSignal) => Promise<R>): DerivedCollection<R, T>;
+    deriveCollection<R extends {}>(callback: (sourceValue: T) => R, options?: SignalOptions<R[]>): DerivedCollection<R, T>;
+    deriveCollection<R extends {}>(callback: (sourceValue: T, abort: AbortSignal) => Promise<R>, options?: SignalOptions<R[]>): DerivedCollection<R, T>;
     get length(): number;
 }
 /**