valtech-components 2.0.985 → 2.0.986

package/esm2022/lib/components/organisms/account-view/account-view.i18n.mjs

@@ -0,0 +1,96 @@
+/**
+ * Defaults i18n (es/en) embebidos en `val-account-view`. Auto-registrados en el
+ * constructor del componente si el consumer no proveyó el namespace
+ * (`Settings.Account` por default). SOLO incluye las keys que la vista usa.
+ */
+export const ACCOUNT_VIEW_I18N = {
+    es: {
+        pageTitle: 'Cuenta',
+        pageDescription: 'Organizaciones y seguridad de la cuenta',
+        orgsTitle: 'Tus organizaciones',
+        orgsCurrent: 'Actual',
+        orgsEmpty: 'Aún no perteneces a otras organizaciones.',
+        orgsSwitch: 'Cambiar',
+        switchAccountCta: 'Cambiar de cuenta',
+        orgsViewAll: 'Ver todas',
+        orgsManage: 'Gestionar',
+        orgsEmptyHint: 'Aún no perteneces a otras organizaciones.',
+        orgsNewCta: 'Nueva organización',
+        orgsNewQuestion: '¿Necesitas otra organización?',
+        orgsNewHint: 'Crea un espacio separado para otro equipo, empresa o proyecto.',
+        orgsMoreInfo: 'Más información',
+        orgsInfoTitle: '¿Qué son las organizaciones?',
+        orgsInfoSubtitle: 'Todo lo que necesitas saber',
+        orgsInfoClose: 'Cerrar',
+        orgsInfoContent: 'Las organizaciones te permiten separar tus proyectos y datos por empresa, equipo o contexto. Puedes pertenecer a varias organizaciones y cambiar entre ellas en cualquier momento.\n\nCada organización tiene sus propios miembros, roles y permisos. La organización activa determina qué datos ves y qué acciones puedes realizar.\n\nPuedes crear una organización nueva o unirte a una existente mediante invitación.',
+        orgsTypePersonal: 'Personal',
+        orgsTypePrivate: 'Privada',
+        orgsTypePublic: 'Pública',
+        orgsTypeBusiness: 'Empresa',
+        orgsLabelType: 'Tipo',
+        orgsLabelRole: 'Rol',
+        orgsLabelStatus: 'Estado',
+        orgsStatusActive: 'Activa',
+        logoutTitle: 'Cerrar esta sesión',
+        logoutHint: 'Cierra tu sesión en este dispositivo.',
+        logout: 'Cerrar sesión',
+        dangerTitle: 'Zona peligrosa',
+        dangerDeleteTitle: 'Eliminar cuenta',
+        dangerDeleteHint: 'Borra tu cuenta y todos los datos asociados. Esta acción no se puede deshacer.',
+        dangerDeleteCta: 'Eliminar cuenta',
+        inviteAccepted: 'Te has unido a la organización.',
+        inviteDeclined: 'Invitación rechazada.',
+        accept: 'Aceptar',
+        decline: 'Rechazar',
+        pendingInvitesTitle: 'Invitaciones pendientes',
+        orgsErrorTitle: 'No se pudieron cargar las organizaciones',
+        orgsOfflineTitle: 'Sin conexión',
+        orgsOfflineHint: 'Verifica tu conexión e intenta de nuevo.',
+        orgsRetry: 'Reintentar',
+    },
+    en: {
+        pageTitle: 'Account',
+        pageDescription: 'Organizations and account security',
+        orgsTitle: 'Your organizations',
+        orgsCurrent: 'Active',
+        orgsEmpty: "You don't belong to other organizations yet.",
+        orgsSwitch: 'Switch',
+        switchAccountCta: 'Switch account',
+        orgsViewAll: 'View all',
+        orgsManage: 'Manage',
+        orgsEmptyHint: "You don't belong to other organizations yet.",
+        orgsNewCta: 'New organization',
+        orgsNewQuestion: 'Need another organization?',
+        orgsNewHint: 'Create a separate space for another team, company or project.',
+        orgsMoreInfo: 'More information',
+        orgsInfoTitle: 'What are organizations?',
+        orgsInfoSubtitle: 'Everything you need to know',
+        orgsInfoClose: 'Close',
+        orgsInfoContent: 'Organizations let you separate your projects and data by company, team, or context. You can belong to multiple organizations and switch between them at any time.\n\nEach organization has its own members, roles, and permissions. The active organization determines what data you see and what actions you can take.\n\nYou can create a new organization or join an existing one via invitation.',
+        orgsTypePersonal: 'Personal',
+        orgsTypePrivate: 'Private',
+        orgsTypePublic: 'Public',
+        orgsTypeBusiness: 'Business',
+        orgsLabelType: 'Type',
+        orgsLabelRole: 'Role',
+        orgsLabelStatus: 'Status',
+        orgsStatusActive: 'Active',
+        logoutTitle: 'Sign out of this device',
+        logoutHint: 'End your session on this device.',
+        logout: 'Sign out',
+        dangerTitle: 'Danger zone',
+        dangerDeleteTitle: 'Delete account',
+        dangerDeleteHint: 'Delete your account and all related data. This action cannot be undone.',
+        dangerDeleteCta: 'Delete account',
+        inviteAccepted: 'You have joined the organization.',
+        inviteDeclined: 'Invitation declined.',
+        accept: 'Accept',
+        decline: 'Decline',
+        pendingInvitesTitle: 'Pending invitations',
+        orgsErrorTitle: 'Could not load organizations',
+        orgsOfflineTitle: 'No connection',
+        orgsOfflineHint: 'Check your connection and try again.',
+        orgsRetry: 'Retry',
+    },
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"account-view.i18n.js","sourceRoot":"","sources":["../../../../../../../src/lib/components/organisms/account-view/account-view.i18n.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAqB;IACjD,EAAE,EAAE;QACF,SAAS,EAAE,QAAQ;QACnB,eAAe,EAAE,yCAAyC;QAC1D,SAAS,EAAE,oBAAoB;QAC/B,WAAW,EAAE,QAAQ;QACrB,SAAS,EAAE,2CAA2C;QACtD,UAAU,EAAE,SAAS;QACrB,gBAAgB,EAAE,mBAAmB;QACrC,WAAW,EAAE,WAAW;QACxB,UAAU,EAAE,WAAW;QACvB,aAAa,EAAE,2CAA2C;QAC1D,UAAU,EAAE,oBAAoB;QAChC,eAAe,EAAE,+BAA+B;QAChD,WAAW,EAAE,gEAAgE;QAC7E,YAAY,EAAE,iBAAiB;QAC/B,aAAa,EAAE,8BAA8B;QAC7C,gBAAgB,EAAE,6BAA6B;QAC/C,aAAa,EAAE,QAAQ;QACvB,eAAe,EACb,2ZAA2Z;QAC7Z,gBAAgB,EAAE,UAAU;QAC5B,eAAe,EAAE,SAAS;QAC1B,cAAc,EAAE,SAAS;QACzB,gBAAgB,EAAE,SAAS;QAC3B,aAAa,EAAE,MAAM;QACrB,aAAa,EAAE,KAAK;QACpB,eAAe,EAAE,QAAQ;QACzB,gBAAgB,EAAE,QAAQ;QAC1B,WAAW,EAAE,oBAAoB;QACjC,UAAU,EAAE,uCAAuC;QACnD,MAAM,EAAE,eAAe;QACvB,WAAW,EAAE,gBAAgB;QAC7B,iBAAiB,EAAE,iBAAiB;QACpC,gBAAgB,EACd,gFAAgF;QAClF,eAAe,EAAE,iBAAiB;QAClC,cAAc,EAAE,iCAAiC;QACjD,cAAc,EAAE,uBAAuB;QACvC,MAAM,EAAE,SAAS;QACjB,OAAO,EAAE,UAAU;QACnB,mBAAmB,EAAE,yBAAyB;QAC9C,cAAc,EAAE,0CAA0C;QAC1D,gBAAgB,EAAE,cAAc;QAChC,eAAe,EAAE,0CAA0C;QAC3D,SAAS,EAAE,YAAY;KACxB;IACD,EAAE,EAAE;QACF,SAAS,EAAE,SAAS;QACpB,eAAe,EAAE,oCAAoC;QACrD,SAAS,EAAE,oBAAoB;QAC/B,WAAW,EAAE,QAAQ;QACrB,SAAS,EAAE,8CAA8C;QACzD,UAAU,EAAE,QAAQ;QACpB,gBAAgB,EAAE,gBAAgB;QAClC,WAAW,EAAE,UAAU;QACvB,UAAU,EAAE,QAAQ;QACpB,aAAa,EAAE,8CAA8C;QAC7D,UAAU,EAAE,kBAAkB;QAC9B,eAAe,EAAE,4BAA4B;QAC7C,WAAW,EAAE,+DAA+D;QAC5E,YAAY,EAAE,kBAAkB;QAChC,aAAa,EAAE,yBAAyB;QACxC,gBAAgB,EAAE,6BAA6B;QAC/C,aAAa,EAAE,OAAO;QACtB,eAAe,EACb,sYAAsY;QACxY,gBAAgB,EAAE,UAAU;QAC5B,eAAe,EAAE,SAAS;QAC1B,cAAc,EAAE,QAAQ;QACxB,gBAAgB,EAAE,UAAU;QAC5B,aAAa,EAAE,MAAM;QACrB,aAAa,EAAE,MAAM;QACrB,eAAe,EAAE,QAAQ;QACzB,gBAAgB,EAAE,QAAQ;QAC1B,WAAW,EAAE,yBAAyB;QACtC,UAAU,EAAE,kCAAkC;QAC9C,MAAM,EAAE,UAAU;QAClB,WAAW,EAAE,aAAa;QAC1B,iBAAiB,EAAE,gBAAgB;QACnC,gBAAgB,EAAE,yEAAyE;QAC3F,eAAe,EAAE,gBAAgB;QACjC,cAAc,EAAE,mCAAmC;QACnD,cAAc,EAAE,sBAAsB;QACtC,MAAM,EAAE,QAAQ;QAChB,OAAO,EAAE,SAAS;QAClB,mBAAmB,EAAE,qBAAqB;QAC1C,cAAc,EAAE,8BAA8B;QAC9C,gBAAgB,EAAE,eAAe;QACjC,eAAe,EAAE,sCAAsC;QACvD,SAAS,EAAE,OAAO;KACnB;CACF,CAAC","sourcesContent":["import { LanguagesContent } from '../../../services/i18n/types';\n\n/**\n * Defaults i18n (es/en) embebidos en `val-account-view`. Auto-registrados en el\n * constructor del componente si el consumer no proveyó el namespace\n * (`Settings.Account` por default). SOLO incluye las keys que la vista usa.\n */\nexport const ACCOUNT_VIEW_I18N: LanguagesContent = {\n  es: {\n    pageTitle: 'Cuenta',\n    pageDescription: 'Organizaciones y seguridad de la cuenta',\n    orgsTitle: 'Tus organizaciones',\n    orgsCurrent: 'Actual',\n    orgsEmpty: 'Aún no perteneces a otras organizaciones.',\n    orgsSwitch: 'Cambiar',\n    switchAccountCta: 'Cambiar de cuenta',\n    orgsViewAll: 'Ver todas',\n    orgsManage: 'Gestionar',\n    orgsEmptyHint: 'Aún no perteneces a otras organizaciones.',\n    orgsNewCta: 'Nueva organización',\n    orgsNewQuestion: '¿Necesitas otra organización?',\n    orgsNewHint: 'Crea un espacio separado para otro equipo, empresa o proyecto.',\n    orgsMoreInfo: 'Más información',\n    orgsInfoTitle: '¿Qué son las organizaciones?',\n    orgsInfoSubtitle: 'Todo lo que necesitas saber',\n    orgsInfoClose: 'Cerrar',\n    orgsInfoContent:\n      'Las organizaciones te permiten separar tus proyectos y datos por empresa, equipo o contexto. Puedes pertenecer a varias organizaciones y cambiar entre ellas en cualquier momento.\\n\\nCada organización tiene sus propios miembros, roles y permisos. La organización activa determina qué datos ves y qué acciones puedes realizar.\\n\\nPuedes crear una organización nueva o unirte a una existente mediante invitación.',\n    orgsTypePersonal: 'Personal',\n    orgsTypePrivate: 'Privada',\n    orgsTypePublic: 'Pública',\n    orgsTypeBusiness: 'Empresa',\n    orgsLabelType: 'Tipo',\n    orgsLabelRole: 'Rol',\n    orgsLabelStatus: 'Estado',\n    orgsStatusActive: 'Activa',\n    logoutTitle: 'Cerrar esta sesión',\n    logoutHint: 'Cierra tu sesión en este dispositivo.',\n    logout: 'Cerrar sesión',\n    dangerTitle: 'Zona peligrosa',\n    dangerDeleteTitle: 'Eliminar cuenta',\n    dangerDeleteHint:\n      'Borra tu cuenta y todos los datos asociados. Esta acción no se puede deshacer.',\n    dangerDeleteCta: 'Eliminar cuenta',\n    inviteAccepted: 'Te has unido a la organización.',\n    inviteDeclined: 'Invitación rechazada.',\n    accept: 'Aceptar',\n    decline: 'Rechazar',\n    pendingInvitesTitle: 'Invitaciones pendientes',\n    orgsErrorTitle: 'No se pudieron cargar las organizaciones',\n    orgsOfflineTitle: 'Sin conexión',\n    orgsOfflineHint: 'Verifica tu conexión e intenta de nuevo.',\n    orgsRetry: 'Reintentar',\n  },\n  en: {\n    pageTitle: 'Account',\n    pageDescription: 'Organizations and account security',\n    orgsTitle: 'Your organizations',\n    orgsCurrent: 'Active',\n    orgsEmpty: \"You don't belong to other organizations yet.\",\n    orgsSwitch: 'Switch',\n    switchAccountCta: 'Switch account',\n    orgsViewAll: 'View all',\n    orgsManage: 'Manage',\n    orgsEmptyHint: \"You don't belong to other organizations yet.\",\n    orgsNewCta: 'New organization',\n    orgsNewQuestion: 'Need another organization?',\n    orgsNewHint: 'Create a separate space for another team, company or project.',\n    orgsMoreInfo: 'More information',\n    orgsInfoTitle: 'What are organizations?',\n    orgsInfoSubtitle: 'Everything you need to know',\n    orgsInfoClose: 'Close',\n    orgsInfoContent:\n      'Organizations let you separate your projects and data by company, team, or context. You can belong to multiple organizations and switch between them at any time.\\n\\nEach organization has its own members, roles, and permissions. The active organization determines what data you see and what actions you can take.\\n\\nYou can create a new organization or join an existing one via invitation.',\n    orgsTypePersonal: 'Personal',\n    orgsTypePrivate: 'Private',\n    orgsTypePublic: 'Public',\n    orgsTypeBusiness: 'Business',\n    orgsLabelType: 'Type',\n    orgsLabelRole: 'Role',\n    orgsLabelStatus: 'Status',\n    orgsStatusActive: 'Active',\n    logoutTitle: 'Sign out of this device',\n    logoutHint: 'End your session on this device.',\n    logout: 'Sign out',\n    dangerTitle: 'Danger zone',\n    dangerDeleteTitle: 'Delete account',\n    dangerDeleteHint: 'Delete your account and all related data. This action cannot be undone.',\n    dangerDeleteCta: 'Delete account',\n    inviteAccepted: 'You have joined the organization.',\n    inviteDeclined: 'Invitation declined.',\n    accept: 'Accept',\n    decline: 'Decline',\n    pendingInvitesTitle: 'Pending invitations',\n    orgsErrorTitle: 'Could not load organizations',\n    orgsOfflineTitle: 'No connection',\n    orgsOfflineHint: 'Check your connection and try again.',\n    orgsRetry: 'Retry',\n  },\n};\n"]}

package/esm2022/lib/components/organisms/account-view/account.routes.mjs

@@ -0,0 +1,29 @@
+import { AccountViewComponent } from './account-view.component';
+/**
+ * Helper para montar la vista Cuenta (`val-account-view`) como ruta en una app
+ * del factory. El `config` se pasa por route `data` (`accountConfig`) y el
+ * componente lo lee como fallback de su `@Input() config`.
+ *
+ * @example
+ * ```ts
+ * // settings.routes.ts
+ * export const settingsRoutes: Routes = [
+ *   ...provideValtechAccountRoutes(),
+ *   { path: 'preferences', loadComponent: () => ... },
+ * ];
+ *
+ * // con config acotada:
+ * ...provideValtechAccountRoutes({ config: { showDeleteAccount: false } }),
+ * ...provideValtechAccountRoutes({ config: { manageOrgRoute: '/app/org' } }),
+ * ```
+ */
+export function provideValtechAccountRoutes(opts) {
+    return [
+        {
+            path: opts?.path ?? 'account',
+            component: AccountViewComponent,
+            data: { accountConfig: opts?.config },
+        },
+    ];
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/components/organisms/account-view/types.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

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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