locai 2.6.2 → 2.7.0

package/dist/utils/input-validator.js

@@ -3,8 +3,16 @@
  * Defines regex patterns, limits, and validation methods.
  */
 import path from "path";
+const isObject = (value) => typeof value === "object" && value !== null;
+const errorMessage = (error) => error instanceof Error ? error.message : String(error);
 class InputValidator {
-    static LANGUAGE_CODE_PATTERN = /^[a-z]{2}(-[a-z]{2})?$/;
+    /**
+     * Well-formed BCP 47 language tag, limited to the subtags locai supports:
+     * a 2-3 letter language, an optional 4-letter script and an optional
+     * 2-letter or 3-digit region (e.g. "en", "fil", "pt-BR", "zh-Hant-TW", "es-419").
+     * Matching is case-insensitive; see validateLanguageCode for canonical casing.
+     */
+    static LANGUAGE_CODE_PATTERN = /^([a-z]{2,3})(?:-([a-z]{4}))?(?:-([a-z]{2}|\d{3}))?$/i;
     static VALID_PROVIDERS = [
         "dashscope",
         "xai",
@@ -17,44 +25,43 @@ class InputValidator {
     static MAX_KEY_LENGTH = 500;
     static MAX_PATH_LENGTH = 1000;
     static MAX_CONFIG_DEPTH = 10;
-    static DANGEROUS_PATTERNS = [
-        /\.\.\//g,
-        /\0/g,
-        /[\x00-\x08\x0b\x0c\x0e-\x1f\x7F]/g, // eslint-disable-line no-control-regex
-        /<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi,
-        /javascript:/gi,
-        /data:.*base64/gi,
-    ];
-    static _requestCounts;
     /**
-     * Validate and sanitize language code.
-     * @param {string} langCode - Language code to validate.
+     * Validate a BCP 47 language tag and return it in canonical casing:
+     * lowercase language, title-case script, uppercase region
+     * (e.g. "ZH-hant-tw" -> "zh-Hant-TW", "PT-br" -> "pt-BR").
+     * @param {unknown} langCode - Language tag to validate.
      * @param {string} [paramName="language"] - Parameter name for error messages.
-     * @returns {string} - Sanitized language code.
+     * @returns {string} - Canonical language tag.
      * @throws {Error} If validation fails.
      */
     static validateLanguageCode(langCode, paramName = "language") {
         if (!langCode || typeof langCode !== "string") {
             throw new Error(`${paramName} must be a non-empty string`);
         }
-        const sanitized = langCode.trim().toLowerCase();
-        if (sanitized.length === 0) {
+        const trimmed = langCode.trim();
+        if (trimmed.length === 0) {
             throw new Error(`${paramName} cannot be empty after trimming`);
         }
-        if (sanitized.length > 10) {
-            throw new Error(`${paramName} code too long: '${langCode}' (max 10 characters)`);
-        }
-        if (sanitized.includes("..") || sanitized.includes("/") || sanitized.includes("\\")) {
+        if (trimmed.includes("..") || trimmed.includes("/") || trimmed.includes("\\")) {
             throw new Error(`${paramName} code contains forbidden characters: '${langCode}'`);
         }
-        if (!this.LANGUAGE_CODE_PATTERN.test(sanitized)) {
-            throw new Error(`Invalid ${paramName} code: '${langCode}'. Must match pattern: ${this.LANGUAGE_CODE_PATTERN}`);
+        const match = this.LANGUAGE_CODE_PATTERN.exec(trimmed);
+        if (!match) {
+            throw new Error(`Invalid ${paramName} code: '${langCode}'. Expected a BCP 47 language tag such as 'en', 'fil', 'pt-BR', 'zh-Hant' or 'es-419'`);
         }
-        return sanitized;
+        const [, language, script, region] = match;
+        let canonical = language.toLowerCase();
+        if (script) {
+            canonical += `-${script.charAt(0).toUpperCase()}${script.slice(1).toLowerCase()}`;
+        }
+        if (region) {
+            canonical += `-${region.toUpperCase()}`;
+        }
+        return canonical;
     }
     /**
      * Validate array of language codes.
-     * @param {string[]} langCodes - Array of language codes.
+     * @param {unknown} langCodes - Array of language codes.
      * @param {string} [paramName="languages"] - Parameter name for errors.
      * @returns {string[]} - Sanitized array of language codes.
      * @throws {Error} If array is empty or contains invalid codes.
@@ -73,7 +80,7 @@ class InputValidator {
     }
     /**
      * Validate and sanitize directory path.
-     * @param {string} dirPath - Directory path.
+     * @param {unknown} dirPath - Directory path.
      * @param {string} [paramName="directory"] - Parameter name for errors.
      * @returns {string} - Resolved and validated absolute path.
      * @throws {Error} If path is invalid or outside working directory.
@@ -91,7 +98,7 @@ class InputValidator {
     }
     /**
      * Validate translation text.
-     * @param {string} text - Text to validate.
+     * @param {unknown} text - Text to validate.
      * @param {string} [paramName="text"] - Parameter name for errors.
      * @returns {string} - Validated text.
      * @throws {Error} If text is invalid or too long.
@@ -110,7 +117,7 @@ class InputValidator {
     }
     /**
      * Validate translation key.
-     * @param {string} key - Key to validate.
+     * @param {unknown} key - Key to validate.
      * @param {string} [paramName="key"] - Parameter name.
      * @returns {string} - Validated key.
      * @throws {Error} If key is invalid, too long, or contains traversal.
@@ -129,7 +136,7 @@ class InputValidator {
     }
     /**
      * Validate API provider name.
-     * @param {string} provider - Provider name.
+     * @param {unknown} provider - Provider name.
      * @param {string} [fieldName="API provider"] - Parameter name.
      * @returns {string} - Normalized provider name.
      * @throws {Error} If provider is unknown.
@@ -157,7 +164,7 @@ class InputValidator {
         }
         let sanitized = path
             .basename(filename)
-            .replace(/[<>:"/\\|?*\x00-\x1f]/g, "") // eslint-disable-line no-control-regex
+            .replace(/[<>:"/\\|?*\x00-\x1f]/g, "") // eslint-disable-line no-control-regex -- strip ASCII control characters
             .replace(/^\.+/, "")
             .trim();
         if (!sanitized) {
@@ -187,12 +194,14 @@ class InputValidator {
     }
     /**
      * Validate configuration object.
-     * @param {any} config - Configuration object to validate.
+     * Rewrites `source` and `targets` in place to canonical BCP 47 casing so that
+     * file lookups and per-language settings all see the same tag.
+     * @param {unknown} config - Configuration object to validate.
      * @returns {AppConfig} - Validated configuration.
      * @throws {Error} If configuration is invalid.
      */
     static validateConfig(config) {
-        if (!config || typeof config !== "object") {
+        if (!isObject(config)) {
             throw new Error("Configuration must be an object");
         }
         // Check config depth to prevent circular references
@@ -205,10 +214,10 @@ class InputValidator {
         }
         else {
             try {
-                this.validateLanguageCode(config.source, "source language");
+                config.source = this.validateLanguageCode(config.source, "source language");
             }
             catch (error) {
-                errors.push(`Invalid source language: ${error.message}`);
+                errors.push(`Invalid source language: ${errorMessage(error)}`);
             }
         }
         if (!config.targets || !Array.isArray(config.targets) || config.targets.length === 0) {
@@ -216,10 +225,10 @@ class InputValidator {
         }
         else {
             try {
-                this.validateLanguageCodes(config.targets, "target languages");
+                config.targets = this.validateLanguageCodes(config.targets, "target languages");
             }
             catch (error) {
-                errors.push(`Invalid target languages: ${error.message}`);
+                errors.push(`Invalid target languages: ${errorMessage(error)}`);
             }
         }
         if (!config.localesDir) {
@@ -231,7 +240,7 @@ class InputValidator {
                 this.validateProvider(config.apiProvider, "API provider");
             }
             catch (error) {
-                errors.push(`Invalid API provider: ${error.message}`);
+                errors.push(`Invalid API provider: ${errorMessage(error)}`);
             }
         }
         else {
@@ -248,27 +257,27 @@ class InputValidator {
                         this.validateProvider(provider, "fallback provider");
                     }
                     catch (error) {
-                        errors.push(`Invalid provider in fallbackOrder: ${error.message}`);
+                        errors.push(`Invalid provider in fallbackOrder: ${errorMessage(error)}`);
                     }
                 }
             }
         }
         // Concurrency validation
         if (config.concurrencyLimit !== undefined) {
-            const limit = parseInt(config.concurrencyLimit);
+            const limit = parseInt(String(config.concurrencyLimit));
             if (isNaN(limit) || limit < 1 || limit > 50) {
                 errors.push("'concurrencyLimit' must be a number between 1 and 50");
             }
         }
         // Cache configuration validation
         if (config.cacheSize !== undefined) {
-            const size = parseInt(config.cacheSize);
+            const size = parseInt(String(config.cacheSize));
             if (isNaN(size) || size < 100 || size > 10000) {
                 errors.push("'cacheSize' must be a number between 100 and 10000");
             }
         }
         if (config.cacheTTL !== undefined) {
-            const ttl = parseInt(config.cacheTTL);
+            const ttl = parseInt(String(config.cacheTTL));
             if (isNaN(ttl) || ttl < 0) {
                 errors.push("'cacheTTL' must be a non-negative number (milliseconds)");
             }
@@ -278,7 +287,7 @@ class InputValidator {
         }
         // API Config validation
         if (config.apiConfig) {
-            if (typeof config.apiConfig !== "object") {
+            if (!isObject(config.apiConfig)) {
                 errors.push("'apiConfig' must be an object");
             }
             else {
@@ -287,7 +296,7 @@ class InputValidator {
         }
         // Rate Limiter validation
         if (config.rateLimiter) {
-            if (typeof config.rateLimiter !== "object") {
+            if (!isObject(config.rateLimiter)) {
                 errors.push("'rateLimiter' must be an object");
             }
             else {
@@ -296,7 +305,7 @@ class InputValidator {
         }
         // Retry options validation
         if (config.retryOptions) {
-            if (typeof config.retryOptions !== "object") {
+            if (!isObject(config.retryOptions)) {
                 errors.push("'retryOptions' must be an object");
             }
             else {
@@ -305,7 +314,7 @@ class InputValidator {
         }
         // Context configuration validation
         if (config.context) {
-            if (typeof config.context !== "object") {
+            if (!isObject(config.context)) {
                 errors.push("'context' must be an object");
             }
             else {
@@ -314,7 +323,7 @@ class InputValidator {
         }
         // Quality checks validation
         if (config.qualityChecks) {
-            if (typeof config.qualityChecks !== "object") {
+            if (!isObject(config.qualityChecks)) {
                 errors.push("'qualityChecks' must be an object");
             }
             else {
@@ -323,7 +332,7 @@ class InputValidator {
         }
         // Length control validation
         if (config.lengthControl) {
-            if (typeof config.lengthControl !== "object") {
+            if (!isObject(config.lengthControl)) {
                 errors.push("'lengthControl' must be an object");
             }
             else {
@@ -332,7 +341,7 @@ class InputValidator {
         }
         // Advanced settings validation
         if (config.advanced) {
-            if (typeof config.advanced !== "object") {
+            if (!isObject(config.advanced)) {
                 errors.push("'advanced' must be an object");
             }
             else {
@@ -361,7 +370,7 @@ class InputValidator {
     }
     /**
      * Validate API config for each provider.
-     * @param {Record<string, ApiProviderConfig>} apiConfig - API configuration object.
+     * @param {Record<string, unknown>} apiConfig - Raw API configuration object.
      * @param {string[]} errors - Array to push errors to.
      * @param {string[]} warnings - Array to push warnings to.
      */
@@ -371,13 +380,13 @@ class InputValidator {
                 warnings.push(`Unknown provider in apiConfig: '${provider}'`);
                 continue;
             }
-            if (typeof settings !== "object") {
+            if (!isObject(settings)) {
                 errors.push(`apiConfig.${provider} must be an object`);
                 continue;
             }
             // Validate temperature
             if (settings.temperature !== undefined) {
-                const temp = parseFloat(settings.temperature);
+                const temp = parseFloat(String(settings.temperature));
                 if (isNaN(temp) || temp < 0 || temp > 2) {
                     errors.push(`apiConfig.${provider}.temperature must be between 0 and 2`);
                 }
@@ -387,7 +396,7 @@ class InputValidator {
             }
             // Validate maxTokens
             if (settings.maxTokens !== undefined) {
-                const tokens = parseInt(settings.maxTokens);
+                const tokens = parseInt(String(settings.maxTokens));
                 if (isNaN(tokens) || tokens < 100 || tokens > 8000) {
                     errors.push(`apiConfig.${provider}.maxTokens must be between 100 and 8000`);
                 }
@@ -396,25 +405,26 @@ class InputValidator {
     }
     /**
      * Validate rate limiter configuration.
-     * @param {RateLimiterConfig} rateLimiter - Rate limiter configuration.
+     * @param {Record<string, unknown>} rateLimiter - Raw rate limiter configuration.
      * @param {string[]} errors - Array to push errors to.
      * @param {string[]} warnings - Array to push warnings to.
      */
     static validateRateLimiterConfig(rateLimiter, errors, _warnings) {
         if (rateLimiter.queueStrategy) {
             const validStrategies = ["fifo", "priority"];
-            if (!validStrategies.includes(rateLimiter.queueStrategy)) {
+            if (typeof rateLimiter.queueStrategy !== "string" ||
+                !validStrategies.includes(rateLimiter.queueStrategy)) {
                 errors.push(`rateLimiter.queueStrategy must be one of: ${validStrategies.join(", ")}`);
             }
         }
         if (rateLimiter.queueTimeout !== undefined) {
-            const timeout = parseInt(rateLimiter.queueTimeout);
+            const timeout = parseInt(String(rateLimiter.queueTimeout));
             if (isNaN(timeout) || timeout < 1000 || timeout > 120000) {
                 errors.push("rateLimiter.queueTimeout must be between 1000 and 120000 ms");
             }
         }
         if (rateLimiter.providerLimits) {
-            if (typeof rateLimiter.providerLimits !== "object") {
+            if (!isObject(rateLimiter.providerLimits)) {
                 errors.push("rateLimiter.providerLimits must be an object");
             }
             else {
@@ -423,14 +433,24 @@ class InputValidator {
                         _warnings.push(`Unknown provider in providerLimits: '${provider}'`);
                         continue;
                     }
+                    if (limits === null) {
+                        errors.push(`rateLimiter.providerLimits.${provider} must be an object`);
+                        continue;
+                    }
+                    // Primitives and arrays always loaded (the rate limiter ignores them), so
+                    // they stay accepted with a warning rather than failing validation.
+                    if (!isObject(limits) || Array.isArray(limits)) {
+                        _warnings.push(`rateLimiter.providerLimits.${provider} should be an object, ignoring it`);
+                        continue;
+                    }
                     if (limits.rpm !== undefined) {
-                        const rpm = parseInt(limits.rpm);
+                        const rpm = parseInt(String(limits.rpm));
                         if (isNaN(rpm) || rpm < 1 || rpm > 10000) {
                             errors.push(`rateLimiter.providerLimits.${provider}.rpm must be between 1 and 10000`);
                         }
                     }
                     if (limits.concurrency !== undefined) {
-                        const conc = parseInt(limits.concurrency);
+                        const conc = parseInt(String(limits.concurrency));
                         if (isNaN(conc) || conc < 1 || conc > 50) {
                             errors.push(`rateLimiter.providerLimits.${provider}.concurrency must be between 1 and 50`);
                         }
@@ -441,38 +461,40 @@ class InputValidator {
     }
     /**
      * Validate retry options.
-     * @param {RetryOptions} retryOptions - Retry options.
+     * @param {Record<string, unknown>} retryOptions - Raw retry options.
      * @param {string[]} errors - Array to push errors to.
      * @param {string[]} warnings - Array to push warnings to.
      */
     static validateRetryOptions(retryOptions, errors, _warnings) {
         if (retryOptions.maxRetries !== undefined) {
-            const retries = parseInt(retryOptions.maxRetries);
+            const retries = parseInt(String(retryOptions.maxRetries));
             if (isNaN(retries) || retries < 0 || retries > 10) {
                 errors.push("retryOptions.maxRetries must be between 0 and 10");
             }
         }
         if (retryOptions.initialDelay !== undefined) {
-            const delay = parseInt(retryOptions.initialDelay);
+            const delay = parseInt(String(retryOptions.initialDelay));
             if (isNaN(delay) || delay < 100 || delay > 10000) {
                 errors.push("retryOptions.initialDelay must be between 100 and 10000 ms");
             }
         }
         if (retryOptions.maxDelay !== undefined) {
-            const delay = parseInt(retryOptions.maxDelay);
+            const delay = parseInt(String(retryOptions.maxDelay));
             if (isNaN(delay) || delay < 1000 || delay > 60000) {
                 errors.push("retryOptions.maxDelay must be between 1000 and 60000 ms");
             }
         }
-        if (retryOptions.initialDelay !== undefined &&
-            retryOptions.maxDelay !== undefined &&
-            retryOptions.initialDelay > retryOptions.maxDelay) {
+        // Compare the parsed numbers like the range checks above: raw strings compare lexically.
+        // A missing or unparseable delay is NaN, which never compares greater.
+        const initialDelay = parseInt(String(retryOptions.initialDelay));
+        const maxDelay = parseInt(String(retryOptions.maxDelay));
+        if (initialDelay > maxDelay) {
             errors.push("retryOptions.initialDelay cannot be greater than maxDelay");
         }
     }
     /**
      * Validate context configuration.
-     * @param {ContextConfig} context - Context configuration.
+     * @param {Record<string, unknown>} context - Raw context configuration.
      * @param {string[]} errors - Array to push errors to.
      * @param {string[]} warnings - Array to push warnings to.
      */
@@ -482,24 +504,24 @@ class InputValidator {
                 this.validateProvider(context.aiProvider, "context.aiProvider");
             }
             catch (error) {
-                errors.push(`Invalid context.aiProvider: ${error.message}`);
+                errors.push(`Invalid context.aiProvider: ${errorMessage(error)}`);
             }
         }
         if (context.minTextLength !== undefined) {
-            const length = parseInt(context.minTextLength);
+            const length = parseInt(String(context.minTextLength));
             if (isNaN(length) || length < 0 || length > 1000) {
                 errors.push("context.minTextLength must be between 0 and 1000");
             }
         }
-        if (context.detection) {
+        if (isObject(context.detection)) {
             if (context.detection.threshold !== undefined) {
-                const threshold = parseInt(context.detection.threshold);
+                const threshold = parseInt(String(context.detection.threshold));
                 if (isNaN(threshold) || threshold < 1 || threshold > 20) {
                     errors.push("context.detection.threshold must be between 1 and 20");
                 }
             }
             if (context.detection.minConfidence !== undefined) {
-                const confidence = parseFloat(context.detection.minConfidence);
+                const confidence = parseFloat(String(context.detection.minConfidence));
                 if (isNaN(confidence) || confidence < 0 || confidence > 1) {
                     errors.push("context.detection.minConfidence must be between 0 and 1");
                 }
@@ -516,7 +538,7 @@ class InputValidator {
     }
     /**
      * Validate quality checks configuration.
-     * @param {QualityChecksConfig} qualityChecks - Quality checks configuration.
+     * @param {Record<string, unknown>} qualityChecks - Raw quality checks configuration.
      * @param {string[]} errors - Array to push errors to.
      * @param {string[]} warnings - Array to push warnings to.
      */
@@ -530,13 +552,14 @@ class InputValidator {
     }
     /**
      * Validate length control configuration.
-     * @param {LengthControlConfig} lengthControl - Length control configuration.
+     * @param {Record<string, unknown>} lengthControl - Raw length control configuration.
      * @param {string[]} errors - Array to push errors to.
      */
     static validateLengthControl(lengthControl, errors) {
         if (lengthControl.mode) {
             const validModes = ["strict", "flexible", "exact", "relaxed", "smart"];
-            if (!validModes.includes(lengthControl.mode)) {
+            if (typeof lengthControl.mode !== "string" ||
+                !validModes.includes(lengthControl.mode)) {
                 errors.push(`lengthControl.mode must be one of: ${validModes.join(", ")}`);
             }
         }
@@ -548,78 +571,32 @@ class InputValidator {
     }
     /**
      * Validate advanced configuration.
-     * @param {AdvancedConfig} advanced - Advanced configuration.
+     * @param {Record<string, unknown>} advanced - Raw advanced configuration.
      * @param {string[]} errors - Array to push errors to.
      */
     static validateAdvancedConfig(advanced, errors) {
         if (advanced.timeoutMs !== undefined) {
-            const timeout = parseInt(advanced.timeoutMs);
+            const timeout = parseInt(String(advanced.timeoutMs));
             if (isNaN(timeout) || timeout < 1000 || timeout > 300000) {
                 errors.push("advanced.timeoutMs must be between 1000 and 300000 ms (5 min)");
             }
         }
         if (advanced.maxKeyLength !== undefined) {
-            const length = parseInt(advanced.maxKeyLength);
+            const length = parseInt(String(advanced.maxKeyLength));
             if (isNaN(length) || length < 100 || length > 50000) {
                 errors.push("advanced.maxKeyLength must be between 100 and 50000");
             }
         }
         if (advanced.maxBatchSize !== undefined) {
-            const size = parseInt(advanced.maxBatchSize);
+            const size = parseInt(String(advanced.maxBatchSize));
             if (isNaN(size) || size < 1 || size > 100) {
                 errors.push("advanced.maxBatchSize must be between 1 and 100");
             }
         }
     }
-    /**
-     * Sanitize translation text for security.
-     * @param {string | null} text - Text to sanitize.
-     * @returns {string | null} - Sanitized text.
-     */
-    static sanitizeTranslationText(text) {
-        if (!text || typeof text !== "string") {
-            return text;
-        }
-        let sanitized = text;
-        for (const pattern of this.DANGEROUS_PATTERNS) {
-            sanitized = sanitized.replace(pattern, "");
-        }
-        sanitized = sanitized
-            .replace(/\r\n/g, "\n")
-            .replace(/\r/g, "\n")
-            .replace(/\n{3,}/g, "\n\n")
-            .trim();
-        return sanitized;
-    }
-    /**
-     * Validate API key format.
-     * @param {string} apiKey - API key to validate.
-     * @param {string} providerName - Provider name.
-     * @returns {boolean} - True if valid.
-     * @throws {Error} If key is invalid.
-     */
-    static validateApiKeyFormat(apiKey, providerName) {
-        if (!apiKey || typeof apiKey !== "string") {
-            throw new Error(`${providerName} API key must be a non-empty string`);
-        }
-        if (apiKey.length < 10) {
-            throw new Error(`${providerName} API key appears too short`);
-        }
-        if (apiKey.length > 200) {
-            throw new Error(`${providerName} API key appears too long`);
-        }
-        const lowercaseKey = apiKey.toLowerCase();
-        const invalidPatterns = ["test", "placeholder", "example", "your-api-key", "sk-test"];
-        for (const pattern of invalidPatterns) {
-            if (lowercaseKey.includes(pattern)) {
-                throw new Error(`${providerName} API key appears to be a placeholder`);
-            }
-        }
-        return true;
-    }
     /**
      * Validate object depth to prevent circular references and deep nesting.
-     * @param {any} obj - Object to validate.
+     * @param {unknown} obj - Object to validate.
      * @param {number} [maxDepth=10] - Maximum depth.
      * @param {number} [currentDepth=0] - Current depth.
      * @returns {boolean} - True if valid.
@@ -638,33 +615,5 @@ class InputValidator {
         }
         return true;
     }
-    /**
-     * Validate request rate for an identifier.
-     * @param {string} identifier - Identifier (e.g., user ID or IP).
-     * @param {number} [maxRequestsPerMinute=60] - Max requests per minute.
-     * @returns {boolean} - True if allowed.
-     * @throws {Error} If rate limit exceeded.
-     */
-    static validateRequestRate(identifier, maxRequestsPerMinute = 60) {
-        const now = Date.now();
-        const minute = Math.floor(now / 60000);
-        if (!this._requestCounts) {
-            this._requestCounts = new Map();
-        }
-        const key = `${identifier}-${minute}`;
-        const currentCount = this._requestCounts.get(key) || 0;
-        if (currentCount >= maxRequestsPerMinute) {
-            throw new Error(`Too many requests from ${identifier}. Please try again later.`);
-        }
-        this._requestCounts.set(key, currentCount + 1);
-        // Cleanup old entries
-        for (const [k] of this._requestCounts) {
-            const [, keyMinute] = k.split("-");
-            if (parseInt(keyMinute) < minute - 5) {
-                this._requestCounts.delete(k);
-            }
-        }
-        return true;
-    }
 }
 export default InputValidator;

package/dist/utils/locale-paths.d.ts

@@ -0,0 +1,7 @@
+/**
+ * The locale file the translations of `sourceFile` into `language` belong in, in the source's
+ * layout: `<root>/<source>/translation.json` gives `<root>/<language>/translation.json`, any
+ * other source file gives `<language>.json` next to it.
+ * @throws {Error} If `language` would put the file outside the locales directory.
+ */
+export declare function targetLocaleFile(sourceFile: string, language: string): string;

package/dist/utils/locale-paths.js

@@ -0,0 +1,16 @@
+import path from "path";
+import InputValidator from "./input-validator.js";
+/**
+ * The locale file the translations of `sourceFile` into `language` belong in, in the source's
+ * layout: `<root>/<source>/translation.json` gives `<root>/<language>/translation.json`, any
+ * other source file gives `<language>.json` next to it.
+ * @throws {Error} If `language` would put the file outside the locales directory.
+ */
+export function targetLocaleFile(sourceFile, language) {
+    const sourceDir = path.dirname(sourceFile);
+    if (path.basename(sourceFile) === "translation.json") {
+        const languageDir = InputValidator.createSafeFilePath(path.dirname(sourceDir), language);
+        return path.join(languageDir, "translation.json");
+    }
+    return InputValidator.createSafeFilePath(sourceDir, `${language}.json`);
+}

package/dist/utils/logger.d.ts

@@ -42,7 +42,7 @@ declare class Logger {
      * Parse size string (e.g., "10MB") to bytes.
      * @param sizeStr - Size string to parse.
      */
-    parseSize(sizeStr: any): number;
+    parseSize(sizeStr: unknown): number;
     /**
      * Check and rotate logs if needed.
      */
@@ -64,14 +64,14 @@ declare class Logger {
      * @param message - Log message.
      * @param data - Additional data to log.
      */
-    formatMessage(level: string, message: string, data?: any): string;
+    formatMessage(level: string, message: string, data?: unknown): string;
     /**
      * Write to log file.
      * @param level - Log level.
      * @param message - Log message.
      * @param data - Additional data to log.
      */
-    writeToFile(level: string, message: string, data?: any): Promise<void>;
+    writeToFile(level: string, message: string, data?: unknown): Promise<void>;
     /**
      * Simple console log with debug awareness.
      * @param message - Message to log
@@ -83,32 +83,32 @@ declare class Logger {
      * @param message - Error message.
      * @param data - Additional data.
      */
-    error(message: string, data?: any): Promise<void>;
+    error(message: string, data?: unknown): Promise<void>;
     /**
      * Log warning.
      * @param message - Warning message.
      * @param data - Additional data.
      */
-    warn(message: string, data?: any): Promise<void>;
+    warn(message: string, data?: unknown): Promise<void>;
     /**
      * Log info.
      * @param message - Info message.
      * @param data - Additional data.
      */
-    info(message: string, data?: any): Promise<void>;
+    info(message: string, data?: unknown): Promise<void>;
     /**
      * Log debug.
      * @param message - Debug message.
      * @param data - Additional data.
      */
-    debug(message: string, data?: any): Promise<void>;
+    debug(message: string, data?: unknown): Promise<void>;
     /**
      * Log based on diagnostics level.
      * @param level - Log level.
      * @param message - Log message.
      * @param data - Additional data.
      */
-    diagnostics(level: string, message: string, data?: any): Promise<void>;
+    diagnostics(level: string, message: string, data?: unknown): Promise<void>;
     /**
      * Get log statistics.
      * @returns Object containing log stats.