react-native-nitro-modules 0.5.0 → 0.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-nitro-modules",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "Insanely fast native C++, Swift or Kotlin modules with a statically compiled binding layer to JSI.",
   "main": "lib/index",
   "module": "lib/index",
@@ -28,6 +28,7 @@
     "typecheck": "tsc --noEmit",
     "clean": "del-cli android/build node_modules/**/android/build lib",
     "lint": "eslint \"**/*.{js,ts,tsx}\" --fix",
+    "lint-ci": "eslint \"**/*.{js,ts,tsx}\" -f @jamesacarr/github-actions",
     "release": "bob build && release-it",
     "typescript": "tsc --noEmit false"
   },
@@ -51,36 +52,33 @@
   ],
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/mrousavy/react-native-nitro.git"
+    "url": "git+https://github.com/mrousavy/nitro.git"
   },
   "author": "Marc Rousavy <me@mrousavy.com> (https://github.com/mrousavy)",
   "license": "MIT",
   "bugs": {
-    "url": "https://github.com/mrousavy/react-native-nitro/issues"
+    "url": "https://github.com/mrousavy/nitro/issues"
   },
-  "homepage": "https://github.com/mrousavy/react-native-nitro#readme",
+  "homepage": "https://github.com/mrousavy/nitro#readme",
   "publishConfig": {
     "registry": "https://registry.npmjs.org/"
   },
   "devDependencies": {
-    "@react-native/eslint-config": "^0.74.85",
+    "@react-native/eslint-config": "^0.75.2",
     "@types/jest": "^29.5.12",
-    "@types/react": "^18.3.3",
+    "@types/react": "^18.3.4",
     "del-cli": "^5.1.0",
     "eslint": "^8.57.0",
     "eslint-config-prettier": "^9.1.0",
     "eslint-plugin-prettier": "^5.2.1",
     "jest": "^29.7.0",
     "prettier": "^3.3.3",
-    "react": "18.3.1",
-    "react-native": "0.74.3",
-    "react-native-builder-bob": "^0.23.2",
+    "react": "^18.3.1",
+    "react-native": "^0.75.2",
+    "react-native-builder-bob": "^0.30.0",
     "release-it": "^17.6.0",
     "typescript": "^5.5.4"
   },
-  "resolutions": {
-    "@types/react": "^18.2.44"
-  },
   "peerDependencies": {
     "react": "*",
     "react-native": "*"
@@ -108,6 +106,9 @@
       "@react-native",
       "prettier"
     ],
+    "plugins": [
+      "prettier"
+    ],
     "rules": {
       "prettier/prettier": [
         "warn",

package/src/AnyMap.ts

@@ -18,5 +18,8 @@ export type ValueType =
  * - Objects of primitives (`Record<string, ValueType>`)
  * - Arrays of arrays or objects
  * - Objects of arrays or objects
+ *
+ * @note It is recommended to always use typed `interface`s instead of `AnyMap` for
+ * both type safety, as well as better performance.
  */
 export type AnyMap = Record<string, ValueType>

package/src/HybridObject.ts

@@ -80,4 +80,19 @@ export interface HybridObject<Platforms extends PlatformSpec = {}> {
    * ```
    */
   equals(other: HybridObject<Platforms>): boolean
+  /**
+   * Disposes any resources this {@linkcode HybridObject} might hold natively,
+   * and finally releases this {@linkcode HybridObject}'s `NativeState`.
+   *
+   * After calling {@linkcode dispose()}, this object can no longer be used.
+   *
+   * Eagerly disposing a {@linkcode HybridObject} could be beneficial for a queue-/handler-architecture
+   * where a bunch of Hybrid Objects are allocated, and later deallocated once a callback (e.g. a render function)
+   * completes.
+   *
+   * @note It is **NOT** required to call {@linkcode dispose()} manually, as the JavaScript
+   * Garbage Collector automatically disposes and releases any resources when needed.
+   * It is purely optional to eagerly-, and manually-, call {@linkcode dispose()} here - **use with caution!**
+   */
+  dispose(): void
 }

package/src/NativeNitroModules.ts

@@ -4,10 +4,15 @@ import type { UnsafeObject } from 'react-native/Libraries/Types/CodegenTypes'
 import { ModuleNotFoundError } from './ModuleNotFoundError'
 
 export interface Spec extends TurboModule {
+  // Set up
   install(): void
+  // Hybrid Objects stuff
   createHybridObject(name: string, args?: UnsafeObject): UnsafeObject
   hasHybridObject(name: string): boolean
   getAllHybridObjectNames(): string[]
+  // JSI Helpers
+  hasNativeState(obj: UnsafeObject): boolean
+  removeNativeState(obj: UnsafeObject): void
 }
 
 let turboModule: Spec | undefined

package/src/NitroModules.ts

@@ -41,4 +41,28 @@ export const NitroModules = {
     const nitro = getNativeNitroModules()
     return nitro.hasHybridObject(name)
   },
+  /**
+   * Returns whether the given {@linkcode object} has a `NativeState` or not.
+   *
+   * This can be a quick way to check if an object is a valid {@linkcode HybridObject},
+   * and has not yet been disposed.
+   * @example
+   * ```ts
+   * const someObject = NitroModules.createHybridObject<Some>('Some')
+   * console.log(NitroModules.hasNativeState(someObject)) // -> true
+   * someObject.dispose()
+   * console.log(NitroModules.hasNativeState(someObject)) // -> false
+   * ```
+   */
+  hasNativeState(object: object): boolean {
+    const nitro = getNativeNitroModules()
+    return nitro.hasNativeState(object)
+  },
+  /**
+   * Forcefully removes the `NativeState` of the given {@linkcode object}.
+   */
+  removeNativeState(object: object): void {
+    const nitro = getNativeNitroModules()
+    nitro.removeNativeState(object)
+  },
 }

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

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

package/cpp/templates/IsInPack.hpp

@@ -1,21 +0,0 @@
-//
-//  BorrowingReference.hpp
-//  NitroModules
-//
-//  Created by Marc Rousavy on 21.06.24.
-//
-
-#pragma once
-
-#include <type_traits>
-
-namespace margelo::nitro {
-
-// Returns whether the given type `T` is inside `Types...`
-template <typename T, typename... Types>
-struct is_in_pack : std::disjunction<std::is_same<T, Types>...> {};
-
-template <typename T, typename... Types>
-inline constexpr bool is_in_pack_v = is_in_pack<T, Types...>::value;
-
-} // namespace margelo::nitro

package/cpp/utils/NitroLogger.hpp

@@ -1,58 +0,0 @@
-//
-// Created by Marc Rousavy on 05.03.24.
-//
-
-#pragma once
-
-#include <cstdarg>
-#include <cstdio>
-#include <iostream>
-#include <string>
-#include <vector>
-
-namespace margelo::nitro {
-
-class Logger final {
-private:
-  Logger() = delete;
-
-public:
-  template <typename... Args>
-  static void log(const char* tag, const char* message, Args&&... args) {
-    std::string formattedMessage = format(message, std::forward<Args>(args)...);
-    std::cout << "[Nitro." << tag << "] " << formattedMessage << std::endl;
-  }
-
-private:
-  template <typename... Args>
-  static inline std::string format(const char* formatString, Args&&... args) {
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wformat-security"
-    int size_s = std::snprintf(nullptr, 0, formatString, toCString(args)...) + 1; // Extra space for '\0'
-    if (size_s <= 0) [[unlikely]] {
-      throw std::runtime_error("Failed to format log message \"" + std::string(formatString) + "\"!");
-    }
-    auto size = static_cast<size_t>(size_s);
-    std::vector<char> buf(size);
-    std::snprintf(buf.data(), size, formatString, toCString(args)...);
-    return std::string(buf.data(), buf.data() + size - 1); // We don't want the '\0' inside
-#pragma clang diagnostic pop
-  }
-
-private:
-  // When the user passes an `std::string`, it will automatically be converted to a `const char*`
-  static inline const char* toCString(const std::string& s) {
-    return s.c_str();
-  }
-  // When the user passes a `const char*`, we don't want to implicitly convert to `std::string`, so block that
-  static inline const char* toCString(const char* s) {
-    return s;
-  }
-  // When the user passes any other type, just return that directly.
-  template <typename T>
-  static inline T toCString(T value) {
-    return value;
-  }
-};
-
-} // namespace margelo::nitro

package/ios/utils/ClosureWrapper.swift

@@ -1,45 +0,0 @@
-//
-//  ClosureWrapper.swift
-//  NitroModules
-//
-//  Created by Marc Rousavy on 14.08.24.
-//
-
-import Foundation
-
-/**
- * Wraps a closure in a Swift class.
- * This can be used to create unmanaged pointers (`void*`) and
- * passed to C-style function pointers via `void* context` parameters.
- *
- * To create a `ClosureWrapper`, use `ClosureWrapper.wrap(...)`.
- */
-public final class ClosureWrapper {
-  private let closure: () -> Void
-
-  private init(closure: @escaping () -> Void) {
-    self.closure = closure
-  }
-
-  private func invoke() {
-    closure()
-  }
-  
-  /**
-   * Wraps the given Swift closure in a C-style function pointer with `void* context` associated to it.
-   * This way it can be passed to C/C++ and called without worrying about context/binding.
-   */
-  public static func wrap(closure: @escaping () -> Void) -> (@convention(c) (UnsafeMutableRawPointer?) -> Void, UnsafeMutableRawPointer) {
-    // Wrap closure in void*
-    let context = Unmanaged.passRetained(ClosureWrapper(closure: closure)).toOpaque()
-    // Create C-style Function Pointer
-    let cFunc: @convention(c) (UnsafeMutableRawPointer?) -> Void = { context in
-      guard let context else { fatalError("Context was null, even though we created one!") }
-      // Unwrap context from void* to closure again
-      let closure = Unmanaged<ClosureWrapper>.fromOpaque(context).takeRetainedValue()
-      // Call it!
-      closure.invoke()
-    }
-    return (cFunc, context)
-  }
-}