@hxa-rn/react-native-quick-crypto 1.1.0-beta.1

package/harmony/quick_crypto/src/main/cpp/nitro/shared/AnyMap.cpp

@@ -0,0 +1,202 @@
+//
+// Created by Marc Rousavy on 30.07.24.
+//
+
+#include "AnyMap.hpp"
+
+namespace margelo::nitro {
+
+// Contains
+bool AnyMap::contains(const std::string& key) const {
+  return _map.contains(key);
+}
+void AnyMap::remove(const std::string& key) {
+  _map.erase(key);
+}
+void AnyMap::clear() noexcept {
+  _map.clear();
+}
+std::vector<std::string> AnyMap::getAllKeys() const {
+  std::vector<std::string> keys;
+  keys.reserve(_map.size());
+  for (const auto& pair : _map) {
+    keys.push_back(pair.first);
+  }
+  return keys;
+}
+
+// Is
+bool AnyMap::isNull(const std::string& key) const {
+  auto found = _map.find(key);
+  if (found == _map.end()) {
+    return false;
+  }
+  return std::holds_alternative<NullType>(found->second);
+}
+bool AnyMap::isDouble(const std::string& key) const {
+  auto found = _map.find(key);
+  if (found == _map.end()) {
+    return false;
+  }
+  return std::holds_alternative<double>(found->second);
+}
+bool AnyMap::isBoolean(const std::string& key) const {
+  auto found = _map.find(key);
+  if (found == _map.end()) {
+    return false;
+  }
+  return std::holds_alternative<bool>(found->second);
+}
+bool AnyMap::isBigInt(const std::string& key) const {
+  auto found = _map.find(key);
+  if (found == _map.end()) {
+    return false;
+  }
+  return std::holds_alternative<int64_t>(found->second);
+}
+bool AnyMap::isString(const std::string& key) const {
+  auto found = _map.find(key);
+  if (found == _map.end()) {
+    return false;
+  }
+  return std::holds_alternative<std::string>(found->second);
+}
+bool AnyMap::isArray(const std::string& key) const {
+  auto found = _map.find(key);
+  if (found == _map.end()) {
+    return false;
+  }
+  return std::holds_alternative<AnyArray>(found->second);
+}
+bool AnyMap::isObject(const std::string& key) const {
+  auto found = _map.find(key);
+  if (found == _map.end()) {
+    return false;
+  }
+  return std::holds_alternative<AnyObject>(found->second);
+}
+
+// Get
+NullType AnyMap::getNull(const std::string& key) const {
+  auto found = _map.find(key);
+  if (found == _map.end()) {
+    throw std::runtime_error("The key \"" + key + "\" does not exist in this Map!");
+  }
+  if (auto result = std::get_if<NullType>(&found->second)) {
+    return *result;
+  } else {
+    throw std::runtime_error("The value at key \"" + key + "\" is not a null!");
+  }
+}
+double AnyMap::getDouble(const std::string& key) const {
+  auto found = _map.find(key);
+  if (found == _map.end()) {
+    throw std::runtime_error("The key \"" + key + "\" does not exist in this Map!");
+  }
+  if (auto result = std::get_if<double>(&found->second)) {
+    return *result;
+  } else {
+    throw std::runtime_error("The value at key \"" + key + "\" is not a double!");
+  }
+}
+bool AnyMap::getBoolean(const std::string& key) const {
+  auto found = _map.find(key);
+  if (found == _map.end()) {
+    throw std::runtime_error("The key \"" + key + "\" does not exist in this Map!");
+  }
+  if (auto result = std::get_if<bool>(&found->second)) {
+    return *result;
+  } else {
+    throw std::runtime_error("The value at key \"" + key + "\" is not a bool!");
+  }
+}
+int64_t AnyMap::getBigInt(const std::string& key) const {
+  auto found = _map.find(key);
+  if (found == _map.end()) {
+    throw std::runtime_error("The key \"" + key + "\" does not exist in this Map!");
+  }
+  if (auto result = std::get_if<int64_t>(&found->second)) {
+    return *result;
+  } else {
+    throw std::runtime_error("The value at key \"" + key + "\" is not a bigint!");
+  }
+}
+std::string AnyMap::getString(const std::string& key) const {
+  auto found = _map.find(key);
+  if (found == _map.end()) {
+    throw std::runtime_error("The key \"" + key + "\" does not exist in this Map!");
+  }
+  if (auto result = std::get_if<std::string>(&found->second)) {
+    return *result;
+  } else {
+    throw std::runtime_error("The value at key \"" + key + "\" is not a string!");
+  }
+}
+AnyArray AnyMap::getArray(const std::string& key) const {
+  auto found = _map.find(key);
+  if (found == _map.end()) {
+    throw std::runtime_error("The key \"" + key + "\" does not exist in this Map!");
+  }
+  if (auto result = std::get_if<AnyArray>(&found->second)) {
+    return *result;
+  } else {
+    throw std::runtime_error("The value at key \"" + key + "\" is not an array!");
+  }
+}
+AnyObject AnyMap::getObject(const std::string& key) const {
+  auto found = _map.find(key);
+  if (found == _map.end()) {
+    throw std::runtime_error("The key \"" + key + "\" does not exist in this Map!");
+  }
+  if (auto result = std::get_if<AnyObject>(&found->second)) {
+    return *result;
+  } else {
+    throw std::runtime_error("The value at key \"" + key + "\" is not an object!");
+  }
+}
+AnyValue AnyMap::getAny(const std::string& key) const {
+  auto found = _map.find(key);
+  if (found == _map.end()) {
+    throw std::runtime_error("The key \"" + key + "\" does not exist in this Map!");
+  }
+  return found->second;
+}
+
+// Set
+void AnyMap::setNull(const std::string& key) {
+  _map.emplace(key, nitro::null);
+}
+void AnyMap::setDouble(const std::string& key, double value) {
+  _map.emplace(key, value);
+}
+void AnyMap::setBoolean(const std::string& key, bool value) {
+  _map.emplace(key, value);
+}
+void AnyMap::setBigInt(const std::string& key, int64_t value) {
+  _map.emplace(key, value);
+}
+void AnyMap::setString(const std::string& key, const std::string& value) {
+  _map.emplace(key, value);
+}
+void AnyMap::setArray(const std::string& key, const AnyArray& value) {
+  _map.emplace(key, value);
+}
+void AnyMap::setObject(const std::string& key, const AnyObject& value) {
+  _map.emplace(key, value);
+}
+void AnyMap::setAny(const std::string& key, const AnyValue& value) {
+  _map.emplace(key, value);
+}
+
+// C++ getter
+const std::unordered_map<std::string, AnyValue>& AnyMap::getMap() const {
+  return _map;
+}
+
+void AnyMap::merge(const std::shared_ptr<AnyMap>& other) {
+  for (auto& [key, value] : other->_map) {
+    _map[key] = value;
+  }
+}
+
+} // namespace margelo::nitro

package/harmony/quick_crypto/src/main/cpp/nitro/shared/AnyMap.hpp

@@ -0,0 +1,216 @@
+//
+// Created by Marc Rousavy on 30.07.24.
+//
+
+#pragma once
+
+#include "NitroDefines.hpp"
+#include "Null.hpp"
+#include <map>
+#include <memory>
+#include <string>
+#include <unordered_map>
+#include <variant>
+#include <vector>
+
+namespace margelo::nitro {
+
+struct AnyValue;
+using AnyArray = std::vector<AnyValue>;
+using AnyObject = std::unordered_map<std::string, AnyValue>;
+
+using VariantType = std::variant<NullType, bool, double, int64_t, std::string, AnyArray, AnyObject>;
+struct AnyValue : VariantType {
+  using VariantType::variant;
+
+  AnyValue(const VariantType& variant) : VariantType(variant) {}
+  AnyValue(VariantType&& variant) : VariantType(std::move(variant)) {}
+};
+
+/**
+ * Represents a JS map-like object (`Record<K, V>`).
+ * This is essentially a wrapper around `std::unordered_map<string, variant<...>>`.
+ *
+ * Supported values are:
+ * 1. Primitives
+ * 2. Arrays of primitives
+ * 3. Objects of primitives
+ */
+class AnyMap final {
+private:
+  explicit AnyMap() {}
+  AnyMap(size_t size) {
+    _map.reserve(size);
+  }
+
+public:
+  /**
+   * Create a new `shared_ptr` instance of AnyMap.
+   */
+  static std::shared_ptr<AnyMap> make() {
+    return std::shared_ptr<AnyMap>(new AnyMap());
+  }
+  /**
+   * Create a new `shared_ptr` instance of AnyMap with the given amount of spaces pre-allocated.
+   */
+  static std::shared_ptr<AnyMap> make(size_t size) {
+    return std::shared_ptr<AnyMap>(new AnyMap(size));
+  }
+
+public:
+  /**
+   * Returns whether the map contains the given key, or not.
+   */
+  bool contains(const std::string& key) const;
+  /**
+   * Removes the given key from the map, leaving no value.
+   */
+  void remove(const std::string& key);
+  /**
+   * Deletes all keys and values inside the map.
+   */
+  void clear() noexcept;
+  /**
+   * Get all keys this `AnyMap` instance contains.
+   */
+  std::vector<std::string> getAllKeys() const;
+
+public:
+  /**
+   * Returns whether the value under the given key is a `null`.
+   * If the value is not a `null` (or there is no value at the given `key`), this returns `false`.
+   */
+  bool isNull(const std::string& key) const;
+  /**
+   * Returns whether the value under the given key is a `double`.
+   * If the value is not a `double` (or there is no value at the given `key`), this returns `false`.
+   */
+  bool isDouble(const std::string& key) const;
+  /**
+   * Returns whether the value under the given key is a `boolean`.
+   * If the value is not a `boolean` (or there is no value at the given `key`), this returns `false`.
+   */
+  bool isBoolean(const std::string& key) const;
+  /**
+   * Returns whether the value under the given key is a `bigint`.
+   * If the value is not a `bigint` (or there is no value at the given `key`), this returns `false`.
+   */
+  bool isBigInt(const std::string& key) const;
+  /**
+   * Returns whether the value under the given key is a `string`.
+   * If the value is not a `string` (or there is no value at the given `key`), this returns `false`.
+   */
+  bool isString(const std::string& key) const;
+  /**
+   * Returns whether the value under the given key is an array.
+   * If the value is not an array (or there is no value at the given `key`), this returns `false`.
+   */
+  bool isArray(const std::string& key) const;
+  /**
+   * Returns whether the value under the given key is an object.
+   * If the value is not an object (or there is no value at the given `key`), this returns `false`.
+   */
+  bool isObject(const std::string& key) const;
+
+public:
+  /**
+   * Returns the null value at the given `key`.
+   * If no `null` value exists at the given `key`, this method will throw.
+   */
+  NullType getNull(const std::string& key) const;
+  /**
+   * Returns the double value at the given `key`.
+   * If no `double` value exists at the given `key`, this method will throw.
+   */
+  double getDouble(const std::string& key) const;
+  /**
+   * Returns the boolean value at the given `key`.
+   * If no `boolean` value exists at the given `key`, this method will throw.
+   */
+  bool getBoolean(const std::string& key) const;
+  /**
+   * Returns the bigint value at the given `key`.
+   * If no `bigint` value exists at the given `key`, this method will throw.
+   */
+  int64_t getBigInt(const std::string& key) const;
+  /**
+   * Returns the string value at the given `key`.
+   * If no `string` value exists at the given `key`, this method will throw.
+   */
+  std::string getString(const std::string& key) const;
+  /**
+   * Returns the array value at the given `key`.
+   * If no array value exists at the given `key`, this method will throw.
+   */
+  AnyArray getArray(const std::string& key) const;
+  /**
+   * Returns the object value at the given `key`.
+   * If no object value exists at the given `key`, this method will throw.
+   */
+  AnyObject getObject(const std::string& key) const;
+
+  /**
+   * Get the value at the given `key` as it's boxed `AnyValue`.
+   * If no object value exists at the given `key`, this method will throw.
+   */
+  AnyValue getAny(const std::string& key) const;
+
+public:
+  /**
+   * Set the value at the given key to `null`.
+   * If the key already exists, this will overwrite the value at that `key`.
+   */
+  void setNull(const std::string& key);
+  /**
+   * Set the value at the given key to the given `double`.
+   * If the key already exists, this will overwrite the value at that `key`.
+   */
+  void setDouble(const std::string& key, double value);
+  /**
+   * Set the value at the given key to the given `boolean`.
+   * If the key already exists, this will overwrite the value at that `key`.
+   */
+  void setBoolean(const std::string& key, bool value);
+  /**
+   * Set the value at the given key to the given `bigint`.
+   * If the key already exists, this will overwrite the value at that `key`.
+   */
+  void setBigInt(const std::string& key, int64_t value);
+  /**
+   * Set the value at the given key to the given `string`.
+   * If the key already exists, this will overwrite the value at that `key`.
+   */
+  void setString(const std::string& key, const std::string& value);
+  /**
+   * Set the value at the given key to the given array.
+   * If the key already exists, this will overwrite the value at that `key`.
+   */
+  void setArray(const std::string& key, const AnyArray& value);
+  /**
+   * Set the value at the given key to the given object.
+   * If the key already exists, this will overwrite the value at that `key`.
+   */
+  void setObject(const std::string& key, const AnyObject& value);
+  /**
+   * Set the value at the given key to the given `AnyValue`.
+   * If the key already exists, this will overwrite the value at that `key`.
+   */
+  void setAny(const std::string& key, const AnyValue& value);
+
+public:
+  /**
+   * Get the actual C++ map that holds all keys and variant values.
+   */
+  const std::unordered_map<std::string, AnyValue>& getMap() const;
+
+public:
+  /**
+   * Merge all keys and values from given `other` `AnyMap` into this `AnyMap`.
+   */
+  void merge(const std::shared_ptr<AnyMap>& other);
+
+private:
+  std::unordered_map<std::string, AnyValue> _map;
+} SWIFT_NONCOPYABLE;
+
+} // namespace margelo::nitro

package/harmony/quick_crypto/src/main/cpp/nitro/shared/ArrayBuffer.cpp

@@ -0,0 +1,125 @@
+//
+//  ArrayBuffer.cpp
+//  react-native-nitro
+//
+//  Created by Marc Rousavy on 14.07.24.
+//
+
+#include "ArrayBuffer.hpp"
+#include "BorrowingReference.hpp"
+#include "NitroDefines.hpp"
+#include <functional>
+#include <jsi/jsi.h>
+#include <thread>
+
+#include "hilog/log.h"
+#undef LOG_DOMAIN
+#undef LOG_TAG
+#define LOG_DOMAIN 0x3200 // 全局domain宏，标识业务领域
+#define LOG_TAG "MY_TAG"  // 全局tag宏，标识模块日志tag
+
+namespace margelo::nitro {
+
+using namespace facebook;
+
+// 1. ArrayBuffer
+
+std::shared_ptr<ArrayBuffer>
+ArrayBuffer::wrap(uint8_t *NON_NULL data, size_t size, DeleteFn &&deleteFunc) {
+  return std::make_shared<NativeArrayBuffer>(data, size, std::move(deleteFunc));
+}
+
+std::shared_ptr<ArrayBuffer> ArrayBuffer::copy(const uint8_t *NON_NULL data,
+                                               size_t size) {
+  uint8_t *copy = new uint8_t[size];
+  std::memcpy(copy, data, size);
+  return ArrayBuffer::wrap(copy, size, [=]() { delete[] copy; });
+}
+
+std::shared_ptr<ArrayBuffer>
+ArrayBuffer::copy(const std::vector<uint8_t> &data) {
+  return ArrayBuffer::copy(data.data(), data.size());
+}
+
+std::shared_ptr<ArrayBuffer> ArrayBuffer::move(std::vector<uint8_t> &&data) {
+  auto *vector = new std::vector<uint8_t>(std::move(data));
+  return ArrayBuffer::wrap(vector->data(), vector->size(),
+                           [=]() { delete vector; });
+}
+
+std::shared_ptr<ArrayBuffer>
+ArrayBuffer::copy(const std::shared_ptr<ArrayBuffer> &buffer) {
+  OH_LOG_INFO(LOG_APP, "zj->ArrayBuffer::copy");
+  return ArrayBuffer::copy(buffer->data(), buffer->size());
+}
+
+std::shared_ptr<ArrayBuffer> ArrayBuffer::allocate(size_t size) {
+  uint8_t *data = new uint8_t[size];
+  return ArrayBuffer::wrap(data, size, [=]() { delete[] data; });
+}
+
+// 2. NativeArrayBuffer
+
+NativeArrayBuffer::NativeArrayBuffer(uint8_t *NON_NULL data, size_t size,
+                                     DeleteFn &&deleteFunc)
+    : ArrayBuffer(), _data(data), _size(size),
+      _deleteFunc(std::move(deleteFunc)) {}
+
+NativeArrayBuffer::~NativeArrayBuffer() {
+  if (_deleteFunc != nullptr) {
+    _deleteFunc();
+  }
+}
+
+uint8_t *NON_NULL NativeArrayBuffer::data() { return _data; }
+
+size_t NativeArrayBuffer::size() const { return _size; }
+
+bool NativeArrayBuffer::isOwner() const noexcept {
+  return _deleteFunc != nullptr;
+}
+
+// 3. JSArrayBuffer
+
+JSArrayBuffer::JSArrayBuffer(jsi::Runtime &runtime,
+                             BorrowingReference<jsi::ArrayBuffer> jsReference)
+    : ArrayBuffer(), _runtime(runtime), _jsReference(jsReference),
+      _initialThreadId(std::this_thread::get_id()) {}
+
+JSArrayBuffer::~JSArrayBuffer() {}
+
+uint8_t *NULLABLE JSArrayBuffer::data() {
+  if (_initialThreadId != std::this_thread::get_id()) [[unlikely]] {
+    throw std::runtime_error(
+        "`data()` can only be accessed synchronously on the JS Thread! "
+        "If you want to access it elsewhere, copy it first.");
+  }
+
+  if (!_jsReference) [[unlikely]] {
+    // JS Part has been deleted - data is now nullptr.
+    return nullptr;
+  }
+  // JS Part is still alive - we can assume that the jsi::Runtime is safe to
+  // access here too.
+  return _jsReference->data(_runtime);
+}
+
+size_t JSArrayBuffer::size() const {
+  if (_initialThreadId != std::this_thread::get_id()) [[unlikely]] {
+    throw std::runtime_error(
+        "`size()` can only be accessed synchronously on the JS Thread! "
+        "If you want to access it elsewhere, copy it first.");
+  }
+
+  if (!_jsReference) [[unlikely]] {
+    // JS Part has been deleted - size is now 0.
+    return 0;
+  }
+  // JS Part is still alive - we can assume that the jsi::Runtime is safe to
+  // access here too.
+  return _jsReference->size(_runtime);
+}
+
+bool JSArrayBuffer::isOwner() const noexcept { return false; }
+
+} // namespace margelo::nitro

package/harmony/quick_crypto/src/main/cpp/nitro/shared/ArrayBuffer.hpp

@@ -0,0 +1,157 @@
+//
+//  ArrayBuffer.hpp
+//  react-native-nitro
+//
+//  Created by Marc Rousavy on 14.07.24.
+//
+
+#pragma once
+
+#include "BorrowingReference.hpp"
+#include "NitroDefines.hpp"
+#include <jsi/jsi.h>
+#include <thread>
+#include <vector>
+
+namespace margelo::nitro {
+
+using namespace facebook;
+
+using DeleteFn = std::function<void()>;
+
+/**
+ * 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.
+ *
+ * `ArrayBuffer` can either be a `JSArrayBuffer`, or a `NativeArrayBuffer`.
+ * - `NativeArrayBuffer`: Created from native (C++), and can either own the memory (`isOwner()`), or borrow it.
+ * - `JSArrayBuffer`: Received from JS, and will only be alive for as long as the JS Runtime is actually alive.
+ *
+ * Also, an `ArrayBuffer` can either own it's memory, or just borrow it's memory.
+ * - Owning = the `ArrayBuffer`'s `data()` is alive as long as the `ArrayBuffer` is alive.
+ *   When this `ArrayBuffer` gets deleted, it will free the memory.
+ * - Borrowed = the `ArrayBuffer`'s `data()` might be deleted at any point from an external source (e.g. the JS garbage collector).
+ *   When this `ArrayBuffer` gets deleted, the memory will not be freed explicitly, as someone else owns it.
+ */
+class ArrayBuffer : public jsi::MutableBuffer {
+public:
+  ArrayBuffer() = default;
+  ArrayBuffer(const ArrayBuffer&) = delete;
+  ArrayBuffer(ArrayBuffer&&) = delete;
+  virtual ~ArrayBuffer() = default;
+
+public:
+  /**
+   * Returns whether this `ArrayBuffer` is actually owning the data,
+   * or if it is just borrowed from an external source (either a native
+   * memory that we didn't allocate, or from JS - which can be deleted at any point).
+   */
+  virtual bool isOwner() const noexcept = 0;
+
+public:
+  /**
+   * Create a new `NativeArrayBuffer` that wraps the given data (without copy) of the given size,
+   * and calls `deleteFunc` in which `data` should be deleted.
+   */
+  static std::shared_ptr<ArrayBuffer> wrap(uint8_t* NON_NULL data, size_t size, DeleteFn&& deleteFunc);
+  /**
+   * Create a new `NativeArrayBuffer` that copies the given data of the given size
+   * into a newly allocated buffer.
+   */
+  static std::shared_ptr<ArrayBuffer> copy(const uint8_t* NON_NULL data, size_t size);
+  /**
+   * Create a new `NativeArrayBuffer` that copies the given `std::vector`.
+   */
+  static std::shared_ptr<ArrayBuffer> copy(const std::vector<uint8_t>& data);
+  /**
+   * Create a new `NativeArrayBuffer` that moves the given `std::vector`.
+   */
+  static std::shared_ptr<ArrayBuffer> move(std::vector<uint8_t>&& data);
+  /**
+   * Create a new `NativeArrayBuffer` that copies the given `std::shared_ptr<ArrayBuffer>`.
+   */
+  static std::shared_ptr<ArrayBuffer> copy(const std::shared_ptr<ArrayBuffer>& buffer);
+  /**
+   * Create a new `NativeArrayBuffer` that allocates a new buffer of the given size.
+   */
+  static std::shared_ptr<ArrayBuffer> allocate(size_t size);
+};
+
+/**
+ * Represents an `ArrayBuffer` that is allocated on the native (C++) side.
+ * It can either be "owning" or "borrowing".
+ *
+ * - Owning = the `ArrayBuffer`'s `data()` is alive as long as the `ArrayBuffer` is alive.
+ *   When this `ArrayBuffer` gets deleted, it will free the memory.
+ * - Borrowed = the `ArrayBuffer`'s `data()` might be deleted at any point from an external source (e.g. the JS garbage collector).
+ *   When this `ArrayBuffer` gets deleted, the memory will not be freed explicitly, as someone else owns it.
+ *
+ * It is safe to access `data()` and `size()` from any Thread, but there are no synchronization/mutexes implemented by default.
+ */
+class NativeArrayBuffer final : public ArrayBuffer {
+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.
+   *
+   * Once this `ArrayBuffer` goes out of scope, `deleteFunc` will be called.
+   * The caller is responsible for deleting the memory (`data`) here.
+   */
+  NativeArrayBuffer(uint8_t* NON_NULL data, size_t size, DeleteFn&& deleteFunc);
+  ~NativeArrayBuffer();
+
+public:
+  uint8_t* NON_NULL data() override;
+  size_t size() const override;
+  bool isOwner() const noexcept override;
+
+private:
+  uint8_t* NON_NULL _data;
+  size_t _size;
+  DeleteFn _deleteFunc;
+};
+
+/**
+ * Represents a JS-based `ArrayBuffer`.
+ *
+ * While it's underlying data might have been allocated on the native side (`NativeArrayBuffer`),
+ * we only have a JS reference to the `ArrayBuffer` object so it is considered a "borrowed"-resource.
+ *
+ * `data()` and `size()` can only be accessed synchronously on the JS Runtime Thread.
+ * If you want to access it elsewhere, copy the buffer first.
+ *
+ * If the JS ArrayBuffer (or it's JS Runtime) have already been deleted, `data()` returns `nullptr`.
+ */
+class JSArrayBuffer final : public ArrayBuffer {
+public:
+  explicit JSArrayBuffer(jsi::Runtime& runtime, BorrowingReference<jsi::ArrayBuffer> jsReference);
+  ~JSArrayBuffer();
+
+public:
+  /**
+   * Gets the data this `ArrayBuffer` points to, or `nullptr` if it has already been deleted.
+   */
+  uint8_t* NULLABLE data() override;
+  /**
+   * Gets the size of the data this `ArrayBuffer` points to, or `0` if it has already been deleted.
+   */
+  size_t size() const override;
+  /**
+   * Returns `false` for JS-based ArrayBuffers.
+   */
+  bool isOwner() const noexcept override;
+
+public:
+  BorrowingReference<jsi::ArrayBuffer> getJSReference() const noexcept {
+    return _jsReference;
+  }
+
+private:
+  jsi::Runtime& _runtime;
+  BorrowingReference<jsi::ArrayBuffer> _jsReference;
+  std::thread::id _initialThreadId;
+};
+
+} // namespace margelo::nitro