react-native-nitro-modules 0.21.0 → 0.22.0

package/NitroModules.podspec

@@ -43,6 +43,7 @@ Pod::Spec.new do |s|
     "cpp/threading/Dispatcher.hpp",
     "cpp/utils/NitroHash.hpp",
     "cpp/utils/NitroDefines.hpp",
+    "cpp/views/CachedProp.hpp",
     # Public iOS-specific headers that will be exposed in modulemap (for Swift)
     "ios/core/ArrayBufferHolder.hpp",
     "ios/core/AnyMapHolder.hpp",
@@ -60,11 +61,13 @@ Pod::Spec.new do |s|
     "SWIFT_OBJC_INTEROP_MODE" => "objcxx",
     # Enables stricter modular headers
     "DEFINES_MODULE" => "YES",
-    # C++ compiler flags, mainly for folly.
+    # C++ compiler flags, mainly for RN version and folly.
     "GCC_PREPROCESSOR_DEFINITIONS" => "$(inherited) FOLLY_NO_CONFIG FOLLY_CFG_NO_COROUTINES"
   }
 
+  # Nitro depends on JSI.
   s.dependency 'React-jsi'
+  # For React Native, we implement nitro::Dispatcher using react::CallInvoker
   s.dependency 'React-callinvoker'
   install_modules_dependencies(s)
 end

package/README.md

@@ -208,7 +208,7 @@ The following C++ / JS types are supported out of the box:
   <tr>
     <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="./ios/core/HybridObject.swift">HybridObject</a></code></td>
     <td><code><a href="./android/src/main/java/com/margelo/nitro/core/HybridObject.kt">HybridObject</a></code></td>
   </tr>
   <tr>

package/android/CMakeLists.txt

@@ -32,6 +32,7 @@ include_directories(
   ../cpp/threading
   ../cpp/turbomodule
   ../cpp/utils
+  ../cpp/views
   # Android-specific C++ includes
   src/main/cpp/core
   src/main/cpp/registry

package/android/build.gradle

@@ -1,3 +1,5 @@
+import groovy.json.JsonSlurper
+
 buildscript {
   repositories {
     google()
@@ -5,7 +7,7 @@ buildscript {
   }
 
   dependencies {
-    classpath "com.android.tools.build:gradle:8.7.3"
+    classpath "com.android.tools.build:gradle:8.8.0"
   }
 }
 
@@ -154,7 +156,7 @@ if (isNewArchitectureEnabled()) {
   }
 }
 
-task prepareHeaders(type: Copy) {
+tasks.register('prepareHeaders', Copy) {
   from fileTree('./src/main/cpp').filter { it.isFile() }
   from fileTree('../cpp/').filter { it.isFile() }
   include "*.hpp"

package/android/gradle.properties

@@ -1,5 +1,5 @@
-Nitro_kotlinVersion=1.9.24
+Nitro_kotlinVersion=2.0.21
 Nitro_minSdkVersion=23
 Nitro_targetSdkVersion=34
 Nitro_compileSdkVersion=34
-Nitro_ndkVersion=26.1.10909125
+Nitro_ndkVersion=27.1.12297006

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

@@ -17,12 +17,12 @@ 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
+  pthread_t thisThread = pthread_self();
+  char threadName[16]; // Thread name length limit in Android is 16 characters
 
-  int result = pthread_getname_np(this_thread, thread_name, sizeof(thread_name));
+  int result = pthread_getname_np(thisThread, threadName, sizeof(threadName));
   if (result == 0) {
-    return std::string(thread_name);
+    return std::string(threadName);
   }
 #endif
 

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

@@ -20,6 +20,8 @@ public:
   static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/core/HybridObjectRegistry;";
 
 public:
+  [[deprecated("HybridObjects should be registered from C++ instead. Either autolink them using `nitro.json`, "
+               "or add them manually in the C++ HybridObjectRegistry.")]]
   static void registerHybridObjectConstructor(jni::alias_ref<jni::JClass> clazz, std::string hybridObjectName,
                                               jni::alias_ref<JHybridObjectInitializer> constructorFn);
 

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

@@ -4,16 +4,12 @@ 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: ExtendableHybridClass {
+abstract class HybridObject {
     /**
      * Get the memory size of the Kotlin instance (plus any external heap allocations),
      * in bytes.
@@ -32,7 +28,8 @@ abstract class HybridObject: ExtendableHybridClass {
      */
     @get:DoNotStrip
     @get:Keep
-    abstract val memorySize: Long
+    open val memorySize: Long
+        get() = 0L
 
     /**
      * Holds the native C++ instance.
@@ -42,10 +39,14 @@ abstract class HybridObject: ExtendableHybridClass {
     private var mHybridData: HybridData? = null
 
     /**
-     * Must be called in the constructor of a subclass of `HybridObject`, to initialize the C++
-     * `JHybridObject` with a subclass of it.
+     * If `HybridObject` is subclassed, the sub-class needs to create it's own `HybridData`
+     * with a C++ `jni::HybridClass` representing the subclass directly.
+     * Then, that `HybridData` must be passed upwards to `HybridObject` using `updateNative(..)`.
+     *
+     * This must happen for each sub/base class in the whole inheritance chain to ensure
+     * overrides and type-erasure works as expected.
      */
-    override fun updateNative(hybridData: HybridData) {
+    protected open fun updateNative(hybridData: HybridData) {
         mHybridData = hybridData
     }
 }

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

@@ -4,8 +4,12 @@ import androidx.annotation.Keep;
 
 import com.facebook.proguard.annotations.DoNotStrip;
 
+/**
+ * @deprecated HybridObjects should be registered from C++ instead. Either autolink them using `nitro.json`, or add them manually in the C++ `HybridObjectRegistry`.
+ */
 @Keep
 @DoNotStrip
+@Deprecated(forRemoval = true)
 public interface HybridObjectInitializer {
     @Keep
     @DoNotStrip

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

@@ -20,6 +20,8 @@ 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.createHybridObject<T>(name)` - which will call the `constructorFn` here.
+     * @deprecated HybridObjects should be registered from C++ instead. Either autolink them using `nitro.json`, or add them manually in the C++ `HybridObjectRegistry`.
      */
+    @Deprecated(forRemoval = true)
     public static native void registerHybridObjectConstructor(String hybridObjectName, HybridObjectInitializer initializer);
 }

package/android/src/main/java/com/margelo/nitro/views/HybridView.kt

@@ -0,0 +1,23 @@
+package com.margelo.nitro.views
+
+import android.view.View
+import androidx.annotation.Keep
+import com.facebook.jni.HybridData
+import com.facebook.proguard.annotations.DoNotStrip
+import com.margelo.nitro.core.HybridObject
+
+/**
+ * A base class for all Kotlin-based Hybrid Views.
+ */
+@Keep
+@DoNotStrip
+abstract class HybridView: HybridObject() {
+    /**
+     * Get the `UIView` this HybridView is holding.
+     *
+     * This value should not change during the lifetime of this `HybridView`.
+     */
+    @get:DoNotStrip
+    @get:Keep
+    abstract val view: View
+}

package/cpp/core/HybridFunction.hpp

@@ -15,7 +15,7 @@ struct JSIConverter;
 #include "CountTrailingOptionals.hpp"
 #include "JSIConverter.hpp"
 #include "NitroDefines.hpp"
-#include "TypeInfo.hpp"
+#include "NitroTypeInfo.hpp"
 #include <exception>
 #include <functional>
 #include <jsi/jsi.h>

package/cpp/core/HybridObject.cpp

@@ -9,7 +9,6 @@
 namespace margelo::nitro {
 
 HybridObject::HybridObject(const char* name) : HybridObjectPrototype(), _name(name) {}
-HybridObject::~HybridObject() {}
 
 std::string HybridObject::toString() {
   return "[HybridObject " + std::string(_name) + "]";
@@ -19,7 +18,7 @@ std::string HybridObject::getName() {
   return _name;
 }
 
-bool HybridObject::equals(std::shared_ptr<HybridObject> other) {
+bool HybridObject::equals(const std::shared_ptr<HybridObject>& other) {
   return this == other.get();
 }
 
@@ -48,10 +47,12 @@ jsi::Value HybridObject::toObject(jsi::Runtime& runtime) {
   if (cachedObject != _objectCache.end()) {
     // 1.1. We have a WeakObject, try to see if it is still alive
     OwningLock<jsi::WeakObject> lock = cachedObject->second.lock();
-    jsi::Value object = cachedObject->second->lock(runtime);
-    if (!object.isUndefined()) {
-      // 1.2. It is still alive - we can use it instead of creating a new one!
-      return object;
+    jsi::Value value = cachedObject->second->lock(runtime);
+    if (!value.isUndefined()) {
+      // 1.2. It is still alive - we can use it instead of creating a new one! But first, let's update memory-size
+      value.getObject(runtime).setExternalMemoryPressure(runtime, getExternalMemorySize());
+      // 1.3. Return it now
+      return value;
     }
   }
 

package/cpp/core/HybridObject.hpp

@@ -34,7 +34,7 @@ public:
    * Called when no more references to the given `HybridObject` exist in both C++ and JS.
    * JS might keep references for longer, as it is a garbage collected language.
    */
-  virtual ~HybridObject();
+  ~HybridObject() override = default;
   /**
    * HybridObjects cannot be copied.
    */
@@ -80,7 +80,7 @@ public:
    * While two `jsi::Object`s of the same `HybridObject` might not be equal when compared with `==`,
    * they might still be the same `HybridObject` - in this case `equals(other)` will return true.
    */
-  bool equals(std::shared_ptr<HybridObject> other);
+  bool equals(const std::shared_ptr<HybridObject>& other);
   /**
    * Get a string representation of this `HybridObject` - useful for logging or debugging.
    */

package/cpp/core/Promise.hpp

@@ -6,8 +6,8 @@
 
 #include "AssertPromiseState.hpp"
 #include "NitroDefines.hpp"
+#include "NitroTypeInfo.hpp"
 #include "ThreadPool.hpp"
-#include "TypeInfo.hpp"
 #include <exception>
 #include <future>
 #include <jsi/jsi.h>

package/cpp/entrypoint/HybridNitroModulesProxy.cpp

@@ -7,6 +7,7 @@
 
 #include "HybridNitroModulesProxy.hpp"
 #include "HybridObjectRegistry.hpp"
+#include "JSIConverter.hpp"
 #include "NitroDefines.hpp"
 
 namespace margelo::nitro {
@@ -20,6 +21,7 @@ void HybridNitroModulesProxy::loadHybridMethods() {
     prototype.registerHybridMethod("getAllHybridObjectNames", &HybridNitroModulesProxy::getAllHybridObjectNames);
 
     prototype.registerHybridMethod("box", &HybridNitroModulesProxy::box);
+    prototype.registerHybridMethod("updateMemorySize", &HybridNitroModulesProxy::updateMemorySize);
 
     prototype.registerRawHybridMethod("hasNativeState", 1, &HybridNitroModulesProxy::hasNativeState);
 
@@ -53,6 +55,12 @@ jsi::Value HybridNitroModulesProxy::hasNativeState(jsi::Runtime& runtime, const
   return args[0].getObject(runtime).hasNativeState(runtime);
 }
 
+std::shared_ptr<HybridObject> HybridNitroModulesProxy::updateMemorySize(const std::shared_ptr<HybridObject>& hybridObject) {
+  // If a hybridObject goes from Native -> JS, it will update it's memory size internally (in `HybridObject::toObject(..)`).
+  // This is all that function does.
+  return hybridObject;
+}
+
 // Build Info
 std::string HybridNitroModulesProxy::getBuildType() {
 #ifdef NITRO_DEBUG

package/cpp/entrypoint/HybridNitroModulesProxy.hpp

@@ -37,6 +37,7 @@ public:
 
   // Helpers
   std::shared_ptr<BoxedHybridObject> box(const std::shared_ptr<HybridObject>& hybridObject);
+  std::shared_ptr<HybridObject> updateMemorySize(const std::shared_ptr<HybridObject>& hybridObject);
   jsi::Value hasNativeState(jsi::Runtime& runtime, const jsi::Value& thisValue, const jsi::Value* args, size_t size);
 
   // Build Info

package/cpp/jsi/JSICache.cpp

@@ -28,6 +28,7 @@ JSICache::~JSICache() {
   Logger::log(LogLevel::Info, TAG, "Destroying JSICache...");
   std::unique_lock lock(_mutex);
 
+  destroyReferences(_valueCache);
   destroyReferences(_objectCache);
   destroyReferences(_functionCache);
   destroyReferences(_weakObjectCache);

package/cpp/jsi/JSICache.hpp

@@ -59,6 +59,7 @@ private:
 
 private:
   std::mutex _mutex;
+  std::vector<BorrowingReference<jsi::Value>> _valueCache;
   std::vector<BorrowingReference<jsi::Object>> _objectCache;
   std::vector<BorrowingReference<jsi::Function>> _functionCache;
   std::vector<BorrowingReference<jsi::WeakObject>> _weakObjectCache;
@@ -82,6 +83,11 @@ public:
   }
 
 public:
+  OwningReference<jsi::Value> makeShared(jsi::Value&& value) {
+    OwningReference<jsi::Value> owning(new jsi::Value(std::move(value)));
+    _strongCache->_valueCache.push_back(owning.weak());
+    return owning;
+  }
   OwningReference<jsi::Object> makeShared(jsi::Object&& value) {
     OwningReference<jsi::Object> owning(new jsi::Object(std::move(value)));
     _strongCache->_objectCache.push_back(owning.weak());

package/cpp/jsi/JSIConverter+Exception.hpp

@@ -12,7 +12,7 @@ struct JSIConverter;
 
 #include "JSIConverter.hpp"
 
-#include "TypeInfo.hpp"
+#include "NitroTypeInfo.hpp"
 #include <exception>
 #include <jsi/jsi.h>
 

package/cpp/jsi/JSIConverter+HostObject.hpp

@@ -6,7 +6,7 @@
 
 #include "IsSharedPtrTo.hpp"
 #include "NitroDefines.hpp"
-#include "TypeInfo.hpp"
+#include "NitroTypeInfo.hpp"
 #include <jsi/jsi.h>
 #include <type_traits>
 

package/cpp/jsi/JSIConverter+HybridObject.hpp

@@ -11,7 +11,7 @@ class HybridObject;
 
 #include "IsSharedPtrTo.hpp"
 #include "NitroDefines.hpp"
-#include "TypeInfo.hpp"
+#include "NitroTypeInfo.hpp"
 #include <jsi/jsi.h>
 #include <type_traits>
 

package/cpp/jsi/JSIConverter+Tuple.hpp

@@ -12,7 +12,7 @@ struct JSIConverter;
 
 #include "JSIConverter.hpp"
 
-#include "TypeInfo.hpp"
+#include "NitroTypeInfo.hpp"
 #include <jsi/jsi.h>
 #include <memory>
 #include <tuple>

package/cpp/jsi/JSIConverter+Variant.hpp

@@ -18,7 +18,7 @@ struct JSIConverter;
 #include "JSIConverter.hpp"
 
 #include "AnyMap.hpp"
-#include "TypeInfo.hpp"
+#include "NitroTypeInfo.hpp"
 #include <jsi/jsi.h>
 #include <memory>
 #include <variant>

package/cpp/jsi/JSIHelpers.hpp

@@ -46,7 +46,7 @@ static inline bool isPlainObject(jsi::Runtime& runtime, const jsi::Object& objec
  */
 static inline std::string getRuntimeId(jsi::Runtime& runtime) {
   std::string threadName = ThreadUtils::getThreadName();
-  return runtime.description() + std::string(" (") + threadName + std::string(")");
+  return runtime.description() + " (" + threadName + ")";
 }
 
 } // namespace margelo::nitro

package/cpp/prototype/HybridObjectPrototype.cpp

@@ -8,7 +8,7 @@
 #include "HybridObjectPrototype.hpp"
 #include "NitroDefines.hpp"
 #include "NitroLogger.hpp"
-#include "TypeInfo.hpp"
+#include "NitroTypeInfo.hpp"
 
 namespace margelo::nitro {
 

package/cpp/registry/HybridObjectRegistry.cpp

@@ -8,6 +8,7 @@
 #include "HybridObjectRegistry.hpp"
 #include "NitroDefines.hpp"
 #include "NitroLogger.hpp"
+#include <numeric>
 
 namespace margelo::nitro {
 
@@ -29,17 +30,25 @@ std::vector<std::string> HybridObjectRegistry::getAllHybridObjectNames() {
   return keys;
 }
 
+std::string HybridObjectRegistry::getAllRegisteredHybridObjectNamesToString() {
+  std::vector<std::string> names = getAllHybridObjectNames();
+  return std::accumulate(std::next(names.begin()), names.end(), names[0], [](std::string a, std::string b) { return a + ", " + b; });
+}
+
 void HybridObjectRegistry::registerHybridObjectConstructor(const std::string& hybridObjectName, HybridObjectConstructorFn&& constructorFn) {
   Logger::log(LogLevel::Info, TAG, "Registering HybridObject \"%s\"...", hybridObjectName.c_str());
   auto& map = HybridObjectRegistry::getRegistry();
 #ifdef NITRO_DEBUG
   if (map.contains(hybridObjectName)) [[unlikely]] {
+    auto allObjectNames = getAllRegisteredHybridObjectNamesToString();
     auto message =
-        "HybridObject \"" + std::string(hybridObjectName) +
+        "HybridObject \"" + hybridObjectName +
         "\" has already been "
         "registered in the Nitro Modules HybridObjectRegistry! Suggestions:\n"
         "- If you just installed another library, maybe both libraries are using the same name?\n"
-        "- If you just registered your own HybridObject, maybe you accidentally called `registerHybridObjectConstructor(...)` twice?";
+        "- If you just registered your own HybridObject, maybe you accidentally called `registerHybridObjectConstructor(...)` twice?\n"
+        "- All registered HybridObjects: [" +
+        allObjectNames + "]";
     throw std::runtime_error(message);
   }
 #endif
@@ -57,16 +66,20 @@ std::shared_ptr<HybridObject> HybridObjectRegistry::createHybridObject(const std
   auto& map = HybridObjectRegistry::getRegistry();
   auto fn = map.find(hybridObjectName);
   if (fn == map.end()) [[unlikely]] {
-    auto message = "Cannot create an instance of HybridObject \"" + std::string(hybridObjectName) +
-                   "\" - It has not yet been registered in the Nitro Modules HybridObjectRegistry! Suggestions:\n"
-                   "- If you use Nitrogen, make sure your `nitro.json` contains `" +
-                   std::string(hybridObjectName) +
-                   "` on this platform.\n"
-                   "- If you use Nitrogen, make sure your library (*Package.java)/app (MainApplication.java) calls "
-                   "`System.loadLibrary(\"$$androidCxxLibName$$\")` somewhere on app-startup.\n"
-                   "- If you use Nitrogen, make sure your cpp-adapter.cpp calls `margelo::nitro::$$cxxNamespace$$::initialize(vm)`.\n"
-                   "- If you use Nitrogen, inspect the generated `$$androidCxxLibName$$OnLoad.cpp` file.\n"
-                   "- If you don't use Nitrogen, make sure you called `HybridObjectRegistry.registerHybridObject(...)`.";
+    auto allObjectNames = getAllRegisteredHybridObjectNamesToString();
+    auto message =
+        "Cannot create an instance of HybridObject \"" + hybridObjectName +
+        "\" - It has not yet been registered in the Nitro Modules HybridObjectRegistry! Suggestions:\n"
+        "- If you use Nitrogen, make sure your `nitro.json` contains `" +
+        hybridObjectName +
+        "` on this platform.\n"
+        "- If you use Nitrogen, make sure your library (*Package.java)/app (MainApplication.java) calls "
+        "`$$androidCxxLibName$$OnLoad.initializeNative()` somewhere on app-startup.\n"
+        "- If you use Nitrogen, make sure your `cpp-adapter.cpp`/`OnLoad.cpp` calls `margelo::nitro::$$cxxNamespace$$::initialize(vm)`.\n"
+        "- If you use Nitrogen, inspect the generated `$$androidCxxLibName$$OnLoad.cpp` file.\n"
+        "- If you don't use Nitrogen, make sure you called `HybridObjectRegistry.registerHybridObject(...)`."
+        "- All registered HybridObjects: [" +
+        allObjectNames + "]";
     throw std::runtime_error(message);
   }
   std::shared_ptr<HybridObject> instance = fn->second();

package/cpp/registry/HybridObjectRegistry.hpp

@@ -44,6 +44,7 @@ public:
 
 private:
   static std::unordered_map<std::string, HybridObjectConstructorFn>& getRegistry();
+  static std::string getAllRegisteredHybridObjectNamesToString();
 
 private:
   static constexpr auto TAG = "HybridObjectRegistry";

package/cpp/utils/AssertPromiseState.hpp

@@ -12,8 +12,8 @@ template <typename TResult>
 class Promise;
 } // namespace margelo::nitro
 
+#include "NitroTypeInfo.hpp"
 #include "Promise.hpp"
-#include "TypeInfo.hpp"
 #include <exception>
 #include <string>
 

package/cpp/utils/BorrowingReference.hpp

@@ -32,8 +32,10 @@ public:
   BorrowingReference(const BorrowingReference& ref)
       : _value(ref._value), _isDeleted(ref._isDeleted), _strongRefCount(ref._strongRefCount), _weakRefCount(ref._weakRefCount),
         _mutex(ref._mutex) {
-    // increment ref count after copy
-    (*_weakRefCount)++;
+    if (_weakRefCount != nullptr) {
+      // increment ref count after copy
+      (*_weakRefCount)++;
+    }
   }
 
   BorrowingReference(BorrowingReference&& ref)

package/cpp/utils/NitroDefines.hpp

@@ -9,7 +9,7 @@
 #define NitroDefines_h
 
 // Sets the version of the native Nitro core library
-#define NITRO_VERSION "0.21.0"
+#define NITRO_VERSION "0.22.0"
 
 // Sets whether to use debug or optimized production build flags
 #ifdef DEBUG
@@ -31,6 +31,7 @@
 #define _CXX_INTEROP_HAS_ATTRIBUTE(x) 0
 #endif
 
+// Closed/Final Enums
 #if _CXX_INTEROP_HAS_ATTRIBUTE(enum_extensibility)
 // Enum is marked as closed/not extensible
 #define CLOSED_ENUM __attribute__((enum_extensibility(closed)))
@@ -38,6 +39,7 @@
 #define CLOSED_ENUM
 #endif
 
+// Swift Support
 #if __has_include(<swift/bridging>)
 // Swift's bridging header defines those things
 #include <swift/bridging>
@@ -50,4 +52,14 @@
 #define SWIFT_NONCOPYABLE
 #endif
 
+// React Native Support
+#if __has_include(<cxxreact/ReactNativeVersion.h>)
+#include <cxxreact/ReactNativeVersion.h>
+#endif
+#ifndef REACT_NATIVE_VERSION_MINOR
+#define REACT_NATIVE_VERSION_MAJOR 0
+#define REACT_NATIVE_VERSION_MINOR 0
+#define REACT_NATIVE_VERSION_PATCH 0
+#endif
+
 #endif /* NitroDefines_h */

package/cpp/utils/NitroHash.hpp

@@ -9,6 +9,7 @@
 
 #include <cstddef>
 #include <cstdint>
+#include <string>
 
 namespace margelo::nitro {
 
@@ -40,4 +41,20 @@ constexpr uint64_t hashString(const char (&str)[N]) {
   return hashString(str, N - 1); // N includes the null terminator, so subtract 1
 }
 
+/**
+ * Hashes the given `string_view` using the FNV-1a hashing algorithm.
+ * This can be constexpr.
+ */
+constexpr uint64_t hashString(const std::string_view& string) {
+  return hashString(string.data(), string.length());
+}
+
+/**
+ * Hashes the given `string` using the FNV-1a hashing algorithm.
+ * This happens at runtime.
+ */
+inline uint64_t hashString(const std::string& string) {
+  return hashString(string.c_str(), string.length());
+}
+
 } // namespace margelo::nitro

package/cpp/utils/{TypeInfo.hpp → NitroTypeInfo.hpp}

@@ -1,5 +1,5 @@
 //
-//  TypeInfo.hpp
+//  NitroTypeInfo.hpp
 //  Nitro
 //
 //  Created by Marc Rousavy on 17.07.24.

package/cpp/utils/OwningReference.hpp

@@ -8,6 +8,7 @@
 #pragma once
 
 #include "BorrowingReference.hpp"
+#include "NitroDefines.hpp"
 #include "OwningLock.hpp"
 #include <atomic>
 #include <cstddef>
@@ -39,8 +40,10 @@ public:
   OwningReference(const OwningReference& ref)
       : _value(ref._value), _isDeleted(ref._isDeleted), _strongRefCount(ref._strongRefCount), _weakRefCount(ref._weakRefCount),
         _mutex(ref._mutex) {
-    // increment ref count after copy
-    (*_strongRefCount)++;
+    if (_strongRefCount != nullptr) {
+      // increment ref count after copy
+      (*_strongRefCount)++;
+    }
   }
 
   OwningReference(OwningReference&& ref)
@@ -161,10 +164,20 @@ public:
   }
 
   inline T& operator*() const {
+#ifdef NITRO_DEBUG
+    if (!hasValue()) [[unlikely]] {
+      throw std::runtime_error("Tried to dereference (*) nullptr OwningReference<T>!");
+    }
+#endif
     return *_value;
   }
 
   inline T* operator->() const {
+#ifdef NITRO_DEBUG
+    if (!hasValue()) [[unlikely]] {
+      throw std::runtime_error("Tried to dereference (->) nullptr OwningReference<T>!");
+    }
+#endif
     return _value;
   }