@cldmv/slothlet 3.3.0 → 3.4.0

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

@@ -1,145 +1,131 @@
-/**
- * Configuration normalization utilities
- * @class Config
- * @extends ComponentBase
- * @public
- */
 export class Config extends ComponentBase {
     static slothletProperty: string;
-    /**
-     * Normalize collision configuration for handling property collisions
-     * @param {string|Object} collision - Collision mode or object with per-context modes
-     * @returns {Object} Normalized collision configuration with initial and api.slothlet.api.add modes
-     * @public
-     *
-     * @description
-     * Normalizes collision handling configuration for both initial load (buildAPI)
-     * and hot reload (api.add) contexts. Supports six collision modes:
-     * - "skip": Silently ignore collision, keep existing value
-     * - "warn": Warn about collision, keep existing value
-     * - "replace": Replace existing value completely
-     * - "merge": Merge properties (preserve original + add new)
-     * - "merge-replace": Merge properties (add new + overwrite existing with new values)
-     * - "error": Throw error on collision
-     *
-     * @example
-     * // String shorthand applies to both contexts
-     * normalizeCollision("merge")
-     * // => { initial: "merge", api: "merge" }
-     *
-     * @example
-     * // Object allows per-context control
-     * normalizeCollision({ initial: "warn", api: "error" })
-     * // => { initial: "warn", api: "error" }
-     */
-    public normalizeCollision(collision: string | any): any;
-    /**
-     * Normalize runtime input to internal standard format
-     * @param {string} runtime - Input runtime type (various formats accepted)
-     * @returns {string} Normalized runtime type ("async" or "live")
-     * @public
-     */
-    public normalizeRuntime(runtime: string): string;
-    /**
-     * Normalize mode input to internal standard format
-     * @param {string} mode - Input mode type (various formats accepted)
-     * @returns {string} Normalized mode type ("eager" or "lazy")
-     * @public
-     */
-    public normalizeMode(mode: string): string;
-    /**
-     * Normalize mutations configuration for API modification control
-     * @param {Object} mutations - Mutations config object with add/remove/reload properties
-     * @returns {Object} Normalized mutations configuration
-     * @public
-     *
-     * @description
-     * Normalizes mutation control configuration for API runtime modifications.
-     * Controls whether api.slothlet.api.add(), api.slothlet.api.remove(), and
-     * api.slothlet.reload() operations are allowed.
-     *
-     * @example
-     * // Allow all mutations (default)
-     * normalizeMutations({ add: true, remove: true, reload: true })
-     * // => { add: true, remove: true, reload: true }
-     *
-     * @example
-     * // Disable all mutations
-     * normalizeMutations({ add: false, remove: false, reload: false })
-     * // => { add: false, remove: false, reload: false }
-     */
-    public normalizeMutations(mutations: any): any;
-    /**
-     * Normalize debug configuration
-     * @param {boolean|Object} debug - Debug flag or object with targeted flags
-     * @returns {Object} Normalized debug object with all flags
-     * @public
-     */
-    public normalizeDebug(debug: boolean | any): any;
-    /**
-     * Transform and validate configuration
-     * @param {Object} config - Raw configuration options
-     * @returns {Object} Normalized configuration
-     * @throws {SlothletError} If configuration is invalid
-     * @public
-     */
-    public transformConfig(config?: any): any;
-    /**
-     * Normalize TypeScript configuration
-     * @param {boolean|string|Object} typescript - TypeScript config (true, "fast", or { mode: "fast"|"strict", ... })
-     * @returns {Object|null} Normalized TypeScript configuration or null if disabled
-     * @public
-     */
-    public normalizeTypeScript(typescript: boolean | string | any): any | null;
-    /**
-     * Normalize env snapshot configuration.
-     *
-     * @description
-     * Validates the `env` option from user config. When `include` is a non-empty
-     * string array, returns `{ include }` (the allowlist used by `_captureEnvSnapshot`).
-     * Any other value — including `undefined`, `null`, `{}`, or an empty `include`
-     * array — is normalised to `null`, meaning the full `process.env` snapshot is used.
-     *
-     * @param {Object|null|undefined} env - Raw env option from user config.
-     * @param {string[]} [env.include] - Allowlist of env variable names to capture.
-     * @returns {{ include: string[] }|null} Normalized env config, or `null` for full snapshot.
-     * @public
-     *
-     * @example
-     * // No restriction — full snapshot
-     * normalizeEnv(undefined); // => null
-     * normalizeEnv(null);      // => null
-     * normalizeEnv({});        // => null
-     *
-     * @example
-     * // Include allowlist
-     * normalizeEnv({ include: ["NODE_ENV", "PORT"] });
-     * // => { include: ["NODE_ENV", "PORT"] }
-     *
-     * @example
-     * // Non-string keys in the include array are filtered out
-     * normalizeEnv({ include: ["NODE_ENV", 42, null] });
-     * // => { include: ["NODE_ENV"] }
-     */
-    public normalizeEnv(env: any | null | undefined): {
-        include: string[];
+    normalizeCollision(collision: any): {
+        initial: string;
+        api: string;
+    };
+    normalizeRuntime(runtime: any): "async" | "live";
+    normalizeMode(mode: any): "eager" | "lazy";
+    normalizeMutations(mutations: any): {
+        add: boolean;
+        remove: boolean;
+        reload: boolean;
+        permissions: boolean;
+    };
+    normalizeDebug(debug: any): {
+        builder: any;
+        api: any;
+        index: any;
+        modes: any;
+        wrapper: any;
+        ownership: any;
+        context: any;
+        initialization: any;
+        materialize: any;
+        versioning: any;
+        permissions: any;
+    };
+    transformConfig(config?: {}): {
+        dir: any;
+        mode: string;
+        runtime: string;
+        apiDepth: any;
+        reference: any;
+        context: any;
+        i18n: {
+            language: any;
+        } | null;
+        debug: {
+            builder: any;
+            api: any;
+            index: any;
+            modes: any;
+            wrapper: any;
+            ownership: any;
+            context: any;
+            initialization: any;
+            materialize: any;
+            versioning: any;
+            permissions: any;
+        };
+        diagnostics: boolean;
+        hook: {
+            enabled: boolean;
+            pattern: string;
+            suppressErrors: boolean;
+        };
+        collision: {
+            initial: string;
+            api: string;
+        };
+        api: {
+            collision: {
+                initial: string;
+                api: string;
+            };
+            mutations: {
+                add: boolean;
+                remove: boolean;
+                reload: boolean;
+                permissions: boolean;
+            } | {
+                add: boolean;
+                remove: boolean;
+                reload: boolean;
+            };
+        };
+        scope: any;
+        tracking: {
+            materialization: boolean;
+        };
+        backgroundMaterialize: boolean;
+        silent: boolean;
+        typescript: {
+            enabled: boolean;
+            mode: string;
+            types?: undefined;
+            target?: undefined;
+            sourcemap?: undefined;
+        } | {
+            enabled: boolean;
+            mode: string;
+            types: any;
+            target: any;
+            sourcemap: any;
+        } | null;
+        env: {
+            include: any;
+        } | null;
+        versionDispatcher: any;
+        permissions: {
+            defaultPolicy: string;
+            enabled: boolean;
+            audit: string;
+            rules: any;
+        } | null;
+    };
+    normalizeTypeScript(typescript: any): {
+        enabled: boolean;
+        mode: string;
+        types?: undefined;
+        target?: undefined;
+        sourcemap?: undefined;
+    } | {
+        enabled: boolean;
+        mode: string;
+        types: any;
+        target: any;
+        sourcemap: any;
+    } | null;
+    normalizeEnv(env: any): {
+        include: any;
+    } | null;
+    normalizePermissions(permissions: any): {
+        defaultPolicy: string;
+        enabled: boolean;
+        audit: string;
+        rules: any;
     } | null;
-    /**
-     * Normalize permissions configuration.
-     *
-     * @param {object|null} [permissions] - Raw permissions config from user.
-     * @param {string} [permissions.defaultPolicy="allow"] - Fallback policy: "allow" or "deny".
-     * @param {boolean} [permissions.enabled=true] - Global toggle.
-     * @param {string|boolean} [permissions.audit="default"] - Audit level: `"default"` (denied + self-bypass only),
-     *   `"verbose"` (all decisions). `true` and `false` are accepted and both normalize to `"default"`.
-     * @param {Array<object>} [permissions.rules=[]] - Initial permission rules.
-     * @returns {object|null} Normalized permissions config, or null when permissions is absent or not an object.
-     *
-     * @example
-     * normalizePermissions({ defaultPolicy: "deny", rules: [{ caller: "**", target: "admin.**", effect: "deny" }] });
-     * // => { defaultPolicy: "deny", enabled: true, audit: "default", rules: [...] }
-     */
-    normalizePermissions(permissions?: object | null): object | null;
 }
 import { ComponentBase } from "@cldmv/slothlet/factories/component-base";
 //# sourceMappingURL=config.d.mts.map

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

@@ -1 +1 @@
-{"version":3,"file":"config.d.mts","sourceRoot":"","sources":["../../../../dist/lib/helpers/config.mjs"],"names":[],"mappings":"AAqBA;;;;;GAKG;AACH;IACC,gCAAmC;IAEnC;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,qCAxBW,MAAM,MAAO,OAkDvB;IAED;;;;;OAKG;IACH,iCAJW,MAAM,GACJ,MAAM,CAsBlB;IAED;;;;;OAKG;IACH,2BAJW,MAAM,GACJ,MAAM,CAsBlB;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,+CAeC;IAED;;;;;OAKG;IACH,6BAJW,OAAO,MAAO,OAqExB;IAED;;;;;;OAMG;IACH,0CA+IC;IAED;;;;;OAKG;IACH,uCAJW,OAAO,GAAC,MAAM,MAAO,GACnB,MAAO,IAAI,CAsCvB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,yBArBW,MAAO,IAAI,GAAC,SAAS,GAEnB;QAAE,OAAO,EAAE,MAAM,EAAE,CAAA;KAAE,GAAC,IAAI,CA4BtC;IAED;;;;;;;;;;;;;;OAcG;IACH,mCAZW,MAAM,GAAC,IAAI,GAMT,MAAM,GAAC,IAAI,CA6EvB;CACD;8BA1iB6B,0CAA0C"}
+{"version":3,"file":"config.d.mts","sourceRoot":"","sources":["../../../../dist/lib/helpers/config.mjs"],"names":[],"mappings":"AAAsH;IAAmC,gCAAiC;IAAA;;;MAA2mB;IAAA,iDAA+U;IAAA,2CAA0S;IAAA;;;;;MAAqV;IAAA;;;;;;;;;;;;MAA46B;IAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAAyoH;IAAA;;;;;;;;;;;;aAAyf;IAAA;;aAAiN;IAAA;;;;;aAA2wC;CAAC;8BAAruQ,0CAA0C"}

package/types/dist/lib/helpers/eventemitter-context.d.mts

@@ -1,31 +1,5 @@
-/**
- * Set the context checker callback
- * Called by the runtime to register a way to detect API context
- * @param {Function} checker - Function that returns true if in API context
- * @public
- */
-export function setApiContextChecker(checker: Function): void;
-/**
- * Enable EventEmitter context propagation by patching EventEmitter.prototype.
- * This should be called ONCE globally when the first slothlet instance is created.
- * Subsequent calls will be ignored (patching is global).
- *
- * @public
- */
-export function enableEventEmitterPatching(): void;
-/**
- * Disable EventEmitter context propagation and restore original methods.
- * This should only be called when ALL slothlet instances have been shut down.
- *
- * @public
- */
-export function disableEventEmitterPatching(): void;
-/**
- * Cleanup all tracked EventEmitters created within slothlet API context.
- * This removes all listeners from tracked emitters and clears tracking structures.
- * Should be called during shutdown to prevent memory leaks and hanging processes.
- *
- * @public
- */
 export function cleanupEventEmitterResources(): void;
+export function disableEventEmitterPatching(): void;
+export function enableEventEmitterPatching(): void;
+export function setApiContextChecker(checker: any): void;
 //# sourceMappingURL=eventemitter-context.d.mts.map

package/types/dist/lib/helpers/eventemitter-context.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"eventemitter-context.d.mts","sourceRoot":"","sources":["../../../../dist/lib/helpers/eventemitter-context.mjs"],"names":[],"mappings":"AAsCA;;;;;GAKG;AACH,8DAEC;AAyWD;;;;;;GAMG;AACH,mDAeC;AAED;;;;;GAKG;AACH,oDAmBC;AAED;;;;;;GAMG;AACH,qDAcC"}
+{"version":3,"file":"eventemitter-context.d.mts","sourceRoot":"","sources":["../../../../dist/lib/helpers/eventemitter-context.mjs"],"names":[],"mappings":"AAAu2M,qDAAmL;AAAtjB,oDAAmY;AAAroB,mDAAkQ;AAA13L,yDAA8D"}

package/types/dist/lib/helpers/hint-detector.d.mts

@@ -1,20 +1,7 @@
-/**
- * Hint detection for providing helpful error hints
- * @class HintDetector
- * @extends ComponentBase
- * @package
- */
 export class HintDetector extends ComponentBase {
     static slothletProperty: string;
-    /**
-     * Detect appropriate hint key based on error
-     * @param {Error} error - The original error
-     * @param {string} errorCode - The SlothletError code
-     * @returns {string|undefined} Hint key for i18n translation, or undefined
-     * @public
-     */
-    public detectHint(error: Error, errorCode: string): string | undefined;
+    detectHint(error: any, errorCode: any): string;
 }
-export const detectHint: any;
+export function detectHint(error: any, errorCode: any): string;
 import { ComponentBase } from "@cldmv/slothlet/factories/component-base";
 //# sourceMappingURL=hint-detector.d.mts.map

package/types/dist/lib/helpers/hint-detector.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"hint-detector.d.mts","sourceRoot":"","sources":["../../../../dist/lib/helpers/hint-detector.mjs"],"names":[],"mappings":"AAwCA;;;;;GAKG;AACH;IACC,gCAAyC;IAEzC;;;;;;OAMG;IACH,yBALW,KAAK,aACL,MAAM,GACJ,MAAM,GAAC,SAAS,CAiB5B;CACD;AAID,6BAA2G;8BAxD7E,0CAA0C"}
+{"version":3,"file":"hint-detector.d.mts","sourceRoot":"","sources":["../../../../dist/lib/helpers/hint-detector.mjs"],"names":[],"mappings":"AAA4S;IAAyC,gCAAuC;IAAA,+CAA2M;CAAC;AAA5M,+DAA2M;8BAA9iB,0CAA0C"}

package/types/dist/lib/helpers/modes-utils.d.mts

@@ -1,35 +1,8 @@
-/**
- * Mode processing utilities component class
- * @extends ComponentBase
- */
 export class ModesUtils extends ComponentBase {
     static slothletProperty: string;
-    /**
-     * Create a named wrapper for default export functions when they are anonymous.
-     * NOTE: This function is now a pass-through since UnifiedWrapper handles name/length/toString
-     * through its proxy get trap. Wrapping is no longer needed and causes toString mismatches.
-     * @param {Function} fn - Original function.
-     * @param {string} nameHint - Name to apply if fn is anonymous or named "default" (unused).
-     * @returns {Function} Original function unmodified.
-     * @public
-     */
-    public ensureNamedExportFunction(fn: Function, ____nameHint: any): Function;
-    /**
-     * Clone eager-mode module exports to avoid mutating import cache objects.
-     * @param {unknown} value - Value to clone for wrapping
-     * @param {string} mode - Current mode ("eager" or "lazy")
-     * @returns {unknown} Cloned value for eager mode, original otherwise
-     * @public
-     */
-    public cloneWrapperImpl(value: unknown, mode: string): unknown;
-    /**
-     * Helper to determine collision mode for ownership conflicts
-     * @param {Object} config - Slothlet configuration
-     * @param {string} collisionContext - Either 'initial' or 'api'
-     * @returns {string} Collision mode from config
-     * @public
-     */
-    public getOwnershipCollisionMode(config: any, collisionContext?: string): string;
+    ensureNamedExportFunction(fn: any, ____nameHint: any): any;
+    cloneWrapperImpl(value: any, mode: any): any;
+    getOwnershipCollisionMode(config: any, collisionContext?: string): any;
 }
 import { ComponentBase } from "@cldmv/slothlet/factories/component-base";
 //# sourceMappingURL=modes-utils.d.mts.map

package/types/dist/lib/helpers/modes-utils.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"modes-utils.d.mts","sourceRoot":"","sources":["../../../../dist/lib/helpers/modes-utils.mjs"],"names":[],"mappings":"AAqBA;;;GAGG;AACH;IACC,gCAAuC;IAEvC;;;;;;;;OAQG;IACH,4EAIC;IAED;;;;;;OAMG;IACH,+BALW,OAAO,QACP,MAAM,GACJ,OAAO,CAenB;IAED;;;;;;OAMG;IACH,iEAJW,MAAM,GACJ,MAAM,CAKlB;CACD;8BAvD6B,0CAA0C"}
+{"version":3,"file":"modes-utils.d.mts","sourceRoot":"","sources":["../../../../dist/lib/helpers/modes-utils.mjs"],"names":[],"mappings":"AAAoE;IAAuC,gCAAqC;IAAA,2DAAqD;IAAA,6CAAqR;IAAA,uEAAkH;CAAC;8BAApjB,0CAA0C"}

package/types/dist/lib/helpers/pattern-matcher.d.mts

@@ -1,44 +1,4 @@
-/**
- * Compile a glob pattern into a matcher function.
- * Supports: * (any chars except .), ** (any chars including .), ? (single char),
- * {a,b} brace expansion, !pattern negation
- *
- * @param {string} pattern - Glob pattern
- * @param {object} [options={}] - Options
- * @param {Function} [options.onMaxDepth] - Called when brace expansion exceeds max depth.
- *   Should throw an error. If not provided, a SlothletError("BRACE_EXPANSION_MAX_DEPTH") is thrown.
- * @returns {function} Matcher function that takes a path and returns boolean
- * @example
- * const matcher = compilePattern("payments.**");
- * matcher("payments.charge"); // true
- * matcher("admin.users");     // false
- */
-export function compilePattern(pattern: string, options?: {
-    onMaxDepth?: Function;
-}): Function;
-/**
- * Expand brace patterns {a,b,c} into multiple patterns.
- * Supports nested braces with configurable depth limit.
- *
- * @param {string} pattern - Pattern with braces to expand
- * @param {number} [depth=0] - Current recursion depth
- * @param {number} [maxDepth=10] - Maximum nesting depth
- * @param {object} [options={}] - Options
- * @param {Function} [options.onMaxDepth] - Called when max depth exceeded. Should throw.
- * @returns {string[]} Array of expanded patterns
- * @example
- * expandBraces("{a,b}.path"); // ["a.path", "b.path"]
- */
-export function expandBraces(pattern: string, depth?: number, maxDepth?: number, options?: {
-    onMaxDepth?: Function;
-}): string[];
-/**
- * Split brace alternatives on commas, respecting nested braces.
- *
- * @param {string} content - Content inside braces
- * @returns {string[]} Array of alternatives
- * @example
- * splitBraceAlternatives("a,b,c"); // ["a", "b", "c"]
- */
-export function splitBraceAlternatives(content: string): string[];
+export function compilePattern(pattern: any, options?: {}): any;
+export function expandBraces(pattern: any, depth?: number, maxDepth?: number, options?: {}): any;
+export function splitBraceAlternatives(content: any): string[];
 //# sourceMappingURL=pattern-matcher.d.mts.map

package/types/dist/lib/helpers/pattern-matcher.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"pattern-matcher.d.mts","sourceRoot":"","sources":["../../../../dist/lib/helpers/pattern-matcher.mjs"],"names":[],"mappings":"AAoCA;;;;;;;;;;;;;;GAcG;AACH,wCAVW,MAAM,YAEd;IAA2B,UAAU;CAErC,YAsCF;AAED;;;;;;;;;;;;GAYG;AACH,sCATW,MAAM,UACN,MAAM,aACN,MAAM,YAEd;IAA2B,UAAU;CACrC,GAAU,MAAM,EAAE,CAwDpB;AAED;;;;;;;GAOG;AACH,gDALW,MAAM,GACJ,MAAM,EAAE,CA+BpB"}
+{"version":3,"file":"pattern-matcher.d.mts","sourceRoot":"","sources":["../../../../dist/lib/helpers/pattern-matcher.mjs"],"names":[],"mappings":"AAAkD,gEAA+oB;AAAA,iGAA44B;AAAA,+DAAqX"}

package/types/dist/lib/helpers/resolve-from-caller.d.mts

@@ -1,32 +1,8 @@
-/**
- * Path resolver component
- * @class Resolver
- * @extends ComponentBase
- * @package
- */
 export class Resolver extends ComponentBase {
     static slothletProperty: string;
-    /**
-     * Get V8 stack trace as CallSite array.
-     * @param {Function} [skipFn] - Optional function to skip from stack trace
-     * @returns {Array} Array of CallSite objects
-     * @public
-     */
-    public getStack(skipFn?: Function): any[];
-    /**
-     * Convert file:// URL to filesystem path or return as-is.
-     * @param {any} v - Value to convert
-     * @returns {string|null} Filesystem path or null
-     * @public
-     */
-    public toFsPath(v: any): string | null;
-    /**
-     * Resolve relative path from caller's context.
-     * @param {string} rel - Relative path to resolve
-     * @returns {string} Absolute filesystem path
-     * @public
-     */
-    public resolvePathFromCaller(rel: string): string;
+    getStack(skipFn: any): string | undefined;
+    toFsPath(v: any): any;
+    resolvePathFromCaller(rel: any): any;
     #private;
 }
 import { ComponentBase } from "@cldmv/slothlet/factories/component-base";

package/types/dist/lib/helpers/resolve-from-caller.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"resolve-from-caller.d.mts","sourceRoot":"","sources":["../../../../dist/lib/helpers/resolve-from-caller.mjs"],"names":[],"mappings":"AAqCA;;;;;GAKG;AACH;IACC,gCAAqC;IAErC;;;;;OAKG;IACH,0CAUC;IAeD;;;;;OAKG;IACH,mBAJW,GAAG,GACD,MAAM,GAAC,IAAI,CAOvB;IA+FD;;;;;OAKG;IACH,kCAJW,MAAM,GACJ,MAAM,CAsClB;;CACD;8BAvM6B,0CAA0C"}
+{"version":3,"file":"resolve-from-caller.d.mts","sourceRoot":"","sources":["../../../../dist/lib/helpers/resolve-from-caller.mjs"],"names":[],"mappings":"AAAwX;IAAqC,gCAAmC;IAAA,0CAA2N;IAA0L,sBAA0G;IAAm5B,qCAA0c;;CAAC;8BAA5qE,0CAA0C"}

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

@@ -1,98 +1,10 @@
-/**
- * Standalone sanitizePropertyName function for backward compatibility
- * @param {string} input - Input string to sanitize
- * @param {object} options - Sanitization options
- * @returns {string} Sanitized property name
- * @public
- */
-export function sanitizePropertyName(input: string, options?: object): string;
-/**
- * Advanced filename sanitization with rule-based transformation
- * @extends ComponentBase
- * @public
- */
 export class Sanitize extends ComponentBase {
     static slothletProperty: string;
-    /**
-     * Advanced sanitization function with configurable rule-based transformation
-     *
-     * @description
-     * Converts arbitrary strings (filenames, path segments) into valid JavaScript identifiers
-     * suitable for dot-notation property access. Supports sophisticated rule-based transformation
-     * with glob patterns, case preservation, and intelligent segment handling.
-     *
-     * @param {string} input - String to sanitize
-     * @param {Object} [options={}] - Sanitization configuration
-     * @param {boolean} [options.lowerFirst=true] - Lowercase first character of first segment
-     * @param {boolean} [options.preserveAllUpper=false] - Preserve all-uppercase identifiers
-     * @param {boolean} [options.preserveAllLower=false] - Preserve all-lowercase identifiers
-     * @param {Object} [options.rules={}] - Transformation rules
-     * @param {string[]} [options.rules.leave=[]] - Preserve exactly (case-sensitive, supports globs)
-     * @param {string[]} [options.rules.leaveInsensitive=[]] - Preserve exactly (case-insensitive, supports globs)
-     * @param {string[]} [options.rules.upper=[]] - Force UPPERCASE (supports globs and **STRING**)
-     * @param {string[]} [options.rules.lower=[]] - Force lowercase (supports globs and **STRING**)
-     * @returns {string} Valid JavaScript identifier
-     * @public
-     *
-     * @example
-     * // Basic usage
-     * sanitizePropertyName("auto-ip"); // "autoIp"
-     * sanitizePropertyName("root-math"); // "rootMath"
-     *
-     * @example
-     * // Rule-based transformation
-     * sanitizePropertyName("auto-ip", {
-     *   rules: { upper: ["*-ip"] }
-     * }); // "autoIP"
-     *
-     * @example
-     * // Boundary-requiring patterns
-     * sanitizePropertyName("parseJsonData", {
-     *   rules: { upper: ["**json**"] }
-     * }); // "parseJSONData"
-     *
-     * @example
-     * // Case preservation
-     * sanitizePropertyName("COMMON_APPS", {
-     *   preserveAllUpper: true
-     * }); // "COMMON_APPS"
-     *
-     * @example
-     * // Multiple rules
-     * sanitizePropertyName("get-api-status", {
-     *   rules: {
-     *     upper: ["*-api-*", "http"],
-     *     lower: ["xml"]
-     *   }
-     * }); // "getAPIStatus"
-     */
-    public sanitizePropertyName(input: string, options?: {
-        lowerFirst?: boolean;
-        preserveAllUpper?: boolean;
-        preserveAllLower?: boolean;
-        rules?: {
-            leave?: string[];
-            leaveInsensitive?: string[];
-            upper?: string[];
-            lower?: string[];
-        };
-    }): string;
-    /**
-     * Get module ID from file path
-     * @param {string} filePath - Full file path
-     * @param {string} baseDir - Base directory
-     * @returns {string} Module ID
-     * @public
-     */
-    public getModuleId(filePath: string, baseDir: string): string;
-    /**
-     * Check if filename represents a special function name that should preserve case
-     * @param {string} name - Name to check
-     * @returns {boolean} True if special case should be preserved
-     * @public
-     */
-    public shouldPreserveFunctionCase(name: string): boolean;
+    sanitizePropertyName(input: any, options?: {}): string;
+    getModuleId(filePath: any, baseDir: any): any;
+    shouldPreserveFunctionCase(name: any): boolean;
     #private;
 }
+export function sanitizePropertyName(input: any, options?: {}): string;
 import { ComponentBase } from "@cldmv/slothlet/factories/component-base";
 //# sourceMappingURL=sanitize.d.mts.map

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":"AAkcA;;;;;;GAMG;AACH,4CALW,MAAM,YACN,MAAM,GACJ,MAAM,CAMlB;AAnbD;;;;GAIG;AACH;IACC,gCAAqC;IA6LrC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAoDG;IACH,mCA7CW,MAAM,YAEd;QAA0B,UAAU,GAA5B,OAAO;QACW,gBAAgB,GAAlC,OAAO;QACW,gBAAgB,GAAlC,OAAO;QACU,KAAK,GAC9B;YAAiC,KAAK,GAA9B,MAAM,EAAE;YACiB,gBAAgB,GAAzC,MAAM,EAAE;YACiB,KAAK,GAA9B,MAAM,EAAE;YACiB,KAAK,GAA9B,MAAM,EAAE;SAChB;KAAA,GAAU,MAAM,CA8KlB;IAED;;;;;;OAMG;IACH,6BALW,MAAM,WACN,MAAM,GACJ,MAAM,CAUlB;IAED;;;;;OAKG;IACH,wCAJW,MAAM,GACJ,OAAO,CAUnB;;CACD;8BAza6B,0CAA0C"}
+{"version":3,"file":"sanitize.d.mts","sourceRoot":"","sources":["../../../../dist/lib/helpers/sanitize.mjs"],"names":[],"mappings":"AAAoE;IAAqC,gCAAmC;IAAg6G,uDAA4qG;IAAA,8CAA+L;IAAA,+CAA8I;;CAAC;AAAA,uEAAwI;8BAArpO,0CAA0C"}