react-native-nitro-modules 0.31.10 → 0.32.0

package/NitroModules.podspec

@@ -48,6 +48,7 @@ Pod::Spec.new do |s|
     "cpp/utils/FastVectorCopy.hpp",
     "cpp/utils/NitroHash.hpp",
     "cpp/utils/NitroDefines.hpp",
+    "cpp/utils/PropNameIDCache.hpp",
     "cpp/views/CachedProp.hpp",
     # Public iOS-specific headers that will be exposed in modulemap (for Swift)
     "ios/core/ArrayBufferHolder.hpp",
@@ -63,7 +64,7 @@ Pod::Spec.new do |s|
   xcconfig = {
     # Use C++ 20
     "CLANG_CXX_LANGUAGE_STANDARD" => "c++20",
-    # Enables C++ <-> Swift interop (by default it's only C)
+    # Enables C++ <-> Swift interop (by default its only ObjC)
     "SWIFT_OBJC_INTEROP_MODE" => "objcxx",
     # Enables stricter modular headers
     "DEFINES_MODULE" => "YES",

package/android/build.gradle

@@ -7,7 +7,7 @@ buildscript {
   }
 
   dependencies {
-    classpath "com.android.tools.build:gradle:8.13.1"
+    classpath "com.android.tools.build:gradle:8.13.2"
   }
 }
 

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

@@ -0,0 +1,218 @@
+//
+//  JAnyMap.cpp
+//  react-native-nitro
+//
+//  Created by Marc Rousavy on 14.07.24.
+//
+
+#include "JAnyMap.hpp"
+
+namespace margelo::nitro {
+
+using namespace facebook;
+
+jni::local_ref<jni::JArrayClass<jni::JString>> JAnyMap::getAllKeys() {
+  auto& map = _map->getMap();
+  auto array = jni::JArrayClass<jni::JString>::newArray(map.size());
+  size_t index = 0;
+  for (const auto& pair : map) {
+    auto jKey = jni::make_jstring(pair.first);
+    array->setElement(index, *jKey);
+    index++;
+  }
+  return array;
+}
+
+jni::local_ref<JAnyArray> JAnyMap::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::local_ref<JAnyObject> JAnyMap::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;
+}
+
+jni::local_ref<JAnyValue::javaobject> JAnyMap::getAnyValue(const std::string& key) {
+  const auto& any = _map->getAny(key);
+  return JAnyValue::create(any);
+}
+
+void JAnyMap::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 JAnyMap::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);
+}
+void JAnyMap::setAnyValue(const std::string& key, const jni::alias_ref<JAnyValue::javaobject>& value) {
+  _map->setAny(key, value->cthis()->getValue());
+}
+
+jni::local_ref<jni::JHashMap<jni::JString, jni::JObject>> JAnyMap::toHashMap() {
+  const auto& map = _map->getMap();
+  auto javaMap = jni::JHashMap<jni::JString, jni::JObject>::create(map.size());
+  for (const auto& [key, value] : map) {
+    javaMap->put(jni::make_jstring(key), anyValueToJObject(value));
+  }
+  return javaMap;
+}
+
+jni::local_ref<jni::JObject> JAnyMap::anyValueToJObject(const AnyValue& value) {
+  if (std::holds_alternative<NullType>(value)) {
+    return nullptr;
+  } else if (std::holds_alternative<double>(value)) {
+    return jni::JDouble::valueOf(std::get<double>(value));
+  } else if (std::holds_alternative<bool>(value)) {
+    return jni::JBoolean::valueOf(std::get<bool>(value));
+  } else if (std::holds_alternative<int64_t>(value)) {
+    return jni::JLong::valueOf(std::get<int64_t>(value));
+  } else if (std::holds_alternative<std::string>(value)) {
+    return jni::make_jstring(std::get<std::string>(value));
+  } else if (std::holds_alternative<AnyArray>(value)) {
+    return jni::static_ref_cast<jni::JObject>(anyArrayToJList(std::get<AnyArray>(value)));
+  } else if (std::holds_alternative<AnyObject>(value)) {
+    return jni::static_ref_cast<jni::JObject>(anyObjectToJHashMap(std::get<AnyObject>(value)));
+  }
+  return nullptr;
+}
+
+jni::local_ref<jni::JArrayList<jni::JObject>> JAnyMap::anyArrayToJList(const AnyArray& array) {
+  auto jList = jni::JArrayList<jni::JObject>::create(static_cast<int>(array.size()));
+  for (const auto& item : array) {
+    jList->add(anyValueToJObject(item));
+  }
+  return jList;
+}
+
+jni::local_ref<jni::JHashMap<jni::JString, jni::JObject>> JAnyMap::anyObjectToJHashMap(const AnyObject& object) {
+  auto jMap = jni::JHashMap<jni::JString, jni::JObject>::create(object.size());
+  for (const auto& [key, val] : object) {
+    jMap->put(jni::make_jstring(key), anyValueToJObject(val));
+  }
+  return jMap;
+}
+
+AnyValue JAnyMap::jObjectToAnyValue(jni::alias_ref<jni::JObject> jObject) {
+  if (!jObject) {
+    return nitro::null;
+  }
+
+  // Check for Double
+  if (jObject->isInstanceOf(jni::JDouble::javaClassStatic())) {
+    auto jDouble = jni::static_ref_cast<jni::JDouble>(jObject);
+    return jDouble->doubleValue();
+  }
+
+  // Check for Float
+  if (jObject->isInstanceOf(jni::JFloat::javaClassStatic())) {
+    auto jFloat = jni::static_ref_cast<jni::JFloat>(jObject);
+    return static_cast<double>(jFloat->floatValue());
+  }
+
+  // Check for Integer
+  if (jObject->isInstanceOf(jni::JInteger::javaClassStatic())) {
+    auto jInt = jni::static_ref_cast<jni::JInteger>(jObject);
+    return static_cast<double>(jInt->intValue());
+  }
+
+  // Check for Boolean
+  if (jObject->isInstanceOf(jni::JBoolean::javaClassStatic())) {
+    auto jBool = jni::static_ref_cast<jni::JBoolean>(jObject);
+    return jBool->booleanValue();
+  }
+
+  // Check for Long (bigint)
+  if (jObject->isInstanceOf(jni::JLong::javaClassStatic())) {
+    auto jLong = jni::static_ref_cast<jni::JLong>(jObject);
+    return jLong->longValue();
+  }
+
+  // Check for String
+  if (jObject->isInstanceOf(jni::JString::javaClassStatic())) {
+    auto jString = jni::static_ref_cast<jni::JString>(jObject);
+    return jString->toStdString();
+  }
+
+  // Check for List (array)
+  if (jObject->isInstanceOf(jni::JList<jni::JObject>::javaClassStatic())) {
+    auto jList = jni::static_ref_cast<jni::JList<jni::JObject>>(jObject);
+    return jListToAnyArray(jList);
+  }
+
+  // Check for Map (object)
+  if (jObject->isInstanceOf(jni::JMap<jni::JString, jni::JObject>::javaClassStatic())) {
+    auto jMap = jni::static_ref_cast<jni::JMap<jni::JString, jni::JObject>>(jObject);
+    return jHashMapToAnyObject(jMap);
+  }
+
+  throw std::runtime_error("Cannot convert JObject to AnyValue - unsupported type!");
+}
+
+AnyArray JAnyMap::jListToAnyArray(jni::alias_ref<jni::JList<jni::JObject>> jList) {
+  AnyArray array;
+  array.reserve(jList->size());
+  for (const auto& item : *jList) {
+    array.push_back(jObjectToAnyValue(item));
+  }
+  return array;
+}
+
+AnyObject JAnyMap::jHashMapToAnyObject(jni::alias_ref<jni::JMap<jni::JString, jni::JObject>> jMap) {
+  AnyObject object;
+  object.reserve(jMap->size());
+  for (const auto& entry : *jMap) {
+    object.emplace(entry.first->toStdString(), jObjectToAnyValue(entry.second));
+  }
+  return object;
+}
+
+jni::local_ref<JAnyMap::javaobject> JAnyMap::fromMap(jni::alias_ref<jclass>, jni::alias_ref<jni::JMap<jni::JString, jni::JObject>> javaMap,
+                                                     bool ignoreIncompatible) {
+  size_t size = javaMap->size();
+  jni::local_ref<JAnyMap::javaobject> anyMap = JAnyMap::create(size);
+
+  auto& map = anyMap->cthis()->_map->getMap();
+
+  // Bulk convert all entries from Java to C++
+  for (const auto& entry : *javaMap) {
+    try {
+      std::string key = entry.first->toStdString();
+      AnyValue value = jObjectToAnyValue(entry.second);
+      map.emplace(std::move(key), std::move(value));
+    } catch (...) {
+      if (ignoreIncompatible) {
+        // encountered an incompatible key. Ignore it.
+      } else {
+        // encountered an incompatible key - we now throw!
+        throw;
+      }
+    }
+  }
+
+  return anyMap;
+}
+
+} // namespace margelo::nitro

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

@@ -41,6 +41,18 @@ public:
   static jni::local_ref<JAnyMap::javaobject> create(const std::shared_ptr<AnyMap>& map) {
     return newObjectCxxArgs(map);
   }
+  /**
+   * Create a new `JAnyMap` from the given preallocated size.
+   */
+  static jni::local_ref<JAnyMap::javaobject> create(int preallocatedSize) {
+    return newObjectCxxArgs(preallocatedSize);
+  }
+  /**
+   * Create a new empty `JAnyMap`.
+   */
+  static jni::local_ref<JAnyMap::javaobject> create() {
+    return newObjectCxxArgs();
+  }
 
 private:
   JAnyMap() {
@@ -61,17 +73,7 @@ protected:
   void clear() {
     _map->clear();
   }
-  jni::local_ref<jni::JArrayClass<jni::JString>> getAllKeys() {
-    auto& map = _map->getMap();
-    auto array = jni::JArrayClass<jni::JString>::newArray(map.size());
-    size_t index = 0;
-    for (const auto& pair : map) {
-      auto jKey = jni::make_jstring(pair.first);
-      array->setElement(index, *jKey);
-      index++;
-    }
-    return array;
-  }
+  jni::local_ref<jni::JArrayClass<jni::JString>> getAllKeys();
 
 protected:
   bool isNull(const std::string& key) {
@@ -109,29 +111,9 @@ protected:
   std::string getString(const std::string& key) {
     return _map->getString(key);
   }
-  jni::local_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::local_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;
-  }
-  jni::local_ref<JAnyValue::javaobject> getAnyValue(const std::string& key) {
-    const auto& any = _map->getAny(key);
-    return JAnyValue::create(any);
-  }
+  jni::local_ref<JAnyArray> getAnyArray(const std::string& key);
+  jni::local_ref<JAnyObject> getAnyObject(const std::string& key);
+  jni::local_ref<JAnyValue::javaobject> getAnyValue(const std::string& key);
 
 protected:
   void setNull(const std::string& key) {
@@ -149,33 +131,38 @@ protected:
   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);
-  }
-  void setAnyValue(const std::string& key, const jni::alias_ref<JAnyValue::javaobject>& value) {
-    _map->setAny(key, value->cthis()->getValue());
-  }
+  void setAnyArray(const std::string& key, jni::alias_ref<JAnyArray> value);
+  void setAnyObject(const std::string& key, const jni::alias_ref<JAnyObject>& value);
+  void setAnyValue(const std::string& key, const jni::alias_ref<JAnyValue::javaobject>& value);
 
 protected:
   void merge(jni::alias_ref<JAnyMap::javaobject> other) {
     _map->merge(other->cthis()->_map);
   }
 
+  /**
+   * Bulk-converts the entire `JAnyMap` to a Java `HashMap<String, Object>` in a single JNI call.
+   */
+  jni::local_ref<jni::JHashMap<jni::JString, jni::JObject>> toHashMap();
+
+  /**
+   * Bulk-converts a Java `Map<String, Object>` into this `JAnyMap` in a single JNI call.
+   *
+   * When `ignoreIncompatible` is `true`, this will drop keys that can't be converted.
+   * When `ignoreIncompatible` is `false`, this will throw when a key cannot be converted.
+   */
+  static jni::local_ref<JAnyMap::javaobject> fromMap(jni::alias_ref<jclass>, jni::alias_ref<jni::JMap<jni::JString, jni::JObject>> javaMap,
+                                                     bool ignoreIncompatible);
+
+private:
+  static jni::local_ref<jni::JObject> anyValueToJObject(const AnyValue& value);
+  static jni::local_ref<jni::JArrayList<jni::JObject>> anyArrayToJList(const AnyArray& array);
+  static jni::local_ref<jni::JHashMap<jni::JString, jni::JObject>> anyObjectToJHashMap(const AnyObject& object);
+
+  static AnyValue jObjectToAnyValue(jni::alias_ref<jni::JObject> jObject);
+  static AnyArray jListToAnyArray(jni::alias_ref<jni::JList<jni::JObject>> jList);
+  static AnyObject jHashMapToAnyObject(jni::alias_ref<jni::JMap<jni::JString, jni::JObject>> jMap);
+
 public:
   [[nodiscard]]
   std::shared_ptr<AnyMap> getMap() const {
@@ -225,8 +212,11 @@ public:
         makeNativeMethod("setAnyValue", JAnyMap::setAnyValue),
         // merge
         makeNativeMethod("merge", JAnyMap::merge),
+        // bulk conversion
+        makeNativeMethod("toHashMap", JAnyMap::toHashMap),
+        makeNativeMethod("fromMap", JAnyMap::fromMap),
     });
   }
 };
 
-} // namespace margelo::nitro
+} // namespace margelo::nitro

package/android/src/main/cpp/platform/NitroLogger.cpp

@@ -26,7 +26,9 @@ int levelToAndroidLevel(LogLevel level) {
   }
 }
 
-void Logger::nativeLog([[maybe_unused]] LogLevel level, [[maybe_unused]] const char* tag, [[maybe_unused]] const std::string& message) {
+void Logger::nativeLog([[maybe_unused]] LogLevel level,  //
+                       [[maybe_unused]] const char* tag, //
+                       [[maybe_unused]] const std::string& message) {
 #ifdef NITRO_DEBUG
   int logLevel = levelToAndroidLevel(level);
   std::string combinedTag = "Nitro." + std::string(tag);

package/android/src/main/java/com/margelo/nitro/core/AnyMap.kt

@@ -39,33 +39,26 @@ class AnyMap {
   }
 
   companion object {
-    fun fromMap(
+    /**
+     * Converts the given [map] to a new [AnyMap].
+     * @param map The map of keys/value types. Only a number of value types
+     * are supported in [AnyMap] - see Nitro docs for more information.
+     * @param ignoreIncompatible Whether to throw when an incompatible
+     * type is found, or not. If this is `false`, all incompatible key/value
+     * pairs will just be ignored.
+     */
+    @JvmStatic
+    external fun fromMap(
       map: Map<String, Any?>,
-      ignoreIncompatible: Boolean = false,
-    ): AnyMap {
-      val anyMap = AnyMap(map.size)
-      for ((key, value) in map) {
-        try {
-          anyMap.setAny(key, value)
-        } catch (error: Throwable) {
-          if (ignoreIncompatible) {
-            continue
-          } else {
-            throw error
-          }
-        }
-      }
-      return anyMap
-    }
+      ignoreIncompatible: Boolean,
+    ): AnyMap
   }
 
-  fun toMap(): Map<String, Any?> {
-    val map = HashMap<String, Any?>()
-    for (key in getAllKeys()) {
-      map.put(key, getAny(key))
-    }
-    return map
-  }
+  /**
+   * Converts this [AnyMap] to a new [HashMap] by
+   * copying each key/value.
+   */
+  external fun toHashMap(): HashMap<String, Any?>
 
   fun setAny(
     key: String,
@@ -78,6 +71,11 @@ class AnyMap {
     return getAnyValue(key).toAny()
   }
 
+  private external fun fromHashMap(
+    map: Map<String, Any?>,
+    ignoreIncompatible: Boolean,
+  )
+
   @FastNative
   external fun contains(key: String): Boolean
 

package/android/src/main/java/com/margelo/nitro/core/ArrayBuffer.kt

@@ -43,7 +43,7 @@ class ArrayBuffer {
    * - If the `ArrayBuffer` holds a `ByteBuffer`, `getBuffer(false)` can safely be called to
    * get shared access to the underlying data, without performing any copies.
    * - If the `ArrayBuffer` doesn't hold a `ByteBuffer`, it can still be accessed via `getBuffer(false)`,
-   * but the returned `ByteBuffer` is only valid as long as it's parent `ArrayBuffer` is alive.
+   * but the returned `ByteBuffer` is only valid as long as its parent `ArrayBuffer` is alive.
    */
   val isByteBuffer: Boolean
     get() = getIsByteBuffer()
@@ -104,7 +104,7 @@ class ArrayBuffer {
         // The ByteBuffer is 1:1 mapped to a byte array - return as is!
         return array
       }
-      // we had a CPU-backed array, but it's size differs from our ArrayBuffer size.
+      // we had a CPU-backed array, but its size differs from our ArrayBuffer size.
       // This might be because the ArrayBuffer has a smaller view of the data, so we need
       // to resort back to a good ol' copy.
     }

package/android/src/main/java/com/margelo/nitro/core/HybridObject.kt

@@ -35,7 +35,7 @@ abstract class HybridObject {
    * Eagerly- (and manually-) dispose all native resources this `HybridObject` holds.
    * This method can only be manually called from JS using `dispose()`.
    *
-   * If this method is never manually called, a `HybridObject` is expected to disposes it's
+   * If this method is never manually called, a `HybridObject` is expected to disposes its
    * resources as usual via the object's destructor (`~HybridObject()`, `deinit` or `finalize()`).
    *
    * By default, this method does nothing. It can be overridden to perform actual disposing/cleanup
@@ -58,13 +58,13 @@ abstract class HybridObject {
 
   /**
    * Holds the native C++ instance.
-   * In `HybridObject`, the C++ instance is a sub-class of `JHybridObject`, such as one of it's specs.
+   * In `HybridObject`, the C++ instance is a sub-class of `JHybridObject`, such as one of its specs.
    * This is `null`, until `updateNative(..)` is called.
    */
   private var mHybridData: HybridData? = null
 
   /**
-   * If `HybridObject` is subclassed, the sub-class needs to create it's own `HybridData`
+   * If `HybridObject` is subclassed, the sub-class needs to create its own `HybridData`
    * with a C++ `jni::HybridClass` representing the subclass directly.
    * Then, that `HybridData` must be passed upwards to `HybridObject` using `updateNative(..)`.
    *

package/cpp/core/AnyMap.cpp

@@ -189,7 +189,7 @@ void AnyMap::setAny(const std::string& key, const AnyValue& value) {
 }
 
 // C++ getter
-const std::unordered_map<std::string, AnyValue>& AnyMap::getMap() const {
+std::unordered_map<std::string, AnyValue>& AnyMap::getMap() {
   return _map;
 }
 

package/cpp/core/AnyMap.hpp

@@ -38,8 +38,8 @@ struct AnyValue : VariantType {
  */
 class AnyMap final {
 private:
-  explicit AnyMap() {}
-  AnyMap(size_t size) {
+  AnyMap() = default;
+  explicit AnyMap(size_t size) {
     _map.reserve(size);
   }
 
@@ -201,7 +201,7 @@ public:
   /**
    * Get the actual C++ map that holds all keys and variant values.
    */
-  const std::unordered_map<std::string, AnyValue>& getMap() const;
+  std::unordered_map<std::string, AnyValue>& getMap();
 
 public:
   /**

package/cpp/core/ArrayBuffer.hpp

@@ -28,7 +28,7 @@ using DeleteFn = std::function<void()>;
  * - `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.
+ * Also, an `ArrayBuffer` can either own its memory, or just borrow its 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).
@@ -116,13 +116,13 @@ private:
 /**
  * Represents a JS-based `ArrayBuffer`.
  *
- * While it's underlying data might have been allocated on the native side (`NativeArrayBuffer`),
+ * While its 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`.
+ * If the JS ArrayBuffer (or its JS Runtime) have already been deleted, `data()` returns `nullptr`.
  */
 class JSArrayBuffer final : public ArrayBuffer {
 public:

package/cpp/core/HybridObject.cpp

@@ -3,9 +3,9 @@
 //
 
 #include "HybridObject.hpp"
+#include "CommonGlobals.hpp"
 #include "JSIConverter.hpp"
 #include "NitroDefines.hpp"
-#include "ObjectUtils.hpp"
 
 namespace margelo::nitro {
 
@@ -75,7 +75,7 @@ jsi::Value HybridObject::toObject(jsi::Runtime& runtime) {
   jsi::Value prototype = getPrototype(runtime);
 
   // 3. Create the object using Object.create(...)
-  jsi::Object object = ObjectUtils::create(runtime, prototype);
+  jsi::Object object = CommonGlobals::Object::create(runtime, prototype);
 
   // 4. Assign NativeState to the object so the prototype can resolve the native methods
   object.setNativeState(runtime, shared());
@@ -86,14 +86,14 @@ jsi::Value HybridObject::toObject(jsi::Runtime& runtime) {
 #ifdef NITRO_DEBUG
   // 6. Assign a private __type property for debugging - this will be used so users know it's not just an empty object.
   std::string typeName = "HybridObject<" + std::string(_name) + ">";
-  ObjectUtils::defineProperty(runtime, object, "__type",
-                              PlainPropertyDescriptor{
-                                  // .configurable has to be true because this property is non-frozen
-                                  .configurable = true,
-                                  .enumerable = true,
-                                  .value = jsi::String::createFromUtf8(runtime, typeName),
-                                  .writable = false,
-                              });
+  CommonGlobals::Object::defineProperty(runtime, object, "__type",
+                                        PlainPropertyDescriptor{
+                                            // .configurable has to be true because this property is non-frozen
+                                            .configurable = true,
+                                            .enumerable = true,
+                                            .value = jsi::String::createFromUtf8(runtime, typeName),
+                                            .writable = false,
+                                        });
 #endif
 
   // 7. Throw a jsi::WeakObject pointing to our object into cache so subsequent calls can use it from cache

package/cpp/core/HybridObject.hpp

@@ -60,14 +60,14 @@ public:
   /**
    * Return the `jsi::Object` that holds this `HybridObject`. (boxed in a `jsi::Value`)
    * This properly assigns (or creates) the base prototype for this type,
-   * and assigns it's NativeState.
+   * and assigns its NativeState.
    * Additionally, this sets the external memory pressure for proper GC memory management.
    */
   jsi::Value toObject(jsi::Runtime& runtime);
 
 public:
   /**
-   * Get the `std::shared_ptr` instance of this HybridObject as it's concrete type.
+   * Get the `std::shared_ptr` instance of this HybridObject as its concrete type.
    * The HybridObject must be managed inside a `shared_ptr` already, otherwise this will fail.
    */
   template <typename Derived>
@@ -99,7 +99,7 @@ public:
    * Eagerly- (and manually-) dispose all native resources this `HybridObject` holds.
    * This method can only be manually called from JS using `dispose()`.
    *
-   * If this method is never manually called, a `HybridObject` is expected to disposes it's
+   * If this method is never manually called, a `HybridObject` is expected to disposes its
    * resources as usual via the object's destructor (`~HybridObject()`, `deinit` or `finalize()`).
    *
    * By default, this method does nothing. It can be overridden to perform actual disposing/cleanup

package/cpp/entrypoint/HybridNitroModulesProxy.cpp

@@ -71,7 +71,7 @@ jsi::Value HybridNitroModulesProxy::isHybridObject(jsi::Runtime& runtime, const
 }
 
 std::shared_ptr<HybridObject> HybridNitroModulesProxy::updateMemorySize(const std::shared_ptr<HybridObject>& hybridObject) {
-  // If a hybridObject goes from Native -> JS, it will update it's memory size internally (in `HybridObject::toObject(..)`).
+  // If a hybridObject goes from Native -> JS, it will update its memory size internally (in `HybridObject::toObject(..)`).
   // This is all that function does.
   return hybridObject;
 }

package/cpp/entrypoint/InstallNitro.cpp

@@ -6,8 +6,8 @@
 //
 
 #include "InstallNitro.hpp"
+#include "CommonGlobals.hpp"
 #include "HybridNitroModulesProxy.hpp"
-#include "ObjectUtils.hpp"
 
 namespace margelo::nitro {
 
@@ -23,7 +23,7 @@ void install(jsi::Runtime& runtime, std::shared_ptr<Dispatcher> dispatcher) {
 void install(jsi::Runtime& runtime) {
   // Installs global.NitroModulesProxy
   auto proxy = std::make_shared<HybridNitroModulesProxy>();
-  ObjectUtils::defineGlobal(runtime, KnownGlobalPropertyName::NITRO_MODULES_PROXY, proxy->toObject(runtime));
+  CommonGlobals::defineGlobal(runtime, KnownGlobalPropertyName::NITRO_MODULES_PROXY, proxy->toObject(runtime));
 }
 
 } // namespace margelo::nitro