@rnmapbox/maps 10.2.6 → 10.2.8

package/android/build.gradle

@@ -1,5 +1,13 @@
 def defaultMapboxMapsImpl = "mapbox"
-def defaultMapboxMapsVersion = "11.15.2"
+
+def getDefaultMapboxMapsVersion() {
+    def packageJson = new groovy.json.JsonSlurper().parseText(
+        new File(projectDir.getPath(), "../package.json").text
+    )
+    return packageJson.mapbox.android
+}
+
+def defaultMapboxMapsVersion = getDefaultMapboxMapsVersion()
 
 def safeExtGet(prop, fallback) {
     rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback

package/android/src/main/java/com/rnmapbox/rnmbx/RNMBXPackage.kt

@@ -34,11 +34,13 @@ import com.rnmapbox.rnmbx.components.styles.layers.RNMBXHeatmapLayerManager
 import com.rnmapbox.rnmbx.components.styles.layers.RNMBXLineLayerManager
 import com.rnmapbox.rnmbx.components.styles.layers.RNMBXModelLayerManager
 import com.rnmapbox.rnmbx.components.styles.layers.RNMBXRasterLayerManager
+import com.rnmapbox.rnmbx.components.styles.layers.RNMBXRasterParticleLayerManager
 import com.rnmapbox.rnmbx.components.styles.layers.RNMBXSkyLayerManager
 import com.rnmapbox.rnmbx.components.styles.layers.RNMBXSymbolLayerManager
 import com.rnmapbox.rnmbx.components.styles.light.RNMBXLightManager
 import com.rnmapbox.rnmbx.components.styles.model.RNMBXModelsManager
 import com.rnmapbox.rnmbx.components.styles.sources.RNMBXImageSourceManager
+import com.rnmapbox.rnmbx.components.styles.sources.RNMBXRasterArraySourceManager
 import com.rnmapbox.rnmbx.components.styles.sources.RNMBXRasterDemSourceManager
 import com.rnmapbox.rnmbx.components.styles.sources.RNMBXRasterSourceManager
 import com.rnmapbox.rnmbx.components.styles.sources.RNMBXShapeSourceManager
@@ -140,6 +142,9 @@ class RNMBXPackage : TurboReactPackage() {
             ))
         managers.add(RNMBXRasterDemSourceManager(reactApplicationContext))
         managers.add(RNMBXRasterSourceManager(reactApplicationContext))
+        if (RNMBXRasterArraySourceManager.isImplemented) {
+            managers.add(RNMBXRasterArraySourceManager(reactApplicationContext))
+        }
         managers.add(RNMBXImageSourceManager())
 
         // images
@@ -154,6 +159,9 @@ class RNMBXPackage : TurboReactPackage() {
         managers.add(RNMBXCircleLayerManager())
         managers.add(RNMBXSymbolLayerManager())
         managers.add(RNMBXRasterLayerManager())
+        if (RNMBXRasterParticleLayerManager.isImplemented) {
+            managers.add(RNMBXRasterParticleLayerManager())
+        }
         managers.add(RNMBXSkyLayerManager())
         managers.add(RNMBXTerrainManager())
         managers.add(RNMBXAtmosphereManager())

package/android/src/main/java/com/rnmapbox/rnmbx/components/mapview/RNMBXMapView.kt

@@ -917,7 +917,13 @@ open class RNMBXMapView(private val mContext: Context, var mManager: RNMBXMapVie
             Logger.e("queryRenderedFeaturesAtPoint", "mapbox map is null")
             return
         }
-        val screenCoordinate = ScreenCoordinate(point.x.toDouble(), point.y.toDouble())
+        // JS sends point values in DIP (see getPointInView which divides by display density),
+        // but Mapbox core expects screen pixel coordinates. Convert back to px here.
+        val density: Float = getDisplayDensity()
+        val screenCoordinate = ScreenCoordinate(
+                (point.x * density).toDouble(),
+                (point.y * density).toDouble()
+        )
         val queryGeometry = RenderedQueryGeometry(screenCoordinate)
         val layers = layerIDs?.takeUnless { it.isEmpty() } ?: null;
         val queryOptions = RenderedQueryOptions(layers, filter)

package/android/src/main/java/com/rnmapbox/rnmbx/components/styles/RNMBXStyleFactory.kt

@@ -13,6 +13,7 @@ import com.mapbox.maps.extension.style.layers.generated.SkyLayer
 // import com.mapbox.maps.extension.style.layers.generated.PropertyFactory
 // import com.mapbox.maps.extension.style.layers.generated.PropertyValue
 import com.mapbox.maps.extension.style.layers.generated.RasterLayer
+import com.mapbox.maps.extension.style.layers.generated.RasterParticleLayer
 import com.mapbox.maps.extension.style.layers.generated.SymbolLayer
 import com.mapbox.maps.extension.style.layers.generated.HeatmapLayer
 import com.mapbox.maps.extension.style.layers.generated.HillshadeLayer
@@ -704,6 +705,44 @@ object RNMBXStyleFactory {
         }
       }
     }
+    fun setRasterParticleLayerStyle(layer: RasterParticleLayer, style: RNMBXStyle ) {
+      val styleKeys = style.allStyleKeys
+
+      if (styleKeys.isEmpty()) {
+        return
+      }
+
+      for (styleKey in styleKeys) {
+        try {
+          val styleValue = style.getStyleValueForKey(styleKey)
+
+          when (styleKey) {
+              "visibility" ->
+                setVisibility(layer, styleValue)
+              "rasterParticleArrayBand" ->
+                setRasterParticleArrayBand(layer, styleValue)
+              "rasterParticleCount" ->
+                setRasterParticleCount(layer, styleValue)
+              "rasterParticleColor" ->
+                setRasterParticleColor(layer, styleValue)
+              "rasterParticleMaxSpeed" ->
+                setRasterParticleMaxSpeed(layer, styleValue)
+              "rasterParticleSpeedFactor" ->
+                setRasterParticleSpeedFactor(layer, styleValue)
+                "rasterParticleSpeedFactorTransition" ->
+                setRasterParticleSpeedFactorTransition(layer, styleValue)
+              "rasterParticleFadeOpacityFactor" ->
+                setRasterParticleFadeOpacityFactor(layer, styleValue)
+                "rasterParticleFadeOpacityFactorTransition" ->
+                setRasterParticleFadeOpacityFactorTransition(layer, styleValue)
+              "rasterParticleResetRateFactor" ->
+                setRasterParticleResetRateFactor(layer, styleValue)
+          }
+        } catch (e: MapboxStyleException) {
+          Logger.e(LOG_TAG, "Failed to update: $styleKey ${e.message}")
+        }
+      }
+    }
     fun setHillshadeLayerStyle(layer: HillshadeLayer, style: RNMBXStyle ) {
       val styleKeys = style.allStyleKeys
 
@@ -4354,6 +4393,147 @@ object RNMBXStyleFactory {
       }
     }
 
+    fun setVisibility(layer: RasterParticleLayer, styleValue: RNMBXStyleValue ) {
+        layer.visibility(Visibility.valueOf(styleValue.getEnumName()));
+    }
+
+    fun setRasterParticleArrayBand(layer: RasterParticleLayer, styleValue: RNMBXStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.rasterParticleArrayBand(expression)
+        } else {
+          Logger.e("RNMBXRasterParticle", "Expression for rasterParticleArrayBand is null")
+        }
+      } else {
+          val value = styleValue.getString(VALUE_KEY)
+          if (value != null) {
+            layer.rasterParticleArrayBand(value)
+          } else {
+            Logger.e("RNMBXRasterParticle", "value for rasterParticleArrayBand is null")
+          }
+      }
+    }
+
+    fun setRasterParticleCount(layer: RasterParticleLayer, styleValue: RNMBXStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.rasterParticleCount(expression)
+        } else {
+          Logger.e("RNMBXRasterParticle", "Expression for rasterParticleCount is null")
+        }
+      } else {
+          val value = styleValue.getLong(VALUE_KEY)
+          if (value != null) {
+            layer.rasterParticleCount(value)
+          } else {
+            Logger.e("RNMBXRasterParticle", "value for rasterParticleCount is null")
+          }
+      }
+    }
+
+    fun setRasterParticleColor(layer: RasterParticleLayer, styleValue: RNMBXStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.rasterParticleColor(expression)
+        } else {
+          Logger.e("RNMBXRasterParticle", "Expression for rasterParticleColor is null")
+        }
+      } else {
+          layer.rasterParticleColor(styleValue.getIntExpression(VALUE_KEY))
+      }
+    }
+
+    fun setRasterParticleMaxSpeed(layer: RasterParticleLayer, styleValue: RNMBXStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.rasterParticleMaxSpeed(expression)
+        } else {
+          Logger.e("RNMBXRasterParticle", "Expression for rasterParticleMaxSpeed is null")
+        }
+      } else {
+          val value = styleValue.getDouble(VALUE_KEY)
+          if (value != null) {
+            layer.rasterParticleMaxSpeed(value)
+          } else {
+            Logger.e("RNMBXRasterParticle", "value for rasterParticleMaxSpeed is null")
+          }
+      }
+    }
+
+    fun setRasterParticleSpeedFactor(layer: RasterParticleLayer, styleValue: RNMBXStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.rasterParticleSpeedFactor(expression)
+        } else {
+          Logger.e("RNMBXRasterParticle", "Expression for rasterParticleSpeedFactor is null")
+        }
+      } else {
+          val value = styleValue.getDouble(VALUE_KEY)
+          if (value != null) {
+            layer.rasterParticleSpeedFactor(value)
+          } else {
+            Logger.e("RNMBXRasterParticle", "value for rasterParticleSpeedFactor is null")
+          }
+      }
+    }
+
+
+    fun setRasterParticleSpeedFactorTransition(layer: RasterParticleLayer, styleValue: RNMBXStyleValue) {
+      val transition = styleValue.transition
+      if (transition != null) {
+        layer.rasterParticleSpeedFactorTransition(transition);
+      }
+    }
+
+    fun setRasterParticleFadeOpacityFactor(layer: RasterParticleLayer, styleValue: RNMBXStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.rasterParticleFadeOpacityFactor(expression)
+        } else {
+          Logger.e("RNMBXRasterParticle", "Expression for rasterParticleFadeOpacityFactor is null")
+        }
+      } else {
+          val value = styleValue.getDouble(VALUE_KEY)
+          if (value != null) {
+            layer.rasterParticleFadeOpacityFactor(value)
+          } else {
+            Logger.e("RNMBXRasterParticle", "value for rasterParticleFadeOpacityFactor is null")
+          }
+      }
+    }
+
+
+    fun setRasterParticleFadeOpacityFactorTransition(layer: RasterParticleLayer, styleValue: RNMBXStyleValue) {
+      val transition = styleValue.transition
+      if (transition != null) {
+        layer.rasterParticleFadeOpacityFactorTransition(transition);
+      }
+    }
+
+    fun setRasterParticleResetRateFactor(layer: RasterParticleLayer, styleValue: RNMBXStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.rasterParticleResetRateFactor(expression)
+        } else {
+          Logger.e("RNMBXRasterParticle", "Expression for rasterParticleResetRateFactor is null")
+        }
+      } else {
+          val value = styleValue.getDouble(VALUE_KEY)
+          if (value != null) {
+            layer.rasterParticleResetRateFactor(value)
+          } else {
+            Logger.e("RNMBXRasterParticle", "value for rasterParticleResetRateFactor is null")
+          }
+      }
+    }
+
     fun setVisibility(layer: HillshadeLayer, styleValue: RNMBXStyleValue ) {
         layer.visibility(Visibility.valueOf(styleValue.getEnumName()));
     }

package/android/src/main/java/com/rnmapbox/rnmbx/components/styles/RNMBXStyleValue.kt

@@ -33,6 +33,10 @@ class RNMBXStyleValue(key: String?, config: ReadableMap) {
         return mPayload!!.getInt(key!!)
     }
 
+    fun getLong(key: String?): Long {
+        return mPayload!!.getInt(key!!).toLong()
+    }
+
     fun getIntExpression(key: String?): Expression {
         return Expression.literal(mPayload!!.getInt(key!!).toLong())
     }

package/android/src/main/java/com/rnmapbox/rnmbx/modules/CustomHttpHeaders.kt

@@ -1,36 +1,58 @@
 package com.rnmapbox.rnmbx.modules
 
 import com.mapbox.common.*
-
 import com.rnmapbox.rnmbx.v11compat.httpinterceptor.*
 
+data class CustomHttpHeadersOptions(val urlRegexp: Regex?)
+
+data class CustomHttpHeadersMapValue(
+    val headerValue: String,
+    val options: CustomHttpHeadersOptions?
+)
+
 object CustomHttpHeaders : HttpServiceBase() {
+    const val LOG_TAG = "CustomHttpHeaders"
+
     init {}
 
-    val map = mutableMapOf<String, String>()
+    val map = mutableMapOf<String, CustomHttpHeadersMapValue>()
 
-    fun addCustomHeader(headerName: String, headerValue: String) {
+    fun addCustomHeader(headerName: String, headerValue: String, options: CustomHttpHeadersOptions? = null) {
         HttpServiceFactory.getInstance().setInterceptor(
             this
         )
-        map.put(headerName, headerValue)
+        map.put(headerName, CustomHttpHeadersMapValue(headerValue = headerValue, options = options))
     }
 
     fun removeCustomHeader(headerName: String) {
         map.remove(headerName)
     }
 
-    override fun onRequest(request: HttpRequest): HttpRequest {
+    fun getCustomRequestHeaders(customRequestHeaders: MutableMap<String, CustomHttpHeadersMapValue>, httpRequest: HttpRequest): HashMap<String, String> {
+        val headers = hashMapOf<String, String>()
         for (entry in map.entries.iterator()) {
-            request.headers[entry.key] = entry.value
+            val urlRegexp = entry.value.options?.urlRegexp
+            if (urlRegexp != null) {
+                val destination = httpRequest.headers.getOrDefault("location", httpRequest.url)
+                if (urlRegexp.matches(destination)) {
+                    headers[entry.key] = entry.value.headerValue
+                }
+            }
+            else {
+                headers[entry.key] = entry.value.headerValue
+            }
         }
+        return headers
+    }
+
+    override fun onRequest(request: HttpRequest): HttpRequest {
+        request.headers.remove("Authorization")
+        request.headers.putAll(getCustomRequestHeaders(map, request))
         return request
     }
 
     override fun onDownload(download: DownloadOptions): DownloadOptions {
-        for (entry in map.entries.iterator()) {
-            download.request.headers[entry.key] = entry.value
-        }
+        download.request.headers.putAll(getCustomRequestHeaders(map, download.request))
         return download
     }
 

package/android/src/main/java/com/rnmapbox/rnmbx/modules/RNMBXModule.kt

@@ -1,6 +1,7 @@
 package com.rnmapbox.rnmbx.modules
 
 import android.os.Handler
+import androidx.annotation.Nullable
 import com.facebook.react.bridge.Promise
 import com.mapbox.maps.extension.style.layers.properties.generated.LineJoin
 import com.facebook.react.module.annotations.ReactModule
@@ -11,6 +12,8 @@ import com.rnmapbox.rnmbx.events.constants.EventTypes
 import com.rnmapbox.rnmbx.modules.RNMBXOfflineModule
 import com.rnmapbox.rnmbx.modules.RNMBXLocationModule
 import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReadableMap
 import com.facebook.react.common.MapBuilder
 import com.mapbox.bindgen.None
 import com.mapbox.common.*
@@ -24,6 +27,7 @@ import java.util.HashMap
 
 import com.rnmapbox.rnmbx.v11compat.resourceoption.*
 import com.rnmapbox.rnmbx.v11compat.mapboxmap.*
+import java.util.regex.PatternSyntaxException
 
 @ReactModule(name = RNMBXModule.REACT_CLASS)
 class RNMBXModule(private val mReactContext: ReactApplicationContext) : ReactContextBaseJavaModule(
@@ -165,7 +169,17 @@ class RNMBXModule(private val mReactContext: ReactApplicationContext) : ReactCon
 
     @ReactMethod
     fun addCustomHeader(headerName: String, headerValue: String) {
-        CustomHttpHeaders.addCustomHeader(headerName, headerValue)
+        addCustomHeaderWithOptions(headerName, headerValue)
+    }
+
+    @ReactMethod
+    fun addCustomHeaderWithOptions(headerName: String, headerValue: String, options: ReadableMap? = Arguments.createMap()) {
+        try {
+            val urlRegexp = options?.getString("urlRegexp")?.toRegex()
+            CustomHttpHeaders.addCustomHeader(headerName, headerValue, CustomHttpHeadersOptions(urlRegexp = urlRegexp))
+        } catch (e: PatternSyntaxException) {
+            Logger.e(CustomHttpHeaders.LOG_TAG, e.localizedMessage ?: "Error converting ${options?.getString("urlRegexp")} to regex")
+        }
     }
 
     @ReactMethod

package/android/src/main/java/com/rnmapbox/rnmbx/modules/RNMBXOfflineModuleLegacy.kt

@@ -374,6 +374,16 @@ class RNMBXOfflineModuleLegacy(private val mReactContext: ReactApplicationContex
         }
     }
 
+    @ReactMethod
+    fun setTileCountLimit(tileCountLimit: Int) {
+        UiThreadUtil.runOnUiThread {
+            val offlineRegionManager = getOfflineRegionManager {
+                RNMBXModule.getAccessToken(mReactContext)
+            }
+            offlineRegionManager.setOfflineMapboxTileCountLimit(tileCountLimit.toLong())
+        }
+    }
+
     @ReactMethod
     fun resetDatabase(promise: Promise) {
         UiThreadUtil.runOnUiThread {

package/android/src/main/mapbox-v11-compat/v10/com/mapbox/maps/extension/style/layers/generated/RasterParticleLayer.kt

@@ -0,0 +1,58 @@
+// Dummy RasterParticleLayer for v10 compatibility
+// RasterParticleLayer is only available in Mapbox SDK v11+
+package com.mapbox.maps.extension.style.layers.generated
+
+import com.mapbox.maps.extension.style.expressions.generated.Expression
+import com.mapbox.maps.extension.style.layers.properties.generated.Visibility
+import com.mapbox.maps.extension.style.types.StyleTransition
+
+/**
+ * Dummy implementation of RasterParticleLayer for v10 compatibility.
+ * This class should never be instantiated in v10 builds.
+ * Note: Does not extend Layer to avoid abstract method issues in v10.
+ */
+class RasterParticleLayer(private val id: String, private val sourceId: String) {
+
+    val layerId: String
+        get() = id
+
+    var minZoom: Double? = null
+        private set
+
+    var maxZoom: Double? = null
+        private set
+
+    var visibility: Visibility? = null
+        private set
+
+    fun minZoom(minZoom: Double): RasterParticleLayer {
+        this.minZoom = minZoom
+        return this
+    }
+
+    fun maxZoom(maxZoom: Double): RasterParticleLayer {
+        this.maxZoom = maxZoom
+        return this
+    }
+
+    fun getType(): String = "raster-particle"
+
+    fun rasterParticleArrayBand(value: String) {}
+    fun rasterParticleArrayBand(expression: Expression) {}
+    fun rasterParticleCount(value: Long) {}
+    fun rasterParticleCount(expression: Expression) {}
+    fun rasterParticleColor(expression: Expression) {}
+    fun rasterParticleMaxSpeed(value: Double) {}
+    fun rasterParticleMaxSpeed(expression: Expression) {}
+    fun rasterParticleSpeedFactor(value: Double) {}
+    fun rasterParticleSpeedFactor(expression: Expression) {}
+    fun rasterParticleSpeedFactorTransition(transition: StyleTransition) {}
+    fun rasterParticleFadeOpacityFactor(value: Double) {}
+    fun rasterParticleFadeOpacityFactor(expression: Expression) {}
+    fun rasterParticleFadeOpacityFactorTransition(transition: StyleTransition) {}
+    fun rasterParticleResetRateFactor(value: Double) {}
+    fun rasterParticleResetRateFactor(expression: Expression) {}
+    fun visibility(visibility: Visibility) {
+        this.visibility = visibility
+    }
+}

package/android/src/main/mapbox-v11-compat/v10/com/mapbox/maps/extension/style/sources/generated/RasterArraySource.kt

@@ -0,0 +1,20 @@
+// Dummy RasterArraySource for v10 compatibility
+// RasterArraySource is only available in Mapbox SDK v11+
+package com.mapbox.maps.extension.style.sources.generated
+
+/**
+ * Dummy implementation of RasterArraySource for v10 compatibility.
+ * This class should never be instantiated in v10 builds.
+ * Note: Does not extend Source to avoid abstract method issues in v10.
+ */
+class RasterArraySource private constructor(
+    builder: Builder
+) {
+    val sourceId: String = builder.sourceId
+
+    class Builder(val sourceId: String) {
+        fun url(url: String): Builder = this
+        fun tileSize(tileSize: Long): Builder = this
+        fun build(): RasterArraySource = RasterArraySource(this)
+    }
+}

package/android/src/main/mapbox-v11-compat/v10/com/rnmapbox/rnmbx/components/styles/layers/RNMBXRasterParticleLayer.kt

@@ -0,0 +1,22 @@
+package com.rnmapbox.rnmbx.components.styles.layers
+
+import android.content.Context
+import android.view.ViewGroup
+
+/**
+ * Dummy implementation of RNMBXRasterParticleLayer for v10 compatibility.
+ * This class extends ViewGroup directly (instead of RNMBXLayer) to avoid
+ * inheriting from Layer which has internal abstract methods in v10.
+ * This class should never be instantiated in v10 builds.
+ */
+class RNMBXRasterParticleLayer(context: Context) : ViewGroup(context) {
+    var mSourceLayerID: String? = null
+
+    override fun onLayout(changed: Boolean, l: Int, t: Int, r: Int, b: Int) {
+        // Stub - never called
+    }
+
+    fun setSourceLayerID(sourceLayer: String?) {
+        mSourceLayerID = sourceLayer
+    }
+}

package/android/src/main/mapbox-v11-compat/v10/com/rnmapbox/rnmbx/components/styles/layers/RNMBXRasterParticleLayerManager.kt

@@ -0,0 +1,59 @@
+package com.rnmapbox.rnmbx.components.styles.layers
+
+import com.facebook.react.bridge.Dynamic
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.ViewGroupManager
+import com.facebook.react.uimanager.annotations.ReactProp
+import com.facebook.react.viewmanagers.RNMBXRasterParticleLayerManagerInterface
+
+class RNMBXRasterParticleLayerManager : ViewGroupManager<RNMBXRasterParticleLayer>(),
+    RNMBXRasterParticleLayerManagerInterface<RNMBXRasterParticleLayer> {
+    override fun getName(): String {
+        return REACT_CLASS
+    }
+
+    override fun createViewInstance(reactContext: ThemedReactContext): RNMBXRasterParticleLayer {
+        throw UnsupportedOperationException("RasterParticleLayer is only supported in Mapbox v11+")
+    }
+
+    @ReactProp(name = "id")
+    override fun setId(layer: RNMBXRasterParticleLayer, id: Dynamic) {}
+
+    @ReactProp(name = "existing")
+    override fun setExisting(layer: RNMBXRasterParticleLayer, existing: Dynamic) {}
+
+    @ReactProp(name = "sourceID")
+    override fun setSourceID(layer: RNMBXRasterParticleLayer, sourceID: Dynamic) {}
+
+    @ReactProp(name = "aboveLayerID")
+    override fun setAboveLayerID(layer: RNMBXRasterParticleLayer, aboveLayerID: Dynamic) {}
+
+    @ReactProp(name = "belowLayerID")
+    override fun setBelowLayerID(layer: RNMBXRasterParticleLayer, belowLayerID: Dynamic) {}
+
+    @ReactProp(name = "layerIndex")
+    override fun setLayerIndex(layer: RNMBXRasterParticleLayer, layerIndex: Dynamic) {}
+
+    @ReactProp(name = "minZoomLevel")
+    override fun setMinZoomLevel(layer: RNMBXRasterParticleLayer, minZoomLevel: Dynamic) {}
+
+    @ReactProp(name = "maxZoomLevel")
+    override fun setMaxZoomLevel(layer: RNMBXRasterParticleLayer, maxZoomLevel: Dynamic) {}
+
+    @ReactProp(name = "reactStyle")
+    override fun setReactStyle(layer: RNMBXRasterParticleLayer, style: Dynamic) {}
+
+    @ReactProp(name = "sourceLayerID")
+    override fun setSourceLayerID(layer: RNMBXRasterParticleLayer, sourceLayerID: Dynamic) {}
+
+    @ReactProp(name = "filter")
+    override fun setFilter(layer: RNMBXRasterParticleLayer, filterList: Dynamic) {}
+
+    @ReactProp(name = "slot")
+    override fun setSlot(layer: RNMBXRasterParticleLayer, slot: Dynamic) {}
+
+    companion object {
+        const val REACT_CLASS = "RNMBXRasterParticleLayer"
+        const val isImplemented = false
+    }
+}

package/android/src/main/mapbox-v11-compat/v10/com/rnmapbox/rnmbx/components/styles/sources/RNMBXRasterArraySource.kt

@@ -0,0 +1,16 @@
+package com.rnmapbox.rnmbx.components.styles.sources
+
+import android.content.Context
+import android.view.ViewGroup
+
+/**
+ * Dummy implementation of RNMBXRasterArraySource for v10 compatibility.
+ * This class extends ViewGroup directly (instead of RNMBXTileSource) to avoid
+ * inheriting from Source which has internal abstract methods in v10.
+ * This class should never be instantiated in v10 builds.
+ */
+class RNMBXRasterArraySource(context: Context) : ViewGroup(context) {
+    override fun onLayout(changed: Boolean, l: Int, t: Int, r: Int, b: Int) {
+        // Stub - never called
+    }
+}

package/android/src/main/mapbox-v11-compat/v10/com/rnmapbox/rnmbx/components/styles/sources/RNMBXRasterArraySourceManager.kt

@@ -0,0 +1,59 @@
+package com.rnmapbox.rnmbx.components.styles.sources
+
+import com.facebook.react.bridge.Dynamic
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.ViewGroupManager
+import com.facebook.react.uimanager.annotations.ReactProp
+import com.facebook.react.viewmanagers.RNMBXRasterArraySourceManagerInterface
+import javax.annotation.Nonnull
+
+class RNMBXRasterArraySourceManager(reactApplicationContext: ReactApplicationContext) :
+    ViewGroupManager<RNMBXRasterArraySource>(),
+    RNMBXRasterArraySourceManagerInterface<RNMBXRasterArraySource> {
+    @Nonnull
+    override fun getName(): String {
+        return REACT_CLASS
+    }
+
+    @Nonnull
+    override fun createViewInstance(@Nonnull reactContext: ThemedReactContext): RNMBXRasterArraySource {
+        throw UnsupportedOperationException("RasterArraySource is only supported in Mapbox v11+")
+    }
+
+    @ReactProp(name = "id")
+    override fun setId(source: RNMBXRasterArraySource, id: Dynamic) {}
+
+    @ReactProp(name = "url")
+    override fun setUrl(source: RNMBXRasterArraySource, url: Dynamic) {}
+
+    @ReactProp(name = "tileUrlTemplates")
+    override fun setTileUrlTemplates(source: RNMBXRasterArraySource, tileUrlTemplates: Dynamic) {}
+
+    @ReactProp(name = "tileSize")
+    override fun setTileSize(source: RNMBXRasterArraySource, tileSize: Dynamic) {}
+
+    @ReactProp(name = "minZoomLevel")
+    override fun setMinZoomLevel(source: RNMBXRasterArraySource, minZoomLevel: Dynamic) {}
+
+    @ReactProp(name = "maxZoomLevel")
+    override fun setMaxZoomLevel(source: RNMBXRasterArraySource, maxZoomLevel: Dynamic) {}
+
+    @ReactProp(name = "attribution")
+    fun setAttribution(source: RNMBXRasterArraySource, attribution: Dynamic) {}
+
+    fun customEvents(): Map<String, String>? {
+        return null
+    }
+
+    companion object {
+        const val REACT_CLASS = "RNMBXRasterArraySource"
+        const val isImplemented = false
+    }
+
+    @ReactProp(name = "existing")
+    override fun setExisting(source: RNMBXRasterArraySource, value: Dynamic) {}
+
+    @ReactProp(name = "sourceBounds")
+    override fun setSourceBounds(source: RNMBXRasterArraySource, value: Dynamic) {}
+}