mutts 1.0.7 → 1.0.8

package/src/async/node.ts

@@ -1,46 +1,104 @@
 import { createHook } from 'node:async_hooks'
 import { Hook, Restorer, asyncHooks } from '.'
 
+// 1. Generic async_hooks implementation for Hooks
+// This maintains support for 'asyncHooks.addHook' for generic use cases.
+
 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())
+asyncHooks.addHook = function (hook: Hook) {
+	hooks.add(hook)
+	return () => {
+		hooks.delete(hook)
+	}
+}
+
+const contexts = new Map<number, Restorer[]>()
+const activeUndoers = new Map<number, (() => void)[]>()
+
+// Helper to capture current hooks state
+function captureRestorers() {
+	if (hooks.size === 0) return []
+	const restorers: Restorer[] = []
+	for (const h of hooks) {
+		const r = h()
+		if (r) restorers.push(r)
+	}
+	return restorers
+}
+
+// Manual Wrap function to handle Promise callbacks
+function wrap<Args extends any[], R>(fn: ((...args: Args) => R) | null | undefined) {
+	if (typeof fn !== 'function') return fn
+	const restorers = captureRestorers()
+	if (restorers.length === 0) return fn
+
+	return function (this: any, ...args: Args) {
+		const undoers: (() => void)[] = []
+		for (const restore of restorers) {
+			const u = restore()
+			if (u) undoers.push(u)
+		}
+		try {
+			return fn.apply(this, args)
+		} finally {
+			for (let i = undoers.length - 1; i >= 0; i--) undoers[i]()
 		}
-		restorersPerAsyncId.set(asyncId, restorers)
+	}
+}
+
+const hook = createHook({
+	init(asyncId, type, triggerId, resource) {
+		// Used for native resources like Timers
+		const restorers = captureRestorers()
+		if (restorers.length > 0) contexts.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)
+		const restorers = contexts.get(asyncId)
+		if (!restorers) return
+		const undoers: (() => void)[] = []
+		for (const restore of restorers) {
+			const u = restore()
+			if (u) undoers.push(u)
 		}
+		if (undoers.length > 0) activeUndoers.set(asyncId, undoers)
 	},
 	after(asyncId) {
-		const undoers = undoersPerAsyncId.get(asyncId)
-		if (undoers) {
-			for (const undo of undoers) undo()
-			undoersPerAsyncId.delete(asyncId)
-		}
+		const undoers = activeUndoers.get(asyncId)
+		if (!undoers) return
+		for (let i = undoers.length - 1; i >= 0; i--) undoers[i]()
+		activeUndoers.delete(asyncId)
 	},
 	destroy(asyncId) {
-		restorersPerAsyncId.delete(asyncId)
-		undoersPerAsyncId.delete(asyncId)
-	}
-}).enable()
+		contexts.delete(asyncId)
+		activeUndoers.delete(asyncId)
+	},
+})
+hook.enable()
 
-asyncHooks.addHook = function (hook: Hook) {
-	hooks.add(hook)
-	return () => {
-		hooks.delete(hook)
-	}
+// 2. Shadow Promise Implementation
+// Ensures V8 await resumptions are visible as .then callbacks, wrapping them to restore context.
+
+const OriginalPromise = globalThis.Promise
+const originalMethods = {
+	then: OriginalPromise.prototype.then,
+	catch: OriginalPromise.prototype.catch,
+	finally: OriginalPromise.prototype.finally,
+	resolve: OriginalPromise.resolve,
+	reject: OriginalPromise.reject,
+	all: OriginalPromise.all,
 }
 
-export * from '../index'
+
+
+// Patch prototype
+OriginalPromise.prototype.then = function(onFulfilled, onRejected) {
+	return originalMethods.then.call(this, wrap(onFulfilled), wrap(onRejected))
+} as any
+OriginalPromise.prototype.catch = function(onRejected) {
+	return originalMethods.catch.call(this, wrap(onRejected))
+} as any
+OriginalPromise.prototype.finally = function(onFinally) {
+	return originalMethods.finally.call(this, wrap(onFinally))
+} as any
+
+

package/src/entry-browser.ts

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

package/src/entry-node.ts

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

package/src/index.d.ts

@@ -1,9 +1,12 @@
-// Augment Array.isArray to properly handle readonly arrays in type narrowing
-interface ArrayConstructor {
-	/**
-	 * Determines whether an object is an array.
-	 * @param arg Any value to test.
-	 * @returns True if the value is an array (mutable or readonly), false otherwise.
-	 */
-	isArray(arg: any): arg is any[] | readonly any[]
-}
+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

@@ -9,6 +9,7 @@ export * from './reactive'
 export * from './std-decorators'
 export * from './utils'
 export * from './zone'
+export * from './async'
 
 import pkg from '../package.json'
 

package/src/reactive/array.ts

@@ -74,6 +74,7 @@ export abstract class ReactiveArray extends Array {
 	at(index: number): any {
 		const actualIndex = index < 0 ? this.length + index : index
 		dependant(this, actualIndex)
+		if (index < 0) dependant(this, 'length')
 		if (actualIndex < 0 || actualIndex >= this.length) return undefined
 		return reactive(this[actualIndex])
 	}
@@ -136,36 +137,57 @@ export abstract class ReactiveArray extends Array {
 	}
 
 	indexOf(searchElement: any, fromIndex?: number): number {
-		dependant(this)
+		const length = this.length
+		let i = fromIndex === undefined ? 0 : fromIndex
+		if (i < 0) i = Math.max(length + i, 0)
+		
 		const unwrappedSearch = unwrap(searchElement)
-		// Check both wrapped and unwrapped versions since array may contain either
-		const index = this.indexOf(unwrappedSearch, fromIndex)
-		if (index !== -1) return index
-		// If not found with unwrapped, try with wrapped (in case array contains wrapped version)
-		return this.indexOf(searchElement, fromIndex)
+
+		for (; i < length; i++) {
+			dependant(this, i)
+			const item = this[i]
+			if (item === searchElement || item === unwrappedSearch || unwrap(item) === unwrappedSearch) {
+				return i
+			}
+		}
+
+		dependant(this, 'length')
+		return -1
 	}
 
 	lastIndexOf(searchElement: any, fromIndex?: number): number {
-		dependant(this)
+		const length = this.length
+		let i = fromIndex === undefined ? length - 1 : fromIndex
+		if (i >= length) i = length - 1
+		if (i < 0) i = Math.max(length + i, -1) // -1 ensures loop condition i >= 0 works correctly
+
 		const unwrappedSearch = unwrap(searchElement)
-		// Check both wrapped and unwrapped versions since array may contain either
-		const index = this.lastIndexOf(unwrappedSearch, fromIndex)
-		if (index !== -1) return index
-		// If not found with unwrapped, try with wrapped (in case array contains wrapped version)
-		return this.lastIndexOf(searchElement, fromIndex)
+
+		for (; i >= 0; i--) {
+			dependant(this, i)
+			const item = this[i]
+			if (item === searchElement || item === unwrappedSearch || unwrap(item) === unwrappedSearch) {
+				return i
+			}
+		}
+
+		// 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.
+		// If we push an element, should lastIndexOf update?
+		// Yes, if the new element is the one we are looking for.
+		dependant(this, 'length')
+		return -1
 	}
 
 	includes(searchElement: any, fromIndex?: number): boolean {
-		dependant(this)
-		const unwrappedSearch = unwrap(searchElement)
-		// Check both wrapped and unwrapped versions since array may contain either
-		return this.includes(unwrappedSearch, fromIndex) || this.includes(searchElement, fromIndex)
+		return this.indexOf(searchElement, fromIndex) !== -1
 	}
 
 	find(predicate: (this: any, value: any, index: number, obj: any[]) => boolean, thisArg?: any): any
 	find(searchElement: any, fromIndex?: number): any
 	find(predicateOrElement: any, thisArg?: any): any {
-		dependant(this)
 		if (typeof predicateOrElement === 'function') {
 			const predicate = predicateOrElement as (
 				this: any,
@@ -173,12 +195,18 @@ export abstract class ReactiveArray extends Array {
 				index: number,
 				obj: any[]
 			) => boolean
-			return reactive(
-				this.find(
-					(value, index, array) => predicate.call(thisArg, reactive(value), index, array),
-					thisArg
-				)
-			)
+			const length = this.length
+
+			for (let i = 0; i < length; i++) {
+				dependant(this, i)
+				const val = reactive(this[i])
+				if (predicate.call(thisArg, val, i, this)) {
+					return val
+				}
+			}
+
+			dependant(this, 'length')
+			return undefined
 		}
 		const fromIndex = typeof thisArg === 'number' ? thisArg : undefined
 		const index = this.indexOf(predicateOrElement, fromIndex)
@@ -192,7 +220,6 @@ export abstract class ReactiveArray extends Array {
 	): number
 	findIndex(searchElement: any, fromIndex?: number): number
 	findIndex(predicateOrElement: any, thisArg?: any): number {
-		dependant(this)
 		if (typeof predicateOrElement === 'function') {
 			const predicate = predicateOrElement as (
 				this: any,
@@ -200,10 +227,18 @@ export abstract class ReactiveArray extends Array {
 				index: number,
 				obj: any[]
 			) => boolean
-			return this.findIndex(
-				(value, index, array) => predicate.call(thisArg, reactive(value), index, array),
-				thisArg
-			)
+			const length = this.length
+
+			for (let i = 0; i < length; i++) {
+				dependant(this, i)
+				const val = reactive(this[i])
+				if (predicate.call(thisArg, val, i, this)) {
+					return i
+				}
+			}
+
+			dependant(this, 'length')
+			return -1
 		}
 		const fromIndex = typeof thisArg === 'number' ? thisArg : undefined
 		return this.indexOf(predicateOrElement, fromIndex)
@@ -291,7 +326,6 @@ export abstract class ReactiveArray extends Array {
 		})
 	}
 
-	// TODO: re-implement for fun dependencies? (eg - every only check the first ones until it find some),
 	// no need to make it dependant on indexes after the found one
 	every<S>(
 		predicate: (value: any, index: number, array: any[]) => value is S,
@@ -299,18 +333,31 @@ export abstract class ReactiveArray extends Array {
 	): this is S[]
 	every(callbackfn: (value: any, index: number, array: any[]) => boolean, thisArg?: any): boolean
 	every(callbackfn: (value: any, index: number, array: any[]) => boolean, thisArg?: any): boolean {
-		dependant(this)
-		return this.every(
-			(value, index, array) => callbackfn.call(thisArg, reactive(value), index, array),
-			thisArg
-		)
+		const length = this.length
+
+		for (let i = 0; i < length; i++) {
+			dependant(this, i)
+			if (!callbackfn.call(thisArg, reactive(this[i]), i, this)) {
+				return false
+			}
+		}
+
+		dependant(this, 'length')
+		return true
 	}
+
 	some(callbackfn: (value: any, index: number, array: any[]) => boolean, thisArg?: any): boolean {
-		dependant(this)
-		return this.some(
-			(value, index, array) => callbackfn.call(thisArg, reactive(value), index, array),
-			thisArg
-		)
+		const length = this.length
+
+		for (let i = 0; i < length; i++) {
+			dependant(this, i)
+			if (callbackfn.call(thisArg, reactive(this[i]), i, this)) {
+				return true
+			}
+		}
+
+		dependant(this, 'length')
+		return false
 	}
 	// Side-effectful
 	push(...items: any[]) {
@@ -358,7 +405,20 @@ export abstract class ReactiveArray extends Array {
 
 	splice(start: number, deleteCount?: number, ...items: any[]) {
 		const oldLength = this.length
-		if (deleteCount === undefined) deleteCount = oldLength - start
+
+		// Normalize start index
+		let actualStart = start
+		if (actualStart < 0) actualStart = Math.max(oldLength + actualStart, 0)
+		else actualStart = Math.min(actualStart, oldLength)
+
+		// Normalize deleteCount
+		let actualDeleteCount = deleteCount
+		if (actualDeleteCount === undefined) {
+			actualDeleteCount = oldLength - actualStart
+		} else {
+			actualDeleteCount = Math.max(0, Math.min(actualDeleteCount, oldLength - actualStart))
+		}
+
 		try {
 			if (deleteCount === undefined) return reactive(this.splice(start))
 			return reactive(this.splice(start, deleteCount, ...items))
@@ -366,10 +426,9 @@ export abstract class ReactiveArray extends Array {
 			touched(
 				this,
 				{ type: 'bunch', method: 'splice' },
-				// TODO: edge cases
-				deleteCount === items.length
-					? range(start, start + deleteCount)
-					: range(start, oldLength + Math.max(items.length - deleteCount, 0), {
+				actualDeleteCount === items.length
+					? range(actualStart, actualStart + actualDeleteCount - 1)
+					: range(actualStart, oldLength + Math.max(items.length - actualDeleteCount, 0), {
 							length: true,
 						})
 			)
@@ -394,12 +453,23 @@ export abstract class ReactiveArray extends Array {
 	}
 
 	fill(value: any, start?: number, end?: number) {
+		const len = this.length
+		let k = start === undefined ? 0 : start
+		if (k < 0) k = Math.max(len + k, 0)
+		else k = Math.min(k, len)
+
+		let final = end === undefined ? len : end
+		if (final < 0) final = Math.max(len + final, 0)
+		else final = Math.min(final, len)
+
 		try {
 			if (start === undefined) return this.fill(value) as any
 			if (end === undefined) return this.fill(value, start) as any
 			return this.fill(value, start, end) as any
 		} finally {
-			touched(this, { type: 'bunch', method: 'fill' }, range(0, this.length - 1))
+			if (final > k) {
+				touched(this, { type: 'bunch', method: 'fill' }, range(k, final - 1))
+			}
 		}
 	}
 
@@ -408,13 +478,30 @@ export abstract class ReactiveArray extends Array {
 			if (end === undefined) return this.copyWithin(target, start) as any
 			return this.copyWithin(target, start, end) as any
 		} finally {
-			touched(
-				this,
-				{ type: 'bunch', method: 'copyWithin' },
-				// TODO: calculate the range properly
-				range(0, this.length - 1)
-			)
+			const len = this.length
+
+			let to = target
+			if (to < 0) to = Math.max(len + to, 0)
+			else if (to >= len) to = len
+
+			let from = start
+			if (from < 0) from = Math.max(len + from, 0)
+			else if (from >= len) from = len
+
+			let final = end === undefined ? len : end
+			if (final < 0) final = Math.max(len + final, 0)
+			else if (final >= len) final = len
+
+			const count = Math.min(final - from, len - to)
+
+			if (count > 0) {
+				touched(
+					this,
+					{ type: 'bunch', method: 'copyWithin' },
+					range(to, to + count - 1)
+				)
+			}
+
 		}
-		// Touch all affected indices with a single allProps call
 	}
 }

package/src/reactive/effect-context.ts

@@ -3,10 +3,10 @@ import { asyncZone, ZoneAggregator, ZoneHistory } from '../zone'
 import { getRoot } from './registry'
 import { type ScopedCallback } from './types'
 
-export const effectHistory = tag(new ZoneHistory<ScopedCallback>(), 'effectHistory')
-tag(effectHistory.present, 'effectHistory.present')
+export const effectHistory = tag('effectHistory', new ZoneHistory<ScopedCallback>())
+tag('effectHistory.present', effectHistory.present)
 asyncZone.add(effectHistory)
-export const effectAggregator = tag(new ZoneAggregator(effectHistory.present), 'effectAggregator')
+export const effectAggregator = tag('effectAggregator', new ZoneAggregator(effectHistory.present))
 
 export function isRunning(effect: ScopedCallback): boolean {
 	const root = getRoot(effect)

package/src/reactive/index.ts

@@ -27,8 +27,9 @@ export { immutables, isNonReactive, registerNativeReactivity } from './non-react
 export { getActiveProjection, project } from './project'
 export { isReactive, ReactiveBase, reactive, unwrap } from './proxy'
 export { organize, organized } from './record'
-export { scan, type ScanResult } from './buffer'
+export { scan, type ScanResult, resolve } from './buffer'
 export { Register, register } from './register'
+export { getActiveEffect, effectAggregator } from './effect-context'
 export {
 	type DependencyAccess,
 	type Evolution,

package/src/reactive/map.ts

@@ -113,7 +113,7 @@ export abstract class ReactiveMap<K, V> extends Map<K, V> {
 				return this
 			},
 			[Symbol.dispose]() {},
-		}
+		} as any // TODO: real iterator? (If easy)
 	}
 
 	// Implement Map methods with reactivity

package/src/reactive/set.ts

@@ -125,6 +125,6 @@ export abstract class ReactiveSet<T> extends Set<T> {
 				return this
 			},
 			[Symbol.dispose]() {},
-		}
+		} as any	//TODO? (something easy)
 	}
 }

package/src/utils.ts

@@ -275,7 +275,7 @@ export function contentRef(container: object) {
 	return contentRefs.get(container)
 }
 
-export function tag<T extends object>(obj: T, name: string): T {
+export function tag<T extends object>(name: string, obj: T): T {
 	Object.defineProperties(obj, {
 		[Symbol.toStringTag]: {
 			value: name,

package/src/zone.ts

@@ -1,23 +1,34 @@
 import { asyncHooks } from "./async"
 import { named, tag } from "./utils"
 
+interface InternalZoneUse<T> {
+	enter(value?: T): unknown
+	leave(entered: unknown): void
+}
+function isu<T>(z: AZone<T> | InternalZoneUse<T>): InternalZoneUse<T> {
+	return z as InternalZoneUse<T>
+}
 export abstract class AZone<T> {
 	abstract active?: T
-	enter(value?: T): unknown {
+	protected enter(value?: T): unknown {
 		const prev = this.active
 		this.active = value
 		return prev
 	}
-	leave(entered: unknown): void {
+	protected leave(entered: unknown): void {
 		this.active = entered as T | undefined
 	}
 	with<R>(value: T, fn: () => R): R {
 		const entered = this.enter(value)
+        let res: R;
 		try {
-			return fn()
+			res = fn()
 		} finally {
 			this.leave(entered)
 		}
+        // [HACK]: Sanitization
+        // See BROWSER_ASYNC_POLYFILL.md
+        return asyncHooks.sanitizePromise(res) as R
 	}
 	root<R>(fn: () => R): R {
 		let prev = this.enter()
@@ -61,11 +72,11 @@ export class ZoneHistory<T> extends AZone<HistoryValue<T>> {
 				enter(value?: T) {
 					if(value && self.history.has(value)) throw new Error('ZoneHistory: re-entering historical zone')
 					if(value !== undefined) self.history.add(value)
-					return { added: value, entered: controlled.enter(value) }
+					return { added: value, entered: isu(controlled).enter(value) }
 				},
 				leave(entered: { added: T | undefined, entered: unknown }) {
 					if(entered.added !== undefined) self.history.delete(entered.added)
-					return controlled.leave(entered.entered)
+					return isu(controlled).leave(entered.entered)
 				}
 			})
 		)
@@ -98,12 +109,12 @@ export class ZoneAggregator extends AZone<Map<AZone<unknown>, unknown>> {
 		const entered = new Map<AZone<unknown>, unknown>()
 		for (const z of this.#zones) {
 			const v = value?.get(z)
-			entered.set(z, z.enter(v))
+			entered.set(z, isu(z).enter(v))
 		}
 		return entered
 	}
 	leave(entered: Map<AZone<unknown>, unknown>): void {
-		for (const z of this.#zones) z.leave(entered.get(z))
+		for (const z of this.#zones) isu(z).leave(entered.get(z))
 	}
 	add(z: AZone<unknown>) {
 		this.#zones.add(z)
@@ -116,7 +127,7 @@ export class ZoneAggregator extends AZone<Map<AZone<unknown>, unknown>> {
 	}
 }
 
-export const asyncZone = tag(new ZoneAggregator(), 'async')
+export const asyncZone = tag('async', new ZoneAggregator())
 asyncHooks.addHook(() => {
 	const zone = asyncZone.active
 	return () => {