react-native-tvos 0.85.2-0 → 0.86.0-0rc2

package/ReactCommon/jsi/jsi/jsi-inl.h

@@ -11,48 +11,48 @@ namespace facebook {
 namespace jsi {
 namespace detail {
 
-inline Value toValue(Runtime&, std::nullptr_t) {
+inline Value toValue(IRuntime&, std::nullptr_t) {
   return Value::null();
 }
-inline Value toValue(Runtime&, bool b) {
+inline Value toValue(IRuntime&, bool b) {
   return Value(b);
 }
-inline Value toValue(Runtime&, double d) {
+inline Value toValue(IRuntime&, double d) {
   return Value(d);
 }
-inline Value toValue(Runtime&, float f) {
+inline Value toValue(IRuntime&, float f) {
   return Value(static_cast<double>(f));
 }
-inline Value toValue(Runtime&, int i) {
+inline Value toValue(IRuntime&, int i) {
   return Value(i);
 }
-inline Value toValue(Runtime& runtime, const char* str) {
+inline Value toValue(IRuntime& runtime, const char* str) {
   return String::createFromAscii(runtime, str);
 }
-inline Value toValue(Runtime& runtime, const std::string& str) {
+inline Value toValue(IRuntime& runtime, const std::string& str) {
   return String::createFromUtf8(runtime, str);
 }
 template <typename T>
-inline Value toValue(Runtime& runtime, const T& other) {
+inline Value toValue(IRuntime& runtime, const T& other) {
   static_assert(
       std::is_base_of<Pointer, T>::value,
       "This type cannot be converted to Value");
   return Value(runtime, other);
 }
-inline Value toValue(Runtime& runtime, const Value& value) {
+inline Value toValue(IRuntime& runtime, const Value& value) {
   return Value(runtime, value);
 }
-inline Value&& toValue(Runtime&, Value&& value) {
+inline Value&& toValue(IRuntime&, Value&& value) {
   return std::move(value);
 }
 
-inline PropNameID toPropNameID(Runtime& runtime, const char* name) {
+inline PropNameID toPropNameID(IRuntime& runtime, const char* name) {
   return PropNameID::forAscii(runtime, name);
 }
-inline PropNameID toPropNameID(Runtime& runtime, const std::string& name) {
+inline PropNameID toPropNameID(IRuntime& runtime, const std::string& name) {
   return PropNameID::forUtf8(runtime, name);
 }
-inline PropNameID&& toPropNameID(Runtime&, PropNameID&& name) {
+inline PropNameID&& toPropNameID(IRuntime&, PropNameID&& name) {
   return std::move(name);
 }
 
@@ -85,107 +85,109 @@ inline const Runtime::PointerValue* Runtime::getPointerValue(
 }
 
 inline void Runtime::setRuntimeData(
-    const UUID& uuid,
+    const UUID& dataUUID,
     const std::shared_ptr<void>& data) {
   auto* dataPtr = new std::shared_ptr<void>(data);
-  setRuntimeDataImpl(uuid, dataPtr, [](const void* data) {
+  setRuntimeDataImpl(dataUUID, dataPtr, [](const void* data) {
     delete (const std::shared_ptr<void>*)data;
   });
 }
 
-inline std::shared_ptr<void> Runtime::getRuntimeData(const UUID& uuid) {
-  auto* data = (const std::shared_ptr<void>*)getRuntimeDataImpl(uuid);
+inline std::shared_ptr<void> Runtime::getRuntimeData(const UUID& dataUUID) {
+  auto* data = (const std::shared_ptr<void>*)getRuntimeDataImpl(dataUUID);
   return data ? *data : nullptr;
 }
 
-Value Object::getPrototype(Runtime& runtime) const {
+Value Object::getPrototype(IRuntime& runtime) const {
   return runtime.getPrototypeOf(*this);
 }
 
-inline Value Object::getProperty(Runtime& runtime, const char* name) const {
+inline Value Object::getProperty(IRuntime& runtime, const char* name) const {
   return getProperty(runtime, String::createFromAscii(runtime, name));
 }
 
-inline Value Object::getProperty(Runtime& runtime, const String& name) const {
+inline Value Object::getProperty(IRuntime& runtime, const String& name) const {
   return runtime.getProperty(*this, name);
 }
 
-inline Value Object::getProperty(Runtime& runtime, const PropNameID& name)
+inline Value Object::getProperty(IRuntime& runtime, const PropNameID& name)
     const {
   return runtime.getProperty(*this, name);
 }
 
-inline Value Object::getProperty(Runtime& runtime, const Value& name) const {
+inline Value Object::getProperty(IRuntime& runtime, const Value& name) const {
   return runtime.getProperty(*this, name);
 }
 
-inline bool Object::hasProperty(Runtime& runtime, const char* name) const {
+inline bool Object::hasProperty(IRuntime& runtime, const char* name) const {
   return hasProperty(runtime, String::createFromAscii(runtime, name));
 }
 
-inline bool Object::hasProperty(Runtime& runtime, const String& name) const {
+inline bool Object::hasProperty(IRuntime& runtime, const String& name) const {
   return runtime.hasProperty(*this, name);
 }
 
-inline bool Object::hasProperty(Runtime& runtime, const PropNameID& name)
+inline bool Object::hasProperty(IRuntime& runtime, const PropNameID& name)
     const {
   return runtime.hasProperty(*this, name);
 }
 
-inline bool Object::hasProperty(Runtime& runtime, const Value& name) const {
+inline bool Object::hasProperty(IRuntime& runtime, const Value& name) const {
   return runtime.hasProperty(*this, name);
 }
 
 template <typename T>
-void Object::setProperty(Runtime& runtime, const char* name, T&& value) const {
+void Object::setProperty(IRuntime& runtime, const char* name, T&& value) const {
   setProperty(
       runtime, String::createFromAscii(runtime, name), std::forward<T>(value));
 }
 
 template <typename T>
-void Object::setProperty(Runtime& runtime, const String& name, T&& value)
+void Object::setProperty(IRuntime& runtime, const String& name, T&& value)
     const {
   setPropertyValue(
       runtime, name, detail::toValue(runtime, std::forward<T>(value)));
 }
 
 template <typename T>
-void Object::setProperty(Runtime& runtime, const PropNameID& name, T&& value)
+void Object::setProperty(IRuntime& runtime, const PropNameID& name, T&& value)
     const {
   setPropertyValue(
       runtime, name, detail::toValue(runtime, std::forward<T>(value)));
 }
 
 template <typename T>
-void Object::setProperty(Runtime& runtime, const Value& name, T&& value) const {
+void Object::setProperty(IRuntime& runtime, const Value& name, T&& value)
+    const {
   setPropertyValue(
       runtime, name, detail::toValue(runtime, std::forward<T>(value)));
 }
 
-inline void Object::deleteProperty(Runtime& runtime, const char* name) const {
+inline void Object::deleteProperty(IRuntime& runtime, const char* name) const {
   deleteProperty(runtime, String::createFromAscii(runtime, name));
 }
 
-inline void Object::deleteProperty(Runtime& runtime, const String& name) const {
+inline void Object::deleteProperty(IRuntime& runtime, const String& name)
+    const {
   runtime.deleteProperty(*this, name);
 }
 
-inline void Object::deleteProperty(Runtime& runtime, const PropNameID& name)
+inline void Object::deleteProperty(IRuntime& runtime, const PropNameID& name)
     const {
   runtime.deleteProperty(*this, name);
 }
 
-inline void Object::deleteProperty(Runtime& runtime, const Value& name) const {
+inline void Object::deleteProperty(IRuntime& runtime, const Value& name) const {
   runtime.deleteProperty(*this, name);
 }
 
-inline Array Object::getArray(Runtime& runtime) const& {
+inline Array Object::getArray(IRuntime& runtime) const& {
   assert(runtime.isArray(*this));
   (void)runtime; // when assert is disabled we need to mark this as used
   return Array(runtime.cloneObject(ptr_));
 }
 
-inline Array Object::getArray(Runtime& runtime) && {
+inline Array Object::getArray(IRuntime& runtime) && {
   assert(runtime.isArray(*this));
   (void)runtime; // when assert is disabled we need to mark this as used
   Runtime::PointerValue* value = ptr_;
@@ -193,13 +195,13 @@ inline Array Object::getArray(Runtime& runtime) && {
   return Array(value);
 }
 
-inline ArrayBuffer Object::getArrayBuffer(Runtime& runtime) const& {
+inline ArrayBuffer Object::getArrayBuffer(IRuntime& runtime) const& {
   assert(runtime.isArrayBuffer(*this));
   (void)runtime; // when assert is disabled we need to mark this as used
   return ArrayBuffer(runtime.cloneObject(ptr_));
 }
 
-inline ArrayBuffer Object::getArrayBuffer(Runtime& runtime) && {
+inline ArrayBuffer Object::getArrayBuffer(IRuntime& runtime) && {
   assert(runtime.isArrayBuffer(*this));
   (void)runtime; // when assert is disabled we need to mark this as used
   Runtime::PointerValue* value = ptr_;
@@ -207,12 +209,22 @@ inline ArrayBuffer Object::getArrayBuffer(Runtime& runtime) && {
   return ArrayBuffer(value);
 }
 
-inline Function Object::getFunction(Runtime& runtime) const& {
+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_));
 }
 
-inline Function Object::getFunction(Runtime& runtime) && {
+inline Function Object::getFunction(IRuntime& runtime) && {
   assert(runtime.isFunction(*this));
   (void)runtime; // when assert is disabled we need to mark this as used
   Runtime::PointerValue* value = ptr_;
@@ -221,24 +233,24 @@ inline Function Object::getFunction(Runtime& runtime) && {
 }
 
 template <typename T>
-inline bool Object::isHostObject(Runtime& runtime) const {
+inline bool Object::isHostObject(IRuntime& runtime) const {
   return runtime.isHostObject(*this) &&
       std::dynamic_pointer_cast<T>(runtime.getHostObject(*this));
 }
 
 template <>
-inline bool Object::isHostObject<HostObject>(Runtime& runtime) const {
+inline bool Object::isHostObject<HostObject>(IRuntime& runtime) const {
   return runtime.isHostObject(*this);
 }
 
 template <typename T>
-inline std::shared_ptr<T> Object::getHostObject(Runtime& runtime) const {
+inline std::shared_ptr<T> Object::getHostObject(IRuntime& runtime) const {
   assert(isHostObject<T>(runtime));
   return std::static_pointer_cast<T>(runtime.getHostObject(*this));
 }
 
 template <typename T>
-inline std::shared_ptr<T> Object::asHostObject(Runtime& runtime) const {
+inline std::shared_ptr<T> Object::asHostObject(IRuntime& runtime) const {
   if (!isHostObject<T>(runtime)) {
     detail::throwOrDie<JSINativeException>(
         "Object is not a HostObject of desired type");
@@ -248,59 +260,59 @@ inline std::shared_ptr<T> Object::asHostObject(Runtime& runtime) const {
 
 template <>
 inline std::shared_ptr<HostObject> Object::getHostObject<HostObject>(
-    Runtime& runtime) const {
+    IRuntime& runtime) const {
   assert(runtime.isHostObject(*this));
   return runtime.getHostObject(*this);
 }
 
 template <typename T>
-inline bool Object::hasNativeState(Runtime& runtime) const {
+inline bool Object::hasNativeState(IRuntime& runtime) const {
   return runtime.hasNativeState(*this) &&
       std::dynamic_pointer_cast<T>(runtime.getNativeState(*this));
 }
 
 template <>
-inline bool Object::hasNativeState<NativeState>(Runtime& runtime) const {
+inline bool Object::hasNativeState<NativeState>(IRuntime& runtime) const {
   return runtime.hasNativeState(*this);
 }
 
 template <typename T>
-inline std::shared_ptr<T> Object::getNativeState(Runtime& runtime) const {
+inline std::shared_ptr<T> Object::getNativeState(IRuntime& runtime) const {
   assert(hasNativeState<T>(runtime));
   return std::static_pointer_cast<T>(runtime.getNativeState(*this));
 }
 
 inline void Object::setNativeState(
-    Runtime& runtime,
+    IRuntime& runtime,
     std::shared_ptr<NativeState> state) const {
   runtime.setNativeState(*this, state);
 }
 
-inline void Object::setExternalMemoryPressure(Runtime& runtime, size_t amt)
+inline void Object::setExternalMemoryPressure(IRuntime& runtime, size_t amt)
     const {
   runtime.setExternalMemoryPressure(*this, amt);
 }
 
-inline Array Object::getPropertyNames(Runtime& runtime) const {
+inline Array Object::getPropertyNames(IRuntime& runtime) const {
   return runtime.getPropertyNames(*this);
 }
 
-inline Value WeakObject::lock(Runtime& runtime) const {
+inline Value WeakObject::lock(IRuntime& runtime) const {
   return runtime.lockWeakObject(*this);
 }
 
 template <typename T>
-void Array::setValueAtIndex(Runtime& runtime, size_t i, T&& value) const {
+void Array::setValueAtIndex(IRuntime& runtime, size_t i, T&& value) const {
   setValueAtIndexImpl(
       runtime, i, detail::toValue(runtime, std::forward<T>(value)));
 }
 
-inline Value Array::getValueAtIndex(Runtime& runtime, size_t i) const {
+inline Value Array::getValueAtIndex(IRuntime& runtime, size_t i) const {
   return runtime.getValueAtIndex(*this, i);
 }
 
 inline Function Function::createFromHostFunction(
-    Runtime& runtime,
+    IRuntime& runtime,
     const jsi::PropNameID& name,
     unsigned int paramCount,
     jsi::HostFunctionType func) {
@@ -308,18 +320,19 @@ inline Function Function::createFromHostFunction(
       name, paramCount, std::move(func));
 }
 
-inline Value Function::call(Runtime& runtime, const Value* args, size_t count)
+inline Value Function::call(IRuntime& runtime, const Value* args, size_t count)
     const {
   return runtime.call(*this, Value::undefined(), args, count);
 }
 
-inline Value Function::call(Runtime& runtime, std::initializer_list<Value> args)
-    const {
+inline Value Function::call(
+    IRuntime& runtime,
+    std::initializer_list<Value> args) const {
   return call(runtime, args.begin(), args.size());
 }
 
 template <typename... Args>
-inline Value Function::call(Runtime& runtime, Args&&... args) const {
+inline Value Function::call(IRuntime& runtime, Args&&... args) const {
   // A more awesome version of this would be able to create raw values
   // which can be used directly without wrapping and unwrapping, but
   // this will do for now.
@@ -327,7 +340,7 @@ inline Value Function::call(Runtime& runtime, Args&&... args) const {
 }
 
 inline Value Function::callWithThis(
-    Runtime& runtime,
+    IRuntime& runtime,
     const Object& jsThis,
     const Value* args,
     size_t count) const {
@@ -335,7 +348,7 @@ inline Value Function::callWithThis(
 }
 
 inline Value Function::callWithThis(
-    Runtime& runtime,
+    IRuntime& runtime,
     const Object& jsThis,
     std::initializer_list<Value> args) const {
   return callWithThis(runtime, jsThis, args.begin(), args.size());
@@ -343,7 +356,7 @@ inline Value Function::callWithThis(
 
 template <typename... Args>
 inline Value Function::callWithThis(
-    Runtime& runtime,
+    IRuntime& runtime,
     const Object& jsThis,
     Args&&... args) const {
   // A more awesome version of this would be able to create raw values
@@ -354,14 +367,30 @@ inline Value Function::callWithThis(
 }
 
 template <typename... Args>
-inline Array Array::createWithElements(Runtime& runtime, Args&&... args) {
+inline Array Array::createWithElements(IRuntime& runtime, Args&&... args) {
   return createWithElements(
       runtime, {detail::toValue(runtime, std::forward<Args>(args))...});
 }
 
+template <typename... Args>
+inline size_t Array::push(IRuntime& runtime, Args&&... args) {
+  return push(runtime, {detail::toValue(runtime, std::forward<Args>(args))...});
+}
+
+inline size_t Array::push(
+    IRuntime& runtime,
+    std::initializer_list<Value> elements) {
+  return push(runtime, elements.begin(), elements.size());
+}
+
+inline size_t
+Array::push(IRuntime& runtime, const Value* elements, size_t count) {
+  return runtime.push(*this, elements, count);
+}
+
 template <typename... Args>
 inline std::vector<PropNameID> PropNameID::names(
-    Runtime& runtime,
+    IRuntime& runtime,
     Args&&... args) {
   return names({detail::toPropNameID(runtime, std::forward<Args>(args))...});
 }
@@ -378,26 +407,26 @@ inline std::vector<PropNameID> PropNameID::names(
 }
 
 inline Value Function::callAsConstructor(
-    Runtime& runtime,
+    IRuntime& runtime,
     const Value* args,
     size_t count) const {
   return runtime.callAsConstructor(*this, args, count);
 }
 
 inline Value Function::callAsConstructor(
-    Runtime& runtime,
+    IRuntime& runtime,
     std::initializer_list<Value> args) const {
   return callAsConstructor(runtime, args.begin(), args.size());
 }
 
 template <typename... Args>
-inline Value Function::callAsConstructor(Runtime& runtime, Args&&... args)
+inline Value Function::callAsConstructor(IRuntime& runtime, Args&&... args)
     const {
   return callAsConstructor(
       runtime, {detail::toValue(runtime, std::forward<Args>(args))...});
 }
 
-String BigInt::toString(Runtime& runtime, int radix) const {
+String BigInt::toString(IRuntime& runtime, int radix) const {
   return runtime.bigintToString(*this, radix);
 }