mutts 1.0.5 → 1.0.7

package/src/reactive/mapped.ts

@@ -1,129 +0,0 @@
-import { Indexable } from '../indexable'
-import { native, ReactiveBaseArray } from './array'
-import { touched, touched1 } from './change'
-import { effect, untracked } from './effects'
-import { cleanedBy } from './interface'
-import { reactive } from './proxy'
-import { dependant } from './tracking'
-import { prototypeForwarding, type ScopedCallback } from './types'
-
-// TODO: Lazy reactivity ?
-export class ReadOnlyError extends Error { }
-/**
- * Reactive wrapper around JavaScript's Array class with full array method support
- * Tracks length changes, individual index operations, and collection-wide operations
- */
-class ReactiveReadOnlyArrayClass extends Indexable(ReactiveBaseArray, {
-	get(i: number): any {
-		dependant(this, i)
-		return reactive(this[native][i])
-	},
-	set(i: number, _value: any) {
-		throw new ReadOnlyError(`Setting index ${i} on a read-only array`)
-	},
-	getLength() {
-		dependant(this, 'length')
-		return this[native].length
-	},
-	setLength(value: number) {
-		throw new ReadOnlyError(`Setting length to ${value} on a read-only array`)
-	},
-}) {
-	constructor(original: any[]) {
-		super()
-		Object.defineProperties(this, {
-			// We have to make it double, as [native] must be `unique symbol` - impossible through import
-			[native]: { value: original },
-			[prototypeForwarding]: { value: original },
-		})
-	}
-
-	push(..._items: any[]) {
-		throw new ReadOnlyError(`Pushing items to a read-only array`)
-	}
-
-	pop() {
-		throw new ReadOnlyError(`Popping from a read-only array`)
-	}
-
-	shift() {
-		throw new ReadOnlyError(`Shifting from a read-only array`)
-	}
-
-	unshift(..._items: any[]) {
-		throw new ReadOnlyError(`Unshifting items to a read-only array`)
-	}
-
-	splice(_start: number, _deleteCount?: number, ..._items: any[]) {
-		throw new ReadOnlyError(`Splice from a read-only array`)
-	}
-
-	reverse() {
-		throw new ReadOnlyError(`Reversing a read-only array`)
-	}
-
-	sort(_compareFn?: (a: any, b: any) => number) {
-		throw new ReadOnlyError(`Sorting a read-only array`)
-	}
-
-	fill(_value: any, _start?: number, _end?: number) {
-		throw new ReadOnlyError(`Filling a read-only array`)
-	}
-
-	copyWithin(_target: number, _start: number, _end?: number) {
-		throw new ReadOnlyError(`Copying within a read-only array`)
-	}
-}
-
-export const ReactiveReadOnlyArray = reactive(ReactiveReadOnlyArrayClass)
-export type ReactiveReadOnlyArray<T> = readonly T[]
-export function mapped<T, U>(
-	inputs: readonly T[],
-	compute: (input: T, index: number, output: U[]) => U,
-	resize?: (newLength: number, oldLength: number) => void
-): readonly U[] {
-	const result: U[] = []
-	const resultReactive = new ReactiveReadOnlyArray(result)
-	const cleanups: ScopedCallback[] = []
-	function input(index: number) {
-		return effect(function computedIndexedMapInputEffect() {
-			result[index] = compute(inputs[index], index, resultReactive)
-			touched1(resultReactive, { type: 'set', prop: index }, index)
-		})
-	}
-	const cleanupLength = effect(function computedMapLengthEffect({ ascend }) {
-		const length = inputs.length
-		const resultLength = untracked(() => result.length)
-		resize?.(length, resultLength)
-		touched1(resultReactive, { type: 'set', prop: 'length' }, 'length')
-		if (length < resultLength) {
-			const toCleanup = cleanups.splice(length)
-			for (const cleanup of toCleanup) cleanup()
-			result.length = length
-		} else if (length > resultLength)
-			// the input effects will be registered as the call's children, so they will remain not cleaned with this effect on length
-			ascend(function computedMapNewElements() {
-				for (let i = resultLength; i < length; i++) cleanups.push(input(i))
-			})
-	})
-	return cleanedBy(resultReactive, () => {
-		for (const cleanup of cleanups) cleanup()
-		cleanups.length = 0
-		cleanupLength()
-	})
-}
-
-export function reduced<T, U, R extends object = any>(
-	inputs: readonly T[],
-	compute: (input: T, factor: R) => readonly U[]
-): readonly U[] {
-	const result: U[] = []
-	const resultReactive = new ReactiveReadOnlyArray(result)
-	const cleanupFactor = effect(function computedReducedFactorEffect() {
-		const factor: R = {} as R
-		result.length = 0
-		for (const input of inputs) result.push(...compute(input, factor))
-		touched(resultReactive, { type: 'invalidate', prop: 'reduced' })
-	})
-	return cleanedBy(resultReactive, cleanupFactor)
-}

package/src/reactive/zone.ts

@@ -1,208 +0,0 @@
-/**
- * Zone-like async context preservation for reactive effects
- *
- * Automatically preserves effect context across async boundaries:
- * - Promise methods: .then(), .catch(), .finally()
- * - Timers: setTimeout(), setInterval()
- * - Animation: requestAnimationFrame() (if available) - runs in untracked context
- * - Microtasks: queueMicrotask() (if available)
- *
- * **IMPORTANT:** This module is opt-in via `reactiveOptions.asyncMode` (truthy = enabled, false = disabled).
- * By default, async zone is ENABLED with 'cancel' mode.
- *
- * When disabled (asyncMode = false), use `tracked()` manually in async callbacks.
- * When enabled (asyncMode = 'cancel' | 'queue' | 'ignore'), async entry points are wrapped ONCE.
- */
-
-import { captureEffectStack, withEffectStack } from './effect-context'
-import { options, type ScopedCallback } from './types'
-
-let zoneHooked = false
-
-// Store original Promise methods at module load time (before any wrapping)
-// This ensures we always have the true originals, even if wrapping happens multiple times
-const originalPromiseThen =
-	Object.getOwnPropertyDescriptor(Promise.prototype, 'then')?.value || Promise.prototype.then
-const originalPromiseCatch =
-	Object.getOwnPropertyDescriptor(Promise.prototype, 'catch')?.value || Promise.prototype.catch
-const originalPromiseFinally =
-	Object.getOwnPropertyDescriptor(Promise.prototype, 'finally')?.value || Promise.prototype.finally
-
-// Store original timer functions at module load time
-const originalSetTimeout = globalThis.setTimeout
-const originalSetInterval = globalThis.setInterval
-const originalRequestAnimationFrame =
-	typeof globalThis.requestAnimationFrame !== 'undefined'
-		? globalThis.requestAnimationFrame
-		: undefined
-const originalQueueMicrotask =
-	typeof globalThis.queueMicrotask !== 'undefined' ? globalThis.queueMicrotask : undefined
-
-// Store batch function to avoid circular dependency
-let batchFn: ((cb: () => any, type: 'immediate') => any) | undefined
-
-/**
- * Check the asyncMode option and hook Promise.prototype once if enabled
- * Called lazily on first effect creation
- * asyncMode being truthy enables async zone, false disables it
- *
- * @param batch - Optional batch function injection from effects.ts to avoid circular dependency
- */
-export function ensureZoneHooked(batch?: (cb: () => any, type: 'immediate') => any) {
-	if (batch) batchFn = batch
-	if (zoneHooked || !options.asyncMode) return
-	hookZone()
-	zoneHooked = true
-}
-
-/**
- * Hook Promise.prototype methods to preserve effect context
- */
-function hookZone() {
-	// biome-ignore lint/suspicious/noThenProperty: Intentional wrapping for zone functionality
-	Promise.prototype.then = function <T, R1, R2>(
-		this: Promise<T>,
-		onFulfilled?: ((value: T) => R1 | PromiseLike<R1>) | null,
-		onRejected?: ((reason: any) => R2 | PromiseLike<R2>) | null
-	): Promise<R1 | R2> {
-		const capturedStack = captureEffectStack()
-		return originalPromiseThen.call(
-			this,
-			wrapCallback(onFulfilled, capturedStack),
-			wrapCallback(onRejected, capturedStack)
-		)
-	}
-
-	Promise.prototype.catch = function <T>(
-		this: Promise<T>,
-		onRejected?: ((reason: any) => T | PromiseLike<T>) | null
-	): Promise<T> {
-		const capturedStack = captureEffectStack()
-		return originalPromiseCatch.call(this, wrapCallback(onRejected, capturedStack))
-	}
-
-	Promise.prototype.finally = function <T>(
-		this: Promise<T>,
-		onFinally?: (() => void) | null
-	): Promise<T> {
-		const capturedStack = captureEffectStack()
-		return originalPromiseFinally.call(this, wrapCallback(onFinally, capturedStack))
-	}
-
-	// Hook setTimeout - preserve original function properties for Node.js compatibility
-	const wrappedSetTimeout = (<TArgs extends any[]>(
-		callback: (...args: TArgs) => void,
-		delay?: number,
-		...args: TArgs
-	): ReturnType<typeof originalSetTimeout> => {
-		const capturedStack = options.zones.setTimeout ? captureEffectStack() : undefined
-		return originalSetTimeout.apply(globalThis, [
-			wrapCallback(callback, capturedStack) as (...args: any[]) => void,
-			delay,
-			...args,
-		] as any)
-	}) as typeof originalSetTimeout
-	Object.assign(wrappedSetTimeout, originalSetTimeout)
-	globalThis.setTimeout = wrappedSetTimeout
-
-	// Hook setInterval - preserve original function properties for Node.js compatibility
-	const wrappedSetInterval = (<TArgs extends any[]>(
-		callback: (...args: TArgs) => void,
-		delay?: number,
-		...args: TArgs
-	): ReturnType<typeof originalSetInterval> => {
-		const capturedStack = options.zones.setInterval ? captureEffectStack() : undefined
-		return originalSetInterval.apply(globalThis, [
-			wrapCallback(callback, capturedStack) as (...args: any[]) => void,
-			delay,
-			...args,
-		] as any)
-	}) as typeof originalSetInterval
-	Object.assign(wrappedSetInterval, originalSetInterval)
-	globalThis.setInterval = wrappedSetInterval
-
-	// Hook requestAnimationFrame if available
-	if (originalRequestAnimationFrame) {
-		globalThis.requestAnimationFrame = ((
-			callback: FrameRequestCallback
-		): ReturnType<typeof originalRequestAnimationFrame> => {
-			const capturedStack = options.zones.requestAnimationFrame ? captureEffectStack() : undefined
-			return originalRequestAnimationFrame.call(
-				globalThis,
-				wrapCallback(callback as any, capturedStack) as FrameRequestCallback
-			)
-		}) as typeof originalRequestAnimationFrame
-	}
-
-	// Hook queueMicrotask if available
-	if (originalQueueMicrotask) {
-		globalThis.queueMicrotask = ((callback: () => void): void => {
-			const capturedStack = options.zones.queueMicrotask ? captureEffectStack() : undefined
-			originalQueueMicrotask.call(globalThis, wrapCallback(callback, capturedStack) as () => void)
-		}) as typeof originalQueueMicrotask
-	}
-}
-
-/**
- * Wraps a callback to restore effect context and ensure batching
- */
-function wrapCallback<T extends (...args: any[]) => any>(
-	callback: T | null | undefined,
-	capturedStack: (ScopedCallback | undefined)[] | undefined
-): T | undefined {
-	if (!callback) return undefined
-
-	// If no stack to restore and no batch function, direct call (optimization)
-	if ((!capturedStack || !capturedStack.length) && !batchFn) {
-		return callback
-	}
-
-	return ((...args: any[]) => {
-		const execute = () => {
-			if (capturedStack?.length) {
-				return withEffectStack(capturedStack, () => callback(...args))
-			}
-			return callback(...args)
-		}
-
-		if (batchFn) {
-			return batchFn(execute, 'immediate')
-		}
-		return execute()
-	}) as T
-}
-
-/**
- * Manually enable/disable the zone (for testing)
- */
-export function setZoneEnabled(enabled: boolean) {
-	if (enabled && !zoneHooked) {
-		hookZone()
-		zoneHooked = true
-	} else if (!enabled && zoneHooked) {
-		// Restore original Promise methods
-		// biome-ignore lint/suspicious/noThenProperty: Restoring original methods
-		Promise.prototype.then = originalPromiseThen
-		Promise.prototype.catch = originalPromiseCatch
-		Promise.prototype.finally = originalPromiseFinally
-
-		// Restore original timer functions
-		globalThis.setTimeout = originalSetTimeout
-		globalThis.setInterval = originalSetInterval
-		if (originalRequestAnimationFrame) {
-			globalThis.requestAnimationFrame = originalRequestAnimationFrame
-		}
-		if (originalQueueMicrotask) {
-			globalThis.queueMicrotask = originalQueueMicrotask
-		}
-
-		zoneHooked = false
-	}
-}
-
-/**
- * Check if zone is currently hooked
- */
-export function isZoneEnabled(): boolean {
-	return zoneHooked
-}