react-native-nitro-modules 0.31.9 → 0.32.0-beta.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",

package/android/build.gradle

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

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

@@ -0,0 +1,120 @@
+//
+//  JAnyMap.cpp
+//  react-native-nitro
+//
+//  Created by Marc Rousavy on 14.07.24.
+//
+
+#pragma once
+
+#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;
+}
+
+} // namespace margelo::nitro

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

@@ -61,17 +61,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 +99,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 +119,25 @@ 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();
+
+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);
+
 public:
   [[nodiscard]]
   std::shared_ptr<AnyMap> getMap() const {
@@ -225,8 +187,10 @@ public:
         makeNativeMethod("setAnyValue", JAnyMap::setAnyValue),
         // merge
         makeNativeMethod("merge", JAnyMap::merge),
+        // bulk conversion
+        makeNativeMethod("toHashMap", JAnyMap::toHashMap),
     });
   }
 };
 
-} // 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,21 +39,28 @@ class AnyMap {
   }
 
   companion object {
-    fun fromMap(map: Map<String, Any?>): AnyMap {
+    fun fromMap(
+      map: Map<String, Any?>,
+      ignoreIncompatible: Boolean = false,
+    ): AnyMap {
       val anyMap = AnyMap(map.size)
       for ((key, value) in map) {
-        anyMap.setAny(key, value)
+        try {
+          anyMap.setAny(key, value)
+        } catch (error: Throwable) {
+          if (ignoreIncompatible) {
+            continue
+          } else {
+            throw error
+          }
+        }
       }
       return anyMap
     }
   }
 
   fun toMap(): Map<String, Any?> {
-    val map = HashMap<String, Any?>()
-    for (key in getAllKeys()) {
-      map.put(key, getAny(key))
-    }
-    return map
+    return toHashMap()
   }
 
   fun setAny(
@@ -67,6 +74,8 @@ class AnyMap {
     return getAnyValue(key).toAny()
   }
 
+  external fun toHashMap(): HashMap<String, Any?>
+
   @FastNative
   external fun contains(key: String): Boolean
 

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);
   }
 

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/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

package/cpp/jsi/JSICache.cpp

@@ -6,9 +6,9 @@
 //
 
 #include "JSICache.hpp"
+#include "CommonGlobals.hpp"
 #include "JSIHelpers.hpp"
 #include "NitroDefines.hpp"
-#include "ObjectUtils.hpp"
 
 namespace margelo::nitro {
 
@@ -54,11 +54,16 @@ JSICacheReference JSICache::getOrCreateCache(jsi::Runtime& runtime) {
   // Wrap it in a jsi::Value using NativeState
   jsi::Object cache(runtime);
   cache.setNativeState(runtime, nativeState);
-  // Inject it into the jsi::Runtime's global so it's memory is managed by it.
-  // We pass `allowCache = false` because we are the JSICache, and this would cause recursion.
-  ObjectUtils::defineGlobal(runtime, KnownGlobalPropertyName::JSI_CACHE, std::move(cache), /* allowCache */ false);
-  // Add it to our map of caches
+  // Add it to our map of caches first, because the next `::defineGlobal(...)` call will already be using it (recursively)
   _globalCache[&runtime] = nativeState;
+  try {
+    // Call Object.defineProperty(global, ...) now with our cache (it internally already uses cache)
+    CommonGlobals::defineGlobal(runtime, KnownGlobalPropertyName::JSI_CACHE, std::move(cache));
+  } catch (...) {
+    // If `defineGlobal(...)` failed, we should remove it from `_globalCache` so we don't have invalid caches.
+    _globalCache.erase(&runtime);
+    throw;
+  }
   // Return it
   return JSICacheReference(nativeState);
 }

package/cpp/jsi/JSICache.hpp

@@ -63,6 +63,7 @@ private:
   std::vector<WeakReference<jsi::Object>> _objectCache;
   std::vector<WeakReference<jsi::Function>> _functionCache;
   std::vector<WeakReference<jsi::WeakObject>> _weakObjectCache;
+  std::vector<WeakReference<jsi::PropNameID>> _propNameIDCache;
   std::vector<WeakReference<jsi::ArrayBuffer>> _arrayBufferCache;
 
 private:
@@ -103,6 +104,11 @@ public:
     _strongCache->_weakObjectCache.push_back(owning.weak());
     return owning;
   }
+  BorrowingReference<jsi::PropNameID> makeShared(jsi::PropNameID&& value) {
+    BorrowingReference<jsi::PropNameID> owning(new jsi::PropNameID(std::move(value)));
+    _strongCache->_propNameIDCache.push_back(owning.weak());
+    return owning;
+  }
   BorrowingReference<jsi::ArrayBuffer> makeShared(jsi::ArrayBuffer&& value) {
     BorrowingReference<jsi::ArrayBuffer> owning(new jsi::ArrayBuffer(std::move(value)));
     _strongCache->_arrayBufferCache.push_back(owning.weak());

package/cpp/jsi/JSIConverter+AnyMap.hpp

@@ -18,6 +18,7 @@ struct JSIConverter;
 
 #include "AnyMap.hpp"
 #include "JSIHelpers.hpp"
+#include "PropNameIDCache.hpp"
 #include <jsi/jsi.h>
 #include <memory>
 
@@ -48,9 +49,9 @@ struct JSIConverter<std::shared_ptr<AnyMap>> final {
     size_t size = propNames.size(runtime);
     std::shared_ptr<AnyMap> map = AnyMap::make();
     for (size_t i = 0; i < size; i++) {
-      jsi::String jsKey = propNames.getValueAtIndex(runtime, i).getString(runtime);
-      jsi::Value jsValue = object.getProperty(runtime, jsKey);
-      map->setAny(jsKey.utf8(runtime), JSIConverter<AnyValue>::fromJSI(runtime, jsValue));
+      std::string jsKey = propNames.getValueAtIndex(runtime, i).getString(runtime).utf8(runtime);
+      jsi::Value jsValue = object.getProperty(runtime, PropNameIDCache::get(runtime, jsKey));
+      map->setAny(jsKey, JSIConverter<AnyValue>::fromJSI(runtime, jsValue));
     }
     return map;
   }

package/cpp/jsi/JSIConverter+Date.hpp

@@ -14,6 +14,8 @@ struct JSIConverter;
 
 #include "JSIConverter.hpp"
 
+#include "CommonGlobals.hpp"
+#include "PropNameIDCache.hpp"
 #include <chrono>
 #include <jsi/jsi.h>
 #include <memory>
@@ -38,15 +40,15 @@ struct JSIConverter<std::chrono::system_clock::time_point> final {
 
     jsi::Object object = arg.asObject(runtime);
 #ifdef NITRO_DEBUG
-    if (!object.hasProperty(runtime, "getTime")) {
+    if (!object.hasProperty(runtime, PropNameIDCache::get(runtime, "getTime"))) {
       throw std::invalid_argument("Object \"" + arg.toString(runtime).utf8(runtime) +
                                   "\" does not have a .getTime() function! "
                                   "It's not a valid Date object.");
     }
 #endif
 
-    // TODO: Cache this
-    jsi::Function getTimeFunc = object.getPropertyAsFunction(runtime, "getTime");
+    jsi::Function getTimeFunc =
+        object.getProperty(runtime, PropNameIDCache::get(runtime, "getTime")).getObject(runtime).getFunction(runtime);
     double msSinceEpoch = getTimeFunc.callWithThis(runtime, object).getNumber();
 
     // ms -> std::chrono::system_clock::time_point
@@ -62,19 +64,15 @@ struct JSIConverter<std::chrono::system_clock::time_point> final {
     auto ms = chrono::duration_cast<chrono::milliseconds>(date.time_since_epoch()).count();
     auto msSinceEpoch = static_cast<double>(ms);
 
-    // TODO: Cache this
-    jsi::Function dateCtor = runtime.global().getPropertyAsFunction(runtime, "Date");
-
-    jsi::Value jsDate = dateCtor.callAsConstructor(runtime, {jsi::Value(msSinceEpoch)});
+    // 2. Call `new Date(...)` with the milliseconds since epoch
+    jsi::Value jsDate = CommonGlobals::Date::callConstructor(runtime, msSinceEpoch);
     return jsDate;
   }
 
   static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
     if (value.isObject()) {
       jsi::Object object = value.getObject(runtime);
-
-      jsi::Function dateCtor = runtime.global().getPropertyAsFunction(runtime, "Date");
-      return object.instanceOf(runtime, dateCtor);
+      return CommonGlobals::Date::isInstanceOf(runtime, object);
     }
     return false;
   }

package/cpp/jsi/JSIConverter+Exception.hpp

@@ -10,9 +10,10 @@ template <typename T, typename Enable>
 struct JSIConverter;
 } // namespace margelo::nitro
 
+#include "CommonGlobals.hpp"
 #include "JSIConverter.hpp"
-
 #include "NitroTypeInfo.hpp"
+#include "PropNameIDCache.hpp"
 #include <exception>
 #include <jsi/jsi.h>
 
@@ -25,8 +26,8 @@ template <>
 struct JSIConverter<std::exception_ptr> final {
   static inline std::exception_ptr fromJSI(jsi::Runtime& runtime, const jsi::Value& error) {
     jsi::Object object = error.asObject(runtime);
-    std::string name = object.getProperty(runtime, "name").asString(runtime).utf8(runtime);
-    std::string message = object.getProperty(runtime, "message").asString(runtime).utf8(runtime);
+    std::string name = object.getProperty(runtime, PropNameIDCache::get(runtime, "name")).asString(runtime).utf8(runtime);
+    std::string message = object.getProperty(runtime, PropNameIDCache::get(runtime, "message")).asString(runtime).utf8(runtime);
     return std::make_exception_ptr(std::runtime_error(name + ": " + message));
   }
   static inline jsi::Value toJSI(jsi::Runtime& runtime, const std::exception_ptr& exception) {
@@ -51,8 +52,7 @@ struct JSIConverter<std::exception_ptr> final {
       return false;
     }
     jsi::Object object = value.getObject(runtime);
-    jsi::Function errorCtor = runtime.global().getPropertyAsFunction(runtime, "Error");
-    return object.instanceOf(runtime, errorCtor);
+    return CommonGlobals::Error::isInstanceOf(runtime, object);
   }
 };
 

package/cpp/jsi/JSIConverter+Function.hpp

@@ -16,6 +16,7 @@ struct JSIConverter;
 #include "JSCallback.hpp"
 #include "JSICache.hpp"
 #include "PromiseType.hpp"
+#include "PropNameIDCache.hpp"
 #include <jsi/jsi.h>
 
 namespace margelo::nitro {
@@ -56,7 +57,9 @@ struct JSIConverter<std::function<R(Args...)>> final {
       }
       return callHybridFunction(function, runtime, args, std::index_sequence_for<Args...>{});
     };
-    return jsi::Function::createFromHostFunction(runtime, jsi::PropNameID::forUtf8(runtime, "hostFunction"), sizeof...(Args),
+    return jsi::Function::createFromHostFunction(runtime,                                       //
+                                                 PropNameIDCache::get(runtime, "hostFunction"), //
+                                                 sizeof...(Args),                               //
                                                  std::move(jsFunction));
   }
 

package/cpp/jsi/JSIConverter+Promise.hpp

@@ -11,10 +11,12 @@ template <typename T, typename Enable>
 struct JSIConverter;
 } // namespace margelo::nitro
 
+#include "CommonGlobals.hpp"
 #include "JSIConverter.hpp"
 #include "NitroTypeInfo.hpp"
 #include "Null.hpp"
 #include "Promise.hpp"
+#include "PropNameIDCache.hpp"
 #include <exception>
 #include <jsi/jsi.h>
 #include <memory>
@@ -44,7 +46,7 @@ struct JSIConverter<std::shared_ptr<Promise<TResult>>> final {
 
     // Chain .then listeners on JS Promise (onResolved and onRejected)
     jsi::Object jsPromise = value.asObject(runtime);
-    jsi::Function thenFn = jsPromise.getPropertyAsFunction(runtime, "then");
+    jsi::Function thenFn = jsPromise.getProperty(runtime, PropNameIDCache::get(runtime, "then")).asObject(runtime).getFunction(runtime);
     thenFn.callWithThis(runtime, jsPromise, thenCallback, catchCallback);
 
     return promise;
@@ -53,7 +55,6 @@ struct JSIConverter<std::shared_ptr<Promise<TResult>>> final {
   static inline jsi::Value toJSI(jsi::Runtime& runtime, const std::shared_ptr<Promise<TResult>>& promise) {
     if (promise->isPending()) {
       // Get Promise ctor from global
-      jsi::Function promiseCtor = runtime.global().getPropertyAsFunction(runtime, "Promise");
       jsi::HostFunctionType executor = [promise](jsi::Runtime& runtime, const jsi::Value&, const jsi::Value* arguments,
                                                  size_t) -> jsi::Value {
         // Add resolver listener
@@ -72,27 +73,21 @@ struct JSIConverter<std::shared_ptr<Promise<TResult>>> final {
 
         return jsi::Value::undefined();
       };
-      // Call `Promise` constructor (aka create promise), and pass `executor` function
-      return promiseCtor.callAsConstructor(
-          runtime, jsi::Function::createFromHostFunction(runtime, jsi::PropNameID::forUtf8(runtime, "executor"), 2, executor));
+      return CommonGlobals::Promise::callConstructor(runtime, std::move(executor));
     } else if (promise->isResolved()) {
       // Promise is already resolved - just return immediately
-      jsi::Object promiseObject = runtime.global().getPropertyAsObject(runtime, "Promise");
-      jsi::Function createResolvedPromise = promiseObject.getPropertyAsFunction(runtime, "resolve");
       if constexpr (std::is_void_v<TResult>) {
         // It's resolving to void.
-        return createResolvedPromise.call(runtime);
+        return CommonGlobals::Promise::resolved(runtime);
       } else {
         // It's resolving to a type.
         jsi::Value result = JSIConverter<TResult>::toJSI(runtime, promise->getResult());
-        return createResolvedPromise.call(runtime, std::move(result));
+        return CommonGlobals::Promise::resolved(runtime, std::move(result));
       }
     } else if (promise->isRejected()) {
       // Promise is already rejected - just return immediately
-      jsi::Object promiseObject = runtime.global().getPropertyAsObject(runtime, "Promise");
-      jsi::Function createRejectedPromise = promiseObject.getPropertyAsFunction(runtime, "reject");
       jsi::Value error = JSIConverter<std::exception_ptr>::toJSI(runtime, promise->getError());
-      return createRejectedPromise.call(runtime, std::move(error));
+      return CommonGlobals::Promise::rejected(runtime, std::move(error));
     } else {
       std::string typeName = TypeInfo::getFriendlyTypename<TResult>(true);
       throw std::runtime_error("Promise<" + typeName + "> has invalid state!");
@@ -104,8 +99,7 @@ struct JSIConverter<std::shared_ptr<Promise<TResult>>> final {
       return false;
     }
     jsi::Object object = value.getObject(runtime);
-    jsi::Function promiseCtor = runtime.global().getPropertyAsFunction(runtime, "Promise");
-    return object.instanceOf(runtime, promiseCtor);
+    return CommonGlobals::Promise::isInstanceOf(runtime, object);
   }
 };
 

package/cpp/jsi/JSIConverter+UnorderedMap.hpp

@@ -14,6 +14,7 @@ struct JSIConverter;
 
 #include "AnyMap.hpp"
 #include "JSIHelpers.hpp"
+#include "PropNameIDCache.hpp"
 #include <jsi/jsi.h>
 #include <unordered_map>
 
@@ -33,7 +34,7 @@ struct JSIConverter<std::unordered_map<std::string, ValueType>> final {
     map.reserve(length);
     for (size_t i = 0; i < length; ++i) {
       std::string key = propertyNames.getValueAtIndex(runtime, i).asString(runtime).utf8(runtime);
-      jsi::Value value = object.getProperty(runtime, key.c_str());
+      jsi::Value value = object.getProperty(runtime, PropNameIDCache::get(runtime, key));
       map.emplace(key, JSIConverter<ValueType>::fromJSI(runtime, value));
     }
     return map;

package/cpp/jsi/JSIHelpers.hpp

@@ -42,7 +42,7 @@ static inline bool isPlainObject(jsi::Runtime& runtime, const jsi::Object& objec
  * Get an ID for the given Runtime.
  *
  * The ID usually consists of a Runtime description (e.g. "HermesRuntime"),
- * and it's Thread (e.g. "com.facebook.react.runtime.JavaScript")
+ * and its Thread's name (e.g. "com.facebook.react.runtime.JavaScript")
  */
 static inline std::string getRuntimeId(jsi::Runtime& runtime) {
   std::string threadName = ThreadUtils::getThreadName();