react-native-nitro-modules 0.10.0 → 0.12.0

package/NitroModules.podspec

@@ -31,6 +31,8 @@ Pod::Spec.new do |s|
     "cpp/core/AnyMap.hpp",
     "cpp/core/ArrayBuffer.hpp",
     "cpp/core/HybridObject.hpp",
+    "cpp/entrypoint/HybridNitroModulesProxy.hpp",
+    "cpp/entrypoint/InstallNitro.hpp",
     "cpp/registry/HybridObjectRegistry.hpp",
     "cpp/jsi/JSIConverter.hpp",
     "cpp/threading/Dispatcher.hpp",
@@ -49,6 +51,8 @@ Pod::Spec.new do |s|
     "CLANG_CXX_LANGUAGE_STANDARD" => "c++20",
     # Enables C++ <-> Swift interop (by default it's only C)
     "SWIFT_OBJC_INTEROP_MODE" => "objcxx",
+    # Enables stricter modular headers
+    "DEFINES_MODULE" => "YES",
   }
 
   install_modules_dependencies(s)

package/README.md

@@ -1,4 +1,4 @@
-<a href="https://margelo.io">
+<a href="https://margelo.com">
   <picture>
     <source media="(prefers-color-scheme: dark)" srcset="../../docs/static/img/banner-react-native-nitro-modules-dark.png" />
     <source media="(prefers-color-scheme: light)" srcset="../../docs/static/img/banner-react-native-nitro-modules-light.png" />
@@ -203,7 +203,7 @@ The following C++ / JS types are supported out of the box:
     <td>..any <code><a href="./src/HybridObject.ts">HybridObject</a></code></td>
     <td><code>std::shared_ptr&lt;<a href="./cpp/core/HybridObject.hpp">HybridObject</a>&gt;</code></td>
     <td><code><a href="./ios/core/HybridObjectSpec.swift">HybridObjectSpec</a></code></td>
-    <td><code><a href="./android/core/HybridObject.kt">HybridObject</a></code></td>
+    <td><code><a href="./android/src/main/java/com/margelo/nitro/core/HybridObject.kt">HybridObject</a></code></td>
   </tr>
   <tr>
     <td>..any <code>interface</code></td>

package/android/CMakeLists.txt

@@ -22,6 +22,7 @@ add_library(NitroModules SHARED
 include_directories(
   # Shared C++ includes
   ../cpp/core
+  ../cpp/entrypoint
   ../cpp/jsi
   ../cpp/platform
   ../cpp/registry
@@ -34,6 +35,7 @@ include_directories(
   # Android-specific C++ includes
   src/main/cpp/core
   src/main/cpp/registry
+  src/main/cpp/turbomodule
   src/main/cpp/platform
   src/main/cpp/utils
 )
@@ -51,4 +53,5 @@ target_link_libraries(
         fbjni::fbjni                              # <-- Facebook C++ JNI helpers
         ReactAndroid::jsi                         # <-- RN: JSI
         ReactAndroid::react_nativemodule_core     # <-- RN: TurboModules Core
+        ReactAndroid::turbomodulejsijni           # <-- RN: TurboModules utils (e.g. CallInvokerHolder)
 )

package/android/build.gradle

@@ -5,7 +5,7 @@ buildscript {
   }
 
   dependencies {
-    classpath "com.android.tools.build:gradle:7.2.1"
+    classpath "com.android.tools.build:gradle:8.7.1"
   }
 }
 
@@ -33,6 +33,8 @@ def getExtOrIntegerDefault(name) {
   return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["Nitro_" + name]).toInteger()
 }
 
+logger.warn("[NitroModules] Your app is boosted by nitro modules! 🔥")
+
 android {
   namespace "com.margelo.nitro"
 
@@ -65,6 +67,26 @@ android {
     prefabPublishing true
   }
 
+  packagingOptions {
+    excludes = [
+            "META-INF",
+            "META-INF/**",
+            "**/libc++_shared.so",
+            "**/libfbjni.so",
+            "**/libjsi.so",
+            "**/libfolly_json.so",
+            "**/libfolly_runtime.so",
+            "**/libglog.so",
+            "**/libhermes.so",
+            "**/libhermes-executor-debug.so",
+            "**/libhermes_executor.so",
+            "**/libreactnativejni.so",
+            "**/libturbomodulejsijni.so",
+            "**/libreact_nativemodule_core.so",
+            "**/libjscexecutor.so"
+    ]
+  }
+
   prefab {
     NitroModules {
       headers "${project.buildDir}/headers/nitromodules/"
@@ -91,8 +113,11 @@ android {
       if (isNewArchitectureEnabled()) {
         java.srcDirs += [
           // React Codegen files
-          "${project.buildDir}/generated/source/codegen/java"
+          "${project.buildDir}/generated/source/codegen/java",
+          "src/newarch"
         ]
+      } else {
+        java.srcDirs += ["src/oldarch"]
       }
     }
   }
@@ -119,7 +144,6 @@ if (isNewArchitectureEnabled()) {
   }
 }
 
-
 task prepareHeaders(type: Copy) {
   from fileTree('./src/main/cpp').filter { it.isFile() }
   from fileTree('../cpp/').filter { it.isFile() }

package/android/src/main/cpp/JNIOnLoad.cpp

@@ -4,8 +4,8 @@
 #include "JAnyValue.hpp"
 #include "JArrayBuffer.hpp"
 #include "JHybridObjectRegistry.hpp"
+#include "JNitroModules.hpp"
 #include "JPromise.hpp"
-#include "RegisterNativeNitroModules.hpp"
 #include <fbjni/fbjni.h>
 #include <jni.h>
 
@@ -13,14 +13,14 @@ using namespace margelo::nitro;
 
 JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
   return facebook::jni::initialize(vm, [] {
-    // 1. Initialize the Nitro JSI Turbo Module
-    RegisterNativeNitroModules::registerNativeNitroModules();
-
-    // 2. Initialize all Java bindings
+    // 1. Initialize all core Nitro Java bindings
     JHybridObjectRegistry::registerNatives();
     JArrayBuffer::registerNatives();
     JAnyMap::registerNatives();
     JAnyValue::registerNatives();
     JPromise::registerNatives();
+
+    // 2. Initialize the React Native TurboModule C++ part
+    JNitroModules::registerNatives();
   });
 }

package/android/src/main/cpp/platform/NitroLogger.cpp

@@ -22,7 +22,7 @@ int levelToAndroidLevel(LogLevel level) {
     case LogLevel::Error:
       return ANDROID_LOG_ERROR;
     default:
-      throw std::runtime_error("Invalid LogLevel!");
+      throw std::invalid_argument("Invalid LogLevel!");
   }
 }
 

package/android/src/main/cpp/turbomodule/JNitroModules.cpp

@@ -0,0 +1,41 @@
+//
+// Created by Marc Rousavy on 07.10.24.
+//
+
+#include "JNitroModules.hpp"
+#include "CallInvokerDispatcher.hpp"
+#include "InstallNitro.hpp"
+
+#include <exception>
+
+namespace margelo::nitro {
+
+JNitroModules::JNitroModules() = default;
+
+jni::local_ref<JNitroModules::jhybriddata> JNitroModules::initHybrid(jni::alias_ref<JNitroModules::jhybridobject>) {
+  return makeCxxInstance();
+}
+
+void JNitroModules::install(jlong runtimePointer, jni::alias_ref<react::CallInvokerHolder::javaobject> callInvokerHolder) {
+  auto runtime = reinterpret_cast<jsi::Runtime*>(runtimePointer);
+  if (runtime == nullptr) {
+    throw std::invalid_argument("jsi::Runtime was null!");
+  }
+
+  if (callInvokerHolder == nullptr) {
+    throw std::invalid_argument("CallInvokerHolder was null!");
+  }
+  auto callInvoker = callInvokerHolder->cthis()->getCallInvoker();
+  if (callInvoker == nullptr) {
+    throw std::invalid_argument("CallInvoker was null!");
+  }
+
+  auto dispatcher = std::make_shared<CallInvokerDispatcher>(callInvoker);
+  margelo::nitro::install(*runtime, dispatcher);
+}
+
+void JNitroModules::registerNatives() {
+  registerHybrid({makeNativeMethod("initHybrid", JNitroModules::initHybrid), makeNativeMethod("install", JNitroModules::install)});
+}
+
+} // namespace margelo::nitro

package/android/src/main/cpp/turbomodule/JNitroModules.hpp

@@ -0,0 +1,37 @@
+//
+// Created by Marc Rousavy on 07.10.24.
+//
+
+#pragma once
+
+#include <ReactCommon/CallInvoker.h>
+#include <ReactCommon/CallInvokerHolder.h>
+#include <fbjni/fbjni.h>
+#include <jsi/jsi.h>
+
+namespace margelo::nitro {
+
+using namespace facebook;
+
+class JNitroModules final : public jni::HybridClass<JNitroModules> {
+public:
+  static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/NitroModules;";
+
+private:
+  explicit JNitroModules();
+
+private:
+  // JNI Methods
+  static jni::local_ref<JNitroModules::jhybriddata> initHybrid(jni::alias_ref<jhybridobject> javaThis);
+  void install(jlong runtimePointer, jni::alias_ref<react::CallInvokerHolder::javaobject> callInvokerHolder);
+
+private:
+  static auto constexpr TAG = "NitroModules";
+  using HybridBase::HybridBase;
+  friend HybridBase;
+
+public:
+  static void registerNatives();
+};
+
+} // namespace margelo::nitro

package/android/src/main/java/com/margelo/nitro/NitroModules.kt

@@ -0,0 +1,69 @@
+package com.margelo.nitro
+
+import androidx.annotation.Keep
+import com.facebook.jni.HybridData
+import com.facebook.proguard.annotations.DoNotStrip
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.common.annotations.FrameworkAPI
+import com.facebook.react.turbomodule.core.CallInvokerHolderImpl
+import com.facebook.react.turbomodule.core.interfaces.CallInvokerHolder
+
+@DoNotStrip
+@Keep
+@OptIn(FrameworkAPI::class)
+@Suppress("KotlinJniMissingFunction")
+class NitroModules internal constructor(val context: ReactApplicationContext) : NitroModulesSpec(context) {
+    private val mHybridData: HybridData
+
+    init {
+        mHybridData = initHybrid()
+        applicationContext = context
+    }
+
+    override fun getName(): String {
+        return NAME
+    }
+
+    @ReactMethod(isBlockingSynchronousMethod = true)
+    override fun install(): String? {
+        try {
+            // 1. Get jsi::Runtime pointer
+            val jsContext = context.javaScriptContextHolder
+                ?: return "ReactApplicationContext.javaScriptContextHolder is null!"
+
+            // 2. Get CallInvokerHolder
+            val callInvokerHolder = context.jsCallInvokerHolder as? CallInvokerHolderImpl
+                ?: return "ReactApplicationContext.jsCallInvokerHolder is null!"
+
+            // 3. Install Nitro
+            install(jsContext.get(), callInvokerHolder)
+
+            return null
+        } catch (e: Throwable) {
+            // ?. Something went wrong! Maybe a JNI error?
+            return e.message
+        }
+    }
+
+    private external fun initHybrid(): HybridData
+    private external fun install(jsRuntimePointer: Long, callInvokerHolder: CallInvokerHolderImpl)
+
+    companion object {
+        /**
+         * The TurboModule's name.
+         */
+        const val NAME = "NitroModules"
+
+        /**
+         * Get the current `ReactApplicationContext`, or `null` if none is available.
+         */
+        @JvmStatic
+        var applicationContext: ReactApplicationContext? = null
+
+        init {
+            // Make sure Nitro's C++ library is loaded
+            JNIOnLoad.initializeNativeNitro()
+        }
+    }
+}

package/android/src/main/java/com/margelo/nitro/NitroModulesPackage.kt

@@ -0,0 +1,34 @@
+package com.margelo.nitro
+
+import com.facebook.react.TurboReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
+
+class NitroModulesPackage : TurboReactPackage() {
+    override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
+        return if (name == NitroModules.NAME) {
+            NitroModules(reactContext)
+        } else {
+            null
+        }
+    }
+
+    override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
+        return ReactModuleInfoProvider {
+            val moduleInfos: MutableMap<String, ReactModuleInfo> = HashMap()
+            val isTurboModule: Boolean = BuildConfig.IS_NEW_ARCHITECTURE_ENABLED
+            moduleInfos[NitroModules.NAME] = ReactModuleInfo(
+                NitroModules.NAME,
+                NitroModules.NAME,
+                canOverrideExistingModule = false,
+                needsEagerInit = false,
+                hasConstants = false,
+                isCxxModule = false,
+                isTurboModule = isTurboModule
+            )
+            moduleInfos
+        }
+    }
+}

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

@@ -4,12 +4,16 @@ import androidx.annotation.Keep
 import com.facebook.jni.HybridData
 import com.facebook.proguard.annotations.DoNotStrip
 
+interface ExtendableHybridClass {
+    fun updateNative(hybridData: HybridData)
+}
+
 /**
  * A base class for all Kotlin-based HybridObjects.
  */
 @Keep
 @DoNotStrip
-abstract class HybridObject {
+abstract class HybridObject: ExtendableHybridClass {
     /**
      * Get the memory size of the Kotlin instance (plus any external heap allocations),
      * in bytes.
@@ -41,7 +45,7 @@ abstract class HybridObject {
      * Must be called in the constructor of a subclass of `HybridObject`, to initialize the C++
      * `JHybridObject` with a subclass of it.
      */
-    protected fun updateNative(hybridData: HybridData) {
+    override fun updateNative(hybridData: HybridData) {
         mHybridData = hybridData
     }
 }

package/android/src/newarch/NitroModulesSpec.kt

@@ -0,0 +1,6 @@
+package com.margelo.nitro
+
+import com.facebook.react.bridge.ReactApplicationContext
+
+abstract class NitroModulesSpec internal constructor(context: ReactApplicationContext) : NativeNitroModulesSpec(context) {
+}

package/android/src/oldarch/NitroModulesSpec.kt

@@ -0,0 +1,9 @@
+package com.margelo.nitro
+
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.Promise
+
+abstract class NitroModulesSpec internal constructor(context: ReactApplicationContext) : ReactContextBaseJavaModule(context) {
+  abstract fun install(): String?
+}

package/cpp/core/HybridFunction.hpp

@@ -173,7 +173,14 @@ private:
     // 1. Convert jsi::Value to jsi::Object
 #ifdef NITRO_DEBUG
     if (!value.isObject()) [[unlikely]] {
-      throw jsi::JSError(runtime, "Cannot " + getHybridFuncDebugInfo<THybrid>(funcKind, funcName) + " - `this` is not bound!");
+      throw jsi::JSError(runtime, "Cannot " + getHybridFuncDebugInfo<THybrid>(funcKind, funcName) +
+                                      " - `this` is not bound! Suggestions:\n"
+                                      "- Did you accidentally destructure the `HybridObject`? (`const { " +
+                                      funcName +
+                                      " } = ...`)\n"
+                                      "- Did you call `dispose()` on the `HybridObject` before?"
+                                      "- Did you accidentally call `" +
+                                      funcName + "` on the prototype directly?");
     }
 #endif
     jsi::Object object = value.getObject(runtime);
@@ -183,10 +190,12 @@ private:
     if (!object.hasNativeState(runtime)) [[unlikely]] {
       throw jsi::JSError(runtime, "Cannot " + getHybridFuncDebugInfo<THybrid>(funcKind, funcName) +
                                       " - `this` does not have a NativeState! Suggestions:\n"
-                                      "- Did you accidentally destructure the `HybridObject` and lose a reference to the original object?\n"
+                                      "- Did you accidentally destructure the `HybridObject`? (`const { " +
+                                      funcName +
+                                      " } = ...`)\n"
                                       "- Did you call `dispose()` on the `HybridObject` before?"
                                       "- Did you accidentally call `" +
-                                      funcName + "` on the prototype directly?\n");
+                                      funcName + "` on the prototype directly?");
     }
 #endif
 
@@ -215,7 +224,7 @@ private:
   template <typename THybrid>
   static inline std::string getHybridFuncFullName(FunctionKind kind, const std::string& registrationName,
                                                   THybrid* hybridInstance = nullptr) {
-    std::string typeName = hybridInstance != nullptr ? hybridInstance->getName() : TypeInfo::getFriendlyTypenameNoNamespace<THybrid>();
+    std::string typeName = hybridInstance != nullptr ? hybridInstance->getName() : TypeInfo::getFriendlyTypename<THybrid>(true);
     switch (kind) {
       case FunctionKind::METHOD:
         return typeName + "." + registrationName + "(...)";

package/cpp/entrypoint/HybridNitroModulesProxy.cpp

@@ -0,0 +1,55 @@
+//
+//  HybridNitroModulesProxy.hpp
+//  NitroModules
+//
+//  Created by Marc Rousavy on 05.10.24
+//
+
+#include "HybridNitroModulesProxy.hpp"
+#include "HybridObjectRegistry.hpp"
+#include "NitroDefines.hpp"
+
+namespace margelo::nitro {
+
+void HybridNitroModulesProxy::loadHybridMethods() {
+  HybridObject::loadHybridMethods();
+
+  registerHybrids(this, [](Prototype& prototype) {
+    prototype.registerHybridMethod("createHybridObject", &HybridNitroModulesProxy::createHybridObject);
+    prototype.registerHybridMethod("hasHybridObject", &HybridNitroModulesProxy::hasHybridObject);
+    prototype.registerHybridMethod("getAllHybridObjectNames", &HybridNitroModulesProxy::getAllHybridObjectNames);
+
+    prototype.registerHybridMethod("box", &HybridNitroModulesProxy::box);
+
+    prototype.registerHybridGetter("buildType", &HybridNitroModulesProxy::getBuildType);
+  });
+}
+
+// Hybrid Object Registry
+std::shared_ptr<HybridObject> HybridNitroModulesProxy::createHybridObject(const std::string& name) {
+  return HybridObjectRegistry::createHybridObject(name);
+}
+
+bool HybridNitroModulesProxy::hasHybridObject(const std::string& name) {
+  return HybridObjectRegistry::hasHybridObject(name);
+}
+
+std::vector<std::string> HybridNitroModulesProxy::getAllHybridObjectNames() {
+  return HybridObjectRegistry::getAllHybridObjectNames();
+}
+
+// Helpers
+std::shared_ptr<BoxedHybridObject> HybridNitroModulesProxy::box(const std::shared_ptr<HybridObject>& hybridObject) {
+  return std::make_shared<BoxedHybridObject>(hybridObject);
+}
+
+// Build Info
+std::string HybridNitroModulesProxy::getBuildType() {
+#ifdef NITRO_DEBUG
+  return "debug";
+#else
+  return "release";
+#endif
+}
+
+} // namespace margelo::nitro

package/cpp/entrypoint/HybridNitroModulesProxy.hpp

@@ -0,0 +1,48 @@
+//
+//  HybridNitroModulesProxy.hpp
+//  NitroModules
+//
+//  Created by Marc Rousavy on 05.10.24
+//
+
+#pragma once
+
+#include "BoxedHybridObject.hpp"
+#include "HybridObject.hpp"
+#include <memory>
+#include <string>
+
+namespace margelo::nitro {
+
+/**
+ * Represents the entry point for all other HybridObjects.
+ * The flow is as following:
+ * 1. (optional) Install a Dispatcher in `jsi::Runtime` to use async/callbacks.
+ * 2. Create an instance of `HybridNitroModulesProxy`
+ * 3. Pass the object from `.toObject()` it to JS (either install in global, or return somehow)
+ * 4. From JS, you can access methods on this HybridObject to create all other HybridObjects.
+ */
+class HybridNitroModulesProxy : public HybridObject {
+public:
+  explicit HybridNitroModulesProxy() : HybridObject(TAG) {}
+
+public:
+  void loadHybridMethods() override;
+
+public:
+  // Hybrid Object Registry
+  std::shared_ptr<HybridObject> createHybridObject(const std::string& name);
+  bool hasHybridObject(const std::string& name);
+  std::vector<std::string> getAllHybridObjectNames();
+
+  // Helpers
+  std::shared_ptr<BoxedHybridObject> box(const std::shared_ptr<HybridObject>& hybridObject);
+
+  // Build Info
+  std::string getBuildType();
+
+private:
+  static constexpr auto TAG = "NitroModulesProxy";
+};
+
+} // namespace margelo::nitro

package/cpp/entrypoint/InstallNitro.cpp

@@ -0,0 +1,28 @@
+//
+//  InstallNitro.cpp
+//  NitroModules
+//
+//  Created by Marc Rousavy on 05.10.24
+//
+
+#include "InstallNitro.hpp"
+#include "HybridNitroModulesProxy.hpp"
+
+namespace margelo::nitro {
+
+void install(jsi::Runtime& runtime, std::shared_ptr<Dispatcher> dispatcher) {
+  // Registers a Dispatcher for Nitro to call back into the JS Runtime.
+  // This allows creating Promises and calling back to JS.
+  Dispatcher::installRuntimeGlobalDispatcher(runtime, dispatcher);
+
+  // Installs NitroModulesProxy itself into the Runtime's global.
+  install(runtime);
+}
+
+void install(jsi::Runtime& runtime) {
+  // Installs global.NitroModulesProxy
+  auto proxy = std::make_shared<HybridNitroModulesProxy>();
+  runtime.global().setProperty(runtime, "NitroModulesProxy", proxy->toObject(runtime));
+}
+
+} // namespace margelo::nitro

package/cpp/entrypoint/InstallNitro.hpp

@@ -0,0 +1,41 @@
+//
+//  InstallNitro.hpp
+//  NitroModules
+//
+//  Created by Marc Rousavy on 05.10.24
+//
+
+#pragma once
+
+#include "Dispatcher.hpp"
+#include <jsi/jsi.h>
+#include <memory>
+
+namespace margelo::nitro {
+
+/**
+ * Installs Nitro into the given JS `runtime`.
+ * This will create `global.NitroModulesProxy`, Nitro's entry-point,
+ * which can be used to create all registered HybridObjects from JS.
+ *
+ * Also registers the given `dispatcher` which allows using callbacks,
+ * and async code (Promises).
+ * The `dispatcher` needs to implement `runAsync`/`runSync` to run
+ * methods on whatever Thread can safely access `runtime`.
+ * In a non-thread-safe Runtime, it needs to be a single Thread (e.g.
+ * React's `CallInvoker`), but in a thread-safe Runtime it might just be
+ * an implementation that runs the method directly.
+ */
+void install(jsi::Runtime& runtime, std::shared_ptr<Dispatcher> dispatcher);
+
+/**
+ * Installs Nitro into the given JS `runtime`.
+ * This will create `global.NitroModulesProxy`, Nitro's entry-point,
+ * which can be used to create all registered HybridObjects from JS.
+ *
+ * No `Dispatcher` will be installed, meaning Nitro can only use synchronous
+ * methods.
+ */
+void install(jsi::Runtime& runtime);
+
+} // namespace margelo::nitro

package/cpp/jsi/JSIConverter+ArrayBuffer.hpp

@@ -33,18 +33,18 @@ struct JSIConverter<T, std::enable_if_t<is_shared_ptr_to_v<T, jsi::MutableBuffer
   static inline std::shared_ptr<ArrayBuffer> fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
 #ifdef NITRO_DEBUG
     if (!arg.isObject()) [[unlikely]] {
-      throw std::runtime_error("Value \"" + arg.toString(runtime).utf8(runtime) +
-                               "\" is not an ArrayBuffer - "
-                               "in fact, it's not even an object!");
+      throw std::invalid_argument("Value \"" + arg.toString(runtime).utf8(runtime) +
+                                  "\" is not an ArrayBuffer - "
+                                  "in fact, it's not even an object!");
     }
 #endif
 
     jsi::Object object = arg.asObject(runtime);
 #ifdef NITRO_DEBUG
     if (!object.isArrayBuffer(runtime)) [[unlikely]] {
-      throw std::runtime_error("Object \"" + arg.toString(runtime).utf8(runtime) +
-                               "\" is not an ArrayBuffer! "
-                               "Are you maybe passing a TypedArray (e.g. Uint8Array)? Try to pass it's `.buffer` value.");
+      throw std::invalid_argument("Object \"" + arg.toString(runtime).utf8(runtime) +
+                                  "\" is not an ArrayBuffer! "
+                                  "Are you maybe passing a TypedArray (e.g. Uint8Array)? Try to pass it's `.buffer` value.");
     }
 #endif