@digitaldefiance/i18n-lib 1.3.8 → 1.3.10

package/README.md

@@ -2274,6 +2274,14 @@ For issues, questions, or contributions:
 
 ## ChangeLog
 
+### Version 1.3.10
+
+- Add UnifiedTranslator
+
+### Version 1.3.9
+
+- Add more handleable/typed classes
+
 ### Version 1.3.8
 
 - Add TypedHandleable

package/dist/index.d.ts

@@ -21,7 +21,7 @@ export * from './i18n-engine';
 export * from './language-definition';
 export * from './template';
 export * from './timezone';
-export * from './translatable-generic-error';
+export * from './plugin-translatable-generic-error';
 export * from './typed-error';
 export * from './typed-handleable';
 export * from './types';
@@ -33,13 +33,18 @@ export * from './core-string-key';
 export * from './language-codes';
 export * from './language-registry';
 export * from './plugin-i18n-engine';
+export * from './plugin-translatable-generic-error';
+export * from './plugin-translatable-handleable-generic';
+export * from './plugin-typed-handleable';
 export * from './registry-config';
 export * from './registry-error';
 export * from './registry-error-type';
 export * from './translation-engine';
 export * from './translation-request';
 export * from './translation-response';
+export * from './translatable';
 export * from './create-translation-adapter';
+export * from './unified-translator';
 export { createCoreI18nEngine as createCoreI18n } from './core-i18n';
 export { I18nEngine as I18n } from './i18n-engine';
 export { PluginI18nEngine as PluginI18n } from './plugin-i18n-engine';

package/dist/index.js

@@ -40,7 +40,7 @@ __exportStar(require("./i18n-engine"), exports);
 __exportStar(require("./language-definition"), exports);
 __exportStar(require("./template"), exports);
 __exportStar(require("./timezone"), exports);
-__exportStar(require("./translatable-generic-error"), exports);
+__exportStar(require("./plugin-translatable-generic-error"), exports);
 __exportStar(require("./typed-error"), exports);
 __exportStar(require("./typed-handleable"), exports);
 __exportStar(require("./types"), exports);
@@ -52,13 +52,18 @@ __exportStar(require("./core-string-key"), exports);
 __exportStar(require("./language-codes"), exports);
 __exportStar(require("./language-registry"), exports);
 __exportStar(require("./plugin-i18n-engine"), exports);
+__exportStar(require("./plugin-translatable-generic-error"), exports);
+__exportStar(require("./plugin-translatable-handleable-generic"), exports);
+__exportStar(require("./plugin-typed-handleable"), exports);
 __exportStar(require("./registry-config"), exports);
 __exportStar(require("./registry-error"), exports);
 __exportStar(require("./registry-error-type"), exports);
 __exportStar(require("./translation-engine"), exports);
 __exportStar(require("./translation-request"), exports);
 __exportStar(require("./translation-response"), exports);
+__exportStar(require("./translatable"), exports);
 __exportStar(require("./create-translation-adapter"), exports);
+__exportStar(require("./unified-translator"), exports);
 // Re-export for convenience
 var core_i18n_1 = require("./core-i18n");
 Object.defineProperty(exports, "createCoreI18n", { enumerable: true, get: function () { return core_i18n_1.createCoreI18nEngine; } });

package/dist/plugin-translatable-generic-error.d.ts

@@ -0,0 +1,29 @@
+import { PluginI18nEngine } from './plugin-i18n-engine';
+/**
+ * Generic translatable error that works with any plugin engine and component
+ */
+export declare class PluginTranslatableGenericError<TStringKey extends string = string, TLanguage extends string = string> extends Error {
+    readonly stringKey: TStringKey;
+    readonly componentId: string;
+    readonly language?: TLanguage;
+    readonly variables?: Record<string, string | number>;
+    readonly metadata?: Record<string, any>;
+    /**
+     * Create a translatable error
+     * @param componentId - The component ID to translate from
+     * @param stringKey - The translation key
+     * @param variables - Variables for interpolation
+     * @param language - Optional language override
+     * @param metadata - Additional error metadata
+     * @param instanceKey - Optional engine instance key
+     */
+    constructor(componentId: string, stringKey: TStringKey, variables?: Record<string, string | number>, language?: TLanguage, metadata?: Record<string, any>, instanceKey?: string);
+    /**
+     * Create error with explicit engine instance
+     */
+    static withEngine<TStringKey extends string, TLanguage extends string>(engine: PluginI18nEngine<TLanguage>, componentId: string, stringKey: TStringKey, variables?: Record<string, string | number>, language?: TLanguage, metadata?: Record<string, any>): PluginTranslatableGenericError<TStringKey, TLanguage>;
+    /**
+     * Retranslate the error message in a different language
+     */
+    retranslate(language: TLanguage, instanceKey?: string): string;
+}

package/dist/plugin-translatable-generic-error.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginTranslatableGenericError = void 0;
+const plugin_i18n_engine_1 = require("./plugin-i18n-engine");
+/**
+ * Generic translatable error that works with any plugin engine and component
+ */
+class PluginTranslatableGenericError extends Error {
+    /**
+     * Create a translatable error
+     * @param componentId - The component ID to translate from
+     * @param stringKey - The translation key
+     * @param variables - Variables for interpolation
+     * @param language - Optional language override
+     * @param metadata - Additional error metadata
+     * @param instanceKey - Optional engine instance key
+     */
+    constructor(componentId, stringKey, variables, language, metadata, instanceKey) {
+        let translatedMessage;
+        try {
+            const engine = plugin_i18n_engine_1.PluginI18nEngine.getInstance(instanceKey);
+            translatedMessage = engine.safeTranslate(componentId, stringKey, variables, language);
+        }
+        catch (error) {
+            // If engine not found or translation fails, use fallback format
+            translatedMessage = `[${componentId}.${stringKey}]`;
+        }
+        super(translatedMessage);
+        this.name = 'TranslatableGenericError';
+        this.stringKey = stringKey;
+        this.componentId = componentId;
+        this.language = language;
+        this.variables = variables;
+        this.metadata = metadata;
+        // Ensure proper prototype chain for instanceof checks across transpiled targets
+    }
+    /**
+     * Create error with explicit engine instance
+     */
+    static withEngine(engine, componentId, stringKey, variables, language, metadata) {
+        const translatedMessage = engine.safeTranslate(componentId, stringKey, variables, language);
+        const error = Object.create(PluginTranslatableGenericError.prototype);
+        Error.call(error, translatedMessage);
+        error.name = 'TranslatableGenericError';
+        error.stringKey = stringKey;
+        error.componentId = componentId;
+        error.language = language;
+        error.variables = variables;
+        error.metadata = metadata;
+        error.message = translatedMessage;
+        return error;
+    }
+    /**
+     * Retranslate the error message in a different language
+     */
+    retranslate(language, instanceKey) {
+        try {
+            const engine = plugin_i18n_engine_1.PluginI18nEngine.getInstance(instanceKey);
+            return engine.safeTranslate(this.componentId, this.stringKey, this.variables, language);
+        }
+        catch (error) {
+            return `[${this.componentId}.${this.stringKey}]`;
+        }
+    }
+}
+exports.PluginTranslatableGenericError = PluginTranslatableGenericError;

package/dist/plugin-translatable-handleable-generic.d.ts

@@ -0,0 +1,28 @@
+import { IHandleable } from './i-handleable';
+import { PluginTranslatableGenericError } from './plugin-translatable-generic-error';
+/**
+ * Generic translatable error that works with any plugin engine and component
+ */
+export declare class PluginTranslatableHandleableGenericError<TStringKey extends string = string, TLanguage extends string = string> extends PluginTranslatableGenericError<TStringKey, TLanguage> implements IHandleable {
+    private _handled;
+    readonly cause?: Error;
+    readonly statusCode: number;
+    readonly sourceData?: unknown;
+    /**
+     * Create a translatable error
+     * @param componentId - The component ID to translate from
+     * @param stringKey - The translation key
+     * @param variables - Variables for interpolation
+     * @param language - Optional language override
+     * @param metadata - Additional error metadata
+     * @param instanceKey - Optional engine instance key
+     */
+    constructor(componentId: string, stringKey: TStringKey, variables?: Record<string, string | number>, language?: TLanguage, metadata?: Record<string, any>, instanceKey?: string, handleableOptions?: {
+        statusCode?: number;
+        cause?: Error;
+        sourceData?: unknown;
+    });
+    get handled(): boolean;
+    set handled(value: boolean);
+    toJSON(): Record<string, unknown>;
+}

package/dist/plugin-translatable-handleable-generic.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginTranslatableHandleableGenericError = void 0;
+const plugin_translatable_generic_error_1 = require("./plugin-translatable-generic-error");
+/**
+ * Generic translatable error that works with any plugin engine and component
+ */
+class PluginTranslatableHandleableGenericError extends plugin_translatable_generic_error_1.PluginTranslatableGenericError {
+    /**
+     * Create a translatable error
+     * @param componentId - The component ID to translate from
+     * @param stringKey - The translation key
+     * @param variables - Variables for interpolation
+     * @param language - Optional language override
+     * @param metadata - Additional error metadata
+     * @param instanceKey - Optional engine instance key
+     */
+    constructor(componentId, stringKey, variables, language, metadata, instanceKey, handleableOptions) {
+        super(componentId, stringKey, variables, language, metadata, instanceKey);
+        this._handled = false;
+        this.statusCode = handleableOptions?.statusCode ?? 500;
+        this.cause = handleableOptions?.cause;
+        this.sourceData = handleableOptions?.sourceData;
+    }
+    get handled() {
+        return this._handled;
+    }
+    set handled(value) {
+        this._handled = value;
+    }
+    toJSON() {
+        return {
+            statusCode: this.statusCode,
+            message: this.message,
+            cause: this.cause,
+            sourceData: this.sourceData,
+        };
+    }
+}
+exports.PluginTranslatableHandleableGenericError = PluginTranslatableHandleableGenericError;

package/dist/plugin-typed-handleable.d.ts

@@ -0,0 +1,14 @@
+import { HandleableErrorOptions } from './i-handleable-error-options';
+import { IHandleable } from './i-handleable';
+import { CompleteReasonMap, PluginTypedError } from './typed-error';
+import { PluginI18nEngine } from './plugin-i18n-engine';
+export declare class PluginTypedHandleableError<TEnum extends Record<string, string>, TStringKey extends string, TLanguages extends string = string> extends PluginTypedError<TEnum, TStringKey, TLanguages> implements IHandleable {
+    readonly cause?: Error;
+    readonly statusCode: number;
+    readonly sourceData?: unknown;
+    private _handled;
+    constructor(engine: PluginI18nEngine<TLanguages>, componentId: string, type: TEnum[keyof TEnum], reasonMap: CompleteReasonMap<TEnum, TStringKey>, source: Error, options?: HandleableErrorOptions, language?: TLanguages, otherVars?: Record<string, string | number>);
+    get handled(): boolean;
+    set handled(value: boolean);
+    toJSON(): Record<string, unknown>;
+}

package/dist/plugin-typed-handleable.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginTypedHandleableError = void 0;
+const handleable_1 = require("./handleable");
+const typed_error_1 = require("./typed-error");
+class PluginTypedHandleableError extends typed_error_1.PluginTypedError {
+    constructor(engine, componentId, type, reasonMap, source, options, language, otherVars) {
+        super(engine, componentId, type, reasonMap, language, otherVars);
+        this.cause = options?.cause ?? source;
+        this.statusCode = options?.statusCode ?? 500;
+        this._handled = options?.handled ?? false;
+        this.sourceData = options?.sourceData;
+        // Capture stack trace - prioritize source stack, then capture new one
+        if (source.stack) {
+            this.stack = source.stack;
+        }
+        else if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, this.constructor);
+        }
+        else {
+            this.stack = new Error().stack;
+        }
+        this.name = this.constructor.name;
+    }
+    get handled() {
+        return this._handled;
+    }
+    set handled(value) {
+        this._handled = value;
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            message: this.message,
+            statusCode: this.statusCode,
+            handled: this.handled,
+            stack: this.stack,
+            cause: this.cause instanceof handleable_1.HandleableError || this.cause instanceof PluginTypedHandleableError
+                ? this.cause.toJSON()
+                : this.cause?.message,
+            ...(this.sourceData ? { sourceData: this.sourceData } : {}),
+        };
+    }
+}
+exports.PluginTypedHandleableError = PluginTypedHandleableError;

package/dist/translatable.d.ts

@@ -0,0 +1,5 @@
+import { I18nEngine } from './i18n-engine';
+import { Language } from './default-config';
+export declare class TranslatableError<TStringKey extends string> extends Error {
+    constructor(engine: I18nEngine<TStringKey, Language, any, any>, string: TStringKey, otherVars?: Record<string, string | number>, language?: Language);
+}

package/dist/translatable.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TranslatableError = void 0;
+class TranslatableError extends Error {
+    constructor(engine, string, otherVars, language) {
+        super(engine.translate(string, otherVars, language));
+        this.name = 'TranslatableError';
+        Object.setPrototypeOf(this, TranslatableError.prototype);
+    }
+}
+exports.TranslatableError = TranslatableError;

package/dist/unified-translator.d.ts

@@ -0,0 +1,29 @@
+import { PluginI18nEngine } from './plugin-i18n-engine';
+import { I18nEngine } from './i18n-engine';
+/**
+ * Unified translator with explicit component/engine specification
+ */
+export declare class UnifiedTranslator<TLanguage extends string = string> {
+    private sources;
+    private defaultLanguage;
+    private defaultSource?;
+    constructor(defaultLanguage: TLanguage);
+    /**
+     * Register a plugin component
+     */
+    registerPlugin(id: string, engine: PluginI18nEngine<any>, componentId: string): void;
+    /**
+     * Register a legacy engine
+     */
+    registerLegacy(id: string, engine: I18nEngine<any, any, any, any>): void;
+    /**
+     * Set default source for unqualified keys
+     */
+    setDefaultSource(id: string): void;
+    /**
+     * Translate with explicit source: 'source:key' or just 'key' (uses default)
+     */
+    translate(key: string, vars?: Record<string, string | number>, language?: TLanguage): string;
+    setLanguage(language: TLanguage): void;
+    getLanguage(): TLanguage;
+}

package/dist/unified-translator.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnifiedTranslator = void 0;
+/**
+ * Unified translator with explicit component/engine specification
+ */
+class UnifiedTranslator {
+    constructor(defaultLanguage) {
+        this.sources = new Map();
+        this.defaultLanguage = defaultLanguage;
+    }
+    /**
+     * Register a plugin component
+     */
+    registerPlugin(id, engine, componentId) {
+        this.sources.set(id, { type: 'plugin', engine, componentId });
+        if (!this.defaultSource)
+            this.defaultSource = id;
+    }
+    /**
+     * Register a legacy engine
+     */
+    registerLegacy(id, engine) {
+        this.sources.set(id, { type: 'legacy', engine });
+        if (!this.defaultSource)
+            this.defaultSource = id;
+    }
+    /**
+     * Set default source for unqualified keys
+     */
+    setDefaultSource(id) {
+        if (!this.sources.has(id)) {
+            throw new Error(`Source '${id}' not registered`);
+        }
+        this.defaultSource = id;
+    }
+    /**
+     * Translate with explicit source: 'source:key' or just 'key' (uses default)
+     */
+    translate(key, vars, language) {
+        const lang = language || this.defaultLanguage;
+        const [sourceName, actualKey] = key.includes(':')
+            ? key.split(':', 2)
+            : [this.defaultSource, key];
+        if (!sourceName)
+            return `[${key}]`;
+        const source = this.sources.get(sourceName);
+        if (!source)
+            return `[${key}]`;
+        if (source.type === 'plugin') {
+            return source.engine.safeTranslate(source.componentId, actualKey, vars, lang);
+        }
+        else {
+            return source.engine.safeTranslate(actualKey, vars, lang);
+        }
+    }
+    setLanguage(language) {
+        this.defaultLanguage = language;
+    }
+    getLanguage() {
+        return this.defaultLanguage;
+    }
+}
+exports.UnifiedTranslator = UnifiedTranslator;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@digitaldefiance/i18n-lib",
-  "version": "1.3.8",
+  "version": "1.3.10",
   "description": "Generic i18n library with enum translation support",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",