Fix XLIFF backend encoding and structure issues

- Fix UTF-16/UTF-8 encoding mismatch by using MemoryStream instead of StringWriter
- Always write target-language attribute to preserve bilingual structure
- Always write both source (key) and target (value) elements
- Exclude .lrm backup directory from file discovery
- Fix reader to always prefer target element value

Author: nickprotop

LocalizationManager.Core/Backends/Xliff/XliffResourceDiscovery.cs

@@ -38,9 +38,11 @@ public List<LanguageInfo> DiscoverLanguages(string searchPath)
 
         var languageMap = new Dictionary<string, LanguageInfo>(StringComparer.OrdinalIgnoreCase);
 
-        // Find all XLIFF files
+        // Find all XLIFF files, excluding backup/metadata directories
         var xliffFiles = Directory.GetFiles(searchPath, "*.xliff", SearchOption.AllDirectories)
             .Concat(Directory.GetFiles(searchPath, "*.xlf", SearchOption.AllDirectories))
+            .Where(f => !f.Contains($"{Path.DirectorySeparatorChar}.lrm{Path.DirectorySeparatorChar}"))
+            .Where(f => !f.Contains($"{Path.AltDirectorySeparatorChar}.lrm{Path.AltDirectorySeparatorChar}"))
             .ToList();
 
         foreach (var filePath in xliffFiles)
@@ -302,9 +304,15 @@ public XliffDiscoveryResult DiscoverConfiguration(string path)
     {
         var result = new XliffDiscoveryResult();
 
-        // Find XLIFF files
-        var xliffFiles = Directory.GetFiles(path, "*.xliff", SearchOption.AllDirectories).ToList();
-        var xlfFiles = Directory.GetFiles(path, "*.xlf", SearchOption.AllDirectories).ToList();
+        // Find XLIFF files, excluding backup/metadata directories
+        var xliffFiles = Directory.GetFiles(path, "*.xliff", SearchOption.AllDirectories)
+            .Where(f => !f.Contains($"{Path.DirectorySeparatorChar}.lrm{Path.DirectorySeparatorChar}"))
+            .Where(f => !f.Contains($"{Path.AltDirectorySeparatorChar}.lrm{Path.AltDirectorySeparatorChar}"))
+            .ToList();
+        var xlfFiles = Directory.GetFiles(path, "*.xlf", SearchOption.AllDirectories)
+            .Where(f => !f.Contains($"{Path.DirectorySeparatorChar}.lrm{Path.DirectorySeparatorChar}"))
+            .Where(f => !f.Contains($"{Path.AltDirectorySeparatorChar}.lrm{Path.AltDirectorySeparatorChar}"))
+            .ToList();
 
         result.FileExtension = xliffFiles.Count >= xlfFiles.Count ? ".xliff" : ".xlf";
 

LocalizationManager.Core/Backends/Xliff/XliffResourceReader.cs

@@ -188,9 +188,9 @@ private List<ResourceEntry> ParseXliff12(XDocument doc, LanguageInfo metadata)
         // Get state for translation status
         var state = unit.Element(ns + "target")?.Attribute("state")?.Value;
 
-        // For default/source language, return source value
-        // For translation languages, return target with fallback to source
-        var value = metadata.IsDefault ? (source ?? "") : (target ?? source ?? "");
+        // Always prefer target value (which contains the localized text)
+        // Fall back to source if target is not present
+        var value = target ?? source ?? "";
 
         return new ResourceEntry
         {
@@ -220,8 +220,8 @@ private List<ResourceEntry> ParseXliff12(XDocument doc, LanguageInfo metadata)
             var source = unit.Element(ns + "source")?.Value;
             var target = unit.Element(ns + "target")?.Value;
 
-            // For default/source language, use source value; for translations, use target
-            var pluralValue = metadata.IsDefault ? source : (target ?? source);
+            // Always prefer target value (which contains the localized text)
+            var pluralValue = target ?? source;
 
             if (!string.IsNullOrEmpty(pluralId) && pluralValue != null)
             {
@@ -314,8 +314,8 @@ private List<ResourceEntry> ParseXliff20(XDocument doc, LanguageInfo metadata)
 
             if (directSource != null || directTarget != null)
             {
-                // For default/source language, return source value
-                var directValue = metadata.IsDefault ? (directSource ?? "") : (directTarget ?? directSource ?? "");
+                // Always prefer target value (which contains the localized text)
+                var directValue = directTarget ?? directSource ?? "";
                 return new ResourceEntry
                 {
                     Key = id,
@@ -331,8 +331,8 @@ private List<ResourceEntry> ParseXliff20(XDocument doc, LanguageInfo metadata)
         {
             var target = segment.Element(ns + "target")?.Value;
             var source = segment.Element(ns + "source")?.Value;
-            // For default/source language, return source value
-            values.Add(metadata.IsDefault ? (source ?? "") : (target ?? source ?? ""));
+            // Always prefer target value (which contains the localized text)
+            values.Add(target ?? source ?? "");
         }
         var value = string.Join("", values);
 

LocalizationManager.Core/Backends/Xliff/XliffResourceWriter.cs

@@ -117,20 +117,24 @@ public string SerializeToString(ResourceFile file)
             ? CreateXliff20Document(file)
             : CreateXliff12Document(file);
 
+        // Use UTF-8 without BOM to avoid double-BOM issues when file is rewritten
+        var utf8NoBom = new UTF8Encoding(false);
         var settings = new XmlWriterSettings
         {
             Indent = true,
             IndentChars = "  ",
-            Encoding = Encoding.UTF8,
+            Encoding = utf8NoBom,
             OmitXmlDeclaration = false
         };
 
-        using var sw = new StringWriter();
-        using (var writer = XmlWriter.Create(sw, settings))
+        // Use MemoryStream instead of StringWriter to properly handle UTF-8 encoding
+        // StringWriter always reports UTF-16 encoding regardless of XmlWriterSettings
+        using var ms = new MemoryStream();
+        using (var writer = XmlWriter.Create(ms, settings))
         {
             doc.Save(writer);
-        } // XmlWriter is disposed and flushed here
-        return sw.ToString();
+        }
+        return utf8NoBom.GetString(ms.ToArray());
     }
 
     /// <summary>
@@ -140,17 +144,19 @@ private XDocument CreateXliff12Document(ResourceFile file)
     {
         var root = new XElement(Ns12 + "xliff",
             new XAttribute("version", "1.2"),
-            new XAttribute(XNamespace.Xmlns + "xsi", "http://www.w3.org/2001/XMLSchema-instance"),
             new XAttribute("xmlns", Ns12.NamespaceName));
 
+        // For XLIFF, we always use the language code for both source and target
+        // Even for default language files, we write target-language to preserve bilingual structure
         var sourceLanguage = file.Language.IsDefault ? file.Language.Code : "en";
-        var targetLanguage = file.Language.IsDefault ? "" : file.Language.Code;
+        var targetLanguage = file.Language.Code;
 
         var fileElement = new XElement(Ns12 + "file",
             new XAttribute("original", file.Language.BaseName ?? "resources"),
             new XAttribute("source-language", sourceLanguage),
             new XAttribute("datatype", "plaintext"));
 
+        // Always write target-language attribute to preserve bilingual structure
         if (!string.IsNullOrEmpty(targetLanguage))
         {
             fileElement.Add(new XAttribute("target-language", targetLanguage));
@@ -187,22 +193,17 @@ private XDocument CreateXliff12Document(ResourceFile file)
 
     /// <summary>
     /// Creates a trans-unit element for XLIFF 1.2.
+    /// Always creates both source and target elements to preserve bilingual structure.
     /// </summary>
     private XElement CreateTransUnit12(ResourceEntry entry, bool isDefault)
     {
         var unit = new XElement(Ns12 + "trans-unit",
             new XAttribute("id", entry.Key));
 
-        // Source is the key for default language, or include bilingual content
-        if (isDefault || _config.Bilingual)
-        {
-            unit.Add(new XElement(Ns12 + "source", entry.Value ?? ""));
-        }
-        else
-        {
-            unit.Add(new XElement(Ns12 + "source", entry.Key));
-            unit.Add(new XElement(Ns12 + "target", entry.Value ?? ""));
-        }
+        // Always write both source (key) and target (value) for proper bilingual structure
+        // Source contains the key identifier, target contains the translated value
+        unit.Add(new XElement(Ns12 + "source", entry.Key));
+        unit.Add(new XElement(Ns12 + "target", entry.Value ?? ""));
 
         if (!string.IsNullOrEmpty(entry.Comment))
         {
@@ -272,6 +273,7 @@ private XDocument CreateXliff20Document(ResourceFile file)
 
     /// <summary>
     /// Creates a unit element for XLIFF 2.0.
+    /// Always creates both source and target elements to preserve bilingual structure.
     /// </summary>
     private XElement CreateUnit20(ResourceEntry entry, bool isDefault)
     {
@@ -299,18 +301,10 @@ private XElement CreateUnit20(ResourceEntry entry, bool isDefault)
         }
         else
         {
-            var segment = new XElement(Ns20 + "segment");
-
-            if (isDefault)
-            {
-                segment.Add(new XElement(Ns20 + "source", entry.Value ?? ""));
-            }
-            else
-            {
-                segment.Add(new XElement(Ns20 + "source", entry.Key));
-                segment.Add(new XElement(Ns20 + "target", entry.Value ?? ""));
-            }
-
+            // Always write both source (key) and target (value) for proper bilingual structure
+            var segment = new XElement(Ns20 + "segment",
+                new XElement(Ns20 + "source", entry.Key),
+                new XElement(Ns20 + "target", entry.Value ?? ""));
             unit.Add(segment);
         }