react-native-nitro-modules 0.32.0 → 0.32.1

package/cpp/core/BoxedHybridObject.cpp

@@ -6,6 +6,7 @@
 //
 
 #include "BoxedHybridObject.hpp"
+#include "PropNameIDCache.hpp"
 
 namespace margelo::nitro {
 
@@ -18,7 +19,7 @@ jsi::Value BoxedHybridObject::get(jsi::Runtime& runtime, const jsi::PropNameID&
 
   if (name == "unbox") {
     return jsi::Function::createFromHostFunction(
-        runtime, jsi::PropNameID::forUtf8(runtime, "unbox"), 0,
+        runtime, PropNameIDCache::get(runtime, "unbox"), 0,
         [hybridObject = _hybridObject](jsi::Runtime& runtime, const jsi::Value&, const jsi::Value*, size_t) -> jsi::Value {
           return hybridObject->toObject(runtime);
         });

package/cpp/core/HybridFunction.hpp

@@ -17,6 +17,7 @@ struct JSIConverter;
 #include "JSIConverter.hpp"
 #include "NitroDefines.hpp"
 #include "NitroTypeInfo.hpp"
+#include "PropNameIDCache.hpp"
 #include <exception>
 #include <functional>
 #include <jsi/jsi.h>
@@ -67,7 +68,7 @@ public:
 public:
   // functions
   inline jsi::Function toJSFunction(jsi::Runtime& runtime) const {
-    return jsi::Function::createFromHostFunction(runtime, jsi::PropNameID::forUtf8(runtime, _name), static_cast<unsigned int>(_paramCount),
+    return jsi::Function::createFromHostFunction(runtime, PropNameIDCache::get(runtime, _name), static_cast<unsigned int>(_paramCount),
                                                  _function);
   }
 

package/cpp/core/HybridObject.cpp

@@ -91,7 +91,7 @@ jsi::Value HybridObject::toObject(jsi::Runtime& runtime) {
                                             // .configurable has to be true because this property is non-frozen
                                             .configurable = true,
                                             .enumerable = true,
-                                            .value = jsi::String::createFromUtf8(runtime, typeName),
+                                            .value = jsi::String::createFromAscii(runtime, typeName),
                                             .writable = false,
                                         });
 #endif

package/cpp/core/HybridObject.hpp

@@ -90,7 +90,7 @@ public:
    * While two `jsi::Object`s of the same `HybridObject` might not be equal when compared with `==`,
    * they might still be the same `HybridObject` - in this case `equals(other)` will return true.
    */
-  bool equals(const std::shared_ptr<HybridObject>& other);
+  virtual bool equals(const std::shared_ptr<HybridObject>& other);
   /**
    * Get a string representation of this `HybridObject` - useful for logging or debugging.
    */

package/cpp/prototype/HybridObjectPrototype.cpp

@@ -55,25 +55,24 @@ jsi::Value HybridObjectPrototype::createPrototype(jsi::Runtime& runtime, const s
   }
 
   // 5. Add all properties (getter + setter) to it using defineProperty
-  for (const auto& getter : prototype->getGetters()) {
-    const auto& setter = prototype->getSetters().find(getter.first);
-    bool isReadonly = setter == prototype->getSetters().end();
-    const std::string& name = getter.first;
-    if (isReadonly) {
+  for (const auto& [name, getter] : prototype->getGetters()) {
+    const auto& setterIterator = prototype->getSetters().find(name);
+    if (setterIterator != prototype->getSetters().end()) {
+      // get + set
+      const HybridFunction& setter = setterIterator->second;
+      CommonGlobals::Object::defineProperty(runtime, object, name.c_str(),
+                                            ComputedPropertyDescriptor{// getter + setter
+                                                                       .configurable = false,
+                                                                       .enumerable = true,
+                                                                       .get = getter.toJSFunction(runtime),
+                                                                       .set = setter.toJSFunction(runtime)});
+    } else {
       // get
       CommonGlobals::Object::defineProperty(runtime, object, name.c_str(),
-                                            ComputedReadonlyPropertyDescriptor{// readonly
+                                            ComputedReadonlyPropertyDescriptor{// getter
                                                                                .configurable = false,
                                                                                .enumerable = true,
-                                                                               .get = getter.second.toJSFunction(runtime)});
-    } else {
-      // get + set
-      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)});
+                                                                               .get = getter.toJSFunction(runtime)});
     }
   }
 
@@ -84,7 +83,7 @@ jsi::Value HybridObjectPrototype::createPrototype(jsi::Runtime& runtime, const s
                                         PlainPropertyDescriptor{
                                             .configurable = false,
                                             .enumerable = true,
-                                            .value = jsi::String::createFromUtf8(runtime, prototypeName),
+                                            .value = jsi::String::createFromAscii(runtime, prototypeName),
                                             .writable = false,
                                         });
 #endif
@@ -97,13 +96,28 @@ jsi::Value HybridObjectPrototype::createPrototype(jsi::Runtime& runtime, const s
   // 8. Throw it into our cache so the next lookup can be cached and therefore faster
   JSICacheReference jsiCache = JSICache::getOrCreateCache(runtime);
   BorrowingReference<jsi::Object> sharedObject = jsiCache.makeShared(std::move(object));
-  auto instanceId = prototype->getNativeInstanceId();
+  const NativeInstanceId& instanceId = prototype->getNativeInstanceId();
   prototypeCache[instanceId] = sharedObject;
 
   // 9. Return it!
   return jsi::Value(runtime, *sharedObject);
 }
 
+void HybridObjectPrototype::ensureInitialized() {
+  if (!_didLoadMethods) {
+    // lock in case we try to create `HybridObject`s in parallel Runtimes
+    static std::mutex mutex;
+    std::unique_lock lock(mutex);
+    if (_didLoadMethods) [[unlikely]] {
+      // another call to `ensureInitialized()` has initialized in the meantime. abort.
+      return;
+    }
+    // lazy-load all exposed methods
+    loadHybridMethods();
+    _didLoadMethods = true;
+  }
+}
+
 jsi::Value HybridObjectPrototype::getPrototype(jsi::Runtime& runtime) {
   ensureInitialized();
 

package/cpp/prototype/HybridObjectPrototype.hpp

@@ -30,11 +30,6 @@ using namespace facebook;
  * as long as it has a valid NativeState (`this`).
  */
 class HybridObjectPrototype {
-private:
-  PrototypeChain _prototypeChain;
-  bool _didLoadMethods = false;
-  static constexpr auto TAG = "HybridObjectPrototype";
-
 public:
   HybridObjectPrototype() {}
 
@@ -62,13 +57,12 @@ private:
   /**
    * Ensures that all Hybrid Methods, Getters and Setters are initialized by calling loadHybridMethods().
    */
-  inline void ensureInitialized() {
-    if (!_didLoadMethods) [[unlikely]] {
-      // lazy-load all exposed methods
-      loadHybridMethods();
-      _didLoadMethods = true;
-    }
-  }
+  void ensureInitialized();
+
+private:
+  PrototypeChain _prototypeChain;
+  volatile bool _didLoadMethods = false;
+  static constexpr auto TAG = "HybridObjectPrototype";
 
 protected:
   using RegisterFn = void (*NON_NULL)(Prototype&);

package/cpp/utils/CommonGlobals.cpp

@@ -120,7 +120,7 @@ jsi::Value CommonGlobals::Promise::callConstructor(jsi::Runtime& runtime, jsi::H
   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));
+      jsi::Function::createFromHostFunction(runtime, PropNameIDCache::get(runtime, "executor"), 2, std::move(executor));
   return promiseCtor.callAsConstructor(runtime, std::move(executorFunc));
 }
 bool CommonGlobals::Promise::isInstanceOf(jsi::Runtime& runtime, const jsi::Object& object) {

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.32.0"
+#define NITRO_VERSION "0.32.1"
 
 // Sets whether to use debug or optimized production build flags
 #ifdef DEBUG

package/cpp/utils/PropNameIDCache.cpp

@@ -14,7 +14,7 @@ using namespace facebook;
 
 std::unordered_map<jsi::Runtime*, PropNameIDCache::CacheMap> PropNameIDCache::_cache;
 
-const jsi::PropNameID& PropNameIDCache::get(jsi::Runtime& runtime, std::string value) {
+const jsi::PropNameID& PropNameIDCache::get(jsi::Runtime& runtime, const std::string& value) {
   CacheMap& cache = _cache[&runtime];
   const auto& cachedName = cache.find(value);
   if (cachedName != cache.end()) {

package/cpp/utils/PropNameIDCache.hpp

@@ -31,10 +31,11 @@ public:
 
   /**
    * 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.
+   * - The `std::string` must be an ASCII string.
+   * - 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);
+  static const jsi::PropNameID& get(jsi::Runtime& runtime, const std::string& value);
 
 private:
   using CacheMap = std::unordered_map<std::string, BorrowingReference<jsi::PropNameID>>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-nitro-modules",
-  "version": "0.32.0",
+  "version": "0.32.1",
   "description": "Insanely fast native C++, Swift or Kotlin modules with a statically compiled binding layer to JSI.",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",