@cldmv/slothlet 2.10.0 → 3.0.0

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

@@ -1,256 +0,0 @@
-/*
-	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 { AsyncResource, AsyncLocalStorage } from "node:async_hooks";
-import { EventEmitter } from "node:events";
-
-
-const defaultALS = new AsyncLocalStorage();
-
-
-let originalMethods = null;
-
-
-const globalResourceSet = new Set();
-
-
-
-const globalListenerTracker = new WeakMap(); 
-const allPatchedListeners = new Set(); 
-
-
-export function enableAlsForEventEmitters(als = defaultALS) {
-	
-	const kPatched = Symbol.for("slothlet.als.patched");
-
-	if (EventEmitter.prototype[kPatched]) return;
-	EventEmitter.prototype[kPatched] = true;
-
-	
-	const kMap = Symbol("slothlet.als.listenerMap");
-
-	
-	function runtime_ensureMap(emitter) {
-		if (!emitter[kMap]) emitter[kMap] = new WeakMap();
-		return emitter[kMap];
-	}
-
-	
-	function runtime_wrapListener(listener) {
-		
-		const store = als.getStore();
-		if (!store) return listener;
-
-		
-		const resource = new AsyncResource("slothlet-als-listener");
-
-		
-		globalResourceSet.add(resource);
-
-		
-		const runtime_wrappedListener = function (...args) {
-			return resource.runInAsyncScope(
-				() => {
-					return listener.apply(this, args);
-				},
-				this,
-				...args
-			);
-		};
-
-		
-		runtime_wrappedListener._slothletResource = resource;
-
-		return runtime_wrappedListener;
-	}
-
-	const proto = EventEmitter.prototype;
-
-	
-	const origOn = proto.on;
-	const origOnce = proto.once;
-	const origAdd = proto.addListener;
-	const origPre = proto.prependListener;
-	const origPreO = proto.prependOnceListener;
-	const origOff = proto.off ?? proto.removeListener;
-	const origRem = proto.removeListener;
-
-	
-	function runtime_installWrapper(addFnName, orig) {
-		proto[addFnName] = function (event, listener) {
-			const map = runtime_ensureMap(this);
-			const wrapped = runtime_wrapListener(listener);
-
-			
-			
-			if (!globalListenerTracker.has(this)) {
-				globalListenerTracker.set(this, new Set());
-			}
-			const listenerInfo = {
-				emitter: this,
-				event,
-				originalListener: listener,
-				wrappedListener: wrapped,
-				addMethod: addFnName
-			};
-			globalListenerTracker.get(this).add(listenerInfo);
-			allPatchedListeners.add(listenerInfo);
-
-			if (wrapped !== listener) map.set(listener, wrapped);
-			return orig.call(this, event, wrapped);
-		};
-	}
-
-	
-	runtime_installWrapper("on", origOn);
-	runtime_installWrapper("once", origOnce);
-	runtime_installWrapper("addListener", origAdd);
-	if (origPre) runtime_installWrapper("prependListener", origPre);
-	if (origPreO) runtime_installWrapper("prependOnceListener", origPreO);
-
-	
-	function runtime_createRemoveWrapper(method) {
-		
-		const runtime_removeWrapper = function (event, listener) {
-			const map = runtime_ensureMap(this);
-			const wrapped = map.get(listener) || listener;
-
-			
-			if (globalListenerTracker.has(this)) {
-				const emitterListeners = globalListenerTracker.get(this);
-				for (const info of emitterListeners) {
-					if (info.originalListener === listener || info.wrappedListener === wrapped) {
-						emitterListeners.delete(info);
-						allPatchedListeners.delete(info);
-						break;
-					}
-				}
-			}
-
-			
-			if (wrapped && wrapped._slothletResource) {
-				const resource = wrapped._slothletResource;
-				globalResourceSet.delete(resource);
-				try {
-					resource.emitDestroy();
-				} catch (_) {
-					
-				}
-			}
-
-			map.delete(listener);
-			return method.call(this, event, wrapped);
-		};
-
-		return runtime_removeWrapper;
-	}
-
-	
-	if (proto.off) proto.off = runtime_createRemoveWrapper(origOff);
-	proto.removeListener = runtime_createRemoveWrapper(origRem);
-
-	
-	const origRemoveAll = proto.removeAllListeners;
-	proto.removeAllListeners = function (event) {
-		const res = origRemoveAll.call(this, event);
-		if (this[kMap]) this[kMap] = new WeakMap();
-		return res;
-	};
-
-	
-	if (!originalMethods) {
-		originalMethods = {
-			on: origOn,
-			once: origOnce,
-			addListener: origAdd,
-			prependListener: origPre,
-			prependOnceListener: origPreO,
-			off: origOff,
-			removeListener: origRem,
-			removeAllListeners: origRemoveAll
-		};
-	}
-}
-
-
-
-export function cleanupAllSlothletListeners() {
-	let cleanedCount = 0;
-	let errorCount = 0;
-
-	
-	for (const listenerInfo of allPatchedListeners) {
-		try {
-			const { emitter, event, wrappedListener } = listenerInfo;
-			if (emitter && typeof emitter.removeListener === "function") {
-				emitter.removeListener(event, wrappedListener);
-				cleanedCount++;
-			}
-		} catch (_) {
-			errorCount++;
-			
-		}
-	}
-
-	
-	allPatchedListeners.clear();
-	
-
-	if (process.env.SLOTHLET_DEBUG === "1" || process.env.SLOTHLET_DEBUG === "true") {
-		console.log(`[slothlet] Cleaned up ${cleanedCount} listeners (${errorCount} errors)`);
-	}
-}
-
-export function disableAlsForEventEmitters() {
-	const kPatched = Symbol.for("slothlet.als.patched");
-
-	if (!EventEmitter.prototype[kPatched] || !originalMethods) return;
-
-	
-	cleanupAllSlothletListeners();
-
-	
-	for (const resource of globalResourceSet) {
-		try {
-			resource.emitDestroy();
-		} catch (err) {
-			
-			console.warn("[slothlet] AsyncResource cleanup warning:", err.message);
-		}
-	}
-	globalResourceSet.clear();
-
-	
-	const proto = EventEmitter.prototype;
-	proto.on = originalMethods.on;
-	proto.once = originalMethods.once;
-	proto.addListener = originalMethods.addListener;
-	if (originalMethods.prependListener) proto.prependListener = originalMethods.prependListener;
-	if (originalMethods.prependOnceListener) proto.prependOnceListener = originalMethods.prependOnceListener;
-	if (originalMethods.off) proto.off = originalMethods.off;
-	proto.removeListener = originalMethods.removeListener;
-	proto.removeAllListeners = originalMethods.removeAllListeners;
-
-	
-	delete EventEmitter.prototype[kPatched];
-
-	
-	originalMethods = null;
-}

package/dist/lib/helpers/api_builder/add_api.mjs

@@ -1,292 +0,0 @@
-/*
-	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 fs from "node:fs/promises";
-import path from "node:path";
-import { resolvePathFromCaller } from "@cldmv/slothlet/helpers/resolve-from-caller";
-import { cleanMetadata, tagLoadedFunctions } from "./metadata.mjs";
-
-
-export async function addApiFromFolder({ apiPath, folderPath, instance, metadata = {} }) {
-	if (!instance.loaded) {
-		throw new Error("[slothlet] Cannot add API: API not loaded. Call create() or load() first.");
-	}
-
-	
-	if (typeof apiPath !== "string") {
-		throw new TypeError("[slothlet] addApi: 'apiPath' must be a string.");
-	}
-	const normalizedApiPath = apiPath.trim();
-	if (normalizedApiPath === "") {
-		throw new TypeError("[slothlet] addApi: 'apiPath' must be a non-empty, non-whitespace string.");
-	}
-	const pathParts = normalizedApiPath.split(".");
-	if (pathParts.some((part) => part === "")) {
-		throw new Error(`[slothlet] addApi: 'apiPath' must not contain empty segments. Received: "${normalizedApiPath}"`);
-	}
-
-	
-	if (typeof folderPath !== "string") {
-		throw new TypeError("[slothlet] addApi: 'folderPath' must be a string.");
-	}
-
-	
-	
-	
-	let resolvedFolderPath = folderPath;
-	const isAbsolute = path.isAbsolute(folderPath);
-
-	if (instance.config.debug) {
-		console.log(`[DEBUG] addApi: folderPath="${folderPath}"`);
-		console.log(`[DEBUG] addApi: isAbsolute=${isAbsolute}`);
-	}
-
-	if (!isAbsolute) {
-		resolvedFolderPath = resolvePathFromCaller(folderPath);
-		if (instance.config.debug) {
-			console.log(`[DEBUG] addApi: Resolved relative path to: ${resolvedFolderPath}`);
-		}
-	}
-
-	
-	let stats;
-	try {
-		stats = await fs.stat(resolvedFolderPath);
-	} catch (error) {
-		throw new Error(`[slothlet] addApi: Cannot access folder: ${resolvedFolderPath} - ${error.message}`);
-	}
-	if (!stats.isDirectory()) {
-		throw new Error(`[slothlet] addApi: Path is not a directory: ${resolvedFolderPath}`);
-	}
-
-	if (instance.config.debug) {
-		console.log(`[DEBUG] addApi: Loading modules from ${resolvedFolderPath} to path: ${normalizedApiPath}`);
-	}
-
-	
-	let newModules;
-	if (instance.config.lazy) {
-		
-		newModules = await instance.modes.lazy.create.call(instance, resolvedFolderPath, instance.config.apiDepth || Infinity, 0);
-	} else {
-		
-		newModules = await instance.modes.eager.create.call(instance, resolvedFolderPath, instance.config.apiDepth || Infinity, 0);
-	}
-
-	
-	
-	
-	if (newModules && metadata && typeof metadata === "object" && Object.keys(metadata).length > 0) {
-		
-		const fullMetadata = {
-			...metadata,
-			sourceFolder: resolvedFolderPath
-		};
-
-		if (instance.config.debug) {
-			console.log(`[DEBUG] addApi: Tagging functions with metadata:`, Object.keys(fullMetadata));
-		}
-
-		tagLoadedFunctions(newModules, fullMetadata, resolvedFolderPath);
-	} else if (newModules) {
-		
-		if (instance.config.debug) {
-			console.log(`[DEBUG] addApi: Cleaning metadata from functions (no metadata provided)`);
-		}
-		cleanMetadata(newModules);
-	}
-
-	if (instance.config.debug) {
-		if (newModules && typeof newModules === "object") {
-			console.log(`[DEBUG] addApi: Loaded modules:`, Object.keys(newModules));
-		} else {
-			console.log(
-				`[DEBUG] addApi: Loaded modules (non-object):`,
-				typeof newModules === "function" ? `[Function: ${newModules.name || "anonymous"}]` : newModules
-			);
-		}
-	}
-
-	
-	let currentTarget = instance.api;
-	let currentBoundTarget = instance.boundapi;
-
-	for (let i = 0; i < pathParts.length - 1; i++) {
-		const part = pathParts[i];
-		const key = instance._toapiPathKey(part);
-
-		
-		
-		
-		if (Object.prototype.hasOwnProperty.call(currentTarget, key)) {
-			const existing = currentTarget[key];
-			if (existing === null || (typeof existing !== "object" && typeof existing !== "function")) {
-				throw new Error(
-					`[slothlet] Cannot extend API path "${normalizedApiPath}" through segment "${part}": ` +
-						`existing value is type "${typeof existing}", cannot add properties.`
-				);
-			}
-			
-			
-		} else {
-			currentTarget[key] = {};
-		}
-		if (Object.prototype.hasOwnProperty.call(currentBoundTarget, key)) {
-			const existingBound = currentBoundTarget[key];
-			if (existingBound === null || (typeof existingBound !== "object" && typeof existingBound !== "function")) {
-				throw new Error(
-					`[slothlet] Cannot extend bound API path "${normalizedApiPath}" through segment "${part}": ` +
-						`existing value is type "${typeof existingBound}", cannot add properties.`
-				);
-			}
-			
-		} else {
-			currentBoundTarget[key] = {};
-		}
-
-		
-		currentTarget = currentTarget[key];
-		currentBoundTarget = currentBoundTarget[key];
-	}
-
-	
-	const finalKey = instance._toapiPathKey(pathParts[pathParts.length - 1]);
-
-	
-	if (typeof newModules === "function") {
-		
-		
-		if (Object.prototype.hasOwnProperty.call(currentTarget, finalKey)) {
-			const existing = currentTarget[finalKey];
-
-			
-			if (instance.config.allowApiOverwrite === false) {
-				console.warn(
-					`[slothlet] Skipping addApi: API path "${normalizedApiPath}" final key "${finalKey}" ` +
-						`already exists (type: "${typeof existing}"). Set allowApiOverwrite: true to allow overwrites.`
-				);
-				return; 
-			}
-
-			
-			if (existing !== null && typeof existing !== "function") {
-				console.warn(
-					`[slothlet] Overwriting existing non-function value at API path "${normalizedApiPath}" ` +
-						`final key "${finalKey}" with a function. Previous type: "${typeof existing}".`
-				);
-			} else if (typeof existing === "function") {
-				
-				console.warn(
-					`[slothlet] Overwriting existing function at API path "${normalizedApiPath}" ` + `final key "${finalKey}" with a new function.`
-				);
-			}
-		}
-		currentTarget[finalKey] = newModules;
-		currentBoundTarget[finalKey] = newModules;
-	} else if (typeof newModules === "object" && newModules !== null) {
-		
-		if (Object.prototype.hasOwnProperty.call(currentTarget, finalKey)) {
-			const existing = currentTarget[finalKey];
-
-			
-			if (instance.config.allowApiOverwrite === false && existing !== undefined && existing !== null) {
-				
-				const hasContent = typeof existing === "object" ? Object.keys(existing).length > 0 : true;
-				if (hasContent) {
-					console.warn(
-						`[slothlet] Skipping addApi merge: API path "${normalizedApiPath}" final key "${finalKey}" ` +
-							`already exists with content (type: "${typeof existing}"). Set allowApiOverwrite: true to allow merging.`
-					);
-					return; 
-				}
-			}
-
-			if (existing !== null && typeof existing !== "object" && typeof existing !== "function") {
-				throw new Error(
-					`[slothlet] Cannot merge API at "${normalizedApiPath}": ` +
-						`existing value at final key "${finalKey}" is type "${typeof existing}", cannot merge into primitives.`
-				);
-			}
-		}
-		if (Object.prototype.hasOwnProperty.call(currentBoundTarget, finalKey)) {
-			const existingBound = currentBoundTarget[finalKey];
-			if (existingBound !== null && typeof existingBound !== "object" && typeof existingBound !== "function") {
-				throw new Error(
-					`[slothlet] Cannot merge bound API at "${normalizedApiPath}": ` +
-						`existing value at final key "${finalKey}" is type "${typeof existingBound}", cannot merge into primitives.`
-				);
-			}
-		}
-
-		
-		
-		
-		const targetValue = currentTarget[finalKey];
-		if (typeof targetValue === "function" && targetValue.__slothletPath) {
-			
-			
-			const _ = targetValue.__trigger; 
-			await targetValue(); 
-			
-		}
-
-		const boundTargetValue = currentBoundTarget[finalKey];
-		if (typeof boundTargetValue === "function" && boundTargetValue.__slothletPath) {
-			
-			const _ = boundTargetValue.__trigger;
-			await boundTargetValue();
-		}
-
-		
-		if (!currentTarget[finalKey]) {
-			currentTarget[finalKey] = {};
-		}
-		if (!currentBoundTarget[finalKey]) {
-			currentBoundTarget[finalKey] = {};
-		}
-
-		
-		
-		
-		
-		
-		Object.assign(currentTarget[finalKey], newModules);
-		Object.assign(currentBoundTarget[finalKey], newModules);
-	} else if (newModules === null || newModules === undefined) {
-		
-		const receivedType = newModules === null ? "null" : "undefined";
-		console.warn(
-			`[slothlet] addApi: No modules loaded from folder at API path "${normalizedApiPath}". ` +
-				`Loaded modules resulted in ${receivedType}. Check that the folder contains valid module files.`
-		);
-	} else {
-		
-		
-		currentTarget[finalKey] = newModules;
-		currentBoundTarget[finalKey] = newModules;
-	}
-
-	
-	instance.updateBindings(instance.context, instance.reference, instance.boundapi);
-
-	if (instance.config.debug) {
-		console.log(`[DEBUG] addApi: Successfully added modules at ${normalizedApiPath}`);
-	}
-}