react-native-nitro-xlsx 0.1.4 → 0.2.6

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,99 +1,10 @@
 #include "HybridNitroXlsx.hpp"
+#include "XlsxError.hpp"
 #include <fstream>
 #include <stdexcept>
 #include <cstring>
 #include <cstdlib>
 
-namespace {
-
-struct JsonParser {
-  const char* p;
-  explicit JsonParser(const char* s) : p(s) {}
-
-  void skipWs() { while (*p == ' ' || *p == '\t' || *p == '\n' || *p == '\r') ++p; }
-
-  char peek() { skipWs(); return *p; }
-
-  void expect(char c) {
-    skipWs();
-    if (*p != c) throw std::runtime_error(std::string("Expected '") + c + "' but got '" + *p + "'");
-    ++p;
-  }
-
-  std::string parseString() {
-    expect('"');
-    std::string s;
-    while (*p && *p != '"') {
-      if (*p == '\\') {
-        ++p;
-        switch (*p) {
-          case '"':  s += '"';  break;
-          case '\\': s += '\\'; break;
-          case '/':  s += '/';  break;
-          case 'b':  s += '\b'; break;
-          case 'f':  s += '\f'; break;
-          case 'n':  s += '\n'; break;
-          case 'r':  s += '\r'; break;
-          case 't':  s += '\t'; break;
-          case 'u': {
-            ++p;
-            char hex[5] = {};
-            std::memcpy(hex, p, 4);
-            p += 4;
-            unsigned long cp = std::strtoul(hex, nullptr, 16);
-            if (cp < 0x80) {
-              s += static_cast<char>(cp);
-            } else if (cp < 0x800) {
-              s += static_cast<char>(0xC0 | (cp >> 6));
-              s += static_cast<char>(0x80 | (cp & 0x3F));
-            } else {
-              s += static_cast<char>(0xE0 | (cp >> 12));
-              s += static_cast<char>(0x80 | ((cp >> 6) & 0x3F));
-              s += static_cast<char>(0x80 | (cp & 0x3F));
-            }
-            continue;
-          }
-          default: s += '\\'; s += *p; break;
-        }
-      } else {
-        s += *p;
-      }
-      ++p;
-    }
-    if (*p == '"') ++p;
-    return s;
-  }
-
-  enum ValueType { T_STRING, T_NUMBER, T_BOOL, T_NULL };
-
-  struct Value {
-    ValueType type;
-    std::string str;
-    double num = 0;
-    bool boolean = false;
-  };
-
-  Value parseValue() {
-    skipWs();
-    if (*p == '"') return { T_STRING, parseString(), 0, false };
-    if (*p == 't') { p += 4; return { T_BOOL, "", 0, true }; }
-    if (*p == 'f') { p += 5; return { T_BOOL, "", 0, false }; }
-    if (*p == 'n') { p += 4; return { T_NULL, "", 0, false }; }
-
-    // number
-    Value v{ T_NUMBER, "", 0, false };
-    const char* start = p;
-    if (*p == '-') ++p;
-    while (*p >= '0' && *p <= '9') ++p;
-    if (*p == '.') { ++p; while (*p >= '0' && *p <= '9') ++p; }
-    if (*p == 'e' || *p == 'E') { ++p; if (*p == '+' || *p == '-') ++p; while (*p >= '0' && *p <= '9') ++p; }
-    v.num = std::strtod(start, nullptr);
-    return v;
-  }
-};
-
-} // anonymous namespace
-
 namespace margelo::nitro::xlsx {
 
 HybridNitroXlsx::HybridNitroXlsx()
@@ -103,104 +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::string& data) {
-  auto workbook = std::make_shared<HybridXlsxWorkbook>();
-  auto sheet = workbook->addWorksheet("Sheet1");
-
-  JsonParser parser(data.c_str());
-  parser.skipWs();
-  parser.expect('[');
+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;
 
-  if (parser.peek() == ']') return workbook;
-
-  // Parse first object to extract keys
-  parser.expect('{');
-
-  std::vector<std::string> keys;
-  unsigned int col = 1;
-
-  while (parser.peek() != '}') {
-    std::string key = parser.parseString();
-    keys.push_back(key);
-    parser.expect(':');
-    auto val = parser.parseValue();
-
-    switch (val.type) {
-      case JsonParser::T_STRING:
-        sheet->writeString(1, col, val.str, std::nullopt);
-        break;
-      case JsonParser::T_NUMBER:
-        sheet->writeNumber(1, col, val.num, std::nullopt);
-        break;
-      case JsonParser::T_BOOL:
-        sheet->writeBoolean(1, col, val.boolean, std::nullopt);
-        break;
-      default:
-        break;
+    for (const auto& [sheetName, rows] : data) {
+      auto sheet = workbook->addWorksheet(sheetName);
+      sheet->fromJSON(rows);
     }
-    ++col;
-    if (parser.peek() == ',') ++parser.p;
-  }
-  parser.expect('}');
-
-  unsigned int row = 2;
-
-  while (parser.peek() == ',') {
-    ++parser.p;
-    parser.expect('{');
-
-    while (parser.peek() != '}') {
-      std::string key = parser.parseString();
-      parser.expect(':');
-      auto val = parser.parseValue();
-
-      unsigned int targetCol = 0;
-      for (size_t k = 0; k < keys.size(); ++k) {
-        if (keys[k] == key) { targetCol = static_cast<unsigned int>(k + 1); break; }
-      }
-      if (targetCol == 0) {
-        keys.push_back(key);
-        targetCol = static_cast<unsigned int>(keys.size());
-      }
-
-      switch (val.type) {
-        case JsonParser::T_STRING:
-          sheet->writeString(row, targetCol, val.str, std::nullopt);
-          break;
-        case JsonParser::T_NUMBER:
-          sheet->writeNumber(row, targetCol, val.num, std::nullopt);
-          break;
-        case JsonParser::T_BOOL:
-          sheet->writeBoolean(row, targetCol, val.boolean, std::nullopt);
-          break;
-        default:
-          break;
-      }
-
-      if (parser.peek() == ',') ++parser.p;
-    }
-    parser.expect('}');
-    ++row;
-  }
-
-  parser.expect(']');
-  return workbook;
+    return workbook;
+  });
 }
 
-}
+}

package/cpp/HybridNitroXlsx.hpp

@@ -11,10 +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::string& data) 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