valtech-components 2.0.829 → 2.0.831

package/esm2022/lib/components/organisms/debug-console/config.mjs

@@ -0,0 +1,44 @@
+/**
+ * DebugConsole Provider
+ *
+ * Provider e injection token para el overlay de logs `val-debug-console`.
+ */
+import { InjectionToken, makeEnvironmentProviders } from '@angular/core';
+import { DEFAULT_DEBUG_CONSOLE_CONFIG } from './types';
+/**
+ * Token de inyección para la configuración de DebugConsole.
+ */
+export const VALTECH_DEBUG_CONSOLE = new InjectionToken('ValtechDebugConsole');
+/**
+ * Provee el overlay de logs `val-debug-console` a la aplicación Angular.
+ *
+ * El componente parchea `console.*` para espejar cada llamada a un panel en
+ * pantalla — útil para leer logs en un PWA iOS añadido al home screen, donde
+ * la consola del navegador no es accesible.
+ *
+ * El gate `enabled` lo decide la app (la lib no puede importar su
+ * `environment`). Sin provider, el componente queda inerte (`enabled: false`).
+ *
+ * @example
+ * ```typescript
+ * // main.ts
+ * import { provideValtechDebugConsole } from 'valtech-components';
+ * import { environment } from './environments/environment';
+ *
+ * bootstrapApplication(AppComponent, {
+ *   providers: [
+ *     provideValtechDebugConsole({ enabled: !environment.production }),
+ *   ],
+ * });
+ * ```
+ *
+ * Luego declarar `<val-debug-console />` una vez en el componente raíz.
+ */
+export function provideValtechDebugConsole(config = {}) {
+    const mergedConfig = {
+        ...DEFAULT_DEBUG_CONSOLE_CONFIG,
+        ...config,
+    };
+    return makeEnvironmentProviders([{ provide: VALTECH_DEBUG_CONSOLE, useValue: mergedConfig }]);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/components/organisms/debug-console/debug-console.component.mjs

@@ -0,0 +1,237 @@
+import { ChangeDetectionStrategy, Component, inject, signal } from '@angular/core';
+import { VALTECH_DEBUG_CONSOLE } from './config';
+import * as i0 from "@angular/core";
+/**
+ * `val-debug-console` — overlay de logs en pantalla para diagnóstico.
+ *
+ * Herramienta de desarrollo. Permite leer los `console.*` desde un PWA en iOS
+ * añadido a la pantalla de inicio, donde la consola del navegador no es
+ * accesible.
+ *
+ * Comportamiento:
+ *  - Monkey-patch de `console.log/warn/error/info`: cada llamada también empuja
+ *    una entrada al buffer (últimas ~150) además de llamar al `console` original.
+ *  - Botón flotante (esquina) que abre/cierra un panel scrollable con las
+ *    entradas más nuevas abajo, coloreadas por nivel.
+ *  - Botones "copiar" (al portapapeles) y "limpiar".
+ *
+ * Gate maestro vía `provideValtechDebugConsole({ enabled })` en `main.ts`. Sin
+ * provider — o con `enabled: false` — el componente NO parchea `console` y NO
+ * renderiza nada. La app decide el valor (normalmente `!environment.production`).
+ *
+ * i18n: NO usa i18n a propósito — es un dev-tool que ningún end-user ve;
+ * los labels van en español plano.
+ *
+ * @example
+ * ```typescript
+ * // main.ts
+ * provideValtechDebugConsole({ enabled: !environment.production }),
+ * ```
+ * ```html
+ * <!-- componente raíz, una sola vez -->
+ * <val-debug-console />
+ * ```
+ */
+/** Máximo de entradas retenidas en el buffer. */
+const MAX_ENTRIES = 150;
+export class DebugConsoleComponent {
+    constructor() {
+        /** Gate maestro: `false` (sin provider o `enabled: false`) → todo inerte. */
+        this.enabled = inject(VALTECH_DEBUG_CONSOLE, { optional: true })?.enabled ?? false;
+        this.open = signal(false);
+        this.entries = signal([]);
+        /**
+         * Buffer plano (NO signal). `console.log` puede invocarse dentro de un
+         * `effect()`/`computed()`; escribir el signal `entries` ahí mismo dispara
+         * NG0600. Acumulamos en este array y volcamos al signal en un microtask,
+         * fuera de todo contexto reactivo.
+         */
+        this.buffer = [];
+        this.flushScheduled = false;
+        /** Referencias a los métodos originales para restaurarlos en destroy. */
+        this.original = {};
+    }
+    ngOnInit() {
+        if (!this.enabled)
+            return;
+        this.patchConsole();
+    }
+    ngOnDestroy() {
+        if (!this.enabled)
+            return;
+        this.restoreConsole();
+    }
+    toggle() {
+        this.open.update(v => !v);
+    }
+    clear() {
+        this.buffer = [];
+        this.entries.set([]);
+    }
+    async copy() {
+        const text = this.entries()
+            .map(e => `${e.ts} [${e.level}] ${e.text}`)
+            .join('\n');
+        try {
+            await navigator.clipboard.writeText(text);
+        }
+        catch {
+            // Fallback para WebViews sin Clipboard API.
+            const ta = document.createElement('textarea');
+            ta.value = text;
+            ta.style.position = 'fixed';
+            ta.style.opacity = '0';
+            document.body.appendChild(ta);
+            ta.select();
+            try {
+                document.execCommand('copy');
+            }
+            catch {
+                /* sin recurso de copia disponible */
+            }
+            document.body.removeChild(ta);
+        }
+    }
+    /** Reemplaza los métodos de `console` para espejar cada llamada al buffer. */
+    patchConsole() {
+        const levels = ['log', 'warn', 'error', 'info'];
+        for (const level of levels) {
+            const orig = console[level].bind(console);
+            this.original[level] = orig;
+            console[level] = (...args) => {
+                orig(...args);
+                this.push(level, args);
+            };
+        }
+    }
+    /** Restaura los métodos originales de `console`. */
+    restoreConsole() {
+        for (const level of Object.keys(this.original)) {
+            const orig = this.original[level];
+            if (orig) {
+                console[level] = orig;
+            }
+        }
+        this.original = {};
+    }
+    /**
+     * Agrega una entrada al buffer plano y programa el volcado al signal.
+     * El volcado se difiere a un microtask: `console.log` puede llamarse desde
+     * dentro de un `effect()`, y escribir un signal ahí lanzaría NG0600.
+     */
+    push(level, args) {
+        const text = args.map(a => this.stringify(a)).join(' ');
+        const ts = new Date().toISOString().slice(11, 23);
+        this.buffer.push({ ts, level, text });
+        if (this.buffer.length > MAX_ENTRIES) {
+            this.buffer = this.buffer.slice(this.buffer.length - MAX_ENTRIES);
+        }
+        this.scheduleFlush();
+    }
+    /**
+     * Vuelca el buffer al signal `entries` en un microtask — fuera del contexto
+     * reactivo desde el que se haya llamado `console.log`. Batchea: múltiples
+     * logs del mismo tick resultan en una sola escritura del signal.
+     */
+    scheduleFlush() {
+        if (this.flushScheduled)
+            return;
+        this.flushScheduled = true;
+        queueMicrotask(() => {
+            this.flushScheduled = false;
+            this.entries.set([...this.buffer]);
+        });
+    }
+    /** Convierte cualquier argumento a una representación legible de una línea. */
+    stringify(value) {
+        if (typeof value === 'string')
+            return value;
+        if (value instanceof Error)
+            return `${value.name}: ${value.message}`;
+        try {
+            return JSON.stringify(value);
+        }
+        catch {
+            return String(value);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DebugConsoleComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.14", type: DebugConsoleComponent, isStandalone: true, selector: "val-debug-console", ngImport: i0, template: `
+    @if (enabled) {
+      <button
+        type="button"
+        class="dbg-fab"
+        (click)="toggle()"
+        [attr.aria-label]="open() ? 'Cerrar consola' : 'Abrir consola'"
+      >
+        {{ open() ? '×' : '‹/›' }}
+        @if (!open() && entries().length) {
+          <span class="dbg-fab__count">{{ entries().length }}</span>
+        }
+      </button>
+
+      @if (open()) {
+        <div class="dbg-panel" role="log">
+          <div class="dbg-panel__bar">
+            <span class="dbg-panel__title"> Debug · {{ entries().length }} </span>
+            <span class="dbg-panel__actions">
+              <button type="button" (click)="copy()">copiar</button>
+              <button type="button" (click)="clear()">limpiar</button>
+            </span>
+          </div>
+          <div class="dbg-panel__body">
+            @for (e of entries(); track $index) {
+              <div class="dbg-line" [class]="'dbg-line--' + e.level">
+                <span class="dbg-line__ts">{{ e.ts }}</span>
+                <span class="dbg-line__text">{{ e.text }}</span>
+              </div>
+            } @empty {
+              <div class="dbg-empty">Sin logs todavía.</div>
+            }
+          </div>
+        </div>
+      }
+    }
+  `, isInline: true, styles: [":host{position:fixed;z-index:2147483000;inset:auto 0 0 auto;pointer-events:none}.dbg-fab,.dbg-panel{pointer-events:auto}.dbg-fab{position:fixed;right:calc(12px + env(safe-area-inset-right,0px));bottom:calc(12px + env(safe-area-inset-bottom,0px));width:48px;height:48px;border-radius:50%;border:0;background:#1a1a1a;color:#fff;font-size:16px;font-weight:700;cursor:pointer;box-shadow:0 2px 10px #0006;display:flex;align-items:center;justify-content:center}.dbg-fab__count{position:absolute;top:-4px;right:-4px;min-width:18px;height:18px;padding:0 4px;border-radius:9px;background:#d33;color:#fff;font-size:11px;line-height:18px;text-align:center}.dbg-panel{position:fixed;right:calc(8px + env(safe-area-inset-right,0px));left:calc(8px + env(safe-area-inset-left,0px));bottom:calc(68px + env(safe-area-inset-bottom,0px));max-width:560px;margin:0 auto;max-height:55vh;display:flex;flex-direction:column;background:#101010;color:#eee;border-radius:10px;box-shadow:0 6px 24px #00000080;overflow:hidden;font-family:ui-monospace,SFMono-Regular,Menlo,monospace}.dbg-panel__bar{display:flex;align-items:center;justify-content:space-between;padding:8px 10px;background:#1c1c1c;border-bottom:1px solid #2c2c2c}.dbg-panel__title{font-size:12px;font-weight:700}.dbg-panel__actions button{margin-left:8px;background:#2c2c2c;color:#eee;border:0;border-radius:6px;padding:4px 10px;font-size:11px;cursor:pointer}.dbg-panel__body{overflow-y:auto;padding:6px 8px;-webkit-overflow-scrolling:touch}.dbg-line{display:flex;gap:6px;padding:3px 0;font-size:11px;line-height:1.4;border-bottom:1px solid rgba(255,255,255,.04);word-break:break-word}.dbg-line__ts{flex-shrink:0;color:#777}.dbg-line__text{white-space:pre-wrap}.dbg-line--log .dbg-line__text{color:#ddd}.dbg-line--info .dbg-line__text{color:#6cb6ff}.dbg-line--warn .dbg-line__text{color:#f1c40f}.dbg-line--error .dbg-line__text{color:#ff6b6b}.dbg-empty{padding:12px;font-size:11px;color:#777;text-align:center}\n"], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DebugConsoleComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'val-debug-console', standalone: true, changeDetection: ChangeDetectionStrategy.OnPush, template: `
+    @if (enabled) {
+      <button
+        type="button"
+        class="dbg-fab"
+        (click)="toggle()"
+        [attr.aria-label]="open() ? 'Cerrar consola' : 'Abrir consola'"
+      >
+        {{ open() ? '×' : '‹/›' }}
+        @if (!open() && entries().length) {
+          <span class="dbg-fab__count">{{ entries().length }}</span>
+        }
+      </button>
+
+      @if (open()) {
+        <div class="dbg-panel" role="log">
+          <div class="dbg-panel__bar">
+            <span class="dbg-panel__title"> Debug · {{ entries().length }} </span>
+            <span class="dbg-panel__actions">
+              <button type="button" (click)="copy()">copiar</button>
+              <button type="button" (click)="clear()">limpiar</button>
+            </span>
+          </div>
+          <div class="dbg-panel__body">
+            @for (e of entries(); track $index) {
+              <div class="dbg-line" [class]="'dbg-line--' + e.level">
+                <span class="dbg-line__ts">{{ e.ts }}</span>
+                <span class="dbg-line__text">{{ e.text }}</span>
+              </div>
+            } @empty {
+              <div class="dbg-empty">Sin logs todavía.</div>
+            }
+          </div>
+        </div>
+      }
+    }
+  `, styles: [":host{position:fixed;z-index:2147483000;inset:auto 0 0 auto;pointer-events:none}.dbg-fab,.dbg-panel{pointer-events:auto}.dbg-fab{position:fixed;right:calc(12px + env(safe-area-inset-right,0px));bottom:calc(12px + env(safe-area-inset-bottom,0px));width:48px;height:48px;border-radius:50%;border:0;background:#1a1a1a;color:#fff;font-size:16px;font-weight:700;cursor:pointer;box-shadow:0 2px 10px #0006;display:flex;align-items:center;justify-content:center}.dbg-fab__count{position:absolute;top:-4px;right:-4px;min-width:18px;height:18px;padding:0 4px;border-radius:9px;background:#d33;color:#fff;font-size:11px;line-height:18px;text-align:center}.dbg-panel{position:fixed;right:calc(8px + env(safe-area-inset-right,0px));left:calc(8px + env(safe-area-inset-left,0px));bottom:calc(68px + env(safe-area-inset-bottom,0px));max-width:560px;margin:0 auto;max-height:55vh;display:flex;flex-direction:column;background:#101010;color:#eee;border-radius:10px;box-shadow:0 6px 24px #00000080;overflow:hidden;font-family:ui-monospace,SFMono-Regular,Menlo,monospace}.dbg-panel__bar{display:flex;align-items:center;justify-content:space-between;padding:8px 10px;background:#1c1c1c;border-bottom:1px solid #2c2c2c}.dbg-panel__title{font-size:12px;font-weight:700}.dbg-panel__actions button{margin-left:8px;background:#2c2c2c;color:#eee;border:0;border-radius:6px;padding:4px 10px;font-size:11px;cursor:pointer}.dbg-panel__body{overflow-y:auto;padding:6px 8px;-webkit-overflow-scrolling:touch}.dbg-line{display:flex;gap:6px;padding:3px 0;font-size:11px;line-height:1.4;border-bottom:1px solid rgba(255,255,255,.04);word-break:break-word}.dbg-line__ts{flex-shrink:0;color:#777}.dbg-line__text{white-space:pre-wrap}.dbg-line--log .dbg-line__text{color:#ddd}.dbg-line--info .dbg-line__text{color:#6cb6ff}.dbg-line--warn .dbg-line__text{color:#f1c40f}.dbg-line--error .dbg-line__text{color:#ff6b6b}.dbg-empty{padding:12px;font-size:11px;color:#777;text-align:center}\n"] }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"debug-console.component.js","sourceRoot":"","sources":["../../../../../../../src/lib/components/organisms/debug-console/debug-console.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { ChangeDetectionStrategy, Component, inject, OnDestroy, OnInit, signal } from '@angular/core';\n\nimport { VALTECH_DEBUG_CONSOLE } from './config';\nimport { DebugLogEntry, DebugLogLevel } from './types';\n\n/**\n * `val-debug-console` — overlay de logs en pantalla para diagnóstico.\n *\n * Herramienta de desarrollo. Permite leer los `console.*` desde un PWA en iOS\n * añadido a la pantalla de inicio, donde la consola del navegador no es\n * accesible.\n *\n * Comportamiento:\n *  - Monkey-patch de `console.log/warn/error/info`: cada llamada también empuja\n *    una entrada al buffer (últimas ~150) además de llamar al `console` original.\n *  - Botón flotante (esquina) que abre/cierra un panel scrollable con las\n *    entradas más nuevas abajo, coloreadas por nivel.\n *  - Botones \"copiar\" (al portapapeles) y \"limpiar\".\n *\n * Gate maestro vía `provideValtechDebugConsole({ enabled })` en `main.ts`. Sin\n * provider — o con `enabled: false` — el componente NO parchea `console` y NO\n * renderiza nada. La app decide el valor (normalmente `!environment.production`).\n *\n * i18n: NO usa i18n a propósito — es un dev-tool que ningún end-user ve;\n * los labels van en español plano.\n *\n * @example\n * ```typescript\n * // main.ts\n * provideValtechDebugConsole({ enabled: !environment.production }),\n * ```\n * ```html\n * <!-- componente raíz, una sola vez -->\n * <val-debug-console />\n * ```\n */\n\n/** Máximo de entradas retenidas en el buffer. */\nconst MAX_ENTRIES = 150;\n\n@Component({\n  selector: 'val-debug-console',\n  standalone: true,\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `\n    @if (enabled) {\n      <button\n        type=\"button\"\n        class=\"dbg-fab\"\n        (click)=\"toggle()\"\n        [attr.aria-label]=\"open() ? 'Cerrar consola' : 'Abrir consola'\"\n      >\n        {{ open() ? '×' : '‹/›' }}\n        @if (!open() && entries().length) {\n          <span class=\"dbg-fab__count\">{{ entries().length }}</span>\n        }\n      </button>\n\n      @if (open()) {\n        <div class=\"dbg-panel\" role=\"log\">\n          <div class=\"dbg-panel__bar\">\n            <span class=\"dbg-panel__title\"> Debug · {{ entries().length }} </span>\n            <span class=\"dbg-panel__actions\">\n              <button type=\"button\" (click)=\"copy()\">copiar</button>\n              <button type=\"button\" (click)=\"clear()\">limpiar</button>\n            </span>\n          </div>\n          <div class=\"dbg-panel__body\">\n            @for (e of entries(); track $index) {\n              <div class=\"dbg-line\" [class]=\"'dbg-line--' + e.level\">\n                <span class=\"dbg-line__ts\">{{ e.ts }}</span>\n                <span class=\"dbg-line__text\">{{ e.text }}</span>\n              </div>\n            } @empty {\n              <div class=\"dbg-empty\">Sin logs todavía.</div>\n            }\n          </div>\n        </div>\n      }\n    }\n  `,\n  styleUrls: ['./debug-console.component.scss'],\n})\nexport class DebugConsoleComponent implements OnInit, OnDestroy {\n  /** Gate maestro: `false` (sin provider o `enabled: false`) → todo inerte. */\n  readonly enabled = inject(VALTECH_DEBUG_CONSOLE, { optional: true })?.enabled ?? false;\n\n  readonly open = signal(false);\n  readonly entries = signal<DebugLogEntry[]>([]);\n\n  /**\n   * Buffer plano (NO signal). `console.log` puede invocarse dentro de un\n   * `effect()`/`computed()`; escribir el signal `entries` ahí mismo dispara\n   * NG0600. Acumulamos en este array y volcamos al signal en un microtask,\n   * fuera de todo contexto reactivo.\n   */\n  private buffer: DebugLogEntry[] = [];\n  private flushScheduled = false;\n\n  /** Referencias a los métodos originales para restaurarlos en destroy. */\n  private original: Partial<Record<DebugLogLevel, (...args: unknown[]) => void>> = {};\n\n  ngOnInit(): void {\n    if (!this.enabled) return;\n    this.patchConsole();\n  }\n\n  ngOnDestroy(): void {\n    if (!this.enabled) return;\n    this.restoreConsole();\n  }\n\n  toggle(): void {\n    this.open.update(v => !v);\n  }\n\n  clear(): void {\n    this.buffer = [];\n    this.entries.set([]);\n  }\n\n  async copy(): Promise<void> {\n    const text = this.entries()\n      .map(e => `${e.ts} [${e.level}] ${e.text}`)\n      .join('\\n');\n    try {\n      await navigator.clipboard.writeText(text);\n    } catch {\n      // Fallback para WebViews sin Clipboard API.\n      const ta = document.createElement('textarea');\n      ta.value = text;\n      ta.style.position = 'fixed';\n      ta.style.opacity = '0';\n      document.body.appendChild(ta);\n      ta.select();\n      try {\n        document.execCommand('copy');\n      } catch {\n        /* sin recurso de copia disponible */\n      }\n      document.body.removeChild(ta);\n    }\n  }\n\n  /** Reemplaza los métodos de `console` para espejar cada llamada al buffer. */\n  private patchConsole(): void {\n    const levels: DebugLogLevel[] = ['log', 'warn', 'error', 'info'];\n    for (const level of levels) {\n      const orig = console[level].bind(console) as (...a: unknown[]) => void;\n      this.original[level] = orig;\n      console[level] = (...args: unknown[]) => {\n        orig(...args);\n        this.push(level, args);\n      };\n    }\n  }\n\n  /** Restaura los métodos originales de `console`. */\n  private restoreConsole(): void {\n    for (const level of Object.keys(this.original) as DebugLogLevel[]) {\n      const orig = this.original[level];\n      if (orig) {\n        console[level] = orig;\n      }\n    }\n    this.original = {};\n  }\n\n  /**\n   * Agrega una entrada al buffer plano y programa el volcado al signal.\n   * El volcado se difiere a un microtask: `console.log` puede llamarse desde\n   * dentro de un `effect()`, y escribir un signal ahí lanzaría NG0600.\n   */\n  private push(level: DebugLogLevel, args: unknown[]): void {\n    const text = args.map(a => this.stringify(a)).join(' ');\n    const ts = new Date().toISOString().slice(11, 23);\n    this.buffer.push({ ts, level, text });\n    if (this.buffer.length > MAX_ENTRIES) {\n      this.buffer = this.buffer.slice(this.buffer.length - MAX_ENTRIES);\n    }\n    this.scheduleFlush();\n  }\n\n  /**\n   * Vuelca el buffer al signal `entries` en un microtask — fuera del contexto\n   * reactivo desde el que se haya llamado `console.log`. Batchea: múltiples\n   * logs del mismo tick resultan en una sola escritura del signal.\n   */\n  private scheduleFlush(): void {\n    if (this.flushScheduled) return;\n    this.flushScheduled = true;\n    queueMicrotask(() => {\n      this.flushScheduled = false;\n      this.entries.set([...this.buffer]);\n    });\n  }\n\n  /** Convierte cualquier argumento a una representación legible de una línea. */\n  private stringify(value: unknown): string {\n    if (typeof value === 'string') return value;\n    if (value instanceof Error) return `${value.name}: ${value.message}`;\n    try {\n      return JSON.stringify(value);\n    } catch {\n      return String(value);\n    }\n  }\n}\n"]}

package/esm2022/lib/components/organisms/debug-console/types.mjs

@@ -0,0 +1,12 @@
+/**
+ * DebugConsole Types
+ *
+ * Tipos para el overlay de logs en pantalla (`val-debug-console`).
+ */
+/**
+ * Configuración por defecto: deshabilitado (inerte).
+ */
+export const DEFAULT_DEBUG_CONSOLE_CONFIG = {
+    enabled: false,
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9zcmMvbGliL2NvbXBvbmVudHMvb3JnYW5pc21zL2RlYnVnLWNvbnNvbGUvdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7R0FJRztBQWFIOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sNEJBQTRCLEdBQWlDO0lBQ3hFLE9BQU8sRUFBRSxLQUFLO0NBQ2YsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogRGVidWdDb25zb2xlIFR5cGVzXG4gKlxuICogVGlwb3MgcGFyYSBlbCBvdmVybGF5IGRlIGxvZ3MgZW4gcGFudGFsbGEgKGB2YWwtZGVidWctY29uc29sZWApLlxuICovXG5cbi8qKlxuICogQ29uZmlndXJhY2nDs24gZGVsIHByb3ZlZWRvciBkZSBEZWJ1Z0NvbnNvbGUuXG4gKlxuICogQHByb3BlcnR5IGVuYWJsZWQgLSBHYXRlIG1hZXN0cm8uIEN1YW5kbyBlcyBgZmFsc2VgIGVsIGNvbXBvbmVudGUgTk8gcGFyY2hlYVxuICogICBgY29uc29sZWAgeSBOTyByZW5kZXJpemEgbmFkYS4gTGEgYXBwIGRlY2lkZSBlbCB2YWxvciDigJQgbm9ybWFsbWVudGVcbiAqICAgYCFlbnZpcm9ubWVudC5wcm9kdWN0aW9uYC4gU2luIHByb3ZpZGVyLCBlbCBkZWZhdWx0IGVzIGBmYWxzZWAuXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgRGVidWdDb25zb2xlQ29uZmlnIHtcbiAgZW5hYmxlZD86IGJvb2xlYW47XG59XG5cbi8qKlxuICogQ29uZmlndXJhY2nDs24gcG9yIGRlZmVjdG86IGRlc2hhYmlsaXRhZG8gKGluZXJ0ZSkuXG4gKi9cbmV4cG9ydCBjb25zdCBERUZBVUxUX0RFQlVHX0NPTlNPTEVfQ09ORklHOiBSZXF1aXJlZDxEZWJ1Z0NvbnNvbGVDb25maWc+ID0ge1xuICBlbmFibGVkOiBmYWxzZSxcbn07XG5cbi8qKiBOaXZlbCBkZSBsb2cgY2FwdHVyYWRvLiAqL1xuZXhwb3J0IHR5cGUgRGVidWdMb2dMZXZlbCA9ICdsb2cnIHwgJ3dhcm4nIHwgJ2Vycm9yJyB8ICdpbmZvJztcblxuLyoqIEVudHJhZGEgZGVsIGJ1ZmZlciBkZSBsb2dzLiAqL1xuZXhwb3J0IGludGVyZmFjZSBEZWJ1Z0xvZ0VudHJ5IHtcbiAgdHM6IHN0cmluZztcbiAgbGV2ZWw6IERlYnVnTG9nTGV2ZWw7XG4gIHRleHQ6IHN0cmluZztcbn1cbiJdfQ==

package/esm2022/lib/services/app-version/app-version.service.mjs

@@ -159,6 +159,15 @@ export class AppVersionService {
         this.swUpdate.versionUpdates
             .pipe(filter(evt => evt.type === 'VERSION_READY'), takeUntilDestroyed(this.destroyRef))
             .subscribe(() => this.swUpdateReady.set(true));
+        // SW en estado irrecuperable — la caché del service worker se corrompió o
+        // fue parcialmente evictada (común en PWAs standalone de iOS tras deploys
+        // repetidos). La app no puede cargar sus assets → pantalla en blanco.
+        // Recuperación recomendada por Angular: recargar para traer todo fresco
+        // desde la red.
+        this.swUpdate.unrecoverable.pipe(takeUntilDestroyed(this.destroyRef)).subscribe(event => {
+            console.error('[AppVersionService] SW unrecoverable — reloading:', event.reason);
+            this.document.defaultView?.location.reload();
+        });
         // Chequeo periódico.
         const intervalMs = this.serviceConfig?.checkIntervalMs ?? DEFAULT_APP_VERSION_SERVICE_CONFIG.checkIntervalMs;
         interval(intervalMs)
@@ -184,4 +193,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImpo
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }], ctorParameters: () => [] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"app-version.service.js","sourceRoot":"","sources":["../../../../../../src/lib/services/app-version/app-version.service.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * AppVersionService\n *\n * Verificación de versión de la app para PWA / web.\n *\n * Unifica dos señales para detectar actualizaciones:\n *\n * 1. `SwUpdate` (`@angular/service-worker`) — el evento `VERSION_READY` indica\n *    que un bundle nuevo fue descargado y está listo para activarse. Solo está\n *    disponible cuando el service worker está registrado (build de producción).\n *    Además se chequea proactivamente cada `checkIntervalMs` y cada vez que la\n *    app vuelve a foreground (`visibilitychange`).\n *\n * 2. `AppConfigService` (config remoto en Firestore) — expone `version`\n *    (última versión publicada) y `minVersion` (versión mínima soportada).\n *    Se usa para la política de actualización obligatoria (hard gate).\n *\n * Ambas dependencias se inyectan como opcionales: el servicio degrada con\n * gracia si el SW no está habilitado (dev mode) o si `AppConfigService` no\n * está wireado en la app.\n */\n\nimport { DOCUMENT } from '@angular/common';\nimport { DestroyRef, Injectable, Signal, computed, inject, signal } from '@angular/core';\nimport { takeUntilDestroyed } from '@angular/core/rxjs-interop';\nimport { SwUpdate } from '@angular/service-worker';\nimport { filter, interval } from 'rxjs';\n\nimport { AppConfigService } from '../app-config/app-config.service';\nimport { VALTECH_APP_VERSION } from './config';\nimport { AppVersionStatus, DEFAULT_APP_VERSION_SERVICE_CONFIG } from './types';\n\n/**\n * Compara dos versiones semver. Retorna true si `a` es estrictamente menor\n * que `b`. Tolerante a longitudes distintas y a partes no numéricas.\n */\nfunction isVersionLower(a: string, b: string): boolean {\n  const pa = a.split('.').map(n => Number(n) || 0);\n  const pb = b.split('.').map(n => Number(n) || 0);\n  const len = Math.max(pa.length, pb.length);\n\n  for (let i = 0; i < len; i++) {\n    const x = pa[i] || 0;\n    const y = pb[i] || 0;\n    if (x < y) return true;\n    if (x > y) return false;\n  }\n\n  return false;\n}\n\n@Injectable({ providedIn: 'root' })\nexport class AppVersionService {\n  /** SwUpdate solo existe si el SW está registrado (prod build). */\n  private readonly swUpdate = inject(SwUpdate, { optional: true });\n  /** AppConfigService es opcional: la app puede no wirearlo. */\n  private readonly appConfig = inject(AppConfigService, { optional: true });\n  private readonly serviceConfig = inject(VALTECH_APP_VERSION, {\n    optional: true,\n  });\n  private readonly document = inject(DOCUMENT);\n  private readonly destroyRef = inject(DestroyRef);\n\n  /** True cuando el SW reportó un bundle nuevo listo (`VERSION_READY`). */\n  private readonly swUpdateReady = signal(false);\n\n  /**\n   * True cuando el usuario descartó el banner de actualización opcional.\n   * El banner obligatorio (`update-required`) ignora este flag.\n   */\n  private readonly _dismissed = signal(false);\n  readonly dismissed: Signal<boolean> = this._dismissed.asReadonly();\n\n  // ===========================================================================\n  // SIGNALS PÚBLICOS\n  // ===========================================================================\n\n  /**\n   * Versión local del build actual de la app.\n   * Proviene del provider `provideValtechAppVersion({ currentVersion })`.\n   */\n  readonly currentVersion: Signal<string> = computed(\n    () => this.serviceConfig?.currentVersion ?? '0.0.0'\n  );\n\n  /**\n   * Última versión publicada según el config remoto.\n   * `null` si `AppConfigService` no está disponible o aún no cargó.\n   */\n  readonly latestVersion: Signal<string | null> = computed(\n    () => this.appConfig?.remoteVersion() ?? null\n  );\n\n  /**\n   * Estado de la versión:\n   * - `update-required` — la versión local quedó por debajo de `minVersion`\n   *   del config remoto. Hard gate. Solo si `AppConfigService` tiene datos.\n   * - `update-available` — el SW descargó un bundle nuevo (`VERSION_READY`)\n   *   o `AppConfigService.hasUpdate` es true.\n   * - `up-to-date` — en cualquier otro caso.\n   */\n  readonly status: Signal<AppVersionStatus> = computed(() => {\n    // 1. Hard gate — minVersion del config remoto.\n    if (this.appConfig) {\n      const minVersion = this.appConfig.appConfig()?.minVersion;\n      if (minVersion && isVersionLower(this.currentVersion(), minVersion)) {\n        return 'update-required';\n      }\n    }\n\n    // 2. Update opcional — SW bundle listo o config remoto más nuevo.\n    if (this.swUpdateReady() || this.appConfig?.hasUpdate()) {\n      return 'update-available';\n    }\n\n    return 'up-to-date';\n  });\n\n  constructor() {\n    this.wireServiceWorker();\n  }\n\n  // ===========================================================================\n  // MÉTODOS PÚBLICOS\n  // ===========================================================================\n\n  /**\n   * Aplica la actualización pendiente.\n   *\n   * Si el SW está habilitado, activa la versión descargada y recarga; si no,\n   * solo recarga la página (la web obtiene el bundle nuevo del servidor).\n   */\n  async applyUpdate(): Promise<void> {\n    try {\n      if (this.swUpdate?.isEnabled) {\n        await this.swUpdate.activateUpdate();\n      }\n    } catch (err) {\n      console.warn('[AppVersionService] activateUpdate failed:', err);\n    } finally {\n      this.document.defaultView?.location.reload();\n    }\n  }\n\n  /**\n   * Descarta el banner de actualización opcional.\n   * No tiene efecto sobre el estado `update-required` (hard gate).\n   */\n  dismiss(): void {\n    this._dismissed.set(true);\n  }\n\n  /**\n   * Fuerza un chequeo de actualización del service worker.\n   * No-op si el SW no está habilitado.\n   */\n  async checkNow(): Promise<void> {\n    if (!this.swUpdate?.isEnabled) return;\n    try {\n      await this.swUpdate.checkForUpdate();\n    } catch (err) {\n      console.warn('[AppVersionService] checkForUpdate failed:', err);\n    }\n  }\n\n  // ===========================================================================\n  // PRIVADO\n  // ===========================================================================\n\n  /**\n   * Suscribe `versionUpdates`, programa chequeos periódicos y reacciona al\n   * volver la app a foreground. Solo actúa si el SW está habilitado.\n   */\n  private wireServiceWorker(): void {\n    if (!this.swUpdate?.isEnabled) return;\n\n    // Bundle nuevo descargado y listo.\n    this.swUpdate.versionUpdates\n      .pipe(\n        filter(evt => evt.type === 'VERSION_READY'),\n        takeUntilDestroyed(this.destroyRef)\n      )\n      .subscribe(() => this.swUpdateReady.set(true));\n\n    // Chequeo periódico.\n    const intervalMs =\n      this.serviceConfig?.checkIntervalMs ?? DEFAULT_APP_VERSION_SERVICE_CONFIG.checkIntervalMs;\n\n    interval(intervalMs)\n      .pipe(takeUntilDestroyed(this.destroyRef))\n      .subscribe(() => void this.checkNow());\n\n    // Chequeo al volver la app a foreground.\n    const onVisible = (): void => {\n      if (this.document.visibilityState === 'visible') {\n        void this.checkNow();\n      }\n    };\n    this.document.addEventListener('visibilitychange', onVisible);\n    this.destroyRef.onDestroy(() => {\n      this.document.removeEventListener('visibilitychange', onVisible);\n    });\n\n    // Chequeo inicial.\n    void this.checkNow();\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"app-version.service.js","sourceRoot":"","sources":["../../../../../../src/lib/services/app-version/app-version.service.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * AppVersionService\n *\n * Verificación de versión de la app para PWA / web.\n *\n * Unifica dos señales para detectar actualizaciones:\n *\n * 1. `SwUpdate` (`@angular/service-worker`) — el evento `VERSION_READY` indica\n *    que un bundle nuevo fue descargado y está listo para activarse. Solo está\n *    disponible cuando el service worker está registrado (build de producción).\n *    Además se chequea proactivamente cada `checkIntervalMs` y cada vez que la\n *    app vuelve a foreground (`visibilitychange`).\n *\n * 2. `AppConfigService` (config remoto en Firestore) — expone `version`\n *    (última versión publicada) y `minVersion` (versión mínima soportada).\n *    Se usa para la política de actualización obligatoria (hard gate).\n *\n * Ambas dependencias se inyectan como opcionales: el servicio degrada con\n * gracia si el SW no está habilitado (dev mode) o si `AppConfigService` no\n * está wireado en la app.\n */\n\nimport { DOCUMENT } from '@angular/common';\nimport { DestroyRef, Injectable, Signal, computed, inject, signal } from '@angular/core';\nimport { takeUntilDestroyed } from '@angular/core/rxjs-interop';\nimport { SwUpdate } from '@angular/service-worker';\nimport { filter, interval } from 'rxjs';\n\nimport { AppConfigService } from '../app-config/app-config.service';\nimport { VALTECH_APP_VERSION } from './config';\nimport { AppVersionStatus, DEFAULT_APP_VERSION_SERVICE_CONFIG } from './types';\n\n/**\n * Compara dos versiones semver. Retorna true si `a` es estrictamente menor\n * que `b`. Tolerante a longitudes distintas y a partes no numéricas.\n */\nfunction isVersionLower(a: string, b: string): boolean {\n  const pa = a.split('.').map(n => Number(n) || 0);\n  const pb = b.split('.').map(n => Number(n) || 0);\n  const len = Math.max(pa.length, pb.length);\n\n  for (let i = 0; i < len; i++) {\n    const x = pa[i] || 0;\n    const y = pb[i] || 0;\n    if (x < y) return true;\n    if (x > y) return false;\n  }\n\n  return false;\n}\n\n@Injectable({ providedIn: 'root' })\nexport class AppVersionService {\n  /** SwUpdate solo existe si el SW está registrado (prod build). */\n  private readonly swUpdate = inject(SwUpdate, { optional: true });\n  /** AppConfigService es opcional: la app puede no wirearlo. */\n  private readonly appConfig = inject(AppConfigService, { optional: true });\n  private readonly serviceConfig = inject(VALTECH_APP_VERSION, {\n    optional: true,\n  });\n  private readonly document = inject(DOCUMENT);\n  private readonly destroyRef = inject(DestroyRef);\n\n  /** True cuando el SW reportó un bundle nuevo listo (`VERSION_READY`). */\n  private readonly swUpdateReady = signal(false);\n\n  /**\n   * True cuando el usuario descartó el banner de actualización opcional.\n   * El banner obligatorio (`update-required`) ignora este flag.\n   */\n  private readonly _dismissed = signal(false);\n  readonly dismissed: Signal<boolean> = this._dismissed.asReadonly();\n\n  // ===========================================================================\n  // SIGNALS PÚBLICOS\n  // ===========================================================================\n\n  /**\n   * Versión local del build actual de la app.\n   * Proviene del provider `provideValtechAppVersion({ currentVersion })`.\n   */\n  readonly currentVersion: Signal<string> = computed(\n    () => this.serviceConfig?.currentVersion ?? '0.0.0'\n  );\n\n  /**\n   * Última versión publicada según el config remoto.\n   * `null` si `AppConfigService` no está disponible o aún no cargó.\n   */\n  readonly latestVersion: Signal<string | null> = computed(\n    () => this.appConfig?.remoteVersion() ?? null\n  );\n\n  /**\n   * Estado de la versión:\n   * - `update-required` — la versión local quedó por debajo de `minVersion`\n   *   del config remoto. Hard gate. Solo si `AppConfigService` tiene datos.\n   * - `update-available` — el SW descargó un bundle nuevo (`VERSION_READY`)\n   *   o `AppConfigService.hasUpdate` es true.\n   * - `up-to-date` — en cualquier otro caso.\n   */\n  readonly status: Signal<AppVersionStatus> = computed(() => {\n    // 1. Hard gate — minVersion del config remoto.\n    if (this.appConfig) {\n      const minVersion = this.appConfig.appConfig()?.minVersion;\n      if (minVersion && isVersionLower(this.currentVersion(), minVersion)) {\n        return 'update-required';\n      }\n    }\n\n    // 2. Update opcional — SW bundle listo o config remoto más nuevo.\n    if (this.swUpdateReady() || this.appConfig?.hasUpdate()) {\n      return 'update-available';\n    }\n\n    return 'up-to-date';\n  });\n\n  constructor() {\n    this.wireServiceWorker();\n  }\n\n  // ===========================================================================\n  // MÉTODOS PÚBLICOS\n  // ===========================================================================\n\n  /**\n   * Aplica la actualización pendiente.\n   *\n   * Si el SW está habilitado, activa la versión descargada y recarga; si no,\n   * solo recarga la página (la web obtiene el bundle nuevo del servidor).\n   */\n  async applyUpdate(): Promise<void> {\n    try {\n      if (this.swUpdate?.isEnabled) {\n        await this.swUpdate.activateUpdate();\n      }\n    } catch (err) {\n      console.warn('[AppVersionService] activateUpdate failed:', err);\n    } finally {\n      this.document.defaultView?.location.reload();\n    }\n  }\n\n  /**\n   * Descarta el banner de actualización opcional.\n   * No tiene efecto sobre el estado `update-required` (hard gate).\n   */\n  dismiss(): void {\n    this._dismissed.set(true);\n  }\n\n  /**\n   * Fuerza un chequeo de actualización del service worker.\n   * No-op si el SW no está habilitado.\n   */\n  async checkNow(): Promise<void> {\n    if (!this.swUpdate?.isEnabled) return;\n    try {\n      await this.swUpdate.checkForUpdate();\n    } catch (err) {\n      console.warn('[AppVersionService] checkForUpdate failed:', err);\n    }\n  }\n\n  // ===========================================================================\n  // PRIVADO\n  // ===========================================================================\n\n  /**\n   * Suscribe `versionUpdates`, programa chequeos periódicos y reacciona al\n   * volver la app a foreground. Solo actúa si el SW está habilitado.\n   */\n  private wireServiceWorker(): void {\n    if (!this.swUpdate?.isEnabled) return;\n\n    // Bundle nuevo descargado y listo.\n    this.swUpdate.versionUpdates\n      .pipe(\n        filter(evt => evt.type === 'VERSION_READY'),\n        takeUntilDestroyed(this.destroyRef)\n      )\n      .subscribe(() => this.swUpdateReady.set(true));\n\n    // SW en estado irrecuperable — la caché del service worker se corrompió o\n    // fue parcialmente evictada (común en PWAs standalone de iOS tras deploys\n    // repetidos). La app no puede cargar sus assets → pantalla en blanco.\n    // Recuperación recomendada por Angular: recargar para traer todo fresco\n    // desde la red.\n    this.swUpdate.unrecoverable.pipe(takeUntilDestroyed(this.destroyRef)).subscribe(event => {\n      console.error('[AppVersionService] SW unrecoverable — reloading:', event.reason);\n      this.document.defaultView?.location.reload();\n    });\n\n    // Chequeo periódico.\n    const intervalMs =\n      this.serviceConfig?.checkIntervalMs ?? DEFAULT_APP_VERSION_SERVICE_CONFIG.checkIntervalMs;\n\n    interval(intervalMs)\n      .pipe(takeUntilDestroyed(this.destroyRef))\n      .subscribe(() => void this.checkNow());\n\n    // Chequeo al volver la app a foreground.\n    const onVisible = (): void => {\n      if (this.document.visibilityState === 'visible') {\n        void this.checkNow();\n      }\n    };\n    this.document.addEventListener('visibilitychange', onVisible);\n    this.destroyRef.onDestroy(() => {\n      this.document.removeEventListener('visibilitychange', onVisible);\n    });\n\n    // Chequeo inicial.\n    void this.checkNow();\n  }\n}\n"]}