react-native-nitro-modules 0.0.2 → 0.0.4

package/cpp/core/HybridObject.cpp

@@ -0,0 +1,220 @@
+//
+// Created by Marc Rousavy on 21.02.24.
+//
+
+#include "HybridObject.hpp"
+#include "HybridContext.hpp"
+#include "JSIConverter.hpp"
+#include "NitroLogger.hpp"
+
+#define LOG_MEMORY_ALLOCATIONS true
+
+namespace margelo::nitro {
+
+#if LOG_MEMORY_ALLOCATIONS
+static std::mutex _instanceCounterMutex;
+static std::unordered_map<const char*, uint32_t> _aliveInstances;
+static std::unordered_map<const char*, int> _instanceIds;
+
+static uint32_t incrementAliveInstancesAndGet(const char* name) {
+  std::unique_lock lock(_instanceCounterMutex);
+  return ++_aliveInstances[name];
+}
+
+static uint32_t decrementAliveInstancesAndGet(const char* name) {
+  std::unique_lock lock(_instanceCounterMutex);
+  return --_aliveInstances[name];
+}
+
+static uint32_t getTotalAliveInstances() {
+  std::unique_lock lock(_instanceCounterMutex);
+  uint32_t total = 0;
+  for (const auto& iter : _aliveInstances) {
+    total += iter.second;
+  }
+  return total;
+}
+
+static int getId(const char* name) {
+  std::unique_lock lock(_instanceCounterMutex);
+  if (_instanceIds.find(name) == _instanceIds.end()) {
+    _instanceIds.insert({name, 1});
+  }
+  auto iterator = _instanceIds.find(name);
+  return iterator->second++;
+}
+#endif
+
+HybridObject::HybridObject(const char* name) : _name(name), _mutex(std::make_unique<std::mutex>()) {
+#if LOG_MEMORY_ALLOCATIONS
+  _instanceId = getId(name);
+  uint32_t alive = incrementAliveInstancesAndGet(_name);
+  uint32_t totalObjects = getTotalAliveInstances();
+  Logger::log(TAG, "(MEMORY) ✅ Creating %s (#%i)... (Total %s(s): %i | Total HybridObjects: %i)", _name, _instanceId, _name, alive,
+              totalObjects);
+#endif
+}
+
+HybridObject::~HybridObject() {
+#if LOG_MEMORY_ALLOCATIONS
+  uint32_t alive = decrementAliveInstancesAndGet(_name);
+  uint32_t totalObjects = getTotalAliveInstances();
+  Logger::log(TAG, "(MEMORY) ❌ Deleting %s (#%i)... (Total %s(s): %i | Total HybridObjects: %i) ", _name, _instanceId, _name, alive,
+              totalObjects);
+#endif
+  _functionCache.clear();
+}
+
+size_t HybridObject::getTotalExternalMemorySize() noexcept {
+  static constexpr int STRING_KEY_AVERAGE_SIZE = 32; // good average for string keys
+  static constexpr int CACHED_SIZE = STRING_KEY_AVERAGE_SIZE + sizeof(jsi::Function);
+  static constexpr int METHOD_SIZE = STRING_KEY_AVERAGE_SIZE + sizeof(HybridFunction);
+  static constexpr int GETTER_SIZE = STRING_KEY_AVERAGE_SIZE + sizeof(jsi::HostFunctionType);
+  static constexpr int SETTER_SIZE = STRING_KEY_AVERAGE_SIZE + sizeof(jsi::HostFunctionType);
+
+  size_t cachedFunctions = 0;
+  for (const auto& cache : _functionCache) {
+    cachedFunctions += cache.second.size();
+  }
+
+  size_t externalSize = getExternalMemorySize();
+  return (_getters.size() * GETTER_SIZE) + (_setters.size() * SETTER_SIZE) + (_methods.size() * METHOD_SIZE) +
+         (cachedFunctions * CACHED_SIZE) + sizeof(std::mutex) + externalSize;
+}
+
+jsi::Value HybridObject::toObject(jsi::Runtime& runtime) {
+  // 1. Try to find existing jsi::Object from cache
+  auto found = _jsObjects.find(&runtime);
+  if (found != _jsObjects.end()) {
+    // 1.1 We found an object in cache, let's see if it's still alive..
+    BorrowingReference<jsi::Object> weak = found->second;
+    OwningReference<jsi::Object> strong = weak.lock();
+    if (strong) {
+      // 1.2. It is alive (strong) - update memory size and return to JS!
+      size_t memorySize = getTotalExternalMemorySize();
+      strong->setExternalMemoryPressure(runtime, memorySize);
+      // 1.3. It is alive (strong) - copy the JSI Pointer into a new jsi::Value, and return to JS
+      return jsi::Value(runtime, *strong);
+    }
+  }
+
+  // 2. There is either no value in cache, or it's already dead. Create a new one
+  auto cache = JSICache<jsi::Object>::getOrCreateCache(runtime);
+  // 3. Create a new jsi::Object from this HybridObject/jsi::HostObject
+  std::shared_ptr<HybridObject> shared = shared_from_this();
+  jsi::Object object = jsi::Object::createFromHostObject(runtime, shared);
+  // 4. HybridObjects expose their external memory size, so inform JS GC about it!
+  size_t memorySize = getTotalExternalMemorySize();
+  object.setExternalMemoryPressure(runtime, memorySize);
+  // 5. Make it a global (weak) reference
+  auto global = cache.makeGlobal(std::move(object));
+  _jsObjects[&runtime] = global.weak();
+  // 6. Return a jsi::Value copy again to the caller.
+  return jsi::Value(runtime, *global);
+}
+
+std::string HybridObject::toString() {
+  return "[HybridObject " + std::string(_name) + "]";
+}
+
+std::string HybridObject::getName() {
+  return _name;
+}
+
+bool HybridObject::equals(std::shared_ptr<HybridObject> other) {
+  return this == other.get();
+}
+
+void HybridObject::loadHybridMethods() {
+  registerHybridGetter("name", &HybridObject::getName, this);
+  registerHybridMethod("toString", &HybridObject::toString, this);
+  registerHybridMethod("equals", &HybridObject::equals, this);
+}
+
+std::vector<jsi::PropNameID> HybridObject::getPropertyNames(facebook::jsi::Runtime& runtime) {
+  std::unique_lock lock(*_mutex);
+  ensureInitialized(runtime);
+
+  std::vector<jsi::PropNameID> result;
+  size_t totalSize = _methods.size() + _getters.size() + _setters.size() + 1;
+  result.reserve(totalSize);
+
+  for (const auto& item : _methods) {
+    result.push_back(jsi::PropNameID::forUtf8(runtime, item.first));
+  }
+  for (const auto& item : _getters) {
+    result.push_back(jsi::PropNameID::forUtf8(runtime, item.first));
+  }
+  for (const auto& item : _setters) {
+    result.push_back(jsi::PropNameID::forUtf8(runtime, item.first));
+  }
+  return result;
+}
+
+jsi::Value HybridObject::get(facebook::jsi::Runtime& runtime, const facebook::jsi::PropNameID& propName) {
+  std::unique_lock lock(*_mutex);
+  ensureInitialized(runtime);
+
+  std::string name = propName.utf8(runtime);
+
+  auto& functionCache = _functionCache[&runtime];
+
+  if (functionCache.contains(name)) [[likely]] {
+    // cache hit - let's see if the function is still alive..
+    OwningReference<jsi::Function> function = functionCache[name];
+    if (function) [[likely]] {
+      // function is still alive, we can use it.
+      return jsi::Value(runtime, *function);
+    }
+  }
+
+  if (_getters.contains(name)) {
+    // it's a property getter. call it directly
+    return _getters[name](runtime, jsi::Value::undefined(), nullptr, 0);
+  }
+
+  if (_methods.contains(name)) {
+    // it's a function. we now need to wrap it in a jsi::Function, store it in cache, then return it.
+    HybridFunction& hybridFunction = _methods.at(name);
+    // get (or create) a runtime-specific function cache
+    auto runtimeCache = JSICache<jsi::Function>::getOrCreateCache(runtime);
+    // create the jsi::Function
+    jsi::Function function = jsi::Function::createFromHostFunction(runtime, jsi::PropNameID::forUtf8(runtime, name),
+                                                                   hybridFunction.parameterCount, hybridFunction.function);
+    // throw it into the cache for next time
+    OwningReference<jsi::Function> globalFunction = runtimeCache.makeGlobal(std::move(function));
+    functionCache[name] = globalFunction;
+    // copy the reference & return it to JS
+    return jsi::Value(runtime, *globalFunction);
+  }
+
+  // this property does not exist. Return undefined
+  return jsi::Value::undefined();
+}
+
+void HybridObject::set(facebook::jsi::Runtime& runtime, const facebook::jsi::PropNameID& propName, const facebook::jsi::Value& value) {
+  std::unique_lock lock(*_mutex);
+  ensureInitialized(runtime);
+
+  std::string name = propName.utf8(runtime);
+
+  if (_setters.contains(name)) {
+    // Call setter
+    _setters[name](runtime, jsi::Value::undefined(), &value, 1);
+    return;
+  }
+
+  // this property does not exist, and cannot be set. Throw and error!
+  throw std::runtime_error("Cannot set property \"" + name + "\" - " + std::string(_name) + " does not have a setter for \"" + name +
+                           "\"!");
+}
+
+void HybridObject::ensureInitialized(facebook::jsi::Runtime& runtime) {
+  if (!_didLoadMethods) [[unlikely]] {
+    // lazy-load all exposed methods
+    loadHybridMethods();
+    _didLoadMethods = true;
+  }
+}
+
+} // namespace margelo::nitro

package/cpp/core/HybridObject.hpp

@@ -0,0 +1,241 @@
+//
+// Created by Marc Rousavy on 21.02.24.
+//
+
+#pragma once
+
+#include "HybridContext.hpp"
+#include "JSIConverter.hpp"
+#include "NitroLogger.hpp"
+#include "OwningReference.hpp"
+#include <functional>
+#include <jsi/jsi.h>
+#include <memory>
+#include <mutex>
+#include <type_traits>
+#include <unordered_map>
+
+namespace margelo::nitro {
+
+enum class MethodType { METHOD, GETTER, SETTER };
+
+using namespace facebook;
+
+/**
+ * Represents a C++ object that is exposed to JS.
+ * `HybridObject`s can have native getters and setters, and normal methods.
+ *
+ * To implement a `HybridObject`, simply inherit from this class and override `loadHybridMethods`
+ * to register the given getters, setters or methods.
+ *
+ * The new class can then be passed to JS using the `JSIConverter<HybridObject>`.
+ */
+class HybridObject : public jsi::HostObject, public std::enable_shared_from_this<HybridObject> {
+public:
+  struct HybridFunction {
+    jsi::HostFunctionType function;
+    size_t parameterCount;
+  };
+
+public:
+  /**
+   * Create a new instance of a `HybridObject`.
+   * The given `name` will be used for logging and stringifying.
+   */
+  explicit HybridObject(const char* name);
+  /**
+   * Called when no more references to the given `HybridObject` exist in both C++ and JS.
+   * JS might keep references for longer, as it is a garbage collected language.
+   */
+  virtual ~HybridObject();
+  /**
+   * HybridObjects cannot be copied.
+   */
+  HybridObject(const HybridObject& copy) = delete;
+  /**
+   * HybridObjects cannot be moved.
+   */
+  HybridObject(HybridObject&& move) = delete;
+
+public:
+  void set(jsi::Runtime&, const jsi::PropNameID& name, const jsi::Value& value) override;
+  jsi::Value get(jsi::Runtime& runtime, const jsi::PropNameID& propName) override;
+  std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime& runtime) override;
+
+public:
+  /**
+   * Get the `std::shared_ptr` instance of this HybridObject.
+   * The HybridObject must be managed inside a `shared_ptr` already, otherwise this will fail.
+   */
+  template <typename Derived> std::shared_ptr<Derived> shared() {
+    return std::static_pointer_cast<Derived>(shared_from_this());
+  }
+
+public:
+  /**
+   * Get the total size of any external (heap) allocations this `HybridObject` (or
+   * a subclass of it) has made.
+   * This includes any base allocations (such as function cache), as well as
+   * overridden extra memory size.
+   */
+  size_t getTotalExternalMemorySize() noexcept;
+
+  /**
+   * Return the `jsi::Object` that holds this `HybridObject` (boxed in a `jsi::Value`)
+   * Compared to other `jsi::HostObject`s, the `HybridObject` actually
+   * caches the created `jsi::Object` instances for safer memory management.
+   */
+  jsi::Value toObject(jsi::Runtime& runtime);
+
+public:
+  /**
+   * Get the HybridObject's name
+   */
+  std::string getName();
+  /**
+   * Get a string representation of this HostObject, useful for logging or debugging.
+   */
+  virtual std::string toString();
+  /**
+   * Compare this HybridObject for reference equality to the other HybridObject.
+   *
+   * While two `jsi::Object`s of the same `HybridObject` might not be equal when compared with `==`,
+   * they might still be the same `HybridObject` - in this case `equals(other)` will return true.
+   */
+  bool equals(std::shared_ptr<HybridObject> other);
+
+protected:
+  /**
+   * Get the size of any external (heap) allocations this `HybridObject` has made, in bytes.
+   * This will be used to notify the JS GC about memory pressure.
+   */
+  virtual inline size_t getExternalMemorySize() noexcept {
+    return 0;
+  }
+
+protected:
+  /**
+   * Loads all native methods of this `HybridObject` to be exposed to JavaScript.
+   * The base implementation registers a `toString()` method and `name` property.
+   *
+   * Example:
+   *
+   * ```cpp
+   * int User::getAge() {
+   *   return 23;
+   * }
+   *
+   * void User::loadHybridMethods() {
+   *   HybridObject::loadHybridMethods();
+   *   registerHybridMethod("getAge", &User::getAge, this);
+   * }
+   * ```
+   */
+  virtual void loadHybridMethods();
+
+private:
+  static constexpr auto TAG = "HybridObject";
+  const char* _name = TAG;
+  int _instanceId = 1;
+  bool _didLoadMethods = false;
+  std::unique_ptr<std::mutex> _mutex;
+  std::unordered_map<std::string, HybridFunction> _methods;
+  std::unordered_map<std::string, jsi::HostFunctionType> _getters;
+  std::unordered_map<std::string, jsi::HostFunctionType> _setters;
+  std::unordered_map<jsi::Runtime*, std::unordered_map<std::string, OwningReference<jsi::Function>>> _functionCache;
+  std::unordered_map<jsi::Runtime*, BorrowingReference<jsi::Object>> _jsObjects;
+
+private:
+  inline void ensureInitialized(jsi::Runtime& runtime);
+
+private:
+  template <typename Derived, typename ReturnType, typename... Args, size_t... Is>
+  static inline jsi::Value callMethod(Derived* obj, ReturnType (Derived::*method)(Args...), jsi::Runtime& runtime, const jsi::Value* args,
+                                      std::index_sequence<Is...>) {
+    if constexpr (std::is_void_v<ReturnType>) {
+      // It's a void method.
+      (obj->*method)(JSIConverter<std::decay_t<Args>>::fromJSI(runtime, args[Is])...);
+      return jsi::Value::undefined();
+    } else {
+      // It's returning some C++ type, we need to convert that to a JSI value now.
+      ReturnType result = (obj->*method)(JSIConverter<std::decay_t<Args>>::fromJSI(runtime, args[Is])...);
+      return JSIConverter<std::decay_t<ReturnType>>::toJSI(runtime, std::move(result));
+    }
+  }
+
+  template <typename Derived, typename ReturnType, typename... Args>
+  static inline jsi::HostFunctionType createHybridMethod(std::string name, ReturnType (Derived::*method)(Args...), Derived* derivedInstance,
+                                                         MethodType type) {
+    return [name, derivedInstance, method, type](jsi::Runtime& runtime, const jsi::Value& thisVal, const jsi::Value* args,
+                                                 size_t count) -> jsi::Value {
+      if (count != sizeof...(Args)) {
+        // invalid amount of arguments passed!
+        std::string hybridObjectName = derivedInstance->_name;
+        throw jsi::JSError(runtime, hybridObjectName + "." + name + "(...) expected " + std::to_string(sizeof...(Args)) +
+                                        " arguments, but received " + std::to_string(count) + "!");
+      }
+
+      try {
+        if constexpr (std::is_same_v<ReturnType, jsi::Value>) {
+          // If the return type is a jsi::Value, we assume the user wants full JSI code control.
+          // The signature must be identical to jsi::HostFunction (jsi::Runtime&, jsi::Value& this, ...)
+          return (derivedInstance->*method)(runtime, thisVal, args, count);
+        } else {
+          // Call the actual method with JSI values as arguments and return a JSI value again.
+          // Internally, this method converts the JSI values to C++ values.
+          return callMethod(derivedInstance, method, runtime, args, std::index_sequence_for<Args...>{});
+        }
+      } catch (const std::exception& exception) {
+        std::string hybridObjectName = derivedInstance->_name;
+        std::string message = exception.what();
+        std::string suffix = type == MethodType::METHOD ? "(...)" : "";
+        throw jsi::JSError(runtime, hybridObjectName + "." + name + suffix + ": " + message);
+      } catch (...) {
+        std::string hybridObjectName = derivedInstance->_name;
+        std::string errorName = TypeInfo::getCurrentExceptionName();
+        std::string suffix = type == MethodType::METHOD ? "(...)" : "";
+        throw jsi::JSError(runtime, hybridObjectName + "." + name + suffix + " threw an unknown " + errorName + " error.");
+      }
+    };
+  }
+
+protected:
+  template <typename Derived, typename ReturnType, typename... Args>
+  inline void registerHybridMethod(std::string name, ReturnType (Derived::*method)(Args...), Derived* derivedInstance) {
+    if (_getters.contains(name) || _setters.contains(name)) [[unlikely]] {
+      throw std::runtime_error("Cannot add Hybrid Method \"" + name + "\" - a property with that name already exists!");
+    }
+    if (_methods.contains(name)) [[unlikely]] {
+      throw std::runtime_error("Cannot add Hybrid Method \"" + name + "\" - a method with that name already exists!");
+    }
+
+    _methods[name] = HybridFunction{.function = createHybridMethod(name, method, derivedInstance, MethodType::METHOD),
+                                    .parameterCount = sizeof...(Args)};
+  }
+
+  template <typename Derived, typename ReturnType>
+  inline void registerHybridGetter(std::string name, ReturnType (Derived::*method)(), Derived* derivedInstance) {
+    if (_getters.contains(name)) [[unlikely]] {
+      throw std::runtime_error("Cannot add Hybrid Property Getter \"" + name + "\" - a getter with that name already exists!");
+    }
+    if (_methods.contains(name)) [[unlikely]] {
+      throw std::runtime_error("Cannot add Hybrid Property Getter \"" + name + "\" - a method with that name already exists!");
+    }
+
+    _getters[name] = createHybridMethod(name, method, derivedInstance, MethodType::GETTER);
+  }
+
+  template <typename Derived, typename ValueType>
+  inline void registerHybridSetter(std::string name, void (Derived::*method)(ValueType), Derived* derivedInstance) {
+    if (_setters.contains(name)) [[unlikely]] {
+      throw std::runtime_error("Cannot add Hybrid Property Setter \"" + name + "\" - a setter with that name already exists!");
+    }
+    if (_methods.contains(name)) [[unlikely]] {
+      throw std::runtime_error("Cannot add Hybrid Property Setter \"" + name + "\" - a method with that name already exists!");
+    }
+
+    _setters[name] = createHybridMethod(name, method, derivedInstance, MethodType::SETTER);
+  }
+};
+
+} // namespace margelo::nitro

package/cpp/core/PointerHolder.hpp

@@ -0,0 +1,93 @@
+//
+// Created by Marc Rousavy on 16.04.24.
+//
+
+#pragma once
+
+#include "HybridObject.hpp"
+#include "NitroLogger.hpp"
+#include <memory>
+#include <mutex>
+
+namespace margelo::nitro {
+
+using namespace facebook;
+
+template <typename T> class PointerHolder final : public HybridObject {
+protected:
+  // no default constructor
+  PointerHolder() = delete;
+
+  /**
+   * Create a new instance of a pointer holder which holds the given shared_ptr.
+   * @param name The name of the implementing class, for example "ViewWrapper".
+   * @param pointer The pointer this class will hold. It might be released from JS at any point via `release()`.
+   */
+  PointerHolder(const char* name, std::shared_ptr<T> pointer) : HybridObject(name), _name(name), _pointer(pointer) {
+    // eagerly initialize the release() method instead of putting it in `loadHybridMethods`
+    registerHybridMethod("release", &PointerHolder<T>::release, this);
+    registerHybridGetter("isValid", &PointerHolder<T>::getIsValid, this);
+  }
+
+  /**
+   * Create a new instance of a pointer holder which holds a shared_ptr of the given value.
+   * The shared_ptr will be move-constructed.
+   * @param name The name of the implementing class, for example "ViewWrapper".
+   * @param value The value this class will hold as a shared_ptr. It might be destroyed from JS at any point via `release()`.
+   */
+  PointerHolder(const char* name, T&& value) : PointerHolder(name, std::make_shared<T>(std::move(value))) {}
+
+  /**
+   * Called when the PointerHolder gets automatically destroyed (e.g. via GC) and the shared_ptr will be destroyed.
+   */
+  ~PointerHolder() {
+    if (_pointer != nullptr) {
+      Logger::log(TAG, "Automatically releasing %s... (~PointerHolder())", _name.c_str());
+    }
+  }
+
+protected:
+  /**
+   * Manually release this reference to the pointer.
+   * If there are any other references to this pointer, no memory will be force-deleted.
+   */
+  virtual void release() {
+    std::unique_lock lock(_mutex);
+
+    if (_pointer == nullptr) {
+      throw std::runtime_error("Pointer " + _name + " has already been manually released!");
+    }
+    Logger::log(TAG, "Manually releasing %s... (PointerHolder::release())", _name.c_str());
+    _pointer = nullptr;
+  }
+
+  /**
+   * Get the shared_ptr this class is holding.
+   * If it has already been manually released from JS, this method will throw a runtime_error.
+   */
+  std::shared_ptr<T> pointee() {
+    std::unique_lock lock(_mutex);
+
+    if (_pointer == nullptr) {
+      throw std::runtime_error("Pointer " + _name + " has already been manually released!");
+    }
+    return _pointer;
+  }
+
+  /**
+   * Get if the pointer is still valid and strong.
+   */
+  bool getIsValid() {
+    std::unique_lock lock(_mutex);
+
+    return _pointer != nullptr;
+  }
+
+private:
+  std::string _name;
+  std::shared_ptr<T> _pointer;
+  std::mutex _mutex;
+  static constexpr auto TAG = "PointerHolder";
+};
+
+} // namespace margelo::nitro

package/cpp/jsi/ArrayBuffer.hpp

@@ -0,0 +1,79 @@
+//
+//  ArrayBuffer.hpp
+//  react-native-nitro
+//
+//  Created by Marc Rousavy on 14.07.24.
+//
+
+#pragma once
+
+#include <functional>
+#include <jsi/jsi.h>
+
+namespace margelo::nitro {
+
+using namespace facebook;
+
+using DeleteFn = std::function<void(uint8_t*)>;
+
+static DeleteFn defaultDeleteFn = [](uint8_t* buffer) { delete[] buffer; };
+
+/**
+ * Represents a raw byte buffer that can be read from-, and
+ * written to- from both JavaScript and C++.
+ * `ArrayBuffer` is not thread-safe and does not lock multi-thread access.
+ *
+ * Also, if `ArrayBuffer` is coming from JS, it is not safe to keep a strong
+ * reference on `ArrayBuffer` as C++ does not own the data (`isOwner() == false`) -
+ * it can be deleted at any point without C++ knowing about it.
+ *
+ * Only if C++ creates the `ArrayBuffer` a reference to it can be safely
+ * kept in memory, as C++ is then the owner of `ArrayBuffer` (`isOwner() == true`).
+ */
+class ArrayBuffer : public jsi::MutableBuffer {
+public:
+  /**
+   * Create a new **owning** `ArrayBuffer`.
+   * The `ArrayBuffer` can be kept in memory, as C++ owns the data
+   * and will only delete it once this `ArrayBuffer` gets deleted
+   */
+  ArrayBuffer(uint8_t* data, size_t size, DeleteFn&& deleteFunc) : _data(data), _size(size), _deleteFunc(std::move(deleteFunc)) {}
+  /**
+   * Create a new `ArrayBuffer`.
+   * If `destroyOnDeletion` is `true`, the `ArrayBuffer` is **owning**, otherwise it is **non-owning**.
+   * The `ArrayBuffer` can only be safely kept in memory if it is owning (`isOwning()`).
+   */
+  ArrayBuffer(uint8_t* data, size_t size, bool destroyOnDeletion) : _data(data), _size(size) {
+    _deleteFunc = destroyOnDeletion ? defaultDeleteFn : nullptr;
+  }
+
+  // ArrayBuffer cannot be copied
+  ArrayBuffer(const ArrayBuffer&) = delete;
+  // ArrayBuffer cannot be moved
+  ArrayBuffer(ArrayBuffer&&) = delete;
+
+  ~ArrayBuffer() {
+    if (_deleteFunc != nullptr) {
+      _deleteFunc(_data);
+    }
+  }
+
+  uint8_t* data() noexcept override {
+    return _data;
+  }
+
+  size_t size() const noexcept override {
+    return _size;
+  }
+
+  bool isOwner() const noexcept {
+    return _deleteFunc != nullptr;
+  }
+
+private:
+  uint8_t* _data;
+  size_t _size;
+  DeleteFn _deleteFunc;
+};
+
+} // namespace margelo::nitro