@cldmv/slothlet 2.2.0 → 2.3.1

package/dist/lib/runtime/runtime.mjs

@@ -35,8 +35,102 @@ export const runWithCtx = (ctx, fn, thisArg, args) => {
 export const getCtx = () => als.getStore() || null;
 
 
+const EXCLUDED_CONSTRUCTORS = new Set([Object, Array, Promise, Date, RegExp, Error]);
+
+
+const EXCLUDED_INSTANCEOF_CLASSES = [ArrayBuffer, Map, Set, WeakMap, WeakSet];
+
+
+const PROMISE_METHODS = new Set(["then", "catch", "finally"]);
+
+
+function runtime_shouldWrapMethod(value, prop) {
+	return (
+		typeof value === "function" &&
+		typeof prop === "string" && 
+		prop !== "constructor" &&
+		!(prop in Object.prototype) &&
+		!prop.startsWith("__")
+	);
+}
+
+
+function runtime_isClassInstance(val) {
+	if (
+		val == null ||
+		typeof val !== "object" ||
+		!val.constructor ||
+		typeof val.constructor !== "function" ||
+		EXCLUDED_CONSTRUCTORS.has(val.constructor)
+	) {
+		return false;
+	}
+
+	for (const cls of EXCLUDED_INSTANCEOF_CLASSES) {
+		if (typeof cls === "function" && val instanceof cls) {
+			return false;
+		}
+	}
+
+	return true;
+}
+
+
+function runtime_wrapClassInstance(instance, ctx, wrapFn, instanceCache) {
+	if (instanceCache.has(instance)) {
+		return instanceCache.get(instance);
+	}
+
+	
+	const methodCache = new Map();
+
+	const wrappedInstance = new Proxy(instance, {
+		get(target, prop, receiver) {
+			
+			if (methodCache.has(prop)) {
+				return methodCache.get(prop);
+			}
+
+			const value = Reflect.get(target, prop, receiver);
+
+			
+			
+			if (runtime_shouldWrapMethod(value, prop)) {
+				
+				
+				const runtime_contextPreservingMethod = function (...args) {
+					const result = runWithCtx(ctx, value, target, args);
+					
+					return wrapFn(result);
+				};
+
+				
+				methodCache.set(prop, runtime_contextPreservingMethod);
+				return runtime_contextPreservingMethod;
+			}
+
+			
+			return wrapFn(value);
+		},
+
+		set(target, prop, value, receiver) {
+			
+			if (methodCache.has(prop)) {
+				methodCache.delete(prop);
+			}
+			return Reflect.set(target, prop, value, receiver);
+		}
+	});
+
+	instanceCache.set(instance, wrappedInstance);
+	return wrappedInstance;
+}
+
+
 export const makeWrapper = (ctx) => {
 	const cache = new WeakMap();
+	const instanceCache = new WeakMap();
+	const promiseMethodCache = new WeakMap(); 
 	const wrap = (val) => {
 		if (val == null || (typeof val !== "object" && typeof val !== "function")) return val;
 		if (cache.has(val)) return cache.get(val);
@@ -53,18 +147,88 @@ export const makeWrapper = (ctx) => {
 				
 				
 				
-				return runWithCtx(ctx, target, thisArg, args);
+
+				const result = runWithCtx(ctx, target, thisArg, args);
+
+				
+				if (runtime_isClassInstance(result)) {
+					return runtime_wrapClassInstance(result, ctx, wrap, instanceCache);
+				}
+
+				return result;
 			},
 			construct(target, args, newTarget) {
 				
-				return runWithCtx(ctx, Reflect.construct, undefined, [target, args, newTarget]);
+				const result = runWithCtx(ctx, Reflect.construct, undefined, [target, args, newTarget]);
+
+				
+				if (runtime_isClassInstance(result)) {
+					return runtime_wrapClassInstance(result, ctx, wrap, instanceCache);
+				}
+
+				return result;
 			},
 			get(target, prop, receiver) {
-				return wrap(Reflect.get(target, prop, receiver));
+				const value = Reflect.get(target, prop, receiver);
+
+				
+				
+				const isPromiseMethod = typeof value === "function" && PROMISE_METHODS.has(prop);
+				const isNativePromise = util.types.isPromise(target);
+				const hasThen = typeof target?.then === "function";
+
+				if (isPromiseMethod && (isNativePromise || hasThen)) {
+					
+					let targetMethodCache = promiseMethodCache.get(target);
+					if (!targetMethodCache) {
+						targetMethodCache = new Map();
+						promiseMethodCache.set(target, targetMethodCache);
+					}
+
+					if (targetMethodCache.has(prop)) {
+						return targetMethodCache.get(prop);
+					}
+
+					const wrappedMethod = function (...args) {
+						
+						const wrappedArgs = args.map((arg) => {
+							if (typeof arg === "function") {
+								return function (...callbackArgs) {
+									return runWithCtx(ctx, arg, undefined, callbackArgs);
+								};
+							}
+							return arg;
+						});
+
+						
+						const result = Reflect.apply(value, target, wrappedArgs);
+						
+						return wrap(result);
+					};
+
+					targetMethodCache.set(prop, wrappedMethod);
+					return wrappedMethod;
+				}
+
+				return wrap(value);
+			},
+			set(target, prop, value, receiver) {
+				
+				const methodCache = promiseMethodCache.get(target);
+				if (methodCache && methodCache.has(prop)) {
+					methodCache.delete(prop);
+				}
+				return Reflect.set(target, prop, value, receiver);
 			},
-			set: Reflect.set,
 			defineProperty: Reflect.defineProperty,
-			deleteProperty: Reflect.deleteProperty,
+			deleteProperty(target, prop) {
+				
+				const methodCache = promiseMethodCache.get(target);
+				if (methodCache && methodCache.has(prop)) {
+					methodCache.delete(prop);
+				}
+				return Reflect.deleteProperty(target, prop);
+			},
 			ownKeys: Reflect.ownKeys,
 			getOwnPropertyDescriptor: Reflect.getOwnPropertyDescriptor,
 			has: Reflect.has

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@cldmv/slothlet",
-	"version": "2.2.0",
+	"version": "2.3.1",
 	"moduleVersions": {
 		"lazy": "1.0.0",
 		"eager": "1.0.0"

package/types/dist/lib/runtime/runtime.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"runtime.d.mts","sourceRoot":"","sources":["../../../../dist/lib/runtime/runtime.mjs"],"names":[],"mappings":"AA0CO,gCAdI,MAAM,yBAEN,GAAG,gBAED,GAAG,CA6Bf;AAiBM,0BAZM,MAAM,GAAC,IAAI,CAY0B;AAsB3C,iCAjBI,MAAM,YAwDhB;AA4RD;;;;;;;;;;;;;GAaG;AACH,mBATU,WAAS,MAAM,CAS6B;AAEtD;;;;;;;;;;;;;GAaG;AACH,sBATU,MAAM,CAS4C;AAE5D;;;;;;;;;;;;;GAaG;AACH,wBATU,MAAM,CASgD"}
+{"version":3,"file":"runtime.d.mts","sourceRoot":"","sources":["../../../../dist/lib/runtime/runtime.mjs"],"names":[],"mappings":"AA0CO,gCAdI,MAAM,yBAEN,GAAG,gBAED,GAAG,CA6Bf;AAiBM,0BAZM,MAAM,GAAC,IAAI,CAY0B;AAiL3C,iCAjBI,MAAM,YAgIhB;AA4RD;;;;;;;;;;;;;GAaG;AACH,mBATU,WAAS,MAAM,CAS6B;AAEtD;;;;;;;;;;;;;GAaG;AACH,sBATU,MAAM,CAS4C;AAE5D;;;;;;;;;;;;;GAaG;AACH,wBATU,MAAM,CASgD"}