react-native-nitro-modules 0.0.6 → 0.0.8

package/NitroModules.podspec

@@ -28,11 +28,11 @@ Pod::Spec.new do |s|
   ]
   s.public_header_files = [
     # Public C++ headers will be exposed in modulemap (for Swift)
+    "cpp/core/ArrayBuffer.hpp",
     "cpp/core/HybridObject.hpp",
     "cpp/core/HybridContext.hpp",
     "cpp/registry/HybridObjectRegistry.hpp",
     "cpp/jsi/JSIConverter.hpp",
-    "cpp/jsi/ArrayBuffer.hpp",
     "cpp/threading/Dispatcher.hpp",
     "cpp/utils/NitroHash.hpp",
     "cpp/utils/NitroDefines.hpp",

package/README.md

@@ -0,0 +1,210 @@
+<a href="https://margelo.io">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="../../docs/img/banner-react-native-nitro-modules-dark.png" />
+    <source media="(prefers-color-scheme: light)" srcset="../../docs/img/banner-react-native-nitro-modules-light.png" />
+    <img alt="Nitrogen" src="../../docs/img/banner-react-native-nitro-modules-light.png" />
+  </picture>
+</a>
+
+<br />
+
+**react-native-nitro-modules** is a core library that contains highly efficient statically compiled JS to C++ bindings.
+
+It uses JSI to generate C++ templates that can bridge virtually any JS type to a C++ type with minimal overhead.
+
+## Installation
+
+### Inside an app
+
+Install [react-native-nitro-modules](https://npmjs.org/react-native-nitro-modules) as a `dependency` in your react-native app:
+```sh
+npm i react-native-nitro-modules
+cd ios && pod install
+```
+
+### Inside a nitro module library
+
+If you are building a nitro module yourself, add [react-native-nitro-modules](https://npmjs.org/react-native-nitro-modules) as a `peerDependency` into your library's `package.json`:
+
+```json
+{
+  ...
+  "peerDependencies": {
+    ...
+    "react-native-nitro-modules": "*"
+  },
+}
+```
+
+Then install `react-native-nitro-modules` as a normal `dependency` in your library's `example/` app as seen above.
+
+## Usage
+
+**react-native-nitro-modules** can either be used with-, or without nitrogen, or mixed (some objects are automatically generated, some manually).
+
+### With Nitrogen
+
+When using Nitrogen, all the bindings are automatically generated. You only need to implement C++, Swift or Kotlin interfaces inside your codebase.
+
+### Without Nitrogen
+
+All C++ bindings are bridged to JS using "Hybrid Objects".
+
+A Hybrid Object can have both methods and properties (get and set).
+Create a C++ Hybrid Object by inheriting from `HybridObject`:
+
+```cpp
+#include <NitroModules/HybridObject.hpp>
+
+using namespace margelo::nitro;
+
+class MyHybridObject: public HybridObject {
+public:
+  explicit MyHybridObject(): HybridObject(TAG) {}
+
+public:
+  // Property (get)
+  double getNumber() { return 13; }
+  // Property (set)
+  void setNumber(double value) { }
+  // Method
+  double add(double left, double right) { return left + right; }
+
+public:
+  void loadHybridMethods() override {
+    // Register all methods that need to be exposed to JS
+    registerHybridGetter("number", &MyHybridObject::getNumber, this);
+    registerHybridSetter("number", &MyHybridObject::setNumber, this);
+    registerHybridMethod("add", &MyHybridObject::add, this);
+  }
+
+private:
+  static constexpr auto TAG = "MyHybrid";
+};
+```
+
+The `MyHybridObject` can then be registered in the [`HybridObjectRegistry`](./cpp/registry/HybridObjectRegistry.hpp) at app startup:
+
+```cpp
+#include <NitroModules/HybridObjectRegistry.hpp>
+
+// Call this at app startup to register the HybridObjects
+void load() {
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "MyHybrid",
+    []() -> std::shared_ptr<HybridObject> {
+      return std::make_shared<MyHybridObject>();
+    }
+  );
+}
+```
+
+Inside your `MyHybridObject`, you can use standard C++ types which will automatically be converted to JS using Nitro's [`JSIConverter<T>`](./cpp/jsi/JSIConverter.hpp) interface.
+
+The following C++ / JS types are supported out of the box:
+
+<table>
+  <tr>
+    <th>JS Type</th>
+    <th>C++ Type</th>
+  </tr>
+
+  <tr>
+    <td><code>number</code></td>
+    <td><code>double</code> / <code>int</code> / <code>float</code></td>
+  </tr>
+  <tr>
+    <td><code>boolean</code></td>
+    <td><code>bool</code></td>
+  </tr>
+  <tr>
+    <td><code>string</code></td>
+    <td><code>std::string</code></td>
+  </tr>
+  <tr>
+    <td><code>bigint</code></td>
+    <td><code>int64_t</code> / <code>uint64_t</code></td>
+  </tr>
+  <tr>
+    <td><code>T[]</code></td>
+    <td><code>std::vector&lt;T&gt;</code></td>
+  </tr>
+  <tr>
+    <td><code>[A, B, C, ...]</code></td>
+    <td><code>std::tuple&lt;A, B, C, ...&gt;</code></td>
+  </tr>
+  <tr>
+    <td><code>A | B | C | ...</code></td>
+    <td><code>std::variant&lt;A, B, C, ...&gt;</code></td>
+  </tr>
+  <tr>
+    <td><code>Record&lt;string, T&gt;</code></td>
+    <td><code>std::unordered_map&lt;std::string, T&gt;</code></td>
+  </tr>
+  <tr>
+    <td><code>T?</code></td>
+    <td><code>std::optional&lt;T&gt;</code></td>
+  </tr>
+  <tr>
+    <td><code>Promise&lt;T&gt;</code></td>
+    <td><code>std::future&lt;T&gt;</code></td>
+  </tr>
+  <tr>
+    <td><code>(TArgs...) =&gt; TReturn</code></td>
+    <td><code>std::function&lt;std::future&lt;TReturn&gt; (TArgs...)&gt;</code></td>
+  </tr>
+  <tr>
+    <td><code>{ ... }</code></td>
+    <td><code>std::shared_ptr&lt;<a href="./cpp/core/AnyMap.hpp">AnyMap</a>&gt;</code></td>
+  </tr>
+  <tr>
+    <td><code>ArrayBuffer</code></td>
+    <td><code>std::shared_ptr&lt;<a href="./cpp/core/ArrayBuffer.hpp">ArrayBuffer</a>&gt;</code></td>
+  </tr>
+  <tr>
+    <td><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>
+  </tr>
+</table>
+
+
+Since the `JSIConverter<T>` is just a template, you can extend it with any other custom types by overloading the interface.
+
+For example, to add support for an enum, overload `JSIConverter<YourEnum>`:
+
+```cpp
+#include <NitroModules/JSIConverter.hpp>
+
+enum class MyEnum {
+  FIRST = 0,
+  SECOND = 1
+};
+
+namespace margelo::nitro {
+  template <>
+  struct JSIConverter<MyEnum> {
+    static inline MyEnum fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      int intValue = JSIConverter<int>::fromJSI(runtime, arg);
+      return static_cast<MyEnum>(intValue);
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, MyEnum arg) {
+      int intValue = static_cast<int>(arg);
+      return JSIConverter<int>::toJSI(runtime, intValue);
+    }
+  };
+}
+```
+
+..and on the JS side, you can implicitly cast the `number` to an enum as well:
+
+```js
+enum MyEnum {
+  FIRST = 0,
+  SECOND = 1
+}
+const value = myHybridObject.getEnumValue() // <-- typed as `MyEnum` instead of `number`
+```
+
+Make sure to always include the header that defines the `JSIConverter<MyEnum>` overload inside the `MyHybridObject` file, as this is where the `JSIConverter<T>` overloads are accessed from.
+
+[**Nitrogen**](../nitrogen/) can automatically generate such `JSIConverter<T>` extensions for enums, TypeScript unions, and even structs/objects - so it is generally recommended to use nitrogen.

package/android/CMakeLists.txt

@@ -26,6 +26,7 @@ include_directories(
   ../cpp/platform
   ../cpp/registry
   ../cpp/test-object
+  ../cpp/templates
   ../cpp/threading
   ../cpp/turbomodule
   ../cpp/utils

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+</manifest>

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

@@ -0,0 +1,17 @@
+/// Entry point for JNI.
+
+#include "JHybridObjectRegistry.hpp"
+#include "RegisterNativeNitroModules.hpp"
+#include <jni.h>
+
+using namespace margelo::nitro;
+
+JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
+  // 1. Initialize the Nitro JSI Turbo Module
+  RegisterNativeNitroModules::registerNativeNitroModules();
+
+  // 2. Initialize all Java bindings
+  JHybridObjectRegistry::registerNatives();
+
+  return JNI_VERSION_1_2;
+}

package/android/src/main/cpp/core/JHybridObject.cpp

@@ -0,0 +1,8 @@
+//
+//  JHybridObject.hpp
+//  react-native-nitro
+//
+//  Created by Marc Rousavy on 14.07.24.
+//
+
+namespace margelo::nitro {} // namespace margelo::nitro

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

@@ -0,0 +1,25 @@
+//
+//  JHybridObject.hpp
+//  react-native-nitro
+//
+//  Created by Marc Rousavy on 14.07.24.
+//
+
+#pragma once
+
+#include "HybridObject.hpp"
+#include <fbjni/fbjni.h>
+
+namespace margelo::nitro {
+
+using namespace facebook;
+
+struct JHybridObject : public jni::HybridClass<JHybridObject>, public HybridObject {
+public:
+  static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/HybridObject;";
+
+public:
+  static void registerNatives();
+};
+
+} // namespace margelo::nitro

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

@@ -0,0 +1,35 @@
+//
+//  ThreadUtils.cpp
+//  react-native-nitro
+//
+//  Created by Marc Rousavy on 14.07.24.
+//
+
+#include "ThreadUtils.hpp"
+#include <pthread.h>
+#include <sstream>
+#include <string>
+#include <thread>
+
+namespace margelo::nitro {
+
+std::string ThreadUtils::getThreadName() {
+#ifdef HAVE_ANDROID_PTHREAD_SETNAME_NP
+  // Try using pthread APIs
+  pthread_t this_thread = pthread_self();
+  char thread_name[16]; // Thread name length limit in Android is 16 characters
+
+  int result = pthread_getname_np(this_thread, thread_name, sizeof(thread_name));
+  if (result == 0) {
+    return std::string(thread_name);
+  }
+#endif
+
+  // Fall back to this_thread ID
+  std::stringstream stream;
+  stream << std::this_thread::get_id();
+  std::string threadId = stream.str();
+  return "Thread #" + threadId;
+}
+
+} // namespace margelo::nitro

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

@@ -0,0 +1,29 @@
+//
+//  JHybridObjectInitializer.hpp
+//  DoubleConversion
+//
+//  Created by Marc Rousavy on 22.07.24.
+//
+
+#pragma once
+
+#include "HybridObject.hpp"
+#include "JHybridObject.hpp"
+#include <fbjni/fbjni.h>
+
+namespace margelo::nitro {
+
+using namespace facebook;
+
+struct JHybridObjectInitializer : public jni::JavaClass<JHybridObjectInitializer> {
+public:
+  jni::local_ref<JHybridObject::javaobject> call() const {
+    const auto method = this->getClass()->getMethod<JHybridObject::javaobject()>("initialize");
+    return method(self());
+  }
+
+public:
+  static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/HybridObjectInitializer;";
+};
+
+} // namespace margelo::nitro

package/android/src/main/cpp/registry/JHybridObjectRegistry.cpp

@@ -0,0 +1,35 @@
+//
+//  JHybridObjectRegistry.cpp
+//  DoubleConversion
+//
+//  Created by Marc Rousavy on 22.07.24.
+//
+
+#include "JHybridObjectRegistry.hpp"
+#include "HybridObjectRegistry.hpp"
+#include "JNISharedPtr.h"
+
+namespace margelo::nitro {
+
+void JHybridObjectRegistry::registerHybridObjectConstructor(jni::alias_ref<jni::JClass> clazz, std::string hybridObjectName,
+                                                            jni::alias_ref<JHybridObjectInitializer> constructorFn) {
+  auto sharedInitializer = jni::make_global(constructorFn);
+  HybridObjectRegistry::registerHybridObjectConstructor(hybridObjectName, [=]() -> std::shared_ptr<HybridObject> {
+    // 1. Call the Java initializer function
+    jni::local_ref<JHybridObject::javaobject> hybridObject = sharedInitializer->call();
+    // 2. Make the resulting HybridObject a global (shared) reference
+    jni::global_ref<JHybridObject::javaobject> globalHybridObject = jni::make_global(hybridObject);
+    // 3. Create a shared_ptr from the JNI global reference
+    std::shared_ptr<JHybridObject> sharedCppPart = JNISharedPtr::make_shared_from_jni<JHybridObject>(globalHybridObject);
+    // 4. Up-cast to a HybridObject (kinda unsafe)
+    std::shared_ptr<HybridObject> cast = std::static_pointer_cast<HybridObject>(sharedCppPart);
+    return cast;
+  });
+}
+
+void JHybridObjectRegistry::registerNatives() {
+  javaClassStatic()->registerNatives({
+      makeNativeMethod("registerHybridObjectConstructor", JHybridObjectRegistry::registerHybridObjectConstructor),
+  });
+}
+} // namespace margelo::nitro

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

@@ -0,0 +1,30 @@
+//
+//  JHybridObjectRegistry.hpp
+//  DoubleConversion
+//
+//  Created by Marc Rousavy on 22.07.24.
+//
+
+#pragma once
+
+#include "HybridObject.hpp"
+#include "JHybridObjectInitializer.hpp"
+#include <fbjni/fbjni.h>
+
+namespace margelo::nitro {
+
+using namespace facebook;
+
+struct JHybridObjectRegistry : public jni::JavaClass<JHybridObjectRegistry> {
+public:
+  static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/HybridObjectRegistry;";
+
+public:
+  static void registerHybridObjectConstructor(jni::alias_ref<jni::JClass> clazz, std::string hybridObjectName,
+                                              jni::alias_ref<JHybridObjectInitializer> constructorFn);
+
+public:
+  static void registerNatives();
+};
+
+} // namespace margelo::nitro

package/android/src/main/cpp/utils/JNISharedPtr.h

@@ -0,0 +1,36 @@
+//
+// Created by Marc Rousavy on 21.02.24.
+//
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <memory>
+
+namespace margelo::nitro {
+
+using namespace facebook;
+
+template <typename T>
+struct GlobalRefDeleter {
+  explicit GlobalRefDeleter(jni::global_ref<typename T::javaobject> ref) : _ref(ref) {}
+
+  void operator()(T* ptr) {
+    if (_ref) {
+      _ref.release();
+    }
+  }
+
+private:
+  jni::global_ref<typename T::javaobject> _ref;
+};
+
+class JNISharedPtr {
+public:
+  template <typename T, typename std::enable_if<std::is_base_of<jni::HybridClass<T>, T>::value>::type* = nullptr>
+  static std::shared_ptr<T> make_shared_from_jni(jni::global_ref<typename T::javaobject> ref) {
+    return std::shared_ptr<T>(ref->cthis(), GlobalRefDeleter<T>{ref});
+  }
+};
+
+} // namespace margelo::nitro

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

@@ -0,0 +1,61 @@
+package com.margelo.nitro
+
+import android.util.Log
+import androidx.annotation.Keep
+import com.facebook.jni.HybridData
+import com.facebook.proguard.annotations.DoNotStrip
+
+/**
+ * A base class for all Kotlin-based HybridObjects.
+ */
+@Keep
+@DoNotStrip
+@Suppress("KotlinJniMissingFunction")
+abstract class HybridObject {
+    /**
+     * Get the memory size of the Kotlin instance (plus any external heap allocations),
+     * in bytes.
+     *
+     * Override this to allow tracking heap allocations such as buffers or images,
+     * which will help the JS GC be more efficient in deleting large unused objects.
+     *
+     * @example
+     * ```kotlin
+     * val memorySize: ULong
+     *   get() {
+     *     val imageSize = this.bitmap.bytesPerRow * this.bitmap.height
+     *     return getSizeOf(this) + imageSize
+     *   }
+     * ```
+     */
+    @get:DoNotStrip
+    @get:Keep
+    abstract val memorySize: ULong
+
+    /**
+     * Contains the C++ context (Hybrid Data) for the fbjni C++ part.
+     */
+    @DoNotStrip
+    @Keep
+    val mHybridData: HybridData
+
+    init {
+        mHybridData = initHybrid()
+    }
+
+    private external fun initHybrid(): HybridData
+
+    companion object {
+        private const val TAG = "HybridObject"
+        init {
+            try {
+                Log.i(TAG, "Loading NitroModules C++ library...")
+                System.loadLibrary("NitroModules")
+                Log.i(TAG, "Successfully loaded NitroModules C++ library!")
+            } catch (e: Error) {
+                Log.e(TAG, "Failed to load NitroModules C++ library! Is it properly installed and linked?", e)
+                throw e
+            }
+        }
+    }
+}

package/android/src/main/java/com/margelo/nitro/HybridObjectInitializer.java

@@ -0,0 +1,13 @@
+package com.margelo.nitro;
+
+import androidx.annotation.Keep;
+
+import com.facebook.proguard.annotations.DoNotStrip;
+
+@Keep
+@DoNotStrip
+public interface HybridObjectInitializer {
+    @Keep
+    @DoNotStrip
+    HybridObject initialize();
+}

package/android/src/main/java/com/margelo/nitro/HybridObjectRegistry.java

@@ -0,0 +1,30 @@
+package com.margelo.nitro;
+
+import android.util.Log;
+
+import java.util.function.Supplier;
+
+/**
+ * A registry that holds initializers for HybridObjects.
+ * This will be used to initialize them from JS using `NitroModules.get<T>(name)`.
+ * @noinspection JavaJniMissingFunction
+ */
+public class HybridObjectRegistry {
+    /**
+     * Registers the given HybridObject in the `HybridObjectRegistry`.
+     * It will be uniquely identified via it's `hybridObjectName`, and can be initialized from
+     * JS using `NitroModules.get<T>(name)` - which will call the `constructorFn` here.
+     */
+    public static native void registerHybridObjectConstructor(String hybridObjectName, HybridObjectInitializer initializer);
+
+    private static final String TAG = "HybridObjectRegistry";
+    static {
+        Log.i(TAG, "Loading native NitroModules C++ library...");
+        try {
+            System.loadLibrary("NitroModules");
+            Log.i(TAG, "Successfully loaded native NitroModules C++ library!");
+        } catch (Throwable e) {
+            Log.e(TAG, "Failed to load native NitroModules C++ library!", e);
+        }
+    }
+}

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

@@ -0,0 +1,26 @@
+package com.margelo.nitro;
+
+import androidx.annotation.Nullable;
+
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.module.model.ReactModuleInfoProvider;
+import com.facebook.react.TurboReactPackage;
+
+import java.util.HashMap;
+
+public class NitroModulesPackage extends TurboReactPackage {
+
+  @Nullable
+  @Override
+  public NativeModule getModule(String name, ReactApplicationContext reactContext) {
+    return null;
+  }
+
+  @Override
+  public ReactModuleInfoProvider getReactModuleInfoProvider() {
+    return () -> {
+      return new HashMap<>();
+    };
+  }
+}

package/cpp/core/HybridObject.hpp

@@ -4,6 +4,7 @@
 
 #pragma once
 
+#include "CountTrailingOptionals.hpp"
 #include "HybridContext.hpp"
 #include "JSIConverter.hpp"
 #include "NitroLogger.hpp"
@@ -67,7 +68,8 @@ public:
    * Get the `std::shared_ptr` instance of this HybridObject.
    * The HybridObject must be managed inside a `shared_ptr` already, otherwise this will fail.
    */
-  template <typename Derived> std::shared_ptr<Derived> shared() {
+  template <typename Derived>
+  std::shared_ptr<Derived> shared() {
     return std::static_pointer_cast<Derived>(shared_from_this());
   }
 
@@ -151,14 +153,16 @@ private:
 private:
   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,
-                                      std::index_sequence<Is...>) {
+                                      size_t argsSize, std::index_sequence<Is...>) {
+    jsi::Value defaultValue;
+
     if constexpr (std::is_void_v<ReturnType>) {
       // It's a void method.
-      (obj->*method)(JSIConverter<std::decay_t<Args>>::fromJSI(runtime, args[Is])...);
+      (obj->*method)(JSIConverter<std::decay_t<Args>>::fromJSI(runtime, Is < argsSize ? args[Is] : defaultValue)...);
       return jsi::Value::undefined();
     } else {
       // It's returning some C++ type, we need to convert that to a JSI value now.
-      ReturnType result = (obj->*method)(JSIConverter<std::decay_t<Args>>::fromJSI(runtime, args[Is])...);
+      ReturnType result = (obj->*method)(JSIConverter<std::decay_t<Args>>::fromJSI(runtime, Is < argsSize ? args[Is] : defaultValue)...);
       return JSIConverter<std::decay_t<ReturnType>>::toJSI(runtime, std::move(result));
     }
   }
@@ -168,11 +172,22 @@ private:
                                                          MethodType type) {
     return [name, derivedInstance, method, type](jsi::Runtime& runtime, const jsi::Value& thisVal, const jsi::Value* args,
                                                  size_t count) -> jsi::Value {
-      if (count != sizeof...(Args)) {
+      constexpr size_t optionalArgsCount = trailing_optionals_count_v<Args...>;
+      constexpr size_t maxArgsCount = sizeof...(Args);
+      constexpr size_t minArgsCount = maxArgsCount - optionalArgsCount;
+      bool isWithinArgsRange = (count >= minArgsCount && count <= maxArgsCount);
+      if (!isWithinArgsRange) {
         // invalid amount of arguments passed!
         std::string hybridObjectName = derivedInstance->_name;
-        throw jsi::JSError(runtime, hybridObjectName + "." + name + "(...) expected " + std::to_string(sizeof...(Args)) +
-                                        " arguments, but received " + std::to_string(count) + "!");
+        if (minArgsCount == maxArgsCount) {
+          // min and max args length is the same, so we don't have any optional parameters. fixed count
+          throw jsi::JSError(runtime, hybridObjectName + "." + name + "(...) expected " + std::to_string(maxArgsCount) +
+                                          " arguments, but received " + std::to_string(count) + "!");
+        } else {
+          // min and max args length are different, so we have optional parameters - variable length arguments.
+          throw jsi::JSError(runtime, hybridObjectName + "." + name + "(...) expected between " + std::to_string(minArgsCount) + " and " +
+                                          std::to_string(maxArgsCount) + " arguments, but received " + std::to_string(count) + "!");
+        }
       }
 
       try {
@@ -183,7 +198,7 @@ private:
         } else {
           // Call the actual method with JSI values as arguments and return a JSI value again.
           // Internally, this method converts the JSI values to C++ values.
-          return callMethod(derivedInstance, method, runtime, args, std::index_sequence_for<Args...>{});
+          return callMethod(derivedInstance, method, runtime, args, count, std::index_sequence_for<Args...>{});
         }
       } catch (const std::exception& exception) {
         std::string hybridObjectName = derivedInstance->_name;

package/cpp/core/PointerHolder.hpp

@@ -13,7 +13,8 @@ namespace margelo::nitro {
 
 using namespace facebook;
 
-template <typename T> class PointerHolder final : public HybridObject {
+template <typename T>
+class PointerHolder final : public HybridObject {
 protected:
   // no default constructor
   PointerHolder() = delete;