react-native-nitro-xlsx 0.1.1 → 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,33 +28,66 @@ 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:
+
+MIT License
+
+Copyright (c) 2024 Marc Rousavy
+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.
+
 ================================================================================
 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
 
-================================================================================
-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) 2006-2026 Arseny Kapoulkine
+
+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
 
-Full standard MIT License text:
+Full MIT License text:
 
-MIT License
+Copyright 2013-2014 RAD Game Tools and Valve Software
+Copyright 2010-2014 Rich Geldreich and Tenacious Software LLC
+
+All Rights Reserved.
 
-Copyright (c) 2024 Marc Rousavy
 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
@@ -61,13 +95,13 @@ 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 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.
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

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
@@ -34,6 +36,8 @@ No additional setup needed.
 
 ## Usage
 
+> **Note**: Row and column indices are **1-based** (following Excel convention).
+
 ### Creating a Workbook
 
 ```typescript
@@ -53,27 +57,27 @@ headerFormat.setFgColor(Colors.BLUE);
 headerFormat.setAlign(Align.CENTER);
 
 // Write headers
-sheet.writeString(0, 0, 'Name', headerFormat);
-sheet.writeString(0, 1, 'Price', headerFormat);
-sheet.writeString(0, 2, 'Total', headerFormat);
+sheet.writeString(1, 1, 'Name', headerFormat);
+sheet.writeString(1, 2, 'Price', headerFormat);
+sheet.writeString(1, 3, 'Total', headerFormat);
 
 // Write data
-sheet.writeString(1, 0, 'Apple');
-sheet.writeNumber(1, 1, 1.50);
-sheet.writeFormula(1, 2, '=B2*1.1');
+sheet.writeString(2, 1, 'Apple');
+sheet.writeNumber(2, 2, 1.50);
+sheet.writeFormula(2, 3, '=B2*1.1');
 
-sheet.writeString(2, 0, 'Orange');
-sheet.writeNumber(2, 1, 2.00);
-sheet.writeFormula(2, 2, '=B3*1.1');
+sheet.writeString(3, 1, 'Orange');
+sheet.writeNumber(3, 2, 2.00);
+sheet.writeFormula(3, 3, '=B3*1.1');
 
 // Date example
 const date = new Date(2024, 0, 15);
 const excelDate = (date.getTime() / 86400000) + 25569; // Convert to Excel date
-sheet.writeDatetime(3, 0, excelDate);
+sheet.writeDatetime(4, 1, excelDate);
 
 // Set column widths
-sheet.setColumn(0, 0, 15);
-sheet.setColumn(1, 2, 12);
+sheet.setColumn(1, 1, 15);
+sheet.setColumn(2, 3, 12);
 
 // Get the buffer and do something with it
 const buffer = await workbook.getBuffer();
@@ -104,8 +108,8 @@ const lastRow = sheet.getLastRow();
 const lastCol = sheet.getLastColumn();
 
 // Read cell values
-for (let row = 0; row <= lastRow; row++) {
-  for (let col = 0; col <= lastCol; col++) {
+for (let row = 1; row <= lastRow; row++) {
+  for (let col = 1; col <= lastCol; col++) {
     const value = sheet.getCellValue(row, col);
     const type = sheet.getCellType(row, col);
     const strValue = sheet.getCellString(row, col);
@@ -114,19 +118,61 @@ for (let row = 0; row <= lastRow; row++) {
 }
 
 // Read cell format
-const format = sheet.getCellFormat(0, 0);
+const format = sheet.getCellFormat(1, 1);
 const isBold = format.getIsBold();
 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
 
-- `createWorkbook(): XlsxWorkbook` - Create a new workbook
+- `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
 
@@ -137,9 +183,12 @@ 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
 
+> **Note**: All row and column indices are **1-based** (following Excel convention).
+
 #### Basic Write Methods
 | Method | Description |
 |--------|-------------|

package/android/CMakeLists.txt

@@ -5,18 +5,31 @@ set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
 set(OPENXLSX_DIR ${CMAKE_SOURCE_DIR}/../OpenXLSX)
+
+# 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"
+  )
+endif()
+
+# Verify OpenXLSX is available
 if(NOT EXISTS ${OPENXLSX_DIR}/CMakeLists.txt)
-  include(FetchContent)
-  FetchContent_Declare(
-    OpenXLSX
-    GIT_REPOSITORY https://github.com/troldal/OpenXLSX.git
-    GIT_TAG v0.5.1
+  message(FATAL_ERROR
+    "OpenXLSX not found at ${OPENXLSX_DIR}.\n"
+    "Please manually clone OpenXLSX:\n"
+    "  cd ${CMAKE_SOURCE_DIR}/.. && git clone --depth 1 --branch v0.5.1 https://github.com/troldal/OpenXLSX.git OpenXLSX\n"
+    "Then clean CMake cache and rebuild."
   )
-  FetchContent_GetProperties(OpenXLSX)
-  if(NOT OpenXLSX_POPULATED)
-    FetchContent_Populate(OpenXLSX)
-  endif()
-  set(OPENXLSX_DIR ${openxlsx_SOURCE_DIR})
 endif()
 
 set(OPENXLSX_BUILD_SAMPLES 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/android/src/main/java/com/margelo/nitro/xlsx/NitroXlsxPackage.kt

@@ -12,6 +12,7 @@ class NitroXlsxPackage : ReactPackage {
     }
   }
 
+  @Suppress("OVERRIDE_DEPRECATION")
   override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
     return emptyList()
   }

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 {
 
@@ -10,8 +103,8 @@ HybridNitroXlsx::HybridNitroXlsx()
 HybridNitroXlsx::~HybridNitroXlsx() {
 }
 
-std::shared_ptr<HybridXlsxWorkbookSpec> HybridNitroXlsx::createWorkbook() {
-  return std::make_shared<HybridXlsxWorkbook>();
+std::shared_ptr<HybridXlsxWorkbookSpec> HybridNitroXlsx::createWorkbook(const std::optional<std::string>& tempDir) {
+  return std::make_shared<HybridXlsxWorkbook>(tempDir);
 }
 
 std::shared_ptr<HybridXlsxWorkbookSpec> HybridNitroXlsx::openWorkbook(const std::string& path) {
@@ -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

@@ -11,9 +11,10 @@ public:
   HybridNitroXlsx();
   ~HybridNitroXlsx() override;
 
-  std::shared_ptr<HybridXlsxWorkbookSpec> createWorkbook() override;
+  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/HybridXlsxCellFormat.cpp

@@ -1,6 +1,7 @@
 #include "HybridXlsxCellFormat.hpp"
 #include <sstream>
 #include <iomanip>
+#include <cctype>
 
 namespace margelo::nitro::xlsx {
 
@@ -10,7 +11,12 @@ static std::string doubleToHexColor(double color) {
   uint32_t argb = c | 0xFF000000;
   std::stringstream ss;
   ss << std::hex << std::setfill('0') << std::setw(8) << argb;
-  return ss.str();
+  std::string result = ss.str();
+  // Convert to uppercase (OpenXLSX expects uppercase hex)
+  for (char& ch : result) {
+    ch = std::toupper(ch);
+  }
+  return result;
 }
 
 HybridXlsxCellFormat::HybridXlsxCellFormat()
@@ -21,11 +27,23 @@ HybridXlsxCellFormat::~HybridXlsxCellFormat() {
 }
 
 OpenXLSX::XLStyleIndex HybridXlsxCellFormat::applyToDocument(OpenXLSX::XLStyles& styles) {
-  OpenXLSX::XLCellFormat cellFormat;
+  if (_styleIndex.has_value()) {
+    return *_styleIndex;
+  }
+
+  // Create cell format in document first to get a valid XML node.
+  // OpenXLSX default-constructed style objects have empty XML nodes;
+  // setters on empty nodes silently fail. We must create the node in
+  // the document first, then modify the live node via operator[].
+  OpenXLSX::XLCellFormat emptyCellFormat;
+  OpenXLSX::XLStyleIndex cellFormatIndex = styles.cellFormats().create(emptyCellFormat);
+  OpenXLSX::XLCellFormat cellFormat = styles.cellFormats()[cellFormatIndex];
 
   // Font
   if (!_fontName.empty() || _fontSize > 0 || _fontColor > 0 || _bold || _italic || _underline > 0 || _strikeout || _fontScript > 0) {
-    OpenXLSX::XLFont font;
+    OpenXLSX::XLFont emptyFont;
+    OpenXLSX::XLStyleIndex fontIndex = styles.fonts().create(emptyFont);
+    OpenXLSX::XLFont font = styles.fonts()[fontIndex];
     if (!_fontName.empty()) font.setFontName(_fontName);
     if (_fontSize > 0) font.setFontSize(static_cast<size_t>(_fontSize));
     if (_fontColor > 0) font.setFontColor(OpenXLSX::XLColor(doubleToHexColor(_fontColor)));
@@ -34,49 +52,55 @@ OpenXLSX::XLStyleIndex HybridXlsxCellFormat::applyToDocument(OpenXLSX::XLStyles&
     if (_underline > 0) font.setUnderline(static_cast<OpenXLSX::XLUnderlineStyle>(_underline));
     if (_strikeout) font.setStrikethrough();
     if (_fontScript > 0) font.setVertAlign(static_cast<OpenXLSX::XLVerticalAlignRunStyle>(_fontScript));
-    cellFormat.setFontIndex(styles.fonts().create(font));
+    cellFormat.setFontIndex(fontIndex);
     cellFormat.setApplyFont(true);
   }
 
   // Alignment
   if (_textWrap || _rotation != 0 || _indent > 0 || _align > 0 || _verticalAlign > 0 || _shrink) {
-    auto alignment = cellFormat.alignment(true);
-    if (_align > 0) alignment.setHorizontal(static_cast<OpenXLSX::XLAlignmentStyle>(_align));
-    if (_verticalAlign > 0) alignment.setVertical(static_cast<OpenXLSX::XLAlignmentStyle>(_verticalAlign));
-    if (_textWrap) alignment.setWrapText();
-    if (_rotation != 0) alignment.setTextRotation(static_cast<uint16_t>(_rotation));
-    if (_indent > 0) alignment.setIndent(static_cast<uint32_t>(_indent));
-    if (_shrink) alignment.setShrinkToFit();
+    if (_align > 0) cellFormat.alignment(true).setHorizontal(static_cast<OpenXLSX::XLAlignmentStyle>(_align));
+    if (_verticalAlign > 0) cellFormat.alignment(true).setVertical(static_cast<OpenXLSX::XLAlignmentStyle>(_verticalAlign));
+    if (_textWrap) cellFormat.alignment(true).setWrapText();
+    if (_rotation != 0) cellFormat.alignment(true).setTextRotation(static_cast<uint16_t>(_rotation));
+    if (_indent > 0) cellFormat.alignment(true).setIndent(static_cast<uint32_t>(_indent));
+    if (_shrink) cellFormat.alignment(true).setShrinkToFit();
     cellFormat.setApplyAlignment(true);
   }
 
   // Number format
   if (!_numFormat.empty()) {
-    OpenXLSX::XLNumberFormat numFormat;
+    OpenXLSX::XLNumberFormat emptyNumFormat;
+    OpenXLSX::XLStyleIndex numFmtIndex = styles.numberFormats().create(emptyNumFormat);
+    OpenXLSX::XLNumberFormat numFormat = styles.numberFormats()[numFmtIndex];
     numFormat.setFormatCode(_numFormat);
-    OpenXLSX::XLStyleIndex numFmtIndex = styles.numberFormats().create(numFormat);
-    uint32_t numFmtId = styles.numberFormats().numberFormatIdFromIndex(numFmtIndex);
-    cellFormat.setNumberFormatId(numFmtId);
+    // Assign a unique custom numFmtId (>= 164 for user-defined formats)
+    static uint32_t nextCustomNumFmtId = 164;
+    numFormat.setNumberFormatId(nextCustomNumFmtId++);
+    cellFormat.setNumberFormatId(numFormat.numberFormatId());
     cellFormat.setApplyNumberFormat(true);
   }
 
   // Fill
   if (_bgColor > 0 || _fgColor > 0 || _pattern > 0) {
-    OpenXLSX::XLFill fill;
+    OpenXLSX::XLFill emptyFill;
+    OpenXLSX::XLStyleIndex fillIndex = styles.fills().create(emptyFill);
+    OpenXLSX::XLFill fill = styles.fills()[fillIndex];
     fill.setPatternType(_pattern > 0
       ? static_cast<OpenXLSX::XLPatternType>(_pattern)
       : OpenXLSX::XLPatternType::XLPatternSolid);
     if (_bgColor > 0) fill.setBackgroundColor(OpenXLSX::XLColor(doubleToHexColor(_bgColor)));
     if (_fgColor > 0) fill.setColor(OpenXLSX::XLColor(doubleToHexColor(_fgColor)));
-    cellFormat.setFillIndex(styles.fills().create(fill));
+    cellFormat.setFillIndex(fillIndex);
     cellFormat.setApplyFill(true);
   }
 
   // Border
   if (_border > 0 || _bottom > 0 || _top > 0 || _left > 0 || _right > 0 || _diagonal > 0) {
-    OpenXLSX::XLBorder border;
+    OpenXLSX::XLBorder emptyBorder;
+    OpenXLSX::XLStyleIndex borderIndex = styles.borders().create(emptyBorder);
+    OpenXLSX::XLBorder border = styles.borders()[borderIndex];
     // TODO: Implement border styling with OpenXLSX v0.5.1 API
-    cellFormat.setBorderIndex(styles.borders().create(border));
+    cellFormat.setBorderIndex(borderIndex);
     cellFormat.setApplyBorder(true);
   }
 
@@ -86,7 +110,8 @@ OpenXLSX::XLStyleIndex HybridXlsxCellFormat::applyToDocument(OpenXLSX::XLStyles&
     cellFormat.setApplyProtection(true);
   }
 
-  return styles.cellFormats().create(cellFormat);
+  _styleIndex = cellFormatIndex;
+  return cellFormatIndex;
 }
 
 void HybridXlsxCellFormat::applyToCell(OpenXLSX::XLCell& cell, OpenXLSX::XLStyleIndex styleIndex) {

package/cpp/HybridXlsxCellFormat.hpp

@@ -68,6 +68,7 @@ public:
   double getBgColor() override;
 
 private:
+  std::optional<OpenXLSX::XLStyleIndex> _styleIndex;
   std::string _fontName;
   double _fontSize = 0;
   double _fontColor = 0;

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 {
@@ -40,10 +71,14 @@ namespace {
   }
 }
 
-HybridXlsxWorkbook::HybridXlsxWorkbook()
+HybridXlsxWorkbook::HybridXlsxWorkbook(const std::optional<std::string>& tempDir)
     : HybridObject("XlsxWorkbook"), HybridXlsxWorkbookSpec(), _finalized(false) {
   _workbook = std::make_unique<OpenXLSX::XLDocument>();
-  _tempDir = getTempDir();
+  if (tempDir.has_value()) {
+    _tempDir = *tempDir;
+  } else {
+    _tempDir = getTempDir();
+  }
 }
 
 HybridXlsxWorkbook::~HybridXlsxWorkbook() {
@@ -93,7 +128,8 @@ std::shared_ptr<HybridXlsxWorksheetSpec> HybridXlsxWorkbook::addWorksheet(const
     sheetName = *name;
     auto it = _worksheetNames.find(sheetName);
     if (it != _worksheetNames.end()) {
-      throw std::runtime_error("Sheet named '" + sheetName + "' already exists");
+      // Worksheet already exists (e.g., default Sheet1 created by OpenXLSX), return it
+      return it->second;
     }
   } else {
     int idx = 1;
@@ -181,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

@@ -13,7 +13,7 @@ namespace margelo::nitro::xlsx {
 
 class HybridXlsxWorkbook : public HybridXlsxWorkbookSpec {
 public:
-  HybridXlsxWorkbook();
+  HybridXlsxWorkbook(const std::optional<std::string>& tempDir = std::nullopt);
   ~HybridXlsxWorkbook() override;
 
   void openFromFile(const std::string& path);
@@ -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) {
@@ -104,7 +128,9 @@ void HybridXlsxWorksheet::mergeRange(double firstRow, double firstCol, double la
   OpenXLSX::XLCellReference bottomRight(static_cast<unsigned int>(lastRow), static_cast<unsigned int>(lastCol));
   OpenXLSX::XLCellRange range = _worksheet.range(topLeft, bottomRight);
   _worksheet.mergeCells(range);
-  _worksheet.cell(static_cast<unsigned int>(firstRow), static_cast<unsigned int>(firstCol)).value() = value;
+  OpenXLSX::XLCell cell = _worksheet.cell(static_cast<unsigned int>(firstRow), static_cast<unsigned int>(firstCol));
+  cell.value() = value;
+  applyFormat(cell, format);
 }
 
 void HybridXlsxWorksheet::mergeRangeNum(double firstRow, double firstCol, double lastRow, double lastCol, double value, const std::optional<std::shared_ptr<HybridXlsxCellFormatSpec>>& format) {
@@ -112,7 +138,9 @@ void HybridXlsxWorksheet::mergeRangeNum(double firstRow, double firstCol, double
   OpenXLSX::XLCellReference bottomRight(static_cast<unsigned int>(lastRow), static_cast<unsigned int>(lastCol));
   OpenXLSX::XLCellRange range = _worksheet.range(topLeft, bottomRight);
   _worksheet.mergeCells(range);
-  _worksheet.cell(static_cast<unsigned int>(firstRow), static_cast<unsigned int>(firstCol)).value() = value;
+  OpenXLSX::XLCell cell = _worksheet.cell(static_cast<unsigned int>(firstRow), static_cast<unsigned int>(firstCol));
+  cell.value() = value;
+  applyFormat(cell, format);
 }
 
 void HybridXlsxWorksheet::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) {

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

@@ -19,6 +19,7 @@ namespace margelo::nitro::xlsx { class HybridXlsxWorkbookSpec; }
 #include <memory>
 #include "HybridXlsxWorkbookSpec.hpp"
 #include <string>
+#include <optional>
 #include <NitroModules/ArrayBuffer.hpp>
 
 namespace margelo::nitro::xlsx {
@@ -52,9 +53,10 @@ namespace margelo::nitro::xlsx {
 
     public:
       // Methods
-      virtual std::shared_ptr<HybridXlsxWorkbookSpec> createWorkbook() = 0;
+      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.1",
+  "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++' }> {
@@ -148,7 +149,8 @@ export interface XlsxCellFormat extends HybridObject<{ ios: 'c++'; android: 'c++
 }
 
 export interface NitroXlsx extends HybridObject<{ ios: 'c++'; android: 'c++' }> {
-  createWorkbook(): XlsxWorkbook
+  createWorkbook(tempDir?: string): XlsxWorkbook
   openWorkbook(path: string): XlsxWorkbook
   openWorkbookFromBuffer(buffer: ArrayBuffer): XlsxWorkbook
+  fromJSON(data: string): XlsxWorkbook
 }