valtech-components 2.0.840 → 2.0.842

package/esm2022/lib/services/errors/error-logging.interceptor.mjs

@@ -0,0 +1,75 @@
+import { inject } from '@angular/core';
+import { throwError } from 'rxjs';
+import { catchError } from 'rxjs/operators';
+import { AnalyticsService } from '../firebase/analytics.service';
+import { interpretError } from './interpret-error';
+/**
+ * Interceptor HTTP de observabilidad (Capa 1 del estándar de manejo de errores).
+ *
+ * Para CADA respuesta HTTP con error:
+ * 1. Normaliza el error con `interpretError`.
+ * 2. Loguea un evento estructurado a consola con el prefijo `[HTTP]`.
+ * 3. Reporta el error a Firebase Analytics (`source: 'http'`), si hay analytics.
+ *
+ * **NO traga el error** — lo re-lanza tal cual. Las páginas y servicios siguen
+ * recibiendo el error en su `catch` / `catchError` y deciden la UX (eso es
+ * Capa 3: `ValtechErrorService`).
+ *
+ * `AnalyticsService` se inyecta `@Optional()` — apps sin Firebase Analytics
+ * igual obtienen el log estructurado a consola.
+ *
+ * Decisión sobre 401: **se saltea** del tracking de Analytics. Un 401 es el
+ * disparador normal del flujo de refresh de token del `authInterceptor`; el
+ * token se renueva y la request se reintenta de forma transparente. Trackear
+ * cada 401 inundaría Analytics de ruido (cada sesión genera varios al expirar
+ * el access token). El 401 SÍ se loguea a consola (nivel `info`, no `error`)
+ * para no perder la traza en debugging local, pero no se reporta como error.
+ *
+ * Se registra vía {@link provideValtechErrorHandling}.
+ */
+export const errorLoggingInterceptor = (request, next) => {
+    // `AnalyticsService` puede no estar provisto (apps sin Firebase). El inject
+    // funcional con `optional: true` devuelve `null` en ese caso.
+    const analytics = inject(AnalyticsService, { optional: true });
+    return next(request).pipe(catchError((error) => {
+        const interpreted = interpretError(error);
+        const status = interpreted.status ?? error?.status;
+        // 401 → ruido del refresh de auth. Log informativo, sin Analytics.
+        if (status === 401) {
+            console.info(`[HTTP] 401 ${request.method} ${request.url}` +
+                (interpreted.operationId ? ` (op=${interpreted.operationId})` : ''));
+            return throwError(() => error);
+        }
+        // Log estructurado a consola — siempre, haya o no Analytics.
+        console.error('[HTTP] request failed', {
+            method: request.method,
+            url: request.url,
+            status: status ?? 'n/a',
+            code: interpreted.code,
+            operationId: interpreted.operationId ?? 'n/a',
+            isNetwork: interpreted.isNetwork,
+            message: interpreted.message,
+        });
+        // Reporte a Analytics (best-effort) — solo si hay servicio.
+        if (analytics) {
+            try {
+                analytics.logError(interpreted.message, {
+                    source: 'http',
+                    code: interpreted.code,
+                    url: request.url,
+                    method: request.method,
+                    status: String(status ?? 0),
+                    ...(interpreted.operationId ? { operationId: interpreted.operationId } : {}),
+                    ...(interpreted.isNetwork ? { error_category: 'network' } : {}),
+                });
+            }
+            catch (trackingError) {
+                // El tracking nunca debe romper el flujo HTTP.
+                console.warn('[HTTP] analytics tracking failed:', trackingError);
+            }
+        }
+        // Re-lanzar: NO tragamos el error. La Capa 3 / las páginas lo manejan.
+        return throwError(() => error);
+    }));
+};
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,9 +1,15 @@
 /**
- * Error interpretation helpers.
+ * Estándar de manejo de errores del factory Valtech.
  *
- * `interpretError` normaliza cualquier error (HttpErrorResponse crudo,
- * AuthError aplanado, Error de JS, o un valor arbitrario) a un
- * `InterpretedError` con forma estable. Función pura, sin Angular DI.
+ * - `interpretError` (Capa 0) — normaliza cualquier error a `InterpretedError`.
+ *   Función pura, sin Angular DI.
+ * - `provideValtechErrorHandling` (Capa 1) — registra el interceptor HTTP de
+ *   observabilidad: log estructurado + reporte a Analytics, re-lanza el error.
+ * - `ValtechErrorService` (Capa 3) — punto único para el `catch` de una página:
+ *   normaliza, observa, resuelve un mensaje i18n y muestra un toast.
  */
 export { interpretError } from './interpret-error';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvbGliL3NlcnZpY2VzL2Vycm9ycy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7O0dBTUc7QUFDSCxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sbUJBQW1CLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEVycm9yIGludGVycHJldGF0aW9uIGhlbHBlcnMuXG4gKlxuICogYGludGVycHJldEVycm9yYCBub3JtYWxpemEgY3VhbHF1aWVyIGVycm9yIChIdHRwRXJyb3JSZXNwb25zZSBjcnVkbyxcbiAqIEF1dGhFcnJvciBhcGxhbmFkbywgRXJyb3IgZGUgSlMsIG8gdW4gdmFsb3IgYXJiaXRyYXJpbykgYSB1blxuICogYEludGVycHJldGVkRXJyb3JgIGNvbiBmb3JtYSBlc3RhYmxlLiBGdW5jacOzbiBwdXJhLCBzaW4gQW5ndWxhciBESS5cbiAqL1xuZXhwb3J0IHsgaW50ZXJwcmV0RXJyb3IgfSBmcm9tICcuL2ludGVycHJldC1lcnJvcic7XG5leHBvcnQgdHlwZSB7IEludGVycHJldGVkRXJyb3IgfSBmcm9tICcuL2ludGVycHJldC1lcnJvcic7XG4iXX0=
+export { errorLoggingInterceptor } from './error-logging.interceptor';
+export { provideValtechErrorHandling } from './provide-error-handling';
+export { ValtechErrorService, VALTECH_NETWORK_ERROR_KEY } from './valtech-error.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvbGliL3NlcnZpY2VzL2Vycm9ycy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7Ozs7O0dBU0c7QUFDSCxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFHbkQsT0FBTyxFQUFFLHVCQUF1QixFQUFFLE1BQU0sNkJBQTZCLENBQUM7QUFDdEUsT0FBTyxFQUFFLDJCQUEyQixFQUFFLE1BQU0sMEJBQTBCLENBQUM7QUFFdkUsT0FBTyxFQUFFLG1CQUFtQixFQUFFLHlCQUF5QixFQUFFLE1BQU0seUJBQXlCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEVzdMOhbmRhciBkZSBtYW5lam8gZGUgZXJyb3JlcyBkZWwgZmFjdG9yeSBWYWx0ZWNoLlxuICpcbiAqIC0gYGludGVycHJldEVycm9yYCAoQ2FwYSAwKSDigJQgbm9ybWFsaXphIGN1YWxxdWllciBlcnJvciBhIGBJbnRlcnByZXRlZEVycm9yYC5cbiAqICAgRnVuY2nDs24gcHVyYSwgc2luIEFuZ3VsYXIgREkuXG4gKiAtIGBwcm92aWRlVmFsdGVjaEVycm9ySGFuZGxpbmdgIChDYXBhIDEpIOKAlCByZWdpc3RyYSBlbCBpbnRlcmNlcHRvciBIVFRQIGRlXG4gKiAgIG9ic2VydmFiaWxpZGFkOiBsb2cgZXN0cnVjdHVyYWRvICsgcmVwb3J0ZSBhIEFuYWx5dGljcywgcmUtbGFuemEgZWwgZXJyb3IuXG4gKiAtIGBWYWx0ZWNoRXJyb3JTZXJ2aWNlYCAoQ2FwYSAzKSDigJQgcHVudG8gw7puaWNvIHBhcmEgZWwgYGNhdGNoYCBkZSB1bmEgcMOhZ2luYTpcbiAqICAgbm9ybWFsaXphLCBvYnNlcnZhLCByZXN1ZWx2ZSB1biBtZW5zYWplIGkxOG4geSBtdWVzdHJhIHVuIHRvYXN0LlxuICovXG5leHBvcnQgeyBpbnRlcnByZXRFcnJvciB9IGZyb20gJy4vaW50ZXJwcmV0LWVycm9yJztcbmV4cG9ydCB0eXBlIHsgSW50ZXJwcmV0ZWRFcnJvciB9IGZyb20gJy4vaW50ZXJwcmV0LWVycm9yJztcblxuZXhwb3J0IHsgZXJyb3JMb2dnaW5nSW50ZXJjZXB0b3IgfSBmcm9tICcuL2Vycm9yLWxvZ2dpbmcuaW50ZXJjZXB0b3InO1xuZXhwb3J0IHsgcHJvdmlkZVZhbHRlY2hFcnJvckhhbmRsaW5nIH0gZnJvbSAnLi9wcm92aWRlLWVycm9yLWhhbmRsaW5nJztcblxuZXhwb3J0IHsgVmFsdGVjaEVycm9yU2VydmljZSwgVkFMVEVDSF9ORVRXT1JLX0VSUk9SX0tFWSB9IGZyb20gJy4vdmFsdGVjaC1lcnJvci5zZXJ2aWNlJztcbmV4cG9ydCB0eXBlIHsgVmFsdGVjaEVycm9ySGFuZGxlT3B0aW9ucyB9IGZyb20gJy4vdmFsdGVjaC1lcnJvci5zZXJ2aWNlJztcbiJdfQ==

package/esm2022/lib/services/errors/provide-error-handling.mjs

@@ -0,0 +1,39 @@
+import { makeEnvironmentProviders } from '@angular/core';
+import { provideHttpClient, withInterceptors } from '@angular/common/http';
+import { errorLoggingInterceptor } from './error-logging.interceptor';
+/**
+ * Provee el manejo de errores estándar del factory Valtech.
+ *
+ * Registra el {@link errorLoggingInterceptor} (Capa 1 — observabilidad): toda
+ * respuesta HTTP con error se normaliza, se loguea de forma estructurada a
+ * consola y se reporta a Firebase Analytics. El interceptor **re-lanza** el
+ * error, así que las páginas siguen haciendo su `catch`.
+ *
+ * Se registra vía `withInterceptors`, igual que el `authInterceptor`. Angular
+ * fusiona los interceptores de múltiples llamadas a `provideHttpClient` dentro
+ * del mismo injector, así que esto compone con `provideValtechAuth()` sin
+ * pisarlo. El orden relativo lo determina Angular por orden de provisión;
+ * para una traza limpia, declarar `provideValtechErrorHandling()` **después**
+ * de `provideValtechAuth(...)` en `main.ts`.
+ *
+ * La Capa 3 ({@link ValtechErrorService}) es `providedIn: 'root'` — no
+ * requiere registro. La Capa 2 (`AnalyticsErrorHandler`, errores no
+ * capturados) la activa `provideValtechFirebase` con `enableErrorTracking`.
+ *
+ * @example
+ * ```typescript
+ * // main.ts
+ * import { provideValtechAuth, provideValtechErrorHandling } from 'valtech-components';
+ *
+ * bootstrapApplication(AppComponent, {
+ *   providers: [
+ *     provideValtechAuth({ apiUrl: environment.apiUrl }),
+ *     provideValtechErrorHandling(),
+ *   ],
+ * });
+ * ```
+ */
+export function provideValtechErrorHandling() {
+    return makeEnvironmentProviders([provideHttpClient(withInterceptors([errorLoggingInterceptor]))]);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/errors/valtech-error.service.mjs

@@ -0,0 +1,157 @@
+import { Injectable, inject } from '@angular/core';
+import { AnalyticsService } from '../firebase/analytics.service';
+import { I18nService } from '../i18n/i18n.service';
+import { ToastService } from '../toast.service';
+import { interpretError } from './interpret-error';
+import * as i0 from "@angular/core";
+/**
+ * Key i18n fija de la librería para fallos de red. Las apps pueden definirla en
+ * su contenido i18n (namespace `_global`) para personalizar el texto; si no
+ * existe, se usa {@link NETWORK_FALLBACK_MESSAGE}.
+ */
+export const VALTECH_NETWORK_ERROR_KEY = 'valtech.error.network';
+/** Texto en español por defecto cuando {@link VALTECH_NETWORK_ERROR_KEY} no está definida. */
+const NETWORK_FALLBACK_MESSAGE = 'Sin conexión. Revisá tu internet.';
+/** Texto genérico en español cuando no hay match ni `fallbackKey`. */
+const GENERIC_FALLBACK_MESSAGE = 'Ocurrió un error. Intentá de nuevo.';
+/**
+ * Servicio de UX de errores capturados (Capa 3 del estándar de manejo de errores).
+ *
+ * Mientras la Capa 1 ({@link errorLoggingInterceptor}) observa TODAS las
+ * respuestas HTTP con error, y la Capa 2 (`AnalyticsErrorHandler`) captura los
+ * errores NO manejados, la Capa 3 es el punto único que una página usa en su
+ * `catch` para convertir un error en feedback al usuario.
+ *
+ * Responsabilidades de {@link handle}:
+ * 1. Normaliza el error (`interpretError`).
+ * 2. Loguea a consola + reporta a Analytics (`source: 'handled'`, con `context`).
+ * 3. Resuelve un mensaje localizado (ver orden de resolución en {@link handle}).
+ * 4. Muestra un toast (`color: 'dark'`, estándar Valtech) salvo `toast: false`.
+ * 5. Devuelve el {@link InterpretedError} para que la página decida lógica extra.
+ *
+ * **Nunca lanza.** `AnalyticsService` se inyecta `@Optional()`.
+ *
+ * @example
+ * ```ts
+ * private errors = inject(ValtechErrorService);
+ *
+ * async save() {
+ *   try {
+ *     await firstValueFrom(this.api.updateProfile(this.form.value));
+ *     this.toast.show({ message: 'Perfil actualizado', color: 'dark' });
+ *   } catch (err) {
+ *     this.errors.handle(err, {
+ *       context: 'profile.save',
+ *       i18nMap: { EMAIL_TAKEN: 'errors.emailTaken' },
+ *       fallbackKey: 'errors.profileSaveFailed',
+ *     });
+ *   }
+ * }
+ * ```
+ */
+export class ValtechErrorService {
+    constructor() {
+        this.i18n = inject(I18nService);
+        this.toast = inject(ToastService);
+        // Apps sin Firebase Analytics: el servicio sigue funcionando (log + toast).
+        this.analytics = inject(AnalyticsService, { optional: true });
+    }
+    /**
+     * Maneja un error capturado: normaliza, observa y produce feedback de usuario.
+     *
+     * Orden de resolución del mensaje del toast:
+     * 1. `i18nMap[code]` definido → `i18n.t(esa key)`.
+     * 2. Sin match y `isNetwork` → key de red ({@link VALTECH_NETWORK_ERROR_KEY}),
+     *    con fallback al texto español si la app no la tradujo.
+     * 3. `fallbackKey` definido → `i18n.t(fallbackKey)`.
+     * 4. Genérico en español.
+     *
+     * @param err Cualquier error capturado.
+     * @param opts Opciones de contexto, mapeo i18n y toast.
+     * @returns El {@link InterpretedError} normalizado. Nunca lanza.
+     */
+    handle(err, opts = {}) {
+        const interpreted = interpretError(err);
+        const { context, i18nMap, fallbackKey, i18nNamespace, toast } = opts;
+        // 1. Observabilidad — log estructurado a consola.
+        console.error('[ValtechError] handled', {
+            context: context ?? 'n/a',
+            code: interpreted.code,
+            status: interpreted.status ?? 'n/a',
+            operationId: interpreted.operationId ?? 'n/a',
+            isNetwork: interpreted.isNetwork,
+            message: interpreted.message,
+        });
+        // 2. Reporte a Analytics (best-effort, opcional).
+        if (this.analytics) {
+            try {
+                this.analytics.logError(interpreted.message, {
+                    source: 'handled',
+                    code: interpreted.code,
+                    ...(context ? { context } : {}),
+                    ...(interpreted.status !== undefined ? { status: String(interpreted.status) } : {}),
+                    ...(interpreted.operationId ? { operationId: interpreted.operationId } : {}),
+                    ...(interpreted.isNetwork ? { error_category: 'network' } : {}),
+                });
+            }
+            catch (trackingError) {
+                console.warn('[ValtechError] analytics tracking failed:', trackingError);
+            }
+        }
+        // 3. Resolver mensaje localizado para el usuario.
+        const message = this.resolveMessage(interpreted, {
+            i18nMap,
+            fallbackKey,
+            i18nNamespace,
+        });
+        // 4. Toast (estándar Valtech: color 'dark', position 'top').
+        if (toast !== false) {
+            this.toast.show({
+                message,
+                color: 'dark',
+                position: 'top',
+                duration: 3000,
+            });
+        }
+        // 5. Devolver el error normalizado para lógica extra del caller.
+        return interpreted;
+    }
+    /**
+     * Resuelve el mensaje a mostrar siguiendo el orden documentado en {@link handle}.
+     */
+    resolveMessage(interpreted, opts) {
+        const ns = opts.i18nNamespace;
+        // 1. Match exacto por código de backend.
+        const mappedKey = opts.i18nMap?.[interpreted.code];
+        if (mappedKey) {
+            return this.translate(mappedKey, ns) ?? interpreted.message;
+        }
+        // 2. Fallo de red → key de red de la lib, con fallback español.
+        if (interpreted.isNetwork) {
+            return this.translate(VALTECH_NETWORK_ERROR_KEY, ns) ?? NETWORK_FALLBACK_MESSAGE;
+        }
+        // 3. fallbackKey provisto por la app.
+        if (opts.fallbackKey) {
+            return this.translate(opts.fallbackKey, ns) ?? interpreted.message;
+        }
+        // 4. Genérico — preferir el mensaje del backend (ya viene en español) si lo hay.
+        return interpreted.message || GENERIC_FALLBACK_MESSAGE;
+    }
+    /**
+     * Traduce una key i18n. Devuelve `null` si la key no está definida — el
+     * `I18nService` devuelve un placeholder `[namespace.key]` para keys faltantes;
+     * lo detectamos para poder caer a un fallback en lugar de mostrar el placeholder.
+     */
+    translate(key, namespace) {
+        const text = this.i18n.t(key, namespace);
+        const ns = namespace ?? '_global';
+        return text === `[${ns}.${key}]` ? null : text;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ValtechErrorService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ValtechErrorService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ValtechErrorService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"valtech-error.service.js","sourceRoot":"","sources":["../../../../../../src/lib/services/errors/valtech-error.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, inject } from '@angular/core';\nimport { AnalyticsService } from '../firebase/analytics.service';\nimport { I18nService } from '../i18n/i18n.service';\nimport { ToastService } from '../toast.service';\nimport { InterpretedError, interpretError } from './interpret-error';\n\n/**\n * Key i18n fija de la librería para fallos de red. Las apps pueden definirla en\n * su contenido i18n (namespace `_global`) para personalizar el texto; si no\n * existe, se usa {@link NETWORK_FALLBACK_MESSAGE}.\n */\nexport const VALTECH_NETWORK_ERROR_KEY = 'valtech.error.network';\n\n/** Texto en español por defecto cuando {@link VALTECH_NETWORK_ERROR_KEY} no está definida. */\nconst NETWORK_FALLBACK_MESSAGE = 'Sin conexión. Revisá tu internet.';\n\n/** Texto genérico en español cuando no hay match ni `fallbackKey`. */\nconst GENERIC_FALLBACK_MESSAGE = 'Ocurrió un error. Intentá de nuevo.';\n\n/**\n * Opciones de {@link ValtechErrorService.handle}.\n */\nexport interface ValtechErrorHandleOptions {\n  /**\n   * Identificador del punto de fallo, ej. `'profile.save'`. Se incluye en el\n   * log de consola y en el reporte a Analytics para facilitar el tracing.\n   */\n  context?: string;\n\n  /**\n   * Mapa `código de backend → key i18n`. Lo provee la app, que conoce sus\n   * propias traducciones. Ej. `{ EMAIL_TAKEN: 'errors.emailTaken' }`.\n   */\n  i18nMap?: Record<string, string>;\n\n  /**\n   * Key i18n a usar cuando no hay match en `i18nMap` (y el error no es de red).\n   * Si se omite, se usa un mensaje genérico en español.\n   */\n  fallbackKey?: string;\n\n  /**\n   * Namespace i18n para resolver `i18nMap` / `fallbackKey` / la key de red.\n   * Default: `_global`.\n   */\n  i18nNamespace?: string;\n\n  /** Si mostrar un toast con el mensaje resuelto. Default: `true`. */\n  toast?: boolean;\n}\n\n/**\n * Servicio de UX de errores capturados (Capa 3 del estándar de manejo de errores).\n *\n * Mientras la Capa 1 ({@link errorLoggingInterceptor}) observa TODAS las\n * respuestas HTTP con error, y la Capa 2 (`AnalyticsErrorHandler`) captura los\n * errores NO manejados, la Capa 3 es el punto único que una página usa en su\n * `catch` para convertir un error en feedback al usuario.\n *\n * Responsabilidades de {@link handle}:\n * 1. Normaliza el error (`interpretError`).\n * 2. Loguea a consola + reporta a Analytics (`source: 'handled'`, con `context`).\n * 3. Resuelve un mensaje localizado (ver orden de resolución en {@link handle}).\n * 4. Muestra un toast (`color: 'dark'`, estándar Valtech) salvo `toast: false`.\n * 5. Devuelve el {@link InterpretedError} para que la página decida lógica extra.\n *\n * **Nunca lanza.** `AnalyticsService` se inyecta `@Optional()`.\n *\n * @example\n * ```ts\n * private errors = inject(ValtechErrorService);\n *\n * async save() {\n *   try {\n *     await firstValueFrom(this.api.updateProfile(this.form.value));\n *     this.toast.show({ message: 'Perfil actualizado', color: 'dark' });\n *   } catch (err) {\n *     this.errors.handle(err, {\n *       context: 'profile.save',\n *       i18nMap: { EMAIL_TAKEN: 'errors.emailTaken' },\n *       fallbackKey: 'errors.profileSaveFailed',\n *     });\n *   }\n * }\n * ```\n */\n@Injectable({ providedIn: 'root' })\nexport class ValtechErrorService {\n  private readonly i18n = inject(I18nService);\n  private readonly toast = inject(ToastService);\n  // Apps sin Firebase Analytics: el servicio sigue funcionando (log + toast).\n  private readonly analytics = inject(AnalyticsService, { optional: true });\n\n  /**\n   * Maneja un error capturado: normaliza, observa y produce feedback de usuario.\n   *\n   * Orden de resolución del mensaje del toast:\n   * 1. `i18nMap[code]` definido → `i18n.t(esa key)`.\n   * 2. Sin match y `isNetwork` → key de red ({@link VALTECH_NETWORK_ERROR_KEY}),\n   *    con fallback al texto español si la app no la tradujo.\n   * 3. `fallbackKey` definido → `i18n.t(fallbackKey)`.\n   * 4. Genérico en español.\n   *\n   * @param err Cualquier error capturado.\n   * @param opts Opciones de contexto, mapeo i18n y toast.\n   * @returns El {@link InterpretedError} normalizado. Nunca lanza.\n   */\n  handle(err: unknown, opts: ValtechErrorHandleOptions = {}): InterpretedError {\n    const interpreted = interpretError(err);\n    const { context, i18nMap, fallbackKey, i18nNamespace, toast } = opts;\n\n    // 1. Observabilidad — log estructurado a consola.\n    console.error('[ValtechError] handled', {\n      context: context ?? 'n/a',\n      code: interpreted.code,\n      status: interpreted.status ?? 'n/a',\n      operationId: interpreted.operationId ?? 'n/a',\n      isNetwork: interpreted.isNetwork,\n      message: interpreted.message,\n    });\n\n    // 2. Reporte a Analytics (best-effort, opcional).\n    if (this.analytics) {\n      try {\n        this.analytics.logError(interpreted.message, {\n          source: 'handled',\n          code: interpreted.code,\n          ...(context ? { context } : {}),\n          ...(interpreted.status !== undefined ? { status: String(interpreted.status) } : {}),\n          ...(interpreted.operationId ? { operationId: interpreted.operationId } : {}),\n          ...(interpreted.isNetwork ? { error_category: 'network' } : {}),\n        });\n      } catch (trackingError) {\n        console.warn('[ValtechError] analytics tracking failed:', trackingError);\n      }\n    }\n\n    // 3. Resolver mensaje localizado para el usuario.\n    const message = this.resolveMessage(interpreted, {\n      i18nMap,\n      fallbackKey,\n      i18nNamespace,\n    });\n\n    // 4. Toast (estándar Valtech: color 'dark', position 'top').\n    if (toast !== false) {\n      this.toast.show({\n        message,\n        color: 'dark',\n        position: 'top',\n        duration: 3000,\n      });\n    }\n\n    // 5. Devolver el error normalizado para lógica extra del caller.\n    return interpreted;\n  }\n\n  /**\n   * Resuelve el mensaje a mostrar siguiendo el orden documentado en {@link handle}.\n   */\n  private resolveMessage(\n    interpreted: InterpretedError,\n    opts: Pick<ValtechErrorHandleOptions, 'i18nMap' | 'fallbackKey' | 'i18nNamespace'>\n  ): string {\n    const ns = opts.i18nNamespace;\n\n    // 1. Match exacto por código de backend.\n    const mappedKey = opts.i18nMap?.[interpreted.code];\n    if (mappedKey) {\n      return this.translate(mappedKey, ns) ?? interpreted.message;\n    }\n\n    // 2. Fallo de red → key de red de la lib, con fallback español.\n    if (interpreted.isNetwork) {\n      return this.translate(VALTECH_NETWORK_ERROR_KEY, ns) ?? NETWORK_FALLBACK_MESSAGE;\n    }\n\n    // 3. fallbackKey provisto por la app.\n    if (opts.fallbackKey) {\n      return this.translate(opts.fallbackKey, ns) ?? interpreted.message;\n    }\n\n    // 4. Genérico — preferir el mensaje del backend (ya viene en español) si lo hay.\n    return interpreted.message || GENERIC_FALLBACK_MESSAGE;\n  }\n\n  /**\n   * Traduce una key i18n. Devuelve `null` si la key no está definida — el\n   * `I18nService` devuelve un placeholder `[namespace.key]` para keys faltantes;\n   * lo detectamos para poder caer a un fallback en lugar de mostrar el placeholder.\n   */\n  private translate(key: string, namespace?: string): string | null {\n    const text = this.i18n.t(key, namespace);\n    const ns = namespace ?? '_global';\n    return text === `[${ns}.${key}]` ? null : text;\n  }\n}\n"]}

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

@@ -5,7 +5,7 @@
  */
 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 { addCircleOutline, addOutline, alertCircleOutline, alertOutline, arrowBackOutline, arrowDownOutline, arrowForwardOutline, businessOutline, calendarOutline, chatbubblesOutline, checkmarkCircleOutline, checkmarkOutline, chevronDownOutline, chevronForwardOutline, clipboardOutline, closeOutline, cloudDownloadOutline, 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, warningOutline, } from 'ionicons/icons';
 import * as i0 from "@angular/core";
 export class IconService {
     /**
@@ -69,6 +69,8 @@ export class IconService {
             keyOutline,
             desktopOutline,
             logOutOutline,
+            cloudDownloadOutline,
+            warningOutline,
         });
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: IconService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
@@ -80,4 +82,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImpo
                     providedIn: 'root',
                 }]
         }], ctorParameters: () => [] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/version.mjs

@@ -2,5 +2,5 @@
  * Current version of valtech-components.
  * This is automatically updated during the publish process.
  */
-export const VERSION = '2.0.840';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyc2lvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9saWIvdmVyc2lvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7O0dBR0c7QUFDSCxNQUFNLENBQUMsTUFBTSxPQUFPLEdBQUcsU0FBUyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBDdXJyZW50IHZlcnNpb24gb2YgdmFsdGVjaC1jb21wb25lbnRzLlxuICogVGhpcyBpcyBhdXRvbWF0aWNhbGx5IHVwZGF0ZWQgZHVyaW5nIHRoZSBwdWJsaXNoIHByb2Nlc3MuXG4gKi9cbmV4cG9ydCBjb25zdCBWRVJTSU9OID0gJzIuMC44NDAnO1xuIl19
+export const VERSION = '2.0.842';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyc2lvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9saWIvdmVyc2lvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7O0dBR0c7QUFDSCxNQUFNLENBQUMsTUFBTSxPQUFPLEdBQUcsU0FBUyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBDdXJyZW50IHZlcnNpb24gb2YgdmFsdGVjaC1jb21wb25lbnRzLlxuICogVGhpcyBpcyBhdXRvbWF0aWNhbGx5IHVwZGF0ZWQgZHVyaW5nIHRoZSBwdWJsaXNoIHByb2Nlc3MuXG4gKi9cbmV4cG9ydCBjb25zdCBWRVJTSU9OID0gJzIuMC44NDInO1xuIl19