valtech-components 2.0.985 → 2.0.986

package/esm2022/lib/components/organisms/delete-account-modal/delete-account-modal.component.mjs

@@ -0,0 +1,272 @@
+import { Component, computed, inject, Input, signal } from '@angular/core';
+import { Validators } from '@angular/forms';
+import { IonButton, IonButtons, IonContent, IonHeader, IonSpinner, IonToolbar } from '@ionic/angular/standalone';
+import { firstValueFrom } from 'rxjs';
+import { FormComponent } from '../form/form.component';
+import { ComponentStates, InputType } from '../../types';
+import { AuthService } from '../../../services/auth/auth.service';
+import { I18nService } from '../../../services/i18n';
+import { ToastService } from '../../../services/toast.service';
+import { ValtechErrorService } from '../../../services/errors/valtech-error.service';
+import { DELETE_ACCOUNT_MODAL_I18N } from './delete-account-modal.i18n';
+import * as i0 from "@angular/core";
+const DEFAULT_NAMESPACE = 'Settings.DeleteAccount';
+/**
+ * `val-delete-account-modal` — modal de eliminación de cuenta (organism,
+ * cuenta-específico). Promovido desde `showcase` bajo el proceso de ADR-021.
+ *
+ * Decide el flujo según si la cuenta tiene contraseña:
+ *  - **con password** → pide la contraseña actual y la verifica vía
+ *    `auth.deleteAccount({ password })`.
+ *  - **sin password** (cuenta OAuth) → envía un código por email
+ *    (`auth.sendDeleteAccountCode()`) y lo pide para confirmar
+ *    (`auth.deleteAccount({ code })`).
+ *
+ * Abierto vía `ModalService` — recibe `_modalRef` por `componentProps` para
+ * cerrar desde dentro. Header canónico (Regla #5): sin `ion-title`, botón Cerrar
+ * texto en `slot=end`, título/subtítulo en el body vía `val-form`.
+ *
+ * Auto-registra sus defaults i18n (es/en) en el constructor si el consumer no
+ * proveyó el namespace `Settings.DeleteAccount`.
+ */
+export class DeleteAccountModalComponent {
+    constructor() {
+        this.auth = inject(AuthService);
+        this.errors = inject(ValtechErrorService);
+        this.i18n = inject(I18nService);
+        this.toast = inject(ToastService);
+        /** Namespace i18n con que la vista resuelve sus textos. */
+        this.i18nNamespace = DEFAULT_NAMESPACE;
+        this.hasPassword = signal(null);
+        this.codeSent = signal(false);
+        this.formState = signal(ComponentStates.ENABLED);
+        this.t = (key) => this.i18n.t(key, this.i18nNamespace);
+        this.passwordFormProps = computed(() => ({
+            name: this.t('title'),
+            state: this.formState(),
+            sections: [
+                {
+                    name: this.t('warningPassword'),
+                    order: 0,
+                    fields: [
+                        {
+                            token: 'delete-password',
+                            name: 'password',
+                            label: this.t('passwordLabel'),
+                            hint: '',
+                            placeholder: this.t('passwordPlaceholder'),
+                            type: InputType.PASSWORD,
+                            order: 0,
+                            validators: [Validators.required],
+                            errors: { required: this.t('passwordRequired') },
+                            state: ComponentStates.ENABLED,
+                        },
+                    ],
+                },
+            ],
+            actions: this.submitBtn('delete-password-submit', 'confirmCta'),
+        }));
+        this.sendCodeFormProps = computed(() => ({
+            name: this.t('title'),
+            state: this.formState(),
+            sections: [
+                {
+                    name: this.t('warningSendCode'),
+                    order: 0,
+                    fields: [],
+                },
+            ],
+            actions: this.submitBtn('delete-send-code-submit', 'sendCodeCta'),
+        }));
+        this.codeFormProps = computed(() => ({
+            name: this.t('title'),
+            state: this.formState(),
+            sections: [
+                {
+                    name: this.t('warningEnterCode'),
+                    order: 0,
+                    fields: [
+                        {
+                            token: 'delete-code',
+                            name: 'code',
+                            label: this.t('codeLabel'),
+                            hint: '',
+                            placeholder: this.t('codePlaceholder'),
+                            type: InputType.TEXT,
+                            order: 0,
+                            validators: [Validators.required],
+                            errors: { required: this.t('codeRequired') },
+                            state: ComponentStates.ENABLED,
+                        },
+                    ],
+                },
+            ],
+            actions: this.submitBtn('delete-code-submit', 'confirmCta'),
+        }));
+        if (!this.i18n.hasNamespace(DEFAULT_NAMESPACE)) {
+            this.i18n.registerContent(DEFAULT_NAMESPACE, DELETE_ACCOUNT_MODAL_I18N);
+        }
+    }
+    ngOnInit() {
+        firstValueFrom(this.auth.getProfile())
+            .then(profile => this.hasPassword.set(profile.hasPassword ?? true))
+            .catch(() => this.hasPassword.set(true));
+    }
+    submitBtn(token, textKey) {
+        return {
+            text: this.t(textKey),
+            type: 'submit',
+            expand: 'block',
+            fill: 'solid',
+            color: 'dark',
+            size: 'default',
+            token,
+            state: ComponentStates.ENABLED,
+        };
+    }
+    close() {
+        this._modalRef?.dismiss(undefined, 'cancel');
+    }
+    async onPasswordSubmit(event) {
+        const password = event.fields['password'];
+        if (!password) {
+            this.toast.show({
+                message: this.t('passwordRequired'),
+                duration: 3000,
+                color: 'dark',
+                position: 'top',
+            });
+            return;
+        }
+        this.formState.set(ComponentStates.WORKING);
+        try {
+            await firstValueFrom(this.auth.deleteAccount({ password }));
+        }
+        catch (err) {
+            this.errors.handle(err, { context: 'delete-account.password' });
+            this.formState.set(ComponentStates.ENABLED);
+        }
+    }
+    async onSendCode() {
+        this.formState.set(ComponentStates.WORKING);
+        try {
+            await firstValueFrom(this.auth.sendDeleteAccountCode());
+            this.codeSent.set(true);
+        }
+        catch (err) {
+            this.errors.handle(err, { context: 'delete-account.send-code' });
+        }
+        finally {
+            this.formState.set(ComponentStates.ENABLED);
+        }
+    }
+    async onResendCode() {
+        this.codeSent.set(false);
+        await this.onSendCode();
+    }
+    async onCodeSubmit(event) {
+        const code = event.fields['code'];
+        if (!code) {
+            this.toast.show({
+                message: this.t('codeRequired'),
+                duration: 3000,
+                color: 'dark',
+                position: 'top',
+            });
+            return;
+        }
+        this.formState.set(ComponentStates.WORKING);
+        try {
+            await firstValueFrom(this.auth.deleteAccount({ code }));
+        }
+        catch (err) {
+            this.errors.handle(err, { context: 'delete-account.code' });
+            this.formState.set(ComponentStates.ENABLED);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DeleteAccountModalComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.14", type: DeleteAccountModalComponent, isStandalone: true, selector: "val-delete-account-modal", inputs: { _modalRef: "_modalRef", i18nNamespace: "i18nNamespace" }, ngImport: i0, template: `
+    <ion-header>
+      <ion-toolbar>
+        <ion-buttons slot="end">
+          <ion-button fill="clear" color="dark" (click)="close()">
+            <strong>{{ t('close') }}</strong>
+          </ion-button>
+        </ion-buttons>
+      </ion-toolbar>
+    </ion-header>
+
+    <ion-content class="ion-padding">
+      <section class="modal-form-section">
+        @if (hasPassword() === null) {
+          <div class="spinner-center">
+            <ion-spinner name="crescent" />
+          </div>
+        } @else if (hasPassword()) {
+          <val-form [props]="passwordFormProps()" (onSubmit)="onPasswordSubmit($event)" />
+        } @else if (!codeSent()) {
+          <val-form [props]="sendCodeFormProps()" (onSubmit)="onSendCode()" />
+        } @else {
+          <val-form [props]="codeFormProps()" (onSubmit)="onCodeSubmit($event)" />
+          <div class="resend-row">
+            <ion-button
+              fill="clear"
+              color="medium"
+              size="small"
+              [disabled]="formState() === 'WORKING'"
+              (click)="onResendCode()"
+            >
+              {{ t('resend') }}
+            </ion-button>
+          </div>
+        }
+      </section>
+    </ion-content>
+  `, isInline: true, styles: [".modal-form-section{display:flex;flex-direction:column;gap:16px;max-width:420px;margin:0 auto;padding-top:8px}.resend-row{display:flex;justify-content:center;margin-top:-8px}.spinner-center{display:flex;justify-content:center;padding-top:32px}\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: IonSpinner, selector: "ion-spinner", inputs: ["color", "duration", "name", "paused"] }, { kind: "component", type: FormComponent, selector: "val-form", inputs: ["props"], outputs: ["onSubmit", "onInvalid", "onSelectChange"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DeleteAccountModalComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'val-delete-account-modal', standalone: true, imports: [IonHeader, IonToolbar, IonButtons, IonButton, IonContent, IonSpinner, FormComponent], template: `
+    <ion-header>
+      <ion-toolbar>
+        <ion-buttons slot="end">
+          <ion-button fill="clear" color="dark" (click)="close()">
+            <strong>{{ t('close') }}</strong>
+          </ion-button>
+        </ion-buttons>
+      </ion-toolbar>
+    </ion-header>
+
+    <ion-content class="ion-padding">
+      <section class="modal-form-section">
+        @if (hasPassword() === null) {
+          <div class="spinner-center">
+            <ion-spinner name="crescent" />
+          </div>
+        } @else if (hasPassword()) {
+          <val-form [props]="passwordFormProps()" (onSubmit)="onPasswordSubmit($event)" />
+        } @else if (!codeSent()) {
+          <val-form [props]="sendCodeFormProps()" (onSubmit)="onSendCode()" />
+        } @else {
+          <val-form [props]="codeFormProps()" (onSubmit)="onCodeSubmit($event)" />
+          <div class="resend-row">
+            <ion-button
+              fill="clear"
+              color="medium"
+              size="small"
+              [disabled]="formState() === 'WORKING'"
+              (click)="onResendCode()"
+            >
+              {{ t('resend') }}
+            </ion-button>
+          </div>
+        }
+      </section>
+    </ion-content>
+  `, styles: [".modal-form-section{display:flex;flex-direction:column;gap:16px;max-width:420px;margin:0 auto;padding-top:8px}.resend-row{display:flex;justify-content:center;margin-top:-8px}.spinner-center{display:flex;justify-content:center;padding-top:32px}\n"] }]
+        }], ctorParameters: () => [], propDecorators: { _modalRef: [{
+                type: Input
+            }], i18nNamespace: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"delete-account-modal.component.js","sourceRoot":"","sources":["../../../../../../../src/lib/components/organisms/delete-account-modal/delete-account-modal.component.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAU,MAAM,EAAE,MAAM,eAAe,CAAC;AACnF,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAC5C,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,UAAU,EAAE,SAAS,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AACjH,OAAO,EAAE,cAAc,EAAE,MAAM,MAAM,CAAC;AAEtC,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,EAAkB,eAAe,EAA2C,SAAS,EAAE,MAAM,aAAa,CAAC;AAElH,OAAO,EAAE,WAAW,EAAE,MAAM,qCAAqC,CAAC;AAClE,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAC;AAC/D,OAAO,EAAE,mBAAmB,EAAE,MAAM,gDAAgD,CAAC;AAErF,OAAO,EAAE,yBAAyB,EAAE,MAAM,6BAA6B,CAAC;;AAExE,MAAM,iBAAiB,GAAG,wBAAwB,CAAC;AAEnD;;;;;;;;;;;;;;;;;GAiBG;AAkEH,MAAM,OAAO,2BAA2B;IAgBtC;QAfQ,SAAI,GAAG,MAAM,CAAC,WAAW,CAAC,CAAC;QAC3B,WAAM,GAAG,MAAM,CAAC,mBAAmB,CAAC,CAAC;QACrC,SAAI,GAAG,MAAM,CAAC,WAAW,CAAC,CAAC;QAC3B,UAAK,GAAG,MAAM,CAAC,YAAY,CAAC,CAAC;QAKrC,2DAA2D;QAClD,kBAAa,GAAG,iBAAiB,CAAC;QAElC,gBAAW,GAAG,MAAM,CAAiB,IAAI,CAAC,CAAC;QAC3C,aAAQ,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;QACzB,cAAS,GAAG,MAAM,CAAiB,eAAe,CAAC,OAAO,CAAC,CAAC;QAcrE,MAAC,GAAG,CAAC,GAAW,EAAU,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,EAAE,IAAI,CAAC,aAAa,CAAC,CAAC;QAezD,sBAAiB,GAAG,QAAQ,CAAe,GAAG,EAAE,CAAC,CAAC;YACzD,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC,OAAO,CAAC;YACrB,KAAK,EAAE,IAAI,CAAC,SAAS,EAAE;YACvB,QAAQ,EAAE;gBACR;oBACE,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC,iBAAiB,CAAC;oBAC/B,KAAK,EAAE,CAAC;oBACR,MAAM,EAAE;wBACN;4BACE,KAAK,EAAE,iBAAiB;4BACxB,IAAI,EAAE,UAAU;4BAChB,KAAK,EAAE,IAAI,CAAC,CAAC,CAAC,eAAe,CAAC;4BAC9B,IAAI,EAAE,EAAE;4BACR,WAAW,EAAE,IAAI,CAAC,CAAC,CAAC,qBAAqB,CAAC;4BAC1C,IAAI,EAAE,SAAS,CAAC,QAAQ;4BACxB,KAAK,EAAE,CAAC;4BACR,UAAU,EAAE,CAAC,UAAU,CAAC,QAAQ,CAAC;4BACjC,MAAM,EAAE,EAAE,QAAQ,EAAE,IAAI,CAAC,CAAC,CAAC,kBAAkB,CAAC,EAAE;4BAChD,KAAK,EAAE,eAAe,CAAC,OAAO;yBACd;qBACnB;iBACF;aACF;YACD,OAAO,EAAE,IAAI,CAAC,SAAS,CAAC,wBAAwB,EAAE,YAAY,CAAC;SAChE,CAAC,CAAC,CAAC;QAEK,sBAAiB,GAAG,QAAQ,CAAe,GAAG,EAAE,CAAC,CAAC;YACzD,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC,OAAO,CAAC;YACrB,KAAK,EAAE,IAAI,CAAC,SAAS,EAAE;YACvB,QAAQ,EAAE;gBACR;oBACE,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC,iBAAiB,CAAC;oBAC/B,KAAK,EAAE,CAAC;oBACR,MAAM,EAAE,EAAE;iBACX;aACF;YACD,OAAO,EAAE,IAAI,CAAC,SAAS,CAAC,yBAAyB,EAAE,aAAa,CAAC;SAClE,CAAC,CAAC,CAAC;QAEK,kBAAa,GAAG,QAAQ,CAAe,GAAG,EAAE,CAAC,CAAC;YACrD,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC,OAAO,CAAC;YACrB,KAAK,EAAE,IAAI,CAAC,SAAS,EAAE;YACvB,QAAQ,EAAE;gBACR;oBACE,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC,kBAAkB,CAAC;oBAChC,KAAK,EAAE,CAAC;oBACR,MAAM,EAAE;wBACN;4BACE,KAAK,EAAE,aAAa;4BACpB,IAAI,EAAE,MAAM;4BACZ,KAAK,EAAE,IAAI,CAAC,CAAC,CAAC,WAAW,CAAC;4BAC1B,IAAI,EAAE,EAAE;4BACR,WAAW,EAAE,IAAI,CAAC,CAAC,CAAC,iBAAiB,CAAC;4BACtC,IAAI,EAAE,SAAS,CAAC,IAAI;4BACpB,KAAK,EAAE,CAAC;4BACR,UAAU,EAAE,CAAC,UAAU,CAAC,QAAQ,CAAC;4BACjC,MAAM,EAAE,EAAE,QAAQ,EAAE,IAAI,CAAC,CAAC,CAAC,cAAc,CAAC,EAAE;4BAC5C,KAAK,EAAE,eAAe,CAAC,OAAO;yBACd;qBACnB;iBACF;aACF;YACD,OAAO,EAAE,IAAI,CAAC,SAAS,CAAC,oBAAoB,EAAE,YAAY,CAAC;SAC5D,CAAC,CAAC,CAAC;QAzFF,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,iBAAiB,CAAC,EAAE,CAAC;YAC/C,IAAI,CAAC,IAAI,CAAC,eAAe,CAAC,iBAAiB,EAAE,yBAAyB,CAAC,CAAC;QAC1E,CAAC;IACH,CAAC;IAED,QAAQ;QACN,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,CAAC;aACnC,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,OAAO,CAAC,WAAW,IAAI,IAAI,CAAC,CAAC;aAClE,KAAK,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC;IAC7C,CAAC;IAIO,SAAS,CAAC,KAAa,EAAE,OAAe;QAC9C,OAAO;YACL,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC,OAAO,CAAC;YACrB,IAAI,EAAE,QAAiB;YACvB,MAAM,EAAE,OAAgB;YACxB,IAAI,EAAE,OAAgB;YACtB,KAAK,EAAE,MAAM;YACb,IAAI,EAAE,SAAkB;YACxB,KAAK;YACL,KAAK,EAAE,eAAe,CAAC,OAAO;SAC/B,CAAC;IACJ,CAAC;IAmED,KAAK;QACH,IAAI,CAAC,SAAS,EAAE,OAAO,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC;IAC/C,CAAC;IAED,KAAK,CAAC,gBAAgB,CAAC,KAAiB;QACtC,MAAM,QAAQ,GAAG,KAAK,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC;QAC1C,IAAI,CAAC,QAAQ,EAAE,CAAC;YACd,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC;gBACd,OAAO,EAAE,IAAI,CAAC,CAAC,CAAC,kBAAkB,CAAC;gBACnC,QAAQ,EAAE,IAAI;gBACd,KAAK,EAAE,MAAM;gBACb,QAAQ,EAAE,KAAK;aAChB,CAAC,CAAC;YACH,OAAO;QACT,CAAC;QACD,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC;QAC5C,IAAI,CAAC;YACH,MAAM,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,EAAE,QAAQ,EAAE,CAAC,CAAC,CAAC;QAC9D,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,EAAE,OAAO,EAAE,yBAAyB,EAAE,CAAC,CAAC;YAChE,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC;QAC9C,CAAC;IACH,CAAC;IAED,KAAK,CAAC,UAAU;QACd,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC;QAC5C,IAAI,CAAC;YACH,MAAM,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,qBAAqB,EAAE,CAAC,CAAC;YACxD,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QAC1B,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,EAAE,OAAO,EAAE,0BAA0B,EAAE,CAAC,CAAC;QACnE,CAAC;gBAAS,CAAC;YACT,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC;QAC9C,CAAC;IACH,CAAC;IAED,KAAK,CAAC,YAAY;QAChB,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;QACzB,MAAM,IAAI,CAAC,UAAU,EAAE,CAAC;IAC1B,CAAC;IAED,KAAK,CAAC,YAAY,CAAC,KAAiB;QAClC,MAAM,IAAI,GAAG,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;QAClC,IAAI,CAAC,IAAI,EAAE,CAAC;YACV,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC;gBACd,OAAO,EAAE,IAAI,CAAC,CAAC,CAAC,cAAc,CAAC;gBAC/B,QAAQ,EAAE,IAAI;gBACd,KAAK,EAAE,MAAM;gBACb,QAAQ,EAAE,KAAK;aAChB,CAAC,CAAC;YACH,OAAO;QACT,CAAC;QACD,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC;QAC5C,IAAI,CAAC;YACH,MAAM,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC;QAC1D,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,EAAE,OAAO,EAAE,qBAAqB,EAAE,CAAC,CAAC;YAC5D,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC;QAC9C,CAAC;IACH,CAAC;+GAvKU,2BAA2B;mGAA3B,2BAA2B,wJA7D5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCT,+TAtCS,SAAS,oGAAE,UAAU,mFAAE,UAAU,8EAAE,SAAS,oPAAE,UAAU,wKAAE,UAAU,yGAAE,aAAa;;4FA8DlF,2BAA2B;kBAjEvC,SAAS;+BACE,0BAA0B,cACxB,IAAI,WACP,CAAC,SAAS,EAAE,UAAU,EAAE,UAAU,EAAE,SAAS,EAAE,UAAU,EAAE,UAAU,EAAE,aAAa,CAAC,YACpF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCT;wDA+BQ,SAAS;sBAAjB,KAAK;gBAGG,aAAa;sBAArB,KAAK","sourcesContent":["import { Component, computed, inject, Input, OnInit, signal } from '@angular/core';\nimport { Validators } from '@angular/forms';\nimport { IonButton, IonButtons, IonContent, IonHeader, IonSpinner, IonToolbar } from '@ionic/angular/standalone';\nimport { firstValueFrom } from 'rxjs';\n\nimport { FormComponent } from '../form/form.component';\nimport { ComponentState, ComponentStates, FormMetadata, FormSubmit, InputMetadata, InputType } from '../../types';\n\nimport { AuthService } from '../../../services/auth/auth.service';\nimport { I18nService } from '../../../services/i18n';\nimport { ToastService } from '../../../services/toast.service';\nimport { ValtechErrorService } from '../../../services/errors/valtech-error.service';\n\nimport { DELETE_ACCOUNT_MODAL_I18N } from './delete-account-modal.i18n';\n\nconst DEFAULT_NAMESPACE = 'Settings.DeleteAccount';\n\n/**\n * `val-delete-account-modal` — modal de eliminación de cuenta (organism,\n * cuenta-específico). Promovido desde `showcase` bajo el proceso de ADR-021.\n *\n * Decide el flujo según si la cuenta tiene contraseña:\n *  - **con password** → pide la contraseña actual y la verifica vía\n *    `auth.deleteAccount({ password })`.\n *  - **sin password** (cuenta OAuth) → envía un código por email\n *    (`auth.sendDeleteAccountCode()`) y lo pide para confirmar\n *    (`auth.deleteAccount({ code })`).\n *\n * Abierto vía `ModalService` — recibe `_modalRef` por `componentProps` para\n * cerrar desde dentro. Header canónico (Regla #5): sin `ion-title`, botón Cerrar\n * texto en `slot=end`, título/subtítulo en el body vía `val-form`.\n *\n * Auto-registra sus defaults i18n (es/en) en el constructor si el consumer no\n * proveyó el namespace `Settings.DeleteAccount`.\n */\n@Component({\n  selector: 'val-delete-account-modal',\n  standalone: true,\n  imports: [IonHeader, IonToolbar, IonButtons, IonButton, IonContent, IonSpinner, FormComponent],\n  template: `\n    <ion-header>\n      <ion-toolbar>\n        <ion-buttons slot=\"end\">\n          <ion-button fill=\"clear\" color=\"dark\" (click)=\"close()\">\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      <section class=\"modal-form-section\">\n        @if (hasPassword() === null) {\n          <div class=\"spinner-center\">\n            <ion-spinner name=\"crescent\" />\n          </div>\n        } @else if (hasPassword()) {\n          <val-form [props]=\"passwordFormProps()\" (onSubmit)=\"onPasswordSubmit($event)\" />\n        } @else if (!codeSent()) {\n          <val-form [props]=\"sendCodeFormProps()\" (onSubmit)=\"onSendCode()\" />\n        } @else {\n          <val-form [props]=\"codeFormProps()\" (onSubmit)=\"onCodeSubmit($event)\" />\n          <div class=\"resend-row\">\n            <ion-button\n              fill=\"clear\"\n              color=\"medium\"\n              size=\"small\"\n              [disabled]=\"formState() === 'WORKING'\"\n              (click)=\"onResendCode()\"\n            >\n              {{ t('resend') }}\n            </ion-button>\n          </div>\n        }\n      </section>\n    </ion-content>\n  `,\n  styles: [\n    `\n      .modal-form-section {\n        display: flex;\n        flex-direction: column;\n        gap: 16px;\n        max-width: 420px;\n        margin: 0 auto;\n        padding-top: 8px;\n      }\n      .resend-row {\n        display: flex;\n        justify-content: center;\n        margin-top: -8px;\n      }\n      .spinner-center {\n        display: flex;\n        justify-content: center;\n        padding-top: 32px;\n      }\n    `,\n  ],\n})\nexport class DeleteAccountModalComponent implements OnInit {\n  private auth = inject(AuthService);\n  private errors = inject(ValtechErrorService);\n  private i18n = inject(I18nService);\n  private toast = inject(ToastService);\n\n  /** Inyectado por `ModalService.open` — referencia para cerrar desde dentro. */\n  @Input() _modalRef?: { dismiss: (data?: unknown, role?: string) => void };\n\n  /** Namespace i18n con que la vista resuelve sus textos. */\n  @Input() i18nNamespace = DEFAULT_NAMESPACE;\n\n  readonly hasPassword = signal<boolean | null>(null);\n  readonly codeSent = signal(false);\n  readonly formState = signal<ComponentState>(ComponentStates.ENABLED);\n\n  constructor() {\n    if (!this.i18n.hasNamespace(DEFAULT_NAMESPACE)) {\n      this.i18n.registerContent(DEFAULT_NAMESPACE, DELETE_ACCOUNT_MODAL_I18N);\n    }\n  }\n\n  ngOnInit(): void {\n    firstValueFrom(this.auth.getProfile())\n      .then(profile => this.hasPassword.set(profile.hasPassword ?? true))\n      .catch(() => this.hasPassword.set(true));\n  }\n\n  t = (key: string): string => this.i18n.t(key, this.i18nNamespace);\n\n  private submitBtn(token: string, textKey: string) {\n    return {\n      text: this.t(textKey),\n      type: 'submit' as const,\n      expand: 'block' as const,\n      fill: 'solid' as const,\n      color: 'dark',\n      size: 'default' as const,\n      token,\n      state: ComponentStates.ENABLED,\n    };\n  }\n\n  readonly passwordFormProps = computed<FormMetadata>(() => ({\n    name: this.t('title'),\n    state: this.formState(),\n    sections: [\n      {\n        name: this.t('warningPassword'),\n        order: 0,\n        fields: [\n          {\n            token: 'delete-password',\n            name: 'password',\n            label: this.t('passwordLabel'),\n            hint: '',\n            placeholder: this.t('passwordPlaceholder'),\n            type: InputType.PASSWORD,\n            order: 0,\n            validators: [Validators.required],\n            errors: { required: this.t('passwordRequired') },\n            state: ComponentStates.ENABLED,\n          } as InputMetadata,\n        ],\n      },\n    ],\n    actions: this.submitBtn('delete-password-submit', 'confirmCta'),\n  }));\n\n  readonly sendCodeFormProps = computed<FormMetadata>(() => ({\n    name: this.t('title'),\n    state: this.formState(),\n    sections: [\n      {\n        name: this.t('warningSendCode'),\n        order: 0,\n        fields: [],\n      },\n    ],\n    actions: this.submitBtn('delete-send-code-submit', 'sendCodeCta'),\n  }));\n\n  readonly codeFormProps = computed<FormMetadata>(() => ({\n    name: this.t('title'),\n    state: this.formState(),\n    sections: [\n      {\n        name: this.t('warningEnterCode'),\n        order: 0,\n        fields: [\n          {\n            token: 'delete-code',\n            name: 'code',\n            label: this.t('codeLabel'),\n            hint: '',\n            placeholder: this.t('codePlaceholder'),\n            type: InputType.TEXT,\n            order: 0,\n            validators: [Validators.required],\n            errors: { required: this.t('codeRequired') },\n            state: ComponentStates.ENABLED,\n          } as InputMetadata,\n        ],\n      },\n    ],\n    actions: this.submitBtn('delete-code-submit', 'confirmCta'),\n  }));\n\n  close(): void {\n    this._modalRef?.dismiss(undefined, 'cancel');\n  }\n\n  async onPasswordSubmit(event: FormSubmit): Promise<void> {\n    const password = event.fields['password'];\n    if (!password) {\n      this.toast.show({\n        message: this.t('passwordRequired'),\n        duration: 3000,\n        color: 'dark',\n        position: 'top',\n      });\n      return;\n    }\n    this.formState.set(ComponentStates.WORKING);\n    try {\n      await firstValueFrom(this.auth.deleteAccount({ password }));\n    } catch (err) {\n      this.errors.handle(err, { context: 'delete-account.password' });\n      this.formState.set(ComponentStates.ENABLED);\n    }\n  }\n\n  async onSendCode(): Promise<void> {\n    this.formState.set(ComponentStates.WORKING);\n    try {\n      await firstValueFrom(this.auth.sendDeleteAccountCode());\n      this.codeSent.set(true);\n    } catch (err) {\n      this.errors.handle(err, { context: 'delete-account.send-code' });\n    } finally {\n      this.formState.set(ComponentStates.ENABLED);\n    }\n  }\n\n  async onResendCode(): Promise<void> {\n    this.codeSent.set(false);\n    await this.onSendCode();\n  }\n\n  async onCodeSubmit(event: FormSubmit): Promise<void> {\n    const code = event.fields['code'];\n    if (!code) {\n      this.toast.show({\n        message: this.t('codeRequired'),\n        duration: 3000,\n        color: 'dark',\n        position: 'top',\n      });\n      return;\n    }\n    this.formState.set(ComponentStates.WORKING);\n    try {\n      await firstValueFrom(this.auth.deleteAccount({ code }));\n    } catch (err) {\n      this.errors.handle(err, { context: 'delete-account.code' });\n      this.formState.set(ComponentStates.ENABLED);\n    }\n  }\n}\n"]}

package/esm2022/lib/components/organisms/delete-account-modal/delete-account-modal.i18n.mjs

@@ -0,0 +1,40 @@
+/**
+ * Defaults i18n (es/en) embebidos en `val-delete-account-modal`. Auto-registrados
+ * en el constructor del componente si el consumer no proveyó el namespace
+ * (`Settings.DeleteAccount` por default). SOLO incluye las keys que el modal usa.
+ */
+export const DELETE_ACCOUNT_MODAL_I18N = {
+    es: {
+        title: 'Eliminar cuenta',
+        warningPassword: 'Esta acción es permanente y no se puede deshacer. Se eliminarán tu cuenta, sesiones activas, organizaciones personales y todos los datos asociados.',
+        passwordLabel: 'Contraseña actual',
+        passwordPlaceholder: 'Ingresa tu contraseña',
+        passwordRequired: 'La contraseña es requerida',
+        warningSendCode: 'Tu cuenta está vinculada a un proveedor externo. Para confirmar la eliminación, enviaremos un código de verificación a tu correo electrónico.',
+        sendCodeCta: 'Enviar código de confirmación',
+        warningEnterCode: 'Ingresa el código que enviamos a tu correo. Expira en 15 minutos.',
+        codeLabel: 'Código de verificación',
+        codePlaceholder: 'Código de 6 dígitos',
+        codeRequired: 'El código es requerido',
+        confirmCta: 'Eliminar mi cuenta',
+        close: 'Cancelar',
+        resend: 'Reenviar código',
+    },
+    en: {
+        title: 'Delete account',
+        warningPassword: 'This action is permanent and cannot be undone. Your account, active sessions, personal organizations and all associated data will be permanently deleted.',
+        passwordLabel: 'Current password',
+        passwordPlaceholder: 'Enter your password',
+        passwordRequired: 'Password is required',
+        warningSendCode: "Your account is linked to an external provider. To confirm deletion, we'll send a verification code to your email address.",
+        sendCodeCta: 'Send confirmation code',
+        warningEnterCode: 'Enter the code we sent to your email. It expires in 15 minutes.',
+        codeLabel: 'Verification code',
+        codePlaceholder: '6-digit code',
+        codeRequired: 'Code is required',
+        confirmCta: 'Delete my account',
+        close: 'Cancel',
+        resend: 'Resend code',
+    },
+};
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,205 @@
+import { Component, computed, inject, Input } from '@angular/core';
+import { IonButton, IonButtons, IonContent, IonHeader, IonIcon, IonToolbar } from '@ionic/angular/standalone';
+import { addIcons } from 'ionicons';
+import { mailOutline, peopleOutline, swapHorizontalOutline } from 'ionicons/icons';
+import { ButtonComponent } from '../../atoms/button/button.component';
+import { DisplayComponent } from '../../atoms/display/display.component';
+import { TextComponent } from '../../atoms/text/text.component';
+import { TitleComponent } from '../../atoms/title/title.component';
+import { I18nService } from '../../../services/i18n';
+import { ORG_INFO_SHEET_I18N } from './org-info-sheet.i18n';
+import * as i0 from "@angular/core";
+const DEFAULT_NAMESPACE = 'OrgInfoSheet';
+/**
+ * `val-org-info-sheet` — sheet informativo "¿Qué son las organizaciones?".
+ * Extraído del `OrgInfoSheetComponent` inline de `AccountPage` bajo el proceso de
+ * ADR-021.
+ *
+ * El consumer pasa `title`/`subtitle`/`body`/`closeLabel` ya resueltos por props
+ * (patrón del resto de modales del factory). Los textos de los 3 features
+ * (Colaboración / Cambio rápido / Invitaciones), que en la versión inline estaban
+ * hardcoded, ahora se auto-resuelven desde el namespace `OrgInfoSheet`
+ * (auto-registrado en el constructor).
+ *
+ * Abierto vía `ModalService` — recibe `_modalRef` por `componentProps`. Header
+ * canónico (Regla #5): sin `ion-title`, botón Cerrar texto en `slot=end`,
+ * título/subtítulo en el body con `val-display`/`val-title`.
+ */
+export class OrgInfoSheetComponent {
+    constructor() {
+        this.i18n = inject(I18nService);
+        /** Título principal (resuelto por el consumer). Fallback al namespace propio. */
+        this.title = '';
+        /** Subtítulo (resuelto por el consumer). Fallback al namespace propio. */
+        this.subtitle = '';
+        /** Cuerpo en párrafos separados por doble salto de línea (resuelto por el consumer). */
+        this.body = '';
+        /** Label del botón cerrar (resuelto por el consumer). Fallback al namespace propio. */
+        this.closeLabel = '';
+        /** Props del botón cerrar del footer (el consumer puede pasar custom). */
+        this.closeProps = {
+            text: 'Cerrar',
+            fill: 'outline',
+            color: 'dark',
+            size: 'default',
+            expand: 'block',
+            type: 'button',
+        };
+        this.resolvedTitle = computed(() => this.title || this.tt('title'));
+        this.resolvedSubtitle = computed(() => this.subtitle || this.tt('subtitle'));
+        this.resolvedCloseLabel = computed(() => this.closeLabel || this.tt('close'));
+        this.paragraphs = computed(() => this.body.split('\n\n').filter(Boolean));
+        this.resolvedCloseProps = computed(() => ({
+            ...this.closeProps,
+            text: this.closeProps.text || this.resolvedCloseLabel(),
+        }));
+        addIcons({ peopleOutline, swapHorizontalOutline, mailOutline });
+        if (!this.i18n.hasNamespace(DEFAULT_NAMESPACE)) {
+            this.i18n.registerContent(DEFAULT_NAMESPACE, ORG_INFO_SHEET_I18N);
+        }
+    }
+    dismiss() {
+        this._modalRef?.dismiss(null, 'cancel');
+    }
+    tt(key) {
+        return this.i18n.t(key, DEFAULT_NAMESPACE);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: OrgInfoSheetComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.14", type: OrgInfoSheetComponent, isStandalone: true, selector: "val-org-info-sheet", inputs: { title: "title", subtitle: "subtitle", body: "body", closeLabel: "closeLabel", closeProps: "closeProps", _modalRef: "_modalRef" }, ngImport: i0, template: `
+    <ion-header>
+      <ion-toolbar>
+        <ion-buttons slot="end">
+          <ion-button fill="clear" color="dark" (click)="dismiss()">
+            <strong>{{ resolvedCloseLabel() }}</strong>
+          </ion-button>
+        </ion-buttons>
+      </ion-toolbar>
+    </ion-header>
+
+    <ion-content class="ion-padding">
+      <val-display [props]="{ content: resolvedTitle(), size: 'small', color: 'dark' }" />
+      <val-title [props]="{ content: resolvedSubtitle(), size: 'large', color: '', bold: false }" />
+
+      <div class="info-features">
+        <div class="info-feature">
+          <ion-icon name="people-outline" class="info-feature__icon" />
+          <div>
+            <div class="info-feature__title">{{ tt('featureCollabTitle') }}</div>
+            <div class="info-feature__desc">{{ tt('featureCollabDesc') }}</div>
+          </div>
+        </div>
+        <div class="info-feature">
+          <ion-icon name="swap-horizontal-outline" class="info-feature__icon" />
+          <div>
+            <div class="info-feature__title">{{ tt('featureSwitchTitle') }}</div>
+            <div class="info-feature__desc">{{ tt('featureSwitchDesc') }}</div>
+          </div>
+        </div>
+        <div class="info-feature">
+          <ion-icon name="mail-outline" class="info-feature__icon" />
+          <div>
+            <div class="info-feature__title">{{ tt('featureInviteTitle') }}</div>
+            <div class="info-feature__desc">{{ tt('featureInviteDesc') }}</div>
+          </div>
+        </div>
+      </div>
+
+      @for (para of paragraphs(); track $index) {
+        <val-text
+          [props]="{
+            size: 'medium',
+            color: 'dark',
+            bold: false,
+            content: para,
+          }"
+        />
+      }
+
+      <div class="sheet-footer">
+        <val-button [props]="resolvedCloseProps()" (click)="dismiss()" />
+      </div>
+    </ion-content>
+  `, isInline: true, styles: ["ion-content{--padding-bottom: 32px}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,
+            args: [{ selector: 'val-org-info-sheet', standalone: true, imports: [
+                        IonHeader,
+                        IonToolbar,
+                        IonButtons,
+                        IonButton,
+                        IonContent,
+                        IonIcon,
+                        ButtonComponent,
+                        DisplayComponent,
+                        TextComponent,
+                        TitleComponent,
+                    ], template: `
+    <ion-header>
+      <ion-toolbar>
+        <ion-buttons slot="end">
+          <ion-button fill="clear" color="dark" (click)="dismiss()">
+            <strong>{{ resolvedCloseLabel() }}</strong>
+          </ion-button>
+        </ion-buttons>
+      </ion-toolbar>
+    </ion-header>
+
+    <ion-content class="ion-padding">
+      <val-display [props]="{ content: resolvedTitle(), size: 'small', color: 'dark' }" />
+      <val-title [props]="{ content: resolvedSubtitle(), size: 'large', color: '', bold: false }" />
+
+      <div class="info-features">
+        <div class="info-feature">
+          <ion-icon name="people-outline" class="info-feature__icon" />
+          <div>
+            <div class="info-feature__title">{{ tt('featureCollabTitle') }}</div>
+            <div class="info-feature__desc">{{ tt('featureCollabDesc') }}</div>
+          </div>
+        </div>
+        <div class="info-feature">
+          <ion-icon name="swap-horizontal-outline" class="info-feature__icon" />
+          <div>
+            <div class="info-feature__title">{{ tt('featureSwitchTitle') }}</div>
+            <div class="info-feature__desc">{{ tt('featureSwitchDesc') }}</div>
+          </div>
+        </div>
+        <div class="info-feature">
+          <ion-icon name="mail-outline" class="info-feature__icon" />
+          <div>
+            <div class="info-feature__title">{{ tt('featureInviteTitle') }}</div>
+            <div class="info-feature__desc">{{ tt('featureInviteDesc') }}</div>
+          </div>
+        </div>
+      </div>
+
+      @for (para of paragraphs(); track $index) {
+        <val-text
+          [props]="{
+            size: 'medium',
+            color: 'dark',
+            bold: false,
+            content: para,
+          }"
+        />
+      }
+
+      <div class="sheet-footer">
+        <val-button [props]="resolvedCloseProps()" (click)="dismiss()" />
+      </div>
+    </ion-content>
+  `, styles: ["ion-content{--padding-bottom: 32px}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: [{
+                type: Input
+            }], body: [{
+                type: Input
+            }], closeLabel: [{
+                type: Input
+            }], closeProps: [{
+                type: Input
+            }], _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      <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      @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: 32px;\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  /** 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"]}

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

@@ -0,0 +1,35 @@
+/**
+ * Defaults i18n (es/en) embebidos en `val-org-info-sheet`. Auto-registrados en el
+ * constructor del componente si el consumer no proveyó el namespace
+ * (`OrgInfoSheet`). Cubre los textos de los 3 features (que en la versión inline
+ * de showcase estaban hardcoded) más fallbacks de título/subtítulo/closeLabel.
+ *
+ * `title`/`subtitle`/`body`/`closeLabel` los suele pasar el consumer ya resueltos
+ * por props (patrón del resto de modales); las keys `feature*` se auto-resuelven
+ * desde este namespace.
+ */
+export const ORG_INFO_SHEET_I18N = {
+    es: {
+        title: '¿Qué son las organizaciones?',
+        subtitle: 'Todo lo que necesitas saber',
+        close: 'Cerrar',
+        featureCollabTitle: 'Colaboración',
+        featureCollabDesc: 'Separa proyectos y datos por empresa o equipo.',
+        featureSwitchTitle: 'Cambio rápido',
+        featureSwitchDesc: 'Cambia entre organizaciones en cualquier momento.',
+        featureInviteTitle: 'Invitaciones',
+        featureInviteDesc: 'Invita a otros a unirse mediante email.',
+    },
+    en: {
+        title: 'What are organizations?',
+        subtitle: 'Everything you need to know',
+        close: 'Close',
+        featureCollabTitle: 'Collaboration',
+        featureCollabDesc: 'Separate projects and data by company or team.',
+        featureSwitchTitle: 'Quick switch',
+        featureSwitchDesc: 'Switch between organizations at any time.',
+        featureInviteTitle: 'Invitations',
+        featureInviteDesc: 'Invite others to join via email.',
+    },
+};
+//# sourceMappingURL=data:application/json;base64,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