mutts 1.0.5 → 1.0.7

package/src/async/browser.ts

@@ -0,0 +1,87 @@
+import { Hook, Restorer, asyncHooks } from '.'
+
+const hooks = new Set<Hook>()
+
+asyncHooks.addHook = function (hook: Hook) {
+	hooks.add(hook)
+	return () => {
+		hooks.delete(hook)
+	}
+}
+
+export * from '../index'
+
+function wrap<Args extends any[], R>(fn: ((...args: Args) => R) | null | undefined) {
+	if (typeof fn !== 'function') return fn
+	const restorers = new Set<Restorer>()
+	for (const hook of hooks) restorers.add(hook())
+
+	return function (this: any, ...args: Args) {
+		const undoers = new Set<() => void>()
+		for (const restore of restorers) undoers.add(restore())
+		try {
+			return fn.apply(this, args)
+		} finally {
+			for (const undo of undoers) undo()
+		}
+	}
+}
+
+const originals = {
+	then: Promise.prototype.then,
+	catch: Promise.prototype.catch,
+	finally: Promise.prototype.finally,
+	setTimeout: globalThis.setTimeout,
+	setInterval: globalThis.setInterval,
+	setImmediate: globalThis.setImmediate,
+	requestAnimationFrame: globalThis.requestAnimationFrame,
+	queueMicrotask: globalThis.queueMicrotask,
+}
+
+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> {
+	return originals.then.call(this, wrap(onFulfilled), wrap(onRejected))
+}
+
+Promise.prototype.catch = function <T>(
+	this: Promise<T>,
+	onRejected?: ((reason: any) => T | PromiseLike<T>) | null
+): Promise<T> {
+	return originals.catch.call(this, wrap(onRejected))
+}
+
+Promise.prototype.finally = function <T>(
+	this: Promise<T>,
+	onFinally?: (() => void) | null
+): Promise<T> {
+	return originals.finally.call(this, wrap(onFinally))
+}
+
+globalThis.setTimeout = ((callback: Function, ...args: any[]) => {
+	return originals.setTimeout.call(globalThis, wrap(callback as any), ...args)
+}) as any
+
+globalThis.setInterval = ((callback: Function, ...args: any[]) => {
+	return originals.setInterval.call(globalThis, wrap(callback as any), ...args)
+}) as any
+
+if (originals.setImmediate) {
+	globalThis.setImmediate = ((callback: Function, ...args: any[]) => {
+		return originals.setImmediate.call(globalThis, wrap(callback as any), ...args)
+	}) as any
+}
+
+if (originals.requestAnimationFrame) {
+	globalThis.requestAnimationFrame = (callback: FrameRequestCallback) => {
+		return originals.requestAnimationFrame.call(globalThis, wrap(callback))
+	}
+}
+
+if (originals.queueMicrotask) {
+	globalThis.queueMicrotask = (callback: VoidFunction): void => {
+		originals.queueMicrotask.call(globalThis, wrap(callback))
+	}
+}

package/src/async/index.ts

@@ -0,0 +1,8 @@
+export type Restorer = () => () => void
+export type Hook = () => Restorer
+
+export const asyncHooks = {
+	addHook(_hook: Hook): () => void {
+		throw 'One must import the library from the server or the client side'
+	}
+}

package/src/async/node.ts

@@ -0,0 +1,46 @@
+import { createHook } from 'node:async_hooks'
+import { Hook, Restorer, asyncHooks } from '.'
+
+const hooks = new Set<Hook>()
+const restorersPerAsyncId = new Map<number, Set<Restorer>>()
+const undoersPerAsyncId = new Map<number, Set<() => void>>()
+
+createHook({
+	init(asyncId) {
+		const restorers = new Set<Restorer>()
+		for (const hook of hooks) {
+			restorers.add(hook())
+		}
+		restorersPerAsyncId.set(asyncId, restorers)
+	},
+	before(asyncId) {
+		const restorers = restorersPerAsyncId.get(asyncId)
+		if (restorers) {
+			const undoers = new Set<() => void>()
+			for (const restore of restorers) {
+				undoers.add(restore())
+			}
+			undoersPerAsyncId.set(asyncId, undoers)
+		}
+	},
+	after(asyncId) {
+		const undoers = undoersPerAsyncId.get(asyncId)
+		if (undoers) {
+			for (const undo of undoers) undo()
+			undoersPerAsyncId.delete(asyncId)
+		}
+	},
+	destroy(asyncId) {
+		restorersPerAsyncId.delete(asyncId)
+		undoersPerAsyncId.delete(asyncId)
+	}
+}).enable()
+
+asyncHooks.addHook = function (hook: Hook) {
+	hooks.add(hook)
+	return () => {
+		hooks.delete(hook)
+	}
+}
+
+export * from '../index'

package/src/decorator.ts

@@ -58,13 +58,19 @@ export type ModernClassDecorator<T> = (target: T, context: ClassDecoratorContext
 
 type DDMethod<T> = (
 	original: (this: T, ...args: any[]) => any,
+	target: any,
 	name: PropertyKey
 ) => ((this: T, ...args: any[]) => any) | void
 
-type DDGetter<T> = (original: (this: T) => any, name: PropertyKey) => ((this: T) => any) | void
+type DDGetter<T> = (
+	original: (this: T) => any,
+	target: any,
+	name: PropertyKey
+) => ((this: T) => any) | void
 
 type DDSetter<T> = (
 	original: (this: T, value: any) => void,
+	target: any,
 	name: PropertyKey
 ) => ((this: T, value: any) => void) | void
 
@@ -153,17 +159,17 @@ export function legacyDecorator<T = any>(description: DecoratorDescription<T>):
 					if (!('getter' in description || 'setter' in description))
 						throw new Error('Decorator cannot be applied to a getter or setter')
 					if ('getter' in description) {
-						const newGetter = description.getter!(descriptor.get as any, propertyKey)
+						const newGetter = description.getter!(descriptor.get as any, target, propertyKey)
 						if (newGetter) descriptor.get = newGetter
 					}
 					if ('setter' in description) {
-						const newSetter = description.setter!(descriptor.set as any, propertyKey)
+						const newSetter = description.setter!(descriptor.set as any, target, propertyKey)
 						if (newSetter) descriptor.set = newSetter
 					}
 					return descriptor
 				} else if (typeof descriptor.value === 'function') {
 					if (!('method' in description)) throw new Error('Decorator cannot be applied to a method')
-					const newMethod = description.method!(descriptor.value, propertyKey)
+					const newMethod = description.method!(descriptor.value, target, propertyKey)
 					if (newMethod) descriptor.value = newMethod
 					return descriptor
 				}
@@ -196,23 +202,23 @@ export function modernDecorator<T = any>(description: DecoratorDescription<T>):
 				throw new Error('Decorator cannot be applied to a field')
 			case 'getter':
 				if (!('getter' in description)) throw new Error('Decorator cannot be applied to a getter')
-				return description.getter!(target, context.name)
+				return description.getter!(target, target, context.name)
 			case 'setter':
 				if (!('setter' in description)) throw new Error('Decorator cannot be applied to a setter')
-				return description.setter!(target, context.name)
+				return description.setter!(target, target, context.name)
 			case 'method':
 				if (!('method' in description)) throw new Error('Decorator cannot be applied to a method')
-				return description.method!(target, context.name)
+				return description.method!(target, target, context.name)
 			case 'accessor': {
 				if (!('getter' in description || 'setter' in description))
 					throw new Error('Decorator cannot be applied to a getter or setter')
 				const rv: Partial<ClassAccessorDecoratorResult<any, any>> = {}
 				if ('getter' in description) {
-					const newGetter = description.getter!(target.get, context.name)
+					const newGetter = description.getter!(target.get, target, context.name)
 					if (newGetter) rv.get = newGetter
 				}
 				if ('setter' in description) {
-					const newSetter = description.setter!(target.set, context.name)
+					const newSetter = description.setter!(target.set, target, context.name)
 					if (newSetter) rv.set = newSetter
 				}
 				return rv

package/src/destroyable.ts

@@ -117,7 +117,7 @@ export function Destroyable<
 		base = undefined
 	}
 	if (!base) {
-		base = class { } as T
+		base = class {} as T
 	}
 
 	return class Destroyable extends (base as T) {
@@ -125,7 +125,7 @@ export function Destroyable<
 		static destroy(obj: Destroyable) {
 			const destructor = Destroyable.destructors.get(obj)
 			if (!destructor) return false
-			fr.unregister(obj)
+			fr.unregister(obj[allocatedValues])
 			Destroyable.destructors.delete(obj)
 			Object.setPrototypeOf(obj, new Proxy({}, destroyedHandler))
 			// Clear all own properties
@@ -154,7 +154,7 @@ export function Destroyable<
 				myDestructor(allocated)
 			}
 			Destroyable.destructors.set(this, destruction)
-			fr.register(this, destruction, this)
+			fr.register(this, destruction, allocated)
 		}
 	}
 }
@@ -165,7 +165,7 @@ const forwardProperties = Symbol('forwardProperties')
  * Use with accessor properties or explicit get/set pairs
  */
 export const allocated = decorator({
-	setter(original, propertyKey) {
+	setter(original, _target, propertyKey) {
 		return function (value) {
 			this[allocatedValues][propertyKey] = value
 			return original.call(this, value)

package/src/index.ts

@@ -4,6 +4,60 @@ export * from './eventful'
 export * from './indexable'
 export * from './iterableWeak'
 export * from './mixins'
+export * from './promiseChain'
 export * from './reactive'
 export * from './std-decorators'
 export * from './utils'
+export * from './zone'
+
+import pkg from '../package.json'
+
+const { version } = pkg
+
+// Singleton verification
+const GLOBAL_MUTTS_KEY = '__MUTTS_INSTANCE__'
+const globalScope = (
+	typeof globalThis !== 'undefined'
+		? globalThis
+		: typeof window !== 'undefined'
+			? window
+			: typeof global !== 'undefined'
+				? global
+				: false
+) as any
+if (globalScope) {
+	// Detect the source of this instance safely across different environments
+	let source = 'mutts/index'
+	const viteEval = eval
+	try {
+		// @ts-ignore
+		if (typeof __filename !== 'undefined') source = __filename
+		else {
+			// Using eval to avoid SyntaxError in CJS environments where import.meta is not allowed
+			const meta = viteEval('import.meta')
+			if (meta && meta.url) source = meta.url
+		}
+	} catch (e) {
+		// Fallback for environments where neither is available or accessible
+	}
+
+	const currentSourceInfo = {
+		version,
+		source,
+		timestamp: Date.now(),
+	}
+
+	if (globalScope[GLOBAL_MUTTS_KEY]) {
+		const existing = globalScope[GLOBAL_MUTTS_KEY]
+		throw new Error(
+			`[Mutts] Multiple instances detected!\n` +
+				`Existing instance: ${JSON.stringify(existing, null, 2)}\n` +
+				`New instance: ${JSON.stringify(currentSourceInfo, null, 2)}\n` +
+				`This usually happens when 'mutts' is both installed as a dependency and bundled, ` +
+				`or when different versions are loaded. ` +
+				`Please check your build configuration (aliases, externals) to ensure a single source of truth.`
+		)
+	}
+
+	globalScope[GLOBAL_MUTTS_KEY] = currentSourceInfo
+}

package/src/indexable.ts

@@ -140,6 +140,48 @@ export function Indexable<Items, Base extends abstract new (...args: any[]) => a
 				})
 				return true
 			},
+			has(target, prop) {
+				if (prop in target) return true
+				if (typeof prop === 'string') {
+					if (prop === 'length' && accessor.getLength) return true
+					const numProp = Number(prop)
+					if (!Number.isNaN(numProp)) return true
+				}
+				return false
+			},
+			ownKeys(target) {
+				const keys = Reflect.ownKeys(target)
+				if (accessor.getLength) {
+					keys.push('length')
+					const len = accessor.getLength.call(this as any)
+					for (let i = 0; i < len; i++) keys.push(String(i))
+				}
+				return keys
+			},
+			getOwnPropertyDescriptor(target, prop) {
+				if (prop in target) return Object.getOwnPropertyDescriptor(target, prop)
+				if (typeof prop === 'string') {
+					if (prop === 'length' && accessor.getLength) {
+						return {
+							enumerable: false,
+							configurable: true,
+							get: () => accessor.getLength!.call(this as any),
+						}
+					}
+					const numProp = Number(prop)
+					if (!Number.isNaN(numProp)) {
+						return {
+							enumerable: true,
+							configurable: true,
+							get: () => accessor.get!.call(this as any, numProp),
+							set: accessor.set
+								? (v: any) => accessor.set!.call(this as any, numProp, v)
+								: undefined,
+						}
+					}
+				}
+				return undefined
+			},
 		})
 	)
 	return Indexable

package/src/mixins.ts

@@ -1,4 +1,4 @@
-import { isConstructor, ReflectGet } from './utils'
+import { FoolProof, isConstructor } from './utils'
 
 /**
  * A mixin function that takes a base class and returns a new class with mixed-in functionality
@@ -85,7 +85,7 @@ export function mixin<MixinFn extends (base: any) => new (...args: any[]) => any
 				const originalPrototype = baseClass.prototype
 				const proxiedPrototype = new Proxy(originalPrototype, {
 					get(target, prop, receiver) {
-						const value = ReflectGet(target, prop, receiver)
+						const value = FoolProof.get(target, prop, receiver)
 
 						// Only wrap methods that are likely to access private fields
 						// Skip symbols and special properties that the reactive system needs