mutts 1.0.4 → 1.0.5

package/src/reactive/project.ts

@@ -1,9 +1,29 @@
 import { ReflectGet, ReflectSet } from '../utils'
+import { setEffectName } from './debug'
+import { getActiveEffect } from './effect-context'
 import { effect, untracked } from './effects'
 import { cleanedBy, cleanup } from './interface'
 import { reactive } from './proxy'
 import { Register } from './register'
-import { type ScopedCallback } from './types'
+import { type ProjectionContext, projectionInfo, type ScopedCallback } from './types'
+
+/**
+ * Maps projection effects (item effects) to their projection context
+ */
+export const effectProjectionMetadata = new WeakMap<ScopedCallback, ProjectionContext>()
+
+/**
+ * Returns the projection context of the currently running effect, if any.
+ */
+export function getActiveProjection(): ProjectionContext | undefined {
+	const active = getActiveEffect()
+	return active ? effectProjectionMetadata.get(active) : undefined
+}
+
+/* TODO
+It seems to work and I feel like it's correct but I couldn't validate theoretically that `ascend`
+is the correct way to deal with nested effects.
+*/
 
 type ProjectOldValue<Target> = Target extends readonly (infer Item)[]
 	? Item
@@ -50,8 +70,17 @@ function defineAccessValue<Access extends { get(): unknown; set(value: unknown):
 function makeCleanup<Result extends object>(
 	target: Result,
 	effectMap: Map<unknown, ScopedCallback>,
-	onDispose: () => void
+	onDispose: () => void,
+	metadata?: any
 ): ProjectResult<Result> {
+	if (metadata) {
+		Object.defineProperty(target, projectionInfo, {
+			value: metadata,
+			writable: false,
+			enumerable: false,
+			configurable: true,
+		})
+	}
 	return cleanedBy(target, () => {
 		onDispose()
 		for (const stop of effectMap.values()) stop?.()
@@ -80,6 +109,9 @@ function projectArray<SourceValue, ResultValue>(
 		}
 	}
 
+	const parent = getActiveProjection()
+	const depth = parent ? parent.depth + 1 : 0
+
 	const cleanupLength = effect(function projectArrayLengthEffect({ ascend }) {
 		const length = observedSource.length
 		normalizeTargetLength(length)
@@ -102,13 +134,27 @@ function projectArray<SourceValue, ResultValue>(
 					const produced = apply(accessBase, target)
 					target[index] = produced
 				})
+				setEffectName(stop, `project[${depth}]:${index}`)
+				effectProjectionMetadata.set(stop, {
+					source: observedSource,
+					key: index,
+					target,
+					depth,
+					parent,
+				})
 				indexEffects.set(i, stop)
 			})
 		}
 		for (const index of existing) if (index >= length) disposeIndex(index)
 	})
 
-	return makeCleanup(target, indexEffects, () => cleanupLength())
+	return makeCleanup(target, indexEffects, () => cleanupLength(), {
+		source: observedSource,
+		target,
+		apply,
+		depth,
+		parent,
+	} as ProjectionContext)
 }
 
 function projectRegister<Key extends PropertyKey, SourceValue, ResultValue>(
@@ -135,6 +181,9 @@ function projectRegister<Key extends PropertyKey, SourceValue, ResultValue>(
 		}
 	}
 
+	const parent = getActiveProjection()
+	const depth = parent ? parent.depth + 1 : 0
+
 	const cleanupKeys = effect(function projectRegisterEffect({ ascend }) {
 		const keys = new Set<Key>()
 		for (const key of observedSource.mapKeys()) keys.add(key)
@@ -158,6 +207,14 @@ function projectRegister<Key extends PropertyKey, SourceValue, ResultValue>(
 					const produced = apply(accessBase, target)
 					target.set(key, produced)
 				})
+				setEffectName(stop, `project[${depth}]:${String(key)}`)
+				effectProjectionMetadata.set(stop, {
+					source: observedSource,
+					key,
+					target,
+					depth,
+					parent,
+				})
 				keyEffects.set(key, stop)
 			})
 		}
@@ -165,7 +222,13 @@ function projectRegister<Key extends PropertyKey, SourceValue, ResultValue>(
 		for (const key of Array.from(keyEffects.keys())) if (!keys.has(key)) disposeKey(key)
 	})
 
-	return makeCleanup(target, keyEffects, () => cleanupKeys())
+	return makeCleanup(target, keyEffects, () => cleanupKeys(), {
+		source: observedSource,
+		target,
+		apply,
+		depth,
+		parent,
+	} as ProjectionContext)
 }
 
 function projectRecord<Source extends Record<PropertyKey, any>, ResultValue>(
@@ -191,6 +254,9 @@ function projectRecord<Source extends Record<PropertyKey, any>, ResultValue>(
 		}
 	}
 
+	const parent = getActiveProjection()
+	const depth = parent ? parent.depth + 1 : 0
+
 	const cleanupKeys = effect(function projectRecordEffect({ ascend }) {
 		const keys = new Set<PropertyKey>()
 		for (const key in observedSource) keys.add(key)
@@ -222,6 +288,14 @@ function projectRecord<Source extends Record<PropertyKey, any>, ResultValue>(
 					const produced = apply(accessBase, target)
 					;(target as any)[sourceKey] = produced
 				})
+				setEffectName(stop, `project[${depth}]:${String(key)}`)
+				effectProjectionMetadata.set(stop, {
+					source: observedSource,
+					key,
+					target,
+					depth,
+					parent,
+				})
 				keyEffects.set(key, stop)
 			})
 		}
@@ -229,7 +303,13 @@ function projectRecord<Source extends Record<PropertyKey, any>, ResultValue>(
 		for (const key of Array.from(keyEffects.keys())) if (!keys.has(key)) disposeKey(key)
 	})
 
-	return makeCleanup(target, keyEffects, () => cleanupKeys())
+	return makeCleanup(target, keyEffects, () => cleanupKeys(), {
+		source: observedSource,
+		target,
+		apply,
+		depth,
+		parent,
+	} as ProjectionContext)
 }
 
 function projectMap<Key, Value, ResultValue>(
@@ -250,6 +330,9 @@ function projectMap<Key, Value, ResultValue>(
 		}
 	}
 
+	const parent = getActiveProjection()
+	const depth = parent ? parent.depth + 1 : 0
+
 	const cleanupKeys = effect(function projectMapEffect({ ascend }) {
 		const keys = new Set<Key>()
 		for (const key of observedSource.keys()) keys.add(key)
@@ -273,6 +356,14 @@ function projectMap<Key, Value, ResultValue>(
 					const produced = apply(accessBase, target)
 					target.set(key, produced)
 				})
+				setEffectName(stop, `project[${depth}]:${String(key)}`)
+				effectProjectionMetadata.set(stop, {
+					source: observedSource,
+					key,
+					target,
+					depth,
+					parent,
+				})
 				keyEffects.set(key, stop)
 			})
 		}
@@ -280,7 +371,13 @@ function projectMap<Key, Value, ResultValue>(
 		for (const key of Array.from(keyEffects.keys())) if (!keys.has(key)) disposeKey(key)
 	})
 
-	return makeCleanup(target, keyEffects, () => cleanupKeys())
+	return makeCleanup(target, keyEffects, () => cleanupKeys(), {
+		source: observedSource,
+		target,
+		apply,
+		depth,
+		parent,
+	} as ProjectionContext)
 }
 
 type ProjectOverload = {

package/src/reactive/set.ts

@@ -11,14 +11,14 @@ const native = Symbol('native')
  * Only tracks individual value operations, no size tracking (WeakSet limitation)
  */
 export class ReactiveWeakSet<T extends object> {
-	declare readonly [native]: WeakSet<T>
-	declare readonly content: symbol
+	readonly [native]!: WeakSet<T>
+	readonly content!: symbol
 
 	constructor(original: WeakSet<T>) {
 		Object.defineProperties(this, {
 			[native]: { value: original },
 			[prototypeForwarding]: { value: original },
-			content: { value: Symbol('content') },
+			content: { value: Symbol('WeakSetContent') },
 			[Symbol.toStringTag]: { value: 'ReactiveWeakSet' },
 		})
 	}
@@ -52,13 +52,13 @@ export class ReactiveWeakSet<T extends object> {
  * Tracks size changes, individual value operations, and collection-wide operations
  */
 export class ReactiveSet<T> {
-	declare readonly [native]: Set<T>
-	declare readonly content: symbol
+	readonly [native]!: Set<T>
+	readonly content!: symbol
 	constructor(original: Set<T>) {
 		Object.defineProperties(this, {
 			[native]: { value: original },
 			[prototypeForwarding]: { value: original },
-			content: { value: Symbol('content') },
+			content: { value: Symbol('SetContent') },
 			[Symbol.toStringTag]: { value: 'ReactiveSet' },
 		})
 	}

package/src/reactive/types.ts

@@ -141,6 +141,22 @@ export const prototypeForwarding: unique symbol = Symbol('prototype-forwarding')
  */
 export const allProps = Symbol('all-props')
 
+/**
+ * Symbol for accessing projection information on reactive objects
+ */
+export const projectionInfo = Symbol('projection-info')
+
+/**
+ * Context for a running projection item effect
+ */
+export interface ProjectionContext {
+	source: any
+	key?: any
+	target: any
+	depth: number
+	parent?: ProjectionContext
+}
+
 // Symbol to mark functions with their root function
 const rootFunction = Symbol('root-function')
 
@@ -250,6 +266,12 @@ export const options = {
 	 * @default 100
 	 */
 	maxEffectChain: 100,
+	/**
+	 * Maximum number of times an effect can be triggered by the same cause in a single batch
+	 * Used to detect aggressive re-computation or infinite loops
+	 * @default 10
+	 */
+	maxTriggerPerBatch: 10,
 	/**
 	 * Debug purpose: maximum effect reaction (like call stack max depth)
 	 * Used to prevent infinite loops

package/src/reactive/zone.ts

@@ -15,7 +15,7 @@
  */
 
 import { captureEffectStack, withEffectStack } from './effect-context'
-import { options, ScopedCallback } from './types'
+import { options, type ScopedCallback } from './types'
 
 let zoneHooked = false
 

package/src/std-decorators.ts

@@ -1,4 +1,4 @@
-import { decorator, GenericClassDecorator } from './decorator'
+import { decorator, type GenericClassDecorator } from './decorator'
 
 // In order to avoid async re-entrance, we could use zone.js or something like that.
 const syncCalculating: { object: object; prop: PropertyKey }[] = []