valtech-components 2.0.984 → 2.0.986

package/esm2022/lib/components/organisms/create-org-modal/create-org-modal.component.mjs

@@ -0,0 +1,240 @@
+import { Component, effect, inject, Input, signal } from '@angular/core';
+import { Validators } from '@angular/forms';
+import { firstValueFrom } from 'rxjs';
+import { IonButton, IonButtons, IonContent, IonHeader, IonToolbar } from '@ionic/angular/standalone';
+import { FormComponent } from '../form/form.component';
+import { DisplayComponent } from '../../atoms/display/display.component';
+import { TitleComponent } from '../../atoms/title/title.component';
+import { ComponentStates, InputType } from '../../types';
+import { I18nService } from '../../../services/i18n';
+import { OrgService } from '../../../services/org/org.service';
+import { OrgSwitchService } from '../../../services/auth/org-switch.service';
+import { ToastService } from '../../../services/toast.service';
+import { ValtechErrorService } from '../../../services/errors/valtech-error.service';
+import { CREATE_ORG_MODAL_I18N } from './create-org-modal.i18n';
+import * as i0 from "@angular/core";
+const DEFAULT_NAMESPACE = 'CreateOrgModal';
+/**
+ * `val-create-org-modal` — modal de creación de organización (organism
+ * compartido). Promovido desde `showcase` bajo el proceso de ADR-021. Reusado por
+ * la vista Cuenta (y futuras vistas org-aware).
+ *
+ * Crea la org vía `OrgService.createOrg` y, en éxito, cambia a ella con
+ * `OrgSwitchService.switchTo`. El formulario (nombre + tipo + descripción) se
+ * construye una vez y se mantiene reactivo a idioma + estado de trabajo vía
+ * effects `allowSignalWrites`.
+ *
+ * Abierto vía `ModalService` — recibe `_modalRef` por `componentProps` + callback
+ * `onSuccess(newOrg)`. 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`.
+ *
+ * Auto-registra sus defaults i18n (es/en) si el consumer no proveyó el namespace
+ * `CreateOrgModal`.
+ */
+export class CreateOrgModalComponent {
+    constructor() {
+        this.i18n = inject(I18nService);
+        this.orgService = inject(OrgService);
+        this.orgSwitch = inject(OrgSwitchService);
+        this.toast = inject(ToastService);
+        this.errors = inject(ValtechErrorService);
+        /** Namespace i18n con que la vista resuelve sus textos. */
+        this.i18nNamespace = DEFAULT_NAMESPACE;
+        this._busy = signal(false);
+        if (!this.i18n.hasNamespace(DEFAULT_NAMESPACE)) {
+            this.i18n.registerContent(DEFAULT_NAMESPACE, CREATE_ORG_MODAL_I18N);
+        }
+        this.formMeta = signal(this.buildFormMeta());
+        effect(() => {
+            this.i18n.lang();
+            this.formMeta.set(this.buildFormMeta());
+        }, { allowSignalWrites: true });
+        effect(() => {
+            const working = this._busy();
+            this.formMeta.update(meta => ({
+                ...meta,
+                state: working ? ComponentStates.WORKING : ComponentStates.ENABLED,
+                actions: {
+                    ...meta.actions,
+                    state: working ? ComponentStates.WORKING : ComponentStates.ENABLED,
+                },
+            }));
+        }, { allowSignalWrites: true });
+    }
+    async onSubmit(event) {
+        if (this._busy())
+            return;
+        const name = event.fields['name'];
+        const type = event.fields['type'];
+        if (!name?.trim() || !type) {
+            this.toast.show({
+                message: this.t('fillRequired'),
+                duration: 3000,
+                color: 'dark',
+                position: 'top',
+            });
+            return;
+        }
+        this._busy.set(true);
+        try {
+            const description = event.fields['description'];
+            const newOrg = await firstValueFrom(this.orgService.createOrg({ name, type, description }));
+            this.toast.show({
+                message: this.t('successMsg'),
+                color: 'dark',
+                duration: 3500,
+            });
+            await this.orgSwitch.switchTo(newOrg.id);
+            this.onSuccess?.(newOrg);
+            this._modalRef?.dismiss(newOrg, 'confirm');
+        }
+        catch (err) {
+            this.errors.handle(err, { i18nNamespace: this.i18nNamespace });
+        }
+        finally {
+            this._busy.set(false);
+        }
+    }
+    dismiss() {
+        this._modalRef?.dismiss(null, 'cancel');
+    }
+    buildFormMeta() {
+        const nameField = {
+            token: 'new-org-name',
+            name: 'name',
+            label: this.t('nameLabel'),
+            hint: '',
+            placeholder: this.t('namePlaceholder'),
+            type: InputType.TEXT,
+            order: 1,
+            validators: [Validators.required, Validators.minLength(2), Validators.maxLength(100)],
+            errors: {
+                required: this.t('nameRequired'),
+                minlength: this.t('nameMin'),
+            },
+            value: '',
+            state: ComponentStates.ENABLED,
+        };
+        const typeField = {
+            token: 'new-org-type',
+            name: 'type',
+            label: this.t('typeLabel'),
+            hint: '',
+            placeholder: '',
+            type: InputType.SELECT,
+            order: 2,
+            validators: [Validators.required],
+            errors: {},
+            value: 'PERSONAL',
+            withDefault: 'PERSONAL',
+            state: ComponentStates.ENABLED,
+            options: [
+                { id: 'PERSONAL', name: this.t('typePersonal'), order: 1 },
+                { id: 'PRIVATE', name: this.t('typePrivate'), order: 2 },
+                { id: 'PUBLIC', name: this.t('typePublic'), order: 3 },
+                { id: 'BUSINESS', name: this.t('typeBusiness'), order: 4 },
+            ],
+        };
+        const descriptionField = {
+            token: 'new-org-description',
+            name: 'description',
+            label: this.t('descriptionLabel'),
+            hint: '',
+            placeholder: this.t('descriptionPlaceholder'),
+            type: InputType.TEXTAREA,
+            order: 3,
+            validators: [],
+            errors: {},
+            value: '',
+            state: ComponentStates.ENABLED,
+        };
+        const submitButton = {
+            text: this.t('createCta'),
+            color: 'dark',
+            type: 'submit',
+            fill: 'solid',
+            size: 'default',
+            shape: 'round',
+            expand: 'block',
+            state: ComponentStates.ENABLED,
+            token: 'new-org-submit',
+        };
+        return {
+            name: '',
+            state: ComponentStates.ENABLED,
+            sections: [
+                {
+                    name: '',
+                    order: 1,
+                    fields: [nameField, typeField, descriptionField],
+                },
+            ],
+            actions: submitButton,
+        };
+    }
+    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: CreateOrgModalComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: CreateOrgModalComponent, isStandalone: true, selector: "val-create-org-modal", inputs: { _modalRef: "_modalRef", onSuccess: "onSuccess", 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('pageTitle'), size: 'small', color: 'dark' }" />
+      <val-title
+        [props]="{
+          content: t('pageDescription'),
+          size: 'large',
+          color: '',
+          bold: false,
+        }"
+      />
+      <val-form [props]="formMeta()" (onSubmit)="onSubmit($event)" />
+    </ion-content>
+  `, isInline: true, 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: FormComponent, selector: "val-form", inputs: ["props"], outputs: ["onSubmit", "onInvalid", "onSelectChange"] }, { kind: "component", type: DisplayComponent, selector: "val-display", inputs: ["props"] }, { kind: "component", type: TitleComponent, selector: "val-title", inputs: ["props"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: CreateOrgModalComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'val-create-org-modal',
+                    standalone: true,
+                    imports: [IonHeader, IonToolbar, IonButtons, IonButton, IonContent, FormComponent, DisplayComponent, 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('pageTitle'), size: 'small', color: 'dark' }" />
+      <val-title
+        [props]="{
+          content: t('pageDescription'),
+          size: 'large',
+          color: '',
+          bold: false,
+        }"
+      />
+      <val-form [props]="formMeta()" (onSubmit)="onSubmit($event)" />
+    </ion-content>
+  `,
+                }]
+        }], ctorParameters: () => [], propDecorators: { _modalRef: [{
+                type: Input
+            }], onSuccess: [{
+                type: Input
+            }], i18nNamespace: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"create-org-modal.component.js","sourceRoot":"","sources":["../../../../../../../src/lib/components/organisms/create-org-modal/create-org-modal.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, effect, inject, Input, signal, WritableSignal } from '@angular/core';\nimport { Validators } from '@angular/forms';\nimport { firstValueFrom } from 'rxjs';\nimport { IonButton, IonButtons, IonContent, IonHeader, IonToolbar } from '@ionic/angular/standalone';\n\nimport { FormComponent } from '../form/form.component';\nimport { DisplayComponent } from '../../atoms/display/display.component';\nimport { TitleComponent } from '../../atoms/title/title.component';\nimport { ComponentStates, FormMetadata, FormSubmit, InputMetadata, InputType } from '../../types';\n\nimport { I18nService } from '../../../services/i18n';\nimport { OrgService } from '../../../services/org/org.service';\nimport { Organization, OrgType } from '../../../services/org/types';\nimport { OrgSwitchService } from '../../../services/auth/org-switch.service';\nimport { ToastService } from '../../../services/toast.service';\nimport { ValtechErrorService } from '../../../services/errors/valtech-error.service';\n\nimport { CREATE_ORG_MODAL_I18N } from './create-org-modal.i18n';\n\nconst DEFAULT_NAMESPACE = 'CreateOrgModal';\n\n/**\n * `val-create-org-modal` — modal de creación de organización (organism\n * compartido). Promovido desde `showcase` bajo el proceso de ADR-021. Reusado por\n * la vista Cuenta (y futuras vistas org-aware).\n *\n * Crea la org vía `OrgService.createOrg` y, en éxito, cambia a ella con\n * `OrgSwitchService.switchTo`. El formulario (nombre + tipo + descripción) se\n * construye una vez y se mantiene reactivo a idioma + estado de trabajo vía\n * effects `allowSignalWrites`.\n *\n * Abierto vía `ModalService` — recibe `_modalRef` por `componentProps` + callback\n * `onSuccess(newOrg)`. Header canónico (Regla #5): sin `ion-title`, botón Cerrar\n * texto en `slot=end`, título/subtítulo en el body con `val-display`/`val-title`.\n *\n * Auto-registra sus defaults i18n (es/en) si el consumer no proveyó el namespace\n * `CreateOrgModal`.\n */\n@Component({\n  selector: 'val-create-org-modal',\n  standalone: true,\n  imports: [IonHeader, IonToolbar, IonButtons, IonButton, IonContent, FormComponent, DisplayComponent, TitleComponent],\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    <ion-content class=\"ion-padding\">\n      <val-display [props]=\"{ content: t('pageTitle'), size: 'small', color: 'dark' }\" />\n      <val-title\n        [props]=\"{\n          content: t('pageDescription'),\n          size: 'large',\n          color: '',\n          bold: false,\n        }\"\n      />\n      <val-form [props]=\"formMeta()\" (onSubmit)=\"onSubmit($event)\" />\n    </ion-content>\n  `,\n})\nexport class CreateOrgModalComponent {\n  private i18n = inject(I18nService);\n  private orgService = inject(OrgService);\n  private orgSwitch = inject(OrgSwitchService);\n  private toast = inject(ToastService);\n  private errors = inject(ValtechErrorService);\n\n  /** Inyectado por `ModalService.open` — referencia para cerrar desde dentro. */\n  @Input() _modalRef?: { dismiss: (data?: unknown, role?: string) => void };\n\n  /** Callback tras crear la org (pasado por `componentProps`). */\n  @Input() onSuccess?: (newOrg: Organization) => void;\n\n  /** Namespace i18n con que la vista resuelve sus textos. */\n  @Input() i18nNamespace = DEFAULT_NAMESPACE;\n\n  private readonly _busy = signal(false);\n  readonly formMeta: WritableSignal<FormMetadata>;\n\n  constructor() {\n    if (!this.i18n.hasNamespace(DEFAULT_NAMESPACE)) {\n      this.i18n.registerContent(DEFAULT_NAMESPACE, CREATE_ORG_MODAL_I18N);\n    }\n    this.formMeta = signal(this.buildFormMeta());\n\n    effect(\n      () => {\n        this.i18n.lang();\n        this.formMeta.set(this.buildFormMeta());\n      },\n      { allowSignalWrites: true }\n    );\n\n    effect(\n      () => {\n        const working = this._busy();\n        this.formMeta.update(meta => ({\n          ...meta,\n          state: working ? ComponentStates.WORKING : ComponentStates.ENABLED,\n          actions: {\n            ...meta.actions,\n            state: working ? ComponentStates.WORKING : ComponentStates.ENABLED,\n          },\n        }));\n      },\n      { allowSignalWrites: true }\n    );\n  }\n\n  async onSubmit(event: FormSubmit): Promise<void> {\n    if (this._busy()) return;\n    const name = event.fields['name'] as string;\n    const type = event.fields['type'] as OrgType;\n    if (!name?.trim() || !type) {\n      this.toast.show({\n        message: this.t('fillRequired'),\n        duration: 3000,\n        color: 'dark',\n        position: 'top',\n      });\n      return;\n    }\n    this._busy.set(true);\n    try {\n      const description = event.fields['description'] as string | undefined;\n      const newOrg = await firstValueFrom(this.orgService.createOrg({ name, type, description }));\n      this.toast.show({\n        message: this.t('successMsg'),\n        color: 'dark',\n        duration: 3500,\n      });\n      await this.orgSwitch.switchTo(newOrg.id);\n      this.onSuccess?.(newOrg);\n      this._modalRef?.dismiss(newOrg, 'confirm');\n    } catch (err) {\n      this.errors.handle(err, { i18nNamespace: this.i18nNamespace });\n    } finally {\n      this._busy.set(false);\n    }\n  }\n\n  dismiss(): void {\n    this._modalRef?.dismiss(null, 'cancel');\n  }\n\n  private buildFormMeta(): FormMetadata {\n    const nameField: InputMetadata = {\n      token: 'new-org-name',\n      name: 'name',\n      label: this.t('nameLabel'),\n      hint: '',\n      placeholder: this.t('namePlaceholder'),\n      type: InputType.TEXT,\n      order: 1,\n      validators: [Validators.required, Validators.minLength(2), Validators.maxLength(100)],\n      errors: {\n        required: this.t('nameRequired'),\n        minlength: this.t('nameMin'),\n      },\n      value: '',\n      state: ComponentStates.ENABLED,\n    } as InputMetadata;\n\n    const typeField: InputMetadata = {\n      token: 'new-org-type',\n      name: 'type',\n      label: this.t('typeLabel'),\n      hint: '',\n      placeholder: '',\n      type: InputType.SELECT,\n      order: 2,\n      validators: [Validators.required],\n      errors: {},\n      value: 'PERSONAL',\n      withDefault: 'PERSONAL',\n      state: ComponentStates.ENABLED,\n      options: [\n        { id: 'PERSONAL', name: this.t('typePersonal'), order: 1 },\n        { id: 'PRIVATE', name: this.t('typePrivate'), order: 2 },\n        { id: 'PUBLIC', name: this.t('typePublic'), order: 3 },\n        { id: 'BUSINESS', name: this.t('typeBusiness'), order: 4 },\n      ],\n    } as InputMetadata;\n\n    const descriptionField: InputMetadata = {\n      token: 'new-org-description',\n      name: 'description',\n      label: this.t('descriptionLabel'),\n      hint: '',\n      placeholder: this.t('descriptionPlaceholder'),\n      type: InputType.TEXTAREA,\n      order: 3,\n      validators: [],\n      errors: {},\n      value: '',\n      state: ComponentStates.ENABLED,\n    } as InputMetadata;\n\n    const submitButton = {\n      text: this.t('createCta'),\n      color: 'dark' as const,\n      type: 'submit' as const,\n      fill: 'solid' as const,\n      size: 'default' as const,\n      shape: 'round' as const,\n      expand: 'block' as const,\n      state: ComponentStates.ENABLED,\n      token: 'new-org-submit',\n    };\n\n    return {\n      name: '',\n      state: ComponentStates.ENABLED,\n      sections: [\n        {\n          name: '',\n          order: 1,\n          fields: [nameField, typeField, descriptionField],\n        },\n      ],\n      actions: submitButton,\n    };\n  }\n\n  t(key: string): string {\n    return this.i18n.t(key, this.i18nNamespace);\n  }\n}\n"]}

package/esm2022/lib/components/organisms/create-org-modal/create-org-modal.i18n.mjs

@@ -0,0 +1,46 @@
+/**
+ * Defaults i18n (es/en) embebidos en `val-create-org-modal`. Auto-registrados en
+ * el constructor del componente si el consumer no proveyó el namespace
+ * (`CreateOrgModal` por default). SOLO incluye las keys que el modal usa.
+ */
+export const CREATE_ORG_MODAL_I18N = {
+    es: {
+        pageTitle: 'Nueva organización',
+        pageDescription: 'Crea una nueva organización',
+        nameLabel: 'Nombre',
+        namePlaceholder: 'Nombre de la organización',
+        typeLabel: 'Tipo',
+        descriptionLabel: 'Descripción',
+        descriptionPlaceholder: 'Opcional',
+        createCta: 'Crear organización',
+        close: 'Cancelar',
+        nameRequired: 'El nombre es obligatorio',
+        nameMin: 'Mínimo 2 caracteres',
+        typePersonal: 'Personal',
+        typePrivate: 'Privada',
+        typePublic: 'Pública',
+        typeBusiness: 'Empresa',
+        successMsg: 'Organización creada. Cambiando...',
+        fillRequired: 'Completa todos los campos requeridos.',
+    },
+    en: {
+        pageTitle: 'New organization',
+        pageDescription: 'Create a new organization',
+        nameLabel: 'Name',
+        namePlaceholder: 'Organization name',
+        typeLabel: 'Type',
+        descriptionLabel: 'Description',
+        descriptionPlaceholder: 'Optional',
+        createCta: 'Create organization',
+        close: 'Cancel',
+        nameRequired: 'Name is required',
+        nameMin: 'Minimum 2 characters',
+        typePersonal: 'Personal',
+        typePrivate: 'Private',
+        typePublic: 'Public',
+        typeBusiness: 'Business',
+        successMsg: 'Organization created. Switching...',
+        fillRequired: 'Please fill in all required fields.',
+    },
+};
+//# sourceMappingURL=data:application/json;base64,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

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":"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","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"]}