react-native-nitro-modules 0.31.9 → 0.32.0-beta.0

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

package/cpp/utils/CommonGlobals.cpp

@@ -0,0 +1,215 @@
+//
+//  CommonGlobals.cpp
+//  react-native-nitro
+//
+//  Created by Marc Rousavy on 17.10.25.
+//
+
+#include "CommonGlobals.hpp"
+#include "JSICache.hpp"
+#include "JSIHelpers.hpp"
+#include "NitroDefines.hpp"
+#include "PropNameIDCache.hpp"
+
+#if __has_include(<cxxreact/ReactNativeVersion.h>)
+#include <cxxreact/ReactNativeVersion.h>
+#if REACT_NATIVE_VERSION_MINOR >= 78
+#define ENABLE_NATIVE_OBJECT_CREATE
+#endif
+#endif
+
+namespace margelo::nitro {
+
+using namespace facebook;
+
+std::unordered_map<jsi::Runtime*, CommonGlobals::FunctionCache> CommonGlobals::_cache;
+
+// pragma MARK: Object
+
+jsi::Object CommonGlobals::Object::create(jsi::Runtime& runtime, const jsi::Value& prototype) {
+#ifdef ENABLE_NATIVE_OBJECT_CREATE
+  return jsi::Object::create(runtime, prototype);
+#else
+  const jsi::Function& createFn = getGlobalFunction(runtime, "Object.create", [](jsi::Runtime& runtime) {
+    return runtime.global().getPropertyAsObject(runtime, "Object").getPropertyAsFunction(runtime, "create");
+  });
+  return createFn.call(runtime, prototype).getObject(runtime);
+#endif
+}
+
+void CommonGlobals::Object::defineProperty(jsi::Runtime& runtime, const jsi::Object& object, const char* propertyName,
+                                           PlainPropertyDescriptor&& descriptor) {
+  const jsi::Function& definePropertyFn = getGlobalFunction(runtime, "Object.defineProperty", [](jsi::Runtime& runtime) {
+    return runtime.global().getPropertyAsObject(runtime, "Object").getPropertyAsFunction(runtime, "defineProperty");
+  });
+
+  jsi::String nameJs = jsi::String::createFromAscii(runtime, propertyName);
+
+  jsi::Object descriptorJs(runtime);
+  descriptorJs.setProperty(runtime, PropNameIDCache::get(runtime, "configurable"), jsi::Value(descriptor.configurable));
+  descriptorJs.setProperty(runtime, PropNameIDCache::get(runtime, "enumerable"), jsi::Value(descriptor.enumerable));
+  descriptorJs.setProperty(runtime, PropNameIDCache::get(runtime, "value"), std::move(descriptor.value));
+  descriptorJs.setProperty(runtime, PropNameIDCache::get(runtime, "writable"), jsi::Value(descriptor.writable));
+
+  definePropertyFn.call(runtime, object, std::move(nameJs), std::move(descriptorJs));
+}
+
+void CommonGlobals::Object::defineProperty(jsi::Runtime& runtime, const jsi::Object& object, const char* propertyName,
+                                           ComputedReadonlyPropertyDescriptor&& descriptor) {
+  const jsi::Function& definePropertyFn = getGlobalFunction(runtime, "Object.defineProperty", [](jsi::Runtime& runtime) {
+    return runtime.global().getPropertyAsObject(runtime, "Object").getPropertyAsFunction(runtime, "defineProperty");
+  });
+
+  jsi::String nameJs = jsi::String::createFromAscii(runtime, propertyName);
+
+  jsi::Object descriptorJs(runtime);
+  descriptorJs.setProperty(runtime, PropNameIDCache::get(runtime, "configurable"), jsi::Value(descriptor.configurable));
+  descriptorJs.setProperty(runtime, PropNameIDCache::get(runtime, "enumerable"), jsi::Value(descriptor.enumerable));
+  descriptorJs.setProperty(runtime, PropNameIDCache::get(runtime, "get"), std::move(descriptor.get));
+
+  definePropertyFn.call(runtime, object, std::move(nameJs), std::move(descriptorJs));
+}
+
+void CommonGlobals::Object::defineProperty(jsi::Runtime& runtime, const jsi::Object& object, const char* propertyName,
+                                           ComputedPropertyDescriptor&& descriptor) {
+  const jsi::Function& definePropertyFn = getGlobalFunction(runtime, "Object.defineProperty", [](jsi::Runtime& runtime) {
+    return runtime.global().getPropertyAsObject(runtime, "Object").getPropertyAsFunction(runtime, "defineProperty");
+  });
+
+  jsi::String nameJs = jsi::String::createFromAscii(runtime, propertyName);
+
+  jsi::Object descriptorJs(runtime);
+  descriptorJs.setProperty(runtime, PropNameIDCache::get(runtime, "configurable"), jsi::Value(descriptor.configurable));
+  descriptorJs.setProperty(runtime, PropNameIDCache::get(runtime, "enumerable"), jsi::Value(descriptor.enumerable));
+  descriptorJs.setProperty(runtime, PropNameIDCache::get(runtime, "get"), std::move(descriptor.get));
+  descriptorJs.setProperty(runtime, PropNameIDCache::get(runtime, "set"), std::move(descriptor.set));
+
+  definePropertyFn.call(runtime, object, std::move(nameJs), std::move(descriptorJs));
+}
+
+void CommonGlobals::Object::freeze(jsi::Runtime& runtime, const jsi::Object& object) {
+  const jsi::Function& freezeFn = getGlobalFunction(runtime, "Object.freeze", [](jsi::Runtime& runtime) {
+    return runtime.global().getPropertyAsObject(runtime, "Object").getPropertyAsFunction(runtime, "freeze");
+  });
+
+  freezeFn.call(runtime, object);
+}
+
+// pragma MARK: Promise
+
+jsi::Value CommonGlobals::Promise::resolved(jsi::Runtime& runtime) {
+  const jsi::Function& resolvedFunc = getGlobalFunction(runtime, "Promise.resolve", [](jsi::Runtime& runtime) {
+    return runtime.global().getPropertyAsObject(runtime, "Promise").getPropertyAsFunction(runtime, "resolve");
+  });
+  return resolvedFunc.call(runtime);
+}
+jsi::Value CommonGlobals::Promise::resolved(jsi::Runtime& runtime, jsi::Value&& value) {
+  const jsi::Function& resolvedFunc = getGlobalFunction(runtime, "Promise.resolve", [](jsi::Runtime& runtime) {
+    return runtime.global().getPropertyAsObject(runtime, "Promise").getPropertyAsFunction(runtime, "resolve");
+  });
+  return resolvedFunc.call(runtime, {std::move(value)});
+}
+jsi::Value CommonGlobals::Promise::rejected(jsi::Runtime& runtime, jsi::Value&& error) {
+  const jsi::Function& rejectedFunc = getGlobalFunction(runtime, "Promise.reject", [](jsi::Runtime& runtime) {
+    return runtime.global().getPropertyAsObject(runtime, "Promise").getPropertyAsFunction(runtime, "reject");
+  });
+  return rejectedFunc.call(runtime, {std::move(error)});
+}
+
+jsi::Value CommonGlobals::Promise::callConstructor(jsi::Runtime& runtime, jsi::HostFunctionType&& executor) {
+  const jsi::Function& promiseCtor = getGlobalFunction(
+      runtime, "Promise", [](jsi::Runtime& runtime) { return runtime.global().getPropertyAsFunction(runtime, "Promise"); });
+  jsi::Function executorFunc =
+      jsi::Function::createFromHostFunction(runtime, jsi::PropNameID::forAscii(runtime, "executor"), 2, std::move(executor));
+  return promiseCtor.callAsConstructor(runtime, std::move(executorFunc));
+}
+bool CommonGlobals::Promise::isInstanceOf(jsi::Runtime& runtime, const jsi::Object& object) {
+  const jsi::Function& promiseCtor = getGlobalFunction(
+      runtime, "Promise", [](jsi::Runtime& runtime) { return runtime.global().getPropertyAsFunction(runtime, "Promise"); });
+  return object.instanceOf(runtime, promiseCtor);
+}
+
+// pragma MARK: Date
+
+jsi::Value CommonGlobals::Date::callConstructor(jsi::Runtime& runtime, double msSinceEpoch) {
+  const jsi::Function& dateCtor =
+      getGlobalFunction(runtime, "Date", [](jsi::Runtime& runtime) { return runtime.global().getPropertyAsFunction(runtime, "Date"); });
+  return dateCtor.callAsConstructor(runtime, {jsi::Value(msSinceEpoch)});
+}
+bool CommonGlobals::Date::isInstanceOf(jsi::Runtime& runtime, const jsi::Object& object) {
+  const jsi::Function& dateCtor =
+      getGlobalFunction(runtime, "Date", [](jsi::Runtime& runtime) { return runtime.global().getPropertyAsFunction(runtime, "Date"); });
+  return object.instanceOf(runtime, dateCtor);
+}
+
+// pragma MARK: Error
+
+bool CommonGlobals::Error::isInstanceOf(jsi::Runtime& runtime, const jsi::Object& object) {
+  const jsi::Function& errorCtor =
+      getGlobalFunction(runtime, "Error", [](jsi::Runtime& runtime) { return runtime.global().getPropertyAsFunction(runtime, "Error"); });
+  return object.instanceOf(runtime, errorCtor);
+}
+
+// pragma MARK: CommonGlobals
+
+void CommonGlobals::defineGlobal(jsi::Runtime& runtime, KnownGlobalPropertyName name, jsi::Value&& value) {
+  const char* nameString = getKnownGlobalPropertyNameString(name);
+
+#ifdef NITRO_DEBUG
+  // In debug, let's perform additional safety checks.
+  if (runtime.global().hasProperty(runtime, nameString)) [[unlikely]] {
+    throw std::runtime_error("Failed to set `global." + std::string(nameString) + "` - it already exists for Runtime \"" +
+                             getRuntimeId(runtime) + "\"! Did you call `defineGlobal(\"" + std::string(nameString) +
+                             "\")` twice? Did you link Nitro Modules twice?");
+  }
+  Object::defineProperty(runtime, runtime.global(), nameString,
+                         PlainPropertyDescriptor{.configurable = false, .enumerable = true, .value = std::move(value), .writable = false});
+#else
+  // In release, just set the property.
+  runtime.global().setProperty(runtime, nameString, std::move(value));
+#endif
+}
+
+const char* CommonGlobals::getKnownGlobalPropertyNameString(KnownGlobalPropertyName name) {
+  switch (name) {
+    case KnownGlobalPropertyName::DISPATCHER:
+      return "__nitroDispatcher";
+    case KnownGlobalPropertyName::JSI_CACHE:
+      return "__nitroJsiCache";
+    case KnownGlobalPropertyName::NITRO_MODULES_PROXY:
+      return "NitroModulesProxy";
+  }
+}
+
+const jsi::PropNameID& CommonGlobals::getKnownGlobalPropertyName(jsi::Runtime& runtime, KnownGlobalPropertyName name) {
+  return PropNameIDCache::get(runtime, getKnownGlobalPropertyNameString(name));
+}
+
+const jsi::Function& CommonGlobals::getGlobalFunction(jsi::Runtime& runtime, const char* key,
+                                                      std::function<jsi::Function(jsi::Runtime&)> getFunction) {
+  // Let's try to find the function in cache
+  FunctionCache& functionCache = _cache[&runtime];
+  std::string stringKey = key;
+  auto iterator = functionCache.find(stringKey);
+  if (iterator != functionCache.end()) {
+    // We found it! Let's check if the reference is still valid...
+    BorrowingReference<jsi::Function> function = iterator->second;
+    if (function != nullptr) [[likely]] {
+      // It's still alive - let's use it from cache!
+      return *function;
+    }
+  }
+
+  // We haven't found the function with the given key in cache - so let's get it:
+  jsi::Function function = getFunction(runtime);
+
+  // Let's throw it in cache!
+  JSICacheReference jsiCache = JSICache::getOrCreateCache(runtime);
+  BorrowingReference<jsi::Function> sharedFunction = jsiCache.makeShared(std::move(function));
+  functionCache[stringKey] = sharedFunction;
+
+  // And now return:
+  return *sharedFunction;
+}
+
+} // namespace margelo::nitro

package/cpp/utils/CommonGlobals.hpp

@@ -0,0 +1,158 @@
+//
+//  CommonGlobals.hpp
+//  react-native-nitro
+//
+//  Created by Marc Rousavy on 17.10.25.
+//
+
+#pragma once
+
+#include "BorrowingReference.hpp"
+#include <jsi/jsi.h>
+#include <unordered_map>
+
+namespace margelo::nitro {
+
+using namespace facebook;
+
+struct PlainPropertyDescriptor {
+  bool configurable;
+  bool enumerable;
+  jsi::Value value;
+  bool writable;
+};
+struct ComputedReadonlyPropertyDescriptor {
+  bool configurable;
+  bool enumerable;
+  jsi::Function get;
+};
+struct ComputedPropertyDescriptor {
+  bool configurable;
+  bool enumerable;
+  jsi::Function get;
+  jsi::Function set;
+};
+
+enum class KnownGlobalPropertyName { DISPATCHER, JSI_CACHE, NITRO_MODULES_PROXY };
+
+class CommonGlobals final {
+public:
+  CommonGlobals() = delete;
+  ~CommonGlobals() = delete;
+
+public:
+  /**
+   * Define a global value for the given Runtime.
+   * In debug, this performs additional safety checks such as freezing the property.
+   */
+  static void defineGlobal(jsi::Runtime& runtime, KnownGlobalPropertyName name, jsi::Value&& value);
+  /**
+   * Get a string name for a known global property name.
+   */
+  static const char* getKnownGlobalPropertyNameString(KnownGlobalPropertyName name);
+  /**
+   * Get a `jsi::PropNameID` for a known global property name.
+   */
+  static const jsi::PropNameID& getKnownGlobalPropertyName(jsi::Runtime& runtime, KnownGlobalPropertyName name);
+
+  /**
+   * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object
+   */
+  class Object final {
+  public:
+    Object() = delete;
+    ~Object() = delete;
+
+    /**
+     * Create a new `jsi::Object` with the given `prototype`.
+     * Uses a native implementation if possible.
+     */
+    static jsi::Object create(jsi::Runtime& runtime, const jsi::Value& prototype);
+
+    /**
+     * Define a plain property on the given `object` with the given `propertyName`.
+     * The `descriptor` defines the attributes of this property.
+     */
+    static void defineProperty(jsi::Runtime& runtime, const jsi::Object& object, const char* propertyName,
+                               PlainPropertyDescriptor&& descriptor);
+    /**
+     * Define a plain property on the given `object` with the given `propertyName`.
+     * The `descriptor` defines the attributes of this property.
+     */
+    static void defineProperty(jsi::Runtime& runtime, const jsi::Object& object, const char* propertyName,
+                               ComputedReadonlyPropertyDescriptor&& descriptor);
+    /**
+     * Define a plain property on the given `object` with the given `propertyName`.
+     * The `descriptor` defines the attributes of this property.
+     */
+    static void defineProperty(jsi::Runtime& runtime, const jsi::Object& object, const char* propertyName,
+                               ComputedPropertyDescriptor&& descriptor);
+
+    /**
+     * Freezes all values of the given `object`.
+     */
+    static void freeze(jsi::Runtime& runtime, const jsi::Object& object);
+  };
+
+  /**
+   * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise
+   */
+  class Promise final {
+  public:
+    Promise() = delete;
+    ~Promise() = delete;
+
+    static jsi::Value resolved(jsi::Runtime& runtime);
+    static jsi::Value resolved(jsi::Runtime& runtime, jsi::Value&& value);
+    static jsi::Value rejected(jsi::Runtime& runtime, jsi::Value&& error);
+
+    static jsi::Value callConstructor(jsi::Runtime& runtime, jsi::HostFunctionType&& executor);
+    static bool isInstanceOf(jsi::Runtime& runtime, const jsi::Object& object);
+  };
+
+  /**
+   * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date
+   */
+  class Date final {
+  public:
+    Date() = delete;
+    ~Date() = delete;
+
+    static jsi::Value callConstructor(jsi::Runtime& runtime, double msSinceEpoch);
+    static bool isInstanceOf(jsi::Runtime& runtime, const jsi::Object& object);
+  };
+
+  /**
+   * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error
+   */
+  class Error final {
+  public:
+    Error() = delete;
+    ~Error() = delete;
+
+    static bool isInstanceOf(jsi::Runtime& runtime, const jsi::Object& object);
+  };
+
+private:
+  friend Object;
+  friend Promise;
+  friend Date;
+  friend Error;
+
+private:
+  /**
+   * Get a global Function, and optionally cache it in the Runtime via the `key`.
+   *
+   * The returned const-ref to a `jsi::Function` should only be used within the callee's
+   * synchronous scope.
+   * It may no longer be active after the scope ends (function return).
+   */
+  static const jsi::Function& getGlobalFunction(jsi::Runtime& runtime, const char* key,
+                                                std::function<jsi::Function(jsi::Runtime&)> getFunction);
+
+private:
+  using FunctionCache = std::unordered_map<std::string, BorrowingReference<jsi::Function>>;
+  static std::unordered_map<jsi::Runtime*, FunctionCache> _cache;
+};
+
+} // namespace margelo::nitro

package/cpp/utils/NitroDefines.hpp

@@ -9,7 +9,7 @@
 #define NitroDefines_h
 
 // Sets the version of the native Nitro core library
-#define NITRO_VERSION "0.31.9"
+#define NITRO_VERSION "0.32.0-beta.0"
 
 // Sets whether to use debug or optimized production build flags
 #ifdef DEBUG

package/cpp/utils/PropNameIDCache.cpp

@@ -0,0 +1,38 @@
+//
+//  PropNameIDCache.cpp
+//  react-native-nitro
+//
+//  Created by Marc Rousavy on 17.10.25.
+//
+
+#include "PropNameIDCache.hpp"
+#include "JSICache.hpp"
+
+namespace margelo::nitro {
+
+using namespace facebook;
+
+std::unordered_map<jsi::Runtime*, PropNameIDCache::CacheMap> PropNameIDCache::_cache;
+
+const jsi::PropNameID& PropNameIDCache::get(jsi::Runtime& runtime, std::string value) {
+  CacheMap& cache = _cache[&runtime];
+  const auto& cachedName = cache.find(value);
+  if (cachedName != cache.end()) {
+    // cache warm!
+    const BorrowingReference<jsi::PropNameID>& value = cachedName->second;
+    return *value;
+  }
+
+  // not cached - create the jsi::PropNameID...
+  auto propName = jsi::PropNameID::forAscii(runtime, value);
+  auto jsiCache = JSICache::getOrCreateCache(runtime);
+  auto sharedPropName = jsiCache.makeShared(std::move(propName));
+
+  // store it in cache...
+  cache.emplace(value, sharedPropName);
+
+  // return it!
+  return *sharedPropName;
+}
+
+} // namespace margelo::nitro

package/cpp/utils/PropNameIDCache.hpp

@@ -0,0 +1,44 @@
+//
+//  PropNameIDCache.hpp
+//  react-native-nitro
+//
+//  Created by Marc Rousavy on 17.10.25.
+//
+
+#pragma once
+
+#include "BorrowingReference.hpp"
+#include <jsi/jsi.h>
+#include <unordered_map>
+
+namespace margelo::nitro {
+
+using namespace facebook;
+
+/**
+ * Allows caching `jsi::PropNameID`s via `std::string`s.
+ * The returned `jsi::PropNameID` can be used for JSI operations like
+ * - `jsi::Object::getProperty(...)`
+ * - `jsi::Object::setProperty(...)`
+ * - `jsi::Object::hasProperty(...)`
+ * And is more efficient than the string equivalent overloads of those
+ * functions due to caching.
+ */
+class PropNameIDCache final {
+public:
+  PropNameIDCache() = delete;
+  ~PropNameIDCache() = delete;
+
+  /**
+   * Get a `jsi::PropNameID` for the given `std::string` value.
+   * The `jsi::PropNameID` is only valid within the callee's current
+   * synchronous scope, and must be non-escaping.
+   */
+  static const jsi::PropNameID& get(jsi::Runtime& runtime, std::string value);
+
+private:
+  using CacheMap = std::unordered_map<std::string, BorrowingReference<jsi::PropNameID>>;
+  static std::unordered_map<jsi::Runtime*, CacheMap> _cache;
+};
+
+} // namespace margelo::nitro

package/cpp/utils/{WeakReference+Owning.hpp → WeakReference+Borrowing.hpp}

@@ -1,5 +1,5 @@
 //
-//  WeakReference+Owning.hpp
+//  WeakReference+Borrowing.hpp
 //  react-native-nitro
 //
 //  Created by Marc Rousavy on 23.06.24.

package/cpp/utils/WeakReference.hpp

@@ -72,7 +72,7 @@ public:
   }
 
   /**
-   Try to lock the borrowing reference to an owning reference, or `nullptr` if it has already been deleted.
+   * Try to lock the weak reference to a borrowing reference, or `nullptr` if it has already been deleted.
    */
   [[nodiscard]]
   BorrowingReference<T> lock() const;