react-native-tvos 0.87.1-0 → 0.88.0-0rc2

package/ReactAndroid/src/main/jni/react/featureflags/JReactNativeFeatureFlagsCxxInterop.h

@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @generated SignedSource<<b4ad11ddb9d9beb0a8b3ae326d45dd97>>
+ * @generated SignedSource<<c17b71e1b754ff1773bb370681de06e4>>
  */
 
 /**
@@ -66,15 +66,15 @@ class JReactNativeFeatureFlagsCxxInterop
   static bool enableAccumulatedUpdatesInRawPropsAndroid(
     facebook::jni::alias_ref<JReactNativeFeatureFlagsCxxInterop>);
 
-  static bool enableAndroidFontWeightAdjustment(
-    facebook::jni::alias_ref<JReactNativeFeatureFlagsCxxInterop>);
-
   static bool enableAndroidTextMeasurementOptimizations(
     facebook::jni::alias_ref<JReactNativeFeatureFlagsCxxInterop>);
 
   static bool enableBridgelessArchitecture(
     facebook::jni::alias_ref<JReactNativeFeatureFlagsCxxInterop>);
 
+  static bool enableBufferedCallInvoker(
+    facebook::jni::alias_ref<JReactNativeFeatureFlagsCxxInterop>);
+
   static bool enableCppPropsIteratorSetter(
     facebook::jni::alias_ref<JReactNativeFeatureFlagsCxxInterop>);
 
@@ -117,9 +117,15 @@ class JReactNativeFeatureFlagsCxxInterop
   static bool enableImagePrefetchingAndroid(
     facebook::jni::alias_ref<JReactNativeFeatureFlagsCxxInterop>);
 
+  static bool enableImageTransparentTintColor(
+    facebook::jni::alias_ref<JReactNativeFeatureFlagsCxxInterop>);
+
   static bool enableImmediateUpdateModeForContentOffsetChanges(
     facebook::jni::alias_ref<JReactNativeFeatureFlagsCxxInterop>);
 
+  static bool enableImperativeEvents(
+    facebook::jni::alias_ref<JReactNativeFeatureFlagsCxxInterop>);
+
   static bool enableImperativeFocus(
     facebook::jni::alias_ref<JReactNativeFeatureFlagsCxxInterop>);
 
@@ -141,13 +147,13 @@ class JReactNativeFeatureFlagsCxxInterop
   static bool enableModuleArgumentNSNullConversionIOS(
     facebook::jni::alias_ref<JReactNativeFeatureFlagsCxxInterop>);
 
-  static bool enableMutationObserverByDefault(
+  static bool enableMountingCoordinatorPullModelAndroid(
     facebook::jni::alias_ref<JReactNativeFeatureFlagsCxxInterop>);
 
-  static bool enableNativeCSSParsing(
+  static bool enableMutationObserverByDefault(
     facebook::jni::alias_ref<JReactNativeFeatureFlagsCxxInterop>);
 
-  static bool enableNetworkEventReporting(
+  static bool enableNativeCSSParsing(
     facebook::jni::alias_ref<JReactNativeFeatureFlagsCxxInterop>);
 
   static bool enablePreparedTextLayout(
@@ -156,10 +162,7 @@ class JReactNativeFeatureFlagsCxxInterop
   static bool enablePropsUpdateReconciliationAndroid(
     facebook::jni::alias_ref<JReactNativeFeatureFlagsCxxInterop>);
 
-  static bool enableRuntimeSchedulerQueueClearingOnError(
-    facebook::jni::alias_ref<JReactNativeFeatureFlagsCxxInterop>);
-
-  static bool enableSchedulerDelegateInvalidation(
+  static bool enableResizeObserverByDefault(
     facebook::jni::alias_ref<JReactNativeFeatureFlagsCxxInterop>);
 
   static bool enableSwiftUIBasedFilters(
@@ -204,10 +207,10 @@ class JReactNativeFeatureFlagsCxxInterop
   static bool fuseboxFrameRecordingEnabled(
     facebook::jni::alias_ref<JReactNativeFeatureFlagsCxxInterop>);
 
-  static bool fuseboxNetworkInspectionEnabled(
+  static bool fuseboxScreenshotCaptureEnabled(
     facebook::jni::alias_ref<JReactNativeFeatureFlagsCxxInterop>);
 
-  static bool fuseboxScreenshotCaptureEnabled(
+  static bool fuseboxWebSocketEventsEnabled(
     facebook::jni::alias_ref<JReactNativeFeatureFlagsCxxInterop>);
 
   static bool optimizedAnimatedPropUpdates(

package/ReactAndroid/src/main/jni/react/jni/CMakeLists.txt

@@ -23,6 +23,7 @@ include(${REACT_ANDROID_DIR}/src/main/jni/first-party/jni-lib-merge/SoMerging-ut
 add_library(
         reactnativejni_common
         OBJECT
+          JArrayBuffer.cpp
           JDynamicNative.cpp
           JReactMarker.cpp
           NativeArray.cpp
@@ -38,7 +39,7 @@ add_library(
 target_merge_so(reactnativejni_common)
 target_include_directories(reactnativejni_common PUBLIC ../../)
 
-target_link_libraries(reactnativejni_common fbjni folly_runtime react_cxxreact rrc_view)
+target_link_libraries(reactnativejni_common fbjni folly_runtime react_bridging react_cxxreact rrc_view)
 target_compile_reactnative_options(reactnativejni_common PRIVATE)
 target_compile_options(reactnativejni_common PRIVATE -Wno-unused-lambda-capture)
 

package/ReactAndroid/src/main/jni/react/jni/JArrayBuffer.cpp

@@ -0,0 +1,129 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include "JArrayBuffer.h"
+
+#include <cstring>
+#include <span>
+#include <stdexcept>
+#include <utility>
+#include <vector>
+
+#include <react/bridging/ArrayBuffer.h>
+
+#include "JByteBufferMutableBuffer.h"
+
+namespace facebook::react {
+
+namespace {
+
+const char* const kRevokedBorrowMessage =
+    "com.facebook.react.bridge.ArrayBuffer: the bytes of a non-owning ArrayBuffer "
+    "were accessed after the method that received it returned. Copy them with "
+    "ArrayBuffer.arrayBufferWithCopiedBytes() to use them later.";
+
+} // namespace
+
+void JArrayBuffer::registerNatives() {
+  registerHybrid({
+      makeNativeMethod("initHybrid", JArrayBuffer::initHybrid),
+      makeNativeMethod("isBytesValid", JArrayBuffer::isBytesValid),
+  });
+}
+
+void JArrayBuffer::initHybrid(
+    jni::alias_ref<jhybridobject> jobj,
+    jni::alias_ref<jni::JByteBuffer> buffer,
+    jboolean owningBytes) {
+  setCxxInstance(
+      jobj,
+      std::make_shared<JByteBufferMutableBuffer>(buffer),
+      owningBytes != JNI_FALSE);
+}
+
+jboolean JArrayBuffer::isBytesValid() {
+  return hasBytes() ? JNI_TRUE : JNI_FALSE;
+}
+
+void JArrayBuffer::invalidate() noexcept {
+  if (!owningBytes_) {
+    buffer_.reset();
+  }
+}
+
+const std::shared_ptr<jsi::MutableBuffer>& JArrayBuffer::mutableBuffer() const {
+  if (!hasBytes()) {
+    throw std::runtime_error(kRevokedBorrowMessage);
+  }
+  return buffer_;
+}
+
+jni::local_ref<JArrayBuffer::javaobject> JArrayBuffer::create(
+    jni::local_ref<jni::JByteBuffer> byteBuffer,
+    std::shared_ptr<jsi::MutableBuffer> buffer,
+    bool owningBytes) {
+  auto cxxPart = std::make_unique<JArrayBuffer>(std::move(buffer), owningBytes);
+  auto javaPart = newObjectJavaArgs(byteBuffer, owningBytes);
+  setNativePointer(javaPart, std::move(cxxPart));
+  return javaPart;
+}
+
+jni::local_ref<JArrayBuffer::javaobject> JArrayBuffer::createOwning(
+    std::shared_ptr<jsi::MutableBuffer> buffer) {
+  auto byteBuffer = jni::JByteBuffer::wrapBytes(buffer->data(), buffer->size());
+  return create(std::move(byteBuffer), std::move(buffer), true);
+}
+
+jni::local_ref<JArrayBuffer::javaobject> JArrayBuffer::createUnowned(
+    void* bytes,
+    size_t size) {
+  auto byteBuffer =
+      jni::JByteBuffer::wrapBytes(static_cast<uint8_t*>(bytes), size);
+  auto buffer = std::make_shared<JByteBufferMutableBuffer>(byteBuffer);
+  return create(std::move(byteBuffer), std::move(buffer), false);
+}
+
+jni::local_ref<JArrayBuffer::javaobject> JArrayBuffer::createOwned(
+    const void* bytes,
+    size_t size) {
+  auto byteBuffer = jni::JByteBuffer::allocateDirect(static_cast<jint>(size));
+  if (size > 0 && bytes != nullptr) {
+    // @lint-ignore CLANGSECURITY facebook-security-vulnerable-memcpy
+    std::memcpy(byteBuffer->getDirectBytes(), bytes, size);
+  }
+
+  auto buffer = std::make_shared<JByteBufferMutableBuffer>(byteBuffer);
+  return create(std::move(byteBuffer), std::move(buffer), true);
+}
+
+std::shared_ptr<jsi::MutableBuffer> JArrayBuffer::toJSBuffer(
+    jsi::Runtime& runtime,
+    jni::alias_ref<javaobject> arrayBuffer) {
+  auto* self = arrayBuffer->cthis();
+  // create() runs the Kotlin constructor before setNativePointer, so a Java
+  // ArrayBuffer without a C++ peer is reachable if either step throws.
+  if (self == nullptr) {
+    throw jsi::JSError(
+        runtime, "com.facebook.react.bridge.ArrayBuffer has no native peer.");
+  }
+  if (!self->hasBytes()) {
+    throw jsi::JSError(runtime, kRevokedBorrowMessage);
+  }
+
+  const auto& buffer = self->mutableBuffer();
+  if (self->owningBytes_) {
+    return buffer;
+  }
+
+  // Borrowed bytes still belong to the inbound JS ArrayBuffer; copy them before
+  // handing a new buffer back to JS.
+  auto bytes = std::span<uint8_t>(buffer->data(), buffer->size());
+  return std::make_shared<detail::OwnedBytesBuffer>(
+      std::vector<uint8_t>(bytes.begin(), bytes.end()));
+}
+
+} // namespace facebook::react

package/ReactAndroid/src/main/jni/react/jni/JArrayBuffer.h

@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <memory>
+
+#include <fbjni/ByteBuffer.h>
+#include <fbjni/fbjni.h>
+#include <jsi/jsi.h>
+
+namespace facebook::react {
+
+// JNI side of com.facebook.react.bridge.ArrayBuffer.
+//
+// When owningBytes_ is true, the module may retain the buffer and return it to
+// JS without copying. When false, the bytes were borrowed from a JS-heap
+// ArrayBuffer for a synchronous call only.
+class JArrayBuffer : public jni::HybridClass<JArrayBuffer> {
+ public:
+  static constexpr auto kJavaDescriptor = "Lcom/facebook/react/bridge/ArrayBuffer;";
+
+  static void registerNatives();
+
+  // JS ArrayBuffer with a native MutableBuffer (tryGetMutableBuffer). Retain
+  // the owner so the bytes stay valid after the call.
+  static jni::local_ref<javaobject> createOwning(std::shared_ptr<jsi::MutableBuffer> buffer);
+
+  // JS-heap bytes passed to a synchronous call. Zero-copy for the call only;
+  // do not retain the result.
+  static jni::local_ref<javaobject> createUnowned(void *bytes, size_t size);
+
+  // Copy JS-heap bytes into a new owned buffer. Used for async/promise calls
+  // and anywhere the module needs its own copy of the data.
+  static jni::local_ref<javaobject> createOwned(const void *bytes, size_t size);
+
+  // Convert a module return value for rt.createArrayBuffer. Owning buffers pass
+  // through; borrowed ones are copied because createArrayBuffer needs its own
+  // backing store. Raises a jsi::JSError if the buffer has no native peer or
+  // its borrow has been revoked.
+  static std::shared_ptr<jsi::MutableBuffer> toJSBuffer(jsi::Runtime &runtime, jni::alias_ref<javaobject> arrayBuffer);
+
+  // Revokes access to borrowed bytes. Called when the call frame that lent the
+  // bytes unwinds, so a module that retained a non-owning ArrayBuffer gets an
+  // exception instead of reading memory the JS heap has moved or freed. Owning
+  // buffers are unaffected.
+  void invalidate() noexcept;
+
+  // The bytes this buffer was created over. Throws if a borrow has since been
+  // revoked by invalidate().
+  const std::shared_ptr<jsi::MutableBuffer> &mutableBuffer() const;
+
+  // Whether the bytes are still reachable, i.e. this is an owning buffer or a
+  // borrow that invalidate() has not revoked.
+  bool hasBytes() const noexcept
+  {
+    return buffer_ != nullptr;
+  }
+
+  bool isOwningBytes() const noexcept
+  {
+    return owningBytes_;
+  }
+
+  JArrayBuffer(std::shared_ptr<jsi::MutableBuffer> buffer, bool owningBytes) noexcept
+      : buffer_(std::move(buffer)), owningBytes_(owningBytes)
+  {
+  }
+
+ private:
+  friend HybridBase;
+
+  static void
+  initHybrid(jni::alias_ref<jhybridobject> jobj, jni::alias_ref<jni::JByteBuffer> buffer, jboolean owningBytes);
+
+  jboolean isBytesValid();
+
+  static jni::local_ref<javaobject>
+  create(jni::local_ref<jni::JByteBuffer> byteBuffer, std::shared_ptr<jsi::MutableBuffer> buffer, bool owningBytes);
+
+  std::shared_ptr<jsi::MutableBuffer> buffer_;
+  bool owningBytes_;
+};
+
+} // namespace facebook::react

package/ReactAndroid/src/main/jni/react/jni/JByteBufferMutableBuffer.h

@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <fbjni/ByteBuffer.h>
+#include <fbjni/fbjni.h>
+#include <jsi/jsi.h>
+
+namespace facebook::react {
+
+// Wraps a direct Java ByteBuffer as a jsi::MutableBuffer for zero-copy JS
+// ArrayBuffer access. The global ref keeps the Java object alive for as long as
+// the JS ArrayBuffer is reachable.
+//
+// IMPORTANT: jsi::MutableBuffer finalizers run on the Hermes GC background
+// thread, which is not attached to JNI. Destroying a jni::global_ref on an
+// unattached thread calls abort(). jni::ThreadScope in the destructor attaches
+// the GC thread temporarily, making the global_ref teardown safe.
+class JByteBufferMutableBuffer final : public jsi::MutableBuffer {
+ public:
+  explicit JByteBufferMutableBuffer(jni::alias_ref<jni::JByteBuffer> byteBuffer)
+      : byteBuffer_(jni::make_global(byteBuffer))
+  {
+  }
+
+  ~JByteBufferMutableBuffer() override
+  {
+    jni::ThreadScope threadScope;
+    byteBuffer_.reset();
+  }
+
+  JByteBufferMutableBuffer(const JByteBufferMutableBuffer &) = delete;
+  JByteBufferMutableBuffer &operator=(const JByteBufferMutableBuffer &) = delete;
+  JByteBufferMutableBuffer(JByteBufferMutableBuffer &&) = delete;
+  JByteBufferMutableBuffer &operator=(JByteBufferMutableBuffer &&) = delete;
+
+  size_t size() const override
+  {
+    return byteBuffer_->getDirectSize();
+  }
+  uint8_t *data() override
+  {
+    // GetDirectBufferAddress may report null for a zero-capacity direct buffer,
+    // which getDirectBytes turns into an exception. An empty buffer has no bytes
+    // to address, so report that directly instead.
+    if (byteBuffer_->getDirectSize() == 0) {
+      return nullptr;
+    }
+    return byteBuffer_->getDirectBytes();
+  }
+
+ private:
+  jni::global_ref<jni::JByteBuffer> byteBuffer_;
+};
+
+} // namespace facebook::react

package/ReactAndroid/src/main/jni/react/jni/JDynamicNative.cpp

@@ -17,7 +17,7 @@ jboolean JDynamicNative::isNullNative() {
   return static_cast<jboolean>(payload_.isNull());
 }
 
-jni::local_ref<ReadableType> JDynamicNative::getTypeNative() {
+jni::alias_ref<ReadableType> JDynamicNative::getTypeNative() {
   return ReadableType::getType(payload_.type());
 }
 

package/ReactAndroid/src/main/jni/react/jni/JDynamicNative.h

@@ -42,7 +42,7 @@ class JDynamicNative : public jni::HybridClass<JDynamicNative, JDynamic> {
  private:
   friend HybridBase;
 
-  jni::local_ref<ReadableType> getTypeNative();
+  jni::alias_ref<ReadableType> getTypeNative();
   jni::local_ref<jstring> asString();
   jboolean asBoolean();
   jdouble asDouble();

package/ReactAndroid/src/main/jni/react/jni/JavaModuleWrapper.cpp

@@ -20,6 +20,7 @@
 #include <fbsystrace.h>
 #endif
 
+#include "NativeMap.h"
 #include "ReadableNativeArray.h"
 
 #ifndef RCT_REMOVE_LEGACY_ARCH
@@ -119,6 +120,8 @@ void JavaNativeModule::invoke(
         if (callId != -1) {
           fbsystrace_end_async_flow(TRACE_TAG_REACT, "native", callId);
         }
+#else
+        (void)callId;
 #endif
         invokeMethod(
             wrapper_,

package/ReactAndroid/src/main/jni/react/jni/NativeCommon.cpp

@@ -27,32 +27,32 @@ alias_ref<ReadableType> getTypeField(const char* fieldName) {
 
 } // namespace
 
-local_ref<ReadableType> ReadableType::getType(folly::dynamic::Type type) {
+alias_ref<ReadableType> ReadableType::getType(folly::dynamic::Type type) {
   switch (type) {
     case folly::dynamic::Type::NULLT: {
-      static alias_ref<ReadableType> val = getTypeField("Null");
-      return make_local(val);
+      static auto val = getTypeField("Null");
+      return val;
     }
     case folly::dynamic::Type::BOOL: {
-      static alias_ref<ReadableType> val = getTypeField("Boolean");
-      return make_local(val);
+      static auto val = getTypeField("Boolean");
+      return val;
     }
     case folly::dynamic::Type::DOUBLE:
     case folly::dynamic::Type::INT64: {
-      static alias_ref<ReadableType> val = getTypeField("Number");
-      return make_local(val);
+      static auto val = getTypeField("Number");
+      return val;
     }
     case folly::dynamic::Type::STRING: {
-      static alias_ref<ReadableType> val = getTypeField("String");
-      return make_local(val);
+      static auto val = getTypeField("String");
+      return val;
     }
     case folly::dynamic::Type::OBJECT: {
-      static alias_ref<ReadableType> val = getTypeField("Map");
-      return make_local(val);
+      static auto val = getTypeField("Map");
+      return val;
     }
     case folly::dynamic::Type::ARRAY: {
-      static alias_ref<ReadableType> val = getTypeField("Array");
-      return make_local(val);
+      static auto val = getTypeField("Array");
+      return val;
     }
     default:
       throwNewJavaException(

package/ReactAndroid/src/main/jni/react/jni/NativeCommon.h

@@ -19,7 +19,7 @@ namespace facebook::react {
 struct ReadableType : public jni::JavaClass<ReadableType> {
   static auto constexpr kJavaDescriptor = "Lcom/facebook/react/bridge/ReadableType;";
 
-  static jni::local_ref<ReadableType> getType(folly::dynamic::Type type);
+  static jni::alias_ref<ReadableType> getType(folly::dynamic::Type type);
 };
 
 namespace exceptions {
@@ -29,7 +29,7 @@ extern const char *gUnexpectedNativeTypeExceptionClass;
 template <typename T>
 void throwIfObjectAlreadyConsumed(const T &t, const char *msg)
 {
-  if (t->isConsumed) {
+  if (t->isConsumed) [[unlikely]] {
     jni::throwNewJavaException("com/facebook/react/bridge/ObjectAlreadyConsumedException", msg);
   }
 }

package/ReactAndroid/src/main/jni/react/jni/OnLoad-common.cpp

@@ -6,6 +6,7 @@
  */
 
 #include <fbjni/fbjni.h>
+#include "JArrayBuffer.h"
 #include "JCallback.h"
 #include "JDynamicNative.h"
 #include "JReactMarker.h"
@@ -18,6 +19,7 @@ namespace facebook::react {
 
 extern "C" JNIEXPORT jint JNI_OnLoad(JavaVM* vm, void* reserved) {
   return facebook::jni::initialize(vm, [] {
+    JArrayBuffer::registerNatives();
     JCxxCallbackImpl::registerNatives();
     JDynamicNative::registerNatives();
     JReactMarker::registerNatives();

package/ReactAndroid/src/main/jni/react/jni/ReadableNativeArray.cpp

@@ -23,7 +23,7 @@ void ReadableNativeArray::mapException(std::exception_ptr ex) {
 }
 
 local_ref<JArrayClass<jobject>> ReadableNativeArray::importArray() {
-  auto size = static_cast<jint>(array_.size());
+  auto size = static_cast<jsize>(array_.size());
   auto jarray = JArrayClass<jobject>::newArray(size);
   for (jint ii = 0; ii < size; ii++) {
     addDynamicToJArray(jarray, ii, array_.at(ii));
@@ -32,10 +32,10 @@ local_ref<JArrayClass<jobject>> ReadableNativeArray::importArray() {
 }
 
 local_ref<JArrayClass<jobject>> ReadableNativeArray::importTypeArray() {
-  auto size = static_cast<jint>(array_.size());
+  auto size = static_cast<jsize>(array_.size());
   auto jarray = JArrayClass<jobject>::newArray(size);
   for (jint ii = 0; ii < size; ii++) {
-    (*jarray)[ii] = ReadableType::getType(array_.at(ii).type());
+    jarray->setElement(ii, ReadableType::getType(array_.at(ii).type()).get());
   }
   return jarray;
 }

package/ReactAndroid/src/main/jni/react/jni/ReadableNativeArray.h

@@ -9,9 +9,6 @@
 
 #include "NativeArray.h"
 
-#include "NativeCommon.h"
-#include "NativeMap.h"
-
 namespace facebook::react {
 
 struct ReadableArray : jni::JavaClass<ReadableArray> {

package/ReactAndroid/src/main/jni/react/jni/ReadableNativeMap.cpp

@@ -7,6 +7,8 @@
 
 #include "ReadableNativeMap.h"
 
+#include "ReadableNativeArray.h"
+
 using namespace facebook::jni;
 
 namespace facebook::react {
@@ -20,84 +22,86 @@ void ReadableNativeMap::mapException(std::exception_ptr ex) {
   }
 }
 
+void ReadableNativeMap::throwIfKeysNotImported() const {
+  if (!values_.has_value()) [[unlikely]] {
+    throwNewJavaException(
+        "java/lang/IllegalStateException",
+        "importKeys must be called before importing values or types");
+  }
+}
+
 void addDynamicToJArray(
-    local_ref<JArrayClass<jobject>> jarray,
+    alias_ref<JArrayClass<jobject>> jarray,
     jint index,
     const folly::dynamic& dyn) {
+  local_ref<jobject> value;
   switch (dyn.type()) {
-    case folly::dynamic::Type::NULLT: {
-      jarray->setElement(index, nullptr);
-      break;
-    }
-    case folly::dynamic::Type::BOOL: {
-      (*jarray)[index] =
-          JBoolean::valueOf(static_cast<unsigned char>(dyn.getBool()));
+    case folly::dynamic::Type::BOOL:
+      value = JBoolean::valueOf(static_cast<jboolean>(dyn.getBool()));
       break;
-    }
-    case folly::dynamic::Type::INT64: {
-      (*jarray)[index] = JDouble::valueOf(dyn.getInt());
+    case folly::dynamic::Type::INT64:
+      value = JDouble::valueOf(static_cast<double>(dyn.getInt()));
       break;
-    }
-    case folly::dynamic::Type::DOUBLE: {
-      (*jarray)[index] = JDouble::valueOf(dyn.getDouble());
+    case folly::dynamic::Type::DOUBLE:
+      value = JDouble::valueOf(dyn.getDouble());
       break;
-    }
-    case folly::dynamic::Type::STRING: {
-      (*jarray)[index] = make_jstring(dyn.getString());
+    case folly::dynamic::Type::STRING:
+      value = make_jstring(dyn.getString());
       break;
-    }
-    case folly::dynamic::Type::OBJECT: {
-      (*jarray)[index] = ReadableNativeMap::newObjectCxxArgs(dyn);
+    case folly::dynamic::Type::OBJECT:
+      value = ReadableNativeMap::newObjectCxxArgs(dyn);
       break;
-    }
-    case folly::dynamic::Type::ARRAY: {
-      (*jarray)[index] = ReadableNativeArray::newObjectCxxArgs(dyn);
+    case folly::dynamic::Type::ARRAY:
+      value = ReadableNativeArray::newObjectCxxArgs(dyn);
       break;
-    }
+    case folly::dynamic::Type::NULLT:
     default:
-      jarray->setElement(index, nullptr);
       break;
   }
+  jarray->setElement(index, value.get());
 }
 
 local_ref<JArrayClass<jstring>> ReadableNativeMap::importKeys() {
   throwIfConsumed();
 
-  keys_ = folly::dynamic::array();
-  if (map_ == nullptr) {
-    return JArrayClass<jstring>::newArray(0);
-  }
-  auto jarray = JArrayClass<jstring>::newArray(map_.size());
+  auto size = map_ == nullptr ? 0 : static_cast<jsize>(map_.size());
+  std::vector<const folly::dynamic*> values(size);
+
+  auto jarray = JArrayClass<jstring>::newArray(size);
   jint i = 0;
-  for (auto& pair : map_.items()) {
-    auto value = pair.first.asString();
-    (*keys_).push_back(value);
-    (*jarray)[i++] = make_jstring(value);
+  if (map_ != nullptr) {
+    for (auto& pair : map_.items()) {
+      values[i] = &pair.second;
+      jarray->setElement(i++, make_jstring(pair.first.getString()).get());
+    }
   }
+  values_ = std::move(values);
 
   return jarray;
 }
 
 local_ref<JArrayClass<jobject>> ReadableNativeMap::importValues() {
   throwIfConsumed();
+  throwIfKeysNotImported();
 
-  auto size = static_cast<jint>(keys_.value().size());
+  const auto& values = values_.value();
+  auto size = static_cast<jsize>(values.size());
   auto jarray = JArrayClass<jobject>::newArray(size);
   for (jint ii = 0; ii < size; ii++) {
-    const std::string& key = (*keys_)[ii].getString();
-    addDynamicToJArray(jarray, ii, map_.at(key));
+    addDynamicToJArray(jarray, ii, *values[ii]);
   }
   return jarray;
 }
 
 local_ref<JArrayClass<jobject>> ReadableNativeMap::importTypes() {
   throwIfConsumed();
+  throwIfKeysNotImported();
 
-  auto size = static_cast<jint>(keys_.value().size());
+  const auto& values = values_.value();
+  auto size = static_cast<jsize>(values.size());
   auto jarray = JArrayClass<jobject>::newArray(size);
   for (jint ii = 0; ii < size; ii++) {
-    const std::string& key = (*keys_)[ii].getString();
-    (*jarray)[ii] = ReadableType::getType(map_.at(key).type());
+    jarray->setElement(ii, ReadableType::getType(values[ii]->type()).get());
   }
   return jarray;
 }