valtech-components 4.0.938 → 4.0.940

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"]}

package/esm2022/lib/directives/feature-guard.directive.mjs

@@ -0,0 +1,48 @@
+import { Directive, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../services/feature-control.service";
+/**
+ * Structural directive to hide elements when a feature is disabled.
+ *
+ * Usage: <button *valFeatureGuard="'oauth_facebook'">Sign in with Facebook</button>
+ * If oauth_facebook is disabled, the button is not rendered.
+ */
+export class FeatureGuardDirective {
+    set valFeatureGuard(featureKey) {
+        this.featureKey = featureKey;
+        this.updateVisibility();
+    }
+    constructor(templateRef, viewContainer, featureControl) {
+        this.templateRef = templateRef;
+        this.viewContainer = viewContainer;
+        this.featureControl = featureControl;
+        this.featureKey = '';
+    }
+    ngOnInit() {
+        this.updateVisibility();
+    }
+    updateVisibility() {
+        if (!this.featureKey) {
+            return;
+        }
+        const isEnabled = this.featureControl.isEnabled(this.featureKey);
+        if (isEnabled) {
+            this.viewContainer.createEmbeddedView(this.templateRef);
+        }
+        else {
+            this.viewContainer.clear();
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: FeatureGuardDirective, deps: [{ token: i0.TemplateRef }, { token: i0.ViewContainerRef }, { token: i1.FeatureControlService }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.14", type: FeatureGuardDirective, isStandalone: true, selector: "[valFeatureGuard]", inputs: { valFeatureGuard: "valFeatureGuard" }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: FeatureGuardDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[valFeatureGuard]',
+                    standalone: true,
+                }]
+        }], ctorParameters: () => [{ type: i0.TemplateRef }, { type: i0.ViewContainerRef }, { type: i1.FeatureControlService }], propDecorators: { valFeatureGuard: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/feature-control.service.mjs

@@ -0,0 +1,117 @@
+import { Injectable, signal, Optional } from '@angular/core';
+import { firstValueFrom } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "./firebase/analytics.service";
+export class FeatureControlService {
+    constructor(http, analytics) {
+        this.http = http;
+        this.analytics = analytics;
+        this.features = signal(new Map());
+        this.isLoaded = signal(false);
+        this.previousState = new Map();
+    }
+    logFeatureEvent(key, enabled, previousEnabled) {
+        if (!this.analytics)
+            return;
+        try {
+            if (previousEnabled === null) {
+                // Carga inicial
+                this.analytics.logEvent('feature_loaded', {
+                    feature_key: key,
+                    feature_enabled: enabled,
+                });
+            }
+            else if (previousEnabled !== enabled) {
+                // Transición de estado
+                this.analytics.logEvent('feature_changed', {
+                    feature_key: key,
+                    previous_state: previousEnabled ? 'enabled' : 'disabled',
+                    current_state: enabled ? 'enabled' : 'disabled',
+                });
+            }
+        }
+        catch (err) {
+            console.warn(`Failed to log feature event for ${key}:`, err);
+        }
+    }
+    /**
+     * Load user features from backend.
+     * Call this during app initialization (AppComponent ctor or effect).
+     * Logs feature state changes to Firebase Analytics.
+     */
+    async loadUserFeatures() {
+        try {
+            const response = await firstValueFrom(this.http.get('/v2/user/features'));
+            const map = new Map();
+            response.forEach(f => {
+                const previousEnabled = this.previousState.get(f.key) ?? null;
+                this.logFeatureEvent(f.key, f.enabled, previousEnabled);
+                this.previousState.set(f.key, f.enabled);
+                map.set(f.key, f.enabled);
+            });
+            this.features.set(map);
+            this.isLoaded.set(true);
+        }
+        catch (error) {
+            console.error('Failed to load feature control:', error);
+            // Fallback: assume all features enabled on error (optimistic)
+            this.isLoaded.set(true);
+        }
+    }
+    /**
+     * Check if a feature is enabled for the current user.
+     * Returns true if feature is not found (optimistic default).
+     * If rollout percentage is set, uses consistent hashing for canary rollouts.
+     */
+    isEnabled(featureKey) {
+        const featuresMap = this.features();
+        const feature = featuresMap.get(featureKey);
+        // Not in map: default to enabled (optimistic)
+        if (feature === undefined)
+            return true;
+        // Not enabled: return false
+        if (!feature)
+            return false;
+        // TODO: Implement rollout percentage check with hash
+        // For now, if enabled and no rollout, it's enabled for everyone
+        return true;
+    }
+    /**
+     * Get a computed signal for a feature.
+     * Use in templates: *ngIf="featureEnabled('oauth_facebook')()"
+     * Or in component: featureEnabled('payment_settings').
+     */
+    featureEnabled(featureKey) {
+        return () => this.isEnabled(featureKey);
+    }
+    /**
+     * Get all features for debugging (admin only).
+     */
+    getAllFeatures() {
+        return this.features();
+    }
+    /**
+     * Check if features have been loaded.
+     */
+    isReady() {
+        return this.isLoaded();
+    }
+    /**
+     * Watch for feature changes (for testing/demo purposes).
+     */
+    watchFeatures() {
+        return this.features;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: FeatureControlService, deps: [{ token: i1.HttpClient }, { token: i2.AnalyticsService, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: FeatureControlService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: FeatureControlService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1.HttpClient }, { type: i2.AnalyticsService, decorators: [{
+                    type: Optional
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"feature-control.service.js","sourceRoot":"","sources":["../../../../../src/lib/services/feature-control.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, signal, Optional } from '@angular/core';\nimport { HttpClient } from '@angular/common/http';\nimport { firstValueFrom } from 'rxjs';\nimport { AnalyticsService } from './firebase/analytics.service';\n\nexport interface UserFeature {\n  key: string;\n  enabled: boolean;\n  rolloutPercentage?: number; // 0-100: percentage of users who get this feature\n  rolloutHash?: string; // Hash used for consistent rollout (e.g., user ID hash)\n}\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class FeatureControlService {\n  private features = signal<Map<string, boolean>>(new Map());\n  private isLoaded = signal(false);\n  private previousState = new Map<string, boolean>();\n\n  constructor(\n    private http: HttpClient,\n    @Optional() private analytics?: AnalyticsService\n  ) {}\n\n  private logFeatureEvent(key: string, enabled: boolean, previousEnabled: boolean | null): void {\n    if (!this.analytics) return;\n\n    try {\n      if (previousEnabled === null) {\n        // Carga inicial\n        this.analytics.logEvent('feature_loaded', {\n          feature_key: key,\n          feature_enabled: enabled,\n        });\n      } else if (previousEnabled !== enabled) {\n        // Transición de estado\n        this.analytics.logEvent('feature_changed', {\n          feature_key: key,\n          previous_state: previousEnabled ? 'enabled' : 'disabled',\n          current_state: enabled ? 'enabled' : 'disabled',\n        });\n      }\n    } catch (err) {\n      console.warn(`Failed to log feature event for ${key}:`, err);\n    }\n  }\n\n  /**\n   * Load user features from backend.\n   * Call this during app initialization (AppComponent ctor or effect).\n   * Logs feature state changes to Firebase Analytics.\n   */\n  async loadUserFeatures(): Promise<void> {\n    try {\n      const response = await firstValueFrom(this.http.get<UserFeature[]>('/v2/user/features'));\n      const map = new Map<string, boolean>();\n\n      response.forEach(f => {\n        const previousEnabled = this.previousState.get(f.key) ?? null;\n        this.logFeatureEvent(f.key, f.enabled, previousEnabled);\n        this.previousState.set(f.key, f.enabled);\n        map.set(f.key, f.enabled);\n      });\n\n      this.features.set(map);\n      this.isLoaded.set(true);\n    } catch (error) {\n      console.error('Failed to load feature control:', error);\n      // Fallback: assume all features enabled on error (optimistic)\n      this.isLoaded.set(true);\n    }\n  }\n\n  /**\n   * Check if a feature is enabled for the current user.\n   * Returns true if feature is not found (optimistic default).\n   * If rollout percentage is set, uses consistent hashing for canary rollouts.\n   */\n  isEnabled(featureKey: string): boolean {\n    const featuresMap = this.features();\n    const feature = featuresMap.get(featureKey);\n\n    // Not in map: default to enabled (optimistic)\n    if (feature === undefined) return true;\n\n    // Not enabled: return false\n    if (!feature) return false;\n\n    // TODO: Implement rollout percentage check with hash\n    // For now, if enabled and no rollout, it's enabled for everyone\n    return true;\n  }\n\n  /**\n   * Get a computed signal for a feature.\n   * Use in templates: *ngIf=\"featureEnabled('oauth_facebook')()\"\n   * Or in component: featureEnabled('payment_settings').\n   */\n  featureEnabled(featureKey: string) {\n    return () => this.isEnabled(featureKey);\n  }\n\n  /**\n   * Get all features for debugging (admin only).\n   */\n  getAllFeatures(): Map<string, boolean> {\n    return this.features();\n  }\n\n  /**\n   * Check if features have been loaded.\n   */\n  isReady(): boolean {\n    return this.isLoaded();\n  }\n\n  /**\n   * Watch for feature changes (for testing/demo purposes).\n   */\n  watchFeatures() {\n    return this.features;\n  }\n}\n"]}

package/esm2022/lib/services/groups/groups.service.mjs

@@ -0,0 +1,92 @@
+import { Injectable, Inject } from '@angular/core';
+import { map } from 'rxjs/operators';
+import { VALTECH_AUTH_CONFIG } from '../auth/config';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+/**
+ * Cliente de `/v2/groups/*` (ADR-083). Servicio de PLATAFORMA: no sabe qué es
+ * un blueprint ni un refugio, solo agrupa recursos y personas. Cada app lo
+ * consume igual — es lo que evita reescribir esta capa por producto.
+ */
+export class GroupsService {
+    constructor(config, http) {
+        this.config = config;
+        this.http = http;
+    }
+    get baseUrl() {
+        return `${this.config.apiUrl}/v2/groups`;
+    }
+    /** Grupos activos de la organización (filtrados por app en el backend). */
+    listGroups() {
+        return this.http
+            .get(this.baseUrl)
+            .pipe(map((r) => r.groups ?? []));
+    }
+    /** Incluye archivados: para la pantalla de administración. */
+    listAllGroups() {
+        return this.http
+            .get(`${this.baseUrl}/all`)
+            .pipe(map((r) => r.groups ?? []));
+    }
+    getGroup(id) {
+        return this.http
+            .get(`${this.baseUrl}/${id}`)
+            .pipe(map((r) => r.group));
+    }
+    createGroup(req) {
+        return this.http
+            .post(this.baseUrl, req)
+            .pipe(map((r) => r.group));
+    }
+    updateGroup(id, req) {
+        return this.http
+            .put(`${this.baseUrl}/${id}`, req)
+            .pipe(map((r) => r.group));
+    }
+    /**
+     * No hay `deleteGroup`: el ADR-083 decidió que un servicio de plataforma no
+     * puede saber si un vertical todavía apunta al grupo, y como "sin grupo"
+     * significa visible para toda la organización, borrarlo publicaría sus
+     * recursos a la planta entera. `archiveGroup`/`restoreGroup` cubren la
+     * necesidad real sin ese riesgo.
+     */
+    archiveGroup(id) {
+        return this.http
+            .post(`${this.baseUrl}/${id}/archive`, {})
+            .pipe(map((r) => r.group));
+    }
+    restoreGroup(id) {
+        return this.http
+            .post(`${this.baseUrl}/${id}/restore`, {})
+            .pipe(map((r) => r.group));
+    }
+    listMembers(groupId) {
+        return this.http
+            .get(`${this.baseUrl}/${groupId}/members`)
+            .pipe(map((r) => r.members ?? []));
+    }
+    addMember(groupId, req) {
+        return this.http
+            .post(`${this.baseUrl}/${groupId}/members`, req)
+            .pipe(map((r) => r.members ?? []));
+    }
+    removeMember(groupId, userId) {
+        return this.http
+            .delete(`${this.baseUrl}/${groupId}/members/${userId}`)
+            .pipe(map((r) => r.members ?? []));
+    }
+    /** Los grupos del usuario actual. Referencial: el filtrado real corre en el backend. */
+    myGroups() {
+        return this.http.get(`${this.baseUrl}/mine`);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: GroupsService, deps: [{ token: VALTECH_AUTH_CONFIG }, { token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: GroupsService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: GroupsService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [VALTECH_AUTH_CONFIG]
+                }] }, { type: i1.HttpClient }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"groups.service.js","sourceRoot":"","sources":["../../../../../../src/lib/services/groups/groups.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, Inject } from '@angular/core';\nimport { HttpClient } from '@angular/common/http';\nimport { Observable } from 'rxjs';\nimport { map } from 'rxjs/operators';\n\nimport { VALTECH_AUTH_CONFIG } from '../auth/config';\nimport { ValtechAuthConfig } from '../auth/types';\nimport {\n  ValGroup,\n  ValGroupMember,\n  CreateGroupRequest,\n  UpdateGroupRequest,\n  AddGroupMemberRequest,\n  GroupResponse,\n  ListGroupsResponse,\n  ListGroupMembersResponse,\n  MyGroupsResponse,\n} from './types';\n\n/**\n * Cliente de `/v2/groups/*` (ADR-083). Servicio de PLATAFORMA: no sabe qué es\n * un blueprint ni un refugio, solo agrupa recursos y personas. Cada app lo\n * consume igual — es lo que evita reescribir esta capa por producto.\n */\n@Injectable({ providedIn: 'root' })\nexport class GroupsService {\n  constructor(\n    @Inject(VALTECH_AUTH_CONFIG) private config: ValtechAuthConfig,\n    private http: HttpClient\n  ) {}\n\n  private get baseUrl(): string {\n    return `${this.config.apiUrl}/v2/groups`;\n  }\n\n  /** Grupos activos de la organización (filtrados por app en el backend). */\n  listGroups(): Observable<ValGroup[]> {\n    return this.http\n      .get<ListGroupsResponse>(this.baseUrl)\n      .pipe(map((r) => r.groups ?? []));\n  }\n\n  /** Incluye archivados: para la pantalla de administración. */\n  listAllGroups(): Observable<ValGroup[]> {\n    return this.http\n      .get<ListGroupsResponse>(`${this.baseUrl}/all`)\n      .pipe(map((r) => r.groups ?? []));\n  }\n\n  getGroup(id: string): Observable<ValGroup> {\n    return this.http\n      .get<GroupResponse>(`${this.baseUrl}/${id}`)\n      .pipe(map((r) => r.group));\n  }\n\n  createGroup(req: CreateGroupRequest): Observable<ValGroup> {\n    return this.http\n      .post<GroupResponse>(this.baseUrl, req)\n      .pipe(map((r) => r.group));\n  }\n\n  updateGroup(id: string, req: UpdateGroupRequest): Observable<ValGroup> {\n    return this.http\n      .put<GroupResponse>(`${this.baseUrl}/${id}`, req)\n      .pipe(map((r) => r.group));\n  }\n\n  /**\n   * No hay `deleteGroup`: el ADR-083 decidió que un servicio de plataforma no\n   * puede saber si un vertical todavía apunta al grupo, y como \"sin grupo\"\n   * significa visible para toda la organización, borrarlo publicaría sus\n   * recursos a la planta entera. `archiveGroup`/`restoreGroup` cubren la\n   * necesidad real sin ese riesgo.\n   */\n  archiveGroup(id: string): Observable<ValGroup> {\n    return this.http\n      .post<GroupResponse>(`${this.baseUrl}/${id}/archive`, {})\n      .pipe(map((r) => r.group));\n  }\n\n  restoreGroup(id: string): Observable<ValGroup> {\n    return this.http\n      .post<GroupResponse>(`${this.baseUrl}/${id}/restore`, {})\n      .pipe(map((r) => r.group));\n  }\n\n  listMembers(groupId: string): Observable<ValGroupMember[]> {\n    return this.http\n      .get<ListGroupMembersResponse>(`${this.baseUrl}/${groupId}/members`)\n      .pipe(map((r) => r.members ?? []));\n  }\n\n  addMember(groupId: string, req: AddGroupMemberRequest): Observable<ValGroupMember[]> {\n    return this.http\n      .post<ListGroupMembersResponse>(`${this.baseUrl}/${groupId}/members`, req)\n      .pipe(map((r) => r.members ?? []));\n  }\n\n  removeMember(groupId: string, userId: string): Observable<ValGroupMember[]> {\n    return this.http\n      .delete<ListGroupMembersResponse>(`${this.baseUrl}/${groupId}/members/${userId}`)\n      .pipe(map((r) => r.members ?? []));\n  }\n\n  /** Los grupos del usuario actual. Referencial: el filtrado real corre en el backend. */\n  myGroups(): Observable<MyGroupsResponse> {\n    return this.http.get<MyGroupsResponse>(`${this.baseUrl}/mine`);\n  }\n}\n"]}

package/esm2022/lib/services/groups/types.mjs

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