valtech-components 2.0.795 → 2.0.796

package/esm2022/lib/services/i18n/i18n.service.mjs

@@ -0,0 +1,217 @@
+import { Injectable, signal, computed } from '@angular/core';
+import { LANG_STORAGE_KEY, DEFAULT_I18N_CONFIG, } from './types';
+import { getTimeOfDayKey } from '../../shared/utils/datetime';
+import * as i0 from "@angular/core";
+/**
+ * Servicio de internacionalización basado en Angular Signals.
+ *
+ * Características:
+ * - Sin RxJS: usa Signals para evitar memory leaks y congelamiento
+ * - Namespace-based: organiza traducciones por contexto
+ * - Fallback multi-nivel: namespace → _global → placeholder
+ * - Interpolación: soporta {variable} en textos
+ *
+ * @example
+ * // En un componente
+ * i18n = inject(I18nService);
+ *
+ * // Obtener texto
+ * const title = this.i18n.t('title', 'Login');
+ *
+ * // Con interpolación
+ * const welcome = this.i18n.t('welcome', 'Login', { name: 'Juan' });
+ *
+ * // Cambiar idioma
+ * this.i18n.setLanguage('en');
+ */
+export class I18nService {
+    constructor() {
+        // Estado interno con Signals
+        this._lang = signal(DEFAULT_I18N_CONFIG.defaultLanguage);
+        this._content = signal({});
+        this._supportedLanguages = signal(DEFAULT_I18N_CONFIG.supportedLanguages);
+        // Públicos readonly
+        this.lang = this._lang.asReadonly();
+        this.supportedLanguages = this._supportedLanguages.asReadonly();
+        // Computed para verificaciones rápidas
+        this.isSpanish = computed(() => this._lang() === 'es');
+        this.isEnglish = computed(() => this._lang() === 'en');
+        this.loadStoredLanguage();
+    }
+    /**
+     * Obtiene texto traducido (alias corto de getText)
+     *
+     * @param key Clave del texto
+     * @param namespace Namespace (default: '_global')
+     * @param data Variables para interpolación
+     * @returns Texto traducido o placeholder [namespace.key]
+     *
+     * @example
+     * i18n.t('submit');                    // busca en _global
+     * i18n.t('title', 'Login');            // busca en Login
+     * i18n.t('welcome', 'Login', {name});  // con interpolación
+     */
+    t(key, namespace, data) {
+        return this.getText(key, namespace, data);
+    }
+    /**
+     * Returns a time-of-day greeting in the current language.
+     *
+     * Uses bundled keys `goodMorning` / `goodAfternoon` / `goodEvening` from `_global`.
+     * Reactive to `lang()` when called inside a `computed()`.
+     *
+     * @param name Optional name to append: "Buenos días, Juan"
+     * @param date Optional date to evaluate (defaults to now)
+     *
+     * @example
+     * greeting = computed(() => {
+     *   this.i18n.lang();
+     *   return this.i18n.greeting(this.auth.user()?.name);
+     * });
+     */
+    greeting(name, date = new Date()) {
+        this._lang(); // track for reactivity inside computed()
+        const text = this.t(getTimeOfDayKey(date));
+        return name ? `${text}, ${name}` : text;
+    }
+    /**
+     * Obtiene texto traducido
+     *
+     * Fallback order:
+     * 1. content[namespace][lang][key]
+     * 2. content['_global'][lang][key]
+     * 3. "[namespace.key]" (placeholder)
+     */
+    getText(key, namespace, data) {
+        const content = this._content();
+        const lang = this._lang();
+        const ns = namespace || '_global';
+        // Buscar en namespace específico
+        let text = content[ns]?.[lang]?.[key];
+        // Fallback a _global
+        if (!text && ns !== '_global') {
+            text = content['_global']?.[lang]?.[key];
+        }
+        // Fallback a placeholder
+        if (!text) {
+            console.warn(`[i18n] Missing translation: ${ns}.${key} (${lang})`);
+            return `[${ns}.${key}]`;
+        }
+        // Aplicar interpolación si hay data
+        if (data) {
+            return this.interpolate(text, data);
+        }
+        return text;
+    }
+    /**
+     * Cambia el idioma de la aplicación
+     *
+     * @param lang Nuevo idioma
+     * @param forceReload Si true, recarga la página (fallback si reactividad falla)
+     */
+    setLanguage(lang, forceReload = false) {
+        if (!this._supportedLanguages().includes(lang)) {
+            console.warn(`[i18n] Language '${lang}' not in supported languages`);
+            return;
+        }
+        if (lang === this._lang()) {
+            return;
+        }
+        // Persistir en localStorage
+        localStorage.setItem(LANG_STORAGE_KEY, lang);
+        // Actualizar signal
+        this._lang.set(lang);
+        // Fallback: recargar si se solicita
+        if (forceReload) {
+            window.location.reload();
+        }
+    }
+    /**
+     * Registra contenido de traducciones para un namespace
+     *
+     * @param namespace Nombre del namespace
+     * @param content Contenido de traducciones
+     *
+     * @example
+     * i18n.registerContent('Login', {
+     *   es: { title: 'Iniciar sesión' },
+     *   en: { title: 'Sign in' }
+     * });
+     */
+    registerContent(namespace, content) {
+        this._content.update(store => ({
+            ...store,
+            [namespace]: content,
+        }));
+    }
+    /**
+     * Registra múltiples namespaces de una vez
+     *
+     * @param contentStore Objeto con namespaces como keys
+     */
+    registerContentBulk(contentStore) {
+        this._content.update(store => ({
+            ...store,
+            ...contentStore,
+        }));
+    }
+    /**
+     * Configura los idiomas soportados
+     */
+    setI18nLanguages(languages) {
+        this._supportedLanguages.set(languages);
+    }
+    /**
+     * Obtiene todos los namespaces registrados
+     */
+    getNamespaces() {
+        return Object.keys(this._content());
+    }
+    /**
+     * Verifica si un namespace tiene traducciones
+     */
+    hasNamespace(namespace) {
+        return namespace in this._content();
+    }
+    /**
+     * Carga idioma guardado en localStorage o detecta del navegador
+     */
+    loadStoredLanguage() {
+        const stored = localStorage.getItem(LANG_STORAGE_KEY);
+        if (stored && this.isValidLanguage(stored)) {
+            this._lang.set(stored);
+            return;
+        }
+        // Detectar idioma del navegador
+        const browserLang = navigator.language.split('-')[0];
+        if (this.isValidLanguage(browserLang)) {
+            this._lang.set(browserLang);
+            localStorage.setItem(LANG_STORAGE_KEY, browserLang);
+        }
+    }
+    /**
+     * Valida si un idioma está soportado
+     */
+    isValidLanguage(lang) {
+        return this._supportedLanguages().includes(lang);
+    }
+    /**
+     * Reemplaza {variable} en texto con valores de data
+     *
+     * @example
+     * interpolate('Hola {name}', { name: 'Juan' }) // 'Hola Juan'
+     */
+    interpolate(text, data) {
+        return Object.entries(data).reduce((result, [key, value]) => {
+            const regex = new RegExp(`\\{${key}\\}`, 'g');
+            return result.replace(regex, value);
+        }, text);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: I18nService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: I18nService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: I18nService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"i18n.service.js","sourceRoot":"","sources":["../../../../../../src/lib/services/i18n/i18n.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, signal, computed } from '@angular/core';\nimport {\n  I18nLang,\n  LanguagesContent,\n  ContentStore,\n  LANG_STORAGE_KEY,\n  DEFAULT_I18N_CONFIG,\n} from './types';\nimport { getTimeOfDayKey } from '../../shared/utils/datetime';\n\n/**\n * Servicio de internacionalización basado en Angular Signals.\n *\n * Características:\n * - Sin RxJS: usa Signals para evitar memory leaks y congelamiento\n * - Namespace-based: organiza traducciones por contexto\n * - Fallback multi-nivel: namespace → _global → placeholder\n * - Interpolación: soporta {variable} en textos\n *\n * @example\n * // En un componente\n * i18n = inject(I18nService);\n *\n * // Obtener texto\n * const title = this.i18n.t('title', 'Login');\n *\n * // Con interpolación\n * const welcome = this.i18n.t('welcome', 'Login', { name: 'Juan' });\n *\n * // Cambiar idioma\n * this.i18n.setLanguage('en');\n */\n@Injectable({ providedIn: 'root' })\nexport class I18nService {\n  // Estado interno con Signals\n  private readonly _lang = signal<I18nLang>(DEFAULT_I18N_CONFIG.defaultLanguage);\n  private readonly _content = signal<ContentStore>({});\n  private readonly _supportedLanguages = signal<I18nLang[]>(DEFAULT_I18N_CONFIG.supportedLanguages);\n\n  // Públicos readonly\n  readonly lang = this._lang.asReadonly();\n  readonly supportedLanguages = this._supportedLanguages.asReadonly();\n\n  // Computed para verificaciones rápidas\n  readonly isSpanish = computed(() => this._lang() === 'es');\n  readonly isEnglish = computed(() => this._lang() === 'en');\n\n  constructor() {\n    this.loadStoredLanguage();\n  }\n\n  /**\n   * Obtiene texto traducido (alias corto de getText)\n   *\n   * @param key Clave del texto\n   * @param namespace Namespace (default: '_global')\n   * @param data Variables para interpolación\n   * @returns Texto traducido o placeholder [namespace.key]\n   *\n   * @example\n   * i18n.t('submit');                    // busca en _global\n   * i18n.t('title', 'Login');            // busca en Login\n   * i18n.t('welcome', 'Login', {name});  // con interpolación\n   */\n  t(key: string, namespace?: string, data?: Record<string, string>): string {\n    return this.getText(key, namespace, data);\n  }\n\n  /**\n   * Returns a time-of-day greeting in the current language.\n   *\n   * Uses bundled keys `goodMorning` / `goodAfternoon` / `goodEvening` from `_global`.\n   * Reactive to `lang()` when called inside a `computed()`.\n   *\n   * @param name Optional name to append: \"Buenos días, Juan\"\n   * @param date Optional date to evaluate (defaults to now)\n   *\n   * @example\n   * greeting = computed(() => {\n   *   this.i18n.lang();\n   *   return this.i18n.greeting(this.auth.user()?.name);\n   * });\n   */\n  greeting(name?: string, date: Date = new Date()): string {\n    this._lang(); // track for reactivity inside computed()\n    const text = this.t(getTimeOfDayKey(date));\n    return name ? `${text}, ${name}` : text;\n  }\n\n  /**\n   * Obtiene texto traducido\n   *\n   * Fallback order:\n   * 1. content[namespace][lang][key]\n   * 2. content['_global'][lang][key]\n   * 3. \"[namespace.key]\" (placeholder)\n   */\n  getText(key: string, namespace?: string, data?: Record<string, string>): string {\n    const content = this._content();\n    const lang = this._lang();\n    const ns = namespace || '_global';\n\n    // Buscar en namespace específico\n    let text = content[ns]?.[lang]?.[key];\n\n    // Fallback a _global\n    if (!text && ns !== '_global') {\n      text = content['_global']?.[lang]?.[key];\n    }\n\n    // Fallback a placeholder\n    if (!text) {\n      console.warn(`[i18n] Missing translation: ${ns}.${key} (${lang})`);\n      return `[${ns}.${key}]`;\n    }\n\n    // Aplicar interpolación si hay data\n    if (data) {\n      return this.interpolate(text, data);\n    }\n\n    return text;\n  }\n\n  /**\n   * Cambia el idioma de la aplicación\n   *\n   * @param lang Nuevo idioma\n   * @param forceReload Si true, recarga la página (fallback si reactividad falla)\n   */\n  setLanguage(lang: I18nLang, forceReload = false): void {\n    if (!this._supportedLanguages().includes(lang)) {\n      console.warn(`[i18n] Language '${lang}' not in supported languages`);\n      return;\n    }\n\n    if (lang === this._lang()) {\n      return;\n    }\n\n    // Persistir en localStorage\n    localStorage.setItem(LANG_STORAGE_KEY, lang);\n\n    // Actualizar signal\n    this._lang.set(lang);\n\n    // Fallback: recargar si se solicita\n    if (forceReload) {\n      window.location.reload();\n    }\n  }\n\n  /**\n   * Registra contenido de traducciones para un namespace\n   *\n   * @param namespace Nombre del namespace\n   * @param content Contenido de traducciones\n   *\n   * @example\n   * i18n.registerContent('Login', {\n   *   es: { title: 'Iniciar sesión' },\n   *   en: { title: 'Sign in' }\n   * });\n   */\n  registerContent(namespace: string, content: LanguagesContent): void {\n    this._content.update(store => ({\n      ...store,\n      [namespace]: content,\n    }));\n  }\n\n  /**\n   * Registra múltiples namespaces de una vez\n   *\n   * @param contentStore Objeto con namespaces como keys\n   */\n  registerContentBulk(contentStore: ContentStore): void {\n    this._content.update(store => ({\n      ...store,\n      ...contentStore,\n    }));\n  }\n\n  /**\n   * Configura los idiomas soportados\n   */\n  setI18nLanguages(languages: I18nLang[]): void {\n    this._supportedLanguages.set(languages);\n  }\n\n  /**\n   * Obtiene todos los namespaces registrados\n   */\n  getNamespaces(): string[] {\n    return Object.keys(this._content());\n  }\n\n  /**\n   * Verifica si un namespace tiene traducciones\n   */\n  hasNamespace(namespace: string): boolean {\n    return namespace in this._content();\n  }\n\n  /**\n   * Carga idioma guardado en localStorage o detecta del navegador\n   */\n  private loadStoredLanguage(): void {\n    const stored = localStorage.getItem(LANG_STORAGE_KEY);\n\n    if (stored && this.isValidLanguage(stored)) {\n      this._lang.set(stored as I18nLang);\n      return;\n    }\n\n    // Detectar idioma del navegador\n    const browserLang = navigator.language.split('-')[0] as I18nLang;\n    if (this.isValidLanguage(browserLang)) {\n      this._lang.set(browserLang);\n      localStorage.setItem(LANG_STORAGE_KEY, browserLang);\n    }\n  }\n\n  /**\n   * Valida si un idioma está soportado\n   */\n  private isValidLanguage(lang: string): boolean {\n    return this._supportedLanguages().includes(lang as I18nLang);\n  }\n\n  /**\n   * Reemplaza {variable} en texto con valores de data\n   *\n   * @example\n   * interpolate('Hola {name}', { name: 'Juan' }) // 'Hola Juan'\n   */\n  private interpolate(text: string, data: Record<string, string>): string {\n    return Object.entries(data).reduce((result, [key, value]) => {\n      const regex = new RegExp(`\\\\{${key}\\\\}`, 'g');\n      return result.replace(regex, value);\n    }, text);\n  }\n}\n"]}

package/esm2022/lib/services/i18n/index.mjs

@@ -0,0 +1,13 @@
+// Types
+export { LANG_STORAGE_KEY, } from './types';
+// Service
+export { I18nService } from './i18n.service';
+// Helper
+export { InputI18nHelper, } from './input-i18n.helper';
+// Pipe
+export { TranslatePipe } from './translate.pipe';
+// Config
+export { provideValtechI18n } from './config';
+// Default content
+export { VALTECH_DEFAULT_CONTENT } from './default-content';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvbGliL3NlcnZpY2VzL2kxOG4vaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsUUFBUTtBQUNSLE9BQU8sRUFLTCxnQkFBZ0IsR0FDakIsTUFBTSxTQUFTLENBQUM7QUFFakIsVUFBVTtBQUNWLE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSxnQkFBZ0IsQ0FBQztBQUU3QyxTQUFTO0FBQ1QsT0FBTyxFQUNMLGVBQWUsR0FLaEIsTUFBTSxxQkFBcUIsQ0FBQztBQUU3QixPQUFPO0FBQ1AsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBRWpELFNBQVM7QUFDVCxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSxVQUFVLENBQUM7QUFFOUMsa0JBQWtCO0FBQ2xCLE9BQU8sRUFBRSx1QkFBdUIsRUFBRSxNQUFNLG1CQUFtQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLy8gVHlwZXNcbmV4cG9ydCB7XG4gIEkxOG5MYW5nLFxuICBMYW5ndWFnZXNDb250ZW50LFxuICBDb250ZW50U3RvcmUsXG4gIEkxOG5Db25maWcsXG4gIExBTkdfU1RPUkFHRV9LRVksXG59IGZyb20gJy4vdHlwZXMnO1xuXG4vLyBTZXJ2aWNlXG5leHBvcnQgeyBJMThuU2VydmljZSB9IGZyb20gJy4vaTE4bi5zZXJ2aWNlJztcblxuLy8gSGVscGVyXG5leHBvcnQge1xuICBJbnB1dEkxOG5IZWxwZXIsXG4gIElucHV0TWV0YWRhdGFXaXRoSTE4bixcbiAgRm9ybU1ldGFkYXRhV2l0aEkxOG4sXG4gIEZvcm1TZWN0aW9uV2l0aEkxOG4sXG4gIEJ1dHRvbk1ldGFkYXRhV2l0aEkxOG4sXG59IGZyb20gJy4vaW5wdXQtaTE4bi5oZWxwZXInO1xuXG4vLyBQaXBlXG5leHBvcnQgeyBUcmFuc2xhdGVQaXBlIH0gZnJvbSAnLi90cmFuc2xhdGUucGlwZSc7XG5cbi8vIENvbmZpZ1xuZXhwb3J0IHsgcHJvdmlkZVZhbHRlY2hJMThuIH0gZnJvbSAnLi9jb25maWcnO1xuXG4vLyBEZWZhdWx0IGNvbnRlbnRcbmV4cG9ydCB7IFZBTFRFQ0hfREVGQVVMVF9DT05URU5UIH0gZnJvbSAnLi9kZWZhdWx0LWNvbnRlbnQnO1xuIl19

package/esm2022/lib/services/i18n/input-i18n.helper.mjs

@@ -0,0 +1,97 @@
+import { Injectable, inject } from '@angular/core';
+import { I18nService } from './i18n.service';
+import * as i0 from "@angular/core";
+/**
+ * Helper para resolver traducciones i18n en InputMetadata y FormMetadata.
+ *
+ * @example
+ * ```typescript
+ * helper = inject(InputI18nHelper);
+ *
+ * // Resolver un input
+ * emailInput = this.helper.resolveInput({
+ *   ...baseEmailInput,
+ *   labelKey: 'email',
+ *   placeholderKey: 'emailPlaceholder',
+ *   errorKeys: { required: 'emailRequired', email: 'emailInvalid' },
+ *   i18nNamespace: '_auth',
+ * });
+ *
+ * // Resolver un form completo
+ * loginForm = this.helper.resolveForm(loginFormConfig);
+ * ```
+ */
+export class InputI18nHelper {
+    constructor() {
+        this.i18n = inject(I18nService);
+    }
+    /**
+     * Resuelve traducciones para un InputMetadata.
+     * Si hay keys de i18n, las resuelve; sino, usa los valores directos.
+     */
+    resolveInput(input) {
+        const namespace = input.i18nNamespace || '_global';
+        return {
+            ...input,
+            label: input.labelKey
+                ? this.i18n.t(input.labelKey, namespace)
+                : input.label || '',
+            placeholder: input.placeholderKey
+                ? this.i18n.t(input.placeholderKey, namespace)
+                : input.placeholder || '',
+            hint: input.hintKey ? this.i18n.t(input.hintKey, namespace) : input.hint || '',
+            errors: input.errorKeys
+                ? this.resolveErrors(input.errorKeys, namespace)
+                : input.errors || {},
+        };
+    }
+    /**
+     * Resuelve traducciones para un FormMetadata completo.
+     * Lee i18n.lang() para crear dependencia reactiva con computed().
+     */
+    resolveForm(form) {
+        // Leer el signal del idioma para crear dependencia reactiva
+        // Esto permite que computed() detecte cambios de idioma
+        this.i18n.lang();
+        const namespace = form.i18nNamespace || '_global';
+        return {
+            ...form,
+            name: form.nameKey ? this.i18n.t(form.nameKey, namespace) : form.name || '',
+            sections: form.sections.map((section) => ({
+                ...section,
+                name: section.nameKey
+                    ? this.i18n.t(section.nameKey, namespace)
+                    : section.name || '',
+                fields: section.fields.map((field) => this.resolveInput({ ...field, i18nNamespace: namespace })),
+            })),
+            actions: this.resolveButton(form.actions, namespace),
+        };
+    }
+    /**
+     * Resuelve traducciones para un ButtonMetadata.
+     */
+    resolveButton(button, namespace) {
+        const ns = namespace || button.i18nNamespace || '_global';
+        return {
+            ...button,
+            text: button.textKey ? this.i18n.t(button.textKey, ns) : button.text,
+        };
+    }
+    /**
+     * Resuelve un mapa de error keys a mensajes traducidos.
+     */
+    resolveErrors(errorKeys, namespace) {
+        const resolved = {};
+        for (const [validatorKey, i18nKey] of Object.entries(errorKeys)) {
+            resolved[validatorKey] = this.i18n.t(i18nKey, namespace);
+        }
+        return resolved;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: InputI18nHelper, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: InputI18nHelper, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: InputI18nHelper, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"input-i18n.helper.js","sourceRoot":"","sources":["../../../../../../src/lib/services/i18n/input-i18n.helper.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, inject } from '@angular/core';\nimport { I18nService } from './i18n.service';\nimport {\n  InputMetadata,\n  FormMetadata,\n  FormSection,\n  ButtonMetadata,\n  ComponentState,\n} from '../../components/types';\n\n/**\n * Helper para resolver traducciones i18n en InputMetadata y FormMetadata.\n *\n * @example\n * ```typescript\n * helper = inject(InputI18nHelper);\n *\n * // Resolver un input\n * emailInput = this.helper.resolveInput({\n *   ...baseEmailInput,\n *   labelKey: 'email',\n *   placeholderKey: 'emailPlaceholder',\n *   errorKeys: { required: 'emailRequired', email: 'emailInvalid' },\n *   i18nNamespace: '_auth',\n * });\n *\n * // Resolver un form completo\n * loginForm = this.helper.resolveForm(loginFormConfig);\n * ```\n */\n@Injectable({ providedIn: 'root' })\nexport class InputI18nHelper {\n  private i18n = inject(I18nService);\n\n  /**\n   * Resuelve traducciones para un InputMetadata.\n   * Si hay keys de i18n, las resuelve; sino, usa los valores directos.\n   */\n  resolveInput(input: InputMetadataWithI18n): InputMetadata {\n    const namespace = input.i18nNamespace || '_global';\n\n    return {\n      ...input,\n      label: input.labelKey\n        ? this.i18n.t(input.labelKey, namespace)\n        : input.label || '',\n      placeholder: input.placeholderKey\n        ? this.i18n.t(input.placeholderKey, namespace)\n        : input.placeholder || '',\n      hint: input.hintKey ? this.i18n.t(input.hintKey, namespace) : input.hint || '',\n      errors: input.errorKeys\n        ? this.resolveErrors(input.errorKeys, namespace)\n        : input.errors || {},\n    } as InputMetadata;\n  }\n\n  /**\n   * Resuelve traducciones para un FormMetadata completo.\n   * Lee i18n.lang() para crear dependencia reactiva con computed().\n   */\n  resolveForm(form: FormMetadataWithI18n): FormMetadata {\n    // Leer el signal del idioma para crear dependencia reactiva\n    // Esto permite que computed() detecte cambios de idioma\n    this.i18n.lang();\n    const namespace = form.i18nNamespace || '_global';\n\n    return {\n      ...form,\n      name: form.nameKey ? this.i18n.t(form.nameKey, namespace) : form.name || '',\n      sections: form.sections.map((section) => ({\n        ...section,\n        name: section.nameKey\n          ? this.i18n.t(section.nameKey, namespace)\n          : section.name || '',\n        fields: section.fields.map((field) =>\n          this.resolveInput({ ...field, i18nNamespace: namespace })\n        ),\n      })) as FormSection[],\n      actions: this.resolveButton(form.actions, namespace),\n    };\n  }\n\n  /**\n   * Resuelve traducciones para un ButtonMetadata.\n   */\n  resolveButton(\n    button: ButtonMetadataWithI18n,\n    namespace?: string\n  ): ButtonMetadata {\n    const ns = namespace || button.i18nNamespace || '_global';\n\n    return {\n      ...button,\n      text: button.textKey ? this.i18n.t(button.textKey, ns) : button.text,\n    } as ButtonMetadata;\n  }\n\n  /**\n   * Resuelve un mapa de error keys a mensajes traducidos.\n   */\n  private resolveErrors(\n    errorKeys: Record<string, string>,\n    namespace: string\n  ): Record<string, string> {\n    const resolved: Record<string, string> = {};\n    for (const [validatorKey, i18nKey] of Object.entries(errorKeys)) {\n      resolved[validatorKey] = this.i18n.t(i18nKey, namespace);\n    }\n    return resolved;\n  }\n}\n\n// Tipos extendidos con soporte i18n\nexport interface InputMetadataWithI18n extends Partial<InputMetadata> {\n  i18nNamespace?: string;\n  labelKey?: string;\n  placeholderKey?: string;\n  hintKey?: string;\n  errorKeys?: Record<string, string>;\n}\n\nexport interface FormSectionWithI18n {\n  name?: string;\n  nameKey?: string;\n  order: number;\n  fields: InputMetadataWithI18n[];\n}\n\nexport interface FormMetadataWithI18n {\n  name?: string;\n  nameKey?: string;\n  i18nNamespace?: string;\n  sections: FormSectionWithI18n[];\n  actions: ButtonMetadataWithI18n;\n  state: ComponentState;\n}\n\nexport interface ButtonMetadataWithI18n extends Partial<ButtonMetadata> {\n  i18nNamespace?: string;\n  textKey?: string;\n}\n"]}

package/esm2022/lib/services/i18n/translate.pipe.mjs

@@ -0,0 +1,50 @@
+import { Pipe, inject } from '@angular/core';
+import { I18nService } from './i18n.service';
+import * as i0 from "@angular/core";
+/**
+ * Pipe de traducción para templates.
+ *
+ * NOTA: Es impure para detectar cambios de idioma.
+ * El costo es mínimo porque I18nService usa Signals internamente.
+ *
+ * @example
+ * <!-- Busca en _global -->
+ * {{ 'submit' | t }}
+ *
+ * <!-- Busca en namespace específico -->
+ * {{ 'title' | t:'Login' }}
+ *
+ * <!-- Con interpolación -->
+ * {{ 'welcome' | t:'Login':{ name: userName } }}
+ *
+ * <!-- En atributos -->
+ * <val-button [label]="'submit' | t"></val-button>
+ * <val-input [label]="'email' | t:'Login'"></val-input>
+ */
+export class TranslatePipe {
+    constructor() {
+        this.i18n = inject(I18nService);
+    }
+    /**
+     * Transforma una key de traducción a su valor
+     *
+     * @param key Clave del texto
+     * @param namespace Namespace opcional (default: '_global')
+     * @param data Variables para interpolación opcional
+     * @returns Texto traducido
+     */
+    transform(key, namespace, data) {
+        return this.i18n.t(key, namespace, data);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TranslatePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "18.2.14", ngImport: i0, type: TranslatePipe, isStandalone: true, name: "t", pure: false }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TranslatePipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 't',
+                    standalone: true,
+                    pure: false, // Impure para detectar cambios de idioma
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/i18n/types.mjs

@@ -0,0 +1,15 @@
+/**
+ * Valores por defecto de configuración
+ */
+export const DEFAULT_I18N_CONFIG = {
+    defaultLanguage: 'es',
+    supportedLanguages: ['es', 'en'],
+    detectBrowserLanguage: true,
+    content: {},
+    includeDefaultContent: true,
+};
+/**
+ * Clave para persistir idioma en localStorage
+ */
+export const LANG_STORAGE_KEY = 'app_lang';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvbGliL3NlcnZpY2VzL2kxOG4vdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBNkZBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sbUJBQW1CLEdBQXlCO0lBQ3ZELGVBQWUsRUFBRSxJQUFJO0lBQ3JCLGtCQUFrQixFQUFFLENBQUMsSUFBSSxFQUFFLElBQUksQ0FBQztJQUNoQyxxQkFBcUIsRUFBRSxJQUFJO0lBQzNCLE9BQU8sRUFBRSxFQUFFO0lBQ1gscUJBQXFCLEVBQUUsSUFBSTtDQUM1QixDQUFDO0FBRUY7O0dBRUc7QUFDSCxNQUFNLENBQUMsTUFBTSxnQkFBZ0IsR0FBRyxVQUFVLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIElkaW9tYXMgc29wb3J0YWRvcyBwb3IgZWwgc2lzdGVtYSBpMThuXG4gKi9cbmV4cG9ydCB0eXBlIEkxOG5MYW5nID0gJ2VzJyB8ICdlbicgfCAncHQnIHwgJ2ZyJyB8ICdkZSc7XG5cbi8qKlxuICogQ29udGVuaWRvIGRlIHRyYWR1Y2Npb25lcyBwYXJhIHVuIG5hbWVzcGFjZVxuICpcbiAqIEBleGFtcGxlXG4gKiBjb25zdCBsb2dpbkNvbnRlbnQ6IExhbmd1YWdlc0NvbnRlbnQgPSB7XG4gKiAgIGVzOiB7IHRpdGxlOiAnSW5pY2lhciBzZXNpw7NuJywgc3VibWl0OiAnRW50cmFyJyB9LFxuICogICBlbjogeyB0aXRsZTogJ1NpZ24gaW4nLCBzdWJtaXQ6ICdTaWduIGluJyB9XG4gKiB9O1xuICovXG5leHBvcnQgdHlwZSBMYW5ndWFnZXNDb250ZW50ID0ge1xuICBbbGFuZyBpbiBJMThuTGFuZ10/OiBSZWNvcmQ8c3RyaW5nLCBzdHJpbmc+O1xufTtcblxuLyoqXG4gKiBBbG1hY8OpbiBkZSBjb250ZW5pZG8gcG9yIG5hbWVzcGFjZVxuICpcbiAqIEBleGFtcGxlXG4gKiB7XG4gKiAgICdfZ2xvYmFsJzogeyBlczogey4uLn0sIGVuOiB7Li4ufSB9LFxuICogICAnTG9naW4nOiB7IGVzOiB7Li4ufSwgZW46IHsuLi59IH0sXG4gKiAgICdQcm9maWxlJzogeyBlczogey4uLn0sIGVuOiB7Li4ufSB9XG4gKiB9XG4gKi9cbmV4cG9ydCB0eXBlIENvbnRlbnRTdG9yZSA9IFJlY29yZDxzdHJpbmcsIExhbmd1YWdlc0NvbnRlbnQ+O1xuXG4vKipcbiAqIENvbmZpZ3VyYWNpw7NuIHBhcmEgcHJvdmlkZVZhbHRlY2hJMThuKClcbiAqL1xuZXhwb3J0IGludGVyZmFjZSBJMThuQ29uZmlnIHtcbiAgLyoqXG4gICAqIElkaW9tYSBwb3IgZGVmZWN0byBzaSBubyBoYXkgcHJlZmVyZW5jaWEgZ3VhcmRhZGFcbiAgICogQGRlZmF1bHQgJ2VzJ1xuICAgKi9cbiAgZGVmYXVsdExhbmd1YWdlPzogSTE4bkxhbmc7XG5cbiAgLyoqXG4gICAqIExpc3RhIGRlIGlkaW9tYXMgaGFiaWxpdGFkb3MgZW4gbGEgYXBwXG4gICAqIEBkZWZhdWx0IFsnZXMnLCAnZW4nXVxuICAgKi9cbiAgc3VwcG9ydGVkTGFuZ3VhZ2VzPzogSTE4bkxhbmdbXTtcblxuICAvKipcbiAgICogRGV0ZWN0YXIgaWRpb21hIGRlbCBuYXZlZ2Fkb3IgYWwgaW5pY2lhclxuICAgKiBAZGVmYXVsdCB0cnVlXG4gICAqL1xuICBkZXRlY3RCcm93c2VyTGFuZ3VhZ2U/OiBib29sZWFuO1xuXG4gIC8qKlxuICAgKiBDb250ZW5pZG8gaW5pY2lhbCBkZSB0cmFkdWNjaW9uZXMgcG9yIG5hbWVzcGFjZS5cbiAgICogU2kgaW5jbHVkZURlZmF1bHRDb250ZW50IGVzIHRydWUsIGVzdGUgY29udGVuaWRvIHNlIG1lcmdlYVxuICAgKiBjb24gVkFMVEVDSF9ERUZBVUxUX0NPTlRFTlQgKGxhcyBrZXlzIGRlbCB1c3VhcmlvIGdhbmFuKS5cbiAgICovXG4gIGNvbnRlbnQ/OiBDb250ZW50U3RvcmU7XG5cbiAgLyoqXG4gICAqIFNpIGVzIHRydWUsIGluY2x1eWUgdHJhZHVjY2lvbmVzIHBvciBkZWZlY3RvIGRlIHZhbHRlY2gtY29tcG9uZW50cy5cbiAgICogTGFzIHRyYWR1Y2Npb25lcyBkZWwgdXN1YXJpbyBzb2JyZXNjcmliZW4gbGFzIHBvciBkZWZlY3RvLlxuICAgKlxuICAgKiBAZGVmYXVsdCB0cnVlXG4gICAqXG4gICAqIEBleGFtcGxlIFVzYXIgZGVmYXVsdHMgKGNvbXBvcnRhbWllbnRvIHBvciBkZWZlY3RvKVxuICAgKiBgYGB0eXBlc2NyaXB0XG4gICAqIHByb3ZpZGVWYWx0ZWNoSTE4bigpIC8vIEZ1bmNpb25hIHNpbiBjb25maWd1cmFjacOzblxuICAgKiBgYGBcbiAgICpcbiAgICogQGV4YW1wbGUgU29icmVzY3JpYmlyIGtleXMgZXNwZWPDrWZpY2FzXG4gICAqIGBgYHR5cGVzY3JpcHRcbiAgICogcHJvdmlkZVZhbHRlY2hJMThuKHtcbiAgICogICBjb250ZW50OiB7XG4gICAqICAgICBfZ2xvYmFsOiB7XG4gICAqICAgICAgIGVzOiB7IHN1Y2Nlc3M6ICfCoUxvIGhpY2ltb3MhJyB9LFxuICAgKiAgICAgICBlbjogeyBzdWNjZXNzOiAnV2UgZGlkIGl0IScgfSxcbiAgICogICAgIH0sXG4gICAqICAgfSxcbiAgICogfSlcbiAgICogYGBgXG4gICAqXG4gICAqIEBleGFtcGxlIERlc2FjdGl2YXIgZGVmYXVsdHMgY29tcGxldGFtZW50ZVxuICAgKiBgYGB0eXBlc2NyaXB0XG4gICAqIHByb3ZpZGVWYWx0ZWNoSTE4bih7XG4gICAqICAgaW5jbHVkZURlZmF1bHRDb250ZW50OiBmYWxzZSxcbiAgICogICBjb250ZW50OiBNWV9DVVNUT01fQ09OVEVOVCxcbiAgICogfSlcbiAgICogYGBgXG4gICAqL1xuICBpbmNsdWRlRGVmYXVsdENvbnRlbnQ/OiBib29sZWFuO1xufVxuXG4vKipcbiAqIFZhbG9yZXMgcG9yIGRlZmVjdG8gZGUgY29uZmlndXJhY2nDs25cbiAqL1xuZXhwb3J0IGNvbnN0IERFRkFVTFRfSTE4Tl9DT05GSUc6IFJlcXVpcmVkPEkxOG5Db25maWc+ID0ge1xuICBkZWZhdWx0TGFuZ3VhZ2U6ICdlcycsXG4gIHN1cHBvcnRlZExhbmd1YWdlczogWydlcycsICdlbiddLFxuICBkZXRlY3RCcm93c2VyTGFuZ3VhZ2U6IHRydWUsXG4gIGNvbnRlbnQ6IHt9LFxuICBpbmNsdWRlRGVmYXVsdENvbnRlbnQ6IHRydWUsXG59O1xuXG4vKipcbiAqIENsYXZlIHBhcmEgcGVyc2lzdGlyIGlkaW9tYSBlbiBsb2NhbFN0b3JhZ2VcbiAqL1xuZXhwb3J0IGNvbnN0IExBTkdfU1RPUkFHRV9LRVkgPSAnYXBwX2xhbmcnO1xuIl19

package/esm2022/lib/services/icons.service.mjs

@@ -0,0 +1,83 @@
+/* eslint-disable no-underscore-dangle */
+/**
+ * Service for registering and managing custom Ionicons icons in the application.
+ * Automatically registers a set of commonly used icons on initialization.
+ */
+import { Injectable } from '@angular/core';
+import { addIcons } from 'ionicons';
+import { addCircleOutline, addOutline, alertCircleOutline, alertOutline, arrowBackOutline, arrowDownOutline, arrowForwardOutline, businessOutline, calendarOutline, chatbubblesOutline, checkmarkCircleOutline, checkmarkOutline, chevronDownOutline, chevronForwardOutline, clipboardOutline, closeOutline, copyOutline, createOutline, desktopOutline, documentTextOutline, ellipsisHorizontalOutline, eyeOffOutline, eyeOutline, filterOutline, heart, heartOutline, home, homeOutline, informationCircleOutline, keyOutline, locationOutline, lockClosedOutline, logOutOutline, logoFacebook, logoGoogle, logoInstagram, logoLinkedin, logoNpm, logoTiktok, logoTwitter, logoYoutube, notifications, notificationsOutline, openOutline, playOutline, personOutline, phonePortraitOutline, refreshOutline, removeOutline, scanOutline, settings, settingsOutline, shareOutline, shieldCheckmarkOutline, trashOutline, optionsOutline, } from 'ionicons/icons';
+import * as i0 from "@angular/core";
+export class IconService {
+    /**
+     * Registers a set of Ionicons icons for use throughout the app.
+     */
+    constructor() {
+        addIcons({
+            addOutline,
+            addCircleOutline,
+            alertOutline,
+            alertCircleOutline,
+            arrowBackOutline,
+            arrowForwardOutline,
+            arrowDownOutline,
+            settings,
+            settingsOutline,
+            checkmarkCircleOutline,
+            ellipsisHorizontalOutline,
+            notifications,
+            notificationsOutline,
+            openOutline,
+            closeOutline,
+            chatbubblesOutline,
+            shareOutline,
+            heart,
+            heartOutline,
+            home,
+            homeOutline,
+            eyeOffOutline,
+            eyeOutline,
+            scanOutline,
+            chevronDownOutline,
+            chevronForwardOutline,
+            checkmarkOutline,
+            clipboardOutline,
+            copyOutline,
+            filterOutline,
+            locationOutline,
+            calendarOutline,
+            businessOutline,
+            logoTwitter,
+            logoInstagram,
+            logoLinkedin,
+            logoYoutube,
+            logoTiktok,
+            logoFacebook,
+            logoGoogle,
+            createOutline,
+            trashOutline,
+            playOutline,
+            phonePortraitOutline,
+            refreshOutline,
+            documentTextOutline,
+            lockClosedOutline,
+            informationCircleOutline,
+            logoNpm,
+            removeOutline,
+            optionsOutline,
+            personOutline,
+            shieldCheckmarkOutline,
+            keyOutline,
+            desktopOutline,
+            logOutOutline,
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: IconService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: IconService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: IconService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,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