fix: fix template export generating corrupted Excel files

- Change SharedString conversion to use inlineStr format with <is><t> structure
- Add SetCellType method to properly handle cell types (inlineStr for strings, remove t attr for numbers)
- Fix XML element order per ECMA-376 spec (autoFilter before mergeCells/phoneticPr)
- Clean duplicate xmlns declarations from phoneticPr, conditionalFormatting, autoFilter
- Remove empty <v></v> tags that cause invalid XML
- Support <is><t> structure in value node lookup

Fixes template SaveAs generating files that Excel cannot open

Author: A-nony-mous

src/MiniExcel.Core/OpenXml/Templates/OpenXmlTemplate.Impl.cs

@@ -299,6 +299,15 @@ private async Task WriteSheetXmlAsync(Stream outputFileStream, XmlDocument doc,
             phoneticPr.ParentNode.RemoveChild(phoneticPr);
         }
 
+        // Extract autoFilter - must be written before mergeCells and phoneticPr per ECMA-376
+        var autoFilter = doc.SelectSingleNode("/x:worksheet/x:autoFilter", Ns);
+        var autoFilterXml = string.Empty;
+        if (autoFilter is not null)
+        {
+            autoFilterXml = autoFilter.OuterXml;
+            autoFilter.ParentNode.RemoveChild(autoFilter);
+        }
+
         var contents = doc.InnerXml.Split(new[] { $"<{prefix}sheetData>{{{{{{{{{{{{split}}}}}}}}}}}}</{prefix}sheetData>" }, StringSplitOptions.None);
 
         using var writer = new StreamWriter(outputFileStream, Encoding.UTF8);
@@ -524,6 +533,19 @@ await writer.WriteAsync($"</{prefix}sheetData>"
 #endif
         ).ConfigureAwait(false);
 
+        // ECMA-376 element order: sheetData → autoFilter → mergeCells → phoneticPr → conditionalFormatting
+        
+        // 1. autoFilter (must come before mergeCells)
+        if (!string.IsNullOrEmpty(autoFilterXml))
+        {
+            await writer.WriteAsync(CleanXml(autoFilterXml, endPrefix)
+#if NET7_0_OR_GREATER
+                    .AsMemory(), cancellationToken
+#endif
+            ).ConfigureAwait(false);
+        }
+
+        // 2. mergeCells
         if (_newXMergeCellInfos.Count != 0)
         {
             await writer.WriteAsync($"<{prefix}mergeCells count=\"{_newXMergeCellInfos.Count}\">"
@@ -546,18 +568,20 @@ await writer.WriteLineAsync($"</{prefix}mergeCells>"
             ).ConfigureAwait(false);
         }
 
+        // 3. phoneticPr
         if (!string.IsNullOrEmpty(phoneticPrXml))
         {
-            await writer.WriteAsync(phoneticPrXml
+            await writer.WriteAsync(CleanXml(phoneticPrXml, endPrefix)
 #if NET7_0_OR_GREATER
                     .AsMemory(), cancellationToken
 #endif
             ).ConfigureAwait(false);
         }
 
+        // 4. conditionalFormatting
         if (newConditionalFormatRanges.Count != 0)
         {
-            await writer.WriteAsync(string.Join(string.Empty, newConditionalFormatRanges.Select(cf => cf.Node.OuterXml))
+            await writer.WriteAsync(CleanXml(string.Join(string.Empty, newConditionalFormatRanges.Select(cf => cf.Node.OuterXml)), endPrefix)
 #if NET7_0_OR_GREATER
                     .AsMemory(), cancellationToken
 #endif
@@ -762,6 +786,10 @@ private async Task<GenerateCellValuesContext> GenerateCellValuesAsync(GenerateCe
 
                 substXmlRow = rowXml.ToString();
                 substXmlRow = TemplateRegex.Replace(substXmlRow, MatchDelegate);
+                
+                // Cleanup empty <v> tags which defaults to invalid XML
+                substXmlRow = Regex.Replace(substXmlRow, @"<v>\s*</v>", "");
+                substXmlRow = Regex.Replace(substXmlRow, @"<x:v>\s*</x:v>", ""); 
             }
 
             rowXml.Clear();
@@ -794,9 +822,13 @@ private async Task<GenerateCellValuesContext> GenerateCellValuesAsync(GenerateCe
             var mergeBaseRowIndex = newRowIndex;
             newRowIndex += rowInfo.IEnumerableMercell?.Height ?? 1;
 
+            // Replace {{$rowindex}} in the already-built substXmlRow
+            rowXml.Replace("{{$rowindex}}", mergeBaseRowIndex.ToString());
+
             // replace formulas
             ProcessFormulas(rowXml, newRowIndex);
-            await writer.WriteAsync(CleanXml(rowXml, endPrefix).ToString()
+            var finalXml = CleanXml(rowXml, endPrefix).ToString();
+            await writer.WriteAsync(finalXml
 #if NET7_0_OR_GREATER
                 .AsMemory(), cancellationToken
 #endif
@@ -1040,7 +1072,8 @@ private void ProcessFormulas(StringBuilder rowXml, int rowIndex)
     private static string CleanXml(string xml, string endPrefix) => CleanXml(new StringBuilder(xml), endPrefix).ToString();
     private static StringBuilder CleanXml(StringBuilder xml, string endPrefix) => xml
         .Replace("xmlns:x14ac=\"http://schemas.microsoft.com/office/spreadsheetml/2009/9/ac\"", "")
-        .Replace($"xmlns{endPrefix}=\"http://schemas.openxmlformats.org/spreadsheetml/2006/main\"", "");
+        .Replace($"xmlns{endPrefix}=\"http://schemas.openxmlformats.org/spreadsheetml/2006/main\"", "")
+        .Replace("xmlns=\"http://schemas.openxmlformats.org/spreadsheetml/2006/main\"", "");
 
     private static void ReplaceSharedStringsToStr(IDictionary<int, string> sharedStrings, XmlNodeList rows)
     {
@@ -1061,10 +1094,67 @@ private static void ReplaceSharedStringsToStr(IDictionary<int, string> sharedStr
                 if (sharedStrings is null || !sharedStrings.TryGetValue(int.Parse(v.InnerText), out var shared))
                     continue;
 
-                // change type = str and replace its value
-                //TODO: remove sharedstring?
-                v.InnerText = shared;
-                c.SetAttribute("t", "str");
+                // change type = inlineStr and replace its value
+                c.RemoveChild(v);
+                var isNode = c.OwnerDocument.CreateElement("is", Schemas.SpreadsheetmlXmlns);
+                var tNode = c.OwnerDocument.CreateElement("t", Schemas.SpreadsheetmlXmlns);
+                tNode.InnerText = shared;
+                isNode.AppendChild(tNode);
+                c.AppendChild(isNode);
+
+                c.RemoveAttribute("t");
+                c.SetAttribute("t", "inlineStr");
+            }
+        }
+    }
+
+    private static void SetCellType(XmlElement c, string type)
+    {
+        if (type == "str") type = "inlineStr"; // Force inlineStr for strings
+
+        if (type == "inlineStr")
+        {
+            // Ensure <is><t>...</t></is>
+            c.SetAttribute("t", "inlineStr");
+            var v = c.SelectSingleNode("x:v", Ns);
+            if (v != null)
+            {
+                var text = v.InnerText;
+                c.RemoveChild(v);
+                var isNode = c.OwnerDocument.CreateElement("is", Schemas.SpreadsheetmlXmlns);
+                var tNode = c.OwnerDocument.CreateElement("t", Schemas.SpreadsheetmlXmlns);
+                tNode.InnerText = text;
+                isNode.AppendChild(tNode);
+                c.AppendChild(isNode);
+            }
+            else if (c.SelectSingleNode("x:is", Ns) == null)
+            {
+                // Create empty <is><t></t></is> if neither <v> nor <is> exists
+                var isNode = c.OwnerDocument.CreateElement("is", Schemas.SpreadsheetmlXmlns);
+                var tNode = c.OwnerDocument.CreateElement("t", Schemas.SpreadsheetmlXmlns);
+                isNode.AppendChild(tNode);
+                c.AppendChild(isNode);
+            }
+        }
+        else
+        {
+            // Ensure <v>...</v>
+            // For numbers/booleans, we remove 't' attribute to let it be default (number) 
+            // or we could set it to 'n' explicitly, but removing is safer for general number types
+            if (type == "b")
+                 c.SetAttribute("t", "b");
+            else
+                 c.RemoveAttribute("t"); 
+
+            var isNode = c.SelectSingleNode("x:is", Ns);
+            if (isNode != null)
+            {
+                var tNode = isNode.SelectSingleNode("x:t", Ns);
+                var text = tNode?.InnerText;
+                c.RemoveChild(isNode);
+                var v = c.OwnerDocument.CreateElement("v", Schemas.SpreadsheetmlXmlns);
+                v.InnerText = text;
+                c.AppendChild(v);
             }
         }
     }
@@ -1117,7 +1207,7 @@ private void UpdateDimensionAndGetRowsInfo(IDictionary<string, object?> inputMap
                     c.SetAttribute("r", $"{StringHelper.GetLetters(r)}{{{{$rowindex}}}}");
                 }
 
-                var v = c.SelectSingleNode("x:v", Ns);
+                var v = c.SelectSingleNode("x:v", Ns) ?? c.SelectSingleNode("x:is/x:t", Ns);
                 if (v?.InnerText is null)
                     continue;
 
@@ -1240,19 +1330,19 @@ private void UpdateDimensionAndGetRowsInfo(IDictionary<string, object?> inputMap
 
                         if (isMultiMatch)
                         {
-                            c.SetAttribute("t", "str");
+                            SetCellType(c, "str");
                         }
                         else if (TypeHelper.IsNumericType(type) && !type.IsEnum)
                         {
-                            c.SetAttribute("t", "n");
+                            SetCellType(c, "n");
                         }
                         else if (Type.GetTypeCode(type) == TypeCode.Boolean)
                         {
-                            c.SetAttribute("t", "b");
+                            SetCellType(c, "b");
                         }
                         else if (Type.GetTypeCode(type) == TypeCode.DateTime)
                         {
-                            c.SetAttribute("t", "str");
+                            SetCellType(c, "str");
                         }
 
                         break;
@@ -1292,36 +1382,36 @@ private void UpdateDimensionAndGetRowsInfo(IDictionary<string, object?> inputMap
 
                         if (isMultiMatch)
                         {
-                            c.SetAttribute("t", "str");
+                            SetCellType(c, "str");
                         }
                         else if (TypeHelper.IsNumericType(type) && !type.IsEnum)
                         {
-                            c.SetAttribute("t", "n");
+                            SetCellType(c, "n");
                         }
                         else if (Type.GetTypeCode(type) == TypeCode.Boolean)
                         {
-                            c.SetAttribute("t", "b");
+                            SetCellType(c, "b");
                         }
                         else if (Type.GetTypeCode(type) == TypeCode.DateTime)
                         {
-                            c.SetAttribute("t", "str");
+                            SetCellType(c, "str");
                         }
                     }
                     else
                     {
                         var cellValueStr = cellValue?.ToString(); // value did encodexml, so don't duplicate encode value (https://gitee.com/dotnetchina/MiniExcel/issues/I4DQUN)
                         if (isMultiMatch || cellValue is string) // if matchs count over 1 need to set type=str (https://user-images.githubusercontent.com/12729184/114530109-39d46d00-9c7d-11eb-8f6b-52ad8600aca3.png)
                         {
-                            c.SetAttribute("t", "str");
+                            SetCellType(c, "str");
                         }
                         else if (decimal.TryParse(cellValueStr, out var outV))
                         {
-                            c.SetAttribute("t", "n");
+                            SetCellType(c, "n");
                             cellValueStr = outV.ToString(CultureInfo.InvariantCulture);
                         }
                         else if (cellValue is bool b)
                         {
-                            c.SetAttribute("t", "b");
+                            SetCellType(c, "b");
                             cellValueStr = b ? "1" : "0";
                         }
                         else if (cellValue is DateTime timestamp)
@@ -1330,6 +1420,12 @@ private void UpdateDimensionAndGetRowsInfo(IDictionary<string, object?> inputMap
                             cellValueStr = timestamp.ToString("yyyy-MM-dd HH:mm:ss");
                         }
 
+                        if (string.IsNullOrEmpty(cellValueStr) && string.IsNullOrEmpty(c.GetAttribute("t")))
+                        {
+                            SetCellType(c, "str");
+                            v = c.SelectSingleNode("x:v", Ns) ?? c.SelectSingleNode("x:is/x:t", Ns);
+                        }
+
                         v.InnerText = v.InnerText.Replace($"{{{{{propNames[0]}}}}}", cellValueStr); //TODO: auto check type and set value
                     }
                 }
@@ -1396,4 +1492,4 @@ private static bool EvaluateStatement(object tagValue, string comparisonOperator
             _ => false
         };
     }
-}
+}