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

package/harmony/quick_crypto/src/main/cpp/nitro/shared/NitroTypeInfo.hpp

@@ -0,0 +1,66 @@
+//
+//  NitroTypeInfo.hpp
+//  Nitro
+//
+//  Created by Marc Rousavy on 17.07.24.
+//
+
+#pragma once
+
+#include "NitroDefines.hpp"
+#include <regex>
+#include <sstream>
+#include <string>
+#include <type_traits>
+#include <typeindex>
+
+namespace margelo::nitro {
+
+struct TypeInfo final {
+public:
+  TypeInfo() = delete;
+
+  /**
+   * Get the name of the currently thrown exception
+   */
+  static std::string getCurrentExceptionName();
+
+  /**
+   * Get a friendly name of the given `type_info` (if possible, demangled)
+   */
+  static inline std::string getFriendlyTypename(const std::type_info& type, bool removeNamespace = false) {
+    std::string typeName = type.name();
+    return demangleName(typeName, removeNamespace);
+  }
+
+  /**
+   * Get a friendly name of the given `type_index` (if possible, demangled)
+   */
+  static inline std::string getFriendlyTypename(const std::type_index& typeIndex, bool removeNamespace = false) {
+    std::string typeName = typeIndex.name();
+    return demangleName(typeName, removeNamespace);
+  }
+
+  /**
+   * Get a friendly name of the type `T` (if possible, demangled)
+   */
+  template <typename T>
+  static inline std::string getFriendlyTypename(bool removeNamespace = false) {
+    return getFriendlyTypename(typeid(T), removeNamespace);
+  }
+
+  template <typename... Types>
+  static inline std::string getFriendlyTypenames(bool removeNamespace = false) {
+    std::ostringstream stream;
+    ((stream << TypeInfo::getFriendlyTypename<Types>(removeNamespace) << ", "), ...);
+    std::string string = stream.str();
+    return string.substr(0, string.length() - 2);
+  }
+
+private:
+  static std::string replaceRegex(const std::string& original, const std::string& pattern, const std::string& replacement);
+
+  static std::string demangleName(const std::string& typeName, bool removeNamespace = false);
+};
+
+} // namespace margelo::nitro

package/harmony/quick_crypto/src/main/cpp/nitro/shared/Null.hpp

@@ -0,0 +1,42 @@
+//
+// Created by Marc Rousavy on 30.07.24.
+//
+
+#pragma once
+
+#include "NitroDefines.hpp"
+#include <functional>
+#include <type_traits>
+
+namespace margelo::nitro {
+
+/**
+ * Represents the type of `null` - which should always be a singleton.
+ */
+enum class NullType { null };
+
+/**
+ * Represents an explicit `null` from JS.
+ * This is a singleton.
+ */
+inline constexpr NullType null = NullType::null;
+
+// Equality and ordering: all instances are equal
+constexpr bool operator==(NullType, NullType) noexcept {
+  return true;
+}
+constexpr bool operator!=(NullType, NullType) noexcept {
+  return false;
+}
+
+} // namespace margelo::nitro
+
+// Makes nitro::Null hashable
+namespace std {
+template <>
+struct hash<margelo::nitro::NullType> {
+  size_t operator()(margelo::nitro::NullType) const noexcept {
+    return 0;
+  }
+};
+} // namespace std

package/harmony/quick_crypto/src/main/cpp/nitro/shared/ObjectUtils.cpp

@@ -0,0 +1,172 @@
+//
+//  ObjectUtils.cpp
+//  react-native-nitro
+//
+//  Created by Marc Rousavy on 17.10.25.
+//
+
+#include "ObjectUtils.hpp"
+#include "JSICache.hpp"
+#include "JSIHelpers.hpp"
+#include "NitroDefines.hpp"
+
+#if __has_include(<React-cxxreact/cxxreact/ReactNativeVersion.h>)
+#include <React-cxxreact/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*, ObjectUtils::FunctionCache> ObjectUtils::_cache;
+
+const char* ObjectUtils::getKnownGlobalPropertyNameString(KnownGlobalPropertyName name) {
+  switch (name) {
+    case KnownGlobalPropertyName::DISPATCHER:
+      return "__nitroDispatcher";
+    case KnownGlobalPropertyName::JSI_CACHE:
+      return "__nitroJsiCache";
+    case KnownGlobalPropertyName::NITRO_MODULES_PROXY:
+      return "NitroModulesProxy";
+  }
+}
+
+jsi::Object ObjectUtils::create(jsi::Runtime& runtime, const jsi::Value& prototype, bool allowCache) {
+#ifdef ENABLE_NATIVE_OBJECT_CREATE
+  return jsi::Object::create(runtime, prototype);
+#else
+  BorrowingReference<jsi::Function> createFn = getGlobalFunction(
+      runtime, "Object.create",
+      [](jsi::Runtime& runtime) {
+        return runtime.global().getPropertyAsObject(runtime, "Object").getPropertyAsFunction(runtime, "create");
+      },
+      allowCache);
+  return createFn->call(runtime, prototype).getObject(runtime);
+#endif
+}
+
+void ObjectUtils::defineGlobal(jsi::Runtime& runtime, KnownGlobalPropertyName name, jsi::Value&& value, bool allowCache) {
+  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?");
+  }
+  defineProperty(runtime, runtime.global(), nameString,
+                 PlainPropertyDescriptor{.configurable = false, .enumerable = true, .value = std::move(value), .writable = false},
+                 allowCache);
+#else
+  // In release, just set the property.
+  runtime.global().setProperty(runtime, nameString, std::move(value));
+#endif
+}
+
+void ObjectUtils::defineProperty(jsi::Runtime& runtime, const jsi::Object& object, const char* propertyName,
+                                 PlainPropertyDescriptor&& descriptor, bool allowCache) {
+  BorrowingReference<jsi::Function> definePropertyFn = getGlobalFunction(
+      runtime, "Object.defineProperty",
+      [](jsi::Runtime& runtime) {
+        return runtime.global().getPropertyAsObject(runtime, "Object").getPropertyAsFunction(runtime, "defineProperty");
+      },
+      allowCache);
+
+  jsi::String nameJs = jsi::String::createFromAscii(runtime, propertyName);
+
+  jsi::Object descriptorJs(runtime);
+  descriptorJs.setProperty(runtime, "configurable", jsi::Value(descriptor.configurable));
+  descriptorJs.setProperty(runtime, "enumerable", jsi::Value(descriptor.enumerable));
+  descriptorJs.setProperty(runtime, "value", std::move(descriptor.value));
+  descriptorJs.setProperty(runtime, "writable", jsi::Value(descriptor.writable));
+
+  definePropertyFn->call(runtime, object, std::move(nameJs), std::move(descriptorJs));
+}
+
+void ObjectUtils::defineProperty(jsi::Runtime& runtime, const jsi::Object& object, const char* propertyName,
+                                 ComputedReadonlyPropertyDescriptor&& descriptor, bool allowCache) {
+  BorrowingReference<jsi::Function> definePropertyFn = getGlobalFunction(
+      runtime, "Object.defineProperty",
+      [](jsi::Runtime& runtime) {
+        return runtime.global().getPropertyAsObject(runtime, "Object").getPropertyAsFunction(runtime, "defineProperty");
+      },
+      allowCache);
+
+  jsi::String nameJs = jsi::String::createFromAscii(runtime, propertyName);
+
+  jsi::Object descriptorJs(runtime);
+  descriptorJs.setProperty(runtime, "configurable", jsi::Value(descriptor.configurable));
+  descriptorJs.setProperty(runtime, "enumerable", jsi::Value(descriptor.enumerable));
+  descriptorJs.setProperty(runtime, "get", std::move(descriptor.get));
+
+  definePropertyFn->call(runtime, object, std::move(nameJs), std::move(descriptorJs));
+}
+
+void ObjectUtils::defineProperty(jsi::Runtime& runtime, const jsi::Object& object, const char* propertyName,
+                                 ComputedPropertyDescriptor&& descriptor, bool allowCache) {
+  BorrowingReference<jsi::Function> definePropertyFn = getGlobalFunction(
+      runtime, "Object.defineProperty",
+      [](jsi::Runtime& runtime) {
+        return runtime.global().getPropertyAsObject(runtime, "Object").getPropertyAsFunction(runtime, "defineProperty");
+      },
+      allowCache);
+
+  jsi::String nameJs = jsi::String::createFromAscii(runtime, propertyName);
+
+  jsi::Object descriptorJs(runtime);
+  descriptorJs.setProperty(runtime, "configurable", jsi::Value(descriptor.configurable));
+  descriptorJs.setProperty(runtime, "enumerable", jsi::Value(descriptor.enumerable));
+  descriptorJs.setProperty(runtime, "get", std::move(descriptor.get));
+  descriptorJs.setProperty(runtime, "set", std::move(descriptor.set));
+
+  definePropertyFn->call(runtime, object, std::move(nameJs), std::move(descriptorJs));
+}
+
+void ObjectUtils::freeze(jsi::Runtime& runtime, const jsi::Object& object, bool allowCache) {
+  BorrowingReference<jsi::Function> freezeFn = getGlobalFunction(
+      runtime, "Object.freeze",
+      [](jsi::Runtime& runtime) {
+        return runtime.global().getPropertyAsObject(runtime, "Object").getPropertyAsFunction(runtime, "freeze");
+      },
+      allowCache);
+
+  freezeFn->call(runtime, object);
+}
+
+BorrowingReference<jsi::Function> ObjectUtils::getGlobalFunction(jsi::Runtime& runtime, const char* key,
+                                                                 std::function<jsi::Function(jsi::Runtime&)> getFunction, bool allowCache) {
+  if (allowCache) [[likely]] {
+    // 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);
+  if (allowCache) [[likely]] {
+    // Let's throw it in cache!
+    FunctionCache& functionCache = _cache[&runtime];
+    JSICacheReference jsiCache = JSICache::getOrCreateCache(runtime);
+    BorrowingReference<jsi::Function> sharedFunction = jsiCache.makeShared(std::move(function));
+    functionCache[std::string(key)] = sharedFunction;
+    return sharedFunction;
+  } else {
+    // We are not allowed to use cache - so let's just wrap it in a BorrowingReference to match the return type.
+    jsi::Function* heapFunction = new jsi::Function(std::move(function));
+    return BorrowingReference<jsi::Function>(heapFunction);
+  }
+}
+
+} // namespace margelo::nitro

package/harmony/quick_crypto/src/main/cpp/nitro/shared/ObjectUtils.hpp

@@ -0,0 +1,94 @@
+//
+//  ObjectUtils.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 ObjectUtils {
+public:
+  ObjectUtils() = delete;
+  ~ObjectUtils() = delete;
+
+public:
+  /**
+   * 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, bool allowCache = true);
+
+  /**
+   * 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, bool allowCache = true);
+
+  /**
+   * 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, bool allowCache = true);
+  /**
+   * 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, bool allowCache = true);
+  /**
+   * 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, bool allowCache = true);
+
+  /**
+   * Freezes all values of the given `object`.
+   */
+  static void freeze(jsi::Runtime& runtime, const jsi::Object& object, bool allowCache = true);
+
+  /**
+   * Get a string name for a known global property name.
+   */
+  static const char* getKnownGlobalPropertyNameString(KnownGlobalPropertyName name);
+
+private:
+  using FunctionCache = std::unordered_map<std::string, BorrowingReference<jsi::Function>>;
+  static std::unordered_map<jsi::Runtime*, FunctionCache> _cache;
+
+  static BorrowingReference<jsi::Function> getGlobalFunction(jsi::Runtime& runtime, const char* key,
+                                                             std::function<jsi::Function(jsi::Runtime&)> getFunction,
+                                                             bool allowCache = true);
+};
+
+} // namespace margelo::nitro

package/harmony/quick_crypto/src/main/cpp/nitro/shared/Promise.cpp

@@ -0,0 +1,136 @@
+//
+//  Promise.cpp
+//  NitroModules
+//
+//  Created by Marc Rousavy on 18.11.24.
+//
+
+#include "Promise.hpp"
+
+namespace margelo::nitro {
+
+Promise<void>::~Promise() {
+  if (isPending()) [[unlikely]] {
+    std::runtime_error error("Timeouted: Promise<void> was destroyed!");
+    reject(std::make_exception_ptr(error));
+  }
+}
+
+std::shared_ptr<Promise<void>> Promise<void>::create() {
+  return std::shared_ptr<Promise<void>>(new Promise());
+}
+
+std::shared_ptr<Promise<void>> Promise<void>::async(std::function<void()>&& run) {
+  auto promise = create();
+  ThreadPool::shared().run([run = std::move(run), promise]() {
+    try {
+      // Run the code, then resolve.
+      run();
+      promise->resolve();
+    } catch (...) {
+      // It threw an error.
+      promise->reject(std::current_exception());
+    }
+  });
+  return promise;
+}
+
+std::shared_ptr<Promise<void>> Promise<void>::awaitFuture(std::future<void>&& future) {
+  auto sharedFuture = std::make_shared<std::future<void>>(std::move(future));
+  return async([sharedFuture = std::move(sharedFuture)]() { sharedFuture->get(); });
+}
+
+std::shared_ptr<Promise<void>> Promise<void>::resolved() {
+  auto promise = create();
+  promise->resolve();
+  return promise;
+}
+std::shared_ptr<Promise<void>> Promise<void>::rejected(const std::exception_ptr& error) {
+  auto promise = create();
+  promise->reject(error);
+  return promise;
+}
+
+void Promise<void>::resolve() {
+  std::unique_lock lock(_mutex);
+#ifdef NITRO_DEBUG
+  assertPromiseState(*this, PromiseTask::WANTS_TO_RESOLVE);
+#endif
+  _isResolved = true;
+  for (const auto& onResolved : _onResolvedListeners) {
+    onResolved();
+  }
+  didFinish();
+}
+
+void Promise<void>::reject(const std::exception_ptr& exception) {
+  if (exception == nullptr) [[unlikely]] {
+    throw std::runtime_error("Cannot reject Promise<void> with a null exception_ptr!");
+  }
+
+  std::unique_lock lock(_mutex);
+#ifdef NITRO_DEBUG
+  assertPromiseState(*this, PromiseTask::WANTS_TO_REJECT);
+#endif
+  _error = exception;
+  for (const auto& onRejected : _onRejectedListeners) {
+    onRejected(exception);
+  }
+  didFinish();
+}
+
+void Promise<void>::addOnResolvedListener(OnResolvedFunc&& onResolved) {
+  std::unique_lock lock(_mutex);
+  if (_isResolved) {
+    onResolved();
+  } else {
+    _onResolvedListeners.push_back(std::move(onResolved));
+  }
+}
+void Promise<void>::addOnResolvedListener(const OnResolvedFunc& onResolved) {
+  std::unique_lock lock(_mutex);
+  if (_isResolved) {
+    onResolved();
+  } else {
+    _onResolvedListeners.push_back(onResolved);
+  }
+}
+void Promise<void>::addOnRejectedListener(OnRejectedFunc&& onRejected) {
+  std::unique_lock lock(_mutex);
+  if (_error) {
+    onRejected(_error);
+  } else {
+    // Promise is not yet rejected, put the listener in our queue.
+    _onRejectedListeners.push_back(std::move(onRejected));
+  }
+}
+void Promise<void>::addOnRejectedListener(const OnRejectedFunc& onRejected) {
+  std::unique_lock lock(_mutex);
+  if (_error) {
+    onRejected(_error);
+  } else {
+    // Promise is not yet rejected, put the listener in our queue.
+    _onRejectedListeners.push_back(onRejected);
+  }
+}
+
+std::future<void> Promise<void>::await() {
+  auto promise = std::make_shared<std::promise<void>>();
+  addOnResolvedListener([promise]() { promise->set_value(); });
+  addOnRejectedListener([promise](const std::exception_ptr& error) { promise->set_exception(error); });
+  return promise->get_future();
+}
+
+const std::exception_ptr& Promise<void>::getError() {
+  if (!isRejected()) {
+    throw std::runtime_error("Cannot get error when Promise<void> is not yet rejected!");
+  }
+  return _error;
+}
+
+void Promise<void>::didFinish() noexcept {
+  _onResolvedListeners.clear();
+  _onRejectedListeners.clear();
+}
+
+} // namespace margelo::nitro