@cldmv/slothlet 2.11.0 → 3.0.0

package/dist/lib/helpers/sanitize.mjs

@@ -18,260 +18,339 @@
 
 
 
+import { ComponentBase } from "@cldmv/slothlet/factories/component-base";
 
-function globToRegex(pattern, caseSensitive = true) {
-	try {
+
+
+
+
+
+export class Sanitize extends ComponentBase {
+	static slothletProperty = "sanitize";
+
+	
+	
+	
+
+	
+	#compileGlobPattern(pattern, caseSensitive = true) {
 		
 		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
+		const 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, preserveAllUpper = false, preserveAllLower = false, 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));
+	
+	#matchesAnyPattern(input, patterns, caseSensitive = false) {
+		for (const pattern of patterns) {
+			if (pattern.includes("*") || pattern.includes("?")) {
+				const regex = this.#compileGlobPattern(pattern, caseSensitive);
+				if (regex && regex.test(input)) return true;
+			} else {
+				const match = caseSensitive ? input === pattern : input.toLowerCase() === pattern.toLowerCase();
+				if (match) return true;
+			}
+		}
+		return false;
+	}
 
-	let s = String(input).trim();
+	
+	#extractPatternLiterals(pattern) {
+		return pattern.split(/[*?]+/).filter(Boolean);
+	}
 
 	
 	
-
 	
-	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 "_";
+	#applySegmentRules(segment, index, originalString, config) {
+		const { preserveAllUpper, preserveAllLower, leaveRules, leaveInsensitiveRules, upperRules, lowerRules } = config;
 
-	
-	const segmentMatchesPreSplitPattern = (segment, patterns, caseSensitive = false) => {
-		for (const pattern of patterns) {
-			
-			
-			
+		
+		if (this.#matchesAnyPattern(segment, leaveRules, true)) {
+			return segment;
+		}
+
+		
+		if (this.#matchesAnyPattern(segment, leaveInsensitiveRules, false)) {
+			return segment;
+		}
 
+		
+		
+		if (preserveAllUpper && segment === segment.toUpperCase() && segment !== segment.toLowerCase() && /[A-Z]/.test(segment)) {
+			return segment;
+		}
+
+		
+		
+		if (preserveAllLower && segment === segment.toLowerCase() && segment !== segment.toUpperCase() && /[a-z]/.test(segment)) {
+			return segment;
+		}
+
+		
+		
+		for (const pattern of [...upperRules, ...lowerRules]) {
 			if (pattern.includes("*") || pattern.includes("?")) {
-				const regex = globToRegex(pattern, caseSensitive);
-				if (regex && regex.test(s)) {
+				const regex = this.#compileGlobPattern(pattern, false);
+				if (regex && regex.test(originalString)) {
 					
-					
-					const literalParts = pattern.split(/[*?]+/).filter(Boolean);
-
-					for (const literal of literalParts) {
+					const literals = this.#extractPatternLiterals(pattern);
+					for (const literal of literals) {
 						
-						const cleanLiteral = literal.replace(/[^A-Za-z0-9_$]/g, "");
-						if (cleanLiteral) {
-							const match = caseSensitive ? segment === cleanLiteral : segment.toLowerCase() === cleanLiteral.toLowerCase();
-							if (match) {
-								return true;
-							}
+						const cleanLiteral = literal.replace(/[^A-Za-z0-9_$]/g, "").replace(/^_+|_+$/g, "");
+						if (cleanLiteral && segment.toLowerCase() === cleanLiteral.toLowerCase()) {
+							return upperRules.includes(pattern) ? segment.toUpperCase() : segment.toLowerCase();
 						}
 					}
 				}
 			} else {
 				
-				const match = caseSensitive ? segment === pattern : segment.toLowerCase() === pattern.toLowerCase();
-				if (match) {
-					return true;
+				if (segment.toLowerCase() === pattern.toLowerCase()) {
+					return upperRules.includes(pattern) ? segment.toUpperCase() : segment.toLowerCase();
 				}
 			}
 		}
-		return false;
-	};
 
-	const applyRule = (seg, index) => {
 		
-		if (segmentMatchesPreSplitPattern(seg, leaveRules, true)) {
-			return seg;
+		let transformed = this.#applyWithinSegmentPatterns(segment, upperRules, lowerRules);
+		if (transformed !== segment) {
+			return transformed;
 		}
 
 		
-		if (segmentMatchesPreSplitPattern(seg, leaveInsensitiveRules, false)) {
-			return seg;
-		}
-
 		
-		if (preserveAllUpper && seg === seg.toUpperCase() && seg !== seg.toLowerCase() && /[A-Z]/.test(seg)) {
-			return seg;
-		}
+		return segment;
+	}
+
+	
+	#applyWithinSegmentPatterns(segment, upperRules, lowerRules) {
+		let result = segment;
+
+		const applyBoundaryPattern = (pattern, toUpper) => {
+			
+			if (pattern.startsWith("**") && pattern.endsWith("**") && pattern.length > 4) {
+				const innerString = pattern.slice(2, -2);
+				const innerRegex = new RegExp(innerString.replace(/[.+^${}()|[\]\\*?]/g, "\\$&"), "gi");
+				const matches = [...result.matchAll(innerRegex)];
+
+				for (const match of matches) {
+					const startPos = match.index;
+					const endPos = startPos + match[0].length;
+					const hasCharBefore = startPos > 0;
+					const hasCharAfter = endPos < result.length;
+
+					if (hasCharBefore && hasCharAfter) {
+						const replacement = toUpper ? innerString.toUpperCase() : innerString.toLowerCase();
+						result = result.substring(0, startPos) + replacement + result.substring(endPos);
+						break;
+					}
+				}
+			}
+			
+			else if (pattern.includes("*") && !pattern.startsWith("**")) {
+				
+				const literalParts = pattern.split("*").filter(Boolean);
+				for (const literal of literalParts) {
+					const literalRegex = new RegExp(literal.replace(/[.+^${}()|[\]\\]/g, "\\$&"), "gi");
+					const replacement = toUpper ? literal.toUpperCase() : literal.toLowerCase();
+					result = result.replace(literalRegex, replacement);
+				}
+			}
+		};
+
+		upperRules.forEach((pattern) => applyBoundaryPattern(pattern, true));
+		lowerRules.forEach((pattern) => applyBoundaryPattern(pattern, false));
+
+		return result;
+	}
+
+	
+	
+	
+
+	
+	sanitizePropertyName(input, options = {}) {
+		const { lowerFirst = true, preserveAllUpper = false, preserveAllLower = false, rules = {} } = options;
 
 		
-		if (preserveAllLower && seg === seg.toLowerCase() && seg !== seg.toUpperCase() && /[a-z]/.test(seg)) {
-			return seg;
-		}
+		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));
+
+		const originalString = String(input).trim();
 
 		
-		if (segmentMatchesPreSplitPattern(seg, upperRules, false)) {
-			return seg.toUpperCase();
-		}
+		const isAllUpper =
+			originalString === originalString.toUpperCase() && originalString !== originalString.toLowerCase() && /[A-Z]/.test(originalString);
+		const isAllLower =
+			originalString === originalString.toLowerCase() && originalString !== originalString.toUpperCase() && /[a-z]/.test(originalString);
 
+		if (preserveAllUpper && isAllUpper) {
+			return originalString;
+		}
+		
 		
-		if (segmentMatchesPreSplitPattern(seg, lowerRules, false)) {
-			return seg.toLowerCase();
+		if (preserveAllLower && isAllLower && !/-/.test(originalString)) {
+			return originalString;
 		}
 
 		
-		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;
+		let primarySegments = originalString.split(/[-]+|[^A-Za-z0-9_$]+/).filter(Boolean);
 
-							
-							const hasCharBefore = startPos > 0;
-							const hasCharAfter = endPos < transformedSeg.length;
+		
+		if (primarySegments.length === 0) return "_";
 
-							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());
-							}
-						}
-					}
-				}
-			}
+		
+		while (primarySegments.length && !/^[A-Za-z_$]/.test(primarySegments[0][0])) {
+			primarySegments[0] = primarySegments[0].replace(/^[^A-Za-z_$]+/, "");
+			if (!primarySegments[0]) primarySegments.shift();
 		}
+		if (primarySegments.length === 0) return "_";
 
 		
-		for (const pattern of lowerRules) {
-			if (pattern.includes("*") || pattern.includes("?")) {
+		
+		
+		
+		
+		const lowerRuleApplied = [];
+		const processedPrimarySegments = primarySegments.map((primarySeg, primaryIdx) => {
+			
+			const parts = primarySeg.split(/(_+)/);
+
+			
+			const processedParts = parts.map((part, partIdx) => {
 				
-				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");
+				if (partIdx % 2 === 1) return part;
+				if (!part) return part;
 
-						
-						const matches = [...transformedSeg.matchAll(innerRegex)];
-						for (const match of matches) {
-							const startPos = match.index;
-							const endPos = startPos + match[0].length;
+				
+				const cleanSeg = part.replace(/[^A-Za-z0-9_$]/g, "");
 
-							
-							const hasCharBefore = startPos > 0;
-							const hasCharAfter = endPos < transformedSeg.length;
+				
+				const config = { preserveAllUpper, preserveAllLower, leaveRules, leaveInsensitiveRules, upperRules, lowerRules };
+				const result = this.#applySegmentRules(cleanSeg, 0, originalString, config);
 
-							if (hasCharBefore && hasCharAfter) {
-								
-								transformedSeg = transformedSeg.substring(0, startPos) + innerString.toLowerCase() + transformedSeg.substring(endPos);
-								break; 
+				
+				
+				const matchesLower = lowerRules.some((pattern) => {
+					if (pattern.includes("*") || pattern.includes("?")) {
+						const regex = this.#compileGlobPattern(pattern, false);
+						if (regex && regex.test(originalString)) {
+							
+							const literals = this.#extractPatternLiterals(pattern);
+							for (const literal of literals) {
+								const cleanLiteral = literal.replace(/[^A-Za-z0-9_$]/g, "").replace(/^_+|_+$/g, "");
+								if (cleanLiteral && cleanSeg.toLowerCase() === cleanLiteral.toLowerCase()) {
+									return true;
+								}
 							}
 						}
 					} 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());
-							}
+						if (cleanSeg.toLowerCase() === pattern.toLowerCase()) {
+							return true;
 						}
 					}
+					return false;
+				});
+
+				if (matchesLower && result === cleanSeg.toLowerCase()) {
+					lowerRuleApplied[primaryIdx] = true;
 				}
-			}
-		}
+
+				return result;
+			});
+
+			
+			return processedParts.join("");
+		});
 
 		
-		
-		for (const pattern of upperRules) {
-			if (!pattern.includes("*") && !pattern.includes("?")) {
-				
-				const match = seg.toLowerCase() === pattern.toLowerCase();
-				if (match) {
-					return seg.toUpperCase();
-				}
+		const camelCasedSegments = processedPrimarySegments.map((seg, idx) => {
+			
+			const matchesLeave = this.#matchesAnyPattern(seg, leaveRules, true);
+			const matchesLeaveInsensitive = this.#matchesAnyPattern(seg, leaveInsensitiveRules, false);
+			const matchesUpper = this.#matchesAnyPattern(seg, upperRules, false);
+			
+			
+			const hasUnderscores = seg.includes("_");
+			const isAllUpper = !hasUnderscores && preserveAllUpper && seg === seg.toUpperCase() && seg !== seg.toLowerCase() && /[A-Z]/.test(seg);
+			const isAllLower = !hasUnderscores && preserveAllLower && seg === seg.toLowerCase() && seg !== seg.toUpperCase() && /[a-z]/.test(seg);
+
+			
+			if (matchesLeave || matchesLeaveInsensitive || matchesUpper || isAllUpper || isAllLower) {
+				return seg;
 			}
-		}
 
-		
-		for (const pattern of lowerRules) {
-			if (!pattern.includes("*") && !pattern.includes("?")) {
+			
+			
+			let transformed;
+			if (idx === 0) {
 				
-				const match = seg.toLowerCase() === pattern.toLowerCase();
-				if (match) {
-					return seg.toLowerCase();
+				transformed = lowerFirst ? seg[0].toLowerCase() + seg.slice(1) : seg;
+			} else {
+				
+				
+				if (lowerRuleApplied[idx]) {
+					transformed = seg; 
+				} else {
+					transformed = seg[0].toUpperCase() + seg.slice(1);
 				}
 			}
-		}
 
-		
-		if (transformedSeg !== seg) {
-			return transformedSeg;
-		}
+			return transformed;
+		});
 
 		
-		if (index === 0) {
-			
-			return lowerFirst ? seg[0].toLowerCase() + seg.slice(1) : seg;
-		}
-		
-		return seg[0].toUpperCase() + seg.slice(1);
-	};
+		let result = camelCasedSegments.join("");
+		result = result.replace(/[^A-Za-z0-9_$]/g, "");
+
+		return result;
+	}
 
 	
-	let out = parts.map((seg, i) => applyRule(seg.replace(/[^A-Za-z0-9_$]/g, ""), i)).join("");
+	getModuleId(filePath, baseDir) {
+		
+		let relative = filePath.replace(baseDir, "").replace(/\\/g, "/");
+		relative = relative.replace(/^\//, ""); 
+		relative = relative.replace(/\.(mjs|cjs|js)$/, ""); 
+
+		return relative;
+	}
 
 	
-	out = out.replace(/[^A-Za-z0-9_$]/g, "");
-	if (!out || !/^[A-Za-z_$]/.test(out[0])) out = "_" + out;
+	shouldPreserveFunctionCase(name) {
+		const preservePatterns = [
+			/^[A-Z]{2,}$/, 
+			/[A-Z]{2,}/ 
+		];
 
-	return out;
+		return preservePatterns.some((pattern) => pattern.test(name));
+	}
 }
 
 
 
+
+
+
+export function sanitizePropertyName(input, options = {}) {
+	const sanitizer = new Sanitize(null); 
+	return sanitizer.sanitizePropertyName(input, options);
+}

package/dist/lib/helpers/utilities.mjs

@@ -18,104 +18,69 @@
 
 
 
+import { ComponentBase } from "@cldmv/slothlet/factories/component-base";
 
-export function safeDefine(obj, key, value, enumerable = false, config = null) {
-	const desc = Object.getOwnPropertyDescriptor(obj, key);
-	if (!desc) {
-		Object.defineProperty(obj, key, {
-			value,
-			writable: true,
-			configurable: true,
-			enumerable
-		});
-	} else if (desc.configurable) {
-		Object.defineProperty(obj, key, {
-			value,
-			writable: true,
-			configurable: true,
-			enumerable
-		});
-	} else if (config && config.debug) {
-		console.warn(`Could not redefine boundApi.${key}: not configurable`);
-	}
-}
 
+export class Utilities extends ComponentBase {
+	static slothletProperty = "utilities";
 
-export function deepMerge(target, source) {
-	if (!source || typeof source !== "object" || Array.isArray(source)) {
-		return source;
+	
+	isPlainObject(obj) {
+		if (typeof obj !== "object" || obj === null) return false;
+		const proto = Object.getPrototypeOf(obj);
+		return proto === null || proto === Object.prototype;
 	}
 
-	for (const key in source) {
-		if (!Object.prototype.hasOwnProperty.call(source, key)) {
-			continue;
-		}
-
-		
-		if (key === "__proto__" || key === "prototype" || key === "constructor") {
-			continue;
-		}
-
-		const sourceValue = source[key];
-		const targetValue = target[key];
-
-		if (sourceValue && typeof sourceValue === "object" && !Array.isArray(sourceValue)) {
-			target[key] = deepMerge(
-				targetValue && typeof targetValue === "object" && !Array.isArray(targetValue) ? targetValue : {},
-				sourceValue
-			);
-		} else {
-			target[key] = sourceValue;
+	
+	deepMerge(target, source) {
+		if (!this.isPlainObject(target) || !this.isPlainObject(source)) {
+			return source;
 		}
-	}
-
-	return target;
-}
 
+		const result = { ...target };
 
-export function mutateLiveBindingFunction(target, source) {
-	if (typeof source === "function") {
-		target._impl = (...args) => source(...args);
-		
-		for (const key of Object.keys(target)) {
-			if (key !== "_impl" && key !== "__ctx") delete target[key];
-		}
-		
-		for (const key of Object.getOwnPropertyNames(source)) {
-			if (key !== "length" && key !== "name" && key !== "prototype" && key !== "_impl" && key !== "__ctx") {
-				try {
-					target[key] = source[key];
-				} catch {
+		for (const key in source) {
+			if (Object.prototype.hasOwnProperty.call(source, key)) {
+				if (this.isPlainObject(source[key])) {
+					
 					
+					result[key] = this.deepMerge(this.isPlainObject(target[key]) ? target[key] : {}, source[key]);
+				} else {
+					result[key] = source[key];
 				}
 			}
 		}
-	} else if (typeof source === "object" && source !== null) {
-		
-		for (const key of Object.keys(target)) {
-			if (key !== "_impl" && key !== "__ctx") delete target[key];
-		}
-		
-		for (const [key, value] of Object.entries(source)) {
-			if (key !== "__ctx") {
-				target[key] = value;
-			}
-		}
-		
-		const managementMethods = ["shutdown", "addApi", "describe"];
-		for (const method of managementMethods) {
-			const desc = Object.getOwnPropertyDescriptor(source, method);
-			if (desc) {
+
+		return result;
+	}
+
+	
+	deepClone(obj) {
+		try {
+			return structuredClone(obj);
+		} catch {
+			
+			
+			const objType = obj?.__type || typeof obj;
+			if (obj === null || (objType !== "object" && objType !== "function")) return obj;
+			if (obj instanceof Date) return new Date(obj.getTime());
+			if (Array.isArray(obj)) return obj.map((item) => this.deepClone(item));
+			
+			const cloned = {};
+			for (const key in obj) {
 				try {
-					Object.defineProperty(target, method, desc);
+					cloned[key] = this.deepClone(obj[key]);
 				} catch {
 					
+					cloned[key] = obj[key];
 				}
 			}
+			return cloned;
 		}
-		
-		if (typeof source._impl === "function") {
-			target._impl = source._impl;
-		}
+	}
+
+	
+	generateId() {
+		return `slothlet_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
 	}
 }