mutts 1.0.8 → 1.0.9

package/src/async/node.ts

@@ -1,17 +1,9 @@
 import { createHook } from 'node:async_hooks'
-import { Hook, Restorer, asyncHooks } from '.'
+import { hooks, type Restorer } from '.'
 
 // 1. Generic async_hooks implementation for Hooks
 // This maintains support for 'asyncHooks.addHook' for generic use cases.
 
-const hooks = new Set<Hook>()
-asyncHooks.addHook = function (hook: Hook) {
-	hooks.add(hook)
-	return () => {
-		hooks.delete(hook)
-	}
-}
-
 const contexts = new Map<number, Restorer[]>()
 const activeUndoers = new Map<number, (() => void)[]>()
 
@@ -47,7 +39,7 @@ function wrap<Args extends any[], R>(fn: ((...args: Args) => R) | null | undefin
 }
 
 const hook = createHook({
-	init(asyncId, type, triggerId, resource) {
+	init(asyncId, _type, _triggerId, _resource) {
 		// Used for native resources like Timers
 		const restorers = captureRestorers()
 		if (restorers.length > 0) contexts.set(asyncId, restorers)
@@ -88,17 +80,13 @@ const originalMethods = {
 	all: OriginalPromise.all,
 }
 
-
-
 // Patch prototype
-OriginalPromise.prototype.then = function(onFulfilled, onRejected) {
+OriginalPromise.prototype.then = function (onFulfilled, onRejected) {
 	return originalMethods.then.call(this, wrap(onFulfilled), wrap(onRejected))
 } as any
-OriginalPromise.prototype.catch = function(onRejected) {
+OriginalPromise.prototype.catch = function (onRejected) {
 	return originalMethods.catch.call(this, wrap(onRejected))
 } as any
-OriginalPromise.prototype.finally = function(onFinally) {
+OriginalPromise.prototype.finally = function (onFinally) {
 	return originalMethods.finally.call(this, wrap(onFinally))
 } as any
-
-

package/src/eventful.ts

@@ -2,76 +2,109 @@
  * Base type for event maps - all event handlers must be functions
  */
 export type EventsBase = Record<string, (...args: any[]) => void>
-/**
- * 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> {
-	readonly #events = new Map<keyof Events, ((...args: any[]) => void)[]>()
-	readonly #hooks = [] as ((...args: any[]) => void)[]
 
-	public hook(
-		cb: <EventType extends keyof Events>(
-			event: EventType,
-			...args: Parameters<Events[EventType]>
-		) => void
-	): () => void {
-		if (!this.#hooks.includes(cb)) this.#hooks.push(cb)
-		return () => {
-			this.#hooks.splice(this.#hooks.indexOf(cb), 1)
-		}
-	}
+const events = Symbol('events')
+const hooks = Symbol('hooks')
 
-	public on(events: Partial<Events>): void
-	public on<EventType extends keyof Events>(event: EventType, cb: Events[EventType]): () => void
-	public on<EventType extends keyof Events>(
-		eventOrEvents: EventType | Partial<Events>,
-		cb?: Events[EventType]
+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 Events)[]) {
+			for (const e of Object.keys(eventOrEvents) as (keyof EventsBase)[]) {
 				this.on(e, eventOrEvents[e]!)
 			}
 		} else if (cb !== undefined) {
-			let callbacks = this.#events.get(eventOrEvents)
-			if (!callbacks) {
-				callbacks = []
-				this.#events.set(eventOrEvents, callbacks)
-			}
-			callbacks.push(cb)
+			const callbacks = this[events].get(eventOrEvents) ?? new Set<EventsBase[EventType]>()
+			if (!callbacks.has(cb)) callbacks.add(cb)
+			this[events].set(eventOrEvents, callbacks)
 		}
-		// @ts-expect-error Generic case leads to generic case
 		return () => this.off(eventOrEvents, cb)
-	}
-	public off(events: Partial<Events>): void
-	public off<EventType extends keyof Events>(event: EventType, cb?: Events[EventType]): void
-	public off<EventType extends keyof Events>(
-		eventOrEvents: EventType | Partial<Events>,
-		cb?: Events[EventType]
+	},
+	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 Events)[]) {
+			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)
+			const callbacks = this[events].get(eventOrEvents)
 			if (callbacks) {
-				this.#events.set(
-					eventOrEvents,
-					callbacks.filter((c) => c !== cb)
-				)
+				callbacks.delete(cb)
+				if (!callbacks.size) this[events].delete(eventOrEvents)
 			}
 		} else {
 			// Remove all listeners for this event
-			this.#events.delete(eventOrEvents)
+			this[events].delete(eventOrEvents)
 		}
-	}
-	public emit<EventType extends keyof Events>(
+	},
+	emit<EventType extends keyof EventsBase>(
 		event: EventType,
-		...args: Parameters<Events[EventType]>
+		...args: Parameters<EventsBase[EventType]>
 	) {
-		const callbacks = this.#events.get(event)
+		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)
+		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

@@ -0,0 +1,106 @@
+/**
+ * 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 || {})
+}

package/src/index.d.ts

@@ -1,12 +1,12 @@
-export * from './decorator';
-export * from './destroyable';
-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';
-export * from './async';
+export * from './decorator'
+export * from './destroyable'
+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'
+export * from './async'

package/src/index.ts

@@ -1,6 +1,8 @@
+export * from './async'
 export * from './decorator'
 export * from './destroyable'
 export * from './eventful'
+export * from './flavored'
 export * from './indexable'
 export * from './iterableWeak'
 export * from './mixins'
@@ -9,7 +11,6 @@ export * from './reactive'
 export * from './std-decorators'
 export * from './utils'
 export * from './zone'
-export * from './async'
 
 import pkg from '../package.json'
 
@@ -31,7 +32,6 @@ if (globalScope) {
 	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

package/src/introspection.ts

@@ -14,7 +14,7 @@ import {
 	type MutationRecord,
 	type ObjectNode,
 	type ReactivityGraph,
-} from './reactive/debug'
+} from '../debug/debug'
 import { options, type ReactiveDebugInfo, ReactiveErrorCode } from './reactive/types'
 
 export {

package/src/reactive/array.ts

@@ -25,29 +25,18 @@ export abstract class Indexer extends Array {
 		dependant(this, i)
 		return reactive(this[i])
 	}
+	// Returns undefined intentionally: signals the proxy handler that notifications
+	// were already dispatched via touched(), preventing double notification
 	set(i: number, value: any) {
 		const added = i >= this.length
 		this[i] = value
 		touched(this, { type: 'set', prop: i }, index(i, { length: added }))
 	}
-	getLength() {
-		dependant(this, 'length')
-		return this.length
-	}
-	setLength(value: number) {
-		const oldLength = this.length
-		try {
-			this.length = value
-		} finally {
-			touched(this, { type: 'set', prop: 'length' }, range(oldLength, value, { length: true }))
-		}
-	}
 }
 const indexLess = { get: FoolProof.get, set: FoolProof.set }
 Object.assign(FoolProof, {
 	get(obj: any, prop: any, receiver: any) {
 		if (obj instanceof Array && typeof prop === 'string') {
-			if (prop === 'length') return Indexer.prototype.getLength.call(obj)
 			const index = parseInt(prop)
 			if (!Number.isNaN(index)) return Indexer.prototype.get.call(obj, index)
 		}
@@ -55,7 +44,6 @@ Object.assign(FoolProof, {
 	},
 	set(obj: any, prop: any, value: any, receiver: any) {
 		if (obj instanceof Array && typeof prop === 'string') {
-			if (prop === 'length') return Indexer.prototype.setLength.call(obj, value)
 			const index = parseInt(prop)
 			if (!Number.isNaN(index)) return Indexer.prototype.set.call(obj, index, value)
 		}
@@ -67,8 +55,18 @@ export abstract class ReactiveArray extends Array {
 	toJSON() {
 		return this
 	}
-	get [Symbol.toStringTag]() {
-		return 'ReactiveArray'
+	get length(): number {
+		dependant(this, 'length')
+		return this.length
+	}
+	set length(value: number) {
+		const oldLength = this.length
+		if (oldLength === value) return
+		try {
+			this.length = value
+		} finally {
+			touched(this, { type: 'set', prop: 'length' }, range(oldLength, value, { length: true }))
+		}
 	}
 	// Safe array access with negative indices
 	at(index: number): any {
@@ -103,17 +101,17 @@ export abstract class ReactiveArray extends Array {
 	}
 
 	// Iterator methods with reactivity tracking
-	entries() {
+	entries(): any {
 		dependant(this)
 		return makeReactiveEntriesIterator(this.entries())
 	}
 
-	keys() {
+	keys(): any {
 		dependant(this, 'length')
 		return this.keys()
 	}
 
-	values() {
+	values(): any {
 		dependant(this)
 		return makeReactiveIterator(this.values())
 	}
@@ -140,7 +138,7 @@ export abstract class ReactiveArray extends Array {
 		const length = this.length
 		let i = fromIndex === undefined ? 0 : fromIndex
 		if (i < 0) i = Math.max(length + i, 0)
-		
+
 		const unwrappedSearch = unwrap(searchElement)
 
 		for (; i < length; i++) {
@@ -171,7 +169,7 @@ export abstract class ReactiveArray extends Array {
 			}
 		}
 
-		// If we scanned the whole relevant part and didn't find it, we depend on length 
+		// If we scanned the whole relevant part and didn't find it, we depend on length
 		// (because adding elements might shift indices or add the element)
 		// Actually for lastIndexOf, if we start from end, length dependency is implicit in the start index calculation?
 		// But if we return -1, it means we didn't find it.
@@ -360,7 +358,7 @@ export abstract class ReactiveArray extends Array {
 		return false
 	}
 	// Side-effectful
-	push(...items: any[]) {
+	push(...items: any[]): number {
 		const oldLength = this.length
 		try {
 			return this.push(...items)
@@ -373,7 +371,7 @@ export abstract class ReactiveArray extends Array {
 		}
 	}
 
-	pop() {
+	pop(): any {
 		if (this.length === 0) return undefined
 		try {
 			return reactive(this.pop())
@@ -382,7 +380,7 @@ export abstract class ReactiveArray extends Array {
 		}
 	}
 
-	shift() {
+	shift(): any {
 		if (this.length === 0) return undefined
 		try {
 			return reactive(this.shift())
@@ -391,7 +389,7 @@ export abstract class ReactiveArray extends Array {
 		}
 	}
 
-	unshift(...items: any[]) {
+	unshift(...items: any[]): number {
 		try {
 			return this.unshift(...items)
 		} finally {
@@ -403,7 +401,7 @@ export abstract class ReactiveArray extends Array {
 		}
 	}
 
-	splice(start: number, deleteCount?: number, ...items: any[]) {
+	splice(start: number, deleteCount?: number, ...items: any[]): any[] {
 		const oldLength = this.length
 
 		// Normalize start index
@@ -435,7 +433,7 @@ export abstract class ReactiveArray extends Array {
 		}
 	}
 
-	reverse() {
+	reverse(): any[] {
 		try {
 			return this.reverse()
 		} finally {
@@ -443,7 +441,7 @@ export abstract class ReactiveArray extends Array {
 		}
 	}
 
-	sort(compareFn?: (a: any, b: any) => number) {
+	sort(compareFn?: (a: any, b: any) => number): this {
 		compareFn = compareFn || ((a, b) => a.toString().localeCompare(b.toString()))
 		try {
 			return this.sort((a, b) => compareFn(reactive(a), reactive(b))) as any
@@ -452,7 +450,7 @@ export abstract class ReactiveArray extends Array {
 		}
 	}
 
-	fill(value: any, start?: number, end?: number) {
+	fill(value: any, start?: number, end?: number): this {
 		const len = this.length
 		let k = start === undefined ? 0 : start
 		if (k < 0) k = Math.max(len + k, 0)
@@ -473,7 +471,7 @@ export abstract class ReactiveArray extends Array {
 		}
 	}
 
-	copyWithin(target: number, start: number, end?: number) {
+	copyWithin(target: number, start: number, end?: number): this {
 		try {
 			if (end === undefined) return this.copyWithin(target, start) as any
 			return this.copyWithin(target, start, end) as any
@@ -495,13 +493,8 @@ export abstract class ReactiveArray extends Array {
 			const count = Math.min(final - from, len - to)
 
 			if (count > 0) {
-				touched(
-					this,
-					{ type: 'bunch', method: 'copyWithin' },
-					range(to, to + count - 1)
-				)
+				touched(this, { type: 'bunch', method: 'copyWithin' }, range(to, to + count - 1))
 			}
-
 		}
 	}
 }