mutts 1.0.5 → 1.0.7

package/src/utils.ts

@@ -86,32 +86,216 @@ export function renamed<F extends Function>(fct: F, name: string): F {
 		},
 	})
 }
+export const FoolProof = {
+	get(obj: any, prop: any, receiver: any) {
+		// Check if Node is available and obj is an instance of Node
+		if (typeof Node !== 'undefined' && obj instanceof Node) return (obj as any)[prop]
+		return Reflect.get(obj, prop, receiver)
+	},
+	set(obj: any, prop: any, value: any, receiver: any) {
+		// Check if Node is available and obj is an instance of Node
+		if (typeof Node !== 'undefined' && obj instanceof Node) {
+			;(obj as any)[prop] = value
+			return true
+		}
+		if (!(obj instanceof Object) && !Reflect.has(obj, prop)) {
+			Object.defineProperty(obj, prop, {
+				value,
+				configurable: true,
+				writable: true,
+				enumerable: true,
+			})
+			return true
+		}
+		return Reflect.set(obj, prop, value, receiver)
+	},
+}
 
-export function ReflectGet(obj: any, prop: any, receiver: any) {
-	// Check if Node is available and obj is an instance of Node
-	if (typeof Node !== 'undefined' && obj instanceof Node) return (obj as any)[prop]
-	return Reflect.get(obj, prop, receiver)
+export function isOwnAccessor(obj: any, prop: any) {
+	const opd = Object.getOwnPropertyDescriptor(obj, prop)
+	return !!(opd?.get || opd?.set)
 }
 
-export function ReflectSet(obj: any, prop: any, value: any, receiver: any) {
-	// Check if Node is available and obj is an instance of Node
-	if (typeof Node !== 'undefined' && obj instanceof Node) {
-		;(obj as any)[prop] = value
-		return true
+/**
+ * Deeply compares two values.
+ * For objects, compares prototypes with === and then own properties recursively.
+ * Uses a cache to handle circular references.
+ * @param a - First value
+ * @param b - Second value
+ * @param cache - Map for circular reference protection (internal use)
+ * @returns True if values are deeply equal
+ */
+export function deepCompare(a: any, b: any, cache = new Map<object, Set<object>>()): boolean {
+	if (a === b) return true
+
+	if (typeof a !== 'object' || a === null || typeof b !== 'object' || b === null) {
+		return a === b
 	}
-	if (!(obj instanceof Object) && !Reflect.has(obj, prop)) {
-		Object.defineProperty(obj, prop, {
-			value,
-			configurable: true,
-			writable: true,
-			enumerable: true,
+
+	// Prototype check
+	const protoA = Object.getPrototypeOf(a)
+	const protoB = Object.getPrototypeOf(b)
+	if (protoA !== protoB) {
+		console.warn(`[deepCompare] prototype mismatch:`, {
+			nameA: a?.constructor?.name,
+			nameB: b?.constructor?.name,
 		})
+		return false
+	}
+	// Circular reference protection
+	let compared = cache.get(a)
+	if (compared?.has(b)) return true
+	if (!compared) {
+		compared = new Set()
+		cache.set(a, compared)
+	}
+	compared.add(b)
+
+	// Handle specific object types
+	if (Array.isArray(a)) {
+		if (!Array.isArray(b)) {
+			console.warn(`[deepCompare] B is not an array`)
+			return false
+		}
+		if (a.length !== b.length) {
+			console.warn(`[deepCompare] array length mismatch:`, { lenA: a.length, lenB: b.length })
+			return false
+		}
+		for (let i = 0; i < a.length; i++) {
+			if (!deepCompare(a[i], b[i], cache)) {
+				console.warn(`[deepCompare] array element mismatch at index ${i}`)
+				return false
+			}
+		}
+		return true
+	}
+
+	if (a instanceof Date) {
+		const match = b instanceof Date && a.getTime() === b.getTime()
+		if (!match) console.warn(`[deepCompare] Date mismatch`)
+		return match
+	}
+	if (a instanceof RegExp) {
+		const match = b instanceof RegExp && a.toString() === b.toString()
+		if (!match) console.warn(`[deepCompare] RegExp mismatch`)
+		return match
+	}
+	if (a instanceof Set) {
+		if (!(b instanceof Set) || a.size !== b.size) {
+			console.warn(`[deepCompare] Set size mismatch`)
+			return false
+		}
+		for (const val of a) {
+			let found = false
+			for (const bVal of b) {
+				if (deepCompare(val, bVal, cache)) {
+					found = true
+					break
+				}
+			}
+			if (!found) {
+				console.warn(`[deepCompare] missing Set element`)
+				return false
+			}
+		}
 		return true
 	}
-	return Reflect.set(obj, prop, value, receiver)
+	if (a instanceof Map) {
+		if (!(b instanceof Map) || a.size !== b.size) {
+			console.warn(`[deepCompare] Map size mismatch`)
+			return false
+		}
+		for (const [key, val] of a) {
+			if (!b.has(key)) {
+				let foundMatch = false
+				for (const [bKey, bVal] of b) {
+					if (deepCompare(key, bKey, cache) && deepCompare(val, bVal, cache)) {
+						foundMatch = true
+						break
+					}
+				}
+				if (!foundMatch) {
+					console.warn(`[deepCompare] missing Map key`)
+					return false
+				}
+			} else {
+				if (!deepCompare(val, b.get(key), cache)) {
+					console.warn(`[deepCompare] Map value mismatch for key`)
+					return false
+				}
+			}
+		}
+		return true
+	}
+
+	// Compare own properties
+	const keysA = Object.keys(a)
+	const keysB = Object.keys(b)
+	if (keysA.length !== keysB.length) {
+		console.warn(`[deepCompare] keys length mismatch:`, {
+			lenA: keysA.length,
+			lenB: keysB.length,
+			keysA,
+			keysB,
+			a,
+			b,
+		})
+		return false
+	}
+
+	for (const key of keysA) {
+		if (!Object.hasOwn(b, key)) {
+			console.warn(`[deepCompare] missing key ${String(key)} in B`)
+			return false
+		}
+		if (!deepCompare(a[key], b[key], cache)) {
+			console.warn(`[deepCompare] value mismatch for key ${String(key)}:`, {
+				valA: a[key],
+				valB: b[key],
+			})
+			return false
+		}
+	}
+
+	return true
 }
 
-export function isOwnAccessor(obj: any, prop: any) {
-	const opd = Object.getOwnPropertyDescriptor(obj, prop)
-	return !!(opd?.get || opd?.set)
+
+const contentRefs = new WeakMap<object, any>()
+export function contentRef(container: object) {
+	if (!contentRefs.has(container))
+		contentRefs.set(
+			container,
+			Object.seal(
+				Object.create(null, {
+					contentOf: { value: container, writable: false, configurable: false },
+				})
+			)
+		)
+	return contentRefs.get(container)
+}
+
+export function tag<T extends object>(obj: T, name: string): T {
+	Object.defineProperties(obj, {
+		[Symbol.toStringTag]: {
+			value: name,
+			writable: false,
+			configurable: false,
+		},
+		toString: {
+			value: () => name,
+			writable: false,
+			configurable: false,
+		},
+	})
+	return obj
 }
+
+export function named<T extends Function>(name: string, fn: T): T {
+	Object.defineProperty(fn, 'name', {
+		value: fn.name ? `${fn.name}::${name}` : name,
+		writable: false,
+		configurable: false,
+	})
+	return fn
+}

package/src/zone.ts

@@ -0,0 +1,127 @@
+import { asyncHooks } from "./async"
+import { named, tag } from "./utils"
+
+export abstract class AZone<T> {
+	abstract active?: T
+	enter(value?: T): unknown {
+		const prev = this.active
+		this.active = value
+		return prev
+	}
+	leave(entered: unknown): void {
+		this.active = entered as T | undefined
+	}
+	with<R>(value: T, fn: () => R): R {
+		const entered = this.enter(value)
+		try {
+			return fn()
+		} finally {
+			this.leave(entered)
+		}
+	}
+	root<R>(fn: () => R): R {
+		let prev = this.enter()
+		try {
+			return fn()
+		} finally {
+			this.leave(prev)
+		}
+	}
+	get zoned(): FunctionWrapper {
+		const active = this.active
+		return named(`${this}@${active}`, (fn) => this.with(active, fn))
+	}
+}
+
+export type FunctionWrapper = <R>(fn?: () => R) => R
+
+export class Zone<T> extends AZone<T> {
+	active: T | undefined
+}
+type HistoryValue<T> = {present: T | undefined, history: Set<T>}
+export class ZoneHistory<T> extends AZone<HistoryValue<T>> {
+	private	history = new Set<T>()
+	public readonly present: AZone<T>
+	public has(value: T): boolean {
+		return this.history.has(value)
+	}
+	public some(predicate: (value: T) => boolean): boolean {
+		for(const value of this.history) if(predicate(value)) return true
+		return false
+	}
+	constructor(private controlled: AZone<T> = new Zone<T>()) {
+		super()
+		const self = this
+		this.present = Object.create(controlled,
+			Object.getOwnPropertyDescriptors({
+				get active() { return controlled.active },
+				set active(value: T | undefined) {
+					controlled.active = value
+				},
+				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) }
+				},
+				leave(entered: { added: T | undefined, entered: unknown }) {
+					if(entered.added !== undefined) self.history.delete(entered.added)
+					return controlled.leave(entered.entered)
+				}
+			})
+		)
+	}
+	get active() {
+		return {present: this.controlled.active, history: new Set(this.history)}
+	}
+	set active(value: HistoryValue<T> | undefined) {
+		this.history = this.history && new Set(this.history)
+		this.controlled.active = value?.present
+	}
+}
+
+export class ZoneAggregator extends AZone<Map<AZone<unknown>, unknown>> {
+	#zones = new Set<AZone<unknown>>()
+	constructor(...zones: AZone<unknown>[]) {
+		super()
+		for (const z of zones) this.#zones.add(z)
+	}
+	get active(): Map<AZone<unknown>, unknown> | undefined {
+		const rv = new Map<AZone<unknown>, unknown>()
+		for (const z of this.#zones)
+			if (z.active !== undefined) rv.set(z, z.active)
+		return rv
+	}
+	set active(value: Map<AZone<unknown>, unknown> | undefined) {
+		for (const z of this.#zones) z.active = value?.get(z)
+	}
+	enter(value?: Map<AZone<unknown>, unknown> | undefined) {
+		const entered = new Map<AZone<unknown>, unknown>()
+		for (const z of this.#zones) {
+			const v = value?.get(z)
+			entered.set(z, z.enter(v))
+		}
+		return entered
+	}
+	leave(entered: Map<AZone<unknown>, unknown>): void {
+		for (const z of this.#zones) z.leave(entered.get(z))
+	}
+	add(z: AZone<unknown>) {
+		this.#zones.add(z)
+	}
+	delete(z: AZone<unknown>) {
+		this.#zones.delete(z)
+	}
+	clear() {
+		this.#zones.clear()
+	}
+}
+
+export const asyncZone = tag(new ZoneAggregator(), 'async')
+asyncHooks.addHook(() => {
+	const zone = asyncZone.active
+	return () => {
+		const prev = asyncZone.active
+		asyncZone.active = zone
+		return () => asyncZone.active = prev
+	}
+})

package/dist/chunks/_tslib-BgjropY9.js

@@ -1,81 +0,0 @@
-'use strict';
-
-/******************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
-
-
-function __esDecorate(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
-    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
-    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
-    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
-    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
-    var _, done = false;
-    for (var i = decorators.length - 1; i >= 0; i--) {
-        var context = {};
-        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
-        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
-        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
-        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
-        if (kind === "accessor") {
-            if (result === void 0) continue;
-            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
-            if (_ = accept(result.get)) descriptor.get = _;
-            if (_ = accept(result.set)) descriptor.set = _;
-            if (_ = accept(result.init)) initializers.unshift(_);
-        }
-        else if (_ = accept(result)) {
-            if (kind === "field") initializers.unshift(_);
-            else descriptor[key] = _;
-        }
-    }
-    if (target) Object.defineProperty(target, contextIn.name, descriptor);
-    done = true;
-}
-function __runInitializers(thisArg, initializers, value) {
-    var useValue = arguments.length > 2;
-    for (var i = 0; i < initializers.length; i++) {
-        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
-    }
-    return useValue ? value : void 0;
-}
-function __setFunctionName(f, name, prefix) {
-    if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
-    return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
-}
-function __classPrivateFieldGet(receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-}
-
-function __classPrivateFieldSet(receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-}
-
-typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-};
-
-exports.__classPrivateFieldGet = __classPrivateFieldGet;
-exports.__classPrivateFieldSet = __classPrivateFieldSet;
-exports.__esDecorate = __esDecorate;
-exports.__runInitializers = __runInitializers;
-exports.__setFunctionName = __setFunctionName;
-//# sourceMappingURL=_tslib-BgjropY9.js.map

package/dist/chunks/_tslib-BgjropY9.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"_tslib-BgjropY9.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/chunks/_tslib-Mzh1rNsX.esm.js

@@ -1,75 +0,0 @@
-/******************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
-
-
-function __esDecorate(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
-    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
-    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
-    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
-    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
-    var _, done = false;
-    for (var i = decorators.length - 1; i >= 0; i--) {
-        var context = {};
-        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
-        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
-        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
-        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
-        if (kind === "accessor") {
-            if (result === void 0) continue;
-            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
-            if (_ = accept(result.get)) descriptor.get = _;
-            if (_ = accept(result.set)) descriptor.set = _;
-            if (_ = accept(result.init)) initializers.unshift(_);
-        }
-        else if (_ = accept(result)) {
-            if (kind === "field") initializers.unshift(_);
-            else descriptor[key] = _;
-        }
-    }
-    if (target) Object.defineProperty(target, contextIn.name, descriptor);
-    done = true;
-}
-function __runInitializers(thisArg, initializers, value) {
-    var useValue = arguments.length > 2;
-    for (var i = 0; i < initializers.length; i++) {
-        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
-    }
-    return useValue ? value : void 0;
-}
-function __setFunctionName(f, name, prefix) {
-    if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
-    return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
-}
-function __classPrivateFieldGet(receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-}
-
-function __classPrivateFieldSet(receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-}
-
-typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-};
-
-export { __classPrivateFieldGet as _, __setFunctionName as a, __esDecorate as b, __runInitializers as c, __classPrivateFieldSet as d };
-//# sourceMappingURL=_tslib-Mzh1rNsX.esm.js.map

package/dist/chunks/_tslib-Mzh1rNsX.esm.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"_tslib-Mzh1rNsX.esm.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}