react-native-nitro-modules 0.21.0 → 0.22.1

package/lib/typescript/views/HybridView.d.ts

@@ -0,0 +1,35 @@
+import type { HybridObject } from '../HybridObject';
+/**
+ * Describes the languages this view will be implemented in.
+ */
+export interface ViewPlatformSpec {
+    ios?: 'swift';
+    android?: 'kotlin';
+}
+/**
+ * Represents a Nitro `HybridView` which is implemented in a native language
+ * like Swift or Kotlin.
+ *
+ * `HybridViews`s use the Nitro Tunnel for efficient, low-overhead JS <-> Native communication.
+ *
+ * All `HybridViews`s have a C++ Fabric View base with a backing Shadow Node.
+ *
+ * - TypeScript Properties (`name: Type`) will be React Props
+ * - TypeScript Methods (`name(): Type`) will be Ref Methods
+ *
+ * @example
+ * ```tsx
+ * export interface Camera extends HybridView {
+ *   zoom: number
+ *   flash: boolean
+ *   takePhoto(): Image
+ * }
+ * ```
+ */
+export interface HybridView<Platforms extends ViewPlatformSpec = {
+    ios: 'swift';
+    android: 'kotlin';
+}> extends HybridObject<Platforms> {
+}
+export * from './getHostComponent';
+//# sourceMappingURL=HybridView.d.ts.map

package/lib/typescript/views/HybridView.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HybridView.d.ts","sourceRoot":"","sources":["../../../src/views/HybridView.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAA;AAEnD;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,GAAG,CAAC,EAAE,OAAO,CAAA;IACb,OAAO,CAAC,EAAE,QAAQ,CAAA;CACnB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,WAAW,UAAU,CACzB,SAAS,SAAS,gBAAgB,GAAG;IAAE,GAAG,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,QAAQ,CAAA;CAAE,CACxE,SAAQ,YAAY,CAAC,SAAS,CAAC;CAEhC;AAED,cAAc,oBAAoB,CAAA"}

package/lib/typescript/views/getHostComponent.d.ts

@@ -0,0 +1,13 @@
+import { type HostComponent } from 'react-native';
+export interface ViewConfig<Props> {
+    uiViewClassName: string;
+    supportsRawText?: boolean;
+    bubblingEventTypes: Record<string, unknown>;
+    directEventTypes: Record<string, unknown>;
+    validAttributes: Record<keyof Props, boolean>;
+}
+/**
+ * Finds and returns a native view (aka {@linkcode HostComponent}) via the given {@linkcode name}.
+ */
+export declare function getHostComponent<Props>(name: string, getViewConfig: () => ViewConfig<Props>): HostComponent<Props>;
+//# sourceMappingURL=getHostComponent.d.ts.map

package/lib/typescript/views/getHostComponent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getHostComponent.d.ts","sourceRoot":"","sources":["../../../src/views/getHostComponent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,KAAK,aAAa,EAAE,MAAM,cAAc,CAAA;AAI3D,MAAM,WAAW,UAAU,CAAC,KAAK;IAC/B,eAAe,EAAE,MAAM,CAAA;IACvB,eAAe,CAAC,EAAE,OAAO,CAAA;IACzB,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC3C,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IACzC,eAAe,EAAE,MAAM,CAAC,MAAM,KAAK,EAAE,OAAO,CAAC,CAAA;CAC9C;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EACpC,IAAI,EAAE,MAAM,EACZ,aAAa,EAAE,MAAM,UAAU,CAAC,KAAK,CAAC,GACrC,aAAa,CAAC,KAAK,CAAC,CAOtB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-nitro-modules",
-  "version": "0.21.0",
+  "version": "0.22.1",
   "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",
@@ -20,6 +20,7 @@
     "cpp/",
     "app.plugin.js",
     "*.podspec",
+    "nitro_pod_utils.rb",
     "README.md"
   ],
   "keywords": [
@@ -73,7 +74,7 @@
     "@types/react": "*",
     "jest": "*",
     "react": "18.3.1",
-    "react-native": "0.76.5",
+    "react-native": "0.77.0",
     "react-native-builder-bob": "^0.35.0"
   },
   "peerDependencies": {

package/src/NitroModulesProxy.ts

@@ -69,4 +69,12 @@ export interface NitroModulesProxy extends HybridObject {
    * Returns whether the given {@linkcode object} has NativeState or not.
    */
   hasNativeState(object: unknown): boolean
+
+  /**
+   * Re-calculates `memorySize` of the given {@linkcode HybridObject} and notifies
+   * the JS VM about the newly updated memory footprint.
+   *
+   * This is achieved by just doing a round-trip from JS -> native -> JS.
+   */
+  updateMemorySize(obj: HybridObject): HybridObject
 }

package/src/index.ts

@@ -2,3 +2,4 @@ export * from './HybridObject'
 export * from './NitroModules'
 export * from './AnyMap'
 export * from './Constructor'
+export * from './views/HybridView'

package/src/views/HybridView.ts

@@ -0,0 +1,37 @@
+import type { HybridObject } from '../HybridObject'
+
+/**
+ * Describes the languages this view will be implemented in.
+ */
+export interface ViewPlatformSpec {
+  ios?: 'swift'
+  android?: 'kotlin'
+}
+
+/**
+ * Represents a Nitro `HybridView` which is implemented in a native language
+ * like Swift or Kotlin.
+ *
+ * `HybridViews`s use the Nitro Tunnel for efficient, low-overhead JS <-> Native communication.
+ *
+ * All `HybridViews`s have a C++ Fabric View base with a backing Shadow Node.
+ *
+ * - TypeScript Properties (`name: Type`) will be React Props
+ * - TypeScript Methods (`name(): Type`) will be Ref Methods
+ *
+ * @example
+ * ```tsx
+ * export interface Camera extends HybridView {
+ *   zoom: number
+ *   flash: boolean
+ *   takePhoto(): Image
+ * }
+ * ```
+ */
+export interface HybridView<
+  Platforms extends ViewPlatformSpec = { ios: 'swift'; android: 'kotlin' },
+> extends HybridObject<Platforms> {
+  /* empty interface for now */
+}
+
+export * from './getHostComponent'

package/src/views/getHostComponent.ts

@@ -0,0 +1,26 @@
+import { Platform, type HostComponent } from 'react-native'
+// @ts-expect-error this unfortunately isn't typed or default-exported.
+import * as NativeComponentRegistry from 'react-native/Libraries/NativeComponent/NativeComponentRegistry'
+
+export interface ViewConfig<Props> {
+  uiViewClassName: string
+  supportsRawText?: boolean
+  bubblingEventTypes: Record<string, unknown>
+  directEventTypes: Record<string, unknown>
+  validAttributes: Record<keyof Props, boolean>
+}
+
+/**
+ * Finds and returns a native view (aka {@linkcode HostComponent}) via the given {@linkcode name}.
+ */
+export function getHostComponent<Props>(
+  name: string,
+  getViewConfig: () => ViewConfig<Props>
+): HostComponent<Props> {
+  if (NativeComponentRegistry == null) {
+    throw new Error(
+      `NativeComponentRegistry is not available on ${Platform.OS}!`
+    )
+  }
+  return NativeComponentRegistry.get<Props>(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,237 +0,0 @@
-//
-//  OwningReference.hpp
-//  react-native-nitro
-//
-//  Created by Marc Rousavy on 23.06.24.
-//
-
-#pragma once
-
-#include "BorrowingReference.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) {
-    // 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 {
-    return *_value;
-  }
-
-  inline T* operator->() const {
-    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"