valtech-components 2.0.988 → 2.0.990

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

@@ -0,0 +1,148 @@
+/**
+ * Defaults i18n (es/en) embebidos en `val-organization-view`. Auto-registrados en
+ * el constructor del componente si el consumer no proveyó el namespace
+ * (`Settings.Organization` por default). SOLO incluye las keys que la vista usa.
+ *
+ * Portado de `ORG_I18N_CONTENT` (showcase) bajo el proceso de ADR-021.
+ */
+export const ORGANIZATION_VIEW_I18N = {
+    es: {
+        pageTitle: 'Organización',
+        pageDescription: 'Gestiona tu organización activa',
+        infoTitle: 'Información',
+        infoName: 'Nombre',
+        infoDescription: 'Descripción',
+        infoPlan: 'Plan',
+        infoType: 'Tipo',
+        editCta: 'Editar',
+        saveCta: 'Guardar',
+        cancelCta: 'Cancelar',
+        membersTitle: 'Miembros',
+        membersEmpty: 'Sin miembros aún.',
+        memberRoles: 'Roles',
+        inviteTitle: 'Invitar',
+        inviteEmail: 'Correo electrónico',
+        inviteRole: 'Rol',
+        inviteCta: 'Invitar',
+        inviteSuccess: 'Invitación enviada.',
+        inviteError: 'No se pudo enviar la invitación.',
+        membersError: 'No se pudieron cargar los miembros.',
+        leaveTitle: 'Salir de la organización',
+        leaveHint: 'Dejarás de tener acceso a esta organización.',
+        leaveCta: 'Salir',
+        leaveOwnerHint: 'Eres el propietario. Transfiere la propiedad antes de salir.',
+        leaveConfirm: '¿Salir de la organización?',
+        planFree: 'Gratuito',
+        planPro: 'Pro',
+        planEnterprise: 'Empresa',
+        saveSuccess: 'Organización actualizada.',
+        leaveSuccess: 'Has salido de la organización.',
+        errorTitle: 'No se pudo cargar la organización',
+        offlineTitle: 'Sin conexión',
+        offlineHint: 'Verifica tu conexión e intenta de nuevo.',
+        retry: 'Reintentar',
+        saveError: 'No se pudo guardar. Intenta de nuevo.',
+        leaveError: 'No se pudo salir. Intenta de nuevo.',
+        transferTitle: 'Transferir propiedad',
+        transferHint: 'Elige un miembro para transferirle la propiedad de la organización.',
+        transferSelect: 'Seleccionar nuevo propietario',
+        transferCta: 'Transferir',
+        transferConfirm: '¿Transferir la propiedad a este miembro? Perderás el rol de propietario.',
+        transferSuccess: 'Propiedad transferida.',
+        transferError: 'No se pudo transferir la propiedad.',
+        inviteCtaTitle: '¿Deseas agregar a alguien?',
+        inviteCtaHint: 'Invita a usuarios a unirse a tu organización.',
+        inviteOpen: 'Invitar',
+        viewMemberCta: 'Ver miembro',
+        roleViewer: 'Visor',
+        roleEditor: 'Editor',
+        roleAdmin: 'Admin',
+        roleSuperAdmin: 'Super Admin',
+        rolesSectionTitle: 'Roles y permisos',
+        rolesHint: 'Tu organización tiene roles que controlan lo que cada miembro puede ver y hacer. Cada rol lleva un conjunto de permisos asociados.',
+        rolesViewPerms: 'Ver roles y permisos',
+        rolesSystemBadge: 'Sistema',
+        permAll: 'Todo',
+        permUsers: 'Usuarios',
+        permDocuments: 'Documentos',
+        permRoles: 'Roles',
+        permMedia: 'Media',
+        permTemplates: 'Plantillas',
+        permRead: 'Leer',
+        permWrite: 'Escribir',
+        permCreate: 'Crear',
+        permDelete: 'Eliminar',
+        permManage: 'Gestionar',
+        membersShowMore: 'Ver más',
+    },
+    en: {
+        pageTitle: 'Organization',
+        pageDescription: 'Manage your active organization',
+        infoTitle: 'Information',
+        infoName: 'Name',
+        infoDescription: 'Description',
+        infoPlan: 'Plan',
+        infoType: 'Type',
+        editCta: 'Edit',
+        saveCta: 'Save',
+        cancelCta: 'Cancel',
+        membersTitle: 'Members',
+        membersEmpty: 'No members yet.',
+        memberRoles: 'Roles',
+        inviteTitle: 'Invite',
+        inviteEmail: 'Email address',
+        inviteRole: 'Role',
+        inviteCta: 'Invite',
+        inviteSuccess: 'Invitation sent.',
+        inviteError: 'Could not send invitation.',
+        membersError: 'Could not load members.',
+        leaveTitle: 'Leave organization',
+        leaveHint: 'You will lose access to this organization.',
+        leaveCta: 'Leave',
+        leaveOwnerHint: 'You are the owner. Transfer ownership before leaving.',
+        leaveConfirm: 'Leave this organization?',
+        planFree: 'Free',
+        planPro: 'Pro',
+        planEnterprise: 'Enterprise',
+        saveSuccess: 'Organization updated.',
+        leaveSuccess: 'You have left the organization.',
+        errorTitle: 'Could not load organization',
+        offlineTitle: 'No connection',
+        offlineHint: 'Check your connection and try again.',
+        retry: 'Retry',
+        saveError: 'Could not save. Please try again.',
+        leaveError: 'Could not leave. Please try again.',
+        transferTitle: 'Transfer ownership',
+        transferHint: 'Choose a member to transfer ownership of this organization.',
+        transferSelect: 'Select new owner',
+        transferCta: 'Transfer',
+        transferConfirm: 'Transfer ownership to this member? You will lose the owner role.',
+        transferSuccess: 'Ownership transferred.',
+        transferError: 'Could not transfer ownership.',
+        inviteCtaTitle: 'Want to add someone?',
+        inviteCtaHint: 'Invite users to join your organization.',
+        inviteOpen: 'Invite',
+        viewMemberCta: 'View member',
+        roleViewer: 'Viewer',
+        roleEditor: 'Editor',
+        roleAdmin: 'Admin',
+        roleSuperAdmin: 'Super Admin',
+        rolesSectionTitle: 'Roles & permissions',
+        rolesHint: 'Your organization has roles that control what each member can see and do. Each role carries a set of associated permissions.',
+        rolesViewPerms: 'View roles & permissions',
+        rolesSystemBadge: 'System',
+        permAll: 'All',
+        permUsers: 'Users',
+        permDocuments: 'Documents',
+        permRoles: 'Roles',
+        permMedia: 'Media',
+        permTemplates: 'Templates',
+        permRead: 'Read',
+        permWrite: 'Write',
+        permCreate: 'Create',
+        permDelete: 'Delete',
+        permManage: 'Manage',
+        membersShowMore: 'Show more',
+    },
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"organization-view.i18n.js","sourceRoot":"","sources":["../../../../../../../src/lib/components/organisms/organization-view/organization-view.i18n.ts"],"names":[],"mappings":"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","sourcesContent":["import { LanguagesContent } from '../../../services/i18n/types';\n\n/**\n * Defaults i18n (es/en) embebidos en `val-organization-view`. Auto-registrados en\n * el constructor del componente si el consumer no proveyó el namespace\n * (`Settings.Organization` por default). SOLO incluye las keys que la vista usa.\n *\n * Portado de `ORG_I18N_CONTENT` (showcase) bajo el proceso de ADR-021.\n */\nexport const ORGANIZATION_VIEW_I18N: LanguagesContent = {\n  es: {\n    pageTitle: 'Organización',\n    pageDescription: 'Gestiona tu organización activa',\n    infoTitle: 'Información',\n    infoName: 'Nombre',\n    infoDescription: 'Descripción',\n    infoPlan: 'Plan',\n    infoType: 'Tipo',\n    editCta: 'Editar',\n    saveCta: 'Guardar',\n    cancelCta: 'Cancelar',\n    membersTitle: 'Miembros',\n    membersEmpty: 'Sin miembros aún.',\n    memberRoles: 'Roles',\n    inviteTitle: 'Invitar',\n    inviteEmail: 'Correo electrónico',\n    inviteRole: 'Rol',\n    inviteCta: 'Invitar',\n    inviteSuccess: 'Invitación enviada.',\n    inviteError: 'No se pudo enviar la invitación.',\n    membersError: 'No se pudieron cargar los miembros.',\n    leaveTitle: 'Salir de la organización',\n    leaveHint: 'Dejarás de tener acceso a esta organización.',\n    leaveCta: 'Salir',\n    leaveOwnerHint: 'Eres el propietario. Transfiere la propiedad antes de salir.',\n    leaveConfirm: '¿Salir de la organización?',\n    planFree: 'Gratuito',\n    planPro: 'Pro',\n    planEnterprise: 'Empresa',\n    saveSuccess: 'Organización actualizada.',\n    leaveSuccess: 'Has salido de la organización.',\n    errorTitle: 'No se pudo cargar la organización',\n    offlineTitle: 'Sin conexión',\n    offlineHint: 'Verifica tu conexión e intenta de nuevo.',\n    retry: 'Reintentar',\n    saveError: 'No se pudo guardar. Intenta de nuevo.',\n    leaveError: 'No se pudo salir. Intenta de nuevo.',\n    transferTitle: 'Transferir propiedad',\n    transferHint: 'Elige un miembro para transferirle la propiedad de la organización.',\n    transferSelect: 'Seleccionar nuevo propietario',\n    transferCta: 'Transferir',\n    transferConfirm: '¿Transferir la propiedad a este miembro? Perderás el rol de propietario.',\n    transferSuccess: 'Propiedad transferida.',\n    transferError: 'No se pudo transferir la propiedad.',\n    inviteCtaTitle: '¿Deseas agregar a alguien?',\n    inviteCtaHint: 'Invita a usuarios a unirse a tu organización.',\n    inviteOpen: 'Invitar',\n    viewMemberCta: 'Ver miembro',\n    roleViewer: 'Visor',\n    roleEditor: 'Editor',\n    roleAdmin: 'Admin',\n    roleSuperAdmin: 'Super Admin',\n    rolesSectionTitle: 'Roles y permisos',\n    rolesHint:\n      'Tu organización tiene roles que controlan lo que cada miembro puede ver y hacer. Cada rol lleva un conjunto de permisos asociados.',\n    rolesViewPerms: 'Ver roles y permisos',\n    rolesSystemBadge: 'Sistema',\n    permAll: 'Todo',\n    permUsers: 'Usuarios',\n    permDocuments: 'Documentos',\n    permRoles: 'Roles',\n    permMedia: 'Media',\n    permTemplates: 'Plantillas',\n    permRead: 'Leer',\n    permWrite: 'Escribir',\n    permCreate: 'Crear',\n    permDelete: 'Eliminar',\n    permManage: 'Gestionar',\n    membersShowMore: 'Ver más',\n  },\n  en: {\n    pageTitle: 'Organization',\n    pageDescription: 'Manage your active organization',\n    infoTitle: 'Information',\n    infoName: 'Name',\n    infoDescription: 'Description',\n    infoPlan: 'Plan',\n    infoType: 'Type',\n    editCta: 'Edit',\n    saveCta: 'Save',\n    cancelCta: 'Cancel',\n    membersTitle: 'Members',\n    membersEmpty: 'No members yet.',\n    memberRoles: 'Roles',\n    inviteTitle: 'Invite',\n    inviteEmail: 'Email address',\n    inviteRole: 'Role',\n    inviteCta: 'Invite',\n    inviteSuccess: 'Invitation sent.',\n    inviteError: 'Could not send invitation.',\n    membersError: 'Could not load members.',\n    leaveTitle: 'Leave organization',\n    leaveHint: 'You will lose access to this organization.',\n    leaveCta: 'Leave',\n    leaveOwnerHint: 'You are the owner. Transfer ownership before leaving.',\n    leaveConfirm: 'Leave this organization?',\n    planFree: 'Free',\n    planPro: 'Pro',\n    planEnterprise: 'Enterprise',\n    saveSuccess: 'Organization updated.',\n    leaveSuccess: 'You have left the organization.',\n    errorTitle: 'Could not load organization',\n    offlineTitle: 'No connection',\n    offlineHint: 'Check your connection and try again.',\n    retry: 'Retry',\n    saveError: 'Could not save. Please try again.',\n    leaveError: 'Could not leave. Please try again.',\n    transferTitle: 'Transfer ownership',\n    transferHint: 'Choose a member to transfer ownership of this organization.',\n    transferSelect: 'Select new owner',\n    transferCta: 'Transfer',\n    transferConfirm: 'Transfer ownership to this member? You will lose the owner role.',\n    transferSuccess: 'Ownership transferred.',\n    transferError: 'Could not transfer ownership.',\n    inviteCtaTitle: 'Want to add someone?',\n    inviteCtaHint: 'Invite users to join your organization.',\n    inviteOpen: 'Invite',\n    viewMemberCta: 'View member',\n    roleViewer: 'Viewer',\n    roleEditor: 'Editor',\n    roleAdmin: 'Admin',\n    roleSuperAdmin: 'Super Admin',\n    rolesSectionTitle: 'Roles & permissions',\n    rolesHint:\n      'Your organization has roles that control what each member can see and do. Each role carries a set of associated permissions.',\n    rolesViewPerms: 'View roles & permissions',\n    rolesSystemBadge: 'System',\n    permAll: 'All',\n    permUsers: 'Users',\n    permDocuments: 'Documents',\n    permRoles: 'Roles',\n    permMedia: 'Media',\n    permTemplates: 'Templates',\n    permRead: 'Read',\n    permWrite: 'Write',\n    permCreate: 'Create',\n    permDelete: 'Delete',\n    permManage: 'Manage',\n    membersShowMore: 'Show more',\n  },\n};\n"]}

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

@@ -0,0 +1,30 @@
+import { OrganizationViewComponent } from './organization-view.component';
+/**
+ * Helper para montar la vista Gestión de organización (`val-organization-view`)
+ * como ruta en una app del factory. El `config` se pasa por route `data`
+ * (`organizationConfig`) y el componente lo lee como fallback de su
+ * `@Input() config`.
+ *
+ * @example
+ * ```ts
+ * // settings.routes.ts
+ * export const settingsRoutes: Routes = [
+ *   ...provideValtechOrganizationRoutes(),                 // → /app/settings/organization
+ *   { path: 'preferences', loadComponent: () => ... },
+ * ];
+ *
+ * // con config acotada:
+ * ...provideValtechOrganizationRoutes({ config: { showLeave: false } }),
+ * ...provideValtechOrganizationRoutes({ config: { viewPermissionsRoute: '/app/roles' } }),
+ * ```
+ */
+export function provideValtechOrganizationRoutes(opts) {
+    return [
+        {
+            path: opts?.path ?? 'organization',
+            component: OrganizationViewComponent,
+            data: { organizationConfig: opts?.config },
+        },
+    ];
+}
+//# sourceMappingURL=data:application/json;base64,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

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

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

package/esm2022/lib/components/organisms/transfer-ownership-modal/transfer-ownership-modal.component.mjs

@@ -0,0 +1,231 @@
+import { Component, computed, inject, Input, signal } from '@angular/core';
+import { IonButton, IonButtons, IonContent, IonHeader, IonToolbar } from '@ionic/angular/standalone';
+import { SearchbarComponent } from '../../molecules/searchbar/searchbar.component';
+import { DisplayComponent } from '../../atoms/display/display.component';
+import { TextComponent } from '../../atoms/text/text.component';
+import { TitleComponent } from '../../atoms/title/title.component';
+import { I18nService } from '../../../services/i18n';
+import { TRANSFER_OWNERSHIP_MODAL_I18N } from './transfer-ownership-modal.i18n';
+import * as i0 from "@angular/core";
+const DEFAULT_NAMESPACE = 'Settings.TransferModal';
+/**
+ * `val-transfer-ownership-modal` — selector de miembro para transferir la
+ * propiedad de la organización. Promovido desde `showcase` bajo el proceso de
+ * ADR-021.
+ *
+ * Recibe la lista de candidatos por `members` (todos excepto el owner actual),
+ * permite filtrarlos con `val-searchbar` y, al confirmar, ejecuta el callback
+ * `onConfirm(newOwnerId)`. La ejecución real de la transferencia (vía
+ * `OrgService.transferOwnership`) queda en el consumer.
+ *
+ * Abierto vía `ModalService` — recibe `_modalRef` por `componentProps`. Header
+ * canónico (Regla #5): sin `ion-title`, botón Cerrar texto en `slot=end`,
+ * título/subtítulo en el body con `val-display`/`val-title`.
+ *
+ * Auto-registra sus defaults i18n (es/en) si el consumer no proveyó el namespace
+ * `Settings.TransferModal`.
+ */
+export class TransferOwnershipModalComponent {
+    constructor() {
+        this.i18n = inject(I18nService);
+        /** Lista de miembros transferibles (todos excepto el owner actual). */
+        this.members = [];
+        /** Namespace i18n con que la vista resuelve sus textos. */
+        this.i18nNamespace = DEFAULT_NAMESPACE;
+        this.query = signal('');
+        this.selectedId = signal('');
+        this.filtered = computed(() => {
+            const q = this.query().trim().toLowerCase();
+            if (!q)
+                return this.members;
+            return this.members.filter(m => m.name?.toLowerCase().includes(q) ||
+                m.email?.toLowerCase().includes(q) ||
+                m.userId.toLowerCase().includes(q));
+        });
+        this.noResultsLabel = computed(() => `${this.t('noResults')} "${this.query()}"`);
+        if (!this.i18n.hasNamespace(DEFAULT_NAMESPACE)) {
+            this.i18n.registerContent(DEFAULT_NAMESPACE, TRANSFER_OWNERSHIP_MODAL_I18N);
+        }
+    }
+    ngOnInit() {
+        if (!this.i18n.hasNamespace(this.i18nNamespace)) {
+            this.i18n.registerContent(this.i18nNamespace, TRANSFER_OWNERSHIP_MODAL_I18N);
+        }
+    }
+    confirm() {
+        const id = this.selectedId();
+        if (!id)
+            return;
+        this.onConfirm?.(id);
+        this.dismiss();
+    }
+    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: TransferOwnershipModalComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.14", type: TransferOwnershipModalComponent, isStandalone: true, selector: "val-transfer-ownership-modal", inputs: { members: "members", onConfirm: "onConfirm", _modalRef: "_modalRef", i18nNamespace: "i18nNamespace" }, ngImport: i0, template: `
+    <ion-header>
+      <ion-toolbar>
+        <ion-buttons slot="end">
+          <ion-button fill="clear" color="dark" (click)="dismiss()">
+            <strong>{{ t('close') }}</strong>
+          </ion-button>
+        </ion-buttons>
+      </ion-toolbar>
+    </ion-header>
+
+    <ion-content class="ion-padding">
+      <val-display [props]="{ content: t('title'), size: 'small', color: 'dark' }" />
+      <val-title
+        [props]="{
+          content: t('hint'),
+          size: 'large',
+          color: '',
+          bold: false,
+        }"
+      />
+
+      <val-searchbar
+        [props]="{ placeholder: t('searchPlaceholder'), debounce: 150 }"
+        (filterEvent)="query.set($event)"
+      />
+
+      @if (members.length === 0) {
+        <val-text
+          [props]="{
+            content: t('empty'),
+            size: 'medium',
+            color: 'medium',
+            bold: false,
+          }"
+        />
+      } @else if (filtered().length === 0) {
+        <val-text
+          [props]="{
+            content: noResultsLabel(),
+            size: 'medium',
+            color: 'medium',
+            bold: false,
+          }"
+        />
+      } @else {
+        <div class="transfer-member-list">
+          @for (m of filtered(); track m.userId) {
+            <button
+              class="transfer-member-row"
+              [class.transfer-member-row--selected]="selectedId() === m.userId"
+              (click)="selectedId.set(m.userId)"
+              type="button"
+            >
+              <span class="transfer-member-name">{{ m.name || m.email || m.userId }}</span>
+              @if (selectedId() === m.userId) {
+                <span class="transfer-member-check">&#10003;</span>
+              }
+            </button>
+          }
+        </div>
+      }
+
+      <div class="transfer-confirm-row">
+        <ion-button expand="block" color="dark" [disabled]="!selectedId()" (click)="confirm()">
+          {{ t('confirmCta') }}
+        </ion-button>
+      </div>
+    </ion-content>
+  `, isInline: true, styles: ["val-display{display:block;margin-bottom:4px}val-title{display:block;margin-bottom:16px}val-searchbar{display:block;margin-bottom:12px}.transfer-member-list{display:flex;flex-direction:column;gap:4px}.transfer-member-row{display:flex;align-items:center;justify-content:space-between;padding:12px 16px;border-radius:10px;border:1.5px solid var(--ion-color-light);background:transparent;cursor:pointer;width:100%;text-align:left;font-size:15px;color:var(--ion-color-dark);transition:border-color .15s}.transfer-member-row--selected{border-color:var(--ion-color-dark);background:var(--ion-color-light)}.transfer-member-check{font-size:17px;color:var(--ion-color-dark)}.transfer-confirm-row{margin-top:24px}\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: SearchbarComponent, selector: "val-searchbar", inputs: ["preset", "props"], outputs: ["filterEvent", "focusEvent", "blurEvent"] }, { kind: "component", type: DisplayComponent, selector: "val-display", inputs: ["props"] }, { kind: "component", type: TextComponent, selector: "val-text", inputs: ["props"] }, { kind: "component", type: TitleComponent, selector: "val-title", inputs: ["props"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TransferOwnershipModalComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'val-transfer-ownership-modal', standalone: true, imports: [
+                        IonHeader,
+                        IonToolbar,
+                        IonButtons,
+                        IonButton,
+                        IonContent,
+                        SearchbarComponent,
+                        DisplayComponent,
+                        TextComponent,
+                        TitleComponent,
+                    ], template: `
+    <ion-header>
+      <ion-toolbar>
+        <ion-buttons slot="end">
+          <ion-button fill="clear" color="dark" (click)="dismiss()">
+            <strong>{{ t('close') }}</strong>
+          </ion-button>
+        </ion-buttons>
+      </ion-toolbar>
+    </ion-header>
+
+    <ion-content class="ion-padding">
+      <val-display [props]="{ content: t('title'), size: 'small', color: 'dark' }" />
+      <val-title
+        [props]="{
+          content: t('hint'),
+          size: 'large',
+          color: '',
+          bold: false,
+        }"
+      />
+
+      <val-searchbar
+        [props]="{ placeholder: t('searchPlaceholder'), debounce: 150 }"
+        (filterEvent)="query.set($event)"
+      />
+
+      @if (members.length === 0) {
+        <val-text
+          [props]="{
+            content: t('empty'),
+            size: 'medium',
+            color: 'medium',
+            bold: false,
+          }"
+        />
+      } @else if (filtered().length === 0) {
+        <val-text
+          [props]="{
+            content: noResultsLabel(),
+            size: 'medium',
+            color: 'medium',
+            bold: false,
+          }"
+        />
+      } @else {
+        <div class="transfer-member-list">
+          @for (m of filtered(); track m.userId) {
+            <button
+              class="transfer-member-row"
+              [class.transfer-member-row--selected]="selectedId() === m.userId"
+              (click)="selectedId.set(m.userId)"
+              type="button"
+            >
+              <span class="transfer-member-name">{{ m.name || m.email || m.userId }}</span>
+              @if (selectedId() === m.userId) {
+                <span class="transfer-member-check">&#10003;</span>
+              }
+            </button>
+          }
+        </div>
+      }
+
+      <div class="transfer-confirm-row">
+        <ion-button expand="block" color="dark" [disabled]="!selectedId()" (click)="confirm()">
+          {{ t('confirmCta') }}
+        </ion-button>
+      </div>
+    </ion-content>
+  `, styles: ["val-display{display:block;margin-bottom:4px}val-title{display:block;margin-bottom:16px}val-searchbar{display:block;margin-bottom:12px}.transfer-member-list{display:flex;flex-direction:column;gap:4px}.transfer-member-row{display:flex;align-items:center;justify-content:space-between;padding:12px 16px;border-radius:10px;border:1.5px solid var(--ion-color-light);background:transparent;cursor:pointer;width:100%;text-align:left;font-size:15px;color:var(--ion-color-dark);transition:border-color .15s}.transfer-member-row--selected{border-color:var(--ion-color-dark);background:var(--ion-color-light)}.transfer-member-check{font-size:17px;color:var(--ion-color-dark)}.transfer-confirm-row{margin-top:24px}\n"] }]
+        }], ctorParameters: () => [], propDecorators: { members: [{
+                type: Input
+            }], onConfirm: [{
+                type: Input
+            }], _modalRef: [{
+                type: Input
+            }], i18nNamespace: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transfer-ownership-modal.component.js","sourceRoot":"","sources":["../../../../../../../src/lib/components/organisms/transfer-ownership-modal/transfer-ownership-modal.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, computed, inject, Input, OnInit, signal } from '@angular/core';\nimport { IonButton, IonButtons, IonContent, IonHeader, IonToolbar } from '@ionic/angular/standalone';\n\nimport { SearchbarComponent } from '../../molecules/searchbar/searchbar.component';\nimport { DisplayComponent } from '../../atoms/display/display.component';\nimport { TextComponent } from '../../atoms/text/text.component';\nimport { TitleComponent } from '../../atoms/title/title.component';\n\nimport { I18nService } from '../../../services/i18n';\n\nimport { MemberCard } from './types';\nimport { TRANSFER_OWNERSHIP_MODAL_I18N } from './transfer-ownership-modal.i18n';\n\nconst DEFAULT_NAMESPACE = 'Settings.TransferModal';\n\n/**\n * `val-transfer-ownership-modal` — selector de miembro para transferir la\n * propiedad de la organización. Promovido desde `showcase` bajo el proceso de\n * ADR-021.\n *\n * Recibe la lista de candidatos por `members` (todos excepto el owner actual),\n * permite filtrarlos con `val-searchbar` y, al confirmar, ejecuta el callback\n * `onConfirm(newOwnerId)`. La ejecución real de la transferencia (vía\n * `OrgService.transferOwnership`) queda en el consumer.\n *\n * Abierto vía `ModalService` — recibe `_modalRef` por `componentProps`. Header\n * canónico (Regla #5): sin `ion-title`, botón Cerrar texto en `slot=end`,\n * título/subtítulo en el body con `val-display`/`val-title`.\n *\n * Auto-registra sus defaults i18n (es/en) si el consumer no proveyó el namespace\n * `Settings.TransferModal`.\n */\n@Component({\n  selector: 'val-transfer-ownership-modal',\n  standalone: true,\n  imports: [\n    IonHeader,\n    IonToolbar,\n    IonButtons,\n    IonButton,\n    IonContent,\n    SearchbarComponent,\n    DisplayComponent,\n    TextComponent,\n    TitleComponent,\n  ],\n  template: `\n    <ion-header>\n      <ion-toolbar>\n        <ion-buttons slot=\"end\">\n          <ion-button fill=\"clear\" color=\"dark\" (click)=\"dismiss()\">\n            <strong>{{ t('close') }}</strong>\n          </ion-button>\n        </ion-buttons>\n      </ion-toolbar>\n    </ion-header>\n\n    <ion-content class=\"ion-padding\">\n      <val-display [props]=\"{ content: t('title'), size: 'small', color: 'dark' }\" />\n      <val-title\n        [props]=\"{\n          content: t('hint'),\n          size: 'large',\n          color: '',\n          bold: false,\n        }\"\n      />\n\n      <val-searchbar\n        [props]=\"{ placeholder: t('searchPlaceholder'), debounce: 150 }\"\n        (filterEvent)=\"query.set($event)\"\n      />\n\n      @if (members.length === 0) {\n        <val-text\n          [props]=\"{\n            content: t('empty'),\n            size: 'medium',\n            color: 'medium',\n            bold: false,\n          }\"\n        />\n      } @else if (filtered().length === 0) {\n        <val-text\n          [props]=\"{\n            content: noResultsLabel(),\n            size: 'medium',\n            color: 'medium',\n            bold: false,\n          }\"\n        />\n      } @else {\n        <div class=\"transfer-member-list\">\n          @for (m of filtered(); track m.userId) {\n            <button\n              class=\"transfer-member-row\"\n              [class.transfer-member-row--selected]=\"selectedId() === m.userId\"\n              (click)=\"selectedId.set(m.userId)\"\n              type=\"button\"\n            >\n              <span class=\"transfer-member-name\">{{ m.name || m.email || m.userId }}</span>\n              @if (selectedId() === m.userId) {\n                <span class=\"transfer-member-check\">&#10003;</span>\n              }\n            </button>\n          }\n        </div>\n      }\n\n      <div class=\"transfer-confirm-row\">\n        <ion-button expand=\"block\" color=\"dark\" [disabled]=\"!selectedId()\" (click)=\"confirm()\">\n          {{ t('confirmCta') }}\n        </ion-button>\n      </div>\n    </ion-content>\n  `,\n  styles: [\n    `\n      val-display {\n        display: block;\n        margin-bottom: 4px;\n      }\n      val-title {\n        display: block;\n        margin-bottom: 16px;\n      }\n      val-searchbar {\n        display: block;\n        margin-bottom: 12px;\n      }\n      .transfer-member-list {\n        display: flex;\n        flex-direction: column;\n        gap: 4px;\n      }\n      .transfer-member-row {\n        display: flex;\n        align-items: center;\n        justify-content: space-between;\n        padding: 12px 16px;\n        border-radius: 10px;\n        border: 1.5px solid var(--ion-color-light);\n        background: transparent;\n        cursor: pointer;\n        width: 100%;\n        text-align: left;\n        font-size: 15px;\n        color: var(--ion-color-dark);\n        transition: border-color 0.15s;\n      }\n      .transfer-member-row--selected {\n        border-color: var(--ion-color-dark);\n        background: var(--ion-color-light);\n      }\n      .transfer-member-check {\n        font-size: 17px;\n        color: var(--ion-color-dark);\n      }\n      .transfer-confirm-row {\n        margin-top: 24px;\n      }\n    `,\n  ],\n})\nexport class TransferOwnershipModalComponent implements OnInit {\n  private i18n = inject(I18nService);\n\n  /** Lista de miembros transferibles (todos excepto el owner actual). */\n  @Input() members: MemberCard[] = [];\n\n  /** Callback ejecutado con el userId seleccionado tras confirmar. */\n  @Input() onConfirm?: (newOwnerId: string) => void;\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 query = signal('');\n  readonly selectedId = signal('');\n\n  readonly filtered = computed(() => {\n    const q = this.query().trim().toLowerCase();\n    if (!q) return this.members;\n    return this.members.filter(\n      m =>\n        m.name?.toLowerCase().includes(q) ||\n        m.email?.toLowerCase().includes(q) ||\n        m.userId.toLowerCase().includes(q)\n    );\n  });\n\n  readonly noResultsLabel = computed(() => `${this.t('noResults')} \"${this.query()}\"`);\n\n  constructor() {\n    if (!this.i18n.hasNamespace(DEFAULT_NAMESPACE)) {\n      this.i18n.registerContent(DEFAULT_NAMESPACE, TRANSFER_OWNERSHIP_MODAL_I18N);\n    }\n  }\n\n  ngOnInit(): void {\n    if (!this.i18n.hasNamespace(this.i18nNamespace)) {\n      this.i18n.registerContent(this.i18nNamespace, TRANSFER_OWNERSHIP_MODAL_I18N);\n    }\n  }\n\n  confirm(): void {\n    const id = this.selectedId();\n    if (!id) return;\n    this.onConfirm?.(id);\n    this.dismiss();\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/transfer-ownership-modal/transfer-ownership-modal.i18n.mjs

@@ -0,0 +1,27 @@
+/**
+ * Defaults i18n (es/en) embebidos en `val-transfer-ownership-modal`.
+ * Auto-registrados en el constructor del componente si el consumer no proveyó el
+ * namespace (`Settings.TransferModal` por default). SOLO incluye las keys que el
+ * modal usa.
+ */
+export const TRANSFER_OWNERSHIP_MODAL_I18N = {
+    es: {
+        title: 'Transferir propiedad',
+        hint: 'Selecciona el nuevo propietario de la organización.',
+        searchPlaceholder: 'Buscar miembro...',
+        empty: 'No hay otros miembros disponibles.',
+        noResults: 'Sin resultados para',
+        confirmCta: 'Confirmar transferencia',
+        close: 'Cancelar',
+    },
+    en: {
+        title: 'Transfer ownership',
+        hint: 'Select the new owner of the organization.',
+        searchPlaceholder: 'Search member...',
+        empty: 'No other members available.',
+        noResults: 'No results for',
+        confirmCta: 'Confirm transfer',
+        close: 'Cancel',
+    },
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/components/organisms/transfer-ownership-modal/types.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9zcmMvbGliL2NvbXBvbmVudHMvb3JnYW5pc21zL3RyYW5zZmVyLW93bmVyc2hpcC1tb2RhbC90eXBlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgT3JnTWVtYmVyIH0gZnJvbSAnLi4vLi4vLi4vc2VydmljZXMvb3JnL3R5cGVzJztcblxuLyoqXG4gKiBNaWVtYnJvIGRlIG9yZ2FuaXphY2nDs24gZW5yaXF1ZWNpZG8gY29uIGRhdG9zIGRlIHBlcmZpbCBww7pibGljb1xuICogKGBoYW5kbGVgL2BhdmF0YXJgKSwgY29uc3VtaWRvIHBvciBgdmFsLXRyYW5zZmVyLW93bmVyc2hpcC1tb2RhbGAgY29tbyBlbnRyYWRhXG4gKiBkZSBzdSBsaXN0YSBkZSBjYW5kaWRhdG9zLiBQcm9tb3ZpZG8gZGVzZGUgYHNob3djYXNlYCBiYWpvIGVsIHByb2Nlc28gZGVcbiAqIEFEUi0wMjEuXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgTWVtYmVyQ2FyZCBleHRlbmRzIE9yZ01lbWJlciB7XG4gIGhhbmRsZT86IHN0cmluZztcbiAgYXZhdGFyPzogc3RyaW5nO1xufVxuIl19

package/esm2022/lib/components/types.mjs

@@ -58,4 +58,4 @@ export var ToolbarActionType;
     ToolbarActionType["IMAGE"] = "IMAGE";
     ToolbarActionType["BUTTON"] = "BUTTON";
 })(ToolbarActionType || (ToolbarActionType = {}));
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../../src/lib/components/types.ts"],"names":[],"mappings":"AAQA,MAAM,OAAO,GAAmB,SAAS,CAAC;AAC1C,MAAM,QAAQ,GAAmB,UAAU,CAAC;AAC5C,MAAM,OAAO,GAAmB,SAAS,CAAC;AAC1C,MAAM,KAAK,GAAmB,OAAO,CAAC;AAEtC;;GAEG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC;AAErE;;GAEG;AACH,MAAM,CAAN,IAAY,UAMX;AAND,WAAY,UAAU;IACpB,iEAAe,CAAA;IACf,mEAAgB,CAAA;IAChB,iEAAe,CAAA;IACf,+DAAc,CAAA;IACd,uEAAkB,CAAA;AACpB,CAAC,EANW,UAAU,KAAV,UAAU,QAMrB;AAcD;;GAEG;AACH,MAAM,CAAN,IAAY,SA0BX;AA1BD,WAAY,SAAS;IACnB,yCAAI,CAAA;IACJ,iDAAQ,CAAA;IACR,2CAAK,CAAA;IACL,iDAAQ,CAAA;IACR,+CAAO,CAAA;IACP,6CAAM,CAAA;IACN,6DAAc,CAAA;IACd,iDAAQ,CAAA;IACR,yCAAI,CAAA;IACJ,qDAAU,CAAA;IACV,0CAAI,CAAA;IACJ,4CAAK,CAAA;IACL,4CAAK,CAAA;IACL,8CAAM,CAAA;IACN,4DAAa,CAAA;IACb,0DAAY,CAAA;IACZ,wEAAmB,CAAA;IACnB,0CAAI,CAAA;IACJ,8CAAM,CAAA;IACN,4CAAK,CAAA;IACL,4CAAK,CAAA;IACL,kDAAQ,CAAA;IACR,8DAAc,CAAA;IACd,8CAAM,CAAA;IACN,sDAAU,CAAA;AACZ,CAAC,EA1BW,SAAS,KAAT,SAAS,QA0BpB;AAyKD;;GAEG;AACH,MAAM,CAAN,IAAY,iBAKX;AALD,WAAY,iBAAiB;IAC3B,sCAAiB,CAAA;IACjB,kCAAa,CAAA;IACb,oCAAe,CAAA;IACf,sCAAiB,CAAA;AACnB,CAAC,EALW,iBAAiB,KAAjB,iBAAiB,QAK5B","sourcesContent":["import { FormControl, ValidatorFn } from '@angular/forms';\nimport { Color } from '@ionic/core';\nimport { ImageMetadata } from './atoms/image/types';\n\n/**\n * Possible states for an interactive component.\n */\nexport type ComponentState = 'ENABLED' | 'DISABLED' | 'WORKING' | 'ERROR';\nconst ENABLED: ComponentState = 'ENABLED';\nconst DISABLED: ComponentState = 'DISABLED';\nconst WORKING: ComponentState = 'WORKING';\nconst ERROR: ComponentState = 'ERROR';\n\n/**\n * Object containing all possible component states.\n */\nexport const ComponentStates = { ENABLED, DISABLED, WORKING, ERROR };\n\n/**\n * Types of actions that a button or link can perform.\n */\nexport enum ActionType {\n  BROWSER_NEW_TAB, // Open in a new browser tab\n  BROWSER_DOWNLOAD, // Download via browser\n  NATIVE_DOWNLOAD, // Download using native capabilities\n  APP_NAVIGATION, // Internal app navigation\n  BROWSER_NAVIGATION, // Navigation in the browser\n}\n\n/**\n * Represents an executable action for a button or link.\n */\nexport type Action = {\n  /** Action description */\n  description: string;\n  /** Action type */\n  type: ActionType;\n  /** Action source or destination */\n  source: string;\n};\n\n/**\n * Supported input types for forms.\n */\nexport enum InputType {\n  TEXT,\n  TEXTAREA,\n  EMAIL,\n  PASSWORD,\n  COMMENT,\n  NUMBER,\n  NUMBER_FROM_TO,\n  PIN_CODE,\n  DATE,\n  DATE_RANGE,\n  HOUR,\n  CHECK,\n  RADIO,\n  SELECT,\n  SEARCH_SELECT,\n  MULTI_SELECT,\n  MULTI_SELECT_SIMPLE,\n  FILE,\n  TOGGLE,\n  RANGE,\n  PHONE,\n  CURRENCY,\n  CHECKBOX_RADIO,\n  HANDLE,\n  ATTACHMENT,\n}\n\n/**\n * Option for select, radio, etc. inputs.\n */\nexport type InputOption = {\n  /** Unique option identifier */\n  id: string;\n  /** Display name */\n  name: string;\n  /** Whether the option is selected by default */\n  selected?: boolean;\n  /** Display order */\n  order: number;\n};\n\n/**\n * Metadata for a form field.\n */\nexport type InputMetadata = {\n  /** Associated form control (optional, created internally by val-form) */\n  control?: FormControl;\n  /** From control (only for NUMBER_FROM_TO type) */\n  fromControl?: FormControl;\n  /** To control (only for NUMBER_FROM_TO type) */\n  toControl?: FormControl;\n  /** Unique token for the input */\n  token: string;\n  /** Display label */\n  label: string;\n  /** Field name */\n  name: string;\n  /** Help text (shown below input, for validation hints) */\n  hint: string;\n  /** Description text (shown below label, explains the field purpose) */\n  description?: string;\n  /** Input placeholder */\n  placeholder: string;\n  /** Input type */\n  type: InputType;\n  /** Display order */\n  order: number;\n  /** Associated validators */\n  validators: ValidatorFn[];\n  /** Options (for select, radio, etc.) */\n  options?: InputOption[];\n  /** Allowed range (for number, date, etc.) */\n  range?: {\n    min: number;\n    max: number;\n  };\n  /** Custom error messages */\n  errors: {\n    [key: string]: string;\n  };\n  /** Initial value for the field */\n  value?: string;\n  /** Default value configuration - string for custom defaults, true for auto defaults */\n  withDefault?: string | boolean;\n  /** Field state */\n  state: ComponentState;\n  /** Label for \"from\" field (only for NUMBER_FROM_TO type) */\n  fromLabel?: string;\n  /** Label for \"to\" field (only for NUMBER_FROM_TO type) */\n  toLabel?: string;\n  /** Placeholder for \"from\" field (only for NUMBER_FROM_TO type) */\n  fromPlaceholder?: string;\n  /** Placeholder for \"to\" field (only for NUMBER_FROM_TO type) */\n  toPlaceholder?: string;\n\n  // i18n support properties\n  /** Key for content lookup */\n  contentKey?: string;\n  /** Component class name for content lookup */\n  contentClass?: string;\n  /** Fallback text if content key is not found */\n  contentFallback?: string;\n\n  // select-input specific i18n properties\n  /** Custom header text for select modal */\n  modalHeader?: string;\n  /** Custom cancel button text for select modal */\n  cancelText?: string;\n  /** Custom OK button text for select modal */\n  okText?: string;\n  /** Interface del ion-select (default: 'popover'). 'modal' para listas largas. */\n  selectInterface?: 'popover' | 'modal' | 'action-sheet' | 'alert';\n\n  // check-input specific properties\n  /** Position of label for checkbox ('start' | 'end') */\n  labelPlacement?: 'start' | 'end';\n\n  // PIN_CODE specific properties\n  /** Number of digits in PIN (default: 5, only for PIN_CODE type) */\n  length?: number;\n  /** Size of the input boxes: 'small' | 'medium' | 'large' (default: 'medium', only for PIN_CODE type) */\n  size?: 'small' | 'medium' | 'large';\n  /** Allow only numbers (default: true, only for PIN_CODE type) */\n  allowNumbersOnly?: boolean;\n  /** Mask input - show dots instead of characters (only for PIN_CODE type) */\n  mask?: boolean;\n  /** Auto focus first input (only for PIN_CODE type) */\n  autoFocus?: boolean;\n  /** Custom input styles (only for PIN_CODE type) */\n  inputStyles?: Record<string, string>;\n\n  /** Upload function (only for ATTACHMENT type). Receives a File, must resolve to the uploaded URL. */\n  uploadFn?: (file: File) => Promise<string>;\n};\n\n/**\n * A section in a form, grouping multiple fields.\n */\nexport type FormSection = {\n  /** Section name */\n  name: string;\n  /** Display order */\n  order: number;\n  /** Fields included in the section */\n  fields: InputMetadata[];\n};\n\n/**\n * Data sent when submitting a form.\n */\nexport type FormSubmit = {\n  /** Form field values as key-value pairs */\n  fields: Record<string, any>;\n  /** Optional token for the operation */\n  token?: string;\n};\n\n/**\n * Metadata for a complete form.\n */\nexport type FormMetadata = {\n  /** Form name */\n  name: string;\n  /** Form sections */\n  sections: FormSection[];\n  /**\n   * Configuración del botón de submit. Opcional: en modo `controlled` el form\n   * no renderiza submit propio (lo maneja el host) y `actions` se ignora.\n   */\n  actions?: ButtonMetadata;\n  /** Global form state */\n  state: ComponentState;\n  /**\n   * Espacio vertical entre campos, en px. Si se omite, usa el default\n   * responsivo de la lib (8px mobile / 12px desktop). Útil para formularios\n   * densos o más aireados sin tocar CSS del consumer.\n   */\n  fieldSpacing?: number;\n  /**\n   * Modo embebido: el form NO renderiza su button-group/footer de submit.\n   * Solo campos + validación. Para wizards/hosts que controlan la navegación\n   * y leen el estado del form vía `@ViewChild(FormComponent)` (signals públicos\n   * `value`/`valid` + método `validate()`/`markAllTouched()`).\n   * Cuando es `true`, ignora `stickyFooter`.\n   */\n  controlled?: boolean;\n  /**\n   * Fija el button-group de submit al fondo (`position: sticky; bottom: 0`)\n   * para modales largos con scroll. Solo aplica si NO es `controlled`.\n   * Por defecto (sin flags) el submit es inline al final del form.\n   */\n  stickyFooter?: boolean;\n};\n\n/**\n * Possible action types for a toolbar.\n */\nexport enum ToolbarActionType {\n  AVATAR = 'AVATAR',\n  ICON = 'ICON',\n  IMAGE = 'IMAGE',\n  BUTTON = 'BUTTON',\n}\n\n/**\n * Toolbar action definition.\n */\nexport type ToolbarAction = {\n  /** Action type */\n  type: 'AVATAR' | 'ICON' | 'IMAGE' | 'BUTTON';\n  /** Optional token identifier */\n  token?: string;\n  /** Toolbar position */\n  position: 'left' | 'right' | 'center';\n  /** Optional description */\n  description?: string;\n  /** Associated image (if any) */\n  image?: ImageMetadata;\n  /**\n   * User shape para el modo `AVATAR` — habilita fallback inteligente:\n   * foto → iniciales (de `name`/`email`) → icono persona. Si se omite, el\n   * toolbar solo muestra la imagen pasada en `description`.\n   */\n  user?: { name?: string; email?: string; avatarUrl?: string; handle?: string } | null;\n  /** Controls avatar size when type is AVATAR. Defaults to 'small'. */\n  avatarSize?: 'xsmall' | 'small' | 'medium' | 'large' | 'xlarge';\n};\n\n/**\n * Metadata for an icon.\n */\nexport interface IconMetada {\n  /** Icon name */\n  name: string;\n  /** Icon slot position */\n  slot: 'start' | 'end';\n}\n\n/**\n * Button configuration object.\n * Supports both static and reactive content.\n * @type {ButtonMetadata}\n * @property text - Static button label (takes precedence over textConfig).\n * @property textConfig - Reactive content configuration for button text.\n * @property color - The button color (Ionic color string).\n * @property icon - Icon to display (optional).\n * @property state - Button state (enabled, disabled, working, etc.).\n * @property expand, fill, size, shape, href, target, download, handler, etc. - See ButtonMetadata for all options.\n */\nexport interface ButtonMetadata {\n  /** Associated action type */\n  actionType?: ActionType;\n  /** Button expansion */\n  expand?: 'full' | 'block';\n  /** Associated link */\n  link?: string;\n  /** Associated href link */\n  href?: string;\n  /** Link target */\n  target?: '_blank' | '_self' | '_parent' | '_top';\n  /** Download file name */\n  download?: string;\n  /** Button color */\n  color: Color;\n  /** Button state */\n  state: ComponentState;\n  /** Static display text (takes precedence over reactive content) */\n  text?: string;\n  /** Reactive content configuration for button text */\n  contentKey?: string;\n  /** Component class name for content lookup (required with contentKey) */\n  contentClass?: string;\n  /** Fallback text if contentKey is not found */\n  contentFallback?: string;\n  /** Values to interpolate into the content string */\n  contentInterpolation?: Record<string, string | number>;\n  /** Associated icon */\n  icon?: IconMetada;\n  /** Button shape */\n  shape?: 'round';\n  /** Button size */\n  size?: 'small' | 'default' | 'large';\n  /** Button fill */\n  fill?: 'clear' | 'outline' | 'solid' | 'default';\n  /** Button type */\n  type: 'button' | 'submit' | 'reset';\n  /** Optional token identifier */\n  token?: string;\n  /** Optional reference */\n  ref?: any;\n  /** Action handler */\n  handler?: (value: any) => any | Promise<any>;\n}\n\n/**\n * Configuration for reactive content in val-button component.\n * Use this interface when you only need to specify content-related properties.\n * This follows the same pattern as TextContentConfig for consistency.\n */\nexport interface ButtonContentConfig {\n  contentKey: string;\n  contentClass: string;\n  contentFallback?: string;\n  contentInterpolation?: Record<string, string | number>;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../../src/lib/components/types.ts"],"names":[],"mappings":"AAQA,MAAM,OAAO,GAAmB,SAAS,CAAC;AAC1C,MAAM,QAAQ,GAAmB,UAAU,CAAC;AAC5C,MAAM,OAAO,GAAmB,SAAS,CAAC;AAC1C,MAAM,KAAK,GAAmB,OAAO,CAAC;AAEtC;;GAEG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC;AAErE;;GAEG;AACH,MAAM,CAAN,IAAY,UAMX;AAND,WAAY,UAAU;IACpB,iEAAe,CAAA;IACf,mEAAgB,CAAA;IAChB,iEAAe,CAAA;IACf,+DAAc,CAAA;IACd,uEAAkB,CAAA;AACpB,CAAC,EANW,UAAU,KAAV,UAAU,QAMrB;AAcD;;GAEG;AACH,MAAM,CAAN,IAAY,SA0BX;AA1BD,WAAY,SAAS;IACnB,yCAAI,CAAA;IACJ,iDAAQ,CAAA;IACR,2CAAK,CAAA;IACL,iDAAQ,CAAA;IACR,+CAAO,CAAA;IACP,6CAAM,CAAA;IACN,6DAAc,CAAA;IACd,iDAAQ,CAAA;IACR,yCAAI,CAAA;IACJ,qDAAU,CAAA;IACV,0CAAI,CAAA;IACJ,4CAAK,CAAA;IACL,4CAAK,CAAA;IACL,8CAAM,CAAA;IACN,4DAAa,CAAA;IACb,0DAAY,CAAA;IACZ,wEAAmB,CAAA;IACnB,0CAAI,CAAA;IACJ,8CAAM,CAAA;IACN,4CAAK,CAAA;IACL,4CAAK,CAAA;IACL,kDAAQ,CAAA;IACR,8DAAc,CAAA;IACd,8CAAM,CAAA;IACN,sDAAU,CAAA;AACZ,CAAC,EA1BW,SAAS,KAAT,SAAS,QA0BpB;AAyKD;;GAEG;AACH,MAAM,CAAN,IAAY,iBAKX;AALD,WAAY,iBAAiB;IAC3B,sCAAiB,CAAA;IACjB,kCAAa,CAAA;IACb,oCAAe,CAAA;IACf,sCAAiB,CAAA;AACnB,CAAC,EALW,iBAAiB,KAAjB,iBAAiB,QAK5B","sourcesContent":["import { FormControl, ValidatorFn } from '@angular/forms';\nimport { Color } from '@ionic/core';\nimport { ImageMetadata } from './atoms/image/types';\n\n/**\n * Possible states for an interactive component.\n */\nexport type ComponentState = 'ENABLED' | 'DISABLED' | 'WORKING' | 'ERROR';\nconst ENABLED: ComponentState = 'ENABLED';\nconst DISABLED: ComponentState = 'DISABLED';\nconst WORKING: ComponentState = 'WORKING';\nconst ERROR: ComponentState = 'ERROR';\n\n/**\n * Object containing all possible component states.\n */\nexport const ComponentStates = { ENABLED, DISABLED, WORKING, ERROR };\n\n/**\n * Types of actions that a button or link can perform.\n */\nexport enum ActionType {\n  BROWSER_NEW_TAB, // Open in a new browser tab\n  BROWSER_DOWNLOAD, // Download via browser\n  NATIVE_DOWNLOAD, // Download using native capabilities\n  APP_NAVIGATION, // Internal app navigation\n  BROWSER_NAVIGATION, // Navigation in the browser\n}\n\n/**\n * Represents an executable action for a button or link.\n */\nexport type Action = {\n  /** Action description */\n  description: string;\n  /** Action type */\n  type: ActionType;\n  /** Action source or destination */\n  source: string;\n};\n\n/**\n * Supported input types for forms.\n */\nexport enum InputType {\n  TEXT,\n  TEXTAREA,\n  EMAIL,\n  PASSWORD,\n  COMMENT,\n  NUMBER,\n  NUMBER_FROM_TO,\n  PIN_CODE,\n  DATE,\n  DATE_RANGE,\n  HOUR,\n  CHECK,\n  RADIO,\n  SELECT,\n  SEARCH_SELECT,\n  MULTI_SELECT,\n  MULTI_SELECT_SIMPLE,\n  FILE,\n  TOGGLE,\n  RANGE,\n  PHONE,\n  CURRENCY,\n  CHECKBOX_RADIO,\n  HANDLE,\n  ATTACHMENT,\n}\n\n/**\n * Option for select, radio, etc. inputs.\n */\nexport type InputOption = {\n  /** Unique option identifier */\n  id: string;\n  /** Display name */\n  name: string;\n  /** Whether the option is selected by default */\n  selected?: boolean;\n  /** Display order */\n  order: number;\n};\n\n/**\n * Metadata for a form field.\n */\nexport type InputMetadata = {\n  /** Associated form control (optional, created internally by val-form) */\n  control?: FormControl;\n  /** From control (only for NUMBER_FROM_TO type) */\n  fromControl?: FormControl;\n  /** To control (only for NUMBER_FROM_TO type) */\n  toControl?: FormControl;\n  /** Unique token for the input */\n  token: string;\n  /** Display label */\n  label: string;\n  /** Field name */\n  name: string;\n  /** Help text (shown below input, for validation hints) */\n  hint: string;\n  /** Description text (shown below label, explains the field purpose) */\n  description?: string;\n  /** Input placeholder */\n  placeholder: string;\n  /** Input type */\n  type: InputType;\n  /** Display order */\n  order: number;\n  /** Associated validators */\n  validators: ValidatorFn[];\n  /** Options (for select, radio, etc.) */\n  options?: InputOption[];\n  /** Allowed range (for number, date, etc.) */\n  range?: {\n    min: number;\n    max: number;\n  };\n  /** Custom error messages */\n  errors: {\n    [key: string]: string;\n  };\n  /** Initial value for the field */\n  value?: string;\n  /** Default value configuration - string for custom defaults, true for auto defaults */\n  withDefault?: string | boolean;\n  /** Field state */\n  state: ComponentState;\n  /** Label for \"from\" field (only for NUMBER_FROM_TO type) */\n  fromLabel?: string;\n  /** Label for \"to\" field (only for NUMBER_FROM_TO type) */\n  toLabel?: string;\n  /** Placeholder for \"from\" field (only for NUMBER_FROM_TO type) */\n  fromPlaceholder?: string;\n  /** Placeholder for \"to\" field (only for NUMBER_FROM_TO type) */\n  toPlaceholder?: string;\n\n  // i18n support properties\n  /** Key for content lookup */\n  contentKey?: string;\n  /** Component class name for content lookup */\n  contentClass?: string;\n  /** Fallback text if content key is not found */\n  contentFallback?: string;\n\n  // select-input specific i18n properties\n  /** Custom header text for select modal */\n  modalHeader?: string;\n  /** Custom cancel button text for select modal */\n  cancelText?: string;\n  /** Custom OK button text for select modal */\n  okText?: string;\n  /** Interface del ion-select (default: 'popover'). 'modal' para listas largas. */\n  selectInterface?: 'popover' | 'modal' | 'action-sheet' | 'alert';\n\n  // check-input specific properties\n  /** Position of label for checkbox ('start' | 'end') */\n  labelPlacement?: 'start' | 'end';\n\n  // PIN_CODE specific properties\n  /** Number of digits in PIN (default: 5, only for PIN_CODE type) */\n  length?: number;\n  /** Size of the input boxes: 'small' | 'medium' | 'large' (default: 'medium', only for PIN_CODE type) */\n  size?: 'small' | 'medium' | 'large';\n  /** Allow only numbers (default: true, only for PIN_CODE type) */\n  allowNumbersOnly?: boolean;\n  /** Mask input - show dots instead of characters (only for PIN_CODE type) */\n  mask?: boolean;\n  /** Auto focus first input (only for PIN_CODE type) */\n  autoFocus?: boolean;\n  /** Custom input styles (only for PIN_CODE type) */\n  inputStyles?: Record<string, string>;\n\n  /** Upload function (only for ATTACHMENT type). Receives a File, must resolve to the uploaded URL. */\n  uploadFn?: (file: File) => Promise<string>;\n};\n\n/**\n * A section in a form, grouping multiple fields.\n */\nexport type FormSection = {\n  /** Section name */\n  name: string;\n  /** Display order */\n  order: number;\n  /** Fields included in the section */\n  fields: InputMetadata[];\n};\n\n/**\n * Data sent when submitting a form.\n */\nexport type FormSubmit = {\n  /** Form field values as key-value pairs */\n  fields: Record<string, any>;\n  /** Optional token for the operation */\n  token?: string;\n};\n\n/**\n * Metadata for a complete form.\n */\nexport type FormMetadata = {\n  /** Form name */\n  name: string;\n  /** Form sections */\n  sections: FormSection[];\n  /**\n   * Configuración del botón de submit. Opcional: en modo `controlled` el form\n   * no renderiza submit propio (lo maneja el host) y `actions` se ignora.\n   */\n  actions?: ButtonMetadata;\n  /** Global form state */\n  state: ComponentState;\n  /**\n   * Espacio vertical entre campos, en px. Si se omite, usa el default\n   * responsivo de la lib (8px mobile / 12px desktop). Útil para formularios\n   * densos o más aireados sin tocar CSS del consumer.\n   */\n  fieldSpacing?: number;\n  /**\n   * Modo embebido: el form NO renderiza su button-group/footer de submit.\n   * Solo campos + validación. Para wizards/hosts que controlan la navegación\n   * y leen el estado del form vía `@ViewChild(FormComponent)` (signals públicos\n   * `value`/`valid` + método `validate()`/`markAllTouched()`).\n   * Cuando es `true`, ignora `stickyFooter`.\n   */\n  controlled?: boolean;\n  /**\n   * Fija el button-group de submit al fondo (`position: sticky; bottom: 0`)\n   * para modales largos con scroll. Solo aplica si NO es `controlled`.\n   * Por defecto (sin flags) el submit es inline al final del form.\n   */\n  stickyFooter?: boolean;\n};\n\n/**\n * Possible action types for a toolbar.\n */\nexport enum ToolbarActionType {\n  AVATAR = 'AVATAR',\n  ICON = 'ICON',\n  IMAGE = 'IMAGE',\n  BUTTON = 'BUTTON',\n}\n\n/**\n * Toolbar action definition.\n */\nexport type ToolbarAction = {\n  /** Action type */\n  type: 'AVATAR' | 'ICON' | 'IMAGE' | 'BUTTON';\n  /** Optional token identifier */\n  token?: string;\n  /** Toolbar position */\n  position: 'left' | 'right' | 'center';\n  /** Optional description */\n  description?: string;\n  /** Associated image (if any) */\n  image?: ImageMetadata;\n  /**\n   * User shape para el modo `AVATAR` — habilita fallback inteligente:\n   * foto → iniciales (de `name`/`email`) → icono persona. Si se omite, el\n   * toolbar solo muestra la imagen pasada en `description`.\n   */\n  user?: { name?: string; email?: string; avatarUrl?: string; handle?: string } | null;\n  /** Controls avatar size when type is AVATAR. Defaults to 'small'. */\n  avatarSize?: 'xsmall' | 'small' | 'medium' | 'large' | 'xlarge';\n};\n\n/**\n * Metadata for an icon.\n */\nexport interface IconMetada {\n  /** Icon name */\n  name: string;\n  /** Icon slot position */\n  slot: 'start' | 'end';\n}\n\n/**\n * Button configuration object.\n * Supports both static and reactive content.\n * @type {ButtonMetadata}\n * @property text - Static button label (takes precedence over textConfig).\n * @property textConfig - Reactive content configuration for button text.\n * @property color - The button color (Ionic color string).\n * @property icon - Icon to display (optional).\n * @property state - Button state (enabled, disabled, working, etc.).\n * @property expand, fill, size, shape, href, target, download, handler, etc. - See ButtonMetadata for all options.\n */\nexport interface ButtonMetadata {\n  /** Associated action type */\n  actionType?: ActionType;\n  /** Button expansion */\n  expand?: 'full' | 'block';\n  /** Associated link */\n  link?: string;\n  /** Associated href link */\n  href?: string;\n  /** Angular router link (SPA navigation, no reload) */\n  routerLink?: string | any[];\n  /** Link target */\n  target?: '_blank' | '_self' | '_parent' | '_top';\n  /** Download file name */\n  download?: string;\n  /** Button color */\n  color: Color;\n  /** Button state */\n  state: ComponentState;\n  /** Static display text (takes precedence over reactive content) */\n  text?: string;\n  /** Reactive content configuration for button text */\n  contentKey?: string;\n  /** Component class name for content lookup (required with contentKey) */\n  contentClass?: string;\n  /** Fallback text if contentKey is not found */\n  contentFallback?: string;\n  /** Values to interpolate into the content string */\n  contentInterpolation?: Record<string, string | number>;\n  /** Associated icon */\n  icon?: IconMetada;\n  /** Button shape */\n  shape?: 'round';\n  /** Button size */\n  size?: 'small' | 'default' | 'large';\n  /** Button fill */\n  fill?: 'clear' | 'outline' | 'solid' | 'default';\n  /** Button type */\n  type: 'button' | 'submit' | 'reset';\n  /** Optional token identifier */\n  token?: string;\n  /** Optional reference */\n  ref?: any;\n  /** Action handler */\n  handler?: (value: any) => any | Promise<any>;\n}\n\n/**\n * Configuration for reactive content in val-button component.\n * Use this interface when you only need to specify content-related properties.\n * This follows the same pattern as TextContentConfig for consistency.\n */\nexport interface ButtonContentConfig {\n  contentKey: string;\n  contentClass: string;\n  contentFallback?: string;\n  contentInterpolation?: Record<string, string | number>;\n}\n"]}

package/esm2022/lib/version.mjs

@@ -2,5 +2,5 @@
  * Current version of valtech-components.
  * This is automatically updated during the publish process.
  */
-export const VERSION = '2.0.988';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyc2lvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9saWIvdmVyc2lvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7O0dBR0c7QUFDSCxNQUFNLENBQUMsTUFBTSxPQUFPLEdBQUcsU0FBUyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBDdXJyZW50IHZlcnNpb24gb2YgdmFsdGVjaC1jb21wb25lbnRzLlxuICogVGhpcyBpcyBhdXRvbWF0aWNhbGx5IHVwZGF0ZWQgZHVyaW5nIHRoZSBwdWJsaXNoIHByb2Nlc3MuXG4gKi9cbmV4cG9ydCBjb25zdCBWRVJTSU9OID0gJzIuMC45ODgnO1xuIl19
+export const VERSION = '2.0.990';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyc2lvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9saWIvdmVyc2lvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7O0dBR0c7QUFDSCxNQUFNLENBQUMsTUFBTSxPQUFPLEdBQUcsU0FBUyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBDdXJyZW50IHZlcnNpb24gb2YgdmFsdGVjaC1jb21wb25lbnRzLlxuICogVGhpcyBpcyBhdXRvbWF0aWNhbGx5IHVwZGF0ZWQgZHVyaW5nIHRoZSBwdWJsaXNoIHByb2Nlc3MuXG4gKi9cbmV4cG9ydCBjb25zdCBWRVJTSU9OID0gJzIuMC45OTAnO1xuIl19