ai-l10n-core 1.4.0

package/dist/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./logger"), exports);
+__exportStar(require("./consoleLogger"), exports);
+__exportStar(require("./constants"), exports);
+__exportStar(require("./translationService"), exports);
+__exportStar(require("./languageUtils"), exports);

package/dist/languageUtils.d.ts

@@ -0,0 +1,27 @@
+/**
+ * BCP 47 language code regex with optional script and region subtags.
+ * Matches patterns like: en, en-US, en_US, zh-Hans, zh-Hans-CN, zh_Hans_CN
+ */
+export declare const LANGUAGE_CODE_REGEX: RegExp;
+/**
+ * Normalizes language codes to a consistent BCP 47 format with optional script and region subtags
+ * Examples:
+ * - "en" -> "en"
+ * - "en-us", "en_US" -> "en-US"
+ * - "zh_hans", "zh-Hans" -> "zh-Hans"
+ * - "zh_HANS_CN", "zh-Hans-CN" -> "zh-Hans-CN"
+ * @param code Language code to normalize
+ * @returns Normalized language code in the format: language[-Script][-REGION]
+ */
+export declare function normalizeLanguageCode(code: string): string;
+/**
+ * Validates whether the given string is a valid BCP 47 language code
+ */
+export declare function validateLanguageCode(code: string): boolean;
+/**
+ * Extracts language code from file name, handling custom prefixes and suffixes for different file types
+ * ARB files: app_en_US.arb -> en_US, my_app_fr.arb -> fr
+ * JSON files: en-US.json -> en-US
+ * Shopify theme: en.default.schema.json -> en, es-ES.schema.json -> es-ES
+ */
+export declare function extractLanguageCode(fileName: string): string | null;

package/dist/languageUtils.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LANGUAGE_CODE_REGEX = void 0;
+exports.normalizeLanguageCode = normalizeLanguageCode;
+exports.validateLanguageCode = validateLanguageCode;
+exports.extractLanguageCode = extractLanguageCode;
+/**
+ * BCP 47 language code regex with optional script and region subtags.
+ * Matches patterns like: en, en-US, en_US, zh-Hans, zh-Hans-CN, zh_Hans_CN
+ */
+exports.LANGUAGE_CODE_REGEX = /^(?<language>[a-z]{2,3})([-|_](?<script>[A-Z][a-z]{3}))?([-|_](?<region>[A-Z]{2,3}|[0-9]{3}))?$/i;
+/**
+ * Normalizes language codes to a consistent BCP 47 format with optional script and region subtags
+ * Examples:
+ * - "en" -> "en"
+ * - "en-us", "en_US" -> "en-US"
+ * - "zh_hans", "zh-Hans" -> "zh-Hans"
+ * - "zh_HANS_CN", "zh-Hans-CN" -> "zh-Hans-CN"
+ * @param code Language code to normalize
+ * @returns Normalized language code in the format: language[-Script][-REGION]
+ */
+function normalizeLanguageCode(code) {
+    const match = code.match(exports.LANGUAGE_CODE_REGEX);
+    if (!match?.groups) {
+        return code; // Return as-is if it doesn't match the pattern
+    }
+    const { language, script, region } = match.groups;
+    let normalized = language.toLowerCase();
+    if (script) {
+        // Script codes: first letter uppercase, rest lowercase
+        normalized +=
+            "-" + script.charAt(0).toUpperCase() + script.slice(1).toLowerCase();
+    }
+    if (region) {
+        // Region codes: all uppercase
+        normalized += "-" + region.toUpperCase();
+    }
+    return normalized;
+}
+/**
+ * Validates whether the given string is a valid BCP 47 language code
+ */
+function validateLanguageCode(code) {
+    return !!code && exports.LANGUAGE_CODE_REGEX.test(code);
+}
+/**
+ * Extracts language code from file name, handling custom prefixes and suffixes for different file types
+ * ARB files: app_en_US.arb -> en_US, my_app_fr.arb -> fr
+ * JSON files: en-US.json -> en-US
+ * Shopify theme: en.default.schema.json -> en, es-ES.schema.json -> es-ES
+ */
+function extractLanguageCode(fileName) {
+    const isArbFile = fileName.endsWith(".arb");
+    const nameWithoutExt = fileName.replace(/\.[^.]+$/, ""); // Remove extension
+    if (isArbFile) {
+        // ARB files use underscores instead of hyphens
+        const arbLanguageCodeRegex = /^(?<language>[a-z]{2,3})(_(?<script>[A-Z][a-z]{3}))?(_(?<region>[A-Z]{2,3}|[0-9]{3}))?$/;
+        // For ARB files, try to extract language code after potential prefix
+        // Pattern: [prefix_]language[_script][_region]
+        const parts = nameWithoutExt.split("_");
+        // Try combinations from right to left to find valid language code
+        // For example, for "my_app_en_US.arb", parts = ["my", "app", "en", "US"]
+        // Check "en_US", then "app_en_US", then "my_app_en_US" until we find a match
+        for (let i = 0; i < parts.length; i++) {
+            const potentialCode = parts.slice(i).join("_");
+            if (arbLanguageCodeRegex.test(potentialCode)) {
+                return potentialCode;
+            }
+        }
+        return null;
+    }
+    // Handle Shopify theme pattern: en.default.schema, es-ES.schema
+    // Remove .schema first, then .default before extracting language code
+    const cleanedFileName = nameWithoutExt
+        .replace(/\.schema$/, "")
+        .replace(/\.default$/, "");
+    // For JSON files, the entire filename should be the language code
+    return exports.LANGUAGE_CODE_REGEX.test(cleanedFileName) ? cleanedFileName : null;
+}

package/dist/logger.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Logger interface for dependency injection
+ */
+export interface ILogger {
+    logInfo(message: string): void;
+    logWarning(message: string, error?: unknown): void;
+    logError(message: string, error?: unknown): void;
+    showAndLogError(message: string, error?: unknown, context?: string, linkBtnText?: string, url?: string): void;
+}

package/dist/logger.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/test/consoleLogger.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/consoleLogger.test.js

@@ -0,0 +1,242 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert = __importStar(require("assert"));
+const sinon = __importStar(require("sinon"));
+const consoleLogger_1 = require("../consoleLogger");
+suite("ConsoleLogger Test Suite", () => {
+    let logger;
+    let consoleErrorStub;
+    let consoleLogStub;
+    let consoleWarnStub;
+    setup(() => {
+        logger = new consoleLogger_1.ConsoleLogger();
+        consoleErrorStub = sinon.stub(console, "error");
+        consoleLogStub = sinon.stub(console, "log");
+        consoleWarnStub = sinon.stub(console, "warn");
+    });
+    teardown(() => {
+        sinon.restore();
+    });
+    suite("showAndLogError", () => {
+        test("logs error message with emoji", () => {
+            logger.showAndLogError("Test error message");
+            assert.ok(consoleErrorStub.calledOnce);
+            assert.ok(consoleErrorStub.firstCall.args[0].includes("❌"));
+            assert.ok(consoleErrorStub.firstCall.args[0].includes("Test error message"));
+        });
+        test("logs context when provided", () => {
+            logger.showAndLogError("Error", undefined, "Test context");
+            assert.ok(consoleErrorStub.calledTwice);
+            assert.ok(consoleErrorStub.secondCall.args[0].includes("Context:"));
+            assert.ok(consoleErrorStub.secondCall.args[0].includes("Test context"));
+        });
+        test("logs Error object with message and stack", () => {
+            const error = new Error("Test error");
+            logger.showAndLogError("Error occurred", error);
+            // Should log: main message, error message, and stack
+            assert.ok(consoleErrorStub.callCount >= 2);
+            const calls = consoleErrorStub.getCalls();
+            const errorMessageCall = calls.find((call) => call.args[0].includes("Error: Test error"));
+            assert.ok(errorMessageCall, "Should log error message");
+            const stackCall = calls.find((call) => typeof call.args[0] === "string" && call.args[0].includes("at "));
+            assert.ok(stackCall, "Should log stack trace");
+        });
+        test("logs non-Error objects as strings", () => {
+            const error = { message: "Custom error" };
+            logger.showAndLogError("Error occurred", error);
+            const calls = consoleErrorStub.getCalls();
+            const errorCall = calls.find((call) => call.args[0].includes("[object Object]"));
+            assert.ok(errorCall, "Should convert error to string");
+        });
+        test("logs link when both linkBtnText and url provided", () => {
+            logger.showAndLogError("Error", undefined, undefined, "Visit docs", "https://example.com");
+            const calls = consoleErrorStub.getCalls();
+            const linkCall = calls.find((call) => call.args[0].includes("Visit docs") &&
+                call.args[0].includes("https://example.com"));
+            assert.ok(linkCall, "Should log link with button text");
+        });
+        test("does not log link when only linkBtnText provided", () => {
+            logger.showAndLogError("Error", undefined, undefined, "Visit docs");
+            // Should only log the main error message, not the link
+            assert.strictEqual(consoleErrorStub.callCount, 1);
+        });
+        test("does not log link when only url provided", () => {
+            logger.showAndLogError("Error", undefined, undefined, undefined, "https://example.com");
+            // Should only log the main error message, not the link
+            assert.strictEqual(consoleErrorStub.callCount, 1);
+        });
+        test("handles all parameters together", () => {
+            const error = new Error("Full test error");
+            logger.showAndLogError("Complete error", error, "Full context", "Help link", "https://help.com");
+            // Should log: message, context, error message, stack, link
+            assert.ok(consoleErrorStub.callCount >= 4);
+            const allCalls = consoleErrorStub.getCalls().map((call) => call.args[0]);
+            const allOutput = allCalls.join(" ");
+            assert.ok(allOutput.includes("❌ Complete error"));
+            assert.ok(allOutput.includes("Context: Full context"));
+            assert.ok(allOutput.includes("Error: Full test error"));
+            assert.ok(allOutput.includes("Help link: https://help.com"));
+        });
+        test("handles Error without stack trace", () => {
+            const error = new Error("No stack error");
+            delete error.stack;
+            logger.showAndLogError("Error", error);
+            // Should still log the error message
+            const calls = consoleErrorStub.getCalls();
+            const errorCall = calls.find((call) => call.args[0].includes("Error: No stack error"));
+            assert.ok(errorCall, "Should log error message even without stack");
+        });
+        test("handles null error", () => {
+            logger.showAndLogError("Error", null);
+            // Should only log main message, null is falsy so no error details
+            assert.strictEqual(consoleErrorStub.callCount, 1);
+        });
+        test("handles undefined error", () => {
+            logger.showAndLogError("Error", undefined);
+            // Should only log main message
+            assert.strictEqual(consoleErrorStub.callCount, 1);
+        });
+        test("handles number as error", () => {
+            logger.showAndLogError("Error", 404);
+            const calls = consoleErrorStub.getCalls();
+            const errorCall = calls.find((call) => call.args[0].includes("Error: 404"));
+            assert.ok(errorCall, "Should convert number to string");
+        });
+        test("handles string as error", () => {
+            logger.showAndLogError("Error", "String error message");
+            const calls = consoleErrorStub.getCalls();
+            const errorCall = calls.find((call) => call.args[0].includes("Error: String error message"));
+            assert.ok(errorCall, "Should log string error");
+        });
+    });
+    suite("logInfo", () => {
+        test("logs info message", () => {
+            logger.logInfo("Information message");
+            assert.ok(consoleLogStub.calledOnce);
+            assert.strictEqual(consoleLogStub.firstCall.args[0], "Information message");
+        });
+        test("logs empty string", () => {
+            logger.logInfo("");
+            assert.ok(consoleLogStub.calledOnce);
+            assert.strictEqual(consoleLogStub.firstCall.args[0], "");
+        });
+        test("logs multiline message", () => {
+            const multiline = "Line 1\nLine 2\nLine 3";
+            logger.logInfo(multiline);
+            assert.ok(consoleLogStub.calledOnce);
+            assert.strictEqual(consoleLogStub.firstCall.args[0], multiline);
+        });
+        test("logs message with special characters", () => {
+            const message = "Message with 🎉 emoji and special chars: @#$%";
+            logger.logInfo(message);
+            assert.ok(consoleLogStub.calledOnce);
+            assert.strictEqual(consoleLogStub.firstCall.args[0], message);
+        });
+    });
+    suite("logWarning", () => {
+        test("logs warning with emoji", () => {
+            logger.logWarning("Warning message");
+            assert.ok(consoleWarnStub.calledOnce);
+            assert.ok(consoleWarnStub.firstCall.args[0].includes("⚠️  "));
+            assert.ok(consoleWarnStub.firstCall.args[0].includes("Warning message"));
+        });
+        test("logs empty warning", () => {
+            logger.logWarning("");
+            assert.ok(consoleWarnStub.calledOnce);
+            assert.strictEqual(consoleWarnStub.firstCall.args[0], "⚠️  ");
+        });
+        test("logs multiline warning", () => {
+            const multiline = "Warning line 1\nWarning line 2";
+            logger.logWarning(multiline);
+            assert.ok(consoleWarnStub.calledOnce);
+            assert.ok(consoleWarnStub.firstCall.args[0].includes(multiline));
+        });
+        test("preserves warning message format", () => {
+            logger.logWarning("Detailed warning with info");
+            const output = consoleWarnStub.firstCall.args[0];
+            assert.strictEqual(output, "⚠️  Detailed warning with info");
+        });
+    });
+    suite("Logger Interface Compliance", () => {
+        test("implements all required ILogger methods", () => {
+            assert.strictEqual(typeof logger.showAndLogError, "function");
+            assert.strictEqual(typeof logger.logInfo, "function");
+            assert.strictEqual(typeof logger.logWarning, "function");
+        });
+        test("showAndLogError returns void", () => {
+            const result = logger.showAndLogError("Test");
+            assert.strictEqual(result, undefined);
+        });
+        test("logInfo returns void", () => {
+            const result = logger.logInfo("Test");
+            assert.strictEqual(result, undefined);
+        });
+        test("logWarning returns void", () => {
+            const result = logger.logWarning("Test");
+            assert.strictEqual(result, undefined);
+        });
+    });
+    suite("Edge Cases", () => {
+        test("handles very long messages", () => {
+            const longMessage = "A".repeat(10000);
+            logger.logInfo(longMessage);
+            assert.ok(consoleLogStub.calledOnce);
+            assert.strictEqual(consoleLogStub.firstCall.args[0].length, 10000);
+        });
+        test("handles messages with null bytes", () => {
+            const messageWithNull = "Message\x00with\x00nulls";
+            logger.logInfo(messageWithNull);
+            assert.ok(consoleLogStub.calledOnce);
+        });
+        test("handles Unicode characters", () => {
+            const unicode = "Hello 世界 🌍 Привет";
+            logger.logInfo(unicode);
+            assert.ok(consoleLogStub.calledOnce);
+            assert.strictEqual(consoleLogStub.firstCall.args[0], unicode);
+        });
+        test("does not throw on multiple calls", () => {
+            assert.doesNotThrow(() => {
+                logger.logInfo("Message 1");
+                logger.logWarning("Warning 1");
+                logger.showAndLogError("Error 1");
+                logger.logInfo("Message 2");
+            });
+            assert.strictEqual(consoleLogStub.callCount, 2);
+            assert.strictEqual(consoleWarnStub.callCount, 1);
+            assert.ok(consoleErrorStub.callCount >= 1);
+        });
+    });
+});

package/dist/test/translationService.test.d.ts

@@ -0,0 +1 @@
+export {};