fix(translation): handle duplicate texts in batch translation

Fixed critical bug where duplicate texts in batch translation would only
translate the last occurrence. Changed textIndexMap from Map<string, number>
to Map<string, number[]> to track ALL indices for each unique text.

Also added Set-based deduplication to reduce API calls while ensuring all
duplicate entries receive translations.

Changes:
- Track all indices for duplicate texts using Map<string, number[]>
- Add Set-based deduplication for efficiency
- Assign translation results to all duplicate indices
- Add comprehensive test for duplicate text handling
- Fix failing test that relied on duplicate text behavior

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: sjsyrek

CHANGELOG.md

@@ -16,6 +16,17 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   - **Impact**: Ensures future developers understand the importance of property order
   - Location: `src/services/translation.ts:386-417`, test added to `tests/unit/translation-service.test.ts`
 
+### Fixed
+- **Critical: Duplicate text handling in batch translation** - Fixed data loss bug for duplicate inputs
+  - When input array contained duplicate texts (e.g., `["Hello", "Hello", "World"]`), only the last occurrence received translation
+  - Fixed by tracking ALL indices for each unique text using `Map<string, number[]>`
+  - Added automatic deduplication of API requests (sends each unique text only once)
+  - All occurrences of duplicate texts now receive correct translations
+  - Added comprehensive test demonstrating the fix
+  - **Impact**: Previously, duplicate texts in batch translation would return incomplete results
+  - **Example**: `translateBatch(["Hello", "Hello", "World"], {targetLang: "es"})` now returns 3 results instead of 2
+  - Location: `src/services/translation.ts:160-265`
+
 ### Changed
 - **Test Coverage Enhancement** - Comprehensive integration and E2E test expansion
   - Created 10 new test files covering critical workflows and CLI behavior

src/services/translation.ts

@@ -158,8 +158,9 @@ export class TranslationService {
     };
 
     // Check cache and separate cached vs non-cached texts
-    const textsToTranslate: string[] = [];
-    const textIndexMap = new Map<string, number>(); // Maps text to original index
+    // Use Set for deduplication and Map to track all indices for each text
+    const textsToTranslateSet = new Set<string>();
+    const textIndexMap = new Map<string, number[]>(); // Maps text to ALL original indices
     const results: (TranslationResult | null)[] = new Array<TranslationResult | null>(texts.length).fill(null);
 
     for (let i = 0; i < texts.length; i++) {
@@ -179,10 +180,19 @@ export class TranslationService {
       }
 
       // Not cached, need to translate
-      textsToTranslate.push(text);
-      textIndexMap.set(text, i);
+      // Track this text for translation (deduplicated via Set)
+      textsToTranslateSet.add(text);
+
+      // Track ALL indices for this text (handles duplicates)
+      if (!textIndexMap.has(text)) {
+        textIndexMap.set(text, []);
+      }
+      textIndexMap.get(text)!.push(i);
     }
 
+    // Convert Set to Array for batch translation
+    const textsToTranslate = Array.from(textsToTranslateSet);
+
     // If all texts were cached, return cached results
     if (textsToTranslate.length === 0) {
       return results.filter((r): r is TranslationResult => r !== null);
@@ -230,7 +240,7 @@ export class TranslationService {
       throw lastError;
     }
 
-    // Store results in cache and map back to original indices
+    // Store results in cache and map back to ALL original indices
     for (const text of textsToTranslate) {
       const result = textToResultMap.get(text);
 
@@ -239,11 +249,14 @@ export class TranslationService {
         continue;
       }
 
-      const originalIndex = textIndexMap.get(text);
-      if (originalIndex !== undefined) {
-        results[originalIndex] = result;
+      const originalIndices = textIndexMap.get(text);
+      if (originalIndices) {
+        // Assign result to ALL indices where this text appeared (handles duplicates)
+        for (const index of originalIndices) {
+          results[index] = result;
+        }
 
-        // Cache the result
+        // Cache the result (only once per unique text)
         if (cacheEnabled) {
           const cacheKey = this.generateCacheKey(text, translationOptions);
           this.cache.set(cacheKey, result);

tests/unit/translation-service.test.ts

@@ -313,16 +313,17 @@ describe('TranslationService', () => {
     });
 
     it('should handle batch size limits (50 texts per batch)', async () => {
-      const largeTextArray = Array(100).fill('test');
+      // Create 100 UNIQUE texts to avoid deduplication
+      const largeTextArray = Array(100).fill(0).map((_, i) => `test${i}`);
       mockDeepLClient.translateBatch
-        .mockResolvedValueOnce(Array(50).fill({ text: 'traducido' }))
-        .mockResolvedValueOnce(Array(50).fill({ text: 'traducido' }));
+        .mockResolvedValueOnce(Array(50).fill(0).map((_, i) => ({ text: `traducido${i}` })))
+        .mockResolvedValueOnce(Array(50).fill(0).map((_, i) => ({ text: `traducido${i + 50}` })));
 
       await translationService.translateBatch(largeTextArray, {
         targetLang: 'es',
       });
 
-      // Should split into 2 batches of 50
+      // Should split into 2 batches of 50 (100 unique texts)
       expect(mockDeepLClient.translateBatch).toHaveBeenCalledTimes(2);
     });
 
@@ -389,6 +390,35 @@ describe('TranslationService', () => {
         expect(results[i]?.text).toBe(`Text${i}_translated`);
       }
     });
+
+    it('should handle duplicate texts correctly (BUG #2)', async () => {
+      // This test demonstrates the duplicate text bug
+      // When the same text appears multiple times, all occurrences should get translations
+      mockDeepLClient.translateBatch.mockResolvedValue([
+        { text: 'Hola' },     // Translation for "Hello"
+        { text: 'Mundo' },    // Translation for "World"
+      ]);
+
+      // Input has "Hello" twice - both should be translated
+      const results = await translationService.translateBatch(
+        ['Hello', 'Hello', 'World'],  // "Hello" appears twice
+        { targetLang: 'es' }
+      );
+
+      // Should have 3 results (not 2!)
+      expect(results).toHaveLength(3);
+
+      // Both "Hello" instances should have translations
+      expect(results[0]?.text).toBe('Hola');
+      expect(results[1]?.text).toBe('Hola');  // Second "Hello" should also be translated
+      expect(results[2]?.text).toBe('Mundo');
+
+      // Verify API was called with deduplicated texts (only unique texts sent)
+      expect(mockDeepLClient.translateBatch).toHaveBeenCalledWith(
+        ['Hello', 'World'],  // Deduplicated!
+        expect.any(Object)
+      );
+    });
   });
 
   describe('translateToMultiple()', () => {