react-native-nitro-xlsx 0.1.4 → 0.2.6

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,6 +19,9 @@ 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,7 +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 {
 
@@ -63,9 +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::string toJSON(const std::optional<std::vector<std::string>>& keys) = 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.4",
+  "version": "0.2.6",
   "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,10 +10,9 @@
   "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": {
@@ -35,6 +34,7 @@
     "src",
     "cpp",
     "!cpp/tests",
+    "thirdparty",
     "android",
     "ios",
     "scripts",

package/scripts/run-cpp-tests.sh

@@ -0,0 +1,14 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT="$(cd "$(dirname "$0")/.." && pwd)"
+cd "$ROOT/cpp/tests"
+
+if [ -z "${OPENXLSX_PATH:-}" ]; then
+  OPENXLSX_PATH="$ROOT/thirdparty/OpenXLSX"
+fi
+
+cmake -B build -DOPENXLSX_PATH="$OPENXLSX_PATH"
+cmake --build build
+cd build
+ctest --output-on-failure

package/src/__mocks__/react-native-nitro-modules.ts

@@ -24,5 +24,6 @@ export const NitroModules = {
     createWorkbook: jest.fn(),
     openWorkbook: jest.fn(),
     openWorkbookFromBuffer: jest.fn(),
+    fromJSON: jest.fn(),
   }),
 };

package/src/__tests__/index.test.ts

@@ -10,7 +10,11 @@ import {
   Gridlines,
   Colors,
   NumFormat,
-  ImagePosition,
+  XlsxError,
+  XlsxErrorCode,
+  CfType,
+  CfOperator,
+  CfTimePeriod,
 } from '../index';
 
 describe('NitroXlsx', () => {
@@ -33,6 +37,14 @@ describe('NitroXlsx', () => {
     expect(NitroXlsx.openWorkbookFromBuffer).toBeDefined();
     expect(typeof NitroXlsx.openWorkbookFromBuffer).toBe('function');
   });
+
+  it('should have fromJSON method that accepts a Record of sheet rows', () => {
+    expect(NitroXlsx.fromJSON).toBeDefined();
+    expect(typeof NitroXlsx.fromJSON).toBe('function');
+    expect(() =>
+      NitroXlsx.fromJSON({ Sheet1: [{ Name: 'Alice', Age: 30 }] })
+    ).not.toThrow();
+  });
 });
 
 describe('Constants', () => {
@@ -130,12 +142,69 @@ describe('Constants', () => {
     });
   });
 
-  describe('ImagePosition', () => {
-    it('should export ImagePosition constants', () => {
-      expect(ImagePosition).toBeDefined();
-      expect(ImagePosition.MOVE_AND_SIZE).toBe(1);
-      expect(ImagePosition.MOVE_DONT_SIZE).toBe(2);
-      expect(ImagePosition.DONT_MOVE_DONT_SIZE).toBe(3);
+  describe('CfType', () => {
+    it('should export CfType constants', () => {
+      expect(CfType).toBeDefined();
+      expect(CfType.EXPRESSION).toBe(0);
+      expect(CfType.CELL_IS).toBe(1);
+      expect(CfType.TOP10).toBe(5);
+      expect(CfType.CONTAINS_TEXT).toBe(8);
+      expect(CfType.TIME_PERIOD).toBe(16);
+    });
+  });
+
+  describe('CfOperator', () => {
+    it('should export CfOperator constants', () => {
+      expect(CfOperator).toBeDefined();
+      expect(CfOperator.LESS_THAN).toBe(0);
+      expect(CfOperator.EQUAL).toBe(2);
+      expect(CfOperator.GREATER_THAN).toBe(5);
+      expect(CfOperator.BETWEEN).toBe(6);
     });
   });
+
+  describe('CfTimePeriod', () => {
+    it('should export CfTimePeriod constants', () => {
+      expect(CfTimePeriod).toBeDefined();
+      expect(CfTimePeriod.TODAY).toBe(0);
+      expect(CfTimePeriod.YESTERDAY).toBe(1);
+      expect(CfTimePeriod.THIS_WEEK).toBe(7);
+    });
+  });
+});
+
+describe('XlsxError', () => {
+  it('should export XlsxErrorCode constants', () => {
+    expect(XlsxErrorCode.INVALID_ARGUMENT).toBe('INVALID_ARGUMENT');
+    expect(XlsxErrorCode.SHEET_NOT_FOUND).toBe('SHEET_NOT_FOUND');
+    expect(XlsxErrorCode.INDEX_OUT_OF_RANGE).toBe('INDEX_OUT_OF_RANGE');
+    expect(XlsxErrorCode.UNSUPPORTED).toBe('UNSUPPORTED');
+    expect(XlsxErrorCode.XLSX_ERROR).toBe('XLSX_ERROR');
+  });
+
+  it('should create XlsxError with code and message', () => {
+    const err = new XlsxError(XlsxErrorCode.SHEET_NOT_FOUND, 'Sheet missing');
+    expect(err).toBeInstanceOf(Error);
+    expect(err.name).toBe('XlsxError');
+    expect(err.code).toBe('SHEET_NOT_FOUND');
+    expect(err.message).toContain('SHEET_NOT_FOUND');
+    expect(err.message).toContain('Sheet missing');
+  });
+
+  it('should parse native error message into XlsxError', () => {
+    const native = new Error('deleteSheet: SHEET_NOT_FOUND: Worksheet not found: Foo');
+    const err = XlsxError.from(native);
+    expect(err.code).toBe('SHEET_NOT_FOUND');
+    expect(err.message).toContain('Worksheet not found: Foo');
+  });
+
+  it('should wrap unknown errors with INTERNAL_ERROR', () => {
+    const err = XlsxError.from(new Error('something odd'));
+    expect(err.code).toBe('INTERNAL_ERROR');
+  });
+
+  it('should return the same instance if already XlsxError', () => {
+    const original = new XlsxError(XlsxErrorCode.IO_ERROR, 'disk');
+    expect(XlsxError.from(original)).toBe(original);
+  });
 });