react-native-tvos 0.86.0-2 → 0.87.0-0

package/ReactAndroid/src/main/java/com/facebook/react/animated/PropsAnimatedNode.kt

@@ -75,7 +75,12 @@ internal class PropsAnimatedNode(
     }
     for ((key, value) in propNodeMapping) {
       val node = nativeAnimatedNodesManager.getNodeById(value)
-      requireNotNull(node) { "Mapped property node does not exist" }
+      // The mapped node can be dropped mid-teardown (e.g. component unmounts during
+      // navigation) while this prop update is still in flight. Skip it instead of
+      // throwing, mirroring the connectedViewTag == -1 guard.
+      if (node == null) {
+        continue
+      }
       if (node is StyleAnimatedNode) {
         node.collectViewUpdates(propMap)
       } else if (node is ValueAnimatedNode) {

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

@@ -139,6 +139,7 @@ public object Arguments {
   public fun fromJavaArgs(args: Any?): WritableNativeArray = fromJavaArgs(args as Array<Any?>)
 
   @JvmStatic
+  @Suppress("PLATFORM_CLASS_MAPPED_TO_KOTLIN")
   public fun fromJavaArgs(args: Array<Any?>): WritableNativeArray {
     val arguments = WritableNativeArray()
     for (i in args.indices) {

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

@@ -0,0 +1,287 @@
+/*
+ * 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.content.Context
+import com.facebook.common.logging.FLog
+import com.facebook.infer.annotation.Assertions
+import com.facebook.infer.annotation.ThreadConfined
+import com.facebook.proguard.annotations.DoNotStrip
+import com.facebook.react.bridge.queue.ReactQueueConfiguration
+import com.facebook.react.common.ReactConstants
+import com.facebook.react.common.annotations.FrameworkAPI
+import com.facebook.react.common.annotations.UnstableReactNativeAPI
+import com.facebook.react.common.annotations.VisibleForTesting
+import com.facebook.react.common.annotations.internal.LegacyArchitecture
+import com.facebook.react.common.annotations.internal.LegacyArchitectureLogLevel
+import com.facebook.react.common.annotations.internal.LegacyArchitectureLogger
+import com.facebook.react.turbomodule.core.interfaces.CallInvokerHolder
+
+/**
+ * This is the bridge-specific concrete subclass of ReactContext. ReactContext has many methods that
+ * delegate to the react instance. This subclass implements those methods, by delegating to the
+ * CatalystInstance. If you need to create a ReactContext within an "bridge context", please create
+ * BridgeReactContext.
+ *
+ * @deprecated This class is deprecated in the New Architecture and will be replaced by
+ *   [com.facebook.react.runtime.BridgelessReactContext]
+ */
+@VisibleForTesting
+@LegacyArchitecture(logLevel = LegacyArchitectureLogLevel.ERROR)
+@Deprecated(
+    "This class is part of Legacy Architecture and will be removed in a future release",
+    replaceWith = ReplaceWith("BridgelessReactContext"),
+)
+@Suppress("DEPRECATION")
+public open class BridgeReactContext(context: Context) : ReactApplicationContext(context) {
+
+  /** Interface for emitting device events to JavaScript. */
+  @DoNotStrip
+  public interface RCTDeviceEventEmitter : JavaScriptModule {
+    /** Emits an event with the given name and data to JavaScript. */
+    public fun emit(eventName: String, data: Any?)
+  }
+
+  @Volatile private var mDestroyed: Boolean = false
+  private var mCatalystInstance: CatalystInstance? = null
+
+  /** Set and initialize CatalystInstance for this Context. This should be called exactly once. */
+  public fun initializeWithInstance(catalystInstance: CatalystInstance) {
+    requireNotNull(catalystInstance) { "CatalystInstance cannot be null." }
+    if (mCatalystInstance != null) {
+      throw IllegalStateException("ReactContext has been already initialized")
+    }
+    if (mDestroyed) {
+      ReactSoftExceptionLogger.logSoftException(
+          TAG,
+          IllegalStateException("Cannot initialize ReactContext after it has been destroyed."),
+      )
+    }
+
+    mCatalystInstance = catalystInstance
+
+    val queueConfig: ReactQueueConfiguration = catalystInstance.reactQueueConfiguration
+    initializeMessageQueueThreads(queueConfig)
+    initializeInteropModules()
+  }
+
+  private fun raiseCatalystInstanceMissingException() {
+    throw IllegalStateException(
+        if (mDestroyed) LATE_NATIVE_MODULE_EXCEPTION_MESSAGE
+        else EARLY_NATIVE_MODULE_EXCEPTION_MESSAGE
+    )
+  }
+
+  /**
+   * Returns a handle to the specified JS module for the CatalystInstance associated with this
+   * Context.
+   */
+  override fun <T : JavaScriptModule> getJSModule(jsInterface: Class<T>): T? {
+    if (mCatalystInstance == null) {
+      if (mDestroyed) {
+        throw IllegalStateException(LATE_JS_ACCESS_EXCEPTION_MESSAGE)
+      }
+      throw IllegalStateException(EARLY_JS_ACCESS_EXCEPTION_MESSAGE)
+    }
+    mInteropModuleRegistry?.let { registry ->
+      val jsModule = registry.getInteropModule(jsInterface)
+      if (jsModule != null) {
+        return jsModule
+      }
+    }
+    return checkNotNull(mCatalystInstance).getJSModule(jsInterface)
+  }
+
+  override fun <T : NativeModule> hasNativeModule(nativeModuleInterface: Class<T>): Boolean {
+    val catalystInstance =
+        mCatalystInstance
+            ?: run {
+              raiseCatalystInstanceMissingException()
+              error("unreachable")
+            }
+    return catalystInstance.hasNativeModule(nativeModuleInterface)
+  }
+
+  override fun getNativeModules(): Collection<NativeModule> {
+    val catalystInstance =
+        mCatalystInstance
+            ?: run {
+              raiseCatalystInstanceMissingException()
+              error("unreachable")
+            }
+    return catalystInstance.nativeModules
+  }
+
+  /** Returns the instance of the specified module interface associated with this ReactContext. */
+  override fun <T : NativeModule> getNativeModule(nativeModuleInterface: Class<T>): T? {
+    val catalystInstance =
+        mCatalystInstance
+            ?: run {
+              raiseCatalystInstanceMissingException()
+              error("unreachable")
+            }
+    return catalystInstance.getNativeModule(nativeModuleInterface)
+  }
+
+  override fun getNativeModule(moduleName: String): NativeModule? {
+    val catalystInstance =
+        mCatalystInstance
+            ?: run {
+              raiseCatalystInstanceMissingException()
+              error("unreachable")
+            }
+    return catalystInstance.getNativeModule(moduleName)
+  }
+
+  override fun getCatalystInstance(): CatalystInstance {
+    return Assertions.assertNotNull(mCatalystInstance)
+  }
+
+  /**
+   * This API has been deprecated due to naming consideration, please use [hasActiveReactInstance]
+   * instead.
+   */
+  @Deprecated("Use hasActiveReactInstance() instead")
+  override fun hasActiveCatalystInstance(): Boolean {
+    return hasActiveReactInstance()
+  }
+
+  /** Returns true if there is a non-null, alive react native instance. */
+  override fun hasActiveReactInstance(): Boolean {
+    return mCatalystInstance?.isDestroyed == false
+  }
+
+  /**
+   * This API has been deprecated due to naming consideration, please use [hasReactInstance]
+   * instead.
+   */
+  @Deprecated("Use hasReactInstance() instead")
+  override fun hasCatalystInstance(): Boolean {
+    return mCatalystInstance != null
+  }
+
+  override fun hasReactInstance(): Boolean {
+    return mCatalystInstance != null
+  }
+
+  /** Destroy this instance, making it unusable. */
+  @ThreadConfined(ThreadConfined.UI)
+  override fun destroy() {
+    UiThreadUtil.assertOnUiThread()
+
+    mDestroyed = true
+    mCatalystInstance?.destroy()
+  }
+
+  /**
+   * Passes the given exception to the current [JSExceptionHandler] if one exists, rethrowing
+   * otherwise.
+   */
+  override fun handleException(e: Exception) {
+    val catalystInstanceVariableExists = mCatalystInstance != null
+    val isCatalystInstanceAlive = mCatalystInstance?.isDestroyed == false
+    val jsExceptionHandler = getJSExceptionHandler()
+
+    if (isCatalystInstanceAlive && jsExceptionHandler != null) {
+      jsExceptionHandler.handleException(e)
+    } else {
+      FLog.e(
+          ReactConstants.TAG,
+          "Unable to handle Exception - catalystInstanceVariableExists: " +
+              catalystInstanceVariableExists +
+              " - isCatalystInstanceAlive: " +
+              isCatalystInstanceAlive +
+              " - hasExceptionHandler: " +
+              (jsExceptionHandler != null),
+          e,
+      )
+      throw IllegalStateException(e)
+    }
+  }
+
+  /** @deprecated DO NOT USE, this method will be removed in the near future. */
+  @Deprecated("DO NOT USE, this method will be removed in the near future.")
+  override fun isBridgeless(): Boolean {
+    return false
+  }
+
+  /**
+   * Get the C pointer (as a long) to the JavaScriptCore context associated with this instance. Use
+   * the following pattern to ensure that the JS context is not cleared while you are using it:
+   * JavaScriptContextHolder jsContext = reactContext.getJavaScriptContextHolder()
+   * synchronized(jsContext) { nativeThingNeedingJsContext(jsContext.get()); }
+   */
+  @FrameworkAPI
+  @UnstableReactNativeAPI
+  override fun getJavaScriptContextHolder(): JavaScriptContextHolder? {
+    return mCatalystInstance?.javaScriptContextHolder
+  }
+
+  /**
+   * Returns a hybrid object that contains a pointer to a JS CallInvoker, which is used to schedule
+   * work on the JS Thread.
+   */
+  override fun getJSCallInvokerHolder(): CallInvokerHolder? {
+    return mCatalystInstance?.jsCallInvokerHolder
+  }
+
+  /**
+   * Get the UIManager for Fabric from the CatalystInstance.
+   *
+   * @return The UIManager when CatalystInstance is active.
+   * @deprecated Do not use this method. Instead use [com.facebook.react.uimanager.UIManagerHelper]
+   *   method [getUIManager] to get the UIManager instance from the current ReactContext.
+   */
+  @Deprecated("Use UIManagerHelper.getUIManager() instead")
+  override fun getFabricUIManager(): UIManager? {
+    return checkNotNull(mCatalystInstance).getFabricUIManager()
+  }
+
+  /**
+   * Get the sourceURL for the JS bundle from the CatalystInstance. This method is needed for
+   * compatibility with bridgeless mode, which has no CatalystInstance.
+   *
+   * @return The JS bundle URL set when the bundle was loaded
+   */
+  override fun getSourceURL(): String? {
+    return mCatalystInstance?.sourceURL
+  }
+
+  /**
+   * Register a JS segment after loading it from cache or server, make sure mCatalystInstance is
+   * properly initialised and not null before calling.
+   */
+  override fun registerSegment(segmentId: Int, path: String, callback: Callback) {
+    Assertions.assertNotNull(mCatalystInstance).registerSegment(segmentId, path)
+    Assertions.assertNotNull(callback).invoke()
+  }
+
+  private companion object {
+    init {
+      LegacyArchitectureLogger.assertLegacyArchitecture(
+          "BridgeReactContext",
+          LegacyArchitectureLogLevel.ERROR,
+      )
+    }
+
+    private const val TAG: String = "BridgeReactContext"
+
+    private const val EARLY_JS_ACCESS_EXCEPTION_MESSAGE: String =
+        "Tried to access a JS module before the React instance was fully set up. Calls to " +
+            "ReactContext#getJSModule should only happen once initialize() has been called on your " +
+            "native module."
+    private const val LATE_JS_ACCESS_EXCEPTION_MESSAGE: String =
+        "Tried to access a JS module after the React instance was destroyed."
+    private const val EARLY_NATIVE_MODULE_EXCEPTION_MESSAGE: String =
+        "Trying to call native module before CatalystInstance has been set!"
+    private const val LATE_NATIVE_MODULE_EXCEPTION_MESSAGE: String =
+        "Trying to call native module after CatalystInstance has been destroyed!"
+  }
+
+  override fun getRuntimeExecutor(): RuntimeExecutor? = mCatalystInstance?.runtimeExecutor
+}

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

@@ -30,6 +30,7 @@ public object ColorPropConverter {
   private const val ATTR = "attr"
   private const val ATTR_SEGMENT = "attr/"
 
+  @Throws(JSApplicationCausedNativeException::class)
   private fun getColorInteger(value: Any?, context: Context): Int? {
     if (value == null) {
       return null
@@ -64,6 +65,12 @@ public object ColorPropConverter {
         }
       }
 
+      val attemptedPaths = (0 until resourcePaths.size()).map { resourcePaths.getString(it) }
+      FLog.w(
+          ReactConstants.TAG,
+          "ColorValue: Failed to resolve resource paths: ${attemptedPaths.joinToString(", ")}",
+      )
+
       throw JSApplicationCausedNativeException(
           "ColorValue: None of the paths in the `$JSON_KEY` array resolved to a color resource."
       )
@@ -73,6 +80,7 @@ public object ColorPropConverter {
   }
 
   @JvmStatic
+  @Throws(JSApplicationCausedNativeException::class)
   public fun getColorInstance(value: Any?, context: Context): Color? {
     if (value == null) {
       return null
@@ -113,6 +121,12 @@ public object ColorPropConverter {
         }
       }
 
+      val attemptedPaths = (0 until resourcePaths.size()).map { resourcePaths.getString(it) }
+      FLog.w(
+          ReactConstants.TAG,
+          "ColorValue: Failed to resolve resource paths: ${attemptedPaths.joinToString(", ")}",
+      )
+
       throw JSApplicationCausedNativeException(
           "ColorValue: None of the paths in the `$JSON_KEY` array resolved to a color resource."
       )
@@ -122,6 +136,7 @@ public object ColorPropConverter {
   }
 
   @JvmStatic
+  @Throws(JSApplicationCausedNativeException::class)
   public fun getColor(value: Any?, context: Context): Int? {
     try {
       if (supportWideGamut()) {
@@ -188,6 +203,7 @@ public object ColorPropConverter {
     return ResourcesCompat.getColor(context.resources, resourceId, context.theme)
   }
 
+  @Throws(Resources.NotFoundException::class)
   private fun resolveThemeAttribute(context: Context, resourcePath: String): Int {
     val path = resourcePath.replace(ATTR_SEGMENT, "")
     val pathTokens = path.split(PACKAGE_DELIMITER)

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

@@ -26,6 +26,7 @@ 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;
@@ -110,6 +111,9 @@ public abstract class ReactContext extends ContextWrapper {
   }
 
   protected void initializeInteropModules() {
+    if (ReactBuildConfig.UNSTABLE_REMOVE_LEGACY_COMPONENT_INTEROP) {
+      return;
+    }
     mInteropModuleRegistry = new InteropModuleRegistry();
   }
 
@@ -200,6 +204,12 @@ 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.
    *
@@ -270,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 {
@@ -298,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);
@@ -573,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/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/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

@@ -51,13 +51,11 @@ 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()
   }
 
   /**
@@ -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)