@digitaldefiance/i18n-lib 1.3.12 → 1.3.13

package/dist/plugin-i18n-engine.js

@@ -1,360 +0,0 @@
-"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 global_active_context_1 = require("./global-active-context");
-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,
-        };
-        // Register initial languages in static registry (skip if already registered)
-        for (const lang of initialLanguages) {
-            if (!language_registry_1.LanguageRegistry.hasLanguage(lang.id)) {
-                language_registry_1.LanguageRegistry.registerLanguage(lang);
-            }
-        }
-        // Initialize component registry (per-instance)
-        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));
-        // Initialize context key for this engine instance
-        this.contextKey = PluginI18nEngine.DefaultInstanceKey;
-        // Create or get the global context for this engine
-        const globalContext = global_active_context_1.GlobalActiveContext.getInstance();
-        // Always create/update the context for this engine
-        globalContext.createContext(this.config.defaultLanguage, this.config.defaultLanguage, this.contextKey);
-        globalContext.setCurrencyCode(this.config.defaultCurrencyCode, this.contextKey);
-        globalContext.setUserTimezone(this.config.timezone, this.contextKey);
-        globalContext.setAdminTimezone(this.config.adminTimezone, this.contextKey);
-        // Initialize the default template processor for component-based patterns
-        this.t = (str, language, ...otherVars) => {
-            // Step 1: Replace component-based patterns like {{componentId.stringKey}}
-            let result = str.replace(/\{\{([^}]+)\}\}/g, (match, pattern) => {
-                const parts = pattern.split('.');
-                if (parts.length === 2) {
-                    const [componentId, stringKey] = parts;
-                    // For template strings, use the first variable object if available
-                    const isTemplate = stringKey.toLowerCase().endsWith('template');
-                    const vars = isTemplate && otherVars.length > 0 ? otherVars[0] : {};
-                    return this.safeTranslate(componentId.trim(), stringKey.trim(), vars, language);
-                }
-                return match; // Return original if pattern doesn't match expected format
-            });
-            // Step 2: Replace remaining variable patterns like {varName} with merged variables
-            const allVars = otherVars.reduce((acc, vars) => ({ ...acc, ...vars }), {});
-            result = result.replace(/\{(\w+)\}/g, (match, varName) => {
-                return allVars[varName] !== undefined ? String(allVars[varName]) : match;
-            });
-            return result;
-        };
-        // Auto-register as default instance if none exists
-        if (!PluginI18nEngine._defaultKey) {
-            PluginI18nEngine._instances.set(PluginI18nEngine.DefaultInstanceKey, this);
-            PluginI18nEngine._defaultKey = PluginI18nEngine.DefaultInstanceKey;
-        }
-    }
-    /**
-     * 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);
-        instance.contextKey = key;
-        // Create context for this specific instance
-        const globalContext = global_active_context_1.GlobalActiveContext.getInstance();
-        globalContext.createContext(instance.config.defaultLanguage, instance.config.defaultLanguage, key);
-        globalContext.setCurrencyCode(instance.config.defaultCurrencyCode, key);
-        globalContext.setUserTimezone(instance.config.timezone, key);
-        globalContext.setAdminTimezone(instance.config.adminTimezone, key);
-        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 (updates static registry)
-     */
-    registerLanguage(language) {
-        language_registry_1.LanguageRegistry.registerLanguage(language);
-        // Update component registry with new language
-        const newLanguages = language_registry_1.LanguageRegistry.getLanguageIds();
-        this.componentRegistry.updateRegisteredLanguages(newLanguages);
-    }
-    /**
-     * Register multiple languages (updates static registry)
-     */
-    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.getCurrentLanguage(),
-            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.getCurrentLanguage());
-    }
-    /**
-     * Get detailed translation response
-     */
-    getTranslationDetails(componentId, stringKey, variables, language) {
-        const request = {
-            componentId,
-            stringKey,
-            language: language || this.getCurrentLanguage(),
-            variables,
-        };
-        return this.componentRegistry.getTranslation(request);
-    }
-    /**
-     * Get current context
-     */
-    getContext() {
-        const globalContext = global_active_context_1.GlobalActiveContext.getInstance();
-        return globalContext.getContext(this.contextKey);
-    }
-    /**
-     * Update context
-     */
-    updateContext(updates) {
-        const globalContext = global_active_context_1.GlobalActiveContext.getInstance();
-        if (updates.language)
-            globalContext.setUserLanguage(updates.language, this.contextKey);
-        if (updates.adminLanguage)
-            globalContext.setAdminLanguage(updates.adminLanguage, this.contextKey);
-        if (updates.currencyCode)
-            globalContext.setCurrencyCode(updates.currencyCode, this.contextKey);
-        if (updates.currentContext)
-            globalContext.setLanguageContextSpace(updates.currentContext, this.contextKey);
-        if (updates.timezone)
-            globalContext.setUserTimezone(updates.timezone, this.contextKey);
-        if (updates.adminTimezone)
-            globalContext.setAdminTimezone(updates.adminTimezone, this.contextKey);
-    }
-    /**
-     * Get current language from global context
-     * Respects language context space (admin vs user)
-     */
-    getCurrentLanguage() {
-        const globalContext = global_active_context_1.GlobalActiveContext.getInstance();
-        const context = globalContext.getContext(this.contextKey);
-        return context.currentContext === 'admin' ? context.adminLanguage : context.language;
-    }
-    /**
-     * Set current language
-     */
-    setLanguage(language) {
-        if (!language_registry_1.LanguageRegistry.hasLanguage(language)) {
-            throw registry_error_1.RegistryError.createSimple(registry_error_type_1.RegistryErrorType.LanguageNotFound, `Language '${language}' is not registered`, { language });
-        }
-        const globalContext = global_active_context_1.GlobalActiveContext.getInstance();
-        globalContext.setUserLanguage(language, this.contextKey);
-    }
-    /**
-     * Get available languages from static registry
-     */
-    getLanguages() {
-        return language_registry_1.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 in static registry
-     */
-    hasLanguage(language) {
-        return language_registry_1.LanguageRegistry.hasLanguage(language);
-    }
-    /**
-     * Get language by code from static registry
-     */
-    getLanguageByCode(code) {
-        return language_registry_1.LanguageRegistry.getLanguageByCode(code);
-    }
-    /**
-     * 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 = language_registry_1.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 };
-    }
-    /**
-     * Clear all component registrations for this instance (useful for testing)
-     */
-    clearAllComponents() {
-        this.componentRegistry.clearAllComponents();
-    }
-    /**
-     * Remove a specific named instance
-     */
-    static removeInstance(key) {
-        const instanceKey = key || PluginI18nEngine.DefaultInstanceKey;
-        const removed = PluginI18nEngine._instances.delete(instanceKey);
-        // If we removed the default instance, clear the default key
-        if (removed && PluginI18nEngine._defaultKey === instanceKey) {
-            PluginI18nEngine._defaultKey = null;
-        }
-        return removed;
-    }
-    /**
-     * Check if an instance exists
-     */
-    static hasInstance(key) {
-        const instanceKey = key || PluginI18nEngine.DefaultInstanceKey;
-        return PluginI18nEngine._instances.has(instanceKey);
-    }
-    /**
-     * Reset all plugin engines and clear component registrations
-     * Useful for test cleanup
-     */
-    static resetAll() {
-        // Clear component registrations for each engine BEFORE clearing instances
-        for (const engine of PluginI18nEngine._instances.values()) {
-            engine.clearAllComponents();
-        }
-        PluginI18nEngine._instances.clear();
-        PluginI18nEngine._defaultKey = null;
-        language_registry_1.LanguageRegistry.clear();
-        global_active_context_1.GlobalActiveContext.clearAll();
-    }
-}
-exports.PluginI18nEngine = PluginI18nEngine;
-/**
- * Static instances for semi-singleton pattern
- */
-PluginI18nEngine._instances = new Map();
-PluginI18nEngine._defaultKey = null;
-PluginI18nEngine.DefaultInstanceKey = 'default';

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

@@ -1,29 +0,0 @@
-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

@@ -1,66 +0,0 @@
-"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

@@ -1,28 +0,0 @@
-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

@@ -1,40 +0,0 @@
-"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

@@ -1,14 +0,0 @@
-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

@@ -1,45 +0,0 @@
-"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/registry-config.d.ts

@@ -1,14 +0,0 @@
-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

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

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

@@ -1,12 +0,0 @@
-/**
- * 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

@@ -1,16 +0,0 @@
-"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

@@ -1,18 +0,0 @@
-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?: string, metadata?: Record<string, any>): RegistryError;
-    /**
-     * Create a simple RegistryError without engine dependency
-     */
-    static createSimple(type: RegistryErrorType, message: string, metadata?: Record<string, any>): RegistryError;
-}