glisser

app/components/AnonymizationLogic.tsx

@@ -117,41 +117,79 @@ export const useAnonymization = ({
           }
         });
 
-        const seen = new Set<string>();
+        // 2. Créer un mapping basé sur l'ordre d'apparition dans le texte anonymisé
         const uniqueMappings: EntityMapping[] = [];
-        const addedCounts = new Map<string, number>();
-
-        // 2. N'ajouter que les entités réellement anonymisées avec un compteur
-        data.analyzerResults
-          .sort((a, b) => a.start - b.start) // Trier par ordre d'apparition
-          .forEach((result) => {
-            const entityType = result.entity_type;
-            const maxCount = tagCounts.get(entityType) || 0;
-            const currentCount = addedCounts.get(entityType) || 0;
-
-            if (currentCount < maxCount) {
-              const originalValue = textToProcess.substring(
-                result.start,
-                result.end
-              );
-              const frenchLabel = entityTypeMap.get(entityType) || entityType;
-              const uniqueKey = `${frenchLabel}|${originalValue}`;
-
-              if (!seen.has(uniqueKey)) {
-                const newCount = (addedCounts.get(entityType) || 0) + 1;
-                addedCounts.set(entityType, newCount);
-
-                uniqueMappings.push({
-                  entityType: frenchLabel,
-                  originalValue: originalValue,
-                  anonymizedValue: `${frenchLabel} [${newCount}]`,
-                  startIndex: result.start,
-                  endIndex: result.end,
-                });
-                seen.add(uniqueKey);
-              }
+        
+        // Vérifier que les données nécessaires sont disponibles
+        if (!data.analyzerResults || !data.anonymizedText) {
+          setEntityMappings([]);
+          return;
+        }
+        
+        const entityCounters = new Map<string, number>();
+        
+        // Parcourir le texte anonymisé pour trouver les tags dans l'ordre
+        const anonymizedText = data.anonymizedText;
+        const allMatches: Array<{
+          match: RegExpMatchArray;
+          entityType: string;
+          position: number;
+        }> = [];
+        
+        // Trouver tous les tags dans le texte anonymisé
+        patterns.forEach(pattern => {
+          const entityTypeKey = pattern.regex.toString().match(/<([A-Z_]+)>/)?.[1];
+          if (entityTypeKey) {
+            const regex = new RegExp(pattern.regex.source, 'g');
+            let match;
+            while ((match = regex.exec(anonymizedText)) !== null) {
+              allMatches.push({
+                match,
+                entityType: entityTypeKey,
+                position: match.index
+              });
             }
-          });
+          }
+        });
+        
+        // Trier par position dans le texte anonymisé
+        allMatches.sort((a, b) => a.position - b.position);
+        
+        // Créer les mappings dans l'ordre d'apparition
+        const seen = new Set<string>();
+        allMatches.forEach(({ entityType }) => {
+          const frenchLabel = entityTypeMap.get(entityType) || entityType;
+          const currentCount = (entityCounters.get(entityType) || 0) + 1;
+          entityCounters.set(entityType, currentCount);
+          
+          // Trouver l'entité correspondante dans les résultats d'analyse
+          const correspondingResult = data.analyzerResults
+            ?.filter(result => result.entity_type === entityType)
+            .find(result => {
+              const originalValue = textToProcess.substring(result.start, result.end);
+              const uniqueKey = `${frenchLabel}|${originalValue}|${currentCount}`;
+              return !seen.has(uniqueKey);
+            });
+            
+          if (correspondingResult) {
+            const originalValue = textToProcess.substring(
+              correspondingResult.start,
+              correspondingResult.end
+            );
+            const uniqueKey = `${frenchLabel}|${originalValue}|${currentCount}`;
+            
+            if (!seen.has(uniqueKey)) {
+              uniqueMappings.push({
+                entityType: frenchLabel,
+                originalValue: originalValue,
+                anonymizedValue: `${frenchLabel} [${currentCount}]`,
+                startIndex: correspondingResult.start,
+                endIndex: correspondingResult.end,
+              });
+              seen.add(uniqueKey);
+            }
+          }
+        });
 
         setEntityMappings(uniqueMappings);
       } else if (data.text) {