@cldmv/slothlet 1.0.3 → 2.1.0

package/dist/lib/helpers/resolve-from-caller.mjs

@@ -0,0 +1,141 @@
+/*
+	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 "node:fs";
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+
+
+
+export const toFsPath = (v) => (v && String(v).startsWith("file://") ? fileURLToPath(String(v)) : v ? String(v) : null);
+
+
+export function getStack(skipFn) {
+	const orig = Error.prepareStackTrace;
+	try {
+		Error.prepareStackTrace = (_, s) => s; 
+		const e = new Error("Stack trace");
+		if (skipFn) Error.captureStackTrace(e, skipFn);
+		return e.stack || [];
+	} finally {
+		Error.prepareStackTrace = orig;
+	}
+}
+
+const THIS_FILE = fileURLToPath(import.meta.url);
+const THIS_DIR = path.dirname(THIS_FILE);
+
+
+
+
+
+
+
+
+function pickPrimaryBaseFile() {
+	const files = [];
+	for (const cs of getStack(pickPrimaryBaseFile)) {
+		const f = toFsPath(cs?.getFileName?.());
+		if (!f) continue;
+		if (f.startsWith?.("node:internal")) continue;
+		files.push(f);
+	}
+
+	let iSloth = -1;
+	for (let i = 0; i < files.length; i++) {
+		if (path.basename(files[i]).toLowerCase() === "slothlet.mjs") iSloth = i;
+	}
+	if (iSloth !== -1) {
+		const j = iSloth + 1;
+		if (j < files.length) {
+			const b = path.basename(files[j]).toLowerCase();
+			if (/^index\.(mjs|cjs|js)$/.test(b) && j + 1 < files.length) return files[j + 1];
+			return files[j];
+		}
+	}
+	return null;
+}
+
+
+function pickFallbackBaseFile() {
+	for (const cs of getStack(pickFallbackBaseFile)) {
+		const f = toFsPath(cs?.getFileName?.());
+		if (!f) continue;
+		if (f.startsWith?.("node:internal")) continue;
+		if (f === THIS_FILE) continue;
+		if (f.startsWith(THIS_DIR + path.sep)) continue; 
+		if (path.basename(f).toLowerCase() === "slothlet.mjs") continue;
+		return f;
+	}
+	return THIS_FILE;
+}
+
+
+
+
+function resolveWith(rel, makePrimary, exists, makeFallback) {
+	if (typeof rel !== "string") throw new TypeError("rel must be a string");
+
+	
+	const primaryBase = pickPrimaryBaseFile() ?? pickFallbackBaseFile();
+	const primary = makePrimary(primaryBase, rel);
+	if (exists(primary)) return primary;
+
+	const fbBase = pickFallbackBaseFile();
+	return makeFallback(fbBase, rel);
+}
+
+
+
+
+export function resolvePathFromCaller(rel) {
+	
+	if (rel.startsWith?.("file://")) return fileURLToPath(rel);
+	if (path.isAbsolute(rel)) return rel;
+
+	return resolveWith(
+		rel,
+		
+		(baseFile, r) => path.resolve(path.dirname(baseFile), r),
+		
+		(candidate) => fs.existsSync(candidate),
+		
+		(baseFile, r) => path.resolve(path.dirname(baseFile), r)
+	);
+}
+
+
+export function resolveUrlFromCaller(rel) {
+	
+	if (rel.startsWith?.("file://")) return rel;
+	if (path.isAbsolute(rel)) return pathToFileURL(rel).href;
+
+	return resolveWith(
+		rel,
+		
+		(baseFile, r) => new URL(r, pathToFileURL(baseFile)).href,
+		
+		(href) => fs.existsSync(fileURLToPath(href)),
+		
+		(baseFile, r) => new URL(r, pathToFileURL(baseFile)).href
+	);
+}
+
+

package/dist/lib/helpers/sanitize.mjs

@@ -0,0 +1,265 @@
+/*
+	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.
+*/
+
+
+
+
+function globToRegex(pattern, caseSensitive = true) {
+	try {
+		
+		if (pattern.startsWith("**") && pattern.endsWith("**") && pattern.length > 4) {
+			const innerString = pattern.slice(2, -2);
+			
+			const escapedString = innerString.replace(/[.+^${}()|[\]\\*?]/g, "\\$&");
+			
+			
+			const flags = caseSensitive ? "" : "i";
+			return new RegExp(`(?<=.)${escapedString}(?=.)`, flags);
+		}
+
+		
+		
+		let regexPattern = pattern
+			.replace(/[.+^${}()|[\]\\]/g, "\\$&")
+			.replace(/\*/g, ".*")
+			.replace(/\?/g, ".");
+
+		const flags = caseSensitive ? "" : "i";
+		return new RegExp(`^${regexPattern}$`, flags);
+	} catch (_) {
+		return null;
+	}
+}
+
+
+export function sanitizePathName(input, opts = {}) {
+	const { lowerFirst = true, rules = {} } = opts;
+
+	const leaveRules = (rules.leave || []).map((s) => String(s));
+	const leaveInsensitiveRules = (rules.leaveInsensitive || []).map((s) => String(s));
+	const upperRules = (rules.upper || []).map((s) => String(s));
+	const lowerRules = (rules.lower || []).map((s) => String(s));
+
+	let s = String(input).trim();
+
+	
+	
+
+	
+	let parts = s.split(/[^A-Za-z0-9_$]+/).filter(Boolean);
+	if (parts.length === 0) return "_";
+
+	
+	while (parts.length && !/^[A-Za-z_$]/.test(parts[0][0])) {
+		parts[0] = parts[0].replace(/^[^A-Za-z_$]+/, "");
+		if (!parts[0]) parts.shift();
+	}
+	if (parts.length === 0) return "_";
+
+	
+	const segmentMatchesPreSplitPattern = (segment, patterns, caseSensitive = false) => {
+		for (const pattern of patterns) {
+			
+			
+			
+
+			if (pattern.includes("*") || pattern.includes("?")) {
+				const regex = globToRegex(pattern, caseSensitive);
+				if (regex && regex.test(s)) {
+					
+					
+					const literalParts = pattern.split(/[*?]+/).filter(Boolean);
+
+					for (const literal of literalParts) {
+						
+						const cleanLiteral = literal.replace(/[^A-Za-z0-9_$]/g, "");
+						if (cleanLiteral) {
+							const match = caseSensitive ? segment === cleanLiteral : segment.toLowerCase() === cleanLiteral.toLowerCase();
+							if (match) {
+								return true;
+							}
+						}
+					}
+				}
+			} else {
+				
+				const match = caseSensitive ? segment === pattern : segment.toLowerCase() === pattern.toLowerCase();
+				if (match) {
+					return true;
+				}
+			}
+		}
+		return false;
+	};
+
+	const applyRule = (seg, index) => {
+		
+		if (segmentMatchesPreSplitPattern(seg, leaveRules, true)) {
+			return seg;
+		}
+
+		
+		if (segmentMatchesPreSplitPattern(seg, leaveInsensitiveRules, false)) {
+			return seg;
+		}
+
+		
+		if (segmentMatchesPreSplitPattern(seg, upperRules, false)) {
+			return seg.toUpperCase();
+		}
+
+		
+		if (segmentMatchesPreSplitPattern(seg, lowerRules, false)) {
+			return seg.toLowerCase();
+		}
+
+		
+		let transformedSeg = seg;
+
+		
+		for (const pattern of upperRules) {
+			if (pattern.includes("*") || pattern.includes("?")) {
+				
+				if (!segmentMatchesPreSplitPattern(seg, [pattern], false)) {
+					
+					if (pattern.startsWith("**") && pattern.endsWith("**") && pattern.length > 4) {
+						const innerString = pattern.slice(2, -2);
+						
+						
+						const innerRegex = new RegExp(innerString.replace(/[.+^${}()|[\]\\*?]/g, "\\$&"), "gi");
+
+						
+						const matches = [...transformedSeg.matchAll(innerRegex)];
+						for (const match of matches) {
+							const startPos = match.index;
+							const endPos = startPos + match[0].length;
+
+							
+							const hasCharBefore = startPos > 0;
+							const hasCharAfter = endPos < transformedSeg.length;
+
+							if (hasCharBefore && hasCharAfter) {
+								
+								transformedSeg = transformedSeg.substring(0, startPos) + innerString.toUpperCase() + transformedSeg.substring(endPos);
+								break; 
+							}
+						}
+					} else {
+						
+						const literalParts = pattern.split(/[*?]+/).filter(Boolean);
+						for (const literal of literalParts) {
+							if (literal) {
+								
+								const literalRegex = new RegExp(literal.replace(/[.+^${}()|[\]\\]/g, "\\$&"), "gi");
+								transformedSeg = transformedSeg.replace(literalRegex, literal.toUpperCase());
+							}
+						}
+					}
+				}
+			}
+		}
+
+		
+		for (const pattern of lowerRules) {
+			if (pattern.includes("*") || pattern.includes("?")) {
+				
+				if (!segmentMatchesPreSplitPattern(seg, [pattern], false)) {
+					
+					if (pattern.startsWith("**") && pattern.endsWith("**") && pattern.length > 4) {
+						const innerString = pattern.slice(2, -2);
+						
+						
+						const innerRegex = new RegExp(innerString.replace(/[.+^${}()|[\]\\*?]/g, "\\$&"), "gi");
+
+						
+						const matches = [...transformedSeg.matchAll(innerRegex)];
+						for (const match of matches) {
+							const startPos = match.index;
+							const endPos = startPos + match[0].length;
+
+							
+							const hasCharBefore = startPos > 0;
+							const hasCharAfter = endPos < transformedSeg.length;
+
+							if (hasCharBefore && hasCharAfter) {
+								
+								transformedSeg = transformedSeg.substring(0, startPos) + innerString.toLowerCase() + transformedSeg.substring(endPos);
+								break; 
+							}
+						}
+					} else {
+						
+						const literalParts = pattern.split(/[*?]+/).filter(Boolean);
+						for (const literal of literalParts) {
+							if (literal) {
+								const literalRegex = new RegExp(literal.replace(/[.+^${}()|[\]\\]/g, "\\$&"), "gi");
+								transformedSeg = transformedSeg.replace(literalRegex, literal.toLowerCase());
+							}
+						}
+					}
+				}
+			}
+		}
+
+		
+		
+		for (const pattern of upperRules) {
+			if (!pattern.includes("*") && !pattern.includes("?")) {
+				
+				const match = seg.toLowerCase() === pattern.toLowerCase();
+				if (match) {
+					return seg.toUpperCase();
+				}
+			}
+		}
+
+		
+		for (const pattern of lowerRules) {
+			if (!pattern.includes("*") && !pattern.includes("?")) {
+				
+				const match = seg.toLowerCase() === pattern.toLowerCase();
+				if (match) {
+					return seg.toLowerCase();
+				}
+			}
+		}
+
+		
+		if (transformedSeg !== seg) {
+			return transformedSeg;
+		}
+
+		
+		if (index === 0) {
+			
+			return lowerFirst ? seg[0].toLowerCase() + seg.slice(1) : seg;
+		}
+		
+		return seg[0].toUpperCase() + seg.slice(1);
+	};
+
+	
+	let out = parts.map((seg, i) => applyRule(seg.replace(/[^A-Za-z0-9_$]/g, ""), i)).join("");
+
+	
+	out = out.replace(/[^A-Za-z0-9_$]/g, "");
+	if (!out || !/^[A-Za-z_$]/.test(out[0])) out = "_" + out;
+
+	return out;
+}
+
+
+

package/dist/lib/modes/slothlet_eager.mjs

@@ -0,0 +1,80 @@
+/*
+	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";
+
+
+
+
+
+
+export async function create(dir, rootLevel = true, maxDepth = Infinity, currentDepth = 0) {
+	
+	const entries = await fs.readdir(dir, { withFileTypes: true });
+	const api = {};
+	
+	const rootNamedExports = {};
+	
+	let rootDefaultFunction = null;
+
+	if (rootLevel) {
+		for (const entry of entries) {
+			if (this._shouldIncludeFile(entry)) {
+				const ext = path.extname(entry.name);
+				const fileName = path.basename(entry.name, ext);
+				const apiKey = this._toApiKey(fileName);
+				const mod = await this._loadSingleModule(path.join(dir, entry.name), true);
+				if (mod && typeof mod.default === "function") {
+					if (!rootDefaultFunction) rootDefaultFunction = mod.default;
+					for (const [key, value] of Object.entries(mod)) {
+						if (key !== "default") api[key] = value;
+					}
+				} else {
+					api[apiKey] = mod;
+					for (const [key, value] of Object.entries(mod)) {
+						rootNamedExports[key] = value;
+					}
+				}
+			}
+		}
+	}
+
+	for (const entry of entries) {
+		if (entry.isDirectory() && !entry.name.startsWith(".") && currentDepth < maxDepth) {
+			const categoryPath = path.join(dir, entry.name);
+			api[this._toApiKey(entry.name)] = await this._loadCategory(categoryPath, currentDepth + 1, maxDepth);
+		}
+	}
+
+	let finalApi;
+	if (rootDefaultFunction) {
+		Object.assign(rootDefaultFunction, api);
+		finalApi = rootDefaultFunction;
+	} else {
+		finalApi = api;
+	}
+
+	
+	
+	
+
+	return finalApi;
+}