@digitaldefiance/i18n-lib 1.0.33 → 1.1.1

package/dist/default-config.js

@@ -40,56 +40,56 @@ const getConfig = (constants, timezone, adminTimezone) => ({
     strings: {
         [DefaultLanguage.EnglishUS]: {
             [DefaultStringKey.Common_Test]: 'Test',
-            [DefaultStringKey.Error_InstanceAlreadyExistsTemplate]: 'Instance with key \'{key}\' already exists',
-            [DefaultStringKey.Error_InstanceNotFoundTemplate]: 'Instance with key \'{key}\' not found',
+            [DefaultStringKey.Error_InstanceAlreadyExistsTemplate]: "Instance with key '{key}' already exists",
+            [DefaultStringKey.Error_InstanceNotFoundTemplate]: "Instance with key '{key}' not found",
             [DefaultStringKey.Error_MissingStringCollectionTemplate]: 'Missing string collection for language: {language}',
-            [DefaultStringKey.Error_MissingTranslationTemplate]: 'Missing translation for key \'{key}\' in language \'{language}\'',
-            [DefaultStringKey.Error_DefaultLanguageNoCollectionTemplate]: 'Default language \'{language}\' has no string collection',
+            [DefaultStringKey.Error_MissingTranslationTemplate]: "Missing translation for key '{key}' in language '{language}'",
+            [DefaultStringKey.Error_DefaultLanguageNoCollectionTemplate]: "Default language '{language}' has no string collection",
             [DefaultStringKey.Error_MissingTranslationKeyTemplate]: 'Missing translation key for type: {type}',
         },
         [DefaultLanguage.EnglishUK]: {
             [DefaultStringKey.Common_Test]: 'Test',
-            [DefaultStringKey.Error_InstanceAlreadyExistsTemplate]: 'Instance with key \'{key}\' already exists',
-            [DefaultStringKey.Error_InstanceNotFoundTemplate]: 'Instance with key \'{key}\' not found',
+            [DefaultStringKey.Error_InstanceAlreadyExistsTemplate]: "Instance with key '{key}' already exists",
+            [DefaultStringKey.Error_InstanceNotFoundTemplate]: "Instance with key '{key}' not found",
             [DefaultStringKey.Error_MissingStringCollectionTemplate]: 'Missing string collection for language: {language}',
-            [DefaultStringKey.Error_MissingTranslationTemplate]: 'Missing translation for key \'{key}\' in language \'{language}\'',
-            [DefaultStringKey.Error_DefaultLanguageNoCollectionTemplate]: 'Default language \'{language}\' has no string collection',
+            [DefaultStringKey.Error_MissingTranslationTemplate]: "Missing translation for key '{key}' in language '{language}'",
+            [DefaultStringKey.Error_DefaultLanguageNoCollectionTemplate]: "Default language '{language}' has no string collection",
             [DefaultStringKey.Error_MissingTranslationKeyTemplate]: 'Missing translation key for type: {type}',
         },
         [DefaultLanguage.French]: {
             [DefaultStringKey.Common_Test]: 'Test',
-            [DefaultStringKey.Error_InstanceAlreadyExistsTemplate]: 'Instance avec clé \'{key}\' existe déjà',
-            [DefaultStringKey.Error_InstanceNotFoundTemplate]: 'Instance avec clé \'{key}\' introuvable',
+            [DefaultStringKey.Error_InstanceAlreadyExistsTemplate]: "Instance avec clé '{key}' existe déjà",
+            [DefaultStringKey.Error_InstanceNotFoundTemplate]: "Instance avec clé '{key}' introuvable",
             [DefaultStringKey.Error_MissingStringCollectionTemplate]: 'Collection de chaînes manquante pour la langue: {language}',
-            [DefaultStringKey.Error_MissingTranslationTemplate]: 'Traduction manquante pour la clé \'{key}\' dans la langue \'{language}\'',
-            [DefaultStringKey.Error_DefaultLanguageNoCollectionTemplate]: 'La langue par défaut \'{language}\' n\'a pas de collection de chaînes',
+            [DefaultStringKey.Error_MissingTranslationTemplate]: "Traduction manquante pour la clé '{key}' dans la langue '{language}'",
+            [DefaultStringKey.Error_DefaultLanguageNoCollectionTemplate]: "La langue par défaut '{language}' n'a pas de collection de chaînes",
             [DefaultStringKey.Error_MissingTranslationKeyTemplate]: 'Clé de traduction manquante pour le type: {type}',
         },
         [DefaultLanguage.MandarinChinese]: {
             [DefaultStringKey.Common_Test]: '测试',
-            [DefaultStringKey.Error_InstanceAlreadyExistsTemplate]: '键为\'{key}\'的实例已存在',
-            [DefaultStringKey.Error_InstanceNotFoundTemplate]: '未找到键为\'{key}\'的实例',
+            [DefaultStringKey.Error_InstanceAlreadyExistsTemplate]: "键为'{key}'的实例已存在",
+            [DefaultStringKey.Error_InstanceNotFoundTemplate]: "未找到键为'{key}'的实例",
             [DefaultStringKey.Error_MissingStringCollectionTemplate]: '缺少语言的字符串集合: {language}',
-            [DefaultStringKey.Error_MissingTranslationTemplate]: '在语言\'{language}\'中缺少键\'{key}\'的翻译',
-            [DefaultStringKey.Error_DefaultLanguageNoCollectionTemplate]: '默认语言\'{language}\'没有字符串集合',
+            [DefaultStringKey.Error_MissingTranslationTemplate]: "在语言'{language}'中缺少键'{key}'的翻译",
+            [DefaultStringKey.Error_DefaultLanguageNoCollectionTemplate]: "默认语言'{language}'没有字符串集合",
             [DefaultStringKey.Error_MissingTranslationKeyTemplate]: '类型缺少翻译键: {type}',
         },
         [DefaultLanguage.Spanish]: {
             [DefaultStringKey.Common_Test]: 'Prueba',
-            [DefaultStringKey.Error_InstanceAlreadyExistsTemplate]: 'La instancia con clave \'{key}\' ya existe',
-            [DefaultStringKey.Error_InstanceNotFoundTemplate]: 'Instancia con clave \'{key}\' no encontrada',
+            [DefaultStringKey.Error_InstanceAlreadyExistsTemplate]: "La instancia con clave '{key}' ya existe",
+            [DefaultStringKey.Error_InstanceNotFoundTemplate]: "Instancia con clave '{key}' no encontrada",
             [DefaultStringKey.Error_MissingStringCollectionTemplate]: 'Falta colección de cadenas para el idioma: {language}',
-            [DefaultStringKey.Error_MissingTranslationTemplate]: 'Falta traducción para la clave \'{key}\' en el idioma \'{language}\'',
-            [DefaultStringKey.Error_DefaultLanguageNoCollectionTemplate]: 'El idioma predeterminado \'{language}\' no tiene colección de cadenas',
+            [DefaultStringKey.Error_MissingTranslationTemplate]: "Falta traducción para la clave '{key}' en el idioma '{language}'",
+            [DefaultStringKey.Error_DefaultLanguageNoCollectionTemplate]: "El idioma predeterminado '{language}' no tiene colección de cadenas",
             [DefaultStringKey.Error_MissingTranslationKeyTemplate]: 'Falta clave de traducción para el tipo: {type}',
         },
         [DefaultLanguage.Ukrainian]: {
             [DefaultStringKey.Common_Test]: 'Тест',
-            [DefaultStringKey.Error_InstanceAlreadyExistsTemplate]: 'Екземпляр з ключем \'{key}\' вже існує',
-            [DefaultStringKey.Error_InstanceNotFoundTemplate]: 'Екземпляр з ключем \'{key}\' не знайдено',
+            [DefaultStringKey.Error_InstanceAlreadyExistsTemplate]: "Екземпляр з ключем '{key}' вже існує",
+            [DefaultStringKey.Error_InstanceNotFoundTemplate]: "Екземпляр з ключем '{key}' не знайдено",
             [DefaultStringKey.Error_MissingStringCollectionTemplate]: 'Відсутня колекція рядків для мови: {language}',
-            [DefaultStringKey.Error_MissingTranslationTemplate]: 'Відсутній переклад для ключа \'{key}\' в мові \'{language}\'',
-            [DefaultStringKey.Error_DefaultLanguageNoCollectionTemplate]: 'Мова за замовчуванням \'{language}\' не має колекції рядків',
+            [DefaultStringKey.Error_MissingTranslationTemplate]: "Відсутній переклад для ключа '{key}' в мові '{language}'",
+            [DefaultStringKey.Error_DefaultLanguageNoCollectionTemplate]: "Мова за замовчуванням '{language}' не має колекції рядків",
             [DefaultStringKey.Error_MissingTranslationKeyTemplate]: 'Відсутній ключ перекладу для типу: {type}',
         },
     },

package/dist/i18n-config.d.ts

@@ -0,0 +1,20 @@
+import { CurrencyCode } from './currency-code';
+import { Timezone } from './timezone';
+import { LanguageCodeCollection, LanguageContext, MasterStringsCollection } from './types';
+/**
+ * I18n configuration interface
+ */
+export interface I18nConfig<TStringKey extends string, TLanguage extends string, TConstants extends Record<string, any> = Record<string, any>, TTranslationContext extends string = LanguageContext> {
+    stringNames: TStringKey[];
+    strings: MasterStringsCollection<TStringKey, TLanguage>;
+    defaultLanguage: TLanguage;
+    defaultTranslationContext: TTranslationContext;
+    defaultCurrencyCode: CurrencyCode;
+    languageCodes: LanguageCodeCollection<TLanguage>;
+    languages: TLanguage[];
+    constants?: TConstants;
+    enumName?: string;
+    enumObj?: Record<string, TStringKey>;
+    timezone: Timezone;
+    adminTimezone: Timezone;
+}

package/dist/i18n-config.js

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

package/dist/i18n-context.d.ts

@@ -0,0 +1,14 @@
+import { CurrencyCode } from './currency-code';
+import { Timezone } from './timezone';
+import { LanguageContext } from './types';
+/**
+ * I18n context interface
+ */
+export interface I18nContext<TLanguage extends string, TTranslationContext extends string = LanguageContext> {
+    language: TLanguage;
+    adminLanguage: TLanguage;
+    currencyCode: CurrencyCode;
+    currentContext: TTranslationContext;
+    timezone: Timezone;
+    adminTimezone: Timezone;
+}

package/dist/i18n-context.js

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

package/dist/i18n-engine.d.ts

@@ -1,5 +1,7 @@
 import { EnumTranslationRegistry } from './enum-registry';
-import { EnumLanguageTranslation, I18nConfig, I18nContext } from './types';
+import { I18nConfig } from './i18n-config';
+import { I18nContext } from './i18n-context';
+import { EnumLanguageTranslation } from './types';
 /**
  * Internationalization engine class
  */

package/dist/index.d.ts

@@ -1,15 +1,35 @@
 export * from './active-context';
+export * from './component-definition';
+export * from './component-registration';
+export * from './component-registry';
 export * from './context';
 export * from './context-manager';
 export * from './currency';
 export * from './currency-code';
 export * from './currency-format';
-export * from './enum-registry';
 export * from './default-config';
+export * from './enum-registry';
+export * from './i18n-context';
 export * from './i18n-engine';
+export * from './language-definition';
 export * from './template';
 export * from './timezone';
 export * from './typed-error';
 export * from './types';
 export * from './utils';
+export * from './validation-config';
+export * from './validation-result';
+export * from './core-i18n';
+export * from './core-language';
+export * from './core-string-key';
+export * from './language-registry';
+export * from './plugin-i18n-engine';
+export * from './registry-config';
+export * from './registry-context';
+export * from './registry-error';
+export * from './registry-error-type';
+export * from './translation-request';
+export * from './translation-response';
+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

@@ -14,21 +14,44 @@ 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 });
-exports.I18n = void 0;
+exports.PluginI18n = exports.I18n = exports.createCoreI18n = void 0;
+// Legacy exports (for backwards compatibility)
 __exportStar(require("./active-context"), exports);
+__exportStar(require("./component-definition"), exports);
+__exportStar(require("./component-registration"), exports);
+__exportStar(require("./component-registry"), exports);
 __exportStar(require("./context"), exports);
 __exportStar(require("./context-manager"), exports);
 __exportStar(require("./currency"), exports);
 __exportStar(require("./currency-code"), exports);
 __exportStar(require("./currency-format"), exports);
-__exportStar(require("./enum-registry"), exports);
 __exportStar(require("./default-config"), exports);
+__exportStar(require("./enum-registry"), exports);
+__exportStar(require("./i18n-context"), exports);
 __exportStar(require("./i18n-engine"), exports);
+__exportStar(require("./language-definition"), exports);
 __exportStar(require("./template"), exports);
 __exportStar(require("./timezone"), exports);
 __exportStar(require("./typed-error"), exports);
 __exportStar(require("./types"), exports);
 __exportStar(require("./utils"), exports);
+__exportStar(require("./validation-config"), exports);
+__exportStar(require("./validation-result"), exports);
+__exportStar(require("./core-i18n"), exports);
+__exportStar(require("./core-language"), exports);
+__exportStar(require("./core-string-key"), exports);
+__exportStar(require("./language-registry"), exports);
+__exportStar(require("./plugin-i18n-engine"), exports);
+__exportStar(require("./registry-config"), exports);
+__exportStar(require("./registry-context"), exports);
+__exportStar(require("./registry-error"), exports);
+__exportStar(require("./registry-error-type"), exports);
+__exportStar(require("./translation-request"), exports);
+__exportStar(require("./translation-response"), 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; } });
 var i18n_engine_1 = require("./i18n-engine");
 Object.defineProperty(exports, "I18n", { enumerable: true, get: function () { return i18n_engine_1.I18nEngine; } });
+var plugin_i18n_engine_1 = require("./plugin-i18n-engine");
+Object.defineProperty(exports, "PluginI18n", { enumerable: true, get: function () { return plugin_i18n_engine_1.PluginI18nEngine; } });

package/dist/language-definition.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Language definition with its properties
+ */
+export interface LanguageDefinition {
+    /** Unique identifier for the language */
+    readonly id: string;
+    /** Display name in the native language */
+    readonly name: string;
+    /** ISO language code (e.g., 'en', 'fr', 'zh-CN') */
+    readonly code: string;
+    /** Whether this is the fallback/default language */
+    readonly isDefault?: boolean;
+}

package/dist/language-definition.js

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

package/dist/language-registry.d.ts

@@ -0,0 +1,106 @@
+/**
+ * Language registry for managing supported languages and their properties
+ */
+import { LanguageDefinition } from './language-definition';
+/**
+ * Registry for managing supported languages
+ */
+export declare class LanguageRegistry<TLanguages extends string> {
+    private readonly languages;
+    private readonly languagesByCodes;
+    private defaultLanguageId;
+    constructor();
+    /**
+     * Register a new language
+     */
+    registerLanguage(language: LanguageDefinition): void;
+    /**
+     * Register multiple languages at once
+     */
+    registerLanguages(languages: readonly LanguageDefinition[]): void;
+    /**
+     * Get a language by its ID
+     */
+    getLanguage(languageId: TLanguages): LanguageDefinition | undefined;
+    /**
+     * Get a language by its code
+     */
+    getLanguageByCode(code: string): LanguageDefinition | undefined;
+    /**
+     * Get all registered languages
+     */
+    getAllLanguages(): ReadonlyArray<LanguageDefinition>;
+    /**
+     * Get all language IDs
+     */
+    getLanguageIds(): readonly TLanguages[];
+    /**
+     * Get all language codes
+     */
+    getLanguageCodes(): readonly string[];
+    /**
+     * Check if a language is registered
+     */
+    hasLanguage(languageId: TLanguages): boolean;
+    /**
+     * Check if a language code is registered
+     */
+    hasLanguageCode(code: string): boolean;
+    /**
+     * Get the default language
+     */
+    getDefaultLanguage(): LanguageDefinition | null;
+    /**
+     * Get the default language ID
+     */
+    getDefaultLanguageId(): TLanguages | null;
+    /**
+     * Set the default language
+     */
+    setDefaultLanguage(languageId: TLanguages): void;
+    /**
+     * Get the number of registered languages
+     */
+    getLanguageCount(): number;
+    /**
+     * Validate that all required languages are present
+     */
+    validateRequiredLanguages(requiredLanguages: readonly TLanguages[]): LanguageValidationResult;
+    /**
+     * Create a mapping of language IDs to their display names
+     */
+    getLanguageDisplayNames(): Record<TLanguages, string>;
+    /**
+     * Create a mapping of language IDs to their codes
+     */
+    getLanguageCodeMapping(): Record<TLanguages, string>;
+    /**
+     * Find languages by partial name match (case-insensitive)
+     */
+    findLanguagesByName(partialName: string): readonly LanguageDefinition[];
+    /**
+     * Clear all registered languages
+     */
+    clear(): void;
+}
+/**
+ * Validation result for language operations
+ */
+export interface LanguageValidationResult {
+    readonly isValid: boolean;
+    readonly missingLanguages: readonly string[];
+    readonly errors: readonly string[];
+}
+/**
+ * Helper function to create language definitions with type safety
+ */
+export declare function createLanguageDefinition(id: string, name: string, code: string, isDefault?: boolean): LanguageDefinition;
+/**
+ * Helper function to create multiple language definitions
+ */
+export declare function createLanguageDefinitions(languages: Array<{
+    id: string;
+    name: string;
+    code: string;
+    isDefault?: boolean;
+}>): LanguageDefinition[];

package/dist/language-registry.js

@@ -0,0 +1,194 @@
+"use strict";
+/**
+ * Language registry for managing supported languages and their properties
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LanguageRegistry = void 0;
+exports.createLanguageDefinition = createLanguageDefinition;
+exports.createLanguageDefinitions = createLanguageDefinitions;
+const registry_error_1 = require("./registry-error");
+const registry_error_type_1 = require("./registry-error-type");
+/**
+ * Registry for managing supported languages
+ */
+class LanguageRegistry {
+    constructor() {
+        this.languages = new Map();
+        this.languagesByCodes = new Map();
+        this.defaultLanguageId = null;
+        // Empty constructor - languages are registered via registerLanguage method
+    }
+    /**
+     * Register a new language
+     */
+    registerLanguage(language) {
+        const languageId = language.id;
+        // Check for duplicate language ID
+        if (this.languages.has(languageId)) {
+            throw registry_error_1.RegistryError.createSimple(registry_error_type_1.RegistryErrorType.DuplicateLanguage, `Language '${languageId}' is already registered`, { languageId });
+        }
+        // Check for duplicate language code
+        if (this.languagesByCodes.has(language.code)) {
+            const existingLanguageId = this.languagesByCodes.get(language.code);
+            throw registry_error_1.RegistryError.createSimple(registry_error_type_1.RegistryErrorType.DuplicateLanguage, `Language code '${language.code}' is already used by language '${existingLanguageId}'`, { languageId, code: language.code, existingLanguageId });
+        }
+        // Register the language
+        this.languages.set(languageId, language);
+        this.languagesByCodes.set(language.code, languageId);
+        // Set as default if specified or if it's the first language
+        if (language.isDefault || this.defaultLanguageId === null) {
+            this.defaultLanguageId = languageId;
+        }
+    }
+    /**
+     * Register multiple languages at once
+     */
+    registerLanguages(languages) {
+        for (const language of languages) {
+            this.registerLanguage(language);
+        }
+    }
+    /**
+     * Get a language by its ID
+     */
+    getLanguage(languageId) {
+        return this.languages.get(languageId);
+    }
+    /**
+     * Get a language by its code
+     */
+    getLanguageByCode(code) {
+        const languageId = this.languagesByCodes.get(code);
+        return languageId ? this.languages.get(languageId) : undefined;
+    }
+    /**
+     * Get all registered languages
+     */
+    getAllLanguages() {
+        return Array.from(this.languages.values());
+    }
+    /**
+     * Get all language IDs
+     */
+    getLanguageIds() {
+        return Array.from(this.languages.keys());
+    }
+    /**
+     * Get all language codes
+     */
+    getLanguageCodes() {
+        return Array.from(this.languagesByCodes.keys());
+    }
+    /**
+     * Check if a language is registered
+     */
+    hasLanguage(languageId) {
+        return this.languages.has(languageId);
+    }
+    /**
+     * Check if a language code is registered
+     */
+    hasLanguageCode(code) {
+        return this.languagesByCodes.has(code);
+    }
+    /**
+     * Get the default language
+     */
+    getDefaultLanguage() {
+        return this.defaultLanguageId
+            ? this.languages.get(this.defaultLanguageId) || null
+            : null;
+    }
+    /**
+     * Get the default language ID
+     */
+    getDefaultLanguageId() {
+        return this.defaultLanguageId;
+    }
+    /**
+     * Set the default language
+     */
+    setDefaultLanguage(languageId) {
+        if (!this.languages.has(languageId)) {
+            throw registry_error_1.RegistryError.createSimple(registry_error_type_1.RegistryErrorType.LanguageNotFound, `Language '${languageId}' not found`, { languageId });
+        }
+        this.defaultLanguageId = languageId;
+    }
+    /**
+     * Get the number of registered languages
+     */
+    getLanguageCount() {
+        return this.languages.size;
+    }
+    /**
+     * Validate that all required languages are present
+     */
+    validateRequiredLanguages(requiredLanguages) {
+        const missingLanguages = [];
+        const errors = [];
+        for (const languageId of requiredLanguages) {
+            if (!this.languages.has(languageId)) {
+                missingLanguages.push(languageId);
+                errors.push(`Required language '${languageId}' is not registered`);
+            }
+        }
+        return {
+            isValid: missingLanguages.length === 0,
+            missingLanguages,
+            errors,
+        };
+    }
+    /**
+     * Create a mapping of language IDs to their display names
+     */
+    getLanguageDisplayNames() {
+        const result = {};
+        for (const [languageId, language] of this.languages) {
+            result[languageId] = language.name;
+        }
+        return result;
+    }
+    /**
+     * Create a mapping of language IDs to their codes
+     */
+    getLanguageCodeMapping() {
+        const result = {};
+        for (const [languageId, language] of this.languages) {
+            result[languageId] = language.code;
+        }
+        return result;
+    }
+    /**
+     * Find languages by partial name match (case-insensitive)
+     */
+    findLanguagesByName(partialName) {
+        const searchTerm = partialName.toLowerCase();
+        return Array.from(this.languages.values()).filter((language) => language.name.toLowerCase().includes(searchTerm));
+    }
+    /**
+     * Clear all registered languages
+     */
+    clear() {
+        this.languages.clear();
+        this.languagesByCodes.clear();
+        this.defaultLanguageId = null;
+    }
+}
+exports.LanguageRegistry = LanguageRegistry;
+/**
+ * Helper function to create language definitions with type safety
+ */
+function createLanguageDefinition(id, name, code, isDefault) {
+    return {
+        id,
+        name,
+        code,
+        isDefault: isDefault || false,
+    };
+}
+/**
+ * Helper function to create multiple language definitions
+ */
+function createLanguageDefinitions(languages) {
+    return languages.map((lang) => createLanguageDefinition(lang.id, lang.name, lang.code, lang.isDefault));
+}