not-react-native-macos 0.83.0-rc.0 → 0.87.1-rc.1

package/ReactAndroid/src/main/java/com/facebook/react/bridge/PromiseImpl.kt

@@ -38,7 +38,7 @@ constructor(private var resolve: Callback?, private var reject: Callback?) : Pro
    * @param code String
    * @param message String
    */
-  override fun reject(code: String, message: String?) {
+  override fun reject(code: String?, message: String?) {
     reject(code, message, null, null)
   }
 
@@ -48,7 +48,7 @@ constructor(private var resolve: Callback?, private var reject: Callback?) : Pro
    * @param code String
    * @param throwable Throwable
    */
-  override fun reject(code: String, throwable: Throwable?) {
+  override fun reject(code: String?, throwable: Throwable?) {
     reject(code, null, throwable, null)
   }
 
@@ -59,7 +59,7 @@ constructor(private var resolve: Callback?, private var reject: Callback?) : Pro
    * @param message String
    * @param throwable Throwable
    */
-  override fun reject(code: String, message: String?, throwable: Throwable?) {
+  override fun reject(code: String?, message: String?, throwable: Throwable?) {
     reject(code, message, throwable, null)
   }
 
@@ -94,7 +94,7 @@ constructor(private var resolve: Callback?, private var reject: Callback?) : Pro
    * @param code String
    * @param userInfo WritableMap
    */
-  override fun reject(code: String, userInfo: WritableMap) {
+  override fun reject(code: String?, userInfo: WritableMap) {
     reject(code, null, null, userInfo)
   }
 
@@ -105,7 +105,7 @@ constructor(private var resolve: Callback?, private var reject: Callback?) : Pro
    * @param throwable Throwable
    * @param userInfo WritableMap
    */
-  override fun reject(code: String, throwable: Throwable?, userInfo: WritableMap) {
+  override fun reject(code: String?, throwable: Throwable?, userInfo: WritableMap) {
     reject(code, null, throwable, userInfo)
   }
 
@@ -117,7 +117,7 @@ constructor(private var resolve: Callback?, private var reject: Callback?) : Pro
    * @param message String
    * @param userInfo WritableMap
    */
-  override fun reject(code: String, message: String?, userInfo: WritableMap) {
+  override fun reject(code: String?, message: String?, userInfo: WritableMap) {
     reject(code, message, null, userInfo)
   }
 

package/ReactAndroid/src/main/java/com/facebook/react/bridge/ReactContext.java

@@ -15,6 +15,7 @@ import android.content.ContextWrapper;
 import android.content.Intent;
 import android.os.Bundle;
 import android.view.LayoutInflater;
+import android.view.Window;
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
 import com.facebook.common.logging.FLog;
@@ -25,6 +26,8 @@ import com.facebook.react.bridge.interop.InteropModuleRegistry;
 import com.facebook.react.bridge.queue.MessageQueueThread;
 import com.facebook.react.bridge.queue.ReactQueueConfiguration;
 import com.facebook.react.common.LifecycleState;
+import com.facebook.react.common.build.ReactBuildConfig;
+import com.facebook.react.interfaces.ExtraWindowEventListener;
 import com.facebook.react.turbomodule.core.interfaces.CallInvokerHolder;
 import java.lang.ref.WeakReference;
 import java.util.Collection;
@@ -48,8 +51,11 @@ public abstract class ReactContext extends ContextWrapper {
       new CopyOnWriteArraySet<>();
   private final CopyOnWriteArraySet<ActivityEventListener> mActivityEventListeners =
       new CopyOnWriteArraySet<>();
+  private final CopyOnWriteArraySet<ExtraWindowEventListener> mExtraWindowEventListeners =
+      new CopyOnWriteArraySet<>();
   private final CopyOnWriteArraySet<WindowFocusChangeListener> mWindowFocusEventListeners =
       new CopyOnWriteArraySet<>();
+  private final ScrollEndedListeners mScrollEndedListeners = new ScrollEndedListeners();
 
   private LifecycleState mLifecycleState = LifecycleState.BEFORE_CREATE;
 
@@ -105,6 +111,9 @@ public abstract class ReactContext extends ContextWrapper {
   }
 
   protected void initializeInteropModules() {
+    if (ReactBuildConfig.UNSTABLE_REMOVE_LEGACY_COMPONENT_INTEROP) {
+      return;
+    }
     mInteropModuleRegistry = new InteropModuleRegistry();
   }
 
@@ -195,6 +204,21 @@ public abstract class ReactContext extends ContextWrapper {
     return mLifecycleState;
   }
 
+  /**
+   * Returns the {@link RuntimeExecutor} for the underlying JavaScript runtime, or {@code null} if
+   * the runtime has not been initialized. Works in both bridged and bridgeless modes.
+   */
+  public abstract @Nullable RuntimeExecutor getRuntimeExecutor();
+
+  /**
+   * This allows scroll views to notify NativeAnimatedModule when user-driven scrolling ends.
+   *
+   * @return The ScrollEndedListeners instance
+   */
+  public ScrollEndedListeners getScrollEndedListeners() {
+    return mScrollEndedListeners;
+  }
+
   public void addLifecycleEventListener(final LifecycleEventListener listener) {
     mLifecycleEventListeners.add(listener);
     if (hasActiveReactInstance() || isBridgeless()) {
@@ -236,6 +260,14 @@ public abstract class ReactContext extends ContextWrapper {
     mActivityEventListeners.remove(listener);
   }
 
+  public void addExtraWindowEventListener(ExtraWindowEventListener listener) {
+    mExtraWindowEventListeners.add(listener);
+  }
+
+  public void removeExtraWindowEventListener(ExtraWindowEventListener listener) {
+    mExtraWindowEventListeners.remove(listener);
+  }
+
   public void addWindowFocusChangeListener(WindowFocusChangeListener listener) {
     mWindowFocusEventListeners.add(listener);
   }
@@ -248,7 +280,7 @@ public abstract class ReactContext extends ContextWrapper {
   @ThreadConfined(UI)
   public void onHostResume(@Nullable Activity activity) {
     mLifecycleState = LifecycleState.RESUMED;
-    mCurrentActivity = new WeakReference(activity);
+    mCurrentActivity = new WeakReference<>(activity);
     ReactMarker.logMarker(ReactMarkerConstants.ON_HOST_RESUME_START);
     for (LifecycleEventListener listener : mLifecycleEventListeners) {
       try {
@@ -276,7 +308,7 @@ public abstract class ReactContext extends ContextWrapper {
   @ThreadConfined(UI)
   public void onNewIntent(@Nullable Activity activity, Intent intent) {
     UiThreadUtil.assertOnUiThread();
-    mCurrentActivity = new WeakReference(activity);
+    mCurrentActivity = new WeakReference<>(activity);
     for (ActivityEventListener listener : mActivityEventListeners) {
       try {
         listener.onNewIntent(intent);
@@ -346,6 +378,30 @@ public abstract class ReactContext extends ContextWrapper {
     }
   }
 
+  @ThreadConfined(UI)
+  public void onExtraWindowCreate(Window window) {
+    UiThreadUtil.assertOnUiThread();
+    for (ExtraWindowEventListener listener : mExtraWindowEventListeners) {
+      try {
+        listener.onExtraWindowCreate(window);
+      } catch (RuntimeException e) {
+        handleException(e);
+      }
+    }
+  }
+
+  @ThreadConfined(UI)
+  public void onExtraWindowDestroy(Window window) {
+    UiThreadUtil.assertOnUiThread();
+    for (ExtraWindowEventListener listener : mExtraWindowEventListeners) {
+      try {
+        listener.onExtraWindowDestroy(window);
+      } catch (RuntimeException e) {
+        handleException(e);
+      }
+    }
+  }
+
   @ThreadConfined(UI)
   public void onWindowFocusChange(boolean hasFocus) {
     UiThreadUtil.assertOnUiThread();
@@ -527,6 +583,9 @@ public abstract class ReactContext extends ContextWrapper {
    */
   public <T extends JavaScriptModule> void internal_registerInteropModule(
       Class<T> interopModuleInterface, Object interopModule) {
+    if (ReactBuildConfig.UNSTABLE_REMOVE_LEGACY_COMPONENT_INTEROP) {
+      return;
+    }
     if (mInteropModuleRegistry != null) {
       mInteropModuleRegistry.registerInteropModule(interopModuleInterface, interopModule);
     }

package/ReactAndroid/src/main/java/com/facebook/react/bridge/ReactNativeJNISoLoader.kt

@@ -9,7 +9,9 @@ package com.facebook.react.bridge
 
 import com.facebook.react.common.annotations.internal.InteropLegacyArchitecture
 import com.facebook.soloader.SoLoader
+import com.facebook.soloader.annotation.SoLoaderLibrary
 
+@SoLoaderLibrary("reactnativejni")
 @InteropLegacyArchitecture
 internal object ReactNativeJNISoLoader {
 

package/ReactAndroid/src/main/java/com/facebook/react/bridge/ReactNativeJniCommonSoLoader.kt

@@ -8,7 +8,9 @@
 package com.facebook.react.bridge
 
 import com.facebook.soloader.SoLoader
+import com.facebook.soloader.annotation.SoLoaderLibrary
 
+@SoLoaderLibrary("reactnativejni_common")
 internal object ReactNativeJniCommonSoLoader {
 
   @JvmStatic

package/ReactAndroid/src/main/java/com/facebook/react/bridge/ReactSoftExceptionLogger.kt

@@ -11,6 +11,7 @@ import androidx.annotation.StringDef
 import com.facebook.common.logging.FLog
 import com.facebook.proguard.annotations.DoNotStrip
 import com.facebook.react.bridge.ReactSoftExceptionLogger.Categories.CLIPPING_PROHIBITED_VIEW
+import com.facebook.react.bridge.ReactSoftExceptionLogger.Categories.RVG_ADD_CHILDREN_FOR_ACCESSIBILITY
 import com.facebook.react.bridge.ReactSoftExceptionLogger.Categories.RVG_IS_VIEW_CLIPPED
 import com.facebook.react.bridge.ReactSoftExceptionLogger.Categories.RVG_ON_VIEW_REMOVED
 import com.facebook.react.bridge.ReactSoftExceptionLogger.Categories.SOFT_ASSERTIONS
@@ -21,6 +22,7 @@ import java.util.concurrent.CopyOnWriteArrayList
 internal object ReactSoftExceptionLogger {
   @Retention(AnnotationRetention.SOURCE)
   @StringDef(
+      RVG_ADD_CHILDREN_FOR_ACCESSIBILITY,
       RVG_IS_VIEW_CLIPPED,
       RVG_ON_VIEW_REMOVED,
       CLIPPING_PROHIBITED_VIEW,
@@ -31,6 +33,8 @@ internal object ReactSoftExceptionLogger {
 
   /** Constants that listeners can utilize for custom category-based behavior. */
   object Categories {
+    const val RVG_ADD_CHILDREN_FOR_ACCESSIBILITY: String =
+        "ReactViewGroup.addChildrenForAccessibility"
     const val RVG_IS_VIEW_CLIPPED: String = "ReactViewGroup.isViewClipped"
     const val RVG_ON_VIEW_REMOVED: String = "ReactViewGroup.onViewRemoved"
     const val CLIPPING_PROHIBITED_VIEW: String = "ReactClippingProhibitedView"

package/ReactAndroid/src/main/java/com/facebook/react/bridge/ReadableNativeArray.kt

@@ -8,7 +8,6 @@
 package com.facebook.react.bridge
 
 import com.facebook.proguard.annotations.DoNotStrip
-import com.facebook.react.internal.featureflags.ReactNativeFeatureFlags
 import java.util.ArrayList
 import java.util.Arrays
 import kotlin.jvm.JvmStatic
@@ -90,17 +89,7 @@ public open class ReadableNativeArray protected constructor() : NativeArray(), R
 
   override fun hashCode(): Int = localArray.hashCode()
 
-  override fun equals(other: Any?): Boolean {
-    if (other !is ReadableNativeArray) {
-      return false
-    }
-
-    return if (ReactNativeFeatureFlags.useNativeEqualsInNativeReadableArrayAndroid()) {
-      nativeEquals(other)
-    } else {
-      localArray.contentDeepEquals(other.localArray)
-    }
-  }
+  override fun equals(other: Any?): Boolean = (other is ReadableNativeArray) && nativeEquals(other)
 
   private external fun nativeEquals(other: ReadableNativeArray): Boolean
 

package/ReactAndroid/src/main/java/com/facebook/react/bridge/ScrollEndedListener.kt

@@ -0,0 +1,70 @@
+/*
+ * 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.
+ */
+
+package com.facebook.react.bridge
+
+import android.view.ViewGroup
+import java.lang.ref.WeakReference
+import java.util.concurrent.CopyOnWriteArrayList
+
+/** Listener interface for scroll ended events. This is a native only event. */
+public interface ScrollEndedListener {
+  /**
+   * Called when user-driven scrolling ends.
+   *
+   * @param scrollView The scroll view that has stopped scrolling
+   */
+  public fun onScrollEnded(scrollView: ViewGroup)
+}
+
+/**
+ * Registry for managing ScrollEndedListener instances. This provides a decoupled mechanism for
+ * scroll views to notify interested parties (like NativeAnimatedModule) when user-driven scrolling
+ * ends, without creating circular dependencies between modules.
+ *
+ * This class is instantiated per ReactContext and can be accessed via
+ * [com.facebook.react.bridge.ReactContext.getScrollEndedListeners].
+ */
+public class ScrollEndedListeners {
+  private val listeners = CopyOnWriteArrayList<WeakReference<ScrollEndedListener>>()
+
+  /**
+   * Adds a scroll ended listener. This listener is called when user-driven scrolling ends.
+   *
+   * @param listener The listener to add
+   */
+  public fun addListener(listener: ScrollEndedListener) {
+    listeners.add(WeakReference(listener))
+  }
+
+  /**
+   * Removes a scroll ended listener.
+   *
+   * @param listener The listener to remove
+   */
+  public fun removeListener(listener: ScrollEndedListener) {
+    val toRemove = ArrayList<WeakReference<ScrollEndedListener>>()
+    for (ref in listeners) {
+      val target = ref.get()
+      if (target == null || target == listener) {
+        toRemove.add(ref)
+      }
+    }
+    listeners.removeAll(toRemove)
+  }
+
+  /**
+   * Notifies all registered listeners that user-driven scrolling has ended.
+   *
+   * @param scrollView The scroll view that has stopped scrolling
+   */
+  public fun notifyScrollEnded(scrollView: ViewGroup) {
+    for (listenerRef in listeners) {
+      listenerRef.get()?.onScrollEnded(scrollView)
+    }
+  }
+}

package/ReactAndroid/src/main/java/com/facebook/react/bridge/interop/InteropModuleRegistry.kt

@@ -10,7 +10,6 @@ package com.facebook.react.bridge.interop
 import com.facebook.react.bridge.JavaScriptModule
 import com.facebook.react.common.annotations.internal.InteropLegacyArchitecture
 import com.facebook.react.common.annotations.internal.LegacyArchitectureLogger
-import com.facebook.react.internal.featureflags.ReactNativeNewArchitectureFeatureFlags.enableFabricRenderer
 import com.facebook.react.internal.featureflags.ReactNativeNewArchitectureFeatureFlags.useFabricInterop
 
 /**
@@ -44,8 +43,7 @@ internal class InteropModuleRegistry {
     }
   }
 
-  private fun checkReactFeatureFlagsConditions(): Boolean =
-      enableFabricRenderer() && useFabricInterop()
+  private fun checkReactFeatureFlagsConditions(): Boolean = useFabricInterop()
 
   private companion object {
     init {

package/ReactAndroid/src/main/java/com/facebook/react/common/assets/ReactFontManager.kt

@@ -33,6 +33,10 @@ public class ReactFontManager {
   private val fontCache: MutableMap<String, AssetFontFamily> = mutableMapOf()
   private val customTypefaceCache: MutableMap<String, Typeface> = mutableMapOf()
 
+  /** The set of font family names that have been registered via [addCustomFont]. */
+  public val customFontFamilies: Set<String>
+    get() = customTypefaceCache.keys.toSet()
+
   public fun getTypeface(
       fontFamilyName: String,
       style: Int,

package/ReactAndroid/src/main/java/com/facebook/react/common/build/ReactBuildConfig.kt

@@ -37,4 +37,8 @@ public object ReactBuildConfig {
   @JvmField
   public val UNSTABLE_ENABLE_MINIFY_LEGACY_ARCHITECTURE: Boolean =
       BuildConfig.UNSTABLE_ENABLE_MINIFY_LEGACY_ARCHITECTURE
+
+  @JvmField
+  public val UNSTABLE_REMOVE_LEGACY_COMPONENT_INTEROP: Boolean =
+      BuildConfig.UNSTABLE_REMOVE_LEGACY_COMPONENT_INTEROP
 }

package/ReactAndroid/src/main/java/com/facebook/react/common/mapbuffer/MapBuffer.kt

@@ -46,6 +46,9 @@ public interface MapBuffer : Iterable<MapBuffer.Entry> {
     STRING,
     MAP,
     LONG,
+    INT_BUFFER,
+    DOUBLE_BUFFER,
+    MAP_BUFFER_LIST,
   }
 
   /**
@@ -151,8 +154,8 @@ public interface MapBuffer : Iterable<MapBuffer.Entry> {
   public fun getMapBuffer(key: Int): MapBuffer
 
   /**
-   * Provides parsed [List<MapBuffer>] value if the entry for given key exists with [DataType.MAP]
-   * type
+   * Provides parsed [List<MapBuffer>] value if the entry for given key exists with
+   * [DataType.MAP_BUFFER_LIST] type
    *
    * @param key key to lookup [List<MapBuffer>] value for
    * @return value associated with the requested key
@@ -161,6 +164,30 @@ public interface MapBuffer : Iterable<MapBuffer.Entry> {
    */
   public fun getMapBufferList(key: Int): List<MapBuffer>
 
+  /**
+   * Provides parsed [IntArray] value if the entry for given key exists with [DataType.INT_BUFFER]
+   * type. This is a compact representation of a homogeneous list of ints with no per-element
+   * key/type overhead.
+   *
+   * @param key key to lookup the [IntArray] value for
+   * @return value associated with the requested key
+   * @throws IllegalArgumentException if the key doesn't exist
+   * @throws IllegalStateException if the data type doesn't match
+   */
+  public fun getIntBuffer(key: Int): IntArray
+
+  /**
+   * Provides parsed [DoubleArray] value if the entry for given key exists with
+   * [DataType.DOUBLE_BUFFER] type. This is a compact representation of a homogeneous list of
+   * doubles with no per-element key/type overhead.
+   *
+   * @param key key to lookup the [DoubleArray] value for
+   * @return value associated with the requested key
+   * @throws IllegalArgumentException if the key doesn't exist
+   * @throws IllegalStateException if the data type doesn't match
+   */
+  public fun getDoubleBuffer(key: Int): DoubleArray
+
   /** Iterable entry representing parsed MapBuffer values */
   public interface Entry {
     /**
@@ -213,5 +240,26 @@ public interface MapBuffer : Iterable<MapBuffer.Entry> {
      * @throws IllegalStateException if the data type doesn't match [DataType.MAP]
      */
     public val mapBufferValue: MapBuffer
+
+    /**
+     * Entry value represented as [IntArray]
+     *
+     * @throws IllegalStateException if the data type doesn't match [DataType.INT_BUFFER]
+     */
+    public val intBufferValue: IntArray
+
+    /**
+     * Entry value represented as [DoubleArray]
+     *
+     * @throws IllegalStateException if the data type doesn't match [DataType.DOUBLE_BUFFER]
+     */
+    public val doubleBufferValue: DoubleArray
+
+    /**
+     * Entry value represented as [List<MapBuffer>]
+     *
+     * @throws IllegalStateException if the data type doesn't match [DataType.MAP_BUFFER_LIST]
+     */
+    public val mapBufferListValue: List<MapBuffer>
   }
 }

package/ReactAndroid/src/main/java/com/facebook/react/common/mapbuffer/ReadableMapBuffer.kt

@@ -39,6 +39,10 @@ private constructor(
   override var count: Int = 0
     private set
 
+  // returns the relative offset of the first byte of dynamic data
+  private val offsetForDynamicData: Int
+    get() = getKeyOffsetForBucketIndex(count)
+
   init {
     readHeader()
   }
@@ -47,19 +51,13 @@ private constructor(
       ReadableMapBuffer(buffer.duplicate().apply { position(offset) }, offset)
 
   private fun readHeader() {
-    // byte order
-    val storedAlignment = buffer.short
-    if (storedAlignment.toInt() != ALIGNMENT) {
-      buffer.order(ByteOrder.LITTLE_ENDIAN)
-    }
-    // count
-    count = readUnsignedShort(buffer.position()).toInt()
+    // The C++ writer always serializes in little-endian byte order. ByteBuffer
+    // defaults to big-endian and duplicate() resets the order, so set it
+    // explicitly on every instance, including nested clones.
+    buffer.order(ByteOrder.LITTLE_ENDIAN)
+    count = readUnsignedShort(offsetToMapBuffer).toInt()
   }
 
-  // returns the relative offset of the first byte of dynamic data
-  private val offsetForDynamicData: Int
-    get() = getKeyOffsetForBucketIndex(count)
-
   /**
    * @param intKey Key to search for
    * @return the "bucket index" for a key or -1 if not found. It uses a binary search algorithm
@@ -122,26 +120,27 @@ private constructor(
     return readIntValue(bufferPosition) == 1
   }
 
+  // Dynamic-data entries store [offset][byteLength] in the bucket's 8-byte
+  // value: getInt(bufferPosition) is the offset, getInt(bufferPosition + 4) is
+  // the byte length. The dynamic data section itself carries no length prefix.
   private fun readStringValue(bufferPosition: Int): String {
     val offset = offsetForDynamicData + buffer.getInt(bufferPosition)
-    val sizeOfString = buffer.getInt(offset)
+    val sizeOfString = buffer.getInt(bufferPosition + Int.SIZE_BYTES)
     val result = ByteArray(sizeOfString)
-    val stringOffset = offset + Int.SIZE_BYTES
-    buffer.position(stringOffset)
-    buffer[result, 0, sizeOfString]
+    buffer.position(offset)
+    buffer.get(result, 0, sizeOfString)
     return String(result)
   }
 
   private fun readMapBufferValue(position: Int): ReadableMapBuffer {
     val offset = offsetForDynamicData + buffer.getInt(position)
-    return cloneWithOffset(offset + Int.SIZE_BYTES)
+    return cloneWithOffset(offset)
   }
 
   private fun readMapBufferListValue(position: Int): List<ReadableMapBuffer> {
     val readMapBufferList = arrayListOf<ReadableMapBuffer>()
-    var offset = offsetForDynamicData + buffer.getInt(position)
-    val sizeMapBufferList = buffer.getInt(offset)
-    offset += Int.SIZE_BYTES
+    val offset = offsetForDynamicData + buffer.getInt(position)
+    val sizeMapBufferList = buffer.getInt(position + Int.SIZE_BYTES)
     var curLen = 0
     while (curLen < sizeMapBufferList) {
       val sizeMapBuffer = buffer.getInt(offset + curLen)
@@ -152,6 +151,24 @@ private constructor(
     return readMapBufferList
   }
 
+  private fun readIntBufferValue(bufferPosition: Int): IntArray {
+    val offset = offsetForDynamicData + buffer.getInt(bufferPosition)
+    val byteLength = buffer.getInt(bufferPosition + Int.SIZE_BYTES)
+    val count = byteLength / Int.SIZE_BYTES
+    val result = IntArray(count)
+    buffer.duplicate().order(buffer.order()).apply { position(offset) }.asIntBuffer().get(result)
+    return result
+  }
+
+  private fun readDoubleBufferValue(bufferPosition: Int): DoubleArray {
+    val offset = offsetForDynamicData + buffer.getInt(bufferPosition)
+    val byteLength = buffer.getInt(bufferPosition + Int.SIZE_BYTES)
+    val count = byteLength / Double.SIZE_BYTES
+    val result = DoubleArray(count)
+    buffer.duplicate().order(buffer.order()).apply { position(offset) }.asDoubleBuffer().get(result)
+    return result
+  }
+
   private fun getKeyOffsetForBucketIndex(bucketIndex: Int): Int {
     return offsetToMapBuffer + HEADER_SIZE + BUCKET_SIZE * bucketIndex
   }
@@ -191,7 +208,13 @@ private constructor(
       readMapBufferValue(getTypedValueOffsetForKey(key, MapBuffer.DataType.MAP))
 
   override fun getMapBufferList(key: Int): List<ReadableMapBuffer> =
-      readMapBufferListValue(getTypedValueOffsetForKey(key, MapBuffer.DataType.MAP))
+      readMapBufferListValue(getTypedValueOffsetForKey(key, MapBuffer.DataType.MAP_BUFFER_LIST))
+
+  override fun getIntBuffer(key: Int): IntArray =
+      readIntBufferValue(getTypedValueOffsetForKey(key, MapBuffer.DataType.INT_BUFFER))
+
+  override fun getDoubleBuffer(key: Int): DoubleArray =
+      readDoubleBufferValue(getTypedValueOffsetForKey(key, MapBuffer.DataType.DOUBLE_BUFFER))
 
   override fun hashCode(): Int {
     buffer.rewind()
@@ -229,6 +252,9 @@ private constructor(
             append('"')
           }
           MapBuffer.DataType.MAP -> append(entry.mapBufferValue.toString())
+          MapBuffer.DataType.INT_BUFFER -> append(entry.intBufferValue.contentToString())
+          MapBuffer.DataType.DOUBLE_BUFFER -> append(entry.doubleBufferValue.contentToString())
+          MapBuffer.DataType.MAP_BUFFER_LIST -> append(entry.mapBufferListValue.toString())
         }
       }
     }
@@ -311,16 +337,31 @@ private constructor(
         assertType(MapBuffer.DataType.MAP)
         return readMapBufferValue(bucketOffset + VALUE_OFFSET)
       }
+
+    override val intBufferValue: IntArray
+      get() {
+        assertType(MapBuffer.DataType.INT_BUFFER)
+        return readIntBufferValue(bucketOffset + VALUE_OFFSET)
+      }
+
+    override val doubleBufferValue: DoubleArray
+      get() {
+        assertType(MapBuffer.DataType.DOUBLE_BUFFER)
+        return readDoubleBufferValue(bucketOffset + VALUE_OFFSET)
+      }
+
+    override val mapBufferListValue: List<MapBuffer>
+      get() {
+        assertType(MapBuffer.DataType.MAP_BUFFER_LIST)
+        return readMapBufferListValue(bucketOffset + VALUE_OFFSET)
+      }
   }
 
   public companion object {
-    // Value used to verify if the data is serialized with LittleEndian order.
-    private const val ALIGNMENT = 0xFE
-
-    // 8 bytes = 2 (alignment) + 2 (count) + 4 (size)
-    private const val HEADER_SIZE = 8
+    // 2 bytes = 2 (count)
+    private const val HEADER_SIZE = 2
 
-    // 10 bytes = 2 (key) + 2 (type) + 8 (value)
+    // 12 bytes = 2 (key) + 2 (type) + 8 (value)
     private const val BUCKET_SIZE = 12
 
     // 2 bytes = 2 (key)

package/ReactAndroid/src/main/java/com/facebook/react/common/mapbuffer/WritableMapBuffer.kt

@@ -84,6 +84,24 @@ internal class WritableMapBuffer : MapBuffer {
    */
   fun put(key: Int, value: MapBuffer): WritableMapBuffer = putInternal(key, value)
 
+  /**
+   * Adds an [IntArray] value for given key to the current MapBuffer.
+   *
+   * @param key entry key
+   * @param value entry value
+   * @throws IllegalArgumentException if key is out of [UShort] range
+   */
+  fun put(key: Int, value: IntArray): WritableMapBuffer = putInternal(key, value)
+
+  /**
+   * Adds a [DoubleArray] value for given key to the current MapBuffer.
+   *
+   * @param key entry key
+   * @param value entry value
+   * @throws IllegalArgumentException if key is out of [UShort] range
+   */
+  fun put(key: Int, value: DoubleArray): WritableMapBuffer = putInternal(key, value)
+
   private fun putInternal(key: Int, value: Any): WritableMapBuffer {
     require(key in KEY_RANGE) {
       "Only integers in [${UShort.MIN_VALUE};${UShort.MAX_VALUE}] range are allowed for keys."
@@ -126,6 +144,10 @@ internal class WritableMapBuffer : MapBuffer {
 
   override fun getMapBufferList(key: Int): List<MapBuffer> = verifyValue(key, values.get(key))
 
+  override fun getIntBuffer(key: Int): IntArray = verifyValue(key, values.get(key))
+
+  override fun getDoubleBuffer(key: Int): DoubleArray = verifyValue(key, values.get(key))
+
   /** Generalizes verification of the value types based on the requested type. */
   private inline fun <reified T> verifyValue(key: Int, value: Any?): T {
     require(value != null) { "Key not found: $key" }
@@ -143,6 +165,8 @@ internal class WritableMapBuffer : MapBuffer {
       is Double -> DataType.DOUBLE
       is String -> DataType.STRING
       is MapBuffer -> DataType.MAP
+      is IntArray -> DataType.INT_BUFFER
+      is DoubleArray -> DataType.DOUBLE_BUFFER
       else -> throw IllegalStateException("Key $key has value of unknown type: ${value.javaClass}")
     }
   }
@@ -176,6 +200,15 @@ internal class WritableMapBuffer : MapBuffer {
 
     override val mapBufferValue: MapBuffer
       get() = verifyValue(key, values.valueAt(index))
+
+    override val intBufferValue: IntArray
+      get() = verifyValue(key, values.valueAt(index))
+
+    override val doubleBufferValue: DoubleArray
+      get() = verifyValue(key, values.valueAt(index))
+
+    override val mapBufferListValue: List<MapBuffer>
+      get() = verifyValue(key, values.valueAt(index))
   }
 
   /*