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

package/NitroModules.podspec

@@ -64,7 +64,7 @@ Pod::Spec.new do |s|
   xcconfig = {
     # Use C++ 20
     "CLANG_CXX_LANGUAGE_STANDARD" => "c++20",
-    # Enables C++ <-> Swift interop (by default it's only C)
+    # Enables C++ <-> Swift interop (by default its only ObjC)
     "SWIFT_OBJC_INTEROP_MODE" => "objcxx",
     # Enables stricter modular headers
     "DEFINES_MODULE" => "YES",

package/android/build.gradle

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

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

@@ -5,8 +5,6 @@
 //  Created by Marc Rousavy on 14.07.24.
 //
 
-#pragma once
-
 #include "JAnyMap.hpp"
 
 namespace margelo::nitro {
@@ -117,4 +115,104 @@ jni::local_ref<jni::JHashMap<jni::JString, jni::JObject>> JAnyMap::anyObjectToJH
   return jMap;
 }
 
+AnyValue JAnyMap::jObjectToAnyValue(jni::alias_ref<jni::JObject> jObject) {
+  if (!jObject) {
+    return nitro::null;
+  }
+
+  // Check for Double
+  if (jObject->isInstanceOf(jni::JDouble::javaClassStatic())) {
+    auto jDouble = jni::static_ref_cast<jni::JDouble>(jObject);
+    return jDouble->doubleValue();
+  }
+
+  // Check for Float
+  if (jObject->isInstanceOf(jni::JFloat::javaClassStatic())) {
+    auto jFloat = jni::static_ref_cast<jni::JFloat>(jObject);
+    return static_cast<double>(jFloat->floatValue());
+  }
+
+  // Check for Integer
+  if (jObject->isInstanceOf(jni::JInteger::javaClassStatic())) {
+    auto jInt = jni::static_ref_cast<jni::JInteger>(jObject);
+    return static_cast<double>(jInt->intValue());
+  }
+
+  // Check for Boolean
+  if (jObject->isInstanceOf(jni::JBoolean::javaClassStatic())) {
+    auto jBool = jni::static_ref_cast<jni::JBoolean>(jObject);
+    return jBool->booleanValue();
+  }
+
+  // Check for Long (bigint)
+  if (jObject->isInstanceOf(jni::JLong::javaClassStatic())) {
+    auto jLong = jni::static_ref_cast<jni::JLong>(jObject);
+    return jLong->longValue();
+  }
+
+  // Check for String
+  if (jObject->isInstanceOf(jni::JString::javaClassStatic())) {
+    auto jString = jni::static_ref_cast<jni::JString>(jObject);
+    return jString->toStdString();
+  }
+
+  // Check for List (array)
+  if (jObject->isInstanceOf(jni::JList<jni::JObject>::javaClassStatic())) {
+    auto jList = jni::static_ref_cast<jni::JList<jni::JObject>>(jObject);
+    return jListToAnyArray(jList);
+  }
+
+  // Check for Map (object)
+  if (jObject->isInstanceOf(jni::JMap<jni::JString, jni::JObject>::javaClassStatic())) {
+    auto jMap = jni::static_ref_cast<jni::JMap<jni::JString, jni::JObject>>(jObject);
+    return jHashMapToAnyObject(jMap);
+  }
+
+  throw std::runtime_error("Cannot convert JObject to AnyValue - unsupported type!");
+}
+
+AnyArray JAnyMap::jListToAnyArray(jni::alias_ref<jni::JList<jni::JObject>> jList) {
+  AnyArray array;
+  array.reserve(jList->size());
+  for (const auto& item : *jList) {
+    array.push_back(jObjectToAnyValue(item));
+  }
+  return array;
+}
+
+AnyObject JAnyMap::jHashMapToAnyObject(jni::alias_ref<jni::JMap<jni::JString, jni::JObject>> jMap) {
+  AnyObject object;
+  object.reserve(jMap->size());
+  for (const auto& entry : *jMap) {
+    object.emplace(entry.first->toStdString(), jObjectToAnyValue(entry.second));
+  }
+  return object;
+}
+
+jni::local_ref<JAnyMap::javaobject> JAnyMap::fromMap(jni::alias_ref<jclass>, jni::alias_ref<jni::JMap<jni::JString, jni::JObject>> javaMap,
+                                                     bool ignoreIncompatible) {
+  size_t size = javaMap->size();
+  jni::local_ref<JAnyMap::javaobject> anyMap = JAnyMap::create(size);
+
+  auto& map = anyMap->cthis()->_map->getMap();
+
+  // Bulk convert all entries from Java to C++
+  for (const auto& entry : *javaMap) {
+    try {
+      std::string key = entry.first->toStdString();
+      AnyValue value = jObjectToAnyValue(entry.second);
+      map.emplace(std::move(key), std::move(value));
+    } catch (...) {
+      if (ignoreIncompatible) {
+        // encountered an incompatible key. Ignore it.
+      } else {
+        // encountered an incompatible key - we now throw!
+        throw;
+      }
+    }
+  }
+
+  return anyMap;
+}
+
 } // namespace margelo::nitro

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

@@ -41,6 +41,18 @@ public:
   static jni::local_ref<JAnyMap::javaobject> create(const std::shared_ptr<AnyMap>& map) {
     return newObjectCxxArgs(map);
   }
+  /**
+   * Create a new `JAnyMap` from the given preallocated size.
+   */
+  static jni::local_ref<JAnyMap::javaobject> create(int preallocatedSize) {
+    return newObjectCxxArgs(preallocatedSize);
+  }
+  /**
+   * Create a new empty `JAnyMap`.
+   */
+  static jni::local_ref<JAnyMap::javaobject> create() {
+    return newObjectCxxArgs();
+  }
 
 private:
   JAnyMap() {
@@ -133,11 +145,24 @@ protected:
    */
   jni::local_ref<jni::JHashMap<jni::JString, jni::JObject>> toHashMap();
 
+  /**
+   * Bulk-converts a Java `Map<String, Object>` into this `JAnyMap` in a single JNI call.
+   *
+   * When `ignoreIncompatible` is `true`, this will drop keys that can't be converted.
+   * When `ignoreIncompatible` is `false`, this will throw when a key cannot be converted.
+   */
+  static jni::local_ref<JAnyMap::javaobject> fromMap(jni::alias_ref<jclass>, jni::alias_ref<jni::JMap<jni::JString, jni::JObject>> javaMap,
+                                                     bool ignoreIncompatible);
+
 private:
   static jni::local_ref<jni::JObject> anyValueToJObject(const AnyValue& value);
   static jni::local_ref<jni::JArrayList<jni::JObject>> anyArrayToJList(const AnyArray& array);
   static jni::local_ref<jni::JHashMap<jni::JString, jni::JObject>> anyObjectToJHashMap(const AnyObject& object);
 
+  static AnyValue jObjectToAnyValue(jni::alias_ref<jni::JObject> jObject);
+  static AnyArray jListToAnyArray(jni::alias_ref<jni::JList<jni::JObject>> jList);
+  static AnyObject jHashMapToAnyObject(jni::alias_ref<jni::JMap<jni::JString, jni::JObject>> jMap);
+
 public:
   [[nodiscard]]
   std::shared_ptr<AnyMap> getMap() const {
@@ -189,6 +214,7 @@ public:
         makeNativeMethod("merge", JAnyMap::merge),
         // bulk conversion
         makeNativeMethod("toHashMap", JAnyMap::toHashMap),
+        makeNativeMethod("fromMap", JAnyMap::fromMap),
     });
   }
 };

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

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

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

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

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

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

package/cpp/core/AnyMap.cpp

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

package/cpp/core/AnyMap.hpp

@@ -201,7 +201,7 @@ public:
   /**
    * Get the actual C++ map that holds all keys and variant values.
    */
-  const std::unordered_map<std::string, AnyValue>& getMap() const;
+  std::unordered_map<std::string, AnyValue>& getMap();
 
 public:
   /**

package/cpp/core/ArrayBuffer.hpp

@@ -28,7 +28,7 @@ using DeleteFn = std::function<void()>;
  * - `NativeArrayBuffer`: Created from native (C++), and can either own the memory (`isOwner()`), or borrow it.
  * - `JSArrayBuffer`: Received from JS, and will only be alive for as long as the JS Runtime is actually alive.
  *
- * Also, an `ArrayBuffer` can either own it's memory, or just borrow it's memory.
+ * Also, an `ArrayBuffer` can either own its memory, or just borrow its memory.
  * - Owning = the `ArrayBuffer`'s `data()` is alive as long as the `ArrayBuffer` is alive.
  *   When this `ArrayBuffer` gets deleted, it will free the memory.
  * - Borrowed = the `ArrayBuffer`'s `data()` might be deleted at any point from an external source (e.g. the JS garbage collector).
@@ -116,13 +116,13 @@ private:
 /**
  * Represents a JS-based `ArrayBuffer`.
  *
- * While it's underlying data might have been allocated on the native side (`NativeArrayBuffer`),
+ * While its underlying data might have been allocated on the native side (`NativeArrayBuffer`),
  * we only have a JS reference to the `ArrayBuffer` object so it is considered a "borrowed"-resource.
  *
  * `data()` and `size()` can only be accessed synchronously on the JS Runtime Thread.
  * If you want to access it elsewhere, copy the buffer first.
  *
- * If the JS ArrayBuffer (or it's JS Runtime) have already been deleted, `data()` returns `nullptr`.
+ * If the JS ArrayBuffer (or its JS Runtime) have already been deleted, `data()` returns `nullptr`.
  */
 class JSArrayBuffer final : public ArrayBuffer {
 public:

package/cpp/core/HybridObject.hpp

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

package/cpp/entrypoint/HybridNitroModulesProxy.cpp

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

package/cpp/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+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/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/utils/JSCallback.hpp

@@ -35,7 +35,7 @@ public:
 public:
   /**
    * Calls this `SyncJSCallback` synchronously, and
-   * returns it's result (`R`).
+   * returns its result (`R`).
    * The callee is responsible for ensuring that the
    * underlying `jsi::Function` can actually be called from this Thread.
    * In Debug, sanity checks are made to ensure the `jsi::Function` is still alive.

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

package/ios/core/HybridObject.swift

@@ -30,7 +30,7 @@ public protocol HybridObject: AnyObject {
    * Eagerly- (and manually-) dispose all native resources this `HybridObject` holds.
    * This method can only be manually called from JS using `dispose()`.
    *
-   * If this method is never manually called, a `HybridObject` is expected to disposes it's
+   * If this method is never manually called, a `HybridObject` is expected to disposes its
    * resources as usual via the object's destructor (`~HybridObject()`, `deinit` or `finalize()`).
    *
    * By default, this method does nothing. It can be overridden to perform actual disposing/cleanup

package/ios/utils/SwiftClosure.swift

@@ -31,7 +31,7 @@ extension SwiftClosure {
    * This can then be called from both C++ and Swift.
    */
   public init(wrappingClosure closure: @escaping () -> Void) {
-    // Wrap closure in void*, and increment it's ref count so it stays alive.
+    // Wrap closure in void*, and increment its ref count so it stays alive.
     let context = Unmanaged.passRetained(ClosureWrapper(closure: closure)).toOpaque()
 
     // Create a C-style Function Pointer, which calls the actual Swift closure.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-nitro-modules",
-  "version": "0.32.0-beta.0",
+  "version": "0.32.0",
   "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",