react-native-nitro-xlsx 0.1.1

package/nitrogen/generated/ios/NitroXlsx+autolinking.rb

@@ -0,0 +1,62 @@
+#
+# NitroXlsx+autolinking.rb
+# This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+# https://github.com/mrousavy/nitro
+# Copyright © Marc Rousavy @ Margelo
+#
+
+# This is a Ruby script that adds all files generated by Nitrogen
+# to the given podspec.
+#
+# To use it, add this to your .podspec:
+# ```ruby
+# Pod::Spec.new do |spec|
+#   # ...
+#
+#   # Add all files generated by Nitrogen
+#   load 'nitrogen/generated/ios/NitroXlsx+autolinking.rb'
+#   add_nitrogen_files(spec)
+# end
+# ```
+
+def add_nitrogen_files(spec)
+  Pod::UI.puts "[NitroModules] 🔥 NitroXlsx is boosted by nitro!"
+
+  spec.dependency "NitroModules"
+
+  current_source_files = Array(spec.attributes_hash['source_files'])
+  spec.source_files = current_source_files + [
+    # Generated cross-platform specs
+    "nitrogen/generated/shared/**/*.{h,hpp,c,cpp,swift}",
+    # Generated bridges for the cross-platform specs
+    "nitrogen/generated/ios/**/*.{h,hpp,c,cpp,mm,swift}",
+  ]
+
+  current_public_header_files = Array(spec.attributes_hash['public_header_files'])
+  spec.public_header_files = current_public_header_files + [
+    # Generated specs
+    "nitrogen/generated/shared/**/*.{h,hpp}",
+    # Swift to C++ bridging helpers
+    "nitrogen/generated/ios/NitroXlsx-Swift-Cxx-Bridge.hpp"
+  ]
+
+  current_private_header_files = Array(spec.attributes_hash['private_header_files'])
+  spec.private_header_files = current_private_header_files + [
+    # iOS specific specs
+    "nitrogen/generated/ios/c++/**/*.{h,hpp}",
+    # Views are framework-specific and should be private
+    "nitrogen/generated/shared/**/views/**/*"
+  ]
+
+  current_pod_target_xcconfig = spec.attributes_hash['pod_target_xcconfig'] || {}
+  spec.pod_target_xcconfig = current_pod_target_xcconfig.merge({
+    # Use C++ 20
+    "CLANG_CXX_LANGUAGE_STANDARD" => "c++20",
+    # Enables C++ <-> Swift interop (by default it's only ObjC)
+    "SWIFT_OBJC_INTEROP_MODE" => "objcxx",
+    # Enables stricter modular headers
+    "DEFINES_MODULE" => "YES",
+    # Disable auto-generated ObjC header for Swift (Static linkage on Xcode 26.4 breaks here)
+    "SWIFT_INSTALL_OBJC_HEADER" => "NO",
+  })
+end

package/nitrogen/generated/ios/NitroXlsx-Swift-Cxx-Bridge.cpp

@@ -0,0 +1,17 @@
+///
+/// NitroXlsx-Swift-Cxx-Bridge.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "NitroXlsx-Swift-Cxx-Bridge.hpp"
+
+// Include C++ implementation defined types
+
+
+namespace margelo::nitro::xlsx::bridge::swift {
+
+  
+
+} // namespace margelo::nitro::xlsx::bridge::swift

package/nitrogen/generated/ios/NitroXlsx-Swift-Cxx-Bridge.hpp

@@ -0,0 +1,27 @@
+///
+/// NitroXlsx-Swift-Cxx-Bridge.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+// Forward declarations of C++ defined types
+
+
+// Forward declarations of Swift defined types
+
+
+// Include C++ defined types
+
+
+/**
+ * Contains specialized versions of C++ templated types so they can be accessed from Swift,
+ * as well as helper functions to interact with those C++ types from Swift.
+ */
+namespace margelo::nitro::xlsx::bridge::swift {
+
+  
+
+} // namespace margelo::nitro::xlsx::bridge::swift

package/nitrogen/generated/ios/NitroXlsx-Swift-Cxx-Umbrella.hpp

@@ -0,0 +1,38 @@
+///
+/// NitroXlsx-Swift-Cxx-Umbrella.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+// Forward declarations of C++ defined types
+
+
+// Include C++ defined types
+
+
+// C++ helpers for Swift
+#include "NitroXlsx-Swift-Cxx-Bridge.hpp"
+
+// Common C++ types used in Swift
+#include <NitroModules/ArrayBufferHolder.hpp>
+#include <NitroModules/AnyMapUtils.hpp>
+#include <NitroModules/RuntimeError.hpp>
+#include <NitroModules/DateToChronoDate.hpp>
+
+// Forward declarations of Swift defined types
+
+
+// Include Swift defined types
+#if __has_include("NitroXlsx-Swift.h")
+// This header is generated by Xcode/Swift on every app build.
+// If it cannot be found, make sure the Swift module's name (= podspec name) is actually "NitroXlsx".
+#include "NitroXlsx-Swift.h"
+// Same as above, but used when building with frameworks (`use_frameworks`)
+#elif __has_include(<NitroXlsx/NitroXlsx-Swift.h>)
+#include <NitroXlsx/NitroXlsx-Swift.h>
+#else
+#error NitroXlsx's autogenerated Swift header cannot be found! Make sure the Swift module's name (= podspec name) is actually "NitroXlsx", and try building the app first.
+#endif

package/nitrogen/generated/ios/NitroXlsxAutolinking.mm

@@ -0,0 +1,35 @@
+///
+/// NitroXlsxAutolinking.mm
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#import <Foundation/Foundation.h>
+#import <NitroModules/HybridObjectRegistry.hpp>
+
+#import <type_traits>
+
+#include "HybridNitroXlsx.hpp"
+
+@interface NitroXlsxAutolinking : NSObject
+@end
+
+@implementation NitroXlsxAutolinking
+
++ (void) load {
+  using namespace margelo::nitro;
+  using namespace margelo::nitro::xlsx;
+
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "NitroXlsx",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridNitroXlsx>,
+                    "The HybridObject \"HybridNitroXlsx\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridNitroXlsx>();
+    }
+  );
+}
+
+@end

package/nitrogen/generated/ios/NitroXlsxAutolinking.swift

@@ -0,0 +1,16 @@
+///
+/// NitroXlsxAutolinking.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+// TODO: Use empty enums once Swift supports exporting them as namespaces
+//       See: https://github.com/swiftlang/swift/pull/83616
+public final class NitroXlsxAutolinking {
+  public typealias bridge = margelo.nitro.xlsx.bridge.swift
+
+  
+}

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

@@ -0,0 +1,100 @@
+///
+/// CellType.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/NitroHash.hpp>)
+#include <NitroModules/NitroHash.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+namespace margelo::nitro::xlsx {
+
+  /**
+   * An enum which can be represented as a JavaScript union (CellType).
+   */
+  enum class CellType {
+    STRING      SWIFT_NAME(string) = 0,
+    NUMBER      SWIFT_NAME(number) = 1,
+    BOOLEAN      SWIFT_NAME(boolean) = 2,
+    EMPTY      SWIFT_NAME(empty) = 3,
+    DATE      SWIFT_NAME(date) = 4,
+    ERROR      SWIFT_NAME(error) = 5,
+    FORMULA      SWIFT_NAME(formula) = 6,
+    BLANK      SWIFT_NAME(blank) = 7,
+  } CLOSED_ENUM;
+
+} // namespace margelo::nitro::xlsx
+
+namespace margelo::nitro {
+
+  // C++ CellType <> JS CellType (union)
+  template <>
+  struct JSIConverter<margelo::nitro::xlsx::CellType> final {
+    static inline margelo::nitro::xlsx::CellType fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, arg);
+      switch (hashString(unionValue.c_str(), unionValue.size())) {
+        case hashString("string"): return margelo::nitro::xlsx::CellType::STRING;
+        case hashString("number"): return margelo::nitro::xlsx::CellType::NUMBER;
+        case hashString("boolean"): return margelo::nitro::xlsx::CellType::BOOLEAN;
+        case hashString("empty"): return margelo::nitro::xlsx::CellType::EMPTY;
+        case hashString("date"): return margelo::nitro::xlsx::CellType::DATE;
+        case hashString("error"): return margelo::nitro::xlsx::CellType::ERROR;
+        case hashString("formula"): return margelo::nitro::xlsx::CellType::FORMULA;
+        case hashString("blank"): return margelo::nitro::xlsx::CellType::BLANK;
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert \"" + unionValue + "\" to enum CellType - invalid value!");
+      }
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, margelo::nitro::xlsx::CellType arg) {
+      switch (arg) {
+        case margelo::nitro::xlsx::CellType::STRING: return JSIConverter<std::string>::toJSI(runtime, "string");
+        case margelo::nitro::xlsx::CellType::NUMBER: return JSIConverter<std::string>::toJSI(runtime, "number");
+        case margelo::nitro::xlsx::CellType::BOOLEAN: return JSIConverter<std::string>::toJSI(runtime, "boolean");
+        case margelo::nitro::xlsx::CellType::EMPTY: return JSIConverter<std::string>::toJSI(runtime, "empty");
+        case margelo::nitro::xlsx::CellType::DATE: return JSIConverter<std::string>::toJSI(runtime, "date");
+        case margelo::nitro::xlsx::CellType::ERROR: return JSIConverter<std::string>::toJSI(runtime, "error");
+        case margelo::nitro::xlsx::CellType::FORMULA: return JSIConverter<std::string>::toJSI(runtime, "formula");
+        case margelo::nitro::xlsx::CellType::BLANK: return JSIConverter<std::string>::toJSI(runtime, "blank");
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert CellType to JS - invalid value: "
+                                    + std::to_string(static_cast<int>(arg)) + "!");
+      }
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isString()) {
+        return false;
+      }
+      std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, value);
+      switch (hashString(unionValue.c_str(), unionValue.size())) {
+        case hashString("string"):
+        case hashString("number"):
+        case hashString("boolean"):
+        case hashString("empty"):
+        case hashString("date"):
+        case hashString("error"):
+        case hashString("formula"):
+        case hashString("blank"):
+          return true;
+        default:
+          return false;
+      }
+    }
+  };
+
+} // namespace margelo::nitro

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

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

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

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

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

@@ -0,0 +1,62 @@
+///
+/// HybridXlsxCellFormatSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridXlsxCellFormatSpec.hpp"
+
+namespace margelo::nitro::xlsx {
+
+  void HybridXlsxCellFormatSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridMethod("setFontName", &HybridXlsxCellFormatSpec::setFontName);
+      prototype.registerHybridMethod("setFontSize", &HybridXlsxCellFormatSpec::setFontSize);
+      prototype.registerHybridMethod("setFontColor", &HybridXlsxCellFormatSpec::setFontColor);
+      prototype.registerHybridMethod("setFontScript", &HybridXlsxCellFormatSpec::setFontScript);
+      prototype.registerHybridMethod("setBold", &HybridXlsxCellFormatSpec::setBold);
+      prototype.registerHybridMethod("setItalic", &HybridXlsxCellFormatSpec::setItalic);
+      prototype.registerHybridMethod("setUnderline", &HybridXlsxCellFormatSpec::setUnderline);
+      prototype.registerHybridMethod("setStrikeout", &HybridXlsxCellFormatSpec::setStrikeout);
+      prototype.registerHybridMethod("setAlign", &HybridXlsxCellFormatSpec::setAlign);
+      prototype.registerHybridMethod("setVerticalAlign", &HybridXlsxCellFormatSpec::setVerticalAlign);
+      prototype.registerHybridMethod("setTextWrap", &HybridXlsxCellFormatSpec::setTextWrap);
+      prototype.registerHybridMethod("setRotation", &HybridXlsxCellFormatSpec::setRotation);
+      prototype.registerHybridMethod("setIndent", &HybridXlsxCellFormatSpec::setIndent);
+      prototype.registerHybridMethod("setShrink", &HybridXlsxCellFormatSpec::setShrink);
+      prototype.registerHybridMethod("setNumFormat", &HybridXlsxCellFormatSpec::setNumFormat);
+      prototype.registerHybridMethod("setNumFormatIndex", &HybridXlsxCellFormatSpec::setNumFormatIndex);
+      prototype.registerHybridMethod("setBgColor", &HybridXlsxCellFormatSpec::setBgColor);
+      prototype.registerHybridMethod("setFgColor", &HybridXlsxCellFormatSpec::setFgColor);
+      prototype.registerHybridMethod("setPattern", &HybridXlsxCellFormatSpec::setPattern);
+      prototype.registerHybridMethod("setBorder", &HybridXlsxCellFormatSpec::setBorder);
+      prototype.registerHybridMethod("setBorderColor", &HybridXlsxCellFormatSpec::setBorderColor);
+      prototype.registerHybridMethod("setBottom", &HybridXlsxCellFormatSpec::setBottom);
+      prototype.registerHybridMethod("setTop", &HybridXlsxCellFormatSpec::setTop);
+      prototype.registerHybridMethod("setLeft", &HybridXlsxCellFormatSpec::setLeft);
+      prototype.registerHybridMethod("setRight", &HybridXlsxCellFormatSpec::setRight);
+      prototype.registerHybridMethod("setBottomColor", &HybridXlsxCellFormatSpec::setBottomColor);
+      prototype.registerHybridMethod("setTopColor", &HybridXlsxCellFormatSpec::setTopColor);
+      prototype.registerHybridMethod("setLeftColor", &HybridXlsxCellFormatSpec::setLeftColor);
+      prototype.registerHybridMethod("setRightColor", &HybridXlsxCellFormatSpec::setRightColor);
+      prototype.registerHybridMethod("setDiagonal", &HybridXlsxCellFormatSpec::setDiagonal);
+      prototype.registerHybridMethod("setDiagonalColor", &HybridXlsxCellFormatSpec::setDiagonalColor);
+      prototype.registerHybridMethod("setLocked", &HybridXlsxCellFormatSpec::setLocked);
+      prototype.registerHybridMethod("setUnlocked", &HybridXlsxCellFormatSpec::setUnlocked);
+      prototype.registerHybridMethod("setHyperlink", &HybridXlsxCellFormatSpec::setHyperlink);
+      prototype.registerHybridMethod("setFontOnly", &HybridXlsxCellFormatSpec::setFontOnly);
+      prototype.registerHybridMethod("getFontName", &HybridXlsxCellFormatSpec::getFontName);
+      prototype.registerHybridMethod("getFontSize", &HybridXlsxCellFormatSpec::getFontSize);
+      prototype.registerHybridMethod("getFontColor", &HybridXlsxCellFormatSpec::getFontColor);
+      prototype.registerHybridMethod("getIsBold", &HybridXlsxCellFormatSpec::getIsBold);
+      prototype.registerHybridMethod("getIsItalic", &HybridXlsxCellFormatSpec::getIsItalic);
+      prototype.registerHybridMethod("getNumFormat", &HybridXlsxCellFormatSpec::getNumFormat);
+      prototype.registerHybridMethod("getBgColor", &HybridXlsxCellFormatSpec::getBgColor);
+    });
+  }
+
+} // namespace margelo::nitro::xlsx

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

@@ -0,0 +1,104 @@
+///
+/// HybridXlsxCellFormatSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+
+
+#include <string>
+#include <optional>
+
+namespace margelo::nitro::xlsx {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `XlsxCellFormat`
+   * Inherit this class to create instances of `HybridXlsxCellFormatSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridXlsxCellFormat: public HybridXlsxCellFormatSpec {
+   * public:
+   *   HybridXlsxCellFormat(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridXlsxCellFormatSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridXlsxCellFormatSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridXlsxCellFormatSpec() override = default;
+
+    public:
+      // Properties
+      
+
+    public:
+      // Methods
+      virtual void setFontName(const std::string& name) = 0;
+      virtual void setFontSize(double size) = 0;
+      virtual void setFontColor(double color) = 0;
+      virtual void setFontScript(double style) = 0;
+      virtual void setBold() = 0;
+      virtual void setItalic() = 0;
+      virtual void setUnderline(std::optional<double> style) = 0;
+      virtual void setStrikeout() = 0;
+      virtual void setAlign(double align) = 0;
+      virtual void setVerticalAlign(double align) = 0;
+      virtual void setTextWrap() = 0;
+      virtual void setRotation(double angle) = 0;
+      virtual void setIndent(double level) = 0;
+      virtual void setShrink() = 0;
+      virtual void setNumFormat(const std::string& format) = 0;
+      virtual void setNumFormatIndex(double index) = 0;
+      virtual void setBgColor(double color) = 0;
+      virtual void setFgColor(double color) = 0;
+      virtual void setPattern(double pattern) = 0;
+      virtual void setBorder(double style) = 0;
+      virtual void setBorderColor(double color) = 0;
+      virtual void setBottom(double style) = 0;
+      virtual void setTop(double style) = 0;
+      virtual void setLeft(double style) = 0;
+      virtual void setRight(double style) = 0;
+      virtual void setBottomColor(double color) = 0;
+      virtual void setTopColor(double color) = 0;
+      virtual void setLeftColor(double color) = 0;
+      virtual void setRightColor(double color) = 0;
+      virtual void setDiagonal(double style) = 0;
+      virtual void setDiagonalColor(double color) = 0;
+      virtual void setLocked() = 0;
+      virtual void setUnlocked() = 0;
+      virtual void setHyperlink() = 0;
+      virtual void setFontOnly() = 0;
+      virtual std::string getFontName() = 0;
+      virtual double getFontSize() = 0;
+      virtual double getFontColor() = 0;
+      virtual bool getIsBold() = 0;
+      virtual bool getIsItalic() = 0;
+      virtual std::string getNumFormat() = 0;
+      virtual double getBgColor() = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "XlsxCellFormat";
+  };
+
+} // namespace margelo::nitro::xlsx

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

@@ -0,0 +1,27 @@
+///
+/// HybridXlsxWorkbookSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridXlsxWorkbookSpec.hpp"
+
+namespace margelo::nitro::xlsx {
+
+  void HybridXlsxWorkbookSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridMethod("addWorksheet", &HybridXlsxWorkbookSpec::addWorksheet);
+      prototype.registerHybridMethod("getWorksheet", &HybridXlsxWorkbookSpec::getWorksheet);
+      prototype.registerHybridMethod("getWorksheetByName", &HybridXlsxWorkbookSpec::getWorksheetByName);
+      prototype.registerHybridMethod("getOrAddWorksheet", &HybridXlsxWorkbookSpec::getOrAddWorksheet);
+      prototype.registerHybridMethod("getWorksheetCount", &HybridXlsxWorkbookSpec::getWorksheetCount);
+      prototype.registerHybridMethod("addCellFormat", &HybridXlsxWorkbookSpec::addCellFormat);
+      prototype.registerHybridMethod("getBuffer", &HybridXlsxWorkbookSpec::getBuffer);
+    });
+  }
+
+} // namespace margelo::nitro::xlsx

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

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