From 4182d162d4b1f4d061d7422adcf51589d48bc266 Mon Sep 17 00:00:00 2001
From: Victor Irzak <victor.irzak@zomp.com>
Date: Sat, 10 Oct 2026 14:30:23 -0400
Subject: [PATCH 1/3] Add OpenXmlCellValue for per-cell formulas and styles on
 export

Wrapping a value sets a formula, number format or font color for that
cell alone. Cell formats now share one cache with column formats, which
also gives the minimal style builder the numFmt offset it lacked when
inserting into an existing workbook.
---
 .../Constants/WorksheetXml.cs                 |  10 ++
 .../Models/OpenXmlCellValue.cs                |  30 ++++
 .../Builder/DefaultSheetStyleBuilder.cs       | 155 ++++++++++-------
 .../Builder/MinimalSheetStyleBuilder.cs       |  64 +++----
 .../Styles/Builder/SheetStyleBuildContext.cs  |   7 +-
 .../Styles/Builder/SheetStyleBuilderBase.cs   |  67 +++++++-
 .../Styles/Builder/SheetStyleFormatsCache.cs  |  80 +++++++--
 .../Writer/OpenXmlWriter.XmlGeneration.cs     |   4 +-
 src/MiniExcel.OpenXml/Writer/OpenXmlWriter.cs |  91 ++++++++--
 .../CellValues/OpenXmlCellValueAsyncTests.cs  | 156 ++++++++++++++++++
 .../CellValues/OpenXmlCellValueTests.cs       |  31 ++++
 11 files changed, 566 insertions(+), 129 deletions(-)
 create mode 100644 src/MiniExcel.OpenXml/Models/OpenXmlCellValue.cs
 create mode 100644 tests/MiniExcel.OpenXml.Tests/CellValues/OpenXmlCellValueAsyncTests.cs
 create mode 100644 tests/MiniExcel.OpenXml.Tests/CellValues/OpenXmlCellValueTests.cs

diff --git a/src/MiniExcel.OpenXml/Constants/WorksheetXml.cs b/src/MiniExcel.OpenXml/Constants/WorksheetXml.cs
index d5f14f9e..b20f0fab 100644
--- a/src/MiniExcel.OpenXml/Constants/WorksheetXml.cs
+++ b/src/MiniExcel.OpenXml/Constants/WorksheetXml.cs
@@ -67,6 +67,16 @@ internal static string Cell(string cellReference, string? cellType, string style
         };
     }
 
+    /// <summary>
+    /// A formula cell, with its cached result when <paramref name="cachedValue"/> is not null.
+    /// </summary>
+    internal static string FormulaCell(string cellReference, string? cellType, string styleIndex, string formula, string? cachedValue)
+    {
+        var type = cachedValue is null ? "" : $" t=\"{cellType}\"";
+        var value = cachedValue is null ? "" : $"<x:v>{XmlHelper.EncodeXml(cachedValue)}</x:v>";
+        return $"""<x:c r="{cellReference}"{type} s="{styleIndex}"><x:f>{XmlHelper.EncodeXml(formula)}</x:f>{value}</x:c>""";
+    }
+
     internal static string Autofilter(string dimensionRef) => $"<x:autoFilter ref=\"{dimensionRef}\" />";
     internal static string Drawing(int sheetIndex) => $"<x:drawing r:id=\"rDrawing{sheetIndex}\" />";
 }
diff --git a/src/MiniExcel.OpenXml/Models/OpenXmlCellValue.cs b/src/MiniExcel.OpenXml/Models/OpenXmlCellValue.cs
new file mode 100644
index 00000000..0ca6d116
--- /dev/null
+++ b/src/MiniExcel.OpenXml/Models/OpenXmlCellValue.cs
@@ -0,0 +1,30 @@
+using System.Drawing;
+
+namespace MiniExcelLib.OpenXml.Models;
+
+/// <summary>
+/// A value to export together with a formula or style of its own, overriding the column's settings for that cell.
+/// </summary>
+/// <param name="value">The value written to the cell. When <see cref="Formula"/> is set, it is the cached result of the formula.</param>
+public sealed class OpenXmlCellValue(object? value)
+{
+    /// <summary>
+    /// The value written to the cell, or the cached result when <see cref="Formula"/> is set.
+    /// </summary>
+    public object? Value { get; } = value;
+
+    /// <summary>
+    /// A formula for the cell, without the leading equals sign.
+    /// </summary>
+    public string? Formula { get; set; }
+
+    /// <summary>
+    /// A number format for the cell, replacing the column's format.
+    /// </summary>
+    public string? NumberFormat { get; set; }
+
+    /// <summary>
+    /// The font color of the cell.
+    /// </summary>
+    public Color? FontColor { get; set; }
+}
diff --git a/src/MiniExcel.OpenXml/Styles/Builder/DefaultSheetStyleBuilder.cs b/src/MiniExcel.OpenXml/Styles/Builder/DefaultSheetStyleBuilder.cs
index aa6f6073..a93e1657 100644
--- a/src/MiniExcel.OpenXml/Styles/Builder/DefaultSheetStyleBuilder.cs
+++ b/src/MiniExcel.OpenXml/Styles/Builder/DefaultSheetStyleBuilder.cs
@@ -20,6 +20,20 @@ internal partial class DefaultSheetStyleBuilder(SheetStyleBuilderContext context
 
     private readonly OpenXmlStyleOptions _styleOptions = styleOptions;
 
+    private string CellHorizontalAlignment => _styleOptions.HorizontalAlignment switch
+    {
+        HorizontalCellAlignment.Center => "center",
+        HorizontalCellAlignment.Right => "right",
+        _ => "general"
+    };
+
+    private string CellVerticalAlignment => _styleOptions.VerticalAlignment switch
+    {
+        VerticalCellAlignment.Top => "top",
+        VerticalCellAlignment.Center => "center",
+        _ => "bottom"
+    };
+
     protected internal override SheetStyleElementInfos GetGeneratedElementInfos()
     {
         return GeneratedElementInfos;
@@ -28,20 +42,7 @@ protected internal override SheetStyleElementInfos GetGeneratedElementInfos()
     [CreateSyncVersion]
     protected override async Task GenerateNumFmtAsync()
     {
-        const int numFmtIndex = 166;
-        var index = 0;
-        foreach (var map in Context.SheetStyleFormatsCache.FormatMappings)
-        {
-            index++;
-
-            /*
-             * <x:numFmt numFmtId="{numFmtIndex + i}" formatCode="{x.Format}"
-             */
-            await NewWriter.WriteStartElementAsync(OldReader.Prefix, "numFmt", OldReader.NamespaceURI).ConfigureAwait(false);
-            await NewWriter.WriteAttributeStringAsync(null, "numFmtId", null, (numFmtIndex + index + Context.OldElementInfos.NumFmtCount).ToString()).ConfigureAwait(false);
-            await NewWriter.WriteAttributeStringAsync(null, "formatCode", null, map.Format).ConfigureAwait(false);
-            await NewWriter.WriteEndElementAsync().ConfigureAwait(false);
-        }
+        await GenerateCustomNumFmtsAsync().ConfigureAwait(false);
     }
 
     [CreateSyncVersion]
@@ -100,6 +101,8 @@ protected override async Task GenerateFontAsync()
         await NewWriter.WriteAttributeStringAsync(null, "val", null, "2").ConfigureAwait(false);
         await NewWriter.WriteEndElementAsync().ConfigureAwait(false);
         await NewWriter.WriteEndElementAsync().ConfigureAwait(false);
+
+        await GenerateCustomFontsAsync().ConfigureAwait(false);
     }
 
     [CreateSyncVersion]
@@ -344,20 +347,9 @@ protected override async Task GenerateCellXfAsync()
             _ => "bottom"
         };
 
-        var cellHorizontalAlignment = _styleOptions.HorizontalAlignment switch
-        {
-            HorizontalCellAlignment.Center => "center",
-            HorizontalCellAlignment.Right => "right",
-            _ => "general"
-        };
+        var cellHorizontalAlignment = CellHorizontalAlignment;
+        var cellVerticalAlignment = CellVerticalAlignment;
 
-        var cellVerticalAlignment = _styleOptions.VerticalAlignment switch
-        {
-            VerticalCellAlignment.Top => "top",
-            VerticalCellAlignment.Center => "center",
-            _ => "bottom"
-        };
-        
         /* Empty style is required because Excel always considers the first one to be the default and ignores all its  properties
          * <x:xf numFmtId="0" fontId="0" fillId="0" borderId="0" xfId="0" />
          * */
@@ -529,42 +521,77 @@ protected override async Task GenerateCellXfAsync()
         await NewWriter.WriteEndElementAsync().ConfigureAwait(false);
         await NewWriter.WriteEndElementAsync().ConfigureAwait(false);
         
-        const int numFmtIndex = 166;
-        for (var i = 1; i <= Context.CustomFormatCount; i++)
-        {
-            /*
-             * <x:xf numFmtId=""{numFmtIndex + i}"" fontId=""0"" fillId=""0"" borderId=""1"" xfId=""0"" applyNumberFormat=""1"" applyFill=""1"" applyBorder=""1"" applyAlignment=""1"" applyProtection=""1"">
-             *     <x:alignment horizontal=""general"" vertical=""bottom"" textRotation=""0"" wrapText=""0"" indent=""0"" relativeIndent=""0"" justifyLastLine=""0"" shrinkToFit=""0"" readingOrder=""0"" />
-             *     <x:protection locked=""1"" hidden=""0"" />
-             * </x:xf>
-             */
-            await NewWriter.WriteStartElementAsync(OldReader.Prefix, "xf", OldReader.NamespaceURI).ConfigureAwait(false);
-            await NewWriter.WriteAttributeStringAsync(null, "numFmtId", null, (numFmtIndex + i + Context.OldElementInfos.NumFmtCount).ToString()).ConfigureAwait(false);
-            await NewWriter.WriteAttributeStringAsync(null, "fontId", null, $"{Context.OldElementInfos.FontCount}").ConfigureAwait(false);
-            await NewWriter.WriteAttributeStringAsync(null, "fillId", null, $"{Context.OldElementInfos.FillCount}").ConfigureAwait(false);
-            await NewWriter.WriteAttributeStringAsync(null, "borderId", null, $"{Context.OldElementInfos.BorderCount + 1}").ConfigureAwait(false);
-            await NewWriter.WriteAttributeStringAsync(null, "xfId", null, "0").ConfigureAwait(false);
-            await NewWriter.WriteAttributeStringAsync(null, "applyNumberFormat", null, "1").ConfigureAwait(false);
-            await NewWriter.WriteAttributeStringAsync(null, "applyFill", null, "1").ConfigureAwait(false);
-            await NewWriter.WriteAttributeStringAsync(null, "applyBorder", null, "1").ConfigureAwait(false);
-            await NewWriter.WriteAttributeStringAsync(null, "applyAlignment", null, "1").ConfigureAwait(false);
-            await NewWriter.WriteAttributeStringAsync(null, "applyProtection", null, "1").ConfigureAwait(false);
-            await NewWriter.WriteStartElementAsync(OldReader.Prefix, "alignment", OldReader.NamespaceURI).ConfigureAwait(false);
-            await NewWriter.WriteAttributeStringAsync(null, "horizontal", null, cellHorizontalAlignment).ConfigureAwait(false);
-            await NewWriter.WriteAttributeStringAsync(null, "vertical", null, cellVerticalAlignment).ConfigureAwait(false);
-            await NewWriter.WriteAttributeStringAsync(null, "textRotation", null, "0").ConfigureAwait(false);
-            await NewWriter.WriteAttributeStringAsync(null, "wrapText", null, "0").ConfigureAwait(false);
-            await NewWriter.WriteAttributeStringAsync(null, "indent", null, "0").ConfigureAwait(false);
-            await NewWriter.WriteAttributeStringAsync(null, "relativeIndent", null, "0").ConfigureAwait(false);
-            await NewWriter.WriteAttributeStringAsync(null, "justifyLastLine", null, "0").ConfigureAwait(false);
-            await NewWriter.WriteAttributeStringAsync(null, "shrinkToFit", null, "0").ConfigureAwait(false);
-            await NewWriter.WriteAttributeStringAsync(null, "readingOrder", null, "0").ConfigureAwait(false);
-            await NewWriter.WriteEndElementAsync().ConfigureAwait(false);
-            await NewWriter.WriteStartElementAsync(OldReader.Prefix, "protection", OldReader.NamespaceURI).ConfigureAwait(false);
-            await NewWriter.WriteAttributeStringAsync(null, "locked", null, "1").ConfigureAwait(false);
-            await NewWriter.WriteAttributeStringAsync(null, "hidden", null, "0").ConfigureAwait(false);
-            await NewWriter.WriteEndElementAsync().ConfigureAwait(false);
-            await NewWriter.WriteEndElementAsync().ConfigureAwait(false);
-        }
+        await GenerateCustomCellXfsAsync().ConfigureAwait(false);
+    }
+
+    [CreateSyncVersion]
+    protected override async Task GenerateCustomFontAsync(string argb)
+    {
+        /*
+         * <x:font>
+         *     <x:vertAlign val="baseline" />
+         *     <x:sz val="11" />
+         *     <x:color rgb="{argb}" />
+         *     <x:name val="Calibri" />
+         *     <x:family val="2" />
+         * </x:font>
+         */
+        await NewWriter.WriteStartElementAsync(OldReader.Prefix, "font", OldReader.NamespaceURI).ConfigureAwait(false);
+        await NewWriter.WriteStartElementAsync(OldReader.Prefix, "vertAlign", OldReader.NamespaceURI).ConfigureAwait(false);
+        await NewWriter.WriteAttributeStringAsync(null, "val", null, "baseline").ConfigureAwait(false);
+        await NewWriter.WriteEndElementAsync().ConfigureAwait(false);
+        await NewWriter.WriteStartElementAsync(OldReader.Prefix, "sz", OldReader.NamespaceURI).ConfigureAwait(false);
+        await NewWriter.WriteAttributeStringAsync(null, "val", null, "11").ConfigureAwait(false);
+        await NewWriter.WriteEndElementAsync().ConfigureAwait(false);
+        await NewWriter.WriteStartElementAsync(OldReader.Prefix, "color", OldReader.NamespaceURI).ConfigureAwait(false);
+        await NewWriter.WriteAttributeStringAsync(null, "rgb", null, argb).ConfigureAwait(false);
+        await NewWriter.WriteEndElementAsync().ConfigureAwait(false);
+        await NewWriter.WriteStartElementAsync(OldReader.Prefix, "name", OldReader.NamespaceURI).ConfigureAwait(false);
+        await NewWriter.WriteAttributeStringAsync(null, "val", null, "Calibri").ConfigureAwait(false);
+        await NewWriter.WriteEndElementAsync().ConfigureAwait(false);
+        await NewWriter.WriteStartElementAsync(OldReader.Prefix, "family", OldReader.NamespaceURI).ConfigureAwait(false);
+        await NewWriter.WriteAttributeStringAsync(null, "val", null, "2").ConfigureAwait(false);
+        await NewWriter.WriteEndElementAsync().ConfigureAwait(false);
+        await NewWriter.WriteEndElementAsync().ConfigureAwait(false);
+    }
+
+    [CreateSyncVersion]
+    protected override async Task GenerateCustomCellXfAsync(string numFmtId, string? fontId)
+    {
+        /*
+         * <x:xf numFmtId="{numFmtId}" fontId="{fontId}" fillId="0" borderId="1" xfId="0" applyNumberFormat="1" applyFill="1" applyBorder="1" applyAlignment="1" applyProtection="1">
+         *     <x:alignment horizontal="general" vertical="bottom" textRotation="0" wrapText="0" indent="0" relativeIndent="0" justifyLastLine="0" shrinkToFit="0" readingOrder="0" />
+         *     <x:protection locked="1" hidden="0" />
+         * </x:xf>
+         */
+        await NewWriter.WriteStartElementAsync(OldReader.Prefix, "xf", OldReader.NamespaceURI).ConfigureAwait(false);
+        await NewWriter.WriteAttributeStringAsync(null, "numFmtId", null, numFmtId).ConfigureAwait(false);
+        await NewWriter.WriteAttributeStringAsync(null, "fontId", null, fontId ?? $"{Context.OldElementInfos.FontCount}").ConfigureAwait(false);
+        await NewWriter.WriteAttributeStringAsync(null, "fillId", null, $"{Context.OldElementInfos.FillCount}").ConfigureAwait(false);
+        await NewWriter.WriteAttributeStringAsync(null, "borderId", null, $"{Context.OldElementInfos.BorderCount + 1}").ConfigureAwait(false);
+        await NewWriter.WriteAttributeStringAsync(null, "xfId", null, "0").ConfigureAwait(false);
+        await NewWriter.WriteAttributeStringAsync(null, "applyNumberFormat", null, "1").ConfigureAwait(false);
+        if (fontId is not null)
+            await NewWriter.WriteAttributeStringAsync(null, "applyFont", null, "1").ConfigureAwait(false);
+        await NewWriter.WriteAttributeStringAsync(null, "applyFill", null, "1").ConfigureAwait(false);
+        await NewWriter.WriteAttributeStringAsync(null, "applyBorder", null, "1").ConfigureAwait(false);
+        await NewWriter.WriteAttributeStringAsync(null, "applyAlignment", null, "1").ConfigureAwait(false);
+        await NewWriter.WriteAttributeStringAsync(null, "applyProtection", null, "1").ConfigureAwait(false);
+        await NewWriter.WriteStartElementAsync(OldReader.Prefix, "alignment", OldReader.NamespaceURI).ConfigureAwait(false);
+        await NewWriter.WriteAttributeStringAsync(null, "horizontal", null, CellHorizontalAlignment).ConfigureAwait(false);
+        await NewWriter.WriteAttributeStringAsync(null, "vertical", null, CellVerticalAlignment).ConfigureAwait(false);
+        await NewWriter.WriteAttributeStringAsync(null, "textRotation", null, "0").ConfigureAwait(false);
+        await NewWriter.WriteAttributeStringAsync(null, "wrapText", null, "0").ConfigureAwait(false);
+        await NewWriter.WriteAttributeStringAsync(null, "indent", null, "0").ConfigureAwait(false);
+        await NewWriter.WriteAttributeStringAsync(null, "relativeIndent", null, "0").ConfigureAwait(false);
+        await NewWriter.WriteAttributeStringAsync(null, "justifyLastLine", null, "0").ConfigureAwait(false);
+        await NewWriter.WriteAttributeStringAsync(null, "shrinkToFit", null, "0").ConfigureAwait(false);
+        await NewWriter.WriteAttributeStringAsync(null, "readingOrder", null, "0").ConfigureAwait(false);
+        await NewWriter.WriteEndElementAsync().ConfigureAwait(false);
+        await NewWriter.WriteStartElementAsync(OldReader.Prefix, "protection", OldReader.NamespaceURI).ConfigureAwait(false);
+        await NewWriter.WriteAttributeStringAsync(null, "locked", null, "1").ConfigureAwait(false);
+        await NewWriter.WriteAttributeStringAsync(null, "hidden", null, "0").ConfigureAwait(false);
+        await NewWriter.WriteEndElementAsync().ConfigureAwait(false);
+        await NewWriter.WriteEndElementAsync().ConfigureAwait(false);
     }
 }
diff --git a/src/MiniExcel.OpenXml/Styles/Builder/MinimalSheetStyleBuilder.cs b/src/MiniExcel.OpenXml/Styles/Builder/MinimalSheetStyleBuilder.cs
index 7afce315..41d77a07 100644
--- a/src/MiniExcel.OpenXml/Styles/Builder/MinimalSheetStyleBuilder.cs
+++ b/src/MiniExcel.OpenXml/Styles/Builder/MinimalSheetStyleBuilder.cs
@@ -20,20 +20,7 @@ protected internal override SheetStyleElementInfos GetGeneratedElementInfos()
     [CreateSyncVersion]
     protected override async Task GenerateNumFmtAsync()
     {
-        const int numFmtIndex = 166;
-        var index = 0;
-        foreach (var map in Context.SheetStyleFormatsCache.FormatMappings)
-        {
-            index++;
-
-            /*
-             * <x:numFmt numFmtId="{numFmtIndex + i}" formatCode="{item.Format}" />
-             */
-            await NewWriter.WriteStartElementAsync(OldReader.Prefix, "numFmt", OldReader.NamespaceURI).ConfigureAwait(false);
-            await NewWriter.WriteAttributeStringAsync(null, "numFmtId", null, (numFmtIndex + index + Context.OldElementInfos.NumFmtCount).ToString()).ConfigureAwait(false);
-            await NewWriter.WriteAttributeStringAsync(null, "formatCode", null, map.Format).ConfigureAwait(false);
-            await NewWriter.WriteEndElementAsync().ConfigureAwait(false);
-        }
+        await GenerateCustomNumFmtsAsync().ConfigureAwait(false);
     }
 
     [CreateSyncVersion]
@@ -44,6 +31,8 @@ protected override async Task GenerateFontAsync()
          */
         await NewWriter.WriteStartElementAsync(OldReader.Prefix, "font", OldReader.NamespaceURI).ConfigureAwait(false);
         await NewWriter.WriteEndElementAsync().ConfigureAwait(false);
+
+        await GenerateCustomFontsAsync().ConfigureAwait(false);
     }
 
     [CreateSyncVersion]
@@ -119,20 +108,37 @@ protected override async Task GenerateCellXfAsync()
         await NewWriter.WriteAttributeStringAsync(null, "applyNumberFormat", null, "1").ConfigureAwait(false);
         await NewWriter.WriteEndElementAsync().ConfigureAwait(false);
 
-        const int numFmtIndex = 166;
-        for (var i = 1; i <= Context.CustomFormatCount; i++)
-        {
-            /*
-             * <x:xf numFmtId="{numFmtIndex + i}" applyNumberFormat="1"
-             */
-            await NewWriter.WriteStartElementAsync(OldReader.Prefix, "xf", OldReader.NamespaceURI).ConfigureAwait(false);
-            await NewWriter.WriteAttributeStringAsync(null, "numFmtId", null, (numFmtIndex + i).ToString()).ConfigureAwait(false);
-            await NewWriter.WriteAttributeStringAsync(null, "fontId", null, "0").ConfigureAwait(false);
-            await NewWriter.WriteAttributeStringAsync(null, "fillId", null, "0").ConfigureAwait(false);
-            await NewWriter.WriteAttributeStringAsync(null, "borderId", null, "0").ConfigureAwait(false);
-            await NewWriter.WriteAttributeStringAsync(null, "xfId", null, "0").ConfigureAwait(false);
-            await NewWriter.WriteAttributeStringAsync(null, "applyNumberFormat", null, "1").ConfigureAwait(false);
-            await NewWriter.WriteEndElementAsync().ConfigureAwait(false);
-        }
+        await GenerateCustomCellXfsAsync().ConfigureAwait(false);
+    }
+
+    [CreateSyncVersion]
+    protected override async Task GenerateCustomFontAsync(string argb)
+    {
+        /*
+         * <x:font><x:color rgb="{argb}" /></x:font>
+         */
+        await NewWriter.WriteStartElementAsync(OldReader.Prefix, "font", OldReader.NamespaceURI).ConfigureAwait(false);
+        await NewWriter.WriteStartElementAsync(OldReader.Prefix, "color", OldReader.NamespaceURI).ConfigureAwait(false);
+        await NewWriter.WriteAttributeStringAsync(null, "rgb", null, argb).ConfigureAwait(false);
+        await NewWriter.WriteEndElementAsync().ConfigureAwait(false);
+        await NewWriter.WriteEndElementAsync().ConfigureAwait(false);
+    }
+
+    [CreateSyncVersion]
+    protected override async Task GenerateCustomCellXfAsync(string numFmtId, string? fontId)
+    {
+        /*
+         * <x:xf numFmtId="{numFmtId}" fontId="{fontId}" fillId="0" borderId="0" xfId="0" applyNumberFormat="1" applyFont="1" />
+         */
+        await NewWriter.WriteStartElementAsync(OldReader.Prefix, "xf", OldReader.NamespaceURI).ConfigureAwait(false);
+        await NewWriter.WriteAttributeStringAsync(null, "numFmtId", null, numFmtId).ConfigureAwait(false);
+        await NewWriter.WriteAttributeStringAsync(null, "fontId", null, fontId ?? "0").ConfigureAwait(false);
+        await NewWriter.WriteAttributeStringAsync(null, "fillId", null, "0").ConfigureAwait(false);
+        await NewWriter.WriteAttributeStringAsync(null, "borderId", null, "0").ConfigureAwait(false);
+        await NewWriter.WriteAttributeStringAsync(null, "xfId", null, "0").ConfigureAwait(false);
+        await NewWriter.WriteAttributeStringAsync(null, "applyNumberFormat", null, "1").ConfigureAwait(false);
+        if (fontId is not null)
+            await NewWriter.WriteAttributeStringAsync(null, "applyFont", null, "1").ConfigureAwait(false);
+        await NewWriter.WriteEndElementAsync().ConfigureAwait(false);
     }
 }
diff --git a/src/MiniExcel.OpenXml/Styles/Builder/SheetStyleBuildContext.cs b/src/MiniExcel.OpenXml/Styles/Builder/SheetStyleBuildContext.cs
index 35cd1826..00765c0a 100644
--- a/src/MiniExcel.OpenXml/Styles/Builder/SheetStyleBuildContext.cs
+++ b/src/MiniExcel.OpenXml/Styles/Builder/SheetStyleBuildContext.cs
@@ -28,7 +28,9 @@ internal sealed partial class SheetStyleBuilderContext(Dictionary<string, string
     public XmlWriter? NewXmlWriter { get; private set; }
     public SheetStyleElementInfos OldElementInfos { get; private set; } = null!;
     public SheetStyleElementInfos GeneratedElementInfos { get; private set; } = null!;
-    public int CustomFormatCount => SheetStyleFormatsCache.FormatMappingsCount;
+    public int CustomNumberFormatCount => SheetStyleFormatsCache.NumberFormats.Count;
+    public int CustomFontCount => SheetStyleFormatsCache.FontColors.Count;
+    public int CustomCellFormatCount => SheetStyleFormatsCache.CellFormats.Count;
 
     [CreateSyncVersion]
     public async Task CreateAsync(SheetStyleElementInfos generatedElementInfos, CancellationToken cancellationToken = default)
@@ -115,6 +117,9 @@ public void UpdateFormatIds(ICollection<MiniExcelColumnMapping> mappings)
     {
         SheetStyleFormatsCache.AddMappings(mappings);
     }
+
+    public int GetCellFormatIndex(string? numberFormat, int builtInNumberFormatId, System.Drawing.Color? fontColor)
+        => SheetStyleFormatsCache.GetCellFormatIndex(numberFormat, builtInNumberFormatId, fontColor);
     
     [CreateSyncVersion]
     public async Task FinalizeAndUpdateZipDictionaryAsync(CancellationToken cancellationToken = default)
diff --git a/src/MiniExcel.OpenXml/Styles/Builder/SheetStyleBuilderBase.cs b/src/MiniExcel.OpenXml/Styles/Builder/SheetStyleBuilderBase.cs
index 7984c02d..b4663253 100644
--- a/src/MiniExcel.OpenXml/Styles/Builder/SheetStyleBuilderBase.cs
+++ b/src/MiniExcel.OpenXml/Styles/Builder/SheetStyleBuilderBase.cs
@@ -106,12 +106,12 @@ protected virtual async Task WriteAttributesAsync(string element, CancellationTo
                     {
                         var value = element switch
                         {
-                            "numFmts" => (Context.OldElementInfos.NumFmtCount + Context.GeneratedElementInfos.NumFmtCount + Context.CustomFormatCount).ToString(),
-                            "fonts" => (Context.OldElementInfos.FontCount + Context.GeneratedElementInfos.FontCount).ToString(),
+                            "numFmts" => (Context.OldElementInfos.NumFmtCount + Context.GeneratedElementInfos.NumFmtCount + Context.CustomNumberFormatCount).ToString(),
+                            "fonts" => (Context.OldElementInfos.FontCount + Context.GeneratedElementInfos.FontCount + Context.CustomFontCount).ToString(),
                             "fills" => (Context.OldElementInfos.FillCount + Context.GeneratedElementInfos.FillCount).ToString(),
                             "borders" => (Context.OldElementInfos.BorderCount + Context.GeneratedElementInfos.BorderCount).ToString(),
                             "cellStyleXfs" => (Context.OldElementInfos.CellStyleXfCount + Context.GeneratedElementInfos.CellStyleXfCount).ToString(),
-                            "cellXfs" => (Context.OldElementInfos.CellXfCount + Context.GeneratedElementInfos.CellXfCount + Context.CustomFormatCount).ToString(),
+                            "cellXfs" => (Context.OldElementInfos.CellXfCount + Context.GeneratedElementInfos.CellXfCount + Context.CustomCellFormatCount).ToString(),
                             _ => OldReader.Value
                         };
                         await NewWriter.WriteStringAsync(value).ConfigureAwait(false);
@@ -198,7 +198,7 @@ protected virtual async Task GenerateElementBeforEndElementAsync()
     protected virtual async Task GenerateNumFmtsAsync()
     {
         await NewWriter.WriteStartElementAsync(OldReader.Prefix, "numFmts", OldReader.NamespaceURI).ConfigureAwait(false);
-        await NewWriter.WriteAttributeStringAsync(null, "count", null, (Context.OldElementInfos.NumFmtCount + Context.GeneratedElementInfos.NumFmtCount + Context.CustomFormatCount).ToString()).ConfigureAwait(false);
+        await NewWriter.WriteAttributeStringAsync(null, "count", null, (Context.OldElementInfos.NumFmtCount + Context.GeneratedElementInfos.NumFmtCount + Context.CustomNumberFormatCount).ToString()).ConfigureAwait(false);
         await GenerateNumFmtAsync().ConfigureAwait(false);
         await NewWriter.WriteFullEndElementAsync().ConfigureAwait(false);
 
@@ -215,7 +215,7 @@ protected virtual async Task GenerateNumFmtsAsync()
     protected virtual async Task GenerateFontsAsync()
     {
         await NewWriter.WriteStartElementAsync(OldReader.Prefix, "fonts", OldReader.NamespaceURI).ConfigureAwait(false);
-        await NewWriter.WriteAttributeStringAsync(null, "count", null, (Context.OldElementInfos.FontCount + Context.GeneratedElementInfos.FontCount).ToString()).ConfigureAwait(false);
+        await NewWriter.WriteAttributeStringAsync(null, "count", null, (Context.OldElementInfos.FontCount + Context.GeneratedElementInfos.FontCount + Context.CustomFontCount).ToString()).ConfigureAwait(false);
         await GenerateFontAsync().ConfigureAwait(false);
         await NewWriter.WriteFullEndElementAsync().ConfigureAwait(false);
 
@@ -283,11 +283,66 @@ protected virtual async Task GenerateCellStyleXfsAsync()
     protected virtual async Task GenerateCellXfsAsync()
     {
         await NewWriter.WriteStartElementAsync(OldReader.Prefix, "cellXfs", OldReader.NamespaceURI).ConfigureAwait(false);
-        await NewWriter.WriteAttributeStringAsync(null, "count", null, (Context.OldElementInfos.CellXfCount + Context.GeneratedElementInfos.CellXfCount + Context.CustomFormatCount).ToString()).ConfigureAwait(false);
+        await NewWriter.WriteAttributeStringAsync(null, "count", null, (Context.OldElementInfos.CellXfCount + Context.GeneratedElementInfos.CellXfCount + Context.CustomCellFormatCount).ToString()).ConfigureAwait(false);
         await GenerateCellXfAsync().ConfigureAwait(false);
         await NewWriter.WriteFullEndElementAsync().ConfigureAwait(false);
     }
 
     [CreateSyncVersion]
     protected abstract Task GenerateCellXfAsync();
+
+    // Custom number formats get numFmtIds from 167 upwards, after any the workbook already had
+    private string GetCustomNumberFormatId(int position) => (167 + position + Context.OldElementInfos.NumFmtCount).ToString();
+
+    [CreateSyncVersion]
+    protected async Task GenerateCustomNumFmtsAsync()
+    {
+        var numberFormats = Context.SheetStyleFormatsCache.NumberFormats;
+        for (var i = 0; i < numberFormats.Count; i++)
+        {
+            /*
+             * <x:numFmt numFmtId="{167 + i}" formatCode="{format}" />
+             */
+            await NewWriter.WriteStartElementAsync(OldReader.Prefix, "numFmt", OldReader.NamespaceURI).ConfigureAwait(false);
+            await NewWriter.WriteAttributeStringAsync(null, "numFmtId", null, GetCustomNumberFormatId(i)).ConfigureAwait(false);
+            await NewWriter.WriteAttributeStringAsync(null, "formatCode", null, numberFormats[i]).ConfigureAwait(false);
+            await NewWriter.WriteEndElementAsync().ConfigureAwait(false);
+        }
+    }
+
+    [CreateSyncVersion]
+    protected async Task GenerateCustomFontsAsync()
+    {
+        foreach (var color in Context.SheetStyleFormatsCache.FontColors)
+        {
+            await GenerateCustomFontAsync($"{color.A:X2}{color.R:X2}{color.G:X2}{color.B:X2}").ConfigureAwait(false);
+        }
+    }
+
+    /// <summary>
+    /// Writes a font element in the given ARGB color, otherwise like the builder's default font.
+    /// </summary>
+    [CreateSyncVersion]
+    protected abstract Task GenerateCustomFontAsync(string argb);
+
+    [CreateSyncVersion]
+    protected async Task GenerateCustomCellXfsAsync()
+    {
+        var firstCustomFontId = Context.OldElementInfos.FontCount + Context.GeneratedElementInfos.FontCount;
+        foreach (var format in Context.SheetStyleFormatsCache.CellFormats)
+        {
+            var numFmtId = format.CustomNumberFormat is { } position
+                ? GetCustomNumberFormatId(position)
+                : format.BuiltInNumberFormatId.ToString();
+            var fontId = format.FontColor is { } fontColor ? (firstCustomFontId + fontColor).ToString() : null;
+
+            await GenerateCustomCellXfAsync(numFmtId, fontId).ConfigureAwait(false);
+        }
+    }
+
+    /// <summary>
+    /// Writes an xf element for a regular cell with the given number format and, when not null, font.
+    /// </summary>
+    [CreateSyncVersion]
+    protected abstract Task GenerateCustomCellXfAsync(string numFmtId, string? fontId);
 }
\ No newline at end of file
diff --git a/src/MiniExcel.OpenXml/Styles/Builder/SheetStyleFormatsCache.cs b/src/MiniExcel.OpenXml/Styles/Builder/SheetStyleFormatsCache.cs
index 2feb550b..3ec55603 100644
--- a/src/MiniExcel.OpenXml/Styles/Builder/SheetStyleFormatsCache.cs
+++ b/src/MiniExcel.OpenXml/Styles/Builder/SheetStyleFormatsCache.cs
@@ -1,30 +1,82 @@
+using System.Drawing;
+// A cell format added on top of the builder's own. CustomNumberFormat and FontColor are positions in
+// NumberFormats and FontColors, or null; BuiltInNumberFormatId applies when there is no custom number format.
+using CustomCellFormat = (int? CustomNumberFormat, int BuiltInNumberFormatId, int? FontColor);
+
 namespace MiniExcelLib.OpenXml.Styles.Builder;
 
 // todo: find a way to make it compatible with SharedStringsDiskCache
 internal class SheetStyleFormatsCache
 {
-    private readonly Dictionary<string, int> _formatMappings = [];
-    private int _stylesCount;
-    
-    internal int FormatMappingsCount => _formatMappings.Count;
-    internal IEnumerable<(string Format, int FormatId)> FormatMappings => _formatMappings.Select(x => (x.Key, x.Value));
-    
+    private readonly Dictionary<string, int> _numberFormatIndexes = [];
+    private readonly List<string> _numberFormats = [];
+    private readonly Dictionary<int, int> _fontColorIndexes = [];
+    private readonly List<Color> _fontColors = [];
+    private readonly Dictionary<CustomCellFormat, int> _cellFormatIndexes = [];
+    private readonly List<CustomCellFormat> _cellFormats = [];
+    private int _firstCellFormatIndex;
+
+    internal IReadOnlyList<string> NumberFormats => _numberFormats;
+    internal IReadOnlyList<Color> FontColors => _fontColors;
+    internal IReadOnlyList<CustomCellFormat> CellFormats => _cellFormats;
+
     public void AddMappings(IEnumerable<MiniExcelColumnMapping?> mappings)
     {
         foreach (var mapping in mappings.Where(map => map is { ExcelIgnoreColumn: false }))
         {
             if (!string.IsNullOrWhiteSpace(mapping!.ExcelFormat) && new OpenXmlNumberFormatHelper(mapping.ExcelFormat).IsValid)
             {
-                if (!_formatMappings.TryGetValue(mapping.ExcelFormat, out var formatId))
-                {
-                    formatId = _stylesCount++;
-                    _formatMappings.Add(mapping.ExcelFormat, formatId);
-                }
+                mapping.SetFormatId(GetCellFormatIndex(mapping.ExcelFormat, 0, null));
+            }
+        }
+    }
 
-                mapping.SetFormatId(formatId);
+    /// <summary>
+    /// Gets the cellXfs index of a format, adding the format when it is new.
+    /// </summary>
+    /// <param name="numberFormat">A valid custom number format, or null.</param>
+    /// <param name="builtInNumberFormatId">The built-in numFmtId used when <paramref name="numberFormat"/> is null.</param>
+    /// <param name="fontColor">The font color, or null for the default font.</param>
+    internal int GetCellFormatIndex(string? numberFormat, int builtInNumberFormatId, Color? fontColor)
+    {
+        int? customNumberFormat = null;
+        if (numberFormat is not null)
+        {
+            if (!_numberFormatIndexes.TryGetValue(numberFormat, out var position))
+            {
+                position = _numberFormats.Count;
+                _numberFormats.Add(numberFormat);
+                _numberFormatIndexes.Add(numberFormat, position);
             }
+
+            customNumberFormat = position;
+            builtInNumberFormatId = 0;
         }
+
+        int? fontColorPosition = null;
+        if (fontColor is { } color)
+        {
+            var argb = color.ToArgb();
+            if (!_fontColorIndexes.TryGetValue(argb, out var position))
+            {
+                position = _fontColors.Count;
+                _fontColors.Add(color);
+                _fontColorIndexes.Add(argb, position);
+            }
+
+            fontColorPosition = position;
+        }
+
+        CustomCellFormat format = (customNumberFormat, builtInNumberFormatId, fontColorPosition);
+        if (!_cellFormatIndexes.TryGetValue(format, out var index))
+        {
+            index = _firstCellFormatIndex + _cellFormats.Count;
+            _cellFormats.Add(format);
+            _cellFormatIndexes.Add(format, index);
+        }
+
+        return index;
     }
-    
-    internal void SetCurrentIndex(int index) => _stylesCount = index; 
+
+    internal void SetCurrentIndex(int index) => _firstCellFormatIndex = index;
 }
diff --git a/src/MiniExcel.OpenXml/Writer/OpenXmlWriter.XmlGeneration.cs b/src/MiniExcel.OpenXml/Writer/OpenXmlWriter.XmlGeneration.cs
index 29e3aa00..ae476fd5 100644
--- a/src/MiniExcel.OpenXml/Writer/OpenXmlWriter.XmlGeneration.cs
+++ b/src/MiniExcel.OpenXml/Writer/OpenXmlWriter.XmlGeneration.cs
@@ -157,7 +157,7 @@ private string GetPanes()
         return sb.ToString();
     }
 
-    private (string StyleIndex, string DataType, string? CellValue) GetCellValue(int rowIndex, int cellIndex, object value, MiniExcelColumnMapping? columnMapping, bool valueIsNull)
+    private (string StyleIndex, string DataType, string? CellValue) GetCellValue(int rowIndex, int cellIndex, object value, MiniExcelColumnMapping? columnMapping, bool valueIsNull, bool useRuntimeType = false)
     {
         if (valueIsNull)
             return (RegularCellStyleIndex, GetStringType(), string.Empty);
@@ -168,7 +168,7 @@ private string GetPanes()
             return (styleIndex, GetStringType(), str);
         }
 
-        var type = GetValueType(value, columnMapping);
+        var type = useRuntimeType ? Nullable.GetUnderlyingType(value.GetType()) ?? value.GetType() : GetValueType(value, columnMapping);
 
         if (columnMapping is { ExcelFormat: not null, ExcelFormatId: -1 } && value is IFormattable formattableValue)
         {
diff --git a/src/MiniExcel.OpenXml/Writer/OpenXmlWriter.cs b/src/MiniExcel.OpenXml/Writer/OpenXmlWriter.cs
index 2c7aeaff..c55422e8 100644
--- a/src/MiniExcel.OpenXml/Writer/OpenXmlWriter.cs
+++ b/src/MiniExcel.OpenXml/Writer/OpenXmlWriter.cs
@@ -440,6 +440,12 @@ private static async Task PrintHeaderAsync(MiniExcelStreamWriter writer, List<Mi
     [CreateSyncVersion]
     private async Task WriteCellAsync(MiniExcelStreamWriter writer, int rowIndex, int cellIndex, object? value, MiniExcelColumnMapping? columnMapping, ExcelColumnWidthCollection? widthCollection, CancellationToken cancellationToken = default)
     {
+        var cellValueOverride = value as OpenXmlCellValue;
+        if (cellValueOverride is not null)
+        {
+            value = cellValueOverride.Value;
+        }
+
         if (columnMapping?.CustomFormatter is { } formatter)
         {
             try
@@ -455,6 +461,12 @@ private async Task WriteCellAsync(MiniExcelStreamWriter writer, int rowIndex, in
         var columnReference = CellReferenceConverter.GetCellFromCoordinates(cellIndex, rowIndex);
         var valueIsNull = value is null or DBNull || (_configuration.WriteEmptyStringAsNull && value is "");
 
+        if (cellValueOverride is not null)
+        {
+            await WriteCellValueOverrideAsync(writer, columnReference, rowIndex, cellIndex, value, valueIsNull, cellValueOverride, columnMapping, widthCollection, cancellationToken).ConfigureAwait(false);
+            return;
+        }
+
         if (_configuration.EnableWriteNullValueCell && valueIsNull)
         {
             await writer.WriteAsync(WorksheetXml.EmptyCell(columnReference, DefaultCellStyleIndex), cancellationToken).ConfigureAwait(false);
@@ -465,25 +477,78 @@ private async Task WriteCellAsync(MiniExcelStreamWriter writer, int rowIndex, in
         var (styleIndex, dataType, cellValue) = GetCellValue(rowIndex, cellIndex, value, columnMapping, valueIsNull);
         widthCollection?.AdjustWidth(cellIndex, cellValue);
 
-        if (_configuration.StringStorageMode == StringStorageMode.Shared && 
-            dataType == ExcelDataTypes.SharedString 
-            && cellValue is not null)
+        /*Prefix and suffix blank space will lost after SaveAs #294*/
+        var preserveSpace = cellValue.StartsWith(" ") || cellValue.EndsWith(" ");
+        cellValue = GetSharedStringIndexIfNeeded(dataType, cellValue);
+        await writer.WriteAsync(WorksheetXml.Cell(columnReference, dataType, styleIndex, cellValue, preserveSpace: preserveSpace, columnType: columnType), cancellationToken).ConfigureAwait(false);
+    }
+
+    [CreateSyncVersion]
+    private async Task WriteCellValueOverrideAsync(MiniExcelStreamWriter writer, string columnReference, int rowIndex, int cellIndex, object? value, bool valueIsNull, OpenXmlCellValue cell, MiniExcelColumnMapping? columnMapping, ExcelColumnWidthCollection? widthCollection, CancellationToken cancellationToken)
+    {
+        var numberFormat = cell.NumberFormat;
+        if (numberFormat is not null && !new OpenXmlNumberFormatHelper(numberFormat).IsValid)
+            throw new InvalidOperationException($"The number format '{numberFormat}' of cell {columnReference} is not valid.");
+
+        // The cell's number format replaces the column's, so the value is converted without the column mapping.
+        // The declared type of the column says nothing about a wrapped value, so its runtime type is used.
+        var (styleIndex, dataType, cellValue) = valueIsNull
+            ? (DefaultCellStyleIndex, null, null)
+            : GetCellValue(rowIndex, cellIndex, value!, numberFormat is null ? columnMapping : null, false, useRuntimeType: true);
+
+        if (numberFormat is not null || cell.FontColor is not null)
         {
-            if (_sharedStrings.TryGetValue(cellValue, out var sharedStringIndex))
+            // Without a number format of its own, the cell keeps the one it would have had
+            var builtInNumberFormatId = 0;
+            if (numberFormat is null)
             {
-                cellValue = sharedStringIndex.ToString();
-            }
-            else
-            {
-                var count = _sharedStrings.Count;
-                _sharedStrings[cellValue] = count;
-                cellValue = count.ToString();
+                if (columnMapping?.ExcelFormat is not null && columnMapping.ExcelFormatId != -1 && styleIndex == columnMapping.ExcelFormatId.ToString())
+                    numberFormat = columnMapping.ExcelFormat;
+                else if (styleIndex == DateCellStyleIndex)
+                    builtInNumberFormatId = 14;
+                else if (styleIndex == TimeCellStyleIndex)
+                    builtInNumberFormatId = 21;
             }
+
+            styleIndex = _sheetStyleBuilderContext.GetCellFormatIndex(numberFormat, builtInNumberFormatId, cell.FontColor).ToString();
+        }
+
+        if (cellValue is not null)
+            widthCollection?.AdjustWidth(cellIndex, cellValue);
+
+        if (cell.Formula is { } formula)
+        {
+            if (formula.StartsWith("="))
+                formula = formula.Substring(1);
+
+            var resultType = dataType is ExcelDataTypes.Numeric or ExcelDataTypes.Boolean ? dataType : ExcelDataTypes.CalculatedString;
+            await writer.WriteAsync(WorksheetXml.FormulaCell(columnReference, resultType, styleIndex, formula, cellValue), cancellationToken).ConfigureAwait(false);
+            return;
+        }
+
+        if (cellValue is null)
+        {
+            await writer.WriteAsync(WorksheetXml.EmptyCell(columnReference, styleIndex), cancellationToken).ConfigureAwait(false);
+            return;
         }
 
-        /*Prefix and suffix blank space will lost after SaveAs #294*/
         var preserveSpace = cellValue.StartsWith(" ") || cellValue.EndsWith(" ");
-        await writer.WriteAsync(WorksheetXml.Cell(columnReference, dataType, styleIndex, cellValue, preserveSpace: preserveSpace, columnType: columnType), cancellationToken).ConfigureAwait(false);
+        cellValue = GetSharedStringIndexIfNeeded(dataType, cellValue);
+        await writer.WriteAsync(WorksheetXml.Cell(columnReference, dataType, styleIndex, cellValue, preserveSpace: preserveSpace), cancellationToken).ConfigureAwait(false);
+    }
+
+    private string GetSharedStringIndexIfNeeded(string? dataType, string cellValue)
+    {
+        if (_configuration.StringStorageMode != StringStorageMode.Shared || dataType != ExcelDataTypes.SharedString)
+            return cellValue;
+
+        if (!_sharedStrings.TryGetValue(cellValue, out var sharedStringIndex))
+        {
+            sharedStringIndex = _sharedStrings.Count;
+            _sharedStrings[cellValue] = sharedStringIndex;
+        }
+
+        return sharedStringIndex.ToString();
     }
 
     [CreateSyncVersion]
diff --git a/tests/MiniExcel.OpenXml.Tests/CellValues/OpenXmlCellValueAsyncTests.cs b/tests/MiniExcel.OpenXml.Tests/CellValues/OpenXmlCellValueAsyncTests.cs
new file mode 100644
index 00000000..ab3e3348
--- /dev/null
+++ b/tests/MiniExcel.OpenXml.Tests/CellValues/OpenXmlCellValueAsyncTests.cs
@@ -0,0 +1,156 @@
+using System.Drawing;
+using System.Xml.Linq;
+using ClosedXML.Excel;
+using MiniExcelLib.OpenXml.Models;
+
+namespace MiniExcelLib.OpenXml.Tests.CellValues;
+
+public class OpenXmlCellValueAsyncTests
+{
+    private readonly OpenXmlExporter _exporter = MiniExcelV2.Exporters.GetOpenXmlExporter();
+
+    private class FormattedRow
+    {
+        [MiniExcelFormat("0.000")]
+        public object? Amount { get; set; }
+
+        public object? When { get; set; }
+    }
+
+    private async Task<XLWorkbook> ExportAsync(object value, OpenXmlConfiguration? configuration = null)
+    {
+        var stream = new MemoryStream();
+        await _exporter.ExportAsync(stream, value, configuration: configuration);
+        stream.Position = 0;
+        return new XLWorkbook(stream);
+    }
+
+    [Fact]
+    public async Task FormulaIsWrittenWithItsCachedResultAsync()
+    {
+        Dictionary<string, object?>[] rows =
+        [
+            new() { ["A"] = 3, ["B"] = new OpenXmlCellValue(6) { Formula = "A2*2" }, ["C"] = new OpenXmlCellValue("x3") { Formula = "=\"x\"&A2" } }
+        ];
+
+        using var workbook = await ExportAsync(rows);
+        var sheet = workbook.Worksheet(1);
+
+        Assert.Equal("A2*2", sheet.Cell("B2").FormulaA1);
+        Assert.Equal(6, sheet.Cell("B2").CachedValue.GetNumber());
+        Assert.Equal("\"x\"&A2", sheet.Cell("C2").FormulaA1);
+        Assert.Equal("x3", sheet.Cell("C2").CachedValue.GetText());
+        Assert.False(sheet.Cell("A2").HasFormula);
+    }
+
+    [Fact]
+    public async Task FontColorAndNumberFormatApplyToTheCellOnlyAsync()
+    {
+        Dictionary<string, object?>[] rows =
+        [
+            new() { ["Value"] = new OpenXmlCellValue(0.25) { NumberFormat = "0.0%", FontColor = Color.Red } },
+            new() { ["Value"] = new OpenXmlCellValue("grey") { FontColor = Color.Gray } },
+            new() { ["Value"] = 1.5 }
+        ];
+
+        using var workbook = await ExportAsync(rows);
+        var sheet = workbook.Worksheet(1);
+
+        Assert.Equal(0.25, sheet.Cell("A2").GetDouble());
+        Assert.Equal("0.0%", sheet.Cell("A2").Style.NumberFormat.Format);
+        Assert.Equal(Color.Red.ToArgb(), sheet.Cell("A2").Style.Font.FontColor.Color.ToArgb());
+        Assert.Equal("grey", sheet.Cell("A3").GetString());
+        Assert.Equal(Color.Gray.ToArgb(), sheet.Cell("A3").Style.Font.FontColor.Color.ToArgb());
+        Assert.Equal(1.5, sheet.Cell("A4").GetDouble());
+        Assert.NotEqual(Color.Red.ToArgb(), sheet.Cell("A4").Style.Font.FontColor.Color.ToArgb());
+    }
+
+    [Fact]
+    public async Task FontColorKeepsTheColumnFormatAsync()
+    {
+        Dictionary<string, object?>[] rows =
+        [
+            new() { ["Amount"] = new OpenXmlCellValue(1.23456) { FontColor = Color.Blue } },
+            new() { ["Amount"] = 2.5 }
+        ];
+        var configuration = new OpenXmlConfiguration { DynamicColumns = [new DynamicExcelColumn("Amount") { Format = "0.000" }] };
+
+        using var workbook = await ExportAsync(rows, configuration);
+        var sheet = workbook.Worksheet(1);
+
+        Assert.Equal(1.23456, sheet.Cell("A2").GetDouble());
+        Assert.Equal("0.000", sheet.Cell("A2").Style.NumberFormat.Format);
+        Assert.Equal(Color.Blue.ToArgb(), sheet.Cell("A2").Style.Font.FontColor.Color.ToArgb());
+        Assert.Equal("0.000", sheet.Cell("A3").Style.NumberFormat.Format);
+    }
+
+    [Fact]
+    public async Task WrappedValuesInTypedRowsUseTheirOwnTypeAsync()
+    {
+        FormattedRow[] rows =
+        [
+            new() { Amount = new OpenXmlCellValue(1.23456) { FontColor = Color.Blue }, When = new OpenXmlCellValue(new DateTime(2024, 5, 6)) { FontColor = Color.Blue } }
+        ];
+
+        using var workbook = await ExportAsync(rows);
+        var sheet = workbook.Worksheet(1);
+
+        Assert.Equal(1.23456, sheet.Cell("A2").GetDouble());
+        Assert.Equal("0.000", sheet.Cell("A2").Style.NumberFormat.Format);
+        Assert.Equal(new DateTime(2024, 5, 6), sheet.Cell("B2").GetDateTime());
+        Assert.Equal(14, sheet.Cell("B2").Style.NumberFormat.NumberFormatId);
+        Assert.Equal(Color.Blue.ToArgb(), sheet.Cell("B2").Style.Font.FontColor.Color.ToArgb());
+    }
+
+    [Fact]
+    public async Task CellsWithTheSameStyleShareOneFormatAsync()
+    {
+        var rows = Enumerable.Range(1, 50)
+            .Select(i => new Dictionary<string, object?> { ["Value"] = new OpenXmlCellValue(i) { NumberFormat = "0.00", FontColor = Color.Gray } })
+            .ToArray();
+
+        var stream = new MemoryStream();
+        await _exporter.ExportAsync(stream, rows);
+        stream.Position = 0;
+
+        using var archive = new ZipArchive(stream);
+        using var reader = new StreamReader(archive.GetEntry("xl/styles.xml")!.Open());
+        var styles = XDocument.Parse(await reader.ReadToEndAsync());
+        XNamespace ns = "http://schemas.openxmlformats.org/spreadsheetml/2006/main";
+
+        Assert.Single(styles.Descendants(ns + "numFmt"), e => (string?)e.Attribute("formatCode") == "0.00");
+        Assert.Single(styles.Descendants(ns + "font"), e => (string?)e.Element(ns + "color")?.Attribute("rgb") == "FF808080");
+    }
+
+    [Fact]
+    public async Task NullValueKeepsItsStyleAsync()
+    {
+        Dictionary<string, object?>[] rows = [new() { ["Value"] = new OpenXmlCellValue(null) { FontColor = Color.Red } }];
+
+        using var workbook = await ExportAsync(rows);
+        var cell = workbook.Worksheet(1).Cell("A2");
+
+        Assert.True(cell.IsEmpty());
+        Assert.Equal(Color.Red.ToArgb(), cell.Style.Font.FontColor.Color.ToArgb());
+    }
+
+    [Fact]
+    public async Task MinimalStylesSupportCellValuesAsync()
+    {
+        Dictionary<string, object?>[] rows = [new() { ["Value"] = new OpenXmlCellValue(0.5) { NumberFormat = "0%", FontColor = Color.Green } }];
+
+        using var workbook = await ExportAsync(rows, new OpenXmlConfiguration { TableStyles = TableStyles.None });
+        var cell = workbook.Worksheet(1).Cell("A2");
+
+        Assert.Equal("0%", cell.Style.NumberFormat.Format);
+        Assert.Equal(Color.Green.ToArgb(), cell.Style.Font.FontColor.Color.ToArgb());
+    }
+
+    [Fact]
+    public async Task InvalidNumberFormatThrowsAsync()
+    {
+        Dictionary<string, object?>[] rows = [new() { ["Value"] = new OpenXmlCellValue(1) { NumberFormat = "0.0\"" } }];
+
+        await Assert.ThrowsAsync<InvalidOperationException>(() => _exporter.ExportAsync(new MemoryStream(), rows));
+    }
+}
diff --git a/tests/MiniExcel.OpenXml.Tests/CellValues/OpenXmlCellValueTests.cs b/tests/MiniExcel.OpenXml.Tests/CellValues/OpenXmlCellValueTests.cs
new file mode 100644
index 00000000..729319f1
--- /dev/null
+++ b/tests/MiniExcel.OpenXml.Tests/CellValues/OpenXmlCellValueTests.cs
@@ -0,0 +1,31 @@
+using System.Drawing;
+using ClosedXML.Excel;
+using MiniExcelLib.OpenXml.Models;
+
+namespace MiniExcelLib.OpenXml.Tests.CellValues;
+
+public class OpenXmlCellValueTests
+{
+    private readonly OpenXmlExporter _exporter = MiniExcelV2.Exporters.GetOpenXmlExporter();
+
+    [Fact]
+    public void FormulaFontColorAndNumberFormatAreWritten()
+    {
+        Dictionary<string, object?>[] rows =
+        [
+            new() { ["A"] = 3, ["B"] = new OpenXmlCellValue(0.6) { Formula = "A2/5", NumberFormat = "0.0%", FontColor = Color.Gray } }
+        ];
+
+        var stream = new MemoryStream();
+        _exporter.Export(stream, rows);
+        stream.Position = 0;
+
+        using var workbook = new XLWorkbook(stream);
+        var cell = workbook.Worksheet(1).Cell("B2");
+
+        Assert.Equal("A2/5", cell.FormulaA1);
+        Assert.Equal(0.6, cell.CachedValue.GetNumber());
+        Assert.Equal("0.0%", cell.Style.NumberFormat.Format);
+        Assert.Equal(Color.Gray.ToArgb(), cell.Style.Font.FontColor.Color.ToArgb());
+    }
+}

From e73c2da16972a3594154f8186af347e2e9535dea Mon Sep 17 00:00:00 2001
From: Victor Irzak <victor.irzak@zomp.com>
Date: Sun, 11 Oct 2026 08:15:18 -0400
Subject: [PATCH 2/3] Style OpenXmlCellValue through OpenXmlCellStyle

Shares the style type with the editor, so properties added to it later
apply to exported cells as well.
---
 src/MiniExcel.OpenXml/Models/OpenXmlCellValue.cs   |  6 +++---
 src/MiniExcel.OpenXml/Writer/OpenXmlWriter.cs      |  4 ++--
 .../CellValues/OpenXmlCellValueAsyncTests.cs       | 14 +++++++-------
 .../CellValues/OpenXmlCellValueTests.cs            |  2 +-
 4 files changed, 13 insertions(+), 13 deletions(-)

diff --git a/src/MiniExcel.OpenXml/Models/OpenXmlCellValue.cs b/src/MiniExcel.OpenXml/Models/OpenXmlCellValue.cs
index 0ca6d116..a96d12d6 100644
--- a/src/MiniExcel.OpenXml/Models/OpenXmlCellValue.cs
+++ b/src/MiniExcel.OpenXml/Models/OpenXmlCellValue.cs
@@ -1,4 +1,4 @@
-using System.Drawing;
+using MiniExcelLib.OpenXml.Styles;
 
 namespace MiniExcelLib.OpenXml.Models;
 
@@ -24,7 +24,7 @@ public sealed class OpenXmlCellValue(object? value)
     public string? NumberFormat { get; set; }
 
     /// <summary>
-    /// The font color of the cell.
+    /// The style of the cell, such as its font color.
     /// </summary>
-    public Color? FontColor { get; set; }
+    public OpenXmlCellStyle Style { get; } = new();
 }
diff --git a/src/MiniExcel.OpenXml/Writer/OpenXmlWriter.cs b/src/MiniExcel.OpenXml/Writer/OpenXmlWriter.cs
index c55422e8..76ea51a0 100644
--- a/src/MiniExcel.OpenXml/Writer/OpenXmlWriter.cs
+++ b/src/MiniExcel.OpenXml/Writer/OpenXmlWriter.cs
@@ -496,7 +496,7 @@ private async Task WriteCellValueOverrideAsync(MiniExcelStreamWriter writer, str
             ? (DefaultCellStyleIndex, null, null)
             : GetCellValue(rowIndex, cellIndex, value!, numberFormat is null ? columnMapping : null, false, useRuntimeType: true);
 
-        if (numberFormat is not null || cell.FontColor is not null)
+        if (numberFormat is not null || cell.Style.FontColor is not null)
         {
             // Without a number format of its own, the cell keeps the one it would have had
             var builtInNumberFormatId = 0;
@@ -510,7 +510,7 @@ private async Task WriteCellValueOverrideAsync(MiniExcelStreamWriter writer, str
                     builtInNumberFormatId = 21;
             }
 
-            styleIndex = _sheetStyleBuilderContext.GetCellFormatIndex(numberFormat, builtInNumberFormatId, cell.FontColor).ToString();
+            styleIndex = _sheetStyleBuilderContext.GetCellFormatIndex(numberFormat, builtInNumberFormatId, cell.Style.FontColor).ToString();
         }
 
         if (cellValue is not null)
diff --git a/tests/MiniExcel.OpenXml.Tests/CellValues/OpenXmlCellValueAsyncTests.cs b/tests/MiniExcel.OpenXml.Tests/CellValues/OpenXmlCellValueAsyncTests.cs
index ab3e3348..37700a6d 100644
--- a/tests/MiniExcel.OpenXml.Tests/CellValues/OpenXmlCellValueAsyncTests.cs
+++ b/tests/MiniExcel.OpenXml.Tests/CellValues/OpenXmlCellValueAsyncTests.cs
@@ -48,8 +48,8 @@ public async Task FontColorAndNumberFormatApplyToTheCellOnlyAsync()
     {
         Dictionary<string, object?>[] rows =
         [
-            new() { ["Value"] = new OpenXmlCellValue(0.25) { NumberFormat = "0.0%", FontColor = Color.Red } },
-            new() { ["Value"] = new OpenXmlCellValue("grey") { FontColor = Color.Gray } },
+            new() { ["Value"] = new OpenXmlCellValue(0.25) { NumberFormat = "0.0%", Style = { FontColor = Color.Red } } },
+            new() { ["Value"] = new OpenXmlCellValue("grey") { Style = { FontColor = Color.Gray } } },
             new() { ["Value"] = 1.5 }
         ];
 
@@ -70,7 +70,7 @@ public async Task FontColorKeepsTheColumnFormatAsync()
     {
         Dictionary<string, object?>[] rows =
         [
-            new() { ["Amount"] = new OpenXmlCellValue(1.23456) { FontColor = Color.Blue } },
+            new() { ["Amount"] = new OpenXmlCellValue(1.23456) { Style = { FontColor = Color.Blue } } },
             new() { ["Amount"] = 2.5 }
         ];
         var configuration = new OpenXmlConfiguration { DynamicColumns = [new DynamicExcelColumn("Amount") { Format = "0.000" }] };
@@ -89,7 +89,7 @@ public async Task WrappedValuesInTypedRowsUseTheirOwnTypeAsync()
     {
         FormattedRow[] rows =
         [
-            new() { Amount = new OpenXmlCellValue(1.23456) { FontColor = Color.Blue }, When = new OpenXmlCellValue(new DateTime(2024, 5, 6)) { FontColor = Color.Blue } }
+            new() { Amount = new OpenXmlCellValue(1.23456) { Style = { FontColor = Color.Blue } }, When = new OpenXmlCellValue(new DateTime(2024, 5, 6)) { Style = { FontColor = Color.Blue } } }
         ];
 
         using var workbook = await ExportAsync(rows);
@@ -106,7 +106,7 @@ public async Task WrappedValuesInTypedRowsUseTheirOwnTypeAsync()
     public async Task CellsWithTheSameStyleShareOneFormatAsync()
     {
         var rows = Enumerable.Range(1, 50)
-            .Select(i => new Dictionary<string, object?> { ["Value"] = new OpenXmlCellValue(i) { NumberFormat = "0.00", FontColor = Color.Gray } })
+            .Select(i => new Dictionary<string, object?> { ["Value"] = new OpenXmlCellValue(i) { NumberFormat = "0.00", Style = { FontColor = Color.Gray } } })
             .ToArray();
 
         var stream = new MemoryStream();
@@ -125,7 +125,7 @@ public async Task CellsWithTheSameStyleShareOneFormatAsync()
     [Fact]
     public async Task NullValueKeepsItsStyleAsync()
     {
-        Dictionary<string, object?>[] rows = [new() { ["Value"] = new OpenXmlCellValue(null) { FontColor = Color.Red } }];
+        Dictionary<string, object?>[] rows = [new() { ["Value"] = new OpenXmlCellValue(null) { Style = { FontColor = Color.Red } } }];
 
         using var workbook = await ExportAsync(rows);
         var cell = workbook.Worksheet(1).Cell("A2");
@@ -137,7 +137,7 @@ public async Task NullValueKeepsItsStyleAsync()
     [Fact]
     public async Task MinimalStylesSupportCellValuesAsync()
     {
-        Dictionary<string, object?>[] rows = [new() { ["Value"] = new OpenXmlCellValue(0.5) { NumberFormat = "0%", FontColor = Color.Green } }];
+        Dictionary<string, object?>[] rows = [new() { ["Value"] = new OpenXmlCellValue(0.5) { NumberFormat = "0%", Style = { FontColor = Color.Green } } }];
 
         using var workbook = await ExportAsync(rows, new OpenXmlConfiguration { TableStyles = TableStyles.None });
         var cell = workbook.Worksheet(1).Cell("A2");
diff --git a/tests/MiniExcel.OpenXml.Tests/CellValues/OpenXmlCellValueTests.cs b/tests/MiniExcel.OpenXml.Tests/CellValues/OpenXmlCellValueTests.cs
index 729319f1..c0fb71e5 100644
--- a/tests/MiniExcel.OpenXml.Tests/CellValues/OpenXmlCellValueTests.cs
+++ b/tests/MiniExcel.OpenXml.Tests/CellValues/OpenXmlCellValueTests.cs
@@ -13,7 +13,7 @@ public void FormulaFontColorAndNumberFormatAreWritten()
     {
         Dictionary<string, object?>[] rows =
         [
-            new() { ["A"] = 3, ["B"] = new OpenXmlCellValue(0.6) { Formula = "A2/5", NumberFormat = "0.0%", FontColor = Color.Gray } }
+            new() { ["A"] = 3, ["B"] = new OpenXmlCellValue(0.6) { Formula = "A2/5", NumberFormat = "0.0%", Style = { FontColor = Color.Gray } } }
         ];
 
         var stream = new MemoryStream();

From 6db7accddebad4d8f22fb43061a4ac76d4054c63 Mon Sep 17 00:00:00 2001
From: Victor Irzak <victor.irzak@zomp.com>
Date: Sun, 11 Oct 2026 08:18:19 -0400
Subject: [PATCH 3/3] Document OpenXmlCellValue in README_V2

---
 README_V2.md | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)

diff --git a/README_V2.md b/README_V2.md
index 8402a915..f12b6f86 100644
--- a/README_V2.md
+++ b/README_V2.md
@@ -745,6 +745,28 @@ exporter.Export("Book1.xlsx", dt, configuration: config);
 
 ![image](docs/images/freeze-pane-1.png)
 
+#### 14. Per-cell formulas and formatting
+
+Wrapping a value in `OpenXmlCellValue` sets a formula, number format or style for that one cell, overriding the column's settings:
+
+```csharp
+var rows = new[]
+{
+    new Dictionary<string, object?>
+    {
+        ["Input"] = 3,
+        ["Share"] = new OpenXmlCellValue(0.25) { NumberFormat = "0.0%", Style = { FontColor = Color.Red } },
+        ["Double"] = new OpenXmlCellValue(6) { Formula = "A2*2" }
+    }
+};
+
+var exporter = MiniExcelV2.Exporters.GetOpenXmlExporter();
+exporter.Export("Book1.xlsx", rows);
+```
+
+The value given with a formula is written as its cached result, which Excel shows until it recalculates. Pass `null` to leave the result for Excel to calculate.
+A cell with only a style keeps the number format it would otherwise have had.
+
 
 ### Fill Data To Excel Template <a name="docs-template" />