mutts 1.0.8 → 1.0.10

package/src/reactive/register.ts

@@ -1,419 +0,0 @@
-import { FunctionWrapper } from '../zone'
-import { ArrayReadForward, forwardArray, getAt, Indexable, setAt } from '../indexable'
-import { effect } from './effects'
-import { unreactive } from './interface'
-import { reactive } from './proxy'
-import { type ScopedCallback } from './types'
-
-// TODO: use register in a real-world crud situation, have "events" for add, delete, update
-
-type KeyFunction<T, K extends PropertyKey> = (item: T) => K
-
-// Helper to work around TypeScript limitation: base class expressions cannot reference class type parameters
-function getRegisterBase<T>() {
-	class RegisterBase extends Indexable(ArrayReadForward, {
-		get(this: any, index: number) {
-			return this[getAt](index)
-		},
-		set(this: any, index: number, value: T) {
-			this[setAt](index, value)
-		},
-		getLength(this: any) {
-			return this.length
-		},
-		setLength(this: any, value: number) {
-			this.length = value
-		},
-	}) {
-		toArray(): T[] {
-			return Array.from(this)
-		}
-	}
-	return RegisterBase as new () => ArrayReadForward<T> & {
-		[x: number]: T
-		toArray(): T[]
-	}
-}
-interface RegisterInstance<T> extends ArrayReadForward<T> {
-	[index: number]: T
-}
-// TODO: What to do with prototype forwarding ?
-@unreactive
-class RegisterClass<T, K extends PropertyKey = PropertyKey>
-	extends getRegisterBase<any>()
-	implements RegisterInstance<T>
-{
-	protected get [forwardArray](): readonly T[] {
-		return this.toArray()
-	}
-	readonly #keyFn: KeyFunction<T, K>
-	readonly #keys: K[]
-	readonly #values: Map<K, T>
-	readonly #usage = new Map<K, number>()
-	readonly #valueInfo = new Map<T, { key: K; stop?: ScopedCallback }>()
-	readonly #keyEffects = new Set<ScopedCallback>()
-	readonly #ascend: FunctionWrapper
-
-	constructor(keyFn: KeyFunction<T, K>, initial?: Iterable<T>) {
-		super()
-		/* Moved below initialization */
-		let ascendGet: FunctionWrapper | undefined
-		effect(({ ascend }) => {
-			ascendGet = ascend
-		})
-		this.#ascend = ascendGet!
-		if (typeof keyFn !== 'function') throw new Error('Register requires a key function')
-		this.#keyFn = keyFn
-		this.#keys = reactive([] as K[])
-		this.#values = reactive(new Map<K, T>())
-		if (initial) this.push(...initial)
-	}
-
-	private ensureKey(value: T): K {
-		let info = this.#valueInfo.get(value)
-		if (info) return info.key
-		info = { key: undefined as unknown as K }
-		this.#valueInfo.set(value, info)
-		this.#ascend(() => {
-			const stop = effect(({ reaction }) => {
-				const nextKey = this.#keyFn(value)
-				this.assertValidKey(nextKey)
-				const previousKey = info!.key
-				if (reaction && previousKey !== undefined && !Object.is(nextKey, previousKey))
-					this.#rekeyValue(value, previousKey, nextKey)
-				info!.key = nextKey
-			})
-			info!.stop = stop
-			this.#keyEffects.add(stop)
-		})
-		if (info.key === undefined) throw new Error('Register key function must return a property key')
-		return info.key
-	}
-
-	private assertValidKey(key: unknown): asserts key is K {
-		const type = typeof key
-		if (type !== 'string' && type !== 'number' && type !== 'symbol')
-			throw new Error('Register key function must return a property key')
-	}
-
-	private setKeyValue(key: K, value: T) {
-		const existing = this.#values.get(key)
-		if (existing !== undefined && existing !== value) this.cleanupValue(existing)
-		this.#values.set(key, value)
-	}
-
-	private cleanupValue(value: T) {
-		const info = this.#valueInfo.get(value)
-		if (!info) return
-		const stop = info.stop
-		if (stop) {
-			info.stop = undefined
-			this.#keyEffects.delete(stop)
-			stop()
-		}
-		this.#valueInfo.delete(value)
-	}
-
-	private disposeKeyEffects() {
-		for (const value of Array.from(this.#valueInfo.keys())) this.cleanupValue(value)
-		this.#keyEffects.clear()
-	}
-
-	#rekeyValue(value: T, oldKey: K, newKey: K) {
-		if (Object.is(oldKey, newKey)) return
-		const existingValue = this.#values.get(newKey)
-		if (existingValue !== undefined && existingValue !== value)
-			throw new Error(`Register key collision for key ${String(newKey)}`)
-		const count = this.#usage.get(oldKey)
-		if (!count) return
-		const existingCount = this.#usage.get(newKey) ?? 0
-		this.setKeyValue(newKey, value)
-		for (let i = 0; i < this.#keys.length; i++)
-			if (Object.is(this.#keys[i], oldKey)) this.#keys[i] = newKey
-		this.#usage.set(newKey, existingCount + count)
-		this.#usage.delete(oldKey)
-		this.#values.delete(oldKey)
-		const updatedInfo = this.#valueInfo.get(value)
-		if (updatedInfo) updatedInfo.key = newKey
-	}
-
-	private incrementUsage(key: K) {
-		const count = this.#usage.get(key) ?? 0
-		this.#usage.set(key, count + 1)
-	}
-
-	private decrementUsage(key: K) {
-		const count = this.#usage.get(key)
-		if (!count) return
-		if (count <= 1) {
-			const value = this.#values.get(key)
-			this.#usage.delete(key)
-			this.#values.delete(key)
-			if (value !== undefined) this.cleanupValue(value)
-		} else {
-			this.#usage.set(key, count - 1)
-		}
-	}
-
-	private normalizeIndex(index: number, allowEnd = false): number {
-		const length = this.length
-		let resolved = index
-		if (resolved < 0) resolved = Math.max(length + resolved, 0)
-		if (resolved > length) {
-			if (allowEnd) resolved = length
-			else throw new RangeError('Index out of bounds')
-		}
-		if (!allowEnd && resolved === length) throw new RangeError('Index out of bounds')
-		return resolved
-	}
-
-	private assignAt(index: number, key: K, value: T) {
-		const oldKey = this.#keys[index]
-		if (oldKey !== undefined && Object.is(oldKey, key)) {
-			this.setKeyValue(key, value)
-			return
-		}
-		if (oldKey !== undefined) this.decrementUsage(oldKey as K)
-		this.#keys[index] = key
-		this.incrementUsage(key)
-		this.setKeyValue(key, value)
-	}
-
-	private insertKeyValue(index: number, key: K, value: T) {
-		this.#keys.splice(index, 0, key)
-		this.incrementUsage(key)
-		this.setKeyValue(key, value)
-	}
-
-	private rebuildFrom(values: T[]) {
-		this.disposeKeyEffects()
-		this.#keys.splice(0, this.#keys.length)
-		this.#usage.clear()
-		this.#values.clear()
-		for (const value of values) {
-			const key = this.ensureKey(value)
-			this.#keys.push(key)
-			this.incrementUsage(key)
-			this.#values.set(key, value)
-		}
-	}
-
-	get length(): number {
-		return this.#keys.length
-	}
-
-	[getAt](index: number): T | undefined {
-		const key = this.#keys[index]
-		return key === undefined ? undefined : this.#values.get(key)
-	}
-
-	[setAt](index: number, value: T): void {
-		const key = this.ensureKey(value)
-		if (index === this.length) {
-			this.insertKeyValue(index, key, value)
-			return
-		}
-		const normalized = this.normalizeIndex(index)
-		this.assignAt(normalized, key, value)
-	}
-
-	push(...items: T[]): number {
-		for (const item of items) {
-			const key = this.ensureKey(item)
-			this.insertKeyValue(this.length, key, item)
-		}
-		return this.length
-	}
-
-	pop(): T | undefined {
-		if (!this.length) return undefined
-		return this.removeAt(this.length - 1)
-	}
-
-	shift(): T | undefined {
-		if (!this.length) return undefined
-		return this.removeAt(0)
-	}
-
-	unshift(...items: T[]): number {
-		let index = 0
-		for (const item of items) {
-			const key = this.ensureKey(item)
-			this.insertKeyValue(index++, key, item)
-		}
-		return this.length
-	}
-
-	splice(start: number, deleteCount?: number, ...items: T[]): T[] {
-		const normalizedStart = this.normalizeIndex(start, true)
-		const maxDeletions = this.length - normalizedStart
-		const actualDelete = Math.min(
-			deleteCount === undefined ? maxDeletions : Math.max(deleteCount, 0),
-			maxDeletions
-		)
-		const keysToInsert: K[] = []
-		for (const item of items) keysToInsert.push(this.ensureKey(item))
-		const removedKeys = this.#keys.splice(normalizedStart, actualDelete, ...keysToInsert)
-		const removedValues: T[] = []
-		for (const key of removedKeys) {
-			if (key === undefined) continue
-			const value = this.#values.get(key as K)
-			this.decrementUsage(key as K)
-			removedValues.push(value as T)
-		}
-		for (let i = 0; i < keysToInsert.length; i++) {
-			const key = keysToInsert[i]
-			const value = items[i]
-			this.incrementUsage(key)
-			this.setKeyValue(key, value)
-		}
-		return removedValues
-	}
-
-	clear(): void {
-		this.#keys.length = 0
-		this.#usage.clear()
-		this.#values.clear()
-		this.disposeKeyEffects()
-	}
-
-	get(key: K): T | undefined {
-		return this.#values.get(key)
-	}
-	set(key: K, value: T): void {
-		if (this.#values.has(key)) this.setKeyValue(key, value)
-	}
-
-	remove(key: K) {
-		let index: number = this.indexOfKey(key)
-		while (index !== -1) {
-			this.removeAt(index)
-			index = this.indexOfKey(key)
-		}
-	}
-
-	public removeAt(index: number): T | undefined {
-		const [key] = this.#keys.splice(index, 1)
-		if (key === undefined) return undefined
-		const value = this.#values.get(key as K)
-		this.decrementUsage(key as K)
-		return value
-	}
-
-	/**
-	 * Keep only the items for which the predicate returns true.
-	 * Items for which the predicate returns false are removed.
-	 *
-	 * The predicate is evaluated once per distinct key; duplicate keys
-	 * will follow the same keep/remove decision.
-	 */
-	public keep(predicate: (value: T) => boolean): void {
-		const decisions = new Map<K, boolean>()
-		for (const [index, key] of this.#keys.entries()) {
-			if (decisions.has(key)) {
-				if (!decisions.get(key)) this.removeAt(index)
-				continue
-			}
-			const value = this.#values.get(key)
-			const shouldKeep = predicate(value as T)
-			decisions.set(key, shouldKeep)
-			if (!shouldKeep) this.removeAt(index)
-		}
-	}
-
-	hasKey(key: K): boolean {
-		return this.#usage.has(key)
-	}
-
-	indexOfKey(key: K): number {
-		return this.#keys.indexOf(key)
-	}
-
-	mapKeys(): IterableIterator<K> {
-		return this.#values.keys()
-	}
-
-	update(...values: T[]): void {
-		for (const value of values) {
-			const key = this.ensureKey(value)
-			if (this.#values.has(key)) this.setKeyValue(key, value)
-		}
-	}
-
-	upsert(insert: (value: T) => void, ...values: T[]): void {
-		for (const value of values) {
-			const key = this.ensureKey(value)
-			if (this.#values.has(key)) this.setKeyValue(key, value)
-			else insert(value)
-		}
-	}
-
-	entries(): IterableIterator<[number, T]> {
-		const self = this
-		function* iterator(): IterableIterator<[number, T]> {
-			for (let i = 0; i < self.#keys.length; i++) {
-				const val = self.#values.get(self.#keys[i])
-				if (val !== undefined) yield [i, val]
-			}
-		}
-		return iterator()
-	}
-
-	[Symbol.iterator](): IterableIterator<T> {
-		const self = this
-		function* iterator(): IterableIterator<T> {
-			for (const key of self.#keys) {
-				const value = self.#values.get(key)
-				if (value !== undefined) yield value
-			}
-		}
-		return iterator()
-	}
-
-	toString(): string {
-		return `[Register length=${this.length}]`
-	}
-
-	at(index: number): T | undefined {
-		const resolved = index < 0 ? this.length + index : index
-		if (resolved < 0 || resolved >= this.length) return undefined
-		return this[getAt](resolved)
-	}
-	reverse(): this {
-		this.#keys.reverse()
-		return this
-	}
-	sort(compareFn?: ((a: T, b: T) => number) | undefined): this {
-		const fwdCompareFn = compareFn
-			? (a: K, b: K) => compareFn(this.#values.get(a) as T, this.#values.get(b) as T)
-			: undefined
-		this.#keys.sort(fwdCompareFn)
-		return this
-	}
-	fill(value: T, start = 0, end = this.length): this {
-		const values = this.toArray()
-		values.fill(value, start, end)
-		this.rebuildFrom(values)
-		return this
-	}
-
-	copyWithin(target: number, start: number, end?: number): this {
-		const values = this.toArray()
-		values.copyWithin(target, start, end)
-		this.rebuildFrom(values)
-		return this
-	}
-}
-
-export type Register<T, K extends PropertyKey = PropertyKey> = RegisterClass<T, K> & T[]
-export const Register = RegisterClass as new <T, K extends PropertyKey = PropertyKey>(
-	keyFn: KeyFunction<T, K>,
-	initial?: Iterable<T>
-) => Register<T, K>
-
-export function register<T, K extends PropertyKey = PropertyKey>(
-	keyFn: KeyFunction<T, K>,
-	initial?: Iterable<T>
-): Register<T, K> {
-	return new RegisterClass(keyFn, initial) as Register<T, K>
-}

package/src/reactive/registry.ts

@@ -1,59 +0,0 @@
-import { rootFunction, type ScopedCallback } from './types'
-
-// Track which effects are watching which reactive objects for cleanup
-export const effectToReactiveObjects = new WeakMap<ScopedCallback, Set<object>>()
-
-// Track effects per reactive object and property
-export const watchers = new WeakMap<object, Map<any, Set<ScopedCallback>>>()
-
-// runEffect -> set<stop>
-export const effectChildren = new WeakMap<ScopedCallback, Set<ScopedCallback>>()
-
-// Track parent effect relationships for hierarchy traversal (used in deep touch filtering)
-export const effectParent = new WeakMap<ScopedCallback, ScopedCallback | undefined>()
-
-// Track reverse mapping to ensure unicity: One Root -> One Function
-const reverseRoots = new WeakMap<any, WeakRef<Function>>()
-
-/**
- * Marks a function with its root function for effect tracking
- * Enforces strict unicity: A root function can only identify ONE function.
- * @param fn - The function to mark
- * @param root - The root function
- * @returns The marked function
- */
-export function markWithRoot<T extends Function>(fn: T, root: any): T {
-	// Check for collision
-	const existingRef = reverseRoots.get(root)
-	const existing = existingRef?.deref()
-
-	if (existing && existing !== fn) {
-		const rootName = root.name || 'anonymous'
-		const existingName = existing.name || 'anonymous'
-		const fnName = fn.name || 'anonymous'
-		throw new Error(
-			`[reactive] Abusive Shared Root detected: Root '${rootName}' is already identifying function '${existingName}'. ` +
-				`Cannot reuse it for '${fnName}'. Shared roots cause lost updates and broken identity logic.`
-		)
-	}
-
-	// Always update the map so subsequent checks find this one
-	// (Last writer wins for the check)
-	reverseRoots.set(root, new WeakRef(fn))
-
-	// Mark fn with the new root
-	return Object.defineProperty(fn, rootFunction, {
-		value: getRoot(root),
-		writable: false,
-	})
-}
-
-/**
- * Gets the root function of a function for effect tracking
- * @param fn - The function to get the root of
- * @returns The root function
- */
-export function getRoot<T extends Function | undefined>(fn: T): T {
-	while (fn && rootFunction in fn) fn = fn[rootFunction] as T
-	return fn
-}

package/src/reactive/set.ts

@@ -1,130 +0,0 @@
-import { contentRef } from '../utils'
-import { touched, touched1 } from './change'
-import { makeReactiveEntriesIterator, makeReactiveIterator } from './non-reactive'
-import { reactive } from './proxy'
-import { dependant } from './tracking'
-
-/**
- * Reactive wrapper around JavaScript's WeakSet class
- * Only tracks individual value operations, no size tracking (WeakSet limitation)
- */
-export abstract class ReactiveWeakSet<T extends object> extends WeakSet<T> {
-	get [Symbol.toStringTag]() {
-		return 'ReactiveWeakSet'
-	}
-	add(value: T): this {
-		const had = this.has(value)
-		this.add(value)
-		if (!had) {
-			// touch the specific value and the collection view
-			touched1(contentRef(this), { type: 'add', prop: value }, value)
-			// no size/allProps for WeakSet
-		}
-		return this
-	}
-
-	delete(value: T): boolean {
-		const had = this.has(value)
-		const res = this.delete(value)
-		if (had) touched1(contentRef(this), { type: 'del', prop: value }, value)
-		return res
-	}
-
-	has(value: T): boolean {
-		dependant(contentRef(this), value)
-		return this.has(value)
-	}
-}
-
-/**
- * Reactive wrapper around JavaScript's Set class
- * Tracks size changes, individual value operations, and collection-wide operations
- */
-export abstract class ReactiveSet<T> extends Set<T> {
-	get [Symbol.toStringTag]() {
-		return 'ReactiveSet'
-	}
-
-	get size(): number {
-		// size depends on the wrapper instance, like Map counterpart
-		dependant(this, 'size')
-		return this.size
-	}
-
-	add(value: T): this {
-		const had = this.has(value)
-		const reactiveValue = reactive(value)
-		this.add(reactiveValue)
-		if (!had) {
-			const evolution = { type: 'add', prop: reactiveValue } as const
-			// touch for value-specific and aggregate dependencies
-			touched1(contentRef(this), evolution, reactiveValue)
-			touched1(this, evolution, 'size')
-		}
-		return this
-	}
-
-	clear(): void {
-		const hadEntries = this.size > 0
-		this.clear()
-		if (hadEntries) {
-			const evolution = { type: 'bunch', method: 'clear' } as const
-			touched1(this, evolution, 'size')
-			touched(contentRef(this), evolution)
-		}
-	}
-
-	delete(value: T): boolean {
-		const had = this.has(value)
-		const res = this.delete(value)
-		if (had) {
-			const evolution = { type: 'del', prop: value } as const
-			touched1(contentRef(this), evolution, value)
-			touched1(this, evolution, 'size')
-		}
-		return res
-	}
-
-	has(value: T): boolean {
-		dependant(contentRef(this), value)
-		return this.has(value)
-	}
-
-	entries(): Generator<[T, T]> {
-		dependant(contentRef(this))
-		return makeReactiveEntriesIterator(this.entries())
-	}
-
-	forEach(callbackfn: (value: T, value2: T, set: Set<T>) => void, thisArg?: any): void {
-		dependant(contentRef(this))
-		this.forEach(callbackfn, thisArg)
-	}
-
-	keys(): Generator<T> {
-		dependant(contentRef(this))
-		return makeReactiveIterator(this.keys())
-	}
-
-	values(): Generator<T> {
-		dependant(contentRef(this))
-		return makeReactiveIterator(this.values())
-	}
-
-	[Symbol.iterator](): SetIterator<T> {
-		dependant(contentRef(this))
-		const nativeIterator = this[Symbol.iterator]()
-		return {
-			next() {
-				const result = nativeIterator.next()
-				if (result.done) {
-					return result
-				}
-				return { value: reactive(result.value), done: false }
-			},
-			[Symbol.iterator]() {
-				return this
-			},
-			[Symbol.dispose]() {},
-		} as any	//TODO? (something easy)
-	}
-}

package/src/reactive/tracking.ts

@@ -1,44 +0,0 @@
-import { getActiveEffect } from './effect-context'
-import { unwrap } from './proxy-state'
-import {
-	effectToReactiveObjects,
-	watchers,
-} from './registry'
-import { allProps, type ScopedCallback } from './types'
-
-/**
- * Marks a property as a dependency of the current effect
- * @param obj - The object containing the property
- * @param prop - The property name (defaults to allProps)
- */
-export function dependant(obj: any, prop: any = allProps) {
-	obj = unwrap(obj)
-	const currentActiveEffect = getActiveEffect()
-
-	// Early return if no active effect, tracking disabled, or invalid prop
-	if (
-		!currentActiveEffect ||
-		(typeof prop === 'symbol' && prop !== allProps)
-	)
-		return
-
-	let objectWatchers = watchers.get(obj)
-	if (!objectWatchers) {
-		objectWatchers = new Map<PropertyKey, Set<ScopedCallback>>()
-		watchers.set(obj, objectWatchers)
-	}
-	let deps = objectWatchers.get(prop)
-	if (!deps) {
-		deps = new Set<ScopedCallback>()
-		objectWatchers.set(prop, deps)
-	}
-	deps.add(currentActiveEffect)
-
-	// Track which reactive objects this effect is watching
-	const effectObjects = effectToReactiveObjects.get(currentActiveEffect)
-	if (effectObjects) {
-		effectObjects.add(obj)
-	} else {
-		effectToReactiveObjects.set(currentActiveEffect, new Set([obj]))
-	}
-}