react-native-mmkv 2.10.2 → 2.11.0

package/android/src/main/cpp/cpp-adapter.cpp

@@ -1,70 +1,77 @@
-#include <jni.h>
-#include <jsi/jsi.h>
-#include <MMKV.h>
 #include "MmkvHostObject.h"
 #include "TypedArray.h"
+#include <MMKV.h>
+#include <jni.h>
+#include <jsi/jsi.h>
 
 using namespace facebook;
 
-std::string getPropertyAsStringOrEmptyFromObject(jsi::Object& object, const std::string& propertyName, jsi::Runtime& runtime) {
-    jsi::Value value = object.getProperty(runtime, propertyName.c_str());
-    return value.isString() ? value.asString(runtime).utf8(runtime) : "";
+std::string getPropertyAsStringOrEmptyFromObject(jsi::Object& object,
+                                                 const std::string& propertyName,
+                                                 jsi::Runtime& runtime) {
+  jsi::Value value = object.getProperty(runtime, propertyName.c_str());
+  return value.isString() ? value.asString(runtime).utf8(runtime) : "";
 }
 
 void install(jsi::Runtime& jsiRuntime) {
-    // MMKV.createNewInstance()
-    auto mmkvCreateNewInstance = jsi::Function::createFromHostFunction(jsiRuntime,
-                                                                       jsi::PropNameID::forAscii(jsiRuntime, "mmkvCreateNewInstance"),
-                                                                       1,
-                                                                       [](jsi::Runtime& runtime,
-                                                                          const jsi::Value& thisValue,
-                                                                          const jsi::Value* arguments,
-                                                                          size_t count) -> jsi::Value {
-                                                                         if (count != 1) {
-                                                                             throw jsi::JSError(runtime, "MMKV.createNewInstance(..) expects one argument (object)!");
-                                                                         }
-                                                                         jsi::Object config = arguments[0].asObject(runtime);
+  // MMKV.createNewInstance()
+  auto mmkvCreateNewInstance = jsi::Function::createFromHostFunction(
+      jsiRuntime, jsi::PropNameID::forAscii(jsiRuntime, "mmkvCreateNewInstance"), 1,
+      [](jsi::Runtime& runtime, const jsi::Value& thisValue, const jsi::Value* arguments,
+         size_t count) -> jsi::Value {
+        if (count != 1) {
+          throw jsi::JSError(runtime, "MMKV.createNewInstance(..) expects one argument (object)!");
+        }
+        jsi::Object config = arguments[0].asObject(runtime);
 
-                                                                         std::string instanceId = getPropertyAsStringOrEmptyFromObject(config, "id", runtime);
-                                                                         std::string path = getPropertyAsStringOrEmptyFromObject(config, "path", runtime);
-                                                                         std::string encryptionKey = getPropertyAsStringOrEmptyFromObject(config, "encryptionKey", runtime);
+        std::string instanceId = getPropertyAsStringOrEmptyFromObject(config, "id", runtime);
+        std::string path = getPropertyAsStringOrEmptyFromObject(config, "path", runtime);
+        std::string encryptionKey =
+            getPropertyAsStringOrEmptyFromObject(config, "encryptionKey", runtime);
 
-                                                                         auto instance = std::make_shared<MmkvHostObject>(instanceId, path, encryptionKey);
-                                                                         return jsi::Object::createFromHostObject(runtime, instance);
-                                                                       });
-    jsiRuntime.global().setProperty(jsiRuntime, "mmkvCreateNewInstance", std::move(mmkvCreateNewInstance));
+        auto instance = std::make_shared<MmkvHostObject>(instanceId, path, encryptionKey);
+        return jsi::Object::createFromHostObject(runtime, instance);
+      });
+  jsiRuntime.global().setProperty(jsiRuntime, "mmkvCreateNewInstance",
+                                  std::move(mmkvCreateNewInstance));
 
-    // Adds the PropNameIDCache object to the Runtime. If the Runtime gets destroyed, the Object gets destroyed and the cache gets invalidated.
-    auto propNameIdCache = std::make_shared<InvalidateCacheOnDestroy>(jsiRuntime);
-    jsiRuntime.global().setProperty(jsiRuntime, "mmkvArrayBufferPropNameIdCache", jsi::Object::createFromHostObject(jsiRuntime, propNameIdCache));
+  // Adds the PropNameIDCache object to the Runtime. If the Runtime gets destroyed, the Object gets
+  // destroyed and the cache gets invalidated.
+  auto propNameIdCache = std::make_shared<InvalidateCacheOnDestroy>(jsiRuntime);
+  jsiRuntime.global().setProperty(jsiRuntime, "mmkvArrayBufferPropNameIdCache",
+                                  jsi::Object::createFromHostObject(jsiRuntime, propNameIdCache));
 }
 
-std::string jstringToStdString(JNIEnv *env, jstring jStr) {
-    if (!jStr) return "";
+std::string jstringToStdString(JNIEnv* env, jstring jStr) {
+  if (!jStr)
+    return "";
 
-    const auto stringClass = env->GetObjectClass(jStr);
-    const auto getBytes = env->GetMethodID(stringClass, "getBytes", "(Ljava/lang/String;)[B");
-    const auto stringJbytes = (jbyteArray) env->CallObjectMethod(jStr, getBytes, env->NewStringUTF("UTF-8"));
+  const auto stringClass = env->GetObjectClass(jStr);
+  const auto getBytes = env->GetMethodID(stringClass, "getBytes", "(Ljava/lang/String;)[B");
+  const auto stringJbytes =
+      (jbyteArray)env->CallObjectMethod(jStr, getBytes, env->NewStringUTF("UTF-8"));
 
-    auto length = (size_t) env->GetArrayLength(stringJbytes);
-    auto pBytes = env->GetByteArrayElements(stringJbytes, nullptr);
+  auto length = (size_t)env->GetArrayLength(stringJbytes);
+  auto pBytes = env->GetByteArrayElements(stringJbytes, nullptr);
 
-    std::string ret = std::string((char *)pBytes, length);
-    env->ReleaseByteArrayElements(stringJbytes, pBytes, JNI_ABORT);
+  std::string ret = std::string((char*)pBytes, length);
+  env->ReleaseByteArrayElements(stringJbytes, pBytes, JNI_ABORT);
 
-    env->DeleteLocalRef(stringJbytes);
-    env->DeleteLocalRef(stringClass);
-    return ret;
+  env->DeleteLocalRef(stringJbytes);
+  env->DeleteLocalRef(stringClass);
+  return ret;
 }
 
-extern "C"
-JNIEXPORT void JNICALL
-Java_com_reactnativemmkv_MmkvModule_nativeInstall(JNIEnv *env, jobject clazz, jlong jsiPtr, jstring path) {
-    MMKV::initializeMMKV(jstringToStdString(env, path));
+extern "C" JNIEXPORT void JNICALL Java_com_reactnativemmkv_MmkvModule_nativeInstall(JNIEnv* env,
+                                                                                    jobject clazz,
+                                                                                    jlong jsiPtr,
+                                                                                    jstring path) {
+  MMKV::initializeMMKV(jstringToStdString(env, path));
 
-    auto runtime = reinterpret_cast<jsi::Runtime*>(jsiPtr);
-    if (runtime) {
-        install(*runtime);
-    }
-    // if runtime was nullptr, MMKV will not be installed. This should only happen while Remote Debugging (Chrome), but will be weird either way.
+  auto runtime = reinterpret_cast<jsi::Runtime*>(jsiPtr);
+  if (runtime) {
+    install(*runtime);
+  }
+  // if runtime was nullptr, MMKV will not be installed. This should only happen while Remote
+  // Debugging (Chrome), but will be weird either way.
 }

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");
   }