@hxa-rn/react-native-quick-crypto 1.1.0-beta.1

package/harmony/quick_crypto/src/main/cpp/nitro/NitroModules/BorrowingReference.hpp

@@ -0,0 +1,223 @@
+//
+//  BorrowingReference.hpp
+//  react-native-nitro
+//
+//  Created by Marc Rousavy on 23.06.24.
+//
+
+#pragma once
+
+#include "NitroDefines.hpp"
+#include "NitroTypeInfo.hpp"
+#include "ReferenceState.hpp"
+#include "WeakReference.hpp"
+#include <atomic>
+#include <cstddef>
+#include <mutex>
+
+namespace margelo::nitro {
+
+/**
+ * An `BorrowingReference<T>` is a smart-pointer that holds a strong reference to a pointer.
+ * You can have multiple `BorrowingReference<T>` instances point to the same pointer, as they internally keep a ref-count.
+ * As opposed to a `shared_ptr<T>`, an `BorrowingReference<T>` can also be imperatively manually deleted, even if there
+ * are multiple strong references still holding onto the pointer.
+ * This is useful in cases where the `BorrowingReference` might keep a reference alive, but an external value holder
+ * is actually responsible for truly deleting the underlying value - like a `jsi::Runtime` for a `jsi::Value`.
+ *
+ * An `BorrowingReference<T>` can be weakified, which gives the user a `WeakReference<T>`.
+ * A `WeakReference<T>` can be locked to get an `BorrowingReference<T>` again, assuming it has not been deleted yet.
+ */
+template <typename T>
+class BorrowingReference final {
+public:
+  BorrowingReference() : _value(nullptr), _state(nullptr) {}
+
+  explicit BorrowingReference(T* NULLABLE value) : _value(value), _state(new ReferenceState()) {}
+
+  BorrowingReference(const BorrowingReference& ref) : _value(ref._value), _state(ref._state) {
+    if (_state != nullptr) {
+      // increment ref count after copy
+      _state->strongRefCount++;
+    }
+  }
+
+  BorrowingReference(BorrowingReference&& ref) noexcept : _value(ref._value), _state(ref._state) {
+    ref._value = nullptr;
+    ref._state = nullptr;
+  }
+
+  BorrowingReference& operator=(const BorrowingReference& ref) {
+    if (this == &ref)
+      return *this;
+
+    if (_state != nullptr) {
+      // destroy previous pointer
+      bool shouldDestroy = _state->decrementStrongRefCount();
+      if (shouldDestroy) {
+        forceDestroyValue();
+      }
+      maybeDestroyState();
+    }
+
+    _value = ref._value;
+    _state = ref._state;
+    if (_state != nullptr) {
+      // increment new pointer
+      _state->strongRefCount++;
+    }
+
+    return *this;
+  }
+
+private:
+  // WeakReference<T> -> BorrowingReference<T> Lock-constructor
+  explicit BorrowingReference(const WeakReference<T>& ref) : _value(ref._value), _state(ref._state) {
+    _state->strongRefCount++;
+  }
+
+private:
+  // BorrowingReference<C> -> BorrowingReference<T> Cast-constructor
+  template <typename OldT>
+  BorrowingReference(T* NULLABLE value, const BorrowingReference<OldT>& originalRef) : _value(value), _state(originalRef._state) {
+    _state->strongRefCount++;
+  }
+
+  template <typename C>
+  friend class BorrowingReference;
+
+public:
+  ~BorrowingReference() {
+    if (_state == nullptr) {
+      // we are just a dangling nullptr.
+      return;
+    }
+
+    // decrement strong ref count on destroy
+    bool shouldDestroy = _state->decrementStrongRefCount();
+    if (shouldDestroy) {
+      forceDestroyValue();
+    }
+    maybeDestroyState();
+  }
+
+public:
+  /**
+   * Casts this `BorrowingReference<T>` to a `BorrowingReference<C>`.
+   */
+  template <typename C>
+  BorrowingReference<C> as() {
+    return BorrowingReference<C>(static_cast<C*>(_value), *this);
+  }
+
+public:
+  /**
+   * Get whether the `BorrowingReference<T>` is still pointing to a valid value, or not.
+   */
+  [[nodiscard]]
+  inline bool hasValue() const {
+    return _value != nullptr && !_state->isDeleted;
+  }
+
+  /**
+   * Get a borrowing (or "weak") reference to this owning reference
+   */
+  [[nodiscard]]
+  WeakReference<T> weak() const {
+    return WeakReference(*this);
+  }
+
+  /**
+   * Delete and destroy the value this BorrowingReference is pointing to.
+   * This can even be called if there are still multiple strong references to the value.
+   */
+  void destroy() {
+    std::unique_lock lock(_state->mutex);
+
+    forceDestroyValue();
+  }
+
+public:
+  // Dereference (*)
+  inline T& operator*() const {
+#ifdef NITRO_DEBUG
+    if (!hasValue()) [[unlikely]] {
+      std::string typeName = TypeInfo::getFriendlyTypename<T>(true);
+      throw std::runtime_error("Tried to dereference (*) nullptr BorrowingReference<" + typeName + ">!");
+    }
+#endif
+    return *_value;
+  }
+
+  // Dereference (->)
+  inline T* NON_NULL operator->() const {
+#ifdef NITRO_DEBUG
+    if (!hasValue()) [[unlikely]] {
+      std::string typeName = TypeInfo::getFriendlyTypename<T>(true);
+      throw std::runtime_error("Tried to dereference (->) nullptr BorrowingReference<" + typeName + ">!");
+    }
+#endif
+    return _value;
+  }
+
+  // null-check (bool)
+  explicit inline operator bool() const {
+    return hasValue();
+  }
+  // null-check (== nullptr)
+  inline bool operator==(std::nullptr_t) const {
+    return !hasValue();
+  }
+  // null-check (!= nullptr)
+  inline bool operator!=(std::nullptr_t) const {
+    return hasValue();
+  }
+
+  // comparison (== *)
+  inline bool operator==(T* NULLABLE other) const {
+    return _value == other;
+  }
+  // comparison (!= *)
+  inline bool operator!=(T* NULLABLE other) const {
+    return _value != other;
+  }
+
+  // comparison (== BorrowingReference<T>)
+  inline bool operator==(const BorrowingReference<T>& other) const {
+    return _value == other._value;
+  }
+  // comparison (!= BorrowingReference<T>)
+  inline bool operator!=(const BorrowingReference<T>& other) const {
+    return _value != other._value;
+  }
+
+private:
+  void maybeDestroyState() {
+    if (_state->strongRefCount == 0 && _state->weakRefCount == 0) {
+      // free the full memory if there are no more references at all
+      delete _state;
+      _state = nullptr;
+    }
+  }
+
+  void forceDestroyValue() {
+    if (_state->isDeleted) [[unlikely]] {
+      // it has already been destroyed.
+      return;
+    }
+    delete _value;
+    _value = nullptr;
+    _state->isDeleted = true;
+  }
+
+public:
+  friend class WeakReference<T>;
+
+private:
+  T* NULLABLE _value;
+  ReferenceState* NON_NULL _state;
+};
+
+} // namespace margelo::nitro
+
+#include "WeakReference+Owning.hpp"

package/harmony/quick_crypto/src/main/cpp/nitro/NitroModules/BoxedHybridObject.hpp

@@ -0,0 +1,36 @@
+//
+// Created by Marc Rousavy on 21.02.24.
+//
+
+#pragma once
+
+#include "HybridObject.hpp"
+#include <jsi/jsi.h>
+#include <memory>
+
+namespace margelo::nitro {
+
+using namespace facebook;
+
+/**
+ * Represents a `HybridObject` that has been boxed into a `jsi::HostObject`.
+ *
+ * While `HybridObject`s are runtime agnostic, some threading/worklet libraries do not support copying over objects
+ * with `jsi::NativeState` and a prototype chain (which is what a `HybridObject` is), so Nitro offers support for
+ * boxing those `HybridObject`s into a type that those libraries support - which is a `jsi::HostObject`.
+ *
+ * Simply call `unbox()` on this `jsi::HostObject` from the new Runtime/context to get the `HybridObject` again.
+ */
+class BoxedHybridObject final : public jsi::HostObject {
+public:
+  explicit BoxedHybridObject(const std::shared_ptr<HybridObject>& hybridObject) : _hybridObject(hybridObject) {}
+
+public:
+  jsi::Value get(jsi::Runtime& runtime, const jsi::PropNameID& propName) override;
+  std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime& runtime) override;
+
+private:
+  std::shared_ptr<HybridObject> _hybridObject;
+};
+
+} // namespace margelo::nitro

package/harmony/quick_crypto/src/main/cpp/nitro/NitroModules/CachedProp.hpp

@@ -0,0 +1,44 @@
+//
+// Created by Marc Rousavy on 30.07.24.
+//
+
+#pragma once
+
+#include "BorrowingReference.hpp"
+#include "JSIConverter.hpp"
+#include "NitroDefines.hpp"
+#include <jsi/jsi.h>
+
+namespace margelo::nitro {
+
+using namespace facebook;
+
+template <typename T>
+struct CachedProp {
+public:
+  T value;
+  BorrowingReference<jsi::Value> jsiValue;
+  bool isDirty = false;
+
+public:
+  bool equals(jsi::Runtime& runtime, const jsi::Value& other) const {
+    if (jsiValue == nullptr) {
+      return false;
+    }
+    return jsi::Value::strictEquals(runtime, *jsiValue, other);
+  }
+
+public:
+  static CachedProp<T> fromRawValue(jsi::Runtime& runtime, const jsi::Value& value, const CachedProp<T>& oldProp) {
+    if (oldProp.equals(runtime, value)) {
+      // jsi::Value hasn't changed - no need to convert it again!
+      return oldProp;
+    }
+    T converted = JSIConverter<T>::fromJSI(runtime, value);
+    JSICacheReference cache = JSICache::getOrCreateCache(runtime);
+    BorrowingReference<jsi::Value> cached = cache.makeShared(jsi::Value(runtime, value));
+    return CachedProp<T>(std::move(converted), std::move(cached), /* isDirty */ true);
+  }
+};
+
+} // namespace margelo::nitro

package/harmony/quick_crypto/src/main/cpp/nitro/NitroModules/CallInvokerDispatcher.hpp

@@ -0,0 +1,38 @@
+//
+// Created by Marc Rousavy on 27.03.24.
+//
+
+#pragma once
+
+#include "Dispatcher.hpp"
+
+// This is react-native specific
+#if __has_include(<ReactCommon/CallInvoker.h>)
+#include <ReactCommon/CallInvoker.h>
+
+namespace margelo::nitro {
+
+using namespace facebook;
+
+/**
+ * A Dispatcher that uses react::CallInvoker for it's implementation
+ */
+class CallInvokerDispatcher final : public Dispatcher {
+public:
+  explicit CallInvokerDispatcher(std::shared_ptr<react::CallInvoker> callInvoker) : _callInvoker(callInvoker) {}
+
+  void runAsync(std::function<void()>&& function) override {
+    _callInvoker->invokeAsync(std::move(function));
+  }
+
+  void runSync(std::function<void()>&& function) override {
+    _callInvoker->invokeSync(std::move(function));
+  }
+
+private:
+  std::shared_ptr<react::CallInvoker> _callInvoker;
+};
+
+} // namespace margelo::nitro
+
+#endif

package/harmony/quick_crypto/src/main/cpp/nitro/NitroModules/CountTrailingOptionals.hpp

@@ -0,0 +1,64 @@
+//
+//  CountTrailingOptionals.hpp
+//  NitroModules
+//
+//  Created by Marc Rousavy on 21.06.24.
+//
+
+#pragma once
+
+#include <optional>
+#include <type_traits>
+
+namespace margelo::nitro {
+
+// Helper template to check if a type is std::optional
+template <typename T>
+struct is_optional : std::false_type {};
+
+template <typename T>
+struct is_optional<std::optional<T>> : std::true_type {};
+
+// Helper template to count trailing optionals
+template <int N = 0, typename... Args>
+struct count_trailing_optionals;
+
+template <>
+struct count_trailing_optionals<> {
+  static constexpr int value = 0;
+};
+
+template <int N, typename Current, typename... Rest>
+struct count_trailing_optionals<N, Current, Rest...> {
+  static constexpr int count_trailing_optionals_impl() {
+    constexpr bool isOptional = is_optional<std::remove_cvref_t<Current>>::value;
+    if constexpr (sizeof...(Rest) == 0) {
+      // end of parameter pack!
+      if constexpr (isOptional) {
+        // last item is an optional, finally return the final number incremented by one.
+        return N + 1;
+      } else {
+        // last item is not an optional, so there are 0 trailing optionals.
+        return 0;
+      }
+    } else {
+      // recursively look into next T, either bump N by one or reset it to 0 if it's not an optional.
+      constexpr int newValue = isOptional ? N + 1 : 0;
+      return count_trailing_optionals<newValue, Rest...>::count_trailing_optionals_impl();
+    }
+  }
+
+  static constexpr int value = count_trailing_optionals_impl();
+};
+
+// Main template to count trailing optionals in Args... pack
+template <typename... Args>
+struct trailing_optionals_count {
+  static constexpr int value = count_trailing_optionals<0, Args...>::value;
+};
+
+// Helper alias
+template <typename... Args>
+constexpr int trailing_optionals_count_v = trailing_optionals_count<std::remove_cvref_t<Args>...>::value;
+
+} // namespace margelo::nitro

package/harmony/quick_crypto/src/main/cpp/nitro/NitroModules/Dispatcher.hpp

@@ -0,0 +1,83 @@
+//
+// Created by Marc Rousavy on 12.03.24.
+//
+
+#pragma once
+
+#include "NitroDefines.hpp"
+#include "Promise.hpp"
+#include <functional>
+#include <jsi/jsi.h>
+#include <queue>
+#include <unordered_map>
+
+namespace margelo::nitro {
+
+using namespace facebook;
+
+class Dispatcher : public jsi::NativeState {
+public:
+  /**
+   Installs the Dispatcher into the given Runtime.
+   It can be accessed using `getRuntimeGlobalDispatcher` later.
+   */
+  static void installRuntimeGlobalDispatcher(jsi::Runtime& runtime, std::shared_ptr<Dispatcher> dispatcher);
+  /**
+   Gets the global Dispatcher in the given Runtime, or throws an error if not found.
+  */
+  static std::shared_ptr<Dispatcher> getRuntimeGlobalDispatcher(jsi::Runtime& runtime);
+
+private:
+  static jsi::Value getRuntimeGlobalDispatcherHolder(jsi::Runtime& runtime);
+
+public:
+  /**
+   * Run the given void function synchronously on the Thread this Dispatcher is managing.
+   */
+  virtual void runSync(std::function<void()>&& function) = 0;
+
+  /**
+   * Run the given void function asynchronously on the Thread this Dispatcher is managing.
+   */
+  virtual void runAsync(std::function<void()>&& function) = 0;
+
+  /**
+   * Run the given function asynchronously on the Thread this Dispatcher is managing,
+   * and return a `Promise<T>` that will hold the result of the function.
+   */
+  template <typename T>
+  std::shared_ptr<Promise<T>> runAsyncAwaitable(std::function<T()>&& function) {
+    // 1. Create Promise that can be shared between this and dispatcher thread
+    auto promise = Promise<T>::create();
+
+    runAsync([function = std::move(function), promise]() {
+      try {
+        if constexpr (std::is_void_v<T>) {
+          // 4. Call the actual function on the new Thread
+          function();
+          // 5.a. Resolve the Promise if we succeeded
+          promise->resolve();
+        } else {
+          // 4. Call the actual function on the new Thread
+          T result = function();
+          // 5.a. Resolve the Promise if we succeeded
+          promise->resolve(std::move(result));
+        }
+      } catch (...) {
+        // 5.b. Reject the Promise if the call failed
+        promise->reject(std::current_exception());
+      }
+    });
+
+    // 3. Return an open `Promise<T>` that gets resolved later by the dispatcher Thread
+    return promise;
+  }
+
+private:
+  static std::unordered_map<jsi::Runtime * NON_NULL, std::weak_ptr<Dispatcher>> _globalCache;
+
+private:
+  static constexpr auto TAG = "Dispatcher";
+};
+
+} // namespace margelo::nitro

package/harmony/quick_crypto/src/main/cpp/nitro/NitroModules/FastVectorCopy.hpp

@@ -0,0 +1,45 @@
+//
+//  FastVectorCopy.hpp
+//  NitroModules
+//
+//  Created by Marc Rousavy on 22.09.25.
+//
+
+#pragma once
+
+#include "NitroDefines.hpp"
+#include <span>
+#include <type_traits>
+#include <vector>
+
+namespace margelo::nitro {
+
+/**
+ * Copies `data` into an `std::vector` as fast as possible.
+ *
+ * If the type is trivially copyable (aka if it does not have a copy constructor),
+ * the data will be bulk-memcopied.
+ */
+template <typename T>
+[[deprecated("FastVectorCopy is not safe for Swift - upgrade Nitro!")]]
+std::vector<T> FastVectorCopy(const T* CONTIGUOUS_MEMORY NON_NULL data, size_t size) {
+  assert(data != nullptr && "FastVectoryCopy: data cannot be null!");
+
+  if (size == 0) [[unlikely]] {
+    // It's an empty vector.
+    return std::vector<T>();
+  }
+
+  if constexpr (std::is_trivially_copyable_v<T>) {
+    // FAST: Type does not have a copy constructor - simply memcpy it
+    std::vector<T> vector(size);
+    std::memcpy(vector.data(), data, size * sizeof(T));
+    return vector;
+  } else {
+    // SLOW: Type needs to be iterated to copy-construct it
+    std::span<const T> span(data, size);
+    return std::vector<T>(span.begin(), span.end());
+  }
+}
+
+} // namespace margelo::nitro

package/harmony/quick_crypto/src/main/cpp/nitro/NitroModules/FutureType.hpp

@@ -0,0 +1,28 @@
+//
+//  FutureType.hpp
+//  NitroModules
+//
+//  Created by Marc Rousavy on 21.06.24.
+//
+
+#pragma once
+
+#include <future>
+#include <type_traits>
+
+namespace margelo::nitro {
+
+// Gets the `T` in `std::future<T>`.
+template <typename T>
+struct future_type {
+  using type = void;
+};
+template <typename T>
+struct future_type<std::future<T>> {
+  using type = T;
+};
+
+template <typename T>
+using future_type_v = typename future_type<std::remove_reference_t<T>>::type;
+
+} // namespace margelo::nitro