new interactive

app/utils/generateAnonymizedText.ts

@@ -1,5 +1,59 @@
 import { EntityMapping } from "@/app/config/entityLabels";
 
+// Fonction améliorée pour résoudre les chevauchements d'entités
+const resolveOverlaps = (mappings: EntityMapping[]): EntityMapping[] => {
+  if (mappings.length <= 1) return mappings;
+  
+  // Trier par position de début, puis par score/longueur
+  const sorted = [...mappings].sort((a, b) => {
+    if (a.start !== b.start) return a.start - b.start;
+    // En cas d'égalité, privilégier l'entité la plus longue
+    return (b.end - b.start) - (a.end - a.start);
+  });
+  
+  const resolved: EntityMapping[] = [];
+  
+  for (const current of sorted) {
+    // Vérifier si cette entité chevauche avec une entité déjà acceptée
+    let hasConflict = false;
+    
+    for (const existing of resolved) {
+      // Détecter tout type de chevauchement
+      const overlap = (
+        (current.start >= existing.start && current.start < existing.end) ||
+        (current.end > existing.start && current.end <= existing.end) ||
+        (current.start <= existing.start && current.end >= existing.end)
+      );
+      
+      if (overlap) {
+        hasConflict = true;
+        break;
+      }
+    }
+    
+    if (!hasConflict) {
+      resolved.push(current);
+    }
+  }
+  
+  return resolved.sort((a, b) => a.start - b.start);
+};
+
+// Fonction pour nettoyer et valider les mappings
+const cleanMappings = (mappings: EntityMapping[], originalText: string): EntityMapping[] => {
+  return mappings.filter(mapping => {
+    // Vérifier que les indices sont valides
+    if (mapping.start < 0 || mapping.end < 0) return false;
+    if (mapping.start >= originalText.length) return false;
+    if (mapping.end > originalText.length) return false;
+    if (mapping.start >= mapping.end) return false;
+    
+    // Vérifier que le texte correspond
+    const extractedText = originalText.slice(mapping.start, mapping.end);
+    return extractedText === mapping.text;
+  });
+};
+
 export const generateAnonymizedText = (
   originalText: string,
   mappings: EntityMapping[]
@@ -8,20 +62,30 @@ export const generateAnonymizedText = (
     return originalText;
   }
 
-  // Trier les mappings par position de début
-  const sortedMappings = [...mappings].sort((a, b) => a.start - b.start);
+  // Nettoyer et valider les mappings
+  const cleanedMappings = cleanMappings(mappings, originalText);
+  
+  // Résoudre les chevauchements
+  const resolvedMappings = resolveOverlaps(cleanedMappings);
 
   let result = "";
   let lastIndex = 0;
 
-  for (const mapping of sortedMappings) {
+  for (const mapping of resolvedMappings) {
+    // Sécurité supplémentaire
+    if (mapping.start < lastIndex) continue;
+    
     // Ajouter le texte avant l'entité
     result += originalText.slice(lastIndex, mapping.start);
 
-    // Utiliser displayName comme dans le tableau de mapping
-    result += mapping.displayName;
-
-    // Mettre à jour la position
+    // Utiliser la valeur de remplacement appropriée
+    let replacement = mapping.replacementValue;
+    
+    if (!replacement) {
+      replacement = mapping.displayName || `[${mapping.entity_type}]`;
+    }
+    
+    result += replacement;
     lastIndex = mapping.end;
   }