valtech-components 2.0.988 → 2.0.989

package/esm2022/lib/components/organisms/invite-member-modal/invite-member-modal.i18n.mjs

@@ -0,0 +1,54 @@
+/**
+ * Defaults i18n (es/en) embebidos en `val-invite-member-modal`. Auto-registrados
+ * en el constructor del componente si el consumer no proveyó el namespace
+ * (`InviteModal` por default). SOLO incluye las keys que el modal usa.
+ */
+export const INVITE_MEMBER_MODAL_I18N = {
+    es: {
+        title: 'Invitar miembro',
+        subtitle: 'Busca por handle o escribe un correo para invitar.',
+        searchPlaceholder: 'Handle (@usuario) o correo...',
+        searchingLabel: 'Buscando...',
+        noResults: 'No se encontraron usuarios.',
+        inviteByEmail: 'Invitar por correo a:',
+        sendInvite: 'Enviar invitación',
+        sending: 'Enviando...',
+        success: 'Invitación enviada.',
+        successPlural: 'Invitaciones enviadas.',
+        close: 'Cerrar',
+        errorInvalid: 'Ingresa un handle o correo válido.',
+        sendSelected: 'Invitar seleccionados',
+        selectedLabel: 'Seleccionados',
+        roleLabel: 'Rol',
+        roleViewer: 'Visor',
+        roleViewerDesc: 'Solo lectura',
+        roleEditor: 'Editor',
+        roleEditorDesc: 'Puede editar contenido',
+        roleAdmin: 'Administrador',
+        roleAdminDesc: 'Gestión completa',
+    },
+    en: {
+        title: 'Invite member',
+        subtitle: 'Search by handle or enter an email to invite.',
+        searchPlaceholder: 'Handle (@user) or email...',
+        searchingLabel: 'Searching...',
+        noResults: 'No users found.',
+        inviteByEmail: 'Invite by email:',
+        sendInvite: 'Send invitation',
+        sending: 'Sending...',
+        success: 'Invitation sent.',
+        successPlural: 'Invitations sent.',
+        close: 'Close',
+        errorInvalid: 'Enter a valid handle or email.',
+        sendSelected: 'Invite selected',
+        selectedLabel: 'Selected',
+        roleLabel: 'Role',
+        roleViewer: 'Viewer',
+        roleViewerDesc: 'Read only',
+        roleEditor: 'Editor',
+        roleEditorDesc: 'Can edit content',
+        roleAdmin: 'Admin',
+        roleAdminDesc: 'Full management',
+    },
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/components/organisms/member-detail-modal/member-detail-modal.component.mjs

@@ -0,0 +1,406 @@
+import { Component, computed, inject, Input, signal } from '@angular/core';
+import { FormControl, ReactiveFormsModule } from '@angular/forms';
+import { firstValueFrom } from 'rxjs';
+import { IonButton, IonButtons, IonContent, IonHeader, IonToolbar } from '@ionic/angular/standalone';
+import { ButtonComponent } from '../../atoms/button/button.component';
+import { DisplayComponent } from '../../atoms/display/display.component';
+import { TextComponent } from '../../atoms/text/text.component';
+import { TitleComponent } from '../../atoms/title/title.component';
+import { UserAvatarComponent } from '../../atoms/user-avatar/user-avatar.component';
+import { SearchSelectorComponent } from '../../molecules/select-input/select-input.component';
+import { ComponentStates, InputType } from '../../types';
+import { I18nService } from '../../../services/i18n';
+import { OrgService } from '../../../services/org/org.service';
+import { ToastService } from '../../../services/toast.service';
+import { ValtechErrorService } from '../../../services/errors/valtech-error.service';
+import { ConfirmationDialogService } from '../../../services/confirmation-dialog/confirmation-dialog.service';
+import { MEMBER_DETAIL_MODAL_I18N } from './member-detail-modal.i18n';
+import * as i0 from "@angular/core";
+const DEFAULT_NAMESPACE = 'Settings.MemberDetail';
+/**
+ * `val-member-detail-modal` — detalle de miembro de organización: perfil, rol y
+ * permisos. Promovido desde `showcase` bajo el proceso de ADR-021.
+ *
+ * Si `canManage` es true, permite cambiar el rol (vía `OrgService.changeMemberRole`)
+ * y quitar al miembro (vía `OrgService.removeMember`, con confirmación destructiva).
+ * Los permisos del rol actual se muestran cuando el consumer los provee en
+ * `availableRoles`.
+ *
+ * Abierto vía `ModalService` — recibe `_modalRef` por `componentProps` + callback
+ * `onChanged`. Header canónico (Regla #5): sin `ion-title`, botón Cerrar texto en
+ * `slot=end`, identidad en el body con `val-user-avatar`/`val-display`/`val-title`.
+ *
+ * Auto-registra sus defaults i18n (es/en) si el consumer no proveyó el namespace
+ * `Settings.MemberDetail`.
+ */
+export class MemberDetailModalComponent {
+    constructor() {
+        this.orgService = inject(OrgService);
+        this.toast = inject(ToastService);
+        this.errors = inject(ValtechErrorService);
+        this.i18n = inject(I18nService);
+        this.confirmDialog = inject(ConfirmationDialogService);
+        /** Organización a la que pertenece el miembro. */
+        this.orgId = '';
+        /** Si true, habilita cambio de rol y eliminación. */
+        this.canManage = false;
+        /** Si true, el miembro mostrado es el propio usuario. */
+        this.isSelf = false;
+        /** Roles disponibles (con permisos opcionales) para el selector de rol. */
+        this.availableRoles = [
+            { id: 'viewer', name: 'viewer' },
+            { id: 'editor', name: 'editor' },
+            { id: 'admin', name: 'admin' },
+        ];
+        /** Namespace i18n con que la vista resuelve sus textos. */
+        this.i18nNamespace = DEFAULT_NAMESPACE;
+        this.working = signal(false);
+        this.currentRole = signal('');
+        this.roleControl = new FormControl('');
+        this.displayName = computed(() => this.member?.name || this.member?.handle || this.member?.email || '—');
+        this.subtitle = computed(() => {
+            if (this.isSelf)
+                return this.t('subtitleSelf');
+            if (this.member?.handle)
+                return '@' + this.member.handle;
+            return this.member?.email ?? '';
+        });
+        this.currentRoleLabel = computed(() => this.roleLabel(this.currentRole()));
+        this.permissionsForCurrentRole = computed(() => {
+            const roleId = this.currentRole();
+            const role = this.availableRoles.find(r => r.id === roleId || r.name === roleId);
+            return role?.permissions ?? [];
+        });
+        this.roleSelectProps = computed(() => ({
+            control: this.roleControl,
+            label: '',
+            placeholder: this.t('roleLabel'),
+            type: InputType.SELECT,
+            state: this.working() ? ComponentStates.DISABLED : ComponentStates.ENABLED,
+            options: this.availableRoles.map(r => ({
+                id: r.id,
+                name: this.roleLabel(r.name),
+                order: 0,
+            })),
+        }));
+        this.removeButtonProps = computed(() => ({
+            text: this.t('removeCta'),
+            token: 'member-remove',
+            color: 'danger',
+            fill: 'outline',
+            expand: 'block',
+            size: 'default',
+            type: 'button',
+            state: this.working() ? ComponentStates.WORKING : ComponentStates.ENABLED,
+        }));
+        if (!this.i18n.hasNamespace(DEFAULT_NAMESPACE)) {
+            this.i18n.registerContent(DEFAULT_NAMESPACE, MEMBER_DETAIL_MODAL_I18N);
+        }
+    }
+    ngOnInit() {
+        if (!this.i18n.hasNamespace(this.i18nNamespace)) {
+            this.i18n.registerContent(this.i18nNamespace, MEMBER_DETAIL_MODAL_I18N);
+        }
+        const roleName = this.member?.roles?.[0] ?? '';
+        // Resolve the role name to its UUID -- the select uses r.id (UUID) as value
+        const matched = this.availableRoles.find(r => r.name === roleName);
+        const roleId = matched?.id ?? roleName;
+        this.currentRole.set(roleId);
+        this.roleControl.setValue(roleId, { emitEvent: false });
+        this.roleSub = this.roleControl.valueChanges.subscribe(v => {
+            if (v && v !== this.currentRole())
+                void this.onChangeRole(v);
+        });
+    }
+    permissionLabel(perm) {
+        if (perm === '*:*')
+            return this.t('permAll');
+        const [resource, action] = perm.split(':');
+        const resKey = {
+            users: 'permUsers',
+            documents: 'permDocuments',
+            roles: 'permRoles',
+            media: 'permMedia',
+            templates: 'permTemplates',
+            '*': 'permAll',
+        };
+        const actKey = {
+            read: 'permRead',
+            write: 'permWrite',
+            create: 'permCreate',
+            delete: 'permDelete',
+            manage: 'permManage',
+            '*': 'permAll',
+        };
+        const res = this.t(resKey[resource] ?? resource);
+        const act = this.t(actKey[action] ?? action);
+        return `${res}: ${act}`;
+    }
+    async onChangeRole(newRoleId) {
+        if (this.working())
+            return;
+        this.working.set(true);
+        try {
+            await firstValueFrom(this.orgService.changeMemberRole(this.orgId, this.member.userId, newRoleId));
+            this.currentRole.set(newRoleId);
+            this.member = { ...this.member, roles: [newRoleId] };
+            this.toast.show({
+                message: this.t('changeRoleSuccess'),
+                color: 'dark',
+                duration: 3000,
+            });
+            this.onChanged?.();
+        }
+        catch (err) {
+            this.roleControl.setValue(this.currentRole(), { emitEvent: false });
+            this.errors.handle(err, {
+                context: 'memberDetail.changeRole',
+                fallbackKey: 'changeRoleError',
+                i18nNamespace: this.i18nNamespace,
+            });
+        }
+        finally {
+            this.working.set(false);
+        }
+    }
+    async onRemove() {
+        if (this.working())
+            return;
+        const result = await this.confirmDialog.confirmDestructive({
+            title: this.t('removeConfirmTitle'),
+            message: this.t('removeConfirmMessage'),
+            confirmButton: { text: this.t('removeConfirmOk') },
+            cancelButton: { text: this.t('cancelCta') },
+        });
+        if (!result.confirmed)
+            return;
+        this.working.set(true);
+        try {
+            await firstValueFrom(this.orgService.removeMember(this.orgId, this.member.userId));
+            this.toast.show({
+                message: this.t('removeSuccess'),
+                color: 'dark',
+                duration: 3000,
+            });
+            this.onChanged?.();
+            this.dismiss();
+        }
+        catch (err) {
+            this.errors.handle(err, {
+                context: 'memberDetail.remove',
+                fallbackKey: 'removeError',
+                i18nNamespace: this.i18nNamespace,
+            });
+        }
+        finally {
+            this.working.set(false);
+        }
+    }
+    roleLabel(roleIdOrName) {
+        // Try to find by id first (post-change, UUID stored), then by name (initial load)
+        const found = this.availableRoles.find(r => r.id === roleIdOrName || r.name === roleIdOrName);
+        const name = found?.name ?? roleIdOrName;
+        const keyMap = {
+            viewer: 'roleViewer',
+            editor: 'roleEditor',
+            admin: 'roleAdmin',
+            super_admin: 'roleSuperAdmin',
+        };
+        const key = keyMap[name] ?? name;
+        const label = this.t(key);
+        return label && !label.startsWith('[') ? label : name;
+    }
+    ngOnDestroy() {
+        this.roleSub?.unsubscribe();
+    }
+    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: MemberDetailModalComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.14", type: MemberDetailModalComponent, isStandalone: true, selector: "val-member-detail-modal", inputs: { _modalRef: "_modalRef", member: "member", orgId: "orgId", canManage: "canManage", isSelf: "isSelf", availableRoles: "availableRoles", onChanged: "onChanged", 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">
+      <div class="member-head">
+        <val-user-avatar
+          [props]="{
+            name: member.name,
+            avatarUrl: member.avatar,
+            email: member.email,
+            size: 'large',
+          }"
+        />
+        <val-display [props]="{ content: displayName(), size: 'small', color: 'dark' }" />
+        <val-title
+          [props]="{
+            content: subtitle(),
+            size: 'large',
+            color: '',
+            bold: false,
+          }"
+        />
+      </div>
+
+      <div class="role-section">
+        @if (canManage) {
+          <val-title
+            [props]="{
+              content: t('roleLabel'),
+              size: 'small',
+              color: 'dark',
+              bold: false,
+            }"
+          />
+          <val-select-input data-testid="member-role-select" [props]="roleSelectProps()" />
+          <val-text
+            [props]="{
+              content: t('roleHint'),
+              size: 'small',
+              color: 'medium',
+              bold: false,
+            }"
+          />
+        } @else {
+          <span class="role-readonly-label">{{ t('roleReadonly') }}</span>
+          <span class="member-role-badge">{{ currentRoleLabel() }}</span>
+        }
+      </div>
+
+      @if (permissionsForCurrentRole().length > 0) {
+        <div class="perms-section">
+          <span class="perms-label">{{ t('permissionsTitle') }}</span>
+          <div class="perms-list">
+            @for (perm of permissionsForCurrentRole(); track perm) {
+              <span class="perm-chip">{{ permissionLabel(perm) }}</span>
+            }
+          </div>
+        </div>
+      }
+
+      @if (canManage) {
+        <div class="remove-section">
+          <val-button [props]="removeButtonProps()" (click)="onRemove()" />
+        </div>
+      }
+    </ion-content>
+  `, isInline: true, styles: ["ion-content{--padding-bottom: 24px}.member-head{display:flex;flex-direction:column;align-items:center;text-align:center;gap:6px;margin-bottom:20px}val-display{display:block}val-title{display:block}.role-section{display:flex;flex-direction:column;gap:8px;margin-bottom:24px}.role-readonly-label{font-size:.74rem;font-weight:600;text-transform:uppercase;letter-spacing:.04em;color:var(--ion-color-medium)}.member-role-badge{font-size:.78rem;font-weight:700;text-transform:uppercase;letter-spacing:.04em;padding:4px 12px;border-radius:20px;width:fit-content;background:color-mix(in srgb,var(--ion-color-primary) 12%,transparent);color:var(--ion-color-primary)}.perms-section{display:flex;flex-direction:column;gap:10px;margin-bottom:24px}.perms-label{font-size:.74rem;font-weight:600;text-transform:uppercase;letter-spacing:.04em;color:var(--ion-color-medium)}.perms-list{display:flex;flex-wrap:wrap;gap:6px}.perm-chip{font-size:.75rem;font-weight:500;padding:3px 10px;border-radius:20px;border:1px solid var(--val-border-color, rgba(0, 0, 0, .12));color:var(--ion-color-dark);background:transparent}.remove-section{border-top:1px solid var(--val-border-color, rgba(0, 0, 0, .08));padding-top:20px}\n"], dependencies: [{ kind: "component", type: IonHeader, selector: "ion-header", inputs: ["collapse", "mode", "translucent"] }, { kind: "component", type: IonToolbar, selector: "ion-toolbar", inputs: ["color", "mode"] }, { kind: "component", type: IonButtons, selector: "ion-buttons", inputs: ["collapse"] }, { kind: "component", type: IonButton, selector: "ion-button", inputs: ["buttonType", "color", "disabled", "download", "expand", "fill", "form", "href", "mode", "rel", "routerAnimation", "routerDirection", "shape", "size", "strong", "target", "type"] }, { kind: "component", type: IonContent, selector: "ion-content", inputs: ["color", "fixedSlotPlacement", "forceOverscroll", "fullscreen", "scrollEvents", "scrollX", "scrollY"] }, { kind: "ngmodule", type: ReactiveFormsModule }, { kind: "component", type: ButtonComponent, selector: "val-button", inputs: ["preset", "props"], outputs: ["onClick"] }, { kind: "component", type: DisplayComponent, selector: "val-display", inputs: ["props"] }, { kind: "component", type: SearchSelectorComponent, selector: "val-select-input", inputs: ["preset", "props"] }, { kind: "component", type: TextComponent, selector: "val-text", inputs: ["props"] }, { kind: "component", type: TitleComponent, selector: "val-title", inputs: ["props"] }, { kind: "component", type: UserAvatarComponent, selector: "val-user-avatar", inputs: ["props"], outputs: ["onClick"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: MemberDetailModalComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'val-member-detail-modal', standalone: true, imports: [
+                        IonHeader,
+                        IonToolbar,
+                        IonButtons,
+                        IonButton,
+                        IonContent,
+                        ReactiveFormsModule,
+                        ButtonComponent,
+                        DisplayComponent,
+                        SearchSelectorComponent,
+                        TextComponent,
+                        TitleComponent,
+                        UserAvatarComponent,
+                    ], 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">
+      <div class="member-head">
+        <val-user-avatar
+          [props]="{
+            name: member.name,
+            avatarUrl: member.avatar,
+            email: member.email,
+            size: 'large',
+          }"
+        />
+        <val-display [props]="{ content: displayName(), size: 'small', color: 'dark' }" />
+        <val-title
+          [props]="{
+            content: subtitle(),
+            size: 'large',
+            color: '',
+            bold: false,
+          }"
+        />
+      </div>
+
+      <div class="role-section">
+        @if (canManage) {
+          <val-title
+            [props]="{
+              content: t('roleLabel'),
+              size: 'small',
+              color: 'dark',
+              bold: false,
+            }"
+          />
+          <val-select-input data-testid="member-role-select" [props]="roleSelectProps()" />
+          <val-text
+            [props]="{
+              content: t('roleHint'),
+              size: 'small',
+              color: 'medium',
+              bold: false,
+            }"
+          />
+        } @else {
+          <span class="role-readonly-label">{{ t('roleReadonly') }}</span>
+          <span class="member-role-badge">{{ currentRoleLabel() }}</span>
+        }
+      </div>
+
+      @if (permissionsForCurrentRole().length > 0) {
+        <div class="perms-section">
+          <span class="perms-label">{{ t('permissionsTitle') }}</span>
+          <div class="perms-list">
+            @for (perm of permissionsForCurrentRole(); track perm) {
+              <span class="perm-chip">{{ permissionLabel(perm) }}</span>
+            }
+          </div>
+        </div>
+      }
+
+      @if (canManage) {
+        <div class="remove-section">
+          <val-button [props]="removeButtonProps()" (click)="onRemove()" />
+        </div>
+      }
+    </ion-content>
+  `, styles: ["ion-content{--padding-bottom: 24px}.member-head{display:flex;flex-direction:column;align-items:center;text-align:center;gap:6px;margin-bottom:20px}val-display{display:block}val-title{display:block}.role-section{display:flex;flex-direction:column;gap:8px;margin-bottom:24px}.role-readonly-label{font-size:.74rem;font-weight:600;text-transform:uppercase;letter-spacing:.04em;color:var(--ion-color-medium)}.member-role-badge{font-size:.78rem;font-weight:700;text-transform:uppercase;letter-spacing:.04em;padding:4px 12px;border-radius:20px;width:fit-content;background:color-mix(in srgb,var(--ion-color-primary) 12%,transparent);color:var(--ion-color-primary)}.perms-section{display:flex;flex-direction:column;gap:10px;margin-bottom:24px}.perms-label{font-size:.74rem;font-weight:600;text-transform:uppercase;letter-spacing:.04em;color:var(--ion-color-medium)}.perms-list{display:flex;flex-wrap:wrap;gap:6px}.perm-chip{font-size:.75rem;font-weight:500;padding:3px 10px;border-radius:20px;border:1px solid var(--val-border-color, rgba(0, 0, 0, .12));color:var(--ion-color-dark);background:transparent}.remove-section{border-top:1px solid var(--val-border-color, rgba(0, 0, 0, .08));padding-top:20px}\n"] }]
+        }], ctorParameters: () => [], propDecorators: { _modalRef: [{
+                type: Input
+            }], member: [{
+                type: Input
+            }], orgId: [{
+                type: Input
+            }], canManage: [{
+                type: Input
+            }], isSelf: [{
+                type: Input
+            }], availableRoles: [{
+                type: Input
+            }], onChanged: [{
+                type: Input
+            }], i18nNamespace: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"member-detail-modal.component.js","sourceRoot":"","sources":["../../../../../../../src/lib/components/organisms/member-detail-modal/member-detail-modal.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, computed, inject, Input, OnDestroy, OnInit, signal } from '@angular/core';\nimport { FormControl, ReactiveFormsModule } from '@angular/forms';\nimport { firstValueFrom, Subscription } from 'rxjs';\nimport { IonButton, IonButtons, IonContent, IonHeader, IonToolbar } from '@ionic/angular/standalone';\n\nimport { ButtonComponent } from '../../atoms/button/button.component';\nimport { DisplayComponent } from '../../atoms/display/display.component';\nimport { TextComponent } from '../../atoms/text/text.component';\nimport { TitleComponent } from '../../atoms/title/title.component';\nimport { UserAvatarComponent } from '../../atoms/user-avatar/user-avatar.component';\nimport { SearchSelectorComponent } from '../../molecules/select-input/select-input.component';\nimport { ButtonMetadata, ComponentStates, InputMetadata, InputType } from '../../types';\n\nimport { I18nService } from '../../../services/i18n';\nimport { OrgService } from '../../../services/org/org.service';\nimport { ToastService } from '../../../services/toast.service';\nimport { ValtechErrorService } from '../../../services/errors/valtech-error.service';\nimport { ConfirmationDialogService } from '../../../services/confirmation-dialog/confirmation-dialog.service';\n\nimport { MemberDetail, OrgRoleWithPermissions } from './types';\nimport { MEMBER_DETAIL_MODAL_I18N } from './member-detail-modal.i18n';\n\nconst DEFAULT_NAMESPACE = 'Settings.MemberDetail';\n\n/**\n * `val-member-detail-modal` — detalle de miembro de organización: perfil, rol y\n * permisos. Promovido desde `showcase` bajo el proceso de ADR-021.\n *\n * Si `canManage` es true, permite cambiar el rol (vía `OrgService.changeMemberRole`)\n * y quitar al miembro (vía `OrgService.removeMember`, con confirmación destructiva).\n * Los permisos del rol actual se muestran cuando el consumer los provee en\n * `availableRoles`.\n *\n * Abierto vía `ModalService` — recibe `_modalRef` por `componentProps` + callback\n * `onChanged`. Header canónico (Regla #5): sin `ion-title`, botón Cerrar texto en\n * `slot=end`, identidad en el body con `val-user-avatar`/`val-display`/`val-title`.\n *\n * Auto-registra sus defaults i18n (es/en) si el consumer no proveyó el namespace\n * `Settings.MemberDetail`.\n */\n@Component({\n  selector: 'val-member-detail-modal',\n  standalone: true,\n  imports: [\n    IonHeader,\n    IonToolbar,\n    IonButtons,\n    IonButton,\n    IonContent,\n    ReactiveFormsModule,\n    ButtonComponent,\n    DisplayComponent,\n    SearchSelectorComponent,\n    TextComponent,\n    TitleComponent,\n    UserAvatarComponent,\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      <div class=\"member-head\">\n        <val-user-avatar\n          [props]=\"{\n            name: member.name,\n            avatarUrl: member.avatar,\n            email: member.email,\n            size: 'large',\n          }\"\n        />\n        <val-display [props]=\"{ content: displayName(), size: 'small', color: 'dark' }\" />\n        <val-title\n          [props]=\"{\n            content: subtitle(),\n            size: 'large',\n            color: '',\n            bold: false,\n          }\"\n        />\n      </div>\n\n      <div class=\"role-section\">\n        @if (canManage) {\n          <val-title\n            [props]=\"{\n              content: t('roleLabel'),\n              size: 'small',\n              color: 'dark',\n              bold: false,\n            }\"\n          />\n          <val-select-input data-testid=\"member-role-select\" [props]=\"roleSelectProps()\" />\n          <val-text\n            [props]=\"{\n              content: t('roleHint'),\n              size: 'small',\n              color: 'medium',\n              bold: false,\n            }\"\n          />\n        } @else {\n          <span class=\"role-readonly-label\">{{ t('roleReadonly') }}</span>\n          <span class=\"member-role-badge\">{{ currentRoleLabel() }}</span>\n        }\n      </div>\n\n      @if (permissionsForCurrentRole().length > 0) {\n        <div class=\"perms-section\">\n          <span class=\"perms-label\">{{ t('permissionsTitle') }}</span>\n          <div class=\"perms-list\">\n            @for (perm of permissionsForCurrentRole(); track perm) {\n              <span class=\"perm-chip\">{{ permissionLabel(perm) }}</span>\n            }\n          </div>\n        </div>\n      }\n\n      @if (canManage) {\n        <div class=\"remove-section\">\n          <val-button [props]=\"removeButtonProps()\" (click)=\"onRemove()\" />\n        </div>\n      }\n    </ion-content>\n  `,\n  styles: [\n    `\n      ion-content {\n        --padding-bottom: 24px;\n      }\n      .member-head {\n        display: flex;\n        flex-direction: column;\n        align-items: center;\n        text-align: center;\n        gap: 6px;\n        margin-bottom: 20px;\n      }\n      val-display {\n        display: block;\n      }\n      val-title {\n        display: block;\n      }\n      .role-section {\n        display: flex;\n        flex-direction: column;\n        gap: 8px;\n        margin-bottom: 24px;\n      }\n      .role-readonly-label {\n        font-size: 0.74rem;\n        font-weight: 600;\n        text-transform: uppercase;\n        letter-spacing: 0.04em;\n        color: var(--ion-color-medium);\n      }\n      .member-role-badge {\n        font-size: 0.78rem;\n        font-weight: 700;\n        text-transform: uppercase;\n        letter-spacing: 0.04em;\n        padding: 4px 12px;\n        border-radius: 20px;\n        width: fit-content;\n        background: color-mix(in srgb, var(--ion-color-primary) 12%, transparent);\n        color: var(--ion-color-primary);\n      }\n      .perms-section {\n        display: flex;\n        flex-direction: column;\n        gap: 10px;\n        margin-bottom: 24px;\n      }\n      .perms-label {\n        font-size: 0.74rem;\n        font-weight: 600;\n        text-transform: uppercase;\n        letter-spacing: 0.04em;\n        color: var(--ion-color-medium);\n      }\n      .perms-list {\n        display: flex;\n        flex-wrap: wrap;\n        gap: 6px;\n      }\n      .perm-chip {\n        font-size: 0.75rem;\n        font-weight: 500;\n        padding: 3px 10px;\n        border-radius: 20px;\n        border: 1px solid var(--val-border-color, rgba(0, 0, 0, 0.12));\n        color: var(--ion-color-dark);\n        background: transparent;\n      }\n      .remove-section {\n        border-top: 1px solid var(--val-border-color, rgba(0, 0, 0, 0.08));\n        padding-top: 20px;\n      }\n    `,\n  ],\n})\nexport class MemberDetailModalComponent implements OnInit, OnDestroy {\n  private orgService = inject(OrgService);\n  private toast = inject(ToastService);\n  private errors = inject(ValtechErrorService);\n  private i18n = inject(I18nService);\n  private confirmDialog = inject(ConfirmationDialogService);\n\n  /** Inyectado por `ModalService.open` — referencia para cerrar desde dentro. */\n  @Input() _modalRef?: { dismiss: (data?: unknown, role?: string) => void };\n\n  /** Miembro a mostrar (pasado por `componentProps`). */\n  @Input() member!: MemberDetail;\n\n  /** Organización a la que pertenece el miembro. */\n  @Input() orgId = '';\n\n  /** Si true, habilita cambio de rol y eliminación. */\n  @Input() canManage = false;\n\n  /** Si true, el miembro mostrado es el propio usuario. */\n  @Input() isSelf = false;\n\n  /** Roles disponibles (con permisos opcionales) para el selector de rol. */\n  @Input() availableRoles: OrgRoleWithPermissions[] = [\n    { id: 'viewer', name: 'viewer' },\n    { id: 'editor', name: 'editor' },\n    { id: 'admin', name: 'admin' },\n  ];\n\n  /** Callback tras cambiar rol o quitar al miembro (pasado por `componentProps`). */\n  @Input() onChanged?: () => void;\n\n  /** Namespace i18n con que la vista resuelve sus textos. */\n  @Input() i18nNamespace = DEFAULT_NAMESPACE;\n\n  readonly working = signal(false);\n  readonly currentRole = signal<string>('');\n\n  readonly roleControl = new FormControl<string>('');\n  private roleSub?: Subscription;\n\n  readonly displayName = computed(\n    () => this.member?.name || this.member?.handle || this.member?.email || '—'\n  );\n\n  readonly subtitle = computed(() => {\n    if (this.isSelf) return this.t('subtitleSelf');\n    if (this.member?.handle) return '@' + this.member.handle;\n    return this.member?.email ?? '';\n  });\n\n  readonly currentRoleLabel = computed(() => this.roleLabel(this.currentRole()));\n\n  readonly permissionsForCurrentRole = computed<string[]>(() => {\n    const roleId = this.currentRole();\n    const role = this.availableRoles.find(r => r.id === roleId || r.name === roleId);\n    return role?.permissions ?? [];\n  });\n\n  readonly roleSelectProps = computed<Partial<InputMetadata>>(() => ({\n    control: this.roleControl as FormControl,\n    label: '',\n    placeholder: this.t('roleLabel'),\n    type: InputType.SELECT,\n    state: this.working() ? ComponentStates.DISABLED : ComponentStates.ENABLED,\n    options: this.availableRoles.map(r => ({\n      id: r.id,\n      name: this.roleLabel(r.name),\n      order: 0,\n    })),\n  }));\n\n  readonly removeButtonProps = computed<Partial<ButtonMetadata>>(() => ({\n    text: this.t('removeCta'),\n    token: 'member-remove',\n    color: 'danger',\n    fill: 'outline',\n    expand: 'block',\n    size: 'default',\n    type: 'button',\n    state: this.working() ? ComponentStates.WORKING : ComponentStates.ENABLED,\n  }));\n\n  constructor() {\n    if (!this.i18n.hasNamespace(DEFAULT_NAMESPACE)) {\n      this.i18n.registerContent(DEFAULT_NAMESPACE, MEMBER_DETAIL_MODAL_I18N);\n    }\n  }\n\n  ngOnInit(): void {\n    if (!this.i18n.hasNamespace(this.i18nNamespace)) {\n      this.i18n.registerContent(this.i18nNamespace, MEMBER_DETAIL_MODAL_I18N);\n    }\n    const roleName = this.member?.roles?.[0] ?? '';\n    // Resolve the role name to its UUID -- the select uses r.id (UUID) as value\n    const matched = this.availableRoles.find(r => r.name === roleName);\n    const roleId = matched?.id ?? roleName;\n    this.currentRole.set(roleId);\n    this.roleControl.setValue(roleId, { emitEvent: false });\n    this.roleSub = this.roleControl.valueChanges.subscribe(v => {\n      if (v && v !== this.currentRole()) void this.onChangeRole(v);\n    });\n  }\n\n  permissionLabel(perm: string): string {\n    if (perm === '*:*') return this.t('permAll');\n    const [resource, action] = perm.split(':');\n    const resKey: Record<string, string> = {\n      users: 'permUsers',\n      documents: 'permDocuments',\n      roles: 'permRoles',\n      media: 'permMedia',\n      templates: 'permTemplates',\n      '*': 'permAll',\n    };\n    const actKey: Record<string, string> = {\n      read: 'permRead',\n      write: 'permWrite',\n      create: 'permCreate',\n      delete: 'permDelete',\n      manage: 'permManage',\n      '*': 'permAll',\n    };\n    const res = this.t(resKey[resource] ?? resource);\n    const act = this.t(actKey[action] ?? action);\n    return `${res}: ${act}`;\n  }\n\n  private async onChangeRole(newRoleId: string): Promise<void> {\n    if (this.working()) return;\n    this.working.set(true);\n    try {\n      await firstValueFrom(this.orgService.changeMemberRole(this.orgId, this.member.userId, newRoleId));\n      this.currentRole.set(newRoleId);\n      this.member = { ...this.member, roles: [newRoleId] };\n      this.toast.show({\n        message: this.t('changeRoleSuccess'),\n        color: 'dark',\n        duration: 3000,\n      });\n      this.onChanged?.();\n    } catch (err) {\n      this.roleControl.setValue(this.currentRole(), { emitEvent: false });\n      this.errors.handle(err, {\n        context: 'memberDetail.changeRole',\n        fallbackKey: 'changeRoleError',\n        i18nNamespace: this.i18nNamespace,\n      });\n    } finally {\n      this.working.set(false);\n    }\n  }\n\n  async onRemove(): Promise<void> {\n    if (this.working()) return;\n    const result = await this.confirmDialog.confirmDestructive({\n      title: this.t('removeConfirmTitle'),\n      message: this.t('removeConfirmMessage'),\n      confirmButton: { text: this.t('removeConfirmOk') },\n      cancelButton: { text: this.t('cancelCta') },\n    });\n    if (!result.confirmed) return;\n    this.working.set(true);\n    try {\n      await firstValueFrom(this.orgService.removeMember(this.orgId, this.member.userId));\n      this.toast.show({\n        message: this.t('removeSuccess'),\n        color: 'dark',\n        duration: 3000,\n      });\n      this.onChanged?.();\n      this.dismiss();\n    } catch (err) {\n      this.errors.handle(err, {\n        context: 'memberDetail.remove',\n        fallbackKey: 'removeError',\n        i18nNamespace: this.i18nNamespace,\n      });\n    } finally {\n      this.working.set(false);\n    }\n  }\n\n  roleLabel(roleIdOrName: string): string {\n    // Try to find by id first (post-change, UUID stored), then by name (initial load)\n    const found = this.availableRoles.find(r => r.id === roleIdOrName || r.name === roleIdOrName);\n    const name = found?.name ?? roleIdOrName;\n    const keyMap: Record<string, string> = {\n      viewer: 'roleViewer',\n      editor: 'roleEditor',\n      admin: 'roleAdmin',\n      super_admin: 'roleSuperAdmin',\n    };\n    const key = keyMap[name] ?? name;\n    const label = this.t(key);\n    return label && !label.startsWith('[') ? label : name;\n  }\n\n  ngOnDestroy(): void {\n    this.roleSub?.unsubscribe();\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/member-detail-modal/member-detail-modal.i18n.mjs

@@ -0,0 +1,72 @@
+/**
+ * Defaults i18n (es/en) embebidos en `val-member-detail-modal`. Auto-registrados
+ * en el constructor del componente si el consumer no proveyó el namespace
+ * (`Settings.MemberDetail` por default). SOLO incluye las keys que el modal usa.
+ */
+export const MEMBER_DETAIL_MODAL_I18N = {
+    es: {
+        close: 'Cerrar',
+        subtitleSelf: 'Tú',
+        roleLabel: 'Rol',
+        roleHint: 'Cambia el rol de este miembro en la organización.',
+        roleReadonly: 'Rol en la organización',
+        roleViewer: 'Visor',
+        roleEditor: 'Editor',
+        roleAdmin: 'Admin',
+        roleSuperAdmin: 'Super Admin',
+        removeCta: 'Quitar de la organización',
+        removeConfirmTitle: 'Quitar miembro',
+        removeConfirmMessage: '¿Quitar a este miembro de la organización?',
+        removeConfirmOk: 'Quitar',
+        cancelCta: 'Cancelar',
+        changeRoleSuccess: 'Rol actualizado.',
+        changeRoleError: 'No se pudo cambiar el rol.',
+        removeSuccess: 'Miembro eliminado.',
+        removeError: 'No se pudo eliminar al miembro.',
+        permissionsTitle: 'Permisos del rol',
+        permAll: 'Todo',
+        permUsers: 'Usuarios',
+        permDocuments: 'Documentos',
+        permRoles: 'Roles',
+        permMedia: 'Media',
+        permTemplates: 'Plantillas',
+        permRead: 'Leer',
+        permWrite: 'Escribir',
+        permCreate: 'Crear',
+        permDelete: 'Eliminar',
+        permManage: 'Gestionar',
+    },
+    en: {
+        close: 'Close',
+        subtitleSelf: 'You',
+        roleLabel: 'Role',
+        roleHint: "Change this member's role in the organization.",
+        roleReadonly: 'Role in the organization',
+        roleViewer: 'Viewer',
+        roleEditor: 'Editor',
+        roleAdmin: 'Admin',
+        roleSuperAdmin: 'Super Admin',
+        removeCta: 'Remove from organization',
+        removeConfirmTitle: 'Remove member',
+        removeConfirmMessage: 'Remove this member from the organization?',
+        removeConfirmOk: 'Remove',
+        cancelCta: 'Cancel',
+        changeRoleSuccess: 'Role updated.',
+        changeRoleError: 'Could not change role.',
+        removeSuccess: 'Member removed.',
+        removeError: 'Could not remove member.',
+        permissionsTitle: 'Role permissions',
+        permAll: 'All',
+        permUsers: 'Users',
+        permDocuments: 'Documents',
+        permRoles: 'Roles',
+        permMedia: 'Media',
+        permTemplates: 'Templates',
+        permRead: 'Read',
+        permWrite: 'Write',
+        permCreate: 'Create',
+        permDelete: 'Delete',
+        permManage: 'Manage',
+    },
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/components/organisms/member-detail-modal/types.mjs

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