@cldmv/slothlet 2.1.0 → 2.3.0

package/dist/lib/helpers/sanitize.mjs

@@ -46,7 +46,7 @@ function globToRegex(pattern, caseSensitive = true) {
 
 
 export function sanitizePathName(input, opts = {}) {
-	const { lowerFirst = true, rules = {} } = 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));
@@ -117,6 +117,16 @@ export function sanitizePathName(input, opts = {}) {
 		}
 
 		
+		if (preserveAllUpper && seg === seg.toUpperCase() && seg !== seg.toLowerCase() && /[A-Z]/.test(seg)) {
+			return seg;
+		}
+
+		
+		if (preserveAllLower && seg === seg.toLowerCase() && seg !== seg.toUpperCase() && /[a-z]/.test(seg)) {
+			return seg;
+		}
+
+		
 		if (segmentMatchesPreSplitPattern(seg, upperRules, false)) {
 			return seg.toUpperCase();
 		}

package/dist/lib/runtime/runtime.mjs

@@ -35,8 +35,98 @@ export const runWithCtx = (ctx, fn, thisArg, args) => {
 export const getCtx = () => als.getStore() || null;
 
 
+const EXCLUDED_CONSTRUCTORS = new Set([Object, Array, Promise, Date, RegExp, Error]);
+
+
+const EXCLUDED_INSTANCEOF_CLASSES = [ArrayBuffer, Map, Set, WeakMap, WeakSet];
+
+
+function runtime_shouldWrapMethod(value, prop) {
+	return (
+		typeof value === "function" &&
+		typeof prop === "string" && 
+		prop !== "constructor" &&
+		!(prop in Object.prototype) &&
+		!prop.startsWith("__")
+	);
+}
+
+
+function runtime_isClassInstance(val) {
+	if (
+		val == null ||
+		typeof val !== "object" ||
+		!val.constructor ||
+		typeof val.constructor !== "function" ||
+		EXCLUDED_CONSTRUCTORS.has(val.constructor)
+	) {
+		return false;
+	}
+
+	for (const cls of EXCLUDED_INSTANCEOF_CLASSES) {
+		if (typeof cls === "function" && val instanceof cls) {
+			return false;
+		}
+	}
+
+	return true;
+}
+
+
+function runtime_wrapClassInstance(instance, ctx, wrapFn, instanceCache) {
+	if (instanceCache.has(instance)) {
+		return instanceCache.get(instance);
+	}
+
+	
+	const methodCache = new Map();
+
+	const wrappedInstance = new Proxy(instance, {
+		get(target, prop, receiver) {
+			
+			if (methodCache.has(prop)) {
+				return methodCache.get(prop);
+			}
+
+			const value = Reflect.get(target, prop, receiver);
+
+			
+			
+			if (runtime_shouldWrapMethod(value, prop)) {
+				
+				
+				const runtime_contextPreservingMethod = function (...args) {
+					const result = runWithCtx(ctx, value, target, args);
+					
+					return wrapFn(result);
+				};
+
+				
+				methodCache.set(prop, runtime_contextPreservingMethod);
+				return runtime_contextPreservingMethod;
+			}
+
+			
+			return wrapFn(value);
+		},
+
+		set(target, prop, value, receiver) {
+			
+			if (methodCache.has(prop)) {
+				methodCache.delete(prop);
+			}
+			return Reflect.set(target, prop, value, receiver);
+		}
+	});
+
+	instanceCache.set(instance, wrappedInstance);
+	return wrappedInstance;
+}
+
+
 export const makeWrapper = (ctx) => {
 	const cache = new WeakMap();
+	const instanceCache = new WeakMap();
 	const wrap = (val) => {
 		if (val == null || (typeof val !== "object" && typeof val !== "function")) return val;
 		if (cache.has(val)) return cache.get(val);
@@ -53,11 +143,26 @@ export const makeWrapper = (ctx) => {
 				
 				
 				
-				return runWithCtx(ctx, target, thisArg, args);
+
+				const result = runWithCtx(ctx, target, thisArg, args);
+
+				
+				if (runtime_isClassInstance(result)) {
+					return runtime_wrapClassInstance(result, ctx, wrap, instanceCache);
+				}
+
+				return result;
 			},
 			construct(target, args, newTarget) {
 				
-				return runWithCtx(ctx, Reflect.construct, undefined, [target, args, newTarget]);
+				const result = runWithCtx(ctx, Reflect.construct, undefined, [target, args, newTarget]);
+
+				
+				if (runtime_isClassInstance(result)) {
+					return runtime_wrapClassInstance(result, ctx, wrap, instanceCache);
+				}
+
+				return result;
 			},
 			get(target, prop, receiver) {
 				return wrap(Reflect.get(target, prop, receiver));

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@cldmv/slothlet",
-	"version": "2.1.0",
+	"version": "2.3.0",
 	"moduleVersions": {
 		"lazy": "1.0.0",
 		"eager": "1.0.0"

package/types/dist/lib/helpers/sanitize.d.mts

@@ -5,6 +5,8 @@
  * @param {string} input - The input string to sanitize (e.g., file name, path segment)
  * @param {Object} [opts={}] - Sanitization configuration options
  * @param {boolean} [opts.lowerFirst=true] - Lowercase the first character of the first segment for camelCase convention
+ * @param {boolean} [opts.preserveAllUpper=false] - Automatically preserve any identifier that is already in all-uppercase format
+ * @param {boolean} [opts.preserveAllLower=false] - Automatically preserve any identifier that is already in all-lowercase format
  * @param {Object} [opts.rules={}] - Advanced segment transformation rules (supports glob patterns: *, ?, **STRING**)
  * @param {string[]} [opts.rules.leave=[]] - Segments to preserve exactly as-is (case-sensitive, supports globs)
  * @param {string[]} [opts.rules.leaveInsensitive=[]] - Segments to preserve exactly as-is (case-insensitive, supports globs)
@@ -48,6 +50,20 @@
  * }); // Result: "getAPIStatus" (api becomes API due to pattern)
  *
  * @example
+ * // Automatic case preservation
+ * sanitizePathName("COMMON_APPS", { preserveAllUpper: true });      // "COMMON_APPS" (preserved)
+ * sanitizePathName("cOMMON_APPS", { preserveAllUpper: true });      // "cOMMON_APPS" (not all-uppercase, transformed)
+ * sanitizePathName("common_apps", { preserveAllLower: true });      // "common_apps" (preserved)
+ * sanitizePathName("Common_apps", { preserveAllLower: true });      // "commonApps" (not all-lowercase, transformed)
+ *
+ * @example
+ * // Combining preserve options with other rules
+ * sanitizePathName("parse-XML-data", {
+ *   preserveAllUpper: true,
+ *   rules: { upper: ["xml"] }
+ * }); // "parseXMLData" (XML preserved by preserveAllUpper)
+ *
+ * @example
  * // Boundary-requiring patterns with **STRING** syntax
  * sanitizePathName("buildUrlWithParams", {
  *   rules: {
@@ -69,6 +85,8 @@
  */
 export function sanitizePathName(input: string, opts?: {
     lowerFirst?: boolean;
+    preserveAllUpper?: boolean;
+    preserveAllLower?: boolean;
     rules?: {
         leave?: string[];
         leaveInsensitive?: string[];

package/types/dist/lib/helpers/sanitize.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"sanitize.d.mts","sourceRoot":"","sources":["../../../../dist/lib/helpers/sanitize.mjs"],"names":[],"mappings":"AAmEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoEG;AACH,wCAjEW,MAAM,SAEd;IAAuB,UAAU,GAAzB,OAAO;IACO,KAAK,GAC3B;QAA8B,KAAK,GAA3B,MAAM,EAAE;QACc,gBAAgB,GAAtC,MAAM,EAAE;QACc,KAAK,GAA3B,MAAM,EAAE;QACc,KAAK,GAA3B,MAAM,EAAE;KAChB;CAAA,GAAU,MAAM,CA+QlB"}
+{"version":3,"file":"sanitize.d.mts","sourceRoot":"","sources":["../../../../dist/lib/helpers/sanitize.mjs"],"names":[],"mappings":"AAmEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoFG;AACH,wCAjFW,MAAM,SAEd;IAAuB,UAAU,GAAzB,OAAO;IACQ,gBAAgB,GAA/B,OAAO;IACQ,gBAAgB,GAA/B,OAAO;IACO,KAAK,GAC3B;QAA8B,KAAK,GAA3B,MAAM,EAAE;QACc,gBAAgB,GAAtC,MAAM,EAAE;QACc,KAAK,GAA3B,MAAM,EAAE;QACc,KAAK,GAA3B,MAAM,EAAE;KAChB;CAAA,GAAU,MAAM,CAuSlB"}

package/types/dist/lib/runtime/runtime.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"runtime.d.mts","sourceRoot":"","sources":["../../../../dist/lib/runtime/runtime.mjs"],"names":[],"mappings":"AA0CO,gCAdI,MAAM,yBAEN,GAAG,gBAED,GAAG,CA6Bf;AAiBM,0BAZM,MAAM,GAAC,IAAI,CAY0B;AAsB3C,iCAjBI,MAAM,YAwDhB;AA4RD;;;;;;;;;;;;;GAaG;AACH,mBATU,WAAS,MAAM,CAS6B;AAEtD;;;;;;;;;;;;;GAaG;AACH,sBATU,MAAM,CAS4C;AAE5D;;;;;;;;;;;;;GAaG;AACH,wBATU,MAAM,CASgD"}
+{"version":3,"file":"runtime.d.mts","sourceRoot":"","sources":["../../../../dist/lib/runtime/runtime.mjs"],"names":[],"mappings":"AA0CO,gCAdI,MAAM,yBAEN,GAAG,gBAED,GAAG,CA6Bf;AAiBM,0BAZM,MAAM,GAAC,IAAI,CAY0B;AA8K3C,iCAjBI,MAAM,YAwEhB;AA4RD;;;;;;;;;;;;;GAaG;AACH,mBATU,WAAS,MAAM,CAS6B;AAEtD;;;;;;;;;;;;;GAaG;AACH,sBATU,MAAM,CAS4C;AAE5D;;;;;;;;;;;;;GAaG;AACH,wBATU,MAAM,CASgD"}

package/types/dist/slothlet.d.mts

@@ -103,6 +103,8 @@ export type SlothletOptions = {
      */
     sanitize?: {
         lowerFirst?: boolean;
+        preserveAllUpper?: boolean;
+        preserveAllLower?: boolean;
         rules?: {
             leave?: string[];
             leaveInsensitive?: string[];

package/types/dist/slothlet.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"slothlet.d.mts","sourceRoot":"","sources":["../../dist/slothlet.mjs"],"names":[],"mappings":"AAi5CA;;;;;;;;;GASG;AACH,kDARW,WAAS,MAAM,UACf,WAAS,MAAM,QAwCzB;AAzzCD;;;;;GAKG;AACH,sBAJU,MAAM,CAIoE;AAKpF;;;;;;;GAOG;AACH,mBAJU,MAAM,CAIO;AAEvB;;;;;GAKG;AACH,sBAJU,MAAM,CAIU;AAE1B;;;;;GAKG;AACH,wBAJU,MAAM,CAIY;;;;;;;;;UAiyCd,MAAM;;;;;;WAIN,OAAO;;;;;;;eAGP,MAAM;;;;;;;;YAIN,OAAO;;;;;;;;WAKP,MAAM;;;;;;;eAKN,MAAM;;;;;;cAIN,MAAM;;;;;;gBAGN,MAAM;;;;;;eAMjB;QAA8B,UAAU,GAA7B,OAAO;QACW,KAAK,GAClC;YAAqC,KAAK,GAA/B,MAAM,EAAE;YACkB,gBAAgB,GAA1C,MAAM,EAAE;YACkB,KAAK,GAA/B,MAAM,EAAE;YACkB,KAAK,GAA/B,MAAM,EAAE;SACrB;KAAA;;AAv0CD;;;;;;;;GAQG;AACH,mCAJW,eAAe,GACb,OAAO,CAAC,WAAS,MAAM,CAAC,CAiCpC"}
+{"version":3,"file":"slothlet.d.mts","sourceRoot":"","sources":["../../dist/slothlet.mjs"],"names":[],"mappings":"AAi5CA;;;;;;;;;GASG;AACH,kDARW,WAAS,MAAM,UACf,WAAS,MAAM,QAwCzB;AAzzCD;;;;;GAKG;AACH,sBAJU,MAAM,CAIoE;AAKpF;;;;;;;GAOG;AACH,mBAJU,MAAM,CAIO;AAEvB;;;;;GAKG;AACH,sBAJU,MAAM,CAIU;AAE1B;;;;;GAKG;AACH,wBAJU,MAAM,CAIY;;;;;;;;;UAiyCd,MAAM;;;;;;WAIN,OAAO;;;;;;;eAGP,MAAM;;;;;;;;YAIN,OAAO;;;;;;;;WAKP,MAAM;;;;;;;eAKN,MAAM;;;;;;cAIN,MAAM;;;;;;gBAGN,MAAM;;;;;;eAMjB;QAA8B,UAAU,GAA7B,OAAO;QACY,gBAAgB,GAAnC,OAAO;QACY,gBAAgB,GAAnC,OAAO;QACW,KAAK,GAClC;YAAqC,KAAK,GAA/B,MAAM,EAAE;YACkB,gBAAgB,GAA1C,MAAM,EAAE;YACkB,KAAK,GAA/B,MAAM,EAAE;YACkB,KAAK,GAA/B,MAAM,EAAE;SACrB;KAAA;;AAz0CD;;;;;;;;GAQG;AACH,mCAJW,eAAe,GACb,OAAO,CAAC,WAAS,MAAM,CAAC,CAiCpC"}