react-native-nitro-modules 0.4.1 → 0.6.0

package/cpp/turbomodule/NativeNitroModules.cpp

@@ -25,7 +25,7 @@ jsi::Value NativeNitroModules::get(jsi::Runtime& runtime, const jsi::PropNameID&
   if (name == "install") {
     return jsi::Function::createFromHostFunction(
         runtime, jsi::PropNameID::forUtf8(runtime, "install"), 0,
-        [=](jsi::Runtime& runtime, const jsi::Value& thisArg, const jsi::Value* args, size_t count) -> jsi::Value {
+        [this](jsi::Runtime& runtime, const jsi::Value& thisArg, const jsi::Value* args, size_t count) -> jsi::Value {
           install(runtime);
           return jsi::Value::undefined();
         });
@@ -33,8 +33,8 @@ jsi::Value NativeNitroModules::get(jsi::Runtime& runtime, const jsi::PropNameID&
   if (name == "createHybridObject") {
     return jsi::Function::createFromHostFunction(
         runtime, jsi::PropNameID::forUtf8(runtime, "createHybridObject"), 2,
-        [=](jsi::Runtime& runtime, const jsi::Value& thisArg, const jsi::Value* args, size_t count) -> jsi::Value {
-#if DEBUG
+        [this](jsi::Runtime& runtime, const jsi::Value& thisArg, const jsi::Value* args, size_t count) -> jsi::Value {
+#ifndef NDEBUG
           if (count != 1 && count != 2) [[unlikely]] {
             throw jsi::JSError(runtime, "NitroModules.createHybridObject(..) expects 1 or 2 arguments, but " + std::to_string(count) +
                                             " were supplied!");
@@ -52,8 +52,8 @@ jsi::Value NativeNitroModules::get(jsi::Runtime& runtime, const jsi::PropNameID&
   if (name == "hasHybridObject") {
     return jsi::Function::createFromHostFunction(
         runtime, jsi::PropNameID::forUtf8(runtime, "hasHybridObject"), 1,
-        [=](jsi::Runtime& runtime, const jsi::Value& thisArg, const jsi::Value* args, size_t count) -> jsi::Value {
-#if DEBUG
+        [this](jsi::Runtime& runtime, const jsi::Value& thisArg, const jsi::Value* args, size_t count) -> jsi::Value {
+#ifndef NDEBUG
           if (count != 1) [[unlikely]] {
             throw jsi::JSError(runtime,
                                "NitroModules.hasHybridObject(..) expects 1 argument (name), but received " + std::to_string(count) + "!");
@@ -65,8 +65,26 @@ jsi::Value NativeNitroModules::get(jsi::Runtime& runtime, const jsi::PropNameID&
   }
   if (name == "getAllHybridObjectNames") {
     return jsi::Function::createFromHostFunction(runtime, jsi::PropNameID::forUtf8(runtime, "getAllHybridObjectNames"), 0,
-                                                 [=](jsi::Runtime& runtime, const jsi::Value& thisArg, const jsi::Value* args,
-                                                     size_t count) -> jsi::Value { return getAllHybridObjectNames(runtime); });
+                                                 [this](jsi::Runtime& runtime, const jsi::Value& thisArg, const jsi::Value* args,
+                                                        size_t count) -> jsi::Value { return getAllHybridObjectNames(runtime); });
+  }
+  if (name == "hasNativeState") {
+    return jsi::Function::createFromHostFunction(
+        runtime, jsi::PropNameID::forUtf8(runtime, "hasNativeState"), 1,
+        [](jsi::Runtime& runtime, const jsi::Value& thisArg, const jsi::Value* args, size_t count) -> jsi::Value {
+          jsi::Object object = args[0].asObject(runtime);
+          bool has = object.hasNativeState(runtime) && object.getNativeState(runtime) != nullptr;
+          return jsi::Value(has);
+        });
+  }
+  if (name == "removeNativeState") {
+    return jsi::Function::createFromHostFunction(
+        runtime, jsi::PropNameID::forUtf8(runtime, "removeNativeState"), 1,
+        [](jsi::Runtime& runtime, const jsi::Value& thisArg, const jsi::Value* args, size_t count) -> jsi::Value {
+          jsi::Object object = args[0].asObject(runtime);
+          object.setNativeState(runtime, nullptr);
+          return jsi::Value::undefined();
+        });
   }
 
   return jsi::Value::undefined();
@@ -80,7 +98,7 @@ void NativeNitroModules::install(jsi::Runtime& runtime) {
 }
 
 jsi::Value NativeNitroModules::createHybridObject(jsi::Runtime& runtime, const jsi::String& hybridObjectName,
-                                                  const std::optional<jsi::Object>& args) {
+                                                  const std::optional<jsi::Object>&) {
   auto name = hybridObjectName.utf8(runtime);
   // TODO: Pass args? Do we need that?
   auto hybridObject = HybridObjectRegistry::createHybridObject(name.c_str());

package/cpp/turbomodule/NativeNitroModules.h

@@ -4,4 +4,5 @@
 
 #pragma once
 
+// Forward include, because in react-native they use `.h` instead of `.hpp`
 #include "NativeNitroModules.hpp"

package/cpp/turbomodule/NativeNitroModules.hpp

@@ -22,7 +22,9 @@ public:
 public:
   jsi::Value get(jsi::Runtime& runtime, const jsi::PropNameID& propName) override;
 
+  // Setup
   void install(jsi::Runtime& runtime);
+  // Hybrid Objects stuff
   jsi::Value createHybridObject(jsi::Runtime& runtime, const jsi::String& hybridObjectName, const std::optional<jsi::Object>& args);
   jsi::Value hasHybridObject(jsi::Runtime& runtime, const jsi::String& hybridObjectName);
   jsi::Value getAllHybridObjectNames(jsi::Runtime& runtime);

package/cpp/utils/TypeInfo.hpp

@@ -71,6 +71,20 @@ public:
     return name;
   }
 
+  /**
+   * Get a friendly name of the type `T` (if possible, demangled), without any namespaces
+   */
+  template <typename T>
+  static inline std::string getFriendlyTypenameNoNamespace() {
+    std::string friendly = getFriendlyTypename<T>();
+    size_t lastColon = friendly.rfind(':');
+    if (lastColon == std::string::npos) {
+      // Type does not have any namespace (:), just return as is.
+      return friendly;
+    }
+    return friendly.substr(lastColon + 1);
+  }
+
   template <typename... Types>
   static inline std::string getFriendlyTypenames() {
     std::ostringstream stream;

package/ios/core/AnyMapHolder.hpp

@@ -0,0 +1,91 @@
+//
+//  AnyMapHolder.hpp
+//  NitroModules
+//
+//  Created by Marc Rousavy on 20.08.24.
+//
+
+#pragma once
+
+#include "AnyMap.hpp"
+
+namespace margelo::nitro {
+
+using TSharedMap = std::shared_ptr<AnyMap>;
+
+inline AnyValue create_AnyValue() {
+  return AnyValue{std::monostate{}};
+}
+inline AnyValue create_AnyValue(bool boolValue) {
+  return AnyValue{boolValue};
+}
+inline AnyValue create_AnyValue(double doubleValue) {
+  return AnyValue{doubleValue};
+}
+inline AnyValue create_AnyValue(int64_t bigintValue) {
+  return AnyValue{bigintValue};
+}
+inline AnyValue create_AnyValue(const std::string& stringValue) {
+  return AnyValue{stringValue};
+}
+inline AnyValue create_AnyValue(const AnyArray& arrayValue) {
+  return AnyValue{arrayValue};
+}
+inline AnyValue create_AnyValue(const AnyObject& objectValue) {
+  return AnyValue{objectValue};
+}
+
+inline bool is_AnyValue_null(const AnyValue& value) {
+  return std::holds_alternative<std::monostate>(value);
+}
+inline bool is_AnyValue_bool(const AnyValue& value) {
+  return std::holds_alternative<bool>(value);
+}
+inline bool is_AnyValue_number(const AnyValue& value) {
+  return std::holds_alternative<double>(value);
+}
+inline bool is_AnyValue_bigint(const AnyValue& value) {
+  return std::holds_alternative<int64_t>(value);
+}
+inline bool is_AnyValue_string(const AnyValue& value) {
+  return std::holds_alternative<std::string>(value);
+}
+inline bool is_AnyValue_AnyArray(const AnyValue& value) {
+  return std::holds_alternative<AnyArray>(value);
+}
+inline bool is_AnyValue_AnyObject(const AnyValue& value) {
+  return std::holds_alternative<AnyObject>(value);
+}
+
+inline std::monostate get_AnyValue_null(const AnyValue& value) {
+  return std::get<std::monostate>(value);
+}
+inline bool get_AnyValue_bool(const AnyValue& value) {
+  return std::get<bool>(value);
+}
+inline double get_AnyValue_number(const AnyValue& value) {
+  return std::get<double>(value);
+}
+inline int64_t get_AnyValue_bigint(const AnyValue& value) {
+  return std::get<int64_t>(value);
+}
+inline std::string get_AnyValue_string(const AnyValue& value) {
+  return std::get<std::string>(value);
+}
+inline AnyArray get_AnyValue_AnyArray(const AnyValue& value) {
+  return std::get<AnyArray>(value);
+}
+inline AnyObject get_AnyValue_AnyObject(const AnyValue& value) {
+  return std::get<AnyObject>(value);
+}
+
+inline std::vector<std::string> getAnyObjectKeys(const AnyObject& object) {
+  std::vector<std::string> keys;
+  keys.reserve(object.size());
+  for (const auto& entry : object) {
+    keys.push_back(entry.first);
+  }
+  return keys;
+}
+
+} // namespace margelo::nitro

package/ios/core/AnyMapHolder.swift

@@ -0,0 +1,316 @@
+//
+//  AnyMapHolder.swift
+//  NitroModules
+//
+//  Created by Marc Rousavy on 20.08.24.
+//
+
+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 {
+  case null
+  case number(Double)
+  case bool(Bool)
+  case bigint(Int64)
+  case string(String)
+  case object(Dictionary<String, AnyValue>)
+
+  static func create(_ value: margelo.nitro.AnyValue) -> AnyValue {
+    if margelo.nitro.is_AnyValue_null(value) {
+      return .null
+    } else if margelo.nitro.is_AnyValue_bool(value) {
+      return .bool(margelo.nitro.get_AnyValue_bool(value))
+    } else if margelo.nitro.is_AnyValue_number(value) {
+      return .number(margelo.nitro.get_AnyValue_number(value))
+    } else if margelo.nitro.is_AnyValue_bigint(value) {
+      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_AnyObject(value) {
+      return .object(margelo.nitro.get_AnyValue_AnyObject(value).toSwift())
+    } else {
+      fatalError("AnyValue has unknown type!")
+    }
+  }
+}
+
+/**
+ * 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 init() {
+    _cppPart = margelo.nitro.AnyMap.make()
+  }
+
+  public init(withPreallocatedSize size: Int) {
+    _cppPart = margelo.nitro.AnyMap.make(size)
+  }
+  
+  public init(withCppPart cppPart: margelo.nitro.TSharedMap) {
+    _cppPart = cppPart
+  }
+
+  // pragma MARK: Common Operations
+
+  /**
+   * Returns whether the given key exists in the map.
+   */
+  public func contains(key: String) -> Bool {
+    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))
+  }
+
+  /**
+   * Removes all keys in this map.
+   */
+  public func clear() {
+    _cppPart.pointee.clear()
+  }
+
+  // pragma MARK: Getters
+
+  /**
+   * Gets the double 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 getDouble(key: String) -> Double {
+    return _cppPart.pointee.getDouble(std.string(key))
+  }
+
+  /**
+   * Gets the double 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))
+  }
+
+  /**
+   * Gets the double 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))
+  }
+
+  /**
+   * Gets the double 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))
+    return String(value)
+  }
+
+  /**
+   * Gets the double 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))
+    return value.toSwift()
+  }
+
+  // pragma MARK: Setters
+
+  /**
+   * Set the given key to `null`.
+   */
+  public func setNull(key: String) {
+    _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)
+  }
+
+  /**
+   * Set the given key to the given boolean value.
+   */
+  public func setBoolean(key: String, value: Bool) {
+    _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)
+  }
+
+  /**
+   * 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))
+  }
+
+  /**
+   * 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))
+  }
+
+  // pragma MARK: Is Getters
+
+  /**
+   * 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))
+  }
+
+  /**
+   * 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))
+  }
+
+  /**
+   * 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))
+  }
+
+  /**
+   * 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))
+  }
+
+  /**
+   * 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))
+  }
+
+  /**
+   * Gets whether the given `key` is holding a object value, or not.
+   */
+  public func isObject(key: String) -> Bool {
+    return _cppPart.pointee.isObject(std.string(key))
+  }
+}
+
+// pragma MARK: margelo.nitro.AnyValue extension
+
+extension margelo.nitro.AnyValue {
+  static func create(_ value: AnyValue) -> margelo.nitro.AnyValue {
+    switch value {
+    case .null:
+      return create()
+    case .bool(let bool):
+      return create(bool)
+    case .number(let number):
+      return create(number)
+    case .bigint(let bigint):
+      return create(bigint)
+    case .string(let string):
+      return create(string)
+    case .object(let object):
+      return create(object)
+    }
+  }
+  static func create() -> margelo.nitro.AnyValue {
+    return margelo.nitro.create_AnyValue()
+  }
+  static func create(_ value: Bool) -> margelo.nitro.AnyValue {
+    return margelo.nitro.create_AnyValue(value)
+  }
+  static func create(_ value: Double) -> margelo.nitro.AnyValue {
+    return margelo.nitro.create_AnyValue(value)
+  }
+  static func create(_ value: Int64) -> margelo.nitro.AnyValue {
+    return margelo.nitro.create_AnyValue(value)
+  }
+  static func create(_ value: String) -> margelo.nitro.AnyValue {
+    return margelo.nitro.create_AnyValue(std.string(value))
+  }
+  static func create(_ value: [AnyValue]) -> margelo.nitro.AnyValue {
+    return margelo.nitro.create_AnyValue(margelo.nitro.AnyArray.create(value))
+  }
+  static func create(_ value: Dictionary<String, AnyValue>) -> margelo.nitro.AnyValue {
+    return margelo.nitro.create_AnyValue(margelo.nitro.AnyObject.create(value))
+  }
+}
+
+// pragma MARK: std.string extension
+
+extension std.string {
+  func toSwift() -> String {
+    return String(self)
+  }
+}
+
+// pragma MARK: margelo.nitro.AnyArray extension
+
+extension margelo.nitro.AnyArray {
+  static func create(_ array: [AnyValue]) -> margelo.nitro.AnyArray {
+    var vector = margelo.nitro.AnyArray()
+    vector.reserve(array.count)
+    for value in array {
+      vector.push_back(margelo.nitro.AnyValue.create(value))
+    }
+    return vector
+  }
+
+  func toSwift() -> [AnyValue] {
+    var array: [AnyValue] = []
+    array.reserveCapacity(self.size())
+    for value in self {
+      array.append(AnyValue.create(value))
+    }
+    return array
+  }
+}
+
+// pragma MARK: margelo.nitro.AnyObject extension
+
+extension margelo.nitro.AnyObject {
+  static func create(_ dictionary: Dictionary<String, AnyValue>) -> margelo.nitro.AnyObject {
+    var object = margelo.nitro.AnyObject()
+    object.reserve(dictionary.count)
+    for (key, value) in dictionary {
+      object[std.string(key)] = margelo.nitro.AnyValue.create(value)
+    }
+    return object
+  }
+
+  func toSwift() -> Dictionary<String, AnyValue> {
+    let keys = margelo.nitro.getAnyObjectKeys(self)
+    var dictionary = Dictionary<String, AnyValue>(minimumCapacity: keys.size())
+    for key in keys {
+
+    }
+    return dictionary
+  }
+}

package/ios/core/ArrayBufferHolder.hpp

@@ -8,8 +8,9 @@
 #pragma once
 
 #include "ArrayBuffer.hpp"
-#include "NitroDefines.hpp"
+#include "SwiftClosure.hpp"
 #include <memory>
+#include <swift/bridging>
 
 namespace margelo::nitro {
 
@@ -32,10 +33,11 @@ public:
    * Create a new `NativeArrayBuffer` that wraps the given data of the given size, without copying it.
    *
    * Once the `ArrayBuffer` is no longer in use, the given `deleteFunc` will be called with the given `deleteFuncContext`
-   * as an argument. The caller is responsible for deleting `data` (and `deleteFuncContext`) once this is called.
+   * as an argument. The caller is responsible for deleting `data` once this is called.
    */
-  static ArrayBufferHolder makeBuffer(uint8_t* data, size_t size, DeleteFn deleteFunc, void* deleteFuncContext) {
-    auto arrayBuffer = ArrayBuffer::makeBuffer(data, size, deleteFunc, deleteFuncContext);
+  static ArrayBufferHolder makeBuffer(uint8_t* data, size_t size, SwiftClosure destroy) {
+    std::function<void()> deleteFunc = destroy.getFunction();
+    auto arrayBuffer = ArrayBuffer::makeBuffer(data, size, std::move(deleteFunc));
     return ArrayBufferHolder(arrayBuffer);
   }
 
@@ -53,7 +55,16 @@ public:
     return _arrayBuffer->size();
   }
 
-  bool isOwner() const SWIFT_COMPUTED_PROPERTY {
+  /**
+   * Whether the underlying `ArrayBuffer` actually owns the data it points to, or not.
+   *
+   * - If an `ArrayBuffer` owns the data, it is likely an ArrayBuffer created on the native side (C++/Swift).
+   *   This means the `ArrayBuffer` is safe to access as long as you have a reference to it, and cannot be deleted otherwise.
+   * - If an `ArrayBuffer` doesn't own the data, it is likely an ArrayBuffer coming from JS.
+   *   This means the `ArrayBuffer` is **NOT** safe to access outside of the synchronous function's scope.
+   *   If you plan on hopping do a different Thread, or storing a long-lived reference to it, make sure to **copy** the data.
+   */
+  bool getIsOwner() const SWIFT_COMPUTED_PROPERTY {
     return _arrayBuffer->isOwner();
   }
 

package/ios/core/{ArrayBuffer.swift → ArrayBufferHolder.swift}

@@ -1,5 +1,5 @@
 //
-//  ArrayBuffer.swift
+//  ArrayBufferHolder.swift
 //  NitroModules
 //
 //  Created by Marc Rousavy on 17.07.24.
@@ -7,6 +7,12 @@
 
 import Foundation
 
+/**
+ * Holds instances of `std::shared_ptr<ArrayBuffer>`, which can be passed
+ * between native and JS **without copy**.
+ *
+ * See `data`, `size` and `isOwning`.
+ */
 public typealias ArrayBufferHolder = margelo.nitro.ArrayBufferHolder
 
 public extension ArrayBufferHolder {
@@ -16,22 +22,13 @@ public extension ArrayBufferHolder {
    * When the `ArrayBuffer` is no longer used, `onDelete` will be called, in which
    * you as a caller are responsible for deleting `data`.
    */
-  static func wrap(wrappingDataWithoutCopy data: UnsafeMutablePointer<UInt8>,
+  static func wrap(dataWithoutCopy data: UnsafeMutablePointer<UInt8>,
                    size: Int,
                    onDelete delete: @escaping () -> Void) -> ArrayBufferHolder {
     // Convert escaping Swift closure to a `void*`
-    let wrapper = ClosureWrapper(closure: delete)
-    let wrappedClosure = Unmanaged.passRetained(wrapper).toOpaque()
-    
-    return ArrayBufferHolder.makeBuffer(data, size, { context in
-      guard let context else {
-        fatalError("Context was null, even though we created one!")
-      }
-      // Convert `void*` to a Swift closure
-      let closure = Unmanaged<ClosureWrapper>.fromOpaque(context).takeRetainedValue()
-      // Call it (deleteFunc)
-      closure.invoke()
-    }, wrappedClosure)
+    let swiftClosure = SwiftClosure(wrappingClosure: delete)
+    // Create ArrayBufferHolder with our wrapped Swift closure to make it callable as a C-function pointer
+    return ArrayBufferHolder.makeBuffer(data, size, swiftClosure)
   }
   
   /**
@@ -44,8 +41,9 @@ public extension ArrayBufferHolder {
       data.initialize(repeating: 0, count: size)
     }
     
-    return ArrayBufferHolder.makeBuffer(data, size, { data in
-      data?.deallocate()
-    }, data)
+    let deleteFunc = SwiftClosure {
+      data.deallocate()
+    }
+    return ArrayBufferHolder.makeBuffer(data, size, deleteFunc)
   }
 }

package/ios/core/HybridContext.hpp

@@ -32,15 +32,15 @@ public:
   template <typename THybridObject, typename TSwiftPart>
   static inline std::shared_ptr<THybridObject> getOrCreate(TSwiftPart swiftPart) noexcept {
     auto hybridContext = swiftPart.getHybridContext();
-    auto hybridObject = std::static_pointer_cast<THybridObject>(hybridContext.cppPart.lock());
+    auto hybridObject = std::dynamic_pointer_cast<THybridObject>(hybridContext.cppPart.lock());
     if (hybridObject != nullptr) [[likely]] {
       // Fast path - an existing HybridObject is still in cache! (HybridContext)
       return hybridObject;
     }
 
     // Slow path - we need to create a new HybridObject that wraps our Swift implementation.
-    Logger::log(TAG, "Creating new HybridObject<%s> for %s...", TypeInfo::getFriendlyTypename<THybridObject>(),
-                TypeInfo::getFriendlyTypename<TSwiftPart>());
+    Logger::log(LogLevel::Info, TAG, "Creating new HybridObject<%s> for %s...", TypeInfo::getFriendlyTypename<THybridObject>().c_str(),
+                TypeInfo::getFriendlyTypename<TSwiftPart>().c_str());
     hybridObject = std::make_shared<THybridObject>(std::forward<decltype(swiftPart)>(swiftPart));
     hybridContext.cppPart = hybridObject;
     swiftPart.setHybridContext(hybridContext);