valtech-components 2.0.1022 → 2.0.1024

package/esm2022/lib/components/organisms/api-keys-view/api-keys-view.component.mjs

@@ -0,0 +1,316 @@
+import { Component, computed, inject, Input, signal } from '@angular/core';
+import { ActivatedRoute } from '@angular/router';
+import { Firestore, doc, getDoc } from '@angular/fire/firestore';
+import { ButtonComponent } from '../../atoms/button/button.component';
+import { DisplayComponent } from '../../atoms/display/display.component';
+import { TextComponent } from '../../atoms/text/text.component';
+import { TitleComponent } from '../../atoms/title/title.component';
+import { UserAvatarComponent } from '../../atoms/user-avatar/user-avatar.component';
+import { EmptyStateComponent } from '../../molecules/empty-state/empty-state.component';
+import { createErrorStateProps } from '../../molecules/empty-state/factory';
+import { SkeletonLayoutComponent } from '../skeleton-layout/skeleton-layout.component';
+import { ComponentStates } from '../../types';
+import { I18nService } from '../../../services/i18n';
+import { AuthService } from '../../../services/auth/auth.service';
+import { ApiKeyService } from '../../../services/apikeys/api-keys.service';
+import { NavigationService } from '../../../services/navigation/navigation.service';
+import { ModalService } from '../../../services/modal/modal.service';
+import { ToastService } from '../../../services/toast.service';
+import { ConfirmationDialogService } from '../../../services/confirmation-dialog/confirmation-dialog.service';
+import { ValtechErrorService } from '../../../services/errors/valtech-error.service';
+import { interpretError } from '../../../services/errors/interpret-error';
+import { connectPageRefresh } from '../../../services/page-refresh/page-refresh.service';
+import { ApiKeyCreateModalComponent } from '../api-key-create-modal/api-key-create-modal.component';
+import { API_KEYS_VIEW_I18N } from './api-keys-view.i18n';
+import * as i0 from "@angular/core";
+const DEFAULT_NAMESPACE = 'Settings.ApiKeys';
+/**
+ * `val-api-keys-view` — vista full-feature de gestión de Client API Keys (ADR-021).
+ *
+ * Reemplaza al `val-api-keys-modal` como pantalla propia: ofrece **crear** arriba
+ * (CTA que abre `val-api-key-create-modal`) y **lista** abajo, con quién la creó
+ * (avatar + handle, resuelto de `/profiles`) y la fecha de creación. Revocar con
+ * confirmación destructiva. Estados loading / error / empty (Capa 4).
+ *
+ * NO renderiza ion-content — vive dentro de `val-page-wrapper`. Header vía
+ * `NavigationService.setBackHeader`. i18n auto-registrado bajo `i18nNamespace`.
+ */
+export class ApiKeysViewComponent {
+    get ns() {
+        return this.resolvedConfig().i18nNamespace;
+    }
+    constructor() {
+        this.i18n = inject(I18nService);
+        this.auth = inject(AuthService);
+        this.apiKeys = inject(ApiKeyService);
+        this.firestore = inject(Firestore);
+        this.nav = inject(NavigationService);
+        this.modalService = inject(ModalService);
+        this.toast = inject(ToastService);
+        this.confirmDialog = inject(ConfirmationDialogService);
+        this.errors = inject(ValtechErrorService);
+        this.route = inject(ActivatedRoute, { optional: true });
+        this.resolvedConfig = computed(() => {
+            const fromRoute = (this.route?.snapshot.data['apiKeysConfig'] ?? {});
+            const merged = { ...fromRoute, ...(this.config ?? {}) };
+            return { i18nNamespace: merged.i18nNamespace ?? DEFAULT_NAMESPACE };
+        });
+        this.keys = signal([]);
+        this.loading = signal(false);
+        this.loadError = signal(null);
+        this.activeOrgId = computed(() => {
+            const u = this.auth.user();
+            return u?.activeOrgId ?? u?.activeOrg ?? '';
+        });
+        this.newKeyButton = computed(() => ({
+            text: this.tt('newKey'),
+            color: 'dark',
+            fill: 'solid',
+            shape: 'round',
+            size: 'small',
+            type: 'button',
+            state: ComponentStates.ENABLED,
+        }));
+        this.errorState = computed(() => {
+            this.i18n.lang();
+            const err = this.loadError();
+            if (!err)
+                return null;
+            return createErrorStateProps(err, {
+                title: { offline: this.tt('offlineTitle'), error: this.tt('errorTitle') },
+                description: { offline: this.tt('offlineHint'), error: interpretError(err).message },
+                retryLabel: this.tt('retry'),
+                onRetry: () => this.load(),
+                retrying: this.loading(),
+            });
+        });
+        this.emptyState = computed(() => {
+            this.i18n.lang();
+            return { variant: 'empty', title: this.tt('empty'), description: this.tt('emptyHint') };
+        });
+        if (!this.i18n.hasNamespace(this.ns)) {
+            this.i18n.registerContent(this.ns, API_KEYS_VIEW_I18N);
+        }
+        this.nav.setBackHeader('pageTitle', this.ns, { withMenu: true });
+        this.load();
+        connectPageRefresh(() => this.load());
+    }
+    revokeButton(k) {
+        return {
+            text: this.tt('revoke'),
+            color: 'danger',
+            fill: 'clear',
+            size: 'small',
+            type: 'button',
+            state: ComponentStates.ENABLED,
+            token: k.keyId,
+        };
+    }
+    load() {
+        if (!this.activeOrgId())
+            return;
+        this.loading.set(true);
+        this.loadError.set(null);
+        this.apiKeys.list().subscribe({
+            next: async (keys) => {
+                this.keys.set(await this.enrichWithCreators(keys));
+                this.loading.set(false);
+            },
+            error: err => {
+                this.loadError.set(err);
+                this.loading.set(false);
+            },
+        });
+    }
+    /** Resuelve handle/avatar/name del creador (`createdBy`) desde `/profiles`. */
+    async enrichWithCreators(keys) {
+        const ids = Array.from(new Set(keys.map(k => k.createdBy).filter(Boolean)));
+        const profiles = new Map();
+        await Promise.allSettled(ids.map(async (id) => {
+            try {
+                const snap = await getDoc(doc(this.firestore, `profiles/${id}`));
+                const p = snap.exists() ? snap.data() : {};
+                profiles.set(id, {
+                    name: p['name'],
+                    handle: p['handle'],
+                    avatar: (p['avatarUrl'] ?? p['avatar']),
+                });
+            }
+            catch {
+                // perfil no accesible → se cae al fallback (unknownUser/createdBy)
+            }
+        }));
+        return keys.map(k => {
+            const p = profiles.get(k.createdBy);
+            return { ...k, creatorName: p?.name, creatorHandle: p?.handle, creatorAvatar: p?.avatar };
+        });
+    }
+    creatorLabel(k) {
+        if (k.creatorHandle)
+            return '@' + k.creatorHandle;
+        if (k.creatorName)
+            return k.creatorName;
+        return this.tt('unknownUser');
+    }
+    formatDate(iso) {
+        if (!iso)
+            return '';
+        const d = new Date(iso);
+        if (isNaN(d.getTime()))
+            return '';
+        return d.toLocaleDateString(this.i18n.lang(), { year: 'numeric', month: 'short', day: 'numeric' });
+    }
+    openCreate() {
+        void this.modalService.open({
+            component: ApiKeyCreateModalComponent,
+            componentProps: {
+                onCreated: () => this.load(),
+            },
+            breakpoints: { breakpoints: [0, 0.92], initialBreakpoint: 0.92, showHandle: true },
+            backdropDismiss: true,
+        });
+    }
+    async revoke(k) {
+        const result = await this.confirmDialog.confirmDestructive({
+            title: this.tt('revokeConfirmTitle'),
+            message: this.tt('revokeConfirmMessage'),
+            confirmButton: { text: this.tt('revokeConfirmOk') },
+            cancelButton: { text: this.tt('cancel') },
+        });
+        if (!result.confirmed)
+            return;
+        this.apiKeys.revoke(k.keyId).subscribe({
+            next: () => {
+                this.toast.show({ message: this.tt('revokeSuccess'), color: 'dark', duration: 3000 });
+                this.load();
+            },
+            error: err => {
+                this.errors.handle(err, { context: 'apiKeys.revoke', fallbackKey: 'errorTitle', i18nNamespace: this.ns });
+            },
+        });
+    }
+    tt(key) {
+        return this.i18n.t(key, this.ns);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ApiKeysViewComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.14", type: ApiKeysViewComponent, isStandalone: true, selector: "val-api-keys-view", inputs: { config: "config" }, ngImport: i0, template: `
+    <div class="apikeys">
+      <header class="apikeys__header">
+        <div class="apikeys__text">
+          <val-display [props]="{ content: tt('title'), size: 'small', color: 'dark' }" />
+          <val-title [props]="{ content: tt('subtitle'), size: 'large', color: 'dark', bold: false }" />
+        </div>
+        <val-button class="apikeys__cta" [props]="newKeyButton()" (onClick)="openCreate()" />
+      </header>
+
+      @if (loading()) {
+        <val-skeleton-layout [props]="{ preset: 'list', rows: 3 }" />
+      } @else if (errorState()) {
+        <val-empty-state [props]="errorState()!" />
+      } @else if (keys().length === 0) {
+        <val-empty-state [props]="emptyState()" />
+      } @else {
+        <div class="apikeys__list">
+          @for (k of keys(); track k.keyId) {
+            <div class="apikey-row">
+              <div class="apikey-row__main">
+                <span class="apikey-row__name">{{ k.name }}</span>
+                <span class="apikey-row__meta">
+                  {{ k.permissions.length }} {{ tt('permsCount') }} ·
+                  {{ k.status === 'revoked' ? tt('statusRevoked') : tt('statusActive') }} · {{ tt('lastUsed') }}:
+                  {{ formatDate(k.lastUsedAt) || tt('never') }}
+                </span>
+                <span class="apikey-row__creator">
+                  <val-user-avatar
+                    [props]="{
+                      name: k.creatorName || k.creatorHandle || '',
+                      avatarUrl: k.creatorAvatar,
+                      size: 'xsmall',
+                    }"
+                  />
+                  <span class="apikey-row__creator-text">
+                    {{ tt('createdBy') }}
+                    {{ creatorLabel(k) }}
+                    @if (formatDate(k.createdAt); as d) {
+                      · {{ tt('createdOn') }} {{ d }}
+                    }
+                  </span>
+                </span>
+              </div>
+              @if (k.status !== 'revoked') {
+                <val-button [props]="revokeButton(k)" (onClick)="revoke(k)" />
+              }
+            </div>
+          }
+        </div>
+      }
+    </div>
+  `, isInline: true, styles: [".apikeys{max-width:720px;margin:0 auto;padding:8px 0 24px}.apikeys__header{display:flex;align-items:flex-start;justify-content:space-between;gap:16px;margin-bottom:20px}.apikeys__text{flex:1;min-width:0}.apikeys__text val-display{display:block;margin-bottom:4px}.apikeys__cta{flex-shrink:0}.apikeys__list{display:flex;flex-direction:column;gap:10px}.apikey-row{display:flex;align-items:center;justify-content:space-between;gap:12px;padding:12px 14px;border-radius:12px;border:1px solid var(--val-border-color, rgba(0, 0, 0, .1))}.apikey-row__main{display:flex;flex-direction:column;gap:4px;min-width:0}.apikey-row__name{font-weight:600;color:var(--ion-color-dark)}.apikey-row__meta{font-size:.78rem;color:var(--ion-color-medium)}.apikey-row__creator{display:flex;align-items:center;gap:6px;font-size:.78rem;color:var(--ion-color-medium)}.apikey-row__creator-text{min-width:0}\n"], dependencies: [{ kind: "component", type: ButtonComponent, selector: "val-button", inputs: ["preset", "props"], outputs: ["onClick"] }, { kind: "component", type: DisplayComponent, selector: "val-display", inputs: ["props"] }, { kind: "component", type: TitleComponent, selector: "val-title", inputs: ["props"] }, { kind: "component", type: UserAvatarComponent, selector: "val-user-avatar", inputs: ["props"], outputs: ["onClick"] }, { kind: "component", type: EmptyStateComponent, selector: "val-empty-state", inputs: ["props"] }, { kind: "component", type: SkeletonLayoutComponent, selector: "val-skeleton-layout", inputs: ["props"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ApiKeysViewComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'val-api-keys-view', standalone: true, imports: [
+                        ButtonComponent,
+                        DisplayComponent,
+                        TextComponent,
+                        TitleComponent,
+                        UserAvatarComponent,
+                        EmptyStateComponent,
+                        SkeletonLayoutComponent,
+                    ], template: `
+    <div class="apikeys">
+      <header class="apikeys__header">
+        <div class="apikeys__text">
+          <val-display [props]="{ content: tt('title'), size: 'small', color: 'dark' }" />
+          <val-title [props]="{ content: tt('subtitle'), size: 'large', color: 'dark', bold: false }" />
+        </div>
+        <val-button class="apikeys__cta" [props]="newKeyButton()" (onClick)="openCreate()" />
+      </header>
+
+      @if (loading()) {
+        <val-skeleton-layout [props]="{ preset: 'list', rows: 3 }" />
+      } @else if (errorState()) {
+        <val-empty-state [props]="errorState()!" />
+      } @else if (keys().length === 0) {
+        <val-empty-state [props]="emptyState()" />
+      } @else {
+        <div class="apikeys__list">
+          @for (k of keys(); track k.keyId) {
+            <div class="apikey-row">
+              <div class="apikey-row__main">
+                <span class="apikey-row__name">{{ k.name }}</span>
+                <span class="apikey-row__meta">
+                  {{ k.permissions.length }} {{ tt('permsCount') }} ·
+                  {{ k.status === 'revoked' ? tt('statusRevoked') : tt('statusActive') }} · {{ tt('lastUsed') }}:
+                  {{ formatDate(k.lastUsedAt) || tt('never') }}
+                </span>
+                <span class="apikey-row__creator">
+                  <val-user-avatar
+                    [props]="{
+                      name: k.creatorName || k.creatorHandle || '',
+                      avatarUrl: k.creatorAvatar,
+                      size: 'xsmall',
+                    }"
+                  />
+                  <span class="apikey-row__creator-text">
+                    {{ tt('createdBy') }}
+                    {{ creatorLabel(k) }}
+                    @if (formatDate(k.createdAt); as d) {
+                      · {{ tt('createdOn') }} {{ d }}
+                    }
+                  </span>
+                </span>
+              </div>
+              @if (k.status !== 'revoked') {
+                <val-button [props]="revokeButton(k)" (onClick)="revoke(k)" />
+              }
+            </div>
+          }
+        </div>
+      }
+    </div>
+  `, styles: [".apikeys{max-width:720px;margin:0 auto;padding:8px 0 24px}.apikeys__header{display:flex;align-items:flex-start;justify-content:space-between;gap:16px;margin-bottom:20px}.apikeys__text{flex:1;min-width:0}.apikeys__text val-display{display:block;margin-bottom:4px}.apikeys__cta{flex-shrink:0}.apikeys__list{display:flex;flex-direction:column;gap:10px}.apikey-row{display:flex;align-items:center;justify-content:space-between;gap:12px;padding:12px 14px;border-radius:12px;border:1px solid var(--val-border-color, rgba(0, 0, 0, .1))}.apikey-row__main{display:flex;flex-direction:column;gap:4px;min-width:0}.apikey-row__name{font-weight:600;color:var(--ion-color-dark)}.apikey-row__meta{font-size:.78rem;color:var(--ion-color-medium)}.apikey-row__creator{display:flex;align-items:center;gap:6px;font-size:.78rem;color:var(--ion-color-medium)}.apikey-row__creator-text{min-width:0}\n"] }]
+        }], ctorParameters: () => [], propDecorators: { config: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api-keys-view.component.js","sourceRoot":"","sources":["../../../../../../../src/lib/components/organisms/api-keys-view/api-keys-view.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, computed, inject, Input, signal } from '@angular/core';\nimport { ActivatedRoute } from '@angular/router';\nimport { Firestore, doc, getDoc } from '@angular/fire/firestore';\n\nimport { ButtonComponent } from '../../atoms/button/button.component';\nimport { DisplayComponent } from '../../atoms/display/display.component';\nimport { TextComponent } from '../../atoms/text/text.component';\nimport { TitleComponent } from '../../atoms/title/title.component';\nimport { UserAvatarComponent } from '../../atoms/user-avatar/user-avatar.component';\nimport { EmptyStateComponent } from '../../molecules/empty-state/empty-state.component';\nimport { EmptyStateMetadata } from '../../molecules/empty-state/types';\nimport { createErrorStateProps } from '../../molecules/empty-state/factory';\nimport { SkeletonLayoutComponent } from '../skeleton-layout/skeleton-layout.component';\nimport { ButtonMetadata, ComponentStates } from '../../types';\n\nimport { I18nService } from '../../../services/i18n';\nimport { AuthService } from '../../../services/auth/auth.service';\nimport { ApiKeyService } from '../../../services/apikeys/api-keys.service';\nimport { ClientApiKey } from '../../../services/apikeys/types';\nimport { NavigationService } from '../../../services/navigation/navigation.service';\nimport { ModalService } from '../../../services/modal/modal.service';\nimport { ToastService } from '../../../services/toast.service';\nimport { ConfirmationDialogService } from '../../../services/confirmation-dialog/confirmation-dialog.service';\nimport { ValtechErrorService } from '../../../services/errors/valtech-error.service';\nimport { interpretError } from '../../../services/errors/interpret-error';\nimport { connectPageRefresh } from '../../../services/page-refresh/page-refresh.service';\n\nimport { ApiKeyCreateModalComponent } from '../api-key-create-modal/api-key-create-modal.component';\nimport { API_KEYS_VIEW_I18N } from './api-keys-view.i18n';\nimport { ApiKeysViewConfig } from './types';\n\nconst DEFAULT_NAMESPACE = 'Settings.ApiKeys';\n\n/** Key enriquecida con el perfil público (handle/avatar/name) de su creador. */\ninterface ApiKeyRow extends ClientApiKey {\n  creatorName?: string;\n  creatorHandle?: string;\n  creatorAvatar?: string;\n}\n\n/**\n * `val-api-keys-view` — vista full-feature de gestión de Client API Keys (ADR-021).\n *\n * Reemplaza al `val-api-keys-modal` como pantalla propia: ofrece **crear** arriba\n * (CTA que abre `val-api-key-create-modal`) y **lista** abajo, con quién la creó\n * (avatar + handle, resuelto de `/profiles`) y la fecha de creación. Revocar con\n * confirmación destructiva. Estados loading / error / empty (Capa 4).\n *\n * NO renderiza ion-content — vive dentro de `val-page-wrapper`. Header vía\n * `NavigationService.setBackHeader`. i18n auto-registrado bajo `i18nNamespace`.\n */\n@Component({\n  selector: 'val-api-keys-view',\n  standalone: true,\n  imports: [\n    ButtonComponent,\n    DisplayComponent,\n    TextComponent,\n    TitleComponent,\n    UserAvatarComponent,\n    EmptyStateComponent,\n    SkeletonLayoutComponent,\n  ],\n  template: `\n    <div class=\"apikeys\">\n      <header class=\"apikeys__header\">\n        <div class=\"apikeys__text\">\n          <val-display [props]=\"{ content: tt('title'), size: 'small', color: 'dark' }\" />\n          <val-title [props]=\"{ content: tt('subtitle'), size: 'large', color: 'dark', bold: false }\" />\n        </div>\n        <val-button class=\"apikeys__cta\" [props]=\"newKeyButton()\" (onClick)=\"openCreate()\" />\n      </header>\n\n      @if (loading()) {\n        <val-skeleton-layout [props]=\"{ preset: 'list', rows: 3 }\" />\n      } @else if (errorState()) {\n        <val-empty-state [props]=\"errorState()!\" />\n      } @else if (keys().length === 0) {\n        <val-empty-state [props]=\"emptyState()\" />\n      } @else {\n        <div class=\"apikeys__list\">\n          @for (k of keys(); track k.keyId) {\n            <div class=\"apikey-row\">\n              <div class=\"apikey-row__main\">\n                <span class=\"apikey-row__name\">{{ k.name }}</span>\n                <span class=\"apikey-row__meta\">\n                  {{ k.permissions.length }} {{ tt('permsCount') }} ·\n                  {{ k.status === 'revoked' ? tt('statusRevoked') : tt('statusActive') }} · {{ tt('lastUsed') }}:\n                  {{ formatDate(k.lastUsedAt) || tt('never') }}\n                </span>\n                <span class=\"apikey-row__creator\">\n                  <val-user-avatar\n                    [props]=\"{\n                      name: k.creatorName || k.creatorHandle || '',\n                      avatarUrl: k.creatorAvatar,\n                      size: 'xsmall',\n                    }\"\n                  />\n                  <span class=\"apikey-row__creator-text\">\n                    {{ tt('createdBy') }}\n                    {{ creatorLabel(k) }}\n                    @if (formatDate(k.createdAt); as d) {\n                      · {{ tt('createdOn') }} {{ d }}\n                    }\n                  </span>\n                </span>\n              </div>\n              @if (k.status !== 'revoked') {\n                <val-button [props]=\"revokeButton(k)\" (onClick)=\"revoke(k)\" />\n              }\n            </div>\n          }\n        </div>\n      }\n    </div>\n  `,\n  styles: [\n    `\n      .apikeys {\n        max-width: 720px;\n        margin: 0 auto;\n        padding: 8px 0 24px;\n      }\n      .apikeys__header {\n        display: flex;\n        align-items: flex-start;\n        justify-content: space-between;\n        gap: 16px;\n        margin-bottom: 20px;\n      }\n      .apikeys__text {\n        flex: 1;\n        min-width: 0;\n      }\n      .apikeys__text val-display {\n        display: block;\n        margin-bottom: 4px;\n      }\n      .apikeys__cta {\n        flex-shrink: 0;\n      }\n      .apikeys__list {\n        display: flex;\n        flex-direction: column;\n        gap: 10px;\n      }\n      .apikey-row {\n        display: flex;\n        align-items: center;\n        justify-content: space-between;\n        gap: 12px;\n        padding: 12px 14px;\n        border-radius: 12px;\n        border: 1px solid var(--val-border-color, rgba(0, 0, 0, 0.1));\n      }\n      .apikey-row__main {\n        display: flex;\n        flex-direction: column;\n        gap: 4px;\n        min-width: 0;\n      }\n      .apikey-row__name {\n        font-weight: 600;\n        color: var(--ion-color-dark);\n      }\n      .apikey-row__meta {\n        font-size: 0.78rem;\n        color: var(--ion-color-medium);\n      }\n      .apikey-row__creator {\n        display: flex;\n        align-items: center;\n        gap: 6px;\n        font-size: 0.78rem;\n        color: var(--ion-color-medium);\n      }\n      .apikey-row__creator-text {\n        min-width: 0;\n      }\n    `,\n  ],\n})\nexport class ApiKeysViewComponent {\n  private i18n = inject(I18nService);\n  private auth = inject(AuthService);\n  private apiKeys = inject(ApiKeyService);\n  private firestore = inject(Firestore);\n  private nav = inject(NavigationService);\n  private modalService = inject(ModalService);\n  private toast = inject(ToastService);\n  private confirmDialog = inject(ConfirmationDialogService);\n  private errors = inject(ValtechErrorService);\n  private route = inject(ActivatedRoute, { optional: true });\n\n  /** Config vía @Input (object-first); fallback al route data `apiKeysConfig`. */\n  @Input() config?: ApiKeysViewConfig;\n\n  readonly resolvedConfig = computed<Required<ApiKeysViewConfig>>(() => {\n    const fromRoute = (this.route?.snapshot.data['apiKeysConfig'] ?? {}) as ApiKeysViewConfig;\n    const merged: ApiKeysViewConfig = { ...fromRoute, ...(this.config ?? {}) };\n    return { i18nNamespace: merged.i18nNamespace ?? DEFAULT_NAMESPACE };\n  });\n\n  private get ns(): string {\n    return this.resolvedConfig().i18nNamespace;\n  }\n\n  readonly keys = signal<ApiKeyRow[]>([]);\n  readonly loading = signal(false);\n  readonly loadError = signal<unknown | null>(null);\n\n  readonly activeOrgId = computed(() => {\n    const u = this.auth.user() as { activeOrgId?: string; activeOrg?: string } | null;\n    return u?.activeOrgId ?? u?.activeOrg ?? '';\n  });\n\n  readonly newKeyButton = computed<Partial<ButtonMetadata>>(() => ({\n    text: this.tt('newKey'),\n    color: 'dark',\n    fill: 'solid',\n    shape: 'round',\n    size: 'small',\n    type: 'button',\n    state: ComponentStates.ENABLED,\n  }));\n\n  readonly errorState = computed<EmptyStateMetadata | null>(() => {\n    this.i18n.lang();\n    const err = this.loadError();\n    if (!err) return null;\n    return createErrorStateProps(err, {\n      title: { offline: this.tt('offlineTitle'), error: this.tt('errorTitle') },\n      description: { offline: this.tt('offlineHint'), error: interpretError(err).message },\n      retryLabel: this.tt('retry'),\n      onRetry: () => this.load(),\n      retrying: this.loading(),\n    });\n  });\n\n  readonly emptyState = computed<EmptyStateMetadata>(() => {\n    this.i18n.lang();\n    return { variant: 'empty', title: this.tt('empty'), description: this.tt('emptyHint') };\n  });\n\n  constructor() {\n    if (!this.i18n.hasNamespace(this.ns)) {\n      this.i18n.registerContent(this.ns, API_KEYS_VIEW_I18N);\n    }\n    this.nav.setBackHeader('pageTitle', this.ns, { withMenu: true });\n    this.load();\n    connectPageRefresh(() => this.load());\n  }\n\n  revokeButton(k: ApiKeyRow): Partial<ButtonMetadata> {\n    return {\n      text: this.tt('revoke'),\n      color: 'danger',\n      fill: 'clear',\n      size: 'small',\n      type: 'button',\n      state: ComponentStates.ENABLED,\n      token: k.keyId,\n    };\n  }\n\n  load(): void {\n    if (!this.activeOrgId()) return;\n    this.loading.set(true);\n    this.loadError.set(null);\n    this.apiKeys.list().subscribe({\n      next: async keys => {\n        this.keys.set(await this.enrichWithCreators(keys));\n        this.loading.set(false);\n      },\n      error: err => {\n        this.loadError.set(err);\n        this.loading.set(false);\n      },\n    });\n  }\n\n  /** Resuelve handle/avatar/name del creador (`createdBy`) desde `/profiles`. */\n  private async enrichWithCreators(keys: ClientApiKey[]): Promise<ApiKeyRow[]> {\n    const ids = Array.from(new Set(keys.map(k => k.createdBy).filter(Boolean)));\n    const profiles = new Map<string, { name?: string; handle?: string; avatar?: string }>();\n    await Promise.allSettled(\n      ids.map(async id => {\n        try {\n          const snap = await getDoc(doc(this.firestore, `profiles/${id}`));\n          const p = snap.exists() ? snap.data() : {};\n          profiles.set(id, {\n            name: p['name'] as string | undefined,\n            handle: p['handle'] as string | undefined,\n            avatar: (p['avatarUrl'] ?? p['avatar']) as string | undefined,\n          });\n        } catch {\n          // perfil no accesible → se cae al fallback (unknownUser/createdBy)\n        }\n      })\n    );\n    return keys.map(k => {\n      const p = profiles.get(k.createdBy);\n      return { ...k, creatorName: p?.name, creatorHandle: p?.handle, creatorAvatar: p?.avatar };\n    });\n  }\n\n  creatorLabel(k: ApiKeyRow): string {\n    if (k.creatorHandle) return '@' + k.creatorHandle;\n    if (k.creatorName) return k.creatorName;\n    return this.tt('unknownUser');\n  }\n\n  formatDate(iso?: string): string {\n    if (!iso) return '';\n    const d = new Date(iso);\n    if (isNaN(d.getTime())) return '';\n    return d.toLocaleDateString(this.i18n.lang(), { year: 'numeric', month: 'short', day: 'numeric' });\n  }\n\n  openCreate(): void {\n    void this.modalService.open({\n      component: ApiKeyCreateModalComponent,\n      componentProps: {\n        onCreated: () => this.load(),\n      },\n      breakpoints: { breakpoints: [0, 0.92], initialBreakpoint: 0.92, showHandle: true },\n      backdropDismiss: true,\n    });\n  }\n\n  async revoke(k: ApiKeyRow): Promise<void> {\n    const result = await this.confirmDialog.confirmDestructive({\n      title: this.tt('revokeConfirmTitle'),\n      message: this.tt('revokeConfirmMessage'),\n      confirmButton: { text: this.tt('revokeConfirmOk') },\n      cancelButton: { text: this.tt('cancel') },\n    });\n    if (!result.confirmed) return;\n    this.apiKeys.revoke(k.keyId).subscribe({\n      next: () => {\n        this.toast.show({ message: this.tt('revokeSuccess'), color: 'dark', duration: 3000 });\n        this.load();\n      },\n      error: err => {\n        this.errors.handle(err, { context: 'apiKeys.revoke', fallbackKey: 'errorTitle', i18nNamespace: this.ns });\n      },\n    });\n  }\n\n  protected tt(key: string): string {\n    return this.i18n.t(key, this.ns);\n  }\n}\n"]}

package/esm2022/lib/components/organisms/api-keys-view/api-keys-view.i18n.mjs

@@ -0,0 +1,59 @@
+/**
+ * Defaults i18n (es/en) de `val-api-keys-view`. Auto-registrados si el consumer no
+ * proveyó el namespace `Settings.ApiKeys`.
+ */
+export const API_KEYS_VIEW_I18N = {
+    es: {
+        pageTitle: 'API Keys',
+        title: 'Client API Keys',
+        subtitle: 'Llaves M2M org-scopeadas para integraciones (p. ej. importar miembros).',
+        newKey: 'Crear API key',
+        empty: 'Aún no hay API keys en esta organización.',
+        emptyHint: 'Crea la primera para habilitar integraciones máquina-a-máquina.',
+        revoke: 'Revocar',
+        revokeConfirmTitle: 'Revocar API key',
+        revokeConfirmMessage: 'Las integraciones que la usen dejarán de funcionar. Esta acción no se puede deshacer.',
+        revokeConfirmOk: 'Revocar',
+        cancel: 'Cancelar',
+        revokeSuccess: 'API key revocada.',
+        permsCount: 'permisos',
+        lastUsed: 'Último uso',
+        never: 'nunca',
+        statusActive: 'Activa',
+        statusRevoked: 'Revocada',
+        createdBy: 'Creada por',
+        createdOn: 'el',
+        unknownUser: 'Usuario',
+        retry: 'Reintentar',
+        errorTitle: 'No se pudieron cargar las API keys',
+        offlineTitle: 'Sin conexión',
+        offlineHint: 'Revisa tu conexión e intenta de nuevo.',
+    },
+    en: {
+        pageTitle: 'API Keys',
+        title: 'Client API Keys',
+        subtitle: 'Org-scoped M2M keys for integrations (e.g. member import).',
+        newKey: 'Create API key',
+        empty: 'No API keys in this organization yet.',
+        emptyHint: 'Create the first one to enable machine-to-machine integrations.',
+        revoke: 'Revoke',
+        revokeConfirmTitle: 'Revoke API key',
+        revokeConfirmMessage: 'Integrations using it will stop working. This action cannot be undone.',
+        revokeConfirmOk: 'Revoke',
+        cancel: 'Cancel',
+        revokeSuccess: 'API key revoked.',
+        permsCount: 'permissions',
+        lastUsed: 'Last used',
+        never: 'never',
+        statusActive: 'Active',
+        statusRevoked: 'Revoked',
+        createdBy: 'Created by',
+        createdOn: 'on',
+        unknownUser: 'User',
+        retry: 'Retry',
+        errorTitle: "Couldn't load API keys",
+        offlineTitle: 'Offline',
+        offlineHint: 'Check your connection and try again.',
+    },
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/components/organisms/api-keys-view/api-keys.routes.mjs

@@ -0,0 +1,27 @@
+import { ApiKeysViewComponent } from './api-keys-view.component';
+/**
+ * Helper para montar la vista de Client API Keys (`val-api-keys-view`) como ruta
+ * en una app del factory. El `config` se pasa por route `data` (`apiKeysConfig`) y
+ * el componente lo lee como fallback de su `@Input() config`.
+ *
+ * @example
+ * ```ts
+ * // settings.routes.ts
+ * import { provideValtechApiKeysRoutes } from 'valtech-components';
+ *
+ * export const settingsRoutes: Routes = [
+ *   ...provideValtechApiKeysRoutes(),                  // → /app/settings/api-keys
+ *   // ...provideValtechApiKeysRoutes({ path: 'integrations/keys' }),
+ * ];
+ * ```
+ */
+export function provideValtechApiKeysRoutes(opts) {
+    return [
+        {
+            path: opts?.path ?? 'api-keys',
+            component: ApiKeysViewComponent,
+            data: { apiKeysConfig: opts?.config },
+        },
+    ];
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXBpLWtleXMucm91dGVzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vc3JjL2xpYi9jb21wb25lbnRzL29yZ2FuaXNtcy9hcGkta2V5cy12aWV3L2FwaS1rZXlzLnJvdXRlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxPQUFPLEVBQUUsb0JBQW9CLEVBQUUsTUFBTSwyQkFBMkIsQ0FBQztBQUdqRTs7Ozs7Ozs7Ozs7Ozs7O0dBZUc7QUFDSCxNQUFNLFVBQVUsMkJBQTJCLENBQUMsSUFHM0M7SUFDQyxPQUFPO1FBQ0w7WUFDRSxJQUFJLEVBQUUsSUFBSSxFQUFFLElBQUksSUFBSSxVQUFVO1lBQzlCLFNBQVMsRUFBRSxvQkFBb0I7WUFDL0IsSUFBSSxFQUFFLEVBQUUsYUFBYSxFQUFFLElBQUksRUFBRSxNQUFNLEVBQUU7U0FDdEM7S0FDRixDQUFDO0FBQ0osQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFJvdXRlcyB9IGZyb20gJ0Bhbmd1bGFyL3JvdXRlcic7XG5cbmltcG9ydCB7IEFwaUtleXNWaWV3Q29tcG9uZW50IH0gZnJvbSAnLi9hcGkta2V5cy12aWV3LmNvbXBvbmVudCc7XG5pbXBvcnQgeyBBcGlLZXlzVmlld0NvbmZpZyB9IGZyb20gJy4vdHlwZXMnO1xuXG4vKipcbiAqIEhlbHBlciBwYXJhIG1vbnRhciBsYSB2aXN0YSBkZSBDbGllbnQgQVBJIEtleXMgKGB2YWwtYXBpLWtleXMtdmlld2ApIGNvbW8gcnV0YVxuICogZW4gdW5hIGFwcCBkZWwgZmFjdG9yeS4gRWwgYGNvbmZpZ2Agc2UgcGFzYSBwb3Igcm91dGUgYGRhdGFgIChgYXBpS2V5c0NvbmZpZ2ApIHlcbiAqIGVsIGNvbXBvbmVudGUgbG8gbGVlIGNvbW8gZmFsbGJhY2sgZGUgc3UgYEBJbnB1dCgpIGNvbmZpZ2AuXG4gKlxuICogQGV4YW1wbGVcbiAqIGBgYHRzXG4gKiAvLyBzZXR0aW5ncy5yb3V0ZXMudHNcbiAqIGltcG9ydCB7IHByb3ZpZGVWYWx0ZWNoQXBpS2V5c1JvdXRlcyB9IGZyb20gJ3ZhbHRlY2gtY29tcG9uZW50cyc7XG4gKlxuICogZXhwb3J0IGNvbnN0IHNldHRpbmdzUm91dGVzOiBSb3V0ZXMgPSBbXG4gKiAgIC4uLnByb3ZpZGVWYWx0ZWNoQXBpS2V5c1JvdXRlcygpLCAgICAgICAgICAgICAgICAgIC8vIOKGkiAvYXBwL3NldHRpbmdzL2FwaS1rZXlzXG4gKiAgIC8vIC4uLnByb3ZpZGVWYWx0ZWNoQXBpS2V5c1JvdXRlcyh7IHBhdGg6ICdpbnRlZ3JhdGlvbnMva2V5cycgfSksXG4gKiBdO1xuICogYGBgXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBwcm92aWRlVmFsdGVjaEFwaUtleXNSb3V0ZXMob3B0cz86IHtcbiAgcGF0aD86IHN0cmluZztcbiAgY29uZmlnPzogQXBpS2V5c1ZpZXdDb25maWc7XG59KTogUm91dGVzIHtcbiAgcmV0dXJuIFtcbiAgICB7XG4gICAgICBwYXRoOiBvcHRzPy5wYXRoID8/ICdhcGkta2V5cycsXG4gICAgICBjb21wb25lbnQ6IEFwaUtleXNWaWV3Q29tcG9uZW50LFxuICAgICAgZGF0YTogeyBhcGlLZXlzQ29uZmlnOiBvcHRzPy5jb25maWcgfSxcbiAgICB9LFxuICBdO1xufVxuIl19

package/esm2022/lib/components/organisms/api-keys-view/types.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9zcmMvbGliL2NvbXBvbmVudHMvb3JnYW5pc21zL2FwaS1rZXlzLXZpZXcvdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQ29uZmlnIGFjb3RhZGEgZGUgYHZhbC1hcGkta2V5cy12aWV3YCAoQURSLTAyMTogdW5hIHZpc3RhIGZ1bGwtZmVhdHVyZSBubyBhYnJlXG4gKiBzbG90cyBhcmJpdHJhcmlvczsgc2kgZmFsdGEgYWxnbywgc2UgcHJvbXVldmUgdW4gbnVldm8gcHVudG8gZGUgZXh0ZW5zacOzbikuXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgQXBpS2V5c1ZpZXdDb25maWcge1xuICAvKiogTmFtZXNwYWNlIGkxOG4gZGUgbG9zIHRleHRvcyBkZSBsYSB2aXN0YS4gRGVmYXVsdCBgU2V0dGluZ3MuQXBpS2V5c2AuICovXG4gIGkxOG5OYW1lc3BhY2U/OiBzdHJpbmc7XG59XG4iXX0=

package/esm2022/lib/components/organisms/org-info-sheet/org-info-sheet.component.mjs

@@ -127,7 +127,7 @@ export class OrgInfoSheetComponent {
         <val-button [props]="resolvedCloseProps()" (click)="dismiss()" />
       </div>
     </ion-content>
-  `, isInline: true, styles: ["ion-content{--padding-bottom: 64px}val-display{margin-bottom:4px;display:block}val-title{margin-bottom:8px;display:block}.info-features{display:flex;flex-direction:column;gap:12px;margin:16px 0}.info-feature{display:flex;align-items:flex-start;gap:14px;padding:12px 14px;border-radius:10px;background:var(--ion-color-light, #f4f5f8)}:host-context(body.dark) .info-feature,:host-context(html.ion-palette-dark) .info-feature,:host-context([data-theme=\"dark\"]) .info-feature{background:#ffffff0d}.info-feature__icon{font-size:22px;color:var(--ion-color-primary);flex-shrink:0;margin-top:2px}.info-feature__title{font-weight:600;font-size:.9rem;color:var(--ion-color-dark)}.info-feature__desc{font-size:.82rem;color:var(--ion-color-medium);margin-top:2px}.sheet-footer{margin-top:20px}\n"], dependencies: [{ 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: IonContent, selector: "ion-content", inputs: ["color", "fixedSlotPlacement", "forceOverscroll", "fullscreen", "scrollEvents", "scrollX", "scrollY"] }, { kind: "component", type: IonIcon, selector: "ion-icon", inputs: ["color", "flipRtl", "icon", "ios", "lazy", "md", "mode", "name", "sanitize", "size", "src"] }, { kind: "component", type: ButtonComponent, selector: "val-button", inputs: ["preset", "props"], outputs: ["onClick"] }, { kind: "component", type: DisplayComponent, selector: "val-display", inputs: ["props"] }, { kind: "component", type: TextComponent, selector: "val-text", inputs: ["props"] }, { kind: "component", type: TitleComponent, selector: "val-title", inputs: ["props"] }] }); }
+  `, isInline: true, styles: ["ion-content{--padding-bottom: calc(96px + env(safe-area-inset-bottom, 0px)) }val-display{margin-bottom:4px;display:block}val-title{margin-bottom:8px;display:block}.info-features{display:flex;flex-direction:column;gap:12px;margin:16px 0}.info-feature{display:flex;align-items:flex-start;gap:14px;padding:12px 14px;border-radius:10px;background:var(--ion-color-light, #f4f5f8)}:host-context(body.dark) .info-feature,:host-context(html.ion-palette-dark) .info-feature,:host-context([data-theme=\"dark\"]) .info-feature{background:#ffffff0d}.info-feature__icon{font-size:22px;color:var(--ion-color-primary);flex-shrink:0;margin-top:2px}.info-feature__title{font-weight:600;font-size:.9rem;color:var(--ion-color-dark)}.info-feature__desc{font-size:.82rem;color:var(--ion-color-medium);margin-top:2px}.sheet-footer{margin-top:20px}\n"], dependencies: [{ 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: IonContent, selector: "ion-content", inputs: ["color", "fixedSlotPlacement", "forceOverscroll", "fullscreen", "scrollEvents", "scrollX", "scrollY"] }, { kind: "component", type: IonIcon, selector: "ion-icon", inputs: ["color", "flipRtl", "icon", "ios", "lazy", "md", "mode", "name", "sanitize", "size", "src"] }, { kind: "component", type: ButtonComponent, selector: "val-button", inputs: ["preset", "props"], outputs: ["onClick"] }, { kind: "component", type: DisplayComponent, selector: "val-display", inputs: ["props"] }, { kind: "component", type: TextComponent, selector: "val-text", inputs: ["props"] }, { kind: "component", type: TitleComponent, selector: "val-title", inputs: ["props"] }] }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: OrgInfoSheetComponent, decorators: [{
             type: Component,
@@ -198,7 +198,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImpo
         <val-button [props]="resolvedCloseProps()" (click)="dismiss()" />
       </div>
     </ion-content>
-  `, styles: ["ion-content{--padding-bottom: 64px}val-display{margin-bottom:4px;display:block}val-title{margin-bottom:8px;display:block}.info-features{display:flex;flex-direction:column;gap:12px;margin:16px 0}.info-feature{display:flex;align-items:flex-start;gap:14px;padding:12px 14px;border-radius:10px;background:var(--ion-color-light, #f4f5f8)}:host-context(body.dark) .info-feature,:host-context(html.ion-palette-dark) .info-feature,:host-context([data-theme=\"dark\"]) .info-feature{background:#ffffff0d}.info-feature__icon{font-size:22px;color:var(--ion-color-primary);flex-shrink:0;margin-top:2px}.info-feature__title{font-weight:600;font-size:.9rem;color:var(--ion-color-dark)}.info-feature__desc{font-size:.82rem;color:var(--ion-color-medium);margin-top:2px}.sheet-footer{margin-top:20px}\n"] }]
+  `, styles: ["ion-content{--padding-bottom: calc(96px + env(safe-area-inset-bottom, 0px)) }val-display{margin-bottom:4px;display:block}val-title{margin-bottom:8px;display:block}.info-features{display:flex;flex-direction:column;gap:12px;margin:16px 0}.info-feature{display:flex;align-items:flex-start;gap:14px;padding:12px 14px;border-radius:10px;background:var(--ion-color-light, #f4f5f8)}:host-context(body.dark) .info-feature,:host-context(html.ion-palette-dark) .info-feature,:host-context([data-theme=\"dark\"]) .info-feature{background:#ffffff0d}.info-feature__icon{font-size:22px;color:var(--ion-color-primary);flex-shrink:0;margin-top:2px}.info-feature__title{font-weight:600;font-size:.9rem;color:var(--ion-color-dark)}.info-feature__desc{font-size:.82rem;color:var(--ion-color-medium);margin-top:2px}.sheet-footer{margin-top:20px}\n"] }]
         }], ctorParameters: () => [], propDecorators: { title: [{
                 type: Input
             }], subtitle: [{
@@ -214,4 +214,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImpo
             }], _modalRef: [{
                 type: Input
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"org-info-sheet.component.js","sourceRoot":"","sources":["../../../../../../../src/lib/components/organisms/org-info-sheet/org-info-sheet.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, computed, inject, Input } from '@angular/core';\nimport { IonButton, IonButtons, IonContent, IonHeader, IonIcon, IonToolbar } from '@ionic/angular/standalone';\nimport { addIcons } from 'ionicons';\nimport { mailOutline, peopleOutline, swapHorizontalOutline } 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 { TitleComponent } from '../../atoms/title/title.component';\nimport { ButtonMetadata } from '../../types';\n\nimport { I18nService } from '../../../services/i18n';\n\nimport { ORG_INFO_SHEET_I18N } from './org-info-sheet.i18n';\n\nconst DEFAULT_NAMESPACE = 'OrgInfoSheet';\n\n/**\n * `val-org-info-sheet` — sheet informativo \"¿Qué son las organizaciones?\".\n * Extraído del `OrgInfoSheetComponent` inline de `AccountPage` bajo el proceso de\n * ADR-021.\n *\n * El consumer pasa `title`/`subtitle`/`body`/`closeLabel` ya resueltos por props\n * (patrón del resto de modales del factory). Los textos de los 3 features\n * (Colaboración / Cambio rápido / Invitaciones), que en la versión inline estaban\n * hardcoded, ahora se auto-resuelven desde el namespace `OrgInfoSheet`\n * (auto-registrado en el constructor).\n *\n * Abierto vía `ModalService` — recibe `_modalRef` por `componentProps`. Header\n * canónico (Regla #5): sin `ion-title`, botón Cerrar texto en `slot=end`,\n * título/subtítulo en el body con `val-display`/`val-title`.\n */\n@Component({\n  selector: 'val-org-info-sheet',\n  standalone: true,\n  imports: [\n    IonHeader,\n    IonToolbar,\n    IonButtons,\n    IonButton,\n    IonContent,\n    IonIcon,\n    ButtonComponent,\n    DisplayComponent,\n    TextComponent,\n    TitleComponent,\n  ],\n  template: `\n    <ion-header>\n      <ion-toolbar>\n        <ion-buttons slot=\"end\">\n          <ion-button fill=\"clear\" color=\"dark\" (click)=\"dismiss()\">\n            <strong>{{ resolvedCloseLabel() }}</strong>\n          </ion-button>\n        </ion-buttons>\n      </ion-toolbar>\n    </ion-header>\n\n    <ion-content class=\"ion-padding\">\n      <val-display [props]=\"{ content: resolvedTitle(), size: 'small', color: 'dark' }\" />\n      <val-title [props]=\"{ content: resolvedSubtitle(), size: 'large', color: '', bold: false }\" />\n\n      @if (showFeatures) {\n        <div class=\"info-features\">\n          <div class=\"info-feature\">\n            <ion-icon name=\"people-outline\" class=\"info-feature__icon\" />\n            <div>\n              <div class=\"info-feature__title\">{{ tt('featureCollabTitle') }}</div>\n              <div class=\"info-feature__desc\">{{ tt('featureCollabDesc') }}</div>\n            </div>\n          </div>\n          <div class=\"info-feature\">\n            <ion-icon name=\"swap-horizontal-outline\" class=\"info-feature__icon\" />\n            <div>\n              <div class=\"info-feature__title\">{{ tt('featureSwitchTitle') }}</div>\n              <div class=\"info-feature__desc\">{{ tt('featureSwitchDesc') }}</div>\n            </div>\n          </div>\n          <div class=\"info-feature\">\n            <ion-icon name=\"mail-outline\" class=\"info-feature__icon\" />\n            <div>\n              <div class=\"info-feature__title\">{{ tt('featureInviteTitle') }}</div>\n              <div class=\"info-feature__desc\">{{ tt('featureInviteDesc') }}</div>\n            </div>\n          </div>\n        </div>\n      }\n\n      @for (para of paragraphs(); track $index) {\n        <val-text\n          [props]=\"{\n            size: 'medium',\n            color: 'dark',\n            bold: false,\n            content: para,\n          }\"\n        />\n      }\n\n      <div class=\"sheet-footer\">\n        <val-button [props]=\"resolvedCloseProps()\" (click)=\"dismiss()\" />\n      </div>\n    </ion-content>\n  `,\n  styles: [\n    `\n      ion-content {\n        --padding-bottom: 64px;\n      }\n      val-display {\n        margin-bottom: 4px;\n        display: block;\n      }\n      val-title {\n        margin-bottom: 8px;\n        display: block;\n      }\n      .info-features {\n        display: flex;\n        flex-direction: column;\n        gap: 12px;\n        margin: 16px 0;\n      }\n      .info-feature {\n        display: flex;\n        align-items: flex-start;\n        gap: 14px;\n        padding: 12px 14px;\n        border-radius: 10px;\n        background: var(--ion-color-light, #f4f5f8);\n      }\n      :host-context(body.dark) .info-feature,\n      :host-context(html.ion-palette-dark) .info-feature,\n      :host-context([data-theme='dark']) .info-feature {\n        background: rgba(255, 255, 255, 0.05);\n      }\n      .info-feature__icon {\n        font-size: 22px;\n        color: var(--ion-color-primary);\n        flex-shrink: 0;\n        margin-top: 2px;\n      }\n      .info-feature__title {\n        font-weight: 600;\n        font-size: 0.9rem;\n        color: var(--ion-color-dark);\n      }\n      .info-feature__desc {\n        font-size: 0.82rem;\n        color: var(--ion-color-medium);\n        margin-top: 2px;\n      }\n      .sheet-footer {\n        margin-top: 20px;\n      }\n    `,\n  ],\n})\nexport class OrgInfoSheetComponent {\n  private i18n = inject(I18nService);\n\n  /** Título principal (resuelto por el consumer). Fallback al namespace propio. */\n  @Input() title = '';\n  /** Subtítulo (resuelto por el consumer). Fallback al namespace propio. */\n  @Input() subtitle = '';\n  /** Cuerpo en párrafos separados por doble salto de línea (resuelto por el consumer). */\n  @Input() body = '';\n  /** Label del botón cerrar (resuelto por el consumer). Fallback al namespace propio. */\n  @Input() closeLabel = '';\n\n  /**\n   * Muestra las 3 feature-cards de organizaciones (colaboración / cambio rápido /\n   * invitaciones). `false` → sheet article-style (solo título + subtítulo + cuerpo),\n   * reusable como explainer genérico (ej. integraciones / API keys). Default `true`.\n   */\n  @Input() showFeatures = true;\n\n  /** Props del botón cerrar del footer (el consumer puede pasar custom). */\n  @Input() closeProps: Partial<ButtonMetadata> = {\n    text: 'Cerrar',\n    fill: 'outline',\n    color: 'dark',\n    size: 'default',\n    expand: 'block',\n    type: 'button',\n  };\n\n  /** Inyectado por `ModalService.open` — referencia para cerrar desde dentro. */\n  @Input() _modalRef?: { dismiss: (data?: unknown, role?: string) => void };\n\n  constructor() {\n    addIcons({ peopleOutline, swapHorizontalOutline, mailOutline });\n    if (!this.i18n.hasNamespace(DEFAULT_NAMESPACE)) {\n      this.i18n.registerContent(DEFAULT_NAMESPACE, ORG_INFO_SHEET_I18N);\n    }\n  }\n\n  readonly resolvedTitle = computed(() => this.title || this.tt('title'));\n  readonly resolvedSubtitle = computed(() => this.subtitle || this.tt('subtitle'));\n  readonly resolvedCloseLabel = computed(() => this.closeLabel || this.tt('close'));\n\n  readonly paragraphs = computed<string[]>(() => this.body.split('\\n\\n').filter(Boolean));\n\n  readonly resolvedCloseProps = computed<Partial<ButtonMetadata>>(() => ({\n    ...this.closeProps,\n    text: this.closeProps.text || this.resolvedCloseLabel(),\n  }));\n\n  dismiss(): void {\n    this._modalRef?.dismiss(null, 'cancel');\n  }\n\n  protected tt(key: string): string {\n    return this.i18n.t(key, DEFAULT_NAMESPACE);\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"org-info-sheet.component.js","sourceRoot":"","sources":["../../../../../../../src/lib/components/organisms/org-info-sheet/org-info-sheet.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, computed, inject, Input } from '@angular/core';\nimport { IonButton, IonButtons, IonContent, IonHeader, IonIcon, IonToolbar } from '@ionic/angular/standalone';\nimport { addIcons } from 'ionicons';\nimport { mailOutline, peopleOutline, swapHorizontalOutline } 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 { TitleComponent } from '../../atoms/title/title.component';\nimport { ButtonMetadata } from '../../types';\n\nimport { I18nService } from '../../../services/i18n';\n\nimport { ORG_INFO_SHEET_I18N } from './org-info-sheet.i18n';\n\nconst DEFAULT_NAMESPACE = 'OrgInfoSheet';\n\n/**\n * `val-org-info-sheet` — sheet informativo \"¿Qué son las organizaciones?\".\n * Extraído del `OrgInfoSheetComponent` inline de `AccountPage` bajo el proceso de\n * ADR-021.\n *\n * El consumer pasa `title`/`subtitle`/`body`/`closeLabel` ya resueltos por props\n * (patrón del resto de modales del factory). Los textos de los 3 features\n * (Colaboración / Cambio rápido / Invitaciones), que en la versión inline estaban\n * hardcoded, ahora se auto-resuelven desde el namespace `OrgInfoSheet`\n * (auto-registrado en el constructor).\n *\n * Abierto vía `ModalService` — recibe `_modalRef` por `componentProps`. Header\n * canónico (Regla #5): sin `ion-title`, botón Cerrar texto en `slot=end`,\n * título/subtítulo en el body con `val-display`/`val-title`.\n */\n@Component({\n  selector: 'val-org-info-sheet',\n  standalone: true,\n  imports: [\n    IonHeader,\n    IonToolbar,\n    IonButtons,\n    IonButton,\n    IonContent,\n    IonIcon,\n    ButtonComponent,\n    DisplayComponent,\n    TextComponent,\n    TitleComponent,\n  ],\n  template: `\n    <ion-header>\n      <ion-toolbar>\n        <ion-buttons slot=\"end\">\n          <ion-button fill=\"clear\" color=\"dark\" (click)=\"dismiss()\">\n            <strong>{{ resolvedCloseLabel() }}</strong>\n          </ion-button>\n        </ion-buttons>\n      </ion-toolbar>\n    </ion-header>\n\n    <ion-content class=\"ion-padding\">\n      <val-display [props]=\"{ content: resolvedTitle(), size: 'small', color: 'dark' }\" />\n      <val-title [props]=\"{ content: resolvedSubtitle(), size: 'large', color: '', bold: false }\" />\n\n      @if (showFeatures) {\n        <div class=\"info-features\">\n          <div class=\"info-feature\">\n            <ion-icon name=\"people-outline\" class=\"info-feature__icon\" />\n            <div>\n              <div class=\"info-feature__title\">{{ tt('featureCollabTitle') }}</div>\n              <div class=\"info-feature__desc\">{{ tt('featureCollabDesc') }}</div>\n            </div>\n          </div>\n          <div class=\"info-feature\">\n            <ion-icon name=\"swap-horizontal-outline\" class=\"info-feature__icon\" />\n            <div>\n              <div class=\"info-feature__title\">{{ tt('featureSwitchTitle') }}</div>\n              <div class=\"info-feature__desc\">{{ tt('featureSwitchDesc') }}</div>\n            </div>\n          </div>\n          <div class=\"info-feature\">\n            <ion-icon name=\"mail-outline\" class=\"info-feature__icon\" />\n            <div>\n              <div class=\"info-feature__title\">{{ tt('featureInviteTitle') }}</div>\n              <div class=\"info-feature__desc\">{{ tt('featureInviteDesc') }}</div>\n            </div>\n          </div>\n        </div>\n      }\n\n      @for (para of paragraphs(); track $index) {\n        <val-text\n          [props]=\"{\n            size: 'medium',\n            color: 'dark',\n            bold: false,\n            content: para,\n          }\"\n        />\n      }\n\n      <div class=\"sheet-footer\">\n        <val-button [props]=\"resolvedCloseProps()\" (click)=\"dismiss()\" />\n      </div>\n    </ion-content>\n  `,\n  styles: [\n    `\n      ion-content {\n        /* Padding generoso para llegar al fondo: el sheet scrollea en su\n           breakpoint máximo, y el botón de cierre del footer debe quedar por\n           encima del safe-area / cualquier overlay flotante. */\n        --padding-bottom: calc(96px + env(safe-area-inset-bottom, 0px));\n      }\n      val-display {\n        margin-bottom: 4px;\n        display: block;\n      }\n      val-title {\n        margin-bottom: 8px;\n        display: block;\n      }\n      .info-features {\n        display: flex;\n        flex-direction: column;\n        gap: 12px;\n        margin: 16px 0;\n      }\n      .info-feature {\n        display: flex;\n        align-items: flex-start;\n        gap: 14px;\n        padding: 12px 14px;\n        border-radius: 10px;\n        background: var(--ion-color-light, #f4f5f8);\n      }\n      :host-context(body.dark) .info-feature,\n      :host-context(html.ion-palette-dark) .info-feature,\n      :host-context([data-theme='dark']) .info-feature {\n        background: rgba(255, 255, 255, 0.05);\n      }\n      .info-feature__icon {\n        font-size: 22px;\n        color: var(--ion-color-primary);\n        flex-shrink: 0;\n        margin-top: 2px;\n      }\n      .info-feature__title {\n        font-weight: 600;\n        font-size: 0.9rem;\n        color: var(--ion-color-dark);\n      }\n      .info-feature__desc {\n        font-size: 0.82rem;\n        color: var(--ion-color-medium);\n        margin-top: 2px;\n      }\n      .sheet-footer {\n        margin-top: 20px;\n      }\n    `,\n  ],\n})\nexport class OrgInfoSheetComponent {\n  private i18n = inject(I18nService);\n\n  /** Título principal (resuelto por el consumer). Fallback al namespace propio. */\n  @Input() title = '';\n  /** Subtítulo (resuelto por el consumer). Fallback al namespace propio. */\n  @Input() subtitle = '';\n  /** Cuerpo en párrafos separados por doble salto de línea (resuelto por el consumer). */\n  @Input() body = '';\n  /** Label del botón cerrar (resuelto por el consumer). Fallback al namespace propio. */\n  @Input() closeLabel = '';\n\n  /**\n   * Muestra las 3 feature-cards de organizaciones (colaboración / cambio rápido /\n   * invitaciones). `false` → sheet article-style (solo título + subtítulo + cuerpo),\n   * reusable como explainer genérico (ej. integraciones / API keys). Default `true`.\n   */\n  @Input() showFeatures = true;\n\n  /** Props del botón cerrar del footer (el consumer puede pasar custom). */\n  @Input() closeProps: Partial<ButtonMetadata> = {\n    text: 'Cerrar',\n    fill: 'outline',\n    color: 'dark',\n    size: 'default',\n    expand: 'block',\n    type: 'button',\n  };\n\n  /** Inyectado por `ModalService.open` — referencia para cerrar desde dentro. */\n  @Input() _modalRef?: { dismiss: (data?: unknown, role?: string) => void };\n\n  constructor() {\n    addIcons({ peopleOutline, swapHorizontalOutline, mailOutline });\n    if (!this.i18n.hasNamespace(DEFAULT_NAMESPACE)) {\n      this.i18n.registerContent(DEFAULT_NAMESPACE, ORG_INFO_SHEET_I18N);\n    }\n  }\n\n  readonly resolvedTitle = computed(() => this.title || this.tt('title'));\n  readonly resolvedSubtitle = computed(() => this.subtitle || this.tt('subtitle'));\n  readonly resolvedCloseLabel = computed(() => this.closeLabel || this.tt('close'));\n\n  readonly paragraphs = computed<string[]>(() => this.body.split('\\n\\n').filter(Boolean));\n\n  readonly resolvedCloseProps = computed<Partial<ButtonMetadata>>(() => ({\n    ...this.closeProps,\n    text: this.closeProps.text || this.resolvedCloseLabel(),\n  }));\n\n  dismiss(): void {\n    this._modalRef?.dismiss(null, 'cancel');\n  }\n\n  protected tt(key: string): string {\n    return this.i18n.t(key, DEFAULT_NAMESPACE);\n  }\n}\n"]}