react-native-nitro-xlsx 0.2.5 → 0.2.7

package/NitroXlsx.podspec

@@ -13,27 +13,33 @@ Pod::Spec.new do |s|
   s.platforms    = { :ios => "15.1" }
   s.source       = { :git => "https://github.com/zydbkqf/react-native-nitro-xlsx.git", :tag => "#{s.version}" }
 
+  # OpenXLSX, pugixml and miniz are vendored under thirdparty/ and shipped
+  # with the package, so no network access is needed during pod install.
   s.exclude_files = [
     "cpp/tests/**/*",
-    "OpenXLSX/ThirdParty/miniz/tests/**/*",
-    "OpenXLSX/ThirdParty/miniz/examples/**/*",
+    "thirdparty/miniz/tests/**/*",
+    "thirdparty/miniz/examples/**/*",
+    "thirdparty/pugixml/tests/**/*",
+    "thirdparty/OpenXLSX/Tests/**/*",
+    "thirdparty/OpenXLSX/Examples/**/*",
+    "thirdparty/OpenXLSX/Benchmarks/**/*",
   ]
 
   s.source_files = [
     "cpp/**/*.{h,hpp,cpp}",
     "ios/**/*.{h,hpp,mm}",
-    "OpenXLSX/OpenXLSX/**/*.hpp",
-    "OpenXLSX/OpenXLSX/**/*.cpp",
-    "OpenXLSX/ThirdParty/pugixml/src/**/*.hpp",
-    "OpenXLSX/ThirdParty/pugixml/src/**/*.cpp",
-    "OpenXLSX/OpenXLSX/headers/detail/Zippy.hpp",
-    "OpenXLSX/ThirdParty/miniz/**/*.h",
-    "OpenXLSX/ThirdParty/miniz/**/*.c",
+    "thirdparty/OpenXLSX/OpenXLSX/**/*.hpp",
+    "thirdparty/OpenXLSX/OpenXLSX/**/*.cpp",
+    "thirdparty/pugixml/src/**/*.hpp",
+    "thirdparty/pugixml/src/**/*.cpp",
+    "thirdparty/OpenXLSX/OpenXLSX/headers/detail/Zippy.hpp",
+    "thirdparty/miniz/**/*.h",
+    "thirdparty/miniz/**/*.c",
   ]
 
   s.private_header_files = [
-    "OpenXLSX/**/*.hpp",
-    "OpenXLSX/**/*.h",
+    "thirdparty/OpenXLSX/**/*.hpp",
+    "thirdparty/OpenXLSX/**/*.h",
   ]
 
   s.dependency "React"
@@ -45,29 +51,22 @@ Pod::Spec.new do |s|
     "SWIFT_INSTALL_OBJC_HEADER" => "NO",
     "OTHER_CFLAGS" => "$(inherited) -fmodules",
     "OTHER_CPLUSPLUSFLAGS" => "$(inherited) -fmodules",
-    "HEADER_SEARCH_PATHS" => "$(inherited) ${PODS_TARGET_SRCROOT}/OpenXLSX ${PODS_TARGET_SRCROOT}/OpenXLSX/OpenXLSX ${PODS_TARGET_SRCROOT}/OpenXLSX/OpenXLSX/headers ${PODS_TARGET_SRCROOT}/OpenXLSX/ThirdParty/pugixml/src ${PODS_TARGET_SRCROOT}/OpenXLSX/ThirdParty/miniz",
+    "HEADER_SEARCH_PATHS" => "$(inherited) ${PODS_TARGET_SRCROOT}/thirdparty/OpenXLSX ${PODS_TARGET_SRCROOT}/thirdparty/OpenXLSX/OpenXLSX ${PODS_TARGET_SRCROOT}/thirdparty/OpenXLSX/OpenXLSX/headers ${PODS_TARGET_SRCROOT}/thirdparty/pugixml/src ${PODS_TARGET_SRCROOT}/thirdparty/miniz",
   }
 
   s.user_target_xcconfig = {
     "OTHER_CFLAGS" => "$(inherited) -fmodules",
     "OTHER_CPLUSPLUSFLAGS" => "$(inherited) -fmodules",
-    "HEADER_SEARCH_PATHS" => "$(inherited) ${PODS_TARGET_SRCROOT}/OpenXLSX ${PODS_TARGET_SRCROOT}/OpenXLSX/OpenXLSX ${PODS_TARGET_SRCROOT}/OpenXLSX/OpenXLSX/headers ${PODS_TARGET_SRCROOT}/OpenXLSX/ThirdParty/pugixml/src ${PODS_TARGET_SRCROOT}/OpenXLSX/ThirdParty/miniz",
+    "HEADER_SEARCH_PATHS" => "$(inherited) ${PODS_TARGET_SRCROOT}/thirdparty/OpenXLSX ${PODS_TARGET_SRCROOT}/thirdparty/OpenXLSX/OpenXLSX ${PODS_TARGET_SRCROOT}/thirdparty/OpenXLSX/OpenXLSX/headers ${PODS_TARGET_SRCROOT}/thirdparty/pugixml/src ${PODS_TARGET_SRCROOT}/thirdparty/miniz",
   }
 
-  # Prepare OpenXLSX and its dependencies (pugixml, miniz) via a Node script
-  # so the same logic can be reused from both CocoaPods and Android CMake.
-  s.prepare_command = "node #{__dir__}/scripts/prepare-openxlsx.js"
-
-  # Swift Package Manager declaration for React Native 0.87+.
-  # This exposes NitroXlsx as a local Swift package; the heavy lifting for
-  # OpenXLSX is still done by the prepare command above.
-  if ENV['NITRO_XLSX_USE_SPM'] == '1' && defined?(SPM) && SPM.respond_to?(:dependency)
-    SPM.dependency(s,
-      url: File.join(__dir__, "."),
-      requirement: { kind: 'upToNextMajorVersion', minimumVersion: s.version.to_s },
-      products: ['NitroXlsx']
-    )
-  end
+  # Swift Package Manager note: this podspec intentionally declares nothing for
+  # SPM. React Native 0.88+ drives SwiftPM from `package.json` (`swiftpmConfig`)
+  # and `npx react-native spm`, and the manifest lives in Package.swift. That
+  # manifest is still a placeholder (it only compiles ios/XlsxCacheDir.mm) and
+  # CocoaPods remains the build path for this library until the C++ targets,
+  # the vendored thirdparty/ tree and the NitroModules dependency are wired
+  # into it.
 
   load 'nitrogen/generated/ios/NitroXlsx+autolinking.rb'
   add_nitrogen_files(s)

package/Package.swift

@@ -1,20 +1,39 @@
 // swift-tools-version: 5.9
 import PackageDescription
 
-// NOTE: This Package.swift is a Swift Package Manager manifest stub for
-// React Native 0.87+ compatibility. The library is still primarily built
-// through CocoaPods (NitroXlsx.podspec), where OpenXLSX, pugixml and miniz
-// are cloned and compiled from source by scripts/prepare-openxlsx.js.
+// NOTE: This manifest is a placeholder for the Swift Package Manager migration,
+// not the build path used today. CocoaPods (NitroXlsx.podspec) still compiles
+// the library, including the vendored OpenXLSX / pugixml / miniz tree under
+// thirdparty/.
 //
-// The local package reference below lets RN 0.87's spm_dependency helper
-// register NitroXlsx in the Pods project when SwiftPM mode is enabled.
-// Full SPM-based compilation of the C++ sources is not yet supported —
-// ios/XlsxCacheDir.mm is listed so the target has a real source file.
+// It is kept so that (a) the package is syntactically valid and `swift package
+// describe` / `swift build` work, and (b) the eventual migration has a starting
+// point. Today the target only compiles ios/XlsxCacheDir.mm — it exposes
+// getCacheDir / setCacheDir but not the Nitro module itself.
+//
+// Migration target (React Native 0.88+ / nitro-modules 1.x): the package becomes
+// one library product whose targets cover `cpp/`, `ios/XlsxCacheDir.mm` and the
+// thirdparty/ sources, depending on `.product(name: "NitroModules",
+// package: "NitroModules")`, with `swiftpmConfig` in package.json driving
+// autolinking via `npx react-native spm`. The unrelated NITRO_XLSX_USE_SPM env
+// switch that used to live in the podspec has been removed — it was never an
+// upstream concept.
+//
+// Target settings worth knowing:
+// - This is a C-family target, so SwiftPM insists on a public headers
+//   directory and defaults it to `include/`, which does not exist here.
+//   `publicHeadersPath: "."` points the generated umbrella header at the
+//   (header-less) source dir instead of failing to resolve the manifest.
+// - cxxLanguageStandard must match the podspec's CLANG_CXX_LANGUAGE_STANDARD
+//   (c++20); SwiftPM defaults to gnu++14 and warns on the nested namespace
+//   definitions used by the sources.
 
 let package = Package(
     name: "NitroXlsx",
     platforms: [
-        .iOS(.v15)
+        // Matches NitroXlsx.podspec (`:ios => "15.1"`). SwiftPM's .v15 only
+        // expresses 15.0, so the explicit version string is used instead.
+        .iOS("15.1")
     ],
     products: [
         .library(
@@ -27,9 +46,11 @@ let package = Package(
             name: "NitroXlsx",
             path: "ios",
             sources: ["XlsxCacheDir.mm"],
+            publicHeadersPath: ".",
             cxxSettings: [
                 .headerSearchPath("../cpp")
             ]
         )
-    ]
+    ],
+    cxxLanguageStandard: .cxx20
 )

package/README.md

@@ -29,7 +29,7 @@ npm install react-native-nitro-xlsx
 yarn add react-native-nitro-xlsx
 ```
 
-> **Note**: Native dependencies (OpenXlsx) are downloaded from GitHub during the first build. Please make sure you have a stable network connection.
+> **Note**: Native dependencies (OpenXLSX, pugixml and miniz) are vendored under `thirdparty/` and shipped with the package. The first build compiles them from source; no network access is required.
 
 ### iOS
 
@@ -197,7 +197,7 @@ const buffer = await workbook.getBuffer();
 - `createWorkbook(): XlsxWorkbook` - Create a new workbook. The native side supplies the platform cache directory automatically (`Context.getCacheDir()` on Android, `NSCachesDirectory` on iOS).
 - `openWorkbook(path: string): XlsxWorkbook` - Open workbook from file path
 - `openWorkbookFromBuffer(buffer: ArrayBuffer): XlsxWorkbook` - Open workbook from buffer
-- `fromJSON(data: Record<string, Array<Record<string, string | number | boolean | null>>>): XlsxWorkbook` - Create a workbook with one worksheet per key (native `AnyMap`s, no JSON round-trip)
+- `fromJSON(data: Record<string, Array<Record<string, string | number | boolean | null>>>): XlsxWorkbook` - Create a workbook with one worksheet per key (native `AnyMap`s, no JSON round-trip). The default sheet is removed unless one of the keys is named after it
 
 ### XlsxWorkbook
 
@@ -211,7 +211,7 @@ const buffer = await workbook.getBuffer();
 - `clone(existingName: string, newName: string): XlsxWorksheet` - Copy a worksheet
 - `addCellFormat(): XlsxCellFormat` - Add a new cell format
 - `getBuffer(): Promise<ArrayBuffer>` - Generate and return the XLSX file as a buffer
-- `toJSON(): Record<string, Array<Record<string, string | number | boolean | null>>>` - Export every worksheet as a `Record` keyed by sheet name
+- `toJSON(): Record<string, Array<Record<string, string | number | boolean | null>>>` - Export every worksheet as a `Record` keyed by sheet name. Worksheets without a single cell are skipped, so a fresh workbook exports as `{}`
 
 ### XlsxWorksheet
 
@@ -232,7 +232,7 @@ const buffer = await workbook.getBuffer();
 | `writeFormulaNum(row, col, formula, number, format?)` | Write a formula with number default |
 | `writeFormulaString(row, col, formula, string, format?)` | Write a formula with string default |
 | `writeFormulaBoolean(row, col, formula, boolean, format?)` | Write a formula with boolean default |
-| `writeArrayFormula(firstRow, firstCol, lastRow, lastCol, formula, format?)` | Write an array formula |
+| `writeArrayFormula(firstRow, firstCol, lastRow, lastCol, formula, format?)` | Not supported by the underlying engine — always throws `UNSUPPORTED` |
 
 #### Date/URL
 | Method | Description |
@@ -409,7 +409,7 @@ The `XlsxCellFormat` interface is based on OpenXLSX's `XLCellFormat` class and p
 - `setNumFormatIndex(index)` - Set built-in format (use `NumFormat` constants)
 
 #### Colors/Pattern
-- `setBgColor(color)`, `setFgColor(color)`
+- `setBgColor(color)`, `setFgColor(color)` - For solid fills Excel paints the foreground colour, so a colour set only via `setBgColor` is also written as the fill's foreground colour to make it visible
 - `setPattern(pattern)`
 
 #### Borders
@@ -436,9 +436,9 @@ The `XlsxCellFormat` interface is based on OpenXLSX's `XLCellFormat` class and p
 
 When reading cells, the following types are returned:
 
-- `empty` - Empty cell
 - `string` - Text string
-- `number` - Numeric value. Dates are stored as **Excel serial numbers in the 1900 date system** (days since `1900-01-01`, where `1900-01-01` = `1`, including the spurious `1900-02-29`), and are read back as `number`:
+- `number` - Numeric value with no date/time number format applied
+- `date` - Numeric value whose number format is a date/time code. This covers the built-in ids 14–22 and custom codes such as `yyyy-mm-dd`, `h:mm` or `yyyy-mm-dd h:mm:ss`. The stored value is still an **Excel serial number in the 1900 date system** (days since `1900-01-01`, where `1900-01-01` = `1`, including the spurious `1900-02-29`):
   ```ts
   // Excel serial (1900-based) → JS Date
   const date = new Date(Math.round((serial - 25569) * 86400000));
@@ -447,8 +447,11 @@ When reading cells, the following types are returned:
   ```
 - `boolean` - Boolean value
 - `error` - Error value
-- `formula` - Formula
-- `blank` - Blank cell
+- `formula` - Cell holds a formula (checked before the value type, so a formula cell never reads as `number`/`string`)
+- `blank` - Cell exists (e.g. it only carries a style) but has no value
+- `empty` - No cell at these coordinates at all
+
+`getCellType` returns `empty`/`blank` without creating the cell, so probing a cell never mutates the sheet.
 
 ## Constants
 
@@ -510,6 +513,15 @@ To regenerate the native specs after modifying the TypeScript spec files:
 npx nitrogen
 ```
 
+### Tests
+
+```sh
+yarn test        # JS/TS suite (Jest)
+yarn test:cpp    # configure + build cpp/tests into cpp/tests/build, then run gtest
+```
+
+`yarn test:cpp` needs a local GoogleTest installation (`brew install googletest` on macOS); the CMake project looks under `/opt/homebrew`, `/usr/local` and `/usr` first and only falls back to downloading googletest when nothing is found. OpenXLSX, pugixml and miniz are vendored under `thirdparty/`, so the C++ build works offline.
+
 ## License
 
 This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

package/android/CMakeLists.txt

@@ -4,33 +4,26 @@ project("NitroXlsx")
 set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
-set(OPENXLSX_DIR ${CMAKE_SOURCE_DIR}/../OpenXLSX)
-
-# Prepare OpenXLSX and its dependencies (pugixml, miniz) using the same
-# Node script that CocoaPods' prepare_command runs on iOS.
-find_program(NODE_EXECUTABLE node REQUIRED)
-execute_process(
-  COMMAND ${NODE_EXECUTABLE} ${CMAKE_SOURCE_DIR}/../scripts/prepare-openxlsx.js
-  WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/..
-  RESULT_VARIABLE PREPARE_RESULT
-)
-if(NOT PREPARE_RESULT EQUAL 0)
-  message(FATAL_ERROR
-    "Failed to prepare OpenXLSX dependencies.\n"
-    "Please ensure Node.js is installed and run:\n"
-    "  node scripts/prepare-openxlsx.js"
-  )
-endif()
-
-# Verify OpenXLSX is available
-if(NOT EXISTS ${OPENXLSX_DIR}/CMakeLists.txt)
-  message(FATAL_ERROR
-    "OpenXLSX not found at ${OPENXLSX_DIR}.\n"
-    "Please manually clone OpenXLSX:\n"
-    "  cd ${CMAKE_SOURCE_DIR}/.. && git clone --depth 1 --branch v0.5.1 https://github.com/troldal/OpenXLSX.git OpenXLSX\n"
-    "Then clean CMake cache and rebuild."
-  )
-endif()
+set(THIRDPARTY_DIR ${CMAKE_SOURCE_DIR}/../thirdparty)
+set(OPENXLSX_DIR ${THIRDPARTY_DIR}/OpenXLSX)
+
+# OpenXLSX, pugixml and miniz are vendored under thirdparty/ so the build
+# never clones anything from GitHub.
+foreach(required_dir OpenXLSX pugixml miniz)
+  if(NOT EXISTS ${THIRDPARTY_DIR}/${required_dir})
+    message(FATAL_ERROR
+      "Vendored dependency '${required_dir}' is missing at ${THIRDPARTY_DIR}/${required_dir}.\n"
+      "The thirdparty/ tree is part of the package - reinstall react-native-nitro-xlsx."
+    )
+  endif()
+endforeach()
+
+# Point OpenXLSX's FetchContent lookups at the vendored copies, so
+# manage_dependency() populates them from disk instead of cloning GitHub.
+set(FORCE_FETCH_ALL ON CACHE BOOL "" FORCE)
+set(FETCHCONTENT_SOURCE_DIR_PUGIXML_FETCH ${THIRDPARTY_DIR}/pugixml CACHE PATH "" FORCE)
+set(FETCHCONTENT_SOURCE_DIR_MINIZ_FETCH ${THIRDPARTY_DIR}/miniz CACHE PATH "" FORCE)
+set(FETCHCONTENT_UPDATES_DISCONNECTED ON CACHE BOOL "" FORCE)
 
 set(OPENXLSX_BUILD_SAMPLES OFF CACHE BOOL "" FORCE)
 set(OPENXLSX_BUILD_TESTS OFF CACHE BOOL "" FORCE)

package/cpp/HybridNitroXlsx.cpp

@@ -39,12 +39,36 @@ std::shared_ptr<HybridXlsxWorkbookSpec> HybridNitroXlsx::openWorkbookFromBuffer(
 std::shared_ptr<HybridXlsxWorkbookSpec> HybridNitroXlsx::fromJSON(const std::unordered_map<std::string, std::vector<std::shared_ptr<AnyMap>>>& data) {
   return withXlsxError(xlsx_error::INVALID_ARGUMENT, [&]() -> std::shared_ptr<HybridXlsxWorkbookSpec> {
     auto workbook = std::make_shared<HybridXlsxWorkbook>();
-    if (data.empty()) return workbook;
+    // Always leave the workbook usable: create the underlying XLDocument even
+    // when there is no data, so getBuffer()/toJSON()/getWorksheetCount() work.
+    workbook->ensureOpen();
+
+    // Snapshot the sheet(s) OpenXLSX created by default (e.g. "Sheet1") so they
+    // can be removed once the key sheets exist (deleteSheet refuses to delete
+    // the last sheet, so key sheets must be added first).
+    std::vector<std::string> defaultNames;
+    {
+      double count = workbook->getWorksheetCount();
+      for (double i = 0; i < count; ++i) {
+        defaultNames.push_back(workbook->getWorksheet(i)->getName());
+      }
+    }
 
     for (const auto& [sheetName, rows] : data) {
       auto sheet = workbook->addWorksheet(sheetName);
       sheet->fromJSON(rows);
     }
+
+    // README promises one worksheet per key: drop the default sheet(s) unless a
+    // key claimed them. Skip when there is no data - a workbook must keep at
+    // least one sheet.
+    if (!data.empty()) {
+      for (const auto& name : defaultNames) {
+        if (data.count(name) == 0) {
+          workbook->deleteSheet(name);
+        }
+      }
+    }
     return workbook;
   });
 }

package/cpp/HybridXlsxCellFormat.cpp

@@ -1,24 +1,7 @@
 #include "HybridXlsxCellFormat.hpp"
-#include <sstream>
-#include <iomanip>
-#include <cctype>
 
 namespace margelo::nitro::xlsx {
 
-static std::string doubleToHexColor(double color) {
-  uint32_t c = static_cast<uint32_t>(color);
-  // Excel uses ARGB format, prepend alpha channel (FF)
-  uint32_t argb = c | 0xFF000000;
-  std::stringstream ss;
-  ss << std::hex << std::setfill('0') << std::setw(8) << argb;
-  std::string result = ss.str();
-  // Convert to uppercase (OpenXLSX expects uppercase hex)
-  for (char& ch : result) {
-    ch = std::toupper(ch);
-  }
-  return result;
-}
-
 HybridXlsxCellFormat::HybridXlsxCellFormat()
     : HybridObject("XlsxCellFormat"), HybridXlsxCellFormatSpec() {
 }
@@ -26,263 +9,180 @@ HybridXlsxCellFormat::HybridXlsxCellFormat()
 HybridXlsxCellFormat::~HybridXlsxCellFormat() {
 }
 
-OpenXLSX::XLStyleIndex HybridXlsxCellFormat::applyToDocument(OpenXLSX::XLStyles& styles) {
-  if (_styleIndex.has_value()) {
-    return *_styleIndex;
-  }
-
-  // Create cell format in document first to get a valid XML node.
-  // OpenXLSX default-constructed style objects have empty XML nodes;
-  // setters on empty nodes silently fail. We must create the node in
-  // the document first, then modify the live node via operator[].
-  OpenXLSX::XLCellFormat emptyCellFormat;
-  OpenXLSX::XLStyleIndex cellFormatIndex = styles.cellFormats().create(emptyCellFormat);
-  OpenXLSX::XLCellFormat cellFormat = styles.cellFormats()[cellFormatIndex];
-
-  // Font
-  if (!_fontName.empty() || _fontSize > 0 || _fontColor > 0 || _bold || _italic || _underline > 0 || _strikeout || _fontScript > 0) {
-    OpenXLSX::XLFont emptyFont;
-    OpenXLSX::XLStyleIndex fontIndex = styles.fonts().create(emptyFont);
-    OpenXLSX::XLFont font = styles.fonts()[fontIndex];
-    if (!_fontName.empty()) font.setFontName(_fontName);
-    if (_fontSize > 0) font.setFontSize(static_cast<size_t>(_fontSize));
-    if (_fontColor > 0) font.setFontColor(OpenXLSX::XLColor(doubleToHexColor(_fontColor)));
-    if (_bold) font.setBold();
-    if (_italic) font.setItalic();
-    if (_underline > 0) font.setUnderline(static_cast<OpenXLSX::XLUnderlineStyle>(_underline));
-    if (_strikeout) font.setStrikethrough();
-    if (_fontScript > 0) font.setVertAlign(static_cast<OpenXLSX::XLVerticalAlignRunStyle>(_fontScript));
-    cellFormat.setFontIndex(fontIndex);
-    cellFormat.setApplyFont(true);
-  }
-
-  // Alignment
-  if (_textWrap || _rotation != 0 || _indent > 0 || _align > 0 || _verticalAlign > 0 || _shrink) {
-    if (_align > 0) cellFormat.alignment(true).setHorizontal(static_cast<OpenXLSX::XLAlignmentStyle>(_align));
-    if (_verticalAlign > 0) cellFormat.alignment(true).setVertical(static_cast<OpenXLSX::XLAlignmentStyle>(_verticalAlign));
-    if (_textWrap) cellFormat.alignment(true).setWrapText();
-    if (_rotation != 0) cellFormat.alignment(true).setTextRotation(static_cast<uint16_t>(_rotation));
-    if (_indent > 0) cellFormat.alignment(true).setIndent(static_cast<uint32_t>(_indent));
-    if (_shrink) cellFormat.alignment(true).setShrinkToFit();
-    cellFormat.setApplyAlignment(true);
-  }
-
-  // Number format
-  if (!_numFormat.empty()) {
-    OpenXLSX::XLNumberFormat emptyNumFormat;
-    OpenXLSX::XLStyleIndex numFmtIndex = styles.numberFormats().create(emptyNumFormat);
-    OpenXLSX::XLNumberFormat numFormat = styles.numberFormats()[numFmtIndex];
-    numFormat.setFormatCode(_numFormat);
-    // Assign a unique custom numFmtId (>= 164 for user-defined formats)
-    static uint32_t nextCustomNumFmtId = 164;
-    numFormat.setNumberFormatId(nextCustomNumFmtId++);
-    cellFormat.setNumberFormatId(numFormat.numberFormatId());
-    cellFormat.setApplyNumberFormat(true);
-  }
-
-  // Fill
-  if (_bgColor > 0 || _fgColor > 0 || _pattern > 0) {
-    OpenXLSX::XLFill emptyFill;
-    OpenXLSX::XLStyleIndex fillIndex = styles.fills().create(emptyFill);
-    OpenXLSX::XLFill fill = styles.fills()[fillIndex];
-    fill.setPatternType(_pattern > 0
-      ? static_cast<OpenXLSX::XLPatternType>(_pattern)
-      : OpenXLSX::XLPatternType::XLPatternSolid);
-    if (_bgColor > 0) fill.setBackgroundColor(OpenXLSX::XLColor(doubleToHexColor(_bgColor)));
-    if (_fgColor > 0) fill.setColor(OpenXLSX::XLColor(doubleToHexColor(_fgColor)));
-    cellFormat.setFillIndex(fillIndex);
-    cellFormat.setApplyFill(true);
-  }
-
-  // Border
-  if (_border > 0 || _bottom > 0 || _top > 0 || _left > 0 || _right > 0 || _diagonal > 0) {
-    OpenXLSX::XLBorder emptyBorder;
-    OpenXLSX::XLStyleIndex borderIndex = styles.borders().create(emptyBorder);
-    OpenXLSX::XLBorder border = styles.borders()[borderIndex];
-    // TODO: Implement border styling with OpenXLSX v0.5.1 API
-    cellFormat.setBorderIndex(borderIndex);
-    cellFormat.setApplyBorder(true);
-  }
-
-  // Protection
-  if (_locked) {
-    cellFormat.setLocked(true);
-    cellFormat.setApplyProtection(true);
-  }
-
-  _styleIndex = cellFormatIndex;
-  return cellFormatIndex;
+OpenXLSX::XLStyleIndex HybridXlsxCellFormat::applyToDocument(OpenXLSX::XLStyles& styles, uint64_t documentGeneration) {
+  return _fmt.applyToDocument(styles, documentGeneration);
 }
 
 void HybridXlsxCellFormat::applyToCell(OpenXLSX::XLCell& cell, OpenXLSX::XLStyleIndex styleIndex) {
-  cell.setCellFormat(styleIndex);
+  _fmt.applyToCell(cell, styleIndex);
 }
 
 void HybridXlsxCellFormat::setFontName(const std::string& name) {
-  _fontName = name;
+  _fmt.setFontName(name);
 }
 
 void HybridXlsxCellFormat::setFontSize(double size) {
-  _fontSize = size;
+  _fmt.setFontSize(size);
 }
 
 void HybridXlsxCellFormat::setFontColor(double color) {
-  _fontColor = color;
+  _fmt.setFontColor(color);
 }
 
 void HybridXlsxCellFormat::setFontScript(double style) {
-  _fontScript = style;
+  _fmt.setFontScript(style);
 }
 
 void HybridXlsxCellFormat::setBold() {
-  _bold = true;
+  _fmt.setBold();
 }
 
 void HybridXlsxCellFormat::setItalic() {
-  _italic = true;
+  _fmt.setItalic();
 }
 
 void HybridXlsxCellFormat::setUnderline(std::optional<double> style) {
-  _underline = style.has_value() ? *style : 1;
+  _fmt.setUnderline(style);
 }
 
 void HybridXlsxCellFormat::setStrikeout() {
-  _strikeout = true;
+  _fmt.setStrikeout();
 }
 
 void HybridXlsxCellFormat::setAlign(double align) {
-  _align = align;
+  _fmt.setAlign(align);
 }
 
 void HybridXlsxCellFormat::setVerticalAlign(double align) {
-  _verticalAlign = align;
+  _fmt.setVerticalAlign(align);
 }
 
 void HybridXlsxCellFormat::setTextWrap() {
-  _textWrap = true;
+  _fmt.setTextWrap();
 }
 
 void HybridXlsxCellFormat::setRotation(double angle) {
-  _rotation = angle;
+  _fmt.setRotation(angle);
 }
 
 void HybridXlsxCellFormat::setIndent(double level) {
-  _indent = level;
+  _fmt.setIndent(level);
 }
 
 void HybridXlsxCellFormat::setShrink() {
-  _shrink = true;
+  _fmt.setShrink();
 }
 
 void HybridXlsxCellFormat::setNumFormat(const std::string& format) {
-  _numFormat = format;
+  _fmt.setNumFormat(format);
 }
 
 void HybridXlsxCellFormat::setNumFormatIndex(double index) {
-  _numFormatIndex = index;
+  _fmt.setNumFormatIndex(index);
 }
 
 void HybridXlsxCellFormat::setBgColor(double color) {
-  _bgColor = color;
+  _fmt.setBgColor(color);
 }
 
 void HybridXlsxCellFormat::setFgColor(double color) {
-  _fgColor = color;
+  _fmt.setFgColor(color);
 }
 
 void HybridXlsxCellFormat::setPattern(double pattern) {
-  _pattern = pattern;
+  _fmt.setPattern(pattern);
 }
 
 void HybridXlsxCellFormat::setBorder(double style) {
-  _border = style;
+  _fmt.setBorder(style);
 }
 
 void HybridXlsxCellFormat::setBorderColor(double color) {
-  _borderColor = color;
+  _fmt.setBorderColor(color);
 }
 
 void HybridXlsxCellFormat::setBottom(double style) {
-  _bottom = style;
+  _fmt.setBottom(style);
 }
 
 void HybridXlsxCellFormat::setTop(double style) {
-  _top = style;
+  _fmt.setTop(style);
 }
 
 void HybridXlsxCellFormat::setLeft(double style) {
-  _left = style;
+  _fmt.setLeft(style);
 }
 
 void HybridXlsxCellFormat::setRight(double style) {
-  _right = style;
+  _fmt.setRight(style);
 }
 
 void HybridXlsxCellFormat::setBottomColor(double color) {
-  _bottomColor = color;
+  _fmt.setBottomColor(color);
 }
 
 void HybridXlsxCellFormat::setTopColor(double color) {
-  _topColor = color;
+  _fmt.setTopColor(color);
 }
 
 void HybridXlsxCellFormat::setLeftColor(double color) {
-  _leftColor = color;
+  _fmt.setLeftColor(color);
 }
 
 void HybridXlsxCellFormat::setRightColor(double color) {
-  _rightColor = color;
+  _fmt.setRightColor(color);
 }
 
 void HybridXlsxCellFormat::setDiagonal(double style) {
-  _diagonal = style;
+  _fmt.setDiagonal(style);
 }
 
 void HybridXlsxCellFormat::setDiagonalColor(double color) {
-  _diagonalColor = color;
+  _fmt.setDiagonalColor(color);
 }
 
 void HybridXlsxCellFormat::setLocked() {
-  _locked = true;
+  _fmt.setLocked();
 }
 
 void HybridXlsxCellFormat::setUnlocked() {
-  _locked = false;
+  _fmt.setUnlocked();
 }
 
 void HybridXlsxCellFormat::setHyperlink() {
-  _hyperlink = true;
+  _fmt.setHyperlink();
 }
 
 void HybridXlsxCellFormat::setFontOnly() {
+  _fmt.setFontOnly();
 }
 
 std::string HybridXlsxCellFormat::getFontName() {
-  return _fontName;
+  return _fmt.getFontName();
 }
 
 double HybridXlsxCellFormat::getFontSize() {
-  return _fontSize;
+  return _fmt.getFontSize();
 }
 
 double HybridXlsxCellFormat::getFontColor() {
-  return _fontColor;
+  return _fmt.getFontColor();
 }
 
 bool HybridXlsxCellFormat::getIsBold() {
-  return _bold;
+  return _fmt.getIsBold();
 }
 
 bool HybridXlsxCellFormat::getIsItalic() {
-  return _italic;
+  return _fmt.getIsItalic();
 }
 
 std::string HybridXlsxCellFormat::getNumFormat() {
-  return _numFormat;
+  return _fmt.getNumFormat();
 }
 
 double HybridXlsxCellFormat::getBgColor() {
-  return _bgColor;
+  return _fmt.getBgColor();
 }
 
-}
+}