valtech-components 2.0.821 → 2.0.823

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

@@ -0,0 +1,92 @@
+import { computed, inject, Injectable, signal } from '@angular/core';
+import { VALTECH_DONATION_CONFIG } from './config';
+import * as i0 from "@angular/core";
+/**
+ * `DonationService`
+ *
+ * Servicio cross-app para el feature de aportes voluntarios (Support).
+ * Patrón factory: cada app llama `provideValtechDonations(...)` y este
+ * servicio expone solo los métodos habilitados.
+ *
+ * **Fase 0 (placeholder)** — abre links externos + expone datos de config.
+ * Sin backend. Fases futuras: rewarded ads reales, webhook de café,
+ * registro de intents para una página de transparencia.
+ *
+ * @example
+ * ```typescript
+ * private donations = inject(DonationService);
+ *
+ * methods = this.donations.enabledMethods();  // ['coffee', 'bank']
+ * onCoffee() { this.donations.openCoffee(); }
+ * accounts = this.donations.bankAccounts();
+ * ```
+ */
+export class DonationService {
+    constructor() {
+        this.config = inject(VALTECH_DONATION_CONFIG, {
+            optional: true,
+        }) ?? { methods: [] };
+        /** Último intent registrado — útil para tests / debugging / UI feedback. */
+        this._lastIntent = signal(null);
+        this.lastIntent = this._lastIntent.asReadonly();
+        /** Métodos habilitados por la app, en orden de config. */
+        this.enabledMethods = computed(() => this.config.methods ?? []);
+    }
+    /** `true` si el método está habilitado en la config de la app. */
+    isEnabled(method) {
+        return this.enabledMethods().includes(method);
+    }
+    /** Cuentas bancarias configuradas (vacío si `bank` no está habilitado). */
+    bankAccounts() {
+        if (!this.isEnabled('bank'))
+            return [];
+        return this.config.bank?.accounts ?? [];
+    }
+    /** Cuentas filtradas por país ISO — para apps multi-mercado. */
+    bankAccountsByCountry(country) {
+        return this.bankAccounts().filter(a => a.country.toUpperCase() === country.toUpperCase());
+    }
+    /**
+     * Abre el checkout de "café" (Buy Me a Coffee / Ko-fi) en una pestaña nueva.
+     * El proveedor es el merchant of record — Valtech no procesa el pago.
+     */
+    openCoffee() {
+        if (!this.isEnabled('coffee')) {
+            return { method: 'coffee', ok: false, reason: 'not-enabled' };
+        }
+        const url = this.config.coffee?.url;
+        if (!url) {
+            return { method: 'coffee', ok: false, reason: 'not-configured' };
+        }
+        this.recordIntent('coffee');
+        window.open(url, '_blank', 'noopener,noreferrer');
+        return { method: 'coffee', ok: true };
+    }
+    /**
+     * Muestra un anuncio rewarded (opt-in). **Fase 0: no implementado** —
+     * placeholder hasta integrar el plugin de ads (AdMob/AdSense) + la
+     * categoría de consentimiento. Retorna `not-supported`.
+     */
+    async showRewardedAd() {
+        if (!this.isEnabled('ads')) {
+            return { method: 'ads', ok: false, reason: 'not-enabled' };
+        }
+        // TODO Fase 3 — integrar Capacitor AdMob (mobile) / AdSense (web)
+        // + gate en una nueva categoría de consentimiento.
+        return { method: 'ads', ok: false, reason: 'not-supported' };
+    }
+    /**
+     * Registra la intención de aporte. **Fase 0: solo estado local.**
+     * Fase 4 — POST a un endpoint para una página de transparencia.
+     */
+    recordIntent(method) {
+        this._lastIntent.set(method);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DonationService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DonationService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DonationService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/donation/index.mjs

@@ -0,0 +1,25 @@
+/**
+ * Valtech Donation / Support Service
+ *
+ * Feature cross-app de aportes voluntarios. Patrón factory: cada app llama
+ * `provideValtechDonations(...)` y habilita los métodos que quiera
+ * (`ads` · `coffee` · `bank`).
+ *
+ * Importante (legal): el dinero recibido por una entidad con fines de lucro
+ * es ingreso afecto a impuesto, NO una donación deducible. La UI debe usar
+ * lenguaje de "aporte voluntario / apoyo", nunca "donación".
+ *
+ * @example
+ * ```typescript
+ * // main.ts
+ * provideValtechDonations({
+ *   appId: 'showcase',
+ *   methods: ['coffee', 'bank'],
+ *   coffee: { provider: 'buymeacoffee', url: 'https://buymeacoffee.com/valtech' },
+ *   bank: { accounts: [ ... ] },
+ * }),
+ * ```
+ */
+export { VALTECH_DONATION_CONFIG, provideValtechDonations, DEFAULT_DONATION_CONFIG, } from './config';
+export { DonationService } from './donation.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvbGliL3NlcnZpY2VzL2RvbmF0aW9uL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7R0FxQkc7QUFFSCxPQUFPLEVBQ0wsdUJBQXVCLEVBQ3ZCLHVCQUF1QixFQUN2Qix1QkFBdUIsR0FDeEIsTUFBTSxVQUFVLENBQUM7QUFFbEIsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLG9CQUFvQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBWYWx0ZWNoIERvbmF0aW9uIC8gU3VwcG9ydCBTZXJ2aWNlXG4gKlxuICogRmVhdHVyZSBjcm9zcy1hcHAgZGUgYXBvcnRlcyB2b2x1bnRhcmlvcy4gUGF0csOzbiBmYWN0b3J5OiBjYWRhIGFwcCBsbGFtYVxuICogYHByb3ZpZGVWYWx0ZWNoRG9uYXRpb25zKC4uLilgIHkgaGFiaWxpdGEgbG9zIG3DqXRvZG9zIHF1ZSBxdWllcmFcbiAqIChgYWRzYCDCtyBgY29mZmVlYCDCtyBgYmFua2ApLlxuICpcbiAqIEltcG9ydGFudGUgKGxlZ2FsKTogZWwgZGluZXJvIHJlY2liaWRvIHBvciB1bmEgZW50aWRhZCBjb24gZmluZXMgZGUgbHVjcm9cbiAqIGVzIGluZ3Jlc28gYWZlY3RvIGEgaW1wdWVzdG8sIE5PIHVuYSBkb25hY2nDs24gZGVkdWNpYmxlLiBMYSBVSSBkZWJlIHVzYXJcbiAqIGxlbmd1YWplIGRlIFwiYXBvcnRlIHZvbHVudGFyaW8gLyBhcG95b1wiLCBudW5jYSBcImRvbmFjacOzblwiLlxuICpcbiAqIEBleGFtcGxlXG4gKiBgYGB0eXBlc2NyaXB0XG4gKiAvLyBtYWluLnRzXG4gKiBwcm92aWRlVmFsdGVjaERvbmF0aW9ucyh7XG4gKiAgIGFwcElkOiAnc2hvd2Nhc2UnLFxuICogICBtZXRob2RzOiBbJ2NvZmZlZScsICdiYW5rJ10sXG4gKiAgIGNvZmZlZTogeyBwcm92aWRlcjogJ2J1eW1lYWNvZmZlZScsIHVybDogJ2h0dHBzOi8vYnV5bWVhY29mZmVlLmNvbS92YWx0ZWNoJyB9LFxuICogICBiYW5rOiB7IGFjY291bnRzOiBbIC4uLiBdIH0sXG4gKiB9KSxcbiAqIGBgYFxuICovXG5cbmV4cG9ydCB7XG4gIFZBTFRFQ0hfRE9OQVRJT05fQ09ORklHLFxuICBwcm92aWRlVmFsdGVjaERvbmF0aW9ucyxcbiAgREVGQVVMVF9ET05BVElPTl9DT05GSUcsXG59IGZyb20gJy4vY29uZmlnJztcblxuZXhwb3J0IHsgRG9uYXRpb25TZXJ2aWNlIH0gZnJvbSAnLi9kb25hdGlvbi5zZXJ2aWNlJztcblxuZXhwb3J0IHtcbiAgRG9uYXRpb25NZXRob2QsXG4gIENvZmZlZVByb3ZpZGVyLFxuICBBZHNQcm92aWRlcixcbiAgQmFua0FjY291bnQsXG4gIENvZmZlZUNvbmZpZyxcbiAgQWRzQ29uZmlnLFxuICBWYWx0ZWNoRG9uYXRpb25Db25maWcsXG4gIERvbmF0aW9uQWN0aW9uUmVzdWx0LFxufSBmcm9tICcuL3R5cGVzJztcbiJdfQ==

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

@@ -0,0 +1,10 @@
+/**
+ * Valtech Donation / Support — tipos.
+ *
+ * Nota legal importante: el dinero recibido por una entidad con fines de lucro
+ * NO es una "donación" deducible de impuestos — es ingreso afecto. Por eso la
+ * UI debe usar lenguaje de "aporte voluntario / apoyo", nunca "donación" en su
+ * sentido jurídico. Ver `docs/` (pendiente) y la vista Support del consumer.
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,80 @@
+/**
+ * Service for downloading files and opening links in new tabs.
+ * Provides utility methods for browser-based file downloads and extracting file names from URLs.
+ */
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class DownloadService {
+    /**
+     * Extracts the file name from a given URL.
+     * @param url The file URL
+     * @returns The file name
+     */
+    getFileNameFromUrl(url) {
+        try {
+            const pathSegments = url.split('/');
+            const lastSegment = pathSegments[pathSegments.length - 1];
+            const fileName = decodeURIComponent(lastSegment);
+            return fileName;
+        }
+        catch (error) {
+            console.error('Error al obtener nombre de archivo: ', JSON.stringify(error));
+            return 'filename';
+        }
+    }
+    /**
+     * Opens a given URL in a new browser tab and triggers download if possible.
+     * @param url The file URL
+     */
+    openNewTab(url) {
+        if (url) {
+            const fileName = this.getFileNameFromUrl(url);
+            const link = document.createElement('a');
+            link.href = url;
+            link.download = fileName;
+            link.target = '_blank';
+            document.body.appendChild(link);
+            link.click();
+            document.body.removeChild(link);
+        }
+        else {
+            console.error('La URL no está definida');
+        }
+    }
+    /**
+     * Downloads a file from the browser using fetch and triggers a download dialog.
+     * @param url The file URL
+     */
+    downloadLinkFromBrowser(url) {
+        console.log('trying to download file from url');
+        if (url) {
+            fetch(url)
+                .then(response => response.blob())
+                .then(blob => {
+                const url = window.URL.createObjectURL(blob);
+                const link = document.createElement('a');
+                link.href = url;
+                const fileName = this.getFileNameFromUrl(url);
+                link.download = `${+new Date()}-${fileName}`;
+                link.target = '_self';
+                link.click();
+                window.URL.revokeObjectURL(url);
+            })
+                .catch(error => {
+                console.error('Error al descargar el archivo:', JSON.stringify(error));
+            });
+        }
+        else {
+            console.error('La URL no está definida');
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DownloadService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DownloadService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DownloadService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/feedback/config.mjs

@@ -0,0 +1,49 @@
+import { InjectionToken, makeEnvironmentProviders, } from '@angular/core';
+/**
+ * Token de inyección para la configuración de Feedback.
+ */
+export const VALTECH_FEEDBACK_CONFIG = new InjectionToken('ValtechFeedbackConfig');
+/**
+ * Configuración por defecto.
+ */
+export const DEFAULT_FEEDBACK_CONFIG = {
+    feedbackPrefix: '/v1/feedback',
+    maxAttachments: 5,
+    maxFileSize: 10 * 1024 * 1024, // 10MB
+    allowedFileTypes: ['image/*', 'video/*', 'application/pdf'],
+    storagePath: 'feedback',
+};
+/**
+ * Provee el servicio de feedback a la aplicación Angular.
+ *
+ * @param config - Configuración de feedback
+ * @returns EnvironmentProviders para usar en bootstrapApplication
+ *
+ * @example
+ * ```typescript
+ * // main.ts
+ * import { bootstrapApplication } from '@angular/platform-browser';
+ * import { provideValtechFeedback } from 'valtech-components';
+ * import { environment } from './environments/environment';
+ *
+ * bootstrapApplication(AppComponent, {
+ *   providers: [
+ *     provideValtechAuth({ apiUrl: environment.apiUrl }),
+ *     provideValtechFeedback({
+ *       apiUrl: environment.apiUrl,
+ *       appId: 'my-app-name',
+ *     }),
+ *   ],
+ * });
+ * ```
+ */
+export function provideValtechFeedback(config) {
+    const mergedConfig = {
+        ...DEFAULT_FEEDBACK_CONFIG,
+        ...config,
+    };
+    return makeEnvironmentProviders([
+        { provide: VALTECH_FEEDBACK_CONFIG, useValue: mergedConfig },
+    ]);
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,296 @@
+import { Injectable, inject } from '@angular/core';
+import { HttpClient } from '@angular/common/http';
+import { firstValueFrom } from 'rxjs';
+import { VALTECH_FEEDBACK_CONFIG } from './config';
+import { FirestoreService } from '../firebase/firestore.service';
+import { AuthService } from '../auth/auth.service';
+import * as i0 from "@angular/core";
+/**
+ * Servicio para gestionar feedback de usuarios.
+ *
+ * @example
+ * ```typescript
+ * @Component({...})
+ * export class MyComponent {
+ *   private feedbackService = inject(FeedbackService);
+ *
+ *   async submitFeedback() {
+ *     const response = await this.feedbackService.createAsync(
+ *       'feedback',
+ *       'Mi comentario',
+ *       'Descripción detallada...'
+ *     );
+ *     console.log('Feedback enviado:', response.feedbackId);
+ *   }
+ * }
+ * ```
+ */
+export class FeedbackService {
+    constructor() {
+        this.config = inject(VALTECH_FEEDBACK_CONFIG);
+        this.http = inject(HttpClient);
+        this.firestore = inject(FirestoreService, { optional: true });
+        this.auth = inject(AuthService, { optional: true });
+    }
+    /**
+     * URL base para endpoints de feedback.
+     */
+    get baseUrl() {
+        return `${this.config.apiUrl}${this.config.feedbackPrefix}`;
+    }
+    /**
+     * Captura el contexto del dispositivo automáticamente.
+     */
+    captureDeviceContext() {
+        const ua = navigator.userAgent;
+        return {
+            browser: this.detectBrowser(ua),
+            os: this.detectOS(ua),
+            viewport: `${window.innerWidth}x${window.innerHeight}`,
+            language: navigator.language,
+            userAgent: ua,
+            pageUrl: window.location.href,
+        };
+    }
+    /**
+     * Crea un nuevo feedback.
+     *
+     * @param type - Tipo de feedback
+     * @param title - Título del feedback
+     * @param description - Descripción detallada
+     * @param attachments - URLs de archivos adjuntos (opcional)
+     * @param contentRef - Referencia a contenido específico (opcional)
+     * @returns Observable con la respuesta
+     */
+    create(type, title, description, attachments = [], contentRef) {
+        const request = {
+            type,
+            title,
+            description,
+            attachments,
+            contentRef,
+            deviceContext: this.captureDeviceContext(),
+            appId: this.config.appId,
+        };
+        return this.http.post(this.baseUrl, request);
+    }
+    /**
+     * Crea un nuevo feedback (versión async/await).
+     */
+    async createAsync(type, title, description, attachments = [], contentRef) {
+        return firstValueFrom(this.create(type, title, description, attachments, contentRef));
+    }
+    /**
+     * Obtiene un feedback por ID (solo el propietario).
+     *
+     * @param feedbackId - ID del feedback
+     * @returns Observable con la respuesta
+     */
+    getById(feedbackId) {
+        return this.http.get(`${this.baseUrl}/${feedbackId}`);
+    }
+    /**
+     * Obtiene un feedback por ID (versión async/await).
+     */
+    async getByIdAsync(feedbackId) {
+        return firstValueFrom(this.getById(feedbackId));
+    }
+    /**
+     * Valida si un archivo cumple con las restricciones.
+     */
+    validateFile(file) {
+        // Verificar tamaño
+        if (file.size > this.config.maxFileSize) {
+            const maxSizeMB = Math.round(this.config.maxFileSize / (1024 * 1024));
+            return {
+                valid: false,
+                error: `El archivo excede el tamaño máximo de ${maxSizeMB}MB`,
+            };
+        }
+        // Verificar tipo
+        const allowedTypes = this.config.allowedFileTypes || [];
+        const isAllowed = allowedTypes.some((pattern) => {
+            if (pattern.endsWith('/*')) {
+                const baseType = pattern.replace('/*', '');
+                return file.type.startsWith(baseType);
+            }
+            return file.type === pattern;
+        });
+        if (!isAllowed) {
+            return {
+                valid: false,
+                error: 'Tipo de archivo no permitido',
+            };
+        }
+        return { valid: true };
+    }
+    /**
+     * Obtiene la configuración actual del servicio.
+     */
+    getConfig() {
+        return this.config;
+    }
+    // =========================================================================
+    // Reaction Methods (Content feedback with emojis)
+    // =========================================================================
+    /**
+     * Verifica si el usuario ya dio feedback para una entidad específica.
+     *
+     * Primero intenta leer de Firebase (rápido, sin latencia de red al backend).
+     * Si Firebase no está disponible o falla, hace fallback a la API.
+     *
+     * @param entityType - Tipo de entidad (article, docs, feature, etc.)
+     * @param entityId - ID de la entidad
+     * @returns Promise con la respuesta de verificación
+     *
+     * @example
+     * ```typescript
+     * const check = await this.feedbackService.checkFeedback('article', 'art-123');
+     * if (check.hasFeedback) {
+     *   console.log('Ya dio feedback:', check.reactionValue);
+     * }
+     * ```
+     */
+    async checkFeedback(entityType, entityId) {
+        // Si no hay usuario autenticado, no puede haber feedback previo
+        // Retornar inmediatamente sin llamar al API (evita 401 y redirect a login)
+        const userId = this.auth?.user()?.userId;
+        if (!userId) {
+            return { operationId: '', hasFeedback: false };
+        }
+        // 1. Intentar Firebase primero (si está disponible)
+        if (this.firestore) {
+            try {
+                // Path: feedback/{entityType}/{entityId}/{userId}
+                // FirestoreService agrega automáticamente el prefijo apps/{appId}/
+                const collectionPath = `feedback/${entityType}/${entityId}`;
+                const doc = await this.firestore.getDoc(collectionPath, userId);
+                if (doc) {
+                    return {
+                        operationId: '',
+                        hasFeedback: true,
+                        feedbackId: doc.feedbackId,
+                        type: doc.type,
+                        reactionValue: doc.reactionValue,
+                        createdAt: doc.createdAt?.toISOString(),
+                    };
+                }
+                // Doc no existe = no hay feedback
+                return { operationId: '', hasFeedback: false };
+            }
+            catch (error) {
+                console.warn('[FeedbackService] Firebase check failed, falling back to API:', error);
+                // Fallback a API
+            }
+        }
+        // 2. Fallback: llamar API (solo si hay usuario autenticado)
+        const params = new URLSearchParams({
+            appId: this.config.appId,
+            entityType,
+            entityId,
+        });
+        return firstValueFrom(this.http.get(`${this.baseUrl}/check?${params}`));
+    }
+    /**
+     * Crea o actualiza una reacción (feedback con emoji).
+     *
+     * @param entityRef - Referencia a la entidad
+     * @param value - Valor de la reacción (negative, neutral, positive)
+     * @param comment - Comentario opcional (máx 500 caracteres)
+     * @returns Promise con la respuesta
+     *
+     * @example
+     * ```typescript
+     * const response = await this.feedbackService.createReaction(
+     *   { entityType: 'article', entityId: 'art-123' },
+     *   'positive',
+     *   'Muy útil!'
+     * );
+     * ```
+     */
+    async createReaction(entityRef, value, comment) {
+        const request = {
+            type: 'reaction',
+            entityRef,
+            reactionValue: value,
+            description: comment || '',
+            deviceContext: this.captureDeviceContext(),
+            appId: this.config.appId,
+        };
+        return firstValueFrom(this.http.post(this.baseUrl, request));
+    }
+    /**
+     * Crea feedback anónimo (sin autenticación requerida).
+     * Usado para blogs, FAQs y contenido público.
+     *
+     * @param entityRef - Referencia a la entidad
+     * @param value - Valor de la reacción (negative, neutral, positive)
+     * @param comment - Comentario opcional (máx 500 caracteres)
+     * @returns Promise con la respuesta
+     *
+     * @example
+     * ```typescript
+     * // En un blog público
+     * const response = await this.feedbackService.createAnonymousReaction(
+     *   { entityType: 'blog', entityId: 'my-post-slug' },
+     *   'positive'
+     * );
+     * ```
+     */
+    async createAnonymousReaction(entityRef, value, comment) {
+        const request = {
+            type: 'reaction',
+            entityRef,
+            reactionValue: value,
+            description: comment || '',
+            deviceContext: this.captureDeviceContext(),
+            appId: this.config.appId,
+        };
+        return firstValueFrom(this.http.post(`${this.baseUrl}/anonymous`, request));
+    }
+    // =========================================================================
+    // Helpers privados para detección de browser/OS
+    // =========================================================================
+    detectBrowser(ua) {
+        if (ua.includes('Edg/'))
+            return 'Edge';
+        if (ua.includes('Chrome/'))
+            return 'Chrome';
+        if (ua.includes('Firefox/'))
+            return 'Firefox';
+        if (ua.includes('Safari/') && !ua.includes('Chrome'))
+            return 'Safari';
+        if (ua.includes('Opera') || ua.includes('OPR/'))
+            return 'Opera';
+        return 'Unknown';
+    }
+    detectOS(ua) {
+        if (ua.includes('Windows NT 10'))
+            return 'Windows 10';
+        if (ua.includes('Windows NT 11'))
+            return 'Windows 11';
+        if (ua.includes('Windows'))
+            return 'Windows';
+        if (ua.includes('Mac OS X')) {
+            const match = ua.match(/Mac OS X (\d+[._]\d+)/);
+            if (match) {
+                return `macOS ${match[1].replace('_', '.')}`;
+            }
+            return 'macOS';
+        }
+        if (ua.includes('Android'))
+            return 'Android';
+        if (ua.includes('iPhone') || ua.includes('iPad'))
+            return 'iOS';
+        if (ua.includes('Linux'))
+            return 'Linux';
+        return 'Unknown';
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: FeedbackService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: FeedbackService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: FeedbackService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"feedback.service.js","sourceRoot":"","sources":["../../../../../../src/lib/services/feedback/feedback.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, inject } from '@angular/core';\nimport { HttpClient } from '@angular/common/http';\nimport { Observable, firstValueFrom } from 'rxjs';\nimport { VALTECH_FEEDBACK_CONFIG } from './config';\nimport {\n  CreateFeedbackRequest,\n  CreateFeedbackResponse,\n  GetFeedbackResponse,\n  CheckFeedbackResponse,\n  DeviceContext,\n  FeedbackType,\n  ContentRef,\n  EntityRef,\n  ReactionValue,\n  FeedbackFirestoreDoc,\n} from './types';\nimport { FirestoreService } from '../firebase/firestore.service';\nimport { AuthService } from '../auth/auth.service';\n\n/**\n * Servicio para gestionar feedback de usuarios.\n *\n * @example\n * ```typescript\n * @Component({...})\n * export class MyComponent {\n *   private feedbackService = inject(FeedbackService);\n *\n *   async submitFeedback() {\n *     const response = await this.feedbackService.createAsync(\n *       'feedback',\n *       'Mi comentario',\n *       'Descripción detallada...'\n *     );\n *     console.log('Feedback enviado:', response.feedbackId);\n *   }\n * }\n * ```\n */\n@Injectable({ providedIn: 'root' })\nexport class FeedbackService {\n  private config = inject(VALTECH_FEEDBACK_CONFIG);\n  private http = inject(HttpClient);\n  private firestore = inject(FirestoreService, { optional: true });\n  private auth = inject(AuthService, { optional: true });\n\n  /**\n   * URL base para endpoints de feedback.\n   */\n  private get baseUrl(): string {\n    return `${this.config.apiUrl}${this.config.feedbackPrefix}`;\n  }\n\n  /**\n   * Captura el contexto del dispositivo automáticamente.\n   */\n  captureDeviceContext(): DeviceContext {\n    const ua = navigator.userAgent;\n    return {\n      browser: this.detectBrowser(ua),\n      os: this.detectOS(ua),\n      viewport: `${window.innerWidth}x${window.innerHeight}`,\n      language: navigator.language,\n      userAgent: ua,\n      pageUrl: window.location.href,\n    };\n  }\n\n  /**\n   * Crea un nuevo feedback.\n   *\n   * @param type - Tipo de feedback\n   * @param title - Título del feedback\n   * @param description - Descripción detallada\n   * @param attachments - URLs de archivos adjuntos (opcional)\n   * @param contentRef - Referencia a contenido específico (opcional)\n   * @returns Observable con la respuesta\n   */\n  create(\n    type: FeedbackType,\n    title: string,\n    description: string,\n    attachments: string[] = [],\n    contentRef?: ContentRef\n  ): Observable<CreateFeedbackResponse> {\n    const request: CreateFeedbackRequest = {\n      type,\n      title,\n      description,\n      attachments,\n      contentRef,\n      deviceContext: this.captureDeviceContext(),\n      appId: this.config.appId,\n    };\n\n    return this.http.post<CreateFeedbackResponse>(this.baseUrl, request);\n  }\n\n  /**\n   * Crea un nuevo feedback (versión async/await).\n   */\n  async createAsync(\n    type: FeedbackType,\n    title: string,\n    description: string,\n    attachments: string[] = [],\n    contentRef?: ContentRef\n  ): Promise<CreateFeedbackResponse> {\n    return firstValueFrom(\n      this.create(type, title, description, attachments, contentRef)\n    );\n  }\n\n  /**\n   * Obtiene un feedback por ID (solo el propietario).\n   *\n   * @param feedbackId - ID del feedback\n   * @returns Observable con la respuesta\n   */\n  getById(feedbackId: string): Observable<GetFeedbackResponse> {\n    return this.http.get<GetFeedbackResponse>(`${this.baseUrl}/${feedbackId}`);\n  }\n\n  /**\n   * Obtiene un feedback por ID (versión async/await).\n   */\n  async getByIdAsync(feedbackId: string): Promise<GetFeedbackResponse> {\n    return firstValueFrom(this.getById(feedbackId));\n  }\n\n  /**\n   * Valida si un archivo cumple con las restricciones.\n   */\n  validateFile(file: File): { valid: boolean; error?: string } {\n    // Verificar tamaño\n    if (file.size > this.config.maxFileSize!) {\n      const maxSizeMB = Math.round(this.config.maxFileSize! / (1024 * 1024));\n      return {\n        valid: false,\n        error: `El archivo excede el tamaño máximo de ${maxSizeMB}MB`,\n      };\n    }\n\n    // Verificar tipo\n    const allowedTypes = this.config.allowedFileTypes || [];\n    const isAllowed = allowedTypes.some((pattern) => {\n      if (pattern.endsWith('/*')) {\n        const baseType = pattern.replace('/*', '');\n        return file.type.startsWith(baseType);\n      }\n      return file.type === pattern;\n    });\n\n    if (!isAllowed) {\n      return {\n        valid: false,\n        error: 'Tipo de archivo no permitido',\n      };\n    }\n\n    return { valid: true };\n  }\n\n  /**\n   * Obtiene la configuración actual del servicio.\n   */\n  getConfig(): Readonly<typeof this.config> {\n    return this.config;\n  }\n\n  // =========================================================================\n  // Reaction Methods (Content feedback with emojis)\n  // =========================================================================\n\n  /**\n   * Verifica si el usuario ya dio feedback para una entidad específica.\n   *\n   * Primero intenta leer de Firebase (rápido, sin latencia de red al backend).\n   * Si Firebase no está disponible o falla, hace fallback a la API.\n   *\n   * @param entityType - Tipo de entidad (article, docs, feature, etc.)\n   * @param entityId - ID de la entidad\n   * @returns Promise con la respuesta de verificación\n   *\n   * @example\n   * ```typescript\n   * const check = await this.feedbackService.checkFeedback('article', 'art-123');\n   * if (check.hasFeedback) {\n   *   console.log('Ya dio feedback:', check.reactionValue);\n   * }\n   * ```\n   */\n  async checkFeedback(\n    entityType: string,\n    entityId: string\n  ): Promise<CheckFeedbackResponse> {\n    // Si no hay usuario autenticado, no puede haber feedback previo\n    // Retornar inmediatamente sin llamar al API (evita 401 y redirect a login)\n    const userId = this.auth?.user()?.userId;\n    if (!userId) {\n      return { operationId: '', hasFeedback: false };\n    }\n\n    // 1. Intentar Firebase primero (si está disponible)\n    if (this.firestore) {\n      try {\n        // Path: feedback/{entityType}/{entityId}/{userId}\n        // FirestoreService agrega automáticamente el prefijo apps/{appId}/\n        const collectionPath = `feedback/${entityType}/${entityId}`;\n        const doc = await this.firestore.getDoc<FeedbackFirestoreDoc>(\n          collectionPath,\n          userId\n        );\n\n        if (doc) {\n          return {\n            operationId: '',\n            hasFeedback: true,\n            feedbackId: doc.feedbackId,\n            type: doc.type as FeedbackType,\n            reactionValue: doc.reactionValue as ReactionValue,\n            createdAt: doc.createdAt?.toISOString(),\n          };\n        }\n\n        // Doc no existe = no hay feedback\n        return { operationId: '', hasFeedback: false };\n      } catch (error) {\n        console.warn('[FeedbackService] Firebase check failed, falling back to API:', error);\n        // Fallback a API\n      }\n    }\n\n    // 2. Fallback: llamar API (solo si hay usuario autenticado)\n    const params = new URLSearchParams({\n      appId: this.config.appId,\n      entityType,\n      entityId,\n    });\n\n    return firstValueFrom(\n      this.http.get<CheckFeedbackResponse>(`${this.baseUrl}/check?${params}`)\n    );\n  }\n\n  /**\n   * Crea o actualiza una reacción (feedback con emoji).\n   *\n   * @param entityRef - Referencia a la entidad\n   * @param value - Valor de la reacción (negative, neutral, positive)\n   * @param comment - Comentario opcional (máx 500 caracteres)\n   * @returns Promise con la respuesta\n   *\n   * @example\n   * ```typescript\n   * const response = await this.feedbackService.createReaction(\n   *   { entityType: 'article', entityId: 'art-123' },\n   *   'positive',\n   *   'Muy útil!'\n   * );\n   * ```\n   */\n  async createReaction(\n    entityRef: EntityRef,\n    value: ReactionValue,\n    comment?: string\n  ): Promise<CreateFeedbackResponse> {\n    const request: CreateFeedbackRequest = {\n      type: 'reaction',\n      entityRef,\n      reactionValue: value,\n      description: comment || '',\n      deviceContext: this.captureDeviceContext(),\n      appId: this.config.appId,\n    };\n\n    return firstValueFrom(\n      this.http.post<CreateFeedbackResponse>(this.baseUrl, request)\n    );\n  }\n\n  /**\n   * Crea feedback anónimo (sin autenticación requerida).\n   * Usado para blogs, FAQs y contenido público.\n   *\n   * @param entityRef - Referencia a la entidad\n   * @param value - Valor de la reacción (negative, neutral, positive)\n   * @param comment - Comentario opcional (máx 500 caracteres)\n   * @returns Promise con la respuesta\n   *\n   * @example\n   * ```typescript\n   * // En un blog público\n   * const response = await this.feedbackService.createAnonymousReaction(\n   *   { entityType: 'blog', entityId: 'my-post-slug' },\n   *   'positive'\n   * );\n   * ```\n   */\n  async createAnonymousReaction(\n    entityRef: EntityRef,\n    value: ReactionValue,\n    comment?: string\n  ): Promise<CreateFeedbackResponse> {\n    const request = {\n      type: 'reaction' as const,\n      entityRef,\n      reactionValue: value,\n      description: comment || '',\n      deviceContext: this.captureDeviceContext(),\n      appId: this.config.appId,\n    };\n\n    return firstValueFrom(\n      this.http.post<CreateFeedbackResponse>(`${this.baseUrl}/anonymous`, request)\n    );\n  }\n\n  // =========================================================================\n  // Helpers privados para detección de browser/OS\n  // =========================================================================\n\n  private detectBrowser(ua: string): string {\n    if (ua.includes('Edg/')) return 'Edge';\n    if (ua.includes('Chrome/')) return 'Chrome';\n    if (ua.includes('Firefox/')) return 'Firefox';\n    if (ua.includes('Safari/') && !ua.includes('Chrome')) return 'Safari';\n    if (ua.includes('Opera') || ua.includes('OPR/')) return 'Opera';\n    return 'Unknown';\n  }\n\n  private detectOS(ua: string): string {\n    if (ua.includes('Windows NT 10')) return 'Windows 10';\n    if (ua.includes('Windows NT 11')) return 'Windows 11';\n    if (ua.includes('Windows')) return 'Windows';\n    if (ua.includes('Mac OS X')) {\n      const match = ua.match(/Mac OS X (\\d+[._]\\d+)/);\n      if (match) {\n        return `macOS ${match[1].replace('_', '.')}`;\n      }\n      return 'macOS';\n    }\n    if (ua.includes('Android')) return 'Android';\n    if (ua.includes('iPhone') || ua.includes('iPad')) return 'iOS';\n    if (ua.includes('Linux')) return 'Linux';\n    return 'Unknown';\n  }\n}\n"]}