@digitaldefiance/i18n-lib 1.0.32 → 1.1.0

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));
+}

package/dist/plugin-i18n-engine.d.ts

@@ -0,0 +1,126 @@
+/**
+ * Plugin-based internationalization engine with component and language registration
+ */
+import { ComponentDefinition } from './component-definition';
+import { ComponentRegistration } from './component-registration';
+import { ComponentRegistry } from './component-registry';
+import { EnumTranslationRegistry } from './enum-registry';
+import { LanguageDefinition } from './language-definition';
+import { LanguageRegistry } from './language-registry';
+import { RegistryConfig } from './registry-config';
+import { RegistryContext } from './registry-context';
+import { TranslationResponse } from './translation-response';
+import { EnumLanguageTranslation } from './types';
+/**
+ * Plugin-based I18n Engine with registration capabilities
+ */
+export declare class PluginI18nEngine<TLanguages extends string> {
+    private readonly languageRegistry;
+    private readonly componentRegistry;
+    private readonly enumRegistry;
+    private readonly config;
+    private context;
+    /**
+     * Static instances for semi-singleton pattern
+     */
+    private static _instances;
+    private static _defaultKey;
+    protected static readonly DefaultInstanceKey = "default";
+    constructor(initialLanguages: readonly LanguageDefinition[], config?: Partial<RegistryConfig<TLanguages>>);
+    /**
+     * Create a new instance with a specific key
+     */
+    static createInstance<TLangs extends string>(key: string, initialLanguages: readonly LanguageDefinition[], config?: Partial<RegistryConfig<TLangs>>): PluginI18nEngine<TLangs>;
+    /**
+     * Get an existing instance by key
+     */
+    static getInstance<TLangs extends string>(key?: string): PluginI18nEngine<TLangs>;
+    /**
+     * Register a new language
+     */
+    registerLanguage(language: LanguageDefinition): void;
+    /**
+     * Register multiple languages
+     */
+    registerLanguages(languages: readonly LanguageDefinition[]): void;
+    /**
+     * Register a component with its translations
+     */
+    registerComponent<TStringKeys extends string>(registration: ComponentRegistration<TStringKeys, TLanguages>): import("./validation-result").ValidationResult;
+    /**
+     * Update strings for an existing component
+     */
+    updateComponentStrings<TStringKeys extends string>(componentId: string, strings: Parameters<ComponentRegistry<TLanguages>['updateComponentStrings']>[1]): import("./validation-result").ValidationResult;
+    /**
+     * Register an enum with translations
+     */
+    registerEnum<TEnum extends string | number>(enumObj: Record<string, TEnum>, translations: EnumLanguageTranslation<TEnum, TLanguages>, enumName: string): void;
+    /**
+     * Translate a string for a component
+     */
+    translate<TStringKeys extends string>(componentId: string, stringKey: TStringKeys, variables?: Record<string, string | number>, language?: TLanguages): string;
+    /**
+     * Safe translate that returns a placeholder if translation fails
+     */
+    safeTranslate(componentId: string, stringKey: string, variables?: Record<string, string | number>, language?: TLanguages): string;
+    /**
+     * Translate an enum value
+     */
+    translateEnum<TEnum extends string | number>(enumObj: Record<string, TEnum>, value: TEnum, language?: TLanguages): string;
+    /**
+     * Get detailed translation response
+     */
+    getTranslationDetails<TStringKeys extends string>(componentId: string, stringKey: TStringKeys, variables?: Record<string, string | number>, language?: TLanguages): TranslationResponse;
+    /**
+     * Get current context
+     */
+    getContext(): RegistryContext<TLanguages>;
+    /**
+     * Update context
+     */
+    updateContext(updates: Partial<RegistryContext<TLanguages>>): void;
+    /**
+     * Set current language
+     */
+    setLanguage(language: TLanguages): void;
+    /**
+     * Get available languages
+     */
+    getLanguages(): readonly LanguageDefinition[];
+    /**
+     * Get registered components
+     */
+    getComponents(): ReadonlyArray<ComponentDefinition<any>>;
+    /**
+     * Check if a component is registered
+     */
+    hasComponent(componentId: string): boolean;
+    /**
+     * Check if a language is registered
+     */
+    hasLanguage(language: TLanguages): boolean;
+    /**
+     * Get language by code
+     */
+    getLanguageByCode(code: string): LanguageDefinition | undefined;
+    /**
+     * Get language registry for direct access
+     */
+    getLanguageRegistry(): LanguageRegistry<TLanguages>;
+    /**
+     * Get component registry for direct access
+     */
+    getComponentRegistry(): ComponentRegistry<TLanguages>;
+    /**
+     * Get enum registry for direct access
+     */
+    getEnumRegistry(): EnumTranslationRegistry<string, TLanguages>;
+    /**
+     * Validate that all components have complete translations
+     */
+    validateAllComponents(): {
+        isValid: boolean;
+        errors: string[];
+        warnings: string[];
+    };
+}

package/dist/plugin-i18n-engine.js

@@ -0,0 +1,266 @@
+"use strict";
+/**
+ * Plugin-based internationalization engine with component and language registration
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginI18nEngine = void 0;
+const component_registry_1 = require("./component-registry");
+const currency_code_1 = require("./currency-code");
+const enum_registry_1 = require("./enum-registry");
+const language_registry_1 = require("./language-registry");
+const registry_error_1 = require("./registry-error");
+const registry_error_type_1 = require("./registry-error-type");
+const timezone_1 = require("./timezone");
+/**
+ * Plugin-based I18n Engine with registration capabilities
+ */
+class PluginI18nEngine {
+    constructor(initialLanguages, config = {}) {
+        // Find default language from initialLanguages or use the first one
+        const defaultLang = initialLanguages.find((l) => l.isDefault) || initialLanguages[0];
+        if (!defaultLang) {
+            throw new Error('At least one language must be provided');
+        }
+        // Set up configuration with defaults
+        this.config = {
+            defaultLanguage: defaultLang.id,
+            fallbackLanguage: defaultLang.id,
+            defaultCurrencyCode: new currency_code_1.CurrencyCode('USD'),
+            timezone: new timezone_1.Timezone('UTC'),
+            adminTimezone: new timezone_1.Timezone('UTC'),
+            validation: {
+                requireCompleteStrings: false,
+                allowPartialRegistration: true,
+                fallbackLanguageId: defaultLang.id,
+            },
+            ...config,
+        };
+        // Initialize registries
+        this.languageRegistry = new language_registry_1.LanguageRegistry();
+        this.componentRegistry = new component_registry_1.ComponentRegistry(initialLanguages.map((l) => l.id), this.config.validation);
+        this.enumRegistry = new enum_registry_1.EnumTranslationRegistry(initialLanguages.map((l) => l.id), (key, vars) => this.safeTranslate('core', key, vars));
+        // Register initial languages
+        this.languageRegistry.registerLanguages(initialLanguages);
+        // Initialize context
+        this.context = {
+            currentLanguage: this.config.defaultLanguage,
+            fallbackLanguage: this.config.fallbackLanguage,
+            currencyCode: this.config.defaultCurrencyCode,
+            timezone: this.config.timezone,
+            adminTimezone: this.config.adminTimezone,
+        };
+    }
+    /**
+     * Create a new instance with a specific key
+     */
+    static createInstance(key, initialLanguages, config) {
+        if (PluginI18nEngine._instances.has(key)) {
+            throw registry_error_1.RegistryError.createSimple(registry_error_type_1.RegistryErrorType.DuplicateComponent, `I18n instance with key '${key}' already exists`, { key });
+        }
+        const instance = new PluginI18nEngine(initialLanguages, config);
+        PluginI18nEngine._instances.set(key, instance);
+        if (!PluginI18nEngine._defaultKey) {
+            PluginI18nEngine._defaultKey = key;
+        }
+        return instance;
+    }
+    /**
+     * Get an existing instance by key
+     */
+    static getInstance(key) {
+        const instanceKey = key ||
+            PluginI18nEngine._defaultKey ||
+            PluginI18nEngine.DefaultInstanceKey;
+        const instance = PluginI18nEngine._instances.get(instanceKey);
+        if (!instance) {
+            throw registry_error_1.RegistryError.createSimple(registry_error_type_1.RegistryErrorType.ComponentNotFound, `I18n instance with key '${instanceKey}' not found`, { key: instanceKey });
+        }
+        return instance;
+    }
+    /**
+     * Register a new language
+     */
+    registerLanguage(language) {
+        this.languageRegistry.registerLanguage(language);
+        // Update component registry with new language
+        const newLanguages = this.languageRegistry.getLanguageIds();
+        this.componentRegistry.updateRegisteredLanguages(newLanguages);
+    }
+    /**
+     * Register multiple languages
+     */
+    registerLanguages(languages) {
+        for (const language of languages) {
+            this.registerLanguage(language);
+        }
+    }
+    /**
+     * Register a component with its translations
+     */
+    registerComponent(registration) {
+        return this.componentRegistry.registerComponent(registration);
+    }
+    /**
+     * Update strings for an existing component
+     */
+    updateComponentStrings(componentId, strings) {
+        return this.componentRegistry.updateComponentStrings(componentId, strings);
+    }
+    /**
+     * Register an enum with translations
+     */
+    registerEnum(enumObj, translations, enumName) {
+        this.enumRegistry.register(enumObj, translations, enumName);
+    }
+    /**
+     * Translate a string for a component
+     */
+    translate(componentId, stringKey, variables, language) {
+        const request = {
+            componentId,
+            stringKey,
+            language: language || this.context.currentLanguage,
+            variables,
+        };
+        const response = this.componentRegistry.getTranslation(request);
+        return response.translation;
+    }
+    /**
+     * Safe translate that returns a placeholder if translation fails
+     */
+    safeTranslate(componentId, stringKey, variables, language) {
+        try {
+            return this.translate(componentId, stringKey, variables, language);
+        }
+        catch (error) {
+            // Return a placeholder if translation fails
+            return `[${componentId}.${stringKey}]`;
+        }
+    }
+    /**
+     * Translate an enum value
+     */
+    translateEnum(enumObj, value, language) {
+        return this.enumRegistry.translate(enumObj, value, language || this.context.currentLanguage);
+    }
+    /**
+     * Get detailed translation response
+     */
+    getTranslationDetails(componentId, stringKey, variables, language) {
+        const request = {
+            componentId,
+            stringKey,
+            language: language || this.context.currentLanguage,
+            variables,
+        };
+        return this.componentRegistry.getTranslation(request);
+    }
+    /**
+     * Get current context
+     */
+    getContext() {
+        return { ...this.context };
+    }
+    /**
+     * Update context
+     */
+    updateContext(updates) {
+        this.context = { ...this.context, ...updates };
+    }
+    /**
+     * Set current language
+     */
+    setLanguage(language) {
+        if (!this.languageRegistry.hasLanguage(language)) {
+            throw registry_error_1.RegistryError.createSimple(registry_error_type_1.RegistryErrorType.LanguageNotFound, `Language '${language}' is not registered`, { language });
+        }
+        this.context.currentLanguage = language;
+    }
+    /**
+     * Get available languages
+     */
+    getLanguages() {
+        return this.languageRegistry.getAllLanguages();
+    }
+    /**
+     * Get registered components
+     */
+    getComponents() {
+        return this.componentRegistry.getComponents();
+    }
+    /**
+     * Check if a component is registered
+     */
+    hasComponent(componentId) {
+        return this.componentRegistry.hasComponent(componentId);
+    }
+    /**
+     * Check if a language is registered
+     */
+    hasLanguage(language) {
+        return this.languageRegistry.hasLanguage(language);
+    }
+    /**
+     * Get language by code
+     */
+    getLanguageByCode(code) {
+        return this.languageRegistry.getLanguageByCode(code);
+    }
+    /**
+     * Get language registry for direct access
+     */
+    getLanguageRegistry() {
+        return this.languageRegistry;
+    }
+    /**
+     * Get component registry for direct access
+     */
+    getComponentRegistry() {
+        return this.componentRegistry;
+    }
+    /**
+     * Get enum registry for direct access
+     */
+    getEnumRegistry() {
+        return this.enumRegistry;
+    }
+    /**
+     * Validate that all components have complete translations
+     */
+    validateAllComponents() {
+        const errors = [];
+        const warnings = [];
+        let isValid = true;
+        const components = this.getComponents();
+        const languages = this.languageRegistry.getLanguageIds();
+        for (const component of components) {
+            const componentStrings = this.componentRegistry.getComponentStrings(component.id);
+            if (!componentStrings) {
+                errors.push(`Component '${component.id}' has no registered strings`);
+                isValid = false;
+                continue;
+            }
+            for (const language of languages) {
+                const languageStrings = componentStrings[language];
+                if (!languageStrings) {
+                    errors.push(`Component '${component.id}' missing strings for language '${language}'`);
+                    isValid = false;
+                    continue;
+                }
+                for (const stringKey of component.stringKeys) {
+                    if (!languageStrings[stringKey]) {
+                        warnings.push(`Component '${component.id}' missing key '${stringKey}' for language '${language}'`);
+                    }
+                }
+            }
+        }
+        return { isValid, errors, warnings };
+    }
+}
+exports.PluginI18nEngine = PluginI18nEngine;
+/**
+ * Static instances for semi-singleton pattern
+ */
+PluginI18nEngine._instances = new Map();
+PluginI18nEngine._defaultKey = null;
+PluginI18nEngine.DefaultInstanceKey = 'default';

package/dist/registry-config.d.ts

@@ -0,0 +1,14 @@
+import { CurrencyCode } from './currency-code';
+import { Timezone } from './timezone';
+import { ValidationConfig } from './validation-config';
+/**
+ * Registry configuration
+ */
+export interface RegistryConfig<TLanguages extends string> {
+    readonly defaultLanguage: TLanguages;
+    readonly fallbackLanguage: TLanguages;
+    readonly defaultCurrencyCode: CurrencyCode;
+    readonly timezone: Timezone;
+    readonly adminTimezone: Timezone;
+    readonly validation: ValidationConfig;
+}

package/dist/registry-config.js

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

package/dist/registry-context.d.ts

@@ -0,0 +1,12 @@
+import { CurrencyCode } from './currency-code';
+import { Timezone } from './timezone';
+/**
+ * Translation context similar to existing I18nContext
+ */
+export interface RegistryContext<TLanguages extends string> {
+    currentLanguage: TLanguages;
+    fallbackLanguage: TLanguages;
+    currencyCode: CurrencyCode;
+    timezone: Timezone;
+    adminTimezone: Timezone;
+}

package/dist/registry-context.js

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

package/dist/registry-error-type.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Error types for registry operations
+ */
+export declare enum RegistryErrorType {
+    ComponentNotFound = "COMPONENT_NOT_FOUND",
+    LanguageNotFound = "LANGUAGE_NOT_FOUND",
+    StringKeyNotFound = "STRING_KEY_NOT_FOUND",
+    IncompleteRegistration = "INCOMPLETE_REGISTRATION",
+    DuplicateComponent = "DUPLICATE_COMPONENT",
+    DuplicateLanguage = "DUPLICATE_LANGUAGE",
+    ValidationFailed = "VALIDATION_FAILED"
+}

package/dist/registry-error-type.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RegistryErrorType = void 0;
+/**
+ * Error types for registry operations
+ */
+var RegistryErrorType;
+(function (RegistryErrorType) {
+    RegistryErrorType["ComponentNotFound"] = "COMPONENT_NOT_FOUND";
+    RegistryErrorType["LanguageNotFound"] = "LANGUAGE_NOT_FOUND";
+    RegistryErrorType["StringKeyNotFound"] = "STRING_KEY_NOT_FOUND";
+    RegistryErrorType["IncompleteRegistration"] = "INCOMPLETE_REGISTRATION";
+    RegistryErrorType["DuplicateComponent"] = "DUPLICATE_COMPONENT";
+    RegistryErrorType["DuplicateLanguage"] = "DUPLICATE_LANGUAGE";
+    RegistryErrorType["ValidationFailed"] = "VALIDATION_FAILED";
+})(RegistryErrorType || (exports.RegistryErrorType = RegistryErrorType = {}));

package/dist/registry-error.d.ts

@@ -0,0 +1,19 @@
+import { CoreLanguage } from './core-language';
+import { RegistryErrorType } from './registry-error-type';
+import { TranslationEngine } from './typed-error';
+/**
+ * Registry error class that can work with plugin engines
+ */
+export declare class RegistryError extends Error {
+    readonly type: RegistryErrorType;
+    readonly metadata?: Record<string, any> | undefined;
+    constructor(type: RegistryErrorType, message: string, metadata?: Record<string, any> | undefined);
+    /**
+     * Create a registry error with translation support
+     */
+    static createWithEngine(engine: TranslationEngine, type: RegistryErrorType, variables?: Record<string, string | number>, language?: CoreLanguage, metadata?: Record<string, any>): RegistryError;
+    /**
+     * Create a simple RegistryError without engine dependency
+     */
+    static createSimple(type: RegistryErrorType, message: string, metadata?: Record<string, any>): RegistryError;
+}