react-native-quick-crypto 0.7.3 → 1.0.0-beta.1

package/cpp/JSIUtils/MGLJSIUtils.h

@@ -1,41 +0,0 @@
-//
-//  MGLJSIUtils.h
-//  Pods
-//
-//  Created by Oscar on 20.06.22.
-//
-
-#ifndef MGLJSIUtils_h
-#define MGLJSIUtils_h
-
-#include <jsi/jsi.h>
-#include <limits>
-
-namespace jsi = facebook::jsi;
-
-inline bool CheckIsArrayBuffer(jsi::Runtime &runtime, const jsi::Value &value) {
-  return !value.isNull() && !value.isUndefined() && value.isObject() &&
-         value.asObject(runtime).isArrayBuffer(runtime);
-}
-
-inline bool CheckSizeInt32(jsi::Runtime &runtime, jsi::ArrayBuffer &buffer) {
-  return buffer.size(runtime) <= INT_MAX;
-}
-
-inline bool CheckIsInt32(const jsi::Value &value) {
-  if (!value.isNumber()) {
-    return false;
-  }
-  double d = value.asNumber();
-  return (d >= std::numeric_limits<int32_t>::lowest() && d <= std::numeric_limits<int32_t>::max());
-}
-
-inline bool CheckIsUint32(const jsi::Value &value) {
-  if (!value.isNumber()) {
-    return false;
-  }
-  double d = value.asNumber();
-  return (d >= std::numeric_limits<uint32_t>::lowest() && d <= std::numeric_limits<uint32_t>::max());
-}
-
-#endif /* MGLJSIUtils_h */

package/cpp/JSIUtils/MGLSmartHostObject.cpp

@@ -1,43 +0,0 @@
-//
-// Created by Szymon on 24/02/2022.
-//
-
-#include "MGLSmartHostObject.h"
-
-namespace margelo {
-
-namespace jsi = facebook::jsi;
-namespace react = facebook::react;
-
-FieldDefinition buildPair(std::string name, jsi::HostFunctionType &&f) {
-  auto valueBuilder = [f, name](jsi::Runtime &runtime) {
-    const auto func = f;
-    auto propNameID = jsi::PropNameID::forAscii(runtime, name);
-    return jsi::Function::createFromHostFunction(runtime, propNameID, 0, func);
-  };
-  return std::make_pair(name, valueBuilder);
-}
-
-std::vector<jsi::PropNameID> MGLSmartHostObject::getPropertyNames(
-    jsi::Runtime &runtime) {
-  std::vector<jsi::PropNameID> propertyNames;
-  for (auto field : fields) {
-    propertyNames.push_back(jsi::PropNameID::forAscii(runtime, field.first));
-  }
-  return propertyNames;
-}
-
-// TODO(Szymon) maybe add memoization here
-jsi::Value MGLSmartHostObject::get(jsi::Runtime &runtime,
-                                   const jsi::PropNameID &propNameId) {
-  auto name = propNameId.utf8(runtime);
-  for (auto field : fields) {
-    auto fieldName = field.first;
-    if (fieldName == name) {
-      return (field.second)(runtime);
-    }
-  }
-  return jsi::Value::undefined();
-}
-
-}  // namespace margelo

package/cpp/JSIUtils/MGLSmartHostObject.h

@@ -1,46 +0,0 @@
-//
-// Created by Szymon on 24/02/2022.
-//
-
-#ifndef MGL_SMARTHOSTOBJECT_H
-#define MGL_SMARTHOSTOBJECT_H
-
-#include <ReactCommon/TurboModuleUtils.h>
-
-#include <memory>
-#include <string>
-#include <utility>
-#include <vector>
-
-#include "MGLJSIMacros.h"
-#include "MGLThreadAwareHostObject.h"
-
-namespace margelo {
-
-namespace jsi = facebook::jsi;
-namespace react = facebook::react;
-
-typedef std::function<jsi::Value(jsi::Runtime &runtime)> JSIValueBuilder;
-
-typedef std::pair<std::string, JSIValueBuilder> FieldDefinition;
-
-FieldDefinition buildPair(std::string name, jsi::HostFunctionType &&f);
-
-class JSI_EXPORT MGLSmartHostObject : public MGLThreadAwareHostObject {
- public:
-  MGLSmartHostObject(std::shared_ptr<react::CallInvoker> jsCallInvoker,
-                     std::shared_ptr<DispatchQueue::dispatch_queue> workerQueue)
-      : MGLThreadAwareHostObject(jsCallInvoker, workerQueue) {}
-
-  virtual ~MGLSmartHostObject() {}
-
-  std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &runtime);
-
-  jsi::Value get(jsi::Runtime &runtime, const jsi::PropNameID &propNameId);
-
-  std::vector<std::pair<std::string, JSIValueBuilder>> fields;
-};
-
-}  // namespace margelo
-
-#endif  // MGL_SMARTHOSTOBJECT_H

package/cpp/JSIUtils/MGLThreadAwareHostObject.cpp

@@ -1,24 +0,0 @@
-//
-// Created by Szymon on 24/02/2022.
-//
-
-#include "MGLThreadAwareHostObject.h"
-
-#include <utility>
-
-namespace margelo {
-
-namespace jsi = facebook::jsi;
-
-void MGLThreadAwareHostObject::runOnWorkerThread(std::function<void()> &&job) {
-  this->dispatchQueue->dispatch(job);
-}
-
-void MGLThreadAwareHostObject::runOnJSThread(std::function<void()> &&job) {
-  auto callInvoker = this->weakJsCallInvoker.lock();
-  if (callInvoker != nullptr) {
-    callInvoker->invokeAsync(std::move(job));
-  }
-}
-
-}  // namespace margelo

package/cpp/JSIUtils/MGLThreadAwareHostObject.h

@@ -1,43 +0,0 @@
-//
-// Created by Szymon on 24/02/2022.
-//
-
-#ifndef MGL_THREADAWAREHOSTOBJECT_H
-#define MGL_THREADAWAREHOSTOBJECT_H
-
-#include <ReactCommon/CallInvoker.h>
-#include <jsi/jsi.h>
-
-#include <memory>
-
-#ifdef ANDROID
-#include "Utils/MGLDispatchQueue.h"
-#else
-#include "MGLDispatchQueue.h"
-#endif
-
-namespace margelo {
-
-namespace jsi = facebook::jsi;
-namespace react = facebook::react;
-
-class JSI_EXPORT MGLThreadAwareHostObject : public jsi::HostObject {
- public:
-  explicit MGLThreadAwareHostObject(
-      std::shared_ptr<react::CallInvoker> jsCallInvoker,
-      std::shared_ptr<DispatchQueue::dispatch_queue> workerQueue)
-      : weakJsCallInvoker(jsCallInvoker), dispatchQueue(workerQueue) {}
-
-  virtual ~MGLThreadAwareHostObject() {}
-
-  void runOnWorkerThread(std::function<void(void)> &&job);
-  void runOnJSThread(std::function<void(void)> &&job);
-
- protected:
-  std::weak_ptr<react::CallInvoker> weakJsCallInvoker;
-  std::shared_ptr<DispatchQueue::dispatch_queue> dispatchQueue;
-};
-
-}  // namespace margelo
-
-#endif  // MGL_THREADAWAREHOSTOBJECT_H

package/cpp/JSIUtils/MGLTypedArray.cpp

@@ -1,325 +0,0 @@
-//
-//  TypedArray.cpp
-//  react-native-quick-crypto
-//
-//  Created by Marc Rousavy on 31.10.21.
-//  Originally created by Expo (expo-gl)
-//
-
-#include "MGLTypedArray.h"
-
-#include <algorithm>
-#include <memory>
-#include <string>
-#include <unordered_map>
-
-template <MGLTypedArrayKind 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) {
-    if (!this->props[prop]) {
-      this->props[prop] =
-          std::make_unique<jsi::PropNameID>(createProp(runtime, prop));
-    }
-    return *(this->props[prop]);
-  }
-
-  const jsi::PropNameID &getConstructorNameProp(jsi::Runtime &runtime,
-                                                MGLTypedArrayKind kind);
-
-  void invalidate() { props.erase(props.begin(), props.end()); }
-
- private:
-  std::unordered_map<Prop, std::unique_ptr<jsi::PropNameID>> props;
-
-  jsi::PropNameID createProp(jsi::Runtime &runtime, Prop prop);
-};
-
-PropNameIDCache propNameIDCache;
-
-void invalidateJsiPropNameIDCache() { propNameIDCache.invalidate(); }
-
-MGLTypedArrayKind getTypedArrayKindForName(const std::string &name);
-
-MGLTypedArrayBase::MGLTypedArrayBase(jsi::Runtime &runtime, size_t size,
-                                     MGLTypedArrayKind kind)
-    : MGLTypedArrayBase(
-          runtime,
-          runtime.global()
-              .getProperty(runtime, propNameIDCache.getConstructorNameProp(
-                                        runtime, kind))
-              .asObject(runtime)
-              .asFunction(runtime)
-              .callAsConstructor(runtime, {static_cast<double>(size)})
-              .asObject(runtime)) {}
-
-MGLTypedArrayBase::MGLTypedArrayBase(jsi::Runtime &runtime,
-                                     const jsi::Object &obj)
-    : jsi::Object(jsi::Value(runtime, obj).asObject(runtime)) {}
-
-MGLTypedArrayKind MGLTypedArrayBase::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 MGLTypedArrayBase::size(jsi::Runtime &runtime) const {
-  return getProperty(runtime, propNameIDCache.get(runtime, Prop::Length))
-      .asNumber();
-}
-
-size_t MGLTypedArrayBase::length(jsi::Runtime &runtime) const {
-  return getProperty(runtime, propNameIDCache.get(runtime, Prop::Length))
-      .asNumber();
-}
-
-size_t MGLTypedArrayBase::byteLength(jsi::Runtime &runtime) const {
-  return getProperty(runtime, propNameIDCache.get(runtime, Prop::ByteLength))
-      .asNumber();
-}
-
-size_t MGLTypedArrayBase::byteOffset(jsi::Runtime &runtime) const {
-  return getProperty(runtime, propNameIDCache.get(runtime, Prop::ByteOffset))
-      .asNumber();
-}
-
-bool MGLTypedArrayBase::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> MGLTypedArrayBase::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 MGLTypedArrayBase::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");
-  }
-}
-
-MGLTypedArrayBase 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 MGLTypedArrayBase(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 <MGLTypedArrayKind T>
-MGLTypedArray<T>::MGLTypedArray(jsi::Runtime &runtime, size_t size)
-    : MGLTypedArrayBase(runtime, size, T) {}
-
-template <MGLTypedArrayKind T>
-MGLTypedArray<T>::MGLTypedArray(jsi::Runtime &runtime,
-                                std::vector<ContentType<T>> data)
-    : MGLTypedArrayBase(runtime, data.size(), T) {
-  update(runtime, data);
-}
-
-template <MGLTypedArrayKind T>
-MGLTypedArray<T>::MGLTypedArray(MGLTypedArrayBase &&base)
-    : MGLTypedArrayBase(std::move(base)) {}
-
-template <MGLTypedArrayKind T>
-std::vector<ContentType<T>> MGLTypedArray<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 <MGLTypedArrayKind T>
-void MGLTypedArray<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));
-}
-
-const jsi::PropNameID &PropNameIDCache::getConstructorNameProp(
-    jsi::Runtime &runtime, MGLTypedArrayKind kind) {
-  switch (kind) {
-    case MGLTypedArrayKind::Int8Array:
-      return get(runtime, Prop::Int8Array);
-    case MGLTypedArrayKind::Int16Array:
-      return get(runtime, Prop::Int16Array);
-    case MGLTypedArrayKind::Int32Array:
-      return get(runtime, Prop::Int32Array);
-    case MGLTypedArrayKind::Uint8Array:
-      return get(runtime, Prop::Uint8Array);
-    case MGLTypedArrayKind::Uint8ClampedArray:
-      return get(runtime, Prop::Uint8ClampedArray);
-    case MGLTypedArrayKind::Uint16Array:
-      return get(runtime, Prop::Uint16Array);
-    case MGLTypedArrayKind::Uint32Array:
-      return get(runtime, Prop::Uint32Array);
-    case MGLTypedArrayKind::Float32Array:
-      return get(runtime, Prop::Float32Array);
-    case MGLTypedArrayKind::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, MGLTypedArrayKind> nameToKindMap = {
-    {"Int8Array", MGLTypedArrayKind::Int8Array},
-    {"Int16Array", MGLTypedArrayKind::Int16Array},
-    {"Int32Array", MGLTypedArrayKind::Int32Array},
-    {"Uint8Array", MGLTypedArrayKind::Uint8Array},
-    {"Uint8ClampedArray", MGLTypedArrayKind::Uint8ClampedArray},
-    {"Uint16Array", MGLTypedArrayKind::Uint16Array},
-    {"Uint32Array", MGLTypedArrayKind::Uint32Array},
-    {"Float32Array", MGLTypedArrayKind::Float32Array},
-    {"Float64Array", MGLTypedArrayKind::Float64Array},
-};
-
-MGLTypedArrayKind getTypedArrayKindForName(const std::string &name) {
-  return nameToKindMap.at(name);
-}
-
-template class MGLTypedArray<MGLTypedArrayKind::Int8Array>;
-template class MGLTypedArray<MGLTypedArrayKind::Int16Array>;
-template class MGLTypedArray<MGLTypedArrayKind::Int32Array>;
-template class MGLTypedArray<MGLTypedArrayKind::Uint8Array>;
-template class MGLTypedArray<MGLTypedArrayKind::Uint8ClampedArray>;
-template class MGLTypedArray<MGLTypedArrayKind::Uint16Array>;
-template class MGLTypedArray<MGLTypedArrayKind::Uint32Array>;
-template class MGLTypedArray<MGLTypedArrayKind::Float32Array>;
-template class MGLTypedArray<MGLTypedArrayKind::Float64Array>;

package/cpp/JSIUtils/MGLTypedArray.h

@@ -1,160 +0,0 @@
-//
-//  TypedArray.h
-//  react-native-quick-crypto
-//
-//  Created by Marc Rousavy on 31.10.21.
-//  Originally created by Expo (expo-gl)
-//
-
-#pragma once
-
-#include <jsi/jsi.h>
-
-#include <utility>
-#include <vector>
-
-namespace jsi = facebook::jsi;
-
-enum class MGLTypedArrayKind {
-  Int8Array,
-  Int16Array,
-  Int32Array,
-  Uint8Array,
-  Uint8ClampedArray,
-  Uint16Array,
-  Uint32Array,
-  Float32Array,
-  Float64Array,
-};
-
-template <MGLTypedArrayKind T>
-class MGLTypedArray;
-
-template <MGLTypedArrayKind T>
-struct typedArrayTypeMap;
-template <>
-struct typedArrayTypeMap<MGLTypedArrayKind::Int8Array> {
-  typedef int8_t type;
-};
-template <>
-struct typedArrayTypeMap<MGLTypedArrayKind::Int16Array> {
-  typedef int16_t type;
-};
-template <>
-struct typedArrayTypeMap<MGLTypedArrayKind::Int32Array> {
-  typedef int32_t type;
-};
-template <>
-struct typedArrayTypeMap<MGLTypedArrayKind::Uint8Array> {
-  typedef uint8_t type;
-};
-template <>
-struct typedArrayTypeMap<MGLTypedArrayKind::Uint8ClampedArray> {
-  typedef uint8_t type;
-};
-template <>
-struct typedArrayTypeMap<MGLTypedArrayKind::Uint16Array> {
-  typedef uint16_t type;
-};
-template <>
-struct typedArrayTypeMap<MGLTypedArrayKind::Uint32Array> {
-  typedef uint32_t type;
-};
-template <>
-struct typedArrayTypeMap<MGLTypedArrayKind::Float32Array> {
-  typedef float type;
-};
-template <>
-struct typedArrayTypeMap<MGLTypedArrayKind::Float64Array> {
-  typedef double type;
-};
-
-void invalidateJsiPropNameIDCache();
-
-class MGLTypedArrayBase : public jsi::Object {
- public:
-  template <MGLTypedArrayKind T>
-  using ContentType = typename typedArrayTypeMap<T>::type;
-
-  MGLTypedArrayBase(jsi::Runtime &, size_t, MGLTypedArrayKind);
-  MGLTypedArrayBase(jsi::Runtime &, const jsi::Object &);
-  MGLTypedArrayBase(MGLTypedArrayBase &&) = default;
-  MGLTypedArrayBase &operator=(MGLTypedArrayBase &&) = default;
-
-  MGLTypedArrayKind getKind(jsi::Runtime &runtime) const;
-
-  template <MGLTypedArrayKind T>
-  MGLTypedArray<T> get(jsi::Runtime &runtime) const &;
-  template <MGLTypedArrayKind T>
-  MGLTypedArray<T> get(jsi::Runtime &runtime) &&;
-  template <MGLTypedArrayKind T>
-  MGLTypedArray<T> as(jsi::Runtime &runtime) const &;
-  template <MGLTypedArrayKind T>
-  MGLTypedArray<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 <MGLTypedArrayKind>
-  friend class MGLTypedArray;
-};
-
-bool isTypedArray(jsi::Runtime &runtime, const jsi::Object &jsObj);
-MGLTypedArrayBase 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 <MGLTypedArrayKind T>
-class MGLTypedArray : public MGLTypedArrayBase {
- public:
-  MGLTypedArray(jsi::Runtime &runtime, size_t size);
-  MGLTypedArray(jsi::Runtime &runtime, std::vector<ContentType<T>> data);
-  explicit MGLTypedArray(MGLTypedArrayBase &&base);
-  explicit MGLTypedArray(MGLTypedArray &&) = default;
-  MGLTypedArray &operator=(MGLTypedArray &&) = default;
-
-  std::vector<ContentType<T>> toVector(jsi::Runtime &runtime);
-  void update(jsi::Runtime &runtime, const std::vector<ContentType<T>> &data);
-};
-
-template <MGLTypedArrayKind T>
-MGLTypedArray<T> MGLTypedArrayBase::get(jsi::Runtime &runtime) const & {
-  assert(getKind(runtime) == T);
-  (void)runtime;  // when assert is disabled we need to mark this as used
-  return MGLTypedArray<T>(
-      jsi::Value(runtime, jsi::Value(runtime, *this).asObject(runtime)));
-}
-
-template <MGLTypedArrayKind T>
-MGLTypedArray<T> MGLTypedArrayBase::get(jsi::Runtime &runtime) && {
-  assert(getKind(runtime) == T);
-  (void)runtime;  // when assert is disabled we need to mark this as used
-  return MGLTypedArray<T>(std::move(*this));
-}
-
-template <MGLTypedArrayKind T>
-MGLTypedArray<T> MGLTypedArrayBase::as(jsi::Runtime &runtime) const & {
-  if (getKind(runtime) != T) {
-    throw jsi::JSError(runtime, "Object is not a MGLTypedArray");
-  }
-  return get<T>(runtime);
-}
-
-template <MGLTypedArrayKind T>
-MGLTypedArray<T> MGLTypedArrayBase::as(jsi::Runtime &runtime) && {
-  if (getKind(runtime) != T) {
-    throw jsi::JSError(runtime, "Object is not a MGLTypedArray");
-  }
-  return std::move(*this).get<T>(runtime);
-}