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

package/harmony/quick_crypto/src/main/cpp/nitro/NitroModules/JSIConverter+Variant.hpp

@@ -0,0 +1,67 @@
+//
+// Created by Marc Rousavy on 21.02.24.
+//
+
+#pragma once
+
+// Forward declare a few of the common types that might have cyclic includes.
+namespace margelo::nitro {
+struct AnyValue;
+class AnyMap;
+
+template <typename T, typename Enable>
+struct JSIConverter;
+} // namespace margelo::nitro
+
+#include "JSIConverter+UnorderedMap.hpp"
+#include "JSIConverter+Vector.hpp"
+#include "JSIConverter.hpp"
+
+#include "AnyMap.hpp"
+#include "NitroTypeInfo.hpp"
+#include <jsi/jsi.h>
+#include <memory>
+#include <variant>
+
+namespace margelo::nitro {
+
+using namespace facebook;
+
+// std::variant<A, B, C> <> A | B | C
+template <typename... Types>
+struct JSIConverter<std::variant<Types...>> final {
+  static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+    // Check each type in `Types...` to make sure we can convert `jsi::Value` to one of those.
+    return (JSIConverter<Types>::canConvert(runtime, value) || ...);
+  }
+
+  static inline std::variant<Types...> fromJSI(jsi::Runtime& runtime, const jsi::Value& value) {
+    return fromJSIRecursive<Types...>(runtime, value);
+  }
+
+  static inline jsi::Value toJSI(jsi::Runtime& runtime, const std::variant<Types...>& variant) {
+    return std::visit(
+        [&runtime](const auto& val) {
+          // Try to convert each type
+          return JSIConverter<std::decay_t<decltype(val)>>::toJSI(runtime, val);
+        },
+        variant);
+  }
+
+private:
+  template <typename First, typename... Rest>
+  static inline std::variant<Types...> fromJSIRecursive(jsi::Runtime& runtime, const jsi::Value& value) {
+    if (JSIConverter<First>::canConvert(runtime, value)) {
+      return JSIConverter<First>::fromJSI(runtime, value);
+    }
+    if constexpr (sizeof...(Rest) == 0) {
+      std::string string = value.toString(runtime).utf8(runtime);
+      std::string types = TypeInfo::getFriendlyTypenames<Types...>();
+      throw std::runtime_error("Cannot convert \"" + string + "\" to any type in variant<" + types + ">!");
+    } else {
+      return fromJSIRecursive<Rest...>(runtime, value);
+    }
+  }
+};
+
+} // namespace margelo::nitro

package/harmony/quick_crypto/src/main/cpp/nitro/NitroModules/JSIConverter+Vector.hpp

@@ -0,0 +1,69 @@
+//
+// Created by Marc Rousavy on 21.02.24.
+//
+
+#pragma once
+
+// Forward declare a few of the common types that might have cyclic includes.
+namespace margelo::nitro {
+template <typename T, typename Enable>
+struct JSIConverter;
+} // namespace margelo::nitro
+
+#include "JSIConverter.hpp"
+
+#include "AnyMap.hpp"
+#include <jsi/jsi.h>
+#include <vector>
+
+namespace margelo::nitro {
+
+using namespace facebook;
+
+// std::vector<T> <> T[]
+template <typename ElementType>
+struct JSIConverter<std::vector<ElementType>> final {
+  static inline std::vector<ElementType> fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+    jsi::Array array = arg.asObject(runtime).asArray(runtime);
+    size_t length = array.size(runtime);
+
+    std::vector<ElementType> vector;
+    vector.reserve(length);
+    for (size_t i = 0; i < length; ++i) {
+      jsi::Value elementValue = array.getValueAtIndex(runtime, i);
+      vector.emplace_back(JSIConverter<ElementType>::fromJSI(runtime, elementValue));
+    }
+    return vector;
+  }
+  static inline jsi::Value toJSI(jsi::Runtime& runtime, const std::vector<ElementType>& vector) {
+    jsi::Array array(runtime, vector.size());
+    for (size_t i = 0; i < vector.size(); i++) {
+      jsi::Value value = JSIConverter<ElementType>::toJSI(runtime, vector[i]);
+      array.setValueAtIndex(runtime, i, std::move(value));
+    }
+    return array;
+  }
+
+  static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+    if (!value.isObject()) {
+      return false;
+    }
+    jsi::Object object = value.getObject(runtime);
+    if (!object.isArray(runtime)) {
+      return false;
+    }
+    jsi::Array array = object.getArray(runtime);
+    if (array.size(runtime) == 0) {
+      // it is an empty array, so it _theoretically_ doesn't matter what type it holds. Just say true.
+      return true;
+    }
+    // Check the type of the first element in the array.
+    // Technically the array can also have different types for each item,
+    // and to be absolutely sure that we can convert the entire array, we have to check each item in the array.
+    // But we don't want to do that for performance reasons - let's just assume the user doesn't make this mistake.
+    jsi::Value firstElement = array.getValueAtIndex(runtime, 0);
+    return JSIConverter<ElementType>::canConvert(runtime, firstElement);
+  }
+};
+
+} // namespace margelo::nitro

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

@@ -0,0 +1,197 @@
+//
+// Created by Marc Rousavy on 21.02.24.
+//
+
+#pragma once
+
+// Forward declare a few of the common types that might have cyclic includes.
+namespace margelo::nitro {
+template <typename T, typename Enable>
+struct JSIConverter;
+} // namespace margelo::nitro
+
+#include <jsi/jsi.h>
+#include <type_traits>
+#include <variant>
+
+namespace margelo::nitro {
+
+using namespace facebook;
+
+/**
+ * The JSIConverter<T> class can convert any type from and to a jsi::Value.
+ * It uses templates to statically create fromJSI/toJSI methods, and will throw compile-time errors
+ * if a given type is not convertable.
+ * Value types, custom types (HybridObject), and even functions with any number of arguments/types are supported.
+ * This type can be extended by just creating a new template for JSIConverter in a header.
+ */
+template <typename T, typename Enable = void>
+struct JSIConverter final {
+  JSIConverter() = delete;
+
+  /**
+   * Converts the given `jsi::Value` to type `T`.
+   * By default, this static-asserts.
+   */
+  static inline T fromJSI(jsi::Runtime&, const jsi::Value&) {
+    static_assert(always_false<T>::value, "This type is not supported by the JSIConverter!");
+    return T();
+  }
+  /**
+   * Converts `T` to a `jsi::Value`.
+   * By default, this static-asserts.
+   */
+  static inline jsi::Value toJSI(jsi::Runtime&, T) {
+    static_assert(always_false<T>::value, "This type is not supported by the JSIConverter!");
+    return jsi::Value::undefined();
+  }
+  /**
+   * Returns whether the given `jsi::Value` can be converted to `T`.
+   * This involves runtime type-checks.
+   * By default, this returns `false`.
+   */
+  static inline bool canConvert(jsi::Runtime&, const jsi::Value&) {
+    return false;
+  }
+
+private:
+  template <typename>
+  struct always_false : std::false_type {};
+};
+
+// int <> number
+template <>
+struct JSIConverter<int> final {
+  static inline int fromJSI(jsi::Runtime&, const jsi::Value& arg) {
+    return static_cast<int>(arg.asNumber());
+  }
+  static inline jsi::Value toJSI(jsi::Runtime&, int arg) {
+    return jsi::Value(arg);
+  }
+  static inline bool canConvert(jsi::Runtime&, const jsi::Value& value) {
+    return value.isNumber();
+  }
+};
+
+// double <> number
+template <>
+struct JSIConverter<double> final {
+  static inline double fromJSI(jsi::Runtime&, const jsi::Value& arg) {
+    return arg.asNumber();
+  }
+  static inline jsi::Value toJSI(jsi::Runtime&, double arg) {
+    return jsi::Value(arg);
+  }
+  static inline bool canConvert(jsi::Runtime&, const jsi::Value& value) {
+    return value.isNumber();
+  }
+};
+
+// float <> number
+template <>
+struct JSIConverter<float> final {
+  static inline float fromJSI(jsi::Runtime&, const jsi::Value& arg) {
+    return static_cast<float>(arg.asNumber());
+  }
+  static inline jsi::Value toJSI(jsi::Runtime&, float arg) {
+    return jsi::Value(static_cast<double>(arg));
+  }
+  static inline bool canConvert(jsi::Runtime&, const jsi::Value& value) {
+    return value.isNumber();
+  }
+};
+
+// int64_t <> BigInt
+template <>
+struct JSIConverter<int64_t> final {
+  static inline double fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+    return arg.asBigInt(runtime).asInt64(runtime);
+  }
+  static inline jsi::Value toJSI(jsi::Runtime& runtime, int64_t arg) {
+    return jsi::BigInt::fromInt64(runtime, arg);
+  }
+  static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+    if (value.isBigInt()) {
+      jsi::BigInt bigint = value.getBigInt(runtime);
+      return bigint.isInt64(runtime);
+    }
+    return false;
+  }
+};
+
+// uint64_t <> BigInt
+template <>
+struct JSIConverter<uint64_t> final {
+  static inline double fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+    return arg.asBigInt(runtime).asUint64(runtime);
+  }
+  static inline jsi::Value toJSI(jsi::Runtime& runtime, uint64_t arg) {
+    return jsi::BigInt::fromUint64(runtime, arg);
+  }
+  static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+    if (value.isBigInt()) {
+      jsi::BigInt bigint = value.getBigInt(runtime);
+      return bigint.isUint64(runtime);
+    }
+    return false;
+  }
+};
+
+// bool <> boolean
+template <>
+struct JSIConverter<bool> final {
+  static inline bool fromJSI(jsi::Runtime&, const jsi::Value& arg) {
+    return arg.asBool();
+  }
+  static inline jsi::Value toJSI(jsi::Runtime&, bool arg) {
+    return jsi::Value(arg);
+  }
+  static inline bool canConvert(jsi::Runtime&, const jsi::Value& value) {
+    return value.isBool();
+  }
+};
+
+// std::string <> string
+template <>
+struct JSIConverter<std::string> final {
+  static inline std::string fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+    return arg.asString(runtime).utf8(runtime);
+  }
+  static inline jsi::Value toJSI(jsi::Runtime& runtime, const std::string& arg) {
+    return jsi::String::createFromUtf8(runtime, arg);
+  }
+  static inline bool canConvert(jsi::Runtime&, const jsi::Value& value) {
+    return value.isString();
+  }
+};
+
+// std::monostate <> void/undefined
+template <>
+struct JSIConverter<std::monostate> final {
+  static inline std::monostate fromJSI(jsi::Runtime&, const jsi::Value&) {
+    return std::monostate{};
+  }
+  static inline jsi::Value toJSI(jsi::Runtime&, std::monostate) {
+    return jsi::Value();
+  }
+  static inline bool canConvert(jsi::Runtime&, const jsi::Value&) {
+    return true;
+  }
+};
+
+} // namespace margelo::nitro
+
+#include "JSIConverter+AnyMap.hpp"
+#include "JSIConverter+ArrayBuffer.hpp"
+#include "JSIConverter+Date.hpp"
+#include "JSIConverter+Exception.hpp"
+#include "JSIConverter+Function.hpp"
+#include "JSIConverter+HostObject.hpp"
+#include "JSIConverter+NativeState.hpp"
+#include "JSIConverter+Null.hpp"
+#include "JSIConverter+Optional.hpp"
+#include "JSIConverter+Promise.hpp"
+#include "JSIConverter+Tuple.hpp"
+#include "JSIConverter+UnorderedMap.hpp"
+#include "JSIConverter+Variant.hpp"
+#include "JSIConverter+Vector.hpp"

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

@@ -0,0 +1,52 @@
+//
+//  JSIHelpers.hpp
+//  Nitro
+//
+//  Created by Marc Rousavy on 07.08.24.
+//
+
+#pragma once
+
+#include "ThreadUtils.hpp"
+#include <jsi/jsi.h>
+
+namespace margelo::nitro {
+
+using namespace facebook;
+
+/**
+ * Returns whether the given `jsi::Object` is a plain-JS object, or not.
+ * If it is not a plain-JS object, it could be an Array, ArrayBuffer, Function,
+ * HostObject or NativeState.
+ */
+static inline bool isPlainObject(jsi::Runtime& runtime, const jsi::Object& object) {
+  if (object.isArray(runtime)) {
+    return false;
+  }
+  if (object.isArrayBuffer(runtime)) {
+    return false;
+  }
+  if (object.isFunction(runtime)) {
+    return false;
+  }
+  if (object.isHostObject(runtime)) {
+    return false;
+  }
+  if (object.hasNativeState(runtime)) {
+    return false;
+  }
+  return true;
+}
+
+/**
+ * Get an ID for the given Runtime.
+ *
+ * The ID usually consists of a Runtime description (e.g. "HermesRuntime"),
+ * and it's Thread (e.g. "com.facebook.react.runtime.JavaScript")
+ */
+static inline std::string getRuntimeId(jsi::Runtime& runtime) {
+  std::string threadName = ThreadUtils::getThreadName();
+  return runtime.description() + " (" + threadName + ")";
+}
+
+} // namespace margelo::nitro

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

@@ -0,0 +1,73 @@
+//
+//  NitroDefines.hpp
+//  Nitro
+//
+//  Created by Marc Rousavy on 29.07.24.
+//
+
+#ifndef NitroDefines_h
+#define NitroDefines_h
+
+// Sets the version of the native Nitro core library
+#define NITRO_VERSION "0.31.11-rc.4"
+
+// Sets whether to use debug or optimized production build flags
+#ifdef DEBUG
+#define NITRO_DEBUG
+#endif
+#ifdef NDEBUG
+#undef NITRO_DEBUG
+#endif
+#ifdef ANDROID
+#ifndef NDEBUG
+#define NITRO_DEBUG
+#endif
+#endif
+
+// Helper to find out if a C++ compiler attribute is available
+#ifdef __has_attribute
+#define _CXX_INTEROP_HAS_ATTRIBUTE(x) __has_attribute(x)
+#else
+#define _CXX_INTEROP_HAS_ATTRIBUTE(x) 0
+#endif
+
+// Closed/Final Enums
+#if _CXX_INTEROP_HAS_ATTRIBUTE(enum_extensibility)
+// Enum is marked as closed/not extensible
+#define CLOSED_ENUM __attribute__((enum_extensibility(closed)))
+#else
+#define CLOSED_ENUM
+#endif
+
+// Nullability
+#if defined(__clang__)
+#define NON_NULL _Nonnull
+#define NULLABLE _Nullable
+#else
+#define NON_NULL
+#define NULLABLE
+#endif
+
+// Contiguous memory in pointers (__restrict)
+#if defined(__clang__)
+#define CONTIGUOUS_MEMORY __restrict__
+#elif defined(_MSC_VER)
+#define CONTIGUOUS_MEMORY __restrict
+#else
+#define CONTIGUOUS_MEMORY
+#endif
+
+// Swift Support
+#if __has_include(<swift/bridging>)
+// Swift's bridging header defines those things
+#include <swift/bridging>
+#define SWIFT_PRIVATE __attribute__((swift_private))
+#else
+// If we don't have Swift bridging header, those macros do nothing
+#define SWIFT_NAME(_name)
+#define SWIFT_PRIVATE
+#define SWIFT_COMPUTED_PROPERTY
+#define SWIFT_NONCOPYABLE
+#endif
+
+#endif /* NitroDefines_h */

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

@@ -0,0 +1,61 @@
+//
+//  NitroHash.hpp
+//  react-native-nitro
+//
+//  Created by Marc Rousavy on 14.07.24.
+//
+
+#pragma once
+
+#include "NitroDefines.hpp"
+#include <cstddef>
+#include <cstdint>
+#include <string>
+
+namespace margelo::nitro {
+
+/**
+ * Hashes the given C-String using the FNV-1a hashing algorithm.
+ *
+ * This function can be used at compile time as a constexpr to build
+ * statically optimized switch statements.
+ */
+constexpr uint64_t hashString(const char* NON_NULL str, size_t length) {
+  uint64_t hash = 14695981039346656037ull; // FNV offset basis
+  const uint64_t fnv_prime = 1099511628211ull;
+
+  for (size_t i = 0; i < length; ++i) {
+    hash ^= static_cast<uint64_t>(str[i]);
+    hash *= fnv_prime;
+  }
+
+  return hash;
+}
+
+/**
+ * Hashes the given constant C-String using the FNV-1a hashing algorithm.
+ *
+ * String length is known at compile time.
+ */
+template <size_t N>
+constexpr uint64_t hashString(const char (&str)[N]) {
+  return hashString(str, N - 1); // N includes the null terminator, so subtract 1
+}
+
+/**
+ * Hashes the given `string_view` using the FNV-1a hashing algorithm.
+ * This can be constexpr.
+ */
+constexpr uint64_t hashString(const std::string_view& string) {
+  return hashString(string.data(), string.length());
+}
+
+/**
+ * Hashes the given `string` using the FNV-1a hashing algorithm.
+ * This happens at runtime.
+ */
+inline uint64_t hashString(const std::string& string) {
+  return hashString(string.c_str(), string.length());
+}
+
+} // namespace margelo::nitro

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

@@ -0,0 +1,69 @@
+//
+// Created by Marc Rousavy on 05.03.24.
+//
+
+#pragma once
+
+#include "NitroDefines.hpp"
+#include <cstdarg>
+#include <cstdio>
+#include <iostream>
+#include <sstream>
+#include <string>
+#include <type_traits>
+
+namespace margelo::nitro {
+
+enum class LogLevel { Debug, Info, Warning, Error };
+
+class Logger final {
+private:
+  Logger() = delete;
+
+public:
+  template <typename... Args>
+  static void log([[maybe_unused]] LogLevel level, [[maybe_unused]] const char* NON_NULL tag, [[maybe_unused]] const char* NON_NULL format,
+                  [[maybe_unused]] Args... args) {
+#ifdef NITRO_DEBUG
+    // 1. Make sure args can be passed to sprintf(..)
+    static_assert(all_are_trivially_copyable<Args...>(), "All arguments passed to Logger::log(..) must be trivially copyable! "
+                                                         "Did you try to pass a complex type, like std::string?");
+
+    // 2. Format all arguments in the message
+    std::string message = formatString(format, args...);
+
+    // 3. Call the platform specific log function
+    nativeLog(level, tag, message);
+#endif
+  }
+
+  static void nativeLog(LogLevel level, const char* NON_NULL tag, const std::string& string);
+
+private:
+  template <typename... Args>
+  static std::string formatString(const char* NON_NULL format, Args... args) {
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wformat-security"
+    int size = snprintf(nullptr, 0, format, args...) + 1; // Extra space for '\0'
+    if (size <= 0) {
+      return "Error during formatting.";
+    }
+    std::unique_ptr<char[]> buf(new char[size]);
+    snprintf(buf.get(), size, format, args...);
+    return std::string(buf.get(), buf.get() + size - 1); // We don't want the '\0' inside
+#pragma clang diagnostic pop
+  }
+
+  // Overloaded functions to convert std::string to C-style string
+  template <typename T>
+  static constexpr bool is_trivially_copyable() {
+    return std::is_trivially_copyable<T>::value;
+  }
+
+  template <typename... Args>
+  static constexpr bool all_are_trivially_copyable() {
+    return (is_trivially_copyable<Args>() && ...);
+  }
+};
+
+} // namespace margelo::nitro

package/harmony/quick_crypto/src/main/cpp/nitro/NitroModules/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/NitroModules/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