valtech-components 2.0.987 → 2.0.989

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

@@ -0,0 +1,229 @@
+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 { AuthService } from '../../../services/auth/auth.service';
+import { I18nService } from '../../../services/i18n';
+import { OrgService } from '../../../services/org/org.service';
+import { ToastService } from '../../../services/toast.service';
+import { ValtechErrorService } from '../../../services/errors/valtech-error.service';
+import { EDIT_ORG_MODAL_I18N } from './edit-org-modal.i18n';
+import * as i0 from "@angular/core";
+const DEFAULT_NAMESPACE = 'EditOrgModal';
+/**
+ * `val-edit-org-modal` — modal de edición de organización (nombre + descripción).
+ * Promovido desde `showcase` bajo el proceso de ADR-021. Reusado por la vista de
+ * gestión de organización (y futuras vistas org-aware).
+ *
+ * Edita la org vía `OrgService.updateOrg`. El formulario se construye una vez y se
+ * mantiene reactivo a idioma + estado de trabajo vía effects `allowSignalWrites`.
+ * Si el consumer no pasa `org`, cae al `activeOrgId` del `AuthService`.
+ *
+ * Abierto vía `ModalService` — recibe `_modalRef` por `componentProps` + callback
+ * `onSuccess(updated)`. 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
+ * `EditOrgModal`.
+ */
+export class EditOrgModalComponent {
+    constructor() {
+        this.i18n = inject(I18nService);
+        this.orgService = inject(OrgService);
+        this.toast = inject(ToastService);
+        this.errors = inject(ValtechErrorService);
+        this.auth = inject(AuthService);
+        /** Organización a editar (pasada por `componentProps`). */
+        this.org = null;
+        /** Namespace i18n con que la vista resuelve sus textos. */
+        this.i18nNamespace = DEFAULT_NAMESPACE;
+        this.saving = signal(false);
+        if (!this.i18n.hasNamespace(DEFAULT_NAMESPACE)) {
+            this.i18n.registerContent(DEFAULT_NAMESPACE, EDIT_ORG_MODAL_I18N);
+        }
+        this.formMeta = signal(this.buildFormMeta());
+        effect(() => {
+            this.i18n.lang();
+            this.formMeta.set(this.buildFormMeta());
+        }, { allowSignalWrites: true });
+        effect(() => {
+            const w = this.saving();
+            this.formMeta.update(m => ({
+                ...m,
+                state: w ? ComponentStates.WORKING : ComponentStates.ENABLED,
+                actions: {
+                    ...m.actions,
+                    state: w ? ComponentStates.WORKING : ComponentStates.ENABLED,
+                },
+            }));
+        }, { allowSignalWrites: true });
+    }
+    ngOnInit() {
+        this.formMeta.set(this.buildFormMeta());
+    }
+    get activeOrgId() {
+        const u = this.auth.user();
+        return u?.activeOrgId ?? u?.activeOrg ?? '';
+    }
+    buildFormMeta() {
+        const nameField = {
+            token: 'edit-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: this.org?.name ?? '',
+            state: ComponentStates.ENABLED,
+        };
+        const descField = {
+            token: 'edit-org-desc',
+            name: 'description',
+            label: this.t('descriptionLabel'),
+            hint: '',
+            placeholder: this.t('descriptionPlaceholder'),
+            type: InputType.TEXTAREA,
+            order: 2,
+            validators: [],
+            errors: {},
+            value: this.org?.description ?? '',
+            state: ComponentStates.ENABLED,
+        };
+        return {
+            name: '',
+            state: ComponentStates.ENABLED,
+            sections: [{ name: '', order: 1, fields: [nameField, descField] }],
+            actions: {
+                text: this.t('saveCta'),
+                color: 'dark',
+                type: 'submit',
+                fill: 'solid',
+                size: 'default',
+                shape: 'round',
+                expand: 'block',
+                state: ComponentStates.ENABLED,
+                token: 'edit-org-submit',
+            },
+        };
+    }
+    onFormSubmit(event) {
+        const name = event.fields['name'];
+        if (!name?.trim()) {
+            this.toast.show({
+                message: this.t('fillRequired'),
+                duration: 3000,
+                color: 'dark',
+                position: 'top',
+            });
+            return;
+        }
+        const description = event.fields['description'] ?? '';
+        void this.save(name, description);
+    }
+    async save(name, description) {
+        const orgId = this.org?.id ?? this.activeOrgId;
+        if (!orgId || this.saving())
+            return;
+        this.saving.set(true);
+        try {
+            const updated = await firstValueFrom(this.orgService.updateOrg(orgId, { name, description }));
+            this.toast.show({
+                message: this.t('saveSuccess'),
+                color: 'dark',
+                duration: 3500,
+            });
+            this.onSuccess?.(updated);
+            this._modalRef?.dismiss(updated, 'confirm');
+        }
+        catch (err) {
+            this.errors.handle(err, {
+                context: 'editOrgModal.save',
+                fallbackKey: 'saveError',
+                i18nNamespace: this.i18nNamespace,
+            });
+        }
+        finally {
+            this.saving.set(false);
+        }
+    }
+    dismiss() {
+        this._modalRef?.dismiss(null, 'cancel');
+    }
+    t(key) {
+        return this.i18n.t(key, this.i18nNamespace);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: EditOrgModalComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: EditOrgModalComponent, isStandalone: true, selector: "val-edit-org-modal", inputs: { _modalRef: "_modalRef", org: "org", 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('title'), size: 'small', color: 'dark' }" />
+      <val-title
+        [props]="{
+          content: t('subtitle'),
+          size: 'large',
+          color: '',
+          bold: false,
+        }"
+      />
+      <val-form [props]="formMeta()" (onSubmit)="onFormSubmit($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: EditOrgModalComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'val-edit-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('title'), size: 'small', color: 'dark' }" />
+      <val-title
+        [props]="{
+          content: t('subtitle'),
+          size: 'large',
+          color: '',
+          bold: false,
+        }"
+      />
+      <val-form [props]="formMeta()" (onSubmit)="onFormSubmit($event)" />
+    </ion-content>
+  `,
+                }]
+        }], ctorParameters: () => [], propDecorators: { _modalRef: [{
+                type: Input
+            }], org: [{
+                type: Input
+            }], onSuccess: [{
+                type: Input
+            }], i18nNamespace: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"edit-org-modal.component.js","sourceRoot":"","sources":["../../../../../../../src/lib/components/organisms/edit-org-modal/edit-org-modal.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, effect, inject, Input, OnInit, 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 { AuthService } from '../../../services/auth/auth.service';\nimport { I18nService } from '../../../services/i18n';\nimport { OrgService } from '../../../services/org/org.service';\nimport { Organization } from '../../../services/org/types';\nimport { ToastService } from '../../../services/toast.service';\nimport { ValtechErrorService } from '../../../services/errors/valtech-error.service';\n\nimport { EDIT_ORG_MODAL_I18N } from './edit-org-modal.i18n';\n\nconst DEFAULT_NAMESPACE = 'EditOrgModal';\n\n/**\n * `val-edit-org-modal` — modal de edición de organización (nombre + descripción).\n * Promovido desde `showcase` bajo el proceso de ADR-021. Reusado por la vista de\n * gestión de organización (y futuras vistas org-aware).\n *\n * Edita la org vía `OrgService.updateOrg`. El formulario se construye una vez y se\n * mantiene reactivo a idioma + estado de trabajo vía effects `allowSignalWrites`.\n * Si el consumer no pasa `org`, cae al `activeOrgId` del `AuthService`.\n *\n * Abierto vía `ModalService` — recibe `_modalRef` por `componentProps` + callback\n * `onSuccess(updated)`. 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 * `EditOrgModal`.\n */\n@Component({\n  selector: 'val-edit-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('title'), size: 'small', color: 'dark' }\" />\n      <val-title\n        [props]=\"{\n          content: t('subtitle'),\n          size: 'large',\n          color: '',\n          bold: false,\n        }\"\n      />\n      <val-form [props]=\"formMeta()\" (onSubmit)=\"onFormSubmit($event)\" />\n    </ion-content>\n  `,\n})\nexport class EditOrgModalComponent implements OnInit {\n  private i18n = inject(I18nService);\n  private orgService = inject(OrgService);\n  private toast = inject(ToastService);\n  private errors = inject(ValtechErrorService);\n  private auth = inject(AuthService);\n\n  /** Inyectado por `ModalService.open` — referencia para cerrar desde dentro. */\n  @Input() _modalRef?: { dismiss: (data?: unknown, role?: string) => void };\n\n  /** Organización a editar (pasada por `componentProps`). */\n  @Input() org: Organization | null = null;\n\n  /** Callback tras actualizar la org (pasado por `componentProps`). */\n  @Input() onSuccess?: (updated: Organization) => void;\n\n  /** Namespace i18n con que la vista resuelve sus textos. */\n  @Input() i18nNamespace = DEFAULT_NAMESPACE;\n\n  private readonly saving = signal(false);\n  readonly formMeta: WritableSignal<FormMetadata>;\n\n  constructor() {\n    if (!this.i18n.hasNamespace(DEFAULT_NAMESPACE)) {\n      this.i18n.registerContent(DEFAULT_NAMESPACE, EDIT_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 w = this.saving();\n        this.formMeta.update(m => ({\n          ...m,\n          state: w ? ComponentStates.WORKING : ComponentStates.ENABLED,\n          actions: {\n            ...m.actions,\n            state: w ? ComponentStates.WORKING : ComponentStates.ENABLED,\n          },\n        }));\n      },\n      { allowSignalWrites: true }\n    );\n  }\n\n  ngOnInit(): void {\n    this.formMeta.set(this.buildFormMeta());\n  }\n\n  private get activeOrgId(): string {\n    const u = this.auth.user() as {\n      activeOrgId?: string;\n      activeOrg?: string;\n    } | null;\n    return u?.activeOrgId ?? u?.activeOrg ?? '';\n  }\n\n  private buildFormMeta(): FormMetadata {\n    const nameField: InputMetadata = {\n      token: 'edit-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: this.org?.name ?? '',\n      state: ComponentStates.ENABLED,\n    } as InputMetadata;\n\n    const descField: InputMetadata = {\n      token: 'edit-org-desc',\n      name: 'description',\n      label: this.t('descriptionLabel'),\n      hint: '',\n      placeholder: this.t('descriptionPlaceholder'),\n      type: InputType.TEXTAREA,\n      order: 2,\n      validators: [],\n      errors: {},\n      value: this.org?.description ?? '',\n      state: ComponentStates.ENABLED,\n    } as InputMetadata;\n\n    return {\n      name: '',\n      state: ComponentStates.ENABLED,\n      sections: [{ name: '', order: 1, fields: [nameField, descField] }],\n      actions: {\n        text: this.t('saveCta'),\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: 'edit-org-submit',\n      },\n    };\n  }\n\n  onFormSubmit(event: FormSubmit): void {\n    const name = event.fields['name'] as string;\n    if (!name?.trim()) {\n      this.toast.show({\n        message: this.t('fillRequired'),\n        duration: 3000,\n        color: 'dark',\n        position: 'top',\n      });\n      return;\n    }\n    const description = (event.fields['description'] as string | undefined) ?? '';\n    void this.save(name, description);\n  }\n\n  private async save(name: string, description: string): Promise<void> {\n    const orgId = this.org?.id ?? this.activeOrgId;\n    if (!orgId || this.saving()) return;\n    this.saving.set(true);\n    try {\n      const updated = await firstValueFrom(this.orgService.updateOrg(orgId, { name, description }));\n      this.toast.show({\n        message: this.t('saveSuccess'),\n        color: 'dark',\n        duration: 3500,\n      });\n      this.onSuccess?.(updated);\n      this._modalRef?.dismiss(updated, 'confirm');\n    } catch (err) {\n      this.errors.handle(err, {\n        context: 'editOrgModal.save',\n        fallbackKey: 'saveError',\n        i18nNamespace: this.i18nNamespace,\n      });\n    } finally {\n      this.saving.set(false);\n    }\n  }\n\n  dismiss(): void {\n    this._modalRef?.dismiss(null, 'cancel');\n  }\n\n  t(key: string): string {\n    return this.i18n.t(key, this.i18nNamespace);\n  }\n}\n"]}

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

@@ -0,0 +1,38 @@
+/**
+ * Defaults i18n (es/en) embebidos en `val-edit-org-modal`. Auto-registrados en
+ * el constructor del componente si el consumer no proveyó el namespace
+ * (`EditOrgModal` por default). SOLO incluye las keys que el modal usa.
+ */
+export const EDIT_ORG_MODAL_I18N = {
+    es: {
+        title: 'Editar organización',
+        subtitle: 'Actualiza el nombre y descripción.',
+        nameLabel: 'Nombre',
+        namePlaceholder: 'Nombre de la organización',
+        nameRequired: 'El nombre es obligatorio.',
+        nameMin: 'Mínimo 2 caracteres.',
+        descriptionLabel: 'Descripción (opcional)',
+        descriptionPlaceholder: 'Describe tu organización',
+        saveCta: 'Guardar cambios',
+        close: 'Cancelar',
+        saveSuccess: 'Organización actualizada.',
+        saveError: 'No se pudo guardar. Intenta de nuevo.',
+        fillRequired: 'Completa todos los campos requeridos.',
+    },
+    en: {
+        title: 'Edit organization',
+        subtitle: 'Update the name and description.',
+        nameLabel: 'Name',
+        namePlaceholder: 'Organization name',
+        nameRequired: 'Name is required.',
+        nameMin: 'Minimum 2 characters.',
+        descriptionLabel: 'Description (optional)',
+        descriptionPlaceholder: 'Describe your organization',
+        saveCta: 'Save changes',
+        close: 'Cancel',
+        saveSuccess: 'Organization updated.',
+        saveError: 'Could not save. Please try again.',
+        fillRequired: 'Please fill in all required fields.',
+    },
+};
+//# sourceMappingURL=data:application/json;base64,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