react-native-nitro-modules 0.17.0 → 0.18.0

package/NitroModules.podspec

@@ -12,7 +12,12 @@ Pod::Spec.new do |s|
   s.license      = package["license"]
   s.authors      = package["author"]
 
-  s.platforms    = { :ios => min_ios_version_supported, :visionos => 1.0 }
+  s.platforms    = { 
+    :ios => min_ios_version_supported,
+    :visionos => 1.0,
+    :macos => 10.13,
+    :tvos => 13.4,
+  }
   s.source       = { :git => "https://github.com/mrousavy/nitro.git", :tag => "#{s.version}" }
 
   # VisionCamera Core C++ bindings

package/cpp/core/Promise.hpp

@@ -4,6 +4,8 @@
 
 #pragma once
 
+#include "AssertPromiseState.hpp"
+#include "NitroDefines.hpp"
 #include "ThreadPool.hpp"
 #include "TypeInfo.hpp"
 #include <exception>
@@ -17,14 +19,14 @@ namespace margelo::nitro {
 
 using namespace facebook;
 
-template <typename TResult, typename TError = std::exception>
+template <typename TResult>
 class Promise final {
 public:
   using OnResolvedFunc = std::function<void(const TResult&)>;
-  using OnRejectedFunc = std::function<void(const TError&)>;
+  using OnRejectedFunc = std::function<void(const std::exception_ptr&)>;
 
 public:
-  // Promise cannot be deleted.
+  // Promise cannot be copied.
   Promise(const Promise&) = delete;
   // Promise can be moved.
   Promise(Promise&&) = default;
@@ -53,13 +55,9 @@ public:
         // Run the code, then resolve.
         TResult result = run();
         promise->resolve(std::move(result));
-      } catch (const TError& exception) {
-        // It threw an std::exception.
-        promise->reject(exception);
       } catch (...) {
-        // It threw a different error.
-        std::string name = TypeInfo::getCurrentExceptionName();
-        promise->reject(std::runtime_error("Unknown non-std error! Name: " + name));
+        // It threw an error.
+        promise->reject(std::current_exception());
       }
     });
     return promise;
@@ -85,9 +83,9 @@ public:
   /**
    * Creates an immediately rejected Promise.
    */
-  static std::shared_ptr<Promise> rejected(TError&& error) {
+  static std::shared_ptr<Promise> rejected(const std::exception_ptr& error) {
     auto promise = create();
-    promise->reject(std::move(error));
+    promise->reject(error);
     return promise;
   }
 
@@ -97,33 +95,45 @@ public:
    */
   void resolve(TResult&& result) {
     std::unique_lock lock(*_mutex);
-    _result = std::move(result);
+#ifdef NITRO_DEBUG
+    assertPromiseState(*this, PromiseTask::WANTS_TO_RESOLVE);
+#endif
+    _state = std::move(result);
     for (const auto& onResolved : _onResolvedListeners) {
-      onResolved(std::get<TResult>(_result));
+      onResolved(std::get<TResult>(_state));
     }
   }
   void resolve(const TResult& result) {
     std::unique_lock lock(*_mutex);
-    _result = result;
+#ifdef NITRO_DEBUG
+    assertPromiseState(*this, PromiseTask::WANTS_TO_RESOLVE);
+#endif
+    _state = result;
     for (const auto& onResolved : _onResolvedListeners) {
-      onResolved(std::get<TResult>(_result));
+      onResolved(std::get<TResult>(_state));
     }
   }
   /**
    * Rejects this Promise with the given error, and calls any pending listeners.
    */
-  void reject(TError&& exception) {
+  void reject(const std::exception& exception) {
     std::unique_lock lock(*_mutex);
-    _result = std::move(exception);
+#ifdef NITRO_DEBUG
+    assertPromiseState(*this, PromiseTask::WANTS_TO_REJECT);
+#endif
+    _state = std::make_exception_ptr(exception);
     for (const auto& onRejected : _onRejectedListeners) {
-      onRejected(std::get<TError>(_result));
+      onRejected(std::get<std::exception_ptr>(_state));
     }
   }
-  void reject(const TError& exception) {
+  void reject(const std::exception_ptr& exception) {
     std::unique_lock lock(*_mutex);
-    _result = exception;
+#ifdef NITRO_DEBUG
+    assertPromiseState(*this, PromiseTask::WANTS_TO_REJECT);
+#endif
+    _state = exception;
     for (const auto& onRejected : _onRejectedListeners) {
-      onRejected(std::get<TError>(_result));
+      onRejected(exception);
     }
   }
 
@@ -134,9 +144,9 @@ public:
    */
   void addOnResolvedListener(OnResolvedFunc&& onResolved) {
     std::unique_lock lock(*_mutex);
-    if (std::holds_alternative<TResult>(_result)) {
+    if (std::holds_alternative<TResult>(_state)) {
       // Promise is already resolved! Call the callback immediately
-      onResolved(std::get<TResult>(_result));
+      onResolved(std::get<TResult>(_state));
     } else {
       // Promise is not yet resolved, put the listener in our queue.
       _onResolvedListeners.push_back(std::move(onResolved));
@@ -144,9 +154,9 @@ public:
   }
   void addOnResolvedListener(const OnResolvedFunc& onResolved) {
     std::unique_lock lock(*_mutex);
-    if (std::holds_alternative<TResult>(_result)) {
+    if (std::holds_alternative<TResult>(_state)) {
       // Promise is already resolved! Call the callback immediately
-      onResolved(std::get<TResult>(_result));
+      onResolved(std::get<TResult>(_state));
     } else {
       // Promise is not yet resolved, put the listener in our queue.
       _onResolvedListeners.push_back(onResolved);
@@ -154,9 +164,9 @@ public:
   }
   void addOnResolvedListenerCopy(const std::function<void(TResult)>& onResolved) {
     std::unique_lock lock(*_mutex);
-    if (std::holds_alternative<TResult>(_result)) {
+    if (std::holds_alternative<TResult>(_state)) {
       // Promise is already resolved! Call the callback immediately
-      onResolved(std::get<TResult>(_result));
+      onResolved(std::get<TResult>(_state));
     } else {
       // Promise is not yet resolved, put the listener in our queue.
       _onResolvedListeners.push_back(onResolved);
@@ -169,9 +179,9 @@ public:
    */
   void addOnRejectedListener(OnRejectedFunc&& onRejected) {
     std::unique_lock lock(*_mutex);
-    if (std::holds_alternative<TError>(_result)) {
+    if (std::holds_alternative<std::exception_ptr>(_state)) {
       // Promise is already rejected! Call the callback immediately
-      onRejected(std::get<TError>(_result));
+      onRejected(std::get<std::exception_ptr>(_state));
     } else {
       // Promise is not yet rejected, put the listener in our queue.
       _onRejectedListeners.push_back(std::move(onRejected));
@@ -179,15 +189,26 @@ public:
   }
   void addOnRejectedListener(const OnRejectedFunc& onRejected) {
     std::unique_lock lock(*_mutex);
-    if (std::holds_alternative<TError>(_result)) {
+    if (std::holds_alternative<std::exception_ptr>(_state)) {
       // Promise is already rejected! Call the callback immediately
-      onRejected(std::get<TError>(_result));
+      onRejected(std::get<std::exception_ptr>(_state));
     } else {
       // Promise is not yet rejected, put the listener in our queue.
       _onRejectedListeners.push_back(onRejected);
     }
   }
 
+public:
+  /**
+   * Gets an awaitable `std::future<T>` for this `Promise<T>`.
+   */
+  std::future<TResult> await() {
+    auto promise = std::make_shared<std::promise<TResult>>();
+    addOnResolvedListener([promise](const TResult& result) { promise->set_value(result); });
+    addOnRejectedListener([promise](const std::exception_ptr& error) { promise->set_exception(error); });
+    return promise->get_future();
+  }
+
 public:
   /**
    * Get the result of the Promise if it has been resolved.
@@ -197,17 +218,17 @@ public:
     if (!isResolved()) {
       throw std::runtime_error("Cannot get result when Promise is not yet resolved!");
     }
-    return std::get<TResult>(_result);
+    return std::get<TResult>(_state);
   }
   /**
    * Get the error of the Promise if it has been rejected.
    * If the Promise is not rejected, this will throw.
    */
-  inline const TError& getError() {
+  inline const std::exception_ptr& getError() {
     if (!isRejected()) {
       throw std::runtime_error("Cannot get error when Promise is not yet rejected!");
     }
-    return std::get<TError>(_result);
+    return std::get<std::exception_ptr>(_state);
   }
 
 public:
@@ -216,36 +237,36 @@ public:
    */
   [[nodiscard]]
   inline bool isResolved() const noexcept {
-    return std::holds_alternative<TResult>(_result);
+    return std::holds_alternative<TResult>(_state);
   }
   /**
    * Gets whether this Promise has been rejected with an error, or not.
    */
   [[nodiscard]]
   inline bool isRejected() const noexcept {
-    return std::holds_alternative<TError>(_result);
+    return std::holds_alternative<std::exception_ptr>(_state);
   }
   /**
    * Gets whether this Promise has not yet been resolved nor rejected.
    */
   [[nodiscard]]
   inline bool isPending() const noexcept {
-    return std::holds_alternative<std::monostate>(_result);
+    return std::holds_alternative<std::monostate>(_state);
   }
 
 private:
-  std::variant<std::monostate, TResult, TError> _result;
+  std::variant<std::monostate, TResult, std::exception_ptr> _state;
   std::vector<OnResolvedFunc> _onResolvedListeners;
   std::vector<OnRejectedFunc> _onRejectedListeners;
   std::unique_ptr<std::mutex> _mutex;
 };
 
 // Specialization for void
-template <typename TError>
-class Promise<void, TError> final {
+template <>
+class Promise<void> final {
 public:
   using OnResolvedFunc = std::function<void()>;
-  using OnRejectedFunc = std::function<void(const TError&)>;
+  using OnRejectedFunc = std::function<void(const std::exception_ptr&)>;
 
 public:
   Promise(const Promise&) = delete;
@@ -268,13 +289,9 @@ public:
         // Run the code, then resolve.
         run();
         promise->resolve();
-      } catch (const TError& exception) {
-        // It threw an std::exception.
-        promise->reject(exception);
       } catch (...) {
-        // It threw a different error.
-        std::string name = TypeInfo::getCurrentExceptionName();
-        promise->reject(std::runtime_error("Unknown non-std error! Name: " + name));
+        // It threw an error.
+        promise->reject(std::current_exception());
       }
     });
     return promise;
@@ -290,32 +307,41 @@ public:
     promise->resolve();
     return promise;
   }
-  static std::shared_ptr<Promise> rejected(TError&& error) {
+  static std::shared_ptr<Promise> rejected(const std::exception_ptr& error) {
     auto promise = create();
-    promise->reject(std::move(error));
+    promise->reject(error);
     return promise;
   }
 
 public:
   void resolve() {
     std::unique_lock lock(*_mutex);
+#ifdef NITRO_DEBUG
+    assertPromiseState(*this, PromiseTask::WANTS_TO_RESOLVE);
+#endif
     _isResolved = true;
     for (const auto& onResolved : _onResolvedListeners) {
       onResolved();
     }
   }
-  void reject(TError&& exception) {
+  void reject(const std::exception& exception) {
     std::unique_lock lock(*_mutex);
-    _error = std::move(exception);
+#ifdef NITRO_DEBUG
+    assertPromiseState(*this, PromiseTask::WANTS_TO_REJECT);
+#endif
+    _error = std::make_exception_ptr(exception);
     for (const auto& onRejected : _onRejectedListeners) {
       onRejected(_error.value());
     }
   }
-  void reject(const TError& exception) {
+  void reject(const std::exception_ptr& exception) {
     std::unique_lock lock(*_mutex);
+#ifdef NITRO_DEBUG
+    assertPromiseState(*this, PromiseTask::WANTS_TO_REJECT);
+#endif
     _error = exception;
     for (const auto& onRejected : _onRejectedListeners) {
-      onRejected(_error.value());
+      onRejected(exception);
     }
   }
 
@@ -356,7 +382,15 @@ public:
   }
 
 public:
-  inline const TError& getError() {
+  std::future<void> await() {
+    auto promise = std::make_shared<std::promise<void>>();
+    addOnResolvedListener([promise]() { promise->set_value(); });
+    addOnRejectedListener([promise](const std::exception_ptr& error) { promise->set_exception(error); });
+    return promise->get_future();
+  }
+
+public:
+  inline const std::exception_ptr& getError() {
     if (!isRejected()) {
       throw std::runtime_error("Cannot get error when Promise is not yet rejected!");
     }
@@ -380,7 +414,7 @@ public:
 private:
   std::unique_ptr<std::mutex> _mutex;
   bool _isResolved = false;
-  std::optional<TError> _error;
+  std::optional<std::exception_ptr> _error;
   std::vector<OnResolvedFunc> _onResolvedListeners;
   std::vector<OnRejectedFunc> _onRejectedListeners;
 };

package/cpp/jsi/JSIConverter+Exception.hpp

@@ -12,6 +12,7 @@ struct JSIConverter;
 
 #include "JSIConverter.hpp"
 
+#include "TypeInfo.hpp"
 #include <exception>
 #include <jsi/jsi.h>
 
@@ -19,18 +20,27 @@ namespace margelo::nitro {
 
 using namespace facebook;
 
-// std::exception <> Error
+// std::exception_ptr <> Error
 template <>
-struct JSIConverter<std::exception> final {
-  static inline std::exception fromJSI(jsi::Runtime& runtime, const jsi::Value& error) {
+struct JSIConverter<std::exception_ptr> final {
+  static inline std::exception_ptr fromJSI(jsi::Runtime& runtime, const jsi::Value& error) {
     jsi::Object object = error.asObject(runtime);
     std::string name = object.getProperty(runtime, "name").asString(runtime).utf8(runtime);
     std::string message = object.getProperty(runtime, "message").asString(runtime).utf8(runtime);
-    return std::runtime_error(name + ": " + message);
+    return std::make_exception_ptr(std::runtime_error(name + ": " + message));
   }
-  static inline jsi::Value toJSI(jsi::Runtime& runtime, const std::exception& exception) {
-    jsi::JSError error(runtime, exception.what());
-    return jsi::Value(runtime, error.value());
+  static inline jsi::Value toJSI(jsi::Runtime& runtime, const std::exception_ptr& exception) {
+    try {
+      std::rethrow_exception(exception);
+    } catch (const std::exception& e) {
+      jsi::JSError error(runtime, e.what());
+      return jsi::Value(runtime, error.value());
+    } catch (...) {
+      // Some unknown exception was thrown - maybe an Objective-C error?
+      std::string errorName = TypeInfo::getCurrentExceptionName();
+      jsi::JSError error(runtime, "Unknown " + errorName + " error.");
+      return jsi::Value(runtime, error.value());
+    }
   }
   static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
     if (!value.isObject()) {

package/cpp/jsi/JSIConverter+Function.hpp

@@ -56,14 +56,12 @@ struct JSIConverter<std::function<ReturnType(Args...)>> final {
       }
 
       if constexpr (std::is_void_v<ResultingType>) {
-        dispatcher->runAsync([&runtime, sharedFunction = std::move(sharedFunction), ... args = std::move(args)]() {
-          callJSFunction(runtime, sharedFunction, args...);
-        });
+        dispatcher->runAsync(
+            [&runtime, sharedFunction, ... args = std::move(args)]() { callJSFunction(runtime, sharedFunction, args...); });
       } else {
-        return dispatcher->runAsyncAwaitable<ResultingType>(
-            [&runtime, sharedFunction = std::move(sharedFunction), ... args = std::move(args)]() -> ResultingType {
-              return callJSFunction(runtime, sharedFunction, args...);
-            });
+        return dispatcher->runAsyncAwaitable<ResultingType>([&runtime, sharedFunction, ... args = std::move(args)]() -> ResultingType {
+          return callJSFunction(runtime, sharedFunction, args...);
+        });
       }
     };
   }

package/cpp/jsi/JSIConverter+Promise.hpp

@@ -37,8 +37,8 @@ struct JSIConverter<std::shared_ptr<Promise<TResult>>> final {
         return JSIConverter<std::function<void(TResult)>>::toJSI(runtime, [=](const TResult& result) { promise->resolve(result); });
       }
     }();
-    auto catchCallback = JSIConverter<std::function<void(std::exception)>>::toJSI(
-        runtime, [=](const std::exception& exception) { promise->reject(exception); });
+    auto catchCallback = JSIConverter<std::function<void(std::exception_ptr)>>::toJSI(
+        runtime, [=](const std::exception_ptr& exception) { promise->reject(exception); });
 
     // Chain .then listeners on JS Promise (onResolved and onRejected)
     jsi::Object jsPromise = value.asObject(runtime);
@@ -65,7 +65,7 @@ struct JSIConverter<std::shared_ptr<Promise<TResult>>> final {
           promise->addOnResolvedListener(std::move(resolver));
         }
         // Add rejecter listener
-        auto rejecter = JSIConverter<std::function<void(std::exception)>>::fromJSI(runtime, arguments[1]);
+        auto rejecter = JSIConverter<std::function<void(std::exception_ptr)>>::fromJSI(runtime, arguments[1]);
         promise->addOnRejectedListener(std::move(rejecter));
 
         return jsi::Value::undefined();
@@ -89,7 +89,7 @@ struct JSIConverter<std::shared_ptr<Promise<TResult>>> final {
       // Promise is already rejected - just return immediately
       jsi::Object promiseObject = runtime.global().getPropertyAsObject(runtime, "Promise");
       jsi::Function createRejectedPromise = promiseObject.getPropertyAsFunction(runtime, "reject");
-      jsi::Value error = JSIConverter<std::exception>::toJSI(runtime, promise->getError());
+      jsi::Value error = JSIConverter<std::exception_ptr>::toJSI(runtime, promise->getError());
       return createRejectedPromise.call(runtime, std::move(error));
     } else {
       throw std::runtime_error("Promise has invalid state!");

package/cpp/platform/ThreadUtils.hpp

@@ -5,6 +5,8 @@
 //  Created by Marc Rousavy on 14.07.24.
 //
 
+#pragma once
+
 #include <string>
 
 namespace margelo::nitro {

package/cpp/templates/IsSharedPtrTo.hpp

@@ -7,7 +7,6 @@
 
 #pragma once
 
-#include <jsi/jsi.h>
 #include <type_traits>
 
 namespace margelo::nitro {

package/cpp/utils/AssertPromiseState.hpp

@@ -0,0 +1,34 @@
+//
+//  AssertPromiseState.hpp
+//  NitroModules
+//
+//  Created by Marc Rousavy on 20.11.24.
+//
+
+#pragma once
+
+namespace margelo::nitro {
+template <typename TResult>
+class Promise;
+} // namespace margelo::nitro
+
+#include "Promise.hpp"
+#include "TypeInfo.hpp"
+#include <exception>
+#include <string>
+
+namespace margelo::nitro {
+
+enum PromiseTask { WANTS_TO_RESOLVE, WANTS_TO_REJECT };
+
+template <typename TResult>
+void assertPromiseState(Promise<TResult>& promise, PromiseTask task) {
+  if (!promise.isPending()) [[unlikely]] {
+    std::string taskString = task == WANTS_TO_RESOLVE ? "resolve" : "reject";
+    std::string state = promise.isResolved() ? "resolved" : "rejected";
+    throw std::runtime_error("Cannot " + taskString + " Promise<" + TypeInfo::getFriendlyTypename<TResult>() + "> - it is already " +
+                             state + "!");
+  }
+}
+
+} // namespace margelo::nitro

package/cpp/utils/BorrowingReference.hpp

@@ -111,7 +111,7 @@ private:
   bool* _isDeleted;
   std::atomic_size_t* _strongRefCount;
   std::atomic_size_t* _weakRefCount;
-  std::mutex* _mutex;
+  std::recursive_mutex* _mutex;
 };
 
 } // namespace margelo::nitro

package/cpp/utils/OwningReference.hpp

@@ -34,7 +34,7 @@ public:
 
   explicit OwningReference(T* value)
       : _value(value), _isDeleted(new bool(false)), _strongRefCount(new std::atomic_size_t(1)), _weakRefCount(new std::atomic_size_t(0)),
-        _mutex(new std::mutex()) {}
+        _mutex(new std::recursive_mutex()) {}
 
   OwningReference(const OwningReference& ref)
       : _value(ref._value), _isDeleted(ref._isDeleted), _strongRefCount(ref._strongRefCount), _weakRefCount(ref._weakRefCount),
@@ -229,7 +229,7 @@ private:
   bool* _isDeleted;
   std::atomic_size_t* _strongRefCount;
   std::atomic_size_t* _weakRefCount;
-  std::mutex* _mutex;
+  std::recursive_mutex* _mutex;
 };
 
 } // namespace margelo::nitro

package/cpp/utils/TypeInfo.hpp

@@ -24,17 +24,6 @@ struct TypeInfo final {
 public:
   TypeInfo() = delete;
 
-  /**
-   * Get the name of the currently thrown exception
-   */
-  static inline const char* getCurrentExceptionName() {
-#if __has_include(<cxxabi.h>)
-    return __cxxabiv1::__cxa_current_exception_type()->name();
-#else
-    return "<unknown>";
-#endif
-  }
-
   static inline std::string replaceRegex(const std::string& original, const std::string& pattern, const std::string& replacement) {
     std::regex re(pattern);
     return std::regex_replace(original, re, replacement);
@@ -112,6 +101,18 @@ public:
     std::string string = stream.str();
     return string.substr(0, string.length() - 2);
   }
+
+  /**
+   * Get the name of the currently thrown exception
+   */
+  static inline std::string getCurrentExceptionName() {
+#if __has_include(<cxxabi.h>)
+    std::string name = __cxxabiv1::__cxa_current_exception_type()->name();
+    return demangleName(name);
+#else
+    return "<unknown>";
+#endif
+  }
 };
 
 } // namespace margelo::nitro

package/ios/core/RuntimeError.swift

@@ -12,13 +12,20 @@ import Foundation
  *
  * Throw this error in Nitro Modules to provide clear and concise error messages to JS.
  */
-public enum RuntimeError: Error {
+@frozen
+public enum RuntimeError: Error, CustomStringConvertible {
   case error(withMessage: String)
-  
+
+  public var description: String {
+    switch self {
+      case .error(let message): return message
+    }
+  }
+
   /**
    * Creates a new `RuntimeError` from the given C++ `std::exception`.
    */
-  public static func from(cppError: std.exception) -> RuntimeError {
+  public static func from(cppError: std.exception_ptr) -> RuntimeError {
     let message = margelo.nitro.get_exception_message(cppError)
     return .error(withMessage: String(message))
   }
@@ -28,7 +35,7 @@ public extension Error {
   /**
    * Converts this `Error` to a C++ `std::exception`.
    */
-  func toCpp() -> std.exception {
+  func toCpp() -> std.exception_ptr {
     let message = String(describing: self)
     return margelo.nitro.make_exception(std.string(message))
   }

package/ios/turbomodule/NativeNitroModules+OldArch.mm

@@ -57,7 +57,7 @@ RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(install) {
     // 5. Install Nitro
     nitro::install(*runtime, dispatcher);
     return nil;
-  } catch (std::exception& error) {
+  } catch (const std::exception& error) {
     // ?. Any C++ error occurred (probably in nitro::install()?)
     return [NSString stringWithCString:error.what() encoding:kCFStringEncodingUTF8];
   } catch (...) {

package/ios/utils/RuntimeError.hpp

@@ -12,12 +12,19 @@
 
 namespace margelo::nitro {
 
-static inline std::exception make_exception(const std::string& message) {
-  return std::runtime_error(message);
+static inline std::exception_ptr make_exception(const std::string& message) {
+  return std::make_exception_ptr(std::runtime_error(message));
 }
 
-static inline std::string get_exception_message(const std::exception& exception) {
-  return exception.what();
+static inline std::string get_exception_message(const std::exception_ptr& exception) {
+  try {
+    std::rethrow_exception(exception);
+  } catch (const std::exception& error) {
+    return error.what();
+  } catch (...) {
+    std::string errorName = TypeInfo::getCurrentExceptionName();
+    return "Unknown " + errorName + " exception";
+  }
 }
 
 } // namespace margelo::nitro

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-nitro-modules",
-  "version": "0.17.0",
+  "version": "0.18.0",
   "description": "Insanely fast native C++, Swift or Kotlin modules with a statically compiled binding layer to JSI.",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",
@@ -28,6 +28,8 @@
     "ios",
     "android",
     "visionOS",
+    "tvOS",
+    "macOS",
     "cpp",
     "framework",
     "react",
@@ -70,7 +72,7 @@
     "jest": "*",
     "react": "*",
     "react-native": "*",
-    "react-native-builder-bob": "^0.32.0"
+    "react-native-builder-bob": "^0.33.1"
   },
   "peerDependencies": {
     "react": "*",