mutts 1.0.0 → 1.0.2

package/src/decorator.ts

@@ -1,205 +0,0 @@
-// biome-ignore-all lint/suspicious/noConfusingVoidType: We *love* voids
-// Standardized decorator system that works with both Legacy and Modern decorators
-
-import { isConstructor } from './utils'
-
-export class DecoratorError extends Error {
-	constructor(message: string) {
-		super(message)
-		this.name = 'DecoratorException'
-	}
-}
-//#region all decorator types
-
-// Used for get/set and method decorators
-export type LegacyPropertyDecorator<T> = (
-	target: T,
-	name: string | symbol,
-	descriptor: PropertyDescriptor
-) => any
-
-export type LegacyClassDecorator<T> = (target: T) => any
-
-export type ModernMethodDecorator<T> = (target: T, context: ClassMethodDecoratorContext) => any
-
-export type ModernGetterDecorator<T> = (target: T, context: ClassGetterDecoratorContext) => any
-
-export type ModernSetterDecorator<T> = (target: T, context: ClassSetterDecoratorContext) => any
-
-export type ModernAccessorDecorator<T> = (target: T, context: ClassAccessorDecoratorContext) => any
-
-export type ModernClassDecorator<T> = (target: T, context: ClassDecoratorContext) => any
-
-//#endregion
-
-type DDMethod<T> = (
-	original: (this: T, ...args: any[]) => any,
-	name: PropertyKey
-) => ((this: T, ...args: any[]) => any) | void
-
-type DDGetter<T> = (original: (this: T) => any, name: PropertyKey) => ((this: T) => any) | void
-
-type DDSetter<T> = (
-	original: (this: T, value: any) => void,
-	name: PropertyKey
-) => ((this: T, value: any) => void) | void
-
-type DDClass<T> = <Ctor extends new (...args: any[]) => T = new (...args: any[]) => T>(
-	target: Ctor
-) => Ctor | void
-export interface DecoratorDescription<T> {
-	method?: DDMethod<T>
-	class?: DDClass<T>
-	getter?: DDGetter<T>
-	setter?: DDSetter<T>
-	default?: (...args: any[]) => any
-}
-
-export type Decorator<T, Description extends DecoratorDescription<T>> = (Description extends {
-	method: DDMethod<T>
-}
-	? LegacyPropertyDecorator<T> & ModernMethodDecorator<T>
-	: unknown) &
-	(Description extends { class: DDClass<new (...args: any[]) => T> }
-		? LegacyClassDecorator<new (...args: any[]) => T> &
-				ModernClassDecorator<new (...args: any[]) => T>
-		: unknown) &
-	(Description extends { getter: DDGetter<T> }
-		? LegacyPropertyDecorator<T> & ModernGetterDecorator<T> & ModernAccessorDecorator<T>
-		: unknown) &
-	(Description extends { setter: DDSetter<T> }
-		? LegacyPropertyDecorator<T> & ModernSetterDecorator<T> & ModernAccessorDecorator<T>
-		: unknown) &
-	(Description extends { default: infer Signature } ? Signature : unknown)
-
-export type DecoratorFactory<T> = <Description extends DecoratorDescription<T>>(
-	description: Description
-) => (Description extends { method: DDMethod<T> }
-	? LegacyPropertyDecorator<T> & ModernMethodDecorator<T>
-	: unknown) &
-	(Description extends { class: DDClass<new (...args: any[]) => T> }
-		? LegacyClassDecorator<new (...args: any[]) => T> &
-				ModernClassDecorator<new (...args: any[]) => T>
-		: unknown) &
-	(Description extends { getter: DDGetter<T> }
-		? LegacyPropertyDecorator<T> & ModernGetterDecorator<T> & ModernAccessorDecorator<T>
-		: unknown) &
-	(Description extends { setter: DDSetter<T> }
-		? LegacyPropertyDecorator<T> & ModernSetterDecorator<T> & ModernAccessorDecorator<T>
-		: unknown) &
-	(Description extends { default: infer Signature } ? Signature : unknown)
-
-export function legacyDecorator<T = any>(description: DecoratorDescription<T>): any {
-	return function (
-		target: any,
-		propertyKey?: PropertyKey,
-		descriptor?: PropertyDescriptor,
-		...args: any[]
-	) {
-		if (propertyKey === undefined) {
-			if (isConstructor(target)) {
-				if (!('class' in description)) throw new Error('Decorator cannot be applied to a class')
-				return description.class?.(target)
-			}
-		} else if (typeof target === 'object' && ['string', 'symbol'].includes(typeof propertyKey)) {
-			if (!descriptor) throw new Error('Decorator cannot be applied to a field')
-			else if (typeof descriptor === 'object' && 'configurable' in descriptor) {
-				if ('get' in descriptor || 'set' in descriptor) {
-					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, propertyKey)
-						if (newGetter) descriptor.get = newGetter
-					}
-					if ('setter' in description) {
-						const newSetter = description.setter?.(descriptor.set, 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)
-					if (newMethod) descriptor.value = newMethod
-					return descriptor
-				}
-			}
-		}
-		if (!('default' in description))
-			throw new Error('Decorator do not have a default implementation')
-		return description.default.call(this, target, propertyKey, descriptor, ...args)
-	}
-}
-
-export function modernDecorator<T = any>(description: DecoratorDescription<T>): any {
-	return function (target: any, context?: DecoratorContext, ...args: any[]) {
-		if (!context?.kind || typeof context.kind !== 'string') {
-			if (!('default' in description))
-				throw new Error('Decorator do not have a default implementation')
-			return description.default.call(this, target, context, ...args)
-		}
-		switch (context.kind) {
-			case 'class':
-				if (!('class' in description)) throw new Error('Decorator cannot be applied to a class')
-				return description.class?.(target)
-			case 'field':
-				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)
-			case 'setter':
-				if (!('setter' in description)) throw new Error('Decorator cannot be applied to a setter')
-				return description.setter?.(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)
-			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)
-					if (newGetter) rv.get = newGetter
-				}
-				if ('setter' in description) {
-					const newSetter = description.setter?.(target.set, context.name)
-					if (newSetter) rv.set = newSetter
-				}
-				return rv
-			}
-			//return description.accessor?.(target, context.name, target)
-		}
-	}
-}
-
-/**
- * Detects if the decorator is being called in modern (Modern) or legacy (Legacy) mode
- * based on the arguments passed to the decorator function
- */
-function detectDecoratorMode(
-	_target: any,
-	contextOrKey?: any,
-	_descriptor?: any
-): 'modern' | 'legacy' {
-	// Modern decorators have a context object as the second parameter
-	// Legacy decorators have a string/symbol key as the second parameter
-	if (
-		typeof contextOrKey === 'object' &&
-		contextOrKey !== null &&
-		typeof contextOrKey.kind === 'string'
-	) {
-		return 'modern'
-	}
-	return 'legacy'
-}
-
-export const decorator: DecoratorFactory<any> = (description: DecoratorDescription<any>) => {
-	return ((target: any, contextOrKey?: any, ...args: any[]) => {
-		const mode = detectDecoratorMode(target, contextOrKey, args[0])
-		return mode === 'modern'
-			? modernDecorator(description)(target, contextOrKey, ...args)
-			: legacyDecorator(description)(target, contextOrKey, ...args)
-	}) as any
-}
-
-export type GenericClassDecorator<T> = LegacyClassDecorator<new (...args: any[]) => T> &
-	ModernClassDecorator<new (...args: any[]) => T>

package/src/destroyable.test.ts

@@ -1,155 +0,0 @@
-import {
-	allocated,
-	allocatedValues,
-	Destroyable,
-	DestructionError,
-	destructor,
-} from './destroyable'
-
-function tick(ms: number = 0) {
-	return new Promise((resolve) => setTimeout(resolve, ms))
-}
-
-const gc = global.gc
-
-async function collectGarbages() {
-	await tick()
-	gc!()
-	await tick()
-}
-
-describe('Destroyable', () => {
-	describe('with base class and destructor object', () => {
-		it('should create destroyable class with custom destructor', async () => {
-			let receivedAllocated: any = null
-
-			class MyClass extends Destroyable({
-				destructor(allocated) {
-					receivedAllocated = allocated
-				},
-			}) {
-				constructor(public name: string) {
-					super()
-					this[allocatedValues].name = name
-				}
-			}
-
-			;(() => {
-				const obj = new MyClass('test')
-				expect(obj.name).toBe('test')
-			})()
-			await collectGarbages()
-			expect(receivedAllocated.name).toBe('test')
-		})
-
-		it('should pass constructor arguments to base class', () => {
-			class BaseClass {
-				constructor(public value: number) {}
-			}
-
-			const DestroyableBaseClass = Destroyable(BaseClass, {
-				destructor: () => {},
-			})
-
-			const obj = new DestroyableBaseClass(42)
-			expect(obj.value).toBe(42)
-		})
-
-		it('should throw error when accessing destroyed object', () => {
-			class MyClass {
-				constructor(public name: string) {}
-			}
-
-			const DestroyableMyClass = Destroyable(MyClass, {
-				destructor: () => {},
-			})
-
-			const obj = new DestroyableMyClass('test')
-			DestroyableMyClass.destroy(obj)
-
-			expect(() => obj.name).toThrow(DestructionError)
-			expect(() => {
-				obj.name = 'value'
-			}).toThrow(DestructionError)
-		})
-	})
-
-	describe('with destructor object only', () => {
-		it('should create destroyable class from scratch', () => {
-			let destructorCalled = false
-
-			const DestroyableClass = Destroyable({
-				destructor: () => {
-					destructorCalled = true
-				},
-			})
-
-			const obj = new DestroyableClass()
-			expect(DestroyableClass.isDestroyable(obj)).toBe(true)
-			expect(destructorCalled).toBe(false)
-
-			const result = DestroyableClass.destroy(obj)
-			expect(result).toBe(true)
-			expect(destructorCalled).toBe(true)
-		})
-	})
-
-	describe('with base class only', () => {
-		it('should create destroyable class with default destructor', () => {
-			class MyClass {
-				constructor(public name: string) {}
-			}
-
-			const DestroyableMyClass = Destroyable(MyClass)
-
-			expect(() => new DestroyableMyClass('test')).toThrow(DestructionError)
-		})
-	})
-
-	describe('class with [destructor] method', () => {
-		it('should call [destructor] method with allocated values', async () => {
-			let receivedAllocated: any = null
-
-			class MyClass extends Destroyable() {
-				constructor(public name: string) {
-					super()
-					this[allocatedValues].name = name
-				}
-				[destructor](allocated: any) {
-					receivedAllocated = allocated
-				}
-			}
-
-			;(() => {
-				const obj = new MyClass('test')
-				expect(obj.name).toBe('test')
-			})()
-			await collectGarbages()
-			expect(receivedAllocated.name).toBe('test')
-		})
-	})
-	describe('decorators usage', () => {
-		it('should collect allocated from decorators', async () => {
-			let receivedAllocated: any = null
-
-			class MyClass extends Destroyable() {
-				@allocated
-				accessor name: string
-				constructor(name: string) {
-					super()
-					this.name = name
-				}
-				[destructor](allocated: any) {
-					receivedAllocated = allocated
-				}
-			}
-
-			;(() => {
-				const obj = new MyClass('test')
-				expect(obj.name).toBe('test')
-			})()
-			await collectGarbages()
-			expect(receivedAllocated.name).toBe('test')
-		})
-	})
-})

package/src/destroyable.ts

@@ -1,158 +0,0 @@
-import { decorator } from './decorator'
-
-// Integrated with `using` statement via Symbol.dispose
-const fr = new FinalizationRegistry<() => void>((f) => f())
-export const destructor = Symbol('destructor')
-export const allocatedValues = Symbol('allocated')
-export class DestructionError extends Error {
-	static throw<_T = void>(msg: string) {
-		return () => {
-			throw new DestructionError(msg)
-		}
-	}
-	constructor(msg: string) {
-		super(`Object is destroyed. ${msg}`)
-		this.name = 'DestroyedAccessError'
-	}
-}
-const destroyedHandler = {
-	[Symbol.toStringTag]: 'MutTs Destroyable',
-	get: DestructionError.throw('Cannot access destroyed object'),
-	set: DestructionError.throw('Cannot access destroyed object'),
-} as const
-
-abstract class AbstractDestroyable<Allocated> {
-	abstract [destructor](allocated: Allocated): void
-	[Symbol.dispose](): void {
-		this[destructor](this as unknown as Allocated)
-	}
-}
-
-interface Destructor<Allocated> {
-	destructor(allocated: Allocated): void
-}
-
-export function Destroyable<
-	T extends new (
-		...args: any[]
-	) => any,
-	Allocated extends Partial<typeof this>,
->(
-	base: T,
-	destructorObj: Destructor<Allocated>
-): (new (
-	...args: ConstructorParameters<T>
-) => InstanceType<T> & { [allocatedValues]: Allocated }) & {
-	destroy(obj: InstanceType<T>): boolean
-	isDestroyable(obj: InstanceType<T>): boolean
-}
-
-export function Destroyable<Allocated extends Record<PropertyKey, any> = Record<PropertyKey, any>>(
-	destructorObj: Destructor<Allocated>
-): (new () => { [allocatedValues]: Allocated }) & {
-	destroy(obj: any): boolean
-	isDestroyable(obj: any): boolean
-}
-
-export function Destroyable<
-	T extends new (
-		...args: any[]
-	) => any,
-	Allocated extends Record<PropertyKey, any> = Record<PropertyKey, any>,
->(
-	base: T
-): (new (
-	...args: ConstructorParameters<T>
-) => AbstractDestroyable<Allocated> & InstanceType<T> & { [allocatedValues]: Allocated }) & {
-	destroy(obj: InstanceType<T>): boolean
-	isDestroyable(obj: InstanceType<T>): boolean
-}
-
-export function Destroyable<
-	Allocated extends Record<PropertyKey, any> = Record<PropertyKey, any>,
->(): abstract new () => (AbstractDestroyable<Allocated> & {
-	[allocatedValues]: Allocated
-}) & {
-	destroy(obj: any): boolean
-	isDestroyable(obj: any): boolean
-}
-
-export function Destroyable<
-	T extends new (
-		...args: any[]
-	) => any,
-	Allocated extends Record<PropertyKey, any> = Record<PropertyKey, any>,
->(base?: T | Destructor<Allocated>, destructorObj?: Destructor<Allocated>) {
-	if (base && typeof base !== 'function') {
-		destructorObj = base as Destructor<Allocated>
-		base = undefined
-	}
-	if (!base) {
-		base = class {} as T
-	}
-
-	return class Destroyable extends (base as T) {
-		static readonly destructors = new WeakMap<any, () => void>()
-		static destroy(obj: Destroyable) {
-			const destructor = Destroyable.destructors.get(obj)
-			if (!destructor) return false
-			fr.unregister(obj)
-			Destroyable.destructors.delete(obj)
-			Object.setPrototypeOf(obj, new Proxy({}, destroyedHandler))
-			// Clear all own properties
-			for (const key of Object.getOwnPropertyNames(obj)) {
-				delete (obj as any)[key]
-			}
-			destructor()
-			return true
-		}
-		static isDestroyable(obj: Destroyable) {
-			return Destroyable.destructors.has(obj)
-		}
-
-		declare [forwardProperties]: PropertyKey[]
-		readonly [allocatedValues]: Allocated
-		constructor(...args: any[]) {
-			super(...args)
-			const allocated = {} as Allocated
-			this[allocatedValues] = allocated
-			// @ts-expect-error `this` is an AbstractDestroyable
-			const myDestructor = destructorObj?.destructor ?? this[destructor]
-			if (!myDestructor) {
-				throw new DestructionError('Destructor is not defined')
-			}
-			function destruction() {
-				myDestructor(allocated)
-			}
-			Destroyable.destructors.set(this, destruction)
-			fr.register(this, destruction, this)
-		}
-	}
-}
-
-const forwardProperties = Symbol('forwardProperties')
-export const allocated = decorator({
-	setter(original, propertyKey) {
-		return function (value) {
-			this[allocatedValues][propertyKey] = value
-			return original.call(this, value)
-		}
-	},
-})
-
-export function callOnGC(cb: () => void) {
-	let called = false
-	const forward = () => {
-		if (called) return
-		called = true
-		cb()
-	}
-	fr.register(forward, cb, cb)
-	return forward
-}
-
-// Context Manager Protocol for `with` statement integration
-export interface ContextManager<T = any> {
-	[Symbol.dispose](): void
-	value?: T
-}