n8n-nodes-docx-filler 2.4.0 → 2.6.0

package/dist/DocxFillerAI/DocxFillerAI.node.js

@@ -130,6 +130,43 @@ function normalize(text) {
         .replace(/\s+/g, ' ')
         .trim();
 }
+/**
+ * Détecte si un paragraphe est un "placeholder" (zone à remplir dans un template)
+ * Les templates utilisent souvent des pointillés, soulignés, ou zones vides
+ */
+function isPlaceholderOrEmpty(text) {
+    const trimmed = text.trim();
+    // Vraiment vide ou très court
+    if (!trimmed || trimmed.length < 3)
+        return true;
+    // Lignes de pointillés (................)
+    if (/^[.\s…]+$/.test(trimmed))
+        return true;
+    if (/^\.{3,}$/.test(trimmed))
+        return true;
+    // Lignes de soulignement (_______)
+    if (/^[_\s]+$/.test(trimmed))
+        return true;
+    // Lignes de tirets (-------)
+    if (/^[-–—\s]+$/.test(trimmed))
+        return true;
+    // Juste des deux-points ou séparateurs
+    if (/^[:;\s]+$/.test(trimmed))
+        return true;
+    // Espaces non cassants et caractères invisibles
+    if (/^[\s\u00A0\u200B\u2003]+$/.test(trimmed))
+        return true;
+    // Combinaison de caractères de remplissage
+    if (/^[\.\-_:;\s…]+$/.test(trimmed))
+        return true;
+    // Texte très court sans valeur sémantique (1-2 chars)
+    if (trimmed.length <= 2)
+        return true;
+    // Numéros seuls (souvent utilisés comme index dans les formulaires)
+    if (/^\d{1,2}[\.\):]?$/.test(trimmed))
+        return true;
+    return false;
+}
 function escapeXml(text) {
     return text
         .replace(/&/g, '&amp;')
@@ -335,6 +372,15 @@ function isFalsePositive(text) {
         return true;
     return false;
 }
+/**
+ * Vérifie si un paragraphe contient un label suivi d'un placeholder sur la même ligne
+ * Exemple: "Nom commercial : ..............."
+ */
+function hasInlinePlaceholder(text) {
+    // Pattern: label suivi de deux-points, puis placeholder (pointillés, soulignés, espaces)
+    return /:\s*[.\s_\-…]{4,}\s*$/.test(text) ||
+        /:\s*$/.test(text); // Label terminant par ":" sans valeur
+}
 /**
  * Trouve les positions à remplir dans un template
  * IMPORTANT: Chaque type de champ n'est rempli qu'UNE SEULE FOIS (premier match)
@@ -342,27 +388,41 @@ function isFalsePositive(text) {
 function findFillPositions(paragraphs) {
     const positions = [];
     const usedFillIndices = new Set();
-    const usedFieldTypes = new Set(); // NOUVEAU: éviter les doublons par type
+    const usedFieldTypes = new Set(); // éviter les doublons par type
     for (let i = 0; i < paragraphs.length; i++) {
         const p = paragraphs[i];
         // Ignorer les faux positifs (notes, titres, etc.)
         if (isFalsePositive(p.text))
             continue;
         const fieldType = detectFieldType(p.text);
-        // NOUVEAU: Si ce type de champ a déjà été trouvé, passer au suivant
+        // Si ce type de champ a déjà été trouvé, passer au suivant
         if (fieldType && usedFieldTypes.has(fieldType))
             continue;
         if (fieldType) {
-            // Chercher le prochain paragraphe vide pour y insérer la valeur
-            for (let j = i + 1; j < Math.min(i + 6, paragraphs.length); j++) {
+            // CAS 1: Label avec placeholder inline (même paragraphe)
+            // Exemple: "Nom commercial : ..............."
+            if (hasInlinePlaceholder(p.text) && !usedFillIndices.has(i)) {
+                positions.push({
+                    fieldType,
+                    labelIndex: i,
+                    labelText: p.text.slice(0, 60),
+                    fillIndex: i, // On remplit le même paragraphe
+                    paragraph: p,
+                });
+                usedFillIndices.add(i);
+                usedFieldTypes.add(fieldType);
+                continue;
+            }
+            // CAS 2: Chercher le prochain paragraphe vide/placeholder
+            for (let j = i + 1; j < Math.min(i + 8, paragraphs.length); j++) {
                 if (usedFillIndices.has(j))
                     continue;
                 const nextP = paragraphs[j];
                 // Ignorer les faux positifs comme position de remplissage
                 if (isFalsePositive(nextP.text))
                     continue;
-                // Position vide = remplissable
-                if (nextP.isEmpty) {
+                // Position vide OU placeholder (pointillés, soulignés, etc.) = remplissable
+                if (isPlaceholderOrEmpty(nextP.text)) {
                     positions.push({
                         fieldType,
                         labelIndex: i,
@@ -371,7 +431,7 @@ function findFillPositions(paragraphs) {
                         paragraph: nextP,
                     });
                     usedFillIndices.add(j);
-                    usedFieldTypes.add(fieldType); // NOUVEAU: marquer comme utilisé
+                    usedFieldTypes.add(fieldType);
                     break;
                 }
                 // Si on trouve un autre label, arrêter
@@ -405,8 +465,22 @@ function fillTemplateXml(templateXml, templateParagraphs, sourceData, fillPositi
         if (!sourceField)
             continue;
         const oldP = pos.paragraph.fullMatch;
-        // Créer un nouveau paragraphe avec la valeur, en conservant la structure
-        const newP = oldP.replace(/(<w:p[^>]*>)([\s\S]*?)(<\/w:p>)/, `$1<w:r><w:t>${escapeXml(sourceField.value)}</w:t></w:r>$3`);
+        let newP;
+        // CAS INLINE: Label et placeholder sur le même paragraphe
+        // On doit remplacer seulement la partie après ":" par la valeur
+        if (pos.labelIndex === pos.fillIndex && hasInlinePlaceholder(pos.paragraph.text)) {
+            // Trouver et remplacer le placeholder après ":"
+            // On garde le label et on ajoute la valeur après
+            newP = oldP.replace(/(<w:t[^>]*>)([^<]*:\s*)[.\s_\-…]*(<\/w:t>)/, `$1$2${escapeXml(sourceField.value)}$3`);
+            // Si pas de match, fallback: ajouter la valeur à la fin
+            if (newP === oldP) {
+                newP = oldP.replace(/(<\/w:r>)(\s*<\/w:p>)/, `</w:r><w:r><w:t> ${escapeXml(sourceField.value)}</w:t></w:r>$2`);
+            }
+        }
+        else {
+            // CAS NORMAL: Remplacer le paragraphe vide par la valeur
+            newP = oldP.replace(/(<w:p[^>]*>)([\s\S]*?)(<\/w:p>)/, `$1<w:r><w:t>${escapeXml(sourceField.value)}</w:t></w:r>$3`);
+        }
         modifications.push({
             start: pos.paragraph.start,
             end: pos.paragraph.end,
@@ -1117,68 +1191,14 @@ class DocxFillerAI {
                             // Fallback au mode sans LLM
                             sourceData = extractSourceData(sourceParagraphs);
                         }
-                        // Mapping avec LLM - UTILISER les résultats de l'IA
-                        const fillPrompt = FILL_PROMPT
-                            .replace('{source_data}', JSON.stringify(sourceData, null, 2))
-                            .replace('{template_text}', templateStructured);
-                        const fillResponse = await llm.invoke(fillPrompt);
-                        let llmMappings = [];
-                        // Parser la réponse du LLM
-                        try {
-                            let fillText;
-                            if (typeof fillResponse === 'string') {
-                                fillText = fillResponse;
-                            }
-                            else if (fillResponse && typeof fillResponse.content === 'string') {
-                                fillText = fillResponse.content;
-                            }
-                            else if (fillResponse && typeof fillResponse.text === 'string') {
-                                fillText = fillResponse.text;
-                            }
-                            else if (fillResponse && Array.isArray(fillResponse.content)) {
-                                fillText = fillResponse.content
-                                    .filter((c) => c.type === 'text')
-                                    .map((c) => c.text)
-                                    .join('');
-                            }
-                            else {
-                                fillText = JSON.stringify(fillResponse);
-                            }
-                            const jsonMatch = fillText.match(/\{[\s\S]*\}/);
-                            if (jsonMatch) {
-                                const parsed = JSON.parse(jsonMatch[0]);
-                                llmMappings = parsed.mappings || [];
-                            }
-                        }
-                        catch {
-                            // Fallback si parsing échoue
-                            llmMappings = [];
-                        }
-                        // Si l'IA a fourni des mappings valides, les utiliser
-                        if (llmMappings.length > 0) {
-                            // Utiliser les mappings de l'IA
-                            const usedIndices = new Set();
-                            for (const mapping of llmMappings) {
-                                if (usedIndices.has(mapping.templateIndex))
-                                    continue;
-                                const targetParagraph = templateParagraphs.find(p => p.index === mapping.templateIndex);
-                                if (!targetParagraph)
-                                    continue;
-                                const oldP = targetParagraph.fullMatch;
-                                const newP = oldP.replace(/(<w:p[^>]*>)([\s\S]*?)(<\/w:p>)/, `$1<w:r><w:t>${escapeXml(mapping.value)}</w:t></w:r>$3`);
-                                templateXml = templateXml.replace(oldP, newP);
-                                filledFields.push(`${mapping.fieldType}: ${mapping.value}`);
-                                usedIndices.add(mapping.templateIndex);
-                            }
-                        }
-                        else {
-                            // Fallback: utiliser la logique standard
-                            const fillPositions = findFillPositions(templateParagraphs);
-                            const result = fillTemplateXml(templateXml, templateParagraphs, sourceData, fillPositions);
-                            templateXml = result.xml;
-                            filledFields = result.filledFields;
-                            modifiedCheckboxes = result.modifiedCheckboxes;
-                        }
+                        // Utiliser la logique standard de mapping (plus fiable)
+                        // L'IA a été utilisée pour l'extraction des données, mais le mapping
+                        // utilise l'algorithme déterministe pour éviter les corruptions XML
+                        const fillPositions = findFillPositions(templateParagraphs);
+                        const result = fillTemplateXml(templateXml, templateParagraphs, sourceData, fillPositions);
+                        templateXml = result.xml;
+                        filledFields = result.filledFields;
+                        modifiedCheckboxes = result.modifiedCheckboxes;
                     }
                     else {
                         // Mode sans LLM: extraction et mapping par patterns

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "n8n-nodes-docx-filler",
-  "version": "2.4.0",
+  "version": "2.6.0",
   "description": "n8n node to automatically fill DOCX documents (French DC1, DC2, AE forms) using AI for semantic understanding and field mapping.",
   "keywords": [
     "n8n-community-node-package",