@cldmv/slothlet 1.0.3 → 2.1.0

package/dist/lib/modes/slothlet_lazy.mjs

@@ -0,0 +1,342 @@
+/*
+	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 fs from "fs/promises";
+import path from "path";
+import { runWithCtx } from "@cldmv/slothlet/runtime";
+
+
+export async function create(dir, rootLevel = true, maxDepth = Infinity, currentDepth = 0) {
+	const instance = this; 
+	const entries = await fs.readdir(dir, { withFileTypes: true });
+	let api = {};
+	let rootDefaultFn = null;
+
+	
+	if (rootLevel) {
+		for (const entry of entries) {
+			if (instance._shouldIncludeFile(entry)) {
+				const ext = path.extname(entry.name);
+				const fileName = path.basename(entry.name, ext);
+				const apiKey = instance._toApiKey(fileName);
+				const mod = await instance._loadSingleModule(path.join(dir, entry.name), true);
+				if (mod && typeof mod.default === "function") {
+					if (!rootDefaultFn) rootDefaultFn = mod.default;
+					for (const [k, v] of Object.entries(mod)) {
+						if (k !== "default") api[k] = v;
+					}
+				} else {
+					api[apiKey] = mod;
+				}
+			}
+		}
+	}
+
+	
+	if (rootDefaultFn) {
+		Object.assign(rootDefaultFn, api);
+		api = rootDefaultFn;
+	}
+
+	
+	for (const entry of entries) {
+		if (entry.isDirectory() && !entry.name.startsWith(".") && currentDepth < maxDepth) {
+			const key = instance._toApiKey(entry.name);
+			const subDirPath = path.join(dir, entry.name);
+			const parent = api;
+			const depth = 1; 
+			const proxy = createFolderProxy({
+				subDirPath,
+				key,
+				parent,
+				instance,
+				depth,
+				maxDepth,
+				pathParts: [key]
+			});
+			parent[key] = proxy;
+		}
+	}
+
+	return api;
+}
+
+
+function replacePlaceholder(parent, key, placeholder, value, instance, depth) {
+	if (!parent || !key) return;
+	if (parent[key] !== placeholder) return; 
+
+	
+	let finalKey = key;
+	if (typeof value === "function" && value.name && value.name.toLowerCase() === key.toLowerCase() && value.name !== key) {
+		
+		finalKey = value.name;
+
+		
+		if (finalKey !== key && key in parent) {
+			try {
+				delete parent[key];
+			} catch {
+				
+			}
+		}
+	}
+
+	try {
+		Object.defineProperty(parent, finalKey, { value, writable: true, enumerable: true, configurable: true });
+	} catch {
+		parent[finalKey] = value; 
+	}
+	if (instance?.config?.debug) {
+		console.log(`[lazy][materialize] replaced ${key}${finalKey !== key ? ` -> ${finalKey}` : ""} (${typeof value})`);
+	}
+	if (depth === 1 && typeof instance?.updateBoundApiProperty === "function") {
+		instance.updateBoundApiProperty(finalKey, parent[finalKey]);
+	}
+}
+
+
+function createFolderProxy({ subDirPath, key, parent, instance, depth, maxDepth, pathParts }) {
+	let materialized = null;
+	let inFlight = null;
+
+	
+	async function _materialize() {
+		if (materialized) return materialized;
+		if (inFlight) return inFlight;
+		
+		
+		const lazy_materializeCategory = async () => {
+			const value = await instance._buildCategory(subDirPath, {
+				currentDepth: depth,
+				maxDepth,
+				mode: "lazy",
+				subdirHandler: ({ subDirPath: nestedPath, key: nestedKey, categoryModules, currentDepth: cd, maxDepth: md }) =>
+					createFolderProxy({
+						subDirPath: nestedPath,
+						key: nestedKey,
+						parent: categoryModules,
+						instance,
+						depth: cd + 1,
+						maxDepth: md,
+						pathParts: [...pathParts, nestedKey]
+					})
+			});
+			materialized = value;
+			if (instance?.config?.debug) {
+				try {
+					const infoKeys = materialized && typeof materialized === "object" ? Object.keys(materialized) : [];
+					const todayType = materialized && materialized.today ? typeof materialized.today : "n/a";
+					console.log(
+						`[lazy][debug] materialized key='${key}' path='${subDirPath}' type=${typeof materialized} keys=${JSON.stringify(
+							infoKeys
+						)} todayType=${todayType}`
+					);
+				} catch {
+					
+				}
+			}
+			
+			replacePlaceholder(parent, key, placeholder, materialized, instance, depth);
+			
+			if (instance.config.debug) {
+				try {
+					const type = typeof materialized;
+					const keys = type === "object" && materialized ? Object.keys(materialized) : [];
+					console.log(
+						`[lazy][debug] materialized '${pathParts.join("/")}' -> type=${type} keys=${JSON.stringify(keys)} parentHas=${
+							parent[key] === materialized
+						}`
+					);
+				} catch {
+					
+				}
+			}
+			placeholder.__materialized = materialized;
+			return materialized;
+		};
+		inFlight = lazy_materializeCategory();
+		try {
+			return await inFlight;
+		} finally {
+			inFlight = null;
+		}
+	}
+
+	
+	async function lazy_invoke(thisArg, ...args) {
+		const value = await _materialize();
+		if (typeof value === "function") {
+			
+			const ctx = instance.boundapi?.__ctx;
+			if (ctx) {
+				return runWithCtx(ctx, value, thisArg, args);
+			} else {
+				return value.apply(thisArg, args);
+			}
+		}
+		
+		
+		return value;
+	}
+
+	
+	
+	function lazy_lazyTarget(...args) {
+		return lazy_invoke(this, ...args);
+	}
+	
+	Object.defineProperty(lazy_lazyTarget, "__materialized", { value: null, writable: true, enumerable: false, configurable: true });
+	
+	Object.defineProperty(lazy_lazyTarget, "__slothletPath", { value: subDirPath, enumerable: false, configurable: true });
+	
+	Object.defineProperty(lazy_lazyTarget, "_materialize", { value: _materialize, enumerable: false, configurable: true, writable: true });
+
+	
+	try {
+		Object.defineProperty(lazy_lazyTarget, "name", { value: `lazyFolder_${key}`, configurable: true });
+	} catch {
+		
+	}
+
+	const placeholder = new Proxy(lazy_lazyTarget, {
+		apply(_t, thisArg, args) {
+			return lazy_invoke(thisArg, ...args);
+		},
+		get(_t, prop, _) {
+			if (prop === "__materialized") return materialized;
+			if (prop === "_materialize") return _materialize;
+			if (prop === "then") return undefined; 
+			
+			if (materialized) {
+				if (materialized && (typeof materialized === "object" || typeof materialized === "function")) return materialized[prop];
+				return undefined;
+			}
+			
+			if (!inFlight) inFlight = _materialize();
+			
+			
+			
+			
+			return new Proxy(
+				
+				function lazy_propertyAccessor(...args) {
+					return inFlight.then(
+						
+						function lazy_handleResolvedValue(resolved) {
+							const value = resolved ? resolved[prop] : undefined;
+							if (typeof value === "function") {
+								
+								const ctx = instance.boundapi?.__ctx;
+								if (ctx) {
+									return runWithCtx(ctx, value, this, args);
+								} else {
+									return value.apply(this, args);
+								}
+							}
+							return value;
+						}
+					);
+				},
+				{
+					
+					get(target, subProp) {
+						if (subProp === "name") return `lazy_${prop}`;
+						if (subProp === "length") return 0;
+						
+						return new Proxy(
+							 function lazy_deepPropertyAccessor() {},
+							{
+								apply(target, thisArg, args) {
+									
+									if (materialized) {
+										const value = materialized[prop];
+										if (value && typeof value[subProp] === "function") {
+											
+											const ctx = instance.boundapi?.__ctx;
+											if (ctx) {
+												return runWithCtx(ctx, value[subProp], thisArg, args);
+											} else {
+												return value[subProp].apply(thisArg, args);
+											}
+										}
+										return value ? value[subProp] : undefined;
+									}
+
+									
+									if (!inFlight) inFlight = _materialize();
+									return inFlight.then(
+										
+										function lazy_handleDeepResolvedValue(resolved) {
+											const value = resolved ? resolved[prop] : undefined;
+											if (value && typeof value[subProp] === "function") {
+												
+												const ctx = instance.boundapi?.__ctx;
+												if (ctx) {
+													return runWithCtx(ctx, value[subProp], thisArg, args);
+												} else {
+													return value[subProp].apply(thisArg, args);
+												}
+											}
+											return value ? value[subProp] : undefined;
+										}
+									);
+								}
+							}
+						);
+					}
+				}
+			);
+		},
+		has(_t, prop) {
+			if (materialized && (typeof materialized === "object" || typeof materialized === "function")) return prop in materialized;
+			return false;
+		},
+		ownKeys() {
+			const baseKeys = Reflect.ownKeys(lazy_lazyTarget); 
+			if (!materialized) return baseKeys;
+			if (typeof materialized === "object" || typeof materialized === "function") {
+				const matKeys = Reflect.ownKeys(materialized);
+				return Array.from(new Set([...baseKeys, ...matKeys]));
+			}
+			return baseKeys;
+		},
+		getOwnPropertyDescriptor(_t, prop) {
+			if (prop === "_materialize") {
+				
+				return Reflect.getOwnPropertyDescriptor(lazy_lazyTarget, "_materialize");
+			}
+			if (prop === "__materialized") {
+				return { configurable: true, enumerable: false, writable: true, value: materialized };
+			}
+			if (prop === "prototype") {
+				
+				return Object.getOwnPropertyDescriptor(lazy_lazyTarget, "prototype");
+			}
+			if (materialized && (typeof materialized === "object" || typeof materialized === "function")) {
+				const d = Object.getOwnPropertyDescriptor(materialized, prop);
+				if (d) return { ...d, configurable: true };
+			}
+			
+			const td = Object.getOwnPropertyDescriptor(lazy_lazyTarget, prop);
+			if (td) return { ...td, configurable: true };
+			return undefined;
+		}
+	});
+
+	return placeholder;
+}

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");