react-native-nitro-xlsx 0.1.4 → 0.2.5

package/cpp/HybridXlsxWorkbook.cpp

@@ -1,4 +1,7 @@
 #include "HybridXlsxWorkbook.hpp"
+#include "XlsxError.hpp"
+#include "XlsxJson.hpp"
+#include "XlsxCacheDir.hpp"
 #include <stdexcept>
 #include <fstream>
 #include <sstream>
@@ -6,79 +9,23 @@
 #include <unistd.h>
 #include <cmath>
 #include <cstring>
-#include <iomanip>
+#include <chrono>
 
 #ifdef __ANDROID__
 #include <android/api-level.h>
 #include <sys/stat.h>
 #endif
 
-namespace {
-
-void writeJsonString(std::ostringstream& out, const std::string& s) {
-  out << '"';
-  for (char c : s) {
-    switch (c) {
-      case '"':  out << "\\\""; break;
-      case '\\': out << "\\\\"; break;
-      case '\b': out << "\\b";  break;
-      case '\f': out << "\\f";  break;
-      case '\n': out << "\\n";  break;
-      case '\r': out << "\\r";  break;
-      case '\t': out << "\\t";  break;
-      default:
-        if (static_cast<unsigned char>(c) < 0x20) {
-          out << "\\u" << std::hex << std::setw(4) << std::setfill('0')
-              << static_cast<int>(static_cast<unsigned char>(c))
-              << std::dec;
-        } else {
-          out << c;
-        }
-    }
-  }
-  out << '"';
-}
-
-} // anonymous namespace
-
 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(const std::optional<std::string>& tempDir)
+HybridXlsxWorkbook::HybridXlsxWorkbook()
     : HybridObject("XlsxWorkbook"), HybridXlsxWorkbookSpec(), _finalized(false) {
   _workbook = std::make_unique<OpenXLSX::XLDocument>();
-  if (tempDir.has_value()) {
-    _tempDir = *tempDir;
-  } else {
-    _tempDir = getTempDir();
-  }
+  _tempDir = getCacheDir();
+}
+
+std::string HybridXlsxWorkbook::tempFilePath(const char* prefix) {
+  return _tempDir + "/" + prefix + "_" + std::to_string(std::chrono::system_clock::now().time_since_epoch().count()) + ".xlsx";
 }
 
 HybridXlsxWorkbook::~HybridXlsxWorkbook() {
@@ -90,7 +37,7 @@ void HybridXlsxWorkbook::openFromFile(const std::string& path) {
 }
 
 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::string tempPath = tempFilePath("xlsx_open");
   std::ofstream file(tempPath, std::ios::binary);
   file.write(reinterpret_cast<const char*>(data), size);
   file.close();
@@ -103,7 +50,7 @@ void HybridXlsxWorkbook::openFromBuffer(const uint8_t* data, size_t size) {
 void HybridXlsxWorkbook::loadWorksheets() {
   _worksheets.clear();
   _worksheetNames.clear();
-  
+
   auto wb = _workbook->workbook();
   auto count = wb.worksheetCount();
   for (uint16_t i = 1; i <= count; ++i) {
@@ -115,63 +62,149 @@ void HybridXlsxWorkbook::loadWorksheets() {
   }
 }
 
-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();
-  }
+void HybridXlsxWorkbook::ensureOpen() {
+  if (_workbook->isOpen()) return;
+  std::string tempPath = tempFilePath("xlsx_create");
+  _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()) {
-      // Worksheet already exists (e.g., default Sheet1 created by OpenXLSX), return it
-      return it->second;
+std::shared_ptr<HybridXlsxWorksheetSpec> HybridXlsxWorkbook::addWorksheet(const std::optional<std::string>& name) {
+  return withXlsxError(xlsx_error::XLSX_ERROR, [&]() -> std::shared_ptr<HybridXlsxWorksheetSpec> {
+    ensureOpen();
+
+    std::string sheetName;
+    if (name.has_value()) {
+      sheetName = *name;
+      auto it = _worksheetNames.find(sheetName);
+      if (it != _worksheetNames.end()) {
+        // Worksheet already exists (e.g., default Sheet1 created by OpenXLSX), return it
+        return it->second;
+      }
+    } else {
+      int idx = 1;
+      do {
+        sheetName = "Sheet" + std::to_string(idx++);
+      } while (_worksheetNames.count(sheetName) > 0);
     }
-  } 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;
+    _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];
+  return withXlsxError(xlsx_error::INDEX_OUT_OF_RANGE, [&]() -> std::shared_ptr<HybridXlsxWorksheetSpec> {
+    ensureOpen();
+    size_t idx = static_cast<size_t>(index);
+    if (idx >= _worksheets.size()) {
+      throw XlsxError(xlsx_error::INDEX_OUT_OF_RANGE, "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;
+  return withXlsxError(xlsx_error::SHEET_NOT_FOUND, [&]() -> std::shared_ptr<HybridXlsxWorksheetSpec> {
+    ensureOpen();
+    auto it = _worksheetNames.find(name);
+    if (it == _worksheetNames.end()) {
+      throw XlsxError(xlsx_error::SHEET_NOT_FOUND, "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);
+  return withXlsxError(xlsx_error::XLSX_ERROR, [&]() -> std::shared_ptr<HybridXlsxWorksheetSpec> {
+    ensureOpen();
+    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());
+  return withXlsxError(xlsx_error::XLSX_ERROR, [&] {
+    return static_cast<double>(_workbook->workbook().worksheetCount());
+  });
+}
+
+void HybridXlsxWorkbook::deleteSheet(const std::string& name) {
+  withXlsxError(xlsx_error::XLSX_ERROR, [&] {
+    ensureOpen();
+    auto it = _worksheetNames.find(name);
+    if (it == _worksheetNames.end()) {
+      throw XlsxError(xlsx_error::SHEET_NOT_FOUND, "Worksheet not found: " + name);
+    }
+    if (_worksheetNames.size() <= 1) {
+      throw XlsxError(xlsx_error::INVALID_ARGUMENT, "Cannot delete the last worksheet in a workbook");
+    }
+
+    _workbook->workbook().deleteSheet(name);
+
+    // Drop the cached hybrid wrappers for the deleted sheet
+    for (auto wit = _worksheets.begin(); wit != _worksheets.end(); ++wit) {
+      if (*wit == it->second) {
+        _worksheets.erase(wit);
+        break;
+      }
+    }
+    _worksheetNames.erase(it);
+  });
+}
+
+void HybridXlsxWorkbook::updateSheetName(const std::string& oldName, const std::string& newName) {
+  withXlsxError(xlsx_error::XLSX_ERROR, [&] {
+    ensureOpen();
+    auto it = _worksheetNames.find(oldName);
+    if (it == _worksheetNames.end()) {
+      throw XlsxError(xlsx_error::SHEET_NOT_FOUND, "Worksheet not found: " + oldName);
+    }
+    if (_worksheetNames.count(newName) > 0) {
+      throw XlsxError(xlsx_error::SHEET_EXISTS, "Worksheet already exists: " + newName);
+    }
+
+    // Rename the sheet itself
+    it->second->applyRename(oldName, newName);
+
+    // Rewrite formula references on every worksheet (formulas in other sheets may reference oldName)
+    for (auto& [name, hybrid] : _worksheetNames) {
+      if (name == oldName) continue;
+      hybrid->rewriteSheetNameRef(oldName, newName);
+    }
+
+    // Refresh the name map
+    auto hybrid = it->second;
+    _worksheetNames.erase(it);
+    _worksheetNames[newName] = hybrid;
+  });
+}
+
+std::shared_ptr<HybridXlsxWorksheetSpec> HybridXlsxWorkbook::clone(const std::string& existingName, const std::string& newName) {
+  return withXlsxError(xlsx_error::XLSX_ERROR, [&]() -> std::shared_ptr<HybridXlsxWorksheetSpec> {
+    ensureOpen();
+    if (_worksheetNames.count(existingName) == 0) {
+      throw XlsxError(xlsx_error::SHEET_NOT_FOUND, "Worksheet not found: " + existingName);
+    }
+    if (_worksheetNames.count(newName) > 0) {
+      throw XlsxError(xlsx_error::SHEET_EXISTS, "Worksheet already exists: " + newName);
+    }
+
+    _workbook->workbook().cloneSheet(existingName, newName);
+    auto worksheet = _workbook->workbook().worksheet(newName);
+    auto hybridWorksheet = std::make_shared<HybridXlsxWorksheet>(*_workbook, worksheet);
+    _worksheets.push_back(hybridWorksheet);
+    _worksheetNames[newName] = hybridWorksheet;
+    return hybridWorksheet;
+  });
 }
 
 std::shared_ptr<HybridXlsxCellFormatSpec> HybridXlsxWorkbook::addCellFormat() {
@@ -184,118 +217,48 @@ std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>> HybridXlsxWorkbook::getBu
   auto promise = Promise<std::shared_ptr<ArrayBuffer>>::create();
 
   if (_finalized) {
-    promise->reject(std::make_exception_ptr(std::runtime_error("Workbook has already been finalized")));
+    promise->reject(std::make_exception_ptr(XlsxError(xlsx_error::WORKBOOK_CLOSED, "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";
+    std::string tempPath = tempFilePath("xlsx_temp");
     _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")));
+      promise->reject(std::make_exception_ptr(XlsxError(xlsx_error::IO_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) {
+  } catch (const XlsxError& e) {
     promise->reject(std::make_exception_ptr(e));
+  } catch (const OpenXLSX::XLException& e) {
+    promise->reject(std::make_exception_ptr(XlsxError(xlsx_error::XLSX_ERROR, e.what())));
+  } catch (const std::exception& e) {
+    promise->reject(std::make_exception_ptr(XlsxError(xlsx_error::INTERNAL_ERROR, e.what())));
   }
-  
+
   return promise;
 }
 
-std::string HybridXlsxWorkbook::toJSON(const std::optional<std::vector<std::string>>& keys) {
-  if (_worksheets.empty()) {
-    return "[]";
-  }
-  auto& ws = _worksheets[0];
-  auto lastRow = static_cast<unsigned int>(ws->getLastRow());
-  auto lastCol = static_cast<unsigned int>(ws->getLastColumn());
-  if (lastRow == 0 || lastCol == 0) {
-    return "[]";
-  }
-
-  unsigned int dataStartRow = 1;
-  std::vector<std::string> resolvedKeys;
-
-  if (keys.has_value()) {
-    resolvedKeys = *keys;
-  } else {
-    dataStartRow = 2;
-    for (unsigned int c = 1; c <= lastCol; ++c) {
-      auto val = ws->getCellValue(1, c);
-      if (auto* s = std::get_if<std::string>(&val)) {
-        resolvedKeys.push_back(*s);
-      } else if (auto* d = std::get_if<double>(&val)) {
-        resolvedKeys.push_back(std::to_string(static_cast<int>(*d)));
-      } else {
-        resolvedKeys.push_back("col" + std::to_string(c));
-      }
-    }
-  }
-
-  if (resolvedKeys.empty()) {
-    return "[]";
-  }
-
-  std::ostringstream out;
-  out << "[";
-
-  bool firstRow = true;
-
-  for (unsigned int r = dataStartRow; r <= lastRow; ++r) {
-    bool hasData = false;
-    for (unsigned int c = 1; c <= std::min(static_cast<unsigned int>(resolvedKeys.size()), lastCol); ++c) {
-      auto cellType = ws->getCellType(r, c);
-      if (cellType != CellType::EMPTY) {
-        hasData = true;
-        break;
-      }
-    }
-    if (!hasData) continue;
-
-    if (!firstRow) out << ",";
-    firstRow = false;
-
-    out << "{";
-    unsigned int keyCount = std::min(static_cast<unsigned int>(resolvedKeys.size()), lastCol);
-    for (unsigned int c = 0; c < keyCount; ++c) {
-      if (c > 0) out << ",";
-      writeJsonString(out, resolvedKeys[c]);
-      out << ":";
-      auto val = ws->getCellValue(r, c + 1);
-      if (auto* s = std::get_if<std::string>(&val)) {
-        writeJsonString(out, *s);
-      } else if (auto* d = std::get_if<double>(&val)) {
-        if (std::isnan(*d) || std::isinf(*d)) {
-          out << "null";
-        } else {
-          out << *d;
-        }
-      } else if (auto* b = std::get_if<bool>(&val)) {
-        out << (*b ? "true" : "false");
-      } else {
-        out << "null";
-      }
-    }
-    out << "}";
-  }
-
-  out << "]";
-  return out.str();
+std::unordered_map<std::string, std::vector<std::shared_ptr<AnyMap>>> HybridXlsxWorkbook::toJSON() {
+  return withXlsxError(xlsx_error::XLSX_ERROR, [&] {
+    auto wb = _workbook->workbook();
+    return workbookToRecords(wb);
+  });
 }
 
 }

package/cpp/HybridXlsxWorkbook.hpp

@@ -13,7 +13,7 @@ namespace margelo::nitro::xlsx {
 
 class HybridXlsxWorkbook : public HybridXlsxWorkbookSpec {
 public:
-  HybridXlsxWorkbook(const std::optional<std::string>& tempDir = std::nullopt);
+  HybridXlsxWorkbook();
   ~HybridXlsxWorkbook() override;
 
   void openFromFile(const std::string& path);
@@ -24,9 +24,12 @@ public:
   std::shared_ptr<HybridXlsxWorksheetSpec> getWorksheetByName(const std::string& name) override;
   std::shared_ptr<HybridXlsxWorksheetSpec> getOrAddWorksheet(const std::string& name) override;
   double getWorksheetCount() override;
+  void deleteSheet(const std::string& name) override;
+  void updateSheetName(const std::string& oldName, const std::string& newName) override;
+  std::shared_ptr<HybridXlsxWorksheetSpec> clone(const std::string& existingName, const std::string& newName) override;
   std::shared_ptr<HybridXlsxCellFormatSpec> addCellFormat() override;
   std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>> getBuffer() override;
-  std::string toJSON(const std::optional<std::vector<std::string>>& keys) override;
+  std::unordered_map<std::string, std::vector<std::shared_ptr<AnyMap>>> toJSON() override;
 
 private:
   std::unique_ptr<OpenXLSX::XLDocument> _workbook;
@@ -37,6 +40,8 @@ private:
   std::string _tempDir;
 
   void loadWorksheets();
+  void ensureOpen();
+  std::string tempFilePath(const char* prefix);
 };
 
 }