@rnmapbox/maps 10.0.0-beta.44 → 10.0.0-beta.46

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/RCTMGLPackage.java

@@ -10,7 +10,6 @@ import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 
-import com.mapbox.rctmgl.components.annotation.RCTMGLMarkerViewWrapperManager;
 import com.mapbox.rctmgl.components.camera.RCTMGLCameraManager;
 
 import com.mapbox.rctmgl.components.annotation.RCTMGLCalloutManager;
@@ -81,7 +80,6 @@ public class RCTMGLPackage implements ReactPackage {
 
         // annotations
         managers.add(new RCTMGLMarkerViewManager(reactApplicationContext));
-        managers.add(new RCTMGLMarkerViewWrapperManager(reactApplicationContext));
         managers.add(new RCTMGLPointAnnotationManager(reactApplicationContext));
         managers.add(new RCTMGLCalloutManager());
 

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/components/annotation/RCTMGLMarkerView.kt

@@ -1,85 +1,196 @@
 package com.mapbox.rctmgl.components.annotation
 
 import android.content.Context
+import android.os.Handler
+import android.os.Looper
+import android.util.Log
 import android.view.View
+import android.widget.FrameLayout
 import com.mapbox.geojson.Point
+import com.mapbox.maps.ViewAnnotationAnchor
 import com.mapbox.maps.ViewAnnotationOptions
+import com.mapbox.maps.viewannotation.viewAnnotationOptions
 import com.mapbox.rctmgl.components.AbstractMapFeature
 import com.mapbox.rctmgl.components.mapview.RCTMGLMapView
+import com.mapbox.rctmgl.modules.RCTMGLLogging
+import com.mapbox.rctmgl.utils.Logger
+import java.util.Vector
+
+private data class Vec2(val dx: Double, val dy: Double)
+
+class RCTMGLMarkerView(context: Context?, private val mManager: RCTMGLMarkerViewManager):
+    AbstractMapFeature(context),
+    View.OnLayoutChangeListener
+{
+    // region Instance variables
 
-class RCTMGLMarkerView(context: Context?, private val mManager: RCTMGLMarkerViewManager) : AbstractMapFeature(context), View.OnLayoutChangeListener {
     private var mMapView: RCTMGLMapView? = null
-    private var mChildView: View? = null
-    private var mCoordinate: Point? = null
-    private lateinit var mAnchor: Array<Float>
+    private var mView: View? = null
+    private var didAddToMap = false
 
-    override fun addView(childView: View, childPosition: Int) {
-        mChildView = childView
-    }
+    private var mCoordinate: Point? = null
+    private var mAnchor: Vec2 = Vec2(0.5, 0.5)
+    private var mAllowOverlap = false
+    private var mIsSelected = false
 
     fun setCoordinate(point: Point?) {
         mCoordinate = point
-        if (mChildView != null) {
-            val options = ViewAnnotationOptions.Builder().geometry(mCoordinate).build()
-            mMapView?.viewAnnotationManager?.updateViewAnnotation(mChildView!!, options)
-        }
+        update()
     }
 
     fun setAnchor(x: Float, y: Float) {
-        mAnchor = arrayOf(x, y)
-        refresh()
+        mAnchor = Vec2(x.toDouble(), y.toDouble())
+        update()
     }
 
-    fun refresh() {
-        // this will cause position to be recalculated
-        if (mChildView != null) {
-            val width = mChildView!!.width
-            val height = mChildView!!.height
-            val options = ViewAnnotationOptions.Builder().geometry(mCoordinate).width(width).height(height).offsetX(((mAnchor[0] - 0.5) * width).toInt()).offsetY(((mAnchor[1] - 0.5) * height).toInt()).build()
-            mMapView?.viewAnnotationManager?.updateViewAnnotation(mChildView!!, options)
-        }
+    fun setAllowOverlap(allowOverlap: Boolean) {
+        mAllowOverlap = allowOverlap
+        update()
+    }
+
+    fun setIsSelected(isSelected: Boolean) {
+        mIsSelected = isSelected
+        update()
+    }
+
+    // endregion
+
+    // region View methods
+
+    override fun addView(childView: View, childPosition: Int) {
+        mView = childView
+        // Note: Do not call this method on `super`. The view is added manually.
+    }
+
+    override fun onLayoutChange(
+        v: View,
+        left: Int, top: Int, right: Int, bottom: Int,
+        oldLeft: Int, oldTop: Int, oldRight: Int, oldBottom: Int
+    ) {
+        addOrUpdate()
     }
 
+    // endregion
+
+    // region RCTMGLMapComponent methods
+
     override fun addToMap(mapView: RCTMGLMapView) {
         mMapView = mapView
-        val rctmglMarkerView = this
-        mMapView?.getMapAsync {
-            if (mChildView != null) {
-                val width = mChildView!!.width
-                val height = mChildView!!.height
-                val options = ViewAnnotationOptions.Builder().geometry(mCoordinate).width(width).height(height).offsetX(((mAnchor[0] - 0.5) * width).toInt()).offsetY(((mAnchor[1] - 0.5) * height).toInt()).build()
-                mChildView!!.addOnLayoutChangeListener(rctmglMarkerView)
-                if (mChildView!!.layoutParams == null && !mChildView!!.isAttachedToWindow) {
-                    mMapView?.offscreenAnnotationViewContainer()?.addView(mChildView)
-                    mMapView?.offscreenAnnotationViewContainer()?.removeView(mChildView)
-                }
-                mMapView?.viewAnnotationManager?.addViewAnnotation(mChildView!!, options)
-            }
-        }
+        add()
     }
 
     override fun removeFromMap(mapView: RCTMGLMapView) {
-        val childView = mChildView
-        if (childView != null) {
-            childView.removeOnLayoutChangeListener(this)
-            childView.visibility = INVISIBLE;
-            mMapView?.viewAnnotationManager?.removeViewAnnotation(childView)
+        remove(mapView)
+    }
+
+    // endregion
+
+    // region Create, update, and remove methods
+
+    private fun addOrUpdate() {
+        if (didAddToMap) {
+            update()
+        } else {
+            add()
+        }
+    }
+
+    private fun add() {
+        if (didAddToMap) {
+            return
         }
+
+        if (mView == null || mCoordinate == null) {
+            return
+        }
+        val view = mView!!
+
+        view.addOnLayoutChangeListener(this)
+
+        if (view.layoutParams == null && !view.isAttachedToWindow) {
+            mMapView?.offscreenAnnotationViewContainer?.addView(view)
+            mMapView?.offscreenAnnotationViewContainer?.removeView(view)
+        }
+
+        val options = getOptions()
+
+        val annotation = mMapView?.viewAnnotationManager?.addViewAnnotation(
+            view,
+            options
+        )
+        didAddToMap = true
+    }
+
+    fun update() {
+        if (!didAddToMap) {
+            return
+        }
+
+        if (mView == null || mCoordinate == null) {
+            return
+        }
+        val view = mView!!
+
+        val options = getOptions()
+
+        val annotation = mMapView?.viewAnnotationManager?.updateViewAnnotation(
+            view,
+            options
+        )
     }
 
-    override fun onLayoutChange(v: View, left: Int, top: Int, right: Int, bottom: Int, oldLeft: Int, oldTop: Int,
-                                oldRight: Int, oldBottom: Int) {
-        if (left != oldLeft || right != oldRight || top != oldTop || bottom != oldBottom) {
-            val centerX = oldLeft + (oldRight-oldLeft)*mAnchor[0];
-            val centerY = oldTop + (oldBottom-oldTop)*mAnchor[1];
+    private fun remove(mapView: RCTMGLMapView) {
+        this.removeOnLayoutChangeListener(this)
 
-            val newLeft = (centerX - (mAnchor[0] * (right - left))).toInt();
-            val newTop =  (centerY - (mAnchor[1] * (bottom - top))).toInt();
+        mView?.let { view ->
+            mapView.endViewTransition(view) // https://github.com/mapbox/mapbox-maps-android/issues/1723
+            val removed = mapView.viewAnnotationManager?.removeViewAnnotation(view)
+            if (removed == false) {
+                Logger.w("RCTMGLMarkerView", "Unable to remove view")
+            }
+        }
+    }
+
+    // endregion
+
+    // region Helper functions
+
+    private fun getOptions(): ViewAnnotationOptions {
+        val view = mView!!
+        val width = view.width
+        val height = view.height
+        val coordinate = mCoordinate
+
+        val offset = getOffset()
 
-            val childView = mChildView!!
-            childView.x = (newLeft - oldLeft) + childView.x;
-            childView.y = (newTop-oldTop) + childView.y;
-            refresh()
+        val options = viewAnnotationOptions {
+            geometry(coordinate)
+            width(width)
+            height(height)
+            allowOverlap(mAllowOverlap)
+            offsetX(offset.dx.toInt())
+            offsetY(offset.dy.toInt())
+            selected(mIsSelected)
         }
+        return options
     }
+
+    private fun getOffset(): Vec2 {
+        if (mView == null) {
+            return Vec2(0.0, 0.0)
+        }
+        val view = mView!!
+
+        val width = view.width
+        val height = view.height
+
+        // Create a modified offset, normalized from 0..1 to -1..1 and scaled to
+        // the view size.
+        val offsetX = (mAnchor.dx * 2 - 1) * (width / 2) * -1
+        val offsetY = (mAnchor.dy * 2 - 1) * (height / 2)
+
+        return Vec2(offsetX, offsetY)
+    }
+
+    // endregion
 }

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/components/annotation/RCTMGLMarkerViewManager.kt

@@ -25,6 +25,16 @@ class RCTMGLMarkerViewManager(reactApplicationContext: ReactApplicationContext?)
         markerView.setAnchor(map.getDouble("x").toFloat(), map.getDouble("y").toFloat())
     }
 
+    @ReactProp(name = "allowOverlap")
+    fun setAllowOverlap(markerView: RCTMGLMarkerView, allowOverlap: Boolean) {
+        markerView.setAllowOverlap(allowOverlap)
+    }
+
+    @ReactProp(name = "isSelected")
+    fun setIsSelected(markerView: RCTMGLMarkerView, isSelected: Boolean) {
+        markerView.setIsSelected(isSelected)
+    }
+
     override fun createViewInstance(reactContext: ThemedReactContext): RCTMGLMarkerView {
         return RCTMGLMarkerView(reactContext, this)
     }

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/components/annotation/RCTMGLPointAnnotation.kt

@@ -53,7 +53,7 @@ class RCTMGLPointAnnotation(private val mContext: Context, private val mManager:
         }
         childView.addOnLayoutChangeListener(this)
 
-        mMapView?.offscreenAnnotationViewContainer()?.addView(childView)
+        mMapView?.offscreenAnnotationViewContainer?.addView(childView)
 
     }
 
@@ -70,7 +70,7 @@ class RCTMGLPointAnnotation(private val mContext: Context, private val mManager:
                 }
             })
         }
-        mMapView?.offscreenAnnotationViewContainer()?.removeView(childView)
+        mMapView?.offscreenAnnotationViewContainer?.removeView(childView)
     }
 
     override fun addToMap(mapView: RCTMGLMapView) {
@@ -79,14 +79,14 @@ class RCTMGLPointAnnotation(private val mContext: Context, private val mManager:
         makeMarker()
         if (mChildView != null) {
             if (!mChildView!!.isAttachedToWindow) {
-                mMapView!!.offscreenAnnotationViewContainer().addView(mChildView)
+                mMapView!!.offscreenAnnotationViewContainer?.addView(mChildView)
             }
             addBitmapToStyle(mChildBitmap, mChildBitmapId)
             updateOptions()
         }
         if (calloutView != null) {
             if (!calloutView!!.isAttachedToWindow && mMapView != null) {
-                mMapView!!.offscreenAnnotationViewContainer().addView(calloutView)
+                mMapView!!.offscreenAnnotationViewContainer?.addView(calloutView)
             }
             addBitmapToStyle(mCalloutBitmap, mCalloutBitmapId)
         }
@@ -98,10 +98,10 @@ class RCTMGLPointAnnotation(private val mContext: Context, private val mManager:
             map.pointAnnotationManager?.delete(marker!!)
         }
         if (mChildView != null) {
-            map.offscreenAnnotationViewContainer().removeView(mChildView)
+            map.offscreenAnnotationViewContainer?.removeView(mChildView)
         }
         if (calloutView != null) {
-            map.offscreenAnnotationViewContainer().removeView(calloutView)
+            map.offscreenAnnotationViewContainer?.removeView(calloutView)
         }
     }
 

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/components/camera/CameraStop.kt

@@ -84,8 +84,12 @@ import com.mapbox.mapboxsdk.maps.MapboxMap;
     }
 
     fun convert(value: IntArray): EdgeInsets {
+        val left = value[0].toDouble();
+        val top = value[1].toDouble();
+        val right = value[2].toDouble();
+        val bottom = value[3].toDouble();
         return EdgeInsets(
-            value[0].toDouble(), value[1].toDouble(), value[2].toDouble(), value[3].toDouble()
+            top, left, bottom, right
         )
     }
 

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/components/images/RCTMGLImages.kt

@@ -7,6 +7,9 @@ import com.mapbox.rctmgl.components.AbstractMapFeature
 import com.mapbox.rctmgl.utils.ImageEntry
 import android.graphics.drawable.BitmapDrawable
 import androidx.core.content.res.ResourcesCompat
+import com.mapbox.bindgen.Expected
+import com.mapbox.bindgen.None
+import com.mapbox.maps.Image
 import com.mapbox.maps.MapboxMap
 import com.mapbox.maps.Style
 import com.mapbox.rctmgl.R
@@ -15,11 +18,27 @@ import com.mapbox.rctmgl.components.images.RCTMGLImages
 import com.mapbox.rctmgl.events.ImageMissingEvent
 import com.mapbox.rctmgl.utils.BitmapUtils
 import com.mapbox.rctmgl.utils.DownloadMapImageTask
+import java.nio.ByteBuffer
 import java.util.AbstractMap
 import java.util.ArrayList
 import java.util.HashMap
 import java.util.HashSet
 
+fun Style.addBitmapImage(imageId: String, bitmap: Bitmap) : Expected<String, None> {
+    val byteBuffer = ByteBuffer.allocate(bitmap.byteCount)
+    bitmap.copyPixelsToBuffer(byteBuffer)
+    val sdf = false
+    return this.addStyleImage(
+        imageId,
+        (1.0/((160.0/bitmap.density))).toFloat(),
+        Image(bitmap.width, bitmap.height, byteBuffer.array()),
+        sdf,
+        listOf(),
+        listOf(),
+        null
+    )
+}
+
 class RCTMGLImages(context: Context, private val mManager: RCTMGLImagesManager) : AbstractMapFeature(context) {
     var mCurrentImages: MutableSet<String?>
     private var mImages: MutableMap<String, ImageEntry>?
@@ -151,7 +170,8 @@ class RCTMGLImages(context: Context, private val mManager: RCTMGLImagesManager)
         if (style == null || imageEntries == null) return
         for ((key, value) in imageEntries) {
             if (key != null && !hasImage(key, map)) {
-                style.addImage(key, BitmapUtils.toImage(value))
+                val bitmap = value!!.bitmap
+                style.addBitmapImage(key, bitmap)
                 mCurrentImages.add(key)
             }
         }
@@ -171,7 +191,7 @@ class RCTMGLImages(context: Context, private val mManager: RCTMGLImagesManager)
         // See also: https://github.com/mapbox/mapbox-gl-native/pull/14253#issuecomment-478827792
         for (imageEntry in imageEntries) {
             if (!hasImage(imageEntry.key, map)) {
-                mImagePlaceholder?.let { style.addImage(imageEntry.key, it) }
+                mImagePlaceholder?.let { style.addBitmapImage(imageEntry.key, it) }
                 missingImages.add(imageEntry)
                 mCurrentImages.add(imageEntry.key)
             }

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/components/mapview/RCTMGLMapView.kt

@@ -38,6 +38,7 @@ import com.mapbox.maps.plugin.delegates.listeners.*
 import com.mapbox.maps.plugin.gestures.*
 import com.mapbox.maps.plugin.logo.generated.LogoSettings
 import com.mapbox.maps.plugin.logo.logo
+import com.mapbox.maps.viewannotation.ViewAnnotationManager
 import com.mapbox.rctmgl.R
 import com.mapbox.rctmgl.components.AbstractMapFeature
 import com.mapbox.rctmgl.components.annotation.RCTMGLMarkerView
@@ -70,6 +71,14 @@ interface RCTMGLMapViewLifecycleOwner : LifecycleOwner {
 }
 
 open class RCTMGLMapView(private val mContext: Context, var mManager: RCTMGLMapViewManager /*, MapboxMapOptions options*/) : MapView(mContext), OnMapClickListener, OnMapLongClickListener {
+    /**
+     * `PointAnnotations` are rendered to a canvas, but the React Native `Image` component is
+     * implemented on top of Fresco (https://frescolib.org), which does not load images for
+     * views not attached to the window. This provides an offscreen view where views can
+     * be rendered to the canvas before being added as annotations.
+     */
+    public var offscreenAnnotationViewContainer: ViewGroup? = null
+
     private val mSources: MutableMap<String, RCTSource<*>>
     private val mImages: MutableList<RCTMGLImages>
     private var mPointAnnotationManager: PointAnnotationManager? = null
@@ -87,7 +96,6 @@ open class RCTMGLMapView(private val mContext: Context, var mManager: RCTMGLMapV
     var savedStyle: Style? = null
         private set
     private val mHandledMapChangedEvents: HashSet<String>? = null
-    private var mOffscreenAnnotationViewContainer: ViewGroup? = null
     private var mAnnotationClicked = false
     private var mAnnotationDragged = false
     private var mLocationComponentManager: LocationComponentManager? = null
@@ -229,7 +237,6 @@ open class RCTMGLMapView(private val mContext: Context, var mManager: RCTMGLMapV
             mPointAnnotations[annotation.iD.toString()] = annotation
             feature = childView
         } else if (childView is RCTMGLMarkerView) {
-            val marker = childView
             feature = childView
         } else if (childView is RCTMGLCamera) {
             mCamera = childView
@@ -630,23 +637,6 @@ open class RCTMGLMapView(private val mContext: Context, var mManager: RCTMGLMapV
         )
     }
 
-    /**
-     * PointAnnotations are rendered to a canvas, but react native Image component is
-     * implemented on top of Fresco, and fresco will not load images when their view is
-     * not attached to the window. So we'll have an offscreen view where we add those views
-     * so they can rendered full to canvas.
-     */
-    fun offscreenAnnotationViewContainer(): ViewGroup {
-        if (mOffscreenAnnotationViewContainer == null) {
-            mOffscreenAnnotationViewContainer = FrameLayout(context)
-            val flParams = LayoutParams(0, 0)
-            flParams.setMargins(-10000, -10000, -10000, -10000)
-            (mOffscreenAnnotationViewContainer as FrameLayout).setLayoutParams(flParams)
-            addView(mOffscreenAnnotationViewContainer)
-        }
-        return mOffscreenAnnotationViewContainer!!
-    }
-
     val locationComponentManager: LocationComponentManager
         get() {
             if (mLocationComponentManager == null) {
@@ -839,11 +829,19 @@ open class RCTMGLMapView(private val mContext: Context, var mManager: RCTMGLMapV
     }
 
     init {
+        offscreenAnnotationViewContainer = FrameLayout(getContext())
+        val p = FrameLayout.LayoutParams(0, 0)
+        p.setMargins(-10000, -10000, -10000, -10000)
+        offscreenAnnotationViewContainer?.setLayoutParams(p)
+        addView(offscreenAnnotationViewContainer)
+
         mMap = getMapboxMap()
         mSources = HashMap()
         mImages = ArrayList()
         mPointAnnotations = HashMap()
+
         onMapReady(mMap)
+
         val _this = this
         mMap.addOnMapLoadedListener(OnMapLoadedListener { (begin, end) -> _this.handleMapChangedEvent(EventTypes.DID_FINISH_LOADING_MAP) })
         mMap.addOnStyleImageMissingListener(OnStyleImageMissingListener { (begin, end, id) ->

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/components/styles/RCTMGLStyle.kt

@@ -8,7 +8,7 @@ import com.mapbox.rctmgl.utils.DownloadMapImageTask
 import java.util.AbstractMap
 import java.util.ArrayList
 
-class RCTMGLStyle(private val mContext: Context, reactStyle: ReadableMap, map: MapboxMap) {
+class RCTMGLStyle(private val mContext: Context, reactStyle: ReadableMap?, map: MapboxMap) {
     private val mReactStyle: ReadableMap?
     private val mMap: MapboxMap
     val allStyleKeys: List<String>

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/modules/CustomHttpHeaders.kt

@@ -0,0 +1,38 @@
+package com.mapbox.rctmgl.modules
+
+import com.mapbox.common.*
+
+object CustomHttpHeaders : HttpServiceInterceptorInterface {
+    init {}
+
+    val map = mutableMapOf<String, String>()
+
+    fun addCustomHeader(headerName: String, headerValue: String) {
+        HttpServiceFactory.getInstance().setInterceptor(
+            this
+        )
+    }
+
+    fun removeCustomHeader(headerName: String) {
+        map.remove(headerName)
+    }
+
+    override fun onRequest(request: HttpRequest): HttpRequest {
+        for (entry in map.entries.iterator()) {
+            request.headers[entry.key] = entry.value
+        }
+        return request
+    }
+
+    override fun onDownload(download: DownloadOptions): DownloadOptions {
+        for (entry in map.entries.iterator()) {
+            download.request.headers[entry.key] = entry.value
+        }
+        return download
+    }
+
+    override fun onResponse(response: HttpResponse): HttpResponse {
+        return response
+    }
+}
+

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/modules/RCTMGLModule.kt

@@ -12,6 +12,7 @@ import com.mapbox.rctmgl.modules.RCTMGLOfflineModule
 import com.mapbox.rctmgl.modules.RCTMGLLocationModule
 import com.facebook.react.bridge.ReactMethod
 import com.facebook.react.common.MapBuilder
+import com.mapbox.common.*
 import com.mapbox.maps.Style
 import com.mapbox.rctmgl.components.camera.constants.CameraMode
 import java.util.HashMap
@@ -124,6 +125,16 @@ class RCTMGLModule(private val mReactContext: ReactApplicationContext) : ReactCo
         // NO-OP
     }
 
+    @ReactMethod
+    fun addCustomHeader(headerName: String, headerValue: String) {
+        CustomHttpHeaders.addCustomHeader(headerName, headerValue)
+    }
+
+    @ReactMethod
+    fun removeCustomHeader(headerName: String) {
+        CustomHttpHeaders.removeCustomHeader(headerName)
+    }
+
     companion object {
         const val REACT_CLASS = "RCTMGLModule"
         private val customHeaderInterceptorAdded = false
@@ -132,4 +143,4 @@ class RCTMGLModule(private val mReactContext: ReactApplicationContext) : ReactCo
             return getDefault((reactContext)!!, null).resourceOptions.accessToken
         }
     }
-}
+}

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/utils/DownloadMapImageTask.kt

@@ -21,6 +21,7 @@ import com.facebook.imagepipeline.image.CloseableImage
 import com.facebook.imagepipeline.image.CloseableStaticBitmap
 import com.facebook.imagepipeline.request.ImageRequestBuilder
 import com.facebook.react.views.imagehelper.ImageSource
+import com.mapbox.rctmgl.components.images.addBitmapImage
 import java.io.File
 import java.lang.ref.WeakReference
 import java.util.AbstractMap
@@ -120,7 +121,7 @@ class DownloadMapImageTask(context: Context, map: MapboxMap, callback: OnAllImag
                 val bitmapImages = HashMap<String, Bitmap>()
                 for ((key, value) in images) {
                     bitmapImages[key] = value
-                    style.addImage(key, value)
+                    style.addBitmapImage(key, value)
                 }
                 // style.addImages(bitmapImages);
             }

package/docs/MapboxGL.md

@@ -20,7 +20,7 @@ not required when using other tiles
 | `tileServer` | `String` | `Yes` | tile server |
 
 #### Description
-No-op on non MapLibre implemntations. Use MapboxGL.TileServer.Mapbox to consume mapbox tiles with maplibre. *Note*: Consuming mapbox with MapLibre has different pricing than with the official SDK. Other values: MapboxGL.TileServer.MapLibre, MapboxGL.TileServer.MapTiler
+No-op on non MapLibre implemntations. Use MapboxGL.TileServers.Mapbox to consume mapbox tiles with maplibre. *Note*: Consuming mapbox with MapLibre has different pricing than with the official SDK. Other values: MapboxGL.TileServers.MapLibre, MapboxGL.TileServers.MapTiler
 
 ### getAccessToken()
 

package/docs/MarkerView.md

@@ -1,19 +1,26 @@
 <!-- This file was autogenerated from MarkerView.tsx do not modify -->
 # <MapboxGL.MarkerView />
-MarkerView allows you to place a interactive react native marker to the map.
+MarkerView represents an interactive React Native marker on the map.
 
-If you have static view consider using PointAnnotation or SymbolLayer they'll offer much better performance
-.
-This is based on [MakerView plugin](https://docs.mapbox.com/android/plugins/overview/markerview/) on Android
-and PointAnnotation on iOS.
+If you have static views, consider using PointAnnotation or SymbolLayer to display
+an image, as they'll offer much better performance. Mapbox suggests using this
+component for a maximum of around 100 views displayed at one time.
+
+This is implemented with view annotations on [Android](https://docs.mapbox.com/android/maps/guides/annotations/view-annotations/)
+and [iOS](https://docs.mapbox.com/ios/maps/guides/annotations/view-annotations).
+
+This component has no dedicated `onPress` method. Instead, you should handle gestures
+with the React views passed in as `children`.
 
 ## props
 | Prop | Type | Default | Required | Description |
 | ---- | :-- | :----- | :------ | :---------- |
-| coordinate | `tuple` | `none` | `true` | The center point (specified as a map coordinate) of the marker.<br/>See also #anchor. |
-| anchor | `shape` | `{ x: 0.5, y: 0.5 }` | `false` | Specifies the anchor being set on a particular point of the annotation.<br/>The anchor point is specified in the continuous space [0.0, 1.0] x [0.0, 1.0],<br/>where (0, 0) is the top-left corner of the image, and (1, 1) is the bottom-right corner.<br/>Note this is only for custom annotations not the default pin view.<br/>Defaults to the center of the view. |
-| &nbsp;&nbsp;x | `number` | `none` | `true` | `x` of anchor |
-| &nbsp;&nbsp;y | `number` | `none` | `true` | `y` of anchor |
-| children | `ReactReactElement` | `none` | `true` | Expects one child - can be container with multiple elements |
+| coordinate | `tuple` | `none` | `true` | The center point (specified as a map coordinate) of the marker. |
+| anchor | `shape` | `{ x: 0.5, y: 0.5 }` | `false` | Any coordinate between (0, 0) and (1, 1), where (0, 0) is the top-left corner of<br/>the view, and (1, 1) is the bottom-right corner. Defaults to the center at (0.5, 0.5). |
+| &nbsp;&nbsp;x | `number` | `none` | `true` | FIX ME NO DESCRIPTION |
+| &nbsp;&nbsp;y | `number` | `none` | `true` | FIX ME NO DESCRIPTION |
+| allowOverlap | `boolean` | `false` | `false` | @v10<br/><br/>Whether or not nearby markers on the map should all be displayed. If false, adjacent<br/>markers will 'collapse' and only one will be shown. Defaults to false. |
+| isSelected | `boolean` | `false` | `false` | FIX ME NO DESCRIPTION |
+| children | `ReactReactElement` | `none` | `true` | One or more valid React Native views. |
 
 

package/docs/PointAnnotation.md

@@ -6,7 +6,7 @@ Consider using ShapeSource and SymbolLayer instead, if you have many points and
 they'll offer much better performance.
 
 If you need interactive views please use MarkerView,
-as with PointAnnotation on Android child views are rendered onto a bitmap for better performance.
+as with PointAnnotation child views are rendered onto a bitmap
 
 ## props
 | Prop | Type | Default | Required | Description |

package/docs/SymbolLayer.md

@@ -11,7 +11,7 @@ SymbolLayer is a style layer that renders icon and text labels at points or alon
 | aboveLayerID | `string` | `none` | `false` | Inserts a layer above aboveLayerID. |
 | belowLayerID | `string` | `none` | `false` | Inserts a layer below belowLayerID |
 | layerIndex | `number` | `none` | `false` | Inserts a layer at a specified index |
-| filter | `Array` | `none` | `false` | Filter only the features in the source layer that satisfy a condition that you define |
+| filter | `Expression` | `none` | `false` | Filter only the features in the source layer that satisfy a condition that you define |
 | minZoomLevel | `number` | `none` | `false` | The minimum zoom level at which the layer gets parsed and appears. |
 | maxZoomLevel | `number` | `none` | `false` | The maximum zoom level at which the layer gets parsed and appears. |
 | style | `SymbolLayerStyleProps` | `none` | `true` | FIX ME NO DESCRIPTION |