@acontplus/ng-common 1.0.4 → 1.0.6

package/fesm2022/acontplus-ng-common.mjs

@@ -1,7 +1,7 @@
 import * as i0 from '@angular/core';
 import { InjectionToken, inject, Injectable, signal, Input, Component } from '@angular/core';
+import { tap, Observable } from 'rxjs';
 import { HttpClient } from '@angular/common/http';
-import { Observable, throwError } from 'rxjs';
 import * as i1 from '@angular/forms';
 import { FormBuilder, Validators, ReactiveFormsModule } from '@angular/forms';
 import { CommonModule } from '@angular/common';
@@ -184,40 +184,307 @@ const WHATSAPP_MESSAGING_PORT = new InjectionToken('WHATSAPP_MESSAGING_PORT');
 
 const PRINTER_PORT = new InjectionToken('PRINTER_PORT');
 
+/**
+ * Utilidades para manejo de archivos y respuestas HTTP
+ */
+class FileMapperUtil {
+    /**
+     * Extrae el nombre de archivo desde el header Content-Disposition
+     */
+    static extractFileName(response) {
+        const contentDisposition = response.headers?.get('content-disposition');
+        if (!contentDisposition) {
+            return this.generateDefaultFileName();
+        }
+        // Método más robusto para extraer filename
+        const matches = /filename[^;=\n]*=((['"]).*?\2|[^;\n]*)/.exec(contentDisposition);
+        if (matches && matches[1]) {
+            let fileName = matches[1].replace(/['"]/g, '');
+            // Limpiar caracteres especiales
+            fileName = fileName.replaceAll('+', ' ').trim();
+            return fileName || this.generateDefaultFileName();
+        }
+        // Fallback: método simple
+        const simpleParse = contentDisposition.split('filename=')[1];
+        if (simpleParse) {
+            return simpleParse.replace(/['"]/g, '').trim() || this.generateDefaultFileName();
+        }
+        return this.generateDefaultFileName();
+    }
+    /**
+     * Crea un objeto File desde una respuesta HTTP
+     */
+    static fromResponse(response) {
+        const fileName = this.extractFileName(response);
+        const contentType = response.headers?.get('content-type') || 'application/octet-stream';
+        return new File([response.body], fileName, { type: contentType });
+    }
+    /**
+     * Descarga un archivo usando la API nativa del navegador
+     */
+    static downloadFile(blob, fileName) {
+        const url = URL.createObjectURL(blob);
+        const link = document.createElement('a');
+        link.href = url;
+        link.download = fileName;
+        link.style.display = 'none';
+        document.body.appendChild(link);
+        link.click();
+        document.body.removeChild(link);
+        // Limpiar el objeto URL
+        URL.revokeObjectURL(url);
+    }
+    /**
+     * Abre un archivo en una nueva ventana (para PDFs)
+     */
+    static openFile(blob, fileName) {
+        const fileURL = URL.createObjectURL(blob);
+        window.open(fileURL, fileName);
+        // Limpiar URL después de un tiempo
+        setTimeout(() => URL.revokeObjectURL(fileURL), 1000);
+    }
+    /**
+     * Detecta si es un navegador legacy que requiere descarga forzada
+     */
+    static isLegacyBrowser() {
+        const userAgent = navigator.userAgent;
+        return !!(userAgent.match(/Edge/g) || userAgent.match(/.NET/g) || userAgent.match(/MSIE/g));
+    }
+    static generateDefaultFileName() {
+        const timestamp = Date.now();
+        return `document_${timestamp}.pdf`;
+    }
+}
+
+/**
+ * Facade para generación de reportes
+ *
+ * Proporciona una API de alto nivel para generar reportes con manejo automático de archivos.
+ * Todos los métodos devuelven Observables - el consumidor debe hacer subscribe().
+ *
+ * @example
+ * ```typescript
+ * // Control total del blob
+ * this.reportFacade.generate(options).subscribe(response => {
+ *   const blob = response.body;
+ *   // Procesar blob manualmente
+ * });
+ *
+ * // Descarga automática
+ * this.reportFacade.download(options).subscribe();
+ *
+ * // Abrir PDF automáticamente
+ * this.reportFacade.open(options).subscribe();
+ * ```
+ */
 class ReportFacade {
     reportPort = inject(REPORT_PORT);
-    // Método principal unificado
+    /**
+     * Genera un reporte y devuelve el Observable con el blob
+     *
+     * Este método proporciona control total sobre el blob generado.
+     * No realiza ninguna acción automática (descarga/apertura).
+     * Útil cuando necesitas procesar el blob manualmente (enviar por WhatsApp, guardar en servidor, etc.)
+     *
+     * @template T - Tipo de datos del reporte
+     * @param options - Opciones de generación del reporte
+     * @param options.data - Datos del reporte (usar ReportParamsBuilder.build())
+     * @param options.format - Formato del reporte: 'pdf' | 'excel' | 'word'
+     * @param options.useV1Api - Si debe usar la API v1 (por defecto false)
+     * @returns Observable con la respuesta HTTP que contiene el blob
+     *
+     * @example
+     * ```typescript
+     * const options = ReportParamsBuilder.build(
+     *   { codDoc: ELECTRONIC_DOCUMENT_CODE.FV, id: 123 },
+     *   'pdf'
+     * );
+     *
+     * this.reportFacade.generate(options).subscribe({
+     *   next: (response) => {
+     *     const blob = response.body;
+     *     const fileName = FileMapperUtil.extractFileName(response);
+     *     // Procesar blob según necesidad
+     *   },
+     *   error: (err) => console.error('Error:', err)
+     * });
+     * ```
+     */
     generate(options) {
         return this.reportPort.generate(options);
     }
-    // Métodos de conveniencia para casos comunes
-    generatePDF(data, forceDownload = false) {
-        this.reportPort.generate({
+    /**
+     * Genera un reporte y lo descarga automáticamente
+     *
+     * Extrae el nombre del archivo desde los headers HTTP y descarga el archivo automáticamente.
+     * Funciona para cualquier formato (PDF, Excel, Word).
+     * El Observable se completa después de iniciar la descarga.
+     *
+     * @template T - Tipo de datos del reporte
+     * @param options - Opciones de generación del reporte
+     * @returns Observable que se completa después de iniciar la descarga
+     *
+     * @example
+     * ```typescript
+     * // Con formato dinámico
+     * const options = ReportParamsBuilder.build(
+     *   { codDoc: SALE_CODE_REPORT.FG },
+     *   this.selectedFormat // 'pdf' | 'excel' | 'word'
+     * );
+     * this.reportFacade.download(options).subscribe();
+     *
+     * // Con formato fijo
+     * const options = ReportParamsBuilder.build(
+     *   { codDoc: INVENTORY_CODE_REPORT.RCD },
+     *   'excel'
+     * );
+     * this.reportFacade.download(options).subscribe();
+     * ```
+     */
+    download(options) {
+        return this.reportPort.generate(options).pipe(tap((response) => {
+            const fileName = FileMapperUtil.extractFileName(response);
+            if (response.body) {
+                FileMapperUtil.downloadFile(response.body, fileName);
+            }
+        }));
+    }
+    /**
+     * Genera un reporte y lo abre en nueva ventana (o descarga en navegadores legacy)
+     *
+     * Comportamiento inteligente según el navegador:
+     * - Navegadores modernos: Abre el archivo en nueva ventana/pestaña
+     * - Navegadores legacy (IE, Edge antiguo): Descarga el archivo
+     *
+     * Ideal para PDFs que el usuario quiere visualizar inmediatamente.
+     * También funciona con Excel/Word pero la experiencia puede variar según el navegador.
+     *
+     * @template T - Tipo de datos del reporte
+     * @param options - Opciones de generación del reporte
+     * @returns Observable que se completa después de abrir/descargar el archivo
+     *
+     * @example
+     * ```typescript
+     * // Abrir PDF
+     * const options = ReportParamsBuilder.build(
+     *   { codDoc: ELECTRONIC_DOCUMENT_CODE.FV, id: 123 },
+     *   'pdf'
+     * );
+     * this.reportFacade.open(options).subscribe();
+     *
+     * // Con formato dinámico
+     * const format = this.isPDF ? 'pdf' : 'excel';
+     * const options = ReportParamsBuilder.build({ codDoc: code }, format);
+     * this.reportFacade.open(options).subscribe();
+     * ```
+     */
+    open(options) {
+        return this.reportPort.generate(options).pipe(tap((response) => {
+            const fileName = FileMapperUtil.extractFileName(response);
+            if (response.body) {
+                if (FileMapperUtil.isLegacyBrowser()) {
+                    FileMapperUtil.downloadFile(response.body, fileName);
+                }
+                else {
+                    FileMapperUtil.openFile(response.body, fileName);
+                }
+            }
+        }));
+    }
+    /**
+     * Genera un PDF y lo abre automáticamente (shortcut)
+     *
+     * Método de conveniencia para el caso común de generar y abrir PDFs.
+     * Equivalente a llamar open() con format: 'pdf'.
+     *
+     * @template T - Tipo de datos del reporte
+     * @param data - Datos del reporte (resultado de ReportParamsBuilder.build().data)
+     * @param useV1Api - Si debe usar la API v1 (por defecto false)
+     * @returns Observable que se completa después de abrir el PDF
+     *
+     * @example
+     * ```typescript
+     * const reportOptions = ReportParamsBuilder.build(
+     *   { codDoc: ELECTRONIC_DOCUMENT_CODE.FV, id: 123 },
+     *   'pdf'
+     * );
+     *
+     * // Forma corta
+     * this.reportFacade.openPDF(
+     *   reportOptions.data,
+     *   reportOptions.useV1Api
+     * ).subscribe();
+     * ```
+     */
+    openPDF(data, useV1Api = false) {
+        return this.open({
             data,
             format: 'pdf',
-            forceDownload,
+            useV1Api,
         });
     }
-    generateExcel(data, forceDownload = false) {
-        this.reportPort.generate({
+    /**
+     * Genera un Excel y lo descarga automáticamente (shortcut)
+     *
+     * Método de conveniencia para el caso común de generar y descargar archivos Excel.
+     * Equivalente a llamar download() con format: 'excel'.
+     *
+     * @template T - Tipo de datos del reporte
+     * @param data - Datos del reporte (resultado de ReportParamsBuilder.build().data)
+     * @param useV1Api - Si debe usar la API v1 (por defecto false)
+     * @returns Observable que se completa después de iniciar la descarga
+     *
+     * @example
+     * ```typescript
+     * const reportOptions = ReportParamsBuilder.build(
+     *   { codDoc: SALE_CODE_REPORT.FG, fechaInicio: '2024-01-01' },
+     *   'excel'
+     * );
+     *
+     * // Forma corta
+     * this.reportFacade.downloadExcel(
+     *   reportOptions.data,
+     *   reportOptions.useV1Api
+     * ).subscribe();
+     * ```
+     */
+    downloadExcel(data, useV1Api = false) {
+        return this.download({
             data,
             format: 'excel',
-            forceDownload,
+            useV1Api,
         });
     }
-    generateWord(data, forceDownload = false) {
-        this.reportPort.generate({
+    /**
+     * Genera un Word y lo descarga automáticamente (shortcut)
+     *
+     * Método de conveniencia para el caso común de generar y descargar archivos Word.
+     * Equivalente a llamar download() con format: 'word'.
+     *
+     * @template T - Tipo de datos del reporte
+     * @param data - Datos del reporte (resultado de ReportParamsBuilder.build().data)
+     * @param useV1Api - Si debe usar la API v1 (por defecto false)
+     * @returns Observable que se completa después de iniciar la descarga
+     *
+     * @example
+     * ```typescript
+     * const reportOptions = ReportParamsBuilder.build(
+     *   { codDoc: CUSTOMER_CODE_REPORT.RCL },
+     *   'word'
+     * );
+     *
+     * // Forma corta
+     * this.reportFacade.downloadWord(
+     *   reportOptions.data,
+     *   reportOptions.useV1Api
+     * ).subscribe();
+     * ```
+     */
+    downloadWord(data, useV1Api = false) {
+        return this.download({
             data,
             format: 'word',
-            forceDownload,
-        });
-    }
-    // Método para generar y retornar blob
-    generateBlob(data, format = 'pdf') {
-        return this.reportPort.generate({
-            data,
-            format,
-            returnBlob: true,
+            useV1Api,
         });
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: ReportFacade, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
@@ -615,113 +882,19 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.6", ngImpor
         }] });
 
 /**
- * Utilidades para manejo de archivos y respuestas HTTP
+ * Adapter para generación de reportes
+ * Siempre devuelve Observable - el consumidor decide qué hacer con el blob
  */
-class FileMapperUtil {
-    /**
-     * Extrae el nombre de archivo desde el header Content-Disposition
-     */
-    static extractFileName(response) {
-        const contentDisposition = response.headers?.get('content-disposition');
-        if (!contentDisposition) {
-            return this.generateDefaultFileName();
-        }
-        // Método más robusto para extraer filename
-        const matches = /filename[^;=\n]*=((['"]).*?\2|[^;\n]*)/.exec(contentDisposition);
-        if (matches && matches[1]) {
-            let fileName = matches[1].replace(/['"]/g, '');
-            // Limpiar caracteres especiales
-            fileName = fileName.replaceAll('+', ' ').trim();
-            return fileName || this.generateDefaultFileName();
-        }
-        // Fallback: método simple
-        const simpleParse = contentDisposition.split('filename=')[1];
-        if (simpleParse) {
-            return simpleParse.replace(/['"]/g, '').trim() || this.generateDefaultFileName();
-        }
-        return this.generateDefaultFileName();
-    }
-    /**
-     * Crea un objeto File desde una respuesta HTTP
-     */
-    static fromResponse(response) {
-        const fileName = this.extractFileName(response);
-        const contentType = response.headers?.get('content-type') || 'application/octet-stream';
-        return new File([response.body], fileName, { type: contentType });
-    }
-    /**
-     * Descarga un archivo usando la API nativa del navegador
-     */
-    static downloadFile(blob, fileName) {
-        const url = URL.createObjectURL(blob);
-        const link = document.createElement('a');
-        link.href = url;
-        link.download = fileName;
-        link.style.display = 'none';
-        document.body.appendChild(link);
-        link.click();
-        document.body.removeChild(link);
-        // Limpiar el objeto URL
-        URL.revokeObjectURL(url);
-    }
-    /**
-     * Abre un archivo en una nueva ventana (para PDFs)
-     */
-    static openFile(blob, fileName) {
-        const fileURL = URL.createObjectURL(blob);
-        window.open(fileURL, fileName);
-        // Limpiar URL después de un tiempo
-        setTimeout(() => URL.revokeObjectURL(fileURL), 1000);
-    }
-    /**
-     * Detecta si es un navegador legacy que requiere descarga forzada
-     */
-    static isLegacyBrowser() {
-        const userAgent = navigator.userAgent;
-        return !!(userAgent.match(/Edge/g) || userAgent.match(/.NET/g) || userAgent.match(/MSIE/g));
-    }
-    static generateDefaultFileName() {
-        const timestamp = Date.now();
-        return `document_${timestamp}.pdf`;
-    }
-}
-
 class ReportAdapter {
     http = inject(HttpClient);
     generate(options) {
-        const { data, format = 'pdf', useV1Api = false, forceDownload = false, returnBlob = false, } = options;
-        const reportVersionPath = useV1Api ? '/v1/' : '/v2/';
-        const fullPath = `${API_PATHS.REPORTS}${reportVersionPath}download`;
-        const requestOptions = {
+        const { data, useV1Api = false } = options;
+        const reportVersionPath = useV1Api ? '/reporte/download' : '/v2/reporte/download';
+        const fullPath = `${API_PATHS.REPORTS}${reportVersionPath}`;
+        return this.http.post(fullPath, data, {
             observe: 'response',
             responseType: 'blob',
-        };
-        if (returnBlob) {
-            return this.http.post(fullPath, data, requestOptions);
-        }
-        this.http.post(fullPath, data, requestOptions).subscribe({
-            next: (response) => this.saveFile(response, format, forceDownload),
-            error: (err) => {
-                console.error('Error al descargar el reporte:', err);
-            },
         });
-        return;
-    }
-    getFileName(response) {
-        return FileMapperUtil.extractFileName(response);
-    }
-    saveFile(response, format, forceDownload = false) {
-        const fileName = this.getFileName(response);
-        if (!response.body)
-            return;
-        if (format === 'pdf' && !forceDownload && !FileMapperUtil.isLegacyBrowser()) {
-            // Abrir PDF en nueva ventana para navegadores modernos
-            FileMapperUtil.openFile(response.body, fileName);
-        }
-        else {
-            // Descargar archivo (Excel, Word, o PDF forzado)
-            FileMapperUtil.downloadFile(response.body, fileName);
-        }
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: ReportAdapter, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: ReportAdapter });
@@ -1027,17 +1200,47 @@ class ReportParamsBuilder {
     };
     /**
      * Construye los parámetros de reporte según el tipo de documento
+     *
+     * @param docData - Datos del documento con codDoc y parámetros adicionales
+     * @param format - Formato del reporte: 'pdf' | 'excel' | 'word'
+     * @returns Objeto con hasService, reportParams (string JSON) y dataParams (string JSON)
+     *
+     * @example
+     * ```typescript
+     * const params = ReportParamsBuilder.buildParams(
+     *   { codDoc: ELECTRONIC_DOCUMENT_CODE.FV, id: 123, codEstab: '001' },
+     *   'pdf'
+     * );
+     * // Resultado:
+     * // {
+     * //   hasService: true,
+     * //   reportParams: "{\"codigo\":\"FV\",\"format\":\"pdf\",\"hasParams\":true,...}",
+     * //   dataParams: "{\"id\":123,\"codEstab\":\"001\",\"codigo\":\"FV\"}"
+     * // }
+     * ```
      */
     static buildParams(docData, format = 'pdf') {
         const config = this.getReportConfig(docData.codDoc);
         return {
             hasService: config.hasService,
             reportParams: this.buildReportParams(docData, config, format),
-            dataParams: this.buildDataParams(docData, config, format),
+            dataParams: this.buildDataParams(docData, config),
         };
     }
     /**
      * Determina si debe usar la API v1 según el tipo de documento
+     *
+     * @param codDoc - Código del documento (FV, NE, NC, etc.)
+     * @returns true si debe usar API v1, false para API v2
+     *
+     * @example
+     * ```typescript
+     * const useV1 = ReportParamsBuilder.shouldUseV1Api(ELECTRONIC_DOCUMENT_CODE.FV);
+     * // useV1 = true (documentos electrónicos usan v1)
+     *
+     * const useV1Sales = ReportParamsBuilder.shouldUseV1Api(SALE_CODE_REPORT.FG);
+     * // useV1Sales = false (reportes de ventas usan v2)
+     * ```
      */
     static shouldUseV1Api(codDoc) {
         const config = this.getReportConfig(codDoc);
@@ -1045,6 +1248,11 @@ class ReportParamsBuilder {
     }
     /**
      * Obtiene la configuración para un tipo de documento
+     *
+     * @param codDoc - Código del documento
+     * @returns Configuración del reporte
+     * @throws Error si el tipo de documento no está soportado
+     * @private
      */
     static getReportConfig(codDoc) {
         const config = this.reportConfigs[codDoc];
@@ -1054,7 +1262,20 @@ class ReportParamsBuilder {
         return config;
     }
     /**
-     * Construye los parámetros del reporte
+     * Construye los parámetros del reporte (reportParams)
+     *
+     * Genera un string JSON con la configuración del reporte:
+     * - codigo: Código del reporte
+     * - format: Formato de salida (pdf, excel, word)
+     * - hasParams: Si el reporte acepta parámetros adicionales
+     * - codEstab: Código de establecimiento (si aplica)
+     * - aditionalParams: Array vacío para parámetros adicionales (si aplica)
+     *
+     * @param docData - Datos del documento
+     * @param config - Configuración del tipo de reporte
+     * @param format - Formato de salida
+     * @returns String JSON con los parámetros del reporte
+     * @private
      */
     static buildReportParams(docData, config, format) {
         const params = {
@@ -1076,9 +1297,34 @@ class ReportParamsBuilder {
         return JSON.stringify(params);
     }
     /**
-     * Construye los parámetros de datos
+     * Construye los parámetros de datos (dataParams)
+     *
+     * Genera un string JSON con los datos específicos del reporte.
+     * NO incluye hasParams ni configuración, solo datos puros.
+     *
+     * Incluye automáticamente:
+     * - id: ID del documento (si existe)
+     * - codEstab: Código de establecimiento (según configuración)
+     * - codigo: Código del reporte (según configuración)
+     * - Parámetros extra específicos del tipo (extraDataParams)
+     * - Todos los parámetros adicionales del docData (excepto codDoc, codEstab, id, serie)
+     *
+     * @param docData - Datos del documento con parámetros adicionales
+     * @param config - Configuración del tipo de reporte
+     * @returns String JSON con los datos del reporte (sin hasParams anidado)
+     * @private
+     *
+     * @example
+     * ```typescript
+     * // Input:
+     * docData = { codDoc: 'FG', tipo: 2, codEstab: '001', fechaInicio: '2024-01-01' }
+     * config = { idField: 'id', includeEstabInData: false, ... }
+     *
+     * // Output:
+     * "{\"tipo\":2,\"fechaInicio\":\"2024-01-01\"}"
+     * ```
      */
-    static buildDataParams(docData, config, format) {
+    static buildDataParams(docData, config) {
         const params = {};
         // Agregar ID si existe el campo configurado
         if (config.idField && docData[config.idField]) {
@@ -1091,12 +1337,6 @@ class ReportParamsBuilder {
         if (config.includeCodigoInData) {
             params.codigo = config.codigo;
         }
-        if (config.hasService && config.hasParams) {
-            params.hasParams = true;
-            if (config.includeCodigoInData) {
-                params.format = format;
-            }
-        }
         // Agregar parámetros extra específicos del tipo
         if (config.extraDataParams) {
             Object.assign(params, config.extraDataParams);
@@ -1111,29 +1351,94 @@ class ReportParamsBuilder {
     }
     /**
      * Construye las opciones completas para generar un reporte
+     *
+     * @param docData - Datos del documento con codDoc y parámetros adicionales
+     * @param format - Formato del reporte: 'pdf' | 'excel' | 'word'
+     * @returns Objeto con data (para enviar al backend), format y useV1Api
+     *
+     * @example
+     * ```typescript
+     * const options = ReportParamsBuilder.build(
+     *   { codDoc: ELECTRONIC_DOCUMENT_CODE.FV, id: 123, codEstab: '001' },
+     *   'pdf'
+     * );
+     * // Resultado:
+     * // {
+     * //   data: { hasService: true, reportParams: "{...}", dataParams: "{...}" },
+     * //   format: 'pdf',
+     * //   useV1Api: true
+     * // }
+     *
+     * // Usar con facade
+     * this.reportFacade.generate(options).subscribe();
+     * ```
      */
-    static build(docData, format = 'pdf', returnBlob = false) {
+    static build(docData, format = 'pdf') {
         return {
             data: this.buildParams(docData, format),
             format,
             useV1Api: this.shouldUseV1Api(docData.codDoc),
-            returnBlob,
         };
     }
     /**
      * Obtiene la lista de tipos de documento soportados
+     *
+     * @returns Array con todos los códigos de documento soportados
+     *
+     * @example
+     * ```typescript
+     * const types = ReportParamsBuilder.getSupportedDocumentTypes();
+     * // ['FV', 'NE', 'NC', 'ND', 'GR', 'SRR', 'SRRC', 'FG', ...]
+     * ```
      */
     static getSupportedDocumentTypes() {
         return Object.keys(this.reportConfigs);
     }
     /**
      * Verifica si un tipo de documento está soportado
+     *
+     * @param codDoc - Código del documento a verificar
+     * @returns true si el documento está soportado, false en caso contrario
+     *
+     * @example
+     * ```typescript
+     * if (ReportParamsBuilder.isDocumentTypeSupported('FV')) {
+     *   // Generar reporte
+     * } else {
+     *   console.error('Tipo de documento no soportado');
+     * }
+     * ```
      */
     static isDocumentTypeSupported(codDoc) {
         return codDoc in this.reportConfigs;
     }
     /**
      * Registra un nuevo tipo de reporte dinámicamente
+     *
+     * Permite agregar soporte para nuevos tipos de reportes en runtime
+     * sin modificar el código fuente de la librería.
+     *
+     * @param codDoc - Código único del documento
+     * @param config - Configuración completa del reporte
+     *
+     * @example
+     * ```typescript
+     * // Agregar un nuevo tipo de reporte personalizado
+     * ReportParamsBuilder.registerReportType('CUSTOM_REPORT', {
+     *   codigo: 'CUSTOM_REPORT',
+     *   hasService: true,
+     *   useV1Api: false,
+     *   idField: 'id',
+     *   hasParams: true,
+     *   extraDataParams: { customField: 'value' }
+     * });
+     *
+     * // Ahora se puede usar
+     * const options = ReportParamsBuilder.build(
+     *   { codDoc: 'CUSTOM_REPORT', id: 123 },
+     *   'pdf'
+     * );
+     * ```
      */
     static registerReportType(codDoc, config) {
         this.reportConfigs[codDoc] = config;
@@ -1262,10 +1567,8 @@ class WhatsAppSender {
     generateReport() {
         const docData = this.config.documentData;
         // Construir opciones de reporte
-        const reportOptions = ReportParamsBuilder.build(docData, 'pdf', true);
-        const reportResult = this.reportFacade.generate(reportOptions);
-        // Manejar el caso donde generate puede retornar void
-        return reportResult || throwError(() => new Error('No se pudo generar el reporte'));
+        const reportOptions = ReportParamsBuilder.build(docData, 'pdf');
+        return this.reportFacade.generate(reportOptions);
     }
     processReportFile(response) {
         const file = FileMapperUtil.fromResponse(response);