Add TypedArray, UInt8Array in JSI (facebook#56158)

Summary:
Pull Request resolved: facebook#56158

Add TypedArray and Uint8Array types to JSI with supporting APIs.

New types:
- `TypedArray`: Base class for all typed arrays
- `Uint8Array`: Uint8Array type extending TypedArray

New IRuntime APIs:
- `getBuffer(TypedArray)`: Get underlying ArrayBuffer
- `getByteOffset(TypedArray)`: Get byte offset property
- `getByteLength(TypedArray)`: Get byte length property
- `getLength(TypedArray)`: Get length property
- `createUint8Array(size_t)`: Create Uint8Array with length
- `createUint8Array(ArrayBuffer, offset, length)`: Create from
  ArrayBuffer
- `isUint8Array(Object)`: Check if object is Uint8Array

Changelog: [Internal]

Reviewed By: lavenzg

Differential Revision: D95245175

Author: tsaichien

packages/react-native/ReactCommon/jsi/jsi/decorator.h

@@ -356,6 +356,12 @@ class RuntimeDecorator : public Base, private jsi::Instrumentation {
   bool isArrayBuffer(const Object& o) const override {
     return plain_.isArrayBuffer(o);
   }
+  bool isTypedArray(const Object& o) const override {
+    return plain_.isTypedArray(o);
+  }
+  bool isUint8Array(const Object& o) const override {
+    return plain_.isUint8Array(o);
+  }
   bool isFunction(const Object& o) const override {
     return plain_.isFunction(o);
   }
@@ -442,6 +448,30 @@ class RuntimeDecorator : public Base, private jsi::Instrumentation {
     return plain_.tryGetMutableBuffer(arrayBuffer);
   }
 
+  ArrayBuffer buffer(const TypedArray& typedArray) override {
+    return plain_.buffer(typedArray);
+  }
+  size_t byteOffset(const TypedArray& typedArray) override {
+    return plain_.byteOffset(typedArray);
+  }
+  size_t byteLength(const TypedArray& typedArray) override {
+    return plain_.byteLength(typedArray);
+  }
+  size_t length(const TypedArray& typedArray) override {
+    return plain_.length(typedArray);
+  }
+
+  Uint8Array createUint8Array(size_t length) override {
+    return plain_.createUint8Array(length);
+  }
+
+  Uint8Array createUint8Array(
+      const ArrayBuffer& buffer,
+      size_t offset,
+      size_t length) override {
+    return plain_.createUint8Array(buffer, offset, length);
+  }
+
   // Private data for managing scopes.
   Runtime::ScopeState* pushScope() override {
     return plain_.pushScope();
@@ -926,6 +956,14 @@ class WithRuntimeDecorator : public RuntimeDecorator<Plain, Base> {
     Around around{with_};
     return RD::isArrayBuffer(o);
   }
+  bool isTypedArray(const Object& o) const override {
+    Around around{with_};
+    return RD::isTypedArray(o);
+  }
+  bool isUint8Array(const Object& o) const override {
+    Around around{with_};
+    return RD::isUint8Array(o);
+  }
   bool isFunction(const Object& o) const override {
     Around around{with_};
     return RD::isFunction(o);
@@ -1018,6 +1056,35 @@ class WithRuntimeDecorator : public RuntimeDecorator<Plain, Base> {
     return RD::tryGetMutableBuffer(arrayBuffer);
   }
 
+  ArrayBuffer buffer(const TypedArray& typedArray) override {
+    Around around{with_};
+    return RD::buffer(typedArray);
+  }
+  size_t byteOffset(const TypedArray& typedArray) override {
+    Around around{with_};
+    return RD::byteOffset(typedArray);
+  }
+  size_t byteLength(const TypedArray& typedArray) override {
+    Around around{with_};
+    return RD::byteLength(typedArray);
+  }
+  size_t length(const TypedArray& typedArray) override {
+    Around around{with_};
+    return RD::length(typedArray);
+  }
+
+  Uint8Array createUint8Array(size_t length) override {
+    Around around{with_};
+    return RD::createUint8Array(length);
+  }
+  Uint8Array createUint8Array(
+      const ArrayBuffer& buffer,
+      size_t offset,
+      size_t length) override {
+    Around around{with_};
+    return RD::createUint8Array(buffer, offset, length);
+  }
+
   // Private data for managing scopes.
   Runtime::ScopeState* pushScope() override {
     Around around{with_};

packages/react-native/ReactCommon/jsi/jsi/jsi-inl.h

@@ -209,6 +209,16 @@ inline ArrayBuffer Object::getArrayBuffer(IRuntime& runtime) && {
   return ArrayBuffer(value);
 }
 
+inline TypedArray Object::getTypedArray(IRuntime& runtime) const& {
+  assert(runtime.isTypedArray(*this));
+  return TypedArray(runtime.cloneObject(ptr_));
+}
+
+inline Uint8Array Object::getUint8Array(IRuntime& runtime) const& {
+  assert(runtime.isUint8Array(*this));
+  return Uint8Array(runtime.cloneObject(ptr_));
+}
+
 inline Function Object::getFunction(IRuntime& runtime) const& {
   assert(runtime.isFunction(*this));
   return Function(runtime.cloneObject(ptr_));

packages/react-native/ReactCommon/jsi/jsi/jsi.cpp

@@ -557,6 +557,23 @@ std::shared_ptr<MutableBuffer> Runtime::tryGetMutableBuffer(
   return nullptr;
 }
 
+Uint8Array Runtime::createUint8Array(size_t length) {
+  auto uint8ArrayCtor = global().getPropertyAsFunction(*this, "Uint8Array");
+  auto result =
+      uint8ArrayCtor.callAsConstructor(*this, static_cast<int>(length));
+  return Uint8Array(cloneObject(getPointerValue(result.getObject(*this))));
+}
+
+Uint8Array Runtime::createUint8Array(
+    const ArrayBuffer& buffer,
+    size_t offset,
+    size_t length) {
+  auto uint8ArrayCtor = global().getPropertyAsFunction(*this, "Uint8Array");
+  auto result = uint8ArrayCtor.callAsConstructor(
+      *this, buffer, static_cast<int>(offset), static_cast<int>(length));
+  return Uint8Array(cloneObject(getPointerValue(result.getObject(*this))));
+}
+
 bool Runtime::detached(const ArrayBuffer& buffer) {
   Value prop = buffer.getProperty(*this, "detached");
   if (!prop.isBool()) {
@@ -566,6 +583,57 @@ bool Runtime::detached(const ArrayBuffer& buffer) {
   return prop.getBool();
 }
 
+ArrayBuffer Runtime::buffer(const TypedArray& typedArray) {
+  Value buffer = typedArray.getProperty(*this, "buffer");
+  if (!buffer.isObject()) {
+    throw JSINativeException("TypedArray.buffer is not an object");
+  }
+  Object bufferObj = buffer.getObject(*this);
+  if (!bufferObj.isArrayBuffer(*this)) {
+    throw JSINativeException("TypedArray.buffer is not an ArrayBuffer");
+  }
+  return bufferObj.getArrayBuffer(*this);
+}
+
+size_t Runtime::byteOffset(const TypedArray& typedArray) {
+  Value byteOffset = typedArray.getProperty(*this, "byteOffset");
+  if (!byteOffset.isNumber()) {
+    throw JSINativeException("TypedArray.byteOffset is not a number");
+  }
+  return static_cast<size_t>(byteOffset.getNumber());
+}
+
+size_t Runtime::byteLength(const TypedArray& typedArray) {
+  Value byteLength = typedArray.getProperty(*this, "byteLength");
+  if (!byteLength.isNumber()) {
+    throw JSINativeException("TypedArray.byteLength is not a number");
+  }
+  return static_cast<size_t>(byteLength.getNumber());
+}
+
+size_t Runtime::length(const TypedArray& typedArray) {
+  Value length = typedArray.getProperty(*this, "length");
+  if (!length.isNumber()) {
+    throw JSINativeException("TypedArray.length is not a number");
+  }
+  return static_cast<size_t>(length.getNumber());
+}
+
+bool Runtime::isTypedArray(const Object& obj) const {
+  Runtime& self = const_cast<Runtime&>(*this);
+  // Uint8Array.__proto__ is the %TypedArray% intrinsic constructor.
+  auto uint8ArrayCtor = self.global().getPropertyAsFunction(self, "Uint8Array");
+  auto typedArrayCtor =
+      uint8ArrayCtor.getProperty(self, "__proto__").getObject(self);
+  return self.instanceOf(obj, typedArrayCtor.getFunction(self));
+}
+
+bool Runtime::isUint8Array(const Object& obj) const {
+  Runtime& self = const_cast<Runtime&>(*this);
+  auto uint8ArrayCtor = self.global().getPropertyAsFunction(self, "Uint8Array");
+  return self.instanceOf(obj, uint8ArrayCtor);
+}
+
 Pointer& Pointer::operator=(Pointer&& other) noexcept {
   if (ptr_) {
     ptr_->invalidate();
@@ -641,6 +709,26 @@ Function Object::asFunction(IRuntime& runtime) && {
   return std::move(*this).getFunction(runtime);
 }
 
+TypedArray Object::asTypedArray(IRuntime& runtime) const& {
+  if (!isTypedArray(runtime)) {
+    throw JSError(
+        runtime,
+        "Object is " + kindToString(Value(runtime, *this), &runtime) +
+            ", expected a TypedArray");
+  }
+  return getTypedArray(runtime);
+}
+
+Uint8Array Object::asUint8Array(IRuntime& runtime) const& {
+  if (!isUint8Array(runtime)) {
+    throw JSError(
+        runtime,
+        "Object is " + kindToString(Value(runtime, *this), &runtime) +
+            ", expected a Uint8Array");
+  }
+  return getUint8Array(runtime);
+}
+
 Value::Value(Value&& other) noexcept : Value(other.kind_) {
   if (kind_ == BooleanKind) {
     data_.boolean = other.data_.boolean;

packages/react-native/ReactCommon/jsi/jsi/jsi.h

@@ -199,6 +199,8 @@ class Instrumentation;
 class Scope;
 class JSIException;
 class JSError;
+class TypedArray;
+class Uint8Array;
 
 /// A function which has this type can be registered as a function
 /// callable from JavaScript using Function::createFromHostFunction().
@@ -549,6 +551,8 @@ class JSI_EXPORT IRuntime : public ICast {
 
   virtual bool isArray(const Object&) const = 0;
   virtual bool isArrayBuffer(const Object&) const = 0;
+  virtual bool isTypedArray(const Object&) const = 0;
+  virtual bool isUint8Array(const Object&) const = 0;
   virtual bool isFunction(const Object&) const = 0;
   virtual bool isHostObject(const jsi::Object&) const = 0;
   virtual bool isHostFunction(const jsi::Function&) const = 0;
@@ -637,6 +641,22 @@ class JSI_EXPORT IRuntime : public ICast {
   virtual std::shared_ptr<MutableBuffer> tryGetMutableBuffer(
       const jsi::ArrayBuffer& arrayBuffer) = 0;
 
+  /// \return the underlying buffer of the \p typedArray.
+  virtual ArrayBuffer buffer(const TypedArray& typedArray) = 0;
+  /// \return the 'byteOffset' property of the \p typedArray.
+  virtual size_t byteOffset(const TypedArray& typedArray) = 0;
+  /// \return the 'byteLength' property of the \p typedArray.
+  virtual size_t byteLength(const TypedArray& typedArray) = 0;
+  /// \return the 'length; property of the \p typedArray.
+  virtual size_t length(const TypedArray& typedArray) = 0;
+
+  /// Create a JS UInt8Array with length \p length.
+  virtual Uint8Array createUint8Array(size_t length) = 0;
+  /// Create a JS UInt8Array using the ArrayBuffer \p buffer starting at byte
+  /// offset \p offset and length \p length.
+  virtual Uint8Array
+  createUint8Array(const ArrayBuffer& buffer, size_t offset, size_t length) = 0;
+
  protected:
   virtual ~IRuntime() = default;
 };
@@ -727,6 +747,19 @@ class JSI_EXPORT Runtime : public IRuntime {
 
   bool detached(const ArrayBuffer&) override;
 
+  ArrayBuffer buffer(const TypedArray& typedArray) override;
+  size_t byteOffset(const TypedArray& typedArray) override;
+  size_t byteLength(const TypedArray& typedArray) override;
+  size_t length(const TypedArray& typedArray) override;
+
+  bool isTypedArray(const Object&) const override;
+  bool isUint8Array(const Object&) const override;
+  Uint8Array createUint8Array(size_t length) override;
+  Uint8Array createUint8Array(
+      const ArrayBuffer& buffer,
+      size_t offset,
+      size_t length) override;
+
  protected:
   friend class Pointer;
   friend class PropNameID;
@@ -1214,6 +1247,18 @@ class JSI_EXPORT Object : public Pointer {
     return runtime.isArrayBuffer(*this);
   }
 
+  /// \return true iff the Object is a TypedArray (Uint8Array, Int32Array,
+  /// Float64Array, etc.). If so, then \c getTypedArray() will succeed.
+  bool isTypedArray(IRuntime& runtime) const {
+    return runtime.isTypedArray(*this);
+  }
+
+  /// \return true iff the Object is an Uint8Array. If so, then \c
+  /// getUint8Array() will succeed
+  bool isUint8Array(IRuntime& runtime) const {
+    return runtime.isUint8Array(*this);
+  }
+
   /// \return true iff the Object is callable.  If so, then \c
   /// getFunction will succeed.
   bool isFunction(IRuntime& runtime) const {
@@ -1244,6 +1289,16 @@ class JSI_EXPORT Object : public Pointer {
   /// JSIException.
   Array asArray(IRuntime& runtime) &&;
 
+  /// \return a TypedArray instance which refers to the same underlying
+  /// object. If \c isTypedArray() would return false, this will throw
+  /// JSIException.
+  TypedArray asTypedArray(IRuntime& runtime) const&;
+
+  /// \return an Uint8Array instance which refers to the same underlying
+  /// object. If \c isUint8Array() would return false, this will throw
+  /// JSIException.
+  Uint8Array asUint8Array(IRuntime& runtime) const&;
+
   /// \return an ArrayBuffer instance which refers to the same underlying
   /// object.  If \c isArrayBuffer() would return false, this will assert.
   ArrayBuffer getArrayBuffer(IRuntime& runtime) const&;
@@ -1252,6 +1307,14 @@ class JSI_EXPORT Object : public Pointer {
   /// object.  If \c isArrayBuffer() would return false, this will assert.
   ArrayBuffer getArrayBuffer(IRuntime& runtime) &&;
 
+  /// \return a TypedArray instance which refers to the same underlying
+  /// object. If \c isTypedArray() would return false, this will assert.
+  TypedArray getTypedArray(IRuntime& runtime) const&;
+
+  /// \return an Uint8Array instance which refers to the same underlying
+  /// object. If \c isUint8Array() would return false, this will assert.
+  Uint8Array getUint8Array(IRuntime& runtime) const&;
+
   /// \return a Function instance which refers to the same underlying
   /// object.  If \c isFunction() would return false, this will assert.
   Function getFunction(IRuntime& runtime) const&;
@@ -1601,6 +1664,64 @@ class JSI_EXPORT Function : public Object {
   Function(Runtime::PointerValue* value) : Object(value) {}
 };
 
+/// Represents a JS TypedArray
+class JSI_EXPORT TypedArray : public Object {
+ public:
+  TypedArray(TypedArray&&) = default;
+  TypedArray& operator=(TypedArray&&) = default;
+
+  // Gets the buffer of this TypedArray
+  ArrayBuffer buffer(IRuntime& runtime) {
+    return runtime.buffer(*this);
+  }
+
+  // Gets the byte offset of this TypedArray
+  size_t byteOffset(IRuntime& runtime) {
+    return runtime.byteOffset(*this);
+  }
+
+  // Gets the byte length of this TypedArray
+  size_t byteLength(IRuntime& runtime) {
+    return runtime.byteLength(*this);
+  }
+
+  // Gets the element length of this TypedArray
+  size_t length(IRuntime& runtime) {
+    return runtime.length(*this);
+  }
+
+ private:
+  friend class Object;
+  friend class Value;
+  friend class Runtime;
+  friend class Uint8Array;
+
+  explicit TypedArray(Runtime::PointerValue* value) : Object(value) {}
+};
+
+// Represents a JS Uint8Array
+class JSI_EXPORT Uint8Array : public TypedArray {
+ public:
+  Uint8Array(Uint8Array&&) = default;
+  Uint8Array& operator=(Uint8Array&&) = default;
+
+  Uint8Array(IRuntime& runtime, size_t length)
+      : Uint8Array(runtime.createUint8Array(length)) {}
+  Uint8Array(
+      IRuntime& runtime,
+      const ArrayBuffer& buffer,
+      size_t offset,
+      size_t length)
+      : Uint8Array(runtime.createUint8Array(buffer, offset, length)) {}
+
+ private:
+  friend class Object;
+  friend class Value;
+  friend class Runtime;
+
+  explicit Uint8Array(Runtime::PointerValue* value) : TypedArray(value) {}
+};
+
 /// Represents any JS Value (undefined, null, boolean, number, symbol,
 /// string, or object).  Movable, or explicitly copyable (has no copy
 /// ctor).