valtech-components 2.0.1023 → 2.0.1025

package/esm2022/lib/components/organisms/qr-scanner/qr-scanner.component.mjs

@@ -0,0 +1,310 @@
+import { Component, EventEmitter, Input, Output, ViewChild, inject, signal, } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { IonButton, IonIcon, IonSelect, IonSelectOption, IonSpinner } from '@ionic/angular/standalone';
+import { addIcons } from 'ionicons';
+import { cameraOutline, stopCircleOutline, videocamOffOutline, warningOutline } from 'ionicons/icons';
+import { BrowserMultiFormatReader } from '@zxing/browser';
+import { I18nService } from '../../../services/i18n';
+import { QR_SCANNER_I18N } from './qr-scanner.i18n';
+import * as i0 from "@angular/core";
+addIcons({
+    cameraOutline,
+    stopCircleOutline,
+    videocamOffOutline,
+    warningOutline,
+});
+/**
+ * val-qr-scanner
+ *
+ * Organism: scanner de códigos QR por cámara (`@zxing/browser` +
+ * `@zxing/library`). Emite el texto decodificado por `(scanned)`.
+ *
+ * Maneja: permiso de cámara denegado (`denied`), ausencia de cámara
+ * (`no-camera`), selector cuando hay varias cámaras, y botón start/stop. Hace
+ * cleanup del stream en `ngOnDestroy`. i18n auto-registrado (namespace
+ * `QrScanner`).
+ *
+ * Object-first (`@Input() props`) + un único `@Output() scanned`.
+ *
+ * @example
+ * ```html
+ * <val-qr-scanner [props]="{ continuous: true }" (scanned)="onScan($event)" />
+ * ```
+ */
+export class QrScannerComponent {
+    constructor() {
+        this.props = {};
+        /** Emite el texto decodificado del QR. */
+        this.scanned = new EventEmitter();
+        this.i18n = inject(I18nService);
+        this.state = signal('idle');
+        this.devices = signal([]);
+        this.activeDeviceId = signal(undefined);
+        this.reader = null;
+        this.controls = null;
+        // Anti-rebote: ignora la misma lectura repetida dentro de `dedupeMs`.
+        this.lastValue = '';
+        this.lastAt = 0;
+        this.viewReady = false;
+        if (!this.i18n.hasNamespace('QrScanner')) {
+            this.i18n.registerContent('QrScanner', QR_SCANNER_I18N);
+        }
+    }
+    ngAfterViewInit() {
+        this.viewReady = true;
+        if (this.props.autoStart) {
+            void this.start();
+        }
+    }
+    ngOnDestroy() {
+        this.teardown();
+    }
+    t(key) {
+        return this.i18n.t(key, 'QrScanner');
+    }
+    stateMessage() {
+        switch (this.state()) {
+            case 'denied':
+                return this.t('denied');
+            case 'no-camera':
+                return this.t('noCamera');
+            default:
+                return this.t('error');
+        }
+    }
+    deviceLabel(d) {
+        return d.label || `${this.t('cameraLabel')} ${this.devices().indexOf(d) + 1}`;
+    }
+    async start(deviceId) {
+        if (!this.viewReady)
+            return;
+        this.teardown();
+        this.state.set('starting');
+        try {
+            this.reader = new BrowserMultiFormatReader();
+            // Enumerar cámaras. Algunos navegadores solo dan labels tras conceder
+            // permiso, así que esto puede devolver labels vacíos la 1ª vez.
+            let cams = [];
+            try {
+                cams = await BrowserMultiFormatReader.listVideoInputDevices();
+            }
+            catch {
+                cams = [];
+            }
+            this.devices.set(cams);
+            // Preferir la trasera (environment) si el label lo sugiere.
+            const target = deviceId ||
+                this.activeDeviceId() ||
+                cams.find(c => /back|rear|environment|trasera/i.test(c.label))?.deviceId ||
+                cams[0]?.deviceId;
+            this.activeDeviceId.set(target);
+            this.controls = await this.reader.decodeFromVideoDevice(target, this.videoRef.nativeElement, result => {
+                if (result) {
+                    this.handleResult(result.getText());
+                }
+            });
+            this.state.set('scanning');
+        }
+        catch (err) {
+            this.handleStartError(err);
+        }
+    }
+    stop() {
+        this.teardown();
+        this.state.set('idle');
+    }
+    async onSelectDevice(deviceId) {
+        if (deviceId && deviceId !== this.activeDeviceId()) {
+            await this.start(deviceId);
+        }
+    }
+    handleResult(text) {
+        const now = Date.now();
+        const dedupe = this.props.dedupeMs ?? 1500;
+        if (text === this.lastValue && now - this.lastAt < dedupe) {
+            return;
+        }
+        this.lastValue = text;
+        this.lastAt = now;
+        this.scanned.emit(text);
+        // Modo no continuo: detener tras el primer match (la página reanuda si
+        // quiere). `continuous` default true → seguir escaneando.
+        if (this.props.continuous === false) {
+            this.stop();
+        }
+    }
+    handleStartError(err) {
+        const name = err?.name ?? '';
+        if (name === 'NotAllowedError' || name === 'SecurityError') {
+            this.state.set('denied');
+        }
+        else if (name === 'NotFoundError' || name === 'OverconstrainedError') {
+            this.state.set('no-camera');
+        }
+        else {
+            this.state.set('error');
+        }
+        this.teardown(false);
+    }
+    /** Detiene el decode + libera el stream de la cámara. */
+    teardown(resetState = true) {
+        try {
+            this.controls?.stop();
+        }
+        catch {
+            // ignore
+        }
+        this.controls = null;
+        const video = this.videoRef?.nativeElement;
+        const stream = video?.srcObject;
+        if (stream) {
+            stream.getTracks().forEach(track => track.stop());
+            video.srcObject = null;
+        }
+        this.reader = null;
+        if (resetState) {
+            this.lastValue = '';
+            this.lastAt = 0;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: QrScannerComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.14", type: QrScannerComponent, isStandalone: true, selector: "val-qr-scanner", inputs: { props: "props" }, outputs: { scanned: "scanned" }, viewQueries: [{ propertyName: "videoRef", first: true, predicate: ["video"], descendants: true }], ngImport: i0, template: `
+    <div class="qr-scanner">
+      <div class="qr-scanner__viewport" [class.is-active]="state() === 'scanning'">
+        <video #video class="qr-scanner__video" muted playsinline></video>
+
+        @if (state() === 'idle') {
+          <div class="qr-scanner__overlay">
+            <ion-icon name="camera-outline" class="qr-scanner__overlay-icon" />
+          </div>
+        }
+
+        @if (state() === 'starting') {
+          <div class="qr-scanner__overlay">
+            <ion-spinner name="crescent" />
+            <p>{{ t('starting') }}</p>
+          </div>
+        }
+
+        @if (state() === 'scanning') {
+          <div class="qr-scanner__frame"></div>
+        }
+      </div>
+
+      @if (state() === 'denied' || state() === 'no-camera' || state() === 'error') {
+        <div class="qr-scanner__message">
+          <ion-icon [name]="state() === 'no-camera' ? 'videocam-off-outline' : 'warning-outline'" />
+          <span>{{ stateMessage() }}</span>
+        </div>
+      }
+
+      @if (state() === 'scanning' || state() === 'starting') {
+        <p class="qr-scanner__hint">{{ t('hint') }}</p>
+      }
+
+      @if (devices().length > 1 && state() === 'scanning') {
+        <ion-select
+          class="qr-scanner__select"
+          [label]="t('cameraLabel')"
+          labelPlacement="stacked"
+          interface="popover"
+          [value]="activeDeviceId()"
+          (ionChange)="onSelectDevice($any($event).detail.value)"
+        >
+          @for (d of devices(); track d.deviceId) {
+            <ion-select-option [value]="d.deviceId">{{ deviceLabel(d) }}</ion-select-option>
+          }
+        </ion-select>
+      }
+
+      <div class="qr-scanner__actions">
+        @if (state() === 'scanning' || state() === 'starting') {
+          <ion-button fill="outline" color="dark" (click)="stop()">
+            <ion-icon name="stop-circle-outline" slot="start" />
+            {{ props.stopLabel || t('stop') }}
+          </ion-button>
+        } @else {
+          <ion-button color="dark" (click)="start()">
+            <ion-icon name="camera-outline" slot="start" />
+            {{ props.startLabel || t('start') }}
+          </ion-button>
+        }
+      </div>
+    </div>
+  `, isInline: true, styles: ["@charset \"UTF-8\";:host{display:block}.qr-scanner{display:flex;flex-direction:column;align-items:stretch;gap:12px;max-width:420px;margin:0 auto}.qr-scanner__viewport{position:relative;width:100%;aspect-ratio:1/1;border-radius:16px;overflow:hidden;background:var(--ion-color-dark, #1c1c1e);display:flex;align-items:center;justify-content:center}.qr-scanner__video{width:100%;height:100%;object-fit:cover;display:block}.qr-scanner__overlay{position:absolute;inset:0;display:flex;flex-direction:column;align-items:center;justify-content:center;gap:8px;color:var(--ion-color-light, #f4f5f8)}.qr-scanner__overlay p{margin:0;font-size:.875rem}.qr-scanner__overlay-icon{font-size:3rem;opacity:.6}.qr-scanner__frame{position:absolute;inset:18%;border:3px solid var(--ion-color-primary, #ff00b2);border-radius:12px;box-shadow:0 0 0 9999px #00000040;pointer-events:none}.qr-scanner__message{display:flex;align-items:center;gap:8px;padding:12px 14px;border-radius:12px;background:var(--ion-color-light, #f4f5f8);color:var(--ion-color-medium, #6b6675);font-size:.875rem}.qr-scanner__message ion-icon{font-size:1.25rem;flex-shrink:0}.qr-scanner__hint{margin:0;text-align:center;font-size:.8125rem;color:var(--ion-color-medium, #6b6675)}.qr-scanner__select{--padding-start: 0}.qr-scanner__actions{display:flex;justify-content:center}.qr-scanner__actions ion-button{--border-radius: 999px}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "component", type: IonButton, selector: "ion-button", inputs: ["buttonType", "color", "disabled", "download", "expand", "fill", "form", "href", "mode", "rel", "routerAnimation", "routerDirection", "shape", "size", "strong", "target", "type"] }, { kind: "component", type: IonIcon, selector: "ion-icon", inputs: ["color", "flipRtl", "icon", "ios", "lazy", "md", "mode", "name", "sanitize", "size", "src"] }, { kind: "component", type: IonSpinner, selector: "ion-spinner", inputs: ["color", "duration", "name", "paused"] }, { kind: "component", type: IonSelect, selector: "ion-select", inputs: ["cancelText", "color", "compareWith", "disabled", "errorText", "expandedIcon", "fill", "helperText", "interface", "interfaceOptions", "justify", "label", "labelPlacement", "mode", "multiple", "name", "okText", "placeholder", "selectedText", "shape", "toggleIcon", "value"] }, { kind: "component", type: IonSelectOption, selector: "ion-select-option", inputs: ["disabled", "value"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: QrScannerComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'val-qr-scanner', standalone: true, imports: [CommonModule, IonButton, IonIcon, IonSpinner, IonSelect, IonSelectOption], template: `
+    <div class="qr-scanner">
+      <div class="qr-scanner__viewport" [class.is-active]="state() === 'scanning'">
+        <video #video class="qr-scanner__video" muted playsinline></video>
+
+        @if (state() === 'idle') {
+          <div class="qr-scanner__overlay">
+            <ion-icon name="camera-outline" class="qr-scanner__overlay-icon" />
+          </div>
+        }
+
+        @if (state() === 'starting') {
+          <div class="qr-scanner__overlay">
+            <ion-spinner name="crescent" />
+            <p>{{ t('starting') }}</p>
+          </div>
+        }
+
+        @if (state() === 'scanning') {
+          <div class="qr-scanner__frame"></div>
+        }
+      </div>
+
+      @if (state() === 'denied' || state() === 'no-camera' || state() === 'error') {
+        <div class="qr-scanner__message">
+          <ion-icon [name]="state() === 'no-camera' ? 'videocam-off-outline' : 'warning-outline'" />
+          <span>{{ stateMessage() }}</span>
+        </div>
+      }
+
+      @if (state() === 'scanning' || state() === 'starting') {
+        <p class="qr-scanner__hint">{{ t('hint') }}</p>
+      }
+
+      @if (devices().length > 1 && state() === 'scanning') {
+        <ion-select
+          class="qr-scanner__select"
+          [label]="t('cameraLabel')"
+          labelPlacement="stacked"
+          interface="popover"
+          [value]="activeDeviceId()"
+          (ionChange)="onSelectDevice($any($event).detail.value)"
+        >
+          @for (d of devices(); track d.deviceId) {
+            <ion-select-option [value]="d.deviceId">{{ deviceLabel(d) }}</ion-select-option>
+          }
+        </ion-select>
+      }
+
+      <div class="qr-scanner__actions">
+        @if (state() === 'scanning' || state() === 'starting') {
+          <ion-button fill="outline" color="dark" (click)="stop()">
+            <ion-icon name="stop-circle-outline" slot="start" />
+            {{ props.stopLabel || t('stop') }}
+          </ion-button>
+        } @else {
+          <ion-button color="dark" (click)="start()">
+            <ion-icon name="camera-outline" slot="start" />
+            {{ props.startLabel || t('start') }}
+          </ion-button>
+        }
+      </div>
+    </div>
+  `, styles: ["@charset \"UTF-8\";:host{display:block}.qr-scanner{display:flex;flex-direction:column;align-items:stretch;gap:12px;max-width:420px;margin:0 auto}.qr-scanner__viewport{position:relative;width:100%;aspect-ratio:1/1;border-radius:16px;overflow:hidden;background:var(--ion-color-dark, #1c1c1e);display:flex;align-items:center;justify-content:center}.qr-scanner__video{width:100%;height:100%;object-fit:cover;display:block}.qr-scanner__overlay{position:absolute;inset:0;display:flex;flex-direction:column;align-items:center;justify-content:center;gap:8px;color:var(--ion-color-light, #f4f5f8)}.qr-scanner__overlay p{margin:0;font-size:.875rem}.qr-scanner__overlay-icon{font-size:3rem;opacity:.6}.qr-scanner__frame{position:absolute;inset:18%;border:3px solid var(--ion-color-primary, #ff00b2);border-radius:12px;box-shadow:0 0 0 9999px #00000040;pointer-events:none}.qr-scanner__message{display:flex;align-items:center;gap:8px;padding:12px 14px;border-radius:12px;background:var(--ion-color-light, #f4f5f8);color:var(--ion-color-medium, #6b6675);font-size:.875rem}.qr-scanner__message ion-icon{font-size:1.25rem;flex-shrink:0}.qr-scanner__hint{margin:0;text-align:center;font-size:.8125rem;color:var(--ion-color-medium, #6b6675)}.qr-scanner__select{--padding-start: 0}.qr-scanner__actions{display:flex;justify-content:center}.qr-scanner__actions ion-button{--border-radius: 999px}\n"] }]
+        }], ctorParameters: () => [], propDecorators: { props: [{
+                type: Input
+            }], scanned: [{
+                type: Output
+            }], videoRef: [{
+                type: ViewChild,
+                args: ['video']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"qr-scanner.component.js","sourceRoot":"","sources":["../../../../../../../src/lib/components/organisms/qr-scanner/qr-scanner.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  AfterViewInit,\n  Component,\n  ElementRef,\n  EventEmitter,\n  Input,\n  OnDestroy,\n  Output,\n  ViewChild,\n  inject,\n  signal,\n} from '@angular/core';\nimport { CommonModule } from '@angular/common';\nimport { IonButton, IonIcon, IonSelect, IonSelectOption, IonSpinner } from '@ionic/angular/standalone';\nimport { addIcons } from 'ionicons';\nimport { cameraOutline, stopCircleOutline, videocamOffOutline, warningOutline } from 'ionicons/icons';\nimport { BrowserMultiFormatReader, IScannerControls } from '@zxing/browser';\n\nimport { I18nService } from '../../../services/i18n';\nimport { QrScannerMetadata, QrScannerState } from './types';\nimport { QR_SCANNER_I18N } from './qr-scanner.i18n';\n\naddIcons({\n  cameraOutline,\n  stopCircleOutline,\n  videocamOffOutline,\n  warningOutline,\n});\n\n/**\n * val-qr-scanner\n *\n * Organism: scanner de códigos QR por cámara (`@zxing/browser` +\n * `@zxing/library`). Emite el texto decodificado por `(scanned)`.\n *\n * Maneja: permiso de cámara denegado (`denied`), ausencia de cámara\n * (`no-camera`), selector cuando hay varias cámaras, y botón start/stop. Hace\n * cleanup del stream en `ngOnDestroy`. i18n auto-registrado (namespace\n * `QrScanner`).\n *\n * Object-first (`@Input() props`) + un único `@Output() scanned`.\n *\n * @example\n * ```html\n * <val-qr-scanner [props]=\"{ continuous: true }\" (scanned)=\"onScan($event)\" />\n * ```\n */\n@Component({\n  selector: 'val-qr-scanner',\n  standalone: true,\n  imports: [CommonModule, IonButton, IonIcon, IonSpinner, IonSelect, IonSelectOption],\n  template: `\n    <div class=\"qr-scanner\">\n      <div class=\"qr-scanner__viewport\" [class.is-active]=\"state() === 'scanning'\">\n        <video #video class=\"qr-scanner__video\" muted playsinline></video>\n\n        @if (state() === 'idle') {\n          <div class=\"qr-scanner__overlay\">\n            <ion-icon name=\"camera-outline\" class=\"qr-scanner__overlay-icon\" />\n          </div>\n        }\n\n        @if (state() === 'starting') {\n          <div class=\"qr-scanner__overlay\">\n            <ion-spinner name=\"crescent\" />\n            <p>{{ t('starting') }}</p>\n          </div>\n        }\n\n        @if (state() === 'scanning') {\n          <div class=\"qr-scanner__frame\"></div>\n        }\n      </div>\n\n      @if (state() === 'denied' || state() === 'no-camera' || state() === 'error') {\n        <div class=\"qr-scanner__message\">\n          <ion-icon [name]=\"state() === 'no-camera' ? 'videocam-off-outline' : 'warning-outline'\" />\n          <span>{{ stateMessage() }}</span>\n        </div>\n      }\n\n      @if (state() === 'scanning' || state() === 'starting') {\n        <p class=\"qr-scanner__hint\">{{ t('hint') }}</p>\n      }\n\n      @if (devices().length > 1 && state() === 'scanning') {\n        <ion-select\n          class=\"qr-scanner__select\"\n          [label]=\"t('cameraLabel')\"\n          labelPlacement=\"stacked\"\n          interface=\"popover\"\n          [value]=\"activeDeviceId()\"\n          (ionChange)=\"onSelectDevice($any($event).detail.value)\"\n        >\n          @for (d of devices(); track d.deviceId) {\n            <ion-select-option [value]=\"d.deviceId\">{{ deviceLabel(d) }}</ion-select-option>\n          }\n        </ion-select>\n      }\n\n      <div class=\"qr-scanner__actions\">\n        @if (state() === 'scanning' || state() === 'starting') {\n          <ion-button fill=\"outline\" color=\"dark\" (click)=\"stop()\">\n            <ion-icon name=\"stop-circle-outline\" slot=\"start\" />\n            {{ props.stopLabel || t('stop') }}\n          </ion-button>\n        } @else {\n          <ion-button color=\"dark\" (click)=\"start()\">\n            <ion-icon name=\"camera-outline\" slot=\"start\" />\n            {{ props.startLabel || t('start') }}\n          </ion-button>\n        }\n      </div>\n    </div>\n  `,\n  styleUrls: ['./qr-scanner.component.scss'],\n})\nexport class QrScannerComponent implements AfterViewInit, OnDestroy {\n  @Input() props: QrScannerMetadata = {};\n\n  /** Emite el texto decodificado del QR. */\n  @Output() scanned = new EventEmitter<string>();\n\n  @ViewChild('video') videoRef!: ElementRef<HTMLVideoElement>;\n\n  private i18n = inject(I18nService);\n\n  readonly state = signal<QrScannerState>('idle');\n  readonly devices = signal<MediaDeviceInfo[]>([]);\n  readonly activeDeviceId = signal<string | undefined>(undefined);\n\n  private reader: BrowserMultiFormatReader | null = null;\n  private controls: IScannerControls | null = null;\n\n  // Anti-rebote: ignora la misma lectura repetida dentro de `dedupeMs`.\n  private lastValue = '';\n  private lastAt = 0;\n\n  private viewReady = false;\n\n  constructor() {\n    if (!this.i18n.hasNamespace('QrScanner')) {\n      this.i18n.registerContent('QrScanner', QR_SCANNER_I18N);\n    }\n  }\n\n  ngAfterViewInit(): void {\n    this.viewReady = true;\n    if (this.props.autoStart) {\n      void this.start();\n    }\n  }\n\n  ngOnDestroy(): void {\n    this.teardown();\n  }\n\n  t(key: string): string {\n    return this.i18n.t(key, 'QrScanner');\n  }\n\n  stateMessage(): string {\n    switch (this.state()) {\n      case 'denied':\n        return this.t('denied');\n      case 'no-camera':\n        return this.t('noCamera');\n      default:\n        return this.t('error');\n    }\n  }\n\n  deviceLabel(d: MediaDeviceInfo): string {\n    return d.label || `${this.t('cameraLabel')} ${this.devices().indexOf(d) + 1}`;\n  }\n\n  async start(deviceId?: string): Promise<void> {\n    if (!this.viewReady) return;\n    this.teardown();\n    this.state.set('starting');\n\n    try {\n      this.reader = new BrowserMultiFormatReader();\n\n      // Enumerar cámaras. Algunos navegadores solo dan labels tras conceder\n      // permiso, así que esto puede devolver labels vacíos la 1ª vez.\n      let cams: MediaDeviceInfo[] = [];\n      try {\n        cams = await BrowserMultiFormatReader.listVideoInputDevices();\n      } catch {\n        cams = [];\n      }\n      this.devices.set(cams);\n\n      // Preferir la trasera (environment) si el label lo sugiere.\n      const target =\n        deviceId ||\n        this.activeDeviceId() ||\n        cams.find(c => /back|rear|environment|trasera/i.test(c.label))?.deviceId ||\n        cams[0]?.deviceId;\n\n      this.activeDeviceId.set(target);\n\n      this.controls = await this.reader.decodeFromVideoDevice(target, this.videoRef.nativeElement, result => {\n        if (result) {\n          this.handleResult(result.getText());\n        }\n      });\n\n      this.state.set('scanning');\n    } catch (err) {\n      this.handleStartError(err);\n    }\n  }\n\n  stop(): void {\n    this.teardown();\n    this.state.set('idle');\n  }\n\n  async onSelectDevice(deviceId: string): Promise<void> {\n    if (deviceId && deviceId !== this.activeDeviceId()) {\n      await this.start(deviceId);\n    }\n  }\n\n  private handleResult(text: string): void {\n    const now = Date.now();\n    const dedupe = this.props.dedupeMs ?? 1500;\n    if (text === this.lastValue && now - this.lastAt < dedupe) {\n      return;\n    }\n    this.lastValue = text;\n    this.lastAt = now;\n\n    this.scanned.emit(text);\n\n    // Modo no continuo: detener tras el primer match (la página reanuda si\n    // quiere). `continuous` default true → seguir escaneando.\n    if (this.props.continuous === false) {\n      this.stop();\n    }\n  }\n\n  private handleStartError(err: unknown): void {\n    const name = (err as { name?: string } | null)?.name ?? '';\n    if (name === 'NotAllowedError' || name === 'SecurityError') {\n      this.state.set('denied');\n    } else if (name === 'NotFoundError' || name === 'OverconstrainedError') {\n      this.state.set('no-camera');\n    } else {\n      this.state.set('error');\n    }\n    this.teardown(false);\n  }\n\n  /** Detiene el decode + libera el stream de la cámara. */\n  private teardown(resetState = true): void {\n    try {\n      this.controls?.stop();\n    } catch {\n      // ignore\n    }\n    this.controls = null;\n\n    const video = this.videoRef?.nativeElement;\n    const stream = video?.srcObject as MediaStream | null;\n    if (stream) {\n      stream.getTracks().forEach(track => track.stop());\n      video.srcObject = null;\n    }\n    this.reader = null;\n\n    if (resetState) {\n      this.lastValue = '';\n      this.lastAt = 0;\n    }\n  }\n}\n"]}

package/esm2022/lib/components/organisms/qr-scanner/qr-scanner.i18n.mjs

@@ -0,0 +1,28 @@
+/**
+ * Defaults i18n (es/en) del `val-qr-scanner`. Auto-registrados en el
+ * constructor (namespace `QrScanner`) — el consumer NUNCA tiene que
+ * registrarlos. Override por props (start/stop) o registrando el namespace.
+ */
+export const QR_SCANNER_I18N = {
+    es: {
+        start: 'Iniciar cámara',
+        stop: 'Detener',
+        starting: 'Iniciando cámara…',
+        hint: 'Apunta la cámara al código QR de la entrada.',
+        cameraLabel: 'Cámara',
+        denied: 'No se pudo acceder a la cámara. Revisa los permisos del navegador e inténtalo de nuevo.',
+        noCamera: 'No se encontró ninguna cámara en este dispositivo.',
+        error: 'Ocurrió un problema con la cámara. Inténtalo de nuevo.',
+    },
+    en: {
+        start: 'Start camera',
+        stop: 'Stop',
+        starting: 'Starting camera…',
+        hint: 'Point the camera at the ticket QR code.',
+        cameraLabel: 'Camera',
+        denied: 'Could not access the camera. Check your browser permissions and try again.',
+        noCamera: 'No camera was found on this device.',
+        error: 'Something went wrong with the camera. Please try again.',
+    },
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/components/organisms/qr-scanner/types.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/components/organisms/settings-hub/settings.routes.mjs

@@ -5,6 +5,7 @@ import { provideValtechAccountRoutes } from '../account-view/account.routes';
 import { provideValtechOrganizationRoutes } from '../organization-view/organization.routes';
 import { provideValtechNotificationPreferencesRoutes } from '../notification-preferences-view/notification-preferences.routes';
 import { provideValtechPermissionsRoutes } from '../permissions-view/permissions.routes';
+import { provideValtechApiKeysRoutes } from '../api-keys-view/api-keys.routes';
 import { SettingsHubComponent } from './settings-hub.component';
 /**
  * Helper para montar el bloque completo de Settings en una app del factory: el
@@ -47,6 +48,7 @@ export function provideValtechSettingsRoutes(opts) {
     const includeOrganization = opts?.includeOrganization ?? true;
     const includeNotificationPreferences = opts?.includeNotificationPreferences ?? true;
     const includePermissions = opts?.includePermissions ?? true;
+    const includeApiKeys = opts?.includeApiKeys ?? false;
     return [
         {
             path: basePath,
@@ -80,9 +82,10 @@ export function provideValtechSettingsRoutes(opts) {
                 ...(includePermissions
                     ? provideValtechPermissionsRoutes({ config: opts?.permissionsConfig })
                     : []),
+                ...(includeApiKeys ? provideValtechApiKeysRoutes({ config: opts?.apiKeysConfig }) : []),
                 ...(opts?.extraRoutes ?? []),
             ],
         },
     ];
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"settings.routes.js","sourceRoot":"","sources":["../../../../../../../src/lib/components/organisms/settings-hub/settings.routes.ts"],"names":[],"mappings":"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","sourcesContent":["import { Routes } from '@angular/router';\n\nimport { provideValtechProfileRoutes } from '../profile-view/profile.routes';\nimport { ProfileViewConfig } from '../profile-view/types';\nimport { provideValtechPreferencesRoutes } from '../preferences-view/preferences.routes';\nimport { PreferencesViewConfig } from '../preferences-view/types';\nimport { provideValtechSecurityRoutes } from '../security-view/security.routes';\nimport { SecurityViewConfig } from '../security-view/types';\nimport { provideValtechAccountRoutes } from '../account-view/account.routes';\nimport { AccountViewConfig } from '../account-view/types';\nimport { provideValtechOrganizationRoutes } from '../organization-view/organization.routes';\nimport { OrganizationViewConfig } from '../organization-view/types';\nimport { provideValtechNotificationPreferencesRoutes } from '../notification-preferences-view/notification-preferences.routes';\nimport { NotificationPreferencesViewConfig } from '../notification-preferences-view/types';\nimport { provideValtechPermissionsRoutes } from '../permissions-view/permissions.routes';\nimport { PermissionsViewConfig } from '../permissions-view/types';\n\nimport { SettingsHubComponent } from './settings-hub.component';\nimport { SettingsHubConfig } from './types';\n\n/**\n * Opciones de `provideValtechSettingsRoutes`. Agrupa el HUB (`val-settings-hub`)\n * con las vistas ya promovidas (Perfil + Preferencias) bajo un único `path`\n * base, y deja `extraRoutes` para las secciones de la app aún no promovidas\n * (security, account, notifications, organization, …).\n */\nexport interface ValtechSettingsRoutesOptions {\n  /** Path base del bloque de settings. Default `'settings'`. */\n  basePath?: string;\n  /**\n   * Path donde se monta el HUB dentro del bloque. Default `''` (índice). Para\n   * apps que quieren el hub en una sub-ruta (ej. showcase lo tiene en\n   * `preferences`), setear esto + `indexRedirectTo`.\n   */\n  hubPath?: string;\n  /**\n   * Si se setea, agrega `{ path: '', redirectTo, pathMatch: 'full' }` al índice.\n   * Pensado para cuando `hubPath` NO es `''` (el índice queda libre y se redirige\n   * al hub u otra sección). No usar junto con `hubPath: ''` (colisionarían).\n   */\n  indexRedirectTo?: string;\n  /** Config del HUB (pasada por route data `settingsHubConfig`). */\n  hubConfig?: SettingsHubConfig;\n  /** Config de la vista Perfil (pass-through a `provideValtechProfileRoutes`). */\n  profileConfig?: ProfileViewConfig;\n  /** Config de la vista Preferencias (pass-through a `provideValtechPreferencesRoutes`). */\n  preferencesConfig?: PreferencesViewConfig;\n  /** Config de la vista Seguridad (pass-through a `provideValtechSecurityRoutes`). */\n  securityConfig?: SecurityViewConfig;\n  /** Config de la vista Cuenta (pass-through a `provideValtechAccountRoutes`). */\n  accountConfig?: AccountViewConfig;\n  /** Config de la vista Gestión de organización (pass-through a `provideValtechOrganizationRoutes`). */\n  organizationConfig?: OrganizationViewConfig;\n  /** Config de Preferencias de notificaciones push (pass-through). */\n  notificationPreferencesConfig?: NotificationPreferencesViewConfig;\n  /** Config del visor de Permisos (pass-through). */\n  permissionsConfig?: PermissionsViewConfig;\n  /** Monta la ruta `profile`. Default `true`. */\n  includeProfile?: boolean;\n  /** Monta la ruta de preferencias. Default `true`. */\n  includePreferences?: boolean;\n  /** Monta la ruta `security`. Default `true`. */\n  includeSecurity?: boolean;\n  /** Monta la ruta `account`. Default `true`. */\n  includeAccount?: boolean;\n  /** Monta la ruta `organization`. Default `true`. */\n  includeOrganization?: boolean;\n  /** Monta la ruta de preferencias de notificaciones push. Default `true`. */\n  includeNotificationPreferences?: boolean;\n  /** Monta la ruta `permissions`. Default `true`. */\n  includePermissions?: boolean;\n  /** Path de la vista Preferencias. Default `'preferences'`. */\n  preferencesPath?: string;\n  /** Path de la vista Preferencias de notificaciones push. Default `'notifications'`. */\n  notificationPreferencesPath?: string;\n  /** Rutas extra a sumar como hijas (secciones de la app no promovidas). */\n  extraRoutes?: Routes;\n}\n\n/**\n * Helper para montar el bloque completo de Settings en una app del factory: el\n * HUB de navegación (`val-settings-hub`) + TODAS las vistas promovidas (Perfil,\n * Preferencias, Seguridad, Cuenta, Gestión org, Preferencias de notificaciones,\n * Permisos) + las rutas propias de la app (`extraRoutes`). Cada `include*` permite\n * apagar una sección; `hubPath`/`indexRedirectTo`/`*Path` permiten reubicar el hub\n * y las vistas para preservar URLs existentes.\n *\n * showcase lo consume (ver `settings.routes.ts` de showcase): hub en `preferences`,\n * preferences-view en `general`, index→redirect, `organization/new` por `extraRoutes`.\n *\n * @example\n * ```ts\n * // app.routes.ts\n * import { provideValtechSettingsRoutes } from 'valtech-components';\n *\n * export const routes: Routes = [\n *   {\n *     path: 'app',\n *     children: [\n *       ...provideValtechSettingsRoutes({\n *         hubConfig: { onLogout: () => auth.logoutWithConfirmation() },\n *         extraRoutes: [\n *           { path: 'security', loadComponent: () => ... },\n *         ],\n *       }),\n *     ],\n *   },\n * ];\n * ```\n */\nexport function provideValtechSettingsRoutes(opts?: ValtechSettingsRoutesOptions): Routes {\n  const basePath = opts?.basePath ?? 'settings';\n  const hubPath = opts?.hubPath ?? '';\n  const includeProfile = opts?.includeProfile ?? true;\n  const includePreferences = opts?.includePreferences ?? true;\n  const includeSecurity = opts?.includeSecurity ?? true;\n  const includeAccount = opts?.includeAccount ?? true;\n  const includeOrganization = opts?.includeOrganization ?? true;\n  const includeNotificationPreferences = opts?.includeNotificationPreferences ?? true;\n  const includePermissions = opts?.includePermissions ?? true;\n\n  return [\n    {\n      path: basePath,\n      children: [\n        ...(opts?.indexRedirectTo\n          ? [{ path: '', redirectTo: opts.indexRedirectTo, pathMatch: 'full' as const }]\n          : []),\n        {\n          path: hubPath,\n          component: SettingsHubComponent,\n          data: { settingsHubConfig: opts?.hubConfig },\n        },\n        ...(includeProfile ? provideValtechProfileRoutes({ config: opts?.profileConfig }) : []),\n        ...(includePreferences\n          ? provideValtechPreferencesRoutes({\n              path: opts?.preferencesPath ?? 'preferences',\n              config: opts?.preferencesConfig,\n            })\n          : []),\n        ...(includeSecurity ? provideValtechSecurityRoutes({ config: opts?.securityConfig }) : []),\n        ...(includeAccount ? provideValtechAccountRoutes({ config: opts?.accountConfig }) : []),\n        ...(includeOrganization\n          ? provideValtechOrganizationRoutes({ config: opts?.organizationConfig })\n          : []),\n        ...(includeNotificationPreferences\n          ? provideValtechNotificationPreferencesRoutes({\n              path: opts?.notificationPreferencesPath ?? 'notifications',\n              config: opts?.notificationPreferencesConfig,\n            })\n          : []),\n        ...(includePermissions\n          ? provideValtechPermissionsRoutes({ config: opts?.permissionsConfig })\n          : []),\n        ...(opts?.extraRoutes ?? []),\n      ],\n    },\n  ];\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"settings.routes.js","sourceRoot":"","sources":["../../../../../../../src/lib/components/organisms/settings-hub/settings.routes.ts"],"names":[],"mappings":"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","sourcesContent":["import { Routes } from '@angular/router';\n\nimport { provideValtechProfileRoutes } from '../profile-view/profile.routes';\nimport { ProfileViewConfig } from '../profile-view/types';\nimport { provideValtechPreferencesRoutes } from '../preferences-view/preferences.routes';\nimport { PreferencesViewConfig } from '../preferences-view/types';\nimport { provideValtechSecurityRoutes } from '../security-view/security.routes';\nimport { SecurityViewConfig } from '../security-view/types';\nimport { provideValtechAccountRoutes } from '../account-view/account.routes';\nimport { AccountViewConfig } from '../account-view/types';\nimport { provideValtechOrganizationRoutes } from '../organization-view/organization.routes';\nimport { OrganizationViewConfig } from '../organization-view/types';\nimport { provideValtechNotificationPreferencesRoutes } from '../notification-preferences-view/notification-preferences.routes';\nimport { NotificationPreferencesViewConfig } from '../notification-preferences-view/types';\nimport { provideValtechPermissionsRoutes } from '../permissions-view/permissions.routes';\n\nimport { provideValtechApiKeysRoutes } from '../api-keys-view/api-keys.routes';\nimport { ApiKeysViewConfig } from '../api-keys-view/types';\nimport { PermissionsViewConfig } from '../permissions-view/types';\n\nimport { SettingsHubComponent } from './settings-hub.component';\nimport { SettingsHubConfig } from './types';\n\n/**\n * Opciones de `provideValtechSettingsRoutes`. Agrupa el HUB (`val-settings-hub`)\n * con las vistas ya promovidas (Perfil + Preferencias) bajo un único `path`\n * base, y deja `extraRoutes` para las secciones de la app aún no promovidas\n * (security, account, notifications, organization, …).\n */\nexport interface ValtechSettingsRoutesOptions {\n  /** Path base del bloque de settings. Default `'settings'`. */\n  basePath?: string;\n  /**\n   * Path donde se monta el HUB dentro del bloque. Default `''` (índice). Para\n   * apps que quieren el hub en una sub-ruta (ej. showcase lo tiene en\n   * `preferences`), setear esto + `indexRedirectTo`.\n   */\n  hubPath?: string;\n  /**\n   * Si se setea, agrega `{ path: '', redirectTo, pathMatch: 'full' }` al índice.\n   * Pensado para cuando `hubPath` NO es `''` (el índice queda libre y se redirige\n   * al hub u otra sección). No usar junto con `hubPath: ''` (colisionarían).\n   */\n  indexRedirectTo?: string;\n  /** Config del HUB (pasada por route data `settingsHubConfig`). */\n  hubConfig?: SettingsHubConfig;\n  /** Config de la vista Perfil (pass-through a `provideValtechProfileRoutes`). */\n  profileConfig?: ProfileViewConfig;\n  /** Config de la vista Preferencias (pass-through a `provideValtechPreferencesRoutes`). */\n  preferencesConfig?: PreferencesViewConfig;\n  /** Config de la vista Seguridad (pass-through a `provideValtechSecurityRoutes`). */\n  securityConfig?: SecurityViewConfig;\n  /** Config de la vista Cuenta (pass-through a `provideValtechAccountRoutes`). */\n  accountConfig?: AccountViewConfig;\n  /** Config de la vista Gestión de organización (pass-through a `provideValtechOrganizationRoutes`). */\n  organizationConfig?: OrganizationViewConfig;\n  /** Config de Preferencias de notificaciones push (pass-through). */\n  notificationPreferencesConfig?: NotificationPreferencesViewConfig;\n  /** Config del visor de Permisos (pass-through). */\n  permissionsConfig?: PermissionsViewConfig;\n  /** Monta la ruta `profile`. Default `true`. */\n  includeProfile?: boolean;\n  /** Monta la ruta de preferencias. Default `true`. */\n  includePreferences?: boolean;\n  /** Monta la ruta `security`. Default `true`. */\n  includeSecurity?: boolean;\n  /** Monta la ruta `account`. Default `true`. */\n  includeAccount?: boolean;\n  /** Monta la ruta `organization`. Default `true`. */\n  includeOrganization?: boolean;\n  /** Monta la ruta de preferencias de notificaciones push. Default `true`. */\n  includeNotificationPreferences?: boolean;\n  /** Monta la ruta `permissions`. Default `true`. */\n  includePermissions?: boolean;\n  /** Monta la ruta `api-keys` (`val-api-keys-view`). Default `false` (opt-in). */\n  includeApiKeys?: boolean;\n  /** Config de la vista API Keys (pass-through a `provideValtechApiKeysRoutes`). */\n  apiKeysConfig?: ApiKeysViewConfig;\n  /** Path de la vista Preferencias. Default `'preferences'`. */\n  preferencesPath?: string;\n  /** Path de la vista Preferencias de notificaciones push. Default `'notifications'`. */\n  notificationPreferencesPath?: string;\n  /** Rutas extra a sumar como hijas (secciones de la app no promovidas). */\n  extraRoutes?: Routes;\n}\n\n/**\n * Helper para montar el bloque completo de Settings en una app del factory: el\n * HUB de navegación (`val-settings-hub`) + TODAS las vistas promovidas (Perfil,\n * Preferencias, Seguridad, Cuenta, Gestión org, Preferencias de notificaciones,\n * Permisos) + las rutas propias de la app (`extraRoutes`). Cada `include*` permite\n * apagar una sección; `hubPath`/`indexRedirectTo`/`*Path` permiten reubicar el hub\n * y las vistas para preservar URLs existentes.\n *\n * showcase lo consume (ver `settings.routes.ts` de showcase): hub en `preferences`,\n * preferences-view en `general`, index→redirect, `organization/new` por `extraRoutes`.\n *\n * @example\n * ```ts\n * // app.routes.ts\n * import { provideValtechSettingsRoutes } from 'valtech-components';\n *\n * export const routes: Routes = [\n *   {\n *     path: 'app',\n *     children: [\n *       ...provideValtechSettingsRoutes({\n *         hubConfig: { onLogout: () => auth.logoutWithConfirmation() },\n *         extraRoutes: [\n *           { path: 'security', loadComponent: () => ... },\n *         ],\n *       }),\n *     ],\n *   },\n * ];\n * ```\n */\nexport function provideValtechSettingsRoutes(opts?: ValtechSettingsRoutesOptions): Routes {\n  const basePath = opts?.basePath ?? 'settings';\n  const hubPath = opts?.hubPath ?? '';\n  const includeProfile = opts?.includeProfile ?? true;\n  const includePreferences = opts?.includePreferences ?? true;\n  const includeSecurity = opts?.includeSecurity ?? true;\n  const includeAccount = opts?.includeAccount ?? true;\n  const includeOrganization = opts?.includeOrganization ?? true;\n  const includeNotificationPreferences = opts?.includeNotificationPreferences ?? true;\n  const includePermissions = opts?.includePermissions ?? true;\n  const includeApiKeys = opts?.includeApiKeys ?? false;\n\n  return [\n    {\n      path: basePath,\n      children: [\n        ...(opts?.indexRedirectTo\n          ? [{ path: '', redirectTo: opts.indexRedirectTo, pathMatch: 'full' as const }]\n          : []),\n        {\n          path: hubPath,\n          component: SettingsHubComponent,\n          data: { settingsHubConfig: opts?.hubConfig },\n        },\n        ...(includeProfile ? provideValtechProfileRoutes({ config: opts?.profileConfig }) : []),\n        ...(includePreferences\n          ? provideValtechPreferencesRoutes({\n              path: opts?.preferencesPath ?? 'preferences',\n              config: opts?.preferencesConfig,\n            })\n          : []),\n        ...(includeSecurity ? provideValtechSecurityRoutes({ config: opts?.securityConfig }) : []),\n        ...(includeAccount ? provideValtechAccountRoutes({ config: opts?.accountConfig }) : []),\n        ...(includeOrganization\n          ? provideValtechOrganizationRoutes({ config: opts?.organizationConfig })\n          : []),\n        ...(includeNotificationPreferences\n          ? provideValtechNotificationPreferencesRoutes({\n              path: opts?.notificationPreferencesPath ?? 'notifications',\n              config: opts?.notificationPreferencesConfig,\n            })\n          : []),\n        ...(includePermissions\n          ? provideValtechPermissionsRoutes({ config: opts?.permissionsConfig })\n          : []),\n        ...(includeApiKeys ? provideValtechApiKeysRoutes({ config: opts?.apiKeysConfig }) : []),\n        ...(opts?.extraRoutes ?? []),\n      ],\n    },\n  ];\n}\n"]}

package/esm2022/lib/version.mjs

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