mutts 1.0.0 → 1.0.1

package/src/reactive/map.ts

@@ -1,162 +0,0 @@
-import {
-	dependant,
-	makeReactiveEntriesIterator,
-	makeReactiveIterator,
-	prototypeForwarding,
-	reactive,
-	touched,
-	touched1,
-} from './core'
-
-const native = Symbol('native')
-
-// TODO: [prototypeForwarding]
-
-export class ReactiveWeakMap<K extends object, V> {
-	declare readonly [native]: WeakMap<K, V>
-	declare readonly content: symbol
-	constructor(original: WeakMap<K, V>) {
-		Object.defineProperties(this, {
-			[native]: { value: original },
-			[prototypeForwarding]: { value: original },
-			content: { value: Symbol('content') },
-			[Symbol.toStringTag]: { value: 'ReactiveWeakMap' },
-		})
-	}
-
-	// Implement WeakMap interface methods with reactivity
-	delete(key: K): boolean {
-		const hadKey = this[native].has(key)
-		const result = this[native].delete(key)
-
-		if (hadKey) touched1(this.content, { type: 'del', prop: key }, key)
-
-		return result
-	}
-
-	get(key: K): V | undefined {
-		dependant(this.content, key)
-		return reactive(this[native].get(key))
-	}
-
-	has(key: K): boolean {
-		dependant(this.content, key)
-		return this[native].has(key)
-	}
-
-	set(key: K, value: V): this {
-		// Trigger effects for the specific key
-		touched1(this.content, { type: this[native].has(key) ? 'set' : 'add', prop: key }, key)
-		this[native].set(key, value)
-
-		return this
-	}
-}
-
-export class ReactiveMap<K, V> {
-	declare readonly [native]: Map<K, V>
-	declare readonly content: symbol
-
-	constructor(original: Map<K, V>) {
-		Object.defineProperties(this, {
-			[native]: { value: original },
-			[prototypeForwarding]: { value: original },
-			content: { value: Symbol('content') },
-			[Symbol.toStringTag]: { value: 'ReactiveMap' },
-		})
-	}
-
-	// Implement Map interface methods with reactivity
-	get size(): number {
-		dependant(this, 'size') // The ReactiveMap instance still goes through proxy
-		return this[native].size
-	}
-
-	clear(): void {
-		const hadEntries = this[native].size > 0
-		this[native].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(this.content, evolution)
-		}
-	}
-
-	entries(): Generator<[K, V]> {
-		dependant(this.content)
-		return makeReactiveEntriesIterator(this[native].entries())
-	}
-
-	forEach(callbackfn: (value: V, key: K, map: Map<K, V>) => void, thisArg?: any): void {
-		dependant(this.content)
-		this[native].forEach(callbackfn, thisArg)
-	}
-
-	keys(): MapIterator<K> {
-		dependant(this.content)
-		return this[native].keys()
-	}
-
-	values(): Generator<V> {
-		dependant(this.content)
-		return makeReactiveIterator(this[native].values())
-	}
-
-	[Symbol.iterator](): Iterator<[K, V]> {
-		dependant(this.content)
-		const nativeIterator = this[native][Symbol.iterator]()
-		return {
-			next() {
-				const result = nativeIterator.next()
-				if (result.done) {
-					return result
-				}
-				return {
-					value: [result.value[0], reactive(result.value[1])],
-					done: false,
-				}
-			},
-		}
-	}
-
-	// Implement Map methods with reactivity
-	delete(key: K): boolean {
-		const hadKey = this[native].has(key)
-		const result = this[native].delete(key)
-
-		if (hadKey) {
-			const evolution = { type: 'del', prop: key } as const
-			touched1(this.content, evolution, key)
-			touched1(this, evolution, 'size')
-		}
-
-		return result
-	}
-
-	get(key: K): V | undefined {
-		dependant(this.content, key)
-		return reactive(this[native].get(key))
-	}
-
-	has(key: K): boolean {
-		dependant(this.content, key)
-		return this[native].has(key)
-	}
-
-	set(key: K, value: V): this {
-		const hadKey = this[native].has(key)
-		const oldValue = this[native].get(key)
-		const reactiveValue = reactive(value)
-		this[native].set(key, reactiveValue)
-
-		if (!hadKey || oldValue !== reactiveValue) {
-			const evolution = { type: hadKey ? 'set' : 'add', prop: key } as const
-			touched1(this.content, evolution, key)
-			touched1(this, evolution, 'size')
-		}
-
-		return this
-	}
-}

package/src/reactive/set.test.ts

@@ -1,289 +0,0 @@
-import { effect, reactive } from './index'
-
-describe('ReactiveWeakSet', () => {
-	describe('reactive operations', () => {
-		it('should track dependencies when checking existence', () => {
-			const ws = new WeakSet<object>()
-			const rws = reactive(ws)
-			const key = { id: 1 }
-
-			let count = 0
-			effect(() => {
-				count++
-				rws.has(key)
-			})
-
-			expect(count).toBe(1)
-			rws.add(key)
-			expect(count).toBe(2)
-			rws.delete(key)
-			expect(count).toBe(3)
-		})
-
-		it('should not trigger when deleting non-existent keys', () => {
-			const ws = new WeakSet<object>()
-			const rws = reactive(ws)
-			const key = { id: 1 }
-
-			let count = 0
-			effect(() => {
-				count++
-				rws.has(key)
-			})
-
-			expect(count).toBe(1)
-			rws.delete(key)
-			expect(count).toBe(1)
-		})
-	})
-
-	describe('toStringTag', () => {
-		it('should have correct toStringTag', () => {
-			const ws = new WeakSet<object>()
-			const rws = reactive(ws)
-			expect(rws[Symbol.toStringTag]).toBe('ReactiveWeakSet')
-		})
-	})
-})
-
-describe('ReactiveSet', () => {
-	describe('reactive operations', () => {
-		it('should track size dependencies', () => {
-			const s = new Set<number>()
-			const rs = reactive(s)
-
-			let count = 0
-			effect(() => {
-				count++
-				rs.size
-			})
-
-			expect(count).toBe(1)
-			rs.add(1)
-			expect(count).toBe(2)
-		})
-
-		it('should track dependencies when checking existence', () => {
-			const s = new Set<number>()
-			const rs = reactive(s)
-			rs.add(1)
-
-			let count = 0
-			effect(() => {
-				count++
-				rs.has(1)
-			})
-
-			expect(count).toBe(1)
-			rs.add(2)
-			expect(count).toBe(1)
-			rs.delete(1)
-			expect(count).toBe(2)
-		})
-
-		it('should trigger effects when adding new values', () => {
-			const s = new Set<number>()
-			const rs = reactive(s)
-
-			let count = 0
-			effect(() => {
-				count++
-				rs.has(1)
-			})
-
-			expect(count).toBe(1)
-			rs.add(1)
-			expect(count).toBe(2)
-		})
-
-		it('should trigger effects when deleting values', () => {
-			const s = new Set<number>()
-			const rs = reactive(s)
-			rs.add(1)
-
-			let count = 0
-			effect(() => {
-				count++
-				rs.has(1)
-			})
-
-			expect(count).toBe(1)
-			rs.delete(1)
-			expect(count).toBe(2)
-		})
-
-		it('should not trigger effects when deleting non-existent values', () => {
-			const s = new Set<number>()
-			const rs = reactive(s)
-
-			let count = 0
-			effect(() => {
-				count++
-				rs.has(1)
-			})
-
-			expect(count).toBe(1)
-			rs.delete(1)
-			expect(count).toBe(1)
-		})
-	})
-
-	describe('allProps reactivity', () => {
-		it('should trigger allProps effects when adding values', () => {
-			const s = new Set<number>()
-			const rs = reactive(s)
-
-			let allPropsCount = 0
-			effect(() => {
-				allPropsCount++
-				// Use iteration to depend on all entries
-				for (const _v of rs.entries()) {
-				}
-			})
-
-			expect(allPropsCount).toBe(1)
-			rs.add(1)
-			expect(allPropsCount).toBe(2)
-			rs.add(2)
-			expect(allPropsCount).toBe(3)
-		})
-
-		it('should trigger allProps effects when deleting values', () => {
-			const s = new Set<number>()
-			const rs = reactive(s)
-			rs.add(1)
-			rs.add(2)
-
-			let allPropsCount = 0
-			effect(() => {
-				allPropsCount++
-				rs.keys()
-			})
-
-			expect(allPropsCount).toBe(1)
-			rs.delete(1)
-			expect(allPropsCount).toBe(2)
-			rs.delete(2)
-			expect(allPropsCount).toBe(3)
-		})
-
-		it('should trigger allProps effects when clearing', () => {
-			const s = new Set<number>()
-			const rs = reactive(s)
-			rs.add(1)
-			rs.add(2)
-
-			let sizeCount = 0
-			let allPropsCount = 0
-			effect(() => {
-				sizeCount++
-				rs.size
-			})
-			effect(() => {
-				allPropsCount++
-				rs.values()
-			})
-
-			expect(sizeCount).toBe(1)
-			expect(allPropsCount).toBe(1)
-			rs.clear()
-			expect(sizeCount).toBe(2)
-			expect(allPropsCount).toBe(2)
-		})
-	})
-
-	describe('iteration methods', () => {
-		it('should track allProps for entries()', () => {
-			const rs = reactive(new Set<number>())
-
-			let count = 0
-			effect(() => {
-				count++
-				rs.entries()
-			})
-
-			expect(count).toBe(1)
-			rs.add(1)
-			expect(count).toBe(2)
-		})
-
-		it('should track allProps for forEach()', () => {
-			const rs = reactive(new Set<number>())
-
-			let count = 0
-			effect(() => {
-				count++
-				rs.forEach(() => {})
-			})
-
-			expect(count).toBe(1)
-			rs.add(1)
-			expect(count).toBe(2)
-		})
-
-		it('should track allProps for keys() and values() and iterator', () => {
-			const rs = reactive(new Set<number>())
-
-			let countKeys = 0
-			let countValues = 0
-			let countIter = 0
-
-			effect(() => {
-				countKeys++
-				rs.keys()
-			})
-
-			effect(() => {
-				countValues++
-				rs.values()
-			})
-
-			effect(() => {
-				countIter++
-				for (const _v of rs) {
-				}
-			})
-
-			expect(countKeys).toBe(1)
-			expect(countValues).toBe(1)
-			expect(countIter).toBe(1)
-
-			rs.add(1)
-			expect(countKeys).toBe(2)
-			expect(countValues).toBe(2)
-			expect(countIter).toBe(2)
-		})
-	})
-
-	describe('seamless reactive integration', () => {
-		it('should automatically create ReactiveSet when using reactive() on native Set', () => {
-			const nativeSet = new Set([1, 2])
-			const rs = reactive(nativeSet)
-			expect(rs.size).toBe(2)
-			// dependency tracking
-			let count = 0
-			effect(() => {
-				count++
-				rs.has(1)
-			})
-			expect(count).toBe(1)
-			rs.delete(1)
-			expect(count).toBe(2)
-		})
-
-		it('should automatically create ReactiveWeakSet when using reactive() on native WeakSet', () => {
-			const k = { id: 1 }
-			const native = new WeakSet([k])
-			const rws = reactive(native)
-
-			let count = 0
-			effect(() => {
-				count++
-				rws.has(k)
-			})
-			expect(count).toBe(1)
-			rws.delete(k)
-			expect(count).toBe(2)
-		})
-	})
-})

package/src/reactive/set.ts

@@ -1,142 +0,0 @@
-import {
-	dependant,
-	makeReactiveEntriesIterator,
-	makeReactiveIterator,
-	prototypeForwarding,
-	reactive,
-	touched,
-	touched1,
-} from './core'
-
-const native = Symbol('native')
-
-// TODO: [prototypeForwarding]
-
-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)
-	}
-}
-
-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 }
-			},
-		}
-	}
-}