mutts 1.0.8 → 1.0.10

package/src/reactive/project.ts

@@ -1,453 +0,0 @@
-import { FoolProof } 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 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
-	: Target extends Map<any, infer Item>
-		? Item
-		: Target extends Record<PropertyKey, infer Item>
-			? Item
-			: unknown
-
-export type ProjectAccess<SourceValue, Key, SourceType, Target> = {
-	readonly key: Key
-	get(): SourceValue
-	set(value: SourceValue): boolean
-	readonly source: SourceType
-	readonly old?: ProjectOldValue<Target>
-	value: SourceValue
-}
-
-export type ProjectCallback<SourceValue, Key, Target extends object, SourceType, Result> = (
-	access: ProjectAccess<SourceValue, Key, SourceType, Target>,
-	target: Target
-) => Result
-
-export type ProjectResult<Target extends object> = Target & { [cleanup]: ScopedCallback }
-
-function defineAccessValue<Access extends { get(): unknown; set(value: unknown): boolean }>(
-	access: Access
-) {
-	Object.defineProperty(access, 'value', {
-		get: access.get,
-		set: access.set,
-		configurable: true,
-		enumerable: true,
-	})
-}
-
-function makeCleanup<Result extends object>(
-	target: Result,
-	effectMap: Map<unknown, ScopedCallback>,
-	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?.()
-		effectMap.clear()
-	}) as ProjectResult<Result>
-}
-
-function projectArray<SourceValue, ResultValue>(
-	source: readonly SourceValue[],
-	apply: ProjectCallback<SourceValue, number, ResultValue[], readonly SourceValue[], ResultValue>
-): ProjectResult<ResultValue[]> {
-	source = reactive(source)
-	const target = reactive([] as ResultValue[])
-	const indexEffects = new Map<number, ScopedCallback>()
-
-	function normalizeTargetLength(length: number) {
-		FoolProof.set(target as unknown as object, 'length', length, target)
-	}
-
-	function disposeIndex(index: number) {
-		const stopEffect = indexEffects.get(index)
-		if (stopEffect) {
-			indexEffects.delete(index)
-			stopEffect()
-			Reflect.deleteProperty(target as unknown as object, index)
-		}
-	}
-
-	const parent = getActiveProjection()
-	const depth = parent ? parent.depth + 1 : 0
-
-	const cleanupLength = effect(function projectArrayLengthEffect({ ascend }) {
-		const length = source.length
-		normalizeTargetLength(length)
-		const existing = Array.from(indexEffects.keys())
-		for (let i = 0; i < length; i++) {
-			if (indexEffects.has(i)) continue
-			ascend(() => {
-				const index = i
-				const stop = effect(function projectArrayIndexEffect() {
-					const previous = untracked(() => target[index])
-					const accessBase = {
-						key: index,
-						source,
-						get: () => FoolProof.get(source as any, index, source),
-						set: (value: SourceValue) =>
-							FoolProof.set(source as any, index, value, source),
-						old: previous,
-					} as ProjectAccess<SourceValue, number, readonly SourceValue[], ResultValue[]>
-					defineAccessValue(accessBase)
-					const produced = apply(accessBase, target)
-					target[index] = produced
-				})
-				setEffectName(stop, `project[${depth}]:${index}`)
-				effectProjectionMetadata.set(stop, {
-					source,
-					key: index,
-					target,
-					depth,
-					parent,
-				})
-				indexEffects.set(i, stop)
-			})
-		}
-		for (const index of existing) if (index >= length) disposeIndex(index)
-	})
-
-	return makeCleanup(target, indexEffects, () => cleanupLength(), {
-		source,
-		target,
-		apply,
-		depth,
-		parent,
-	} as ProjectionContext)
-}
-
-function projectRegister<Key extends PropertyKey, SourceValue, ResultValue>(
-	source: Register<SourceValue, Key>,
-	apply: ProjectCallback<
-		SourceValue,
-		Key,
-		Map<Key, ResultValue>,
-		Register<SourceValue, Key>,
-		ResultValue
-	>
-): ProjectResult<Map<Key, ResultValue>> {
-	const observedSource = reactive(source) as Register<SourceValue, Key>
-	const rawTarget = new Map<Key, ResultValue>()
-	const target = reactive(rawTarget) as Map<Key, ResultValue>
-	const keyEffects = new Map<Key, ScopedCallback>()
-
-	function disposeKey(key: Key) {
-		const stopEffect = keyEffects.get(key)
-		if (stopEffect) {
-			stopEffect()
-			keyEffects.delete(key)
-			target.delete(key)
-		}
-	}
-
-	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)
-
-		for (const key of keys) {
-			if (keyEffects.has(key)) continue
-			ascend(() => {
-				const stop = effect(function projectRegisterKeyEffect() {
-					const previous = untracked(() => target.get(key))
-					const accessBase = {
-						key,
-						source: observedSource,
-						get: () => observedSource.get(key) as SourceValue,
-						set: (value: SourceValue) => {
-							observedSource.set(key, value)
-							return true
-						},
-						old: previous,
-					} as ProjectAccess<SourceValue, Key, Register<SourceValue, Key>, Map<Key, ResultValue>>
-					defineAccessValue(accessBase)
-					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)
-			})
-		}
-
-		for (const key of Array.from(keyEffects.keys())) if (!keys.has(key)) disposeKey(key)
-	})
-
-	return makeCleanup(target, keyEffects, () => cleanupKeys(), {
-		source: observedSource,
-		target,
-		apply,
-		depth,
-		parent,
-	} as ProjectionContext)
-}
-
-function projectRecord<Source extends Record<PropertyKey, any>, ResultValue>(
-	source: Source,
-	apply: ProjectCallback<
-		Source[keyof Source],
-		keyof Source,
-		Record<keyof Source, ResultValue>,
-		Source,
-		ResultValue
-	>
-): ProjectResult<Record<keyof Source, ResultValue>> {
-	const observedSource = reactive(source) as Source
-	const target = reactive({} as Record<keyof Source, ResultValue>)
-	const keyEffects = new Map<PropertyKey, ScopedCallback>()
-
-	function disposeKey(key: PropertyKey) {
-		const stopEffect = keyEffects.get(key)
-		if (stopEffect) {
-			stopEffect()
-			keyEffects.delete(key)
-			Reflect.deleteProperty(target as Record<PropertyKey, unknown>, key)
-		}
-	}
-
-	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)
-		const observed = Reflect.ownKeys(observedSource)
-		for (const key of observed) keys.add(key)
-
-		for (const key of keys) {
-			if (keyEffects.has(key)) continue
-			ascend(() => {
-				const stop = effect(function projectRecordKeyEffect() {
-					const sourceKey = key as keyof Source
-					const previous = untracked(
-						() => (target as Record<PropertyKey, ResultValue | undefined>)[key]
-					)
-					const accessBase = {
-						key: sourceKey,
-						source: observedSource,
-						get: () => FoolProof.get(observedSource, sourceKey, observedSource),
-						set: (value: Source[typeof sourceKey]) =>
-							FoolProof.set(observedSource, sourceKey, value, observedSource),
-						old: previous,
-					} as ProjectAccess<
-						Source[typeof sourceKey],
-						keyof Source,
-						Source,
-						Record<keyof Source, ResultValue>
-					>
-					defineAccessValue(accessBase)
-					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)
-			})
-		}
-
-		for (const key of Array.from(keyEffects.keys())) if (!keys.has(key)) disposeKey(key)
-	})
-
-	return makeCleanup(target, keyEffects, () => cleanupKeys(), {
-		source: observedSource,
-		target,
-		apply,
-		depth,
-		parent,
-	} as ProjectionContext)
-}
-
-function projectMap<Key, Value, ResultValue>(
-	source: Map<Key, Value>,
-	apply: ProjectCallback<Value, Key, Map<Key, ResultValue>, Map<Key, Value>, ResultValue>
-): ProjectResult<Map<Key, ResultValue>> {
-	const observedSource = reactive(source) as Map<Key, Value>
-	const rawTarget = new Map<Key, ResultValue>()
-	const target = reactive(rawTarget) as Map<Key, ResultValue>
-	const keyEffects = new Map<Key, ScopedCallback>()
-
-	function disposeKey(key: Key) {
-		const stopEffect = keyEffects.get(key)
-		if (stopEffect) {
-			stopEffect()
-			keyEffects.delete(key)
-			target.delete(key)
-		}
-	}
-
-	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)
-
-		for (const key of keys) {
-			if (keyEffects.has(key)) continue
-			ascend(() => {
-				const stop = effect(function projectMapKeyEffect() {
-					const previous = untracked(() => target.get(key))
-					const accessBase = {
-						key,
-						source: observedSource,
-						get: () => observedSource.get(key) as Value,
-						set: (value: Value) => {
-							observedSource.set(key, value)
-							return true
-						},
-						old: previous,
-					} as ProjectAccess<Value, Key, Map<Key, Value>, Map<Key, ResultValue>>
-					defineAccessValue(accessBase)
-					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)
-			})
-		}
-
-		for (const key of Array.from(keyEffects.keys())) if (!keys.has(key)) disposeKey(key)
-	})
-
-	return makeCleanup(target, keyEffects, () => cleanupKeys(), {
-		source: observedSource,
-		target,
-		apply,
-		depth,
-		parent,
-	} as ProjectionContext)
-}
-
-type ProjectOverload = {
-	<SourceValue, ResultValue>(
-		source: readonly SourceValue[],
-		apply: ProjectCallback<SourceValue, number, ResultValue[], readonly SourceValue[], ResultValue>
-	): ProjectResult<ResultValue[]>
-	<Key extends PropertyKey, SourceValue, ResultValue>(
-		source: Register<SourceValue, Key>,
-		apply: ProjectCallback<
-			SourceValue,
-			Key,
-			Map<Key, ResultValue>,
-			Register<SourceValue, Key>,
-			ResultValue
-		>
-	): ProjectResult<Map<Key, ResultValue>>
-	<Source extends Record<PropertyKey, any>, ResultValue>(
-		source: Source,
-		apply: ProjectCallback<
-			Source[keyof Source],
-			keyof Source,
-			Record<keyof Source, ResultValue>,
-			Source,
-			ResultValue
-		>
-	): ProjectResult<Record<keyof Source, ResultValue>>
-	<Key, Value, ResultValue>(
-		source: Map<Key, Value>,
-		apply: ProjectCallback<Value, Key, Map<Key, ResultValue>, Map<Key, Value>, ResultValue>
-	): ProjectResult<Map<Key, ResultValue>>
-	array: typeof projectArray
-	register: typeof projectRegister
-	record: typeof projectRecord
-	map: typeof projectMap
-}
-
-function projectCore<SourceValue, ResultValue>(
-	source: readonly SourceValue[],
-	apply: ProjectCallback<SourceValue, number, ResultValue[], readonly SourceValue[], ResultValue>
-): ProjectResult<ResultValue[]>
-function projectCore<Key extends PropertyKey, SourceValue, ResultValue>(
-	source: Register<SourceValue, Key>,
-	apply: ProjectCallback<
-		SourceValue,
-		Key,
-		Map<Key, ResultValue>,
-		Register<SourceValue, Key>,
-		ResultValue
-	>
-): ProjectResult<Map<Key, ResultValue>>
-function projectCore<Source extends Record<PropertyKey, any>, ResultValue>(
-	source: Source,
-	apply: ProjectCallback<
-		Source[keyof Source],
-		keyof Source,
-		Record<keyof Source, ResultValue>,
-		Source,
-		ResultValue
-	>
-): ProjectResult<Record<keyof Source, ResultValue>>
-function projectCore<Key, Value, ResultValue>(
-	source: Map<Key, Value>,
-	apply: ProjectCallback<Value, Key, Map<Key, ResultValue>, Map<Key, Value>, ResultValue>
-): ProjectResult<Map<Key, ResultValue>>
-function projectCore(source: any, apply: any): ProjectResult<any> {
-	if (Array.isArray(source)) return projectArray(source, apply)
-	if (source instanceof Map) return projectMap(source, apply)
-	if (source instanceof Register) return projectRegister(source, apply)
-	if (source && (source.constructor === Object || source.constructor === undefined))
-		return projectRecord(source, apply)
-	throw new Error('Unsupported source type')
-}
-
-export const project: ProjectOverload = Object.assign(projectCore, {
-	array: projectArray,
-	register: projectRegister,
-	record: projectRecord,
-	map: projectMap,
-})

package/src/reactive/proxy-state.ts

@@ -1,27 +0,0 @@
-export const objectToProxy = new WeakMap<object, object>()
-export const proxyToObject = new WeakMap<object, object>()
-
-export function storeProxyRelationship(target: object, proxy: object) {
-	objectToProxy.set(target, proxy)
-	proxyToObject.set(proxy, target)
-}
-
-export function getExistingProxy<T extends object>(target: T): T | undefined {
-	return objectToProxy.get(target) as T | undefined
-}
-
-export function trackProxyObject(proxy: object, target: object) {
-	proxyToObject.set(proxy, target)
-}
-
-export function unwrap<T>(obj: T): T {
-	let current = obj
-	while (current && typeof current === 'object' && current !== null && proxyToObject.has(current)) {
-		current = proxyToObject.get(current) as T
-	}
-	return current
-}
-
-export function isReactive(obj: any): boolean {
-	return proxyToObject.has(obj)
-}