react-native-nitro-xlsx 0.1.4 → 0.2.5

package/cpp/HybridXlsxWorksheet.hpp

@@ -3,9 +3,11 @@
 #include "HybridXlsxWorksheetSpec.hpp"
 #include <OpenXLSX/XLDocument.hpp>
 #include <OpenXLSX/XLSheet.hpp>
+#include <OpenXLSX/XLComments.hpp>
 #include <string>
 #include <memory>
 #include "HybridXlsxCellFormat.hpp"
+#include "HybridXlsxConditionalFormats.hpp"
 
 namespace margelo::nitro::xlsx {
 
@@ -30,57 +32,102 @@ public:
   
   void setColumn(double firstCol, double lastCol, double width, const std::optional<std::shared_ptr<HybridXlsxCellFormatSpec>>& format) override;
   void setRow(double row, double height, const std::optional<std::shared_ptr<HybridXlsxCellFormatSpec>>& format) override;
-  
+  bool deleteRow(double row) override;
+  bool deleteColumn(double col) override;
+
   void mergeRange(double firstRow, double firstCol, double lastRow, double lastCol, const std::string& value, const std::optional<std::shared_ptr<HybridXlsxCellFormatSpec>>& format) override;
   void mergeRangeNum(double firstRow, double firstCol, double lastRow, double lastCol, double value, const std::optional<std::shared_ptr<HybridXlsxCellFormatSpec>>& format) override;
-  
-  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) override;
-  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) override;
-  
-  void autofilter(double firstRow, double firstCol, double lastRow, double lastCol) override;
-  
-  void freezePanes(double row, double col) override;
-  void splitPanes(double row, double col) override;
-  
-  void setTabColor(double color) override;
+  void unmergeCells(double firstRow, double firstCol, double lastRow, double lastCol) override;
+
   void hide() override;
   void activate() override;
-  void setFirstSheet() override;
+
+  // Sheet protection
   void protect(const std::optional<std::string>& password) override;
-  
-  void setPortrait() override;
-  void setLandscape() override;
-  void setPaper(double paperType) override;
-  void setHeader(const std::string& header) override;
-  void setFooter(const std::string& footer) override;
-  void setPrintArea(double firstRow, double firstCol, double lastRow, double lastCol) override;
-  void fitToPages(double width, double height) override;
-  void setZoom(double scale) override;
-  void setGridlines(double option) override;
-  void centerHorizontally() override;
-  void centerVertically() override;
-  
-  void setOutline(double level) override;
+  void protectSheet(std::optional<bool> set) override;
+  void protectObjects(std::optional<bool> set) override;
+  void protectScenarios(std::optional<bool> set) override;
+
+  // Password
+  void setPassword(const std::string& password) override;
+  void setPasswordHash(const std::string& hash) override;
+  void clearPassword() override;
+  void clearSheetProtection() override;
+
+  // Fine-grained permissions
+  void allowInsertColumns(std::optional<bool> set) override;
+  void allowInsertRows(std::optional<bool> set) override;
+  void allowDeleteColumns(std::optional<bool> set) override;
+  void allowDeleteRows(std::optional<bool> set) override;
+  void allowSelectLockedCells(std::optional<bool> set) override;
+  void allowSelectUnlockedCells(std::optional<bool> set) override;
+
+  void denyInsertColumns() override;
+  void denyInsertRows() override;
+  void denyDeleteColumns() override;
+  void denyDeleteRows() override;
+  void denySelectLockedCells() override;
+  void denySelectUnlockedCells() override;
+
+  // Protection state
+  bool sheetProtected() override;
+  bool objectsProtected() override;
+  bool scenariosProtected() override;
+  bool insertColumnsAllowed() override;
+  bool insertRowsAllowed() override;
+  bool deleteColumnsAllowed() override;
+  bool deleteRowsAllowed() override;
+  bool selectLockedCellsAllowed() override;
+  bool selectUnlockedCellsAllowed() override;
+  bool passwordIsSet() override;
+  std::string passwordHash() override;
+  std::string sheetProtectionSummary() override;
+
   void setColumnHidden(double firstCol, double lastCol, bool hidden) override;
   void setRowHidden(double row, bool hidden) override;
 
+  // Comments (XLComments)
+  void setComment(double row, double col, const std::string& text, std::optional<double> authorId) override;
+  std::string getComment(double row, double col) override;
+  bool hasComment(double row, double col) override;
+  bool deleteComment(double row, double col) override;
+  double getCommentCount() override;
+  double addCommentAuthor(const std::string& author) override;
+  std::string getCommentAuthor(double authorId) override;
+
+  // Conditional formatting
+  std::shared_ptr<HybridXlsxConditionalFormatsSpec> getConditionalFormats() override;
+
   // Read methods
   std::variant<bool, nitro::NullType, std::string, double> getCellValue(double row, double col) override;
   std::string getCellString(double row, double col) override;
   std::string getCellRawValue(double row, double col) override;
   CellType getCellType(double row, double col) override;
   std::shared_ptr<HybridXlsxCellFormatSpec> getCellFormat(double row, double col) override;
+  bool hasFormula(double row, double col) override;
+  std::string formula(double row, double col) override;
+  bool findCell(double row, double col) override;
   double getRowCount() override;
   double getColumnCount() override;
   double getLastRow() override;
   double getLastColumn() override;
   std::string getName() override;
 
+  // JSON import / export for this worksheet
+  std::vector<std::shared_ptr<AnyMap>> toJSON(const std::optional<std::vector<std::string>>& keys) override;
+  void fromJSON(const std::vector<std::shared_ptr<AnyMap>>& data) override;
+
+  // Internal: rename this sheet and rewrite formula references
+  void applyRename(const std::string& oldName, const std::string& newName);
+  // Internal: rewrite formula references to a renamed sheet (no actual rename)
+  void rewriteSheetNameRef(const std::string& oldName, const std::string& newName);
+
 private:
   OpenXLSX::XLDocument& _doc;
   OpenXLSX::XLWorksheet _worksheet;
 
   void applyFormat(OpenXLSX::XLCell& cell, const std::optional<std::shared_ptr<HybridXlsxCellFormatSpec>>& format);
+  std::string cellAddress(double row, double col);
 };
 
 }

package/cpp/XlsxCacheDir.cpp

@@ -0,0 +1,76 @@
+// Android / desktop implementation of XlsxCacheDir.hpp.
+// (Apple is handled by ios/XlsxCacheDir.mm.)
+
+#ifndef __APPLE__
+
+#include "XlsxCacheDir.hpp"
+
+#include <cstdlib>
+#include <sys/stat.h>
+
+#ifdef __ANDROID__
+#include <jni.h>
+#include <fbjni/fbjni.h>
+#endif
+
+namespace margelo::nitro::xlsx {
+
+namespace {
+  std::string g_cacheDir;
+
+  bool isUsableDir(const std::string& path) {
+    if (path.empty()) return false;
+    struct stat st {};
+    return stat(path.c_str(), &st) == 0 && S_ISDIR(st.st_mode);
+  }
+}
+
+void setCacheDir(const std::string& dir) {
+  g_cacheDir = dir;
+}
+
+std::string getCacheDir() {
+  if (!g_cacheDir.empty()) return g_cacheDir;
+  return detail::resolvePlatformCacheDir();
+}
+
+namespace detail {
+
+std::string resolvePlatformCacheDir() {
+#ifdef __ANDROID__
+  // Ask the Android runtime for Context.getCacheDir()
+  using namespace facebook::jni;
+  try {
+    auto activityThread = findClassStatic("android/app/ActivityThread");
+    auto currentApplication = activityThread->getStaticMethod<JObject()>("currentApplication");
+    // JStaticMethod::operator() takes (alias_ref<jclass>, args...)
+    auto application = currentApplication(activityThread);
+    if (application) {
+      auto contextClass = findClassStatic("android/content/Context");
+      auto getCacheDir = contextClass->getMethod<JObject()>("getCacheDir");
+      // JMethod::operator() takes (alias_ref<jobject>, args...)
+      auto cacheDir = getCacheDir(application);
+      if (cacheDir) {
+        auto fileClass = findClassStatic("java/io/File");
+        auto getAbsolutePath = fileClass->getMethod<JString()>("getAbsolutePath");
+        auto path = getAbsolutePath(cacheDir);
+        std::string result = path->toStdString();
+        if (isUsableDir(result)) return result;
+      }
+    }
+  } catch (...) {
+    // fall through to env / default
+  }
+#endif
+
+  const char* tmp = std::getenv("TMPDIR");
+  if (tmp != nullptr && isUsableDir(tmp)) {
+    return std::string(tmp);
+  }
+  return "/tmp";
+}
+
+} // namespace detail
+} // namespace margelo::nitro::xlsx
+
+#endif // !__APPLE__

package/cpp/XlsxCacheDir.hpp

@@ -0,0 +1,27 @@
+#pragma once
+
+#include <string>
+
+namespace margelo::nitro::xlsx {
+
+/**
+ * Override the cache directory used for temporary XLSX files.
+ * Normally called once from the Android native side at startup;
+ * if never called, getCacheDir() falls back to the platform resolver.
+ */
+void setCacheDir(const std::string& dir);
+
+/**
+ * Directory used for temporary XLSX files.
+ * Priority: explicit setCacheDir() > platform cache dir > TMPDIR > /tmp
+ *
+ * Implemented in ios/XlsxCacheDir.mm (Apple) and cpp/XlsxCacheDir.cpp (other).
+ */
+std::string getCacheDir();
+
+namespace detail {
+  /** Platform-specific cache directory (NSCachesDirectory / Context.getCacheDir). */
+  std::string resolvePlatformCacheDir();
+}
+
+} // namespace margelo::nitro::xlsx

package/cpp/XlsxError.hpp

@@ -0,0 +1,68 @@
+#pragma once
+
+#include <OpenXLSX/XLException.hpp>
+#include <stdexcept>
+#include <string>
+
+namespace margelo::nitro::xlsx {
+
+/**
+ * Structured error with a stable code that the JS side can switch on.
+ * Message format written to JS: "CODE: message" (Nitro prefixes the method name).
+ */
+class XlsxError : public std::runtime_error {
+public:
+  XlsxError(std::string code, const std::string& message)
+      : std::runtime_error(code + ": " + message), _code(std::move(code)) {}
+
+  const std::string& code() const noexcept { return _code; }
+
+private:
+  std::string _code;
+};
+
+namespace xlsx_error {
+inline constexpr const char* INVALID_ARGUMENT   = "INVALID_ARGUMENT";
+inline constexpr const char* SHEET_NOT_FOUND    = "SHEET_NOT_FOUND";
+inline constexpr const char* SHEET_EXISTS       = "SHEET_EXISTS";
+inline constexpr const char* INDEX_OUT_OF_RANGE = "INDEX_OUT_OF_RANGE";
+inline constexpr const char* CELL_NOT_FOUND     = "CELL_NOT_FOUND";
+inline constexpr const char* WORKBOOK_CLOSED    = "WORKBOOK_CLOSED";
+inline constexpr const char* IO_ERROR           = "IO_ERROR";
+inline constexpr const char* UNSUPPORTED        = "UNSUPPORTED";
+inline constexpr const char* XLSX_ERROR         = "XLSX_ERROR";
+inline constexpr const char* INTERNAL_ERROR     = "INTERNAL_ERROR";
+} // namespace xlsx_error
+
+/**
+ * Map OpenXLSX / std exceptions to XlsxError so the JS side always sees "CODE: message".
+ * Anything already an XlsxError is rethrown unchanged.
+ */
+template <typename Fn>
+auto withXlsxError(const char* defaultCode, Fn&& fn) -> decltype(fn()) {
+  try {
+    return fn();
+  } catch (const XlsxError&) {
+    throw;
+  } catch (const OpenXLSX::XLInputError& e) {
+    throw XlsxError(xlsx_error::INVALID_ARGUMENT, e.what());
+  } catch (const OpenXLSX::XLCellAddressError& e) {
+    throw XlsxError(xlsx_error::INVALID_ARGUMENT, e.what());
+  } catch (const OpenXLSX::XLSheetError& e) {
+    throw XlsxError(xlsx_error::SHEET_NOT_FOUND, e.what());
+  } catch (const OpenXLSX::XLOverflowError& e) {
+    throw XlsxError(xlsx_error::INDEX_OUT_OF_RANGE, e.what());
+  } catch (const OpenXLSX::XLValueTypeError& e) {
+    throw XlsxError(xlsx_error::INVALID_ARGUMENT, e.what());
+  } catch (const OpenXLSX::XLFormulaError& e) {
+    throw XlsxError(xlsx_error::INVALID_ARGUMENT, e.what());
+  } catch (const OpenXLSX::XLException& e) {
+    throw XlsxError(defaultCode, e.what());
+  } catch (const std::exception& e) {
+    throw XlsxError(defaultCode, e.what());
+  } catch (...) {
+    throw XlsxError(xlsx_error::INTERNAL_ERROR, "Unknown native error");
+  }
+}
+
+} // namespace margelo::nitro::xlsx

package/cpp/XlsxJson.cpp

@@ -0,0 +1,185 @@
+#include "XlsxJson.hpp"
+#include <algorithm>
+#include <cmath>
+#include <limits>
+#include <stdexcept>
+
+namespace margelo::nitro::xlsx {
+
+namespace {
+
+bool isCellEmpty(OpenXLSX::XLWorksheet& ws, uint32_t row, uint16_t col) {
+  return ws.findCell(row, col).empty() || ws.findCell(row, col).value().type() == OpenXLSX::XLValueType::Empty;
+}
+
+std::string keyFromCellValue(OpenXLSX::XLWorksheet& ws, uint32_t row, uint16_t col) {
+  auto cell = ws.findCell(row, col);
+  if (cell.empty()) return "col" + std::to_string(col);
+  switch (cell.value().type()) {
+    case OpenXLSX::XLValueType::String:
+      return cell.value().get<std::string>();
+    case OpenXLSX::XLValueType::Integer:
+      return std::to_string(static_cast<long long>(cell.value().get<int64_t>()));
+    case OpenXLSX::XLValueType::Float:
+      return std::to_string(static_cast<int>(cell.value().get<double>()));
+    default:
+      return "col" + std::to_string(col);
+  }
+}
+
+void recordFromRow(OpenXLSX::XLWorksheet& ws,
+                   uint32_t row,
+                   const std::vector<std::string>& keys,
+                   uint16_t lastCol,
+                   std::shared_ptr<AnyMap> record) {
+  uint16_t keyCount = std::min(static_cast<uint16_t>(keys.size()), lastCol);
+  for (uint16_t c = 0; c < keyCount; ++c) {
+    const std::string& key = keys[c];
+    auto cell = ws.findCell(row, c + 1);
+    if (cell.empty()) {
+      record->setNull(key);
+      continue;
+    }
+    switch (cell.value().type()) {
+      case OpenXLSX::XLValueType::String:
+        record->setString(key, cell.value().get<std::string>());
+        break;
+      case OpenXLSX::XLValueType::Integer:
+        record->setDouble(key, static_cast<double>(cell.value().get<int64_t>()));
+        break;
+      case OpenXLSX::XLValueType::Float: {
+        double d = cell.value().get<double>();
+        if (!std::isnan(d) && !std::isinf(d)) {
+          record->setDouble(key, d);
+        } else {
+          record->setNull(key);
+        }
+        break;
+      }
+      case OpenXLSX::XLValueType::Boolean:
+        record->setBoolean(key, cell.value().get<bool>());
+        break;
+      default:
+        record->setNull(key);
+        break;
+    }
+  }
+}
+
+void writeValue(OpenXLSX::XLWorksheet& ws,
+                uint32_t row,
+                uint16_t col,
+                const std::shared_ptr<AnyMap>& map,
+                const std::string& key) {
+  if (!map->contains(key) || map->isNull(key)) return;
+  auto cell = ws.cell(row, col);
+  if (map->isString(key)) {
+    cell.value() = map->getString(key);
+  } else if (map->isDouble(key)) {
+    cell.value() = map->getDouble(key);
+  } else if (map->isInt64(key)) {
+    // store as number so get<double> round-trips
+    cell.value() = static_cast<double>(map->getInt64(key));
+  } else if (map->isBoolean(key)) {
+    cell.value() = map->getBoolean(key);
+  }
+  // arrays / objects are not representable as a single cell — skipped
+}
+
+// AnyMap is backed by std::unordered_map — sort each row's keys so column
+// order is deterministic, then keep first-seen order across rows.
+std::vector<std::string> collectKeys(const std::vector<std::shared_ptr<AnyMap>>& data) {
+  std::vector<std::string> keys;
+  for (const auto& row : data) {
+    if (!row) continue;
+    auto rowKeys = row->getAllKeys();
+    std::sort(rowKeys.begin(), rowKeys.end());
+    for (const auto& key : rowKeys) {
+      bool known = false;
+      for (const auto& existing : keys) {
+        if (existing == key) { known = true; break; }
+      }
+      if (!known) keys.push_back(key);
+    }
+  }
+  return keys;
+}
+
+} // anonymous namespace
+
+std::vector<std::shared_ptr<AnyMap>> worksheetToRecords(
+    OpenXLSX::XLWorksheet& worksheet,
+    const std::optional<std::vector<std::string>>& keys) {
+  std::vector<std::shared_ptr<AnyMap>> result;
+  uint32_t lastRow = worksheet.rowCount();
+  uint16_t lastCol = worksheet.columnCount();
+  if (lastRow == 0 || lastCol == 0) return result;
+
+  uint32_t dataStartRow = 1;
+  std::vector<std::string> resolvedKeys;
+
+  if (keys.has_value()) {
+    resolvedKeys = *keys;
+  } else {
+    dataStartRow = 2;
+    for (uint16_t c = 1; c <= lastCol; ++c) {
+      resolvedKeys.push_back(keyFromCellValue(worksheet, 1, c));
+    }
+  }
+  if (resolvedKeys.empty()) return result;
+
+  uint16_t keyCount = std::min(static_cast<uint16_t>(resolvedKeys.size()), lastCol);
+  for (uint32_t r = dataStartRow; r <= lastRow; ++r) {
+    bool hasData = false;
+    for (uint16_t c = 1; c <= keyCount; ++c) {
+      if (!isCellEmpty(worksheet, r, c)) {
+        hasData = true;
+        break;
+      }
+    }
+    if (!hasData) continue;
+
+    auto record = AnyMap::make();
+    recordFromRow(worksheet, r, resolvedKeys, lastCol, record);
+    result.push_back(record);
+  }
+  return result;
+}
+
+void recordsToWorksheet(
+    OpenXLSX::XLWorksheet& worksheet,
+    const std::vector<std::shared_ptr<AnyMap>>& data) {
+  if (data.empty()) return;
+
+  // Column order: first-seen keys across rows; each row's keys sorted (AnyMap
+  // is unordered, so sorting keeps the layout deterministic).
+  std::vector<std::string> keys = collectKeys(data);
+
+  // Header row
+  for (size_t c = 0; c < keys.size(); ++c) {
+    worksheet.cell(1, static_cast<uint16_t>(c + 1)).value() = keys[c];
+  }
+
+  // Data rows
+  for (size_t r = 0; r < data.size(); ++r) {
+    const auto& row = data[r];
+    if (!row) continue;
+    uint32_t rowNum = static_cast<uint32_t>(r + 2);
+    for (size_t c = 0; c < keys.size(); ++c) {
+      writeValue(worksheet, rowNum, static_cast<uint16_t>(c + 1), row, keys[c]);
+    }
+  }
+}
+
+std::unordered_map<std::string, std::vector<std::shared_ptr<AnyMap>>> workbookToRecords(
+    OpenXLSX::XLWorkbook& workbook) {
+  std::unordered_map<std::string, std::vector<std::shared_ptr<AnyMap>>> result;
+  uint16_t count = static_cast<uint16_t>(workbook.worksheetCount());
+  for (uint16_t i = 1; i <= count; ++i) {
+    auto ws = workbook.worksheet(i);
+    result[ws.name()] = worksheetToRecords(ws);
+  }
+  return result;
+}
+
+} // namespace margelo::nitro::xlsx

package/cpp/XlsxJson.hpp

@@ -0,0 +1,36 @@
+#pragma once
+
+#include <NitroModules/AnyMap.hpp>
+#include <OpenXLSX/XLSheet.hpp>
+#include <OpenXLSX/XLWorkbook.hpp>
+#include <memory>
+#include <optional>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+namespace margelo::nitro::xlsx {
+
+/**
+ * Convert one worksheet to an array of records.
+ * @param keys if provided, used as record keys; otherwise row 1 is treated as the header
+ */
+std::vector<std::shared_ptr<AnyMap>> worksheetToRecords(
+    OpenXLSX::XLWorksheet& worksheet,
+    const std::optional<std::vector<std::string>>& keys = std::nullopt);
+
+/**
+ * Write an array of records into a worksheet.
+ * The first record's keys become the header row; later-only keys extend the columns.
+ */
+void recordsToWorksheet(
+    OpenXLSX::XLWorksheet& worksheet,
+    const std::vector<std::shared_ptr<AnyMap>>& data);
+
+/**
+ * Export every worksheet as a Record keyed by sheet name.
+ */
+std::unordered_map<std::string, std::vector<std::shared_ptr<AnyMap>>> workbookToRecords(
+    OpenXLSX::XLWorkbook& workbook);
+
+} // namespace margelo::nitro::xlsx

package/ios/XlsxCacheDir.mm

@@ -0,0 +1,60 @@
+// Apple (iOS / macOS) cache directory via Foundation.
+// Full implementation of XlsxCacheDir.hpp for __APPLE__.
+
+#ifdef __APPLE__
+
+#include "XlsxCacheDir.hpp"
+
+#include <cstdlib>
+#include <sys/stat.h>
+
+#import <Foundation/Foundation.h>
+
+namespace margelo::nitro::xlsx {
+
+namespace {
+  std::string g_cacheDir;
+
+  bool isUsableDir(const std::string& path) {
+    if (path.empty()) return false;
+    struct stat st {};
+    return stat(path.c_str(), &st) == 0 && S_ISDIR(st.st_mode);
+  }
+}
+
+void setCacheDir(const std::string& dir) {
+  g_cacheDir = dir;
+}
+
+std::string getCacheDir() {
+  if (!g_cacheDir.empty()) return g_cacheDir;
+  return detail::resolvePlatformCacheDir();
+}
+
+namespace detail {
+
+std::string resolvePlatformCacheDir() {
+  @autoreleasepool {
+    NSArray<NSString*>* caches =
+        NSSearchPathForDirectoriesInDomains(NSCachesDirectory, NSUserDomainMask, YES);
+    if (caches.count > 0) {
+      std::string result([caches.firstObject UTF8String]);
+      if (isUsableDir(result)) return result;
+    }
+    NSString* tmp = NSTemporaryDirectory();
+    if (tmp != nil) {
+      std::string result([tmp UTF8String]);
+      if (isUsableDir(result)) return result;
+    }
+  }
+  const char* env = std::getenv("TMPDIR");
+  if (env != nullptr && isUsableDir(env)) {
+    return std::string(env);
+  }
+  return "/tmp";
+}
+
+} // namespace detail
+} // namespace margelo::nitro::xlsx
+
+#endif // __APPLE__

package/nitrogen/generated/android/NitroXlsx+autolinking.cmake

@@ -35,6 +35,8 @@ target_sources(
   # Shared Nitrogen C++ sources
   ../nitrogen/generated/shared/c++/HybridXlsxWorkbookSpec.cpp
   ../nitrogen/generated/shared/c++/HybridXlsxWorksheetSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridXlsxConditionalFormatSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridXlsxConditionalFormatsSpec.cpp
   ../nitrogen/generated/shared/c++/HybridXlsxCellFormatSpec.cpp
   ../nitrogen/generated/shared/c++/HybridNitroXlsxSpec.cpp
   # Android-specific Nitrogen C++ sources

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

@@ -19,8 +19,10 @@ namespace margelo::nitro::xlsx { class HybridXlsxWorkbookSpec; }
 #include <memory>
 #include "HybridXlsxWorkbookSpec.hpp"
 #include <string>
-#include <optional>
 #include <NitroModules/ArrayBuffer.hpp>
+#include <NitroModules/AnyMap.hpp>
+#include <vector>
+#include <unordered_map>
 
 namespace margelo::nitro::xlsx {
 
@@ -53,10 +55,10 @@ namespace margelo::nitro::xlsx {
 
     public:
       // Methods
-      virtual std::shared_ptr<HybridXlsxWorkbookSpec> createWorkbook(const std::optional<std::string>& tempDir) = 0;
+      virtual std::shared_ptr<HybridXlsxWorkbookSpec> createWorkbook() = 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;
+      virtual std::shared_ptr<HybridXlsxWorkbookSpec> fromJSON(const std::unordered_map<std::string, std::vector<std::shared_ptr<AnyMap>>>& data) = 0;
 
     protected:
       // Hybrid Setup