react-native-nitro-modules 0.31.3 → 0.31.5

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

@@ -29,6 +29,12 @@ public:
   static jni::local_ref<JAnyMap::jhybriddata> initHybrid(jni::alias_ref<jhybridobject>) {
     return makeCxxInstance();
   }
+  /**
+   * Create a new, empty `AnyMap` with the given preallocated size from Java.
+   */
+  static jni::local_ref<JAnyMap::jhybriddata> initHybridPreallocatedSize(jni::alias_ref<jhybridobject>, jint preallocatedSize) {
+    return makeCxxInstance(preallocatedSize);
+  }
   /**
    * Create a new `JAnyMap` from an existing `AnyMap`.
    */
@@ -38,7 +44,10 @@ public:
 
 private:
   JAnyMap() {
-    _map = std::make_shared<AnyMap>();
+    _map = AnyMap::make();
+  }
+  JAnyMap(jint preallocatedSize) {
+    _map = AnyMap::make(static_cast<size_t>(preallocatedSize));
   }
   explicit JAnyMap(const std::shared_ptr<AnyMap>& map) : _map(map) {}
 
@@ -100,7 +109,7 @@ protected:
   std::string getString(const std::string& key) {
     return _map->getString(key);
   }
-  jni::alias_ref<JAnyArray> getAnyArray(const std::string& 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++) {
@@ -109,7 +118,7 @@ protected:
     }
     return javaArray;
   }
-  jni::alias_ref<JAnyObject> getAnyObject(const std::string& key) {
+  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) {
@@ -119,6 +128,10 @@ protected:
     }
     return javaMap;
   }
+  jni::local_ref<JAnyValue::javaobject> getAnyValue(const std::string& key) {
+    const auto& any = _map->getAny(key);
+    return JAnyValue::create(any);
+  }
 
 protected:
   void setNull(const std::string& key) {
@@ -154,8 +167,17 @@ protected:
     }
     _map->setObject(key, map);
   }
+  void setAnyValue(const std::string& key, const jni::alias_ref<JAnyValue::javaobject>& value) {
+    _map->setAny(key, value->cthis()->getValue());
+  }
+
+protected:
+  void merge(jni::alias_ref<JAnyMap::javaobject> other) {
+    _map->merge(other->cthis()->_map);
+  }
 
 public:
+  [[nodiscard]]
   std::shared_ptr<AnyMap> getMap() const {
     return _map;
   }
@@ -170,6 +192,7 @@ public:
     registerHybrid({
         // init
         makeNativeMethod("initHybrid", JAnyMap::initHybrid),
+        makeNativeMethod("initHybrid", JAnyMap::initHybridPreallocatedSize),
         // helpers
         makeNativeMethod("contains", JAnyMap::contains),
         makeNativeMethod("remove", JAnyMap::remove),
@@ -190,6 +213,7 @@ public:
         makeNativeMethod("getString", JAnyMap::getString),
         makeNativeMethod("getAnyArray", JAnyMap::getAnyArray),
         makeNativeMethod("getAnyObject", JAnyMap::getAnyObject),
+        makeNativeMethod("getAnyValue", JAnyMap::getAnyValue),
         // set
         makeNativeMethod("setNull", JAnyMap::setNull),
         makeNativeMethod("setDouble", JAnyMap::setDouble),
@@ -198,6 +222,9 @@ public:
         makeNativeMethod("setString", JAnyMap::setString),
         makeNativeMethod("setAnyArray", JAnyMap::setAnyArray),
         makeNativeMethod("setAnyObject", JAnyMap::setAnyObject),
+        makeNativeMethod("setAnyValue", JAnyMap::setAnyValue),
+        // merge
+        makeNativeMethod("merge", JAnyMap::merge),
     });
   }
 };

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

@@ -125,7 +125,7 @@ protected:
   std::string asString() {
     return std::get<std::string>(_value);
   }
-  jni::alias_ref<JAnyArray> asAnyArray() {
+  jni::local_ref<JAnyArray> asAnyArray() {
     auto vector = std::get<AnyArray>(_value);
     auto javaArray = jni::JArrayClass<JAnyValue::javaobject>::newArray(vector.size());
     for (size_t i = 0; i < vector.size(); i++) {
@@ -134,7 +134,7 @@ protected:
     }
     return javaArray;
   }
-  jni::alias_ref<JAnyObject> asAnyObject() {
+  jni::local_ref<JAnyObject> asAnyObject() {
     auto map = std::get<AnyObject>(_value);
     auto javaMap = jni::JHashMap<jni::JString, JAnyValue::javaobject>::create(map.size());
     for (const auto& entry : map) {

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

@@ -4,6 +4,7 @@ import androidx.annotation.Keep
 import com.facebook.jni.HybridData
 import com.facebook.proguard.annotations.DoNotStrip
 import dalvik.annotation.optimization.FastNative
+import java.util.Dictionary
 
 /**
  * Represents an untyped map of string keys with associated values.
@@ -22,6 +23,13 @@ class AnyMap {
     mHybridData = initHybrid()
   }
 
+  /**
+   * Create a new empty `AnyMap` with the given preallocated size
+   */
+  constructor(preallocatedSize: Int) {
+    mHybridData = initHybrid(preallocatedSize)
+  }
+
   /**
    * Create a new `AnyMap` from C++, which potentially already holds data.
    */
@@ -30,6 +38,35 @@ class AnyMap {
     mHybridData = hybridData
   }
 
+  companion object {
+    fun fromMap(map: Map<String, Any?>): AnyMap {
+      val anyMap = AnyMap(map.size)
+      for ((key, value) in map) {
+        anyMap.setAny(key, value)
+      }
+      return anyMap
+    }
+  }
+
+  fun toMap(): Map<String, Any?> {
+    val map = HashMap<String, Any?>()
+    for (key in getAllKeys()) {
+      map.put(key, getAny(key))
+    }
+    return map
+  }
+
+  fun setAny(
+    key: String,
+    value: Any?,
+  ) {
+    setAnyValue(key, AnyValue.fromAny(value))
+  }
+
+  fun getAny(key: String): Any? {
+    return getAnyValue(key).toAny()
+  }
+
   @FastNative
   external fun contains(key: String): Boolean
 
@@ -77,6 +114,8 @@ class AnyMap {
 
   external fun getAnyObject(key: String): AnyObject
 
+  private external fun getAnyValue(key: String): AnyValue
+
   @FastNative
   external fun setNull(key: String)
 
@@ -114,5 +153,14 @@ class AnyMap {
     value: AnyObject,
   )
 
+  private external fun setAnyValue(
+    key: String,
+    value: AnyValue,
+  )
+
+  external fun merge(other: AnyMap)
+
   private external fun initHybrid(): HybridData
+
+  private external fun initHybrid(preallocatedSize: Int): HybridData
 }

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

@@ -31,6 +31,12 @@ class AnyValue {
     mHybridData = initHybrid()
   }
 
+  @DoNotStrip
+  @Keep
+  private constructor(mHybridData: HybridData) {
+    this.mHybridData = mHybridData
+  }
+
   /**
    * Create a new [AnyValue] that holds the given [Double]
    */
@@ -167,4 +173,56 @@ class AnyValue {
   private external fun initHybrid(value: AnyArray): HybridData
 
   private external fun initHybrid(value: AnyObject): HybridData
+
+  fun toAny(): Any? {
+    if (isNull()) {
+      return null
+    } else if (isDouble()) {
+      return asDouble()
+    } else if (isBigInt()) {
+      return asBigInt()
+    } else if (isBoolean()) {
+      return asBoolean()
+    } else if (isString()) {
+      return asString()
+    } else if (isAnyArray()) {
+      val mapped = asAnyArray().map { it.toAny() }
+      return mapped.toTypedArray()
+    } else if (isAnyObject()) {
+      val mapped = asAnyObject().mapValues { (key, value) -> value.toAny() }
+      return mapped
+    } else {
+      throw Error("AnyValue holds unknown type!")
+    }
+  }
+
+  companion object {
+    fun fromAny(value: Any?): AnyValue {
+      when (value) {
+        null -> return AnyValue()
+        is Double -> return AnyValue(value)
+        is Float -> return AnyValue(value.toDouble())
+        is Int -> return AnyValue(value.toDouble())
+        is Boolean -> return AnyValue(value)
+        is Long -> return AnyValue(value)
+        is String -> return AnyValue(value)
+        is Array<*> -> {
+          val mapped = value.map { v -> AnyValue.fromAny(v) }
+          return AnyValue(mapped.toTypedArray())
+        }
+        is List<*> -> {
+          val mapped = value.map { v -> AnyValue.fromAny(v) }
+          return AnyValue(mapped.toTypedArray())
+        }
+        is Map<*, *> -> {
+          val mapped = value.map { (k, v) -> k.toString() to AnyValue.fromAny(v) }
+          return AnyValue(mapped.toMap())
+        }
+        is AnyValue, is AnyMap -> {
+          throw Error("Cannot box AnyValue ($value) twice!")
+        }
+        else -> throw Error("Value \"$value\" cannot be represented as AnyValue!")
+      }
+    }
+  }
 }

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

@@ -187,3 +187,19 @@ class Promise<T> {
     }
   }
 }
+
+/**
+ * Resolves this `Promise<Unit>`.
+ * @since void overload
+ */
+fun Promise<Unit>.resolve() {
+  resolve(Unit)
+}
+
+/**
+ * Create an already resolved `Promise<Unit>`.
+ * @since void overload
+ */
+fun Promise.Companion.resolved(): Promise<Unit> {
+  return Promise.resolved(Unit)
+}

package/cpp/core/AnyMap.cpp

@@ -154,6 +154,13 @@ AnyObject AnyMap::getObject(const std::string& key) const {
     throw std::runtime_error("The value at key \"" + key + "\" is not an object!");
   }
 }
+AnyValue AnyMap::getAny(const std::string& key) const {
+  auto found = _map.find(key);
+  if (found == _map.end()) {
+    throw std::runtime_error("The key \"" + key + "\" does not exist in this Map!");
+  }
+  return found->second;
+}
 
 // Set
 void AnyMap::setNull(const std::string& key) {
@@ -186,4 +193,10 @@ const std::unordered_map<std::string, AnyValue>& AnyMap::getMap() const {
   return _map;
 }
 
+void AnyMap::merge(const std::shared_ptr<AnyMap>& other) {
+  for (auto& [key, value] : other->_map) {
+    _map[key] = value;
+  }
+}
+
 } // namespace margelo::nitro

package/cpp/core/AnyMap.hpp

@@ -36,15 +36,9 @@ struct AnyValue : VariantType {
  * 3. Objects of primitives
  */
 class AnyMap final {
-public:
-  /**
-   * Create a new instance of AnyMap.
-   */
+private:
   explicit AnyMap() {}
-  /**
-   * Create a new instance of AnyMap with the given amount of spaces pre-allocated.
-   */
-  explicit AnyMap(size_t size) {
+  AnyMap(size_t size) {
     _map.reserve(size);
   }
 
@@ -53,13 +47,13 @@ public:
    * Create a new `shared_ptr` instance of AnyMap.
    */
   static std::shared_ptr<AnyMap> make() {
-    return std::make_shared<AnyMap>();
+    return std::shared_ptr<AnyMap>(new AnyMap());
   }
   /**
    * Create a new `shared_ptr` instance of AnyMap with the given amount of spaces pre-allocated.
    */
   static std::shared_ptr<AnyMap> make(size_t size) {
-    return std::make_shared<AnyMap>(size);
+    return std::shared_ptr<AnyMap>(new AnyMap(size));
   }
 
 public:
@@ -154,6 +148,12 @@ public:
    */
   AnyObject getObject(const std::string& key) const;
 
+  /**
+   * Get the value at the given `key` as it's boxed `AnyValue`.
+   * If no object value exists at the given `key`, this method will throw.
+   */
+  AnyValue getAny(const std::string& key) const;
+
 public:
   /**
    * Set the value at the given key to `null`.
@@ -202,6 +202,12 @@ public:
    */
   const std::unordered_map<std::string, AnyValue>& getMap() const;
 
+public:
+  /**
+   * Merge all keys and values from given `other` `AnyMap` into this `AnyMap`.
+   */
+  void merge(const std::shared_ptr<AnyMap>& other);
+
 private:
   std::unordered_map<std::string, AnyValue> _map;
 } SWIFT_NONCOPYABLE;

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

package/ios/core/AnyMap.swift

@@ -28,7 +28,7 @@ public indirect enum AnyValue {
     } else if margelo.nitro.AnyMapUtils.is_AnyValue_bigint(value) {
       return .bigint(margelo.nitro.AnyMapUtils.get_AnyValue_bigint(value))
     } else if margelo.nitro.AnyMapUtils.is_AnyValue_string(value) {
-      return .string(margelo.nitro.AnyMapUtils.get_AnyValue_string(value).toSwift())
+      return .string(String(margelo.nitro.AnyMapUtils.get_AnyValue_string(value)))
     } else if margelo.nitro.AnyMapUtils.is_AnyValue_AnyArray(value) {
       return .array(margelo.nitro.AnyMapUtils.get_AnyValue_AnyArray(value).toSwift())
     } else if margelo.nitro.AnyMapUtils.is_AnyValue_AnyObject(value) {
@@ -151,6 +151,17 @@ public final class AnyMap: @unchecked Sendable {
     return value.toSwift()
   }
 
+  /**
+   * Gets the value value at the given key.
+   * If no value exists at the given key,
+   * this function throws.
+   */
+  public func getAny(key: String) -> Any? {
+    let value = cppPart.pointee.getAny(std.string(key))
+    let any = AnyValue.create(value)
+    return any.toAny()
+  }
+
   // pragma MARK: Setters
 
   /**
@@ -202,6 +213,15 @@ public final class AnyMap: @unchecked Sendable {
     cppPart.pointee.setObject(std.string(key), margelo.nitro.AnyObject.create(value))
   }
 
+  /**
+   * Set the given key to the given any value.
+   */
+  public func setAny(key: String, value: Any?) throws {
+    let swiftAny = try AnyValue.fromAny(value)
+    let cppAny = margelo.nitro.AnyValue.create(swiftAny)
+    cppPart.pointee.setAny(std.string(key), cppAny)
+  }
+
   // pragma MARK: Is Getters
 
   /**
@@ -252,6 +272,13 @@ public final class AnyMap: @unchecked Sendable {
   public func isObject(key: String) -> Bool {
     return cppPart.pointee.isObject(std.string(key))
   }
+
+  /**
+   * Merges all keys and values from the `other` map into this map.
+   */
+  public func merge(other: AnyMap) {
+    cppPart.pointee.merge(other.cppPart)
+  }
 }
 
 // pragma MARK: margelo.nitro.AnyValue extension
@@ -298,14 +325,6 @@ extension margelo.nitro.AnyValue {
   }
 }
 
-// pragma MARK: std.string extension
-
-extension std.string {
-  func toSwift() -> String {
-    return String(self)
-  }
-}
-
 // pragma MARK: margelo.nitro.AnyArray extension
 
 extension margelo.nitro.AnyArray {
@@ -351,5 +370,103 @@ extension margelo.nitro.AnyObject {
   }
 }
 
+// pragma MARK: AnyValue <-> Any extension
+
+extension AnyValue {
+  public static func fromAny(_ any: Any?) throws -> AnyValue {
+    switch any {
+    case nil:
+      return AnyValue.null
+    case let value as String:
+      return AnyValue.string(value)
+    case let value as Double:
+      return AnyValue.number(value)
+    case let value as Int:
+      return AnyValue.number(Double(value))
+    case let value as Float:
+      return AnyValue.number(Double(value))
+    case let value as Int64:
+      return AnyValue.bigint(value)
+    case let value as Bool:
+      return AnyValue.bool(value)
+    case let value as [Any]:
+      let array = try value.map { try AnyValue.fromAny($0) }
+      return AnyValue.array(array)
+    case let value as [String: Any]:
+      let map = try value.mapValues { try AnyValue.fromAny($0) }
+      return AnyValue.object(map)
+    case is AnyValue, is AnyMap, is margelo.nitro.AnyValue, is margelo.nitro.AnyArray,
+      is margelo.nitro.AnyObject:
+      throw RuntimeError.error(
+        withMessage: "Cannot box AnyValue (\(String(describing: any))) twice!")
+    default:
+      throw RuntimeError.error(
+        withMessage: "Value \(String(describing: any)) cannot be represented as AnyValue!")
+    }
+  }
+
+  public func toAny() -> Any? {
+    switch self {
+    case .null:
+      return nil
+    case .bigint(let int):
+      return int
+    case .bool(let bool):
+      return bool
+    case .number(let double):
+      return double
+    case .array(let array):
+      return array.map { $0.toAny() }
+    case .object(let object):
+      return object.mapValues { $0.toAny() }
+    case .string(let string):
+      return string
+    }
+  }
+}
+
+// pragma MARK: AnyMap <-> Any extension
+
+extension AnyMap {
+  /**
+  * Convert the given `Dictionary<String, Any?>` to an `AnyMap`
+  * by copying all keys and values into the C++ container.
+  * If a key cannot be wrapped as any, this will throw.
+  */
+  public static func fromDictionary(_ dictionary: [String: Any?]) throws -> AnyMap {
+    let map = AnyMap(withPreallocatedSize: dictionary.count)
+    for (key, value) in dictionary {
+      try map.setAny(key: key, value: value)
+    }
+    return map
+  }
+  /**
+  * Convert the given `Dictionary<String, Any?>` to an `AnyMap`
+  * by copying all keys and values into the C++ container.
+  * If a key cannot be wrapped as any, it will simply be ignored and omitted.
+  */
+  public static func fromDictionaryIgnoreIncompatible(_ dictionary: [String: Any?]) -> AnyMap {
+    let map = AnyMap(withPreallocatedSize: dictionary.count)
+    for (key, value) in dictionary {
+      try? map.setAny(key: key, value: value)
+    }
+    return map
+  }
+
+  /**
+  * Convert this `AnyMap` instance to a `Dictionary<String, Any?>`
+  * by copying all keys and values into a wrapped Swift container.
+  */
+  public func toDictionary() -> [String: Any?] {
+    var dictionary: [String: Any?] = [:]
+    let keys = self.getAllKeys()
+    dictionary.reserveCapacity(keys.count)
+    for key in keys {
+      dictionary[key] = self.getAny(key: key)
+    }
+    return dictionary
+  }
+}
+
 @available(*, deprecated, renamed: "AnyMap")
 public typealias AnyMapHolder = AnyMap

package/ios/core/Promise.swift

@@ -108,6 +108,7 @@ extension Promise {
   /**
    * Create a new `Promise<T>` that runs the given `run` function on a parallel Thread/`DispatchQueue`.
    */
+  @preconcurrency
   public static func parallel(
     _ queue: DispatchQueue = .global(),
     _ run: @escaping @Sendable () throws -> T
@@ -125,6 +126,22 @@ extension Promise {
   }
 }
 
+/// Void overloads to avoid typing out `()`
+extension Promise where T == Void {
+  /**
+   * Resolves this `Promise<Void>`.
+   */
+  public func resolve() {
+    return self.resolve(withResult: ())
+  }
+  /**
+   * Create an already resolved `Promise<Void>`.
+   */
+  public static func resolved() -> Promise {
+    return Self.resolved(withResult: ())
+  }
+}
+
 /// Extensions to support then/catch syntax.
 extension Promise {
   /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-nitro-modules",
-  "version": "0.31.3",
+  "version": "0.31.5",
   "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",