react-native-mmkv 2.12.2 → 3.0.0-beta.1

package/cpp/TypedArray.cpp

@@ -1,322 +0,0 @@
-//
-//  TypedArray.cpp
-//  react-native-mmkv
-//
-//  Created by Marc Rousavy on 11.10.2022.
-//  Originally created by Expo (expo-gl)
-//
-
-#include "TypedArray.h"
-
-#include <algorithm>
-#include <memory>
-#include <string>
-#include <unordered_map>
-#include <utility>
-#include <vector>
-
-template <TypedArrayKind T> using ContentType = typename typedArrayTypeMap<T>::type;
-
-enum class Prop {
-  Buffer,            // "buffer"
-  Constructor,       // "constructor"
-  Name,              // "name"
-  Proto,             // "__proto__"
-  Length,            // "length"
-  ByteLength,        // "byteLength"
-  ByteOffset,        // "offset"
-  IsView,            // "isView"
-  ArrayBuffer,       // "ArrayBuffer"
-  Int8Array,         // "Int8Array"
-  Int16Array,        // "Int16Array"
-  Int32Array,        // "Int32Array"
-  Uint8Array,        // "Uint8Array"
-  Uint8ClampedArray, // "Uint8ClampedArray"
-  Uint16Array,       // "Uint16Array"
-  Uint32Array,       // "Uint32Array"
-  Float32Array,      // "Float32Array"
-  Float64Array,      // "Float64Array"
-};
-
-class PropNameIDCache {
-public:
-  const jsi::PropNameID& get(jsi::Runtime& runtime, Prop prop) {
-    auto key = reinterpret_cast<uintptr_t>(&runtime);
-    if (this->props.find(key) == this->props.end()) {
-      this->props[key] = std::unordered_map<Prop, std::unique_ptr<jsi::PropNameID>>();
-    }
-    if (!this->props[key][prop]) {
-      this->props[key][prop] = std::make_unique<jsi::PropNameID>(createProp(runtime, prop));
-    }
-    return *(this->props[key][prop]);
-  }
-
-  const jsi::PropNameID& getConstructorNameProp(jsi::Runtime& runtime, TypedArrayKind kind);
-
-  void invalidate(uintptr_t key) {
-    if (props.find(key) != props.end()) {
-      props[key].clear();
-    }
-  }
-
-private:
-  std::unordered_map<uintptr_t, std::unordered_map<Prop, std::unique_ptr<jsi::PropNameID>>> props;
-
-  jsi::PropNameID createProp(jsi::Runtime& runtime, Prop prop);
-};
-
-PropNameIDCache propNameIDCache;
-
-InvalidateCacheOnDestroy::InvalidateCacheOnDestroy(jsi::Runtime& runtime) {
-  key = reinterpret_cast<uintptr_t>(&runtime);
-}
-InvalidateCacheOnDestroy::~InvalidateCacheOnDestroy() {
-  propNameIDCache.invalidate(key);
-}
-
-TypedArrayKind getTypedArrayKindForName(const std::string& name);
-
-TypedArrayBase::TypedArrayBase(jsi::Runtime& runtime, size_t size, TypedArrayKind kind)
-    : TypedArrayBase(
-          runtime, runtime.global()
-                       .getProperty(runtime, propNameIDCache.getConstructorNameProp(runtime, kind))
-                       .asObject(runtime)
-                       .asFunction(runtime)
-                       .callAsConstructor(runtime, {static_cast<double>(size)})
-                       .asObject(runtime)) {}
-
-TypedArrayBase::TypedArrayBase(jsi::Runtime& runtime, const jsi::Object& obj)
-    : jsi::Object(jsi::Value(runtime, obj).asObject(runtime)) {}
-
-TypedArrayKind TypedArrayBase::getKind(jsi::Runtime& runtime) const {
-  auto constructorName = this->getProperty(runtime, propNameIDCache.get(runtime, Prop::Constructor))
-                             .asObject(runtime)
-                             .getProperty(runtime, propNameIDCache.get(runtime, Prop::Name))
-                             .asString(runtime)
-                             .utf8(runtime);
-  return getTypedArrayKindForName(constructorName);
-}
-
-size_t TypedArrayBase::size(jsi::Runtime& runtime) const {
-  return getProperty(runtime, propNameIDCache.get(runtime, Prop::Length)).asNumber();
-}
-
-size_t TypedArrayBase::length(jsi::Runtime& runtime) const {
-  return getProperty(runtime, propNameIDCache.get(runtime, Prop::Length)).asNumber();
-}
-
-size_t TypedArrayBase::byteLength(jsi::Runtime& runtime) const {
-  return getProperty(runtime, propNameIDCache.get(runtime, Prop::ByteLength)).asNumber();
-}
-
-size_t TypedArrayBase::byteOffset(jsi::Runtime& runtime) const {
-  return getProperty(runtime, propNameIDCache.get(runtime, Prop::ByteOffset)).asNumber();
-}
-
-bool TypedArrayBase::hasBuffer(jsi::Runtime& runtime) const {
-  auto buffer = getProperty(runtime, propNameIDCache.get(runtime, Prop::Buffer));
-  return buffer.isObject() && buffer.asObject(runtime).isArrayBuffer(runtime);
-}
-
-std::vector<uint8_t> TypedArrayBase::toVector(jsi::Runtime& runtime) {
-  auto start = reinterpret_cast<uint8_t*>(getBuffer(runtime).data(runtime) + byteOffset(runtime));
-  auto end = start + byteLength(runtime);
-  return std::vector<uint8_t>(start, end);
-}
-
-jsi::ArrayBuffer TypedArrayBase::getBuffer(jsi::Runtime& runtime) const {
-  auto buffer = getProperty(runtime, propNameIDCache.get(runtime, Prop::Buffer));
-  if (buffer.isObject() && buffer.asObject(runtime).isArrayBuffer(runtime)) {
-    return buffer.asObject(runtime).getArrayBuffer(runtime);
-  } else {
-    throw std::runtime_error("no ArrayBuffer attached");
-  }
-}
-
-bool isTypedArray(jsi::Runtime& runtime, const jsi::Object& jsObj) {
-  auto jsVal = runtime.global()
-                   .getProperty(runtime, propNameIDCache.get(runtime, Prop::ArrayBuffer))
-                   .asObject(runtime)
-                   .getProperty(runtime, propNameIDCache.get(runtime, Prop::IsView))
-                   .asObject(runtime)
-                   .asFunction(runtime)
-                   .callWithThis(runtime, runtime.global(), {jsi::Value(runtime, jsObj)});
-  if (jsVal.isBool()) {
-    return jsVal.getBool();
-  } else {
-    throw std::runtime_error("value is not a boolean");
-  }
-}
-
-TypedArrayBase getTypedArray(jsi::Runtime& runtime, const jsi::Object& jsObj) {
-  auto jsVal = runtime.global()
-                   .getProperty(runtime, propNameIDCache.get(runtime, Prop::ArrayBuffer))
-                   .asObject(runtime)
-                   .getProperty(runtime, propNameIDCache.get(runtime, Prop::IsView))
-                   .asObject(runtime)
-                   .asFunction(runtime)
-                   .callWithThis(runtime, runtime.global(), {jsi::Value(runtime, jsObj)});
-  if (jsVal.isBool()) {
-    return TypedArrayBase(runtime, jsObj);
-  } else {
-    throw std::runtime_error("value is not a boolean");
-  }
-}
-
-std::vector<uint8_t> arrayBufferToVector(jsi::Runtime& runtime, jsi::Object& jsObj) {
-  if (!jsObj.isArrayBuffer(runtime)) {
-    throw std::runtime_error("Object is not an ArrayBuffer");
-  }
-  auto jsArrayBuffer = jsObj.getArrayBuffer(runtime);
-
-  uint8_t* dataBlock = jsArrayBuffer.data(runtime);
-  size_t blockSize =
-      jsArrayBuffer.getProperty(runtime, propNameIDCache.get(runtime, Prop::ByteLength)).asNumber();
-  return std::vector<uint8_t>(dataBlock, dataBlock + blockSize);
-}
-
-void arrayBufferUpdate(jsi::Runtime& runtime, jsi::ArrayBuffer& buffer, std::vector<uint8_t> data,
-                       size_t offset) {
-  uint8_t* dataBlock = buffer.data(runtime);
-  size_t blockSize = buffer.size(runtime);
-  if (data.size() > blockSize) {
-    throw jsi::JSError(runtime, "ArrayBuffer is to small to fit data");
-  }
-  std::copy(data.begin(), data.end(), dataBlock + offset);
-}
-
-template <TypedArrayKind T>
-TypedArray<T>::TypedArray(jsi::Runtime& runtime, size_t size) : TypedArrayBase(runtime, size, T) {}
-
-template <TypedArrayKind T>
-TypedArray<T>::TypedArray(jsi::Runtime& runtime, std::vector<ContentType<T>> data)
-    : TypedArrayBase(runtime, data.size(), T) {
-  update(runtime, data);
-}
-
-template <TypedArrayKind T>
-TypedArray<T>::TypedArray(TypedArrayBase&& base) : TypedArrayBase(std::move(base)) {}
-
-template <TypedArrayKind T>
-std::vector<ContentType<T>> TypedArray<T>::toVector(jsi::Runtime& runtime) {
-  auto start =
-      reinterpret_cast<ContentType<T>*>(getBuffer(runtime).data(runtime) + byteOffset(runtime));
-  auto end = start + size(runtime);
-  return std::vector<ContentType<T>>(start, end);
-}
-
-template <TypedArrayKind T>
-void TypedArray<T>::update(jsi::Runtime& runtime, const std::vector<ContentType<T>>& data) {
-  if (data.size() != size(runtime)) {
-    throw jsi::JSError(runtime, "TypedArray can only be updated with a vector of the same size");
-  }
-  uint8_t* rawData = getBuffer(runtime).data(runtime) + byteOffset(runtime);
-  std::copy(data.begin(), data.end(), reinterpret_cast<ContentType<T>*>(rawData));
-}
-
-template <TypedArrayKind T>
-void TypedArray<T>::updateUnsafe(jsi::Runtime& runtime, ContentType<T>* data, size_t length) {
-  if (length != size(runtime)) {
-    throw jsi::JSError(runtime, "TypedArray can only be updated with an array of the same size");
-  }
-  uint8_t* rawData = getBuffer(runtime).data(runtime) + byteOffset(runtime);
-  memcpy(rawData, data, length);
-}
-
-template <TypedArrayKind T> uint8_t* TypedArray<T>::data(jsi::Runtime& runtime) {
-  return getBuffer(runtime).data(runtime) + byteOffset(runtime);
-}
-
-const jsi::PropNameID& PropNameIDCache::getConstructorNameProp(jsi::Runtime& runtime,
-                                                               TypedArrayKind kind) {
-  switch (kind) {
-    case TypedArrayKind::Int8Array:
-      return get(runtime, Prop::Int8Array);
-    case TypedArrayKind::Int16Array:
-      return get(runtime, Prop::Int16Array);
-    case TypedArrayKind::Int32Array:
-      return get(runtime, Prop::Int32Array);
-    case TypedArrayKind::Uint8Array:
-      return get(runtime, Prop::Uint8Array);
-    case TypedArrayKind::Uint8ClampedArray:
-      return get(runtime, Prop::Uint8ClampedArray);
-    case TypedArrayKind::Uint16Array:
-      return get(runtime, Prop::Uint16Array);
-    case TypedArrayKind::Uint32Array:
-      return get(runtime, Prop::Uint32Array);
-    case TypedArrayKind::Float32Array:
-      return get(runtime, Prop::Float32Array);
-    case TypedArrayKind::Float64Array:
-      return get(runtime, Prop::Float64Array);
-  }
-}
-
-jsi::PropNameID PropNameIDCache::createProp(jsi::Runtime& runtime, Prop prop) {
-  auto create = [&](const std::string& propName) {
-    return jsi::PropNameID::forUtf8(runtime, propName);
-  };
-  switch (prop) {
-    case Prop::Buffer:
-      return create("buffer");
-    case Prop::Constructor:
-      return create("constructor");
-    case Prop::Name:
-      return create("name");
-    case Prop::Proto:
-      return create("__proto__");
-    case Prop::Length:
-      return create("length");
-    case Prop::ByteLength:
-      return create("byteLength");
-    case Prop::ByteOffset:
-      return create("byteOffset");
-    case Prop::IsView:
-      return create("isView");
-    case Prop::ArrayBuffer:
-      return create("ArrayBuffer");
-    case Prop::Int8Array:
-      return create("Int8Array");
-    case Prop::Int16Array:
-      return create("Int16Array");
-    case Prop::Int32Array:
-      return create("Int32Array");
-    case Prop::Uint8Array:
-      return create("Uint8Array");
-    case Prop::Uint8ClampedArray:
-      return create("Uint8ClampedArray");
-    case Prop::Uint16Array:
-      return create("Uint16Array");
-    case Prop::Uint32Array:
-      return create("Uint32Array");
-    case Prop::Float32Array:
-      return create("Float32Array");
-    case Prop::Float64Array:
-      return create("Float64Array");
-  }
-}
-
-std::unordered_map<std::string, TypedArrayKind> nameToKindMap = {
-    {"Int8Array", TypedArrayKind::Int8Array},
-    {"Int16Array", TypedArrayKind::Int16Array},
-    {"Int32Array", TypedArrayKind::Int32Array},
-    {"Uint8Array", TypedArrayKind::Uint8Array},
-    {"Uint8ClampedArray", TypedArrayKind::Uint8ClampedArray},
-    {"Uint16Array", TypedArrayKind::Uint16Array},
-    {"Uint32Array", TypedArrayKind::Uint32Array},
-    {"Float32Array", TypedArrayKind::Float32Array},
-    {"Float64Array", TypedArrayKind::Float64Array},
-};
-
-TypedArrayKind getTypedArrayKindForName(const std::string& name) {
-  return nameToKindMap.at(name);
-}
-
-template class TypedArray<TypedArrayKind::Int8Array>;
-template class TypedArray<TypedArrayKind::Int16Array>;
-template class TypedArray<TypedArrayKind::Int32Array>;
-template class TypedArray<TypedArrayKind::Uint8Array>;
-template class TypedArray<TypedArrayKind::Uint8ClampedArray>;
-template class TypedArray<TypedArrayKind::Uint16Array>;
-template class TypedArray<TypedArrayKind::Uint32Array>;
-template class TypedArray<TypedArrayKind::Float32Array>;
-template class TypedArray<TypedArrayKind::Float64Array>;

package/cpp/TypedArray.h

@@ -1,153 +0,0 @@
-//
-//  TypedArray.h
-//  react-native-mmkv
-//
-//  Created by Marc Rousavy on 11.10.2022.
-//  Originally created by Expo (expo-gl)
-//
-
-#pragma once
-
-#include <jsi/jsi.h>
-#include <utility>
-#include <vector>
-
-namespace jsi = facebook::jsi;
-
-enum class TypedArrayKind {
-  Int8Array,
-  Int16Array,
-  Int32Array,
-  Uint8Array,
-  Uint8ClampedArray,
-  Uint16Array,
-  Uint32Array,
-  Float32Array,
-  Float64Array,
-};
-
-template <TypedArrayKind T> class TypedArray;
-
-template <TypedArrayKind T> struct typedArrayTypeMap;
-template <> struct typedArrayTypeMap<TypedArrayKind::Int8Array> {
-  typedef int8_t type;
-};
-template <> struct typedArrayTypeMap<TypedArrayKind::Int16Array> {
-  typedef int16_t type;
-};
-template <> struct typedArrayTypeMap<TypedArrayKind::Int32Array> {
-  typedef int32_t type;
-};
-template <> struct typedArrayTypeMap<TypedArrayKind::Uint8Array> {
-  typedef uint8_t type;
-};
-template <> struct typedArrayTypeMap<TypedArrayKind::Uint8ClampedArray> {
-  typedef uint8_t type;
-};
-template <> struct typedArrayTypeMap<TypedArrayKind::Uint16Array> {
-  typedef uint16_t type;
-};
-template <> struct typedArrayTypeMap<TypedArrayKind::Uint32Array> {
-  typedef uint32_t type;
-};
-template <> struct typedArrayTypeMap<TypedArrayKind::Float32Array> {
-  typedef float type;
-};
-template <> struct typedArrayTypeMap<TypedArrayKind::Float64Array> {
-  typedef double type;
-};
-
-// Instance of this class will invalidate PropNameIDCache when destructor is called.
-// Attach this object to global in specific jsi::Runtime to make sure lifecycle of
-// the cache object is connected to the lifecycle of the js runtime
-class InvalidateCacheOnDestroy : public jsi::HostObject {
-public:
-  explicit InvalidateCacheOnDestroy(jsi::Runtime& runtime);
-  virtual ~InvalidateCacheOnDestroy();
-  virtual jsi::Value get(jsi::Runtime&, const jsi::PropNameID& name) {
-    return jsi::Value::null();
-  }
-  virtual void set(jsi::Runtime&, const jsi::PropNameID& name, const jsi::Value& value) {}
-  virtual std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime& rt) {
-    return {};
-  }
-
-private:
-  uintptr_t key;
-};
-
-class TypedArrayBase : public jsi::Object {
-public:
-  template <TypedArrayKind T> using ContentType = typename typedArrayTypeMap<T>::type;
-
-  TypedArrayBase(jsi::Runtime&, size_t, TypedArrayKind);
-  TypedArrayBase(jsi::Runtime&, const jsi::Object&);
-  TypedArrayBase(TypedArrayBase&&) = default;
-  TypedArrayBase& operator=(TypedArrayBase&&) = default;
-
-  TypedArrayKind getKind(jsi::Runtime& runtime) const;
-
-  template <TypedArrayKind T> TypedArray<T> get(jsi::Runtime& runtime) const&;
-  template <TypedArrayKind T> TypedArray<T> get(jsi::Runtime& runtime) &&;
-  template <TypedArrayKind T> TypedArray<T> as(jsi::Runtime& runtime) const&;
-  template <TypedArrayKind T> TypedArray<T> as(jsi::Runtime& runtime) &&;
-
-  size_t size(jsi::Runtime& runtime) const;
-  size_t length(jsi::Runtime& runtime) const;
-  size_t byteLength(jsi::Runtime& runtime) const;
-  size_t byteOffset(jsi::Runtime& runtime) const;
-  bool hasBuffer(jsi::Runtime& runtime) const;
-
-  std::vector<uint8_t> toVector(jsi::Runtime& runtime);
-  jsi::ArrayBuffer getBuffer(jsi::Runtime& runtime) const;
-
-private:
-  template <TypedArrayKind> friend class TypedArray;
-};
-
-bool isTypedArray(jsi::Runtime& runtime, const jsi::Object& jsObj);
-TypedArrayBase getTypedArray(jsi::Runtime& runtime, const jsi::Object& jsObj);
-
-std::vector<uint8_t> arrayBufferToVector(jsi::Runtime& runtime, jsi::Object& jsObj);
-void arrayBufferUpdate(jsi::Runtime& runtime, jsi::ArrayBuffer& buffer, std::vector<uint8_t> data,
-                       size_t offset);
-
-template <TypedArrayKind T> class TypedArray : public TypedArrayBase {
-public:
-  explicit TypedArray(TypedArrayBase&& base);
-  TypedArray(jsi::Runtime& runtime, size_t size);
-  TypedArray(jsi::Runtime& runtime, std::vector<ContentType<T>> data);
-  TypedArray(TypedArray&&) = default;
-  TypedArray& operator=(TypedArray&&) = default;
-
-  std::vector<ContentType<T>> toVector(jsi::Runtime& runtime);
-  void update(jsi::Runtime& runtime, const std::vector<ContentType<T>>& data);
-  void updateUnsafe(jsi::Runtime& runtime, ContentType<T>* data, size_t length);
-  uint8_t* data(jsi::Runtime& runtime);
-};
-
-template <TypedArrayKind T> TypedArray<T> TypedArrayBase::get(jsi::Runtime& runtime) const& {
-  assert(getKind(runtime) == T);
-  (void)runtime; // when assert is disabled we need to mark this as used
-  return TypedArray<T>(jsi::Value(runtime, jsi::Value(runtime, *this).asObject(runtime)));
-}
-
-template <TypedArrayKind T> TypedArray<T> TypedArrayBase::get(jsi::Runtime& runtime) && {
-  assert(getKind(runtime) == T);
-  (void)runtime; // when assert is disabled we need to mark this as used
-  return TypedArray<T>(std::move(*this));
-}
-
-template <TypedArrayKind T> TypedArray<T> TypedArrayBase::as(jsi::Runtime& runtime) const& {
-  if (getKind(runtime) != T) {
-    throw jsi::JSError(runtime, "Object is not a TypedArray");
-  }
-  return get<T>(runtime);
-}
-
-template <TypedArrayKind T> TypedArray<T> TypedArrayBase::as(jsi::Runtime& runtime) && {
-  if (getKind(runtime) != T) {
-    throw jsi::JSError(runtime, "Object is not a TypedArray");
-  }
-  return std::move(*this).get<T>(runtime);
-}

package/ios/JSIUtils.h

@@ -1,38 +0,0 @@
-#import <Foundation/Foundation.h>
-#import <React/RCTBridgeModule.h>
-#import <jsi/jsi.h>
-
-using namespace facebook;
-
-jsi::Value convertNSNumberToJSIBoolean(jsi::Runtime& runtime, NSNumber* value);
-jsi::Value convertNSNumberToJSINumber(jsi::Runtime& runtime, NSNumber* value);
-jsi::String convertNSStringToJSIString(jsi::Runtime& runtime, NSString* value);
-jsi::Value convertObjCObjectToJSIValue(jsi::Runtime& runtime, id value);
-;
-jsi::Object convertNSDictionaryToJSIObject(jsi::Runtime& runtime, NSDictionary* value);
-jsi::Array convertNSArrayToJSIArray(jsi::Runtime& runtime, NSArray* value);
-std::vector<jsi::Value> convertNSArrayToStdVector(jsi::Runtime& runtime, NSArray* value);
-jsi::Value convertObjCObjectToJSIValue(jsi::Runtime& runtime, id value);
-id convertJSIValueToObjCObject(jsi::Runtime& runtime, const jsi::Value& value);
-NSString* convertJSIStringToNSString(jsi::Runtime& runtime, const jsi::String& value);
-NSArray* convertJSIArrayToNSArray(jsi::Runtime& runtime, const jsi::Array& value);
-NSDictionary* convertJSIObjectToNSDictionary(jsi::Runtime& runtime, const jsi::Object& value);
-RCTResponseSenderBlock convertJSIFunctionToCallback(jsi::Runtime& runtime,
-                                                    const jsi::Function& value);
-id convertJSIValueToObjCObject(jsi::Runtime& runtime, const jsi::Value& value);
-RCTResponseSenderBlock convertJSIFunctionToCallback(jsi::Runtime& runtime,
-                                                    const jsi::Function& value);
-
-struct Promise {
-  Promise(jsi::Runtime& rt, jsi::Function resolve, jsi::Function reject);
-
-  void resolve(const jsi::Value& result);
-  void reject(const std::string& error);
-
-  jsi::Runtime& runtime_;
-  jsi::Function resolve_;
-  jsi::Function reject_;
-};
-
-using PromiseSetupFunctionType = std::function<void(jsi::Runtime& rt, std::shared_ptr<Promise>)>;
-jsi::Value createPromiseAsJSIValue(jsi::Runtime& rt, const PromiseSetupFunctionType func);

package/ios/JSIUtils.mm

@@ -1,167 +0,0 @@
-//
-//  REAJsiUtilities.cpp
-//  RNReanimated
-//
-//  Created by Christian Falch on 25/04/2019.
-//  Copyright © 2019 Facebook. All rights reserved.
-//
-
-#include "JSIUtils.h"
-#import <React/RCTBridgeModule.h>
-#import <React/RCTConvert.h>
-
-/**
- * All helper functions are ObjC++ specific.
- */
-jsi::Value convertNSNumberToJSIBoolean(jsi::Runtime& runtime, NSNumber* value) {
-  return jsi::Value((bool)[value boolValue]);
-}
-
-jsi::Value convertNSNumberToJSINumber(jsi::Runtime& runtime, NSNumber* value) {
-  return jsi::Value([value doubleValue]);
-}
-
-jsi::String convertNSStringToJSIString(jsi::Runtime& runtime, NSString* value) {
-  return jsi::String::createFromUtf8(runtime, [value UTF8String] ?: "");
-}
-
-jsi::Value convertObjCObjectToJSIValue(jsi::Runtime& runtime, id value);
-
-jsi::Object convertNSDictionaryToJSIObject(jsi::Runtime& runtime, NSDictionary* value) {
-  jsi::Object result = jsi::Object(runtime);
-  for (NSString* k in value) {
-    result.setProperty(runtime, [k UTF8String], convertObjCObjectToJSIValue(runtime, value[k]));
-  }
-  return result;
-}
-
-jsi::Array convertNSArrayToJSIArray(jsi::Runtime& runtime, NSArray* value) {
-  jsi::Array result = jsi::Array(runtime, value.count);
-  for (size_t i = 0; i < value.count; i++) {
-    result.setValueAtIndex(runtime, i, convertObjCObjectToJSIValue(runtime, value[i]));
-  }
-  return result;
-}
-
-std::vector<jsi::Value> convertNSArrayToStdVector(jsi::Runtime& runtime, NSArray* value) {
-  std::vector<jsi::Value> result;
-  for (size_t i = 0; i < value.count; i++) {
-    result.emplace_back(convertObjCObjectToJSIValue(runtime, value[i]));
-  }
-  return result;
-}
-
-jsi::Value convertObjCObjectToJSIValue(jsi::Runtime& runtime, id value) {
-  if ([value isKindOfClass:[NSString class]]) {
-    return convertNSStringToJSIString(runtime, (NSString*)value);
-  } else if ([value isKindOfClass:[NSNumber class]]) {
-    if ([value isKindOfClass:[@YES class]]) {
-      return convertNSNumberToJSIBoolean(runtime, (NSNumber*)value);
-    }
-    return convertNSNumberToJSINumber(runtime, (NSNumber*)value);
-  } else if ([value isKindOfClass:[NSDictionary class]]) {
-    return convertNSDictionaryToJSIObject(runtime, (NSDictionary*)value);
-  } else if ([value isKindOfClass:[NSArray class]]) {
-    return convertNSArrayToJSIArray(runtime, (NSArray*)value);
-  } else if (value == (id)kCFNull) {
-    return jsi::Value::null();
-  }
-  return jsi::Value::undefined();
-}
-
-id convertJSIValueToObjCObject(jsi::Runtime& runtime, const jsi::Value& value);
-
-NSString* convertJSIStringToNSString(jsi::Runtime& runtime, const jsi::String& value) {
-  auto string = value.utf8(runtime);
-  return [NSString stringWithUTF8String:string.c_str()];
-}
-
-NSArray* convertJSIArrayToNSArray(jsi::Runtime& runtime, const jsi::Array& value) {
-  size_t size = value.size(runtime);
-  NSMutableArray* result = [NSMutableArray new];
-  for (size_t i = 0; i < size; i++) {
-    // Insert kCFNull when it's `undefined` value to preserve the indices.
-    [result addObject:convertJSIValueToObjCObject(runtime, value.getValueAtIndex(runtime, i))
-                          ?: (id)kCFNull];
-  }
-  return [result copy];
-}
-
-NSDictionary* convertJSIObjectToNSDictionary(jsi::Runtime& runtime, const jsi::Object& value) {
-  jsi::Array propertyNames = value.getPropertyNames(runtime);
-  size_t size = propertyNames.size(runtime);
-  NSMutableDictionary* result = [NSMutableDictionary new];
-  for (size_t i = 0; i < size; i++) {
-    jsi::String name = propertyNames.getValueAtIndex(runtime, i).getString(runtime);
-    NSString* k = convertJSIStringToNSString(runtime, name);
-    id v = convertJSIValueToObjCObject(runtime, value.getProperty(runtime, name));
-    if (v) {
-      result[k] = v;
-    }
-  }
-  return [result copy];
-}
-
-RCTResponseSenderBlock convertJSIFunctionToCallback(jsi::Runtime& runtime,
-                                                    const jsi::Function& value) {
-  __block auto cb = value.getFunction(runtime);
-
-  return ^(NSArray* responses) {
-    cb.call(runtime, convertNSArrayToJSIArray(runtime, responses), 2);
-  };
-}
-
-id convertJSIValueToObjCObject(jsi::Runtime& runtime, const jsi::Value& value) {
-  if (value.isUndefined() || value.isNull()) {
-    return nil;
-  }
-  if (value.isBool()) {
-    return @(value.getBool());
-  }
-  if (value.isNumber()) {
-    return @(value.getNumber());
-  }
-  if (value.isString()) {
-    return convertJSIStringToNSString(runtime, value.getString(runtime));
-  }
-  if (value.isObject()) {
-    jsi::Object o = value.getObject(runtime);
-    if (o.isArray(runtime)) {
-      return convertJSIArrayToNSArray(runtime, o.getArray(runtime));
-    }
-    if (o.isFunction(runtime)) {
-      return convertJSIFunctionToCallback(runtime, std::move(o.getFunction(runtime)));
-    }
-    return convertJSIObjectToNSDictionary(runtime, o);
-  }
-
-  throw std::runtime_error("Unsupported jsi::jsi::Value kind");
-}
-
-Promise::Promise(jsi::Runtime& rt, jsi::Function resolve, jsi::Function reject)
-    : runtime_(rt), resolve_(std::move(resolve)), reject_(std::move(reject)) {}
-
-void Promise::resolve(const jsi::Value& result) {
-  resolve_.call(runtime_, result);
-}
-
-void Promise::reject(const std::string& message) {
-  jsi::Object error(runtime_);
-  error.setProperty(runtime_, "message", jsi::String::createFromUtf8(runtime_, message));
-  reject_.call(runtime_, error);
-}
-
-jsi::Value createPromiseAsJSIValue(jsi::Runtime& rt, const PromiseSetupFunctionType func) {
-  jsi::Function JSPromise = rt.global().getPropertyAsFunction(rt, "Promise");
-  jsi::Function fn = jsi::Function::createFromHostFunction(
-      rt, jsi::PropNameID::forAscii(rt, "fn"), 2,
-      [func](jsi::Runtime& rt2, const jsi::Value& thisVal, const jsi::Value* args, size_t count) {
-        jsi::Function resolve = args[0].getObject(rt2).getFunction(rt2);
-        jsi::Function reject = args[1].getObject(rt2).getFunction(rt2);
-        auto wrapper = std::make_shared<Promise>(rt2, std::move(resolve), std::move(reject));
-        func(rt2, wrapper);
-        return jsi::Value::undefined();
-      });
-
-  return JSPromise.callAsConstructor(rt, fn);
-}