react-native-nitro-modules 0.29.5 → 0.29.7

package/NitroModules.podspec

@@ -43,6 +43,7 @@ Pod::Spec.new do |s|
     "cpp/platform/NitroLogger.hpp",
     "cpp/threading/Dispatcher.hpp",
     "cpp/utils/JSCallback.hpp",
+    "cpp/utils/FastVectorCopy.hpp",
     "cpp/utils/NitroHash.hpp",
     "cpp/utils/NitroDefines.hpp",
     "cpp/views/CachedProp.hpp",

package/android/src/main/cpp/registry/DefaultConstructableObject.hpp

@@ -15,7 +15,7 @@ namespace margelo::nitro {
 using namespace facebook;
 
 template <typename T>
-class DefaultConstructableObject {
+class DefaultConstructableObject final {
 public:
   explicit DefaultConstructableObject(const char* javaClassDescriptor) {
     try {

package/cpp/core/ArrayBuffer.cpp

@@ -17,11 +17,11 @@ using namespace facebook;
 
 // 1. ArrayBuffer
 
-std::shared_ptr<ArrayBuffer> ArrayBuffer::wrap(uint8_t* data, size_t size, DeleteFn&& deleteFunc) {
+std::shared_ptr<ArrayBuffer> ArrayBuffer::wrap(uint8_t* NON_NULL data, size_t size, DeleteFn&& deleteFunc) {
   return std::make_shared<NativeArrayBuffer>(data, size, std::move(deleteFunc));
 }
 
-std::shared_ptr<ArrayBuffer> ArrayBuffer::copy(const uint8_t* data, size_t size) {
+std::shared_ptr<ArrayBuffer> ArrayBuffer::copy(const uint8_t* NON_NULL data, size_t size) {
   uint8_t* copy = new uint8_t[size];
   std::memcpy(copy, data, size);
   return ArrayBuffer::wrap(copy, size, [=]() { delete[] copy; });
@@ -42,7 +42,7 @@ std::shared_ptr<ArrayBuffer> ArrayBuffer::allocate(size_t size) {
 
 // 2. NativeArrayBuffer
 
-NativeArrayBuffer::NativeArrayBuffer(uint8_t* data, size_t size, DeleteFn&& deleteFunc)
+NativeArrayBuffer::NativeArrayBuffer(uint8_t* NON_NULL data, size_t size, DeleteFn&& deleteFunc)
     : ArrayBuffer(), _data(data), _size(size), _deleteFunc(std::move(deleteFunc)) {}
 
 NativeArrayBuffer::~NativeArrayBuffer() {
@@ -51,7 +51,7 @@ NativeArrayBuffer::~NativeArrayBuffer() {
   }
 }
 
-uint8_t* NativeArrayBuffer::data() {
+uint8_t* NON_NULL NativeArrayBuffer::data() {
   return _data;
 }
 
@@ -70,7 +70,7 @@ JSArrayBuffer::JSArrayBuffer(jsi::Runtime& runtime, BorrowingReference<jsi::Arra
 
 JSArrayBuffer::~JSArrayBuffer() {}
 
-uint8_t* JSArrayBuffer::data() {
+uint8_t* NULLABLE JSArrayBuffer::data() {
   if (_initialThreadId != std::this_thread::get_id()) [[unlikely]] {
     throw std::runtime_error("`data()` can only be accessed synchronously on the JS Thread! "
                              "If you want to access it elsewhere, copy it first.");

package/cpp/core/ArrayBuffer.hpp

@@ -8,6 +8,7 @@
 #pragma once
 
 #include "BorrowingReference.hpp"
+#include "NitroDefines.hpp"
 #include <jsi/jsi.h>
 #include <thread>
 #include <vector>
@@ -53,12 +54,12 @@ public:
    * Create a new `NativeArrayBuffer` that wraps the given data (without copy) of the given size,
    * and calls `deleteFunc` in which `data` should be deleted.
    */
-  static std::shared_ptr<ArrayBuffer> wrap(uint8_t* data, size_t size, DeleteFn&& deleteFunc);
+  static std::shared_ptr<ArrayBuffer> wrap(uint8_t* NON_NULL data, size_t size, DeleteFn&& deleteFunc);
   /**
    * Create a new `NativeArrayBuffer` that copies the given data of the given size
    * into a newly allocated buffer.
    */
-  static std::shared_ptr<ArrayBuffer> copy(const uint8_t* data, size_t size);
+  static std::shared_ptr<ArrayBuffer> copy(const uint8_t* NON_NULL data, size_t size);
   /**
    * Create a new `NativeArrayBuffer` that copies the given `std::vector`.
    */
@@ -94,16 +95,16 @@ public:
    * Once this `ArrayBuffer` goes out of scope, `deleteFunc` will be called.
    * The caller is responsible for deleting the memory (`data`) here.
    */
-  NativeArrayBuffer(uint8_t* data, size_t size, DeleteFn&& deleteFunc);
+  NativeArrayBuffer(uint8_t* NON_NULL data, size_t size, DeleteFn&& deleteFunc);
   ~NativeArrayBuffer();
 
 public:
-  uint8_t* data() override;
+  uint8_t* NON_NULL data() override;
   size_t size() const override;
   bool isOwner() const noexcept override;
 
 private:
-  uint8_t* _data;
+  uint8_t* NON_NULL _data;
   size_t _size;
   DeleteFn _deleteFunc;
 };
@@ -128,7 +129,7 @@ public:
   /**
    * Gets the data this `ArrayBuffer` points to, or `nullptr` if it has already been deleted.
    */
-  uint8_t* data() override;
+  uint8_t* NULLABLE data() override;
   /**
    * Gets the size of the data this `ArrayBuffer` points to, or `0` if it has already been deleted.
    */

package/cpp/core/BoxedHybridObject.hpp

@@ -21,7 +21,7 @@ using namespace facebook;
  *
  * Simply call `unbox()` on this `jsi::HostObject` from the new Runtime/context to get the `HybridObject` again.
  */
-class BoxedHybridObject : public jsi::HostObject {
+class BoxedHybridObject final : public jsi::HostObject {
 public:
   explicit BoxedHybridObject(const std::shared_ptr<HybridObject>& hybridObject) : _hybridObject(hybridObject) {}
 

package/cpp/core/HybridFunction.hpp

@@ -13,6 +13,7 @@ struct JSIConverter;
 } // namespace margelo::nitro
 
 #include "CountTrailingOptionals.hpp"
+#include "InstanceMethod.hpp"
 #include "JSIConverter.hpp"
 #include "NitroDefines.hpp"
 #include "NitroTypeInfo.hpp"
@@ -33,6 +34,15 @@ using namespace facebook;
  */
 enum class FunctionKind { METHOD, GETTER, SETTER };
 
+/**
+ * A helper for an `InstanceMethod` that doesn't have a typed return value or arguments, but instead uses raw JSI values.
+ */
+template <typename T>
+using RawInstanceMethod = InstanceMethod<
+    /* instance type */ T,
+    /* return value */ jsi::Value,
+    /* jsi::HostFunction arguments */ jsi::Runtime&, const jsi::Value&, const jsi::Value*, size_t>;
+
 /**
  * Represents a Hybrid Function.
  */
@@ -73,10 +83,12 @@ public:
    * The object's `this` needs to be a `NativeState`.
    */
   template <typename THybrid, typename ReturnType, typename... Args>
-  static inline HybridFunction createHybridFunction(const std::string& name, ReturnType (THybrid::*method)(Args...), FunctionKind kind) {
+  static inline HybridFunction createHybridFunction(/* The name of the method */ const std::string& name,
+                                                    /* The method on THybrid */ InstanceMethod<THybrid, ReturnType, Args...> method,
+                                                    /* The type of the method */ FunctionKind kind) {
     jsi::HostFunctionType hostFunction = [name, method, kind](/* JS Runtime */ jsi::Runtime& runtime,
                                                               /* HybridObject */ const jsi::Value& thisValue,
-                                                              /* JS arguments */ const jsi::Value* args,
+                                                              /* JS arguments */ const jsi::Value* NON_NULL args,
                                                               /* argument size */ size_t count) -> jsi::Value {
       // 1. Get actual `HybridObject` instance from `thisValue` (it's stored as `NativeState`)
       std::shared_ptr<THybrid> hybridInstance = getHybridObjectNativeState<THybrid>(runtime, thisValue, kind, name);
@@ -126,9 +138,9 @@ public:
    * It is a raw-, untyped JSI method, and the user is expected to manually handle arguments and return values.
    */
   template <typename Derived>
-  static inline HybridFunction createRawHybridFunction(const std::string& name, size_t expectedArgumentsCount,
-                                                       jsi::Value (Derived::*method)(jsi::Runtime& runtime, const jsi::Value& thisArg,
-                                                                                     const jsi::Value* args, size_t count)) {
+  static inline HybridFunction createRawHybridFunction(/* The name of the raw method */ const std::string& name,
+                                                       /* The number of expected arguments */ size_t expectedArgumentsCount,
+                                                       /* The raw JSI method on the instance */ RawInstanceMethod<Derived> method) {
     jsi::HostFunctionType hostFunction = [name, method](/* JS Runtime */ jsi::Runtime& runtime,
                                                         /* HybridObject */ const jsi::Value& thisValue,
                                                         /* JS arguments */ const jsi::Value* args,
@@ -150,8 +162,11 @@ private:
    * The given method's return value will be converted to a `jsi::Value` again.
    */
   template <typename Derived, typename ReturnType, typename... Args, size_t... Is>
-  static inline jsi::Value callMethod(Derived* obj, ReturnType (Derived::*method)(Args...), jsi::Runtime& runtime, const jsi::Value* args,
-                                      size_t argsSize, std::index_sequence<Is...>) {
+  static inline jsi::Value callMethod(/* The instance to call the method on */ Derived* NON_NULL obj,
+                                      /* The method to call */ InstanceMethod<Derived, ReturnType, Args...> method,
+                                      /* JS Runtime */ jsi::Runtime& runtime,
+                                      /* JS Arguments */ const jsi::Value* NON_NULL args,
+                                      /* JS Arguments count */ size_t argsSize, std::index_sequence<Is...>) {
     static const jsi::Value defaultValue;
 
     if constexpr (std::is_void_v<ReturnType>) {
@@ -226,7 +241,7 @@ private:
 private:
   template <typename THybrid>
   static inline std::string getHybridFuncFullName(FunctionKind kind, const std::string& registrationName,
-                                                  THybrid* hybridInstance = nullptr) {
+                                                  THybrid* NULLABLE hybridInstance = nullptr) {
     std::string typeName = hybridInstance != nullptr ? hybridInstance->getName() : TypeInfo::getFriendlyTypename<THybrid>(true);
     switch (kind) {
       case FunctionKind::METHOD:
@@ -238,7 +253,7 @@ private:
   }
   template <typename THybrid>
   static inline std::string getHybridFuncDebugInfo(FunctionKind kind, const std::string& registrationName,
-                                                   THybrid* hybridInstance = nullptr) {
+                                                   THybrid* NULLABLE hybridInstance = nullptr) {
     auto funcName = getHybridFuncFullName<THybrid>(kind, registrationName, hybridInstance);
     switch (kind) {
       case FunctionKind::METHOD:

package/cpp/core/HybridObject.cpp

@@ -8,7 +8,7 @@
 
 namespace margelo::nitro {
 
-HybridObject::HybridObject(const char* name) : HybridObjectPrototype(), _name(name) {}
+HybridObject::HybridObject(const char* NON_NULL name) : HybridObjectPrototype(), _name(name) {}
 
 std::string HybridObject::toString() {
   return "[HybridObject " + std::string(_name) + "]";

package/cpp/core/HybridObject.hpp

@@ -29,7 +29,7 @@ public:
    * Create a new instance of a `HybridObject`.
    * The given `name` will be used for logging and stringifying.
    */
-  explicit HybridObject(const char* name);
+  explicit HybridObject(const char* NON_NULL name);
   /**
    * Called when no more references to the given `HybridObject` exist in both C++ and JS.
    * JS might keep references for longer, as it is a garbage collected language.
@@ -111,7 +111,7 @@ private:
    * The actual `dispose()` function from JS.
    * This needs to be a raw JSI function as we remove the NativeState here.
    */
-  jsi::Value disposeRaw(jsi::Runtime& runtime, const jsi::Value& thisArg, const jsi::Value* args, size_t count);
+  jsi::Value disposeRaw(jsi::Runtime& runtime, const jsi::Value& thisArg, const jsi::Value* NON_NULL args, size_t count);
 
 protected:
   /**
@@ -144,7 +144,7 @@ protected:
 
 private:
   static constexpr auto TAG = "HybridObject";
-  const char* _name = TAG;
+  const char* NON_NULL _name = TAG;
   std::unordered_map<jsi::Runtime*, BorrowingReference<jsi::WeakObject>> _objectCache;
 };
 

package/cpp/platform/NitroLogger.hpp

@@ -22,7 +22,7 @@ private:
 
 public:
   template <typename... Args>
-  static void log([[maybe_unused]] LogLevel level, [[maybe_unused]] const char* tag, [[maybe_unused]] const char* format,
+  static void log([[maybe_unused]] LogLevel level, [[maybe_unused]] const char* NON_NULL tag, [[maybe_unused]] const char* NON_NULL format,
                   [[maybe_unused]] Args... args) {
 #ifdef NITRO_DEBUG
     // 1. Make sure args can be passed to sprintf(..)
@@ -37,11 +37,11 @@ public:
 #endif
   }
 
-  static void nativeLog(LogLevel level, const char* tag, const std::string& string);
+  static void nativeLog(LogLevel level, const char* NON_NULL tag, const std::string& string);
 
 private:
   template <typename... Args>
-  static std::string formatString(const char* format, Args... args) {
+  static std::string formatString(const char* NON_NULL format, Args... args) {
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wformat-security"
     int size = snprintf(nullptr, 0, format, args...) + 1; // Extra space for '\0'

package/cpp/prototype/HybridObjectPrototype.hpp

@@ -47,7 +47,7 @@ public:
 private:
   static jsi::Value createPrototype(jsi::Runtime& runtime, const std::shared_ptr<Prototype>& prototype);
   using PrototypeCache = std::unordered_map<NativeInstanceId, BorrowingReference<jsi::Object>>;
-  static std::unordered_map<jsi::Runtime*, PrototypeCache> _prototypeCache;
+  static std::unordered_map<jsi::Runtime * NON_NULL, PrototypeCache> _prototypeCache;
 
 protected:
   /**
@@ -70,7 +70,7 @@ private:
   }
 
 protected:
-  using RegisterFn = void (*)(Prototype&);
+  using RegisterFn = void (*NON_NULL)(Prototype&);
   /**
    * Registers the given methods inside the Hybrid Object's prototype.
    *
@@ -79,7 +79,7 @@ protected:
    * **Do not conditionally register hybrid methods, getters or setter!**
    */
   template <typename Derived>
-  inline void registerHybrids(Derived* /* this */, RegisterFn registerFunc) {
+  inline void registerHybrids(Derived* NON_NULL /* this */, RegisterFn registerFunc) {
     const std::shared_ptr<Prototype>& prototype = _prototypeChain.extendPrototype<Derived>();
 
     if (!prototype->hasHybrids()) {

package/cpp/prototype/Prototype.hpp

@@ -110,7 +110,7 @@ public:
    * ```
    */
   template <typename Derived, typename ReturnType>
-  inline void registerHybridGetter(std::string name, ReturnType (Derived::*method)()) {
+  inline void registerHybridGetter(std::string name, InstanceMethod<Derived, ReturnType> method) {
     if (_getters.contains(name)) [[unlikely]] {
       throw std::runtime_error("Cannot add Hybrid Property Getter \"" + name + "\" - a getter with that name already exists!");
     }
@@ -129,7 +129,7 @@ public:
    * ```
    */
   template <typename Derived, typename ValueType>
-  inline void registerHybridSetter(std::string name, void (Derived::*method)(ValueType)) {
+  inline void registerHybridSetter(std::string name, InstanceMethod<Derived, void, ValueType> method) {
     if (_setters.contains(name)) [[unlikely]] {
       throw std::runtime_error("Cannot add Hybrid Property Setter \"" + name + "\" - a setter with that name already exists!");
     }
@@ -148,7 +148,7 @@ public:
    * ```
    */
   template <typename Derived, typename ReturnType, typename... Args>
-  inline void registerHybridMethod(std::string name, ReturnType (Derived::*method)(Args...)) {
+  inline void registerHybridMethod(std::string name, InstanceMethod<Derived, ReturnType, Args...> method) {
     if (_getters.contains(name) || _setters.contains(name)) [[unlikely]] {
       throw std::runtime_error("Cannot add Hybrid Method \"" + name + "\" - a property with that name already exists!");
     }
@@ -167,9 +167,7 @@ public:
    * ```
    */
   template <typename Derived>
-  inline void registerRawHybridMethod(std::string name, size_t expectedArgumentsCount,
-                                      jsi::Value (Derived::*method)(jsi::Runtime& runtime, const jsi::Value& thisArg,
-                                                                    const jsi::Value* args, size_t count)) {
+  inline void registerRawHybridMethod(std::string name, size_t expectedArgumentsCount, RawInstanceMethod<Derived> method) {
     if (_getters.contains(name) || _setters.contains(name)) [[unlikely]] {
       throw std::runtime_error("Cannot add Hybrid Method \"" + name + "\" - a property with that name already exists!");
     }

package/cpp/registry/HybridObjectRegistry.cpp

@@ -76,7 +76,7 @@ std::shared_ptr<HybridObject> HybridObjectRegistry::createHybridObject(const std
         "- If you use Nitrogen, make sure your `nitro.json` contains `" +
         hybridObjectName +
         "` on this platform.\n"
-        "- If you use Nitrogen, make sure your library (*Package.java)/app (MainApplication.java) calls "
+        "- If you use Nitrogen, make sure your library (*Package.kt)/app (MainApplication.kt) calls "
         "`$$androidCxxLibName$$OnLoad.initializeNative()` somewhere on app-startup.\n"
         "- If you use Nitrogen, make sure your `cpp-adapter.cpp`/`OnLoad.cpp` calls `margelo::nitro::$$cxxNamespace$$::initialize(vm)`.\n"
         "- If you use Nitrogen, inspect the generated `$$androidCxxLibName$$OnLoad.cpp` file.\n"

package/cpp/templates/InstanceMethod.hpp

@@ -0,0 +1,23 @@
+//
+//  InstanceMethod.hpp
+//  NitroModules
+//
+//  Created by Marc Rousavy on 25.09.25.
+//
+
+#pragma once
+
+#include "NitroDefines.hpp"
+
+namespace margelo::nitro {
+
+/**
+ * Represents a Function pointer to an instance method of the given class.
+ * For example:
+ * `InstanceMethod<std::string, size_t>` could point to `size_t std::string::length()`
+ * `InstanceMethod<std::vector<int>, void, int>` could point to `void std::vector<int>::push_back(int)`
+ */
+template <typename T, typename ReturnType, typename... Args>
+using InstanceMethod = ReturnType (T::*NON_NULL)(Args...);
+
+} // namespace margelo::nitro

package/cpp/threading/Dispatcher.cpp

@@ -16,7 +16,7 @@ using namespace facebook;
 
 static constexpr auto GLOBAL_DISPATCHER_HOLDER_NAME = "__nitroDispatcher";
 
-std::unordered_map<jsi::Runtime*, std::weak_ptr<Dispatcher>> Dispatcher::_globalCache;
+std::unordered_map<jsi::Runtime * NON_NULL, std::weak_ptr<Dispatcher>> Dispatcher::_globalCache;
 
 void Dispatcher::installRuntimeGlobalDispatcher(jsi::Runtime& runtime, std::shared_ptr<Dispatcher> dispatcher) {
   Logger::log(LogLevel::Info, TAG, "Installing global Dispatcher Holder into Runtime \"%s\"...", getRuntimeId(runtime).c_str());

package/cpp/threading/Dispatcher.hpp

@@ -4,6 +4,7 @@
 
 #pragma once
 
+#include "NitroDefines.hpp"
 #include "Promise.hpp"
 #include <functional>
 #include <jsi/jsi.h>
@@ -73,7 +74,7 @@ public:
   }
 
 private:
-  static std::unordered_map<jsi::Runtime*, std::weak_ptr<Dispatcher>> _globalCache;
+  static std::unordered_map<jsi::Runtime * NON_NULL, std::weak_ptr<Dispatcher>> _globalCache;
 
 private:
   static constexpr auto TAG = "Dispatcher";

package/cpp/threading/ThreadPool.hpp

@@ -7,6 +7,7 @@
 
 #pragma once
 
+#include "NitroDefines.hpp"
 #include <atomic>
 #include <condition_variable>
 #include <functional>
@@ -25,7 +26,7 @@ public:
    * Create a new ThreadPool with the given number of minimum workers/threads.
    * The Thread Pool can expand on the fly if it is busy.
    */
-  explicit ThreadPool(const char* const name, size_t initialThreadsCount, size_t maxThreadsCount);
+  explicit ThreadPool(const char* NON_NULL const name, size_t initialThreadsCount, size_t maxThreadsCount);
   ~ThreadPool();
   ThreadPool(const ThreadPool&) = delete;
   ThreadPool(ThreadPool&&) = delete;
@@ -58,7 +59,7 @@ private:
   std::atomic<bool> _isAlive;
   std::atomic<size_t> _threadCount;
   size_t _threadCountLimit;
-  const char* _name;
+  const char* NON_NULL _name;
   static constexpr auto TAG = "ThreadPool";
 };
 

package/cpp/utils/BorrowingReference.hpp

@@ -33,7 +33,7 @@ class BorrowingReference final {
 public:
   BorrowingReference() : _value(nullptr), _state(nullptr) {}
 
-  explicit BorrowingReference(T* value) : _value(value), _state(new ReferenceState()) {}
+  explicit BorrowingReference(T* NULLABLE value) : _value(value), _state(new ReferenceState()) {}
 
   BorrowingReference(const BorrowingReference& ref) : _value(ref._value), _state(ref._state) {
     if (_state != nullptr) {
@@ -79,7 +79,7 @@ private:
 private:
   // BorrowingReference<C> -> BorrowingReference<T> Cast-constructor
   template <typename OldT>
-  BorrowingReference(T* value, const BorrowingReference<OldT>& originalRef) : _value(value), _state(originalRef._state) {
+  BorrowingReference(T* NULLABLE value, const BorrowingReference<OldT>& originalRef) : _value(value), _state(originalRef._state) {
     _state->strongRefCount++;
   }
 
@@ -150,7 +150,7 @@ public:
   }
 
   // Dereference (->)
-  inline T* operator->() const {
+  inline T* NON_NULL operator->() const {
 #ifdef NITRO_DEBUG
     if (!hasValue()) [[unlikely]] {
       std::string typeName = TypeInfo::getFriendlyTypename<T>(true);
@@ -174,11 +174,11 @@ public:
   }
 
   // comparison (== *)
-  inline bool operator==(T* other) const {
+  inline bool operator==(T* NULLABLE other) const {
     return _value == other;
   }
   // comparison (!= *)
-  inline bool operator!=(T* other) const {
+  inline bool operator!=(T* NULLABLE other) const {
     return _value != other;
   }
 
@@ -214,8 +214,8 @@ public:
   friend class WeakReference<T>;
 
 private:
-  T* _value;
-  ReferenceState* _state;
+  T* NULLABLE _value;
+  ReferenceState* NON_NULL _state;
 };
 
 } // namespace margelo::nitro

package/cpp/utils/FastVectorCopy.hpp

@@ -0,0 +1,44 @@
+//
+//  FastVectorCopy.hpp
+//  NitroModules
+//
+//  Created by Marc Rousavy on 22.09.25.
+//
+
+#pragma once
+
+#include "NitroDefines.hpp"
+#include <span>
+#include <type_traits>
+#include <vector>
+
+namespace margelo::nitro {
+
+/**
+ * Copies `data` into an `std::vector` as fast as possible.
+ *
+ * If the type is trivially copyable (aka if it does not have a copy constructor),
+ * the data will be bulk-memcopied.
+ */
+template <typename T>
+std::vector<T> FastVectorCopy(const T* CONTIGUOUS_MEMORY NON_NULL data, size_t size) {
+  assert(data != nullptr && "FastVectoryCopy: data cannot be null!");
+
+  if (size == 0) [[unlikely]] {
+    // It's an empty vector.
+    return std::vector<T>();
+  }
+
+  if constexpr (std::is_trivially_copyable_v<T>) {
+    // FAST: Type does not have a copy constructor - simply memcpy it
+    std::vector<T> vector(size);
+    std::memcpy(vector.data(), data, size * sizeof(T));
+    return vector;
+  } else {
+    // SLOW: Type needs to be iterated to copy-construct it
+    std::span<const T> span(data, size);
+    return std::vector<T>(span.begin(), span.end());
+  }
+}
+
+} // namespace margelo::nitro

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.29.5"
+#define NITRO_VERSION "0.29.7"
 
 // Sets whether to use debug or optimized production build flags
 #ifdef DEBUG
@@ -39,6 +39,24 @@
 #define CLOSED_ENUM
 #endif
 
+// Nullability
+#if defined(__clang__)
+#define NON_NULL _Nonnull
+#define NULLABLE _Nullable
+#else
+#define NON_NULL
+#define NULLABLE
+#endif
+
+// Contiguous memory in pointers (__restrict)
+#if defined(__clang__)
+#define CONTIGUOUS_MEMORY __restrict__
+#elif defined(_MSC_VER)
+#define CONTIGUOUS_MEMORY __restrict
+#else
+#define CONTIGUOUS_MEMORY
+#endif
+
 // Swift Support
 #if __has_include(<swift/bridging>)
 // Swift's bridging header defines those things

package/cpp/utils/NitroHash.hpp

@@ -19,7 +19,7 @@ namespace margelo::nitro {
  * This function can be used at compile time as a constexpr to build
  * statically optimized switch statements.
  */
-constexpr uint64_t hashString(const char* str, size_t length) {
+constexpr uint64_t hashString(const char* NON_NULL str, size_t length) {
   uint64_t hash = 14695981039346656037ull; // FNV offset basis
   const uint64_t fnv_prime = 1099511628211ull;
 

package/cpp/utils/WeakReference.hpp

@@ -94,8 +94,8 @@ private:
   }
 
 private:
-  T* _value;
-  ReferenceState* _state;
+  T* NULLABLE _value;
+  ReferenceState* NON_NULL _state;
 };
 
 } // namespace margelo::nitro

package/ios/utils/Result.hpp

@@ -14,10 +14,10 @@ namespace margelo::nitro {
  * Represents a Result from a function. It's either a value (`T`), or an error (`std::exception_ptr`).
  */
 template <typename T>
-class Result {
+struct Result final {
 public:
   // Constructors
-  Result(const Result& other) : _hasError(other._hasError) {
+  Result(const Result& other) noexcept(std::is_nothrow_copy_constructible<T>::value) : _hasError(other._hasError) {
     if (_hasError) {
       new (&_error) std::exception_ptr(other._error);
     } else {
@@ -33,11 +33,11 @@ public:
     }
   }
 
-  ~Result() {
+  ~Result() noexcept(std::is_nothrow_destructible<T>::value) {
     destroy();
   }
 
-  Result& operator=(const Result& other) {
+  Result& operator=(const Result& other) noexcept(std::is_nothrow_copy_constructible<T>::value && std::is_nothrow_destructible<T>::value) {
     if (this == &other)
       return *this;
     destroy();
@@ -50,7 +50,7 @@ public:
     return *this;
   }
 
-  Result& operator=(Result&& other) noexcept(std::is_nothrow_move_constructible<T>::value) {
+  Result& operator=(Result&& other) noexcept(std::is_nothrow_move_constructible<T>::value && std::is_nothrow_destructible<T>::value) {
     if (this == &other)
       return *this;
     destroy();
@@ -64,15 +64,15 @@ public:
   }
 
   // Static factories
-  static Result withValue(const T& value) {
+  static Result withValue(const T& value) noexcept(std::is_nothrow_copy_constructible<T>::value) {
     return Result(value);
   }
 
-  static Result withValue(T&& value) {
+  static Result withValue(T&& value) noexcept(std::is_nothrow_move_constructible<T>::value) {
     return Result(std::move(value));
   }
 
-  static Result withError(std::exception_ptr eptr) {
+  static Result withError(std::exception_ptr eptr) noexcept {
     return Result(eptr);
   }
 
@@ -85,36 +85,36 @@ public:
     return _hasError;
   }
 
-  const T& value() const {
+  const T& value() const noexcept {
     assert(!_hasError && "Result<T> does not hold a value!");
     return *reinterpret_cast<const T*>(&_storage);
   }
 
-  T& value() {
+  T& value() noexcept {
     assert(!_hasError && "Result<T> does not hold a value!");
     return *reinterpret_cast<T*>(&_storage);
   }
 
-  std::exception_ptr error() const {
+  std::exception_ptr error() const noexcept {
     assert(_hasError && "Result<T> does not hold an error!");
     return _error;
   }
 
 private:
   // Private constructors
-  explicit Result(const T& value) : _hasError(false) {
+  explicit Result(const T& value) noexcept(std::is_nothrow_copy_constructible<T>::value) : _hasError(false) {
     new (&_storage) T(value);
   }
 
-  explicit Result(T&& value) : _hasError(false) {
+  explicit Result(T&& value) noexcept(std::is_nothrow_move_constructible<T>::value) : _hasError(false) {
     new (&_storage) T(std::move(value));
   }
 
-  explicit Result(std::exception_ptr eptr) : _hasError(true) {
+  explicit Result(std::exception_ptr eptr) noexcept : _hasError(true) {
     new (&_error) std::exception_ptr(eptr);
   }
 
-  void destroy() {
+  void destroy() noexcept(std::is_nothrow_destructible<T>::value) {
     if (_hasError) {
       reinterpret_cast<std::exception_ptr*>(&_error)->~exception_ptr();
     } else {
@@ -132,14 +132,14 @@ private:
 
 // Specialization for void
 template <>
-class Result<void> {
+struct Result<void> final {
 public:
   // Constructors
-  Result(const Result& other) : _hasError(other._hasError), _error(other._error) {}
+  Result(const Result& other) noexcept : _hasError(other._hasError), _error(other._error) {}
 
   Result(Result&& other) noexcept : _hasError(other._hasError), _error(std::move(other._error)) {}
 
-  Result& operator=(const Result& other) {
+  Result& operator=(const Result& other) noexcept {
     if (this == &other)
       return *this;
     _hasError = other._hasError;
@@ -160,11 +160,11 @@ public:
   }
 
   // Static factories
-  static Result withValue() {
+  static Result withValue() noexcept {
     return Result();
   }
 
-  static Result withError(std::exception_ptr eptr) {
+  static Result withError(std::exception_ptr eptr) noexcept {
     return Result(eptr);
   }
 
@@ -176,14 +176,14 @@ public:
     return _hasError;
   }
 
-  std::exception_ptr error() const {
+  std::exception_ptr error() const noexcept {
     assert(_hasError && "Result<void> does not hold an error!");
     return _error;
   }
 
 private:
-  explicit Result() : _hasError(false), _error(nullptr) {}
-  explicit Result(std::exception_ptr error) : _hasError(true), _error(error) {}
+  explicit Result() noexcept : _hasError(false), _error(nullptr) {}
+  explicit Result(std::exception_ptr error) noexcept : _hasError(true), _error(error) {}
 
 private:
   bool _hasError;

package/lib/commonjs/views/getHostComponent.js

@@ -7,8 +7,7 @@ exports.callback = callback;
 exports.getHostComponent = getHostComponent;
 var _reactNative = require("react-native");
 var NativeComponentRegistry = _interopRequireWildcard(require("react-native/Libraries/NativeComponent/NativeComponentRegistry"));
-function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
-function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
 // @ts-expect-error this unfortunately isn't typed or default-exported.
 // eslint-disable-next-line @react-native/no-deep-imports
 

package/lib/commonjs/views/getHostComponent.js.map

@@ -1 +1 @@
-{"version":3,"names":["_reactNative","require","NativeComponentRegistry","_interopRequireWildcard","_getRequireWildcardCache","e","WeakMap","r","t","__esModule","default","has","get","n","__proto__","a","Object","defineProperty","getOwnPropertyDescriptor","u","hasOwnProperty","call","i","set","wrapValidAttributes","attributes","keys","key","diff","b","process","getHostComponent","name","getViewConfig","Error","Platform","OS","config","validAttributes","callback","func","f"],"sourceRoot":"../../../src","sources":["views/getHostComponent.ts"],"mappings":";;;;;;;AAAA,IAAAA,YAAA,GAAAC,OAAA;AAGA,IAAAC,uBAAA,GAAAC,uBAAA,CAAAF,OAAA;AAAyG,SAAAG,yBAAAC,CAAA,6BAAAC,OAAA,mBAAAC,CAAA,OAAAD,OAAA,IAAAE,CAAA,OAAAF,OAAA,YAAAF,wBAAA,YAAAA,CAAAC,CAAA,WAAAA,CAAA,GAAAG,CAAA,GAAAD,CAAA,KAAAF,CAAA;AAAA,SAAAF,wBAAAE,CAAA,EAAAE,CAAA,SAAAA,CAAA,IAAAF,CAAA,IAAAA,CAAA,CAAAI,UAAA,SAAAJ,CAAA,eAAAA,CAAA,uBAAAA,CAAA,yBAAAA,CAAA,WAAAK,OAAA,EAAAL,CAAA,QAAAG,CAAA,GAAAJ,wBAAA,CAAAG,CAAA,OAAAC,CAAA,IAAAA,CAAA,CAAAG,GAAA,CAAAN,CAAA,UAAAG,CAAA,CAAAI,GAAA,CAAAP,CAAA,OAAAQ,CAAA,KAAAC,SAAA,UAAAC,CAAA,GAAAC,MAAA,CAAAC,cAAA,IAAAD,MAAA,CAAAE,wBAAA,WAAAC,CAAA,IAAAd,CAAA,oBAAAc,CAAA,OAAAC,cAAA,CAAAC,IAAA,CAAAhB,CAAA,EAAAc,CAAA,SAAAG,CAAA,GAAAP,CAAA,GAAAC,MAAA,CAAAE,wBAAA,CAAAb,CAAA,EAAAc,CAAA,UAAAG,CAAA,KAAAA,CAAA,CAAAV,GAAA,IAAAU,CAAA,CAAAC,GAAA,IAAAP,MAAA,CAAAC,cAAA,CAAAJ,CAAA,EAAAM,CAAA,EAAAG,CAAA,IAAAT,CAAA,CAAAM,CAAA,IAAAd,CAAA,CAAAc,CAAA,YAAAN,CAAA,CAAAH,OAAA,GAAAL,CAAA,EAAAG,CAAA,IAAAA,CAAA,CAAAe,GAAA,CAAAlB,CAAA,EAAAQ,CAAA,GAAAA,CAAA;AAFzG;AACA;;AAyBA;AACA;AACA;;AAsBA;AACA;AACA;;AASA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAYA;AACA;AACA;AACA;AACA,SAASW,mBAAmBA,CAC1BC,UAAmC,EACV;EACzB,MAAMC,IAAI,GAAGV,MAAM,CAACU,IAAI,CAACD,UAAU,CAAsC;EACzE,KAAK,MAAME,GAAG,IAAID,IAAI,EAAE;IACtBD,UAAU,CAACE,GAAG,CAAC,GAAG;MAChBC,IAAI,EAAEA,CAACb,CAAC,EAAEc,CAAC,KAAKd,CAAC,KAAKc,CAAC;MACvBC,OAAO,EAAGR,CAAC,IAAKA;IAClB,CAAC;EACH;EACA,OAAOG,UAAU;AACnB;;AAEA;AACA;AACA;AACA;AACA;AACO,SAASM,gBAAgBA,CAI9BC,IAAY,EACZC,aAAsC,EACL;EACjC,IAAI/B,uBAAuB,IAAI,IAAI,EAAE;IACnC,MAAM,IAAIgC,KAAK,CACb,+CAA+CC,qBAAQ,CAACC,EAAE,GAC5D,CAAC;EACH;EACA,OAAOlC,uBAAuB,CAACU,GAAG,CAACoB,IAAI,EAAE,MAAM;IAC7C,MAAMK,MAAM,GAAGJ,aAAa,CAAC,CAAC;IAC9BI,MAAM,CAACC,eAAe,GAAGd,mBAAmB,CAACa,MAAM,CAACC,eAAe,CAAC;IACpE,OAAOD,MAAM;EACf,CAAC,CAAC;AACJ;;AAEA;AACA;AACA;AACA;AACA;;AAIO,SAASE,QAAQA,CAACC,IAAa,EAAE;EACtC,IAAI,OAAOA,IAAI,KAAK,UAAU,EAAE;IAC9B,OAAO;MAAEC,CAAC,EAAED;IAAK,CAAC;EACpB;EACA,OAAOA,IAAI;AACb","ignoreList":[]}
+{"version":3,"names":["_reactNative","require","NativeComponentRegistry","_interopRequireWildcard","e","t","WeakMap","r","n","__esModule","o","i","f","__proto__","default","has","get","set","hasOwnProperty","call","Object","defineProperty","getOwnPropertyDescriptor","wrapValidAttributes","attributes","keys","key","diff","a","b","process","getHostComponent","name","getViewConfig","Error","Platform","OS","config","validAttributes","callback","func"],"sourceRoot":"../../../src","sources":["views/getHostComponent.ts"],"mappings":";;;;;;;AAAA,IAAAA,YAAA,GAAAC,OAAA;AAGA,IAAAC,uBAAA,GAAAC,uBAAA,CAAAF,OAAA;AAAyG,SAAAE,wBAAAC,CAAA,EAAAC,CAAA,6BAAAC,OAAA,MAAAC,CAAA,OAAAD,OAAA,IAAAE,CAAA,OAAAF,OAAA,YAAAH,uBAAA,YAAAA,CAAAC,CAAA,EAAAC,CAAA,SAAAA,CAAA,IAAAD,CAAA,IAAAA,CAAA,CAAAK,UAAA,SAAAL,CAAA,MAAAM,CAAA,EAAAC,CAAA,EAAAC,CAAA,KAAAC,SAAA,QAAAC,OAAA,EAAAV,CAAA,iBAAAA,CAAA,uBAAAA,CAAA,yBAAAA,CAAA,SAAAQ,CAAA,MAAAF,CAAA,GAAAL,CAAA,GAAAG,CAAA,GAAAD,CAAA,QAAAG,CAAA,CAAAK,GAAA,CAAAX,CAAA,UAAAM,CAAA,CAAAM,GAAA,CAAAZ,CAAA,GAAAM,CAAA,CAAAO,GAAA,CAAAb,CAAA,EAAAQ,CAAA,gBAAAP,CAAA,IAAAD,CAAA,gBAAAC,CAAA,OAAAa,cAAA,CAAAC,IAAA,CAAAf,CAAA,EAAAC,CAAA,OAAAM,CAAA,IAAAD,CAAA,GAAAU,MAAA,CAAAC,cAAA,KAAAD,MAAA,CAAAE,wBAAA,CAAAlB,CAAA,EAAAC,CAAA,OAAAM,CAAA,CAAAK,GAAA,IAAAL,CAAA,CAAAM,GAAA,IAAAP,CAAA,CAAAE,CAAA,EAAAP,CAAA,EAAAM,CAAA,IAAAC,CAAA,CAAAP,CAAA,IAAAD,CAAA,CAAAC,CAAA,WAAAO,CAAA,KAAAR,CAAA,EAAAC,CAAA;AAFzG;AACA;;AAyBA;AACA;AACA;;AAsBA;AACA;AACA;;AASA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAYA;AACA;AACA;AACA;AACA,SAASkB,mBAAmBA,CAC1BC,UAAmC,EACV;EACzB,MAAMC,IAAI,GAAGL,MAAM,CAACK,IAAI,CAACD,UAAU,CAAsC;EACzE,KAAK,MAAME,GAAG,IAAID,IAAI,EAAE;IACtBD,UAAU,CAACE,GAAG,CAAC,GAAG;MAChBC,IAAI,EAAEA,CAACC,CAAC,EAAEC,CAAC,KAAKD,CAAC,KAAKC,CAAC;MACvBC,OAAO,EAAGnB,CAAC,IAAKA;IAClB,CAAC;EACH;EACA,OAAOa,UAAU;AACnB;;AAEA;AACA;AACA;AACA;AACA;AACO,SAASO,gBAAgBA,CAI9BC,IAAY,EACZC,aAAsC,EACL;EACjC,IAAI/B,uBAAuB,IAAI,IAAI,EAAE;IACnC,MAAM,IAAIgC,KAAK,CACb,+CAA+CC,qBAAQ,CAACC,EAAE,GAC5D,CAAC;EACH;EACA,OAAOlC,uBAAuB,CAACc,GAAG,CAACgB,IAAI,EAAE,MAAM;IAC7C,MAAMK,MAAM,GAAGJ,aAAa,CAAC,CAAC;IAC9BI,MAAM,CAACC,eAAe,GAAGf,mBAAmB,CAACc,MAAM,CAACC,eAAe,CAAC;IACpE,OAAOD,MAAM;EACf,CAAC,CAAC;AACJ;;AAEA;AACA;AACA;AACA;AACA;;AAIO,SAASE,QAAQA,CAACC,IAAa,EAAE;EACtC,IAAI,OAAOA,IAAI,KAAK,UAAU,EAAE;IAC9B,OAAO;MAAE5B,CAAC,EAAE4B;IAAK,CAAC;EACpB;EACA,OAAOA,IAAI;AACb","ignoreList":[]}

package/package.json

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