valtech-components 2.0.838 → 2.0.840

package/lib/components/molecules/update-banner/types.d.ts

@@ -15,7 +15,7 @@ export declare const UPDATE_BANNER_I18N_NAMESPACE = "UpdateBanner";
  */
 export declare const UPDATE_BANNER_DEFAULT_CONTENT: {
     readonly es: {
-        readonly availableTitle: "Hay una versión nueva disponible";
+        readonly availableTitle: "✨ Hay una versión nueva disponible";
         readonly availableMessage: "Actualiza para obtener las últimas mejoras.";
         readonly requiredTitle: "Debes actualizar para continuar";
         readonly requiredMessage: "Esta versión ya no es compatible. Actualiza para seguir.";
@@ -23,7 +23,7 @@ export declare const UPDATE_BANNER_DEFAULT_CONTENT: {
         readonly dismissAction: "Cerrar";
     };
     readonly en: {
-        readonly availableTitle: "A new version is available";
+        readonly availableTitle: "✨ A new version is available";
         readonly availableMessage: "Update to get the latest improvements.";
         readonly requiredTitle: "You must update to continue";
         readonly requiredMessage: "This version is no longer supported. Please update.";
@@ -31,7 +31,7 @@ export declare const UPDATE_BANNER_DEFAULT_CONTENT: {
         readonly dismissAction: "Close";
     };
     readonly pt: {
-        readonly availableTitle: "Há uma nova versão disponível";
+        readonly availableTitle: "✨ Há uma nova versão disponível";
         readonly availableMessage: "Atualize para obter as últimas melhorias.";
         readonly requiredTitle: "Você precisa atualizar para continuar";
         readonly requiredMessage: "Esta versão não é mais compatível. Atualize para seguir.";

package/lib/components/organisms/change-password-modal/change-password-modal.component.d.ts

@@ -49,7 +49,6 @@ export declare class ChangePasswordModalComponent {
     /** Modo actual — `loading` mientras se consulta `checkHasPassword()`. */
     readonly mode: import("@angular/core").Signal<PasswordModalMode>;
     private readonly _formState;
-    constructor();
     /** Traduce una clave del namespace `_auth`. */
     t(key: string): string;
     readonly formProps: import("@angular/core").Signal<FormMetadata>;

package/lib/config/company-footer.config.d.ts

@@ -64,6 +64,8 @@ export declare const VALTECH_FOOTER_I18N: {
         aboutUs: string;
         privacyPolicy: string;
         termsConditions: string;
+        cookiesPolicy: string;
+        legalNotice: string;
         contactSupport: string;
         faq: string;
         feedback: string;
@@ -75,6 +77,8 @@ export declare const VALTECH_FOOTER_I18N: {
         aboutUs: string;
         privacyPolicy: string;
         termsConditions: string;
+        cookiesPolicy: string;
+        legalNotice: string;
         contactSupport: string;
         faq: string;
         feedback: string;

package/lib/services/errors/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Error interpretation helpers.
+ *
+ * `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.
+ */
+export { interpretError } from './interpret-error';
+export type { InterpretedError } from './interpret-error';

package/lib/services/errors/interpret-error.d.ts

@@ -0,0 +1,63 @@
+/**
+ * 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.
+ */
+/**
+ * Resultado normalizado de cualquier error. Garantiza una forma estable y
+ * predecible para que las webapps no tengan que hacer narrowing manual.
+ */
+export interface InterpretedError {
+    /** Código del backend, o el sentinel `'NETWORK'` / `'UNKNOWN'`. */
+    code: string;
+    /** Mensaje del backend (español, user-friendly) o un genérico en español. */
+    message: string;
+    /** `operationId` del backend, si vino. Útil para soporte / tracing. */
+    operationId?: string;
+    /** HTTP status, si aplica (`0` para fallos de red). */
+    status?: number;
+    /** `true` si fue un fallo de red (status 0 / sin respuesta). */
+    isNetwork: boolean;
+}
+/**
+ * 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 declare function interpretError(err: unknown): InterpretedError;

package/lib/services/firebase/index.d.ts

@@ -36,7 +36,7 @@ export { CollectionOptions, FirestoreCollection, FirestoreCollectionFactory, Sub
 export { QueryBuilder, query } from './utils/query-builder';
 export { buildPath, extractPathParams, getCollectionPath, getDocumentId, isCollectionPath, isDocumentPath, isValidPath, joinPath, } from './utils/path-builder';
 export { StorageService } from './storage.service';
-export { MessagingService } from './messaging.service';
+export { MessagingService, type EnablePushOptions, type RegisterDeviceFn, } from './messaging.service';
 export { NotificationDocument, NotificationsService } from './notifications.service';
 export { AnalyticsService } from './analytics.service';
 export { AnalyticsRouterTracker } from './analytics-router-tracker';

package/lib/services/firebase/messaging.service.d.ts

@@ -7,8 +7,28 @@
  */
 import { Injector, NgZone } from '@angular/core';
 import { Observable } from 'rxjs';
-import { NotificationAction, NotificationClickEvent, NotificationPayload, NotificationPermission, ValtechFirebaseConfig } from './types';
+import { EnablePushResult, NotificationAction, NotificationClickEvent, NotificationPayload, NotificationPermission, ValtechFirebaseConfig } from './types';
 import * as i0 from "@angular/core";
+/**
+ * Callback opcional de registro de device para `MessagingService.enable()`.
+ *
+ * El registro del device vive en `AuthService` (necesita el JWT + el endpoint
+ * del backend). `MessagingService` NO puede depender de `AuthService` sin
+ * crear un ciclo (AuthService → MessagingService). Por eso el caller le pasa
+ * el paso de registro como callback. Recibe el token FCM y devuelve si el
+ * device quedó registrado.
+ */
+export type RegisterDeviceFn = (token: string) => Promise<boolean>;
+/**
+ * Opciones de `MessagingService.enable()`.
+ */
+export interface EnablePushOptions {
+    /**
+     * Paso opcional de registro de device en el backend. Si se omite, `enable()`
+     * resuelve con `status: 'enabled'` apenas obtiene el token (sin registrar).
+     */
+    registerDevice?: RegisterDeviceFn;
+}
 /**
  * Estado interno del servicio de messaging
  */
@@ -69,6 +89,31 @@ export declare class MessagingService {
      * Es un *optimistic hint* — la verdad la confirma el siguiente `getToken()`.
      */
     private readonly TOKEN_STORAGE_KEY;
+    /**
+     * Timeout (ms) para `navigator.serviceWorker.ready` dentro de `getToken()`.
+     *
+     * En un cold load el SW puede no estar activado aún y `serviceWorker.ready`
+     * no resolver nunca. Pasado este tiempo, `getToken()` rechaza limpio en lugar
+     * de colgarse indefinidamente.
+     */
+    private readonly SW_READY_TIMEOUT_MS;
+    /**
+     * Timeout (ms) del watchdog de `enable()` antes de auto-recargar la página.
+     *
+     * El flujo de activación a veces se cuelga ANTES de `getToken()` — caso
+     * típico: `Notification.requestPermission()` no muestra el popup del SO en un
+     * cold load. El timeout de `getToken()` (SW_READY_TIMEOUT_MS) no cubre eso;
+     * por eso `enable()` envuelve el flujo completo en este watchdog.
+     *
+     * Un flujo exitoso real llega a token+device en ~4s; 15s es holgado y no
+     * atrapa un éxito lento.
+     */
+    private readonly ENABLE_WATCHDOG_MS;
+    /**
+     * Key de sessionStorage — garantiza un solo auto-reload por sesión. Si el
+     * flujo se cuelga una 2ª vez tras el reload, NO se recarga de nuevo (anti-loop).
+     */
+    private readonly AUTORELOAD_FLAG;
     constructor(injector: Injector, config: ValtechFirebaseConfig, platformId: Object, ngZone: NgZone);
     /**
      * Obtiene la instancia de Messaging via Firebase SDK directo (NO AngularFire DI).
@@ -122,6 +167,56 @@ export declare class MessagingService {
      * ```
      */
     requestPermission(): Promise<string | null>;
+    /**
+     * Flujo completo de activación de push, robusto, cross-app.
+     *
+     * Orquesta: pedir permiso → SW ready → obtener token FCM → (opcional)
+     * registrar el device en backend. Es el punto de orquestación único que cada
+     * app del factory consume — la lógica de robustez vive aquí, no en cada página.
+     *
+     * **Watchdog de auto-reload.** El flujo a veces se cuelga ANTES de `getToken()`
+     * (ej. `Notification.requestPermission()` que no muestra el popup en un cold
+     * load) — el timeout interno de `getToken()` no cubre ese caso. Por eso
+     * `enable()` envuelve el flujo entero en un watchdog: si no alcanza un estado
+     * terminal en `ENABLE_WATCHDOG_MS` (15s):
+     *  - 1ª vez en la sesión → marca un flag en `sessionStorage` y hace
+     *    `window.location.reload()` (un fresh load suele tener el SW activo).
+     *    Resuelve con `{ status: 'timeout', reloaded: true }`.
+     *  - ya se auto-recargó antes → NO recarga (anti-loop): limpia el flag y
+     *    resuelve con `{ status: 'timeout', reloaded: false }` para que la app
+     *    muestre un error.
+     *
+     * NO hace throw — siempre resuelve con un `EnablePushResult` descriptivo que
+     * la página consumidora inspecciona para decidir qué toast mostrar.
+     *
+     * @param options.registerDevice Callback opcional que registra el device en
+     *   el backend (vive en `AuthService` — se pasa como callback para evitar el
+     *   ciclo de DI AuthService ↔ MessagingService).
+     *
+     * @example
+     * ```typescript
+     * const result = await messaging.enable({
+     *   registerDevice: (token) => auth.registerDevice(token).then(r => r.registered),
+     * });
+     * if (result.status === 'enabled') {
+     *   // result.token disponible — push activo
+     * } else if (result.status === 'timeout' && !result.reloaded) {
+     *   // mostrar error: el flujo se colgó y ya se consumió el auto-reload
+     * }
+     * ```
+     */
+    enable(options?: EnablePushOptions): Promise<EnablePushResult>;
+    /**
+     * Flujo real de activación, sin el watchdog (lo envuelve `enable()`).
+     * Resuelve siempre con un `EnablePushResult` — no hace throw.
+     */
+    private runEnableFlow;
+    /** True si ya se auto-recargó una vez en esta sesión. */
+    private hasAutoReloaded;
+    /** Marca que se consumió el auto-reload de esta sesión. */
+    private markAutoReloaded;
+    /** Limpia el flag anti-loop — tras un éxito o un fallo definitivo. */
+    private clearAutoReloadFlag;
     /**
      * Obtiene el token FCM actual (sin solicitar permiso).
      *
@@ -142,6 +237,20 @@ export declare class MessagingService {
      * SW en iOS PWA. Solo registramos como fallback si todavía no existe.
      */
     private resolveServiceWorkerRegistration;
+    /**
+     * Espera a que el Service Worker quede activo (`navigator.serviceWorker.ready`)
+     * pero con un timeout duro.
+     *
+     * `navigator.serviceWorker.ready` resuelve cuando hay un SW *activo*. En un
+     * cold load (primera visita, SW recién registrado, iOS PWA recién abierta) el
+     * SW puede quedar en estado `installing`/`waiting` y `ready` no resolver nunca
+     * → `getToken()` se cuelga. El `Promise.race` contra un `setTimeout` garantiza
+     * que esta espera termina: o gana `ready` (caso normal) o gana el timeout y
+     * lanzamos un error claro para que `getToken()` rechace en vez de colgarse.
+     *
+     * El timer se limpia en ambas ramas para no dejar timers colgando.
+     */
+    private waitForServiceWorkerReady;
     /**
      * Persiste el token FCM en localStorage (o lo limpia si es null/empty).
      */

package/lib/services/firebase/types.d.ts

@@ -346,6 +346,36 @@ export interface NotificationAction {
     /** Datos adicionales para la acción */
     actionData?: Record<string, unknown>;
 }
+/**
+ * Resultado de `MessagingService.enable()`.
+ *
+ * Tipo discriminado descriptivo (NO se hace throw): la página consumidora lo
+ * inspecciona para decidir qué toast/UX mostrar.
+ *
+ * `status`:
+ * - `enabled`     — permiso otorgado + token FCM obtenido (`token` presente).
+ * - `denied`      — el usuario denegó el permiso del navegador.
+ * - `unsupported` — el navegador no soporta FCM (incl. iOS sin standalone).
+ * - `error`       — el flujo falló por otra causa (ver `reason`).
+ * - `timeout`     — el flujo se colgó >15s. Si `reloaded` es true, la página
+ *                   está por recargarse (auto-reload, 1ª vez en la sesión); si
+ *                   es false, ya se consumió el auto-reload y la página debe
+ *                   mostrar un error sin recargar.
+ */
+export interface EnablePushResult {
+    /** Resultado del flujo de activación de push. */
+    status: 'enabled' | 'denied' | 'unsupported' | 'error' | 'timeout';
+    /** Token FCM — presente solo cuando `status === 'enabled'`. */
+    token?: string;
+    /** Detalle legible de la causa — presente en `error` / `timeout`. */
+    reason?: string;
+    /**
+     * Solo para `status === 'timeout'`: true si se disparó el auto-reload
+     * (la página está por recargarse). False si el auto-reload ya se consumió
+     * esta sesión y la app debe mostrar un error en lugar de recargar.
+     */
+    reloaded?: boolean;
+}
 /**
  * Evento de click en una notificación
  */

package/lib/version.d.ts

@@ -2,4 +2,4 @@
  * Current version of valtech-components.
  * This is automatically updated during the publish process.
  */
-export declare const VERSION = "2.0.838";
+export declare const VERSION = "2.0.840";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "valtech-components",
-  "version": "2.0.838",
+  "version": "2.0.840",
   "private": false,
   "bin": {
     "valtech-firebase-config": "./src/lib/services/firebase/scripts/generate-sw-config.js"

package/public-api.d.ts

@@ -255,6 +255,7 @@ export * from './lib/services/navigation';
 export * from './lib/services/theme.service';
 export * from './lib/services/toast.service';
 export * from './lib/services/types';
+export * from './lib/services/errors';
 export * from './lib/services/confirmation-dialog/confirmation-dialog.service';
 export * from './lib/services/confirmation-dialog/types';
 export * from './lib/services/qr-generator/qr-generator.service';