react-native-nitro-modules 0.31.10 → 0.32.0

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+ArrayBuffer.hpp

@@ -50,7 +50,7 @@ struct JSIConverter<T, std::enable_if_t<is_shared_ptr_to_v<T, jsi::MutableBuffer
     if (!object.isArrayBuffer(runtime)) [[unlikely]] {
       throw std::invalid_argument("Object \"" + arg.toString(runtime).utf8(runtime) +
                                   "\" is not an ArrayBuffer! "
-                                  "Are you maybe passing a TypedArray (e.g. Uint8Array)? Try to pass it's `.buffer` value.");
+                                  "Are you maybe passing a TypedArray (e.g. Uint8Array)? Try to pass its `.buffer` value.");
     }
 #endif
     if (object.hasNativeState<MutableBufferNativeState>(runtime)) {
@@ -69,7 +69,7 @@ struct JSIConverter<T, std::enable_if_t<is_shared_ptr_to_v<T, jsi::MutableBuffer
   }
   static inline jsi::Value toJSI(jsi::Runtime& runtime, const std::shared_ptr<jsi::MutableBuffer>& buffer) {
     if (auto jsBuffer = std::dynamic_pointer_cast<JSArrayBuffer>(buffer)) {
-      // It already is a JSBuffer! Let's try to just get it's existing jsi::Value...
+      // It already is a JSBuffer! Let's try to just get its existing jsi::Value...
       auto jsValue = jsBuffer->getJSReference();
       if (jsValue != nullptr) [[likely]] {
         return jsi::Value(runtime, *jsValue);

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+NativeState.hpp

@@ -65,7 +65,7 @@ struct JSIConverter<T, std::enable_if_t<is_shared_ptr_to_v<T, jsi::NativeState>>
     }
 
     if constexpr (std::is_base_of_v<HybridObject, TPointee>) {
-      // It's a HybridObject - use it's internal constructor which caches jsi::Objects for proper memory management!
+      // It's a HybridObject - use its internal constructor which caches jsi::Objects for proper memory management!
       return arg->toObject(runtime);
     } else {
       // It's any other kind of jsi::NativeState - just create it as normal. This will not have a prototype then!

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

package/cpp/platform/NitroLogger.hpp

@@ -22,7 +22,9 @@ private:
 
 public:
   template <typename... Args>
-  static void log([[maybe_unused]] LogLevel level, [[maybe_unused]] const char* NON_NULL tag, [[maybe_unused]] const char* NON_NULL format,
+  static void log([[maybe_unused]] LogLevel level,              //
+                  [[maybe_unused]] const char* NON_NULL tag,    //
+                  [[maybe_unused]] const char* NON_NULL format, //
                   [[maybe_unused]] Args... args) {
 #ifdef NITRO_DEBUG
     // 1. Make sure args can be passed to sprintf(..)

package/cpp/prototype/HybridObjectPrototype.cpp

@@ -6,10 +6,10 @@
 //
 
 #include "HybridObjectPrototype.hpp"
+#include "CommonGlobals.hpp"
 #include "NitroDefines.hpp"
 #include "NitroLogger.hpp"
 #include "NitroTypeInfo.hpp"
-#include "ObjectUtils.hpp"
 
 namespace margelo::nitro {
 
@@ -39,19 +39,19 @@ jsi::Value HybridObjectPrototype::createPrototype(jsi::Runtime& runtime, const s
   std::string typeName = TypeInfo::getFriendlyTypename(prototype->getNativeInstanceId(), true);
   Logger::log(LogLevel::Info, TAG, "Creating new JS prototype for C++ instance type \"%s\"...", typeName.c_str());
   jsi::Value basePrototype = createPrototype(runtime, prototype->getBase());
-  jsi::Object object = ObjectUtils::create(runtime, basePrototype);
+  jsi::Object object = CommonGlobals::Object::create(runtime, basePrototype);
 
   // 4. Add all Hybrid Methods to it
   for (const auto& method : prototype->getMethods()) {
     // method()
     const std::string& name = method.first;
-    ObjectUtils::defineProperty(runtime, object, name.c_str(),
-                                PlainPropertyDescriptor{
-                                    .configurable = false,
-                                    .enumerable = true,
-                                    .value = method.second.toJSFunction(runtime),
-                                    .writable = false,
-                                });
+    CommonGlobals::Object::defineProperty(runtime, object, name.c_str(),
+                                          PlainPropertyDescriptor{
+                                              .configurable = false,
+                                              .enumerable = true,
+                                              .value = method.second.toJSFunction(runtime),
+                                              .writable = false,
+                                          });
   }
 
   // 5. Add all properties (getter + setter) to it using defineProperty
@@ -61,37 +61,37 @@ jsi::Value HybridObjectPrototype::createPrototype(jsi::Runtime& runtime, const s
     const std::string& name = getter.first;
     if (isReadonly) {
       // get
-      ObjectUtils::defineProperty(runtime, object, name.c_str(),
-                                  ComputedReadonlyPropertyDescriptor{// readonly
-                                                                     .configurable = false,
-                                                                     .enumerable = true,
-                                                                     .get = getter.second.toJSFunction(runtime)});
+      CommonGlobals::Object::defineProperty(runtime, object, name.c_str(),
+                                            ComputedReadonlyPropertyDescriptor{// readonly
+                                                                               .configurable = false,
+                                                                               .enumerable = true,
+                                                                               .get = getter.second.toJSFunction(runtime)});
     } else {
       // get + set
-      ObjectUtils::defineProperty(runtime, object, name.c_str(),
-                                  ComputedPropertyDescriptor{// readonly with setter
-                                                             .configurable = false,
-                                                             .enumerable = false,
-                                                             .get = getter.second.toJSFunction(runtime),
-                                                             .set = setter->second.toJSFunction(runtime)});
+      CommonGlobals::Object::defineProperty(runtime, object, name.c_str(),
+                                            ComputedPropertyDescriptor{// readonly with setter
+                                                                       .configurable = false,
+                                                                       .enumerable = false,
+                                                                       .get = getter.second.toJSFunction(runtime),
+                                                                       .set = setter->second.toJSFunction(runtime)});
     }
   }
 
   // 6. In DEBUG, add a __type info to the prototype object.
 #ifdef NITRO_DEBUG
   std::string prototypeName = "Prototype<" + typeName + ">";
-  ObjectUtils::defineProperty(runtime, object, "__type",
-                              PlainPropertyDescriptor{
-                                  .configurable = false,
-                                  .enumerable = true,
-                                  .value = jsi::String::createFromUtf8(runtime, prototypeName),
-                                  .writable = false,
-                              });
+  CommonGlobals::Object::defineProperty(runtime, object, "__type",
+                                        PlainPropertyDescriptor{
+                                            .configurable = false,
+                                            .enumerable = true,
+                                            .value = jsi::String::createFromUtf8(runtime, prototypeName),
+                                            .writable = false,
+                                        });
 #endif
 
   // 7. In DEBUG, freeze the prototype.
 #ifdef NITRO_DEBUG
-  ObjectUtils::freeze(runtime, object);
+  CommonGlobals::Object::freeze(runtime, object);
 #endif
 
   // 8. Throw it into our cache so the next lookup can be cached and therefore faster

package/cpp/prototype/PrototypeChain.hpp

@@ -63,7 +63,7 @@ private:
       return node;
     } else {
       if (node->hasBase()) {
-        // We didn't find a match in this prototype, let's recursively try it's parent!
+        // We didn't find a match in this prototype, let's recursively try its parent!
         return getOrExtendPrototype<Derived>(node->getBase());
       } else {
         // We didn't find `Derived` and we don't have a base- add a child and shift the tree by one.

package/cpp/registry/HybridObjectRegistry.hpp

@@ -27,7 +27,7 @@ public:
 public:
   /**
    * Registers the given HybridObject in the `HybridObjectRegistry`.
-   * It will be uniquely identified via it's `hybridObjectName`, and can be initialized from
+   * It will be uniquely identified via its `hybridObjectName`, and can be initialized from
    * JS using `NitroModules.createHybridObject<T>(name)` - which will call the `constructorFn` here.
    */
   static void registerHybridObjectConstructor(const std::string& hybridObjectName, HybridObjectConstructorFn&& constructorFn);

package/cpp/threading/CallInvokerDispatcher.hpp

@@ -15,7 +15,7 @@ namespace margelo::nitro {
 using namespace facebook;
 
 /**
- * A Dispatcher that uses react::CallInvoker for it's implementation
+ * A Dispatcher that uses react::CallInvoker for its implementation
  */
 class CallInvokerDispatcher final : public Dispatcher {
 public:

package/cpp/threading/Dispatcher.cpp

@@ -6,11 +6,11 @@
 //
 
 #include "Dispatcher.hpp"
+#include "CommonGlobals.hpp"
 #include "JSIConverter.hpp"
 #include "JSIHelpers.hpp"
 #include "NitroDefines.hpp"
 #include "NitroLogger.hpp"
-#include "ObjectUtils.hpp"
 
 namespace margelo::nitro {
 
@@ -30,7 +30,7 @@ void Dispatcher::installRuntimeGlobalDispatcher(jsi::Runtime& runtime, std::shar
 
   // Inject the dispatcher into Runtime global (runtime will hold a strong reference)
   jsi::Value dispatcherHolder = JSIConverter<std::shared_ptr<Dispatcher>>::toJSI(runtime, dispatcher);
-  ObjectUtils::defineGlobal(runtime, KnownGlobalPropertyName::DISPATCHER, std::move(dispatcherHolder));
+  CommonGlobals::defineGlobal(runtime, KnownGlobalPropertyName::DISPATCHER, std::move(dispatcherHolder));
 }
 
 std::shared_ptr<Dispatcher> Dispatcher::getRuntimeGlobalDispatcher(jsi::Runtime& runtime) {
@@ -57,15 +57,15 @@ std::shared_ptr<Dispatcher> Dispatcher::getRuntimeGlobalDispatcher(jsi::Runtime&
 }
 
 jsi::Value Dispatcher::getRuntimeGlobalDispatcherHolder(jsi::Runtime& runtime) {
-  const char* dispatcherHolderName = ObjectUtils::getKnownGlobalPropertyNameString(KnownGlobalPropertyName::DISPATCHER);
-  if (!runtime.global().hasProperty(runtime, dispatcherHolderName)) [[unlikely]] {
+  const jsi::PropNameID& dispatcherHolderPropName = CommonGlobals::getKnownGlobalPropertyName(runtime, KnownGlobalPropertyName::DISPATCHER);
+  if (!runtime.global().hasProperty(runtime, dispatcherHolderPropName)) [[unlikely]] {
     throw std::runtime_error("The `jsi::Runtime` \"" + getRuntimeId(runtime) +
                              "\" does not support Callbacks or Promises because it does not have a `Dispatcher` installed!\n"
                              "To use Callbacks and Promises follow these steps;\n"
                              "1. Subclass `Dispatcher` with your implementation of `runAsync`/`runSync` for your Thread.\n"
                              "2. Call `Dispatcher::installRuntimeGlobalDispatcher(...)` with your `Runtime` and your `Dispatcher`.");
   }
-  return runtime.global().getProperty(runtime, dispatcherHolderName);
+  return runtime.global().getProperty(runtime, dispatcherHolderPropName);
 }
 
 } // namespace margelo::nitro

package/cpp/utils/BorrowingReference.hpp

@@ -18,15 +18,15 @@
 namespace margelo::nitro {
 
 /**
- * An `BorrowingReference<T>` is a smart-pointer that holds a strong reference to a pointer.
+ * A `BorrowingReference<T>` is a smart-pointer that holds a strong reference to a pointer.
  * You can have multiple `BorrowingReference<T>` instances point to the same pointer, as they internally keep a ref-count.
- * As opposed to a `shared_ptr<T>`, an `BorrowingReference<T>` can also be imperatively manually deleted, even if there
+ * As opposed to a `shared_ptr<T>`, a `BorrowingReference<T>` can also be imperatively manually deleted, even if there
  * are multiple strong references still holding onto the pointer.
  * This is useful in cases where the `BorrowingReference` might keep a reference alive, but an external value holder
  * is actually responsible for truly deleting the underlying value - like a `jsi::Runtime` for a `jsi::Value`.
  *
- * An `BorrowingReference<T>` can be weakified, which gives the user a `WeakReference<T>`.
- * A `WeakReference<T>` can be locked to get an `BorrowingReference<T>` again, assuming it has not been deleted yet.
+ * A `BorrowingReference<T>` can be weakified, which gives the user a `WeakReference<T>`.
+ * A `WeakReference<T>` can be locked to get a `BorrowingReference<T>` again, assuming it has not been deleted yet.
  */
 template <typename T>
 class BorrowingReference final {
@@ -120,7 +120,7 @@ public:
   }
 
   /**
-   * Get a borrowing (or "weak") reference to this owning reference
+   * Get a weak reference to this borrowing reference.
    */
   [[nodiscard]]
   WeakReference<T> weak() const {
@@ -220,4 +220,4 @@ private:
 
 } // namespace margelo::nitro
 
-#include "WeakReference+Owning.hpp"
+#include "WeakReference+Borrowing.hpp"