mutts 1.0.9 → 1.0.10

package/src/reactive/watch.ts

@@ -1,180 +0,0 @@
-import { decorator, type GenericClassDecorator } from '../decorator'
-import { deepWatch } from './deep-watch'
-import { effect } 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 EffectAccess,
-	type EffectCleanup,
-	nonReactiveMark,
-	stopped,
-	unreactiveProperties,
-} from './types'
-
-//#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: EffectAccess) => T,
-	changed: (value: T, oldValue?: T) => void,
-	options?: Omit<WatchOptions, 'deep'> & { deep?: false }
-): EffectCleanup
-/**
- * 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: EffectAccess) => T,
-	changed: (value: T, oldValue?: T) => void,
-	options?: Omit<WatchOptions, 'deep'> & { deep: true }
-): EffectCleanup
-/**
- * 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
-): EffectCleanup
-
-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 } = {}
-): EffectCleanup {
-	if (deep) return deepWatch(value, changed, { immediate })!
-	return effect(function watchObjectEffect() {
-		dependant(value)
-		if (immediate) changed(value)
-		immediate = true
-	})
-}
-
-function watchCallBack<T>(
-	value: (dep: EffectAccess) => T,
-	changed: (value: T, oldValue?: T) => void,
-	{ immediate = false, deep = false } = {}
-): EffectCleanup {
-	let oldValue: T | typeof unsetYet = unsetYet
-	let deepCleanup: EffectCleanup | 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 Object.defineProperties(
-		() => {
-			cbCleanup()
-			if (deepCleanup) deepCleanup()
-		},
-		{
-			[stopped]: { get: () => cbCleanup[stopped] },
-		}
-	) as EffectCleanup
-}
-
-//#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 shallowNonReactive<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'
-		? shallowNonReactive(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

package/src/std-decorators.ts

@@ -1,256 +0,0 @@
-import { decorator, type GenericClassDecorator } from './decorator'
-import { flavored } from './flavored'
-
-// In order to avoid async re-entrance, we could use zone.js or something like that.
-const syncCalculating: { object: object; prop: PropertyKey }[] = []
-/**
- * Decorator that caches the result of a getter method and only recomputes when dependencies change
- * Prevents circular dependencies and provides automatic cache invalidation
- */
-export const cached = decorator({
-	getter(original, _target, propertyKey) {
-		return function (this: any) {
-			const alreadyCalculating = syncCalculating.findIndex(
-				(c) => c.object === this && c.prop === propertyKey
-			)
-			if (alreadyCalculating > -1)
-				throw new Error(
-					`Circular dependency detected: ${syncCalculating
-						.slice(alreadyCalculating)
-						.map((c) => `${c.object.constructor.name}.${String(c.prop)}`)
-						.join(' -> ')} -> again`
-				)
-			syncCalculating.push({ object: this, prop: propertyKey })
-			try {
-				const rv = original.call(this)
-				cache(this, propertyKey, rv)
-				return rv
-			} finally {
-				syncCalculating.pop()
-			}
-		}
-	},
-})
-
-/**
- * Checks if a property is cached (has a cached value)
- * @param object - The object to check
- * @param propertyKey - The property key to check
- * @returns True if the property has a cached value
- */
-export function isCached(object: Object, propertyKey: PropertyKey) {
-	return !!Object.getOwnPropertyDescriptor(object, propertyKey)
-}
-
-/**
- * Caches a value for a property on an object
- * @param object - The object to cache the value on
- * @param propertyKey - The property key to cache
- * @param value - The value to cache
- */
-export function cache(object: Object, propertyKey: PropertyKey, value: any) {
-	Object.defineProperty(object, propertyKey, { value })
-}
-
-/**
- * Creates a decorator that modifies property descriptors for specified properties
- * @param descriptor - The descriptor properties to apply
- * @returns A class decorator that applies the descriptor to specified properties
- */
-export const descriptor = flavored(
-	function descriptor(descriptor: {
-		enumerable?: boolean
-		configurable?: boolean // Not modifiable once the property has been defined
-		writable?: boolean
-	}) {
-		return <T>(...properties: (keyof T)[]): GenericClassDecorator<T> =>
-			(Base) => {
-				return class extends Base {
-					constructor(...args: any[]) {
-						super(...args)
-						for (const key of properties) {
-							const existing = Object.getOwnPropertyDescriptor(this, key)
-							Object.defineProperty(this, key, Object.assign(existing || {}, descriptor))
-						}
-					}
-				}
-			}
-	},
-	{
-		/**
-		 * enumerable: true
-		 */
-		get enumerable() {
-			return descriptor({ enumerable: true })
-		},
-		/**
-		 * enumerable: false
-		 */
-		get hidden() {
-			return descriptor({ enumerable: false })
-		},
-		/**
-		 * configurable: true
-		 */
-		get configurable() {
-			return descriptor({ configurable: true })
-		},
-		/**
-		 * configurable: false
-		 */
-		get frozen() {
-			return descriptor({ configurable: false })
-		},
-		/**
-		 * writable: true
-		 */
-		get writable() {
-			return descriptor({ writable: true })
-		},
-		/**
-		 * writable: false
-		 */
-		get readonly() {
-			return descriptor({ writable: false })
-		},
-	}
-)
-
-/**
- * Decorator that marks methods, properties, or classes as deprecated
- * Provides warning messages when deprecated items are used
- */
-export const deprecated = Object.assign(
-	decorator({
-		method(original, _target, propertyKey) {
-			return function (this: any, ...args: any[]) {
-				deprecated.warn(this, propertyKey)
-				return original.apply(this, args)
-			}
-		},
-		getter(original, _target, propertyKey) {
-			return function (this: any) {
-				deprecated.warn(this, propertyKey)
-				return original.call(this)
-			}
-		},
-		setter(original, _target, propertyKey) {
-			return function (this: any, value: any) {
-				deprecated.warn(this, propertyKey)
-				return original.call(this, value)
-			}
-		},
-		class(original) {
-			return class extends original {
-				constructor(...args: any[]) {
-					super(...args)
-					deprecated.warn(this, 'constructor')
-				}
-			}
-		},
-		default(message: string) {
-			return decorator({
-				method(original, _target, propertyKey) {
-					return function (this: any, ...args: any[]) {
-						deprecated.warn(this, propertyKey, message)
-						return original.apply(this, args)
-					}
-				},
-				getter(original, _target, propertyKey) {
-					return function (this: any) {
-						deprecated.warn(this, propertyKey, message)
-						return original.call(this)
-					}
-				},
-				setter(original, _target, propertyKey) {
-					return function (this: any, value: any) {
-						deprecated.warn(this, propertyKey, message)
-						return original.call(this, value)
-					}
-				},
-				class(original) {
-					return class extends original {
-						constructor(...args: any[]) {
-							super(...args)
-							deprecated.warn(this, 'constructor', message)
-						}
-					}
-				},
-			})
-		},
-	}),
-	{
-		warn: (target: any, propertyKey: PropertyKey, message?: string) => {
-			// biome-ignore lint/suspicious/noConsole: To be overridden
-			console.warn(
-				`${target.constructor.name}.${String(propertyKey)} is deprecated${message ? `: ${message}` : ''}`
-			)
-		},
-	}
-)
-
-/**
- * Creates a debounced method decorator that delays execution until after the delay period has passed
- * @param delay - The delay in milliseconds
- * @returns A method decorator that debounces method calls
- */
-export function debounce(delay: number) {
-	return decorator({
-		method(original, _target, _propertyKey) {
-			let timeoutId: ReturnType<typeof setTimeout> | null = null
-
-			return function (this: any, ...args: any[]) {
-				// Clear existing timeout
-				if (timeoutId) {
-					clearTimeout(timeoutId)
-				}
-
-				// Set new timeout
-				timeoutId = setTimeout(() => {
-					original.apply(this, args)
-					timeoutId = null
-				}, delay)
-			}
-		},
-	})
-}
-
-/**
- * Creates a throttled method decorator that limits execution to once per delay period
- * @param delay - The delay in milliseconds
- * @returns A method decorator that throttles method calls
- */
-export function throttle(delay: number) {
-	return decorator({
-		method(original, _target, _propertyKey) {
-			let lastCallTime = 0
-			let timeoutId: ReturnType<typeof setTimeout> | null = null
-
-			return function (this: any, ...args: any[]) {
-				const now = Date.now()
-
-				// If enough time has passed since last call, execute immediately
-				if (now - lastCallTime >= delay) {
-					// Clear any pending timeout since we're executing now
-					if (timeoutId) {
-						clearTimeout(timeoutId)
-						timeoutId = null
-					}
-					lastCallTime = now
-					return original.apply(this, args)
-				}
-
-				// Otherwise, schedule execution for when the delay period ends
-				if (!timeoutId) {
-					const remainingTime = delay - (now - lastCallTime)
-					const scheduledArgs = [...args] // Capture args at scheduling time
-					timeoutId = setTimeout(() => {
-						lastCallTime = Date.now()
-						original.apply(this, scheduledArgs)
-						timeoutId = null
-					}, remainingTime)
-				}
-			}
-		},
-	})
-}