mutts 1.0.9 → 1.0.11

package/src/decorator.ts

@@ -1,272 +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'
-
-/**
- * Error thrown when decorator operations fail
- */
-export class DecoratorError extends Error {
-	constructor(message: string) {
-		super(message)
-		this.name = 'DecoratorException'
-	}
-}
-//#region all decorator types
-
-// Used for get/set and method decorators
-/**
- * Legacy property decorator type for methods, getters, and setters
- */
-export type LegacyPropertyDecorator<T> = (
-	target: T,
-	name: string | symbol,
-	descriptor: PropertyDescriptor
-) => any
-
-/**
- * Legacy class decorator type
- */
-export type LegacyClassDecorator<T> = (target: T) => any
-
-/**
- * Modern method decorator type
- */
-export type ModernMethodDecorator<T> = (target: T, context: ClassMethodDecoratorContext) => any
-
-/**
- * Modern getter decorator type
- */
-export type ModernGetterDecorator<T> = (target: T, context: ClassGetterDecoratorContext) => any
-
-/**
- * Modern setter decorator type
- */
-export type ModernSetterDecorator<T> = (target: T, context: ClassSetterDecoratorContext) => any
-
-/**
- * Modern accessor decorator type
- */
-export type ModernAccessorDecorator<T> = (target: T, context: ClassAccessorDecoratorContext) => any
-
-/**
- * Modern class decorator type
- */
-export type ModernClassDecorator<T> = (target: T, context: ClassDecoratorContext) => any
-
-//#endregion
-
-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,
-	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
-
-type DDClass<T> = <Ctor extends new (...args: any[]) => T = new (...args: any[]) => T>(
-	target: Ctor
-) => Ctor | void
-/**
- * Description object for creating decorators that work with both Legacy and Modern decorator proposals
- */
-export interface DecoratorDescription<T> {
-	/** Handler for method decorators */
-	method?: DDMethod<T>
-	/** Handler for class decorators */
-	class?: DDClass<T>
-	/** Handler for getter decorators */
-	getter?: DDGetter<T>
-	/** Handler for setter decorators */
-	setter?: DDSetter<T>
-	/** Default handler for any decorator type not explicitly defined */
-	default?: (...args: any[]) => any
-}
-
-/**
- * Type for decorators that work with both Legacy and Modern decorator proposals
- * Automatically infers the correct decorator type based on the description
- */
-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)
-
-/**
- * Factory type for creating decorators that work with both Legacy and Modern decorator proposals
- */
-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)
-
-/**
- * Creates a decorator that works with Legacy decorator proposals
- * @param description - The decorator description object
- * @returns A decorator function compatible with Legacy decorators
- */
-export function legacyDecorator<T = any>(description: DecoratorDescription<T>): any {
-	return function (
-		this: any,
-		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 as any, target, propertyKey)
-						if (newGetter) descriptor.get = newGetter
-					}
-					if ('setter' in description) {
-						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, target, 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)
-	}
-}
-
-/**
- * Creates a decorator that works with Modern decorator proposals
- * @param description - The decorator description object
- * @returns A decorator function compatible with Modern decorators
- */
-export function modernDecorator<T = any>(description: DecoratorDescription<T>): any {
-	/*return function (target: any, context?: DecoratorContext, ...args: any[]) {*/
-	return function (this: any, 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, target, context.name)
-			case 'setter':
-				if (!('setter' in description)) throw new Error('Decorator cannot be applied to a setter')
-				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, 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, target, context.name)
-					if (newGetter) rv.get = newGetter
-				}
-				if ('setter' in description) {
-					const newSetter = description.setter!(target.set, target, 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'
-}
-
-/**
- * Main decorator factory that automatically detects and works with both Legacy and Modern decorator proposals
- * @param description - The decorator description object
- * @returns A decorator that works in both Legacy and Modern environments
- */
-export const decorator: DecoratorFactory<any> = (description: DecoratorDescription<any>) => {
-	const modern = modernDecorator(description)
-	const legacy = legacyDecorator(description)
-	return ((target: any, contextOrKey?: any, ...args: any[]) => {
-		const mode = detectDecoratorMode(target, contextOrKey, args[0])
-		return mode === 'modern'
-			? modern(target, contextOrKey, ...args)
-			: legacy(target, contextOrKey, ...args)
-	}) as any
-}
-
-/**
- * Generic class decorator type that works with both Legacy and Modern decorator proposals
- */
-export type GenericClassDecorator<T> = LegacyClassDecorator<abstract new (...args: any[]) => T> &
-	ModernClassDecorator<abstract new (...args: any[]) => T>

package/src/destroyable.ts

@@ -1,199 +0,0 @@
-import { decorator } from './decorator'
-
-// Integrated with `using` statement via Symbol.dispose
-const fr = new FinalizationRegistry<() => void>((f) => f())
-/**
- * Symbol for marking destructor methods
- */
-export const destructor = Symbol('destructor')
-/**
- * Symbol for accessing allocated values in destroyable objects
- */
-export const allocatedValues = Symbol('allocated')
-/**
- * Error thrown when attempting to access a destroyed object
- */
-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
-}
-
-/**
- * Creates a destroyable class with a base class and destructor object
- * @param base - The base class to extend
- * @param destructorObj - Object containing the destructor method
- * @returns A destroyable class with static destroy and isDestroyable methods
- */
-export function Destroyable<
-	T extends new (
-		...args: any[]
-	) => any,
-	Allocated extends Partial<InstanceType<T>>,
->(
-	base: T,
-	destructorObj: Destructor<Allocated>
-): (new (
-	...args: ConstructorParameters<T>
-) => InstanceType<T> & { [allocatedValues]: Allocated }) & {
-	destroy(obj: InstanceType<T>): boolean
-	isDestroyable(obj: InstanceType<T>): boolean
-}
-
-/**
- * Creates a destroyable class with only a destructor object (no base class)
- * @param destructorObj - Object containing the destructor method
- * @returns A destroyable class with static destroy and isDestroyable methods
- */
-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
-}
-
-/**
- * Creates a destroyable class with a base class (requires [destructor] method)
- * @param base - The base class to extend
- * @returns A destroyable class with static destroy and isDestroyable methods
- */
-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
-}
-
-/**
- * Creates an abstract destroyable base class
- * @returns An abstract destroyable class with static destroy and isDestroyable methods
- */
-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[allocatedValues])
-			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)
-		}
-
-		[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, allocated)
-		}
-	}
-}
-
-const forwardProperties = Symbol('forwardProperties')
-/**
- * Decorator that marks properties to be stored in the allocated object and passed to the destructor
- * Use with accessor properties or explicit get/set pairs
- */
-export const allocated = decorator({
-	setter(original, _target, propertyKey) {
-		return function (value) {
-			this[allocatedValues][propertyKey] = value
-			return original.call(this, value)
-		}
-	},
-})
-
-/**
- * Registers a callback to be called when an object is garbage collected
- * @param cb - The callback function to execute on garbage collection
- * @returns The object whose reference can be collected
- */
-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 `using` statement integration
- * Provides automatic resource cleanup when used with the `using` statement
- */
-export interface ContextManager<T = any> {
-	[Symbol.dispose](): void
-	value?: T
-}

package/src/entry-browser.ts

@@ -1,5 +0,0 @@
-// Import environment-specific patches first (SIDE EFFECTS)
-import './async/browser'
-
-// Then export the library
-export * from './index'

package/src/entry-node.ts

@@ -1,5 +0,0 @@
-// Import environment-specific patches first (SIDE EFFECTS)
-import './async/node'
-
-// Then export the library
-export * from './index'

package/src/eventful.ts

@@ -1,110 +0,0 @@
-/**
- * Base type for event maps - all event handlers must be functions
- */
-export type EventsBase = Record<string, (...args: any[]) => void>
-
-const events = Symbol('events')
-const hooks = Symbol('hooks')
-
-const eventBehavior = {
-	on<EventType extends keyof EventsBase>(
-		eventOrEvents: EventType | Partial<EventsBase>,
-		cb?: EventsBase[EventType]
-	): () => void {
-		if (typeof eventOrEvents === 'object') {
-			for (const e of Object.keys(eventOrEvents) as (keyof EventsBase)[]) {
-				this.on(e, eventOrEvents[e]!)
-			}
-		} else if (cb !== undefined) {
-			const callbacks = this[events].get(eventOrEvents) ?? new Set<EventsBase[EventType]>()
-			if (!callbacks.has(cb)) callbacks.add(cb)
-			this[events].set(eventOrEvents, callbacks)
-		}
-		return () => this.off(eventOrEvents, cb)
-	},
-	off<EventType extends keyof EventsBase>(
-		eventOrEvents: EventType | Partial<EventsBase>,
-		cb?: EventsBase[EventType]
-	): void {
-		if (typeof eventOrEvents === 'object') {
-			for (const e of Object.keys(eventOrEvents) as (keyof EventsBase)[]) {
-				this.off(e, eventOrEvents[e])
-			}
-		} else if (cb !== null && cb !== undefined) {
-			const callbacks = this[events].get(eventOrEvents)
-			if (callbacks) {
-				callbacks.delete(cb)
-				if (!callbacks.size) this[events].delete(eventOrEvents)
-			}
-		} else {
-			// Remove all listeners for this event
-			this[events].delete(eventOrEvents)
-		}
-	},
-	emit<EventType extends keyof EventsBase>(
-		event: EventType,
-		...args: Parameters<EventsBase[EventType]>
-	) {
-		const callbacks = this[events].get(event)
-		if (callbacks) for (const cb of callbacks) cb.apply(this, args)
-		for (const cb of this[hooks]) cb.call(this, event, ...args)
-	},
-}
-
-function perEvent(
-	eventful: Eventful<any>,
-	fct: (event: string, ...args: any[]) => void,
-	use?: 'use'
-) {
-	const cache = new Map<string, (...args: any[]) => any>()
-	return new Proxy(fct, {
-		get(target, prop: PropertyKey) {
-			if (typeof prop !== 'string') return target[prop]
-			if (use && !eventful[events].has(prop) && !eventful[hooks].size) return () => {}
-
-			// Return cached function or create and cache
-			let cached = cache.get(prop)
-			if (!cached) {
-				cached = (...args: any[]) => fct.apply(eventful, [prop, ...args])
-				cache.set(prop, cached)
-			}
-			return cached
-		},
-	})
-}
-
-/**
- * A type-safe event system that provides a clean API for event handling
- * @template Events - The event map defining event names and their handler signatures
- */
-export class Eventful<Events extends EventsBase> {
-	private readonly [events] = new Map<keyof Events, Set<(...args: any[]) => void>>()
-	private readonly [hooks] = new Set<(...args: any[]) => void>()
-
-	public hook(
-		cb: <EventType extends keyof Events>(
-			event: EventType,
-			...args: Parameters<Events[EventType]>
-		) => void
-	): () => void {
-		this[hooks].add(cb)
-		return () => {
-			this[hooks].delete(cb)
-		}
-	}
-
-	public on = perEvent(this, eventBehavior.on) as ((events: Partial<Events>) => void) &
-		(<EventType extends keyof Events>(event: EventType, cb: Events[EventType]) => () => void) & {
-			[event in keyof Events]: (cb: Events[event]) => () => void
-		}
-	public off = perEvent(this, eventBehavior.off) as ((events: Partial<Events>) => void) &
-		(<EventType extends keyof Events>(event: EventType, cb?: Events[EventType]) => void) & {
-			[event in keyof Events]: (cb?: Events[event]) => void
-		}
-
-	public emit = perEvent(this, eventBehavior.emit, 'use') as (<EventType extends keyof Events>(
-		event: EventType,
-		...args: Parameters<Events[EventType]>
-	) => void) &
-		Events
-}

package/src/flavored.ts

@@ -1,106 +0,0 @@
-/**
- * Creates a flavored (extensible) version of a function with chainable property modifiers.
- *
- * Each property defined in `flavors` returns a new flavored function that transforms
- * how the original function is called. This enables a fluent API where properties
- * create specialized variants of the base function.
- *
- * @param fn - The base function to flavor
- * @param flavors - Object defining the flavor properties (getters or methods)
- * @returns A proxy of the function with the flavor properties attached
- *
- * @example
- * ```typescript
- * function greet(name: string, options?: { loud?: boolean }) {
- *   const greeting = `Hello, ${name}!`
- *   return options?.loud ? greeting.toUpperCase() : greeting
- * }
- *
- * const flavoredGreet = flavored(greet, {
- *   get loud() {
- *     return createFlavor(this, (name, opts) => [name, { ...opts, loud: true }])
- *   }
- * })
- *
- * flavoredGreet('World') // "Hello, World!"
- * flavoredGreet.loud('World') // "HELLO, WORLD!"
- * ```
- */
-import { named } from './utils'
-
-/**
- * Creates a flavored (extensible) version of a function with chainable property modifiers.
- */
-export function flavored<T extends (...args: any[]) => any, F extends Record<string, any>>(
-	fn: T,
-	flavors: F
-): T & F {
-	// Store flavors for recursive flavoring
-	;(fn as any).flavors = flavors
-
-	return new Proxy(fn, {
-		get(target, prop, receiver) {
-			if (prop in flavors) {
-				return Reflect.get(flavors, prop, receiver)
-			}
-			return (target as any)[prop]
-		},
-	}) as T & F
-}
-
-/**
- * Creates a new flavored function that transforms arguments before calling the base.
- *
- * @param fn - The base flavored function
- * @param transform - Function that receives the original arguments and returns transformed arguments
- * @returns A new flavored function with the transformation applied
- *
- * @example
- * ```typescript
- * const loudGreet = createFlavor(greet, (name, opts) => [name, { ...opts, loud: true }])
- * ```
- */
-export function createFlavor<T extends (...args: any[]) => any>(
-	fn: T,
-	transform: (...args: Parameters<T>) => Parameters<T>,
-	name?: string
-): T {
-	const fct = function flavorWrapper(this: any, ...args: Parameters<T>) {
-		return fn.apply(this, transform(...args))
-	}
-	if (name) named(name, fct)
-
-	return flavored(fct as any as T, (fn as any).flavors || {})
-}
-
-/**
- * Creates a new flavored function that merges options objects.
- * Useful when the last argument is an options object that should be merged.
- *
- * @param fn - The base flavored function
- * @param defaultOptions - Options to merge with the provided options
- * @returns A new flavored function with merged options
- *
- * @example
- * ```typescript
- * const opaqueEffect = flavorOptions(effect, { opaque: true })
- * const namedEffect = flavorOptions(effect, { name: 'myEffect' })
- * ```
- */
-export function flavorOptions<T extends (...args: any[]) => any>(
-	fn: T,
-	defaultOptions: Record<string, any>,
-	name?: string
-): T {
-	const fct = function flavorOptionsWrapper(this: any, ...args: any[]) {
-		const lastArg = args[args.length - 1]
-		const mergedArgs =
-			lastArg !== undefined && typeof lastArg === 'object'
-				? [...args.slice(0, -1), { ...defaultOptions, ...lastArg }]
-				: [...args, defaultOptions]
-		return fn.apply(this, mergedArgs)
-	}
-	if (name) named(name, fct)
-
-	return flavored(fct as any as T, (fn as any).flavors || {})
-}