react-native-nitro-xlsx 0.1.2 → 0.1.4

package/NOTICE

@@ -4,7 +4,8 @@ This software uses third-party open source components listed below, with full li
 ================================================================================
 1. OpenXLSX
 Repository: https://github.com/troldal/OpenXLSX
-License: BSD 3-Clause License
+Version: 0.5.1
+License: BSD 3-Clause License (SPDX: BSD-3-Clause)
 Copyright (c) 2020 Kenneth Troldal Balslev
 
 Full BSD 3-Clause License text:
@@ -27,7 +28,7 @@ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 2. react-native-nitro-modules
 Repository: https://github.com/mrousavy/nitro
 Version: 0.58.3
-License: MIT License
+License: MIT License (SPDX: MIT)
 Copyright (c) 2024 Marc Rousavy
 
 Full MIT License text:
@@ -56,7 +57,8 @@ SOFTWARE.
 ================================================================================
 3. pugixml (OpenXLSX dependency)
 Repository: https://github.com/zeux/pugixml
-License: MIT License
+Version: 1.16
+License: MIT License (SPDX: MIT)
 Copyright (c) 2006-2024 Arseny Kapoulkine
 
 Full MIT License text:
@@ -72,39 +74,10 @@ The above copyright notice and this permission notice shall be included in all c
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 ================================================================================
-4. Zippy (OpenXLSX dependency)
-Repository: https://github.com/troldal/Zippy
-License: MIT License
-Copyright (c) 2019 Kenneth Troldal Balslev
-
-Full MIT License text:
-
-MIT License
-
-Copyright (c) 2019 Kenneth Troldal Balslev
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-
-================================================================================
-5. miniz (OpenXLSX dependency)
+4. miniz (OpenXLSX dependency)
 Repository: https://github.com/richgel999/miniz
-License: MIT License
+Version: 3.1.2
+License: MIT License (SPDX: MIT)
 Copyright (c) 2013-2014 RAD Game Tools and Valve Software
 Copyright (c) 2010-2014 Rich Geldreich and Tenacious Software LLC
 

package/NitroXlsx.podspec

@@ -11,9 +11,13 @@ Pod::Spec.new do |s|
   s.authors      = package["author"]
 
   s.platforms    = { :ios => "15.1" }
-  s.source       = { :git => "", :tag => "#{s.version}" }
+  s.source       = { :git => "https://github.com/zydbkqf/react-native-nitro-xlsx.git", :tag => "#{s.version}" }
 
-  s.exclude_files = "cpp/tests/**/*"
+  s.exclude_files = [
+    "cpp/tests/**/*",
+    "OpenXLSX/ThirdParty/miniz/tests/**/*",
+    "OpenXLSX/ThirdParty/miniz/examples/**/*",
+  ]
 
   s.source_files = [
     "cpp/**/*.{h,hpp,cpp}",
@@ -49,61 +53,20 @@ Pod::Spec.new do |s|
     "HEADER_SEARCH_PATHS" => "$(inherited) ${PODS_TARGET_SRCROOT}/OpenXLSX ${PODS_TARGET_SRCROOT}/OpenXLSX/OpenXLSX ${PODS_TARGET_SRCROOT}/OpenXLSX/OpenXLSX/headers ${PODS_TARGET_SRCROOT}/OpenXLSX/ThirdParty/pugixml/src ${PODS_TARGET_SRCROOT}/OpenXLSX/ThirdParty/miniz",
   }
 
-  s.prepare_command = <<-CMD
-    if [ ! -d "OpenXLSX" ]; then
-      git clone --depth 1 --branch v0.5.1 https://github.com/troldal/OpenXLSX.git
-    fi
-    mkdir -p OpenXLSX/ThirdParty
-    if [ ! -d "OpenXLSX/ThirdParty/pugixml" ]; then
-      git clone --depth 1 --branch v1.15 https://github.com/zeux/pugixml.git OpenXLSX/ThirdParty/pugixml
-    fi
-    if [ ! -d "OpenXLSX/ThirdParty/miniz" ]; then
-      git clone --depth 1 --branch 3.0.2 https://github.com/richgel999/miniz.git OpenXLSX/ThirdParty/miniz
-    fi
-    if [ ! -f "OpenXLSX/ThirdParty/miniz/miniz_export.h" ]; then
-      cat > OpenXLSX/ThirdParty/miniz/miniz_export.h << 'EOF'
-#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
-EOF
-    fi
-    if [ ! -f "OpenXLSX/OpenXLSX/headers/OpenXLSX-Exports.hpp" ]; then
-      cat > OpenXLSX/OpenXLSX/headers/OpenXLSX-Exports.hpp << 'EOF'
-#ifndef OPENXLSX_EXPORTS_HPP
-#define OPENXLSX_EXPORTS_HPP
-
-#ifndef OPENXLSX_EXPORT
-#define OPENXLSX_EXPORT
-#endif
-
-#ifndef OPENXLSX_HIDDEN
-#define OPENXLSX_HIDDEN
-#endif
-
-#endif
-EOF
-    fi
-    if [ ! -d "OpenXLSX/OpenXLSX/headers/OpenXLSX" ]; then
-      cd OpenXLSX/OpenXLSX/headers && ln -sf . OpenXLSX && cd -
-    fi
-  CMD
+  # Prepare OpenXLSX and its dependencies (pugixml, miniz) via a Node script
+  # so the same logic can be reused from both CocoaPods and Android CMake.
+  s.prepare_command = "node #{__dir__}/scripts/prepare-openxlsx.js"
+
+  # Swift Package Manager declaration for React Native 0.87+.
+  # This exposes NitroXlsx as a local Swift package; the heavy lifting for
+  # OpenXLSX is still done by the prepare command above.
+  if ENV['NITRO_XLSX_USE_SPM'] == '1' && defined?(SPM) && SPM.respond_to?(:dependency)
+    SPM.dependency(s,
+      url: File.join(__dir__, "."),
+      requirement: { kind: 'upToNextMajorVersion', minimumVersion: s.version.to_s },
+      products: ['NitroXlsx']
+    )
+  end
 
   load 'nitrogen/generated/ios/NitroXlsx+autolinking.rb'
   add_nitrogen_files(s)

package/Package.swift

@@ -0,0 +1,31 @@
+// swift-tools-version: 5.9
+import PackageDescription
+
+// NOTE: This Package.swift is a Swift Package Manager manifest stub for
+// React Native 0.87+ compatibility. The library is still primarily built
+// through CocoaPods (NitroXlsx.podspec), where OpenXLSX, pugixml and miniz
+// are cloned and compiled from source by scripts/prepare-openxlsx.js.
+//
+// The local package reference below lets RN 0.87's spm_dependency helper
+// register NitroXlsx in the Pods project when SwiftPM mode is enabled.
+// Full SPM-based compilation of the C++ sources is not yet supported.
+
+let package = Package(
+    name: "NitroXlsx",
+    platforms: [
+        .iOS(.v15)
+    ],
+    products: [
+        .library(
+            name: "NitroXlsx",
+            targets: ["NitroXlsx"]
+        )
+    ],
+    targets: [
+        .target(
+            name: "NitroXlsx",
+            path: "ios",
+            sources: ["dummy.swift"]
+        )
+    ]
+)

package/README.md

@@ -22,6 +22,8 @@ npm install react-native-nitro-xlsx
 yarn add react-native-nitro-xlsx
 ```
 
+> **Note**: Native dependencies (OpenXlsx) are downloaded from GitHub during the first build. Please make sure you have a stable network connection.
+
 ### iOS
 
 ```sh
@@ -122,6 +124,47 @@ const fontName = format.getFontName();
 const fontSize = format.getFontSize();
 ```
 
+### Working with JSON
+
+#### Export to JSON (`toJSON`)
+
+Convert worksheet data to a JSON array. By default, the first row is used as object keys.
+
+```typescript
+import { NitroXlsx, toJSON } from 'react-native-nitro-xlsx';
+
+const workbook = NitroXlsx.openWorkbook('/path/to/data.xlsx');
+
+// Use the first row as keys (default)
+const data = toJSON(workbook);
+// Result: [{ "Name": "Alice", "Age": 30 }, { "Name": "Bob", "Age": 25 }]
+
+// Provide custom keys
+const data = toJSON(workbook, ['firstName', 'yearsOld']);
+// Result: [{ "firstName": "Alice", "yearsOld": 30 }, { "firstName": "Bob", "yearsOld": 25 }]
+```
+
+#### Import from JSON (`fromJSON`)
+
+Create a workbook from a JSON array. The first object's keys become the header row.
+
+```typescript
+import { NitroXlsx } from 'react-native-nitro-xlsx';
+
+const data = [
+  { Name: 'Alice', Age: 30, Active: true },
+  { Name: 'Bob', Age: 25, Active: false },
+];
+
+const workbook = NitroXlsx.fromJSON(data);
+// The workbook now has a worksheet with:
+// Row 1 (header): Name | Age | Active
+// Row 2:          Alice | 30 | true
+// Row 3:          Bob   | 25 | false
+
+const buffer = await workbook.getBuffer();
+```
+
 ## API
 
 ### NitroXlsx
@@ -129,6 +172,7 @@ const fontSize = format.getFontSize();
 - `createWorkbook(tempDir?: string): XlsxWorkbook` - Create a new workbook. On Android, pass the app's cache directory (e.g., `RNFS.CachesDirectoryPath`) to avoid sandbox write permission issues.
 - `openWorkbook(path: string): XlsxWorkbook` - Open workbook from file path
 - `openWorkbookFromBuffer(buffer: ArrayBuffer): XlsxWorkbook` - Open workbook from buffer
+- `fromJSON(data: Array<Record<string, string | number>>): XlsxWorkbook` - Create a workbook from a JSON array (static method)
 
 ### XlsxWorkbook
 
@@ -139,6 +183,7 @@ const fontSize = format.getFontSize();
 - `getWorksheetCount(): number` - Get number of worksheets
 - `addCellFormat(): XlsxCellFormat` - Add a new cell format
 - `getBuffer(): Promise<ArrayBuffer>` - Generate and return the XLSX file as a buffer
+- `toJSON(keys?: string[]): Array<Record<string, string | number>>` - Convert worksheet data to a JSON array
 
 ### XlsxWorksheet
 

package/android/CMakeLists.txt

@@ -5,22 +5,21 @@ set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
 set(OPENXLSX_DIR ${CMAKE_SOURCE_DIR}/../OpenXLSX)
-if(NOT EXISTS ${OPENXLSX_DIR}/CMakeLists.txt)
-  # Clean up incomplete directory to ensure fresh clone
-  if(EXISTS ${OPENXLSX_DIR})
-    file(REMOVE_RECURSE ${OPENXLSX_DIR})
-  endif()
 
-  include(FetchContent)
-  FetchContent_Declare(
-    OpenXLSX
-    GIT_REPOSITORY https://github.com/troldal/OpenXLSX.git
-    GIT_TAG v0.5.1
-    SOURCE_DIR ${OPENXLSX_DIR}
-    GIT_SHALLOW TRUE
-    GIT_PROGRESS TRUE
+# Prepare OpenXLSX and its dependencies (pugixml, miniz) using the same
+# Node script that CocoaPods' prepare_command runs on iOS.
+find_program(NODE_EXECUTABLE node REQUIRED)
+execute_process(
+  COMMAND ${NODE_EXECUTABLE} ${CMAKE_SOURCE_DIR}/../scripts/prepare-openxlsx.js
+  WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/..
+  RESULT_VARIABLE PREPARE_RESULT
+)
+if(NOT PREPARE_RESULT EQUAL 0)
+  message(FATAL_ERROR
+    "Failed to prepare OpenXLSX dependencies.\n"
+    "Please ensure Node.js is installed and run:\n"
+    "  node scripts/prepare-openxlsx.js"
   )
-  FetchContent_Populate(OpenXLSX)
 endif()
 
 # Verify OpenXLSX is available
@@ -33,15 +32,6 @@ if(NOT EXISTS ${OPENXLSX_DIR}/CMakeLists.txt)
   )
 endif()
 
-# Create symlink for #include <OpenXLSX/XXX.hpp> resolution
-# Same as iOS podspec: cd OpenXLSX/OpenXLSX/headers && ln -sf . OpenXLSX
-if(NOT EXISTS ${OPENXLSX_DIR}/OpenXLSX/headers/OpenXLSX)
-  execute_process(
-    COMMAND ${CMAKE_COMMAND} -E create_symlink . OpenXLSX
-    WORKING_DIRECTORY ${OPENXLSX_DIR}/OpenXLSX/headers
-  )
-endif()
-
 set(OPENXLSX_BUILD_SAMPLES OFF CACHE BOOL "" FORCE)
 set(OPENXLSX_BUILD_TESTS OFF CACHE BOOL "" FORCE)
 set(OPENXLSX_BUILD_BENCHMARKS OFF CACHE BOOL "" FORCE)

package/android/build.gradle

@@ -4,6 +4,11 @@ buildscript {
   }
 }
 
+def reactNativeArchitectures() {
+  def value = rootProject.getProperties().get("reactNativeArchitectures")
+  return value ? value.split(",") : ["armeabi-v7a", "x86", "x86_64", "arm64-v8a"]
+}
+
 apply plugin: 'com.android.library'
 apply plugin: 'kotlin-android'
 
@@ -16,6 +21,7 @@ android {
     externalNativeBuild {
       cmake {
         arguments "-DANDROID_STL=c++_shared"
+        abiFilters (*reactNativeArchitectures())
       }
     }
   }

package/cpp/HybridNitroXlsx.cpp

@@ -1,5 +1,98 @@
 #include "HybridNitroXlsx.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 {
 
@@ -26,4 +119,88 @@ std::shared_ptr<HybridXlsxWorkbookSpec> HybridNitroXlsx::openWorkbookFromBuffer(
   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('[');
+
+  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;
+    }
+    ++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;
+}
+
 }

package/cpp/HybridNitroXlsx.hpp

@@ -14,6 +14,7 @@ public:
   std::shared_ptr<HybridXlsxWorkbookSpec> createWorkbook(const std::optional<std::string>& tempDir = std::nullopt) 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;
 };
 
 }

package/cpp/HybridXlsxWorkbook.cpp

@@ -4,12 +4,43 @@
 #include <sstream>
 #include <cstdlib>
 #include <unistd.h>
+#include <cmath>
+#include <cstring>
+#include <iomanip>
 
 #ifdef __ANDROID__
 #include <android/api-level.h>
 #include <sys/stat.h>
 #endif
 
+namespace {
+
+void writeJsonString(std::ostringstream& out, const std::string& s) {
+  out << '"';
+  for (char c : s) {
+    switch (c) {
+      case '"':  out << "\\\""; break;
+      case '\\': out << "\\\\"; break;
+      case '\b': out << "\\b";  break;
+      case '\f': out << "\\f";  break;
+      case '\n': out << "\\n";  break;
+      case '\r': out << "\\r";  break;
+      case '\t': out << "\\t";  break;
+      default:
+        if (static_cast<unsigned char>(c) < 0x20) {
+          out << "\\u" << std::hex << std::setw(4) << std::setfill('0')
+              << static_cast<int>(static_cast<unsigned char>(c))
+              << std::dec;
+        } else {
+          out << c;
+        }
+    }
+  }
+  out << '"';
+}
+
+} // anonymous namespace
+
 namespace margelo::nitro::xlsx {
 
 namespace {
@@ -186,4 +217,85 @@ std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>> HybridXlsxWorkbook::getBu
   return promise;
 }
 
+std::string HybridXlsxWorkbook::toJSON(const std::optional<std::vector<std::string>>& keys) {
+  if (_worksheets.empty()) {
+    return "[]";
+  }
+  auto& ws = _worksheets[0];
+  auto lastRow = static_cast<unsigned int>(ws->getLastRow());
+  auto lastCol = static_cast<unsigned int>(ws->getLastColumn());
+  if (lastRow == 0 || lastCol == 0) {
+    return "[]";
+  }
+
+  unsigned int dataStartRow = 1;
+  std::vector<std::string> resolvedKeys;
+
+  if (keys.has_value()) {
+    resolvedKeys = *keys;
+  } else {
+    dataStartRow = 2;
+    for (unsigned int c = 1; c <= lastCol; ++c) {
+      auto val = ws->getCellValue(1, c);
+      if (auto* s = std::get_if<std::string>(&val)) {
+        resolvedKeys.push_back(*s);
+      } else if (auto* d = std::get_if<double>(&val)) {
+        resolvedKeys.push_back(std::to_string(static_cast<int>(*d)));
+      } else {
+        resolvedKeys.push_back("col" + std::to_string(c));
+      }
+    }
+  }
+
+  if (resolvedKeys.empty()) {
+    return "[]";
+  }
+
+  std::ostringstream out;
+  out << "[";
+
+  bool firstRow = true;
+
+  for (unsigned int r = dataStartRow; r <= lastRow; ++r) {
+    bool hasData = false;
+    for (unsigned int c = 1; c <= std::min(static_cast<unsigned int>(resolvedKeys.size()), lastCol); ++c) {
+      auto cellType = ws->getCellType(r, c);
+      if (cellType != CellType::EMPTY) {
+        hasData = true;
+        break;
+      }
+    }
+    if (!hasData) continue;
+
+    if (!firstRow) out << ",";
+    firstRow = false;
+
+    out << "{";
+    unsigned int keyCount = std::min(static_cast<unsigned int>(resolvedKeys.size()), lastCol);
+    for (unsigned int c = 0; c < keyCount; ++c) {
+      if (c > 0) out << ",";
+      writeJsonString(out, resolvedKeys[c]);
+      out << ":";
+      auto val = ws->getCellValue(r, c + 1);
+      if (auto* s = std::get_if<std::string>(&val)) {
+        writeJsonString(out, *s);
+      } else if (auto* d = std::get_if<double>(&val)) {
+        if (std::isnan(*d) || std::isinf(*d)) {
+          out << "null";
+        } else {
+          out << *d;
+        }
+      } else if (auto* b = std::get_if<bool>(&val)) {
+        out << (*b ? "true" : "false");
+      } else {
+        out << "null";
+      }
+    }
+    out << "}";
+  }
+
+  out << "]";
+  return out.str();
+}
+
 }

package/cpp/HybridXlsxWorkbook.hpp

@@ -26,6 +26,7 @@ public:
   double getWorksheetCount() override;
   std::shared_ptr<HybridXlsxCellFormatSpec> addCellFormat() override;
   std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>> getBuffer() override;
+  std::string toJSON(const std::optional<std::vector<std::string>>& keys) override;
 
 private:
   std::unique_ptr<OpenXLSX::XLDocument> _workbook;

package/cpp/HybridXlsxWorksheet.cpp

@@ -75,6 +75,7 @@ void HybridXlsxWorksheet::writeFormulaBoolean(double row, double col, const std:
 void HybridXlsxWorksheet::writeArrayFormula(double firstRow, double firstCol, double lastRow, double lastCol, const std::string& formula, const std::optional<std::shared_ptr<HybridXlsxCellFormatSpec>>& format) {
   OpenXLSX::XLCell cell = _worksheet.cell(static_cast<unsigned int>(firstRow), static_cast<unsigned int>(firstCol));
   cell.formula() = formula;
+  applyFormat(cell, format);
 }
 
 void HybridXlsxWorksheet::writeDatetime(double row, double col, double datetime, const std::optional<std::shared_ptr<HybridXlsxCellFormatSpec>>& format) {
@@ -93,10 +94,33 @@ void HybridXlsxWorksheet::setColumn(double firstCol, double lastCol, double widt
   for (unsigned int c = static_cast<unsigned int>(firstCol); c <= static_cast<unsigned int>(lastCol); ++c) {
     _worksheet.column(c).setWidth(static_cast<float>(width));
   }
+  if (format.has_value()) {
+    // Apply format to entire column range by setting it on cells in the first row
+    // (OpenXLSX does not support column-level style; apply to first row cells as a hint)
+    auto hybridFormat = std::dynamic_pointer_cast<HybridXlsxCellFormat>(*format);
+    if (hybridFormat) {
+      auto styleIndex = hybridFormat->applyToDocument(_doc.styles());
+      for (unsigned int c = static_cast<unsigned int>(firstCol); c <= static_cast<unsigned int>(lastCol); ++c) {
+        OpenXLSX::XLCell cell = _worksheet.cell(1, c);
+        hybridFormat->applyToCell(cell, styleIndex);
+      }
+    }
+  }
 }
 
 void HybridXlsxWorksheet::setRow(double row, double height, const std::optional<std::shared_ptr<HybridXlsxCellFormatSpec>>& format) {
   _worksheet.row(static_cast<unsigned int>(row)).setHeight(static_cast<float>(height));
+  if (format.has_value()) {
+    auto hybridFormat = std::dynamic_pointer_cast<HybridXlsxCellFormat>(*format);
+    if (hybridFormat) {
+      auto styleIndex = hybridFormat->applyToDocument(_doc.styles());
+      unsigned int colCount = _worksheet.columnCount();
+      for (unsigned int c = 1; c <= colCount; ++c) {
+        OpenXLSX::XLCell cell = _worksheet.cell(static_cast<unsigned int>(row), c);
+        hybridFormat->applyToCell(cell, styleIndex);
+      }
+    }
+  }
 }
 
 void HybridXlsxWorksheet::mergeRange(double firstRow, double firstCol, double lastRow, double lastCol, const std::string& value, const std::optional<std::shared_ptr<HybridXlsxCellFormatSpec>>& format) {

package/ios/dummy.swift

@@ -0,0 +1,2 @@
+// This file exists solely so that SwiftPM has at least one source file
+// for the NitroXlsx target. The actual build is done via CocoaPods.

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

@@ -17,6 +17,7 @@ namespace margelo::nitro::xlsx {
       prototype.registerHybridMethod("createWorkbook", &HybridNitroXlsxSpec::createWorkbook);
       prototype.registerHybridMethod("openWorkbook", &HybridNitroXlsxSpec::openWorkbook);
       prototype.registerHybridMethod("openWorkbookFromBuffer", &HybridNitroXlsxSpec::openWorkbookFromBuffer);
+      prototype.registerHybridMethod("fromJSON", &HybridNitroXlsxSpec::fromJSON);
     });
   }
 

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

@@ -56,6 +56,7 @@ namespace margelo::nitro::xlsx {
       virtual std::shared_ptr<HybridXlsxWorkbookSpec> createWorkbook(const std::optional<std::string>& tempDir) = 0;
       virtual std::shared_ptr<HybridXlsxWorkbookSpec> openWorkbook(const std::string& path) = 0;
       virtual std::shared_ptr<HybridXlsxWorkbookSpec> openWorkbookFromBuffer(const std::shared_ptr<ArrayBuffer>& buffer) = 0;
+      virtual std::shared_ptr<HybridXlsxWorkbookSpec> fromJSON(const std::string& data) = 0;
 
     protected:
       // Hybrid Setup

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

@@ -21,6 +21,7 @@ namespace margelo::nitro::xlsx {
       prototype.registerHybridMethod("getWorksheetCount", &HybridXlsxWorkbookSpec::getWorksheetCount);
       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,7 @@ namespace margelo::nitro::xlsx { class HybridXlsxCellFormatSpec; }
 #include "HybridXlsxCellFormatSpec.hpp"
 #include <NitroModules/ArrayBuffer.hpp>
 #include <NitroModules/Promise.hpp>
+#include <vector>
 
 namespace margelo::nitro::xlsx {
 
@@ -64,6 +65,7 @@ namespace margelo::nitro::xlsx {
       virtual double getWorksheetCount() = 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;
 
     protected:
       // Hybrid Setup

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-nitro-xlsx",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "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,6 +10,7 @@
   "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",
@@ -36,6 +37,8 @@
     "!cpp/tests",
     "android",
     "ios",
+    "scripts",
+    "Package.swift",
     "nitro.json",
     "nitrogen",
     "NitroXlsx.podspec",

package/scripts/prepare-openxlsx.js

@@ -0,0 +1,109 @@
+import { execSync } from 'child_process';
+import { existsSync, mkdirSync, writeFileSync, symlinkSync, readFileSync } 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) {
+  if (existsSync(link)) {
+    console.log(`Already exists: ${link}`);
+    return;
+  }
+  symlinkSync(target, link);
+  console.log(`Created symlink: ${link} -> ${target}`);
+}
+
+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()}.`);

package/src/index.ts

@@ -1,7 +1,19 @@
 import { NitroModules } from 'react-native-nitro-modules'
-import type { NitroXlsx as NitroXlsxSpec } from './specs/NitroXlsx.nitro'
+import type { NitroXlsx as NitroXlsxSpec, XlsxWorkbook as XlsxWorkbookSpec } from './specs/NitroXlsx.nitro'
 
-export const NitroXlsx = NitroModules.createHybridObject<NitroXlsxSpec>('NitroXlsx')
+const NitroXlsxBridge = NitroModules.createHybridObject<NitroXlsxSpec>('NitroXlsx')
+
+type JsonRecord = Record<string, string | number>
+
+export const NitroXlsx = Object.assign(NitroXlsxBridge, {
+  fromJSON(data: JsonRecord[]): XlsxWorkbookSpec {
+    return NitroXlsxBridge.fromJSON(JSON.stringify(data))
+  },
+})
+
+export function toJSON(workbook: XlsxWorkbookSpec, keys?: string[]): JsonRecord[] {
+  return JSON.parse(workbook.toJSON(keys))
+}
 
 export type { XlsxWorkbook, XlsxWorksheet, XlsxCellFormat } from './specs/NitroXlsx.nitro'
 

package/src/specs/NitroXlsx.nitro.ts

@@ -10,6 +10,7 @@ export interface XlsxWorkbook extends HybridObject<{ ios: 'c++'; android: 'c++'
   getWorksheetCount(): number
   addCellFormat(): XlsxCellFormat
   getBuffer(): Promise<ArrayBuffer>
+  toJSON(keys?: string[]): string
 }
 
 export interface XlsxWorksheet extends HybridObject<{ ios: 'c++'; android: 'c++' }> {
@@ -151,4 +152,5 @@ export interface NitroXlsx extends HybridObject<{ ios: 'c++'; android: 'c++' }>
   createWorkbook(tempDir?: string): XlsxWorkbook
   openWorkbook(path: string): XlsxWorkbook
   openWorkbookFromBuffer(buffer: ArrayBuffer): XlsxWorkbook
+  fromJSON(data: string): XlsxWorkbook
 }