react-native-nitro-modules 0.31.4 → 0.31.6

package/NitroModules.podspec

@@ -35,6 +35,7 @@ Pod::Spec.new do |s|
     "cpp/core/AnyMap.hpp",
     "cpp/core/ArrayBuffer.hpp",
     "cpp/core/HybridObject.hpp",
+    "cpp/core/Null.hpp",
     "cpp/core/Promise.hpp",
     "cpp/entrypoint/HybridNitroModulesProxy.hpp",
     "cpp/entrypoint/InstallNitro.hpp",

package/README.md

@@ -169,6 +169,12 @@ The following C++ / JS types are supported out of the box:
     <td><code>T?</code></td>
     <td><code>T?</code></td>
   </tr>
+  <tr>
+    <td><code>null</code></td>
+    <td><code>NullType</code></td>
+    <td><code>NullType</code></td>
+    <td><code>NullType</code></td>
+  </tr>
   <tr>
     <td><code>(T...) =&gt; void</code></td>
     <td><code>std::function&lt;void (T...)&gt;</code></td>

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

@@ -78,7 +78,7 @@ protected:
 
 private:
   // Java initializers
-  explicit JAnyValue(/* null */) : _value(std::monostate()) {}
+  explicit JAnyValue(NullType null) : _value(null) {}
   explicit JAnyValue(double value) : _value(value) {}
   explicit JAnyValue(bool value) : _value(value) {}
   explicit JAnyValue(int64_t value) : _value(value) {}
@@ -91,7 +91,7 @@ private:
 
 protected:
   bool isNull() {
-    return std::holds_alternative<std::monostate>(_value);
+    return std::holds_alternative<NullType>(_value);
   }
   bool isDouble() {
     return std::holds_alternative<double>(_value);

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

@@ -0,0 +1,33 @@
+//
+//  JNull.hpp
+//  react-native-nitro
+//
+//  Created by Marc Rousavy on 10.11.25
+//
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+
+namespace margelo::nitro {
+
+using namespace facebook;
+
+/**
+ * Represents a `Null` from Kotlin.
+ */
+struct JNull final : public jni::JavaClass<JNull> {
+public:
+  static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/core/NullType;";
+
+public:
+  static jni::global_ref<JNull> null() {
+    static const auto clazz = javaClassStatic();
+    static const auto nullField = clazz->getStaticField<JNull>("NULL");
+    static const auto nullValue = clazz->getStaticFieldValue(nullField);
+    static const auto globalNullValue = jni::make_global(nullValue);
+    return globalNullValue;
+  }
+};
+
+} // namespace margelo::nitro

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

@@ -10,6 +10,7 @@
 #include "Promise.hpp"
 #include <fbjni/fbjni.h>
 #include <mutex>
+#include <variant>
 
 namespace margelo::nitro {
 
@@ -37,6 +38,8 @@ struct JOnRejectedCallback : public jni::JavaClass<JOnRejectedCallback> {
 class JPromise final : public jni::HybridClass<JPromise> {
 public:
   static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/core/Promise;";
+  using ResultType = jni::global_ref<jni::JObject>;
+  using ErrorType = jni::global_ref<jni::JThrowable>;
   using OnResolvedFunc = std::function<void(jni::alias_ref<jni::JObject>)>;
   using OnRejectedFunc = std::function<void(jni::alias_ref<jni::JThrowable>)>;
 
@@ -58,7 +61,7 @@ public:
 
 public:
   ~JPromise() override {
-    if (_result == nullptr && _error == nullptr) [[unlikely]] {
+    if (isPending()) [[unlikely]] {
       jni::ThreadScope::WithClassLoader([&]() {
         std::runtime_error error("Timeouted: JPromise was destroyed!");
         this->reject(jni::getJavaExceptionForCppException(std::make_exception_ptr(error)));
@@ -69,25 +72,27 @@ public:
 public:
   void resolve(jni::alias_ref<jni::JObject> result) {
     std::unique_lock lock(_mutex);
-    _result = jni::make_global(result);
+    jni::global_ref<jni::JObject> globalResult = jni::make_global(result);
+    _state = globalResult;
     for (const auto& onResolved : _onResolvedListeners) {
-      onResolved(_result);
+      onResolved(result);
     }
   }
   void reject(jni::alias_ref<jni::JThrowable> error) {
     std::unique_lock lock(_mutex);
-    _error = jni::make_global(error);
+    jni::global_ref<jni::JThrowable> globalError = jni::make_global(error);
+    _state = globalError;
     for (const auto& onRejected : _onRejectedListeners) {
-      onRejected(_error);
+      onRejected(error);
     }
   }
 
 public:
   void addOnResolvedListener(OnResolvedFunc&& onResolved) {
     std::unique_lock lock(_mutex);
-    if (_result != nullptr) {
+    if (auto result = std::get_if<ResultType>(&_state)) {
       // Promise is already resolved! Call the callback immediately
-      onResolved(_result);
+      onResolved(*result);
     } else {
       // Promise is not yet resolved, put the listener in our queue.
       _onResolvedListeners.push_back(std::move(onResolved));
@@ -95,9 +100,9 @@ public:
   }
   void addOnRejectedListener(OnRejectedFunc&& onRejected) {
     std::unique_lock lock(_mutex);
-    if (_error != nullptr) {
+    if (auto error = std::get_if<ErrorType>(&_state)) {
       // Promise is already rejected! Call the callback immediately
-      onRejected(_error);
+      onRejected(*error);
     } else {
       // Promise is not yet rejected, put the listener in our queue.
       _onRejectedListeners.push_back(std::move(onRejected));
@@ -107,9 +112,9 @@ public:
 private:
   void addOnResolvedListenerJava(jni::alias_ref<JOnResolvedCallback> callback) {
     std::unique_lock lock(_mutex);
-    if (_result != nullptr) {
+    if (auto result = std::get_if<ResultType>(&_state)) {
       // Promise is already resolved! Call the callback immediately
-      callback->onResolved(_result);
+      callback->onResolved(*result);
     } else {
       // Promise is not yet resolved, put the listener in our queue.
       auto sharedCallback = jni::make_global(callback);
@@ -119,9 +124,9 @@ private:
   }
   void addOnRejectedListenerJava(jni::alias_ref<JOnRejectedCallback> callback) {
     std::unique_lock lock(_mutex);
-    if (_error != nullptr) {
+    if (auto error = std::get_if<ErrorType>(&_state)) {
       // Promise is already rejected! Call the callback immediately
-      callback->onRejected(_error);
+      callback->onRejected(*error);
     } else {
       // Promise is not yet rejected, put the listener in our queue.
       auto sharedCallback = jni::make_global(callback);
@@ -130,14 +135,19 @@ private:
     }
   }
 
+private:
+  [[nodiscard]]
+  bool isPending() const noexcept {
+    return std::holds_alternative<std::monostate>(_state);
+  }
+
 private:
   JPromise() = default;
 
 private:
   friend HybridBase;
   using HybridBase::HybridBase;
-  jni::global_ref<jni::JObject> _result;
-  jni::global_ref<jni::JThrowable> _error;
+  std::variant<std::monostate, ResultType, ErrorType> _state;
   std::vector<OnResolvedFunc> _onResolvedListeners;
   std::vector<OnRejectedFunc> _onRejectedListeners;
   std::mutex _mutex;

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

@@ -0,0 +1,28 @@
+package com.margelo.nitro.core
+
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+import com.margelo.nitro.core.NullType.Companion.NULL
+
+@DoNotStrip
+@Keep
+class NullType private constructor() {
+  companion object {
+    /**
+     * Represents an explicit `null` from JS.
+     * This is a singleton.
+     */
+    @DoNotStrip
+    @Keep
+    @JvmField
+    val NULL = NullType()
+  }
+
+  override fun hashCode(): Int {
+    return 0
+  }
+
+  override fun equals(other: Any?): Boolean {
+    return other is NullType
+  }
+}

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

@@ -48,7 +48,7 @@ class Promise<T> {
    * Any `onResolved` listeners will be invoked.
    */
   fun resolve(result: T) {
-    nativeResolve(result as Any)
+    nativeResolve(result as Any?)
   }
 
   /**
@@ -95,7 +95,7 @@ class Promise<T> {
   }
 
   // C++ functions
-  private external fun nativeResolve(result: Any)
+  private external fun nativeResolve(result: Any?)
 
   private external fun nativeReject(error: Throwable)
 
@@ -112,7 +112,7 @@ class Promise<T> {
     @Suppress("unused")
     @Keep
     @DoNotStrip
-    fun onResolved(result: Any)
+    fun onResolved(result: Any?)
   }
 
   @Keep
@@ -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

@@ -31,7 +31,7 @@ bool AnyMap::isNull(const std::string& key) const {
   if (found == _map.end()) {
     return false;
   }
-  return std::holds_alternative<std::monostate>(found->second);
+  return std::holds_alternative<NullType>(found->second);
 }
 bool AnyMap::isDouble(const std::string& key) const {
   auto found = _map.find(key);
@@ -77,12 +77,12 @@ bool AnyMap::isObject(const std::string& key) const {
 }
 
 // Get
-std::monostate AnyMap::getNull(const std::string& key) const {
+NullType AnyMap::getNull(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!");
   }
-  if (auto result = std::get_if<std::monostate>(&found->second)) {
+  if (auto result = std::get_if<NullType>(&found->second)) {
     return *result;
   } else {
     throw std::runtime_error("The value at key \"" + key + "\" is not a null!");
@@ -164,7 +164,7 @@ AnyValue AnyMap::getAny(const std::string& key) const {
 
 // Set
 void AnyMap::setNull(const std::string& key) {
-  _map.emplace(key, std::monostate());
+  _map.emplace(key, nitro::null);
 }
 void AnyMap::setDouble(const std::string& key, double value) {
   _map.emplace(key, value);

package/cpp/core/AnyMap.hpp

@@ -5,6 +5,7 @@
 #pragma once
 
 #include "NitroDefines.hpp"
+#include "Null.hpp"
 #include <map>
 #include <memory>
 #include <string>
@@ -18,7 +19,7 @@ struct AnyValue;
 using AnyArray = std::vector<AnyValue>;
 using AnyObject = std::unordered_map<std::string, AnyValue>;
 
-using VariantType = std::variant<std::monostate, bool, double, int64_t, std::string, AnyArray, AnyObject>;
+using VariantType = std::variant<NullType, bool, double, int64_t, std::string, AnyArray, AnyObject>;
 struct AnyValue : VariantType {
   using VariantType::variant;
 
@@ -116,7 +117,7 @@ public:
    * Returns the null value at the given `key`.
    * If no `null` value exists at the given `key`, this method will throw.
    */
-  std::monostate getNull(const std::string& key) const;
+  NullType getNull(const std::string& key) const;
   /**
    * Returns the double value at the given `key`.
    * If no `double` value exists at the given `key`, this method will throw.

package/cpp/core/Null.hpp

@@ -0,0 +1,42 @@
+//
+// Created by Marc Rousavy on 30.07.24.
+//
+
+#pragma once
+
+#include "NitroDefines.hpp"
+#include <functional>
+#include <type_traits>
+
+namespace margelo::nitro {
+
+/**
+ * Represents the type of `null` - which should always be a singleton.
+ */
+enum class NullType { null };
+
+/**
+ * Represents an explicit `null` from JS.
+ * This is a singleton.
+ */
+inline constexpr NullType null = NullType::null;
+
+// Equality and ordering: all instances are equal
+constexpr bool operator==(NullType, NullType) noexcept {
+  return true;
+}
+constexpr bool operator!=(NullType, NullType) noexcept {
+  return false;
+}
+
+} // namespace margelo::nitro
+
+// Makes nitro::Null hashable
+namespace std {
+template <>
+struct hash<margelo::nitro::NullType> {
+  size_t operator()(margelo::nitro::NullType) const noexcept {
+    return 0;
+  }
+};
+} // namespace std

package/cpp/jsi/JSIConverter+Null.hpp

@@ -0,0 +1,38 @@
+//
+// Created by Marc Rousavy on 10.11.25.
+//
+
+#pragma once
+
+// Forward declare JSIConverter to prevent cyclic includes
+namespace margelo::nitro {
+template <typename T, typename Enable>
+struct JSIConverter;
+} // namespace margelo::nitro
+
+#include "JSIConverter.hpp"
+#include "Null.hpp"
+#include <jsi/jsi.h>
+
+namespace margelo::nitro {
+
+using namespace facebook;
+
+// NullType <> null
+template <>
+struct JSIConverter<NullType> final {
+  static inline NullType fromJSI(jsi::Runtime&, const jsi::Value& arg) {
+    if (!arg.isNull()) [[unlikely]] {
+      throw std::runtime_error("Cannot convert non-null value to NullType!");
+    }
+    return nitro::null;
+  }
+  static inline jsi::Value toJSI(jsi::Runtime&, const NullType&) {
+    return jsi::Value::null();
+  }
+  static inline bool canConvert(jsi::Runtime&, const jsi::Value& value) {
+    return value.isNull();
+  }
+};
+
+} // namespace margelo::nitro

package/cpp/jsi/JSIConverter+Optional.hpp

@@ -23,7 +23,7 @@ using namespace facebook;
 template <typename TInner>
 struct JSIConverter<std::optional<TInner>> final {
   static inline std::optional<TInner> fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
-    if (arg.isUndefined() || arg.isNull()) {
+    if (arg.isUndefined()) {
       return std::nullopt;
     } else {
       return JSIConverter<TInner>::fromJSI(runtime, arg);
@@ -37,7 +37,7 @@ struct JSIConverter<std::optional<TInner>> final {
     }
   }
   static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
-    if (value.isUndefined() || value.isNull()) {
+    if (value.isUndefined()) {
       return true;
     }
     if (JSIConverter<TInner>::canConvert(runtime, value)) {

package/cpp/jsi/JSIConverter+Promise.hpp

@@ -13,6 +13,7 @@ struct JSIConverter;
 
 #include "JSIConverter.hpp"
 #include "NitroTypeInfo.hpp"
+#include "Null.hpp"
 #include "Promise.hpp"
 #include <exception>
 #include <jsi/jsi.h>
@@ -31,6 +32,7 @@ struct JSIConverter<std::shared_ptr<Promise<TResult>>> final {
     auto thenCallback = [&]() {
       if constexpr (std::is_void_v<TResult>) {
         // void: resolve()
+        // std::monostate is used as a placeholder for the first argument
         return JSIConverter<std::function<void(std::monostate)>>::toJSI(runtime, [=](std::monostate) { promise->resolve(); });
       } else {
         // T: resolve(T)

package/cpp/jsi/JSIConverter.hpp

@@ -73,20 +73,6 @@ struct JSIConverter<int> final {
   }
 };
 
-// std::monostate <> null
-template <>
-struct JSIConverter<std::monostate> final {
-  static inline std::monostate fromJSI(jsi::Runtime&, const jsi::Value&) {
-    return std::monostate();
-  }
-  static inline jsi::Value toJSI(jsi::Runtime&, std::monostate) {
-    return jsi::Value::null();
-  }
-  static inline bool canConvert(jsi::Runtime&, const jsi::Value& value) {
-    return value.isNull() || value.isUndefined();
-  }
-};
-
 // double <> number
 template <>
 struct JSIConverter<double> final {
@@ -179,6 +165,20 @@ struct JSIConverter<std::string> final {
   }
 };
 
+// std::monostate <> void/undefined
+template <>
+struct JSIConverter<std::monostate> final {
+  static inline std::monostate fromJSI(jsi::Runtime&, const jsi::Value&) {
+    return std::monostate{};
+  }
+  static inline jsi::Value toJSI(jsi::Runtime&, std::monostate) {
+    return jsi::Value();
+  }
+  static inline bool canConvert(jsi::Runtime&, const jsi::Value&) {
+    return true;
+  }
+};
+
 } // namespace margelo::nitro
 
 #include "JSIConverter+AnyMap.hpp"
@@ -188,6 +188,7 @@ struct JSIConverter<std::string> final {
 #include "JSIConverter+Function.hpp"
 #include "JSIConverter+HostObject.hpp"
 #include "JSIConverter+NativeState.hpp"
+#include "JSIConverter+Null.hpp"
 #include "JSIConverter+Optional.hpp"
 #include "JSIConverter+Promise.hpp"
 #include "JSIConverter+Tuple.hpp"

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

package/ios/core/AnyMap.swift

@@ -287,7 +287,7 @@ extension margelo.nitro.AnyValue {
   static func create(_ value: AnyValue) -> margelo.nitro.AnyValue {
     switch value {
     case .null:
-      return create()
+      return create(NullType.null)
     case .bool(let bool):
       return create(bool)
     case .number(let number):
@@ -302,8 +302,8 @@ extension margelo.nitro.AnyValue {
       return create(object)
     }
   }
-  static func create() -> margelo.nitro.AnyValue {
-    return margelo.nitro.AnyMapUtils.create_AnyValue()
+  static func create(_ null: NullType) -> margelo.nitro.AnyValue {
+    return margelo.nitro.AnyMapUtils.create_AnyValue(margelo.nitro.NullType.null)
   }
   static func create(_ value: Bool) -> margelo.nitro.AnyValue {
     return margelo.nitro.AnyMapUtils.create_AnyValue(value)

package/ios/core/Null.swift

@@ -0,0 +1,16 @@
+//
+//  Null.swift
+//  NitroModules
+//
+//  Created by Marc Rousavy on 10.11.25
+//
+
+import Foundation
+
+@frozen
+public enum NullType: Sendable, Equatable, Hashable {
+  /**
+   * Represents an explicit `null` from JS.
+   */
+  case null
+}

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/ios/utils/AnyMapUtils.hpp

@@ -19,8 +19,8 @@ using TSharedMap = SharedAnyMap;
 
 namespace AnyMapUtils {
 
-  inline AnyValue create_AnyValue() {
-    return AnyValue{std::monostate{}};
+  inline AnyValue create_AnyValue(NullType null) {
+    return AnyValue{null};
   }
   inline AnyValue create_AnyValue(bool boolValue) {
     return AnyValue{boolValue};
@@ -42,7 +42,7 @@ namespace AnyMapUtils {
   }
 
   inline bool is_AnyValue_null(const AnyValue& value) {
-    return std::holds_alternative<std::monostate>(value);
+    return std::holds_alternative<NullType>(value);
   }
   inline bool is_AnyValue_bool(const AnyValue& value) {
     return std::holds_alternative<bool>(value);
@@ -63,8 +63,8 @@ namespace AnyMapUtils {
     return std::holds_alternative<AnyObject>(value);
   }
 
-  inline std::monostate get_AnyValue_null(const AnyValue& value) {
-    return std::get<std::monostate>(value);
+  inline NullType get_AnyValue_null(const AnyValue& value) {
+    return std::get<NullType>(value);
   }
   inline bool get_AnyValue_bool(const AnyValue& value) {
     return std::get<bool>(value);

package/package.json

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