generaltranslation 8.2.12 → 8.2.13

package/dist/logging/errors.js

@@ -0,0 +1,29 @@
+var GT_ERROR_PREFIX = 'GT Error:';
+export var translationTimeoutError = function (timeout) {
+    return "".concat(GT_ERROR_PREFIX, " Translation request timed out after ").concat(timeout, "ms.");
+};
+export var translationRequestFailedError = function (error) {
+    return "".concat(GT_ERROR_PREFIX, " Translation request failed. Error: ").concat(error);
+};
+export var apiError = function (status, statusText, error) {
+    return "".concat(GT_ERROR_PREFIX, " API returned error status. Status: ").concat(status, ", Status Text: ").concat(statusText, ", Error: ").concat(error);
+};
+export var invalidAuthError = "".concat(GT_ERROR_PREFIX, " Invalid authentication.");
+export var noTargetLocaleProvidedError = function (functionName) {
+    return "".concat(GT_ERROR_PREFIX, " Cannot call `").concat(functionName, "` without a specified locale. Either pass a locale to the `").concat(functionName, "` function or specify a targetLocale in the GT constructor.");
+};
+export var noSourceLocaleProvidedError = function (functionName) {
+    return "".concat(GT_ERROR_PREFIX, " Cannot call `").concat(functionName, "` without a specified locale. Either pass a locale to the `").concat(functionName, "` function or specify a sourceLocale in the GT constructor.");
+};
+export var noProjectIdProvidedError = function (functionName) {
+    return "".concat(GT_ERROR_PREFIX, " Cannot call `").concat(functionName, "` without a specified project ID. Either pass a project ID to the `").concat(functionName, "` function or specify a projectId in the GT constructor.");
+};
+export var noApiKeyProvidedError = function (functionName) {
+    return "".concat(GT_ERROR_PREFIX, " Cannot call `").concat(functionName, "` without a specified API key. Either pass an API key to the `").concat(functionName, "` function or specify an apiKey in the GT constructor.");
+};
+export var invalidLocaleError = function (locale) {
+    return "".concat(GT_ERROR_PREFIX, " Invalid locale: ").concat(locale, ".");
+};
+export var invalidLocalesError = function (locales) {
+    return "".concat(GT_ERROR_PREFIX, " Invalid locales: ").concat(locales.join(', '), ".");
+};

package/dist/logging/logger.d.ts

@@ -0,0 +1,121 @@
+/**
+ * Comprehensive logging system for the General Translation library.
+ * Provides structured logging with multiple levels and configurable output.
+ */
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error' | 'off';
+export type LogMetadataValue = string | number | boolean | null | undefined | Date | Error | LogMetadataValue[] | {
+    [key: string]: LogMetadataValue;
+};
+export type LogMetadata = Record<string, LogMetadataValue>;
+export interface LogEntry {
+    level: LogLevel;
+    message: string;
+    timestamp: Date;
+    context?: string;
+    metadata?: LogMetadata;
+}
+export interface LoggerConfig {
+    /** Minimum log level to output. */
+    level: LogLevel;
+    /** Whether to include timestamps in log output. */
+    includeTimestamp: boolean;
+    /** Whether to include context information. */
+    includeContext: boolean;
+    /** Custom prefix for all log messages. */
+    prefix?: string;
+    /** Whether to output to console (default: true) */
+    enableConsole: boolean;
+    /** Custom log handlers. */
+    handlers?: LogHandler[];
+}
+export interface LogHandler {
+    handle(entry: LogEntry): void;
+}
+/**
+ * Console log handler that outputs formatted messages to console
+ */
+export declare class ConsoleLogHandler implements LogHandler {
+    private config;
+    constructor(config: LoggerConfig);
+    handle(entry: LogEntry): void;
+}
+/**
+ * Main Logger class providing structured logging capabilities.
+ */
+export declare class Logger {
+    private config;
+    private handlers;
+    constructor(config?: Partial<LoggerConfig>);
+    /**
+     * Add a custom log handler
+     */
+    addHandler(handler: LogHandler): void;
+    /**
+     * Remove a log handler
+     */
+    removeHandler(handler: LogHandler): void;
+    /**
+     * Update logger configuration
+     */
+    configure(config: Partial<LoggerConfig>): void;
+    /**
+     * Check if a log level should be output based on current configuration
+     */
+    private shouldLog;
+    /**
+     * Internal logging method that creates log entries and passes them to handlers
+     */
+    private log;
+    /**
+     * Log a debug message
+     * Used for detailed diagnostic information, typically of interest only when diagnosing problems
+     */
+    debug(message: string, context?: string, metadata?: LogMetadata): void;
+    /**
+     * Log an info message
+     * Used for general information about application operation.
+     */
+    info(message: string, context?: string, metadata?: LogMetadata): void;
+    /**
+     * Log a warning message
+     * Used for potentially problematic situations that don't prevent operation
+     */
+    warn(message: string, context?: string, metadata?: LogMetadata): void;
+    /**
+     * Log an error message
+     * Used for error events that might still allow the application to continue.
+     */
+    error(message: string, context?: string, metadata?: LogMetadata): void;
+    /**
+     * Create a child logger with a specific context
+     */
+    child(context: string): ContextLogger;
+    /**
+     * Get current logger configuration
+     */
+    getConfig(): LoggerConfig;
+}
+/**
+ * Context logger that automatically includes context information.
+ */
+export declare class ContextLogger {
+    private logger;
+    private context;
+    constructor(logger: Logger, context: string);
+    debug(message: string, metadata?: LogMetadata): void;
+    info(message: string, metadata?: LogMetadata): void;
+    warn(message: string, metadata?: LogMetadata): void;
+    error(message: string, metadata?: LogMetadata): void;
+    child(childContext: string): ContextLogger;
+}
+export declare const defaultLogger: Logger;
+export declare const debug: (message: string, context?: string, metadata?: LogMetadata) => void;
+export declare const info: (message: string, context?: string, metadata?: LogMetadata) => void;
+export declare const warn: (message: string, context?: string, metadata?: LogMetadata) => void;
+export declare const error: (message: string, context?: string, metadata?: LogMetadata) => void;
+export declare const fetchLogger: ContextLogger;
+export declare const validationLogger: ContextLogger;
+export declare const formattingLogger: ContextLogger;
+export declare const localeLogger: ContextLogger;
+export declare const gtInstanceLogger: ContextLogger;
+export { Logger as GTLogger };

package/dist/logging/logger.js

@@ -0,0 +1,259 @@
+/**
+ * Comprehensive logging system for the General Translation library.
+ * Provides structured logging with multiple levels and configurable output.
+ */
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var LOG_LEVELS = {
+    debug: 0,
+    info: 1,
+    warn: 2,
+    error: 3,
+    off: 4,
+};
+var LOG_COLORS = {
+    debug: '\x1b[36m', // Cyan
+    info: '\x1b[32m', // Green
+    warn: '\x1b[33m', // Yellow
+    error: '\x1b[31m', // Red
+    off: '', // No color needed since 'off' level logs are never displayed
+};
+var RESET_COLOR = '\x1b[0m';
+/**
+ * Get the configured log level from environment variable or default to 'warn'
+ */
+function getConfiguredLogLevel() {
+    var _a;
+    if (typeof process !== 'undefined' && ((_a = process.env) === null || _a === void 0 ? void 0 : _a._GT_LOG_LEVEL)) {
+        var envLevel = process.env._GT_LOG_LEVEL.toLowerCase();
+        if (envLevel in LOG_LEVELS) {
+            return envLevel;
+        }
+    }
+    return 'warn';
+}
+/**
+ * Console log handler that outputs formatted messages to console
+ */
+var ConsoleLogHandler = /** @class */ (function () {
+    function ConsoleLogHandler(config) {
+        this.config = config;
+    }
+    ConsoleLogHandler.prototype.handle = function (entry) {
+        var parts = [];
+        // Add timestamp if enabled
+        if (this.config.includeTimestamp) {
+            parts.push("[".concat(entry.timestamp.toISOString(), "]"));
+        }
+        // Add level with color
+        var colorCode = LOG_COLORS[entry.level];
+        var levelText = "[".concat(entry.level.toUpperCase(), "]");
+        parts.push("".concat(colorCode).concat(levelText).concat(RESET_COLOR));
+        // Add prefix if configured
+        if (this.config.prefix) {
+            parts.push("[".concat(this.config.prefix, "]"));
+        }
+        // Add context if available and enabled.
+        if (this.config.includeContext && entry.context) {
+            parts.push("[".concat(entry.context, "]"));
+        }
+        // Add the main message
+        parts.push(entry.message);
+        // Format metadata if available.
+        if (entry.metadata && Object.keys(entry.metadata).length > 0) {
+            parts.push("\n  Metadata: ".concat(JSON.stringify(entry.metadata, null, 2)));
+        }
+        var formattedMessage = parts.join(' ');
+        // Output to appropriate console method based on level
+        switch (entry.level) {
+            case 'debug':
+                // eslint-disable-next-line no-console
+                console.debug(formattedMessage);
+                break;
+            case 'info':
+                // eslint-disable-next-line no-console
+                console.info(formattedMessage);
+                break;
+            case 'warn':
+                console.warn(formattedMessage);
+                break;
+            case 'error':
+                console.error(formattedMessage);
+                break;
+        }
+    };
+    return ConsoleLogHandler;
+}());
+export { ConsoleLogHandler };
+/**
+ * Main Logger class providing structured logging capabilities.
+ */
+var Logger = /** @class */ (function () {
+    function Logger(config) {
+        if (config === void 0) { config = {}; }
+        this.config = __assign({ level: getConfiguredLogLevel(), includeTimestamp: true, includeContext: true, enableConsole: true, handlers: [] }, config);
+        this.handlers = __spreadArray([], (this.config.handlers || []), true);
+        // Add console handler if enabled
+        if (this.config.enableConsole) {
+            this.handlers.push(new ConsoleLogHandler(this.config));
+        }
+    }
+    /**
+     * Add a custom log handler
+     */
+    Logger.prototype.addHandler = function (handler) {
+        this.handlers.push(handler);
+    };
+    /**
+     * Remove a log handler
+     */
+    Logger.prototype.removeHandler = function (handler) {
+        var index = this.handlers.indexOf(handler);
+        if (index > -1) {
+            this.handlers.splice(index, 1);
+        }
+    };
+    /**
+     * Update logger configuration
+     */
+    Logger.prototype.configure = function (config) {
+        this.config = __assign(__assign({}, this.config), config);
+    };
+    /**
+     * Check if a log level should be output based on current configuration
+     */
+    Logger.prototype.shouldLog = function (level) {
+        return LOG_LEVELS[level] >= LOG_LEVELS[this.config.level];
+    };
+    /**
+     * Internal logging method that creates log entries and passes them to handlers
+     */
+    Logger.prototype.log = function (level, message, context, metadata) {
+        if (!this.shouldLog(level)) {
+            return;
+        }
+        var entry = {
+            level: level,
+            message: message,
+            timestamp: new Date(),
+            context: context,
+            metadata: metadata,
+        };
+        // Pass to all handlers
+        this.handlers.forEach(function (handler) {
+            try {
+                handler.handle(entry);
+            }
+            catch (error) {
+                // Prevent logging errors from breaking the application
+                console.error('Error in log handler:', error);
+            }
+        });
+    };
+    /**
+     * Log a debug message
+     * Used for detailed diagnostic information, typically of interest only when diagnosing problems
+     */
+    Logger.prototype.debug = function (message, context, metadata) {
+        this.log('debug', message, context, metadata);
+    };
+    /**
+     * Log an info message
+     * Used for general information about application operation.
+     */
+    Logger.prototype.info = function (message, context, metadata) {
+        this.log('info', message, context, metadata);
+    };
+    /**
+     * Log a warning message
+     * Used for potentially problematic situations that don't prevent operation
+     */
+    Logger.prototype.warn = function (message, context, metadata) {
+        this.log('warn', message, context, metadata);
+    };
+    /**
+     * Log an error message
+     * Used for error events that might still allow the application to continue.
+     */
+    Logger.prototype.error = function (message, context, metadata) {
+        this.log('error', message, context, metadata);
+    };
+    /**
+     * Create a child logger with a specific context
+     */
+    Logger.prototype.child = function (context) {
+        return new ContextLogger(this, context);
+    };
+    /**
+     * Get current logger configuration
+     */
+    Logger.prototype.getConfig = function () {
+        return __assign({}, this.config);
+    };
+    return Logger;
+}());
+export { Logger };
+/**
+ * Context logger that automatically includes context information.
+ */
+var ContextLogger = /** @class */ (function () {
+    function ContextLogger(logger, context) {
+        this.logger = logger;
+        this.context = context;
+    }
+    ContextLogger.prototype.debug = function (message, metadata) {
+        this.logger.debug(message, this.context, metadata);
+    };
+    ContextLogger.prototype.info = function (message, metadata) {
+        this.logger.info(message, this.context, metadata);
+    };
+    ContextLogger.prototype.warn = function (message, metadata) {
+        this.logger.warn(message, this.context, metadata);
+    };
+    ContextLogger.prototype.error = function (message, metadata) {
+        this.logger.error(message, this.context, metadata);
+    };
+    ContextLogger.prototype.child = function (childContext) {
+        return new ContextLogger(this.logger, "".concat(this.context, ":").concat(childContext));
+    };
+    return ContextLogger;
+}());
+export { ContextLogger };
+// Default logger instance.
+export var defaultLogger = new Logger({
+    level: getConfiguredLogLevel(),
+    includeTimestamp: true,
+    includeContext: true,
+    prefix: 'GT',
+});
+// Convenience functions using the default logger.
+export var debug = function (message, context, metadata) { return defaultLogger.debug(message, context, metadata); };
+export var info = function (message, context, metadata) { return defaultLogger.info(message, context, metadata); };
+export var warn = function (message, context, metadata) { return defaultLogger.warn(message, context, metadata); };
+export var error = function (message, context, metadata) { return defaultLogger.error(message, context, metadata); };
+// Create context-specific loggers for different parts of the system
+export var fetchLogger = defaultLogger.child('fetch');
+export var validationLogger = defaultLogger.child('validation');
+export var formattingLogger = defaultLogger.child('formatting');
+export var localeLogger = defaultLogger.child('locale');
+export var gtInstanceLogger = defaultLogger.child('GT instance');
+// Export types and classes
+export { Logger as GTLogger };

package/dist/logging/warnings.d.ts

@@ -0,0 +1,2 @@
+export declare const formatI18nextWarning = "Warning: formatI18next is not currently supported but will be implemented in a future version. Use _formatMessageICU for current ICU message format support.";
+export declare const formatJsxWarning = "Warning: formatJsx is not currently supported but will be implemented in a future version. Use _formatMessageICU for current ICU message format support.";

package/dist/logging/warnings.js

@@ -0,0 +1,2 @@
+export var formatI18nextWarning = 'Warning: formatI18next is not currently supported but will be implemented in a future version. Use _formatMessageICU for current ICU message format support.';
+export var formatJsxWarning = 'Warning: formatJsx is not currently supported but will be implemented in a future version. Use _formatMessageICU for current ICU message format support.';

package/dist/projects/getProjectData.d.ts

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

package/dist/projects/getProjectData.js

@@ -0,0 +1,87 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import { defaultBaseUrl } from '../settings/settingsUrls';
+import fetchWithTimeout from '../translate/utils/fetchWithTimeout';
+import { defaultTimeout } from '../settings/settings';
+import validateResponse from '../translate/utils/validateResponse';
+import handleFetchError from '../translate/utils/handleFetchError';
+import generateRequestHeaders from '../translate/utils/generateRequestHeaders';
+/**
+ * @internal
+ * Gets the project data for a given project ID.
+ * @param projectId - The project ID to get the project data for
+ * @param options - The options for the API call.
+ * @param config - The configuration for the request.
+ * @returns The project data for the given project ID.
+ */
+export default function _getProjectData(projectId, options, config) {
+    return __awaiter(this, void 0, void 0, function () {
+        var baseUrl, timeout, url, response, error_1, result;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    baseUrl = config.baseUrl;
+                    timeout = options.timeout ? options.timeout : defaultTimeout;
+                    url = "".concat(baseUrl || defaultBaseUrl, "/v2/project/info/").concat(encodeURIComponent(projectId));
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 3, , 4]);
+                    return [4 /*yield*/, fetchWithTimeout(url, {
+                            method: 'GET',
+                            headers: generateRequestHeaders(config),
+                        }, timeout)];
+                case 2:
+                    response = _a.sent();
+                    return [3 /*break*/, 4];
+                case 3:
+                    error_1 = _a.sent();
+                    handleFetchError(error_1, timeout);
+                    return [3 /*break*/, 4];
+                case 4: 
+                // Validate the response
+                return [4 /*yield*/, validateResponse(response)];
+                case 5:
+                    // Validate the response
+                    _a.sent();
+                    return [4 /*yield*/, response.json()];
+                case 6:
+                    result = _a.sent();
+                    return [2 /*return*/, result];
+            }
+        });
+    });
+}

package/dist/settings/plurals.d.ts

@@ -0,0 +1,3 @@
+export declare const pluralForms: readonly ["singular", "plural", "dual", "zero", "one", "two", "few", "many", "other"];
+export type PluralType = (typeof pluralForms)[number];
+export declare function isAcceptedPluralForm(form: string): form is PluralType;

package/dist/settings/plurals.js

@@ -0,0 +1,14 @@
+export var pluralForms = [
+    'singular',
+    'plural',
+    'dual',
+    'zero',
+    'one',
+    'two',
+    'few',
+    'many',
+    'other',
+];
+export function isAcceptedPluralForm(form) {
+    return pluralForms.includes(form);
+}

package/dist/settings/settings.d.ts

@@ -0,0 +1,2 @@
+export declare const libraryDefaultLocale: "en";
+export declare const defaultTimeout = 60000;

package/dist/settings/settings.js

@@ -0,0 +1,2 @@
+export var libraryDefaultLocale = 'en';
+export var defaultTimeout = 60000;

package/dist/settings/settingsUrls.d.ts

@@ -0,0 +1,3 @@
+export declare const defaultCacheUrl: "https://cdn.gtx.dev";
+export declare const defaultBaseUrl: "https://api2.gtx.dev";
+export declare const defaultRuntimeApiUrl: "https://runtime2.gtx.dev";

package/dist/settings/settingsUrls.js

@@ -0,0 +1,3 @@
+export var defaultCacheUrl = 'https://cdn.gtx.dev';
+export var defaultBaseUrl = 'https://api2.gtx.dev';
+export var defaultRuntimeApiUrl = 'https://runtime2.gtx.dev';

package/dist/translate/api.d.ts

@@ -0,0 +1 @@
+export declare const API_VERSION = "2026-03-06.v1";

package/dist/translate/api.js

@@ -0,0 +1 @@
+export var API_VERSION = '2026-03-06.v1';

package/dist/translate/awaitJobs.d.ts

@@ -0,0 +1,19 @@
+import { JobStatus } from './checkJobStatus';
+export type AwaitJobsOptions = {
+    /** Polling interval in seconds. Defaults to 5. */
+    pollingIntervalSeconds?: number;
+    /** Timeout in seconds. Defaults to 600 (10 minutes). If reached, resolves with whatever status is current. */
+    timeoutSeconds?: number;
+};
+export type JobResult = {
+    jobId: string;
+    status: JobStatus;
+    error?: {
+        message: string;
+    };
+};
+export type AwaitJobsResult = {
+    /** Whether all jobs completed (none still in progress). */
+    complete: boolean;
+    jobs: JobResult[];
+};