keevo-components 2.0.107 → 2.0.109

package/esm2022/lib/components/kv-inputs/kv-editor/services/kv-editor-mention.service.mjs

@@ -0,0 +1,135 @@
+import { Injectable, signal } from '@angular/core';
+import Quill from 'quill';
+import * as i0 from "@angular/core";
+export class KvEditorMentionService {
+    constructor() {
+        this.filteredVariables = signal([]);
+        this.mentionStartIndex = null;
+        this.mentionEndIndex = null;
+    }
+    /**
+     * Processa o sistema de menções durante a digitação
+     */
+    handleMention(quill, variaveis) {
+        const range = quill.getSelection();
+        if (!range) {
+            this.closeMention();
+            return { shouldShowPanel: false, filteredVariables: [] };
+        }
+        const text = quill.getText(0, range.index);
+        const lastHashIndex = text.lastIndexOf('#');
+        if (lastHashIndex !== -1 && !/\s/.test(text.substring(lastHashIndex + 1))) {
+            this.mentionStartIndex = lastHashIndex;
+            this.mentionEndIndex = range.index;
+            const searchTerm = text.substring(lastHashIndex + 1).toLowerCase();
+            const filtered = variaveis.filter(v => v.descricao.toLowerCase().includes(searchTerm));
+            this.filteredVariables.set(filtered);
+            if (filtered.length > 0) {
+                const bounds = this.calculateMentionBounds(quill, lastHashIndex);
+                return {
+                    shouldShowPanel: true,
+                    filteredVariables: filtered,
+                    mentionBounds: bounds
+                };
+            }
+        }
+        this.closeMention();
+        return { shouldShowPanel: false, filteredVariables: [] };
+    }
+    /**
+     * Calcula a posição onde o painel de menções deve aparecer
+     */
+    calculateMentionBounds(quill, lastHashIndex) {
+        const editorEl = document.querySelector('#kv-editor');
+        if (!editorEl)
+            return { top: 0, left: 0 };
+        const editorRect = editorEl.getBoundingClientRect();
+        // Verifica se o '#' está no início de uma linha
+        const charBefore = lastHashIndex > 0 ? quill.getText(lastHashIndex - 1, 1) : null;
+        const isAtStartOfLine = (lastHashIndex === 0 || charBefore === '\n');
+        if (isAtStartOfLine) {
+            // Posiciona no canto superior esquerdo do editor
+            return {
+                top: editorRect.top + 5,
+                left: editorRect.left + 5
+            };
+        }
+        else {
+            // Usa getBounds() para posição precisa
+            const cursorBounds = quill.getBounds(lastHashIndex);
+            if (cursorBounds) {
+                return {
+                    top: editorRect.top + cursorBounds.bottom,
+                    left: editorRect.left + cursorBounds.left
+                };
+            }
+            else {
+                return {
+                    top: editorRect.top + 5,
+                    left: editorRect.left + 5
+                };
+            }
+        }
+    }
+    /**
+     * Insere uma variável selecionada no editor
+     */
+    insertVariable(quill, variable) {
+        const startIndex = this.mentionStartIndex;
+        const endIndex = this.mentionEndIndex;
+        if (startIndex === null || endIndex === null)
+            return;
+        const lengthToDelete = endIndex - startIndex;
+        const variableHtml = `<span 
+                       style="background-color: #e6f7ff; color: #0066cc; border-radius: 3px; padding: 2px 4px; font-weight: 500;"
+                       class="variavel-inserida" 
+                       title="${variable.descricao}">${variable.descricao}</span>&nbsp;`;
+        const insertedTextLength = variable.descricao.length + 1;
+        const Delta = Quill.import('delta');
+        const insertionDelta = quill.clipboard.convert({ html: variableHtml });
+        quill.updateContents(new Delta()
+            .retain(startIndex)
+            .delete(lengthToDelete)
+            .concat(insertionDelta), 'user');
+        const newCursorPosition = startIndex + insertedTextLength;
+        setTimeout(() => {
+            quill.setSelection(newCursorPosition, 0, 'user');
+            quill.focus();
+        }, 0);
+        this.closeMention();
+    }
+    /**
+     * Fecha o sistema de menções
+     */
+    closeMention() {
+        this.mentionStartIndex = null;
+        this.mentionEndIndex = null;
+        this.filteredVariables.set([]);
+    }
+    /**
+     * Obtém as variáveis filtradas
+     */
+    getFilteredVariables() {
+        return this.filteredVariables();
+    }
+    /**
+     * Cria uma regex especial para busca em texto com HTML
+     */
+    createInterleavedRegex(text) {
+        const specialChars = /[-\/\\^$*+?.()|[\]{}]/g;
+        const pattern = text
+            .split('')
+            .map(char => char.replace(specialChars, '\\$&'))
+            .join('(<[^>]*>)*');
+        return new RegExp(pattern, 'gi');
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: KvEditorMentionService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: KvEditorMentionService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: KvEditorMentionService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"kv-editor-mention.service.js","sourceRoot":"","sources":["../../../../../../../../projects/keevo-components/src/lib/components/kv-inputs/kv-editor/services/kv-editor-mention.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAc,MAAM,EAAE,MAAM,eAAe,CAAC;AAC/D,OAAO,KAAK,MAAM,OAAO,CAAC;;AAM1B,MAAM,OAAO,sBAAsB;IAHnC;QAKU,sBAAiB,GAAG,MAAM,CAAqB,EAAE,CAAC,CAAC;QACnD,sBAAiB,GAAkB,IAAI,CAAC;QACxC,oBAAe,GAAkB,IAAI,CAAC;KAgJ/C;IA9IC;;OAEG;IACH,aAAa,CAAC,KAAY,EAAE,SAA6B;QAKvD,MAAM,KAAK,GAAG,KAAK,CAAC,YAAY,EAAE,CAAC;QACnC,IAAI,CAAC,KAAK,EAAE,CAAC;YACX,IAAI,CAAC,YAAY,EAAE,CAAC;YACpB,OAAO,EAAE,eAAe,EAAE,KAAK,EAAE,iBAAiB,EAAE,EAAE,EAAE,CAAC;QAC3D,CAAC;QAED,MAAM,IAAI,GAAG,KAAK,CAAC,OAAO,CAAC,CAAC,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC;QAC3C,MAAM,aAAa,GAAG,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC;QAE5C,IAAI,aAAa,KAAK,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,aAAa,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC;YAC1E,IAAI,CAAC,iBAAiB,GAAG,aAAa,CAAC;YACvC,IAAI,CAAC,eAAe,GAAG,KAAK,CAAC,KAAK,CAAC;YAEnC,MAAM,UAAU,GAAG,IAAI,CAAC,SAAS,CAAC,aAAa,GAAG,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC;YACnE,MAAM,QAAQ,GAAG,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CACpC,CAAC,CAAC,SAAS,CAAC,WAAW,EAAE,CAAC,QAAQ,CAAC,UAAU,CAAC,CAC/C,CAAC;YAEF,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;YAErC,IAAI,QAAQ,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBACxB,MAAM,MAAM,GAAG,IAAI,CAAC,sBAAsB,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC;gBACjE,OAAO;oBACL,eAAe,EAAE,IAAI;oBACrB,iBAAiB,EAAE,QAAQ;oBAC3B,aAAa,EAAE,MAAM;iBACtB,CAAC;YACJ,CAAC;QACH,CAAC;QAED,IAAI,CAAC,YAAY,EAAE,CAAC;QACpB,OAAO,EAAE,eAAe,EAAE,KAAK,EAAE,iBAAiB,EAAE,EAAE,EAAE,CAAC;IAC3D,CAAC;IAED;;OAEG;IACK,sBAAsB,CAAC,KAAY,EAAE,aAAqB;QAChE,MAAM,QAAQ,GAAG,QAAQ,CAAC,aAAa,CAAC,YAAY,CAAC,CAAC;QACtD,IAAI,CAAC,QAAQ;YAAE,OAAO,EAAE,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,CAAC;QAE1C,MAAM,UAAU,GAAG,QAAQ,CAAC,qBAAqB,EAAE,CAAC;QAEpD,gDAAgD;QAChD,MAAM,UAAU,GAAG,aAAa,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,aAAa,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;QAClF,MAAM,eAAe,GAAG,CAAC,aAAa,KAAK,CAAC,IAAI,UAAU,KAAK,IAAI,CAAC,CAAC;QAErE,IAAI,eAAe,EAAE,CAAC;YACpB,iDAAiD;YACjD,OAAO;gBACL,GAAG,EAAE,UAAU,CAAC,GAAG,GAAG,CAAC;gBACvB,IAAI,EAAE,UAAU,CAAC,IAAI,GAAG,CAAC;aAC1B,CAAC;QACJ,CAAC;aAAM,CAAC;YACN,uCAAuC;YACvC,MAAM,YAAY,GAAG,KAAK,CAAC,SAAS,CAAC,aAAa,CAAC,CAAC;YACpD,IAAI,YAAY,EAAE,CAAC;gBACjB,OAAO;oBACL,GAAG,EAAE,UAAU,CAAC,GAAG,GAAG,YAAY,CAAC,MAAM;oBACzC,IAAI,EAAE,UAAU,CAAC,IAAI,GAAG,YAAY,CAAC,IAAI;iBAC1C,CAAC;YACJ,CAAC;iBAAM,CAAC;gBACN,OAAO;oBACL,GAAG,EAAE,UAAU,CAAC,GAAG,GAAG,CAAC;oBACvB,IAAI,EAAE,UAAU,CAAC,IAAI,GAAG,CAAC;iBAC1B,CAAC;YACJ,CAAC;QACH,CAAC;IACH,CAAC;IAED;;OAEG;IACH,cAAc,CAAC,KAAY,EAAE,QAA0B;QACrD,MAAM,UAAU,GAAG,IAAI,CAAC,iBAAiB,CAAC;QAC1C,MAAM,QAAQ,GAAG,IAAI,CAAC,eAAe,CAAC;QAEtC,IAAI,UAAU,KAAK,IAAI,IAAI,QAAQ,KAAK,IAAI;YAAE,OAAO;QAErD,MAAM,cAAc,GAAG,QAAQ,GAAG,UAAU,CAAC;QAC7C,MAAM,YAAY,GAAG;;;gCAGO,QAAQ,CAAC,SAAS,KAAK,QAAQ,CAAC,SAAS,eAAe,CAAC;QAErF,MAAM,kBAAkB,GAAG,QAAQ,CAAC,SAAS,CAAC,MAAM,GAAG,CAAC,CAAC;QACzD,MAAM,KAAK,GAAG,KAAK,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;QACpC,MAAM,cAAc,GAAG,KAAK,CAAC,SAAS,CAAC,OAAO,CAAC,EAAE,IAAI,EAAE,YAAY,EAAE,CAAC,CAAC;QAEvE,KAAK,CAAC,cAAc,CAClB,IAAI,KAAK,EAAE;aACR,MAAM,CAAC,UAAU,CAAC;aAClB,MAAM,CAAC,cAAc,CAAC;aACtB,MAAM,CAAC,cAAc,CAAC,EACzB,MAAM,CACP,CAAC;QAEF,MAAM,iBAAiB,GAAG,UAAU,GAAG,kBAAkB,CAAC;QAC1D,UAAU,CAAC,GAAG,EAAE;YACd,KAAK,CAAC,YAAY,CAAC,iBAAiB,EAAE,CAAC,EAAE,MAAM,CAAC,CAAC;YACjD,KAAK,CAAC,KAAK,EAAE,CAAC;QAChB,CAAC,EAAE,CAAC,CAAC,CAAC;QAEN,IAAI,CAAC,YAAY,EAAE,CAAC;IACtB,CAAC;IAED;;OAEG;IACH,YAAY;QACV,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC;QAC9B,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC;QAC5B,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;IACjC,CAAC;IAED;;OAEG;IACH,oBAAoB;QAClB,OAAO,IAAI,CAAC,iBAAiB,EAAE,CAAC;IAClC,CAAC;IAED;;OAEG;IACH,sBAAsB,CAAC,IAAY;QACjC,MAAM,YAAY,GAAG,wBAAwB,CAAC;QAC9C,MAAM,OAAO,GAAG,IAAI;aACjB,KAAK,CAAC,EAAE,CAAC;aACT,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC;aAC/C,IAAI,CAAC,YAAY,CAAC,CAAC;QAEtB,OAAO,IAAI,MAAM,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;IACnC,CAAC;8GAnJU,sBAAsB;kHAAtB,sBAAsB,cAFrB,MAAM;;2FAEP,sBAAsB;kBAHlC,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["import { Injectable, ElementRef, signal } from '@angular/core';\r\nimport Quill from 'quill';\r\nimport { KvEditorVariavel } from '../types/kv-editor.types';\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class KvEditorMentionService {\r\n  \r\n  private filteredVariables = signal<KvEditorVariavel[]>([]);\r\n  private mentionStartIndex: number | null = null;\r\n  private mentionEndIndex: number | null = null;\r\n\r\n  /**\r\n   * Processa o sistema de menções durante a digitação\r\n   */\r\n  handleMention(quill: Quill, variaveis: KvEditorVariavel[]): {\r\n    shouldShowPanel: boolean;\r\n    filteredVariables: KvEditorVariavel[];\r\n    mentionBounds?: { top: number; left: number };\r\n  } {\r\n    const range = quill.getSelection();\r\n    if (!range) {\r\n      this.closeMention();\r\n      return { shouldShowPanel: false, filteredVariables: [] };\r\n    }\r\n\r\n    const text = quill.getText(0, range.index);\r\n    const lastHashIndex = text.lastIndexOf('#');\r\n\r\n    if (lastHashIndex !== -1 && !/\\s/.test(text.substring(lastHashIndex + 1))) {\r\n      this.mentionStartIndex = lastHashIndex;\r\n      this.mentionEndIndex = range.index;\r\n\r\n      const searchTerm = text.substring(lastHashIndex + 1).toLowerCase();\r\n      const filtered = variaveis.filter(v => \r\n        v.descricao.toLowerCase().includes(searchTerm)\r\n      );\r\n\r\n      this.filteredVariables.set(filtered);\r\n\r\n      if (filtered.length > 0) {\r\n        const bounds = this.calculateMentionBounds(quill, lastHashIndex);\r\n        return {\r\n          shouldShowPanel: true,\r\n          filteredVariables: filtered,\r\n          mentionBounds: bounds\r\n        };\r\n      }\r\n    }\r\n\r\n    this.closeMention();\r\n    return { shouldShowPanel: false, filteredVariables: [] };\r\n  }\r\n\r\n  /**\r\n   * Calcula a posição onde o painel de menções deve aparecer\r\n   */\r\n  private calculateMentionBounds(quill: Quill, lastHashIndex: number): { top: number; left: number } {\r\n    const editorEl = document.querySelector('#kv-editor');\r\n    if (!editorEl) return { top: 0, left: 0 };\r\n\r\n    const editorRect = editorEl.getBoundingClientRect();\r\n    \r\n    // Verifica se o '#' está no início de uma linha\r\n    const charBefore = lastHashIndex > 0 ? quill.getText(lastHashIndex - 1, 1) : null;\r\n    const isAtStartOfLine = (lastHashIndex === 0 || charBefore === '\\n');\r\n\r\n    if (isAtStartOfLine) {\r\n      // Posiciona no canto superior esquerdo do editor\r\n      return {\r\n        top: editorRect.top + 5,\r\n        left: editorRect.left + 5\r\n      };\r\n    } else {\r\n      // Usa getBounds() para posição precisa\r\n      const cursorBounds = quill.getBounds(lastHashIndex);\r\n      if (cursorBounds) {\r\n        return {\r\n          top: editorRect.top + cursorBounds.bottom,\r\n          left: editorRect.left + cursorBounds.left\r\n        };\r\n      } else {\r\n        return {\r\n          top: editorRect.top + 5,\r\n          left: editorRect.left + 5\r\n        };\r\n      }\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Insere uma variável selecionada no editor\r\n   */\r\n  insertVariable(quill: Quill, variable: KvEditorVariavel): void {\r\n    const startIndex = this.mentionStartIndex;\r\n    const endIndex = this.mentionEndIndex;\r\n\r\n    if (startIndex === null || endIndex === null) return;\r\n\r\n    const lengthToDelete = endIndex - startIndex;\r\n    const variableHtml = `<span \r\n                       style=\"background-color: #e6f7ff; color: #0066cc; border-radius: 3px; padding: 2px 4px; font-weight: 500;\"\r\n                       class=\"variavel-inserida\" \r\n                       title=\"${variable.descricao}\">${variable.descricao}</span>&nbsp;`;\r\n    \r\n    const insertedTextLength = variable.descricao.length + 1;\r\n    const Delta = Quill.import('delta');\r\n    const insertionDelta = quill.clipboard.convert({ html: variableHtml });\r\n\r\n    quill.updateContents(\r\n      new Delta()\r\n        .retain(startIndex)\r\n        .delete(lengthToDelete)\r\n        .concat(insertionDelta),\r\n      'user'\r\n    );\r\n\r\n    const newCursorPosition = startIndex + insertedTextLength;\r\n    setTimeout(() => {\r\n      quill.setSelection(newCursorPosition, 0, 'user');\r\n      quill.focus();\r\n    }, 0);\r\n\r\n    this.closeMention();\r\n  }\r\n\r\n  /**\r\n   * Fecha o sistema de menções\r\n   */\r\n  closeMention(): void {\r\n    this.mentionStartIndex = null;\r\n    this.mentionEndIndex = null;\r\n    this.filteredVariables.set([]);\r\n  }\r\n\r\n  /**\r\n   * Obtém as variáveis filtradas\r\n   */\r\n  getFilteredVariables(): KvEditorVariavel[] {\r\n    return this.filteredVariables();\r\n  }\r\n\r\n  /**\r\n   * Cria uma regex especial para busca em texto com HTML\r\n   */\r\n  createInterleavedRegex(text: string): RegExp {\r\n    const specialChars = /[-\\/\\\\^$*+?.()|[\\]{}]/g;\r\n    const pattern = text\r\n      .split('')\r\n      .map(char => char.replace(specialChars, '\\\\$&'))\r\n      .join('(<[^>]*>)*');\r\n\r\n    return new RegExp(pattern, 'gi');\r\n  }\r\n}\r\n"]}

package/esm2022/lib/components/kv-inputs/kv-editor/services/kv-editor-pdf.service.mjs

@@ -0,0 +1,168 @@
+import { Injectable, inject, signal } from '@angular/core';
+import { DialogService } from 'primeng/dynamicdialog';
+import { PdfService } from '../../../../api/services/pdf.service';
+import { KvReportModalComponent } from '../components/kv-report-modal/kv-report-modal.component';
+import * as i0 from "@angular/core";
+export class KvEditorPdfService {
+    constructor() {
+        this.pdfService = inject(PdfService);
+        this.dialogService = inject(DialogService);
+        this.isLoadingPdf = signal(false);
+    }
+    /**
+     * Obtém o estado de carregamento do PDF
+     */
+    getIsLoadingPdf() {
+        return this.isLoadingPdf();
+    }
+    /**
+     * Define o estado de carregamento do PDF
+     */
+    setIsLoadingPdf(loading) {
+        this.isLoadingPdf.set(loading);
+    }
+    /**
+     * Gera e abre o modal de relatório
+     */
+    async openRelatorio(htmlContent, relatorio, tipoVisualizacao) {
+        if (this.isLoadingPdf())
+            return;
+        this.setIsLoadingPdf(true);
+        try {
+            await new Promise(resolve => setTimeout(resolve, 2000));
+            let htmlComValoresReais = htmlContent;
+            if (relatorio) {
+                htmlComValoresReais = this.processarHtmlParaPdf(htmlContent, relatorio, tipoVisualizacao);
+            }
+            const htmlFinalParaPdf = this.adicionarEstilosParaPdf(htmlComValoresReais);
+            const pdfBlob = await this.gerarPdfBlob(htmlFinalParaPdf);
+            this.abrirModalRelatorio(pdfBlob);
+        }
+        catch (error) {
+            console.error('Falha ao gerar o Blob do PDF:', error);
+            alert('Ocorreu um erro ao gerar o relatório.');
+        }
+        finally {
+            this.setIsLoadingPdf(false);
+            setTimeout(() => window.dispatchEvent(new Event('resize')), 100);
+        }
+    }
+    /**
+     * Processa o HTML substituindo variáveis e limpando formatação
+     */
+    processarHtmlParaPdf(htmlContent, relatorio, tipoVisualizacao) {
+        let htmlProcessado = htmlContent;
+        // Substitui valores das variáveis
+        relatorio.variaveis.forEach(variavel => {
+            if (typeof variavel.descricao !== 'string' || variavel.descricao.trim() === '') {
+                return;
+            }
+            const specialRegex = this.createInterleavedRegex(variavel.descricao);
+            htmlProcessado = htmlProcessado.replace(specialRegex, variavel.value);
+        });
+        // Remove propriedades de estilo padrão
+        htmlProcessado = htmlProcessado.replace(/background-color:\s*rgb\(\s*230,\s*247,\s*255\s*\);?/gi, '');
+        htmlProcessado = htmlProcessado.replace(/color:\s*rgb\(\s*0,\s*102,\s*204\s*\);?/gi, '');
+        htmlProcessado = htmlProcessado.replace(/;(\s*;)+/g, ';');
+        htmlProcessado = htmlProcessado.replace(/\sstyle="[\s;]*"/gi, '');
+        // Remove parágrafos vazios e quebras de linha duplas
+        htmlProcessado = htmlProcessado.replace(/<p><br><\/p>/g, '');
+        htmlProcessado = htmlProcessado.replace(/(<br>\s*){2,}/g, '<br>');
+        return htmlProcessado;
+    }
+    /**
+     * Adiciona estilos CSS específicos para PDF
+     */
+    adicionarEstilosParaPdf(htmlContent) {
+        const estilosParaPdf = `
+      <style>
+        #temp-pdf-render-area { 
+          font-family: 'Sans Serif', Arial, sans-serif; 
+          font-size: 9pt;
+          line-height: 1.2;
+          text-align: justify; 
+        }
+        #temp-pdf-render-area p {
+          min-height: 1.2em;
+          margin: 0;
+          padding: 0;
+        }
+        #temp-pdf-render-area h1, #temp-pdf-render-area h2, #temp-pdf-render-area h3, 
+        #temp-pdf-render-area h4, #temp-pdf-render-area h5, #temp-pdf-render-area h6 { 
+          page-break-after: avoid; 
+        }
+        #temp-pdf-render-area [style*="text-align: center"] {
+          text-align: center !important;
+        }
+        #temp-pdf-render-area p, #temp-pdf-render-area h1, #temp-pdf-render-area h2, 
+        #temp-pdf-render-area h3, #temp-pdf-render-area h4, #temp-pdf-render-area h5, 
+        #temp-pdf-render-area h6, #temp-pdf-render-area blockquote, #temp-pdf-render-area ul, 
+        #temp-pdf-render-area ol, #temp-pdf-render-area li, #temp-pdf-render-area table, 
+        #temp-pdf-render-area tr, #temp-pdf-render-area img { 
+          page-break-inside: avoid; 
+        }
+      </style>
+    `;
+        return estilosParaPdf + htmlContent;
+    }
+    /**
+     * Gera o blob do PDF
+     */
+    async gerarPdfBlob(htmlContent) {
+        const renderContainer = document.createElement('div');
+        renderContainer.id = 'temp-pdf-render-area';
+        renderContainer.style.position = 'absolute';
+        renderContainer.style.left = '-9999px';
+        renderContainer.style.top = '0';
+        renderContainer.style.backgroundColor = 'white';
+        renderContainer.style.padding = '12mm';
+        renderContainer.style.width = '210mm';
+        renderContainer.style.fontSize = '12px';
+        renderContainer.innerHTML = htmlContent;
+        document.body.appendChild(renderContainer);
+        try {
+            await new Promise(resolve => setTimeout(resolve, 100));
+            return await this.pdfService.gerarPdfBlobPorElementoId('temp-pdf-render-area');
+        }
+        finally {
+            if (document.body.contains(renderContainer)) {
+                document.body.removeChild(renderContainer);
+            }
+        }
+    }
+    /**
+     * Abre o modal com o PDF gerado
+     */
+    abrirModalRelatorio(pdfBlob) {
+        this.dialogService.open(KvReportModalComponent, {
+            header: 'Gerar Relatório',
+            width: '60%',
+            height: '90%',
+            modal: true,
+            closable: true,
+            data: {
+                pdfBlob: pdfBlob
+            }
+        });
+    }
+    /**
+     * Cria uma regex especial para busca em texto com HTML
+     */
+    createInterleavedRegex(text) {
+        const specialChars = /[-\/\\^$*+?.()|[\]{}]/g;
+        const pattern = text
+            .split('')
+            .map(char => char.replace(specialChars, '\\$&'))
+            .join('(<[^>]*>)*');
+        return new RegExp(pattern, 'gi');
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: KvEditorPdfService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: KvEditorPdfService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: KvEditorPdfService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"kv-editor-pdf.service.js","sourceRoot":"","sources":["../../../../../../../../projects/keevo-components/src/lib/components/kv-inputs/kv-editor/services/kv-editor-pdf.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, inject, signal } from '@angular/core';\r\nimport { DialogService } from 'primeng/dynamicdialog';\r\nimport { PdfService } from '../../../../api/services/pdf.service';\r\nimport { KvEditorRelatorio, KvEditorVariavel } from '../types/kv-editor.types';\r\nimport { KvReportModalComponent } from '../components/kv-report-modal/kv-report-modal.component';\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class KvEditorPdfService {\r\n  \r\n  private pdfService = inject(PdfService);\r\n  private dialogService = inject(DialogService);\r\n  private isLoadingPdf = signal<boolean>(false);\r\n\r\n  /**\r\n   * Obtém o estado de carregamento do PDF\r\n   */\r\n  getIsLoadingPdf(): boolean {\r\n    return this.isLoadingPdf();\r\n  }\r\n\r\n  /**\r\n   * Define o estado de carregamento do PDF\r\n   */\r\n  setIsLoadingPdf(loading: boolean): void {\r\n    this.isLoadingPdf.set(loading);\r\n  }\r\n\r\n  /**\r\n   * Gera e abre o modal de relatório\r\n   */\r\n  async openRelatorio(\r\n    htmlContent: string, \r\n    relatorio: KvEditorRelatorio | null, \r\n    tipoVisualizacao: 'valor' | 'descricao'\r\n  ): Promise<void> {\r\n    if (this.isLoadingPdf()) return;\r\n    \r\n    this.setIsLoadingPdf(true);\r\n\r\n    try {\r\n      await new Promise(resolve => setTimeout(resolve, 2000));\r\n      \r\n      let htmlComValoresReais = htmlContent;\r\n\r\n      if (relatorio) {\r\n        htmlComValoresReais = this.processarHtmlParaPdf(htmlContent, relatorio, tipoVisualizacao);\r\n      }\r\n\r\n      const htmlFinalParaPdf = this.adicionarEstilosParaPdf(htmlComValoresReais);\r\n      const pdfBlob = await this.gerarPdfBlob(htmlFinalParaPdf);\r\n      \r\n      this.abrirModalRelatorio(pdfBlob);\r\n      \r\n    } catch (error) {\r\n      console.error('Falha ao gerar o Blob do PDF:', error);\r\n      alert('Ocorreu um erro ao gerar o relatório.');\r\n    } finally {\r\n      this.setIsLoadingPdf(false);\r\n      setTimeout(() => window.dispatchEvent(new Event('resize')), 100);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Processa o HTML substituindo variáveis e limpando formatação\r\n   */\r\n  private processarHtmlParaPdf(\r\n    htmlContent: string, \r\n    relatorio: KvEditorRelatorio, \r\n    tipoVisualizacao: 'valor' | 'descricao'\r\n  ): string {\r\n    let htmlProcessado = htmlContent;\r\n\r\n    // Substitui valores das variáveis\r\n    relatorio.variaveis.forEach(variavel => {\r\n      if (typeof variavel.descricao !== 'string' || variavel.descricao.trim() === '') {\r\n        return;\r\n      }\r\n      \r\n      const specialRegex = this.createInterleavedRegex(variavel.descricao);\r\n      htmlProcessado = htmlProcessado.replace(specialRegex, variavel.value);\r\n    });\r\n\r\n    // Remove propriedades de estilo padrão\r\n    htmlProcessado = htmlProcessado.replace(/background-color:\\s*rgb\\(\\s*230,\\s*247,\\s*255\\s*\\);?/gi, '');\r\n    htmlProcessado = htmlProcessado.replace(/color:\\s*rgb\\(\\s*0,\\s*102,\\s*204\\s*\\);?/gi, '');\r\n    htmlProcessado = htmlProcessado.replace(/;(\\s*;)+/g, ';');\r\n    htmlProcessado = htmlProcessado.replace(/\\sstyle=\"[\\s;]*\"/gi, '');\r\n\r\n    // Remove parágrafos vazios e quebras de linha duplas\r\n    htmlProcessado = htmlProcessado.replace(/<p><br><\\/p>/g, '');\r\n    htmlProcessado = htmlProcessado.replace(/(<br>\\s*){2,}/g, '<br>');\r\n\r\n    return htmlProcessado;\r\n  }\r\n\r\n  /**\r\n   * Adiciona estilos CSS específicos para PDF\r\n   */\r\n  private adicionarEstilosParaPdf(htmlContent: string): string {\r\n    const estilosParaPdf = `\r\n      <style>\r\n        #temp-pdf-render-area { \r\n          font-family: 'Sans Serif', Arial, sans-serif; \r\n          font-size: 9pt;\r\n          line-height: 1.2;\r\n          text-align: justify; \r\n        }\r\n        #temp-pdf-render-area p {\r\n          min-height: 1.2em;\r\n          margin: 0;\r\n          padding: 0;\r\n        }\r\n        #temp-pdf-render-area h1, #temp-pdf-render-area h2, #temp-pdf-render-area h3, \r\n        #temp-pdf-render-area h4, #temp-pdf-render-area h5, #temp-pdf-render-area h6 { \r\n          page-break-after: avoid; \r\n        }\r\n        #temp-pdf-render-area [style*=\"text-align: center\"] {\r\n          text-align: center !important;\r\n        }\r\n        #temp-pdf-render-area p, #temp-pdf-render-area h1, #temp-pdf-render-area h2, \r\n        #temp-pdf-render-area h3, #temp-pdf-render-area h4, #temp-pdf-render-area h5, \r\n        #temp-pdf-render-area h6, #temp-pdf-render-area blockquote, #temp-pdf-render-area ul, \r\n        #temp-pdf-render-area ol, #temp-pdf-render-area li, #temp-pdf-render-area table, \r\n        #temp-pdf-render-area tr, #temp-pdf-render-area img { \r\n          page-break-inside: avoid; \r\n        }\r\n      </style>\r\n    `;\r\n    \r\n    return estilosParaPdf + htmlContent;\r\n  }\r\n\r\n  /**\r\n   * Gera o blob do PDF\r\n   */\r\n  private async gerarPdfBlob(htmlContent: string): Promise<Blob> {\r\n    const renderContainer = document.createElement('div');\r\n    renderContainer.id = 'temp-pdf-render-area';\r\n    renderContainer.style.position = 'absolute';\r\n    renderContainer.style.left = '-9999px';\r\n    renderContainer.style.top = '0';\r\n    renderContainer.style.backgroundColor = 'white';\r\n    renderContainer.style.padding = '12mm';\r\n    renderContainer.style.width = '210mm';\r\n    renderContainer.style.fontSize = '12px';\r\n    renderContainer.innerHTML = htmlContent;\r\n    \r\n    document.body.appendChild(renderContainer);\r\n\r\n    try {\r\n      await new Promise(resolve => setTimeout(resolve, 100));\r\n      return await this.pdfService.gerarPdfBlobPorElementoId('temp-pdf-render-area');\r\n    } finally {\r\n      if (document.body.contains(renderContainer)) {\r\n        document.body.removeChild(renderContainer);\r\n      }\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Abre o modal com o PDF gerado\r\n   */\r\n  private abrirModalRelatorio(pdfBlob: Blob): void {\r\n    this.dialogService.open(KvReportModalComponent, {\r\n      header: 'Gerar Relatório',\r\n      width: '60%',\r\n      height: '90%',\r\n      modal: true,\r\n      closable: true,\r\n      data: {\r\n        pdfBlob: pdfBlob\r\n      }\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Cria uma regex especial para busca em texto com HTML\r\n   */\r\n  private createInterleavedRegex(text: string): RegExp {\r\n    const specialChars = /[-\\/\\\\^$*+?.()|[\\]{}]/g;\r\n    const pattern = text\r\n      .split('')\r\n      .map(char => char.replace(specialChars, '\\\\$&'))\r\n      .join('(<[^>]*>)*');\r\n\r\n    return new RegExp(pattern, 'gi');\r\n  }\r\n}\r\n"]}

package/esm2022/lib/components/kv-inputs/kv-editor/services/kv-editor-quill.service.mjs

@@ -0,0 +1,78 @@
+import { Injectable } from '@angular/core';
+import Quill from 'quill';
+import * as i0 from "@angular/core";
+export class KvEditorQuillService {
+    constructor() {
+        this.quillInstance = null;
+    }
+    /**
+     * Carrega o CSS do Quill dinamicamente
+     */
+    loadCss() {
+        return new Promise((resolve, reject) => {
+            const existingLink = document.querySelector('link[href*="quill.snow.css"]');
+            if (existingLink) {
+                resolve();
+                return;
+            }
+            const cssElement = document.createElement('link');
+            cssElement.rel = 'stylesheet';
+            cssElement.href = 'https://cdn.jsdelivr.net/npm/quill@2.0.2/dist/quill.snow.css';
+            cssElement.onload = () => resolve();
+            cssElement.onerror = (err) => reject(err);
+            document.head.appendChild(cssElement);
+        });
+    }
+    /**
+     * Registra os formatos personalizados do Quill
+     */
+    registerCustomFormats() {
+        const ColorStyle = Quill.import('attributors/style/color');
+        const SizeStyle = Quill.import('attributors/style/size');
+        const Font = Quill.import('formats/font');
+        const Size = Quill.import('attributors/style/size');
+        const AlignStyle = Quill.import('attributors/style/align');
+        Size.whitelist = ['15px', '20px', '30px', '40px', '50px', '70px', '90px'];
+        Font.whitelist = ['monospace', 'roboto', 'arial', 'times-new-roman', 'serif', 'inter'];
+        Quill.register(ColorStyle, true);
+        Quill.register(SizeStyle, true);
+        Quill.register(Font, true);
+        Quill.register(Size, true);
+        Quill.register(AlignStyle, true);
+    }
+    /**
+     * Cria uma instância do Quill com a configuração fornecida
+     */
+    createQuillInstance(selector, config) {
+        this.registerCustomFormats();
+        this.quillInstance = new Quill(selector, {
+            theme: config.theme,
+            modules: config.modules,
+            placeholder: config.placeholder,
+            readOnly: config.readOnly,
+            debug: config.debug,
+        });
+        return this.quillInstance;
+    }
+    /**
+     * Obtém a instância atual do Quill
+     */
+    getQuillInstance() {
+        return this.quillInstance;
+    }
+    /**
+     * Limpa a instância do Quill
+     */
+    destroyQuillInstance() {
+        this.quillInstance = null;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: KvEditorQuillService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: KvEditorQuillService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: KvEditorQuillService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/components/kv-inputs/kv-editor/services/kv-editor-relatorio.service.mjs

@@ -0,0 +1,95 @@
+import { Injectable, signal } from '@angular/core';
+import * as i0 from "@angular/core";
+export class KvEditorRelatorioService {
+    constructor() {
+        this.relatorios = signal([]);
+        this.relatorioSelected = signal(null);
+        this.idRelatorioSelected = signal(0);
+    }
+    /**
+     * Define a lista de relatórios disponíveis
+     */
+    setRelatorios(relatorios) {
+        this.relatorios.set(relatorios);
+    }
+    /**
+     * Obtém a lista de relatórios
+     */
+    getRelatorios() {
+        return this.relatorios();
+    }
+    /**
+     * Seleciona um relatório pelo ID
+     */
+    setRelatorioPorId(id) {
+        this.idRelatorioSelected.set(id);
+        const relatorio = this.relatorios().find(r => r.id === id);
+        if (relatorio) {
+            this.relatorioSelected.set(relatorio);
+            return relatorio;
+        }
+        return null;
+    }
+    /**
+     * Define o relatório selecionado
+     */
+    setRelatorio(relatorio) {
+        this.idRelatorioSelected.set(relatorio.id);
+        this.relatorioSelected.set(relatorio);
+    }
+    /**
+     * Obtém o relatório selecionado
+     */
+    getRelatorioSelected() {
+        return this.relatorioSelected();
+    }
+    /**
+     * Obtém o ID do relatório selecionado
+     */
+    getIdRelatorioSelected() {
+        return this.idRelatorioSelected();
+    }
+    /**
+     * Renderiza o template do contrato com as variáveis
+     */
+    renderContrato(texto, variaveis) {
+        return texto.replace(/\{(\d+)\}/g, (_, id) => {
+            const v = variaveis.find(v => v.id === parseInt(id));
+            if (!v)
+                return `{${id}}`;
+            return `<span class="variavel-inserida"
+                   style="background-color: #e6f7ff; color: #0066cc; border-radius: 3px; padding: 2px 4px; font-weight: 500;"
+                    title="${v.descricao ?? ''}">${v.descricao}</span>`;
+        });
+    }
+    /**
+     * Renderiza o contrato para PDF (sem formatação HTML)
+     */
+    renderContratoParaPdf(texto, variaveis, tipoVisualizacao) {
+        return texto.replace(/\{(\d+)\}/g, (_, id) => {
+            const v = variaveis.find(v => v.id === parseInt(id));
+            if (!v)
+                return `{${id}}`;
+            const descricao = tipoVisualizacao === 'descricao' ? v.descricao : v.value;
+            return descricao || '';
+        });
+    }
+    /**
+     * Filtra variáveis baseado no termo de busca
+     */
+    filtrarVariaveis(termo) {
+        const relatorio = this.getRelatorioSelected();
+        if (!relatorio)
+            return [];
+        return relatorio.variaveis.filter(v => v.descricao.toLowerCase().includes(termo.toLowerCase()));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: KvEditorRelatorioService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: KvEditorRelatorioService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: KvEditorRelatorioService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/components/kv-inputs/kv-editor/types/kv-editor.types.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoia3YtZWRpdG9yLnR5cGVzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMva2Vldm8tY29tcG9uZW50cy9zcmMvbGliL2NvbXBvbmVudHMva3YtaW5wdXRzL2t2LWVkaXRvci90eXBlcy9rdi1lZGl0b3IudHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBpbnRlcmZhY2UgS3ZFZGl0b3JSZWxhdG9yaW8ge1xyXG4gIGlkOiBudW1iZXI7XHJcbiAgbGFiZWw6IHN0cmluZztcclxuICBkZXNjcmljYW86IHN0cmluZztcclxuICBtb2RlbG9SZWxhdG9yaW86IHN0cmluZztcclxuICB2YXJpYXZlaXM6IEt2RWRpdG9yVmFyaWF2ZWxbXTtcclxufVxyXG5cclxuZXhwb3J0IGludGVyZmFjZSBLdkVkaXRvclZhcmlhdmVsIHtcclxuICBpZDogbnVtYmVyO1xyXG4gIGRlc2NyaWNhbzogc3RyaW5nO1xyXG4gIHZhbHVlOiBzdHJpbmc7XHJcbiAgY29yPzogc3RyaW5nO1xyXG59XHJcblxyXG5leHBvcnQgaW50ZXJmYWNlIEt2RWRpdG9yQ29uZmlnIHtcclxuICBjb250ZW50VHlwZTogJ2h0bWwnIHwgJ3RleHQnO1xyXG4gIHJlYWRvbmx5OiBib29sZWFuO1xyXG4gIGRlYnVnOiBib29sZWFuO1xyXG4gIGNhbnZhSGVpZ3RoOiBzdHJpbmc7XHJcbn1cclxuXHJcbmV4cG9ydCBpbnRlcmZhY2UgS3ZFZGl0b3JFdmVudHMge1xyXG4gIG9uVGV4dENoYW5nZTogYW55O1xyXG4gIG9uU2VsZWN0aW9uQ2hhbmdlOiBhbnk7XHJcbiAgb3V0cHV0UmF3OiBzdHJpbmc7XHJcbiAgb3V0cHV0SHRtbDogc3RyaW5nO1xyXG59XHJcblxyXG5leHBvcnQgaW50ZXJmYWNlIEt2RWRpdG9yUXVpbGxDb25maWcge1xyXG4gIHRoZW1lOiBzdHJpbmc7XHJcbiAgbW9kdWxlczogYW55O1xyXG4gIHBsYWNlaG9sZGVyOiBzdHJpbmc7XHJcbiAgcmVhZE9ubHk6IGJvb2xlYW47XHJcbiAgZGVidWc6IGJvb2xlYW47XHJcbn1cclxuIl19