react-native-nitro-xlsx 0.1.2 → 0.2.5

package/nitrogen/generated/shared/c++/HybridXlsxConditionalFormatSpec.cpp

@@ -0,0 +1,54 @@
+///
+/// HybridXlsxConditionalFormatSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridXlsxConditionalFormatSpec.hpp"
+
+namespace margelo::nitro::xlsx {
+
+  void HybridXlsxConditionalFormatSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridMethod("getSqref", &HybridXlsxConditionalFormatSpec::getSqref);
+      prototype.registerHybridMethod("setSqref", &HybridXlsxConditionalFormatSpec::setSqref);
+      prototype.registerHybridMethod("getRuleCount", &HybridXlsxConditionalFormatSpec::getRuleCount);
+      prototype.registerHybridMethod("createRule", &HybridXlsxConditionalFormatSpec::createRule);
+      prototype.registerHybridMethod("deleteRule", &HybridXlsxConditionalFormatSpec::deleteRule);
+      prototype.registerHybridMethod("getRuleType", &HybridXlsxConditionalFormatSpec::getRuleType);
+      prototype.registerHybridMethod("setRuleType", &HybridXlsxConditionalFormatSpec::setRuleType);
+      prototype.registerHybridMethod("getRuleDxfId", &HybridXlsxConditionalFormatSpec::getRuleDxfId);
+      prototype.registerHybridMethod("setRuleDxfId", &HybridXlsxConditionalFormatSpec::setRuleDxfId);
+      prototype.registerHybridMethod("getRuleFormula", &HybridXlsxConditionalFormatSpec::getRuleFormula);
+      prototype.registerHybridMethod("setRuleFormula", &HybridXlsxConditionalFormatSpec::setRuleFormula);
+      prototype.registerHybridMethod("getRuleOperator", &HybridXlsxConditionalFormatSpec::getRuleOperator);
+      prototype.registerHybridMethod("setRuleOperator", &HybridXlsxConditionalFormatSpec::setRuleOperator);
+      prototype.registerHybridMethod("getRuleText", &HybridXlsxConditionalFormatSpec::getRuleText);
+      prototype.registerHybridMethod("setRuleText", &HybridXlsxConditionalFormatSpec::setRuleText);
+      prototype.registerHybridMethod("getRulePriority", &HybridXlsxConditionalFormatSpec::getRulePriority);
+      prototype.registerHybridMethod("setRulePriority", &HybridXlsxConditionalFormatSpec::setRulePriority);
+      prototype.registerHybridMethod("getRuleStopIfTrue", &HybridXlsxConditionalFormatSpec::getRuleStopIfTrue);
+      prototype.registerHybridMethod("setRuleStopIfTrue", &HybridXlsxConditionalFormatSpec::setRuleStopIfTrue);
+      prototype.registerHybridMethod("getRuleTimePeriod", &HybridXlsxConditionalFormatSpec::getRuleTimePeriod);
+      prototype.registerHybridMethod("setRuleTimePeriod", &HybridXlsxConditionalFormatSpec::setRuleTimePeriod);
+      prototype.registerHybridMethod("getRuleRank", &HybridXlsxConditionalFormatSpec::getRuleRank);
+      prototype.registerHybridMethod("setRuleRank", &HybridXlsxConditionalFormatSpec::setRuleRank);
+      prototype.registerHybridMethod("getRuleStdDev", &HybridXlsxConditionalFormatSpec::getRuleStdDev);
+      prototype.registerHybridMethod("setRuleStdDev", &HybridXlsxConditionalFormatSpec::setRuleStdDev);
+      prototype.registerHybridMethod("getRuleAboveAverage", &HybridXlsxConditionalFormatSpec::getRuleAboveAverage);
+      prototype.registerHybridMethod("setRuleAboveAverage", &HybridXlsxConditionalFormatSpec::setRuleAboveAverage);
+      prototype.registerHybridMethod("getRulePercent", &HybridXlsxConditionalFormatSpec::getRulePercent);
+      prototype.registerHybridMethod("setRulePercent", &HybridXlsxConditionalFormatSpec::setRulePercent);
+      prototype.registerHybridMethod("getRuleBottom", &HybridXlsxConditionalFormatSpec::getRuleBottom);
+      prototype.registerHybridMethod("setRuleBottom", &HybridXlsxConditionalFormatSpec::setRuleBottom);
+      prototype.registerHybridMethod("getRuleEqualAverage", &HybridXlsxConditionalFormatSpec::getRuleEqualAverage);
+      prototype.registerHybridMethod("setRuleEqualAverage", &HybridXlsxConditionalFormatSpec::setRuleEqualAverage);
+      prototype.registerHybridMethod("summary", &HybridXlsxConditionalFormatSpec::summary);
+    });
+  }
+
+} // namespace margelo::nitro::xlsx

package/nitrogen/generated/shared/c++/HybridXlsxConditionalFormatSpec.hpp

@@ -0,0 +1,95 @@
+///
+/// HybridXlsxConditionalFormatSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+
+
+#include <string>
+
+namespace margelo::nitro::xlsx {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `XlsxConditionalFormat`
+   * Inherit this class to create instances of `HybridXlsxConditionalFormatSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridXlsxConditionalFormat: public HybridXlsxConditionalFormatSpec {
+   * public:
+   *   HybridXlsxConditionalFormat(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridXlsxConditionalFormatSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridXlsxConditionalFormatSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridXlsxConditionalFormatSpec() override = default;
+
+    public:
+      // Properties
+      
+
+    public:
+      // Methods
+      virtual std::string getSqref() = 0;
+      virtual void setSqref(const std::string& sqref) = 0;
+      virtual double getRuleCount() = 0;
+      virtual double createRule() = 0;
+      virtual bool deleteRule(double index) = 0;
+      virtual double getRuleType(double index) = 0;
+      virtual void setRuleType(double index, double type) = 0;
+      virtual double getRuleDxfId(double index) = 0;
+      virtual void setRuleDxfId(double index, double dxfId) = 0;
+      virtual std::string getRuleFormula(double index, double formulaIndex) = 0;
+      virtual void setRuleFormula(double index, double formulaIndex, const std::string& formula) = 0;
+      virtual double getRuleOperator(double index) = 0;
+      virtual void setRuleOperator(double index, double op) = 0;
+      virtual std::string getRuleText(double index) = 0;
+      virtual void setRuleText(double index, const std::string& text) = 0;
+      virtual double getRulePriority(double index) = 0;
+      virtual void setRulePriority(double index, double priority) = 0;
+      virtual bool getRuleStopIfTrue(double index) = 0;
+      virtual void setRuleStopIfTrue(double index, bool stop) = 0;
+      virtual double getRuleTimePeriod(double index) = 0;
+      virtual void setRuleTimePeriod(double index, double period) = 0;
+      virtual double getRuleRank(double index) = 0;
+      virtual void setRuleRank(double index, double rank) = 0;
+      virtual double getRuleStdDev(double index) = 0;
+      virtual void setRuleStdDev(double index, double stdDev) = 0;
+      virtual bool getRuleAboveAverage(double index) = 0;
+      virtual void setRuleAboveAverage(double index, bool set) = 0;
+      virtual bool getRulePercent(double index) = 0;
+      virtual void setRulePercent(double index, bool set) = 0;
+      virtual bool getRuleBottom(double index) = 0;
+      virtual void setRuleBottom(double index, bool set) = 0;
+      virtual bool getRuleEqualAverage(double index) = 0;
+      virtual void setRuleEqualAverage(double index, bool set) = 0;
+      virtual std::string summary() = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "XlsxConditionalFormat";
+  };
+
+} // namespace margelo::nitro::xlsx

package/nitrogen/generated/shared/c++/HybridXlsxConditionalFormatsSpec.cpp

@@ -0,0 +1,24 @@
+///
+/// HybridXlsxConditionalFormatsSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridXlsxConditionalFormatsSpec.hpp"
+
+namespace margelo::nitro::xlsx {
+
+  void HybridXlsxConditionalFormatsSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridMethod("getCount", &HybridXlsxConditionalFormatsSpec::getCount);
+      prototype.registerHybridMethod("create", &HybridXlsxConditionalFormatsSpec::create);
+      prototype.registerHybridMethod("getByIndex", &HybridXlsxConditionalFormatsSpec::getByIndex);
+      prototype.registerHybridMethod("summary", &HybridXlsxConditionalFormatsSpec::summary);
+    });
+  }
+
+} // namespace margelo::nitro::xlsx

package/nitrogen/generated/shared/c++/HybridXlsxConditionalFormatsSpec.hpp

@@ -0,0 +1,68 @@
+///
+/// HybridXlsxConditionalFormatsSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `HybridXlsxConditionalFormatSpec` to properly resolve imports.
+namespace margelo::nitro::xlsx { class HybridXlsxConditionalFormatSpec; }
+
+#include <memory>
+#include "HybridXlsxConditionalFormatSpec.hpp"
+#include <string>
+
+namespace margelo::nitro::xlsx {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `XlsxConditionalFormats`
+   * Inherit this class to create instances of `HybridXlsxConditionalFormatsSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridXlsxConditionalFormats: public HybridXlsxConditionalFormatsSpec {
+   * public:
+   *   HybridXlsxConditionalFormats(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridXlsxConditionalFormatsSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridXlsxConditionalFormatsSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridXlsxConditionalFormatsSpec() override = default;
+
+    public:
+      // Properties
+      
+
+    public:
+      // Methods
+      virtual double getCount() = 0;
+      virtual std::shared_ptr<HybridXlsxConditionalFormatSpec> create(const std::string& sqref) = 0;
+      virtual std::shared_ptr<HybridXlsxConditionalFormatSpec> getByIndex(double index) = 0;
+      virtual std::string summary() = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "XlsxConditionalFormats";
+  };
+
+} // namespace margelo::nitro::xlsx

package/nitrogen/generated/shared/c++/HybridXlsxWorkbookSpec.cpp

@@ -19,8 +19,12 @@ namespace margelo::nitro::xlsx {
       prototype.registerHybridMethod("getWorksheetByName", &HybridXlsxWorkbookSpec::getWorksheetByName);
       prototype.registerHybridMethod("getOrAddWorksheet", &HybridXlsxWorkbookSpec::getOrAddWorksheet);
       prototype.registerHybridMethod("getWorksheetCount", &HybridXlsxWorkbookSpec::getWorksheetCount);
+      prototype.registerHybridMethod("deleteSheet", &HybridXlsxWorkbookSpec::deleteSheet);
+      prototype.registerHybridMethod("updateSheetName", &HybridXlsxWorkbookSpec::updateSheetName);
+      prototype.registerHybridMethod("clone", &HybridXlsxWorkbookSpec::clone);
       prototype.registerHybridMethod("addCellFormat", &HybridXlsxWorkbookSpec::addCellFormat);
       prototype.registerHybridMethod("getBuffer", &HybridXlsxWorkbookSpec::getBuffer);
+      prototype.registerHybridMethod("toJSON", &HybridXlsxWorkbookSpec::toJSON);
     });
   }
 

package/nitrogen/generated/shared/c++/HybridXlsxWorkbookSpec.hpp

@@ -25,6 +25,9 @@ namespace margelo::nitro::xlsx { class HybridXlsxCellFormatSpec; }
 #include "HybridXlsxCellFormatSpec.hpp"
 #include <NitroModules/ArrayBuffer.hpp>
 #include <NitroModules/Promise.hpp>
+#include <NitroModules/AnyMap.hpp>
+#include <vector>
+#include <unordered_map>
 
 namespace margelo::nitro::xlsx {
 
@@ -62,8 +65,12 @@ namespace margelo::nitro::xlsx {
       virtual std::shared_ptr<HybridXlsxWorksheetSpec> getWorksheetByName(const std::string& name) = 0;
       virtual std::shared_ptr<HybridXlsxWorksheetSpec> getOrAddWorksheet(const std::string& name) = 0;
       virtual double getWorksheetCount() = 0;
+      virtual void deleteSheet(const std::string& name) = 0;
+      virtual void updateSheetName(const std::string& oldName, const std::string& newName) = 0;
+      virtual std::shared_ptr<HybridXlsxWorksheetSpec> clone(const std::string& existingName, const std::string& newName) = 0;
       virtual std::shared_ptr<HybridXlsxCellFormatSpec> addCellFormat() = 0;
       virtual std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>> getBuffer() = 0;
+      virtual std::unordered_map<std::string, std::vector<std::shared_ptr<AnyMap>>> toJSON() = 0;
 
     protected:
       // Hybrid Setup

package/nitrogen/generated/shared/c++/HybridXlsxWorksheetSpec.cpp

@@ -27,42 +27,70 @@ namespace margelo::nitro::xlsx {
       prototype.registerHybridMethod("writeURL", &HybridXlsxWorksheetSpec::writeURL);
       prototype.registerHybridMethod("setColumn", &HybridXlsxWorksheetSpec::setColumn);
       prototype.registerHybridMethod("setRow", &HybridXlsxWorksheetSpec::setRow);
+      prototype.registerHybridMethod("deleteRow", &HybridXlsxWorksheetSpec::deleteRow);
+      prototype.registerHybridMethod("deleteColumn", &HybridXlsxWorksheetSpec::deleteColumn);
       prototype.registerHybridMethod("mergeRange", &HybridXlsxWorksheetSpec::mergeRange);
       prototype.registerHybridMethod("mergeRangeNum", &HybridXlsxWorksheetSpec::mergeRangeNum);
-      prototype.registerHybridMethod("insertImage", &HybridXlsxWorksheetSpec::insertImage);
-      prototype.registerHybridMethod("insertImageBuffer", &HybridXlsxWorksheetSpec::insertImageBuffer);
-      prototype.registerHybridMethod("autofilter", &HybridXlsxWorksheetSpec::autofilter);
-      prototype.registerHybridMethod("freezePanes", &HybridXlsxWorksheetSpec::freezePanes);
-      prototype.registerHybridMethod("splitPanes", &HybridXlsxWorksheetSpec::splitPanes);
-      prototype.registerHybridMethod("setTabColor", &HybridXlsxWorksheetSpec::setTabColor);
+      prototype.registerHybridMethod("unmergeCells", &HybridXlsxWorksheetSpec::unmergeCells);
       prototype.registerHybridMethod("hide", &HybridXlsxWorksheetSpec::hide);
       prototype.registerHybridMethod("activate", &HybridXlsxWorksheetSpec::activate);
-      prototype.registerHybridMethod("setFirstSheet", &HybridXlsxWorksheetSpec::setFirstSheet);
       prototype.registerHybridMethod("protect", &HybridXlsxWorksheetSpec::protect);
-      prototype.registerHybridMethod("setPortrait", &HybridXlsxWorksheetSpec::setPortrait);
-      prototype.registerHybridMethod("setLandscape", &HybridXlsxWorksheetSpec::setLandscape);
-      prototype.registerHybridMethod("setPaper", &HybridXlsxWorksheetSpec::setPaper);
-      prototype.registerHybridMethod("setHeader", &HybridXlsxWorksheetSpec::setHeader);
-      prototype.registerHybridMethod("setFooter", &HybridXlsxWorksheetSpec::setFooter);
-      prototype.registerHybridMethod("setPrintArea", &HybridXlsxWorksheetSpec::setPrintArea);
-      prototype.registerHybridMethod("fitToPages", &HybridXlsxWorksheetSpec::fitToPages);
-      prototype.registerHybridMethod("setZoom", &HybridXlsxWorksheetSpec::setZoom);
-      prototype.registerHybridMethod("setGridlines", &HybridXlsxWorksheetSpec::setGridlines);
-      prototype.registerHybridMethod("centerHorizontally", &HybridXlsxWorksheetSpec::centerHorizontally);
-      prototype.registerHybridMethod("centerVertically", &HybridXlsxWorksheetSpec::centerVertically);
-      prototype.registerHybridMethod("setOutline", &HybridXlsxWorksheetSpec::setOutline);
+      prototype.registerHybridMethod("protectSheet", &HybridXlsxWorksheetSpec::protectSheet);
+      prototype.registerHybridMethod("protectObjects", &HybridXlsxWorksheetSpec::protectObjects);
+      prototype.registerHybridMethod("protectScenarios", &HybridXlsxWorksheetSpec::protectScenarios);
+      prototype.registerHybridMethod("setPassword", &HybridXlsxWorksheetSpec::setPassword);
+      prototype.registerHybridMethod("setPasswordHash", &HybridXlsxWorksheetSpec::setPasswordHash);
+      prototype.registerHybridMethod("clearPassword", &HybridXlsxWorksheetSpec::clearPassword);
+      prototype.registerHybridMethod("clearSheetProtection", &HybridXlsxWorksheetSpec::clearSheetProtection);
+      prototype.registerHybridMethod("allowInsertColumns", &HybridXlsxWorksheetSpec::allowInsertColumns);
+      prototype.registerHybridMethod("allowInsertRows", &HybridXlsxWorksheetSpec::allowInsertRows);
+      prototype.registerHybridMethod("allowDeleteColumns", &HybridXlsxWorksheetSpec::allowDeleteColumns);
+      prototype.registerHybridMethod("allowDeleteRows", &HybridXlsxWorksheetSpec::allowDeleteRows);
+      prototype.registerHybridMethod("allowSelectLockedCells", &HybridXlsxWorksheetSpec::allowSelectLockedCells);
+      prototype.registerHybridMethod("allowSelectUnlockedCells", &HybridXlsxWorksheetSpec::allowSelectUnlockedCells);
+      prototype.registerHybridMethod("denyInsertColumns", &HybridXlsxWorksheetSpec::denyInsertColumns);
+      prototype.registerHybridMethod("denyInsertRows", &HybridXlsxWorksheetSpec::denyInsertRows);
+      prototype.registerHybridMethod("denyDeleteColumns", &HybridXlsxWorksheetSpec::denyDeleteColumns);
+      prototype.registerHybridMethod("denyDeleteRows", &HybridXlsxWorksheetSpec::denyDeleteRows);
+      prototype.registerHybridMethod("denySelectLockedCells", &HybridXlsxWorksheetSpec::denySelectLockedCells);
+      prototype.registerHybridMethod("denySelectUnlockedCells", &HybridXlsxWorksheetSpec::denySelectUnlockedCells);
+      prototype.registerHybridMethod("sheetProtected", &HybridXlsxWorksheetSpec::sheetProtected);
+      prototype.registerHybridMethod("objectsProtected", &HybridXlsxWorksheetSpec::objectsProtected);
+      prototype.registerHybridMethod("scenariosProtected", &HybridXlsxWorksheetSpec::scenariosProtected);
+      prototype.registerHybridMethod("insertColumnsAllowed", &HybridXlsxWorksheetSpec::insertColumnsAllowed);
+      prototype.registerHybridMethod("insertRowsAllowed", &HybridXlsxWorksheetSpec::insertRowsAllowed);
+      prototype.registerHybridMethod("deleteColumnsAllowed", &HybridXlsxWorksheetSpec::deleteColumnsAllowed);
+      prototype.registerHybridMethod("deleteRowsAllowed", &HybridXlsxWorksheetSpec::deleteRowsAllowed);
+      prototype.registerHybridMethod("selectLockedCellsAllowed", &HybridXlsxWorksheetSpec::selectLockedCellsAllowed);
+      prototype.registerHybridMethod("selectUnlockedCellsAllowed", &HybridXlsxWorksheetSpec::selectUnlockedCellsAllowed);
+      prototype.registerHybridMethod("passwordIsSet", &HybridXlsxWorksheetSpec::passwordIsSet);
+      prototype.registerHybridMethod("passwordHash", &HybridXlsxWorksheetSpec::passwordHash);
+      prototype.registerHybridMethod("sheetProtectionSummary", &HybridXlsxWorksheetSpec::sheetProtectionSummary);
       prototype.registerHybridMethod("setColumnHidden", &HybridXlsxWorksheetSpec::setColumnHidden);
       prototype.registerHybridMethod("setRowHidden", &HybridXlsxWorksheetSpec::setRowHidden);
+      prototype.registerHybridMethod("setComment", &HybridXlsxWorksheetSpec::setComment);
+      prototype.registerHybridMethod("getComment", &HybridXlsxWorksheetSpec::getComment);
+      prototype.registerHybridMethod("hasComment", &HybridXlsxWorksheetSpec::hasComment);
+      prototype.registerHybridMethod("deleteComment", &HybridXlsxWorksheetSpec::deleteComment);
+      prototype.registerHybridMethod("getCommentCount", &HybridXlsxWorksheetSpec::getCommentCount);
+      prototype.registerHybridMethod("addCommentAuthor", &HybridXlsxWorksheetSpec::addCommentAuthor);
+      prototype.registerHybridMethod("getCommentAuthor", &HybridXlsxWorksheetSpec::getCommentAuthor);
+      prototype.registerHybridMethod("getConditionalFormats", &HybridXlsxWorksheetSpec::getConditionalFormats);
       prototype.registerHybridMethod("getCellValue", &HybridXlsxWorksheetSpec::getCellValue);
       prototype.registerHybridMethod("getCellString", &HybridXlsxWorksheetSpec::getCellString);
       prototype.registerHybridMethod("getCellRawValue", &HybridXlsxWorksheetSpec::getCellRawValue);
       prototype.registerHybridMethod("getCellType", &HybridXlsxWorksheetSpec::getCellType);
       prototype.registerHybridMethod("getCellFormat", &HybridXlsxWorksheetSpec::getCellFormat);
+      prototype.registerHybridMethod("hasFormula", &HybridXlsxWorksheetSpec::hasFormula);
+      prototype.registerHybridMethod("formula", &HybridXlsxWorksheetSpec::formula);
+      prototype.registerHybridMethod("findCell", &HybridXlsxWorksheetSpec::findCell);
       prototype.registerHybridMethod("getRowCount", &HybridXlsxWorksheetSpec::getRowCount);
       prototype.registerHybridMethod("getColumnCount", &HybridXlsxWorksheetSpec::getColumnCount);
       prototype.registerHybridMethod("getLastRow", &HybridXlsxWorksheetSpec::getLastRow);
       prototype.registerHybridMethod("getLastColumn", &HybridXlsxWorksheetSpec::getLastColumn);
       prototype.registerHybridMethod("getName", &HybridXlsxWorksheetSpec::getName);
+      prototype.registerHybridMethod("toJSON", &HybridXlsxWorksheetSpec::toJSON);
+      prototype.registerHybridMethod("fromJSON", &HybridXlsxWorksheetSpec::fromJSON);
     });
   }
 

package/nitrogen/generated/shared/c++/HybridXlsxWorksheetSpec.hpp

@@ -15,6 +15,8 @@
 
 // Forward declaration of `HybridXlsxCellFormatSpec` to properly resolve imports.
 namespace margelo::nitro::xlsx { class HybridXlsxCellFormatSpec; }
+// Forward declaration of `HybridXlsxConditionalFormatsSpec` to properly resolve imports.
+namespace margelo::nitro::xlsx { class HybridXlsxConditionalFormatsSpec; }
 // Forward declaration of `CellType` to properly resolve imports.
 namespace margelo::nitro::xlsx { enum class CellType; }
 
@@ -22,10 +24,12 @@ namespace margelo::nitro::xlsx { enum class CellType; }
 #include <memory>
 #include "HybridXlsxCellFormatSpec.hpp"
 #include <optional>
-#include <NitroModules/ArrayBuffer.hpp>
+#include "HybridXlsxConditionalFormatsSpec.hpp"
 #include <NitroModules/Null.hpp>
 #include <variant>
 #include "CellType.hpp"
+#include <NitroModules/AnyMap.hpp>
+#include <vector>
 
 namespace margelo::nitro::xlsx {
 
@@ -71,42 +75,70 @@ namespace margelo::nitro::xlsx {
       virtual void writeURL(double row, double col, const std::string& url, const std::optional<std::shared_ptr<HybridXlsxCellFormatSpec>>& format) = 0;
       virtual void setColumn(double firstCol, double lastCol, double width, const std::optional<std::shared_ptr<HybridXlsxCellFormatSpec>>& format) = 0;
       virtual void setRow(double row, double height, const std::optional<std::shared_ptr<HybridXlsxCellFormatSpec>>& format) = 0;
+      virtual bool deleteRow(double row) = 0;
+      virtual bool deleteColumn(double col) = 0;
       virtual void mergeRange(double firstRow, double firstCol, double lastRow, double lastCol, const std::string& value, const std::optional<std::shared_ptr<HybridXlsxCellFormatSpec>>& format) = 0;
       virtual void mergeRangeNum(double firstRow, double firstCol, double lastRow, double lastCol, double value, const std::optional<std::shared_ptr<HybridXlsxCellFormatSpec>>& format) = 0;
-      virtual void insertImage(double row, double col, const std::string& path, std::optional<double> xOffset, std::optional<double> yOffset, std::optional<double> xScale, std::optional<double> yScale) = 0;
-      virtual void insertImageBuffer(double row, double col, const std::shared_ptr<ArrayBuffer>& buffer, const std::string& extension, std::optional<double> xOffset, std::optional<double> yOffset, std::optional<double> xScale, std::optional<double> yScale) = 0;
-      virtual void autofilter(double firstRow, double firstCol, double lastRow, double lastCol) = 0;
-      virtual void freezePanes(double row, double col) = 0;
-      virtual void splitPanes(double row, double col) = 0;
-      virtual void setTabColor(double color) = 0;
+      virtual void unmergeCells(double firstRow, double firstCol, double lastRow, double lastCol) = 0;
       virtual void hide() = 0;
       virtual void activate() = 0;
-      virtual void setFirstSheet() = 0;
       virtual void protect(const std::optional<std::string>& password) = 0;
-      virtual void setPortrait() = 0;
-      virtual void setLandscape() = 0;
-      virtual void setPaper(double paperType) = 0;
-      virtual void setHeader(const std::string& header) = 0;
-      virtual void setFooter(const std::string& footer) = 0;
-      virtual void setPrintArea(double firstRow, double firstCol, double lastRow, double lastCol) = 0;
-      virtual void fitToPages(double width, double height) = 0;
-      virtual void setZoom(double scale) = 0;
-      virtual void setGridlines(double option) = 0;
-      virtual void centerHorizontally() = 0;
-      virtual void centerVertically() = 0;
-      virtual void setOutline(double level) = 0;
+      virtual void protectSheet(std::optional<bool> set) = 0;
+      virtual void protectObjects(std::optional<bool> set) = 0;
+      virtual void protectScenarios(std::optional<bool> set) = 0;
+      virtual void setPassword(const std::string& password) = 0;
+      virtual void setPasswordHash(const std::string& hash) = 0;
+      virtual void clearPassword() = 0;
+      virtual void clearSheetProtection() = 0;
+      virtual void allowInsertColumns(std::optional<bool> set) = 0;
+      virtual void allowInsertRows(std::optional<bool> set) = 0;
+      virtual void allowDeleteColumns(std::optional<bool> set) = 0;
+      virtual void allowDeleteRows(std::optional<bool> set) = 0;
+      virtual void allowSelectLockedCells(std::optional<bool> set) = 0;
+      virtual void allowSelectUnlockedCells(std::optional<bool> set) = 0;
+      virtual void denyInsertColumns() = 0;
+      virtual void denyInsertRows() = 0;
+      virtual void denyDeleteColumns() = 0;
+      virtual void denyDeleteRows() = 0;
+      virtual void denySelectLockedCells() = 0;
+      virtual void denySelectUnlockedCells() = 0;
+      virtual bool sheetProtected() = 0;
+      virtual bool objectsProtected() = 0;
+      virtual bool scenariosProtected() = 0;
+      virtual bool insertColumnsAllowed() = 0;
+      virtual bool insertRowsAllowed() = 0;
+      virtual bool deleteColumnsAllowed() = 0;
+      virtual bool deleteRowsAllowed() = 0;
+      virtual bool selectLockedCellsAllowed() = 0;
+      virtual bool selectUnlockedCellsAllowed() = 0;
+      virtual bool passwordIsSet() = 0;
+      virtual std::string passwordHash() = 0;
+      virtual std::string sheetProtectionSummary() = 0;
       virtual void setColumnHidden(double firstCol, double lastCol, bool hidden) = 0;
       virtual void setRowHidden(double row, bool hidden) = 0;
+      virtual void setComment(double row, double col, const std::string& text, std::optional<double> authorId) = 0;
+      virtual std::string getComment(double row, double col) = 0;
+      virtual bool hasComment(double row, double col) = 0;
+      virtual bool deleteComment(double row, double col) = 0;
+      virtual double getCommentCount() = 0;
+      virtual double addCommentAuthor(const std::string& author) = 0;
+      virtual std::string getCommentAuthor(double authorId) = 0;
+      virtual std::shared_ptr<HybridXlsxConditionalFormatsSpec> getConditionalFormats() = 0;
       virtual std::variant<bool, nitro::NullType, std::string, double> getCellValue(double row, double col) = 0;
       virtual std::string getCellString(double row, double col) = 0;
       virtual std::string getCellRawValue(double row, double col) = 0;
       virtual CellType getCellType(double row, double col) = 0;
       virtual std::shared_ptr<HybridXlsxCellFormatSpec> getCellFormat(double row, double col) = 0;
+      virtual bool hasFormula(double row, double col) = 0;
+      virtual std::string formula(double row, double col) = 0;
+      virtual bool findCell(double row, double col) = 0;
       virtual double getRowCount() = 0;
       virtual double getColumnCount() = 0;
       virtual double getLastRow() = 0;
       virtual double getLastColumn() = 0;
       virtual std::string getName() = 0;
+      virtual std::vector<std::shared_ptr<AnyMap>> toJSON(const std::optional<std::vector<std::string>>& keys) = 0;
+      virtual void fromJSON(const std::vector<std::shared_ptr<AnyMap>>& data) = 0;
 
     protected:
       // Hybrid Setup

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-nitro-xlsx",
-  "version": "0.1.2",
+  "version": "0.2.5",
   "description": "Fast XLSX file reading and writing for React Native using OpenXLSX and Nitro Modules",
   "license": "MIT",
   "homepage": "https://github.com/zydbkqf/react-native-nitro-xlsx",
@@ -10,9 +10,10 @@
   "types": "src/index.ts",
   "source": "src/index.ts",
   "scripts": {
+    "postinstall": "node scripts/prepare-openxlsx.js",
     "specs": "nitrogen",
     "test": "jest",
-    "test:cpp": "cd cpp/tests && [ -n \"$OPENXLSX_PATH\" ] || OPENXLSX_PATH=$HOME/OpenXLSX; cmake -B build -DOPENXLSX_PATH=$OPENXLSX_PATH && cmake --build build && cd build && ctest --output-on-failure",
+    "test:cpp": "bash scripts/run-cpp-tests.sh",
     "test:cpp:clean": "rm -rf cpp/tests/build"
   },
   "peerDependencies": {
@@ -36,6 +37,8 @@
     "!cpp/tests",
     "android",
     "ios",
+    "scripts",
+    "Package.swift",
     "nitro.json",
     "nitrogen",
     "NitroXlsx.podspec",

package/scripts/prepare-openxlsx.js

@@ -0,0 +1,126 @@
+import { execSync } from 'child_process';
+import { existsSync, mkdirSync, writeFileSync, symlinkSync, readFileSync, lstatSync, unlinkSync } from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const rootDir = dirname(__dirname);
+
+function run(command, options = {}) {
+  console.log(`> ${command}`);
+  execSync(command, { stdio: 'inherit', ...options });
+}
+
+function ensureDir(dir) {
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+}
+
+function cloneRepo(url, tag, dest) {
+  if (existsSync(dest)) {
+    console.log(`Already exists: ${dest}`);
+    return;
+  }
+  run(`git clone --depth 1 --branch ${tag} ${url} ${dest}`);
+}
+
+function writeFileIfNotExists(path, content) {
+  if (existsSync(path)) {
+    console.log(`Already exists: ${path}`);
+    return;
+  }
+  writeFileSync(path, content);
+  console.log(`Created: ${path}`);
+}
+
+function createSymlinkIfNotExists(target, link) {
+  // lstat does NOT follow symlinks, so a broken link still counts as "exists".
+  // existsSync would return false for a broken link and then symlinkSync throws EEXIST.
+  try {
+    lstatSync(link);
+    if (existsSync(link)) {
+      console.log(`Already exists: ${link}`);
+      return;
+    }
+    // Path exists but is a broken symlink — replace it below.
+    unlinkSync(link);
+  } catch {
+    // not present — fall through and create
+  }
+  try {
+    symlinkSync(target, link);
+    console.log(`Created symlink: ${link} -> ${target}`);
+  } catch (e) {
+    if (e.code === 'EEXIST') {
+      console.log(`Already exists: ${link}`);
+      return;
+    }
+    throw e;
+  }
+}
+
+function getPackageVersion() {
+  const packageJsonPath = join(rootDir, 'package.json');
+  const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
+  return packageJson.version || '0.1.0';
+}
+
+const openxlsxDir = join(rootDir, 'OpenXLSX');
+const thirdPartyDir = join(openxlsxDir, 'ThirdParty');
+const pugixmlDir = join(thirdPartyDir, 'pugixml');
+const minizDir = join(thirdPartyDir, 'miniz');
+
+// Clone OpenXLSX and dependencies
+cloneRepo('https://github.com/troldal/OpenXLSX.git', 'v0.5.1', openxlsxDir);
+ensureDir(thirdPartyDir);
+cloneRepo('https://github.com/zeux/pugixml.git', 'v1.16', pugixmlDir);
+cloneRepo('https://github.com/richgel999/miniz.git', '3.1.2', minizDir);
+
+// Generate miniz_export.h
+const minizExportHeader = `#ifndef MINIZ_EXPORT_H
+#define MINIZ_EXPORT_H
+
+#ifndef MINIZ_EXPORT
+#define MINIZ_EXPORT
+#endif
+
+#ifndef MINIZ_DEPRECATED
+#define MINIZ_DEPRECATED
+#endif
+
+#ifndef MINIZ_DEPRECATED_EXPORT
+#define MINIZ_DEPRECATED_EXPORT MINIZ_EXPORT MINIZ_DEPRECATED
+#endif
+
+#ifndef MINIZ_NO_EXPORT
+#define MINIZ_NO_EXPORT
+#endif
+
+#endif
+`;
+writeFileIfNotExists(join(minizDir, 'miniz_export.h'), minizExportHeader);
+
+// Generate OpenXLSX-Exports.hpp
+const openxlsxExportsHeader = `#ifndef OPENXLSX_EXPORTS_HPP
+#define OPENXLSX_EXPORTS_HPP
+
+#ifndef OPENXLSX_EXPORT
+#define OPENXLSX_EXPORT
+#endif
+
+#ifndef OPENXLSX_HIDDEN
+#define OPENXLSX_HIDDEN
+#endif
+
+#endif
+`;
+const headersDir = join(openxlsxDir, 'OpenXLSX', 'headers');
+ensureDir(headersDir);
+writeFileIfNotExists(join(headersDir, 'OpenXLSX-Exports.hpp'), openxlsxExportsHeader);
+
+// Create symlink for #include <OpenXLSX/XXX.hpp> resolution
+createSymlinkIfNotExists('.', join(headersDir, 'OpenXLSX'));
+
+console.log(`OpenXLSX dependencies prepared successfully for react-native-nitro-xlsx v${getPackageVersion()}.`);