react-native-nitro-xlsx 0.1.1

package/cpp/HybridNitroXlsx.cpp

@@ -0,0 +1,29 @@
+#include "HybridNitroXlsx.hpp"
+#include <fstream>
+
+namespace margelo::nitro::xlsx {
+
+HybridNitroXlsx::HybridNitroXlsx()
+    : HybridObject("NitroXlsx"), HybridNitroXlsxSpec() {
+}
+
+HybridNitroXlsx::~HybridNitroXlsx() {
+}
+
+std::shared_ptr<HybridXlsxWorkbookSpec> HybridNitroXlsx::createWorkbook() {
+  return std::make_shared<HybridXlsxWorkbook>();
+}
+
+std::shared_ptr<HybridXlsxWorkbookSpec> HybridNitroXlsx::openWorkbook(const std::string& path) {
+  auto workbook = std::make_shared<HybridXlsxWorkbook>();
+  workbook->openFromFile(path);
+  return workbook;
+}
+
+std::shared_ptr<HybridXlsxWorkbookSpec> HybridNitroXlsx::openWorkbookFromBuffer(const std::shared_ptr<ArrayBuffer>& buffer) {
+  auto workbook = std::make_shared<HybridXlsxWorkbook>();
+  workbook->openFromBuffer(buffer->data(), buffer->size());
+  return workbook;
+}
+
+}

package/cpp/HybridNitroXlsx.hpp

@@ -0,0 +1,19 @@
+#pragma once
+
+#include "HybridNitroXlsxSpec.hpp"
+#include <memory>
+#include "HybridXlsxWorkbook.hpp"
+
+namespace margelo::nitro::xlsx {
+
+class HybridNitroXlsx : public HybridNitroXlsxSpec {
+public:
+  HybridNitroXlsx();
+  ~HybridNitroXlsx() override;
+
+  std::shared_ptr<HybridXlsxWorkbookSpec> createWorkbook() override;
+  std::shared_ptr<HybridXlsxWorkbookSpec> openWorkbook(const std::string& path) override;
+  std::shared_ptr<HybridXlsxWorkbookSpec> openWorkbookFromBuffer(const std::shared_ptr<ArrayBuffer>& buffer) override;
+};
+
+}

package/cpp/HybridXlsxCellFormat.cpp

@@ -0,0 +1,263 @@
+#include "HybridXlsxCellFormat.hpp"
+#include <sstream>
+#include <iomanip>
+
+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;
+  return ss.str();
+}
+
+HybridXlsxCellFormat::HybridXlsxCellFormat()
+    : HybridObject("XlsxCellFormat"), HybridXlsxCellFormatSpec() {
+}
+
+HybridXlsxCellFormat::~HybridXlsxCellFormat() {
+}
+
+OpenXLSX::XLStyleIndex HybridXlsxCellFormat::applyToDocument(OpenXLSX::XLStyles& styles) {
+  OpenXLSX::XLCellFormat cellFormat;
+
+  // Font
+  if (!_fontName.empty() || _fontSize > 0 || _fontColor > 0 || _bold || _italic || _underline > 0 || _strikeout || _fontScript > 0) {
+    OpenXLSX::XLFont font;
+    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(styles.fonts().create(font));
+    cellFormat.setApplyFont(true);
+  }
+
+  // Alignment
+  if (_textWrap || _rotation != 0 || _indent > 0 || _align > 0 || _verticalAlign > 0 || _shrink) {
+    auto alignment = cellFormat.alignment(true);
+    if (_align > 0) alignment.setHorizontal(static_cast<OpenXLSX::XLAlignmentStyle>(_align));
+    if (_verticalAlign > 0) alignment.setVertical(static_cast<OpenXLSX::XLAlignmentStyle>(_verticalAlign));
+    if (_textWrap) alignment.setWrapText();
+    if (_rotation != 0) alignment.setTextRotation(static_cast<uint16_t>(_rotation));
+    if (_indent > 0) alignment.setIndent(static_cast<uint32_t>(_indent));
+    if (_shrink) alignment.setShrinkToFit();
+    cellFormat.setApplyAlignment(true);
+  }
+
+  // Number format
+  if (!_numFormat.empty()) {
+    OpenXLSX::XLNumberFormat numFormat;
+    numFormat.setFormatCode(_numFormat);
+    OpenXLSX::XLStyleIndex numFmtIndex = styles.numberFormats().create(numFormat);
+    uint32_t numFmtId = styles.numberFormats().numberFormatIdFromIndex(numFmtIndex);
+    cellFormat.setNumberFormatId(numFmtId);
+    cellFormat.setApplyNumberFormat(true);
+  }
+
+  // Fill
+  if (_bgColor > 0 || _fgColor > 0 || _pattern > 0) {
+    OpenXLSX::XLFill fill;
+    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(styles.fills().create(fill));
+    cellFormat.setApplyFill(true);
+  }
+
+  // Border
+  if (_border > 0 || _bottom > 0 || _top > 0 || _left > 0 || _right > 0 || _diagonal > 0) {
+    OpenXLSX::XLBorder border;
+    // TODO: Implement border styling with OpenXLSX v0.5.1 API
+    cellFormat.setBorderIndex(styles.borders().create(border));
+    cellFormat.setApplyBorder(true);
+  }
+
+  // Protection
+  if (_locked) {
+    cellFormat.setLocked(true);
+    cellFormat.setApplyProtection(true);
+  }
+
+  return styles.cellFormats().create(cellFormat);
+}
+
+void HybridXlsxCellFormat::applyToCell(OpenXLSX::XLCell& cell, OpenXLSX::XLStyleIndex styleIndex) {
+  cell.setCellFormat(styleIndex);
+}
+
+void HybridXlsxCellFormat::setFontName(const std::string& name) {
+  _fontName = name;
+}
+
+void HybridXlsxCellFormat::setFontSize(double size) {
+  _fontSize = size;
+}
+
+void HybridXlsxCellFormat::setFontColor(double color) {
+  _fontColor = color;
+}
+
+void HybridXlsxCellFormat::setFontScript(double style) {
+  _fontScript = style;
+}
+
+void HybridXlsxCellFormat::setBold() {
+  _bold = true;
+}
+
+void HybridXlsxCellFormat::setItalic() {
+  _italic = true;
+}
+
+void HybridXlsxCellFormat::setUnderline(std::optional<double> style) {
+  _underline = style.has_value() ? *style : 1;
+}
+
+void HybridXlsxCellFormat::setStrikeout() {
+  _strikeout = true;
+}
+
+void HybridXlsxCellFormat::setAlign(double align) {
+  _align = align;
+}
+
+void HybridXlsxCellFormat::setVerticalAlign(double align) {
+  _verticalAlign = align;
+}
+
+void HybridXlsxCellFormat::setTextWrap() {
+  _textWrap = true;
+}
+
+void HybridXlsxCellFormat::setRotation(double angle) {
+  _rotation = angle;
+}
+
+void HybridXlsxCellFormat::setIndent(double level) {
+  _indent = level;
+}
+
+void HybridXlsxCellFormat::setShrink() {
+  _shrink = true;
+}
+
+void HybridXlsxCellFormat::setNumFormat(const std::string& format) {
+  _numFormat = format;
+}
+
+void HybridXlsxCellFormat::setNumFormatIndex(double index) {
+  _numFormatIndex = index;
+}
+
+void HybridXlsxCellFormat::setBgColor(double color) {
+  _bgColor = color;
+}
+
+void HybridXlsxCellFormat::setFgColor(double color) {
+  _fgColor = color;
+}
+
+void HybridXlsxCellFormat::setPattern(double pattern) {
+  _pattern = pattern;
+}
+
+void HybridXlsxCellFormat::setBorder(double style) {
+  _border = style;
+}
+
+void HybridXlsxCellFormat::setBorderColor(double color) {
+  _borderColor = color;
+}
+
+void HybridXlsxCellFormat::setBottom(double style) {
+  _bottom = style;
+}
+
+void HybridXlsxCellFormat::setTop(double style) {
+  _top = style;
+}
+
+void HybridXlsxCellFormat::setLeft(double style) {
+  _left = style;
+}
+
+void HybridXlsxCellFormat::setRight(double style) {
+  _right = style;
+}
+
+void HybridXlsxCellFormat::setBottomColor(double color) {
+  _bottomColor = color;
+}
+
+void HybridXlsxCellFormat::setTopColor(double color) {
+  _topColor = color;
+}
+
+void HybridXlsxCellFormat::setLeftColor(double color) {
+  _leftColor = color;
+}
+
+void HybridXlsxCellFormat::setRightColor(double color) {
+  _rightColor = color;
+}
+
+void HybridXlsxCellFormat::setDiagonal(double style) {
+  _diagonal = style;
+}
+
+void HybridXlsxCellFormat::setDiagonalColor(double color) {
+  _diagonalColor = color;
+}
+
+void HybridXlsxCellFormat::setLocked() {
+  _locked = true;
+}
+
+void HybridXlsxCellFormat::setUnlocked() {
+  _locked = false;
+}
+
+void HybridXlsxCellFormat::setHyperlink() {
+  _hyperlink = true;
+}
+
+void HybridXlsxCellFormat::setFontOnly() {
+}
+
+std::string HybridXlsxCellFormat::getFontName() {
+  return _fontName;
+}
+
+double HybridXlsxCellFormat::getFontSize() {
+  return _fontSize;
+}
+
+double HybridXlsxCellFormat::getFontColor() {
+  return _fontColor;
+}
+
+bool HybridXlsxCellFormat::getIsBold() {
+  return _bold;
+}
+
+bool HybridXlsxCellFormat::getIsItalic() {
+  return _italic;
+}
+
+std::string HybridXlsxCellFormat::getNumFormat() {
+  return _numFormat;
+}
+
+double HybridXlsxCellFormat::getBgColor() {
+  return _bgColor;
+}
+
+}

package/cpp/HybridXlsxCellFormat.hpp

@@ -0,0 +1,111 @@
+#pragma once
+
+#include "HybridXlsxCellFormatSpec.hpp"
+#include <OpenXLSX/XLDocument.hpp>
+#include <OpenXLSX/XLSheet.hpp>
+#include <OpenXLSX/XLStyles.hpp>
+#include <string>
+#include <memory>
+
+namespace margelo::nitro::xlsx {
+
+class HybridXlsxCellFormat : public HybridXlsxCellFormatSpec {
+public:
+  HybridXlsxCellFormat();
+  ~HybridXlsxCellFormat() override;
+
+  OpenXLSX::XLStyleIndex applyToDocument(OpenXLSX::XLStyles& styles);
+  void applyToCell(OpenXLSX::XLCell& cell, OpenXLSX::XLStyleIndex styleIndex);
+
+  void setFontName(const std::string& name) override;
+  void setFontSize(double size) override;
+  void setFontColor(double color) override;
+  void setFontScript(double style) override;
+  void setBold() override;
+  void setItalic() override;
+  void setUnderline(std::optional<double> style) override;
+  void setStrikeout() override;
+  
+  void setAlign(double align) override;
+  void setVerticalAlign(double align) override;
+  void setTextWrap() override;
+  void setRotation(double angle) override;
+  void setIndent(double level) override;
+  void setShrink() override;
+  
+  void setNumFormat(const std::string& format) override;
+  void setNumFormatIndex(double index) override;
+  
+  void setBgColor(double color) override;
+  void setFgColor(double color) override;
+  void setPattern(double pattern) override;
+  
+  void setBorder(double style) override;
+  void setBorderColor(double color) override;
+  void setBottom(double style) override;
+  void setTop(double style) override;
+  void setLeft(double style) override;
+  void setRight(double style) override;
+  void setBottomColor(double color) override;
+  void setTopColor(double color) override;
+  void setLeftColor(double color) override;
+  void setRightColor(double color) override;
+  void setDiagonal(double style) override;
+  void setDiagonalColor(double color) override;
+  
+  void setLocked() override;
+  void setUnlocked() override;
+  
+  void setHyperlink() override;
+  void setFontOnly() override;
+
+  std::string getFontName() override;
+  double getFontSize() override;
+  double getFontColor() override;
+  bool getIsBold() override;
+  bool getIsItalic() override;
+  std::string getNumFormat() override;
+  double getBgColor() override;
+
+private:
+  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;
+};
+
+}

package/cpp/HybridXlsxWorkbook.cpp

@@ -0,0 +1,184 @@
+#include "HybridXlsxWorkbook.hpp"
+#include <stdexcept>
+#include <fstream>
+#include <sstream>
+#include <cstdlib>
+#include <unistd.h>
+
+#ifdef __ANDROID__
+#include <android/api-level.h>
+#include <sys/stat.h>
+#endif
+
+namespace margelo::nitro::xlsx {
+
+namespace {
+  std::string getTempDir() {
+#ifdef __ANDROID__
+    // /tmp is typically not available in Android sandbox, use app's cache directory
+      const char* cacheDir = std::getenv("TMPDIR");
+    if (cacheDir != nullptr && cacheDir[0] != '\0') {
+      return std::string(cacheDir);
+    }
+    // Try common Android cache directories
+    const char* candidates[] = {
+      "/data/local/tmp",
+      "/data/data/tmp",
+      "/sdcard/tmp",
+      "/tmp"
+    };
+    for (const char* dir : candidates) {
+      struct stat st;
+      if (stat(dir, &st) == 0 && S_ISDIR(st.st_mode)) {
+        return std::string(dir);
+      }
+    }
+    return "/data/local/tmp";
+#else
+    return "/tmp";
+#endif
+  }
+}
+
+HybridXlsxWorkbook::HybridXlsxWorkbook()
+    : HybridObject("XlsxWorkbook"), HybridXlsxWorkbookSpec(), _finalized(false) {
+  _workbook = std::make_unique<OpenXLSX::XLDocument>();
+  _tempDir = getTempDir();
+}
+
+HybridXlsxWorkbook::~HybridXlsxWorkbook() {
+}
+
+void HybridXlsxWorkbook::openFromFile(const std::string& path) {
+  _workbook->open(path);
+  loadWorksheets();
+}
+
+void HybridXlsxWorkbook::openFromBuffer(const uint8_t* data, size_t size) {
+  std::string tempPath = _tempDir + "/xlsx_open_" + std::to_string(std::chrono::system_clock::now().time_since_epoch().count()) + ".xlsx";
+  std::ofstream file(tempPath, std::ios::binary);
+  file.write(reinterpret_cast<const char*>(data), size);
+  file.close();
+
+  _workbook->open(tempPath);
+  std::remove(tempPath.c_str());
+  loadWorksheets();
+}
+
+void HybridXlsxWorkbook::loadWorksheets() {
+  _worksheets.clear();
+  _worksheetNames.clear();
+  
+  auto wb = _workbook->workbook();
+  auto count = wb.worksheetCount();
+  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);
+    _worksheets.push_back(hybridWorksheet);
+    _worksheetNames[sheetName] = hybridWorksheet;
+  }
+}
+
+std::shared_ptr<HybridXlsxWorksheetSpec> HybridXlsxWorkbook::addWorksheet(const std::optional<std::string>& name) {
+  if (!_workbook->isOpen()) {
+    std::string tempPath = _tempDir + "/xlsx_create_" + std::to_string(std::chrono::system_clock::now().time_since_epoch().count()) + ".xlsx";
+    _workbook->create(tempPath, OpenXLSX::XLForceOverwrite);
+    std::remove(tempPath.c_str());
+    loadWorksheets();
+  }
+
+  std::string sheetName;
+  if (name.has_value()) {
+    sheetName = *name;
+    auto it = _worksheetNames.find(sheetName);
+    if (it != _worksheetNames.end()) {
+      throw std::runtime_error("Sheet named '" + sheetName + "' already exists");
+    }
+  } else {
+    int idx = 1;
+    do {
+      sheetName = "Sheet" + std::to_string(idx++);
+    } while (_worksheetNames.count(sheetName) > 0);
+  }
+
+  _workbook->workbook().addWorksheet(sheetName);
+  auto worksheet = _workbook->workbook().worksheet(sheetName);
+  auto hybridWorksheet = std::make_shared<HybridXlsxWorksheet>(*_workbook, worksheet);
+  _worksheets.push_back(hybridWorksheet);
+  _worksheetNames[sheetName] = hybridWorksheet;
+  return hybridWorksheet;
+}
+
+std::shared_ptr<HybridXlsxWorksheetSpec> HybridXlsxWorkbook::getWorksheet(double index) {
+  size_t idx = static_cast<size_t>(index);
+  if (idx >= _worksheets.size()) {
+    throw std::runtime_error("Worksheet index out of range: " + std::to_string(idx));
+  }
+  return _worksheets[idx];
+}
+
+std::shared_ptr<HybridXlsxWorksheetSpec> HybridXlsxWorkbook::getWorksheetByName(const std::string& name) {
+  auto it = _worksheetNames.find(name);
+  if (it == _worksheetNames.end()) {
+    throw std::runtime_error("Worksheet not found: " + name);
+  }
+  return it->second;
+}
+
+std::shared_ptr<HybridXlsxWorksheetSpec> HybridXlsxWorkbook::getOrAddWorksheet(const std::string& name) {
+  auto it = _worksheetNames.find(name);
+  if (it != _worksheetNames.end()) {
+    return it->second;
+  }
+  return addWorksheet(name);
+}
+
+double HybridXlsxWorkbook::getWorksheetCount() {
+  return static_cast<double>(_workbook->workbook().worksheetCount());
+}
+
+std::shared_ptr<HybridXlsxCellFormatSpec> HybridXlsxWorkbook::addCellFormat() {
+  auto hybridFormat = std::make_shared<HybridXlsxCellFormat>();
+  _cellFormats.push_back(hybridFormat);
+  return hybridFormat;
+}
+
+std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>> HybridXlsxWorkbook::getBuffer() {
+  auto promise = Promise<std::shared_ptr<ArrayBuffer>>::create();
+
+  if (_finalized) {
+    promise->reject(std::make_exception_ptr(std::runtime_error("Workbook has already been finalized")));
+    return promise;
+  }
+
+  try {
+    std::string tempPath = _tempDir + "/xlsx_temp_" + std::to_string(std::chrono::system_clock::now().time_since_epoch().count()) + ".xlsx";
+    _workbook->saveAs(tempPath, OpenXLSX::XLForceOverwrite);
+    
+    std::ifstream file(tempPath, std::ios::binary | std::ios::ate);
+    if (!file.is_open()) {
+      promise->reject(std::make_exception_ptr(std::runtime_error("Failed to open temp file")));
+      return promise;
+    }
+    
+    std::streampos size = file.tellg();
+    std::vector<uint8_t> buffer(size);
+    file.seekg(0, std::ios::beg);
+    file.read(reinterpret_cast<char*>(buffer.data()), size);
+    file.close();
+    
+    std::remove(tempPath.c_str());
+    
+    auto arrayBuffer = ArrayBuffer::copy(buffer.data(), buffer.size());
+    _finalized = true;
+    
+    promise->resolve(arrayBuffer);
+  } catch (const std::exception& e) {
+    promise->reject(std::make_exception_ptr(e));
+  }
+  
+  return promise;
+}
+
+}

package/cpp/HybridXlsxWorkbook.hpp

@@ -0,0 +1,41 @@
+#pragma once
+
+#include "HybridXlsxWorkbookSpec.hpp"
+#include <OpenXLSX/XLDocument.hpp>
+#include <memory>
+#include <string>
+#include <vector>
+#include <unordered_map>
+#include "HybridXlsxWorksheet.hpp"
+#include "HybridXlsxCellFormat.hpp"
+
+namespace margelo::nitro::xlsx {
+
+class HybridXlsxWorkbook : public HybridXlsxWorkbookSpec {
+public:
+  HybridXlsxWorkbook();
+  ~HybridXlsxWorkbook() override;
+
+  void openFromFile(const std::string& path);
+  void openFromBuffer(const uint8_t* data, size_t size);
+
+  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;
+  std::shared_ptr<HybridXlsxWorksheetSpec> getOrAddWorksheet(const std::string& name) override;
+  double getWorksheetCount() override;
+  std::shared_ptr<HybridXlsxCellFormatSpec> addCellFormat() override;
+  std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>> getBuffer() override;
+
+private:
+  std::unique_ptr<OpenXLSX::XLDocument> _workbook;
+  std::vector<std::shared_ptr<HybridXlsxWorksheet>> _worksheets;
+  std::unordered_map<std::string, std::shared_ptr<HybridXlsxWorksheet>> _worksheetNames;
+  std::vector<std::shared_ptr<HybridXlsxCellFormat>> _cellFormats;
+  bool _finalized;
+  std::string _tempDir;
+
+  void loadWorksheets();
+};
+
+}