react-native-nitro-modules 0.31.10 → 0.32.0

package/cpp/utils/CommonGlobals.cpp

@@ -0,0 +1,215 @@
+//
+//  CommonGlobals.cpp
+//  react-native-nitro
+//
+//  Created by Marc Rousavy on 17.10.25.
+//
+
+#include "CommonGlobals.hpp"
+#include "JSICache.hpp"
+#include "JSIHelpers.hpp"
+#include "NitroDefines.hpp"
+#include "PropNameIDCache.hpp"
+
+#if __has_include(<cxxreact/ReactNativeVersion.h>)
+#include <cxxreact/ReactNativeVersion.h>
+#if REACT_NATIVE_VERSION_MINOR >= 78
+#define ENABLE_NATIVE_OBJECT_CREATE
+#endif
+#endif
+
+namespace margelo::nitro {
+
+using namespace facebook;
+
+std::unordered_map<jsi::Runtime*, CommonGlobals::FunctionCache> CommonGlobals::_cache;
+
+// pragma MARK: Object
+
+jsi::Object CommonGlobals::Object::create(jsi::Runtime& runtime, const jsi::Value& prototype) {
+#ifdef ENABLE_NATIVE_OBJECT_CREATE
+  return jsi::Object::create(runtime, prototype);
+#else
+  const jsi::Function& createFn = getGlobalFunction(runtime, "Object.create", [](jsi::Runtime& runtime) {
+    return runtime.global().getPropertyAsObject(runtime, "Object").getPropertyAsFunction(runtime, "create");
+  });
+  return createFn.call(runtime, prototype).getObject(runtime);
+#endif
+}
+
+void CommonGlobals::Object::defineProperty(jsi::Runtime& runtime, const jsi::Object& object, const char* propertyName,
+                                           PlainPropertyDescriptor&& descriptor) {
+  const jsi::Function& definePropertyFn = getGlobalFunction(runtime, "Object.defineProperty", [](jsi::Runtime& runtime) {
+    return runtime.global().getPropertyAsObject(runtime, "Object").getPropertyAsFunction(runtime, "defineProperty");
+  });
+
+  jsi::String nameJs = jsi::String::createFromAscii(runtime, propertyName);
+
+  jsi::Object descriptorJs(runtime);
+  descriptorJs.setProperty(runtime, PropNameIDCache::get(runtime, "configurable"), jsi::Value(descriptor.configurable));
+  descriptorJs.setProperty(runtime, PropNameIDCache::get(runtime, "enumerable"), jsi::Value(descriptor.enumerable));
+  descriptorJs.setProperty(runtime, PropNameIDCache::get(runtime, "value"), std::move(descriptor.value));
+  descriptorJs.setProperty(runtime, PropNameIDCache::get(runtime, "writable"), jsi::Value(descriptor.writable));
+
+  definePropertyFn.call(runtime, object, std::move(nameJs), std::move(descriptorJs));
+}
+
+void CommonGlobals::Object::defineProperty(jsi::Runtime& runtime, const jsi::Object& object, const char* propertyName,
+                                           ComputedReadonlyPropertyDescriptor&& descriptor) {
+  const jsi::Function& definePropertyFn = getGlobalFunction(runtime, "Object.defineProperty", [](jsi::Runtime& runtime) {
+    return runtime.global().getPropertyAsObject(runtime, "Object").getPropertyAsFunction(runtime, "defineProperty");
+  });
+
+  jsi::String nameJs = jsi::String::createFromAscii(runtime, propertyName);
+
+  jsi::Object descriptorJs(runtime);
+  descriptorJs.setProperty(runtime, PropNameIDCache::get(runtime, "configurable"), jsi::Value(descriptor.configurable));
+  descriptorJs.setProperty(runtime, PropNameIDCache::get(runtime, "enumerable"), jsi::Value(descriptor.enumerable));
+  descriptorJs.setProperty(runtime, PropNameIDCache::get(runtime, "get"), std::move(descriptor.get));
+
+  definePropertyFn.call(runtime, object, std::move(nameJs), std::move(descriptorJs));
+}
+
+void CommonGlobals::Object::defineProperty(jsi::Runtime& runtime, const jsi::Object& object, const char* propertyName,
+                                           ComputedPropertyDescriptor&& descriptor) {
+  const jsi::Function& definePropertyFn = getGlobalFunction(runtime, "Object.defineProperty", [](jsi::Runtime& runtime) {
+    return runtime.global().getPropertyAsObject(runtime, "Object").getPropertyAsFunction(runtime, "defineProperty");
+  });
+
+  jsi::String nameJs = jsi::String::createFromAscii(runtime, propertyName);
+
+  jsi::Object descriptorJs(runtime);
+  descriptorJs.setProperty(runtime, PropNameIDCache::get(runtime, "configurable"), jsi::Value(descriptor.configurable));
+  descriptorJs.setProperty(runtime, PropNameIDCache::get(runtime, "enumerable"), jsi::Value(descriptor.enumerable));
+  descriptorJs.setProperty(runtime, PropNameIDCache::get(runtime, "get"), std::move(descriptor.get));
+  descriptorJs.setProperty(runtime, PropNameIDCache::get(runtime, "set"), std::move(descriptor.set));
+
+  definePropertyFn.call(runtime, object, std::move(nameJs), std::move(descriptorJs));
+}
+
+void CommonGlobals::Object::freeze(jsi::Runtime& runtime, const jsi::Object& object) {
+  const jsi::Function& freezeFn = getGlobalFunction(runtime, "Object.freeze", [](jsi::Runtime& runtime) {
+    return runtime.global().getPropertyAsObject(runtime, "Object").getPropertyAsFunction(runtime, "freeze");
+  });
+
+  freezeFn.call(runtime, object);
+}
+
+// pragma MARK: Promise
+
+jsi::Value CommonGlobals::Promise::resolved(jsi::Runtime& runtime) {
+  const jsi::Function& resolvedFunc = getGlobalFunction(runtime, "Promise.resolve", [](jsi::Runtime& runtime) {
+    return runtime.global().getPropertyAsObject(runtime, "Promise").getPropertyAsFunction(runtime, "resolve");
+  });
+  return resolvedFunc.call(runtime);
+}
+jsi::Value CommonGlobals::Promise::resolved(jsi::Runtime& runtime, jsi::Value&& value) {
+  const jsi::Function& resolvedFunc = getGlobalFunction(runtime, "Promise.resolve", [](jsi::Runtime& runtime) {
+    return runtime.global().getPropertyAsObject(runtime, "Promise").getPropertyAsFunction(runtime, "resolve");
+  });
+  return resolvedFunc.call(runtime, {std::move(value)});
+}
+jsi::Value CommonGlobals::Promise::rejected(jsi::Runtime& runtime, jsi::Value&& error) {
+  const jsi::Function& rejectedFunc = getGlobalFunction(runtime, "Promise.reject", [](jsi::Runtime& runtime) {
+    return runtime.global().getPropertyAsObject(runtime, "Promise").getPropertyAsFunction(runtime, "reject");
+  });
+  return rejectedFunc.call(runtime, {std::move(error)});
+}
+
+jsi::Value CommonGlobals::Promise::callConstructor(jsi::Runtime& runtime, jsi::HostFunctionType&& executor) {
+  const jsi::Function& promiseCtor = getGlobalFunction(
+      runtime, "Promise", [](jsi::Runtime& runtime) { return runtime.global().getPropertyAsFunction(runtime, "Promise"); });
+  jsi::Function executorFunc =
+      jsi::Function::createFromHostFunction(runtime, jsi::PropNameID::forAscii(runtime, "executor"), 2, std::move(executor));
+  return promiseCtor.callAsConstructor(runtime, std::move(executorFunc));
+}
+bool CommonGlobals::Promise::isInstanceOf(jsi::Runtime& runtime, const jsi::Object& object) {
+  const jsi::Function& promiseCtor = getGlobalFunction(
+      runtime, "Promise", [](jsi::Runtime& runtime) { return runtime.global().getPropertyAsFunction(runtime, "Promise"); });
+  return object.instanceOf(runtime, promiseCtor);
+}
+
+// pragma MARK: Date
+
+jsi::Value CommonGlobals::Date::callConstructor(jsi::Runtime& runtime, double msSinceEpoch) {
+  const jsi::Function& dateCtor =
+      getGlobalFunction(runtime, "Date", [](jsi::Runtime& runtime) { return runtime.global().getPropertyAsFunction(runtime, "Date"); });
+  return dateCtor.callAsConstructor(runtime, {jsi::Value(msSinceEpoch)});
+}
+bool CommonGlobals::Date::isInstanceOf(jsi::Runtime& runtime, const jsi::Object& object) {
+  const jsi::Function& dateCtor =
+      getGlobalFunction(runtime, "Date", [](jsi::Runtime& runtime) { return runtime.global().getPropertyAsFunction(runtime, "Date"); });
+  return object.instanceOf(runtime, dateCtor);
+}
+
+// pragma MARK: Error
+
+bool CommonGlobals::Error::isInstanceOf(jsi::Runtime& runtime, const jsi::Object& object) {
+  const jsi::Function& errorCtor =
+      getGlobalFunction(runtime, "Error", [](jsi::Runtime& runtime) { return runtime.global().getPropertyAsFunction(runtime, "Error"); });
+  return object.instanceOf(runtime, errorCtor);
+}
+
+// pragma MARK: CommonGlobals
+
+void CommonGlobals::defineGlobal(jsi::Runtime& runtime, KnownGlobalPropertyName name, jsi::Value&& value) {
+  const char* nameString = getKnownGlobalPropertyNameString(name);
+
+#ifdef NITRO_DEBUG
+  // In debug, let's perform additional safety checks.
+  if (runtime.global().hasProperty(runtime, nameString)) [[unlikely]] {
+    throw std::runtime_error("Failed to set `global." + std::string(nameString) + "` - it already exists for Runtime \"" +
+                             getRuntimeId(runtime) + "\"! Did you call `defineGlobal(\"" + std::string(nameString) +
+                             "\")` twice? Did you link Nitro Modules twice?");
+  }
+  Object::defineProperty(runtime, runtime.global(), nameString,
+                         PlainPropertyDescriptor{.configurable = false, .enumerable = true, .value = std::move(value), .writable = false});
+#else
+  // In release, just set the property.
+  runtime.global().setProperty(runtime, nameString, std::move(value));
+#endif
+}
+
+const char* CommonGlobals::getKnownGlobalPropertyNameString(KnownGlobalPropertyName name) {
+  switch (name) {
+    case KnownGlobalPropertyName::DISPATCHER:
+      return "__nitroDispatcher";
+    case KnownGlobalPropertyName::JSI_CACHE:
+      return "__nitroJsiCache";
+    case KnownGlobalPropertyName::NITRO_MODULES_PROXY:
+      return "NitroModulesProxy";
+  }
+}
+
+const jsi::PropNameID& CommonGlobals::getKnownGlobalPropertyName(jsi::Runtime& runtime, KnownGlobalPropertyName name) {
+  return PropNameIDCache::get(runtime, getKnownGlobalPropertyNameString(name));
+}
+
+const jsi::Function& CommonGlobals::getGlobalFunction(jsi::Runtime& runtime, const char* key,
+                                                      std::function<jsi::Function(jsi::Runtime&)> getFunction) {
+  // Let's try to find the function in cache
+  FunctionCache& functionCache = _cache[&runtime];
+  std::string stringKey = key;
+  auto iterator = functionCache.find(stringKey);
+  if (iterator != functionCache.end()) {
+    // We found it! Let's check if the reference is still valid...
+    BorrowingReference<jsi::Function> function = iterator->second;
+    if (function != nullptr) [[likely]] {
+      // It's still alive - let's use it from cache!
+      return *function;
+    }
+  }
+
+  // We haven't found the function with the given key in cache - so let's get it:
+  jsi::Function function = getFunction(runtime);
+
+  // Let's throw it in cache!
+  JSICacheReference jsiCache = JSICache::getOrCreateCache(runtime);
+  BorrowingReference<jsi::Function> sharedFunction = jsiCache.makeShared(std::move(function));
+  functionCache[stringKey] = sharedFunction;
+
+  // And now return:
+  return *sharedFunction;
+}
+
+} // namespace margelo::nitro

package/cpp/utils/CommonGlobals.hpp

@@ -0,0 +1,158 @@
+//
+//  CommonGlobals.hpp
+//  react-native-nitro
+//
+//  Created by Marc Rousavy on 17.10.25.
+//
+
+#pragma once
+
+#include "BorrowingReference.hpp"
+#include <jsi/jsi.h>
+#include <unordered_map>
+
+namespace margelo::nitro {
+
+using namespace facebook;
+
+struct PlainPropertyDescriptor {
+  bool configurable;
+  bool enumerable;
+  jsi::Value value;
+  bool writable;
+};
+struct ComputedReadonlyPropertyDescriptor {
+  bool configurable;
+  bool enumerable;
+  jsi::Function get;
+};
+struct ComputedPropertyDescriptor {
+  bool configurable;
+  bool enumerable;
+  jsi::Function get;
+  jsi::Function set;
+};
+
+enum class KnownGlobalPropertyName { DISPATCHER, JSI_CACHE, NITRO_MODULES_PROXY };
+
+class CommonGlobals final {
+public:
+  CommonGlobals() = delete;
+  ~CommonGlobals() = delete;
+
+public:
+  /**
+   * Define a global value for the given Runtime.
+   * In debug, this performs additional safety checks such as freezing the property.
+   */
+  static void defineGlobal(jsi::Runtime& runtime, KnownGlobalPropertyName name, jsi::Value&& value);
+  /**
+   * Get a string name for a known global property name.
+   */
+  static const char* getKnownGlobalPropertyNameString(KnownGlobalPropertyName name);
+  /**
+   * Get a `jsi::PropNameID` for a known global property name.
+   */
+  static const jsi::PropNameID& getKnownGlobalPropertyName(jsi::Runtime& runtime, KnownGlobalPropertyName name);
+
+  /**
+   * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object
+   */
+  class Object final {
+  public:
+    Object() = delete;
+    ~Object() = delete;
+
+    /**
+     * Create a new `jsi::Object` with the given `prototype`.
+     * Uses a native implementation if possible.
+     */
+    static jsi::Object create(jsi::Runtime& runtime, const jsi::Value& prototype);
+
+    /**
+     * Define a plain property on the given `object` with the given `propertyName`.
+     * The `descriptor` defines the attributes of this property.
+     */
+    static void defineProperty(jsi::Runtime& runtime, const jsi::Object& object, const char* propertyName,
+                               PlainPropertyDescriptor&& descriptor);
+    /**
+     * Define a plain property on the given `object` with the given `propertyName`.
+     * The `descriptor` defines the attributes of this property.
+     */
+    static void defineProperty(jsi::Runtime& runtime, const jsi::Object& object, const char* propertyName,
+                               ComputedReadonlyPropertyDescriptor&& descriptor);
+    /**
+     * Define a plain property on the given `object` with the given `propertyName`.
+     * The `descriptor` defines the attributes of this property.
+     */
+    static void defineProperty(jsi::Runtime& runtime, const jsi::Object& object, const char* propertyName,
+                               ComputedPropertyDescriptor&& descriptor);
+
+    /**
+     * Freezes all values of the given `object`.
+     */
+    static void freeze(jsi::Runtime& runtime, const jsi::Object& object);
+  };
+
+  /**
+   * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise
+   */
+  class Promise final {
+  public:
+    Promise() = delete;
+    ~Promise() = delete;
+
+    static jsi::Value resolved(jsi::Runtime& runtime);
+    static jsi::Value resolved(jsi::Runtime& runtime, jsi::Value&& value);
+    static jsi::Value rejected(jsi::Runtime& runtime, jsi::Value&& error);
+
+    static jsi::Value callConstructor(jsi::Runtime& runtime, jsi::HostFunctionType&& executor);
+    static bool isInstanceOf(jsi::Runtime& runtime, const jsi::Object& object);
+  };
+
+  /**
+   * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date
+   */
+  class Date final {
+  public:
+    Date() = delete;
+    ~Date() = delete;
+
+    static jsi::Value callConstructor(jsi::Runtime& runtime, double msSinceEpoch);
+    static bool isInstanceOf(jsi::Runtime& runtime, const jsi::Object& object);
+  };
+
+  /**
+   * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error
+   */
+  class Error final {
+  public:
+    Error() = delete;
+    ~Error() = delete;
+
+    static bool isInstanceOf(jsi::Runtime& runtime, const jsi::Object& object);
+  };
+
+private:
+  friend Object;
+  friend Promise;
+  friend Date;
+  friend Error;
+
+private:
+  /**
+   * Get a global Function, and optionally cache it in the Runtime via the `key`.
+   *
+   * The returned const-ref to a `jsi::Function` should only be used within the callee's
+   * synchronous scope.
+   * It may no longer be active after the scope ends (function return).
+   */
+  static const jsi::Function& getGlobalFunction(jsi::Runtime& runtime, const char* key,
+                                                std::function<jsi::Function(jsi::Runtime&)> getFunction);
+
+private:
+  using FunctionCache = std::unordered_map<std::string, BorrowingReference<jsi::Function>>;
+  static std::unordered_map<jsi::Runtime*, FunctionCache> _cache;
+};
+
+} // namespace margelo::nitro

package/cpp/utils/JSCallback.hpp

@@ -35,7 +35,7 @@ public:
 public:
   /**
    * Calls this `SyncJSCallback` synchronously, and
-   * returns it's result (`R`).
+   * returns its result (`R`).
    * The callee is responsible for ensuring that the
    * underlying `jsi::Function` can actually be called from this Thread.
    * In Debug, sanity checks are made to ensure the `jsi::Function` is still alive.

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.31.10"
+#define NITRO_VERSION "0.32.0"
 
 // Sets whether to use debug or optimized production build flags
 #ifdef DEBUG

package/cpp/utils/PropNameIDCache.cpp

@@ -0,0 +1,38 @@
+//
+//  PropNameIDCache.cpp
+//  react-native-nitro
+//
+//  Created by Marc Rousavy on 17.10.25.
+//
+
+#include "PropNameIDCache.hpp"
+#include "JSICache.hpp"
+
+namespace margelo::nitro {
+
+using namespace facebook;
+
+std::unordered_map<jsi::Runtime*, PropNameIDCache::CacheMap> PropNameIDCache::_cache;
+
+const jsi::PropNameID& PropNameIDCache::get(jsi::Runtime& runtime, std::string value) {
+  CacheMap& cache = _cache[&runtime];
+  const auto& cachedName = cache.find(value);
+  if (cachedName != cache.end()) {
+    // cache warm!
+    const BorrowingReference<jsi::PropNameID>& value = cachedName->second;
+    return *value;
+  }
+
+  // not cached - create the jsi::PropNameID...
+  auto propName = jsi::PropNameID::forAscii(runtime, value);
+  auto jsiCache = JSICache::getOrCreateCache(runtime);
+  auto sharedPropName = jsiCache.makeShared(std::move(propName));
+
+  // store it in cache...
+  cache.emplace(value, sharedPropName);
+
+  // return it!
+  return *sharedPropName;
+}
+
+} // namespace margelo::nitro

package/cpp/utils/PropNameIDCache.hpp

@@ -0,0 +1,44 @@
+//
+//  PropNameIDCache.hpp
+//  react-native-nitro
+//
+//  Created by Marc Rousavy on 17.10.25.
+//
+
+#pragma once
+
+#include "BorrowingReference.hpp"
+#include <jsi/jsi.h>
+#include <unordered_map>
+
+namespace margelo::nitro {
+
+using namespace facebook;
+
+/**
+ * Allows caching `jsi::PropNameID`s via `std::string`s.
+ * The returned `jsi::PropNameID` can be used for JSI operations like
+ * - `jsi::Object::getProperty(...)`
+ * - `jsi::Object::setProperty(...)`
+ * - `jsi::Object::hasProperty(...)`
+ * And is more efficient than the string equivalent overloads of those
+ * functions due to caching.
+ */
+class PropNameIDCache final {
+public:
+  PropNameIDCache() = delete;
+  ~PropNameIDCache() = delete;
+
+  /**
+   * Get a `jsi::PropNameID` for the given `std::string` value.
+   * The `jsi::PropNameID` is only valid within the callee's current
+   * synchronous scope, and must be non-escaping.
+   */
+  static const jsi::PropNameID& get(jsi::Runtime& runtime, std::string value);
+
+private:
+  using CacheMap = std::unordered_map<std::string, BorrowingReference<jsi::PropNameID>>;
+  static std::unordered_map<jsi::Runtime*, CacheMap> _cache;
+};
+
+} // namespace margelo::nitro

package/cpp/utils/{WeakReference+Owning.hpp → WeakReference+Borrowing.hpp}

@@ -1,5 +1,5 @@
 //
-//  WeakReference+Owning.hpp
+//  WeakReference+Borrowing.hpp
 //  react-native-nitro
 //
 //  Created by Marc Rousavy on 23.06.24.

package/cpp/utils/WeakReference.hpp

@@ -72,7 +72,7 @@ public:
   }
 
   /**
-   Try to lock the borrowing reference to an owning reference, or `nullptr` if it has already been deleted.
+   * Try to lock the weak reference to a borrowing reference, or `nullptr` if it has already been deleted.
    */
   [[nodiscard]]
   BorrowingReference<T> lock() const;

package/ios/core/HybridObject.swift

@@ -30,7 +30,7 @@ public protocol HybridObject: AnyObject {
    * Eagerly- (and manually-) dispose all native resources this `HybridObject` holds.
    * This method can only be manually called from JS using `dispose()`.
    *
-   * If this method is never manually called, a `HybridObject` is expected to disposes it's
+   * If this method is never manually called, a `HybridObject` is expected to disposes its
    * resources as usual via the object's destructor (`~HybridObject()`, `deinit` or `finalize()`).
    *
    * By default, this method does nothing. It can be overridden to perform actual disposing/cleanup

package/ios/platform/NitroLogger.cpp

@@ -0,0 +1,37 @@
+//
+//  NitroLogger.cpp
+//  react-native-nitro
+//
+//  Created by Marc Rousavy on 14.07.24.
+//
+
+#include "NitroLogger.hpp"
+#include "NitroDefines.hpp"
+#include <os/log.h>
+
+namespace margelo::nitro {
+
+void Logger::nativeLog([[maybe_unused]] LogLevel level,           //
+                       [[maybe_unused]] const char* NON_NULL tag, //
+                       [[maybe_unused]] const std::string& message) {
+#ifdef NITRO_DEBUG
+  static os_log_t logger = os_log_create("com.margelo.nitro", "nitro");
+
+  switch (level) {
+    case LogLevel::Debug:
+      os_log_debug(logger, "[%s] %s", tag, message.c_str());
+      break;
+    case LogLevel::Info:
+      os_log_info(logger, "[%s] %s", tag, message.c_str());
+      break;
+    case LogLevel::Warning:
+      os_log_error(logger, "[%s] %s", tag, message.c_str());
+      break;
+    case LogLevel::Error:
+      os_log_error(logger, "[%s] %s", tag, message.c_str());
+      break;
+  }
+#endif
+}
+
+} // namespace margelo::nitro

package/ios/platform/ThreadUtils.cpp

@@ -0,0 +1,43 @@
+//
+//  ThreadUtils.cpp
+//  react-native-nitro
+//
+//  Created by Marc Rousavy on 14.07.24.
+//
+
+#include "ThreadUtils.hpp"
+#include <dispatch/dispatch.h>
+#include <pthread.h>
+#include <sstream>
+#include <thread>
+
+namespace margelo::nitro {
+
+std::string ThreadUtils::getThreadName() {
+  // Try using pthread APIs
+  char threadName[64] = {};
+  int pthreadResult = pthread_getname_np(pthread_self(), threadName, sizeof(threadName));
+  if (pthreadResult == 0 && threadName[0] != '\0') {
+    // We have a pthread name
+    return std::string(threadName);
+  }
+
+  // Try getting DispatchQueue name
+  const char* queueName = dispatch_queue_get_label(DISPATCH_CURRENT_QUEUE_LABEL);
+  if (queueName != nullptr && queueName[0] != '\0') {
+    // We are on a DispatchQueue with a name
+    return std::string(queueName);
+  }
+
+  // Fall back to std::this_thread
+  std::stringstream stream;
+  stream << std::this_thread::get_id();
+  std::string threadId = stream.str();
+  return std::string("Thread #") + threadId;
+}
+
+void ThreadUtils::setThreadName(const std::string& name) {
+  pthread_setname_np(name.c_str());
+}
+
+} // namespace margelo::nitro

package/ios/utils/SwiftClosure.swift

@@ -31,7 +31,7 @@ extension SwiftClosure {
    * This can then be called from both C++ and Swift.
    */
   public init(wrappingClosure closure: @escaping () -> Void) {
-    // Wrap closure in void*, and increment it's ref count so it stays alive.
+    // Wrap closure in void*, and increment its ref count so it stays alive.
     let context = Unmanaged.passRetained(ClosureWrapper(closure: closure)).toOpaque()
 
     // Create a C-style Function Pointer, which calls the actual Swift closure.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-nitro-modules",
-  "version": "0.31.10",
+  "version": "0.32.0",
   "description": "Insanely fast native C++, Swift or Kotlin modules with a statically compiled binding layer to JSI.",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",
@@ -59,7 +59,6 @@
     "registry": "https://registry.npmjs.org/"
   },
   "scripts": {
-    "postinstall": "bun build || exit 0;",
     "write-native-version": "version=$(node -p \"require('./package.json').version\") && sed -i '' \"s/#define NITRO_VERSION \\\".*\\\"/#define NITRO_VERSION \\\"$version\\\"/\" ./cpp/utils/NitroDefines.hpp",
     "postversion": "bun run write-native-version",
     "build": "rm -rf lib && bun typecheck && bob build",