valtech-components 2.0.1009 → 2.0.1011

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

@@ -0,0 +1,385 @@
+import { Component, inject, Input, signal } from '@angular/core';
+import { FormsModule } from '@angular/forms';
+import { IonButton, IonButtons, IonCheckbox, IonContent, IonHeader, IonInput, IonSpinner, IonToolbar, } from '@ionic/angular/standalone';
+import { DisplayComponent } from '../../atoms/display/display.component';
+import { TextComponent } from '../../atoms/text/text.component';
+import { TitleComponent } from '../../atoms/title/title.component';
+import { I18nService } from '../../../services/i18n';
+import { ApiKeyService } from '../../../services/apikeys/api-keys.service';
+import { API_KEYS_MODAL_I18N } from './api-keys-modal.i18n';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/forms";
+const DEFAULT_NAMESPACE = 'Settings.ApiKeysModal';
+/**
+ * `val-api-keys-modal` — gestión de Client API Keys org-scopeadas (ADR-023 fase 6).
+ *
+ * Lista las keys de la org, permite crear (mostrando el secreto UNA vez con copia)
+ * y revocar. Pensado para habilitar integraciones M2M del import de miembros, pero
+ * sirve a cualquier permiso del catálogo. Header canónico (Regla #5).
+ */
+export class ApiKeysModalComponent {
+    constructor() {
+        this.i18n = inject(I18nService);
+        this.apiKeys = inject(ApiKeyService);
+        /** Namespace i18n. */
+        this.i18nNamespace = DEFAULT_NAMESPACE;
+        this.keys = signal([]);
+        this.availablePermissions = signal([]);
+        this.loading = signal(true);
+        this.showCreate = signal(false);
+        this.submitting = signal(false);
+        this.errorMsg = signal('');
+        this.secret = signal(null);
+        this.copied = signal(false);
+        this.name = '';
+        this.expiresInDays = null;
+        this.selectedPerms = signal(new Set());
+        if (!this.i18n.hasNamespace(DEFAULT_NAMESPACE)) {
+            this.i18n.registerContent(DEFAULT_NAMESPACE, API_KEYS_MODAL_I18N);
+        }
+    }
+    ngOnInit() {
+        if (!this.i18n.hasNamespace(this.i18nNamespace)) {
+            this.i18n.registerContent(this.i18nNamespace, API_KEYS_MODAL_I18N);
+        }
+        this.refresh();
+        this.apiKeys.availablePermissions().subscribe({
+            next: perms => this.availablePermissions.set(perms),
+            error: () => { },
+        });
+    }
+    refresh() {
+        this.loading.set(true);
+        this.apiKeys.list().subscribe({
+            next: keys => {
+                this.keys.set(keys);
+                this.loading.set(false);
+            },
+            error: () => this.loading.set(false),
+        });
+    }
+    openCreate() {
+        this.errorMsg.set('');
+        this.name = '';
+        this.expiresInDays = null;
+        this.selectedPerms.set(new Set());
+        this.showCreate.set(true);
+    }
+    togglePerm(perm, ev) {
+        const checked = ev.detail?.checked ?? false;
+        const next = new Set(this.selectedPerms());
+        if (checked) {
+            next.add(perm);
+        }
+        else {
+            next.delete(perm);
+        }
+        this.selectedPerms.set(next);
+    }
+    submit() {
+        this.errorMsg.set('');
+        if (!this.name.trim()) {
+            this.errorMsg.set(this.t('noName'));
+            return;
+        }
+        const permissions = Array.from(this.selectedPerms());
+        if (permissions.length === 0) {
+            this.errorMsg.set(this.t('noPerms'));
+            return;
+        }
+        this.submitting.set(true);
+        this.apiKeys
+            .create({
+            name: this.name.trim(),
+            permissions,
+            expiresInDays: this.expiresInDays && this.expiresInDays > 0 ? this.expiresInDays : undefined,
+        })
+            .subscribe({
+            next: res => {
+                this.submitting.set(false);
+                this.showCreate.set(false);
+                this.secret.set(res.key);
+            },
+            error: err => {
+                this.submitting.set(false);
+                this.errorMsg.set(err?.error?.message ?? this.t('genericError'));
+            },
+        });
+    }
+    revoke(key) {
+        if (!confirm(this.t('revokeConfirm')))
+            return;
+        this.apiKeys.revoke(key.keyId).subscribe({
+            next: () => this.refresh(),
+            error: err => this.errorMsg.set(err?.error?.message ?? this.t('genericError')),
+        });
+    }
+    async copy(secret) {
+        try {
+            await navigator.clipboard.writeText(secret);
+            this.copied.set(true);
+        }
+        catch {
+            // clipboard no disponible — el user puede seleccionar el texto manualmente
+        }
+    }
+    finishSecret() {
+        this.secret.set(null);
+        this.copied.set(false);
+        this.refresh();
+    }
+    dismiss() {
+        this._modalRef?.dismiss(null, 'cancel');
+    }
+    t(key) {
+        return this.i18n.t(key, this.i18nNamespace);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ApiKeysModalComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.14", type: ApiKeysModalComponent, isStandalone: true, selector: "val-api-keys-modal", inputs: { _modalRef: "_modalRef", i18nNamespace: "i18nNamespace" }, ngImport: i0, template: `
+    <ion-header>
+      <ion-toolbar>
+        <ion-buttons slot="end">
+          <ion-button fill="clear" color="dark" (click)="dismiss()">
+            <strong>{{ t('close') }}</strong>
+          </ion-button>
+        </ion-buttons>
+      </ion-toolbar>
+    </ion-header>
+
+    <ion-content class="ion-padding">
+      <val-display [props]="{ content: t('title'), size: 'small', color: 'dark' }" />
+      <val-title [props]="{ content: t('hint'), size: 'large', color: '', bold: false }" />
+
+      @if (secret(); as s) {
+        <!-- Secreto recién creado: mostrar UNA vez -->
+        <div class="apikey-secret">
+          <val-title [props]="{ content: t('secretTitle'), size: 'large', color: '', bold: true }" />
+          <p class="apikey-secret__warn">{{ t('secretWarning') }}</p>
+          <div class="apikey-secret__box">
+            <code>{{ s.secret }}</code>
+          </div>
+          <div class="apikey-actions">
+            <ion-button expand="block" color="dark" (click)="copy(s.secret)">
+              {{ copied() ? t('copied') : t('copy') }}
+            </ion-button>
+            <ion-button expand="block" fill="outline" color="dark" (click)="finishSecret()">
+              {{ t('done') }}
+            </ion-button>
+          </div>
+        </div>
+      } @else {
+        @if (loading()) {
+          <ion-spinner name="dots" />
+        } @else {
+          <!-- Lista -->
+          @if (keys().length === 0) {
+            <val-text [props]="{ content: t('empty'), size: 'medium', color: 'medium', bold: false }" />
+          } @else {
+            <div class="apikey-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 }} {{ t('permsCount') }} · {{ t('lastUsed') }}:
+                      {{ k.lastUsedAt || t('never') }}
+                    </span>
+                  </div>
+                  <ion-button fill="clear" color="danger" size="small" (click)="revoke(k)">
+                    {{ t('revoke') }}
+                  </ion-button>
+                </div>
+              }
+            </div>
+          }
+
+          @if (errorMsg()) {
+            <p class="apikey-error">{{ errorMsg() }}</p>
+          }
+
+          <!-- Crear -->
+          @if (showCreate()) {
+            <div class="apikey-create">
+              <ion-input
+                label="{{ t('nameLabel') }}"
+                labelPlacement="stacked"
+                [placeholder]="t('namePlaceholder')"
+                [(ngModel)]="name"
+              />
+              <p class="apikey-create__label">{{ t('permissionsLabel') }}</p>
+              <div class="apikey-perms">
+                @for (p of availablePermissions(); track p) {
+                  <ion-checkbox
+                    labelPlacement="end"
+                    [checked]="selectedPerms().has(p)"
+                    (ionChange)="togglePerm(p, $event)"
+                  >
+                    {{ p }}
+                  </ion-checkbox>
+                }
+              </div>
+              <ion-input
+                label="{{ t('expiresLabel') }}"
+                labelPlacement="stacked"
+                type="number"
+                [(ngModel)]="expiresInDays"
+              />
+              <div class="apikey-actions">
+                <ion-button expand="block" color="dark" [disabled]="submitting()" (click)="submit()">
+                  @if (submitting()) {
+                    <ion-spinner name="dots" />&nbsp;{{ t('creating') }}
+                  } @else {
+                    {{ t('create') }}
+                  }
+                </ion-button>
+                <ion-button expand="block" fill="clear" color="medium" (click)="showCreate.set(false)">
+                  {{ t('cancel') }}
+                </ion-button>
+              </div>
+            </div>
+          } @else {
+            <div class="apikey-actions">
+              <ion-button expand="block" color="primary" (click)="openCreate()">
+                {{ t('newKey') }}
+              </ion-button>
+            </div>
+          }
+        }
+      }
+    </ion-content>
+  `, isInline: true, styles: ["val-display{display:block;margin-bottom:4px}val-title{display:block;margin-bottom:12px}.apikey-list{display:flex;flex-direction:column;gap:8px;margin-bottom:16px}.apikey-row{display:flex;align-items:center;justify-content:space-between;padding:12px;border-radius:10px;border:1.5px solid var(--ion-color-light)}.apikey-row__main{display:flex;flex-direction:column}.apikey-row__name{font-weight:600;color:var(--ion-color-dark)}.apikey-row__meta{font-size:12px;color:var(--ion-color-medium-shade, #6b6e76)}.apikey-create{margin-top:8px;padding:16px;border-radius:12px;background:var(--ion-color-light)}.apikey-create__label{margin:12px 0 4px;font-size:13px;font-weight:600;color:var(--ion-color-dark)}.apikey-perms{display:flex;flex-direction:column;gap:6px;margin-bottom:12px;font-size:13px}.apikey-actions{margin-top:16px;display:flex;flex-direction:column;gap:8px}.apikey-error{margin:8px 0;font-size:.875rem;color:var(--ion-color-danger, #c0392b)}.apikey-secret__warn{font-size:.875rem;color:var(--ion-color-warning-shade, #b88600);margin:0 0 12px}.apikey-secret__box{padding:12px;border-radius:8px;background:var(--ion-color-dark);color:#fff;word-break:break-all;font-family:monospace;font-size:13px}\n"], dependencies: [{ kind: "ngmodule", type: FormsModule }, { kind: "directive", type: i1.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i1.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { 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: IonInput, selector: "ion-input", inputs: ["accept", "autocapitalize", "autocomplete", "autocorrect", "autofocus", "clearInput", "clearOnEdit", "color", "counter", "counterFormatter", "debounce", "disabled", "enterkeyhint", "errorText", "fill", "helperText", "inputmode", "label", "labelPlacement", "max", "maxlength", "min", "minlength", "mode", "multiple", "name", "pattern", "placeholder", "readonly", "required", "shape", "size", "spellcheck", "step", "type", "value"] }, { kind: "component", type: IonCheckbox, selector: "ion-checkbox", inputs: ["checked", "color", "disabled", "errorText", "helperText", "indeterminate", "justify", "labelPlacement", "mode", "name", "value"] }, { kind: "component", type: IonSpinner, selector: "ion-spinner", inputs: ["color", "duration", "name", "paused"] }, { 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: ApiKeysModalComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'val-api-keys-modal', standalone: true, imports: [
+                        FormsModule,
+                        IonHeader,
+                        IonToolbar,
+                        IonButtons,
+                        IonButton,
+                        IonContent,
+                        IonInput,
+                        IonCheckbox,
+                        IonSpinner,
+                        DisplayComponent,
+                        TextComponent,
+                        TitleComponent,
+                    ], template: `
+    <ion-header>
+      <ion-toolbar>
+        <ion-buttons slot="end">
+          <ion-button fill="clear" color="dark" (click)="dismiss()">
+            <strong>{{ t('close') }}</strong>
+          </ion-button>
+        </ion-buttons>
+      </ion-toolbar>
+    </ion-header>
+
+    <ion-content class="ion-padding">
+      <val-display [props]="{ content: t('title'), size: 'small', color: 'dark' }" />
+      <val-title [props]="{ content: t('hint'), size: 'large', color: '', bold: false }" />
+
+      @if (secret(); as s) {
+        <!-- Secreto recién creado: mostrar UNA vez -->
+        <div class="apikey-secret">
+          <val-title [props]="{ content: t('secretTitle'), size: 'large', color: '', bold: true }" />
+          <p class="apikey-secret__warn">{{ t('secretWarning') }}</p>
+          <div class="apikey-secret__box">
+            <code>{{ s.secret }}</code>
+          </div>
+          <div class="apikey-actions">
+            <ion-button expand="block" color="dark" (click)="copy(s.secret)">
+              {{ copied() ? t('copied') : t('copy') }}
+            </ion-button>
+            <ion-button expand="block" fill="outline" color="dark" (click)="finishSecret()">
+              {{ t('done') }}
+            </ion-button>
+          </div>
+        </div>
+      } @else {
+        @if (loading()) {
+          <ion-spinner name="dots" />
+        } @else {
+          <!-- Lista -->
+          @if (keys().length === 0) {
+            <val-text [props]="{ content: t('empty'), size: 'medium', color: 'medium', bold: false }" />
+          } @else {
+            <div class="apikey-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 }} {{ t('permsCount') }} · {{ t('lastUsed') }}:
+                      {{ k.lastUsedAt || t('never') }}
+                    </span>
+                  </div>
+                  <ion-button fill="clear" color="danger" size="small" (click)="revoke(k)">
+                    {{ t('revoke') }}
+                  </ion-button>
+                </div>
+              }
+            </div>
+          }
+
+          @if (errorMsg()) {
+            <p class="apikey-error">{{ errorMsg() }}</p>
+          }
+
+          <!-- Crear -->
+          @if (showCreate()) {
+            <div class="apikey-create">
+              <ion-input
+                label="{{ t('nameLabel') }}"
+                labelPlacement="stacked"
+                [placeholder]="t('namePlaceholder')"
+                [(ngModel)]="name"
+              />
+              <p class="apikey-create__label">{{ t('permissionsLabel') }}</p>
+              <div class="apikey-perms">
+                @for (p of availablePermissions(); track p) {
+                  <ion-checkbox
+                    labelPlacement="end"
+                    [checked]="selectedPerms().has(p)"
+                    (ionChange)="togglePerm(p, $event)"
+                  >
+                    {{ p }}
+                  </ion-checkbox>
+                }
+              </div>
+              <ion-input
+                label="{{ t('expiresLabel') }}"
+                labelPlacement="stacked"
+                type="number"
+                [(ngModel)]="expiresInDays"
+              />
+              <div class="apikey-actions">
+                <ion-button expand="block" color="dark" [disabled]="submitting()" (click)="submit()">
+                  @if (submitting()) {
+                    <ion-spinner name="dots" />&nbsp;{{ t('creating') }}
+                  } @else {
+                    {{ t('create') }}
+                  }
+                </ion-button>
+                <ion-button expand="block" fill="clear" color="medium" (click)="showCreate.set(false)">
+                  {{ t('cancel') }}
+                </ion-button>
+              </div>
+            </div>
+          } @else {
+            <div class="apikey-actions">
+              <ion-button expand="block" color="primary" (click)="openCreate()">
+                {{ t('newKey') }}
+              </ion-button>
+            </div>
+          }
+        }
+      }
+    </ion-content>
+  `, styles: ["val-display{display:block;margin-bottom:4px}val-title{display:block;margin-bottom:12px}.apikey-list{display:flex;flex-direction:column;gap:8px;margin-bottom:16px}.apikey-row{display:flex;align-items:center;justify-content:space-between;padding:12px;border-radius:10px;border:1.5px solid var(--ion-color-light)}.apikey-row__main{display:flex;flex-direction:column}.apikey-row__name{font-weight:600;color:var(--ion-color-dark)}.apikey-row__meta{font-size:12px;color:var(--ion-color-medium-shade, #6b6e76)}.apikey-create{margin-top:8px;padding:16px;border-radius:12px;background:var(--ion-color-light)}.apikey-create__label{margin:12px 0 4px;font-size:13px;font-weight:600;color:var(--ion-color-dark)}.apikey-perms{display:flex;flex-direction:column;gap:6px;margin-bottom:12px;font-size:13px}.apikey-actions{margin-top:16px;display:flex;flex-direction:column;gap:8px}.apikey-error{margin:8px 0;font-size:.875rem;color:var(--ion-color-danger, #c0392b)}.apikey-secret__warn{font-size:.875rem;color:var(--ion-color-warning-shade, #b88600);margin:0 0 12px}.apikey-secret__box{padding:12px;border-radius:8px;background:var(--ion-color-dark);color:#fff;word-break:break-all;font-family:monospace;font-size:13px}\n"] }]
+        }], ctorParameters: () => [], propDecorators: { _modalRef: [{
+                type: Input
+            }], i18nNamespace: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api-keys-modal.component.js","sourceRoot":"","sources":["../../../../../../../src/lib/components/organisms/api-keys-modal/api-keys-modal.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, computed, inject, Input, OnInit, signal } from '@angular/core';\nimport { FormsModule } from '@angular/forms';\nimport {\n  IonButton,\n  IonButtons,\n  IonCheckbox,\n  IonContent,\n  IonHeader,\n  IonInput,\n  IonSpinner,\n  IonToolbar,\n} from '@ionic/angular/standalone';\n\nimport { DisplayComponent } from '../../atoms/display/display.component';\nimport { TextComponent } from '../../atoms/text/text.component';\nimport { TitleComponent } from '../../atoms/title/title.component';\n\nimport { I18nService } from '../../../services/i18n';\nimport { ApiKeyService } from '../../../services/apikeys/api-keys.service';\nimport { ClientApiKey, ClientApiKeyWithSecret } from '../../../services/apikeys/types';\n\nimport { API_KEYS_MODAL_I18N } from './api-keys-modal.i18n';\n\nconst DEFAULT_NAMESPACE = 'Settings.ApiKeysModal';\n\n/**\n * `val-api-keys-modal` — gestión de Client API Keys org-scopeadas (ADR-023 fase 6).\n *\n * Lista las keys de la org, permite crear (mostrando el secreto UNA vez con copia)\n * y revocar. Pensado para habilitar integraciones M2M del import de miembros, pero\n * sirve a cualquier permiso del catálogo. Header canónico (Regla #5).\n */\n@Component({\n  selector: 'val-api-keys-modal',\n  standalone: true,\n  imports: [\n    FormsModule,\n    IonHeader,\n    IonToolbar,\n    IonButtons,\n    IonButton,\n    IonContent,\n    IonInput,\n    IonCheckbox,\n    IonSpinner,\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>{{ t('close') }}</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: t('title'), size: 'small', color: 'dark' }\" />\n      <val-title [props]=\"{ content: t('hint'), size: 'large', color: '', bold: false }\" />\n\n      @if (secret(); as s) {\n        <!-- Secreto recién creado: mostrar UNA vez -->\n        <div class=\"apikey-secret\">\n          <val-title [props]=\"{ content: t('secretTitle'), size: 'large', color: '', bold: true }\" />\n          <p class=\"apikey-secret__warn\">{{ t('secretWarning') }}</p>\n          <div class=\"apikey-secret__box\">\n            <code>{{ s.secret }}</code>\n          </div>\n          <div class=\"apikey-actions\">\n            <ion-button expand=\"block\" color=\"dark\" (click)=\"copy(s.secret)\">\n              {{ copied() ? t('copied') : t('copy') }}\n            </ion-button>\n            <ion-button expand=\"block\" fill=\"outline\" color=\"dark\" (click)=\"finishSecret()\">\n              {{ t('done') }}\n            </ion-button>\n          </div>\n        </div>\n      } @else {\n        @if (loading()) {\n          <ion-spinner name=\"dots\" />\n        } @else {\n          <!-- Lista -->\n          @if (keys().length === 0) {\n            <val-text [props]=\"{ content: t('empty'), size: 'medium', color: 'medium', bold: false }\" />\n          } @else {\n            <div class=\"apikey-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 }} {{ t('permsCount') }} · {{ t('lastUsed') }}:\n                      {{ k.lastUsedAt || t('never') }}\n                    </span>\n                  </div>\n                  <ion-button fill=\"clear\" color=\"danger\" size=\"small\" (click)=\"revoke(k)\">\n                    {{ t('revoke') }}\n                  </ion-button>\n                </div>\n              }\n            </div>\n          }\n\n          @if (errorMsg()) {\n            <p class=\"apikey-error\">{{ errorMsg() }}</p>\n          }\n\n          <!-- Crear -->\n          @if (showCreate()) {\n            <div class=\"apikey-create\">\n              <ion-input\n                label=\"{{ t('nameLabel') }}\"\n                labelPlacement=\"stacked\"\n                [placeholder]=\"t('namePlaceholder')\"\n                [(ngModel)]=\"name\"\n              />\n              <p class=\"apikey-create__label\">{{ t('permissionsLabel') }}</p>\n              <div class=\"apikey-perms\">\n                @for (p of availablePermissions(); track p) {\n                  <ion-checkbox\n                    labelPlacement=\"end\"\n                    [checked]=\"selectedPerms().has(p)\"\n                    (ionChange)=\"togglePerm(p, $event)\"\n                  >\n                    {{ p }}\n                  </ion-checkbox>\n                }\n              </div>\n              <ion-input\n                label=\"{{ t('expiresLabel') }}\"\n                labelPlacement=\"stacked\"\n                type=\"number\"\n                [(ngModel)]=\"expiresInDays\"\n              />\n              <div class=\"apikey-actions\">\n                <ion-button expand=\"block\" color=\"dark\" [disabled]=\"submitting()\" (click)=\"submit()\">\n                  @if (submitting()) {\n                    <ion-spinner name=\"dots\" />&nbsp;{{ t('creating') }}\n                  } @else {\n                    {{ t('create') }}\n                  }\n                </ion-button>\n                <ion-button expand=\"block\" fill=\"clear\" color=\"medium\" (click)=\"showCreate.set(false)\">\n                  {{ t('cancel') }}\n                </ion-button>\n              </div>\n            </div>\n          } @else {\n            <div class=\"apikey-actions\">\n              <ion-button expand=\"block\" color=\"primary\" (click)=\"openCreate()\">\n                {{ t('newKey') }}\n              </ion-button>\n            </div>\n          }\n        }\n      }\n    </ion-content>\n  `,\n  styles: [\n    `\n      val-display {\n        display: block;\n        margin-bottom: 4px;\n      }\n      val-title {\n        display: block;\n        margin-bottom: 12px;\n      }\n      .apikey-list {\n        display: flex;\n        flex-direction: column;\n        gap: 8px;\n        margin-bottom: 16px;\n      }\n      .apikey-row {\n        display: flex;\n        align-items: center;\n        justify-content: space-between;\n        padding: 12px;\n        border-radius: 10px;\n        border: 1.5px solid var(--ion-color-light);\n      }\n      .apikey-row__main {\n        display: flex;\n        flex-direction: column;\n      }\n      .apikey-row__name {\n        font-weight: 600;\n        color: var(--ion-color-dark);\n      }\n      .apikey-row__meta {\n        font-size: 12px;\n        color: var(--ion-color-medium-shade, #6b6e76);\n      }\n      .apikey-create {\n        margin-top: 8px;\n        padding: 16px;\n        border-radius: 12px;\n        background: var(--ion-color-light);\n      }\n      .apikey-create__label {\n        margin: 12px 0 4px 0;\n        font-size: 13px;\n        font-weight: 600;\n        color: var(--ion-color-dark);\n      }\n      .apikey-perms {\n        display: flex;\n        flex-direction: column;\n        gap: 6px;\n        margin-bottom: 12px;\n        font-size: 13px;\n      }\n      .apikey-actions {\n        margin-top: 16px;\n        display: flex;\n        flex-direction: column;\n        gap: 8px;\n      }\n      .apikey-error {\n        margin: 8px 0;\n        font-size: 0.875rem;\n        color: var(--ion-color-danger, #c0392b);\n      }\n      .apikey-secret__warn {\n        font-size: 0.875rem;\n        color: var(--ion-color-warning-shade, #b88600);\n        margin: 0 0 12px 0;\n      }\n      .apikey-secret__box {\n        padding: 12px;\n        border-radius: 8px;\n        background: var(--ion-color-dark);\n        color: #fff;\n        word-break: break-all;\n        font-family: monospace;\n        font-size: 13px;\n      }\n    `,\n  ],\n})\nexport class ApiKeysModalComponent implements OnInit {\n  private i18n = inject(I18nService);\n  private apiKeys = inject(ApiKeyService);\n\n  /** Inyectado por `ModalService.open`. */\n  @Input() _modalRef?: { dismiss: (data?: unknown, role?: string) => void };\n\n  /** Namespace i18n. */\n  @Input() i18nNamespace = DEFAULT_NAMESPACE;\n\n  readonly keys = signal<ClientApiKey[]>([]);\n  readonly availablePermissions = signal<string[]>([]);\n  readonly loading = signal(true);\n  readonly showCreate = signal(false);\n  readonly submitting = signal(false);\n  readonly errorMsg = signal('');\n  readonly secret = signal<ClientApiKeyWithSecret | null>(null);\n  readonly copied = signal(false);\n\n  name = '';\n  expiresInDays: number | null = null;\n  readonly selectedPerms = signal<Set<string>>(new Set());\n\n  constructor() {\n    if (!this.i18n.hasNamespace(DEFAULT_NAMESPACE)) {\n      this.i18n.registerContent(DEFAULT_NAMESPACE, API_KEYS_MODAL_I18N);\n    }\n  }\n\n  ngOnInit(): void {\n    if (!this.i18n.hasNamespace(this.i18nNamespace)) {\n      this.i18n.registerContent(this.i18nNamespace, API_KEYS_MODAL_I18N);\n    }\n    this.refresh();\n    this.apiKeys.availablePermissions().subscribe({\n      next: perms => this.availablePermissions.set(perms),\n      error: () => {},\n    });\n  }\n\n  private refresh(): void {\n    this.loading.set(true);\n    this.apiKeys.list().subscribe({\n      next: keys => {\n        this.keys.set(keys);\n        this.loading.set(false);\n      },\n      error: () => this.loading.set(false),\n    });\n  }\n\n  openCreate(): void {\n    this.errorMsg.set('');\n    this.name = '';\n    this.expiresInDays = null;\n    this.selectedPerms.set(new Set());\n    this.showCreate.set(true);\n  }\n\n  togglePerm(perm: string, ev: Event): void {\n    const checked = (ev as CustomEvent).detail?.checked ?? false;\n    const next = new Set(this.selectedPerms());\n    if (checked) {\n      next.add(perm);\n    } else {\n      next.delete(perm);\n    }\n    this.selectedPerms.set(next);\n  }\n\n  submit(): void {\n    this.errorMsg.set('');\n    if (!this.name.trim()) {\n      this.errorMsg.set(this.t('noName'));\n      return;\n    }\n    const permissions = Array.from(this.selectedPerms());\n    if (permissions.length === 0) {\n      this.errorMsg.set(this.t('noPerms'));\n      return;\n    }\n\n    this.submitting.set(true);\n    this.apiKeys\n      .create({\n        name: this.name.trim(),\n        permissions,\n        expiresInDays: this.expiresInDays && this.expiresInDays > 0 ? this.expiresInDays : undefined,\n      })\n      .subscribe({\n        next: res => {\n          this.submitting.set(false);\n          this.showCreate.set(false);\n          this.secret.set(res.key);\n        },\n        error: err => {\n          this.submitting.set(false);\n          this.errorMsg.set(err?.error?.message ?? this.t('genericError'));\n        },\n      });\n  }\n\n  revoke(key: ClientApiKey): void {\n    if (!confirm(this.t('revokeConfirm'))) return;\n    this.apiKeys.revoke(key.keyId).subscribe({\n      next: () => this.refresh(),\n      error: err => this.errorMsg.set(err?.error?.message ?? this.t('genericError')),\n    });\n  }\n\n  async copy(secret: string): Promise<void> {\n    try {\n      await navigator.clipboard.writeText(secret);\n      this.copied.set(true);\n    } catch {\n      // clipboard no disponible — el user puede seleccionar el texto manualmente\n    }\n  }\n\n  finishSecret(): void {\n    this.secret.set(null);\n    this.copied.set(false);\n    this.refresh();\n  }\n\n  dismiss(): void {\n    this._modalRef?.dismiss(null, 'cancel');\n  }\n\n  t(key: string): string {\n    return this.i18n.t(key, this.i18nNamespace);\n  }\n}\n"]}

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

@@ -0,0 +1,63 @@
+/**
+ * Defaults i18n (es/en) embebidos en `val-api-keys-modal` (ADR-023).
+ * Auto-registrados si el consumer no proveyó el namespace `Settings.ApiKeysModal`.
+ */
+export const API_KEYS_MODAL_I18N = {
+    es: {
+        title: 'Client API Keys',
+        hint: 'Llaves M2M org-scopeadas para integraciones (p. ej. importar miembros).',
+        empty: 'Aún no hay API keys en esta organización.',
+        newKey: 'Nueva API key',
+        nameLabel: 'Nombre',
+        namePlaceholder: 'Ej: Integración RRHH',
+        permissionsLabel: 'Permisos',
+        expiresLabel: 'Expira en (días, opcional)',
+        create: 'Crear key',
+        creating: 'Creando...',
+        cancel: 'Cancelar',
+        revoke: 'Revocar',
+        revokeConfirm: '¿Revocar esta API key? Las integraciones que la usen dejarán de funcionar.',
+        secretTitle: 'Copia tu API key ahora',
+        secretWarning: 'Este secreto se muestra una sola vez. Guárdalo en un lugar seguro.',
+        copy: 'Copiar',
+        copied: 'Copiada',
+        done: 'Listo',
+        statusActive: 'activa',
+        lastUsed: 'Último uso',
+        never: 'nunca',
+        permsCount: 'permisos',
+        noName: 'El nombre es obligatorio.',
+        noPerms: 'Selecciona al menos un permiso.',
+        close: 'Cerrar',
+        genericError: 'No se pudo completar la operación. Intenta de nuevo.',
+    },
+    en: {
+        title: 'Client API Keys',
+        hint: 'Org-scoped M2M keys for integrations (e.g. member import).',
+        empty: 'No API keys in this organization yet.',
+        newKey: 'New API key',
+        nameLabel: 'Name',
+        namePlaceholder: 'E.g: HR integration',
+        permissionsLabel: 'Permissions',
+        expiresLabel: 'Expires in (days, optional)',
+        create: 'Create key',
+        creating: 'Creating...',
+        cancel: 'Cancel',
+        revoke: 'Revoke',
+        revokeConfirm: 'Revoke this API key? Integrations using it will stop working.',
+        secretTitle: 'Copy your API key now',
+        secretWarning: 'This secret is shown only once. Store it somewhere safe.',
+        copy: 'Copy',
+        copied: 'Copied',
+        done: 'Done',
+        statusActive: 'active',
+        lastUsed: 'Last used',
+        never: 'never',
+        permsCount: 'permissions',
+        noName: 'Name is required.',
+        noPerms: 'Select at least one permission.',
+        close: 'Close',
+        genericError: "Couldn't complete the operation. Try again.",
+    },
+};
+//# sourceMappingURL=data:application/json;base64,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