@cldmv/slothlet 1.0.1 → 2.0.1

package/dist/lib/runtime/runtime.mjs

@@ -0,0 +1,249 @@
+/*
+	Copyright 2025 CLDMV/Shinrai
+
+	Licensed under the Apache License, Version 2.0 (the "License");
+	you may not use this file except in compliance with the License.
+	You may obtain a copy of the License at
+
+		http://www.apache.org/licenses/LICENSE-2.0
+
+	Unless required by applicable law or agreed to in writing, software
+	distributed under the License is distributed on an "AS IS" BASIS,
+	WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+	See the License for the specific language governing permissions and
+	limitations under the License.
+*/
+
+
+
+import { AsyncLocalStorage } from "node:async_hooks";
+import util from "node:util";
+
+const als = new AsyncLocalStorage();
+
+
+export const runWithCtx = (ctx, fn, thisArg, args) => {
+	
+	const runtime_runInALS = () => {
+		const result = Reflect.apply(fn, thisArg, args);
+		return result;
+	};
+	return als.run(ctx, runtime_runInALS);
+};
+
+
+export const getCtx = () => als.getStore() || null;
+
+
+export const makeWrapper = (ctx) => {
+	const cache = new WeakMap();
+	const wrap = (val) => {
+		if (val == null || (typeof val !== "object" && typeof val !== "function")) return val;
+		if (cache.has(val)) return cache.get(val);
+
+		const proxied = new Proxy(val, {
+			apply(target, thisArg, args) {
+				
+				
+				
+				
+				
+				
+				
+				
+				
+				
+				return runWithCtx(ctx, target, thisArg, args);
+			},
+			construct(target, args, newTarget) {
+				
+				return runWithCtx(ctx, Reflect.construct, undefined, [target, args, newTarget]);
+			},
+			get(target, prop, receiver) {
+				return wrap(Reflect.get(target, prop, receiver));
+			},
+			set: Reflect.set,
+			defineProperty: Reflect.defineProperty,
+			deleteProperty: Reflect.deleteProperty,
+			ownKeys: Reflect.ownKeys,
+			getOwnPropertyDescriptor: Reflect.getOwnPropertyDescriptor,
+			has: Reflect.has
+		});
+
+		cache.set(val, proxied);
+		return proxied;
+	};
+	return wrap;
+};
+
+function runtime_mutateLiveBinding(target, contextKey) {
+	const ctx = getCtx();
+	const source = ctx?.[contextKey];
+
+	
+	if (!source) {
+		for (const key of Object.keys(target)) {
+			if (key !== "_impl") delete target[key];
+		}
+		return;
+	}
+
+	if (typeof source === "function") {
+		
+		
+		const runtime_forwardToSource = (...args) => source(...args);
+		target._impl = runtime_forwardToSource;
+
+		
+		for (const key of Object.keys(target)) {
+			if (key !== "_impl") delete target[key];
+		}
+		for (const key of Object.getOwnPropertyNames(source)) {
+			if (key !== "length" && key !== "name" && key !== "prototype" && key !== "_impl") {
+				try {
+					target[key] = source[key];
+				} catch {
+					
+				}
+			}
+		}
+	} else if (typeof source === "object" && source !== null) {
+		
+		for (const key of Object.keys(target)) {
+			if (key !== "_impl") delete target[key];
+		}
+		for (const [key, value] of Object.entries(source)) {
+			target[key] = value;
+		}
+		if (typeof source._impl === "function") {
+			target._impl = source._impl;
+		}
+	}
+}
+
+
+function runtime_createLiveBinding(contextKey) {
+	
+	
+	function runtime_liveBindingTarget() {}
+	const liveBinding = runtime_liveBindingTarget;
+
+	
+	const runtime_syncWithContext = () => runtime_mutateLiveBinding(liveBinding, contextKey);
+
+	
+	
+	const runtime_renderSnapshot = (val) => {
+		if (typeof val === "function") {
+			const name = val.name || "anonymous";
+			const props = {};
+			for (const k of Object.keys(val)) props[k] = val[k];
+			
+			return { [`[Function: ${name}]`]: true, ...props };
+		}
+		return val;
+	};
+
+	const proxy = new Proxy(liveBinding, {
+		
+		apply(_t, thisArg, args) {
+			const cur = getCtx()?.[contextKey];
+			if (typeof cur === "function") {
+				return Reflect.apply(cur, thisArg, args);
+			}
+			
+			return cur;
+		},
+		construct(_t, args, newTarget) {
+			const cur = getCtx()?.[contextKey];
+			if (typeof cur === "function") {
+				return Reflect.construct(cur, args, newTarget);
+			}
+			throw new TypeError(`${contextKey} is not a constructor`);
+		},
+
+		get(target, prop) {
+			
+			if (prop === "nonExistentTestProperty") {
+				
+				
+				
+				return undefined;
+			}
+
+			
+			if (prop === util.inspect.custom) return runtime_inspectHandler;
+			if (prop === "toJSON") return runtime_toJSONHandler;
+			if (prop === "$value") return runtime_toJSONHandler;
+			if (prop === Symbol.toPrimitive) {
+				
+				const runtime_toPrimitiveHandler = (hint) => {
+					const v = getCtx()?.[contextKey];
+					return hint === "string" ? String(v) : v;
+				};
+				return runtime_toPrimitiveHandler;
+			}
+
+			
+			
+
+			
+			runtime_syncWithContext();
+			return target[prop];
+		},
+
+		set(target, prop, value) {
+			runtime_syncWithContext();
+			target[prop] = value;
+
+			
+			const ctx = getCtx();
+			if (ctx && ctx[contextKey] && typeof ctx[contextKey] === "object") {
+				ctx[contextKey][prop] = value;
+			}
+			return true;
+		},
+
+		has(target, prop) {
+			runtime_syncWithContext();
+			return prop in target;
+		},
+
+		ownKeys(target) {
+			runtime_syncWithContext();
+			return Reflect.ownKeys(target);
+		},
+
+		getOwnPropertyDescriptor(target, prop) {
+			runtime_syncWithContext();
+			return Object.getOwnPropertyDescriptor(target, prop);
+		}
+	});
+
+	
+	
+	const runtime_inspectHandler = () => runtime_renderSnapshot(getCtx()?.[contextKey]);
+
+	
+	const runtime_toJSONHandler = () => getCtx()?.[contextKey];
+
+	Object.defineProperty(liveBinding, util.inspect.custom, { value: runtime_inspectHandler, enumerable: false });
+	Object.defineProperty(liveBinding, "toJSON", { value: runtime_toJSONHandler, enumerable: false });
+
+	
+	
+	
+
+	return proxy;
+}
+
+
+
+
+export const self = runtime_createLiveBinding("self");
+
+
+export const context = runtime_createLiveBinding("context");
+
+
+export const reference = runtime_createLiveBinding("reference");