@cldmv/slothlet 2.10.0 → 3.0.0

package/dist/lib/helpers/eventemitter-context.mjs

@@ -0,0 +1,365 @@
+/*
+	Copyright 2026 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 { EventEmitter } from "node:events";
+import { AsyncResource } from "node:async_hooks";
+
+
+let isInApiContext = null;
+
+
+export function setApiContextChecker(checker) {
+	isInApiContext = checker;
+}
+
+
+const originalMethods = new Map();
+
+
+const wrappedListeners = new Map();
+
+
+const trackedEmitters = new Set();
+
+
+let isPatchingEnabled = false;
+
+
+function runtime_wrapEventListener(listener) {
+	
+	const resource = new AsyncResource("slothlet-event-listener");
+
+	
+	const runtime_wrappedListener = function (...args) {
+		
+		
+		return resource.runInAsyncScope(() => {
+			return listener.apply(this, args);
+		}, this);
+	};
+
+	
+	runtime_wrappedListener._slothletOriginal = listener;
+	runtime_wrappedListener._slothletResource = resource;
+
+	return runtime_wrappedListener;
+}
+
+
+function runtime_getListenerTracking(emitter) {
+	let emitterTracking = wrappedListeners.get(emitter);
+	if (!emitterTracking) {
+		emitterTracking = new Map();
+		wrappedListeners.set(emitter, emitterTracking);
+	}
+	return emitterTracking;
+}
+
+
+function runtime_trackListener(emitter, event, originalListener, wrappedListener) {
+	const emitterTracking = runtime_getListenerTracking(emitter);
+
+	let eventTracking = emitterTracking.get(event);
+	if (!eventTracking) {
+		eventTracking = new Map();
+		emitterTracking.set(event, eventTracking);
+	}
+
+	eventTracking.set(originalListener, wrappedListener);
+}
+
+
+function runtime_getWrappedListener(emitter, event, originalListener) {
+	const emitterTracking = wrappedListeners.get(emitter);
+	if (!emitterTracking) return undefined;
+
+	const eventTracking = emitterTracking.get(event);
+	if (!eventTracking) return undefined;
+
+	return eventTracking.get(originalListener);
+}
+
+
+function runtime_untrackListener(emitter, event, originalListener) {
+	const emitterTracking = wrappedListeners.get(emitter);
+	
+	
+	
+	if (!emitterTracking) return;
+
+	const eventTracking = emitterTracking.get(event);
+	if (!eventTracking) return;
+
+	const wrappedListener = eventTracking.get(originalListener);
+	if (wrappedListener) {
+		
+		wrappedListener._slothletResource = null;
+		eventTracking.delete(originalListener);
+	}
+
+	
+	if (eventTracking.size === 0) {
+		emitterTracking.delete(event);
+	}
+	if (emitterTracking.size === 0) {
+		wrappedListeners.delete(emitter);
+	}
+}
+
+
+function runtime_shouldWrapListener(listener) {
+	
+	if (typeof listener !== "function") return false;
+
+	
+	if (listener._slothletOriginal) return false;
+
+	return true;
+}
+
+
+function runtime_maybeTrackEmitter(emitter) {
+	
+	if (isInApiContext && isInApiContext()) {
+		trackedEmitters.add(emitter);
+	}
+}
+
+
+function runtime_patchOn() {
+	const original = EventEmitter.prototype.on;
+	originalMethods.set("on", original);
+
+	EventEmitter.prototype.on = function (event, listener) {
+		
+		runtime_maybeTrackEmitter(this);
+
+		if (!runtime_shouldWrapListener(listener)) {
+			return original.call(this, event, listener);
+		}
+
+		const wrapped = runtime_wrapEventListener(listener);
+		runtime_trackListener(this, event, listener, wrapped);
+		return original.call(this, event, wrapped);
+	};
+
+	
+	EventEmitter.prototype.addListener = EventEmitter.prototype.on;
+}
+
+
+function runtime_patchOnce() {
+	const original = EventEmitter.prototype.once;
+	originalMethods.set("once", original);
+
+	EventEmitter.prototype.once = function (event, listener) {
+		
+		runtime_maybeTrackEmitter(this);
+
+		if (!runtime_shouldWrapListener(listener)) {
+			return original.call(this, event, listener);
+		}
+
+		const wrapped = runtime_wrapEventListener(listener);
+
+		
+		const runtime_onceWrapper = function (...args) {
+			const result = wrapped.apply(this, args);
+			
+			runtime_untrackListener(this, event, listener);
+			return result;
+		};
+
+		
+		runtime_onceWrapper._slothletOriginal = listener;
+		runtime_onceWrapper._slothletResource = wrapped._slothletResource;
+
+		runtime_trackListener(this, event, listener, runtime_onceWrapper);
+		return original.call(this, event, runtime_onceWrapper);
+	};
+}
+
+
+function runtime_patchPrependListener() {
+	const original = EventEmitter.prototype.prependListener;
+	originalMethods.set("prependListener", original);
+
+	EventEmitter.prototype.prependListener = function (event, listener) {
+		
+		runtime_maybeTrackEmitter(this);
+
+		if (!runtime_shouldWrapListener(listener)) {
+			return original.call(this, event, listener);
+		}
+
+		const wrapped = runtime_wrapEventListener(listener);
+		runtime_trackListener(this, event, listener, wrapped);
+		return original.call(this, event, wrapped);
+	};
+}
+
+
+function runtime_patchPrependOnceListener() {
+	const original = EventEmitter.prototype.prependOnceListener;
+	originalMethods.set("prependOnceListener", original);
+
+	EventEmitter.prototype.prependOnceListener = function (event, listener) {
+		
+		runtime_maybeTrackEmitter(this);
+
+		if (!runtime_shouldWrapListener(listener)) {
+			return original.call(this, event, listener);
+		}
+
+		const wrapped = runtime_wrapEventListener(listener);
+
+		
+		const runtime_onceWrapper = function (...args) {
+			const result = wrapped.apply(this, args);
+			
+			runtime_untrackListener(this, event, listener);
+			return result;
+		};
+
+		
+		runtime_onceWrapper._slothletOriginal = listener;
+		runtime_onceWrapper._slothletResource = wrapped._slothletResource;
+
+		runtime_trackListener(this, event, listener, runtime_onceWrapper);
+		return original.call(this, event, runtime_onceWrapper);
+	};
+}
+
+
+function runtime_patchRemoveListener() {
+	const original = EventEmitter.prototype.removeListener;
+	originalMethods.set("removeListener", original);
+
+	EventEmitter.prototype.removeListener = function (event, listener) {
+		
+		const wrapped = runtime_getWrappedListener(this, event, listener);
+		if (wrapped) {
+			
+			const result = original.call(this, event, wrapped);
+			
+			runtime_untrackListener(this, event, listener);
+			return result;
+		}
+		
+		return original.call(this, event, listener);
+	};
+
+	
+	EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
+}
+
+
+function runtime_patchRemoveAllListeners() {
+	const original = EventEmitter.prototype.removeAllListeners;
+	originalMethods.set("removeAllListeners", original);
+
+	EventEmitter.prototype.removeAllListeners = function (event) {
+		
+		const emitterTracking = wrappedListeners.get(this);
+		if (emitterTracking) {
+			if (event === undefined) {
+				
+				for (const [____evt, eventTracking] of emitterTracking.entries()) {
+					for (const wrappedListener of eventTracking.values()) {
+						
+						wrappedListener._slothletResource = null;
+					}
+				}
+				wrappedListeners.delete(this);
+			} else {
+				
+				const eventTracking = emitterTracking.get(event);
+				if (eventTracking) {
+					for (const wrappedListener of eventTracking.values()) {
+						
+						wrappedListener._slothletResource = null;
+					}
+					emitterTracking.delete(event);
+					if (emitterTracking.size === 0) {
+						wrappedListeners.delete(this);
+					}
+				}
+			}
+		}
+
+		return original.call(this, event);
+	};
+}
+
+
+export function enableEventEmitterPatching() {
+	if (isPatchingEnabled) {
+		
+		return;
+	}
+
+	
+	runtime_patchOn();
+	runtime_patchOnce();
+	runtime_patchPrependListener();
+	runtime_patchPrependOnceListener();
+	runtime_patchRemoveListener();
+	runtime_patchRemoveAllListeners();
+
+	isPatchingEnabled = true;
+}
+
+
+export function disableEventEmitterPatching() {
+	if (!isPatchingEnabled) {
+		return;
+	}
+
+	
+	for (const [methodName, originalMethod] of originalMethods.entries()) {
+		EventEmitter.prototype[methodName] = originalMethod;
+
+		
+		if (methodName === "on") {
+			EventEmitter.prototype.addListener = originalMethod;
+		} else if (methodName === "removeListener") {
+			EventEmitter.prototype.off = originalMethod;
+		}
+	}
+
+	originalMethods.clear();
+	isPatchingEnabled = false;
+}
+
+
+export function cleanupEventEmitterResources() {
+	
+	for (const emitter of trackedEmitters) {
+		try {
+			
+			emitter.removeAllListeners();
+		} catch (____error) {
+			
+		}
+	}
+
+	
+	trackedEmitters.clear();
+	wrappedListeners.clear();
+}

package/dist/lib/helpers/hint-detector.mjs

@@ -0,0 +1,63 @@
+/*
+	Copyright 2026 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 { ComponentBase } from "@cldmv/slothlet/factories/component-base";
+
+
+const HINT_RULES = [
+	{
+		pattern: /does not provide an export named 'reference'/i,
+		hintKey: "HINT_REFERENCE_REMOVED"
+	},
+	{
+		pattern: /Cannot find module/i,
+		hintKey: "HINT_MODULE_NOT_FOUND"
+	},
+	{
+		pattern: /Unexpected token/i,
+		hintKey: "HINT_SYNTAX_ERROR"
+	}
+];
+
+
+export class HintDetector extends ComponentBase {
+	static slothletProperty = "hintDetector";
+
+	
+	detectHint(error, errorCode) {
+		
+		if (error) {
+			const errorMessage = error.message || error.toString();
+			for (const rule of HINT_RULES) {
+				if (rule.pattern.test(errorMessage)) {
+					return rule.hintKey;
+				}
+			}
+		}
+
+		
+		
+		return `HINT_${errorCode}`;
+	}
+}
+
+
+const hintDetectorInstance_standalone = new HintDetector();
+export const detectHint = hintDetectorInstance_standalone.detectHint.bind(hintDetectorInstance_standalone);

package/dist/lib/helpers/modes-utils.mjs

@@ -0,0 +1,53 @@
+/*
+	Copyright 2026 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 { ComponentBase } from "@cldmv/slothlet/factories/component-base";
+
+
+export class ModesUtils extends ComponentBase {
+	static slothletProperty = "modesUtils";
+
+	
+	ensureNamedExportFunction(fn, ____nameHint) {
+		
+		
+		return fn;
+	}
+
+	
+	cloneWrapperImpl(value, mode) {
+		if (mode !== "eager") {
+			return value;
+		}
+		if (!value || typeof value !== "object") {
+			return value;
+		}
+		if (Array.isArray(value)) {
+			return value.slice();
+		}
+		const descriptors = Object.getOwnPropertyDescriptors(value);
+		return Object.create(Object.getPrototypeOf(value), descriptors);
+	}
+
+	
+	getOwnershipCollisionMode(config, collisionContext = "initial") {
+		return config.collision?.[collisionContext] || "merge";
+	}
+}