valtech-components 4.0.939 → 4.0.940

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/qr-generator/qrbrand.mjs

@@ -0,0 +1,89 @@
+/**
+ * Contrato de marca de un QR, compartido entre backend y frontend (ADR-078).
+ *
+ * Espejo TypeScript de `backend/go/services/pkg/qrbrand/qrbrand.go`. Los tests
+ * de contraste de este archivo usan LOS MISMOS casos que el lado Go
+ * (`qrbrand_test.go`) — si un lado cambia el número esperado sin el otro,
+ * dejan de coincidir.
+ *
+ * No dibuja nada: valida que una combinación de colores sea escaneable y
+ * decide cuánta corrección de errores necesita un QR que lleva logo encima.
+ * El renderizado real sigue siendo QrGeneratorService (cliente) y qrpng.go
+ * (backend, correo) — cada uno dibuja a su manera; lo que comparten es esta
+ * validación.
+ */
+/** Sin marca configurada: tinta sobre blanco. Nunca se persiste. */
+export function defaultQrBrand(orgId, appId) {
+    return { orgId, appId, ink: '#111111', bg: '#FFFFFF', dotStyle: 'square' };
+}
+const HEX_RE = /^#([0-9a-fA-F]{6})$/;
+/** El mínimo WCAG para texto normal (AA) — ver qrbrand.go para el porqué de reusarlo acá. */
+const MIN_CONTRAST_RATIO = 4.5;
+export class QrBrandValidationError extends Error {
+    constructor(field, message) {
+        super(`${field}: ${message}`);
+        this.field = field;
+        this.name = 'QrBrandValidationError';
+    }
+}
+function hexToRgb(hex) {
+    const m = HEX_RE.exec(hex);
+    if (!m)
+        return [0, 0, 0];
+    const v = parseInt(m[1], 16);
+    return [((v >> 16) & 0xff) / 255, ((v >> 8) & 0xff) / 255, (v & 0xff) / 255];
+}
+function srgbToLinear(c) {
+    return c <= 0.03928 ? c / 12.92 : Math.pow((c + 0.055) / 1.055, 2.4);
+}
+function relativeLuminance(hex) {
+    const [r, g, b] = hexToRgb(hex);
+    const [rl, gl, bl] = [srgbToLinear(r), srgbToLinear(g), srgbToLinear(b)];
+    return 0.2126 * rl + 0.7152 * gl + 0.0722 * bl;
+}
+/** Contraste WCAG entre dos colores hex (#RRGGBB). Fórmula estándar (L1+0.05)/(L2+0.05). */
+export function qrContrastRatio(hexA, hexB) {
+    let la = relativeLuminance(hexA);
+    let lb = relativeLuminance(hexB);
+    if (la < lb)
+        [la, lb] = [lb, la];
+    return (la + 0.05) / (lb + 0.05);
+}
+/**
+ * Rechaza una combinación de colores que un lector real no va a poder leer.
+ * Escaneabilidad sobre estética: esta función no negocia (ADR-078 regla 1).
+ * Lanza QrBrandValidationError; no retorna un booleano — el caller casi
+ * siempre necesita el mensaje para mostrarlo en el formulario.
+ */
+export function validateQrBrand(b) {
+    if (!HEX_RE.test(b.ink)) {
+        throw new QrBrandValidationError('ink', 'debe ser un color hex de 6 dígitos, ej. #111111');
+    }
+    if (!HEX_RE.test(b.bg)) {
+        throw new QrBrandValidationError('bg', 'debe ser un color hex de 6 dígitos, ej. #FFFFFF');
+    }
+    if (b.dotStyle && !['square', 'rounded', 'dots'].includes(b.dotStyle)) {
+        throw new QrBrandValidationError('dotStyle', 'debe ser square, rounded o dots');
+    }
+    const ratio = qrContrastRatio(b.ink, b.bg);
+    if (ratio < MIN_CONTRAST_RATIO) {
+        throw new QrBrandValidationError('ink/bg', `contraste ${ratio.toFixed(2)}:1 por debajo del mínimo ${MIN_CONTRAST_RATIO.toFixed(1)}:1 — un lector real no va a poder escanearlo`);
+    }
+    if (b.logo && (b.logo.clearArea ?? 0) > 0.3) {
+        throw new QrBrandValidationError('logo.clearArea', 'un logo que tapa más del 30% del QR deja de ser legible aunque suba la corrección de errores');
+    }
+}
+/**
+ * El logo obliga a subir la corrección de errores, no se le pregunta al
+ * usuario (ADR-078 regla 2). Sin logo, M alcanza. Con logo, sube a Q; con
+ * logo grande (>15% del área), sube al máximo H.
+ */
+export function qrErrorCorrectionFor(b) {
+    const clearArea = b.logo?.clearArea ?? 0;
+    if (!b.logo || clearArea <= 0)
+        return 'M';
+    if (clearArea > 0.15)
+        return 'H';
+    return 'Q';
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"qrbrand.js","sourceRoot":"","sources":["../../../../../../src/lib/services/qr-generator/qrbrand.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Contrato de marca de un QR, compartido entre backend y frontend (ADR-078).\n *\n * Espejo TypeScript de `backend/go/services/pkg/qrbrand/qrbrand.go`. Los tests\n * de contraste de este archivo usan LOS MISMOS casos que el lado Go\n * (`qrbrand_test.go`) — si un lado cambia el número esperado sin el otro,\n * dejan de coincidir.\n *\n * No dibuja nada: valida que una combinación de colores sea escaneable y\n * decide cuánta corrección de errores necesita un QR que lleva logo encima.\n * El renderizado real sigue siendo QrGeneratorService (cliente) y qrpng.go\n * (backend, correo) — cada uno dibuja a su manera; lo que comparten es esta\n * validación.\n */\n\nexport type QrBrandDotStyle = 'square' | 'rounded' | 'dots';\n\nexport type QrBrandErrorCorrection = 'L' | 'M' | 'Q' | 'H';\n\nexport interface QrBrandLogo {\n  assetId: string;\n  /** Fracción del QR (0–1) que el logo tapa en el centro. */\n  clearArea?: number;\n}\n\nexport interface QrBrand {\n  orgId: string;\n  appId: string;\n  ink: string;\n  bg: string;\n  dotStyle?: QrBrandDotStyle;\n  logo?: QrBrandLogo;\n}\n\n/** Sin marca configurada: tinta sobre blanco. Nunca se persiste. */\nexport function defaultQrBrand(orgId: string, appId: string): QrBrand {\n  return { orgId, appId, ink: '#111111', bg: '#FFFFFF', dotStyle: 'square' };\n}\n\nconst HEX_RE = /^#([0-9a-fA-F]{6})$/;\n\n/** El mínimo WCAG para texto normal (AA) — ver qrbrand.go para el porqué de reusarlo acá. */\nconst MIN_CONTRAST_RATIO = 4.5;\n\nexport class QrBrandValidationError extends Error {\n  constructor(\n    public readonly field: string,\n    message: string,\n  ) {\n    super(`${field}: ${message}`);\n    this.name = 'QrBrandValidationError';\n  }\n}\n\nfunction hexToRgb(hex: string): [number, number, number] {\n  const m = HEX_RE.exec(hex);\n  if (!m) return [0, 0, 0];\n  const v = parseInt(m[1], 16);\n  return [((v >> 16) & 0xff) / 255, ((v >> 8) & 0xff) / 255, (v & 0xff) / 255];\n}\n\nfunction srgbToLinear(c: number): number {\n  return c <= 0.03928 ? c / 12.92 : Math.pow((c + 0.055) / 1.055, 2.4);\n}\n\nfunction relativeLuminance(hex: string): number {\n  const [r, g, b] = hexToRgb(hex);\n  const [rl, gl, bl] = [srgbToLinear(r), srgbToLinear(g), srgbToLinear(b)];\n  return 0.2126 * rl + 0.7152 * gl + 0.0722 * bl;\n}\n\n/** Contraste WCAG entre dos colores hex (#RRGGBB). Fórmula estándar (L1+0.05)/(L2+0.05). */\nexport function qrContrastRatio(hexA: string, hexB: string): number {\n  let la = relativeLuminance(hexA);\n  let lb = relativeLuminance(hexB);\n  if (la < lb) [la, lb] = [lb, la];\n  return (la + 0.05) / (lb + 0.05);\n}\n\n/**\n * Rechaza una combinación de colores que un lector real no va a poder leer.\n * Escaneabilidad sobre estética: esta función no negocia (ADR-078 regla 1).\n * Lanza QrBrandValidationError; no retorna un booleano — el caller casi\n * siempre necesita el mensaje para mostrarlo en el formulario.\n */\nexport function validateQrBrand(b: QrBrand): void {\n  if (!HEX_RE.test(b.ink)) {\n    throw new QrBrandValidationError('ink', 'debe ser un color hex de 6 dígitos, ej. #111111');\n  }\n  if (!HEX_RE.test(b.bg)) {\n    throw new QrBrandValidationError('bg', 'debe ser un color hex de 6 dígitos, ej. #FFFFFF');\n  }\n  if (b.dotStyle && !['square', 'rounded', 'dots'].includes(b.dotStyle)) {\n    throw new QrBrandValidationError('dotStyle', 'debe ser square, rounded o dots');\n  }\n  const ratio = qrContrastRatio(b.ink, b.bg);\n  if (ratio < MIN_CONTRAST_RATIO) {\n    throw new QrBrandValidationError(\n      'ink/bg',\n      `contraste ${ratio.toFixed(2)}:1 por debajo del mínimo ${MIN_CONTRAST_RATIO.toFixed(1)}:1 — un lector real no va a poder escanearlo`,\n    );\n  }\n  if (b.logo && (b.logo.clearArea ?? 0) > 0.3) {\n    throw new QrBrandValidationError(\n      'logo.clearArea',\n      'un logo que tapa más del 30% del QR deja de ser legible aunque suba la corrección de errores',\n    );\n  }\n}\n\n/**\n * El logo obliga a subir la corrección de errores, no se le pregunta al\n * usuario (ADR-078 regla 2). Sin logo, M alcanza. Con logo, sube a Q; con\n * logo grande (>15% del área), sube al máximo H.\n */\nexport function qrErrorCorrectionFor(b: QrBrand): QrBrandErrorCorrection {\n  const clearArea = b.logo?.clearArea ?? 0;\n  if (!b.logo || clearArea <= 0) return 'M';\n  if (clearArea > 0.15) return 'H';\n  return 'Q';\n}\n"]}

package/esm2022/lib/version.mjs

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