react-native-mmkv 2.10.1 → 2.11.0

package/cpp/TypedArray.cpp

@@ -8,40 +8,39 @@
 
 #include "TypedArray.h"
 
-#include <unordered_map>
+#include <algorithm>
 #include <memory>
+#include <string>
+#include <unordered_map>
 #include <utility>
 #include <vector>
-#include <algorithm>
-#include <string>
 
-template <TypedArrayKind T>
-using ContentType = typename typedArrayTypeMap<T>::type;
+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"
+  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"
+  Uint16Array,       // "Uint16Array"
+  Uint32Array,       // "Uint32Array"
+  Float32Array,      // "Float32Array"
+  Float64Array,      // "Float64Array"
 };
 
 class PropNameIDCache {
- public:
-  const jsi::PropNameID &get(jsi::Runtime &runtime, Prop prop) {
+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>>();
@@ -52,7 +51,7 @@ class PropNameIDCache {
     return *(this->props[key][prop]);
   }
 
-  const jsi::PropNameID &getConstructorNameProp(jsi::Runtime &runtime, TypedArrayKind kind);
+  const jsi::PropNameID& getConstructorNameProp(jsi::Runtime& runtime, TypedArrayKind kind);
 
   void invalidate(uintptr_t key) {
     if (props.find(key) != props.end()) {
@@ -60,37 +59,36 @@ class PropNameIDCache {
     }
   }
 
- private:
+private:
   std::unordered_map<uintptr_t, std::unordered_map<Prop, std::unique_ptr<jsi::PropNameID>>> props;
 
-  jsi::PropNameID createProp(jsi::Runtime &runtime, Prop prop);
+  jsi::PropNameID createProp(jsi::Runtime& runtime, Prop prop);
 };
 
 PropNameIDCache propNameIDCache;
 
-InvalidateCacheOnDestroy::InvalidateCacheOnDestroy(jsi::Runtime &runtime) {
+InvalidateCacheOnDestroy::InvalidateCacheOnDestroy(jsi::Runtime& runtime) {
   key = reinterpret_cast<uintptr_t>(&runtime);
 }
 InvalidateCacheOnDestroy::~InvalidateCacheOnDestroy() {
   propNameIDCache.invalidate(key);
 }
 
-TypedArrayKind getTypedArrayKindForName(const std::string &name);
+TypedArrayKind getTypedArrayKindForName(const std::string& name);
 
-TypedArrayBase::TypedArrayBase(jsi::Runtime &runtime, size_t size, TypedArrayKind kind)
+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)
+          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 {
+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))
@@ -99,34 +97,34 @@ TypedArrayKind TypedArrayBase::getKind(jsi::Runtime &runtime) const {
   return getTypedArrayKindForName(constructorName);
 }
 
-size_t TypedArrayBase::size(jsi::Runtime &runtime) const {
+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 {
+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 {
+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 {
+size_t TypedArrayBase::byteOffset(jsi::Runtime& runtime) const {
   return getProperty(runtime, propNameIDCache.get(runtime, Prop::ByteOffset)).asNumber();
 }
 
-bool TypedArrayBase::hasBuffer(jsi::Runtime &runtime) const {
+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));
+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 {
+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);
@@ -135,7 +133,7 @@ jsi::ArrayBuffer TypedArrayBase::getBuffer(jsi::Runtime &runtime) const {
   }
 }
 
-bool isTypedArray(jsi::Runtime &runtime, const jsi::Object &jsObj) {
+bool isTypedArray(jsi::Runtime& runtime, const jsi::Object& jsObj) {
   auto jsVal = runtime.global()
                    .getProperty(runtime, propNameIDCache.get(runtime, Prop::ArrayBuffer))
                    .asObject(runtime)
@@ -150,7 +148,7 @@ bool isTypedArray(jsi::Runtime &runtime, const jsi::Object &jsObj) {
   }
 }
 
-TypedArrayBase getTypedArray(jsi::Runtime &runtime, const jsi::Object &jsObj) {
+TypedArrayBase getTypedArray(jsi::Runtime& runtime, const jsi::Object& jsObj) {
   auto jsVal = runtime.global()
                    .getProperty(runtime, propNameIDCache.get(runtime, Prop::ArrayBuffer))
                    .asObject(runtime)
@@ -165,24 +163,21 @@ TypedArrayBase getTypedArray(jsi::Runtime &runtime, const jsi::Object &jsObj) {
   }
 }
 
-std::vector<uint8_t> arrayBufferToVector(jsi::Runtime &runtime, jsi::Object &jsObj) {
+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);
+  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);
+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");
@@ -191,51 +186,49 @@ void arrayBufferUpdate(
 }
 
 template <TypedArrayKind T>
-TypedArray<T>::TypedArray(jsi::Runtime &runtime, size_t size) : TypedArrayBase(runtime, size, 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)
+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)) {}
+TypedArray<T>::TypedArray(TypedArrayBase&& base) : TypedArrayBase(std::move(base)) {}
 
 template <TypedArrayKind T>
-std::vector<ContentType<T>> TypedArray<T>::toVector(jsi::Runtime &runtime) {
+std::vector<ContentType<T>> TypedArray<T>::toVector(jsi::Runtime& runtime) {
   auto start =
-      reinterpret_cast<ContentType<T> *>(getBuffer(runtime).data(runtime) + byteOffset(runtime));
+      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) {
+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));
+  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) {
+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);
+  uint8_t* rawData = getBuffer(runtime).data(runtime) + byteOffset(runtime);
   memcpy(rawData, data, length);
 }
 
-template <TypedArrayKind T>
-uint8_t* TypedArray<T>::data(jsi::Runtime &runtime) {
+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) {
+const jsi::PropNameID& PropNameIDCache::getConstructorNameProp(jsi::Runtime& runtime,
+                                                               TypedArrayKind kind) {
   switch (kind) {
     case TypedArrayKind::Int8Array:
       return get(runtime, Prop::Int8Array);
@@ -258,8 +251,8 @@ const jsi::PropNameID &PropNameIDCache::getConstructorNameProp(
   }
 }
 
-jsi::PropNameID PropNameIDCache::createProp(jsi::Runtime &runtime, Prop prop) {
-  auto create = [&](const std::string &propName) {
+jsi::PropNameID PropNameIDCache::createProp(jsi::Runtime& runtime, Prop prop) {
+  auto create = [&](const std::string& propName) {
     return jsi::PropNameID::forUtf8(runtime, propName);
   };
   switch (prop) {
@@ -314,7 +307,7 @@ std::unordered_map<std::string, TypedArrayKind> nameToKindMap = {
     {"Float64Array", TypedArrayKind::Float64Array},
 };
 
-TypedArrayKind getTypedArrayKindForName(const std::string &name) {
+TypedArrayKind getTypedArrayKindForName(const std::string& name) {
   return nameToKindMap.at(name);
 }
 

package/cpp/TypedArray.h

@@ -26,45 +26,34 @@ enum class TypedArrayKind {
   Float64Array,
 };
 
-template <TypedArrayKind T>
-class TypedArray;
+template <TypedArrayKind T> class TypedArray;
 
-template <TypedArrayKind T>
-struct typedArrayTypeMap;
-template <>
-struct typedArrayTypeMap<TypedArrayKind::Int8Array> {
+template <TypedArrayKind T> struct typedArrayTypeMap;
+template <> struct typedArrayTypeMap<TypedArrayKind::Int8Array> {
   typedef int8_t type;
 };
-template <>
-struct typedArrayTypeMap<TypedArrayKind::Int16Array> {
+template <> struct typedArrayTypeMap<TypedArrayKind::Int16Array> {
   typedef int16_t type;
 };
-template <>
-struct typedArrayTypeMap<TypedArrayKind::Int32Array> {
+template <> struct typedArrayTypeMap<TypedArrayKind::Int32Array> {
   typedef int32_t type;
 };
-template <>
-struct typedArrayTypeMap<TypedArrayKind::Uint8Array> {
+template <> struct typedArrayTypeMap<TypedArrayKind::Uint8Array> {
   typedef uint8_t type;
 };
-template <>
-struct typedArrayTypeMap<TypedArrayKind::Uint8ClampedArray> {
+template <> struct typedArrayTypeMap<TypedArrayKind::Uint8ClampedArray> {
   typedef uint8_t type;
 };
-template <>
-struct typedArrayTypeMap<TypedArrayKind::Uint16Array> {
+template <> struct typedArrayTypeMap<TypedArrayKind::Uint16Array> {
   typedef uint16_t type;
 };
-template <>
-struct typedArrayTypeMap<TypedArrayKind::Uint32Array> {
+template <> struct typedArrayTypeMap<TypedArrayKind::Uint32Array> {
   typedef uint32_t type;
 };
-template <>
-struct typedArrayTypeMap<TypedArrayKind::Float32Array> {
+template <> struct typedArrayTypeMap<TypedArrayKind::Float32Array> {
   typedef float type;
 };
-template <>
-struct typedArrayTypeMap<TypedArrayKind::Float64Array> {
+template <> struct typedArrayTypeMap<TypedArrayKind::Float64Array> {
   typedef double type;
 };
 
@@ -72,105 +61,91 @@ struct typedArrayTypeMap<TypedArrayKind::Float64Array> {
 // 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);
+public:
+  explicit InvalidateCacheOnDestroy(jsi::Runtime& runtime);
   virtual ~InvalidateCacheOnDestroy();
-  virtual jsi::Value get(jsi::Runtime &, const jsi::PropNameID &name) {
+  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) {
+  virtual void set(jsi::Runtime&, const jsi::PropNameID& name, const jsi::Value& value) {}
+  virtual std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime& rt) {
     return {};
   }
 
- private:
+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;
+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);
+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 & {
+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) && {
+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 & {
+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) && {
+template <TypedArrayKind T> TypedArray<T> TypedArrayBase::as(jsi::Runtime& runtime) && {
   if (getKind(runtime) != T) {
     throw jsi::JSError(runtime, "Object is not a TypedArray");
   }

package/ios/JSIUtils.h

@@ -1,50 +1,38 @@
 #import <Foundation/Foundation.h>
-#import <jsi/jsi.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);
+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);
+  Promise(jsi::Runtime& rt, jsi::Function resolve, jsi::Function reject);
 
-    void resolve(const jsi::Value &result);
-    void reject(const std::string &error);
+  void resolve(const jsi::Value& result);
+  void reject(const std::string& error);
 
-    jsi::Runtime &runtime_;
-    jsi::Function resolve_;
-    jsi::Function reject_;
+  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);
+using PromiseSetupFunctionType = std::function<void(jsi::Runtime& rt, std::shared_ptr<Promise>)>;
+jsi::Value createPromiseAsJSIValue(jsi::Runtime& rt, const PromiseSetupFunctionType func);