react-native-nitro-xlsx 0.1.2 → 0.2.5

package/android/cpp-adapter.cpp

@@ -1,9 +1,21 @@
 #include <jni.h>
 #include <fbjni/fbjni.h>
 #include "NitroXlsxOnLoad.hpp"
+#include "XlsxCacheDir.hpp"
 
 JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
   return facebook::jni::initialize(vm, []() {
     margelo::nitro::xlsx::registerAllNatives();
   });
 }
+
+// Called from NitroXlsxPackage with Context.getCacheDir().absolutePath
+extern "C" JNIEXPORT void JNICALL
+Java_com_margelo_nitro_xlsx_NitroXlsxPackage_nativeSetCacheDir(JNIEnv* env, jclass, jstring dir) {
+  if (dir == nullptr) return;
+  const char* chars = env->GetStringUTFChars(dir, nullptr);
+  if (chars != nullptr) {
+    margelo::nitro::xlsx::setCacheDir(std::string(chars));
+    env->ReleaseStringUTFChars(dir, chars);
+  }
+}

package/android/src/main/java/com/margelo/nitro/xlsx/NitroXlsxPackage.kt

@@ -10,10 +10,19 @@ class NitroXlsxPackage : ReactPackage {
     init {
       NitroXlsxOnLoad.initializeNative()
     }
+
+    /** Pass the app cache directory to the native layer for temp XLSX files. */
+    @JvmStatic
+    private external fun nativeSetCacheDir(dir: String)
   }
 
   @Suppress("OVERRIDE_DEPRECATION")
   override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+    try {
+      nativeSetCacheDir(reactContext.cacheDir.absolutePath)
+    } catch (_: Throwable) {
+      // native resolver falls back to Context.getCacheDir() via JNI
+    }
     return emptyList()
   }
 

package/cpp/HybridNitroXlsx.cpp

@@ -1,5 +1,9 @@
 #include "HybridNitroXlsx.hpp"
+#include "XlsxError.hpp"
 #include <fstream>
+#include <stdexcept>
+#include <cstring>
+#include <cstdlib>
 
 namespace margelo::nitro::xlsx {
 
@@ -10,20 +14,39 @@ HybridNitroXlsx::HybridNitroXlsx()
 HybridNitroXlsx::~HybridNitroXlsx() {
 }
 
-std::shared_ptr<HybridXlsxWorkbookSpec> HybridNitroXlsx::createWorkbook(const std::optional<std::string>& tempDir) {
-  return std::make_shared<HybridXlsxWorkbook>(tempDir);
+std::shared_ptr<HybridXlsxWorkbookSpec> HybridNitroXlsx::createWorkbook() {
+  return withXlsxError(xlsx_error::IO_ERROR, [&]() -> std::shared_ptr<HybridXlsxWorkbookSpec> {
+    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;
+  return withXlsxError(xlsx_error::IO_ERROR, [&]() -> std::shared_ptr<HybridXlsxWorkbookSpec> {
+    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;
+  return withXlsxError(xlsx_error::IO_ERROR, [&]() -> std::shared_ptr<HybridXlsxWorkbookSpec> {
+    auto workbook = std::make_shared<HybridXlsxWorkbook>();
+    workbook->openFromBuffer(buffer->data(), buffer->size());
+    return workbook;
+  });
 }
 
-}
+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;
+
+    for (const auto& [sheetName, rows] : data) {
+      auto sheet = workbook->addWorksheet(sheetName);
+      sheet->fromJSON(rows);
+    }
+    return workbook;
+  });
+}
+
+}

package/cpp/HybridNitroXlsx.hpp

@@ -11,9 +11,10 @@ public:
   HybridNitroXlsx();
   ~HybridNitroXlsx() override;
 
-  std::shared_ptr<HybridXlsxWorkbookSpec> createWorkbook(const std::optional<std::string>& tempDir = std::nullopt) 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;
+  std::shared_ptr<HybridXlsxWorkbookSpec> fromJSON(const std::unordered_map<std::string, std::vector<std::shared_ptr<AnyMap>>>& data) override;
 };
 
 }

package/cpp/HybridXlsxConditionalFormat.cpp

@@ -0,0 +1,252 @@
+#include "HybridXlsxConditionalFormat.hpp"
+#include "XlsxError.hpp"
+
+namespace margelo::nitro::xlsx {
+
+HybridXlsxConditionalFormat::HybridXlsxConditionalFormat(OpenXLSX::XLConditionalFormat format)
+    : HybridObject("XlsxConditionalFormat"), HybridXlsxConditionalFormatSpec(), _format(std::move(format)) {
+}
+
+HybridXlsxConditionalFormat::~HybridXlsxConditionalFormat() = default;
+
+OpenXLSX::XLCfRules HybridXlsxConditionalFormat::rules() {
+  return _format.cfRules();
+}
+
+OpenXLSX::XLCfRule HybridXlsxConditionalFormat::ruleAt(double index) {
+  size_t idx = static_cast<size_t>(index);
+  auto cfRules = _format.cfRules();
+  if (idx >= cfRules.count()) {
+    throw XlsxError(xlsx_error::INDEX_OUT_OF_RANGE,
+                    "cfRule index " + std::to_string(idx) + " out of range (count=" + std::to_string(cfRules.count()) + ")");
+  }
+  return cfRules.cfRuleByIndex(idx);
+}
+
+std::string HybridXlsxConditionalFormat::getSqref() {
+  return withXlsxError(xlsx_error::XLSX_ERROR, [&] { return _format.sqref(); });
+}
+
+void HybridXlsxConditionalFormat::setSqref(const std::string& sqref) {
+  withXlsxError(xlsx_error::XLSX_ERROR, [&] {
+    if (!_format.setSqref(sqref)) {
+      throw XlsxError(xlsx_error::XLSX_ERROR, "Failed to set sqref: " + sqref);
+    }
+  });
+}
+
+double HybridXlsxConditionalFormat::getRuleCount() {
+  return withXlsxError(xlsx_error::XLSX_ERROR, [&] {
+    return static_cast<double>(_format.cfRules().count());
+  });
+}
+
+double HybridXlsxConditionalFormat::createRule() {
+  return withXlsxError(xlsx_error::XLSX_ERROR, [&] {
+    auto cfRules = _format.cfRules();
+    return static_cast<double>(cfRules.create());
+  });
+}
+
+bool HybridXlsxConditionalFormat::deleteRule(double index) {
+  // OpenXLSX does not expose cfRule deletion
+  (void)index;
+  return false;
+}
+
+double HybridXlsxConditionalFormat::getRuleType(double index) {
+  return withXlsxError(xlsx_error::XLSX_ERROR, [&] {
+    return static_cast<double>(ruleAt(index).type());
+  });
+}
+
+void HybridXlsxConditionalFormat::setRuleType(double index, double type) {
+  withXlsxError(xlsx_error::XLSX_ERROR, [&] {
+    if (!ruleAt(index).setType(static_cast<OpenXLSX::XLCfType>(static_cast<uint8_t>(type)))) {
+      throw XlsxError(xlsx_error::XLSX_ERROR, "Failed to set rule type");
+    }
+  });
+}
+
+double HybridXlsxConditionalFormat::getRuleDxfId(double index) {
+  return withXlsxError(xlsx_error::XLSX_ERROR, [&] {
+    return static_cast<double>(ruleAt(index).dxfId());
+  });
+}
+
+void HybridXlsxConditionalFormat::setRuleDxfId(double index, double dxfId) {
+  withXlsxError(xlsx_error::XLSX_ERROR, [&] {
+    if (!ruleAt(index).setDxfId(static_cast<OpenXLSX::XLStyleIndex>(dxfId))) {
+      throw XlsxError(xlsx_error::XLSX_ERROR, "Failed to set rule dxfId");
+    }
+  });
+}
+
+std::string HybridXlsxConditionalFormat::getRuleFormula(double index, double formulaIndex) {
+  return withXlsxError(xlsx_error::XLSX_ERROR, [&] {
+    // OpenXLSX only supports the primary <formula> node
+    if (formulaIndex != 0) return std::string();
+    return ruleAt(index).formula();
+  });
+}
+
+void HybridXlsxConditionalFormat::setRuleFormula(double index, double formulaIndex, const std::string& formula) {
+  withXlsxError(xlsx_error::XLSX_ERROR, [&] {
+    if (formulaIndex != 0) {
+      throw XlsxError(xlsx_error::UNSUPPORTED,
+                      "OpenXLSX only supports a single formula per cfRule (formulaIndex must be 0)");
+    }
+    if (!ruleAt(index).setFormula(formula)) {
+      throw XlsxError(xlsx_error::XLSX_ERROR, "Failed to set rule formula");
+    }
+  });
+}
+
+double HybridXlsxConditionalFormat::getRuleOperator(double index) {
+  return withXlsxError(xlsx_error::XLSX_ERROR, [&] {
+    return static_cast<double>(ruleAt(index).Operator());
+  });
+}
+
+void HybridXlsxConditionalFormat::setRuleOperator(double index, double op) {
+  withXlsxError(xlsx_error::XLSX_ERROR, [&] {
+    if (!ruleAt(index).setOperator(static_cast<OpenXLSX::XLCfOperator>(static_cast<uint8_t>(op)))) {
+      throw XlsxError(xlsx_error::XLSX_ERROR, "Failed to set rule operator");
+    }
+  });
+}
+
+std::string HybridXlsxConditionalFormat::getRuleText(double index) {
+  return withXlsxError(xlsx_error::XLSX_ERROR, [&] { return ruleAt(index).text(); });
+}
+
+void HybridXlsxConditionalFormat::setRuleText(double index, const std::string& text) {
+  withXlsxError(xlsx_error::XLSX_ERROR, [&] {
+    if (!ruleAt(index).setText(text)) {
+      throw XlsxError(xlsx_error::XLSX_ERROR, "Failed to set rule text");
+    }
+  });
+}
+
+double HybridXlsxConditionalFormat::getRulePriority(double index) {
+  return withXlsxError(xlsx_error::XLSX_ERROR, [&] {
+    return static_cast<double>(ruleAt(index).priority());
+  });
+}
+
+void HybridXlsxConditionalFormat::setRulePriority(double index, double priority) {
+  withXlsxError(xlsx_error::XLSX_ERROR, [&] {
+    auto cfRules = _format.cfRules();
+    if (!cfRules.setPriority(static_cast<size_t>(index), static_cast<uint16_t>(priority))) {
+      throw XlsxError(xlsx_error::INDEX_OUT_OF_RANGE, "Failed to set rule priority");
+    }
+  });
+}
+
+bool HybridXlsxConditionalFormat::getRuleStopIfTrue(double index) {
+  return withXlsxError(xlsx_error::XLSX_ERROR, [&] { return ruleAt(index).stopIfTrue(); });
+}
+
+void HybridXlsxConditionalFormat::setRuleStopIfTrue(double index, bool stop) {
+  withXlsxError(xlsx_error::XLSX_ERROR, [&] {
+    if (!ruleAt(index).setStopIfTrue(stop)) {
+      throw XlsxError(xlsx_error::XLSX_ERROR, "Failed to set stopIfTrue");
+    }
+  });
+}
+
+double HybridXlsxConditionalFormat::getRuleTimePeriod(double index) {
+  return withXlsxError(xlsx_error::XLSX_ERROR, [&] {
+    return static_cast<double>(ruleAt(index).timePeriod());
+  });
+}
+
+void HybridXlsxConditionalFormat::setRuleTimePeriod(double index, double period) {
+  withXlsxError(xlsx_error::XLSX_ERROR, [&] {
+    if (!ruleAt(index).setTimePeriod(static_cast<OpenXLSX::XLCfTimePeriod>(static_cast<uint8_t>(period)))) {
+      throw XlsxError(xlsx_error::XLSX_ERROR, "Failed to set timePeriod");
+    }
+  });
+}
+
+double HybridXlsxConditionalFormat::getRuleRank(double index) {
+  return withXlsxError(xlsx_error::XLSX_ERROR, [&] {
+    return static_cast<double>(ruleAt(index).rank());
+  });
+}
+
+void HybridXlsxConditionalFormat::setRuleRank(double index, double rank) {
+  withXlsxError(xlsx_error::XLSX_ERROR, [&] {
+    if (!ruleAt(index).setRank(static_cast<uint16_t>(rank))) {
+      throw XlsxError(xlsx_error::XLSX_ERROR, "Failed to set rank");
+    }
+  });
+}
+
+double HybridXlsxConditionalFormat::getRuleStdDev(double index) {
+  return withXlsxError(xlsx_error::XLSX_ERROR, [&] {
+    return static_cast<double>(ruleAt(index).stdDev());
+  });
+}
+
+void HybridXlsxConditionalFormat::setRuleStdDev(double index, double stdDev) {
+  withXlsxError(xlsx_error::XLSX_ERROR, [&] {
+    if (!ruleAt(index).setStdDev(static_cast<int16_t>(stdDev))) {
+      throw XlsxError(xlsx_error::XLSX_ERROR, "Failed to set stdDev");
+    }
+  });
+}
+
+bool HybridXlsxConditionalFormat::getRuleAboveAverage(double index) {
+  return withXlsxError(xlsx_error::XLSX_ERROR, [&] { return ruleAt(index).aboveAverage(); });
+}
+
+void HybridXlsxConditionalFormat::setRuleAboveAverage(double index, bool set) {
+  withXlsxError(xlsx_error::XLSX_ERROR, [&] {
+    if (!ruleAt(index).setAboveAverage(set)) {
+      throw XlsxError(xlsx_error::XLSX_ERROR, "Failed to set aboveAverage");
+    }
+  });
+}
+
+bool HybridXlsxConditionalFormat::getRulePercent(double index) {
+  return withXlsxError(xlsx_error::XLSX_ERROR, [&] { return ruleAt(index).percent(); });
+}
+
+void HybridXlsxConditionalFormat::setRulePercent(double index, bool set) {
+  withXlsxError(xlsx_error::XLSX_ERROR, [&] {
+    if (!ruleAt(index).setPercent(set)) {
+      throw XlsxError(xlsx_error::XLSX_ERROR, "Failed to set percent");
+    }
+  });
+}
+
+bool HybridXlsxConditionalFormat::getRuleBottom(double index) {
+  return withXlsxError(xlsx_error::XLSX_ERROR, [&] { return ruleAt(index).bottom(); });
+}
+
+void HybridXlsxConditionalFormat::setRuleBottom(double index, bool set) {
+  withXlsxError(xlsx_error::XLSX_ERROR, [&] {
+    if (!ruleAt(index).setBottom(set)) {
+      throw XlsxError(xlsx_error::XLSX_ERROR, "Failed to set bottom");
+    }
+  });
+}
+
+bool HybridXlsxConditionalFormat::getRuleEqualAverage(double index) {
+  return withXlsxError(xlsx_error::XLSX_ERROR, [&] { return ruleAt(index).equalAverage(); });
+}
+
+void HybridXlsxConditionalFormat::setRuleEqualAverage(double index, bool set) {
+  withXlsxError(xlsx_error::XLSX_ERROR, [&] {
+    if (!ruleAt(index).setEqualAverage(set)) {
+      throw XlsxError(xlsx_error::XLSX_ERROR, "Failed to set equalAverage");
+    }
+  });
+}
+
+std::string HybridXlsxConditionalFormat::summary() {
+  return withXlsxError(xlsx_error::XLSX_ERROR, [&] { return _format.summary(); });
+}
+
+} // namespace margelo::nitro::xlsx

package/cpp/HybridXlsxConditionalFormat.hpp

@@ -0,0 +1,62 @@
+#pragma once
+
+#include "HybridXlsxConditionalFormatSpec.hpp"
+#include <OpenXLSX/XLSheet.hpp>
+#include <memory>
+#include <string>
+
+namespace margelo::nitro::xlsx {
+
+class HybridXlsxConditionalFormat : public HybridXlsxConditionalFormatSpec {
+public:
+  explicit HybridXlsxConditionalFormat(OpenXLSX::XLConditionalFormat format);
+  ~HybridXlsxConditionalFormat() override;
+
+  std::string getSqref() override;
+  void setSqref(const std::string& sqref) override;
+
+  double getRuleCount() override;
+  double createRule() override;
+  bool deleteRule(double index) override;
+
+  double getRuleType(double index) override;
+  void setRuleType(double index, double type) override;
+  double getRuleDxfId(double index) override;
+  void setRuleDxfId(double index, double dxfId) override;
+
+  std::string getRuleFormula(double index, double formulaIndex) override;
+  void setRuleFormula(double index, double formulaIndex, const std::string& formula) override;
+
+  double getRuleOperator(double index) override;
+  void setRuleOperator(double index, double op) override;
+  std::string getRuleText(double index) override;
+  void setRuleText(double index, const std::string& text) override;
+  double getRulePriority(double index) override;
+  void setRulePriority(double index, double priority) override;
+  bool getRuleStopIfTrue(double index) override;
+  void setRuleStopIfTrue(double index, bool stop) override;
+  double getRuleTimePeriod(double index) override;
+  void setRuleTimePeriod(double index, double period) override;
+  double getRuleRank(double index) override;
+  void setRuleRank(double index, double rank) override;
+  double getRuleStdDev(double index) override;
+  void setRuleStdDev(double index, double stdDev) override;
+  bool getRuleAboveAverage(double index) override;
+  void setRuleAboveAverage(double index, bool set) override;
+  bool getRulePercent(double index) override;
+  void setRulePercent(double index, bool set) override;
+  bool getRuleBottom(double index) override;
+  void setRuleBottom(double index, bool set) override;
+  bool getRuleEqualAverage(double index) override;
+  void setRuleEqualAverage(double index, bool set) override;
+
+  std::string summary() override;
+
+private:
+  OpenXLSX::XLConditionalFormat _format;
+
+  OpenXLSX::XLCfRule ruleAt(double index);
+  OpenXLSX::XLCfRules rules();
+};
+
+} // namespace margelo::nitro::xlsx

package/cpp/HybridXlsxConditionalFormats.cpp

@@ -0,0 +1,46 @@
+#include "HybridXlsxConditionalFormats.hpp"
+#include "XlsxError.hpp"
+
+namespace margelo::nitro::xlsx {
+
+HybridXlsxConditionalFormats::HybridXlsxConditionalFormats(OpenXLSX::XLConditionalFormats formats)
+    : HybridObject("XlsxConditionalFormats"), HybridXlsxConditionalFormatsSpec(), _formats(std::move(formats)) {
+}
+
+HybridXlsxConditionalFormats::~HybridXlsxConditionalFormats() = default;
+
+double HybridXlsxConditionalFormats::getCount() {
+  return withXlsxError(xlsx_error::XLSX_ERROR, [&] {
+    return static_cast<double>(_formats.count());
+  });
+}
+
+std::shared_ptr<HybridXlsxConditionalFormatSpec> HybridXlsxConditionalFormats::create(const std::string& sqref) {
+  return withXlsxError(xlsx_error::XLSX_ERROR, [&] {
+    size_t index = _formats.create();
+    OpenXLSX::XLConditionalFormat format = _formats.conditionalFormatByIndex(index);
+    format.setSqref(sqref);
+    auto hybrid = std::make_shared<HybridXlsxConditionalFormat>(format);
+    _created.push_back(hybrid);
+    return std::static_pointer_cast<HybridXlsxConditionalFormatSpec>(hybrid);
+  });
+}
+
+std::shared_ptr<HybridXlsxConditionalFormatSpec> HybridXlsxConditionalFormats::getByIndex(double index) {
+  return withXlsxError(xlsx_error::XLSX_ERROR, [&] {
+    size_t idx = static_cast<size_t>(index);
+    if (idx >= _formats.count()) {
+      throw XlsxError(xlsx_error::INDEX_OUT_OF_RANGE,
+                      "conditionalFormat index " + std::to_string(idx) + " out of range (count=" + std::to_string(_formats.count()) + ")");
+    }
+    auto hybrid = std::make_shared<HybridXlsxConditionalFormat>(_formats.conditionalFormatByIndex(idx));
+    _created.push_back(hybrid);
+    return std::static_pointer_cast<HybridXlsxConditionalFormatSpec>(hybrid);
+  });
+}
+
+std::string HybridXlsxConditionalFormats::summary() {
+  return withXlsxError(xlsx_error::XLSX_ERROR, [&] { return _formats.summary(); });
+}
+
+} // namespace margelo::nitro::xlsx

package/cpp/HybridXlsxConditionalFormats.hpp

@@ -0,0 +1,28 @@
+#pragma once
+
+#include "HybridXlsxConditionalFormatsSpec.hpp"
+#include "HybridXlsxConditionalFormat.hpp"
+#include <OpenXLSX/XLSheet.hpp>
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace margelo::nitro::xlsx {
+
+class HybridXlsxConditionalFormats : public HybridXlsxConditionalFormatsSpec {
+public:
+  explicit HybridXlsxConditionalFormats(OpenXLSX::XLConditionalFormats formats);
+  ~HybridXlsxConditionalFormats() override;
+
+  double getCount() override;
+  std::shared_ptr<HybridXlsxConditionalFormatSpec> create(const std::string& sqref) override;
+  std::shared_ptr<HybridXlsxConditionalFormatSpec> getByIndex(double index) override;
+  std::string summary() override;
+
+private:
+  OpenXLSX::XLConditionalFormats _formats;
+  // Keep hybrid wrappers alive so JS holds stay valid
+  std::vector<std::shared_ptr<HybridXlsxConditionalFormat>> _created;
+};
+
+} // namespace margelo::nitro::xlsx