react-native-nitro-modules 0.9.2 → 0.11.0

package/cpp/jsi/JSIConverter+HostObject.hpp

@@ -0,0 +1,73 @@
+//
+// Created by Marc Rousavy on 07.10.24.
+//
+
+#pragma once
+
+#include "IsSharedPtrTo.hpp"
+#include "NitroDefines.hpp"
+#include "TypeInfo.hpp"
+#include <jsi/jsi.h>
+#include <type_traits>
+
+namespace margelo::nitro {
+
+using namespace facebook;
+
+// jsi::HostObject <> {}
+template <typename T>
+struct JSIConverter<T, std::enable_if_t<is_shared_ptr_to_v<T, jsi::HostObject>>> final {
+  using TPointee = typename T::element_type;
+
+  static inline T fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+#ifdef NITRO_DEBUG
+    if (!arg.isObject()) [[unlikely]] {
+      if (arg.isUndefined()) [[unlikely]] {
+        throw jsi::JSError(runtime, invalidTypeErrorMessage("undefined", "It is undefined!"));
+      } else {
+        std::string stringRepresentation = arg.toString(runtime).utf8(runtime);
+        throw jsi::JSError(runtime, invalidTypeErrorMessage(stringRepresentation, "It is not an object!"));
+      }
+    }
+#endif
+    jsi::Object object = arg.asObject(runtime);
+
+#ifdef NITRO_DEBUG
+    if (!object.isHostObject<TPointee>(runtime)) [[unlikely]] {
+      if (!object.isHostObject(runtime)) [[unlikely]] {
+        std::string stringRepresentation = arg.toString(runtime).utf8(runtime);
+        throw jsi::JSError(runtime, invalidTypeErrorMessage(stringRepresentation, "It is not a HostObject at all!"));
+      } else {
+        std::string stringRepresentation = arg.toString(runtime).utf8(runtime);
+        throw jsi::JSError(runtime, invalidTypeErrorMessage(stringRepresentation, "It is a different HostObject<T>!"));
+      }
+    }
+#endif
+    return object.getHostObject<TPointee>(runtime);
+  }
+
+  static inline jsi::Value toJSI(jsi::Runtime& runtime, const T& arg) {
+    if (arg == nullptr) [[unlikely]] {
+      std::string typeName = TypeInfo::getFriendlyTypename<TPointee>();
+      throw jsi::JSError(runtime, "Cannot convert nullptr to HostObject<" + typeName + ">!");
+    }
+
+    return jsi::Object::createFromHostObject(runtime, arg);
+  }
+
+  static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+    if (value.isObject()) {
+      jsi::Object object = value.getObject(runtime);
+      return object.isHostObject<TPointee>(runtime);
+    }
+    return false;
+  }
+
+private:
+  static std::string invalidTypeErrorMessage(const std::string& typeDescription, const std::string& reason) {
+    std::string typeName = TypeInfo::getFriendlyTypename<TPointee>();
+    return "Cannot convert \"" + typeDescription + "\" to HostObject<" + typeName + ">! " + reason;
+  }
+};
+
+} // namespace margelo::nitro

package/cpp/jsi/JSIConverter+HybridObject.hpp

@@ -78,7 +78,7 @@ struct JSIConverter<T, std::enable_if_t<is_shared_ptr_to_v<T, jsi::NativeState>>
   }
 
 private:
-  static inline std::string invalidTypeErrorMessage(const std::string& typeDescription, const std::string& reason) {
+  static std::string invalidTypeErrorMessage(const std::string& typeDescription, const std::string& reason) {
     std::string typeName = TypeInfo::getFriendlyTypename<TPointee>();
     return "Cannot convert \"" + typeDescription + "\" to NativeState<" + typeName + ">! " + reason;
   }

package/cpp/jsi/JSIConverter.hpp

@@ -184,6 +184,7 @@ struct JSIConverter<std::string> final {
 #include "JSIConverter+AnyMap.hpp"
 #include "JSIConverter+ArrayBuffer.hpp"
 #include "JSIConverter+Function.hpp"
+#include "JSIConverter+HostObject.hpp"
 #include "JSIConverter+HybridObject.hpp"
 #include "JSIConverter+Optional.hpp"
 #include "JSIConverter+Promise.hpp"

package/cpp/templates/FutureType.hpp

@@ -1,5 +1,5 @@
 //
-//  BorrowingReference.hpp
+//  FutureType.hpp
 //  NitroModules
 //
 //  Created by Marc Rousavy on 21.06.24.

package/cpp/templates/TypeIndex.hpp

@@ -0,0 +1,29 @@
+//
+//  TypeIndex.hpp
+//  NitroModules
+//
+//  Created by Marc Rousavy on 21.06.24.
+//
+
+#pragma once
+
+#include <tuple>
+#include <type_traits>
+
+namespace margelo::nitro {
+
+// Gets the index of `T` in a `std::tuple<...>`.
+template <typename T, typename... Ts>
+struct type_index;
+
+template <typename T, typename First, typename... Rest>
+struct type_index<T, First, Rest...> {
+  static constexpr size_t value = std::is_same_v<T, First> ? 0 : 1 + type_index<T, Rest...>::value;
+};
+
+template <typename T>
+struct type_index<T> {
+  static constexpr size_t value = -1; // Type not found
+};
+
+} // namespace margelo::nitro

package/cpp/utils/NitroDefines.hpp

@@ -15,6 +15,11 @@
 #ifdef NDEBUG
 #undef NITRO_DEBUG
 #endif
+#ifdef ANDROID
+#ifndef NDEBUG
+#define NITRO_DEBUG
+#endif
+#endif
 
 // Helper to find out if a C++ compiler attribute is available
 #ifdef __has_attribute

package/ios/core/AnyMapHolder.hpp

@@ -88,4 +88,12 @@ inline std::vector<std::string> getAnyObjectKeys(const AnyObject& object) {
   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 margelo::nitro

package/ios/core/AnyMapHolder.swift

@@ -11,12 +11,13 @@ import Foundation
  * Represents any value representable by the `AnyMap`.
  * Note: Arrays are currently not implemented due to a Swift compiler bug https://github.com/swiftlang/swift/issues/75994
  */
-public enum AnyValue {
+public indirect enum AnyValue {
   case null
   case number(Double)
   case bool(Bool)
   case bigint(Int64)
   case string(String)
+  case array(Array<AnyValue>)
   case object(Dictionary<String, AnyValue>)
 
   static func create(_ value: margelo.nitro.AnyValue) -> AnyValue {
@@ -30,6 +31,8 @@ public enum AnyValue {
       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 {
@@ -42,22 +45,18 @@ public enum AnyValue {
  * Represents an `AnyMap` that can be passed to Swift.
  */
 public class AnyMapHolder {
-  let _cppPart: margelo.nitro.TSharedMap
-  
-  public var cppPart: margelo.nitro.TSharedMap {
-    return _cppPart
-  }
+  public let cppPart: margelo.nitro.TSharedMap
 
   public init() {
-    _cppPart = margelo.nitro.AnyMap.make()
+    cppPart = margelo.nitro.AnyMap.make()
   }
 
   public init(withPreallocatedSize size: Int) {
-    _cppPart = margelo.nitro.AnyMap.make(size)
+    cppPart = margelo.nitro.AnyMap.make(size)
   }
   
-  public init(withCppPart cppPart: margelo.nitro.TSharedMap) {
-    _cppPart = cppPart
+  public init(withCppPart otherCppPart: margelo.nitro.TSharedMap) {
+    cppPart = otherCppPart
   }
 
   // pragma MARK: Common Operations
@@ -66,21 +65,21 @@ public class AnyMapHolder {
    * Returns whether the given key exists in the map.
    */
   public func contains(key: String) -> Bool {
-    return _cppPart.pointee.contains(std.string(key))
+    return cppPart.pointee.contains(std.string(key))
   }
 
   /**
    * Removes the given key from the map.
    */
   public func remove(key: String) {
-    _cppPart.pointee.remove(std.string(key))
+    cppPart.pointee.remove(std.string(key))
   }
 
   /**
    * Removes all keys in this map.
    */
   public func clear() {
-    _cppPart.pointee.clear()
+    cppPart.pointee.clear()
   }
 
   // pragma MARK: Getters
@@ -91,44 +90,54 @@ public class AnyMapHolder {
    * this function throws.
    */
   public func getDouble(key: String) -> Double {
-    return _cppPart.pointee.getDouble(std.string(key))
+    return cppPart.pointee.getDouble(std.string(key))
   }
 
   /**
-   * Gets the double value at the given key.
+   * Gets the boolean value at the given key.
    * If no value exists at the given key, or if it is not a double,
    * this function throws.
    */
   public func getBoolean(key: String) -> Bool {
-    return _cppPart.pointee.getBoolean(std.string(key))
+    return cppPart.pointee.getBoolean(std.string(key))
   }
 
   /**
-   * Gets the double value at the given key.
+   * Gets the bigint value at the given key.
    * If no value exists at the given key, or if it is not a double,
    * this function throws.
    */
   public func getBigInt(key: String) -> Int64 {
-    return _cppPart.pointee.getBigInt(std.string(key))
+    return cppPart.pointee.getBigInt(std.string(key))
   }
 
   /**
-   * Gets the double value at the given key.
+   * Gets the string value at the given key.
    * If no value exists at the given key, or if it is not a double,
    * this function throws.
    */
   public func getString(key: String) -> String {
-    let value = _cppPart.pointee.getString(std.string(key))
+    let value = cppPart.pointee.getString(std.string(key))
     return String(value)
   }
-
+  
   /**
-   * Gets the double value at the given key.
+   * Gets the array value at the given key.
+   * If no value exists at the given key, or if it is not a double,
+   * this function throws.
+   */
+  public func getArray(key: String) -> [AnyValue] {
+    let value = cppPart.pointee.getArray(std.string(key))
+    return value.toSwift()
+  }
+  
+  /**
+   * Gets the object value at the given key.
    * If no value exists at the given key, or if it is not a double,
    * this function throws.
    */
   public func getObject(key: String) -> Dictionary<String, AnyValue> {
-    let value = _cppPart.pointee.getObject(std.string(key))
+    let value = cppPart.pointee.getObject(std.string(key))
     return value.toSwift()
   }
 
@@ -138,42 +147,49 @@ public class AnyMapHolder {
    * Set the given key to `null`.
    */
   public func setNull(key: String) {
-    _cppPart.pointee.setNull(std.string(key))
+    cppPart.pointee.setNull(std.string(key))
   }
 
   /**
    * Set the given key to the given double value.
    */
   public func setDouble(key: String, value: Double) {
-    _cppPart.pointee.setDouble(std.string(key), value)
+    cppPart.pointee.setDouble(std.string(key), value)
   }
 
   /**
    * Set the given key to the given boolean value.
    */
   public func setBoolean(key: String, value: Bool) {
-    _cppPart.pointee.setBoolean(std.string(key), value)
+    cppPart.pointee.setBoolean(std.string(key), value)
   }
 
   /**
    * Set the given key to the given bigint value.
    */
   public func setBigInt(key: String, value: Int64) {
-    _cppPart.pointee.setBigInt(std.string(key), value)
+    cppPart.pointee.setBigInt(std.string(key), value)
   }
 
   /**
    * Set the given key to the given string value.
    */
   public func setString(key: String, value: String) {
-    _cppPart.pointee.setString(std.string(key), std.string(value))
+    cppPart.pointee.setString(std.string(key), std.string(value))
   }
-
+  
+  /**
+   * Set the given key to the given array value.
+   */
+  public func setArray(key: String, value: [AnyValue]) {
+    cppPart.pointee.setArray(std.string(key), margelo.nitro.AnyArray.create(value))
+  }
+  
   /**
    * Set the given key to the given object value.
    */
   public func setObject(key: String, value: Dictionary<String, AnyValue>) {
-    _cppPart.pointee.setObject(std.string(key), margelo.nitro.AnyObject.create(value))
+    cppPart.pointee.setObject(std.string(key), margelo.nitro.AnyObject.create(value))
   }
 
   // pragma MARK: Is Getters
@@ -182,42 +198,49 @@ public class AnyMapHolder {
    * Gets whether the given `key` is holding a null value, or not.
    */
   public func isNull(key: String) -> Bool {
-    return _cppPart.pointee.isNull(std.string(key))
+    return cppPart.pointee.isNull(std.string(key))
   }
 
   /**
    * Gets whether the given `key` is holding a double value, or not.
    */
   public func isDouble(key: String) -> Bool {
-    return _cppPart.pointee.isDouble(std.string(key))
+    return cppPart.pointee.isDouble(std.string(key))
   }
 
   /**
    * Gets whether the given `key` is holding a boolean value, or not.
    */
   public func isBool(key: String) -> Bool {
-    return _cppPart.pointee.isBoolean(std.string(key))
+    return cppPart.pointee.isBoolean(std.string(key))
   }
 
   /**
    * Gets whether the given `key` is holding a bigint value, or not.
    */
   public func isBigInt(key: String) -> Bool {
-    return _cppPart.pointee.isBigInt(std.string(key))
+    return cppPart.pointee.isBigInt(std.string(key))
   }
 
   /**
    * Gets whether the given `key` is holding a string value, or not.
    */
   public func isString(key: String) -> Bool {
-    return _cppPart.pointee.isString(std.string(key))
+    return cppPart.pointee.isString(std.string(key))
   }
-
+  
   /**
-   * Gets whether the given `key` is holding a object value, or not.
+   * Gets whether the given `key` is holding an array value, or not.
+   */
+  public func isArray(key: String) -> Bool {
+    return cppPart.pointee.isArray(std.string(key))
+  }
+  
+  /**
+   * Gets whether the given `key` is holding an object value, or not.
    */
   public func isObject(key: String) -> Bool {
-    return _cppPart.pointee.isObject(std.string(key))
+    return cppPart.pointee.isObject(std.string(key))
   }
 }
 
@@ -236,6 +259,8 @@ extension margelo.nitro.AnyValue {
       return create(bigint)
     case .string(let string):
       return create(string)
+    case .array(let array):
+      return create(array)
     case .object(let object):
       return create(object)
     }
@@ -309,7 +334,8 @@ extension margelo.nitro.AnyObject {
     let keys = margelo.nitro.getAnyObjectKeys(self)
     var dictionary = Dictionary<String, AnyValue>(minimumCapacity: keys.size())
     for key in keys {
-
+      let value = margelo.nitro.getAnyObjectValue(self, key)
+      dictionary[String(key)] = AnyValue.create(value)
     }
     return dictionary
   }

package/ios/core/HybridObjectSpec.swift

@@ -10,7 +10,7 @@ import Foundation
 /**
  * A base protocol for all Swift-based Hybrid Objects.
  */
-public protocol HybridObjectSpec {
+public protocol HybridObjectSpec: AnyObject {
   /**
    * Holds the C++ HybridObject and it's context.
    * Use the default initializer in your implementation, C++ will set and get this value.

package/ios/platform/NitroLogger.mm

@@ -6,7 +6,6 @@
 //
 
 #include "NitroLogger.hpp"
-#include "AnyMapHolder.hpp"
 #include "NitroDefines.hpp"
 #include <Foundation/Foundation.h>
 

package/ios/turbomodule/NativeNitroModules+NewArch.mm

@@ -0,0 +1,67 @@
+//
+//  NativeNitroModules+NewArch.mm
+//  DoubleConversion
+//
+//  Created by Marc Rousavy on 21.06.24.
+//
+
+#import "NativeNitroModules.h"
+
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#import "CallInvokerDispatcher.hpp"
+#import "InstallNitro.hpp"
+
+#import <ReactCommon/CallInvoker.h>
+#import <ReactCommon/RCTTurboModuleWithJSIBindings.h>
+
+using namespace facebook;
+using namespace margelo;
+
+// Make NativeNitroModules comply to RCTTurboModuleWithJSIBindings
+@interface NativeNitroModules () <RCTTurboModuleWithJSIBindings>
+@end
+
+/**
+ * NativeNitroModules implementation for the new architecture.
+ * This uses `installJSIBindingsWithRuntime:` to install the `global.NitroModulesProxy` into the JS Runtime.
+ */
+@implementation NativeNitroModules {
+  bool _didInstall;
+  std::weak_ptr<react::CallInvoker> _callInvoker;
+}
+RCT_EXPORT_MODULE(NitroModules)
+
+- (void)installJSIBindingsWithRuntime:(jsi::Runtime&)runtime {
+  // 1. Get CallInvoker we cached statically
+  auto callInvoker = _callInvoker.lock();
+  if (callInvoker == nullptr) {
+    throw std::runtime_error("Cannot install global.NitroModulesProxy - CallInvoker was null!");
+  }
+
+  // 2. Wrap CallInvoker as Dispatcher
+  auto dispatcher = std::make_shared<nitro::CallInvokerDispatcher>(callInvoker);
+
+  // 3. Install Nitro
+  nitro::install(runtime, dispatcher);
+  _didInstall = true;
+}
+
+- (NSString*)install {
+  if (_didInstall) {
+    // installJSIBindingsWithRuntime ran successfully.
+    return nil;
+  } else {
+    return @"installJSIBindingsWithRuntime: was not called - JSI Bindings could not be installed!";
+  }
+}
+
+- (std::shared_ptr<react::TurboModule>)getTurboModule:(const react::ObjCTurboModule::InitParams&)params {
+  // Cache the CallInvoker statically (weak) - we use it later in `installJSIBindingsWithRuntime:`.
+  _callInvoker = params.jsInvoker;
+  return std::make_shared<react::NativeNitroModulesSpecJSI>(params);
+}
+
+@end
+
+#endif

package/ios/turbomodule/NativeNitroModules+OldArch.mm

@@ -0,0 +1,68 @@
+//
+//  NativeNitroModules+OldArch.mm
+//  DoubleConversion
+//
+//  Created by Marc Rousavy on 21.06.24.
+//
+
+#import "NativeNitroModules.h"
+
+#ifndef RCT_NEW_ARCH_ENABLED
+
+#import "CallInvokerDispatcher.hpp"
+#import "InstallNitro.hpp"
+
+#import <React/RCTBridge+Private.h>
+#import <React/RCTBridge.h>
+
+using namespace facebook;
+using namespace margelo;
+
+// forward-declaration (private API)
+@interface RCTBridge (JSIRuntime)
+- (void*)runtime;
+- (std::shared_ptr<react::CallInvoker>)jsCallInvoker;
+@end
+
+/**
+ * NativeNitroModules implementation for the old architecture.
+ * This uses `RCTBridge` to grab the `jsi::Runtime` and `react::CallInvoker`.
+ */
+@implementation NativeNitroModules
+RCT_EXPORT_MODULE(NitroModules)
+
+RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(install) {
+  try {
+    // 1. Cast RCTBridge to a RCTCxxBridge (ObjC)
+    RCTCxxBridge* cxxBridge = (RCTCxxBridge*)RCTBridge.currentBridge;
+    if (!cxxBridge) {
+      return @"RCTBridge is not a RCTCxxBridge!";
+    }
+
+    // 2. Access jsi::Runtime and cast from void*
+    jsi::Runtime* runtime = reinterpret_cast<jsi::Runtime*>(cxxBridge.runtime);
+    if (!runtime) {
+      return @"jsi::Runtime on RCTCxxBridge was null!";
+    }
+
+    // 3. Access react::CallInvoker
+    std::shared_ptr<react::CallInvoker> callInvoker = cxxBridge.jsCallInvoker;
+    if (!callInvoker) {
+      return @"react::CallInvoker on RCTCxxBridge was null!";
+    }
+
+    // 4. Wrap react::CallInvoker in nitro::Dispatcher
+    auto dispatcher = std::make_shared<nitro::CallInvokerDispatcher>(callInvoker);
+
+    // 5. Install Nitro
+    nitro::install(*runtime, dispatcher);
+    return nil;
+  } catch (std::runtime_error& error) {
+    // ?. Any C++ error occurred (probably in nitro::install()?)
+    return [NSString stringWithCString:error.what() encoding:kCFStringEncodingUTF8];
+  }
+}
+
+@end
+
+#endif

package/ios/turbomodule/NativeNitroModules.h

@@ -0,0 +1,22 @@
+//
+//  NativeNitroModules.h
+//  NitroModules
+//
+//  Created by Marc Rousavy on 07.10.24.
+//
+
+#ifdef RCT_NEW_ARCH_ENABLED
+
+// New Architecture uses the Codegen'd Spec (TurboModule)
+#import "NitroModulesSpec.h"
+@interface NativeNitroModules : NSObject <NativeNitroModulesSpec>
+@end
+
+#else
+
+// Old Architecture is an untyped RCTBridgeModule
+#import <React/RCTBridgeModule.h>
+@interface NativeNitroModules : NSObject <RCTBridgeModule>
+@end
+
+#endif

package/lib/BoxedHybridObject.d.ts

@@ -0,0 +1,12 @@
+import type { HybridObject } from './HybridObject';
+/**
+ * Represents a boxed {@linkcode HybridObject} that can later be unboxed again.
+ * This is implemented as a `jsi::HostObject`.
+ */
+export interface BoxedHybridObject<T extends HybridObject> {
+    /**
+     * Unboxes the {@linkcode HybridObject}.
+     * This can be called from a different Runtime than the one it was boxed in.
+     */
+    unbox(): T;
+}

package/lib/BoxedHybridObject.js

@@ -0,0 +1 @@
+export {};

package/lib/ModuleNotFoundError.js

@@ -20,26 +20,16 @@ function getFrameworkType() {
 }
 export class ModuleNotFoundError extends Error {
     constructor(cause) {
-        // TurboModule not found, something went wrong!
-        if (global.__turboModuleProxy == null) {
-            // TurboModules are not available/new arch is not enabled.
-            const message = 'Failed to get NitroModules: NitroModules require the new architecture to be enabled!';
-            const suggestions = [];
-            suggestions.push('Enable the new architecture in your app to use NitroModules. (See https://github.com/reactwg/react-native-new-architecture/blob/main/docs/enable-apps.md)');
-            const error = messageWithSuggestions(message, suggestions);
-            super(error, { cause: cause });
-            return;
-        }
         const framework = getFrameworkType();
         if (framework === 'expo-go') {
             super('NitroModules are not supported in Expo Go! Use EAS (`expo prebuild`) or eject to a bare workflow instead.');
             return;
         }
-        const message = 'Failed to get NitroModules: The native "NitroModules" TurboModule could not be found.';
+        const message = 'Failed to get NitroModules: The native "NitroModules" Turbo/Native-Module could not be found.';
         const suggestions = [];
         suggestions.push('Make sure react-native-nitro-modules/NitroModules is correctly autolinked (run `npx react-native config` to verify)');
-        suggestions.push('Make sure you enabled the new architecture (TurboModules) and CodeGen properly generated the "NativeNitroModules"/NitroModulesCxx specs. See https://github.com/reactwg/react-native-new-architecture/blob/main/docs/enable-apps.md');
-        suggestions.push('Make sure you are using react-native 0.74.0 or higher, because NitroModules are built with C++ TurboModules.');
+        suggestions.push('Make sure you enabled the new architecture (TurboModules) and CodeGen properly generated the "NativeNitroModules"/NitroModules specs. See https://github.com/reactwg/react-native-new-architecture/blob/main/docs/enable-apps.md');
+        suggestions.push('Make sure you are using react-native 0.74.0 or higher.');
         suggestions.push('Make sure you rebuilt the app.');
         if (framework === 'expo') {
             suggestions.push('Make sure you ran `expo prebuild`.');