@cldmv/slothlet 2.0.1 → 2.1.0

package/README.md

@@ -1,7 +1,7 @@
 # @cldmv/slothlet
 
 <div align="center">
-  <img src="images/slothlet-logo-v1-horizontal-transparent.png" alt="Slothlet Logo" width="600">
+  <img src="https://github.com/CLDMV/slothlet/raw/HEAD/images/slothlet-logo-v1-horizontal-transparent.png" alt="Slothlet Logo" width="600">
 </div>
 
 **@cldmv/slothlet** is a sophisticated module loading framework that revolutionizes how you work with massive APIs in Node.js. Built for developers who demand smart, efficient module loading without compromising performance or developer experience.
@@ -52,6 +52,14 @@ v2.0 represents a ground-up rewrite with enterprise-grade features:
 - **Smart Function Naming**: Preserves original capitalization (`autoIP`, `parseJSON`, `getHTTPStatus`)
 - **Multi-Execution Environments**: Singleton, VM, worker, fork isolation modes (experimental)
 
+### 🔧 **Advanced Sanitization Control** ⭐ NEW
+
+- **Custom API Naming**: Control how filenames become API property names through sanitize options
+- **Boundary Pattern Matching**: Use `**string**` patterns for precise transformations (`**url**` → `buildURLWithParams`)
+- **Glob Pattern Support**: Apply rules with wildcards (`*json*`, `auto*`, `http*`) for flexible naming control
+- **Case-Sensitive Rules**: Preserve important naming patterns (acronyms, technical terms, branding)
+- **Mixed Rule Types**: Combine exact matches, globs, and boundary patterns for sophisticated naming strategies
+
 ### 📊 **Performance Optimizations**
 
 - **Startup**: Lazy mode 4.3x faster (564.17μs vs 2.45ms)
@@ -76,7 +84,7 @@ v2.0 represents a ground-up rewrite with enterprise-grade features:
 
 ### ⚡ Performance Excellence
 
-- **📊 For comprehensive performance analysis, benchmarks, and recommendations, see [PERFORMANCE.md](PERFORMANCE.md)**
+- **📊 For comprehensive performance analysis, benchmarks, and recommendations, see [PERFORMANCE.md](https://github.com/CLDMV/slothlet/blob/HEAD/PERFORMANCE.md)**
 
 ### 🔧 **Smart API Management**
 
@@ -87,7 +95,7 @@ v2.0 represents a ground-up rewrite with enterprise-grade features:
 - **Hybrid Exports**: Support for callable APIs with methods, default + named exports, and mixed patterns
 
 > [!TIP]  
-> **📁 For comprehensive examples of API flattening, naming conventions, and function preservation patterns, see the test modules in [api_tests/](api_tests/) and their documentation in [docs/api_tests/](docs/api_tests/)**
+> **📁 For comprehensive examples of API flattening, naming conventions, and function preservation patterns, see the test modules in [api_tests/](https://github.com/CLDMV/slothlet/blob/HEAD/api_tests) and their documentation in [docs/api_tests/](https://github.com/CLDMV/slothlet/blob/HEAD/docs/api_tests)**
 
 ### 🔗 **Advanced Binding System**
 
@@ -215,10 +223,52 @@ const api = await slothlet({
 		helpers: {
 			/* ... */
 		}
+	},
+	sanitize: {
+		// 🔧 NEW: Control API property naming
+		lowerFirst: false, // Keep first character casing
+		rules: {
+			leave: ["parseJSON", "autoIP"], // Preserve exact names
+			leaveInsensitive: ["*xml*"], // Case-insensitive preservation
+			upper: ["**url**", "api", "http*"], // Force uppercase (including boundary patterns)
+			lower: ["id", "uuid", "*id"] // Force lowercase
+		}
 	}
 });
 ```
 
+### Sanitize Options Examples
+
+Transform module filenames into clean, professional API property names:
+
+```javascript
+// Without sanitize options (default behavior)
+const api = await slothlet({ dir: "./api" });
+// Files: build-url-with-params.mjs, parse-json-data.mjs, auto-ip.mjs
+// Result: api.buildUrlWithParams, api.parseJsonData, api.autoIp
+
+// With sanitize options (custom naming control)
+const api = await slothlet({
+	dir: "./api",
+	sanitize: {
+		lowerFirst: false,
+		rules: {
+			leave: ["parseJSON"], // Exact match preservation
+			upper: ["**url**", "ip", "http*"], // Boundary + glob patterns
+			leaveInsensitive: ["*xml*"] // Case-insensitive globs
+		}
+	}
+});
+// Result: api.buildURLWithParams, api.parseJSON, api.autoIP
+```
+
+**Sanitize Pattern Types:**
+
+- **Exact Match**: `"parseJSON"` - Matches exact string only
+- **Glob Patterns**: `"*json*"`, `"auto*"`, `"http*"` - Wildcard matching
+- **Boundary Patterns**: `"**url**"` - Only matches when surrounded by word boundaries
+- **Case Control**: `leaveInsensitive` for case-insensitive matching
+
 ### Multiple Instances
 
 In v2.x, each call to `slothlet(options)` automatically creates a new isolated instance with its own context and configuration:
@@ -284,6 +334,7 @@ Creates and loads an API instance with the specified configuration.
 | `api_mode`  | `string`  | `"auto"`      | API structure behavior when root-level default functions exist:<br/>• `"auto"`: Automatically detects if root has default function export and creates callable API<br/>• `"function"`: Forces API to be callable (use when you have root-level default function exports)<br/>• `"object"`: Forces API to be object-only (use when you want object interface regardless of exports) |
 | `context`   | `object`  | `{}`          | Context data object injected into live-binding `context` reference. Available to all loaded modules via `import { context } from '@cldmv/slothlet/runtime'`                                                                                                                                                                                                                        |
 | `reference` | `object`  | `{}`          | Reference object merged into the API root level. Properties not conflicting with loaded modules are added directly to the API                                                                                                                                                                                                                                                      |
+| `sanitize`  | `object`  | `{}`          | **🔧 NEW**: Control how filenames become API property names. Supports exact matches, glob patterns (`*json*`), and boundary patterns (`**url**`). Configure `lowerFirst` and `rules` for `leave`, `leaveInsensitive`, `upper`, and `lower` transformations                                                                                                                         |
 
 #### `slothlet.getApi()` ⇒ `object`
 
@@ -310,7 +361,7 @@ Gracefully shuts down the API and cleans up resources.
 **Returns:** `Promise<void>` - Resolves when shutdown is complete
 
 > [!NOTE]  
-> **📚 For detailed API documentation with comprehensive parameter descriptions, method signatures, and examples, see [docs/API.md](docs/API.md)**
+> **📚 For detailed API documentation with comprehensive parameter descriptions, method signatures, and examples, see [docs/API.md](https://github.com/CLDMV/slothlet/blob/HEAD/docs/API.md)**
 
 ### Live Bindings
 
@@ -809,7 +860,7 @@ We welcome contributions! The experimental modes in particular need development
 4. **Provide feedback** on API design and performance
 5. **Documentation improvements** are always appreciated
 
-See [CONTRIBUTING.md](CONTRIBUTING.md) for detailed contribution guidelines.
+See [CONTRIBUTING.md](https://github.com/CLDMV/slothlet/blob/HEAD/CONTRIBUTING.md) for detailed contribution guidelines.
 
 [![Contributors]][contributors_url] [![Sponsor shinrai]][sponsor_url]
 
@@ -819,7 +870,7 @@ See [CONTRIBUTING.md](CONTRIBUTING.md) for detailed contribution guidelines.
 
 For comprehensive performance benchmarks, analysis, and recommendations:
 
-**📈 [See PERFORMANCE.md](PERFORMANCE.md)**
+**📈 [See PERFORMANCE.md](https://github.com/CLDMV/slothlet/blob/HEAD/PERFORMANCE.md)**
 
 Key highlights:
 
@@ -836,11 +887,11 @@ Key highlights:
 
 ## 📚 Documentation
 
-- **[API Documentation](docs/API.md)** - Complete API reference with examples
-- **[Performance Analysis](PERFORMANCE.md)** - Detailed benchmarks and recommendations
-- **[Contributing Guide](CONTRIBUTING.md)** - How to contribute to the project
-- **[Security Policy](SECURITY.md)** - Security guidelines and reporting
-- **[Test Documentation](api_tests/)** - Comprehensive test module examples
+- **[API Documentation](https://github.com/CLDMV/slothlet/blob/HEAD/docs/API.md)** - Complete API reference with examples
+- **[Performance Analysis](https://github.com/CLDMV/slothlet/blob/HEAD/PERFORMANCE.md)** - Detailed benchmarks and recommendations
+- **[Contributing Guide](https://github.com/CLDMV/slothlet/blob/HEAD/CONTRIBUTING.md)** - How to contribute to the project
+- **[Security Policy](https://github.com/CLDMV/slothlet/blob/HEAD/SECURITY.md)** - Security guidelines and reporting
+- **[Test Documentation](https://github.com/CLDMV/slothlet/blob/HEAD/api_tests)** - Comprehensive test module examples
 
 ---
 
@@ -895,7 +946,7 @@ Slothlet v2.0 represents a complete architectural rewrite with enterprise-grade
 [repo size]: https://img.shields.io/github/repo-size/CLDMV/slothlet?style=for-the-badge&logo=github&logoColor=white&labelColor=181717
 [repo_size_url]: https://github.com/CLDMV/slothlet
 [github license]: https://img.shields.io/github/license/CLDMV/slothlet.svg?style=for-the-badge&logo=github&logoColor=white&labelColor=181717
-[github_license_url]: LICENSE
+[github_license_url]: https://github.com/CLDMV/slothlet/blob/HEAD/LICENSE
 [npm license]: https://img.shields.io/npm/l/%40cldmv%2Fslothlet.svg?style=for-the-badge&logo=npm&logoColor=white&labelColor=CB3837
 [npm_license_url]: https://www.npmjs.com/package/@cldmv/slothlet
 [contributors]: https://img.shields.io/github/contributors/CLDMV/slothlet.svg?style=for-the-badge&logo=github&logoColor=white&labelColor=181717

package/dist/lib/helpers/sanitize.mjs

@@ -17,43 +17,230 @@
 
 
 
+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 L = (rules.leave || []).map((s) => String(s).toLowerCase());
-	const U = (rules.upper || []).map((s) => String(s).toLowerCase());
-	const W = (rules.lower || []).map((s) => String(s).toLowerCase());
-
-	const isValidId = (s) => /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(s);
+	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();
 
 	
-	if (isValidId(s)) return s;
+	
 
 	
 	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) => {
-		const key = seg.toLowerCase();
+		
+		if (segmentMatchesPreSplitPattern(seg, leaveRules, true)) {
+			return seg;
+		}
 
 		
-		if (L.includes(key)) 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();
+		}
 
 		
-		if (U.includes(key)) return seg.toUpperCase();
+		let transformedSeg = seg;
 
 		
-		if (W.includes(key)) return seg.toLowerCase();
+		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) {

package/dist/slothlet.mjs

@@ -112,7 +112,7 @@ const slothletObject = {
 	reference: {},
 	mode: "singleton",
 	loaded: false,
-	config: { lazy: false, apiDepth: Infinity, debug: DEBUG, dir: null },
+	config: { lazy: false, apiDepth: Infinity, debug: DEBUG, dir: null, sanitize: null },
 	_dispose: null,
 	_boundAPIShutdown: null,
 
@@ -179,11 +179,16 @@ const slothletObject = {
 		let api;
 		let dispose;
 		if (mode === "singleton") {
-			const { context = null, reference = null, ...loadConfig } = options;
+			const { context = null, reference = null, sanitize = null, ...loadConfig } = options;
 			this.context = context;
 			this.reference = reference;
 
 			
+			if (sanitize !== null) {
+				this.config.sanitize = sanitize;
+			}
+
+			
 			
 			if (this.api_mode === "function") {
 				this.boundapi = function (...args) {
@@ -334,7 +339,7 @@ const slothletObject = {
 
 	
 	_toApiKey(name) {
-		return sanitizePathName(name);
+		return sanitizePathName(name, this.config.sanitize || {});
 		
 	},
 
@@ -722,7 +727,7 @@ const slothletObject = {
 					
 					
 					
-					obj[exportName] = exportValue;
+					obj[this._toApiKey(exportName)] = exportValue;
 				}
 			}
 
@@ -759,7 +764,7 @@ const slothletObject = {
 		for (const [exportName, exportValue] of namedExports) {
 			
 			
-			apiExport[exportName] = exportValue;
+			apiExport[this._toApiKey(exportName)] = exportValue;
 		}
 		return apiExport;
 	},

package/package.json

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

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

@@ -1,46 +1,3 @@
-/**
- * @fileoverview String sanitization utilities for slothlet API property names. Internal file (not exported in package.json).
- * @module @cldmv/slothlet.helpers.sanitize
- * @memberof module:@cldmv/slothlet.helpers
- * @internal
- * @package
- *
- * @description
- * Advanced string sanitization system for converting arbitrary file names into valid JavaScript
- * property names suitable for slothlet's dot-notation API access. Implements sophisticated
- * identifier validation, segment-based transformation rules, and configurable casing policies.
- *
- * Key features:
- * - Valid identifier detection with fast-path optimization
- * - Configurable first-segment casing (lowerFirst option)
- * - Advanced rule-based transformation (leave, upper, lower arrays)
- * - Cross-platform filename compatibility
- * - Edge case handling for special characters and numeric prefixes
- * - Camel-case conversion for multi-segment identifiers
- *
- * Technical implementation:
- * - Uses regex-based validation for JavaScript identifier compliance
- * - Segment splitting on non-identifier characters [^A-Za-z0-9_$]
- * - Rule precedence: leave → upper → lower → default casing
- * - Safety fallbacks for empty results and invalid identifier starts
- * - Performance-optimized with early returns for valid identifiers
- *
- * Usage context:
- * - File-to-API mapping in slothlet module loading
- * - Dynamic property name generation for module namespaces
- * - Sanitization of user-provided file names into safe property accessors
- *
- *
- * @example
- * // ESM (internal)
- * import { sanitizePathName } from '@cldmv/slothlet/helpers/sanitize';
- * // Internal example using package.json exports
- *
- * @example
- * // Relative import (internal)
- * import { sanitizePathName } from './sanitize.mjs';
- * const apiKey = sanitizePathName('auto-ip.mjs');
- */
 /**
  * @function sanitizePathName
  * @package
@@ -48,37 +5,19 @@
  * @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 {Object} [opts.rules={}] - Advanced segment transformation rules
- * @param {string[]} [opts.rules.leave=[]] - Segments to preserve exactly as-is (case-sensitive)
- * @param {string[]} [opts.rules.upper=[]] - Segments to force to UPPERCASE
- * @param {string[]} [opts.rules.lower=[]] - Segments to force to lowercase
+ * @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)
+ * @param {string[]} [opts.rules.upper=[]] - Segments to force to UPPERCASE (supports globs and **STRING** boundary patterns)
+ * @param {string[]} [opts.rules.lower=[]] - Segments to force to lowercase (supports globs and **STRING** boundary patterns)
  * @returns {string} Valid JavaScript identifier safe for dot-notation property access
  * @throws {TypeError} When input parameter is not a string
  *
  * @description
  * Sanitize a string into a JS identifier suitable for dot-path usage.
- * Core sanitization function that converts arbitrary strings (typically file names) into
- * valid JavaScript identifiers following slothlet's API naming conventions.
- *
- * Sanitization algorithm:
- * 1. **Fast path**: If input is already a valid JS identifier, return unchanged
- * 2. **Segmentation**: Split on non-identifier characters [^A-Za-z0-9_$]
- * 3. **Prefix cleanup**: Remove leading digits/invalid chars from first segment
- * 4. **Rule application**: Apply leave/upper/lower rules with precedence
- * 5. **Default casing**: First segment respects lowerFirst, others get title case
- * 6. **Safety checks**: Ensure result starts with valid identifier character
- *
- * Rule precedence (applied in order):
- * - `leave` rules: Preserve segment exactly as provided
- * - `upper` rules: Force segment to UPPERCASE
- * - `lower` rules: Force segment to lowercase
- * - Default behavior: Apply standard camelCase conversion
- *
- * Edge case handling:
- * - Empty input → "_" (safe fallback identifier)
- * - Numeric prefixes → Stripped from first segment
- * - All invalid chars → Returns "_" + cleaned content
- * - No valid segments → Returns "_"
+ * Advanced sanitization function that applies rules intelligently before splitting while
+ * maintaining proper camelCase transformation. Uses sophisticated tracking to ensure
+ * rule-matched segments are preserved correctly through the transformation process.
  *
  * @example
  * // Basic sanitization (already valid identifiers unchanged)
@@ -93,44 +32,46 @@
  * sanitizePathName("foo-bar-baz");           // "fooBarBaz" (multi-segment camelCase)
  *
  * @example
- * // Numeric prefix handling
- * sanitizePathName("2autoIP");               // "autoIP" (leading digits stripped)
- * sanitizePathName("123-test-file");         // "testFile" (digits stripped, camelCase applied)
+ * // Pre-split pattern matching (matches original filename patterns)
+ * sanitizePathName("auto-ip", {
+ *   rules: {
+ *     upper: ["*-ip"]  // Matches before splitting
+ *   }
+ * }); // Result: "autoIP" (ip becomes IP due to *-ip pattern)
  *
  * @example
- * // First character casing control
- * sanitizePathName("My-File");                        // "myFile" (lowerFirst=true default)
- * sanitizePathName("My-File", { lowerFirst: false }); // "MyFile" (preserve capital first)
- * sanitizePathName("API-util", { lowerFirst: false }); // "APIUtil" (preserve capital first)
+ * // Complex pattern matching with intelligent tracking
+ * sanitizePathName("get-api-status", {
+ *   rules: {
+ *     upper: ["*-api-*"]  // Matches api in middle of filename
+ *   }
+ * }); // Result: "getAPIStatus" (api becomes API due to pattern)
  *
  * @example
- * // Advanced rule-based transformation
- * sanitizePathName("foo-api-json", {
+ * // Boundary-requiring patterns with **STRING** syntax
+ * sanitizePathName("buildUrlWithParams", {
  *   rules: {
- *     leave: ["foo"],    // Keep "foo" exactly as-is
- *     upper: ["api"],    // Force "api" to "API"
- *     lower: ["JSON"]    // Force "JSON" to "json"
+ *     upper: ["**url**"]  // Only matches "url" when surrounded by other characters
  *   }
- * }); // Result: "fooAPIjson"
+ * }); // Result: "buildURLWithParams" (url becomes URL, surrounded by other chars)
  *
- * @example
- * // Real-world slothlet file mapping scenarios
- * sanitizePathName("auto-ip.mjs");           // "autoIp" (common filename pattern)
- * sanitizePathName("parseJSON.mjs");         // "parseJSON" (preserve common acronym)
- * sanitizePathName("get-HTTP-status.js");    // "getHTTPStatus" (multi-acronym handling)
- * sanitizePathName("root-math.mjs");         // "rootMath" (typical slothlet module name)
+ * sanitizePathName("url", {
+ *   rules: {
+ *     upper: ["**url**"]  // Does NOT match standalone "url" (no surrounding chars)
+ *   }
+ * }); // Result: "url" (unchanged - no surrounding characters)
  *
- * @example
- * // Edge cases and safety handling
- * sanitizePathName("");                      // "_" (empty string fallback)
- * sanitizePathName("123");                   // "_" (all numeric becomes fallback)
- * sanitizePathName("!@#$%");                 // "_" (all special chars becomes fallback)
- * sanitizePathName("valid@#$invalid");       // "validInvalid" (special chars removed)
+ * sanitizePathName("parseJsonData", {
+ *   rules: {
+ *     upper: ["**json**"]  // Matches "json" surrounded by other characters
+ *   }
+ * }); // Result: "parseJSONData" (json becomes JSON)
  */
 export function sanitizePathName(input: string, opts?: {
     lowerFirst?: boolean;
     rules?: {
         leave?: string[];
+        leaveInsensitive?: string[];
         upper?: string[];
         lower?: 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":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqFG;AACH,wCAlFW,MAAM,SAEd;IAAuB,UAAU,GAAzB,OAAO;IACO,KAAK,GAC3B;QAA8B,KAAK,GAA3B,MAAM,EAAE;QACc,KAAK,GAA3B,MAAM,EAAE;QACc,KAAK,GAA3B,MAAM,EAAE;KAChB;CAAA,GAAU,MAAM,CAkIlB"}
+{"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"}

package/types/dist/slothlet.d.mts

@@ -96,6 +96,20 @@ export type SlothletOptions = {
      * - Useful for utility functions, constants, or external service connections.
      */
     reference?: object;
+    /**
+     * - Filename sanitization options for API property names.
+     * - Controls how file names are converted to valid JavaScript identifiers.
+     * - Default behavior: camelCase conversion with lowerFirst=true.
+     */
+    sanitize?: {
+        lowerFirst?: boolean;
+        rules?: {
+            leave?: string[];
+            leaveInsensitive?: string[];
+            upper?: string[];
+            lower?: string[];
+        };
+    };
 };
 /**
  * Creates a slothlet API instance with the specified configuration.

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

@@ -1 +1 @@
-{"version":3,"file":"slothlet.d.mts","sourceRoot":"","sources":["../../dist/slothlet.mjs"],"names":[],"mappings":"AA44CA;;;;;;;;;GASG;AACH,kDARW,WAAS,MAAM,UACf,WAAS,MAAM,QAwCzB;AApzCD;;;;;GAKG;AACH,sBAJU,MAAM,CAIoE;AAKpF;;;;;;;GAOG;AACH,mBAJU,MAAM,CAIO;AAEvB;;;;;GAKG;AACH,sBAJU,MAAM,CAIU;AAE1B;;;;;GAKG;AACH,wBAJU,MAAM,CAIY;;;;;;;;;UA4xCd,MAAM;;;;;;WAIN,OAAO;;;;;;;eAGP,MAAM;;;;;;;;YAIN,OAAO;;;;;;;;WAKP,MAAM;;;;;;;eAKN,MAAM;;;;;;cAIN,MAAM;;;;;;gBAGN,MAAM;;AAtzCpB;;;;;;;;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;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"}