react-native-nitro-modules 0.22.0 → 0.23.0

package/src/views/getHostComponent.ts

@@ -1,6 +1,11 @@
-import { Platform, type HostComponent } from 'react-native'
+import { Platform, type HostComponent, type ViewProps } from 'react-native'
 // @ts-expect-error this unfortunately isn't typed or default-exported.
 import * as NativeComponentRegistry from 'react-native/Libraries/NativeComponent/NativeComponentRegistry'
+import type {
+  HybridView,
+  HybridViewMethods,
+  HybridViewProps,
+} from './HybridView'
 
 export interface ViewConfig<Props> {
   uiViewClassName: string
@@ -11,16 +16,73 @@ export interface ViewConfig<Props> {
 }
 
 /**
- * Finds and returns a native view (aka {@linkcode HostComponent}) via the given {@linkcode name}.
+ * Represents all default props a Nitro HybridView has.
  */
-export function getHostComponent<Props>(
+interface DefaultHybridViewProps<RefType> extends ViewProps {
+  /**
+   * A `ref` to the {@linkcode HybridObject} this Hybrid View is rendering.
+   *
+   * The `hybridRef` property expects a stable Ref object received from `useRef` or `createRef`.
+   * @example
+   * ```jsx
+   * function App() {
+   *   return (
+   *     <HybridScrollView
+   *       hybridRef={{ f: (ref) => {
+   *         ref.current.scrollTo(400)
+   *       }
+   *     />
+   *   )
+   * }
+   * ```
+   */
+  hybridRef?: (ref: RefType) => void
+}
+
+// Due to a React limitation, functions cannot be passed to native directly
+// because RN converts them to booleans (`true`). Nitro knows this and just
+// wraps functions as objects - the original function is stored in `f`.
+type WrapFunctionsInObjects<Props> = {
+  [K in keyof Props]: Props[K] extends Function
+    ? { f: Props[K] }
+    : Props[K] extends Function | undefined
+      ? { f: Props[K] }
+      : Props[K]
+}
+
+/**
+ * Represents a React Native view, implemented as a Nitro View, with the given props and methods.
+ *
+ * @note Every React Native view has a {@linkcode DefaultHybridViewProps.hybridRef hybridRef} which can be used to gain access
+ *       to the underlying Nitro {@linkcode HybridView}.
+ * @note Every function/callback is wrapped as a `{ f: … }` object.
+ * @note Every method can be called on the Ref. Including setting properties directly.
+ */
+export type ReactNativeView<
+  Props extends HybridViewProps,
+  Methods extends HybridViewMethods,
+> = HostComponent<
+  WrapFunctionsInObjects<
+    DefaultHybridViewProps<HybridView<Props, Methods>> & Props
+  >
+>
+
+/**
+ * Finds and returns a native view (aka "HostComponent") via the given {@linkcode name}.
+ *
+ * The view is bridged to a native Hybrid Object using Nitro Views.
+ */
+export function getHostComponent<
+  Props extends HybridViewProps,
+  Methods extends HybridViewMethods,
+>(
   name: string,
   getViewConfig: () => ViewConfig<Props>
-): HostComponent<Props> {
+): ReactNativeView<Props, Methods> {
   if (NativeComponentRegistry == null) {
     throw new Error(
       `NativeComponentRegistry is not available on ${Platform.OS}!`
     )
   }
-  return NativeComponentRegistry.get<Props>(name, getViewConfig)
+  return NativeComponentRegistry.get(name, getViewConfig)
 }

package/cpp/utils/BorrowingReference+Owning.hpp

@@ -1,36 +0,0 @@
-//
-//  BorrowingReference+Owning.hpp
-//  react-native-nitro
-//
-//  Created by Marc Rousavy on 23.06.24.
-//
-
-#pragma once
-
-#include "OwningReference.hpp"
-
-namespace margelo::nitro {
-
-template <typename T>
-BorrowingReference<T>::BorrowingReference(const OwningReference<T>& ref) {
-  _value = ref._value;
-  _isDeleted = ref._isDeleted;
-  _strongRefCount = ref._strongRefCount;
-  _weakRefCount = ref._weakRefCount;
-  _mutex = ref._mutex;
-  (*_weakRefCount)++;
-}
-
-template <typename T>
-OwningReference<T> BorrowingReference<T>::lock() const {
-  std::unique_lock lock(*_mutex);
-
-  if (*_isDeleted) {
-    // return nullptr
-    return OwningReference<T>();
-  }
-
-  return OwningReference(*this);
-}
-
-} // namespace margelo::nitro

package/cpp/utils/OwningReference.hpp

@@ -1,250 +0,0 @@
-//
-//  OwningReference.hpp
-//  react-native-nitro
-//
-//  Created by Marc Rousavy on 23.06.24.
-//
-
-#pragma once
-
-#include "BorrowingReference.hpp"
-#include "NitroDefines.hpp"
-#include "OwningLock.hpp"
-#include <atomic>
-#include <cstddef>
-#include <mutex>
-
-namespace margelo::nitro {
-
-/**
- An `OwningReference<T>` is a smart-pointer that holds a strong reference to a pointer.
- You can have multiple `OwningReference<T>` instances point to the same pointer, as they internally keep a ref-count.
- As opposed to a `shared_ptr<T>`, an `OwningReference<T>` can also be imperatively manually deleted, even if there
- are multiple strong references still holding onto the pointer.
-
- An `OwningReference<T>` can be weakified, which gives the user a `BorrowingReference<T>`.
- A `BorrowingReference<T>` can be locked to get an `OwningReference<T>` again, assuming it has not been deleted yet.
- */
-template <typename T>
-class OwningReference final {
-public:
-  using Pointee = T;
-
-public:
-  OwningReference() : _value(nullptr), _isDeleted(nullptr), _strongRefCount(nullptr), _weakRefCount(nullptr), _mutex(nullptr) {}
-
-  explicit OwningReference(T* value)
-      : _value(value), _isDeleted(new bool(false)), _strongRefCount(new std::atomic_size_t(1)), _weakRefCount(new std::atomic_size_t(0)),
-        _mutex(new std::recursive_mutex()) {}
-
-  OwningReference(const OwningReference& ref)
-      : _value(ref._value), _isDeleted(ref._isDeleted), _strongRefCount(ref._strongRefCount), _weakRefCount(ref._weakRefCount),
-        _mutex(ref._mutex) {
-    if (_strongRefCount != nullptr) {
-      // increment ref count after copy
-      (*_strongRefCount)++;
-    }
-  }
-
-  OwningReference(OwningReference&& ref)
-      : _value(ref._value), _isDeleted(ref._isDeleted), _strongRefCount(ref._strongRefCount), _weakRefCount(ref._weakRefCount),
-        _mutex(ref._mutex) {
-    ref._value = nullptr;
-    ref._isDeleted = nullptr;
-    ref._strongRefCount = nullptr;
-    ref._weakRefCount = nullptr;
-  }
-
-  OwningReference& operator=(const OwningReference& ref) {
-    if (this == &ref)
-      return *this;
-
-    if (_strongRefCount != nullptr) {
-      // destroy previous pointer
-      (*_strongRefCount)--;
-      maybeDestroy();
-    }
-
-    _value = ref._value;
-    _isDeleted = ref._isDeleted;
-    _strongRefCount = ref._strongRefCount;
-    _weakRefCount = ref._weakRefCount;
-    _mutex = ref._mutex;
-    if (_strongRefCount != nullptr) {
-      // increment new pointer
-      (*_strongRefCount)++;
-    }
-
-    return *this;
-  }
-
-private:
-  // BorrowingReference<T> -> OwningReference<T> Lock-constructor
-  OwningReference(const BorrowingReference<T>& ref)
-      : _value(ref._value), _isDeleted(ref._isDeleted), _strongRefCount(ref._strongRefCount), _weakRefCount(ref._weakRefCount),
-        _mutex(ref._mutex) {
-    (*_strongRefCount)++;
-  }
-
-private:
-  // OwningReference<C> -> OwningReference<T> Cast-constructor
-  template <typename OldT>
-  OwningReference(T* value, const OwningReference<OldT>& originalRef)
-      : _value(value), _isDeleted(originalRef._isDeleted), _strongRefCount(originalRef._strongRefCount),
-        _weakRefCount(originalRef._weakRefCount), _mutex(originalRef._mutex) {
-    (*_strongRefCount)++;
-  }
-
-  template <typename C>
-  friend class OwningReference;
-
-public:
-  ~OwningReference() {
-    if (_strongRefCount == nullptr) {
-      // we are just a dangling nullptr.
-      return;
-    }
-
-    // decrement strong ref count on destroy
-    --(*_strongRefCount);
-    maybeDestroy();
-  }
-
-public:
-  /**
-   Casts this `OwningReference<T>` to a `OwningReference<C>`.
-   */
-  template <typename C>
-  OwningReference<C> as() {
-    return OwningReference<C>(static_cast<C*>(_value), *this);
-  }
-
-public:
-  /**
-   Creates an `OwningLock<T>` for the given `OwningReference<T>` to guarantee safe
-   safe access to `OwningReference<T>`.
-   Other threads (e.g. the Hermes garbage collector) cannot delete the `OwningReference<T>`
-   as long as the `OwningLock<T>` is still alive.
-   */
-  [[nodiscard]]
-  OwningLock<T> lock() const {
-    return OwningLock<T>(*this);
-  }
-
-  /**
-   Get whether the `OwningReference<T>` is still pointing to a valid value, or not.
-   */
-  inline bool hasValue() const {
-    return _value != nullptr && !(*_isDeleted);
-  }
-
-  /**
-   Get a borrowing (or "weak") reference to this owning reference
-   */
-  [[nodiscard]]
-  BorrowingReference<T> weak() const {
-    return BorrowingReference(*this);
-  }
-
-  /**
-   Delete and destroy the value this OwningReference is pointing to.
-   This can even be called if there are still multiple strong references to the value.
-
-   This will block as long as one or more `OwningLock<T>`s of this `OwningReference<T>` are still alive.
-   */
-  void destroy() {
-    std::unique_lock lock(*_mutex);
-
-    forceDestroy();
-  }
-
-public:
-  explicit inline operator bool() const {
-    return hasValue();
-  }
-
-  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;
-  }
-
-  inline bool operator==(T* other) const {
-    std::unique_lock lock(*_mutex);
-
-    if (*_isDeleted) {
-      return other == nullptr;
-    } else {
-      return other == _value;
-    }
-  }
-
-  inline bool operator!=(T* other) const {
-    return !(this == other);
-  }
-
-  inline bool operator==(const OwningReference<T>& other) const {
-    return _value == other._value;
-  }
-
-  inline bool operator!=(const OwningReference<T>& other) const {
-    return !(this == other);
-  }
-
-private:
-  void maybeDestroy() {
-    _mutex->lock();
-
-    if (*_strongRefCount == 0) {
-      // after no strong references exist anymore
-      forceDestroy();
-    }
-
-    if (*_strongRefCount == 0 && *_weakRefCount == 0) {
-      // free the full memory if there are no more references at all
-      delete _isDeleted;
-      delete _strongRefCount;
-      delete _weakRefCount;
-      _mutex->unlock();
-      return;
-    }
-
-    _mutex->unlock();
-  }
-
-  void forceDestroy() {
-    if (*_isDeleted) {
-      // it has already been destroyed.
-      return;
-    }
-    delete _value;
-    *_isDeleted = true;
-  }
-
-public:
-  friend class BorrowingReference<T>;
-  friend class OwningLock<T>;
-
-private:
-  T* _value;
-  bool* _isDeleted;
-  std::atomic_size_t* _strongRefCount;
-  std::atomic_size_t* _weakRefCount;
-  std::recursive_mutex* _mutex;
-};
-
-} // namespace margelo::nitro
-
-#include "BorrowingReference+Owning.hpp"