valtech-components 2.0.982 → 2.0.984

package/esm2022/lib/components/organisms/faq/faq.component.mjs

@@ -1,7 +1,8 @@
 import { CommonModule } from '@angular/common';
-import { Component, computed, Input, signal } from '@angular/core';
+import { Component, computed, inject, Input, signal } from '@angular/core';
 import { IonAccordion, IonAccordionGroup, IonItem, IonLabel } from '@ionic/angular/standalone';
 import { parseMarkdownArticle } from '../../../services/markdown-article/markdown-article-parser';
+import { I18nService } from '../../../services/i18n/i18n.service';
 import { ArticleComponent } from '../article/article.component';
 import { SearchbarComponent } from '../../molecules/searchbar/searchbar.component';
 import * as i0 from "@angular/core";
@@ -24,6 +25,7 @@ import * as i0 from "@angular/core";
  */
 export class FaqComponent {
     constructor() {
+        this.i18n = inject(I18nService);
         this.props_ = signal({ categories: [] });
         /** Término de búsqueda actual. */
         this.query = signal('');
@@ -33,10 +35,11 @@ export class FaqComponent {
          * Keyed por id de item (los ids son únicos en toda la FAQ).
          */
         this.parsedAnswers = computed(() => {
+            const locale = (this.i18n.lang() ?? 'es');
             const map = new Map();
             for (const cat of this.props_().categories ?? []) {
                 for (const item of cat.items) {
-                    map.set(item.id, parseMarkdownArticle(item.answer));
+                    map.set(item.id, parseMarkdownArticle(item.answer, { locale }));
                 }
             }
             return map;
@@ -173,4 +176,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImpo
         }], propDecorators: { props: [{
                 type: Input
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"faq.component.js","sourceRoot":"","sources":["../../../../../../../src/lib/components/organisms/faq/faq.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { CommonModule } from '@angular/common';\nimport { Component, computed, Input, signal } from '@angular/core';\nimport { IonAccordion, IonAccordionGroup, IonItem, IonLabel } from '@ionic/angular/standalone';\nimport { parseMarkdownArticle } from '../../../services/markdown-article/markdown-article-parser';\nimport { ArticleComponent } from '../article/article.component';\nimport { ArticleMetadata } from '../article/types';\nimport { SearchbarComponent } from '../../molecules/searchbar/searchbar.component';\nimport { FaqCategory, FaqItem, FaqMetadata } from './types';\n\n/**\n * `val-faq`\n *\n * Organism de preguntas frecuentes. Q&A categorizado con accordion colapsable\n * y buscador en vivo. Pensado para vistas FAQ públicas — el caller puede\n * reusar la misma data (`FaqMetadata.categories`) para emitir el structured\n * data `FAQPage` (JSON-LD) y ganar rich results en buscadores.\n *\n * Las respuestas (`FaqItem.answer`) son **Markdown** — se parsean con\n * `parseMarkdownArticle` y se renderizan vía `val-article`. Soportan links,\n * listas, negritas, tablas, etc.\n *\n * @example\n * ```html\n * <val-faq [props]=\"{ categories: faqCategories, searchable: true }\" />\n * ```\n */\n@Component({\n  selector: 'val-faq',\n  standalone: true,\n  imports: [CommonModule, IonAccordion, IonAccordionGroup, IonItem, IonLabel, SearchbarComponent, ArticleComponent],\n  template: `\n    <div class=\"val-faq\">\n      @if (props.searchable !== false) {\n        <div class=\"val-faq__search\">\n          <val-searchbar\n            [props]=\"{\n              placeholder: props.searchPlaceholder || '',\n              debounce: 200,\n            }\"\n            (filterEvent)=\"onSearch($event)\"\n          />\n        </div>\n      }\n\n      @if (visibleCategories().length === 0) {\n        <p class=\"val-faq__empty\">\n          {{ props.noResultsText || 'Sin resultados' }}\n        </p>\n      } @else {\n        @for (cat of visibleCategories(); track cat.id) {\n          <section class=\"val-faq__category\">\n            @if (showCategoryLabel()) {\n              <h3 class=\"val-faq__category-label\">{{ cat.label }}</h3>\n            }\n            <ion-accordion-group [multiple]=\"props.multiple ?? false\">\n              @for (item of cat.items; track item.id) {\n                <ion-accordion [value]=\"item.id\" class=\"val-faq__item\">\n                  <ion-item slot=\"header\" lines=\"none\" class=\"val-faq__q\">\n                    <ion-label class=\"val-faq__q-label\">\n                      {{ item.question }}\n                    </ion-label>\n                  </ion-item>\n                  <div slot=\"content\" class=\"val-faq__a\">\n                    <val-article [props]=\"answerOf(item)\" />\n                  </div>\n                </ion-accordion>\n              }\n            </ion-accordion-group>\n          </section>\n        }\n      }\n    </div>\n  `,\n  styles: [\n    `\n      :host {\n        display: block;\n        width: 100%;\n      }\n\n      .val-faq__search {\n        margin-bottom: 16px;\n      }\n\n      .val-faq__category + .val-faq__category {\n        margin-top: 24px;\n      }\n\n      .val-faq__category-label {\n        font-size: 0.8rem;\n        font-weight: 700;\n        letter-spacing: 0.06em;\n        text-transform: uppercase;\n        color: var(--ion-color-medium, #92949c);\n        margin: 0 0 8px;\n        padding-inline: 4px;\n      }\n\n      ion-accordion-group {\n        display: flex;\n        flex-direction: column;\n        gap: 8px;\n      }\n\n      .val-faq__item {\n        border-radius: 12px;\n        overflow: hidden;\n        background: var(--ion-color-light, #f4f5f8);\n      }\n\n      .val-faq__q {\n        --background: transparent;\n        --min-height: 56px;\n      }\n\n      .val-faq__q-label {\n        font-weight: 600;\n        white-space: normal;\n      }\n\n      .val-faq__a {\n        padding: 4px 16px 16px;\n      }\n\n      .val-faq__empty {\n        text-align: center;\n        padding: 32px 16px;\n        color: var(--ion-color-medium, #92949c);\n        font-size: 0.95rem;\n      }\n    `,\n  ],\n})\nexport class FaqComponent {\n  private readonly props_ = signal<FaqMetadata>({ categories: [] });\n\n  @Input() set props(value: FaqMetadata | undefined) {\n    if (value) this.props_.set(value);\n  }\n  get props(): FaqMetadata {\n    return this.props_();\n  }\n\n  /** Término de búsqueda actual. */\n  private readonly query = signal('');\n\n  /**\n   * Cache de respuestas parseadas (Markdown → ArticleMetadata). Se reconstruye\n   * solo cuando cambian las categorías — el parseo NO corre por keystroke.\n   * Keyed por id de item (los ids son únicos en toda la FAQ).\n   */\n  private readonly parsedAnswers = computed<Map<string, ArticleMetadata>>(() => {\n    const map = new Map<string, ArticleMetadata>();\n    for (const cat of this.props_().categories ?? []) {\n      for (const item of cat.items) {\n        map.set(item.id, parseMarkdownArticle(item.answer));\n      }\n    }\n    return map;\n  });\n\n  /** Respuesta parseada de un item — desde el cache. */\n  answerOf(item: FaqItem): ArticleMetadata {\n    return this.parsedAnswers().get(item.id) ?? { elements: [] };\n  }\n\n  /**\n   * Categorías visibles tras el filtro. Una categoría desaparece si ninguna\n   * de sus preguntas matchea. Match sobre pregunta + respuesta (raw markdown),\n   * case-insensitive.\n   */\n  readonly visibleCategories = computed<FaqCategory[]>(() => {\n    const q = this.query().trim().toLowerCase();\n    const cats = this.props_().categories ?? [];\n    if (!q) return cats;\n    return cats\n      .map(cat => ({\n        ...cat,\n        items: cat.items.filter(it => it.question.toLowerCase().includes(q) || it.answer.toLowerCase().includes(q)),\n      }))\n      .filter(cat => cat.items.length > 0);\n  });\n\n  /** `true` si se debe mostrar el label de cada categoría. */\n  readonly showCategoryLabel = computed(() => {\n    const p = this.props_();\n    if (p.hideSingleCategoryLabel === false) return true;\n    return (p.categories?.length ?? 0) > 1;\n  });\n\n  onSearch(term: string): void {\n    this.query.set(term ?? '');\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"faq.component.js","sourceRoot":"","sources":["../../../../../../../src/lib/components/organisms/faq/faq.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { CommonModule } from '@angular/common';\nimport { Component, computed, inject, Input, signal } from '@angular/core';\nimport { IonAccordion, IonAccordionGroup, IonItem, IonLabel } from '@ionic/angular/standalone';\nimport { parseMarkdownArticle } from '../../../services/markdown-article/markdown-article-parser';\nimport { I18nService } from '../../../services/i18n/i18n.service';\nimport { ArticleComponent } from '../article/article.component';\nimport { ArticleMetadata } from '../article/types';\nimport { SearchbarComponent } from '../../molecules/searchbar/searchbar.component';\nimport { FaqCategory, FaqItem, FaqMetadata } from './types';\n\n/**\n * `val-faq`\n *\n * Organism de preguntas frecuentes. Q&A categorizado con accordion colapsable\n * y buscador en vivo. Pensado para vistas FAQ públicas — el caller puede\n * reusar la misma data (`FaqMetadata.categories`) para emitir el structured\n * data `FAQPage` (JSON-LD) y ganar rich results en buscadores.\n *\n * Las respuestas (`FaqItem.answer`) son **Markdown** — se parsean con\n * `parseMarkdownArticle` y se renderizan vía `val-article`. Soportan links,\n * listas, negritas, tablas, etc.\n *\n * @example\n * ```html\n * <val-faq [props]=\"{ categories: faqCategories, searchable: true }\" />\n * ```\n */\n@Component({\n  selector: 'val-faq',\n  standalone: true,\n  imports: [CommonModule, IonAccordion, IonAccordionGroup, IonItem, IonLabel, SearchbarComponent, ArticleComponent],\n  template: `\n    <div class=\"val-faq\">\n      @if (props.searchable !== false) {\n        <div class=\"val-faq__search\">\n          <val-searchbar\n            [props]=\"{\n              placeholder: props.searchPlaceholder || '',\n              debounce: 200,\n            }\"\n            (filterEvent)=\"onSearch($event)\"\n          />\n        </div>\n      }\n\n      @if (visibleCategories().length === 0) {\n        <p class=\"val-faq__empty\">\n          {{ props.noResultsText || 'Sin resultados' }}\n        </p>\n      } @else {\n        @for (cat of visibleCategories(); track cat.id) {\n          <section class=\"val-faq__category\">\n            @if (showCategoryLabel()) {\n              <h3 class=\"val-faq__category-label\">{{ cat.label }}</h3>\n            }\n            <ion-accordion-group [multiple]=\"props.multiple ?? false\">\n              @for (item of cat.items; track item.id) {\n                <ion-accordion [value]=\"item.id\" class=\"val-faq__item\">\n                  <ion-item slot=\"header\" lines=\"none\" class=\"val-faq__q\">\n                    <ion-label class=\"val-faq__q-label\">\n                      {{ item.question }}\n                    </ion-label>\n                  </ion-item>\n                  <div slot=\"content\" class=\"val-faq__a\">\n                    <val-article [props]=\"answerOf(item)\" />\n                  </div>\n                </ion-accordion>\n              }\n            </ion-accordion-group>\n          </section>\n        }\n      }\n    </div>\n  `,\n  styles: [\n    `\n      :host {\n        display: block;\n        width: 100%;\n      }\n\n      .val-faq__search {\n        margin-bottom: 16px;\n      }\n\n      .val-faq__category + .val-faq__category {\n        margin-top: 24px;\n      }\n\n      .val-faq__category-label {\n        font-size: 0.8rem;\n        font-weight: 700;\n        letter-spacing: 0.06em;\n        text-transform: uppercase;\n        color: var(--ion-color-medium, #92949c);\n        margin: 0 0 8px;\n        padding-inline: 4px;\n      }\n\n      ion-accordion-group {\n        display: flex;\n        flex-direction: column;\n        gap: 8px;\n      }\n\n      .val-faq__item {\n        border-radius: 12px;\n        overflow: hidden;\n        background: var(--ion-color-light, #f4f5f8);\n      }\n\n      .val-faq__q {\n        --background: transparent;\n        --min-height: 56px;\n      }\n\n      .val-faq__q-label {\n        font-weight: 600;\n        white-space: normal;\n      }\n\n      .val-faq__a {\n        padding: 4px 16px 16px;\n      }\n\n      .val-faq__empty {\n        text-align: center;\n        padding: 32px 16px;\n        color: var(--ion-color-medium, #92949c);\n        font-size: 0.95rem;\n      }\n    `,\n  ],\n})\nexport class FaqComponent {\n  private readonly i18n = inject(I18nService);\n  private readonly props_ = signal<FaqMetadata>({ categories: [] });\n\n  @Input() set props(value: FaqMetadata | undefined) {\n    if (value) this.props_.set(value);\n  }\n  get props(): FaqMetadata {\n    return this.props_();\n  }\n\n  /** Término de búsqueda actual. */\n  private readonly query = signal('');\n\n  /**\n   * Cache de respuestas parseadas (Markdown → ArticleMetadata). Se reconstruye\n   * solo cuando cambian las categorías — el parseo NO corre por keystroke.\n   * Keyed por id de item (los ids son únicos en toda la FAQ).\n   */\n  private readonly parsedAnswers = computed<Map<string, ArticleMetadata>>(() => {\n    const locale = (this.i18n.lang() ?? 'es') as 'es' | 'en' | 'pt';\n    const map = new Map<string, ArticleMetadata>();\n    for (const cat of this.props_().categories ?? []) {\n      for (const item of cat.items) {\n        map.set(item.id, parseMarkdownArticle(item.answer, { locale }));\n      }\n    }\n    return map;\n  });\n\n  /** Respuesta parseada de un item — desde el cache. */\n  answerOf(item: FaqItem): ArticleMetadata {\n    return this.parsedAnswers().get(item.id) ?? { elements: [] };\n  }\n\n  /**\n   * Categorías visibles tras el filtro. Una categoría desaparece si ninguna\n   * de sus preguntas matchea. Match sobre pregunta + respuesta (raw markdown),\n   * case-insensitive.\n   */\n  readonly visibleCategories = computed<FaqCategory[]>(() => {\n    const q = this.query().trim().toLowerCase();\n    const cats = this.props_().categories ?? [];\n    if (!q) return cats;\n    return cats\n      .map(cat => ({\n        ...cat,\n        items: cat.items.filter(it => it.question.toLowerCase().includes(q) || it.answer.toLowerCase().includes(q)),\n      }))\n      .filter(cat => cat.items.length > 0);\n  });\n\n  /** `true` si se debe mostrar el label de cada categoría. */\n  readonly showCategoryLabel = computed(() => {\n    const p = this.props_();\n    if (p.hideSingleCategoryLabel === false) return true;\n    return (p.categories?.length ?? 0) > 1;\n  });\n\n  onSearch(term: string): void {\n    this.query.set(term ?? '');\n  }\n}\n"]}

package/esm2022/lib/components/organisms/login-attempt-modal/login-attempt-modal.component.mjs

@@ -0,0 +1,298 @@
+import { CommonModule } from '@angular/common';
+import { Component, Input, signal } from '@angular/core';
+import { IonButton, IonButtons, IonContent, IonHeader, IonIcon, IonToolbar } from '@ionic/angular/standalone';
+import { addIcons } from 'ionicons';
+import { checkmarkCircleOutline, shieldCheckmarkOutline } from 'ionicons/icons';
+import { ButtonComponent } from '../../atoms/button/button.component';
+import { DisplayComponent } from '../../atoms/display/display.component';
+import { TextComponent } from '../../atoms/text/text.component';
+import { ComponentStates } from '../../types';
+import * as i0 from "@angular/core";
+addIcons({ shieldCheckmarkOutline, checkmarkCircleOutline });
+/**
+ * `val-login-attempt-modal` — modal de confirmación de intento de inicio de sesión.
+ *
+ * Se abre cuando el usuario llega a la vista Seguridad vía
+ * `?token=...` desde el email/push de "nuevo acceso". Muestra el dispositivo
+ * detectado y dos acciones: confirmar que fue uno mismo (cierra sin hacer nada)
+ * o bloquear el dispositivo (ejecuta el token de acción).
+ *
+ * Inputs vía `componentProps` del ModalService. Sin `@Output` (no funcionan con
+ * `modalController.create()`) — usa callback `onBlock` y `_modalRef.dismiss`.
+ * Recibe los labels ya traducidos (agnóstico a i18n).
+ *
+ * Header canónico (Regla #5): sin `ion-title`, botón Cerrar texto en `slot=end`,
+ * título en el body con `val-display`.
+ */
+export class LoginAttemptModalComponent {
+    constructor() {
+        /** Título del modal (i18n ya resuelto). */
+        this.title = '';
+        /** Texto explicativo. */
+        this.body = '';
+        /** Descripción del dispositivo (navegador · OS · ubicación). */
+        this.deviceLabel = '';
+        /** Metadata secundaria (fecha, IP). Opcional. */
+        this.metaLabel = '';
+        /** Mensaje mostrado tras bloquear. */
+        this.doneLabel = '';
+        /** Labels de botones. */
+        this.mineLabel = '';
+        this.blockLabel = '';
+        this.closeLabel = '';
+        /** `true` si el dispositivo es móvil — cambia el icono. */
+        this.isMobile = false;
+        /** `true` tras bloquear con éxito — cambia el modal a estado "hecho". */
+        this.done = signal(false);
+        this.working = false;
+    }
+    get deviceIcon() {
+        return this.isMobile ? 'phone-portrait-outline' : 'laptop-outline';
+    }
+    /** "Sí, fui yo" — cierra sin acción. El dispositivo ya está activo. */
+    confirmMine() {
+        this._modalRef?.dismiss(undefined, 'mine');
+    }
+    /** "No fui yo" — ejecuta el bloqueo y pasa a estado done. */
+    async confirmBlock() {
+        if (this.working || !this.onBlock)
+            return;
+        this.working = true;
+        try {
+            await this.onBlock();
+            this.done.set(true);
+        }
+        catch {
+            // El parent muestra el toast de error; cerramos el modal.
+            this._modalRef?.dismiss(undefined, 'error');
+        }
+        finally {
+            this.working = false;
+        }
+    }
+    close() {
+        this._modalRef?.dismiss(undefined, this.done() ? 'blocked' : 'close');
+    }
+    get mineBtn() {
+        return {
+            text: this.mineLabel,
+            color: 'medium',
+            fill: 'outline',
+            size: 'default',
+            type: 'button',
+            state: ComponentStates.ENABLED,
+        };
+    }
+    get blockBtn() {
+        return {
+            text: this.blockLabel,
+            color: 'danger',
+            fill: 'solid',
+            size: 'default',
+            type: 'button',
+            state: ComponentStates.ENABLED,
+        };
+    }
+    get closeBtn() {
+        return {
+            text: this.closeLabel,
+            color: 'dark',
+            fill: 'solid',
+            size: 'default',
+            type: 'button',
+            state: ComponentStates.ENABLED,
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: LoginAttemptModalComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.14", type: LoginAttemptModalComponent, isStandalone: true, selector: "val-login-attempt-modal", inputs: { title: "title", body: "body", deviceLabel: "deviceLabel", metaLabel: "metaLabel", doneLabel: "doneLabel", mineLabel: "mineLabel", blockLabel: "blockLabel", closeLabel: "closeLabel", isMobile: "isMobile", onBlock: "onBlock", _modalRef: "_modalRef" }, ngImport: i0, template: `
+    <ion-header>
+      <ion-toolbar>
+        <ion-buttons slot="end">
+          <ion-button fill="clear" color="dark" (click)="close()">
+            <strong>{{ closeLabel }}</strong>
+          </ion-button>
+        </ion-buttons>
+      </ion-toolbar>
+    </ion-header>
+    <ion-content class="ion-padding">
+      <val-display [props]="{ content: title, size: 'small', color: 'dark' }" />
+      <div class="attempt">
+        <div class="attempt__hero">
+          <ion-icon name="shield-checkmark-outline" aria-hidden="true" />
+        </div>
+
+        <val-text
+          [props]="{
+            content: body,
+            size: 'medium',
+            color: 'dark',
+            bold: false,
+          }"
+        />
+
+        <div class="attempt__device">
+          <ion-icon [name]="deviceIcon" aria-hidden="true" />
+          <div class="attempt__device-body">
+            <val-text
+              [props]="{
+                content: deviceLabel,
+                size: 'medium',
+                color: 'dark',
+                bold: true,
+              }"
+            />
+            @if (metaLabel) {
+              <val-text
+                [props]="{
+                  content: metaLabel,
+                  size: 'small',
+                  color: 'medium',
+                  bold: false,
+                }"
+              />
+            }
+          </div>
+        </div>
+
+        @if (done()) {
+          <div class="attempt__done">
+            <ion-icon name="checkmark-circle-outline" aria-hidden="true" />
+            <val-text
+              [props]="{
+                content: doneLabel,
+                size: 'small',
+                color: 'medium',
+                bold: false,
+              }"
+            />
+          </div>
+        }
+      </div>
+    </ion-content>
+
+    @if (!done()) {
+      <div class="attempt__actions">
+        <val-button [props]="mineBtn" (click)="confirmMine()" />
+        <val-button [props]="blockBtn" (click)="confirmBlock()" />
+      </div>
+    } @else {
+      <div class="attempt__actions">
+        <val-button [props]="closeBtn" (click)="close()" />
+      </div>
+    }
+  `, isInline: true, styles: [":host{display:block}.attempt{display:flex;flex-direction:column;gap:18px;align-items:flex-start}.attempt__hero{width:56px;height:56px;border-radius:16px;display:flex;align-items:center;justify-content:center;background:#7026df1a}.attempt__hero ion-icon{font-size:30px;color:var(--ion-color-primary, #7026df)}.attempt__device{display:flex;align-items:center;gap:12px;width:100%;padding:14px 16px;border-radius:12px;background:var(--ion-color-light, #f4f5f8);border:1px solid var(--val-border-color, rgba(0, 0, 0, .08))}.attempt__device ion-icon{font-size:26px;color:var(--ion-color-dark);flex-shrink:0}.attempt__device-body{display:flex;flex-direction:column;gap:2px;min-width:0}.attempt__done{display:flex;align-items:center;gap:8px}.attempt__done ion-icon{font-size:20px;color:var(--ion-color-success);flex-shrink:0}.attempt__actions{display:flex;gap:10px;padding:12px 16px calc(12px + env(safe-area-inset-bottom,0px));border-top:1px solid var(--val-border-color, rgba(0, 0, 0, .08))}.attempt__actions val-button{flex:1}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "component", type: IonContent, selector: "ion-content", inputs: ["color", "fixedSlotPlacement", "forceOverscroll", "fullscreen", "scrollEvents", "scrollX", "scrollY"] }, { kind: "component", type: IonHeader, selector: "ion-header", inputs: ["collapse", "mode", "translucent"] }, { kind: "component", type: IonToolbar, selector: "ion-toolbar", inputs: ["color", "mode"] }, { kind: "component", type: IonButtons, selector: "ion-buttons", inputs: ["collapse"] }, { 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: DisplayComponent, selector: "val-display", inputs: ["props"] }, { kind: "component", type: TextComponent, selector: "val-text", inputs: ["props"] }, { kind: "component", type: ButtonComponent, selector: "val-button", inputs: ["preset", "props"], outputs: ["onClick"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: LoginAttemptModalComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'val-login-attempt-modal', standalone: true, imports: [
+                        CommonModule,
+                        IonContent,
+                        IonHeader,
+                        IonToolbar,
+                        IonButtons,
+                        IonButton,
+                        IonIcon,
+                        DisplayComponent,
+                        TextComponent,
+                        ButtonComponent,
+                    ], template: `
+    <ion-header>
+      <ion-toolbar>
+        <ion-buttons slot="end">
+          <ion-button fill="clear" color="dark" (click)="close()">
+            <strong>{{ closeLabel }}</strong>
+          </ion-button>
+        </ion-buttons>
+      </ion-toolbar>
+    </ion-header>
+    <ion-content class="ion-padding">
+      <val-display [props]="{ content: title, size: 'small', color: 'dark' }" />
+      <div class="attempt">
+        <div class="attempt__hero">
+          <ion-icon name="shield-checkmark-outline" aria-hidden="true" />
+        </div>
+
+        <val-text
+          [props]="{
+            content: body,
+            size: 'medium',
+            color: 'dark',
+            bold: false,
+          }"
+        />
+
+        <div class="attempt__device">
+          <ion-icon [name]="deviceIcon" aria-hidden="true" />
+          <div class="attempt__device-body">
+            <val-text
+              [props]="{
+                content: deviceLabel,
+                size: 'medium',
+                color: 'dark',
+                bold: true,
+              }"
+            />
+            @if (metaLabel) {
+              <val-text
+                [props]="{
+                  content: metaLabel,
+                  size: 'small',
+                  color: 'medium',
+                  bold: false,
+                }"
+              />
+            }
+          </div>
+        </div>
+
+        @if (done()) {
+          <div class="attempt__done">
+            <ion-icon name="checkmark-circle-outline" aria-hidden="true" />
+            <val-text
+              [props]="{
+                content: doneLabel,
+                size: 'small',
+                color: 'medium',
+                bold: false,
+              }"
+            />
+          </div>
+        }
+      </div>
+    </ion-content>
+
+    @if (!done()) {
+      <div class="attempt__actions">
+        <val-button [props]="mineBtn" (click)="confirmMine()" />
+        <val-button [props]="blockBtn" (click)="confirmBlock()" />
+      </div>
+    } @else {
+      <div class="attempt__actions">
+        <val-button [props]="closeBtn" (click)="close()" />
+      </div>
+    }
+  `, styles: [":host{display:block}.attempt{display:flex;flex-direction:column;gap:18px;align-items:flex-start}.attempt__hero{width:56px;height:56px;border-radius:16px;display:flex;align-items:center;justify-content:center;background:#7026df1a}.attempt__hero ion-icon{font-size:30px;color:var(--ion-color-primary, #7026df)}.attempt__device{display:flex;align-items:center;gap:12px;width:100%;padding:14px 16px;border-radius:12px;background:var(--ion-color-light, #f4f5f8);border:1px solid var(--val-border-color, rgba(0, 0, 0, .08))}.attempt__device ion-icon{font-size:26px;color:var(--ion-color-dark);flex-shrink:0}.attempt__device-body{display:flex;flex-direction:column;gap:2px;min-width:0}.attempt__done{display:flex;align-items:center;gap:8px}.attempt__done ion-icon{font-size:20px;color:var(--ion-color-success);flex-shrink:0}.attempt__actions{display:flex;gap:10px;padding:12px 16px calc(12px + env(safe-area-inset-bottom,0px));border-top:1px solid var(--val-border-color, rgba(0, 0, 0, .08))}.attempt__actions val-button{flex:1}\n"] }]
+        }], propDecorators: { title: [{
+                type: Input
+            }], body: [{
+                type: Input
+            }], deviceLabel: [{
+                type: Input
+            }], metaLabel: [{
+                type: Input
+            }], doneLabel: [{
+                type: Input
+            }], mineLabel: [{
+                type: Input
+            }], blockLabel: [{
+                type: Input
+            }], closeLabel: [{
+                type: Input
+            }], isMobile: [{
+                type: Input
+            }], onBlock: [{
+                type: Input
+            }], _modalRef: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"login-attempt-modal.component.js","sourceRoot":"","sources":["../../../../../../../src/lib/components/organisms/login-attempt-modal/login-attempt-modal.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { CommonModule } from '@angular/common';\nimport { Component, Input, signal } from '@angular/core';\nimport { IonButton, IonButtons, IonContent, IonHeader, IonIcon, IonToolbar } from '@ionic/angular/standalone';\nimport { addIcons } from 'ionicons';\nimport { checkmarkCircleOutline, shieldCheckmarkOutline } from 'ionicons/icons';\n\nimport { ButtonComponent } from '../../atoms/button/button.component';\nimport { DisplayComponent } from '../../atoms/display/display.component';\nimport { TextComponent } from '../../atoms/text/text.component';\nimport { ButtonMetadata, ComponentStates } from '../../types';\n\naddIcons({ shieldCheckmarkOutline, checkmarkCircleOutline });\n\n/**\n * `val-login-attempt-modal` — modal de confirmación de intento de inicio de sesión.\n *\n * Se abre cuando el usuario llega a la vista Seguridad vía\n * `?token=...` desde el email/push de \"nuevo acceso\". Muestra el dispositivo\n * detectado y dos acciones: confirmar que fue uno mismo (cierra sin hacer nada)\n * o bloquear el dispositivo (ejecuta el token de acción).\n *\n * Inputs vía `componentProps` del ModalService. Sin `@Output` (no funcionan con\n * `modalController.create()`) — usa callback `onBlock` y `_modalRef.dismiss`.\n * Recibe los labels ya traducidos (agnóstico a i18n).\n *\n * Header canónico (Regla #5): sin `ion-title`, botón Cerrar texto en `slot=end`,\n * título en el body con `val-display`.\n */\n@Component({\n  selector: 'val-login-attempt-modal',\n  standalone: true,\n  imports: [\n    CommonModule,\n    IonContent,\n    IonHeader,\n    IonToolbar,\n    IonButtons,\n    IonButton,\n    IonIcon,\n    DisplayComponent,\n    TextComponent,\n    ButtonComponent,\n  ],\n  template: `\n    <ion-header>\n      <ion-toolbar>\n        <ion-buttons slot=\"end\">\n          <ion-button fill=\"clear\" color=\"dark\" (click)=\"close()\">\n            <strong>{{ closeLabel }}</strong>\n          </ion-button>\n        </ion-buttons>\n      </ion-toolbar>\n    </ion-header>\n    <ion-content class=\"ion-padding\">\n      <val-display [props]=\"{ content: title, size: 'small', color: 'dark' }\" />\n      <div class=\"attempt\">\n        <div class=\"attempt__hero\">\n          <ion-icon name=\"shield-checkmark-outline\" aria-hidden=\"true\" />\n        </div>\n\n        <val-text\n          [props]=\"{\n            content: body,\n            size: 'medium',\n            color: 'dark',\n            bold: false,\n          }\"\n        />\n\n        <div class=\"attempt__device\">\n          <ion-icon [name]=\"deviceIcon\" aria-hidden=\"true\" />\n          <div class=\"attempt__device-body\">\n            <val-text\n              [props]=\"{\n                content: deviceLabel,\n                size: 'medium',\n                color: 'dark',\n                bold: true,\n              }\"\n            />\n            @if (metaLabel) {\n              <val-text\n                [props]=\"{\n                  content: metaLabel,\n                  size: 'small',\n                  color: 'medium',\n                  bold: false,\n                }\"\n              />\n            }\n          </div>\n        </div>\n\n        @if (done()) {\n          <div class=\"attempt__done\">\n            <ion-icon name=\"checkmark-circle-outline\" aria-hidden=\"true\" />\n            <val-text\n              [props]=\"{\n                content: doneLabel,\n                size: 'small',\n                color: 'medium',\n                bold: false,\n              }\"\n            />\n          </div>\n        }\n      </div>\n    </ion-content>\n\n    @if (!done()) {\n      <div class=\"attempt__actions\">\n        <val-button [props]=\"mineBtn\" (click)=\"confirmMine()\" />\n        <val-button [props]=\"blockBtn\" (click)=\"confirmBlock()\" />\n      </div>\n    } @else {\n      <div class=\"attempt__actions\">\n        <val-button [props]=\"closeBtn\" (click)=\"close()\" />\n      </div>\n    }\n  `,\n  styles: [\n    `\n      :host {\n        display: block;\n      }\n      .attempt {\n        display: flex;\n        flex-direction: column;\n        gap: 18px;\n        align-items: flex-start;\n      }\n      .attempt__hero {\n        width: 56px;\n        height: 56px;\n        border-radius: 16px;\n        display: flex;\n        align-items: center;\n        justify-content: center;\n        background: rgba(112, 38, 223, 0.1);\n      }\n      .attempt__hero ion-icon {\n        font-size: 30px;\n        color: var(--ion-color-primary, #7026df);\n      }\n      .attempt__device {\n        display: flex;\n        align-items: center;\n        gap: 12px;\n        width: 100%;\n        padding: 14px 16px;\n        border-radius: 12px;\n        background: var(--ion-color-light, #f4f5f8);\n        border: 1px solid var(--val-border-color, rgba(0, 0, 0, 0.08));\n      }\n      .attempt__device ion-icon {\n        font-size: 26px;\n        color: var(--ion-color-dark);\n        flex-shrink: 0;\n      }\n      .attempt__device-body {\n        display: flex;\n        flex-direction: column;\n        gap: 2px;\n        min-width: 0;\n      }\n      .attempt__done {\n        display: flex;\n        align-items: center;\n        gap: 8px;\n      }\n      .attempt__done ion-icon {\n        font-size: 20px;\n        color: var(--ion-color-success);\n        flex-shrink: 0;\n      }\n      .attempt__actions {\n        display: flex;\n        gap: 10px;\n        padding: 12px 16px calc(12px + env(safe-area-inset-bottom, 0px));\n        border-top: 1px solid var(--val-border-color, rgba(0, 0, 0, 0.08));\n      }\n      .attempt__actions val-button {\n        flex: 1;\n      }\n    `,\n  ],\n})\nexport class LoginAttemptModalComponent {\n  /** Título del modal (i18n ya resuelto). */\n  @Input() title = '';\n  /** Texto explicativo. */\n  @Input() body = '';\n  /** Descripción del dispositivo (navegador · OS · ubicación). */\n  @Input() deviceLabel = '';\n  /** Metadata secundaria (fecha, IP). Opcional. */\n  @Input() metaLabel = '';\n  /** Mensaje mostrado tras bloquear. */\n  @Input() doneLabel = '';\n  /** Labels de botones. */\n  @Input() mineLabel = '';\n  @Input() blockLabel = '';\n  @Input() closeLabel = '';\n  /** `true` si el dispositivo es móvil — cambia el icono. */\n  @Input() isMobile = false;\n\n  /**\n   * Callback que ejecuta el bloqueo (executeAction con el token) contra el\n   * backend. Lo provee el parent vía `componentProps`. Debe lanzar si falla.\n   */\n  @Input() onBlock?: () => Promise<void>;\n\n  /** Inyectado por `ModalService.open` — referencia para cerrar. */\n  @Input() _modalRef?: { dismiss: (data?: unknown, role?: string) => void };\n\n  /** `true` tras bloquear con éxito — cambia el modal a estado \"hecho\". */\n  protected readonly done = signal(false);\n  private working = false;\n\n  get deviceIcon(): string {\n    return this.isMobile ? 'phone-portrait-outline' : 'laptop-outline';\n  }\n\n  /** \"Sí, fui yo\" — cierra sin acción. El dispositivo ya está activo. */\n  confirmMine(): void {\n    this._modalRef?.dismiss(undefined, 'mine');\n  }\n\n  /** \"No fui yo\" — ejecuta el bloqueo y pasa a estado done. */\n  async confirmBlock(): Promise<void> {\n    if (this.working || !this.onBlock) return;\n    this.working = true;\n    try {\n      await this.onBlock();\n      this.done.set(true);\n    } catch {\n      // El parent muestra el toast de error; cerramos el modal.\n      this._modalRef?.dismiss(undefined, 'error');\n    } finally {\n      this.working = false;\n    }\n  }\n\n  close(): void {\n    this._modalRef?.dismiss(undefined, this.done() ? 'blocked' : 'close');\n  }\n\n  get mineBtn(): Partial<ButtonMetadata> {\n    return {\n      text: this.mineLabel,\n      color: 'medium',\n      fill: 'outline',\n      size: 'default',\n      type: 'button',\n      state: ComponentStates.ENABLED,\n    };\n  }\n\n  get blockBtn(): Partial<ButtonMetadata> {\n    return {\n      text: this.blockLabel,\n      color: 'danger',\n      fill: 'solid',\n      size: 'default',\n      type: 'button',\n      state: ComponentStates.ENABLED,\n    };\n  }\n\n  get closeBtn(): Partial<ButtonMetadata> {\n    return {\n      text: this.closeLabel,\n      color: 'dark',\n      fill: 'solid',\n      size: 'default',\n      type: 'button',\n      state: ComponentStates.ENABLED,\n    };\n  }\n}\n"]}