react-native-nitro-xlsx 0.2.5 → 0.2.7

package/cpp/HybridXlsxCellFormat.hpp

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "HybridXlsxCellFormatSpec.hpp"
+#include "XlsxCellStyle.hpp"
 #include <OpenXLSX/XLDocument.hpp>
 #include <OpenXLSX/XLSheet.hpp>
 #include <OpenXLSX/XLStyles.hpp>
@@ -14,7 +15,11 @@ public:
   HybridXlsxCellFormat();
   ~HybridXlsxCellFormat() override;
 
-  OpenXLSX::XLStyleIndex applyToDocument(OpenXLSX::XLStyles& styles);
+  // `documentGeneration` identifies the XLDocument that owns `styles` (see
+  // HybridXlsxWorkbook::documentGeneration()). It must be passed on every call
+  // so the style cache can never be reused by a different document that happens
+  // to reuse the same heap address.
+  OpenXLSX::XLStyleIndex applyToDocument(OpenXLSX::XLStyles& styles, uint64_t documentGeneration);
   void applyToCell(OpenXLSX::XLCell& cell, OpenXLSX::XLStyleIndex styleIndex);
 
   void setFontName(const std::string& name) override;
@@ -68,45 +73,8 @@ public:
   double getBgColor() override;
 
 private:
-  std::optional<OpenXLSX::XLStyleIndex> _styleIndex;
-  std::string _fontName;
-  double _fontSize = 0;
-  double _fontColor = 0;
-  double _fontScript = 0;
-  bool _bold = false;
-  bool _italic = false;
-  double _underline = 0;
-  bool _strikeout = false;
-  
-  double _align = 0;
-  double _verticalAlign = 0;
-  bool _textWrap = false;
-  double _rotation = 0;
-  double _indent = 0;
-  bool _shrink = false;
-  
-  std::string _numFormat;
-  double _numFormatIndex = 0;
-  
-  double _bgColor = 0;
-  double _fgColor = 0;
-  double _pattern = 0;
-  
-  double _border = 0;
-  double _borderColor = 0;
-  double _bottom = 0;
-  double _top = 0;
-  double _left = 0;
-  double _right = 0;
-  double _bottomColor = 0;
-  double _topColor = 0;
-  double _leftColor = 0;
-  double _rightColor = 0;
-  double _diagonal = 0;
-  double _diagonalColor = 0;
-  
-  bool _locked = false;
-  bool _hyperlink = false;
+  // Style state and styles.xml materialization, shared with the unit tests.
+  XlsxCellStyle _fmt;
 };
 
-}
+}

package/cpp/HybridXlsxConditionalFormat.cpp

@@ -84,9 +84,12 @@ void HybridXlsxConditionalFormat::setRuleDxfId(double index, double dxfId) {
 
 std::string HybridXlsxConditionalFormat::getRuleFormula(double index, double formulaIndex) {
   return withXlsxError(xlsx_error::XLSX_ERROR, [&] {
+    // Validate the rule index first so out-of-range throws INDEX_OUT_OF_RANGE
+    // like every other getter (and like setRuleFormula).
+    auto rule = ruleAt(index);
     // OpenXLSX only supports the primary <formula> node
     if (formulaIndex != 0) return std::string();
-    return ruleAt(index).formula();
+    return rule.formula();
   });
 }
 

package/cpp/HybridXlsxConditionalFormats.cpp

@@ -19,7 +19,11 @@ std::shared_ptr<HybridXlsxConditionalFormatSpec> HybridXlsxConditionalFormats::c
   return withXlsxError(xlsx_error::XLSX_ERROR, [&] {
     size_t index = _formats.create();
     OpenXLSX::XLConditionalFormat format = _formats.conditionalFormatByIndex(index);
-    format.setSqref(sqref);
+    // setSqref() returns false when it cannot apply the value (and treats an empty
+    // attribute value as a no-op), so a blank sqref is rejected explicitly too.
+    if (sqref.empty() || !format.setSqref(sqref)) {
+      throw XlsxError(xlsx_error::INVALID_ARGUMENT, "Invalid sqref: " + sqref);
+    }
     auto hybrid = std::make_shared<HybridXlsxConditionalFormat>(format);
     _created.push_back(hybrid);
     return std::static_pointer_cast<HybridXlsxConditionalFormatSpec>(hybrid);

package/cpp/HybridXlsxWorkbook.cpp

@@ -33,17 +33,34 @@ HybridXlsxWorkbook::~HybridXlsxWorkbook() {
 
 void HybridXlsxWorkbook::openFromFile(const std::string& path) {
   _workbook->open(path);
+  ++_generation;
   loadWorksheets();
 }
 
 void HybridXlsxWorkbook::openFromBuffer(const uint8_t* data, size_t size) {
   std::string tempPath = tempFilePath("xlsx_open");
-  std::ofstream file(tempPath, std::ios::binary);
-  file.write(reinterpret_cast<const char*>(data), size);
-  file.close();
+  {
+    std::ofstream file(tempPath, std::ios::binary);
+    if (!file.is_open()) {
+      throw XlsxError(xlsx_error::IO_ERROR, "Failed to open temp file for writing: " + tempPath);
+    }
+    file.write(reinterpret_cast<const char*>(data), static_cast<std::streamsize>(size));
+    file.close();
+    if (file.fail()) {
+      std::remove(tempPath.c_str());
+      throw XlsxError(xlsx_error::IO_ERROR, "Failed to write buffer to temp file: " + tempPath);
+    }
+  }
 
-  _workbook->open(tempPath);
+  try {
+    _workbook->open(tempPath);
+  } catch (...) {
+    // Never leak the temp file when opening fails.
+    std::remove(tempPath.c_str());
+    throw;
+  }
   std::remove(tempPath.c_str());
+  ++_generation;
   loadWorksheets();
 }
 
@@ -56,7 +73,7 @@ void HybridXlsxWorkbook::loadWorksheets() {
   for (uint16_t i = 1; i <= count; ++i) {
     auto worksheet = wb.worksheet(i);
     std::string sheetName = worksheet.name();
-    auto hybridWorksheet = std::make_shared<HybridXlsxWorksheet>(*_workbook, worksheet);
+    auto hybridWorksheet = std::make_shared<HybridXlsxWorksheet>(*_workbook, worksheet, _generation);
     _worksheets.push_back(hybridWorksheet);
     _worksheetNames[sheetName] = hybridWorksheet;
   }
@@ -67,6 +84,7 @@ void HybridXlsxWorkbook::ensureOpen() {
   std::string tempPath = tempFilePath("xlsx_create");
   _workbook->create(tempPath, OpenXLSX::XLForceOverwrite);
   std::remove(tempPath.c_str());
+  ++_generation;
   loadWorksheets();
 }
 
@@ -91,7 +109,7 @@ std::shared_ptr<HybridXlsxWorksheetSpec> HybridXlsxWorkbook::addWorksheet(const
 
     _workbook->workbook().addWorksheet(sheetName);
     auto worksheet = _workbook->workbook().worksheet(sheetName);
-    auto hybridWorksheet = std::make_shared<HybridXlsxWorksheet>(*_workbook, worksheet);
+    auto hybridWorksheet = std::make_shared<HybridXlsxWorksheet>(*_workbook, worksheet, _generation);
     _worksheets.push_back(hybridWorksheet);
     _worksheetNames[sheetName] = hybridWorksheet;
     return hybridWorksheet;
@@ -133,6 +151,7 @@ std::shared_ptr<HybridXlsxWorksheetSpec> HybridXlsxWorkbook::getOrAddWorksheet(c
 
 double HybridXlsxWorkbook::getWorksheetCount() {
   return withXlsxError(xlsx_error::XLSX_ERROR, [&] {
+    ensureOpen();
     return static_cast<double>(_workbook->workbook().worksheetCount());
   });
 }
@@ -200,7 +219,7 @@ std::shared_ptr<HybridXlsxWorksheetSpec> HybridXlsxWorkbook::clone(const std::st
 
     _workbook->workbook().cloneSheet(existingName, newName);
     auto worksheet = _workbook->workbook().worksheet(newName);
-    auto hybridWorksheet = std::make_shared<HybridXlsxWorksheet>(*_workbook, worksheet);
+    auto hybridWorksheet = std::make_shared<HybridXlsxWorksheet>(*_workbook, worksheet, _generation);
     _worksheets.push_back(hybridWorksheet);
     _worksheetNames[newName] = hybridWorksheet;
     return hybridWorksheet;
@@ -222,6 +241,7 @@ std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>> HybridXlsxWorkbook::getBu
   }
 
   try {
+    ensureOpen();
     std::string tempPath = tempFilePath("xlsx_temp");
     _workbook->saveAs(tempPath, OpenXLSX::XLForceOverwrite);
 
@@ -256,8 +276,18 @@ std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>> HybridXlsxWorkbook::getBu
 
 std::unordered_map<std::string, std::vector<std::shared_ptr<AnyMap>>> HybridXlsxWorkbook::toJSON() {
   return withXlsxError(xlsx_error::XLSX_ERROR, [&] {
+    ensureOpen();
     auto wb = _workbook->workbook();
-    return workbookToRecords(wb);
+    auto records = workbookToRecords(wb);
+    // Sheets without any records (e.g. the default sheet of a fresh workbook)
+    // are omitted so an empty workbook round-trips to an empty map.
+    std::unordered_map<std::string, std::vector<std::shared_ptr<AnyMap>>> result;
+    for (auto& [name, rows] : records) {
+      if (!rows.empty()) {
+        result.emplace(name, std::move(rows));
+      }
+    }
+    return result;
   });
 }
 

package/cpp/HybridXlsxWorkbook.hpp

@@ -19,6 +19,10 @@ public:
   void openFromFile(const std::string& path);
   void openFromBuffer(const uint8_t* data, size_t size);
 
+  // Ensure the underlying XLDocument has been created/opened so the workbook is
+  // usable even if it was never explicitly opened (fromJSON, createWorkbook).
+  void ensureOpen();
+
   std::shared_ptr<HybridXlsxWorksheetSpec> addWorksheet(const std::optional<std::string>& name) override;
   std::shared_ptr<HybridXlsxWorksheetSpec> getWorksheet(double index) override;
   std::shared_ptr<HybridXlsxWorksheetSpec> getWorksheetByName(const std::string& name) override;
@@ -37,10 +41,15 @@ private:
   std::unordered_map<std::string, std::shared_ptr<HybridXlsxWorksheet>> _worksheetNames;
   std::vector<std::shared_ptr<HybridXlsxCellFormat>> _cellFormats;
   bool _finalized;
+  // Identifies the current underlying XLDocument. Bumped every time the
+  // document is (re)created or opened so per-document caches (cell styles) can
+  // tell a recycled heap address apart from the document it was built for.
+  uint64_t documentGeneration() const { return _generation; }
+
   std::string _tempDir;
+  uint64_t _generation = 0;
 
   void loadWorksheets();
-  void ensureOpen();
   std::string tempFilePath(const char* prefix);
 };