@rnmapbox/maps 10.1.0-rc.6 → 10.1.0

package/src/utils/styleMap.ts

@@ -38,8 +38,6 @@ const styleMap = {
   fillTranslateTransition: StyleTypes.Transition,
   fillTranslateAnchor: StyleTypes.Enum,
   fillPattern: StyleTypes.Image,
-  fillEmissiveStrength: StyleTypes.Constant,
-  fillEmissiveStrengthTransition: StyleTypes.Transition,
 
   lineCap: StyleTypes.Enum,
   lineJoin: StyleTypes.Enum,
@@ -65,8 +63,6 @@ const styleMap = {
   linePattern: StyleTypes.Image,
   lineGradient: StyleTypes.Color,
   lineTrimOffset: StyleTypes.Constant,
-  lineEmissiveStrength: StyleTypes.Constant,
-  lineEmissiveStrengthTransition: StyleTypes.Transition,
 
   symbolPlacement: StyleTypes.Enum,
   symbolSpacing: StyleTypes.Constant,
@@ -135,13 +131,6 @@ const styleMap = {
   textTranslate: StyleTypes.Translation,
   textTranslateTransition: StyleTypes.Transition,
   textTranslateAnchor: StyleTypes.Enum,
-  symbolZElevate: StyleTypes.Constant,
-  iconEmissiveStrength: StyleTypes.Constant,
-  iconEmissiveStrengthTransition: StyleTypes.Transition,
-  textEmissiveStrength: StyleTypes.Constant,
-  textEmissiveStrengthTransition: StyleTypes.Transition,
-  iconImageCrossFade: StyleTypes.Constant,
-  iconImageCrossFadeTransition: StyleTypes.Transition,
 
   circleSortKey: StyleTypes.Constant,
   circleRadius: StyleTypes.Constant,
@@ -163,8 +152,6 @@ const styleMap = {
   circleStrokeColorTransition: StyleTypes.Transition,
   circleStrokeOpacity: StyleTypes.Constant,
   circleStrokeOpacityTransition: StyleTypes.Transition,
-  circleEmissiveStrength: StyleTypes.Constant,
-  circleEmissiveStrengthTransition: StyleTypes.Transition,
 
   heatmapRadius: StyleTypes.Constant,
   heatmapRadiusTransition: StyleTypes.Transition,
@@ -188,27 +175,6 @@ const styleMap = {
   fillExtrusionBase: StyleTypes.Constant,
   fillExtrusionBaseTransition: StyleTypes.Transition,
   fillExtrusionVerticalGradient: StyleTypes.Constant,
-  fillExtrusionRoundedRoof: StyleTypes.Constant,
-  fillExtrusionAmbientOcclusionWallRadius: StyleTypes.Constant,
-  fillExtrusionAmbientOcclusionWallRadiusTransition: StyleTypes.Transition,
-  fillExtrusionAmbientOcclusionGroundRadius: StyleTypes.Constant,
-  fillExtrusionAmbientOcclusionGroundRadiusTransition: StyleTypes.Transition,
-  fillExtrusionAmbientOcclusionGroundAttenuation: StyleTypes.Constant,
-  fillExtrusionAmbientOcclusionGroundAttenuationTransition:
-    StyleTypes.Transition,
-  fillExtrusionFloodLightColor: StyleTypes.Color,
-  fillExtrusionFloodLightColorTransition: StyleTypes.Transition,
-  fillExtrusionFloodLightIntensity: StyleTypes.Constant,
-  fillExtrusionFloodLightIntensityTransition: StyleTypes.Transition,
-  fillExtrusionFloodLightWallRadius: StyleTypes.Constant,
-  fillExtrusionFloodLightWallRadiusTransition: StyleTypes.Transition,
-  fillExtrusionFloodLightGroundRadius: StyleTypes.Constant,
-  fillExtrusionFloodLightGroundRadiusTransition: StyleTypes.Transition,
-  fillExtrusionFloodLightGroundAttenuation: StyleTypes.Constant,
-  fillExtrusionFloodLightGroundAttenuationTransition: StyleTypes.Transition,
-  fillExtrusionVerticalScale: StyleTypes.Constant,
-  fillExtrusionVerticalScaleTransition: StyleTypes.Transition,
-  fillExtrusionCutoffFadeRange: StyleTypes.Constant,
 
   rasterOpacity: StyleTypes.Constant,
   rasterOpacityTransition: StyleTypes.Transition,
@@ -224,11 +190,6 @@ const styleMap = {
   rasterContrastTransition: StyleTypes.Transition,
   rasterResampling: StyleTypes.Enum,
   rasterFadeDuration: StyleTypes.Constant,
-  rasterColor: StyleTypes.Color,
-  rasterColorMix: StyleTypes.Constant,
-  rasterColorMixTransition: StyleTypes.Transition,
-  rasterColorRange: StyleTypes.Constant,
-  rasterColorRangeTransition: StyleTypes.Transition,
 
   hillshadeIlluminationDirection: StyleTypes.Constant,
   hillshadeIlluminationAnchor: StyleTypes.Enum,
@@ -241,39 +202,11 @@ const styleMap = {
   hillshadeAccentColor: StyleTypes.Color,
   hillshadeAccentColorTransition: StyleTypes.Transition,
 
-  modelId: StyleTypes.Constant,
-  modelOpacity: StyleTypes.Constant,
-  modelOpacityTransition: StyleTypes.Transition,
-  modelRotation: StyleTypes.Constant,
-  modelRotationTransition: StyleTypes.Transition,
-  modelScale: StyleTypes.Constant,
-  modelScaleTransition: StyleTypes.Transition,
-  modelTranslation: StyleTypes.Constant,
-  modelTranslationTransition: StyleTypes.Transition,
-  modelColor: StyleTypes.Color,
-  modelColorTransition: StyleTypes.Transition,
-  modelColorMixIntensity: StyleTypes.Constant,
-  modelColorMixIntensityTransition: StyleTypes.Transition,
-  modelType: StyleTypes.Enum,
-  modelCastShadows: StyleTypes.Constant,
-  modelReceiveShadows: StyleTypes.Constant,
-  modelAmbientOcclusionIntensity: StyleTypes.Constant,
-  modelAmbientOcclusionIntensityTransition: StyleTypes.Transition,
-  modelEmissiveStrength: StyleTypes.Constant,
-  modelEmissiveStrengthTransition: StyleTypes.Transition,
-  modelRoughness: StyleTypes.Constant,
-  modelRoughnessTransition: StyleTypes.Transition,
-  modelHeightBasedEmissiveStrengthMultiplier: StyleTypes.Constant,
-  modelHeightBasedEmissiveStrengthMultiplierTransition: StyleTypes.Transition,
-  modelCutoffFadeRange: StyleTypes.Constant,
-
   backgroundColor: StyleTypes.Color,
   backgroundColorTransition: StyleTypes.Transition,
   backgroundPattern: StyleTypes.Image,
   backgroundOpacity: StyleTypes.Constant,
   backgroundOpacityTransition: StyleTypes.Transition,
-  backgroundEmissiveStrength: StyleTypes.Constant,
-  backgroundEmissiveStrengthTransition: StyleTypes.Transition,
 
   skyType: StyleTypes.Enum,
   skyAtmosphereSun: StyleTypes.Constant,
@@ -302,10 +235,10 @@ const styleMap = {
   horizonBlendTransition: StyleTypes.Transition,
   starIntensity: StyleTypes.Constant,
   starIntensityTransition: StyleTypes.Transition,
-  verticalRange: StyleTypes.Constant,
-  verticalRangeTransition: StyleTypes.Transition,
 
+  source: StyleTypes.Constant,
   exaggeration: StyleTypes.Constant,
+  exaggerationTransition: StyleTypes.Transition,
 
   color: StyleTypes.Color,
   colorTransition: StyleTypes.Transition,

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

@@ -1,24 +0,0 @@
-package com.rnmapbox.rnmbx.components
-
-import com.facebook.react.bridge.WritableMap
-import com.facebook.react.uimanager.events.Event
-import com.facebook.react.uimanager.events.RCTEventEmitter
-
-class AbstractEvent(
-    viewId: Int,
-    private val mEventName: String,
-    private val mCanCoalesce: Boolean,
-    private val mEvent: WritableMap?
-) : Event<AbstractEvent>(viewId) {
-    override fun getEventName(): String {
-        return mEventName
-    }
-
-    override fun dispatch(rctEventEmitter: RCTEventEmitter) {
-        rctEventEmitter.receiveEvent(viewTag, eventName, mEvent)
-    }
-
-    override fun canCoalesce(): Boolean {
-        return mCanCoalesce
-    }
-}

package/android/src/main/java/com/rnmapbox/rnmbx/components/annotation/RNMBXMarkerViewContent.kt

@@ -1,31 +0,0 @@
-package com.rnmapbox.rnmbx.components.annotation
-
-import android.content.Context
-import android.view.View.MeasureSpec
-import com.facebook.react.uimanager.MeasureSpecAssertions
-import com.facebook.react.views.view.ReactViewGroup
-
-class RNMBXMarkerViewContent(context: Context): ReactViewGroup(context) {
-
-    var inAdd: Boolean = false
-    // see https://github.com/rnmapbox/maps/pull/3235
-    override fun onMeasure(widthMeasureSpec: Int, heightMeasureSpec: Int) {
-        if (inAdd) {
-            val w = if (widthMeasureSpec == 0) {
-                MeasureSpec.makeMeasureSpec(measuredWidth, MeasureSpec.EXACTLY)
-            } else {
-                widthMeasureSpec
-            };
-            val h = if (heightMeasureSpec == 0) {
-                MeasureSpec.makeMeasureSpec(measuredHeight, MeasureSpec.EXACTLY)
-            } else {
-                heightMeasureSpec
-            }
-            super.onMeasure(w, h)
-        } else {
-            super.onMeasure(widthMeasureSpec, heightMeasureSpec)
-        }
-    }
-
-}
-

package/android/src/main/java/com/rnmapbox/rnmbx/components/annotation/RNMBXMarkerViewContentManager.kt

@@ -1,23 +0,0 @@
-package com.rnmapbox.rnmbx.components.annotation
-
-import com.facebook.react.bridge.ReactApplicationContext
-import com.facebook.react.uimanager.ThemedReactContext
-import com.facebook.react.uimanager.ViewGroupManager
-import com.facebook.react.viewmanagers.RNMBXMarkerViewContentManagerInterface
-
-
-class RNMBXMarkerViewContentManager(reactApplicationContext: ReactApplicationContext) :
-    ViewGroupManager<RNMBXMarkerViewContent>(),
-    RNMBXMarkerViewContentManagerInterface<RNMBXMarkerView> {
-    override fun getName(): String {
-        return REACT_CLASS
-    }
-
-    override fun createViewInstance(context: ThemedReactContext): RNMBXMarkerViewContent {
-        return RNMBXMarkerViewContent(context)
-    }
-
-    companion object {
-        const val REACT_CLASS = "RNMBXMarkerViewContent"
-    }
-}

package/android/src/main/java/com/rnmapbox/rnmbx/components/camera/RNMBXVIewportManager.kt

@@ -1,55 +0,0 @@
-package com.rnmapbox.rnmbx.components.camera
-
-import com.facebook.react.bridge.Arguments
-import com.facebook.react.bridge.Dynamic
-import com.facebook.react.bridge.ReactApplicationContext
-import com.facebook.react.bridge.WritableArray
-import com.facebook.react.bridge.WritableMap
-import com.facebook.react.common.MapBuilder
-import com.facebook.react.uimanager.ThemedReactContext
-import com.facebook.react.uimanager.annotations.ReactProp
-import com.facebook.react.viewmanagers.RNMBXViewportManagerInterface
-import com.rnmapbox.rnmbx.components.AbstractEventEmitter
-import com.rnmapbox.rnmbx.events.constants.EventKeys
-import com.rnmapbox.rnmbx.events.constants.eventMapOf
-
-class RNMBXViewportManager(private val mContext: ReactApplicationContext) : AbstractEventEmitter<RNMBXViewport?>(
-        mContext
-    ), RNMBXViewportManagerInterface<RNMBXViewport> {
-
-    override fun getName(): String {
-        return REACT_CLASS
-    }
-
-    override fun createViewInstance(reactContext: ThemedReactContext): RNMBXViewport {
-        return RNMBXViewport(reactContext, this)
-    }
-
-    @ReactProp(name = "transitionsToIdleUponUserInteraction")
-    override fun setTransitionsToIdleUponUserInteraction(view: RNMBXViewport?, value: Dynamic?) {
-        view?.transitionsToIdleUponUserInteraction = value?.asBoolean()
-    }
-
-    @ReactProp(name = "hasStatusChanged")
-    override fun setHasStatusChanged(view: RNMBXViewport?, value: Boolean) {
-        view?.hasStatusChanged = value
-    }
-
-    //region Custom Events
-    override fun customEvents(): Map<String, String>? {
-        return eventMapOf(
-            EventKeys.VIEWPORT_STATUS_CHANGE to "onStatusChanged"
-        )
-    }
-
-    override fun getCommandsMap(): Map<String, Int>? {
-        return mapOf(
-            "_useCommandName" to 1
-        );
-    }
-    //endregion
-
-    companion object {
-        const val REACT_CLASS = "RNMBXViewport"
-    }
-}

package/android/src/main/java/com/rnmapbox/rnmbx/components/camera/RNMBXViewport.kt

@@ -1,408 +0,0 @@
-package com.rnmapbox.rnmbx.components.camera
-
-import android.content.Context
-import android.util.Log
-import androidx.annotation.RequiresPermission.Read
-import com.facebook.react.bridge.Arguments
-import com.facebook.react.bridge.Callback
-import com.facebook.react.bridge.Promise
-import com.facebook.react.bridge.ReadableMap
-import com.facebook.react.bridge.ReadableType
-import com.facebook.react.bridge.UIManager
-import com.facebook.react.bridge.WritableMap
-import com.facebook.react.uimanager.UIManagerHelper
-import com.mapbox.maps.MapView
-import com.mapbox.maps.plugin.viewport.CompletionListener
-import com.mapbox.maps.plugin.viewport.ViewportPlugin
-import com.mapbox.maps.plugin.viewport.ViewportStatus
-import com.mapbox.maps.plugin.viewport.ViewportStatusObserver
-import com.mapbox.maps.plugin.viewport.data.DefaultViewportTransitionOptions
-import com.mapbox.maps.plugin.viewport.data.ViewportStatusChangeReason
-import com.mapbox.maps.plugin.viewport.state.FollowPuckViewportState
-import com.mapbox.maps.plugin.viewport.state.OverviewViewportState
-import com.mapbox.maps.plugin.viewport.state.ViewportState
-import com.mapbox.maps.plugin.viewport.transition.DefaultViewportTransition
-import com.mapbox.maps.plugin.viewport.transition.ViewportTransition
-import com.mapbox.maps.plugin.viewport.viewport
-import com.rnmapbox.rnmbx.components.AbstractMapFeature
-import com.rnmapbox.rnmbx.components.mapview.RNMBXMapView
-import com.rnmapbox.rnmbx.modules.RNMBXLogging
-import com.rnmapbox.rnmbx.utils.Logger
-import com.rnmapbox.rnmbx.utils.extensions.*
-import com.rnmapbox.rnmbx.utils.writableMapOf
-
-import com.facebook.react.uimanager.events.Event
-import com.mapbox.geojson.Geometry
-import com.mapbox.maps.EdgeInsets
-import com.mapbox.maps.plugin.viewport.data.FollowPuckViewportStateBearing
-import com.mapbox.maps.plugin.viewport.data.FollowPuckViewportStateOptions
-import com.mapbox.maps.plugin.viewport.data.OverviewViewportStateOptions
-import com.rnmapbox.rnmbx.events.constants.EventKeys
-
-class BaseEvent(
-    private val surfaceId: Int,
-    private val viewTag: Int,
-    private val eventName: String,
-    private val eventData: WritableMap,
-    private val canCoalesce: Boolean = false
-): Event<BaseEvent>(surfaceId, viewTag) {
-    override fun getEventName(): String {
-        return eventName
-    }
-
-    override fun canCoalesce(): Boolean {
-        return canCoalesce
-    }
-
-    override fun getEventData(): WritableMap? {
-        return eventData
-    }
-}
-
-class RNMBXViewport(private val mContext: Context, private val mManager: RNMBXViewportManager) :
-AbstractMapFeature(
-mContext
-) {
-    // region properties
-    var transitionsToIdleUponUserInteraction: Boolean? = null
-        set(value: Boolean?) {
-            field = value
-            if (value != null) {
-                mMapView?.let { applyTransitionsToIdleUponUserIntraction(it.mapView) }
-            }
-        }
-
-    fun applyTransitionsToIdleUponUserIntraction(mapView: MapView) {
-        this.transitionsToIdleUponUserInteraction?.let {
-            mapView.viewport.options = mapView.viewport.options.toBuilder().transitionsToIdleUponUserInteraction(it).build()
-        }
-    }
-
-    var hasStatusChanged: Boolean = false
-        set(value: Boolean) {
-            field = value
-            mMapView?.let { applyHasStatusChanged(it.mapView) }
-        }
-    private var statusObserver: ViewportStatusObserver? = null
-
-    private fun applyHasStatusChanged(mapView: MapView) {
-        val viewport = mapView.viewport
-        if (hasStatusChanged) {
-            if (statusObserver == null) {
-                val statusObserver = ViewportStatusObserver { from, to, reason ->
-                    val payload = writableMapOf("from" to statusToMap(from), "to" to statusToMap(to), "reason" to reasonToSrting(reason))
-                    mManager.dispatchEvent(
-                        BaseEvent(
-                            UIManagerHelper.getSurfaceId(mContext),
-                            id,
-                            EventKeys.VIEWPORT_STATUS_CHANGE.value,
-                            writableMapOf(
-                                "type" to "statuschanged",
-                                "payload" to payload
-                            )
-                        )
-                    )
-                }
-                this.statusObserver = statusObserver
-                viewport.addStatusObserver(statusObserver)
-            }
-        } else {
-            statusObserver?.let {
-                viewport.removeStatusObserver(it)
-            }
-        }
-    }
-    // endregion
-
-    override fun addToMap(mapView: RNMBXMapView) {
-        super.addToMap(mapView)
-        applyTransitionsToIdleUponUserIntraction(mapView.mapView)
-        applyHasStatusChanged(mapView.mapView)
-    }
-
-    private fun toState(viewport: ViewportPlugin, state: ReadableMap): ViewportState? {
-        return when (val kind = state.getAndLogIfNotString("kind")) {
-            "followPuck" -> viewport.makeFollowPuckViewportState(
-                parseFollowViewportOptions(state)
-            )
-            "overview" -> return viewport.makeOverviewViewportState(
-                parseOverviewViewportOption(state)
-            )
-            else -> {
-                Logger.e(LOG_TAG, "toState: unexpected state: $kind")
-                null
-            }
-        }
-    }
-
-    data class FollowPuckViewportStateBearingOrNull(val state: FollowPuckViewportStateBearing?)
-    private fun parseFollowViewportOptions(state: ReadableMap): FollowPuckViewportStateOptions {
-        val builder = FollowPuckViewportStateOptions.Builder()
-        state.getAndLogIfNotMap("options", LOG_TAG)?.let { options ->
-            if (options.hasKey("zoom")) {
-                if (options.isKeep("zoom")) {
-                    builder.zoom(null)
-                } else {
-                    options.getAndLogIfNotDouble("zoom", LOG_TAG)?.let { zoom ->
-                        builder.zoom(zoom)
-                    }
-                }
-            }
-            if (options.hasKey("pitch")) {
-                if (options.isKeep("pitch")) {
-                    builder.pitch(null)
-                } else {
-                    options.getAndLogIfNotDouble("pitch", LOG_TAG)?.let {pitch ->
-                        builder.pitch(pitch)
-                    }
-                }
-            }
-
-            if (options.hasKey("bearing")) {
-                when (options.getType("bearing")) {
-                    ReadableType.Number ->
-                        FollowPuckViewportStateBearingOrNull(FollowPuckViewportStateBearing.Constant(options.getDouble("bearing")))
-
-                    ReadableType.String ->
-                        when (options.getString("bearing")) {
-                            "course" ->
-                                FollowPuckViewportStateBearingOrNull(FollowPuckViewportStateBearing.SyncWithLocationPuck)
-                            "heading" ->
-                                FollowPuckViewportStateBearingOrNull(FollowPuckViewportStateBearing.SyncWithLocationPuck)
-                            "keep" ->
-                                FollowPuckViewportStateBearingOrNull(null)
-                            else -> {
-                                Logger.e(
-                                    LOG_TAG,
-                                    "bearing in viewport options should be either a constant number or syncWithLocationPuck"
-                                )
-                                null
-                            }
-                        }
-                    else -> {
-                        Logger.e(
-                            LOG_TAG,
-                        "bearing in viewport options should be either constant number or course or heading or keep"
-                        )
-                        null
-                    }
-                }?.let { bearing ->
-                    builder.bearing(bearing.state)
-                }
-            }
-            if (options.hasKey("padding")) {
-                if (options.isNull("padding")) {
-                    builder.padding(null)
-                } else {
-                    options.getAndLogIfNotMap("padding", LOG_TAG)?.let { paddingMap ->
-                        paddingMap?.toPadding(LOG_TAG, resources.displayMetrics.density)?.let { padding ->
-                            builder.padding(padding)
-                        }
-                    }
-                }
-            }
-        }
-        return builder.build()
-    }
-
-    private fun parseOverviewViewportOption(state: ReadableMap): OverviewViewportStateOptions {
-        val builder = OverviewViewportStateOptions.Builder()
-
-        state.getAndLogIfNotMap("options", LOG_TAG)?.let { options ->
-            if (options.hasKey("padding")) {
-                if (!options.isNull("padding")) {
-                    options.getAndLogIfNotMap("padding", LOG_TAG)?.let { paddingMap ->
-                        paddingMap?.toPadding(LOG_TAG, resources.displayMetrics.density)?.let { padding ->
-                            builder.padding(padding)
-                        }
-                    }
-                }
-            }
-
-            if (options.hasKey("bearing")) {
-                when (options.getType("bearing")) {
-                    ReadableType.Number ->
-                        builder.bearing(options.getDouble("bearing"))
-                    ReadableType.Null ->
-                        builder.bearing(null)
-                    else -> {
-                        Logger.e(
-                            LOG_TAG,
-                            "bearing in viewport options should be either constant number or null"
-                        )
-                        null
-                    }
-                }
-            }
-
-            if (options.hasKey("pitch")) {
-                if (options.isNull("pitch")) {
-                    builder.pitch(null)
-                } else {
-                    options.getAndLogIfNotDouble("pitch", LOG_TAG)?.let {pitch ->
-                        builder.pitch(pitch)
-                    }
-                }
-            }
-
-            if (options.hasKey("animationDuration")) {
-                if (!options.isNull("animationDuration")) {
-                    options.getAndLogIfNotDouble("zoom", LOG_TAG)?.let { duration ->
-                        builder.animationDurationMs((duration * 1000.0).toLong())
-                    }
-                }
-            }
-
-            if (options.hasKey("geometry")) {
-                options.getAndLogIfNotMap("geometry")?.let {map ->
-                    map.toGeometry()?.let { geometry ->
-                        builder.geometry(geometry)
-                    }
-                }
-            }
-        }
-
-        return builder.build()
-    }
-
-
-    private fun toDefaultViewportTransitionOptions(state: ReadableMap?): DefaultViewportTransitionOptions {
-        val builder = DefaultViewportTransitionOptions.Builder()
-        if (state?.hasKey("maxDurationMs") == true) {
-            val maxDurationMs = state.getAndLogIfNotDouble("maxDurationMs", LOG_TAG)
-            if (maxDurationMs != null) {
-                builder.maxDurationMs(maxDurationMs.toLong())
-            }
-            builder.build()
-        }
-        return builder.build()
-    }
-
-    private fun toGeometry(geometry: ReadableMap): Geometry? {
-        return geometry.toGeometry()
-    }
-
-    private fun toTransition(viewport: ViewportPlugin, state: ReadableMap?): ViewportTransition? {
-        viewport.idle()
-        return when (val kind = state?.getAndLogIfNotString("kind", LOG_TAG)) {
-            "default" -> viewport.makeDefaultViewportTransition(
-               toDefaultViewportTransitionOptions(state?.getMap("options"))
-            )
-            "immediate" -> viewport.makeImmediateViewportTransition()
-            null -> null
-            else -> {
-                Logger.e(LOG_TAG, "toTransition: unexpected transition to: $kind")
-                null
-            }
-        }
-    }
-
-    fun transitionTo(state: ReadableMap,
-                     transition: ReadableMap?,
-                     promise: Promise
-    ) {
-        val mapView = mMapView
-        if (mapView == null) {
-            Logger.e(LOG_TAG, "transitionTo: mapView is null")
-            return
-        }
-
-        val toState = toState(mapView.mapView.viewport, state)
-        if (toState == null) {
-            Logger.e(LOG_TAG, "transitionTo: no state to transition to: $state")
-            return;
-        }
-        val transition = toTransition(mapView.mapView.viewport, transition)
-
-        mapView.mapView.viewport.transitionTo(toState, transition, CompletionListener { promise.resolve(it) } )
-    }
-
-    fun idle() {
-        val mapView = mMapView
-        if (mapView == null) {
-            Logger.e(LOG_TAG, "transitionTo: mapView is null")
-            return
-        }
-
-        mapView.mapView.viewport.idle()
-    }
-
-    private fun transitionToMap(transition: ViewportTransition): WritableMap? {
-        return when (transition) {
-            is DefaultViewportTransition -> writableMapOf("kind" to "default", "maxDurationMs" to transition.options.maxDurationMs)
-            else ->
-                if (transition.javaClass.toString().indexOf("ImmediateViewportTransition") >= 0) {
-                    writableMapOf("kind" to "immediate")
-                } else {
-                    writableMapOf("kind" to "unknown")
-                }
-        }
-    }
-
-    private fun stateToMap(state: ViewportState): WritableMap? {
-        return when (state) {
-            is FollowPuckViewportState -> writableMapOf("kind" to "followPuck")
-            is OverviewViewportState -> writableMapOf("kind" to "overview")
-            else -> {
-                writableMapOf("kind" to "custom", "impl" to state.javaClass.toString())
-            }
-        }
-    }
-
-    private fun statusToMap(status: ViewportStatus): WritableMap? {
-        return when (status) {
-            is ViewportStatus.Idle -> {
-                writableMapOf(
-                    "kind" to "idle"
-                )
-            }
-
-            is ViewportStatus.State -> {
-                writableMapOf(
-                    "kind" to "state",
-                    "state" to stateToMap(status.state)
-                )
-            }
-
-            is ViewportStatus.Transition -> {
-                writableMapOf(
-                    "kind" to "transition",
-                    "transition" to transitionToMap(status.transition),
-                    "toState" to stateToMap(status.toState)
-                )
-            }
-        }
-    }
-
-    private fun reasonToSrting(reason: ViewportStatusChangeReason): String {
-        return when (reason) {
-           ViewportStatusChangeReason.IDLE_REQUESTED -> "IdleRequested"
-            ViewportStatusChangeReason.TRANSITION_FAILED -> "TransitionFailed"
-            ViewportStatusChangeReason.TRANSITION_STARTED -> "TransitionStarted"
-            ViewportStatusChangeReason.USER_INTERACTION -> "UserInteraction"
-            ViewportStatusChangeReason.TRANSITION_SUCCEEDED -> "TransitionSucceeded"
-            else -> {
-                "Unknown:${reason.toString()}"
-            }
-        }
-    }
-
-    fun getState(): WritableMap? {
-        val mapView = mMapView
-        if (mapView == null) {
-            Logger.e(LOG_TAG, "getState: mapView is null")
-            return null
-        }
-        return statusToMap(mapView.mapView.viewport.status)
-    }
-
-    companion object {
-        const val LOG_TAG = "RNMBXViewport"
-    }
-}
-
-private fun ReadableMap.isKeep(s: String): Boolean {
-    return ((getType(s) == ReadableType.String) && (getString(s) == "keep"))
-}
-
-