mutts 1.0.1 → 1.0.3

package/src/reactive/register.ts

@@ -0,0 +1,421 @@
+import { ArrayReadForward, forwardArray, getAt, Indexable, setAt } from '../indexable'
+import { effect } from './effects'
+import { unreactive } from './interface'
+import { reactive } from './proxy'
+import { type DependencyFunction, prototypeForwarding, 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
+}
+
+@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: DependencyFunction
+
+	constructor(keyFn: KeyFunction<T, K>, initial?: Iterable<T>) {
+		super()
+		/* Moved below initialization */
+		let ascendGet: DependencyFunction | 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>())
+		Object.defineProperties(this, {
+			[prototypeForwarding]: { value: this.#keys },
+		})
+		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/set.ts

@@ -0,0 +1,144 @@
+import { touched, touched1 } from './change'
+import { makeReactiveEntriesIterator, makeReactiveIterator } from './non-reactive'
+import { reactive } from './proxy'
+import { dependant } from './tracking'
+import { prototypeForwarding } from './types'
+
+const native = Symbol('native')
+
+/**
+ * Reactive wrapper around JavaScript's WeakSet class
+ * 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
+
+	constructor(original: WeakSet<T>) {
+		Object.defineProperties(this, {
+			[native]: { value: original },
+			[prototypeForwarding]: { value: original },
+			content: { value: Symbol('content') },
+			[Symbol.toStringTag]: { value: 'ReactiveWeakSet' },
+		})
+	}
+
+	add(value: T): this {
+		const had = this[native].has(value)
+		this[native].add(value)
+		if (!had) {
+			// touch the specific value and the collection view
+			touched1(this.content, { type: 'add', prop: value }, value)
+			// no size/allProps for WeakSet
+		}
+		return this
+	}
+
+	delete(value: T): boolean {
+		const had = this[native].has(value)
+		const res = this[native].delete(value)
+		if (had) touched1(this.content, { type: 'del', prop: value }, value)
+		return res
+	}
+
+	has(value: T): boolean {
+		dependant(this.content, value)
+		return this[native].has(value)
+	}
+}
+
+/**
+ * Reactive wrapper around JavaScript's Set class
+ * Tracks size changes, individual value operations, and collection-wide operations
+ */
+export class ReactiveSet<T> {
+	declare readonly [native]: Set<T>
+	declare readonly content: symbol
+	constructor(original: Set<T>) {
+		Object.defineProperties(this, {
+			[native]: { value: original },
+			[prototypeForwarding]: { value: original },
+			content: { value: Symbol('content') },
+			[Symbol.toStringTag]: { value: 'ReactiveSet' },
+		})
+	}
+
+	get size(): number {
+		// size depends on the wrapper instance, like Map counterpart
+		dependant(this, 'size')
+		return this[native].size
+	}
+
+	add(value: T): this {
+		const had = this[native].has(value)
+		const reactiveValue = reactive(value)
+		this[native].add(reactiveValue)
+		if (!had) {
+			const evolution = { type: 'add', prop: reactiveValue } as const
+			// touch for value-specific and aggregate dependencies
+			touched1(this.content, evolution, reactiveValue)
+			touched1(this, evolution, 'size')
+		}
+		return this
+	}
+
+	clear(): void {
+		const hadEntries = this[native].size > 0
+		this[native].clear()
+		if (hadEntries) {
+			const evolution = { type: 'bunch', method: 'clear' } as const
+			touched1(this, evolution, 'size')
+			touched(this.content, evolution)
+		}
+	}
+
+	delete(value: T): boolean {
+		const had = this[native].has(value)
+		const res = this[native].delete(value)
+		if (had) {
+			const evolution = { type: 'del', prop: value } as const
+			touched1(this.content, evolution, value)
+			touched1(this, evolution, 'size')
+		}
+		return res
+	}
+
+	has(value: T): boolean {
+		dependant(this.content, value)
+		return this[native].has(value)
+	}
+
+	entries(): Generator<[T, T]> {
+		dependant(this.content)
+		return makeReactiveEntriesIterator(this[native].entries())
+	}
+
+	forEach(callbackfn: (value: T, value2: T, set: Set<T>) => void, thisArg?: any): void {
+		dependant(this.content)
+		this[native].forEach(callbackfn, thisArg)
+	}
+
+	keys(): Generator<T> {
+		dependant(this.content)
+		return makeReactiveIterator(this[native].keys())
+	}
+
+	values(): Generator<T> {
+		dependant(this.content)
+		return makeReactiveIterator(this[native].values())
+	}
+
+	[Symbol.iterator](): Iterator<T> {
+		dependant(this.content)
+		const nativeIterator = this[native][Symbol.iterator]()
+		return {
+			next() {
+				const result = nativeIterator.next()
+				if (result.done) {
+					return result
+				}
+				return { value: reactive(result.value), done: false }
+			},
+		}
+	}
+}

package/src/reactive/tracking.ts

@@ -0,0 +1,101 @@
+import { getActiveEffect } from './effect-context'
+import { unwrap } from './proxy-state'
+import { allProps, 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>()
+
+/**
+ * Marks a function with its root function for effect tracking
+ * @param fn - The function to mark
+ * @param root - The root function
+ * @returns The marked function
+ */
+export function markWithRoot<T extends Function>(fn: T, root: Function): T {
+	// 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 {
+	return (fn as any)?.[rootFunction] || fn
+}
+
+// Flag to disable dependency tracking for the current active effect (not globally)
+const trackingDisabledEffects = new WeakSet<ScopedCallback>()
+let globalTrackingDisabled = false
+
+export function getTrackingDisabled(): boolean {
+	const active = getActiveEffect()
+	if (!active) return globalTrackingDisabled
+	return trackingDisabledEffects.has(getRoot(active))
+}
+
+export function setTrackingDisabled(value: boolean): void {
+	const active = getActiveEffect()
+	if (!active) {
+		globalTrackingDisabled = value
+		return
+	}
+	const root = getRoot(active)
+	if (value) trackingDisabledEffects.add(root)
+	else trackingDisabledEffects.delete(root)
+}
+
+/**
+ * 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 ||
+		getTrackingDisabled() ||
+		(typeof prop === 'symbol' && prop !== allProps)
+	)
+		return
+
+	registerDependency(obj, prop, currentActiveEffect)
+}
+
+function registerDependency(obj: any, prop: any, currentActiveEffect: ScopedCallback) {
+	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]))
+	}
+}