react-native-nitro-modules 0.5.0 → 0.7.0

package/NitroModules.podspec

@@ -13,7 +13,7 @@ Pod::Spec.new do |s|
   s.authors      = package["author"]
 
   s.platforms    = { :ios => min_ios_version_supported }
-  s.source       = { :git => "https://github.com/mrousavy/react-native-nitro.git", :tag => "#{s.version}" }
+  s.source       = { :git => "https://github.com/mrousavy/nitro.git", :tag => "#{s.version}" }
 
   # VisionCamera Core C++ bindings
   s.source_files = [
@@ -39,7 +39,9 @@ Pod::Spec.new do |s|
     # Public iOS-specific headers that will be exposed in modulemap (for Swift)
     "ios/core/ArrayBufferHolder.hpp",
     "ios/core/PromiseHolder.hpp",
+    "ios/core/AnyMapHolder.hpp",
     "ios/core/HybridContext.hpp",
+    "ios/utils/SwiftClosure.hpp",
   ]
 
   s.pod_target_xcconfig = {

package/README.md

@@ -1,8 +1,8 @@
 <a href="https://margelo.io">
   <picture>
-    <source media="(prefers-color-scheme: dark)" srcset="../../docs/img/banner-react-native-nitro-modules-dark.png" />
-    <source media="(prefers-color-scheme: light)" srcset="../../docs/img/banner-react-native-nitro-modules-light.png" />
-    <img alt="Nitrogen" src="../../docs/img/banner-react-native-nitro-modules-light.png" />
+    <source media="(prefers-color-scheme: dark)" srcset="../../docs/static/img/banner-react-native-nitro-modules-dark.png" />
+    <source media="(prefers-color-scheme: light)" srcset="../../docs/static/img/banner-react-native-nitro-modules-light.png" />
+    <img alt="Nitrogen" src="../../docs/static/img/banner-react-native-nitro-modules-light.png" />
   </picture>
 </a>
 
@@ -112,97 +112,116 @@ The following C++ / JS types are supported out of the box:
     <th>JS Type</th>
     <th>C++ Type</th>
     <th>Swift Type</th>
+    <th>Kotlin Type</th>
   </tr>
 
   <tr>
     <td><code>number</code></td>
     <td><code>double</code> / <code>int</code> / <code>float</code></td>
-    <td><code>Double</code> / <code>Int</code> / <code>Float</code></td>
+    <td><code>Double</code></td>
+    <td><code>Double</code></td>
   </tr>
   <tr>
     <td><code>boolean</code></td>
     <td><code>bool</code></td>
     <td><code>Bool</code></td>
+    <td><code>Boolean</code></td>
   </tr>
   <tr>
     <td><code>string</code></td>
     <td><code>std::string</code></td>
     <td><code>String</code></td>
+    <td><code>String</code></td>
   </tr>
   <tr>
     <td><code>bigint</code></td>
     <td><code>int64_t</code> / <code>uint64_t</code></td>
-    <td><code>Int64</code> / <code>UInt64</code></td>
+    <td><code>Int64</code></td>
+    <td><code>Long</code></td>
   </tr>
   <tr>
     <td><code>T[]</code></td>
     <td><code>std::vector&lt;T&gt;</code></td>
     <td><code>[T]</code></td>
+    <td><code>Array&lt;T&gt;</code> / <code>PrimitiveArray</code></td>
   </tr>
   <tr>
     <td><code>[A, B, C, ...]</code></td>
     <td><code>std::tuple&lt;A, B, C, ...&gt;</code></td>
-    <td><code>(A, B, C)</code></td>
+    <td><code>(A, B, C)</code> 🟡  (<a href="https://github.com/mrousavy/nitro/issues/38">#38</a>)</td>
+    <td>❌</td>
   </tr>
   <tr>
     <td><code>A | B | C | ...</code></td>
     <td><code>std::variant&lt;A, B, C, ...&gt;</code></td>
-    <td><code>Variant_A_B_C</code></td>
+    <td><code>Variant_A_B_C</code> 🟡  (<a href="https://github.com/mrousavy/nitro/issues/39">#39</a>)</td>
+    <td>❌</td>
   </tr>
   <tr>
     <td><code>Record&lt;string, T&gt;</code></td>
     <td><code>std::unordered_map&lt;std::string, T&gt;</code></td>
     <td><code>Dictionary&lt;String, T&gt;</code></td>
+    <td><code>Map&lt;std::string, T&gt;</code></td>
   </tr>
   <tr>
     <td><code>T?</code></td>
     <td><code>std::optional&lt;T&gt;</code></td>
     <td><code>T?</code></td>
+    <td><code>T?</code></td>
   </tr>
   <tr>
     <td><code>Promise&lt;T&gt;</code></td>
     <td><code>std::future&lt;T&gt;</code></td>
     <td><code><a href="./ios/core/Promise.swift">Promise&lt;T&gt;</a></code></td>
+    <td><code><a href="./android/src/main/java/com/margelo/nitro/core/Promise.kt">Promise&lt;T&gt;</a></code></td>
   </tr>
   <tr>
-    <td><code>(TArgs...) =&gt; void</code></td>
-    <td><code>std::function&lt;void (TArgs...)&gt;</code></td>
-    <td><code>@escaping (TArgs...) -&gt; Void</code></td>
+    <td><code>(T...) =&gt; void</code></td>
+    <td><code>std::function&lt;void (T...)&gt;</code></td>
+    <td><code>@escaping (T...) -&gt; Void</code></td>
+    <td><code>(T...) -&gt; Unit</code></td>
   </tr>
   <tr>
-    <td><code>(TArgs...) =&gt; TReturn</code></td>
-    <td><code>std::function&lt;std::future&lt;TReturn&gt; (TArgs...)&gt;</code></td>
+    <td><code>(T...) =&gt; R</code></td>
+    <td><code>std::function&lt;std::future&lt;R&gt; (T...)&gt;</code></td>
+    <td>❌</td>
     <td>❌</td>
   </tr>
   <tr>
     <td><code>{ ... }</code></td>
     <td><code>std::shared_ptr&lt;<a href="./cpp/core/AnyMap.hpp">AnyMap</a>&gt;</code></td>
-    <td>❌</td>
+    <td><code><a href="./ios/core/AnyMapHolder.swift">AnyMapHolder</a></code> 🟡  (<a href="https://github.com/mrousavy/nitro/issues/57">#57</a>)</td>
+    <td><code><a href="./android/src/main/java/com/margelo/nitro/core/AnyMap.kt">AnyMap</a></code></td>
   </tr>
   <tr>
     <td><code>ArrayBuffer</code></td>
     <td><code>std::shared_ptr&lt;<a href="./cpp/core/ArrayBuffer.hpp">ArrayBuffer</a>&gt;</code></td>
-    <td><code><a href="./ios/core/ArrayBufferHolder.hpp">ArrayBufferHolder</a></code></td>
+    <td><code><a href="./ios/core/ArrayBufferHolder.swift">ArrayBufferHolder</a></code></td>
+    <td><code><a href="./android/src/main/java/com/margelo/nitro/core/ArrayBuffer.kt">ArrayBuffer</a></code></td>
   </tr>
   <tr>
     <td>..any <code><a href="./src/HybridObject.ts">HybridObject</a></code></td>
     <td><code>std::shared_ptr&lt;<a href="./cpp/core/HybridObject.hpp">HybridObject</a>&gt;</code></td>
     <td><code><a href="./ios/core/HybridObjectSpec.swift">HybridObjectSpec</a></code></td>
+    <td><code><a href="./android/core/HybridObject.kt">HybridObject</a></code></td>
   </tr>
   <tr>
     <td>..any <code>interface</code></td>
     <td><code>T</code></td>
     <td><code>T</code></td>
+    <td><code>T</code></td>
   </tr>
   <tr>
     <td>..any <code>enum</code></td>
     <td><code>T</code></td>
     <td><code>T</code></td>
+    <td><code>T</code></td>
   </tr>
   <tr>
     <td>..any <code>union</code></td>
     <td><code>T</code></td>
     <td><code>T</code></td>
+    <td><code>T</code></td>
   </tr>
 </table>
 

package/android/gradle.properties

@@ -1,5 +1,5 @@
-Nitro_kotlinVersion=1.7.0
-Nitro_minSdkVersion=21
-Nitro_targetSdkVersion=31
-Nitro_compileSdkVersion=31
-Nitro_ndkVersion=21.4.7075529
+Nitro_kotlinVersion=1.9.24
+Nitro_minSdkVersion=23
+Nitro_targetSdkVersion=34
+Nitro_compileSdkVersion=34
+Nitro_ndkVersion=26.1.10909125

package/android/src/main/cpp/JNIOnLoad.cpp

@@ -1,6 +1,10 @@
 /// Entry point for JNI.
 
+#include "JAnyMap.hpp"
+#include "JAnyValue.hpp"
+#include "JArrayBuffer.hpp"
 #include "JHybridObjectRegistry.hpp"
+#include "JPromise.hpp"
 #include "RegisterNativeNitroModules.hpp"
 #include <fbjni/fbjni.h>
 #include <jni.h>
@@ -14,5 +18,9 @@ JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
 
     // 2. Initialize all Java bindings
     JHybridObjectRegistry::registerNatives();
+    JArrayBuffer::registerNatives();
+    JAnyMap::registerNatives();
+    JAnyValue::registerNatives();
+    JPromise::registerNatives();
   });
 }

package/android/src/main/cpp/core/ByteBufferArrayBuffer.hpp

@@ -0,0 +1,47 @@
+//
+//  ByteBufferArrayBuffer.hpp
+//  react-native-nitro
+//
+//  Created by Marc Rousavy on 14.07.24.
+//
+
+#pragma once
+
+#include "ArrayBuffer.hpp"
+#include <fbjni/ByteBuffer.h>
+#include <fbjni/fbjni.h>
+
+namespace margelo::nitro {
+
+using namespace facebook;
+
+/**
+ * Represents an `ArrayBuffer` that holds a `ByteBuffer`.
+ */
+class ByteBufferArrayBuffer final : public ArrayBuffer {
+public:
+  explicit ByteBufferArrayBuffer(const jni::alias_ref<jni::JByteBuffer>& byteBuffer) : _byteBuffer(jni::make_global(byteBuffer)) {
+    _byteBuffer->order(jni::JByteOrder::bigEndian());
+  }
+
+public:
+  [[nodiscard]] uint8_t* data() override {
+    return _byteBuffer->getDirectBytes();
+  }
+  [[nodiscard]] size_t size() const override {
+    return _byteBuffer->getDirectSize();
+  }
+  [[nodiscard]] bool isOwner() const noexcept override {
+    return _byteBuffer != nullptr && _byteBuffer->isDirect();
+  }
+
+public:
+  [[nodiscard]] jni::alias_ref<jni::JByteBuffer> getBuffer() const {
+    return _byteBuffer;
+  }
+
+private:
+  jni::global_ref<jni::JByteBuffer> _byteBuffer;
+};
+
+} // namespace margelo::nitro

package/android/src/main/cpp/core/JAnyMap.hpp

@@ -0,0 +1,193 @@
+//
+//  JAnyMap.hpp
+//  react-native-nitro
+//
+//  Created by Marc Rousavy on 14.07.24.
+//
+
+#pragma once
+
+#include "AnyMap.hpp"
+#include "JAnyValue.hpp"
+#include <fbjni/fbjni.h>
+
+namespace margelo::nitro {
+
+using namespace facebook;
+
+/**
+ * Represents an `AnyMap` implemented in Java.
+ */
+class JAnyMap final : public jni::HybridClass<JAnyMap> {
+public:
+  static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/core/AnyMap;";
+
+public:
+  /**
+   * Create a new, empty `AnyMap` from Java.
+   */
+  static jni::local_ref<JAnyMap::jhybriddata> initHybrid(jni::alias_ref<jhybridobject>) {
+    return makeCxxInstance();
+  }
+  /**
+   * Create a new `JAnyMap` from an existing `AnyMap`.
+   */
+  static jni::local_ref<JAnyMap::javaobject> create(const std::shared_ptr<AnyMap>& map) {
+    return newObjectCxxArgs(map);
+  }
+
+private:
+  JAnyMap() {
+    _map = std::make_shared<AnyMap>();
+  }
+  JAnyMap(const std::shared_ptr<AnyMap>& map) : _map(map) {}
+
+protected:
+  bool contains(const std::string& key) {
+    return _map->contains(key);
+  }
+  void remove(const std::string& key) {
+    _map->remove(key);
+  }
+  void clear() {
+    _map->clear();
+  }
+
+protected:
+  bool isNull(const std::string& key) {
+    return _map->isNull(key);
+  }
+  bool isDouble(const std::string& key) {
+    return _map->isDouble(key);
+  }
+  bool isBoolean(const std::string& key) {
+    return _map->isBoolean(key);
+  }
+  bool isBigInt(const std::string& key) {
+    return _map->isBigInt(key);
+  }
+  bool isString(const std::string& key) {
+    return _map->isString(key);
+  }
+  bool isArray(const std::string& key) {
+    return _map->isArray(key);
+  }
+  bool isObject(const std::string& key) {
+    return _map->isObject(key);
+  }
+
+protected:
+  double getDouble(const std::string& key) {
+    return _map->getDouble(key);
+  }
+  bool getBoolean(const std::string& key) {
+    return _map->getBoolean(key);
+  }
+  int64_t getBigInt(const std::string& key) {
+    return _map->getBigInt(key);
+  }
+  std::string getString(const std::string& key) {
+    return _map->getString(key);
+  }
+  jni::alias_ref<JAnyArray> getAnyArray(const std::string& key) {
+    const auto& vector = _map->getArray(key);
+    auto javaArray = jni::JArrayClass<JAnyValue::javaobject>::newArray(vector.size());
+    for (size_t i = 0; i < vector.size(); i++) {
+      auto value = JAnyValue::create(vector[i]);
+      javaArray->setElement(i, value.get());
+    }
+    return javaArray;
+  }
+  jni::alias_ref<JAnyObject> getAnyObject(const std::string& key) {
+    const auto& map = _map->getObject(key);
+    auto javaMap = jni::JHashMap<jni::JString, JAnyValue::javaobject>::create(map.size());
+    for (const auto& entry : map) {
+      auto string = jni::make_jstring(entry.first);
+      auto value = JAnyValue::create(entry.second);
+      javaMap->put(string, value);
+    }
+    return javaMap;
+  }
+
+protected:
+  void setNull(const std::string& key) {
+    _map->setNull(key);
+  }
+  void setDouble(const std::string& key, double value) {
+    _map->setDouble(key, value);
+  }
+  void setBoolean(const std::string& key, bool value) {
+    _map->setBoolean(key, value);
+  }
+  void setBigInt(const std::string& key, int64_t value) {
+    _map->setBigInt(key, value);
+  }
+  void setString(const std::string& key, const std::string& value) {
+    _map->setString(key, value);
+  }
+  void setAnyArray(const std::string& key, jni::alias_ref<JAnyArray> value) {
+    std::vector<AnyValue> vector;
+    size_t size = value->size();
+    vector.reserve(size);
+    for (size_t i = 0; i < size; i++) {
+      auto anyValue = value->getElement(i);
+      vector.push_back(anyValue->cthis()->getValue());
+    }
+    _map->setArray(key, vector);
+  }
+  void setAnyObject(const std::string& key, const jni::alias_ref<JAnyObject>& value) {
+    std::unordered_map<std::string, AnyValue> map;
+    map.reserve(value->size());
+    for (const auto& entry : *value) {
+      map.emplace(entry.first->toStdString(), entry.second->cthis()->getValue());
+    }
+    _map->setObject(key, map);
+  }
+
+public:
+  std::shared_ptr<AnyMap> getMap() const {
+    return _map;
+  }
+
+private:
+  friend HybridBase;
+  using HybridBase::HybridBase;
+  std::shared_ptr<AnyMap> _map;
+
+public:
+  static void registerNatives() {
+    registerHybrid({
+        // init
+        makeNativeMethod("initHybrid", JAnyMap::initHybrid),
+        // helpers
+        makeNativeMethod("contains", JAnyMap::contains),
+        makeNativeMethod("remove", JAnyMap::remove),
+        makeNativeMethod("clear", JAnyMap::clear),
+        // is
+        makeNativeMethod("isNull", JAnyMap::isNull),
+        makeNativeMethod("isDouble", JAnyMap::isDouble),
+        makeNativeMethod("isBoolean", JAnyMap::isBoolean),
+        makeNativeMethod("isBigInt", JAnyMap::isBigInt),
+        makeNativeMethod("isString", JAnyMap::isString),
+        makeNativeMethod("isArray", JAnyMap::isArray),
+        makeNativeMethod("isObject", JAnyMap::isObject),
+        // get
+        makeNativeMethod("getDouble", JAnyMap::getDouble),
+        makeNativeMethod("getBoolean", JAnyMap::getBoolean),
+        makeNativeMethod("getBigInt", JAnyMap::getBigInt),
+        makeNativeMethod("getString", JAnyMap::getString),
+        makeNativeMethod("getAnyArray", JAnyMap::getAnyArray),
+        makeNativeMethod("getAnyObject", JAnyMap::getAnyObject),
+        // set
+        makeNativeMethod("setNull", JAnyMap::setNull),
+        makeNativeMethod("setDouble", JAnyMap::setDouble),
+        makeNativeMethod("setBoolean", JAnyMap::setBoolean),
+        makeNativeMethod("setBigInt", JAnyMap::setBigInt),
+        makeNativeMethod("setString", JAnyMap::setString),
+        makeNativeMethod("setAnyArray", JAnyMap::setAnyArray),
+        makeNativeMethod("setAnyObject", JAnyMap::setAnyObject),
+    });
+  }
+};
+
+} // namespace margelo::nitro

package/android/src/main/cpp/core/JAnyValue.hpp

@@ -0,0 +1,191 @@
+//
+//  JAnyMap.hpp
+//  react-native-nitro
+//
+//  Created by Marc Rousavy on 14.07.24.
+//
+
+#pragma once
+
+#include "AnyMap.hpp"
+#include <fbjni/fbjni.h>
+
+namespace margelo::nitro {
+
+using namespace facebook;
+
+/**
+ * Represents an `AnyValue` (variant) implemented in Java.
+ */
+class JAnyValue final : public jni::HybridClass<JAnyValue> {
+public:
+  static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/core/AnyValue;";
+
+  /**
+   * Represents an `Array<AnyValue>`
+   */
+  using JAnyArray = jni::JArrayClass<JAnyValue::javaobject>;
+  /**
+   * Represents a `Map<String, AnyValue>`
+   */
+  using JAnyObject = jni::JMap<jni::JString, JAnyValue::javaobject>;
+
+public:
+  /**
+   * Create a new `JAnyValue` from an existing `AnyValue`.
+   */
+  static jni::local_ref<JAnyValue::javaobject> create(AnyValue&& value) {
+    return newObjectCxxArgs(std::move(value));
+  }
+  static jni::local_ref<JAnyValue::javaobject> create(const AnyValue& value) {
+    return newObjectCxxArgs(value);
+  }
+
+protected:
+  static jni::local_ref<JAnyValue::jhybriddata> initHybridNull(jni::alias_ref<jhybridobject>) {
+    return makeCxxInstance(/* null */);
+  }
+  static jni::local_ref<JAnyValue::jhybriddata> initHybridDouble(jni::alias_ref<jhybridobject>, double value) {
+    return makeCxxInstance(value);
+  }
+  static jni::local_ref<JAnyValue::jhybriddata> initHybridBoolean(jni::alias_ref<jhybridobject>, bool value) {
+    return makeCxxInstance(value);
+  }
+  static jni::local_ref<JAnyValue::jhybriddata> initHybridLong(jni::alias_ref<jhybridobject>, int64_t value) {
+    return makeCxxInstance(value);
+  }
+  static jni::local_ref<JAnyValue::jhybriddata> initHybridString(jni::alias_ref<jhybridobject>, const std::string& value) {
+    return makeCxxInstance(value);
+  }
+  static jni::local_ref<JAnyValue::jhybriddata> initHybridAnyArray(jni::alias_ref<jhybridobject>, jni::alias_ref<JAnyArray> value) {
+    std::vector<AnyValue> vector;
+    size_t size = value->size();
+    vector.reserve(size);
+    for (size_t i = 0; i < size; i++) {
+      auto anyValue = value->getElement(i);
+      vector.push_back(anyValue->cthis()->getValue());
+    }
+    return makeCxxInstance(std::move(vector));
+  }
+  static jni::local_ref<JAnyValue::jhybriddata> initHybridAnyObject(jni::alias_ref<jhybridobject>, jni::alias_ref<JAnyObject> value) {
+    std::unordered_map<std::string, AnyValue> map;
+    map.reserve(value->size());
+    for (const auto& entry : *value) {
+      map.emplace(entry.first->toStdString(), entry.second->cthis()->getValue());
+    }
+    return makeCxxInstance(std::move(map));
+  }
+
+private:
+  // Java initializers
+  explicit JAnyValue(/* null */) : _value(std::monostate()) {}
+  explicit JAnyValue(double value) : _value(value) {}
+  explicit JAnyValue(bool value) : _value(value) {}
+  explicit JAnyValue(int64_t value) : _value(value) {}
+  explicit JAnyValue(const std::string& value) : _value(value) {}
+  explicit JAnyValue(AnyArray&& value) : _value(std::move(value)) {}
+  explicit JAnyValue(AnyObject&& value) : _value(std::move(value)) {}
+  // C++ initializers
+  explicit JAnyValue(const AnyValue& value) : _value(value) {}
+  explicit JAnyValue(AnyValue&& value) : _value(std::move(value)) {}
+
+protected:
+  bool isNull() {
+    return std::holds_alternative<std::monostate>(_value);
+  }
+  bool isDouble() {
+    return std::holds_alternative<double>(_value);
+  }
+  bool isBoolean() {
+    return std::holds_alternative<bool>(_value);
+  }
+  bool isBigInt() {
+    return std::holds_alternative<int64_t>(_value);
+  }
+  bool isString() {
+    return std::holds_alternative<std::string>(_value);
+  }
+  bool isAnyArray() {
+    return std::holds_alternative<AnyArray>(_value);
+  }
+  bool isAnyObject() {
+    return std::holds_alternative<AnyObject>(_value);
+  }
+
+protected:
+  double asDouble() {
+    return std::get<double>(_value);
+  }
+  bool asBoolean() {
+    return std::get<bool>(_value);
+  }
+  int64_t asBigInt() {
+    return std::get<int64_t>(_value);
+  }
+  std::string asString() {
+    return std::get<std::string>(_value);
+  }
+  jni::alias_ref<JAnyArray> asAnyArray() {
+    auto vector = std::get<AnyArray>(_value);
+    auto javaArray = jni::JArrayClass<JAnyValue::javaobject>::newArray(vector.size());
+    for (size_t i = 0; i < vector.size(); i++) {
+      auto value = JAnyValue::create(vector[i]);
+      javaArray->setElement(i, value.get());
+    }
+    return javaArray;
+  }
+  jni::alias_ref<JAnyObject> asAnyObject() {
+    auto map = std::get<AnyObject>(_value);
+    auto javaMap = jni::JHashMap<jni::JString, JAnyValue::javaobject>::create(map.size());
+    for (const auto& entry : map) {
+      auto key = jni::make_jstring(entry.first);
+      auto value = JAnyValue::create(entry.second);
+      javaMap->put(key, value);
+    }
+    return javaMap;
+  }
+
+public:
+  [[nodiscard]] const AnyValue& getValue() const noexcept {
+    return _value;
+  }
+
+private:
+  friend HybridBase;
+  using HybridBase::HybridBase;
+  AnyValue _value;
+
+public:
+  static void registerNatives() {
+    registerHybrid({
+        // init
+        makeNativeMethod("initHybrid", JAnyValue::initHybridNull),
+        makeNativeMethod("initHybrid", JAnyValue::initHybridDouble),
+        makeNativeMethod("initHybrid", JAnyValue::initHybridBoolean),
+        makeNativeMethod("initHybrid", JAnyValue::initHybridLong),
+        makeNativeMethod("initHybrid", JAnyValue::initHybridString),
+        makeNativeMethod("initHybrid", JAnyValue::initHybridAnyArray),
+        makeNativeMethod("initHybrid", JAnyValue::initHybridAnyObject),
+        // is
+        makeNativeMethod("isNull", JAnyValue::isNull),
+        makeNativeMethod("isDouble", JAnyValue::isDouble),
+        makeNativeMethod("isBoolean", JAnyValue::isBoolean),
+        makeNativeMethod("isBigInt", JAnyValue::isBigInt),
+        makeNativeMethod("isString", JAnyValue::isString),
+        makeNativeMethod("isAnyArray", JAnyValue::isAnyArray),
+        makeNativeMethod("isAnyObject", JAnyValue::isAnyObject),
+        // get
+        makeNativeMethod("asDouble", JAnyValue::asDouble),
+        makeNativeMethod("asBoolean", JAnyValue::asBoolean),
+        makeNativeMethod("asBigInt", JAnyValue::asBigInt),
+        makeNativeMethod("asString", JAnyValue::asString),
+        makeNativeMethod("asAnyArray", JAnyValue::asAnyArray),
+        makeNativeMethod("asAnyObject", JAnyValue::asAnyObject),
+    });
+  }
+};
+
+using JAnyArray = JAnyValue::JAnyArray;
+using JAnyObject = JAnyValue::JAnyObject;
+
+} // namespace margelo::nitro