mutts 1.0.8 → 1.0.10

package/src/reactive/index.ts

@@ -1,75 +0,0 @@
-export { getState, touched, touched1 } from './change'
-export type { ReactivityGraph } from './debug'
-export {
-	buildReactivityGraph,
-	enableDevTools,
-	isDevtoolsEnabled,
-	registerEffectForDebug,
-	registerObjectForDebug,
-	setEffectName,
-	setObjectName,
-} from './debug'
-export { deepWatch } from './deep-watch'
-export {
-	addBatchCleanup,
-	atomic,
-	biDi,
-	defer,
-	effect,
-	getActivationLog,
-	root,
-	trackEffect,
-	untracked,
-} from './effects'
-export { cleanedBy, cleanup, derived, unreactive, watch } from './interface'
-export { type Memoizable, memoize } from './memoize'
-export { immutables, isNonReactive, registerNativeReactivity } from './non-reactive'
-export { getActiveProjection, project } from './project'
-export { isReactive, ReactiveBase, reactive, unwrap } from './proxy'
-export { organize, organized } from './record'
-export { scan, type ScanResult, resolve } from './buffer'
-export { Register, register } from './register'
-export { getActiveEffect, effectAggregator } from './effect-context'
-export {
-	type DependencyAccess,
-	type Evolution,
-	options as reactiveOptions,
-	ReactiveError,
-	ReactiveErrorCode,
-	type ScopedCallback,
-} from './types'
-
-import { ReactiveArray } from './array'
-import {
-	deepWatchers,
-	effectToDeepWatchedObjects,
-	objectParents,
-	objectsWithDeepWatchers,
-} from './deep-watch'
-import { ReactiveMap, ReactiveWeakMap } from './map'
-import { nonReactiveObjects } from './non-reactive-state'
-import { metaProtos, objectToProxy, proxyToObject } from './proxy'
-import { effectToReactiveObjects, watchers } from './registry'
-import { ReactiveSet, ReactiveWeakSet } from './set'
-
-// Register native collection types to use specialized reactive wrappers
-metaProtos.set(Array, ReactiveArray.prototype)
-metaProtos.set(Set, ReactiveSet.prototype)
-metaProtos.set(WeakSet, ReactiveWeakSet.prototype)
-metaProtos.set(Map, ReactiveMap.prototype)
-metaProtos.set(WeakMap, ReactiveWeakMap.prototype)
-
-/**
- * Object containing internal reactive system state for debugging and profiling
- */
-export const profileInfo: any = {
-	objectToProxy,
-	proxyToObject,
-	effectToReactiveObjects,
-	watchers,
-	objectParents,
-	objectsWithDeepWatchers,
-	deepWatchers,
-	effectToDeepWatchedObjects,
-	nonReactiveObjects,
-}

package/src/reactive/interface.ts

@@ -1,210 +0,0 @@
-import { decorator, type GenericClassDecorator } from '../decorator'
-import { deepWatch } from './deep-watch'
-import { effect, untracked } from './effects'
-import { isNonReactive, nonReactiveClass, nonReactiveObjects } from './non-reactive-state'
-import { unwrap } from './proxy-state'
-import { markWithRoot } from './registry'
-import { dependant } from './tracking'
-import {
-	type DependencyAccess,
-	nonReactiveMark,
-	type ScopedCallback,
-	unreactiveProperties,
-} from './types'
-
-/**
- * Symbol for accessing the cleanup function on cleaned objects
- */
-export const cleanup = Symbol('cleanup')
-
-//#region watch
-
-const unsetYet = Symbol('unset-yet')
-/**
- * Options for the watch function
- */
-export interface WatchOptions {
-	/** Whether to call the callback immediately */
-	immediate?: boolean
-	/** Whether to watch nested properties */
-	deep?: boolean
-}
-
-/**
- * Watches a reactive value and calls a callback when it changes
- * @param value - Function that returns the value to watch
- * @param changed - Callback to call when the value changes
- * @param options - Watch options
- * @returns Cleanup function to stop watching
- */
-export function watch<T>(
-	value: (dep: DependencyAccess) => T,
-	changed: (value: T, oldValue?: T) => void,
-	options?: Omit<WatchOptions, 'deep'> & { deep?: false }
-): ScopedCallback
-/**
- * Watches a reactive value with deep watching enabled
- * @param value - Function that returns the value to watch
- * @param changed - Callback to call when the value changes
- * @param options - Watch options with deep watching enabled
- * @returns Cleanup function to stop watching
- */
-export function watch<T extends object | any[]>(
-	value: (dep: DependencyAccess) => T,
-	changed: (value: T, oldValue?: T) => void,
-	options?: Omit<WatchOptions, 'deep'> & { deep: true }
-): ScopedCallback
-/**
- * Watches a reactive object directly
- * @param value - The reactive object to watch
- * @param changed - Callback to call when the object changes
- * @param options - Watch options
- * @returns Cleanup function to stop watching
- */
-export function watch<T extends object | any[]>(
-	value: T,
-	changed: (value: T) => void,
-	options?: WatchOptions
-): ScopedCallback
-
-export function watch(
-	value: any, //object | ((dep: DependencyAccess) => object),
-	changed: (value?: object, oldValue?: object) => void,
-	options: any = {}
-) {
-	return typeof value === 'function'
-		? watchCallBack(value, changed, options)
-		: typeof value === 'object' && value !== null
-			? watchObject(value, changed, options)
-			: (() => {
-					throw new Error('watch: value must be a function or an object')
-				})()
-}
-
-function watchObject(
-	value: object,
-	changed: (value: object) => void,
-	{ immediate = false, deep = false } = {}
-): ScopedCallback {
-	if (deep) return deepWatch(value, changed, { immediate })!
-	return effect(function watchObjectEffect() {
-		dependant(value)
-		if (immediate) changed(value)
-		immediate = true
-	})
-}
-
-function watchCallBack<T>(
-	value: (dep: DependencyAccess) => T,
-	changed: (value: T, oldValue?: T) => void,
-	{ immediate = false, deep = false } = {}
-): ScopedCallback {
-	let oldValue: T | typeof unsetYet = unsetYet
-	let deepCleanup: ScopedCallback | undefined
-	const cbCleanup = effect(
-		markWithRoot(function watchCallBackEffect(access) {
-			const newValue = value(access)
-			if (oldValue !== newValue)
-				if (oldValue === unsetYet) {
-					if (immediate) changed(newValue)
-				} else changed(newValue, oldValue)
-				oldValue = newValue
-				if (deep) {
-					if (deepCleanup) deepCleanup()
-					deepCleanup = deepWatch(newValue as object, (value) => changed(value as T, value as T))
-				}
-		}, value)
-	)
-	return () => {
-		cbCleanup()
-		if (deepCleanup) deepCleanup()
-	}
-}
-
-//#endregion
-
-//#region nonReactive
-
-/**
- * Mark an object as non-reactive. This object and all its properties will never be made reactive.
- * @param obj - The object to mark as non-reactive
- */
-function deepNonReactive<T>(obj: T): T {
-	obj = unwrap(obj)
-	if (isNonReactive(obj)) return obj
-	try {
-		Object.defineProperty(obj as object, nonReactiveMark, {
-			value: true,
-			writable: false,
-			enumerable: false,
-			configurable: true,
-		})
-	} catch {}
-	if (!(nonReactiveMark in (obj as object))) nonReactiveObjects.add(obj as object)
-	// Finally, not deep
-	//for (const key in obj) deepNonReactive(obj[key])
-	return obj
-}
-function unreactiveApplication<T extends object>(...args: (keyof T)[]): GenericClassDecorator<T>
-function unreactiveApplication<T extends object>(obj: T): T
-function unreactiveApplication<T extends object>(
-	arg1: T | keyof T,
-	...args: (keyof T)[]
-): GenericClassDecorator<T> | T {
-	return typeof arg1 === 'object'
-		? deepNonReactive(arg1)
-		: (((original) => {
-				// Copy the parent's unreactive properties if they exist
-				original.prototype[unreactiveProperties] = new Set<PropertyKey>(
-					original.prototype[unreactiveProperties] || []
-				)
-				// Add all arguments (including the first one)
-				original.prototype[unreactiveProperties].add(arg1)
-				for (const arg of args) original.prototype[unreactiveProperties].add(arg)
-				return original // Return the class
-			}) as GenericClassDecorator<T>)
-}
-/**
- * Decorator that marks classes or properties as non-reactive
- * Prevents objects from being made reactive
- */
-export const unreactive = decorator({
-	class(original) {
-		// Called without arguments, mark entire class as non-reactive
-		nonReactiveClass(original)
-	},
-	default: unreactiveApplication,
-})
-
-//#endregion
-
-export function cleanedBy<T extends object>(obj: T, cleanupFn: ScopedCallback) {
-	return Object.defineProperty(obj, cleanup, {
-		value: cleanupFn,
-		writable: false,
-		enumerable: false,
-		configurable: true,
-	}) as T & { [cleanup]: ScopedCallback }
-}
-
-//#region greedy caching
-
-/**
- * Creates a derived value that automatically recomputes when dependencies change
- * @param compute - Function that computes the derived value
- * @returns Object with value and cleanup function
- */
-export function derived<T>(compute: (dep: DependencyAccess) => T): {
-	value: T
-	[cleanup]: ScopedCallback
-} {
-	const rv = { value: undefined as unknown as T }
-	return cleanedBy(
-		rv,
-		untracked(() =>
-			effect(function derivedEffect(access) {
-				rv.value = compute(access)
-			})
-		)
-	)
-}

package/src/reactive/map.ts

@@ -1,158 +0,0 @@
-import { contentRef } from '../utils'
-import { touched, touched1 } from './change'
-import { notifyPropertyChange } from './deep-touch'
-import { makeReactiveEntriesIterator, makeReactiveIterator } from './non-reactive'
-import { reactive } from './proxy'
-import { dependant } from './tracking'
-
-/**
- * Reactive wrapper around JavaScript's WeakMap class
- * Only tracks individual key operations, no size tracking (WeakMap limitation)
- */
-export abstract class ReactiveWeakMap<K extends object, V> extends WeakMap<K, V> {
-	get [Symbol.toStringTag]() {
-		return 'ReactiveWeakMap'
-	}
-
-	// Implement WeakMap interface methods with reactivity
-	delete(key: K): boolean {
-		const hadKey = this.has(key)
-		const result = this.delete(key)
-
-		if (hadKey) touched1(contentRef(this), { type: 'del', prop: key }, key)
-
-		return result
-	}
-
-	get(key: K): V | undefined {
-		dependant(contentRef(this), key)
-		return reactive(this.get(key))
-	}
-
-	has(key: K): boolean {
-		dependant(contentRef(this), key)
-		return this.has(key)
-	}
-
-	set(key: K, value: V): this {
-		const hadKey = this.has(key)
-		const oldValue = this.get(key)
-		const reactiveValue = reactive(value)
-		this.set(key, reactiveValue)
-
-		if (!hadKey || oldValue !== reactiveValue) {
-			notifyPropertyChange(contentRef(this), key, oldValue, reactiveValue, hadKey)
-		}
-
-		return this
-	}
-}
-
-/**
- * Reactive wrapper around JavaScript's Map class
- * Tracks size changes, individual key operations, and collection-wide operations
- */
-export abstract class ReactiveMap<K, V> extends Map<K, V> {
-	get [Symbol.toStringTag]() {
-		return 'ReactiveMap'
-	}
-
-	// Implement Map interface methods with reactivity
-	get size(): number {
-		dependant(this, 'size') // The ReactiveMap instance still goes through proxy
-		return this.size
-	}
-
-	clear(): void {
-		const hadEntries = this.size > 0
-		this.clear()
-
-		if (hadEntries) {
-			const evolution = { type: 'bunch', method: 'clear' } as const
-			// Clear triggers all effects since all keys are affected
-			touched1(this, evolution, 'size')
-			touched(contentRef(this), evolution)
-		}
-	}
-
-	entries(): Generator<[K, V]> {
-		dependant(contentRef(this))
-		return makeReactiveEntriesIterator(this.entries())
-	}
-
-	forEach(callbackfn: (value: V, key: K, map: Map<K, V>) => void, thisArg?: any): void {
-		dependant(contentRef(this))
-		this.forEach(callbackfn, thisArg)
-	}
-
-	keys(): MapIterator<K> {
-		dependant(contentRef(this))
-		return this.keys()
-	}
-
-	values(): Generator<V> {
-		dependant(contentRef(this))
-		return makeReactiveIterator(this.values())
-	}
-
-	[Symbol.iterator](): MapIterator<[K, V]> {
-		dependant(contentRef(this))
-		const nativeIterator = this[Symbol.iterator]()
-		return {
-			next() {
-				const result = nativeIterator.next()
-				if (result.done) {
-					return result
-				}
-				return {
-					value: [result.value[0], reactive(result.value[1])],
-					done: false,
-				}
-			},
-			[Symbol.iterator]() {
-				return this
-			},
-			[Symbol.dispose]() {},
-		} as any // TODO: real iterator? (If easy)
-	}
-
-	// Implement Map methods with reactivity
-	delete(key: K): boolean {
-		const hadKey = this.has(key)
-		const result = this.delete(key)
-
-		if (hadKey) {
-			const evolution = { type: 'del', prop: key } as const
-			touched1(contentRef(this), evolution, key)
-			touched1(this, evolution, 'size')
-		}
-
-		return result
-	}
-
-	get(key: K): V | undefined {
-		dependant(contentRef(this), key)
-		return reactive(this.get(key))
-	}
-
-	has(key: K): boolean {
-		dependant(contentRef(this), key)
-		return this.has(key)
-	}
-
-	set(key: K, value: V): this {
-		const hadKey = this.has(key)
-		const oldValue = this.get(key)
-		const reactiveValue = reactive(value)
-		this.set(key, reactiveValue)
-
-		if (!hadKey || oldValue !== reactiveValue) {
-			notifyPropertyChange(contentRef(this), key, oldValue, reactiveValue, hadKey)
-			// Also notify size change for Map (WeakMap doesn't track size)
-			const evolution = { type: hadKey ? 'set' : 'add', prop: key } as const
-			touched1(this, evolution, 'size')
-		}
-
-		return this
-	}
-}

package/src/reactive/memoize.ts

@@ -1,163 +0,0 @@
-import { decorator } from '../decorator'
-import { deepCompare, renamed } from '../utils'
-import { touched1 } from './change'
-import { effect, root, untracked } from './effects'
-import { getRoot, markWithRoot } from './registry'
-import { dependant } from './tracking'
-import { options, rootFunction } from './types'
-
-export type Memoizable = object | any[] | symbol | ((...args: any[]) => any)
-
-type MemoCacheTree<Result> = {
-	result?: Result
-	cleanup?: () => void
-	branches?: WeakMap<Memoizable, MemoCacheTree<Result>>
-}
-
-const memoizedRegistry = new WeakMap<any, Function>()
-const wrapperRegistry = new WeakMap<Function, Function>()
-
-function getBranch<Result>(tree: MemoCacheTree<Result>, key: Memoizable): MemoCacheTree<Result> {
-	tree.branches ??= new WeakMap()
-	let branch = tree.branches.get(key)
-	if (!branch) {
-		branch = {}
-		tree.branches.set(key, branch)
-	}
-	return branch
-}
-
-function memoizeFunction<Result, Args extends Memoizable[]>(
-	fn: (...args: Args) => Result
-): (...args: Args) => Result {
-	const fnRoot = getRoot(fn)
-	const existing = memoizedRegistry.get(fnRoot)
-	if (existing) return existing as (...args: Args) => Result
-
-	const cacheRoot: MemoCacheTree<Result> = {}
-	const memoized = markWithRoot((...args: Args): Result => {
-		const localArgs = args //: Args = maxArgs !== undefined ? (args.slice(0, maxArgs) as Args) : args
-		if (localArgs.some((arg) => !(arg && ['object', 'symbol', 'function'].includes(typeof arg))))
-			throw new Error('memoize expects non-null object arguments')
-
-		let node: MemoCacheTree<Result> = cacheRoot
-		// Note: decorators add `this` as first argument
-		for (const arg of localArgs) {
-			node = getBranch(node, arg)
-		}
-
-		dependant(node, 'memoize')
-		if ('result' in node) {
-			if (options.onMemoizationDiscrepancy) {
-				const wasVerification = options.isVerificationRun
-				options.isVerificationRun = true
-				try {
-					const fresh = untracked(() => fn(...localArgs))
-					if (!deepCompare(node.result, fresh)) {
-						options.onMemoizationDiscrepancy(node.result, fresh, fn, localArgs, 'calculation')
-					}
-				} finally {
-					options.isVerificationRun = wasVerification
-				}
-			}
-			return node.result!
-		}
-
-		// Create memoize internal effect to track dependencies and invalidate cache
-		// Use untracked to prevent the effect creation from being affected by parent effects
-		node.cleanup = root(() =>
-			effect(
-				() => {
-					// Execute the function and track its dependencies
-					// The function execution will automatically track dependencies on reactive objects
-					node.result = fn(...localArgs)
-					return () => {
-						// When dependencies change, clear the cache and notify consumers
-						delete node.result
-						touched1(node, { type: 'invalidate', prop: localArgs }, 'memoize')
-						// Lazy memoization: stop the effect so it doesn't re-run immediately.
-						// It will be re-created on next access.
-						if (node.cleanup) {
-							node.cleanup()
-							node.cleanup = undefined
-						}
-					}
-				},
-				{ opaque: true }
-			)
-		)
-
-		if (options.onMemoizationDiscrepancy) {
-			const wasVerification = options.isVerificationRun
-			options.isVerificationRun = true
-			try {
-				const fresh = untracked(() => fn(...localArgs))
-				if (!deepCompare(node.result, fresh)) {
-					options.onMemoizationDiscrepancy(node.result, fresh, fn, localArgs, 'comparison')
-				}
-			} finally {
-				options.isVerificationRun = wasVerification
-			}
-		}
-
-		return node.result!
-	}, fn)
-
-	memoizedRegistry.set(fnRoot, memoized)
-	memoizedRegistry.set(memoized, memoized)
-	return memoized as (...args: Args) => Result
-}
-
-export const memoize = decorator({
-	getter(original, target, propertyKey) {
-		return function (this: any) {
-			let wrapper = wrapperRegistry.get(original)
-			if (!wrapper) {
-				wrapper = markWithRoot(
-					renamed(
-						(that: object) => {
-							return original.call(that)
-						},
-						`${String(target?.constructor?.name ?? target?.name ?? 'Object')}.${String(propertyKey)}`
-					),
-					{
-						method: original,
-						propertyKey,
-						...((original as any)[rootFunction]
-							? { [rootFunction]: (original as any)[rootFunction] }
-							: {}),
-					}
-				)
-				wrapperRegistry.set(original, wrapper)
-			}
-			const memoized = memoizeFunction(wrapper as any)
-			return memoized(this)
-		}
-	},
-	method(original, target, name) {
-		return function (this: any, ...args: object[]) {
-			let wrapper = wrapperRegistry.get(original)
-			if (!wrapper) {
-				wrapper = markWithRoot(
-					renamed(
-						(that: object, ...args: object[]) => {
-							return original.call(that, ...args)
-						},
-						`${String(target?.constructor?.name ?? target?.name ?? 'Object')}.${String(name)}`
-					),
-					{
-						method: original,
-						propertyKey: name,
-						...((original as any)[rootFunction]
-							? { [rootFunction]: (original as any)[rootFunction] }
-							: {}),
-					}
-				)
-				wrapperRegistry.set(original, wrapper)
-			}
-			const memoized = memoizeFunction(wrapper as any) as (...args: object[]) => unknown
-			return memoized(this, ...args)
-		}
-	},
-	default: memoizeFunction,
-})

package/src/reactive/non-reactive-state.ts

@@ -1,49 +0,0 @@
-import { nativeReactive, nonReactiveMark } from './types'
-
-export const nonReactiveObjects = new WeakSet<object>()
-export const immutables = new Set<(tested: any) => boolean>()
-export const absent = Symbol('absent')
-
-function markNonReactive<T extends object[]>(...obj: T): T[0] {
-	for (const o of obj) {
-		try {
-			Object.defineProperty(o, nonReactiveMark, {
-				value: true,
-				writable: false,
-				enumerable: false,
-				configurable: false,
-			})
-		} catch {}
-		if (!(nonReactiveMark in (o as object))) nonReactiveObjects.add(o as object)
-	}
-	return obj[0]
-}
-
-export function nonReactiveClass<T extends (new (...args: any[]) => any)[]>(...cls: T): T[0] {
-	for (const c of cls) if (c) (c.prototype as any)[nonReactiveMark] = true
-	return cls[0]
-}
-
-export function isNonReactive(obj: any): boolean {
-	if (obj === null || typeof obj !== 'object') return true
-	if (nonReactiveObjects.has(obj)) return true
-	if ((obj as any)[nonReactiveMark]) return true
-	for (const fn of immutables) if (fn(obj)) return true
-	return false
-}
-
-export function registerNativeReactivity(
-	originalClass: new (...args: any[]) => any,
-	reactiveClass: new (...args: any[]) => any
-) {
-	originalClass.prototype[nativeReactive] = reactiveClass
-	nonReactiveClass(reactiveClass)
-}
-
-nonReactiveClass(Date, RegExp, Error, Promise, Function)
-if (typeof window !== 'undefined') {
-	markNonReactive(window, document)
-	nonReactiveClass(Node, Element, HTMLElement, EventTarget)
-}
-
-export { markNonReactive as nonReactive }

package/src/reactive/non-reactive.ts

@@ -1,43 +0,0 @@
-import {
-	absent,
-	immutables,
-	isNonReactive,
-	nonReactive,
-	nonReactiveClass,
-	nonReactiveObjects,
-	registerNativeReactivity,
-} from './non-reactive-state'
-import { reactive } from './proxy'
-
-/**
- * Converts an iterator to a generator that yields reactive values
- */
-export function* makeReactiveIterator<T>(iterator: Iterator<T>): Generator<T> {
-	let result = iterator.next()
-	while (!result.done) {
-		yield reactive(result.value)
-		result = iterator.next()
-	}
-}
-
-/**
- * Converts an iterator of key-value pairs to a generator that yields reactive key-value pairs
- */
-export function* makeReactiveEntriesIterator<K, V>(iterator: Iterator<[K, V]>): Generator<[K, V]> {
-	let result = iterator.next()
-	while (!result.done) {
-		const [key, value] = result.value
-		yield [reactive(key), reactive(value)]
-		result = iterator.next()
-	}
-}
-
-export {
-	absent,
-	immutables,
-	isNonReactive,
-	nonReactive,
-	nonReactiveClass,
-	nonReactiveObjects,
-	registerNativeReactivity,
-}