valtech-components 2.0.839 → 2.0.841

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

@@ -0,0 +1,15 @@
+/**
+ * Estándar de manejo de errores del factory Valtech.
+ *
+ * - `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';
+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/interpret-error.mjs

@@ -0,0 +1,130 @@
+/**
+ * Error interpretation helper for the Valtech factory.
+ *
+ * Todos los frontends del factory consumen la misma API (backend Go) y la misma
+ * librería. La lógica de interpretar errores debe vivir una sola vez, acá.
+ *
+ * El backend Go (`apperrors`) SIEMPRE devuelve errores como JSON:
+ *   { "code": string, "message": string, "operationId": string }
+ * donde `message` ya viene en español y es user-friendly.
+ *
+ * En Angular un error HTTP llega como `HttpErrorResponse` (body en `.error`).
+ * Un fallo de red es un `HttpErrorResponse` con `status === 0`.
+ *
+ * Además `AuthService.handleAuthError` aplana el `HttpErrorResponse` a un
+ * `AuthError { code, message }` (code/message al nivel superior). Por eso este
+ * helper acepta AMBAS formas — el crudo y el aplanado.
+ */
+/** Mensaje genérico para fallos de red (sin conexión / backend inalcanzable). */
+const NETWORK_MESSAGE = 'Sin conexión. Verifica tu conexión a internet e inténtalo de nuevo.';
+/** Mensaje genérico para errores no identificables. */
+const UNKNOWN_MESSAGE = 'Ocurrió un error inesperado. Inténtalo de nuevo.';
+/** Sentinel para fallos de red. */
+const NETWORK_CODE = 'NETWORK';
+/** Sentinel para errores no identificables. */
+const UNKNOWN_CODE = 'UNKNOWN';
+/** Type guard laxo: ¿el valor parece un `HttpErrorResponse`? */
+function isHttpErrorResponse(err) {
+    return (typeof err === 'object' &&
+        err !== null &&
+        // No importamos HttpErrorResponse para mantener la fn libre de Angular;
+        // detectamos por shape: tiene `status` numérico y `name` reconocible o `error`.
+        ('status' in err || err.name === 'HttpErrorResponse'));
+}
+/** Devuelve un string si el valor lo es y no está vacío; si no, `undefined`. */
+function asNonEmptyString(value) {
+    return typeof value === 'string' && value.length > 0 ? value : undefined;
+}
+/**
+ * Normaliza CUALQUIER error a un `InterpretedError`.
+ *
+ * Función pura — sin dependencias de Angular DI, testeable y usable desde
+ * cualquier lado (componentes, servicios, interceptores, scripts).
+ *
+ * Nunca lanza: siempre devuelve un `InterpretedError` válido.
+ *
+ * Casos cubiertos:
+ * - `HttpErrorResponse` con `status === 0` (o sin respuesta) → fallo de red.
+ * - `HttpErrorResponse` con body `{ code, message, operationId }` del backend.
+ * - `AuthError` aplanado `{ code, message }` (code/message top-level).
+ * - `Error` plano de JS → `code: 'UNKNOWN'`, `message: err.message`.
+ * - Cualquier otra cosa (string, null, undefined, objeto raro) → genérico.
+ *
+ * @example
+ * ```ts
+ * try {
+ *   await firstValueFrom(this.http.get(url));
+ * } catch (err) {
+ *   const e = interpretError(err);
+ *   if (e.isNetwork) {
+ *     this.toast.show({ message: e.message, color: 'dark' });
+ *   } else {
+ *     this.errorCode.set(e.code);
+ *   }
+ * }
+ * ```
+ */
+export function interpretError(err) {
+    // 1. HttpErrorResponse — el caso más común al hablar con el backend.
+    if (isHttpErrorResponse(err)) {
+        const status = typeof err.status === 'number' ? err.status : undefined;
+        // 1a. Fallo de red: status 0 o sin body de respuesta del servidor.
+        if (status === 0) {
+            return {
+                code: NETWORK_CODE,
+                message: NETWORK_MESSAGE,
+                status: 0,
+                isNetwork: true,
+            };
+        }
+        // 1b. Body del backend `{ code, message, operationId }`.
+        const body = err.error;
+        if (typeof body === 'object' && body !== null) {
+            const b = body;
+            return {
+                code: asNonEmptyString(b.code) ?? UNKNOWN_CODE,
+                message: asNonEmptyString(b.message) ?? UNKNOWN_MESSAGE,
+                operationId: asNonEmptyString(b.operationId),
+                status,
+                isNetwork: false,
+            };
+        }
+        // 1c. HttpErrorResponse sin body estructurado (ej. body string / null).
+        return {
+            code: UNKNOWN_CODE,
+            message: asNonEmptyString(err.message) ?? UNKNOWN_MESSAGE,
+            status,
+            isNetwork: false,
+        };
+    }
+    // 2. AuthError aplanado u objeto con `code`/`message` top-level.
+    if (typeof err === 'object' && err !== null) {
+        const o = err;
+        const code = asNonEmptyString(o.code);
+        const message = asNonEmptyString(o.message);
+        if (code || message) {
+            return {
+                code: code ?? UNKNOWN_CODE,
+                message: message ?? UNKNOWN_MESSAGE,
+                operationId: asNonEmptyString(o.operationId),
+                isNetwork: false,
+            };
+        }
+        // 2b. Error plano de JS (instancia de Error sin code) — `message` ya
+        //     cubierto arriba; este branch atrapa Error con message vacío.
+        if (err instanceof Error) {
+            return {
+                code: UNKNOWN_CODE,
+                message: asNonEmptyString(err.message) ?? UNKNOWN_MESSAGE,
+                isNetwork: false,
+            };
+        }
+    }
+    // 3. Cualquier otra cosa: string, null, undefined, objeto raro.
+    return {
+        code: UNKNOWN_CODE,
+        message: UNKNOWN_MESSAGE,
+        isNetwork: false,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"interpret-error.js","sourceRoot":"","sources":["../../../../../../src/lib/services/errors/interpret-error.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Error interpretation helper for the Valtech factory.\n *\n * Todos los frontends del factory consumen la misma API (backend Go) y la misma\n * librería. La lógica de interpretar errores debe vivir una sola vez, acá.\n *\n * El backend Go (`apperrors`) SIEMPRE devuelve errores como JSON:\n *   { \"code\": string, \"message\": string, \"operationId\": string }\n * donde `message` ya viene en español y es user-friendly.\n *\n * En Angular un error HTTP llega como `HttpErrorResponse` (body en `.error`).\n * Un fallo de red es un `HttpErrorResponse` con `status === 0`.\n *\n * Además `AuthService.handleAuthError` aplana el `HttpErrorResponse` a un\n * `AuthError { code, message }` (code/message al nivel superior). Por eso este\n * helper acepta AMBAS formas — el crudo y el aplanado.\n */\n\n/**\n * Resultado normalizado de cualquier error. Garantiza una forma estable y\n * predecible para que las webapps no tengan que hacer narrowing manual.\n */\nexport interface InterpretedError {\n  /** Código del backend, o el sentinel `'NETWORK'` / `'UNKNOWN'`. */\n  code: string;\n  /** Mensaje del backend (español, user-friendly) o un genérico en español. */\n  message: string;\n  /** `operationId` del backend, si vino. Útil para soporte / tracing. */\n  operationId?: string;\n  /** HTTP status, si aplica (`0` para fallos de red). */\n  status?: number;\n  /** `true` si fue un fallo de red (status 0 / sin respuesta). */\n  isNetwork: boolean;\n}\n\n/** Mensaje genérico para fallos de red (sin conexión / backend inalcanzable). */\nconst NETWORK_MESSAGE = 'Sin conexión. Verifica tu conexión a internet e inténtalo de nuevo.';\n\n/** Mensaje genérico para errores no identificables. */\nconst UNKNOWN_MESSAGE = 'Ocurrió un error inesperado. Inténtalo de nuevo.';\n\n/** Sentinel para fallos de red. */\nconst NETWORK_CODE = 'NETWORK';\n\n/** Sentinel para errores no identificables. */\nconst UNKNOWN_CODE = 'UNKNOWN';\n\n/** Type guard laxo: ¿el valor parece un `HttpErrorResponse`? */\nfunction isHttpErrorResponse(err: unknown): err is {\n  status?: number;\n  error?: unknown;\n  message?: string;\n  name?: string;\n} {\n  return (\n    typeof err === 'object' &&\n    err !== null &&\n    // No importamos HttpErrorResponse para mantener la fn libre de Angular;\n    // detectamos por shape: tiene `status` numérico y `name` reconocible o `error`.\n    ('status' in err || (err as { name?: string }).name === 'HttpErrorResponse')\n  );\n}\n\n/** Devuelve un string si el valor lo es y no está vacío; si no, `undefined`. */\nfunction asNonEmptyString(value: unknown): string | undefined {\n  return typeof value === 'string' && value.length > 0 ? value : undefined;\n}\n\n/**\n * Normaliza CUALQUIER error a un `InterpretedError`.\n *\n * Función pura — sin dependencias de Angular DI, testeable y usable desde\n * cualquier lado (componentes, servicios, interceptores, scripts).\n *\n * Nunca lanza: siempre devuelve un `InterpretedError` válido.\n *\n * Casos cubiertos:\n * - `HttpErrorResponse` con `status === 0` (o sin respuesta) → fallo de red.\n * - `HttpErrorResponse` con body `{ code, message, operationId }` del backend.\n * - `AuthError` aplanado `{ code, message }` (code/message top-level).\n * - `Error` plano de JS → `code: 'UNKNOWN'`, `message: err.message`.\n * - Cualquier otra cosa (string, null, undefined, objeto raro) → genérico.\n *\n * @example\n * ```ts\n * try {\n *   await firstValueFrom(this.http.get(url));\n * } catch (err) {\n *   const e = interpretError(err);\n *   if (e.isNetwork) {\n *     this.toast.show({ message: e.message, color: 'dark' });\n *   } else {\n *     this.errorCode.set(e.code);\n *   }\n * }\n * ```\n */\nexport function interpretError(err: unknown): InterpretedError {\n  // 1. HttpErrorResponse — el caso más común al hablar con el backend.\n  if (isHttpErrorResponse(err)) {\n    const status = typeof err.status === 'number' ? err.status : undefined;\n\n    // 1a. Fallo de red: status 0 o sin body de respuesta del servidor.\n    if (status === 0) {\n      return {\n        code: NETWORK_CODE,\n        message: NETWORK_MESSAGE,\n        status: 0,\n        isNetwork: true,\n      };\n    }\n\n    // 1b. Body del backend `{ code, message, operationId }`.\n    const body = err.error;\n    if (typeof body === 'object' && body !== null) {\n      const b = body as {\n        code?: unknown;\n        message?: unknown;\n        operationId?: unknown;\n      };\n      return {\n        code: asNonEmptyString(b.code) ?? UNKNOWN_CODE,\n        message: asNonEmptyString(b.message) ?? UNKNOWN_MESSAGE,\n        operationId: asNonEmptyString(b.operationId),\n        status,\n        isNetwork: false,\n      };\n    }\n\n    // 1c. HttpErrorResponse sin body estructurado (ej. body string / null).\n    return {\n      code: UNKNOWN_CODE,\n      message: asNonEmptyString(err.message) ?? UNKNOWN_MESSAGE,\n      status,\n      isNetwork: false,\n    };\n  }\n\n  // 2. AuthError aplanado u objeto con `code`/`message` top-level.\n  if (typeof err === 'object' && err !== null) {\n    const o = err as {\n      code?: unknown;\n      message?: unknown;\n      operationId?: unknown;\n    };\n    const code = asNonEmptyString(o.code);\n    const message = asNonEmptyString(o.message);\n\n    if (code || message) {\n      return {\n        code: code ?? UNKNOWN_CODE,\n        message: message ?? UNKNOWN_MESSAGE,\n        operationId: asNonEmptyString(o.operationId),\n        isNetwork: false,\n      };\n    }\n\n    // 2b. Error plano de JS (instancia de Error sin code) — `message` ya\n    //     cubierto arriba; este branch atrapa Error con message vacío.\n    if (err instanceof Error) {\n      return {\n        code: UNKNOWN_CODE,\n        message: asNonEmptyString(err.message) ?? UNKNOWN_MESSAGE,\n        isNetwork: false,\n      };\n    }\n  }\n\n  // 3. Cualquier otra cosa: string, null, undefined, objeto raro.\n  return {\n    code: UNKNOWN_CODE,\n    message: UNKNOWN_MESSAGE,\n    isNetwork: false,\n  };\n}\n"]}

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"]}