react-native-nitro-modules 0.26.2 → 0.26.4

package/cpp/core/ArrayBuffer.hpp

@@ -63,6 +63,10 @@ public:
    * Create a new `NativeArrayBuffer` that copies the given `std::vector`.
    */
   static std::shared_ptr<ArrayBuffer> copy(const std::vector<uint8_t>& data);
+  /**
+   * Create a new `NativeArrayBuffer` that copies the given `std::shared_ptr<ArrayBuffer>`.
+   */
+  static std::shared_ptr<ArrayBuffer> copy(const std::shared_ptr<ArrayBuffer>& buffer);
   /**
    * Create a new `NativeArrayBuffer` that allocates a new buffer of the given size.
    */
@@ -134,6 +138,11 @@ public:
    */
   bool isOwner() const noexcept override;
 
+public:
+  BorrowingReference<jsi::ArrayBuffer> getJSReference() const noexcept {
+    return _jsReference;
+  }
+
 private:
   jsi::Runtime& _runtime;
   BorrowingReference<jsi::ArrayBuffer> _jsReference;

package/cpp/core/HybridFunction.hpp

@@ -109,17 +109,6 @@ public:
         std::string funcName = getHybridFuncFullName<THybrid>(kind, name, hybridInstance.get());
         std::string message = exception.what();
         throw jsi::JSError(runtime, funcName + ": " + message);
-#ifdef ANDROID
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wexceptions"
-        // Workaround for https://github.com/mrousavy/nitro/issues/382
-      } catch (const std::runtime_error& exception) {
-        // Some exception was thrown - add method name information and re-throw as `JSError`.
-        std::string funcName = getHybridFuncFullName<THybrid>(kind, name, hybridInstance.get());
-        std::string message = exception.what();
-        throw jsi::JSError(runtime, funcName + ": " + message);
-#pragma clang diagnostic pop
-#endif
       } catch (...) {
         // Some unknown exception was thrown - add method name information and re-throw as `JSError`.
         std::string funcName = getHybridFuncFullName<THybrid>(kind, name, hybridInstance.get());
@@ -181,8 +170,9 @@ private:
    * Get the `NativeState` of the given `value`.
    */
   template <typename THybrid>
-  static inline std::shared_ptr<THybrid> getHybridObjectNativeState(jsi::Runtime& runtime, const jsi::Value& value, FunctionKind funcKind,
-                                                                    const std::string& funcName) {
+  static inline std::shared_ptr<THybrid> getHybridObjectNativeState(jsi::Runtime& runtime, const jsi::Value& value,
+                                                                    [[maybe_unused]] FunctionKind funcKind,
+                                                                    [[maybe_unused]] const std::string& funcName) {
     // 1. Convert jsi::Value to jsi::Object
 #ifdef NITRO_DEBUG
     if (!value.isObject()) [[unlikely]] {

package/cpp/jsi/JSIConverter+ArrayBuffer.hpp

@@ -27,6 +27,12 @@ namespace margelo::nitro {
 
 using namespace facebook;
 
+struct MutableBufferNativeState final : public jsi::NativeState {
+public:
+  explicit MutableBufferNativeState(const std::shared_ptr<jsi::MutableBuffer>& buffer) : buffer(buffer) {}
+  std::shared_ptr<jsi::MutableBuffer> buffer;
+};
+
 // MutableBuffer <> ArrayBuffer
 template <typename T>
 struct JSIConverter<T, std::enable_if_t<is_shared_ptr_to_v<T, jsi::MutableBuffer>>> final {
@@ -47,6 +53,14 @@ struct JSIConverter<T, std::enable_if_t<is_shared_ptr_to_v<T, jsi::MutableBuffer
                                   "Are you maybe passing a TypedArray (e.g. Uint8Array)? Try to pass it's `.buffer` value.");
     }
 #endif
+    if (object.hasNativeState<MutableBufferNativeState>(runtime)) {
+      // It already is a NativeBuffer! Let's get the jsi::MutableBuffer from the jsi::NativeState...
+      auto mutableBufferHolder = object.getNativeState<MutableBufferNativeState>(runtime);
+      auto mutableBuffer = mutableBufferHolder->buffer;
+      if (auto arrayBuffer = std::dynamic_pointer_cast<ArrayBuffer>(mutableBuffer)) [[likely]] {
+        return arrayBuffer;
+      }
+    }
 
     JSICacheReference cache = JSICache::getOrCreateCache(runtime);
     auto borrowingArrayBuffer = cache.makeShared(object.getArrayBuffer(runtime));
@@ -54,7 +68,21 @@ struct JSIConverter<T, std::enable_if_t<is_shared_ptr_to_v<T, jsi::MutableBuffer
     return std::make_shared<JSArrayBuffer>(runtime, borrowingArrayBuffer);
   }
   static inline jsi::Value toJSI(jsi::Runtime& runtime, const std::shared_ptr<jsi::MutableBuffer>& buffer) {
-    return jsi::ArrayBuffer(runtime, 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...
+      auto jsValue = jsBuffer->getJSReference();
+      if (jsValue != nullptr) [[likely]] {
+        return jsi::Value(runtime, *jsValue);
+      }
+    }
+
+    // 1. Create jsi::ArrayBuffer
+    jsi::ArrayBuffer arrayBuffer(runtime, buffer);
+    // 2. Wrap jsi::MutableBuffer in jsi::NativeState holder & attach it
+    auto mutableBufferHolder = std::make_shared<MutableBufferNativeState>(buffer);
+    arrayBuffer.setNativeState(runtime, mutableBufferHolder);
+    // 3. Return jsi::ArrayBuffer (with jsi::NativeState) to JS
+    return arrayBuffer;
   }
   static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
     if (value.isObject()) {

package/cpp/jsi/JSIConverter+Exception.hpp

@@ -39,15 +39,6 @@ struct JSIConverter<std::exception_ptr> final {
     } catch (const std::exception& e) {
       jsi::JSError error(runtime, e.what());
       return jsi::Value(runtime, error.value());
-#ifdef ANDROID
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wexceptions"
-      // Workaround for https://github.com/mrousavy/nitro/issues/382
-    } catch (const std::runtime_error& e) {
-      jsi::JSError error(runtime, e.what());
-      return jsi::Value(runtime, error.value());
-#pragma clang diagnostic pop
-#endif
     } catch (...) {
       // Some unknown exception was thrown - maybe an Objective-C error?
       std::string errorName = TypeInfo::getCurrentExceptionName();

package/cpp/platform/NitroLogger.hpp

@@ -22,7 +22,8 @@ private:
 
 public:
   template <typename... Args>
-  static void log(LogLevel level, const char* tag, const char* format, Args... args) {
+  static void log([[maybe_unused]] LogLevel level, [[maybe_unused]] const char* tag, [[maybe_unused]] const char* format,
+                  [[maybe_unused]] Args... args) {
 #ifdef NITRO_DEBUG
     // 1. Make sure args can be passed to sprintf(..)
     static_assert(all_are_trivially_copyable<Args...>(), "All arguments passed to Logger::log(..) must be trivially copyable! "

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

package/ios/core/{AnyMapHolder.swift → AnyMap.swift}

@@ -1,5 +1,5 @@
 //
-//  AnyMapHolder.swift
+//  AnyMap.swift
 //  NitroModules
 //
 //  Created by Marc Rousavy on 20.08.24.
@@ -21,20 +21,20 @@ public indirect enum AnyValue {
   case object(Dictionary<String, AnyValue>)
 
   static func create(_ value: margelo.nitro.AnyValue) -> AnyValue {
-    if margelo.nitro.is_AnyValue_null(value) {
+    if margelo.nitro.AnyMapUtils.is_AnyValue_null(value) {
       return .null
-    } else if margelo.nitro.is_AnyValue_bool(value) {
-      return .bool(margelo.nitro.get_AnyValue_bool(value))
-    } else if margelo.nitro.is_AnyValue_number(value) {
-      return .number(margelo.nitro.get_AnyValue_number(value))
-    } else if margelo.nitro.is_AnyValue_bigint(value) {
-      return .bigint(margelo.nitro.get_AnyValue_bigint(value))
-    } else if margelo.nitro.is_AnyValue_string(value) {
-      return .string(margelo.nitro.get_AnyValue_string(value).toSwift())
-    } else if margelo.nitro.is_AnyValue_AnyArray(value) {
-      return .array(margelo.nitro.get_AnyValue_AnyArray(value).toSwift())
-    } else if margelo.nitro.is_AnyValue_AnyObject(value) {
-      return .object(margelo.nitro.get_AnyValue_AnyObject(value).toSwift())
+    } else if margelo.nitro.AnyMapUtils.is_AnyValue_bool(value) {
+      return .bool(margelo.nitro.AnyMapUtils.get_AnyValue_bool(value))
+    } else if margelo.nitro.AnyMapUtils.is_AnyValue_number(value) {
+      return .number(margelo.nitro.AnyMapUtils.get_AnyValue_number(value))
+    } 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())
+    } 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) {
+      return .object(margelo.nitro.AnyMapUtils.get_AnyValue_AnyObject(value).toSwift())
     } else {
       fatalError("AnyValue has unknown type!")
     }
@@ -42,10 +42,11 @@ public indirect enum AnyValue {
 }
 
 /**
- * Represents an `AnyMap` that can be passed to Swift.
+ * Represents an `AnyMap`- an untyped map instance.
+ * See C++ `AnyMap.hpp` for more information.
  */
-public final class AnyMapHolder {
-  public let cppPart: margelo.nitro.TSharedMap
+public final class AnyMap {
+  public let cppPart: margelo.nitro.SharedAnyMap
 
   public init() {
     cppPart = margelo.nitro.AnyMap.make()
@@ -55,7 +56,7 @@ public final class AnyMapHolder {
     cppPart = margelo.nitro.AnyMap.make(size)
   }
 
-  public init(withCppPart otherCppPart: margelo.nitro.TSharedMap) {
+  public init(withCppPart otherCppPart: margelo.nitro.SharedAnyMap) {
     cppPart = otherCppPart
   }
 
@@ -279,25 +280,25 @@ extension margelo.nitro.AnyValue {
     }
   }
   static func create() -> margelo.nitro.AnyValue {
-    return margelo.nitro.create_AnyValue()
+    return margelo.nitro.AnyMapUtils.create_AnyValue()
   }
   static func create(_ value: Bool) -> margelo.nitro.AnyValue {
-    return margelo.nitro.create_AnyValue(value)
+    return margelo.nitro.AnyMapUtils.create_AnyValue(value)
   }
   static func create(_ value: Double) -> margelo.nitro.AnyValue {
-    return margelo.nitro.create_AnyValue(value)
+    return margelo.nitro.AnyMapUtils.create_AnyValue(value)
   }
   static func create(_ value: Int64) -> margelo.nitro.AnyValue {
-    return margelo.nitro.create_AnyValue(value)
+    return margelo.nitro.AnyMapUtils.create_AnyValue(value)
   }
   static func create(_ value: String) -> margelo.nitro.AnyValue {
-    return margelo.nitro.create_AnyValue(std.string(value))
+    return margelo.nitro.AnyMapUtils.create_AnyValue(std.string(value))
   }
   static func create(_ value: [AnyValue]) -> margelo.nitro.AnyValue {
-    return margelo.nitro.create_AnyValue(margelo.nitro.AnyArray.create(value))
+    return margelo.nitro.AnyMapUtils.create_AnyValue(margelo.nitro.AnyArray.create(value))
   }
   static func create(_ value: Dictionary<String, AnyValue>) -> margelo.nitro.AnyValue {
-    return margelo.nitro.create_AnyValue(margelo.nitro.AnyObject.create(value))
+    return margelo.nitro.AnyMapUtils.create_AnyValue(margelo.nitro.AnyObject.create(value))
   }
 }
 
@@ -344,12 +345,16 @@ extension margelo.nitro.AnyObject {
   }
 
   func toSwift() -> Dictionary<String, AnyValue> {
-    let keys = margelo.nitro.getAnyObjectKeys(self)
+    let keys = margelo.nitro.AnyMapUtils.getAnyObjectKeys(self)
     var dictionary = Dictionary<String, AnyValue>(minimumCapacity: keys.size())
     for key in keys {
-      let value = margelo.nitro.getAnyObjectValue(self, key)
+      let value = margelo.nitro.AnyMapUtils.getAnyObjectValue(self, key)
       dictionary[String(key)] = AnyValue.create(value)
     }
     return dictionary
   }
 }
+
+
+@available(*, deprecated, renamed: "AnyMap")
+public typealias AnyMapHolder = AnyMap

package/ios/core/{ArrayBufferHolder.swift → ArrayBuffer.swift}

@@ -1,5 +1,5 @@
 //
-//  ArrayBufferHolder.swift
+//  ArrayBuffer.swift
 //  NitroModules
 //
 //  Created by Marc Rousavy on 17.07.24.
@@ -13,36 +13,39 @@ import Foundation
  *
  * See `data`, `size` and `isOwning`.
  */
-public typealias ArrayBufferHolder = margelo.nitro.ArrayBufferHolder
+public typealias ArrayBuffer = margelo.nitro.ArrayBufferHolder
+
+@available(*, deprecated, renamed: "ArrayBuffer")
+public typealias ArrayBufferHolder = ArrayBuffer
 
 // pragma MARK: Wrap
 
-public extension ArrayBufferHolder {
+public extension ArrayBuffer {
   /**
-   * Create a new `ArrayBufferHolder` that wraps the given `data` of the given `size`
+   * Create a new `ArrayBuffer` that wraps the given `data` of the given `size`
    * without performing a copy.
    * When the `ArrayBuffer` is no longer used, `onDelete` will be called, in which
    * you as a caller are responsible for deleting `data`.
    */
   static func wrap(dataWithoutCopy data: UnsafeMutablePointer<UInt8>,
                    size: Int,
-                   onDelete delete: @escaping () -> Void) -> ArrayBufferHolder {
+                   onDelete delete: @escaping () -> Void) -> ArrayBuffer {
     // Convert escaping Swift closure to a `void*`
     let swiftClosure = SwiftClosure(wrappingClosure: delete)
-    // Create ArrayBufferHolder with our wrapped Swift closure to make it callable as a C-function pointer
-    return ArrayBufferHolder.wrap(data, size, swiftClosure)
+    // Create ArrayBuffer with our wrapped Swift closure to make it callable as a C-function pointer
+    return ArrayBuffer.wrap(data, size, swiftClosure)
   }
 
   /**
-   * Create a new `ArrayBufferHolder` that wraps the given `data` of the given `size`
+   * Create a new `ArrayBuffer` that wraps the given `data` of the given `size`
    * without performing a copy.
    * When the `ArrayBuffer` is no longer used, `onDelete` will be called, in which
    * you as a caller are responsible for deleting `data`.
    */
   static func wrap(dataWithoutCopy data: UnsafeMutableRawPointer,
                    size: Int,
-                   onDelete delete: @escaping () -> Void) -> ArrayBufferHolder {
-    return ArrayBufferHolder.wrap(dataWithoutCopy: data.assumingMemoryBound(to: UInt8.self),
+                   onDelete delete: @escaping () -> Void) -> ArrayBuffer {
+    return ArrayBuffer.wrap(dataWithoutCopy: data.assumingMemoryBound(to: UInt8.self),
                                   size: size,
                                   onDelete: delete)
   }
@@ -50,12 +53,12 @@ public extension ArrayBufferHolder {
 
 // pragma MARK: Allocate
 
-public extension ArrayBufferHolder {
+public extension ArrayBuffer {
   /**
    * Allocate a new buffer of the given `size`.
    * If `initializeToZero` is `true`, all bytes are set to `0`, otherwise they are left untouched.
    */
-  static func allocate(size: Int, initializeToZero: Bool = false) -> ArrayBufferHolder {
+  static func allocate(size: Int, initializeToZero: Bool = false) -> ArrayBuffer {
     let data = UnsafeMutablePointer<UInt8>.allocate(capacity: size)
     if initializeToZero {
       data.initialize(repeating: 0, count: size)
@@ -63,18 +66,18 @@ public extension ArrayBufferHolder {
     let deleteFunc = SwiftClosure {
       data.deallocate()
     }
-    return ArrayBufferHolder.wrap(data, size, deleteFunc)
+    return ArrayBuffer.wrap(data, size, deleteFunc)
   }
 }
 
 // pragma MARK: Copy
 
-public extension ArrayBufferHolder {
+public extension ArrayBuffer {
   /**
-   * Copy the given `UnsafeMutablePointer<UInt8>` into a new **owning** `ArrayBufferHolder`.
+   * Copy the given `UnsafeMutablePointer<UInt8>` into a new **owning** `ArrayBuffer`.
    */
   static func copy(of other: UnsafeMutablePointer<UInt8>,
-                   size: Int) -> ArrayBufferHolder {
+                   size: Int) -> ArrayBuffer {
     // 1. Create new `UnsafeMutablePointer<UInt8>`
     let copy = UnsafeMutablePointer<UInt8>.allocate(capacity: size)
     // 2. Copy over data
@@ -83,32 +86,32 @@ public extension ArrayBufferHolder {
     let deleteFunc = SwiftClosure {
       copy.deallocate()
     }
-    return ArrayBufferHolder.wrap(copy, size, deleteFunc)
+    return ArrayBuffer.wrap(copy, size, deleteFunc)
   }
 
   /**
-   * Copy the given `UnsafeMutableRawPointer` into a new **owning** `ArrayBufferHolder`.
+   * Copy the given `UnsafeMutableRawPointer` into a new **owning** `ArrayBuffer`.
    */
   static func copy(of other: UnsafeMutableRawPointer,
-                   size: Int) -> ArrayBufferHolder {
-    return ArrayBufferHolder.copy(of: other.assumingMemoryBound(to: UInt8.self),
+                   size: Int) -> ArrayBuffer {
+    return ArrayBuffer.copy(of: other.assumingMemoryBound(to: UInt8.self),
                                   size: size)
   }
 
   /**
-   * Copy the given `ArrayBufferHolder` into a new **owning** `ArrayBufferHolder`.
+   * Copy the given `ArrayBuffer` into a new **owning** `ArrayBuffer`.
    */
-  static func copy(of other: ArrayBufferHolder) -> ArrayBufferHolder {
-    return ArrayBufferHolder.copy(of: other.data, size: other.size)
+  static func copy(of other: ArrayBuffer) -> ArrayBuffer {
+    return ArrayBuffer.copy(of: other.data, size: other.size)
   }
 
   /**
-   * Copy the given `Data` into a new **owning** `ArrayBufferHolder`.
+   * Copy the given `Data` into a new **owning** `ArrayBuffer`.
    */
-  static func copy(data: Data) throws -> ArrayBufferHolder {
+  static func copy(data: Data) throws -> ArrayBuffer {
     // 1. Create new `ArrayBuffer` of same size
     let size = data.count
-    let arrayBuffer = ArrayBufferHolder.allocate(size: size)
+    let arrayBuffer = ArrayBuffer.allocate(size: size)
     // 2. Copy all bytes from `Data` into our new `ArrayBuffer`
     try data.withUnsafeBytes { rawPointer in
       guard let baseAddress = rawPointer.baseAddress else {
@@ -123,9 +126,9 @@ public extension ArrayBufferHolder {
 
 // pragma MARK: Data
 
-public extension ArrayBufferHolder {
+public extension ArrayBuffer {
   /**
-   * Wrap this `ArrayBufferHolder` in a `Data` instance, without performing a copy.
+   * Wrap this `ArrayBuffer` in a `Data` instance, without performing a copy.
    * - `copyIfNeeded`: If this `ArrayBuffer` is **non-owning**, the foreign
    *                   data may needs to be copied to be safely used outside of the scope of the caller function.
    *                   This flag controls that.

package/ios/core/ArrayBufferHolder.hpp

@@ -24,7 +24,7 @@ using namespace facebook;
  * Passing around instances of `ArrayBufferHolder` (or `std::shared_ptr<ArrayBuffer>`)
  * does not involve any data copies and is almost zero-overhead - even when passed to JS.
  */
-class ArrayBufferHolder {
+class ArrayBufferHolder final {
 public:
   ArrayBufferHolder(const std::shared_ptr<ArrayBuffer>& arrayBuffer) : _arrayBuffer(arrayBuffer) {}
 

package/ios/utils/AnyMapHolder.hpp

@@ -0,0 +1,13 @@
+//
+//  AnyMapHolder.hpp
+//  NitroModules
+//
+//  Created by Marc Rousavy on 20.08.24.
+//
+
+#pragma once
+
+#include "AnyMapUtils.hpp"
+
+// THIS HEADER IS DEPRECATED! Update to latest Nitro
+#warning "AnyMapHolder.hpp is deprecated. Update Nitro to the latest version to use AnyMapUtils.hpp instead!"

package/ios/utils/AnyMapUtils.hpp

@@ -0,0 +1,107 @@
+//
+//  AnyMapUtils.hpp
+//  NitroModules
+//
+//  Created by Marc Rousavy on 20.08.24.
+//
+
+#pragma once
+
+#include "AnyMap.hpp"
+
+namespace margelo::nitro {
+
+using SharedAnyMap = std::shared_ptr<AnyMap>;
+
+// TODO: Remove TSharedMap.
+/// @deprecated
+using TSharedMap = SharedAnyMap;
+
+namespace AnyMapUtils {
+
+  inline AnyValue create_AnyValue() {
+    return AnyValue{std::monostate{}};
+  }
+  inline AnyValue create_AnyValue(bool boolValue) {
+    return AnyValue{boolValue};
+  }
+  inline AnyValue create_AnyValue(double doubleValue) {
+    return AnyValue{doubleValue};
+  }
+  inline AnyValue create_AnyValue(int64_t bigintValue) {
+    return AnyValue{bigintValue};
+  }
+  inline AnyValue create_AnyValue(const std::string& stringValue) {
+    return AnyValue{stringValue};
+  }
+  inline AnyValue create_AnyValue(const AnyArray& arrayValue) {
+    return AnyValue{arrayValue};
+  }
+  inline AnyValue create_AnyValue(const AnyObject& objectValue) {
+    return AnyValue{objectValue};
+  }
+
+  inline bool is_AnyValue_null(const AnyValue& value) {
+    return std::holds_alternative<std::monostate>(value);
+  }
+  inline bool is_AnyValue_bool(const AnyValue& value) {
+    return std::holds_alternative<bool>(value);
+  }
+  inline bool is_AnyValue_number(const AnyValue& value) {
+    return std::holds_alternative<double>(value);
+  }
+  inline bool is_AnyValue_bigint(const AnyValue& value) {
+    return std::holds_alternative<int64_t>(value);
+  }
+  inline bool is_AnyValue_string(const AnyValue& value) {
+    return std::holds_alternative<std::string>(value);
+  }
+  inline bool is_AnyValue_AnyArray(const AnyValue& value) {
+    return std::holds_alternative<AnyArray>(value);
+  }
+  inline bool is_AnyValue_AnyObject(const AnyValue& value) {
+    return std::holds_alternative<AnyObject>(value);
+  }
+
+  inline std::monostate get_AnyValue_null(const AnyValue& value) {
+    return std::get<std::monostate>(value);
+  }
+  inline bool get_AnyValue_bool(const AnyValue& value) {
+    return std::get<bool>(value);
+  }
+  inline double get_AnyValue_number(const AnyValue& value) {
+    return std::get<double>(value);
+  }
+  inline int64_t get_AnyValue_bigint(const AnyValue& value) {
+    return std::get<int64_t>(value);
+  }
+  inline std::string get_AnyValue_string(const AnyValue& value) {
+    return std::get<std::string>(value);
+  }
+  inline AnyArray get_AnyValue_AnyArray(const AnyValue& value) {
+    return std::get<AnyArray>(value);
+  }
+  inline AnyObject get_AnyValue_AnyObject(const AnyValue& value) {
+    return std::get<AnyObject>(value);
+  }
+
+  inline std::vector<std::string> getAnyObjectKeys(const AnyObject& object) {
+    std::vector<std::string> keys;
+    keys.reserve(object.size());
+    for (const auto& entry : object) {
+      keys.push_back(entry.first);
+    }
+    return keys;
+  }
+
+  inline AnyValue getAnyObjectValue(const AnyObject& object, const std::string& key) {
+    auto item = object.find(key);
+    if (item == object.end()) {
+      throw std::runtime_error("Couldn't find " + key + " in AnyObject!");
+    }
+    return item->second;
+  }
+
+}; // namespace AnyMapUtils
+
+} // namespace margelo::nitro

package/ios/utils/Date+fromChrono.swift

@@ -11,7 +11,7 @@ public extension Date {
   /**
    * Create a new `Date` object from the given `std::chrono::system_clock::time_point` value.
    */
-  public init(fromChrono date: margelo.nitro.chrono_time) {
+  init(fromChrono date: margelo.nitro.chrono_time) {
     let millisecondsSinceEpoch = margelo.nitro.millisecondsSinceEpochFromChronoDate(date)
     self = .init(timeIntervalSince1970: millisecondsSinceEpoch / 1_000)
   }
@@ -19,7 +19,7 @@ public extension Date {
   /**
    * Converts this `Date` object to a `std::chrono::system_clock::time_point` value.
    */
-  public func toCpp() -> margelo.nitro.chrono_time {
+  func toCpp() -> margelo.nitro.chrono_time {
     let secondsSinceEpoch = self.timeIntervalSince1970
     let millisecondsSinceEpoch = secondsSinceEpoch * 1_000
     return margelo.nitro.chronoDateFromMillisecondsSinceEpoch(millisecondsSinceEpoch)