@rnmapbox/maps 10.0.0-beta.76 → 10.0.0-beta.78

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

@@ -16,6 +16,7 @@ import com.mapbox.geojson.Feature
 import com.mapbox.maps.Style
 import com.mapbox.maps.extension.style.StyleContract
 import com.mapbox.maps.extension.style.sources.Source
+import com.mapbox.rctmgl.components.RemovalReason
 import com.mapbox.rctmgl.components.styles.sources.RCTSource.OnPressEvent
 import com.mapbox.rctmgl.utils.LatLng
 import com.mapbox.rctmgl.utils.Logger
@@ -23,6 +24,9 @@ import java.lang.ClassCastException
 import java.util.ArrayList
 import java.util.HashMap
 
+data class FeatureInfo(val feature: AbstractMapFeature?, var added: Boolean) {
+}
+
 abstract class RCTSource<T : Source?>(context: Context?) : AbstractMapFeature(context) {
     @JvmField
     protected var mMap: MapboxMap? = null
@@ -31,19 +35,40 @@ abstract class RCTSource<T : Source?>(context: Context?) : AbstractMapFeature(co
     protected var mSource: T? = null
     protected var mHasPressListener = false
     protected var mTouchHitbox: Map<String, Double>? = null
-    protected var mLayers: MutableList<AbstractSourceConsumer>
-    private var mQueuedLayers: MutableList<AbstractSourceConsumer>?
+    private var mSubFeatures = mutableListOf<FeatureInfo>()
+
     val layerIDs: List<String>
         get() {
-            val layerIDs: MutableList<String> = ArrayList()
-            for (i in mLayers.indices) {
-                val layer = mLayers[i]
-                val id = layer.iD
-                if (id != null) {
-                    layerIDs.add(id)
+           return mSubFeatures.mapIndexed { index, featureInfo ->
+                if (featureInfo.added && featureInfo.feature is AbstractSourceConsumer)  {
+                    featureInfo.feature.iD
+                } else {
+                    null
+                }
+            }.filterNotNull()
+        }
+
+    abstract fun hasNoDataSoRefersToExisting(): Boolean;
+
+    public var mExisting: Boolean? = null
+
+    val existing: Boolean
+        get() {
+            var result: Boolean = false
+            mExisting?.also {
+                result = it
+            } ?: run {
+                if (hasNoDataSoRefersToExisting()) {
+                    Logger.w(
+                        LOG_TAG,
+                        "RCTSource: soure with id: $id seems to refer to existing value but existing flag is not set. This is deprecated."
+                    )
+                    result = true
+                } else {
+                    result = false
                 }
             }
-            return layerIDs
+            return result
         }
 
     private fun getSourceAs(style: Style, id: String?): T? {
@@ -55,18 +80,6 @@ abstract class RCTSource<T : Source?>(context: Context?) : AbstractMapFeature(co
         }
     }
 
-    protected fun addLayerToMap(layer: AbstractSourceConsumer?, childPosition: Int) {
-        mMapView?.let {
-            val mapView = it
-            layer?.let {
-                it.addToMap(mapView)
-                if (!mLayers.contains(it)) {
-                    mLayers.add(childPosition, it)
-                }
-            }
-        }
-    }
-
     open fun hasPressListener(): Boolean {
         return mHasPressListener
     }
@@ -94,52 +107,60 @@ abstract class RCTSource<T : Source?>(context: Context?) : AbstractMapFeature(co
                         .build()
             } else mTouchHitbox
         }
-    val layerCount: Int
-        get() {
-            var totalCount = 0
-            if (mQueuedLayers != null) {
-                totalCount = mQueuedLayers!!.size
+
+    fun addToMap(existings: Boolean, style: Style, mapView: RCTMGLMapView) {
+        mSource = null
+        if (existings) {
+            val existingSource = getSourceAs(style, iD)
+            if (existingSource != null) {
+                mSource = existingSource
+            } else {
+                Logger.w(LOG_TAG, "Source $iD was makred as existing but was not found in style")
             }
-            totalCount += mLayers.size
-            return totalCount
         }
+        if (mSource == null) {
+            mSource = makeSource()
+            style.addSource(mSource as StyleContract.StyleSourceExtension)
+        }
+        mSubFeatures?.forEach {
+            it.feature?.let {
+                it.addToMap(mapView)
+            }
+            it.added = true
+        }
+    }
 
     override fun addToMap(mapView: RCTMGLMapView) {
         super.addToMap(mapView)
         mMap = mapView.getMapboxMap()
-        mMap?.getStyle(object : Style.OnStyleLoaded {
-            override fun onStyleLoaded(style: Style) {
-                val existingSource = getSourceAs(style, iD)
-                if (existingSource != null) {
-                    mSource = existingSource
-                } else {
-                    mSource = makeSource()
-                    style.addSource(mSource as StyleContract.StyleSourceExtension)
-                }
-                if (mQueuedLayers != null && mQueuedLayers!!.size > 0) { // first load
-                    for (i in mQueuedLayers!!.indices) {
-                        addLayerToMap(mQueuedLayers!![i], i)
-                    }
-                    mQueuedLayers = null
-                } else if (mLayers.size > 0) { // handles the case of switching style url, but keeping layers on map
-                    for (i in mLayers.indices) {
-                        addLayerToMap(mLayers[i], i)
-                    }
+        val map = mMap
+        if (map == null) {
+            Logger.e("RCTSource", "map is exepted to be valid but was null, $iD")
+            return
+        }
+        val style = map.getStyle()
+        if (existing || style == null) {
+            map.getStyle(object : Style.OnStyleLoaded {
+                override fun onStyleLoaded(style: Style) {
+                    addToMap(existing, style, mapView)
                 }
-            }
-        })
+            })
+        } else {
+            addToMap(existing, style, mapView)
+        }
+
     }
 
-    override fun removeFromMap(mapView: RCTMGLMapView) {
-        if (mLayers.size > 0) {
-            for (i in mLayers.indices) {
-                val layer = mLayers[i]
-                layer.removeFromMap(mapView)
+    override fun removeFromMap(mapView: RCTMGLMapView, reason: RemovalReason): Boolean {
+
+        mSubFeatures.forEach { it
+            var featureInfo = it
+            featureInfo.feature?.let {
+                if (it.removeFromMap(mapView, reason)) {
+                    featureInfo.added = false
+                }
             }
         }
-        if (mQueuedLayers != null) {
-            mQueuedLayers!!.clear()
-        }
         if (mMap != null && mSource != null && mMap!!.getStyle() != null) {
             try {
                 iD?.let { mMap?.getStyle()?.removeStyleSource(it) }
@@ -147,51 +168,52 @@ abstract class RCTSource<T : Source?>(context: Context?) : AbstractMapFeature(co
                 Logger.w(LOG_TAG, String.format("RCTSource.removeFromMap: %s - %s", mSource, ex.message), ex)
             }
         }
-        super.removeFromMap(mapView)
+        return super.removeFromMap(mapView, reason)
     }
 
     fun addLayer(childView: View?, childPosition: Int) {
-        if (childView !is AbstractSourceConsumer) {
-            return
+        var feature: AbstractMapFeature? = null
+        if (childView !is AbstractMapFeature) {
+            Logger.w(LOG_TAG, "Attempted to insert view: $childView to shape source: $iD, since it's not a MapFeature it will not be added")
+        } else {
+            feature = childView
         }
-        val layer = childView
-        if (mMap == null) {
-            mQueuedLayers?.add(childPosition, layer)
+
+        val mapView = mMapView
+
+        val added = if (mapView != null && feature != null) {
+            feature.addToMap(mapView)
+            true
         } else {
-            addLayerToMap(layer, childPosition)
+            false
         }
+        mSubFeatures.add(childPosition, FeatureInfo(feature, added))
     }
 
     fun removeLayer(childPosition: Int) {
-        val layer: AbstractSourceConsumer
-        layer = if (mQueuedLayers != null && mQueuedLayers!!.size > 0) {
-            mQueuedLayers!![childPosition]
-        } else {
-            mLayers[childPosition]
+        var featureInfo = mSubFeatures[childPosition]
+        if (featureInfo.added) {
+            val mapView = mMapView
+            if (mapView != null) {
+                featureInfo.feature?.let { it.removeFromMap(mapView, RemovalReason.VIEW_REMOVAL) }
+            }
+            featureInfo.added = false
         }
-        removeLayerFromMap(layer, childPosition)
+        mSubFeatures.removeAt(childPosition)
     }
 
-    fun getLayerAt(childPosition: Int): AbstractSourceConsumer {
-        return if (mQueuedLayers != null && mQueuedLayers!!.size > 0) {
-            mQueuedLayers!![childPosition]
-        } else mLayers[childPosition]
+    val childViews: List<AbstractMapFeature>
+        get() = mSubFeatures.map { it.feature }.filterNotNull()
+
+    override fun getChildAt(childPosition: Int): View {
+        return childViews[childPosition]
     }
 
-    protected fun removeLayerFromMap(layer: AbstractSourceConsumer?, childPosition: Int) {
-        mMapView?.let {
-            val mapView = it
-            layer?.let {
-                it.removeFromMap(mapView)
-            }
-        }
-        if (mQueuedLayers != null && mQueuedLayers!!.size > 0) {
-            mQueuedLayers?.removeAt(childPosition)
-        } else {
-            mLayers.removeAt(childPosition)
-        }
+    override fun getChildCount(): Int {
+        return childViews.size;
     }
 
+
     abstract fun makeSource(): T
     class OnPressEvent(var features: List<Feature>, var latLng: LatLng, var screenPoint: PointF)
 
@@ -209,7 +231,5 @@ abstract class RCTSource<T : Source?>(context: Context?) : AbstractMapFeature(co
     }
 
     init {
-        mLayers = ArrayList()
-        mQueuedLayers = ArrayList()
     }
 }

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

@@ -5,6 +5,7 @@ import com.facebook.react.bridge.ReadableMap
 import com.mapbox.maps.MapboxMap
 import com.mapbox.maps.extension.style.terrain.generated.Terrain
 import com.mapbox.maps.extension.style.terrain.generated.removeTerrain
+import com.mapbox.rctmgl.components.RemovalReason
 import com.mapbox.rctmgl.components.mapview.RCTMGLMapView
 import com.mapbox.rctmgl.components.styles.RCTMGLStyle
 import com.mapbox.rctmgl.components.styles.RCTMGLStyleFactory
@@ -44,10 +45,10 @@ class RCTMGLTerrain(context: Context?) : AbstractSourceConsumer(context) {
         mapView.savedStyle?.let { terrain.bindTo(it) }
     }
 
-    override fun removeFromMap(mapView: RCTMGLMapView) {
+    override fun removeFromMap(mapView: RCTMGLMapView, reason: RemovalReason): Boolean {
         mapView.savedStyle?.let { it.removeTerrain() }
         mMap = null
-        super.removeFromMap(mapView)
+        return super.removeFromMap(mapView, reason)
     }
 
     fun makeTerrain(): Terrain {

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

@@ -43,9 +43,11 @@ public class PointAnnotationDragEvent extends MapClickEvent {
     @Override
     public WritableMap getPayload() {
         WritableMap properties = new WritableNativeMap();
-        properties.putString("id", mView.getID());
         properties.putDouble("screenPointX", mScreenPoint.x);
         properties.putDouble("screenPointY", mScreenPoint.y);
-        return GeoJSONUtils.toPointFeature(mTouchedLatLng, properties);
+        WritableMap feature = GeoJSONUtils.toPointFeature(mTouchedLatLng, properties);
+        feature.putString("id", mView.getID());
+        
+        return feature;
     }
 }

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

@@ -147,14 +147,14 @@ class RCTMGLOfflineModule(private val mReactContext: ReactApplicationContext) :
     private fun convertRegionsToJSON(tileRegions: List<TileRegion>, promise: Promise) {
         val countDownLatch = CountDownLatch(tileRegions.size)
         val errors = ArrayList<TileRegionError?>()
-        val geometries = ArrayList<Geometry?>()
+        val geometries = ArrayList<Geometry>()
         try {
             for (region: TileRegion in tileRegions) {
                 getTileStore()!!
                     .getTileRegionGeometry(region.id, object : TileRegionGeometryCallback {
                         override fun run(result: Expected<TileRegionError, Geometry>) {
                             if (result.isValue) {
-                                geometries.add(result.value)
+                                geometries.add(result.value!!)
                             } else {
                                 errors.add(result.error)
                             }
@@ -168,7 +168,7 @@ class RCTMGLOfflineModule(private val mReactContext: ReactApplicationContext) :
         try {
             countDownLatch.await()
             val result = Arguments.createArray()
-            for (geometry: Geometry? in geometries) {
+            for (geometry: Geometry in geometries) {
                 result.pushMap(fromOfflineRegion(geometry))
             }
             for (error: TileRegionError? in errors) {
@@ -567,7 +567,7 @@ class RCTMGLOfflineModule(private val mReactContext: ReactApplicationContext) :
         return map
     }
 
-    private fun fromOfflineRegion(region: Geometry?): WritableMap {
+    private fun fromOfflineRegion(region: Geometry): WritableMap {
         val map = Arguments.createMap()
         val bbox = TurfMeasurement.bbox(region)
         val bounds = Arguments.createArray()

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

@@ -18,69 +18,75 @@ object GeoJSONUtils {
         val map = Arguments.createMap()
         map.putString("type", "Feature")
         map.putString("id", feature.id())
-        val geometry = fromGeometry(feature.geometry())
-        map.putMap("geometry", geometry)
+        feature.geometry()?.also {
+            val geometry = fromGeometry(it)
+            map.putMap("geometry", geometry)
+        } ?: {
+            Logger.w(LOG_TAG, "GeoJSONUtils.fromFeature geometry was null for feature: ${feature.toJson()}")
+        }
         val properties = ConvertUtils.toWritableMap(feature.properties())
         map.putMap("properties", properties)
         return map
     }
 
-    fun fromGeometry(geometry: Geometry?): WritableMap? {
-        val type = geometry!!.type()
-        return when (type) {
-            "Point" -> fromPoint(geometry as Point?)
-            "LineString" -> fromLineString(geometry as LineString?)
-            "Polygon" -> fromPolygon(geometry as Polygon?)
-            else -> null
+    fun fromGeometry(geometry: Geometry): WritableMap? {
+        val type = geometry.type()
+        val coordinates : WritableArray = when (type) {
+            "Point" -> coordinates(geometry as Point)
+            "LineString" -> coordinatesL((geometry as LineString).coordinates())
+            "Polygon" -> coordinatesLL((geometry as Polygon).coordinates())
+            "MultiLineString" -> coordinatesLL((geometry as MultiLineString).coordinates())
+            "MultiPolygon" -> coordinatesLLL((geometry as MultiPolygon).coordinates())
+            "GeometryCollection" -> {
+                return multiGeometry(type,
+                    Arguments.fromList((geometry as GeometryCollection).geometries().map {
+                        fromGeometry(it)
+                    })
+                )
+            }
+            else -> {
+                Logger.w(LOG_TAG, "GeoJSONUtils.fromGeometry unsupported type:$type")
+                return null
+            }
         }
+        return geometry(type, coordinates);
     }
 
-    fun fromPoint(point: Point?): WritableMap {
-        val map = Arguments.createMap()
-        map.putString("type", "Point")
-        map.putArray("coordinates", getCoordinates(point))
+    private fun multiGeometry(type: String, geometries: WritableArray):WritableMap {
+        val map = Arguments.createMap();
+        map.putString("type", type);
+        map.putArray("geometries", geometries);
         return map
     }
-
-    fun fromLineString(lineString: LineString?): WritableMap {
-        val map = Arguments.createMap()
-        map.putString("type", "LineString")
-        map.putArray("coordinates", getCoordinates(lineString))
+    private fun geometry(type: String, coordinates: WritableArray):WritableMap {
+        val map = Arguments.createMap();
+        map.putString("type", type);
+        map.putArray("coordinates", coordinates);
         return map
     }
 
-    fun fromPolygon(polygon: Polygon?): WritableMap {
-        val map = Arguments.createMap()
-        map.putString("type", "Polygon")
-        map.putArray("coordinates", getCoordinates(polygon))
-        return map
-    }
-
-    fun getCoordinates(point: Point?): WritableArray {
+    private fun coordinates(point: Point): WritableArray {
         return Arguments.fromArray(pointToDoubleArray(point))
     }
 
-    fun getCoordinates(lineString: LineString?): WritableArray {
-        val array = Arguments.createArray()
-        val points = lineString!!.coordinates()
-        for (point in points) {
-            array.pushArray(Arguments.fromArray(pointToDoubleArray(point)))
+    private fun fromList(items: List<ReadableArray>): WritableArray {
+        val ret = WritableNativeArray();
+        items.forEach {
+            ret.pushArray(it)
         }
-        return array
+        return ret;
     }
 
-    fun getCoordinates(polygon: Polygon?): WritableArray {
-        val array = Arguments.createArray()
-        val points = polygon!!.coordinates()
-            ?: return array
-        for (curPoint in points) {
-            val innerArray = Arguments.createArray()
-            for (point in curPoint) {
-                innerArray.pushArray(Arguments.fromArray(pointToDoubleArray(point)))
-            }
-            array.pushArray(innerArray)
-        }
-        return array
+    private fun coordinatesL(points: List<Point>): WritableArray {
+        return fromList(points.map { coordinates(it) })
+    }
+
+    private fun coordinatesLL(points: List<List<Point>>): WritableArray {
+        return fromList(points.map { coordinatesL(it) })
+    }
+
+    private fun coordinatesLLL(points: List<List<List<Point>>>): WritableArray {
+        return fromList(points.map { coordinatesLL(it) })
     }
 
     @JvmStatic
@@ -208,4 +214,6 @@ object GeoJSONUtils {
         }
         return result
     }
+
+    const val LOG_TAG = "GeoJSONUtils"
 }

package/ios/RCTMGL-v10/RCTMGLCamera.swift

@@ -2,7 +2,7 @@ import Foundation
 import MapboxMaps
 import Turf
 
-protocol RCTMGLMapComponent : AnyObject {
+protocol RCTMGLMapComponent : class {
   func addToMap(_ map: RCTMGLMapView, style: Style)
   func removeFromMap(_ map: RCTMGLMapView)
   
@@ -104,7 +104,7 @@ open class RCTMGLMapComponentBase : UIView, RCTMGLMapComponent {
   }
 }
 
-class RCTMGLCamera : RCTMGLMapComponentBase, LocationConsumer {
+class RCTMGLCamera : RCTMGLMapComponentBase {
   var cameraAnimator: BasicCameraAnimator?
   let cameraUpdateQueue = CameraUpdateQueue()
   
@@ -219,7 +219,6 @@ class RCTMGLCamera : RCTMGLMapComponentBase, LocationConsumer {
   
   func _disableUsetTracking(_ map: MapView) {
     map.viewport.idle()
-    map.location.removeLocationConsumer(consumer: self)
   }
   
   func _toCoordinateBounds(_ bounds: FeatureCollection) throws -> CoordinateBounds  {
@@ -274,10 +273,17 @@ class RCTMGLCamera : RCTMGLMapComponentBase, LocationConsumer {
       }
 
       if let locationModule = RCTMGLLocationModule.shared {
-        map.location.overrideLocationProvider(with: locationModule.locationProvider)
+        var isSameProvider = false
+        if let currentProvider = map.location.locationProvider as? AnyObject, let newProvider = locationModule.locationProvider as? AnyObject {
+          if currentProvider === newProvider {
+            isSameProvider = true
+          }
+        }
+        if !isSameProvider {
+          map.location.overrideLocationProvider(with: locationModule.locationProvider)
+        }
       }
       map.location.locationProvider.requestWhenInUseAuthorization()
-      map.location.addLocationConsumer(newConsumer: self)
       var trackingModeChanged = false
       var followOptions = FollowPuckViewportStateOptions()
       switch userTrackingMode {
@@ -506,32 +512,6 @@ class RCTMGLCamera : RCTMGLMapComponentBase, LocationConsumer {
     map.viewport.removeStatusObserver(self)
     super.removeFromMap(map)
   }
-
-  // MARK: - LocationConsumer
-  
-  func locationUpdate(newLocation: Location) {
-    // viewport manages following user location
-    if false && followUserLocation {
-      withMapView { map in
-        var animationType = CameraMode.none
-        if let m = self.animationMode as? String, let m = CameraMode(rawValue: m) {
-          animationType = m
-        }
-        let _camera = CameraOptions(center: newLocation.coordinate)
-        let _duration = self.animationDuration as? Double ?? 0.5
-        switch (animationType) {
-          case .flight:
-            map.camera.fly(to: _camera, duration: _duration)
-          case .ease:
-            map.camera.ease(to: _camera, duration: _duration, curve: .easeInOut, completion: nil)
-          case .linear:
-            map.camera.ease(to: _camera, duration: _duration, curve: .linear, completion: nil)
-          default:
-            map.mapboxMap.setCamera(to: CameraOptions(center: newLocation.coordinate))
-        }
-      }
-    }
-  }
 }
 
 // MARK: - ViewportStatusObserver

package/ios/RCTMGL-v10/RCTMGLInteractiveElement.swift

@@ -16,7 +16,19 @@ class RCTMGLInteractiveElement : UIView, RCTMGLMapComponent {
     "height": NSNumber(value: hitboxDefault)
   ]
   
-  @objc var id: String! = nil
+  @objc var id: String! = nil {
+    willSet {
+      if id != nil && newValue != id {
+        Logger.log(level:.warn, message: "Changing id from: \(optional: id) to \(optional: newValue), changing of id is supported")
+        if let map = map { removeFromMap(map) }
+      }
+    }
+    didSet {
+      if oldValue != nil && oldValue != id {
+        if let map = map { addToMap(map, style: map.mapboxMap.style) }
+      }
+    }
+  }
   
   @objc var onDragStart: RCTBubblingEventBlock? = nil
   

package/ios/RCTMGL-v10/RCTMGLLayer.swift

@@ -1,6 +1,6 @@
 @_spi(Experimental) import MapboxMaps
 
-protocol RCTMGLSourceConsumer {
+protocol RCTMGLSourceConsumer : class {
   func addToMap(_ map: RCTMGLMapView, style: Style)
   func removeFromMap(_ map: RCTMGLMapView, style: Style)
 }
@@ -9,6 +9,8 @@ protocol RCTMGLSourceConsumer {
 class RCTMGLLayer : UIView, RCTMGLMapComponent, RCTMGLSourceConsumer {
   weak var bridge : RCTBridge? = nil
 
+  var waitingForID: String? = nil
+
   @objc var sourceLayerID : String? = nil {
     didSet { self.optionsChanged() }
   }
@@ -31,7 +33,20 @@ class RCTMGLLayer : UIView, RCTMGLMapComponent, RCTMGLSourceConsumer {
     didSet { optionsChanged() }
   }
   
-  @objc var id: String! = nil
+  @objc var id: String! = nil {
+    willSet {
+      if id != nil && newValue != id {
+        Logger.log(level:.warn, message: "Changing id from: \(optional: id) to \(optional: newValue), changing of id is supported")
+        if let style = style { self.removeFromMap(style) }
+      }
+    }
+    didSet {
+      if oldValue != nil && oldValue != id {
+        if let map = map, let style = style { self.addToMap(map, style: style) }
+      }
+    }
+  }
+
   @objc var sourceID: String? = nil {
     didSet { optionsChanged() }
   }
@@ -74,6 +89,13 @@ class RCTMGLLayer : UIView, RCTMGLMapComponent, RCTMGLSourceConsumer {
   }
   
   @objc weak var map: RCTMGLMapView? = nil
+
+  deinit {
+    if let waitingForID = waitingForID {
+      Logger.log(level:.warn, message: "RCTMGLLayer.removeFromMap - unmetPositionDependency: layer: \(optional: id) was waiting for layer: \(optional: waitingForID) but it hasn't added to map")
+      self.waitingForID = nil
+    }
+  }
   
   var styleLayer: Layer? = nil
   
@@ -86,9 +108,9 @@ class RCTMGLLayer : UIView, RCTMGLMapComponent, RCTMGLSourceConsumer {
   }
   
   func removeAndReaddLayer() {
-    if let style = style {
+    if let map = map, let style = style {
       self.removeFromMap(style)
-      self.insert(style, layerPosition: position())
+      self.addToMap(map, style:style)
     }
   }
    
@@ -248,7 +270,7 @@ class RCTMGLLayer : UIView, RCTMGLMapComponent, RCTMGLSourceConsumer {
   }
   
   private func optionsChanged() {
-    if let style = self.style {
+    if let style = self.style, self.styleLayer != nil {
       self.setOptions(&self.styleLayer!)
       self.loggedApply(style: style)
     }
@@ -259,10 +281,14 @@ class RCTMGLLayer : UIView, RCTMGLMapComponent, RCTMGLSourceConsumer {
   }
   
   private func removeFromMap(_ style: Style) {
+    if let waitingForID = waitingForID {
+      Logger.log(level:.warn, message: "RCTMGLLayer.removeFromMap - unmetPositionDependency: layer: \(optional: id) was waiting for layer: \(optional: waitingForID) but it hasn't added to map")
+    }
+
     do {
       try style.removeLayer(withId: self.id)
     } catch {
-      Logger.log(level: .error, message: "removing layer failed for layer \(optional: id): \(error.localizedDescription)")
+      Logger.log(level: .error, message: "RCTMGLLayer.removeFromMap: removing layer failed for layer \(optional: id): \(error.localizedDescription)")
     }
   }
   
@@ -279,8 +305,11 @@ class RCTMGLLayer : UIView, RCTMGLMapComponent, RCTMGLSourceConsumer {
       idToWaitFor = nil
     }
     
+    
     if let idToWaitFor = idToWaitFor {
+      self.waitingForID = idToWaitFor
       map!.waitForLayerWithID(idToWaitFor) { _ in
+        self.waitingForID = nil
         self.attemptInsert(style, layerPosition: layerPosition, onInsert: onInsert)
       }
     } else {