valtech-components 4.0.937 → 4.0.939

package/esm2022/lib/components/molecules/group-picker/group-picker.component.mjs

@@ -0,0 +1,97 @@
+import { CommonModule } from '@angular/common';
+import { Component, EventEmitter, Input, Output, inject } from '@angular/core';
+import { IonSelect, IonSelectOption } from '@ionic/angular/standalone';
+import { GroupsService } from '../../../services/groups/groups.service';
+import * as i0 from "@angular/core";
+/**
+ * val-group-picker — elegir el grupo dueño de un recurso (ADR-083).
+ *
+ * Se auto-carga: pide sus propios grupos a `GroupsService` en vez de esperar
+ * que el consumer se los pase. Es la razón por la que existe como componente y
+ * no como un `<select>` armado a mano en cada app — "una línea, una etiqueta
+ * i18n" (ver ADR-083 §"Qué se construye una sola vez").
+ *
+ * Sin texto hardcodeado: los labels llegan por `@Input` (lib i18n-agnostic).
+ * Cada app pone su palabra ("Equipo", "Sucursal", "Refugio").
+ */
+export class GroupPickerComponent {
+    constructor() {
+        this.label = '';
+        this.placeholder = '';
+        this.noGroupLabel = '';
+        this.value = null;
+        this.disabled = false;
+        this.valueChange = new EventEmitter();
+        this.groupsSvc = inject(GroupsService);
+        this.groups = [];
+    }
+    ngOnInit() {
+        this.groupsSvc.listGroups().subscribe({
+            next: (g) => (this.groups = g),
+            // Best-effort: si la lectura falla, el picker queda con la opción "sin
+            // grupo" únicamente. No es un error bloqueante — crear el recurso sin
+            // asignar sigue siendo válido.
+            error: () => (this.groups = []),
+        });
+    }
+    onChange(v) {
+        this.value = v || null;
+        this.valueChange.emit(this.value);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: GroupPickerComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.14", type: GroupPickerComponent, isStandalone: true, selector: "val-group-picker", inputs: { label: "label", placeholder: "placeholder", noGroupLabel: "noGroupLabel", value: "value", disabled: "disabled" }, outputs: { valueChange: "valueChange" }, ngImport: i0, template: `
+    <ion-select
+      [label]="label"
+      [placeholder]="placeholder"
+      [value]="value ?? ''"
+      [disabled]="disabled"
+      interface="popover"
+      (ionChange)="onChange($event.detail.value)"
+    >
+      <!-- Opción vacía SIEMPRE disponible: un recurso sin grupo es visible para
+           toda la organización (ADR-083, decisión 3), no un estado inválido. -->
+      <ion-select-option value="">{{ noGroupLabel }}</ion-select-option>
+      @for (g of groups; track g.id) {
+        <ion-select-option [value]="g.id">{{ g.name }}</ion-select-option>
+      }
+    </ion-select>
+  `, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "component", type: IonSelect, selector: "ion-select", inputs: ["cancelText", "color", "compareWith", "disabled", "errorText", "expandedIcon", "fill", "helperText", "interface", "interfaceOptions", "justify", "label", "labelPlacement", "mode", "multiple", "name", "okText", "placeholder", "selectedText", "shape", "toggleIcon", "value"] }, { kind: "component", type: IonSelectOption, selector: "ion-select-option", inputs: ["disabled", "value"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: GroupPickerComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'val-group-picker',
+                    standalone: true,
+                    imports: [CommonModule, IonSelect, IonSelectOption],
+                    template: `
+    <ion-select
+      [label]="label"
+      [placeholder]="placeholder"
+      [value]="value ?? ''"
+      [disabled]="disabled"
+      interface="popover"
+      (ionChange)="onChange($event.detail.value)"
+    >
+      <!-- Opción vacía SIEMPRE disponible: un recurso sin grupo es visible para
+           toda la organización (ADR-083, decisión 3), no un estado inválido. -->
+      <ion-select-option value="">{{ noGroupLabel }}</ion-select-option>
+      @for (g of groups; track g.id) {
+        <ion-select-option [value]="g.id">{{ g.name }}</ion-select-option>
+      }
+    </ion-select>
+  `,
+                }]
+        }], propDecorators: { label: [{
+                type: Input
+            }], placeholder: [{
+                type: Input
+            }], noGroupLabel: [{
+                type: Input
+            }], value: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], valueChange: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/components/organisms/group-members/group-members.component.mjs

@@ -0,0 +1,178 @@
+import { CommonModule } from '@angular/common';
+import { Component, EventEmitter, Input, Output, inject } from '@angular/core';
+import { IonIcon, IonSelect, IonSelectOption } from '@ionic/angular/standalone';
+import { ButtonComponent } from '../../atoms/button/button.component';
+import { ComponentStates } from '../../types';
+import { GroupsService } from '../../../services/groups/groups.service';
+import * as i0 from "@angular/core";
+/**
+ * val-group-members — administrar la membresía de UN grupo (ADR-083).
+ *
+ * Deliberadamente NO trae su propio selector de personas: la fuente de
+ * "quiénes son los miembros elegibles de la organización" varía por app (org
+ * members, invitados, etc.), así que se recibe por `@Input candidates` en vez
+ * de que este organismo importe un servicio de organización que no le
+ * corresponde. Sin candidatos, igual funciona: solo lista y quita.
+ *
+ * Sin texto hardcodeado (lib i18n-agnostic): los labels llegan por `@Input`.
+ */
+export class GroupMembersComponent {
+    constructor() {
+        /** Personas elegibles para agregar. Vacío = el organismo solo lista/quita. */
+        this.candidates = [];
+        this.addPlaceholder = '';
+        this.emptyLabel = '';
+        this.removeLabel = '';
+        this.membersChange = new EventEmitter();
+        this.groupsSvc = inject(GroupsService);
+        this.members = [];
+        this.busy = false;
+    }
+    get removeButtonProps() {
+        return {
+            text: this.removeLabel,
+            color: 'dark',
+            fill: 'clear',
+            size: 'small',
+            shape: 'round',
+            type: 'button',
+            state: this.busy ? ComponentStates.DISABLED : ComponentStates.ENABLED,
+        };
+    }
+    ngOnChanges(changes) {
+        if (changes['groupId'] && this.groupId) {
+            this.reload();
+        }
+    }
+    reload() {
+        this.groupsSvc.listMembers(this.groupId).subscribe({
+            next: (m) => (this.members = m),
+            error: () => (this.members = []),
+        });
+    }
+    /** Candidatos que todavía no están en el grupo — evita ofrecer un alta duplicada. */
+    eligible() {
+        const current = new Set(this.members.map((m) => m.userId));
+        return this.candidates.filter((c) => !current.has(c.userId));
+    }
+    nameFor(userId) {
+        const c = this.candidates.find((x) => x.userId === userId);
+        return c?.name || c?.email || userId;
+    }
+    add(userId) {
+        if (!userId || this.busy)
+            return;
+        this.busy = true;
+        this.groupsSvc.addMember(this.groupId, { userId }).subscribe({
+            next: (members) => {
+                this.members = members;
+                this.busy = false;
+                this.membersChange.emit(members);
+            },
+            error: () => (this.busy = false),
+        });
+    }
+    remove(userId) {
+        if (this.busy)
+            return;
+        this.busy = true;
+        this.groupsSvc.removeMember(this.groupId, userId).subscribe({
+            next: (members) => {
+                this.members = members;
+                this.busy = false;
+                this.membersChange.emit(members);
+            },
+            error: () => (this.busy = false),
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: GroupMembersComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.14", type: GroupMembersComponent, isStandalone: true, selector: "val-group-members", inputs: { groupId: "groupId", candidates: "candidates", addPlaceholder: "addPlaceholder", emptyLabel: "emptyLabel", removeLabel: "removeLabel" }, outputs: { membersChange: "membersChange" }, usesOnChanges: true, ngImport: i0, template: `
+    <div class="group-members">
+      @if (candidates.length > 0) {
+        <div class="group-members__add">
+          <ion-select
+            [placeholder]="addPlaceholder"
+            interface="popover"
+            [disabled]="busy"
+            (ionChange)="add($event.detail.value)"
+          >
+            @for (c of eligible(); track c.userId) {
+              <ion-select-option [value]="c.userId">
+                {{ c.name || c.email || c.userId }}
+              </ion-select-option>
+            }
+          </ion-select>
+        </div>
+      }
+
+      @if (members.length === 0) {
+        <p class="group-members__empty">{{ emptyLabel }}</p>
+      } @else {
+        <ul class="group-members__list">
+          @for (m of members; track m.userId) {
+            <li class="group-members__row">
+              <span class="group-members__name">{{ nameFor(m.userId) }}</span>
+              <val-button
+                [props]="removeButtonProps"
+                (onClick)="remove(m.userId)"
+              />
+            </li>
+          }
+        </ul>
+      }
+    </div>
+  `, isInline: true, styles: [".group-members{display:flex;flex-direction:column;gap:12px}.group-members__empty{font-size:.875rem;color:var(--ion-color-medium, #92949c);margin:0}.group-members__list{list-style:none;margin:0;padding:0;display:flex;flex-direction:column;gap:4px}.group-members__row{display:flex;align-items:center;justify-content:space-between;padding:8px 12px;border-radius:10px;background:var(--ion-color-light, #f4f5f8)}.group-members__name{font-size:.9375rem;color:var(--ion-text-color, #000)}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "component", type: IonSelect, selector: "ion-select", inputs: ["cancelText", "color", "compareWith", "disabled", "errorText", "expandedIcon", "fill", "helperText", "interface", "interfaceOptions", "justify", "label", "labelPlacement", "mode", "multiple", "name", "okText", "placeholder", "selectedText", "shape", "toggleIcon", "value"] }, { kind: "component", type: IonSelectOption, selector: "ion-select-option", inputs: ["disabled", "value"] }, { kind: "component", type: ButtonComponent, selector: "val-button", inputs: ["preset", "props"], outputs: ["onClick"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: GroupMembersComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'val-group-members', standalone: true, imports: [CommonModule, IonIcon, IonSelect, IonSelectOption, ButtonComponent], template: `
+    <div class="group-members">
+      @if (candidates.length > 0) {
+        <div class="group-members__add">
+          <ion-select
+            [placeholder]="addPlaceholder"
+            interface="popover"
+            [disabled]="busy"
+            (ionChange)="add($event.detail.value)"
+          >
+            @for (c of eligible(); track c.userId) {
+              <ion-select-option [value]="c.userId">
+                {{ c.name || c.email || c.userId }}
+              </ion-select-option>
+            }
+          </ion-select>
+        </div>
+      }
+
+      @if (members.length === 0) {
+        <p class="group-members__empty">{{ emptyLabel }}</p>
+      } @else {
+        <ul class="group-members__list">
+          @for (m of members; track m.userId) {
+            <li class="group-members__row">
+              <span class="group-members__name">{{ nameFor(m.userId) }}</span>
+              <val-button
+                [props]="removeButtonProps"
+                (onClick)="remove(m.userId)"
+              />
+            </li>
+          }
+        </ul>
+      }
+    </div>
+  `, styles: [".group-members{display:flex;flex-direction:column;gap:12px}.group-members__empty{font-size:.875rem;color:var(--ion-color-medium, #92949c);margin:0}.group-members__list{list-style:none;margin:0;padding:0;display:flex;flex-direction:column;gap:4px}.group-members__row{display:flex;align-items:center;justify-content:space-between;padding:8px 12px;border-radius:10px;background:var(--ion-color-light, #f4f5f8)}.group-members__name{font-size:.9375rem;color:var(--ion-text-color, #000)}\n"] }]
+        }], propDecorators: { groupId: [{
+                type: Input,
+                args: [{ required: true }]
+            }], candidates: [{
+                type: Input
+            }], addPlaceholder: [{
+                type: Input
+            }], emptyLabel: [{
+                type: Input
+            }], removeLabel: [{
+                type: Input
+            }], membersChange: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"group-members.component.js","sourceRoot":"","sources":["../../../../../../../src/lib/components/organisms/group-members/group-members.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { CommonModule } from '@angular/common';\nimport { Component, EventEmitter, Input, OnChanges, Output, SimpleChanges, inject } from '@angular/core';\nimport { IonIcon, IonSelect, IonSelectOption } from '@ionic/angular/standalone';\nimport { ButtonComponent } from '../../atoms/button/button.component';\nimport { ComponentStates, ButtonMetadata } from '../../types';\nimport { GroupsService } from '../../../services/groups/groups.service';\nimport { ValGroupMember } from '../../../services/groups/types';\n\n/** Persona elegible para agregar al grupo (típicamente un `OrgMember`). */\nexport interface GroupMemberCandidate {\n  userId: string;\n  name?: string;\n  email?: string;\n}\n\n/**\n * val-group-members — administrar la membresía de UN grupo (ADR-083).\n *\n * Deliberadamente NO trae su propio selector de personas: la fuente de\n * \"quiénes son los miembros elegibles de la organización\" varía por app (org\n * members, invitados, etc.), así que se recibe por `@Input candidates` en vez\n * de que este organismo importe un servicio de organización que no le\n * corresponde. Sin candidatos, igual funciona: solo lista y quita.\n *\n * Sin texto hardcodeado (lib i18n-agnostic): los labels llegan por `@Input`.\n */\n@Component({\n  selector: 'val-group-members',\n  standalone: true,\n  imports: [CommonModule, IonIcon, IonSelect, IonSelectOption, ButtonComponent],\n  template: `\n    <div class=\"group-members\">\n      @if (candidates.length > 0) {\n        <div class=\"group-members__add\">\n          <ion-select\n            [placeholder]=\"addPlaceholder\"\n            interface=\"popover\"\n            [disabled]=\"busy\"\n            (ionChange)=\"add($event.detail.value)\"\n          >\n            @for (c of eligible(); track c.userId) {\n              <ion-select-option [value]=\"c.userId\">\n                {{ c.name || c.email || c.userId }}\n              </ion-select-option>\n            }\n          </ion-select>\n        </div>\n      }\n\n      @if (members.length === 0) {\n        <p class=\"group-members__empty\">{{ emptyLabel }}</p>\n      } @else {\n        <ul class=\"group-members__list\">\n          @for (m of members; track m.userId) {\n            <li class=\"group-members__row\">\n              <span class=\"group-members__name\">{{ nameFor(m.userId) }}</span>\n              <val-button\n                [props]=\"removeButtonProps\"\n                (onClick)=\"remove(m.userId)\"\n              />\n            </li>\n          }\n        </ul>\n      }\n    </div>\n  `,\n  styleUrls: ['./group-members.component.scss'],\n})\nexport class GroupMembersComponent implements OnChanges {\n  @Input({ required: true }) groupId!: string;\n  /** Personas elegibles para agregar. Vacío = el organismo solo lista/quita. */\n  @Input() candidates: GroupMemberCandidate[] = [];\n  @Input() addPlaceholder = '';\n  @Input() emptyLabel = '';\n  @Input() removeLabel = '';\n  @Output() membersChange = new EventEmitter<ValGroupMember[]>();\n\n  private readonly groupsSvc = inject(GroupsService);\n  members: ValGroupMember[] = [];\n  busy = false;\n\n  get removeButtonProps(): ButtonMetadata {\n    return {\n      text: this.removeLabel,\n      color: 'dark',\n      fill: 'clear',\n      size: 'small',\n      shape: 'round',\n      type: 'button',\n      state: this.busy ? ComponentStates.DISABLED : ComponentStates.ENABLED,\n    };\n  }\n\n  ngOnChanges(changes: SimpleChanges): void {\n    if (changes['groupId'] && this.groupId) {\n      this.reload();\n    }\n  }\n\n  private reload(): void {\n    this.groupsSvc.listMembers(this.groupId).subscribe({\n      next: (m) => (this.members = m),\n      error: () => (this.members = []),\n    });\n  }\n\n  /** Candidatos que todavía no están en el grupo — evita ofrecer un alta duplicada. */\n  eligible(): GroupMemberCandidate[] {\n    const current = new Set(this.members.map((m) => m.userId));\n    return this.candidates.filter((c) => !current.has(c.userId));\n  }\n\n  nameFor(userId: string): string {\n    const c = this.candidates.find((x) => x.userId === userId);\n    return c?.name || c?.email || userId;\n  }\n\n  add(userId: string): void {\n    if (!userId || this.busy) return;\n    this.busy = true;\n    this.groupsSvc.addMember(this.groupId, { userId }).subscribe({\n      next: (members) => {\n        this.members = members;\n        this.busy = false;\n        this.membersChange.emit(members);\n      },\n      error: () => (this.busy = false),\n    });\n  }\n\n  remove(userId: string): void {\n    if (this.busy) return;\n    this.busy = true;\n    this.groupsSvc.removeMember(this.groupId, userId).subscribe({\n      next: (members) => {\n        this.members = members;\n        this.busy = false;\n        this.membersChange.emit(members);\n      },\n      error: () => (this.busy = false),\n    });\n  }\n}\n"]}