@nativescript-community/ui-mapbox 6.2.10 → 6.2.14

package/{mapbox.ios.js → index.ios.js}

@@ -1,1564 +1,1665 @@
-import { Color, File, ImageSource, Trace, knownFolders, path } from '@nativescript/core';
-import { CLog, CLogTypes, MapStyle, MapboxCommon, MapboxTraceCategory, MapboxViewBase, telemetryProperty } from './mapbox.common';
-import { iOSNativeHelper } from '@nativescript/core/utils';
-import { getImage } from '@nativescript/core/http';
-import { LayerFactory } from './layers/layer-factory';
-import { FilterParser } from './filter/filter-parser.ios';
-export { MapboxTraceCategory, MapStyle };
-let _markers = [];
-const _markerIconDownloadCache = [];
-const _setMapboxMapOptions = (mapView, settings) => {
-    mapView.logoView.hidden = settings.hideLogo;
-    mapView.attributionButton.hidden = settings.hideAttribution;
-    mapView.compassView.hidden = settings.hideCompass;
-    mapView.rotateEnabled = !settings.disableRotation;
-    mapView.scrollEnabled = !settings.disableScroll;
-    mapView.zoomEnabled = !settings.disableZoom;
-    mapView.allowsTilting = !settings.disableTilt;
-    if (settings.center && settings.center.lat && settings.center.lng) {
-        const centerCoordinate = CLLocationCoordinate2DMake(settings.center.lat, settings.center.lng);
-        mapView.setCenterCoordinateZoomLevelAnimated(centerCoordinate, settings.zoomLevel, false);
-    }
-    else {
-        mapView.setZoomLevelAnimated(settings.zoomLevel, false);
-    }
-    mapView.showsUserLocation = settings.showUserLocation;
-    mapView.autoresizingMask = 2 | 16;
-};
-const _getMapStyle = (input) => {
-    if (input.startsWith('mapbox://styles') || input.startsWith('http://') || input.startsWith('https://')) {
-        return NSURL.URLWithString(input);
-    }
-    else if (input.startsWith('~/')) {
-        return NSURL.URLWithString('file://' + path.join(knownFolders.currentApp().path, input.replace('~/', '')));
-    }
-    else if (input === MapStyle.LIGHT) {
-        return MGLStyle.lightStyleURL;
-    }
-    else if (input === MapStyle.DARK) {
-        return MGLStyle.darkStyleURL;
-    }
-    else if (input === MapStyle.OUTDOORS) {
-        return MGLStyle.outdoorsStyleURL;
-    }
-    else if (input === MapStyle.SATELLITE) {
-        return MGLStyle.satelliteStyleURL;
-    }
-    else if (input === MapStyle.SATELLITE_STREETS) {
-        return MGLStyle.satelliteStreetsStyleURL;
-    }
-    else if (input === MapStyle.TRAFFIC_DAY) {
-        return NSURL.URLWithString('mapbox://styles/mapbox/traffic-day-v2');
-    }
-    else if (input === MapStyle.TRAFFIC_NIGHT) {
-        return NSURL.URLWithString('mapbox://styles/mapbox/traffic-night-v2');
-    }
-    else {
-        return MGLStyle.streetsStyleURL;
-    }
-};
-function _getTrackingMode(input) {
-    return 0;
-}
-function _getLocation(loc) {
-    if (loc === null) {
-        return null;
-    }
-    else {
-        return {
-            location: {
-                lat: loc.coordinate.latitude,
-                lng: loc.coordinate.longitude
-            },
-            speed: loc.location ? loc.location.speed : 0
-        };
-    }
-}
-export function setLogLevel(level) {
-    let loggingLevel;
-    switch (level) {
-        case 'none':
-            loggingLevel = 0;
-            break;
-        case 'info':
-            loggingLevel = 1;
-            break;
-        case 'verbose':
-        case 'debug':
-            loggingLevel = 2;
-            break;
-        case 'error':
-            loggingLevel = 3;
-            break;
-        case 'fault':
-            loggingLevel = 4;
-            break;
-    }
-    MGLLoggingConfiguration.sharedConfiguration.loggingLevel = loggingLevel;
-}
-export class MapboxView extends MapboxViewBase {
-    constructor() {
-        super(...arguments);
-        this.nativeMapView = null;
-        this.delegate = null;
-        this.settings = null;
-        this.initialized = false;
-        this.initCountHack = 50;
+import { Color, File, Http, ImageSource, Trace, Utils, knownFolders, path } from '@nativescript/core';
+import { CLog, CLogTypes, MapStyle, MapboxCommon, MapboxViewBase, telemetryProperty } from './common';
+import { Layer, LayerFactory } from './layers/layer-factory';
+import { ExpressionParser } from './expression/expression-parser';
+var MGLMapViewDelegateImpl = /** @class */ (function (_super) {
+    __extends(MGLMapViewDelegateImpl, _super);
+    function MGLMapViewDelegateImpl() {
+        return _super !== null && _super.apply(this, arguments) || this;
     }
-    setConfig(settings) {
+    MGLMapViewDelegateImpl.new = function () {
+        return _super.new.call(this);
+    };
+    /**
+     * initialize with the mapReady callback
+     */
+    MGLMapViewDelegateImpl.prototype.initWithCallback = function (mapLoadedCallback) {
         if (Trace.isEnabled()) {
-            CLog(CLogTypes.info, 'setConfig(): settings:', settings);
+            CLog(CLogTypes.info, 'MGLMapViewDelegateImpl::initWithCallback()');
         }
-        this.settings = settings;
-    }
-    getNativeMapView() {
-        return this.nativeMapView;
-    }
-    createNativeView() {
+        this.mapLoadedCallback = mapLoadedCallback;
+        return this;
+    };
+    /**
+     * set a reference to the mapboxAPI instance
+     */
+    MGLMapViewDelegateImpl.prototype.setMapboxApi = function (api) {
+        this.mapboxApi = api;
+    };
+    /**
+     * set the user location click listener callback
+     */
+    MGLMapViewDelegateImpl.prototype.setUserLocationClickListener = function (callback) {
+        this.userLocationClickListener = callback;
+    };
+    /**
+     * set the user location click listener callback
+     */
+    MGLMapViewDelegateImpl.prototype.setUserLocationChangedistener = function (callback) {
+        this.userLocationChangedListener = callback;
+    };
+    /**
+     * set user location marker modes
+     */
+    MGLMapViewDelegateImpl.prototype.changeUserLocationRenderMode = function (userLocationRenderMode) {
+        this.userLocationAnnotationView.changeUserLocationRenderMode(userLocationRenderMode);
+    };
+    /**
+     * set the camera changd listener callback
+     */
+    MGLMapViewDelegateImpl.prototype.setCameraChangedListener = function (callback) {
+        this.cameraChangedListener = callback;
+    };
+    /**
+     * set the camera idled listener callback
+     */
+    MGLMapViewDelegateImpl.prototype.setCameraIdledListener = function (callback) {
+        this.cameraIdledListener = callback;
+    };
+    /**
+     * set style loaded callback.
+     *
+     * set an optional callback to be invoked when a style set with
+     * setMapStyle() is finished loading
+     *
+     * @param {function} callback function with loaded style as parameter.
+     *
+     * @see Mapbox:setMapStyle()
+     */
+    MGLMapViewDelegateImpl.prototype.setStyleLoadedCallback = function (callback) {
+        this.styleLoadedCallback = callback;
+    };
+    /**
+     * map ready callback
+     */
+    MGLMapViewDelegateImpl.prototype.mapViewDidFinishLoadingMap = function (mapView) {
         if (Trace.isEnabled()) {
-            CLog(CLogTypes.info, 'createNativeView(): top');
+            CLog(CLogTypes.info, 'MGLMapViewDelegateImpl:mapViewDidFinishLoadingMap(): top');
         }
-        const v = super.createNativeView();
-        return v;
-    }
-    onLoaded() {
-        super.onLoaded();
+        if (this.mapLoadedCallback !== undefined) {
+            this.mapLoadedCallback(mapView);
+            // this should be fired only once, but it's also fired when the style changes, so just remove the callback
+            this.mapLoadedCallback = undefined;
+        }
+    };
+    MGLMapViewDelegateImpl.prototype.mapViewDidFinishRenderingMapFullyRendered = function (mapView, fullyRendered) {
         if (Trace.isEnabled()) {
-            CLog(CLogTypes.info, 'initNativeView(): on - loaded');
+            CLog(CLogTypes.info, 'MGLMapViewDelegateImpl:mapViewDidFinishRenderingMapFullyRendered(): rendered is:', fullyRendered);
         }
-        if (this.telemetry === false) {
-            NSUserDefaults.standardUserDefaults.setBoolForKey(false, 'MGLMapboxMetricsEnabled');
+    };
+    /**
+     * Callback when the style has been loaded.
+     *
+     * Based on my testing, it looks like this callback is invoked multiple times.
+     *
+     * @see Mapbox:setMapStyle()
+     *
+     * @link https://mapbox.github.io/mapbox-gl-native/macos/0.3.0/Protocols/MGLMapViewDelegate.html#/c:objc(pl)MGLMapViewDelegate(im)mapView:didFinishLoadingStyle:
+     */
+    MGLMapViewDelegateImpl.prototype.mapViewDidFinishLoadingStyle = function (mapView, style) {
+        if (Trace.isEnabled()) {
+            CLog(CLogTypes.info, 'MGLMapViewDelegateImpl:mapViewDidFinishLoadingStyle(): callback called.');
         }
-        if (!this.initialized) {
-            this.initMap();
-            this.initialized = true;
+        if (this.styleLoadedCallback !== undefined) {
+            this.styleLoadedCallback(mapView, style);
+            // to avoid multiple calls. This is only invoked from setMapStyle().
+            this.styleLoadedCallback = undefined;
         }
-    }
-    initNativeView() {
-        super.initNativeView();
-        this.nativeView.owner = this;
-    }
-    async disposeNativeView() {
-        if (Trace.isEnabled()) {
-            CLog(CLogTypes.info, 'disposeNativeView(): top');
+    };
+    /**
+     * disable the default user location callout
+     *
+     * This took forever to find. The default iOS click handler for the user location
+     * marker is about useless. It just displays "You Are Here". The examples do not
+     * show how to disable it.
+     */
+    MGLMapViewDelegateImpl.prototype.mapViewAnnotationCanShowCallout = function (mapView, annotation) {
+        if (annotation.isKindOfClass(MGLUserLocation.class())) {
+            return false;
         }
-        this.nativeView.owner = null;
-        await this.mapbox.destroy();
-        if (Trace.isEnabled()) {
-            CLog(CLogTypes.info, 'disposeNativeView(): after mapbox.destroy()');
+        else {
+            return true;
         }
-        super.disposeNativeView();
+    };
+    MGLMapViewDelegateImpl.prototype.mapViewDidFailLoadingMapWithError = function (mapView, error) {
         if (Trace.isEnabled()) {
-            CLog(CLogTypes.info, 'disposeNativeView(): bottom');
+            CLog(CLogTypes.info, 'mapViewDidFailLoadingMapWithError: ' + error);
         }
-    }
-    getMapboxApi() {
-        return this.mapbox;
-    }
-    initMap() {
+    };
+    MGLMapViewDelegateImpl.prototype.mapViewDidChangeUserTrackingModeAnimated = function (mapView, mode, animated) {
         if (Trace.isEnabled()) {
-            CLog(CLogTypes.info, 'initMap() top with settings:', this.settings);
+            CLog(CLogTypes.info, 'mapViewDidChangeUserTrackingModeAnimated: ' + mode);
         }
-        if (!this.settings && !this.config.accessToken) {
-            if (Trace.isEnabled()) {
-                CLog(CLogTypes.info, 'initMap() no access token. Race condition on XML property evaluation?');
-            }
-            if (this.initCountHack > 50) {
-                return;
-            }
-            setTimeout(() => {
-                this.initMap();
-            }, 50);
-            this.initCountHack++;
-            return;
-        }
-        if (!this.settings) {
-            this.settings = Mapbox.merge(this.config, Mapbox.defaults);
-        }
-        else {
-            this.settings = Mapbox.merge(this.settings, Mapbox.defaults);
-        }
-        if (!this.nativeMapView) {
-            this.mapbox = new Mapbox(this);
-            if (Trace.isEnabled()) {
-                CLog(CLogTypes.info, 'initMap(): after new Mapbox()');
+    };
+    /**
+     * fired when the marker icon is about to be rendered - return null for the default icon
+     */
+    MGLMapViewDelegateImpl.prototype.mapViewImageForAnnotation = function (mapView, annotation) {
+        var cachedMarker = this.getTappedMarkerDetails(annotation);
+        if (cachedMarker) {
+            if (cachedMarker.reuseIdentifier) {
+                var reusedImage = mapView.dequeueReusableAnnotationImageWithIdentifier(cachedMarker.reuseIdentifier);
+                if (reusedImage) {
+                    return reusedImage;
+                }
             }
-            const drawMap = () => {
-                MGLAccountManager.accessToken = this.settings.accessToken;
-                this.nativeMapView = MGLMapView.alloc().initWithFrameStyleURL(CGRectMake(0, 0, this.nativeView.frame.size.width, this.nativeView.frame.size.height), _getMapStyle(this.settings.style));
-                this.nativeMapView.delegate = this.delegate = MGLMapViewDelegateImpl.new().initWithCallback(() => {
-                    if (Trace.isEnabled()) {
-                        CLog(CLogTypes.info, 'initMap(): MLMapViewDeleteImpl onMapReady callback');
+            // TODO try adding .rotatesToMatchCamera = true;
+            // .. for instance in the mapViewDidDeselectAnnotationView / mapViewDidSelectAnnotationView / mapViewViewForAnnotation delegate
+            if (cachedMarker.icon) {
+                if (cachedMarker.icon.startsWith('res://')) {
+                    var resourceName = cachedMarker.icon.substring('res://'.length);
+                    var imageSource = ImageSource.fromResourceSync(resourceName);
+                    if (imageSource === null) {
+                        console.log("Unable to locate ".concat(resourceName));
                     }
-                    this.mapbox.setMapboxViewInstance(this.nativeMapView);
-                    this.mapbox.initEventHandlerShim(this.settings, this.nativeMapView);
-                    this.notify({
-                        eventName: MapboxViewBase.mapReadyEvent,
-                        object: this,
-                        map: this,
-                        ios: this.nativeMapView
-                    });
-                    this.notify({
-                        eventName: MapboxViewBase.locationPermissionGrantedEvent,
-                        object: this,
-                        map: this,
-                        ios: this.nativeMapView
-                    });
-                });
-                _setMapboxMapOptions(this.nativeMapView, this.settings);
-                _markers = [];
-                this.nativeView.addSubview(this.nativeMapView);
-                this.mapbox.setOnMoveBeginListener((data) => {
+                    else {
+                        cachedMarker.reuseIdentifier = cachedMarker.icon;
+                        return MGLAnnotationImage.annotationImageWithImageReuseIdentifier(imageSource.ios, cachedMarker.reuseIdentifier);
+                    }
+                }
+                else if (cachedMarker.icon.startsWith('http')) {
+                    if (cachedMarker.iconDownloaded !== null) {
+                        cachedMarker.reuseIdentifier = cachedMarker.icon;
+                        return MGLAnnotationImage.annotationImageWithImageReuseIdentifier(cachedMarker.iconDownloaded, cachedMarker.reuseIdentifier);
+                    }
+                }
+                else {
                     if (Trace.isEnabled()) {
-                        CLog(CLogTypes.info, 'initMap(): onMoveBegin listener');
+                        CLog(CLogTypes.info, 'Please use res://resourceName, http(s)://imageUrl or iconPath to use a local path');
                     }
-                    this.notify({
-                        eventName: MapboxViewBase.moveBeginEvent,
-                        object: this,
-                        map: this,
-                        ios: this.nativeMapView
-                    });
-                }, this.nativeMapView);
-            };
-            setTimeout(drawMap, this.settings.delay ? this.settings.delay : 0);
-        }
-    }
-    onLayout(left, top, right, bottom) {
-        super.onLayout(left, top, right, bottom);
-        if (this.nativeMapView) {
-            this.nativeMapView.layer.frame = this.ios.layer.bounds;
-        }
-    }
-    [telemetryProperty.setNative](value) {
-        NSUserDefaults.standardUserDefaults.setBoolForKey(false, 'MGLMapboxMetricsEnabled');
-    }
-}
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CustomUserLocationAnnotationView = void 0;
-var CustomUserLocationAnnotationView = /** @class */ (function (_super) {
-    __extends(CustomUserLocationAnnotationView, _super);
-    function CustomUserLocationAnnotationView() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    /**
-     * init
-     *
-     * @link https://docs.nativescript.org/core-concepts/ios-runtime/HelloWorld
-     */
-    CustomUserLocationAnnotationView.prototype.init = function () {
-        this.size = 48;
-        _super.prototype.initWithFrame.call(this, CGRectMake(0, 0, this.size, this.size));
-        this.renderModeChanged = true;
-        this.userLocationRenderMode = 'NORMAL';
-        return this;
-    };
-    /**
-     * update
-     *
-     * The note from the Objective-C sample indicates this method may be called quite
-     * often so it needs to be kept lightweight.
-     */
-    CustomUserLocationAnnotationView.prototype.update = function () {
-        if (CLLocationCoordinate2DIsValid(this.userLocation.coordinate)) {
-            // if it's the first time here, setup the layers that make up the
-            // location marker.
-            if (!this.dot) {
-                this.drawNonTrackingLocationMarker();
+                }
             }
-            if (this.userLocationRenderMode === 'GPS') {
-                this.updateHeading();
+            else if (cachedMarker.iconPath) {
+                var appPath = knownFolders.currentApp().path;
+                var iconFullPath = appPath + '/' + cachedMarker.iconPath.replace('~/', '');
+                if (File.exists(iconFullPath)) {
+                    var image = ImageSource.fromFileSync(iconFullPath).ios;
+                    // perhaps add resize options for nice retina rendering (although you can now use the 'icon' param instead)
+                    cachedMarker.reuseIdentifier = cachedMarker.iconPath;
+                    return MGLAnnotationImage.annotationImageWithImageReuseIdentifier(image, cachedMarker.reuseIdentifier);
+                }
             }
         }
+        return null;
     };
     /**
-     * Draw the GPS tracking arrow.
-     *
-     * @link https://docs.nativescript.org/ns-framework-modules/color
+     * fired when one of the callout's accessoryviews is tapped (not currently used)
      */
-    CustomUserLocationAnnotationView.prototype.drawTrackingLocationMarker = function () {
-        if (Trace.isEnabled()) {
-            CLog(CLogTypes.info, 'CustomerUserLocationAnnotatinView::drawTrackingLocationMarker()');
-        }
-        this.drawTrackingDot();
-        this.drawArrow();
-    }; // end of setupLayers()
+    MGLMapViewDelegateImpl.prototype.mapViewAnnotationCalloutAccessoryControlTapped = function (mapView, annotation, control) { };
     /**
-     * draw the non-tracking marker
+     * fired when a marker is tapped
      */
-    CustomUserLocationAnnotationView.prototype.drawNonTrackingLocationMarker = function () {
+    MGLMapViewDelegateImpl.prototype.mapViewDidSelectAnnotation = function (mapView, annotation) {
         if (Trace.isEnabled()) {
-            CLog(CLogTypes.info, 'CustomerUserLocationAnnotatinView::drawNonTrackingLocationMarker()');
+            CLog(CLogTypes.info, 'MGLMapViewDelegateImpl::mapViewDidSelectAnntation()');
         }
-        this.drawNonTrackingDot();
-        if (this.arrow) {
-            this.arrow.removeFromSuperlayer();
-            this.arrow = null;
+        if (annotation.isKindOfClass(MGLUserLocation.class())) {
+            if (Trace.isEnabled()) {
+                CLog(CLogTypes.info, 'MGLMapViewDelegateImpl::mapViewDidSelectAnnotation(): tapped the user location button');
+            }
+            if (typeof this.userLocationClickListener != 'undefined') {
+                this.userLocationClickListener(annotation);
+                return;
+            }
+            mapView.deselectAnnotationAnimated(annotation, false);
+        }
+        var cachedMarker = this.getTappedMarkerDetails(annotation);
+        if (cachedMarker && cachedMarker.onTap) {
+            cachedMarker.onTap(cachedMarker);
         }
     };
     /**
-     * draw the tracking dot.
+     * fired when a callout is tapped
      */
-    CustomUserLocationAnnotationView.prototype.drawTrackingDot = function () {
-        this.size = 48;
-        // we need to adjust the size of the bounds of the marker. The Tracking marker
-        // is larger than the non tracking marker.
-        this.bounds = CGRectMake(0, 0, this.size, this.size);
-        var dot = CALayer.layer();
-        dot.frame = this.bounds;
-        // user corner radius to turn the layer into a circle
-        dot.cornerRadius = this.size / 2;
-        dot.backgroundColor = this.tintColor.CGColor;
-        dot.borderWidth = 4;
-        var whiteColor = new Color('#FFFFFF');
-        dot.borderColor = whiteColor.ios.CGColor;
-        if (!this.dot) {
-            this.layer.addSublayer(dot);
+    MGLMapViewDelegateImpl.prototype.mapViewTapOnCalloutForAnnotation = function (mapView, annotation) {
+        var cachedMarker = this.getTappedMarkerDetails(annotation);
+        if (cachedMarker && cachedMarker.onCalloutTap) {
+            cachedMarker.onCalloutTap(cachedMarker);
         }
-        else {
-            this.layer.replaceSublayerWith(this.dot, dot);
+    };
+    MGLMapViewDelegateImpl.prototype.getTappedMarkerDetails = function (tapped) {
+        for (var m in _markers) {
+            var cached = _markers[m];
+            // don't compare lat/lng types as they're not the same (same for (sub)title, they may be null vs undefined)
+            if (
+            // eslint-disable-next-line eqeqeq
+            cached.lat == tapped.coordinate.latitude &&
+                // eslint-disable-next-line eqeqeq
+                cached.lng == tapped.coordinate.longitude &&
+                // eslint-disable-next-line eqeqeq
+                cached.title == tapped.title &&
+                // eslint-disable-next-line eqeqeq
+                cached.subtitle == tapped.subtitle) {
+                return cached;
+            }
         }
-        // QUESTION: does GC catch this?
-        this.dot = dot;
     };
     /**
-     * draw the non-tracking dot.
+     * override the standard location marker
      */
-    CustomUserLocationAnnotationView.prototype.drawNonTrackingDot = function () {
-        this.size = 24;
-        this.bounds = CGRectMake(0, 0, this.size, this.size);
-        var dot = CALayer.layer();
-        dot.frame = this.bounds;
-        // user corner radius to turn the layer into a circle
-        dot.cornerRadius = this.size / 2;
-        dot.backgroundColor = this.tintColor.CGColor;
-        dot.borderWidth = 1;
-        var whiteColor = new Color('#FFFFFF');
-        dot.borderColor = whiteColor.ios.CGColor;
-        if (!this.dot) {
-            this.layer.addSublayer(dot);
+    MGLMapViewDelegateImpl.prototype.mapViewViewForAnnotation = function (mapView, annotation) {
+        if (Trace.isEnabled()) {
+            CLog(CLogTypes.info, 'MGLMapViewDelegateImpl::mapViewViewForAnnotation() top');
         }
-        else {
-            this.layer.replaceSublayerWith(this.dot, dot);
+        if (annotation.isKindOfClass(MGLUserLocation.class())) {
+            this.userLocationAnnotationView = CustomUserLocationAnnotationView.alloc().init();
+            return this.userLocationAnnotationView;
         }
-        // QUESTION: does GC catch this?
-        this.dot = dot;
+        return null;
     };
-    /**
-     * draw an arrow
-     */
-    CustomUserLocationAnnotationView.prototype.drawArrow = function () {
-        var arrow = CAShapeLayer.layer();
-        arrow.path = this.arrowPath();
-        arrow.frame = CGRectMake(0, 0, this.size / 2, this.size / 2);
-        arrow.position = CGPointMake(CGRectGetMidX(this.dot.frame), CGRectGetMidY(this.dot.frame));
-        arrow.fillColor = this.dot.borderColor;
-        if (!this.arrow) {
-            this.layer.addSublayer(arrow);
+    MGLMapViewDelegateImpl.prototype.mapViewRegionIsChangingWithReason = function (mapView, reason) {
+        if (Trace.isEnabled()) {
+            CLog(CLogTypes.info, 'MGLMapViewDelegateImpl::mapViewRegionIsChanging()');
         }
-        else {
-            this.layer.replaceSublayerWith(this.arrow, arrow);
+        if (this.cameraChangedListener) {
+            this.cameraChangedListener(reason);
         }
-        // QUESTION: Does GC catch this?
-        this.arrow = arrow;
     };
-    /**
-     * update arrow heading
-     *
-     * @link https://docs.nativescript.org/core-concepts/ios-runtime/types/C-Functions
-     */
-    CustomUserLocationAnnotationView.prototype.updateHeading = function () {
-        // just to avoid a possible race condition where the arrow isnt' drawn yet
-        if (!this.arrow) {
-            return;
-        }
-        if (typeof this.userLocation == 'undefined') {
-            return;
+    MGLMapViewDelegateImpl.prototype.mapViewRegionDidChangeWithReasonAnimated = function (mapView, reason, animated) {
+        if (Trace.isEnabled()) {
+            CLog(CLogTypes.info, 'MGLMapViewDelegateImpl::mapViewRegionDidChangeAnimated()');
         }
-        if (typeof this.userLocation.heading == 'undefined' || this.userLocation.heading === null) {
-            return;
+        if (this.cameraChangedListener) {
+            this.cameraChangedListener(reason, animated);
         }
-        if (typeof this.userLocation.heading.trueHeading == 'undefined' || this.userLocation.heading.trueHeading === null) {
-            return;
+        if (this.cameraIdledListener) {
+            this.cameraIdledListener();
         }
-        if (this.userLocation.heading.trueHeading > 0) {
-            this.arrow.hidden = false;
-            // get the difference between the map's current direction and the
-            // user's heading, then convert it from degrees to radians
-            //
-            // The original Objective-C example uses the inline C function MGLRadiansFromDegrees but because
-            // it's declared as inline it is not available for NativeScript. See linked article above.
-            // let rotation : number = MGLRadiansFromDegrees( this.mapView.direction - this.userLocation.heading.trueHeading );
-            var degrees = this.mapView.direction - this.userLocation.heading.trueHeading;
-            // in radians
-            var rotation = (degrees * Math.PI) / 180;
-            rotation = -rotation;
-            // if the difference would be perceptible, rotate the arrow.
-            if (fabs(rotation) > 0.01) {
-                // Disable implicit animations of this rotation, which reduces lag between updates
-                CATransaction.begin();
-                CATransaction.setDisableActions(true);
-                this.arrow.setAffineTransform(CGAffineTransformRotate(CGAffineTransformIdentity, rotation));
-                CATransaction.commit();
-            }
+    };
+    MGLMapViewDelegateImpl.prototype.mapViewDidUpdateUserLocation = function (mapView, userLocation) {
+        if (Trace.isEnabled()) {
+            CLog(CLogTypes.info, 'MGLMapViewDelegateImpl::mapViewDidUpdateUserLocation()');
         }
-        else {
-            this.arrow.hidden = true;
+        if (this.userLocationChangedListener) {
+            this.userLocationChangedListener(_getLocation(userLocation));
         }
     };
-    /**
-     * Calculate the vector path for an arrow
-     */
-    CustomUserLocationAnnotationView.prototype.arrowPath = function () {
-        var max = this.size / 2;
-        var pad = 3;
-        var top = CGPointMake(max * 0.5, 0);
-        var left = CGPointMake(0 + pad, max - pad);
-        var right = CGPointMake(max - pad, max - pad);
-        var center = CGPointMake(max * 0.5, max * 0.6);
-        var bezierPath = UIBezierPath.bezierPath();
-        bezierPath.moveToPoint(top);
-        bezierPath.addLineToPoint(left);
-        bezierPath.addLineToPoint(center);
-        bezierPath.addLineToPoint(right);
-        bezierPath.addLineToPoint(top);
-        bezierPath.closePath();
-        return bezierPath.CGPath;
+    MGLMapViewDelegateImpl.ObjCProtocols = [MGLMapViewDelegate];
+    return MGLMapViewDelegateImpl;
+}(NSObject));
+var MapTapHandlerImpl = /** @class */ (function (_super) {
+    __extends(MapTapHandlerImpl, _super);
+    function MapTapHandlerImpl() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    MapTapHandlerImpl.initWithOwnerAndListenerForMap = function (owner, listener, mapView) {
+        var handler = MapTapHandlerImpl.new();
+        handler._owner = owner;
+        handler._listener = listener;
+        handler._mapView = mapView;
+        return handler;
     };
-    /**
-     * change Render mode
-     *
-     * @param {string} renderMode
-     */
-    CustomUserLocationAnnotationView.prototype.changeUserLocationRenderMode = function (renderMode) {
+    MapTapHandlerImpl.prototype.tap = function (recognizer) {
+        var tapPoint = recognizer.locationInView(this._mapView);
+        var tapCoordinate = this._mapView.convertPointToCoordinateFromView(tapPoint, this._mapView);
+        this._listener({
+            lat: tapCoordinate.latitude,
+            lng: tapCoordinate.longitude
+        });
+    };
+    MapTapHandlerImpl.ObjCExposedMethods = {
+        tap: { returns: interop.types.void, params: [interop.types.id] }
+    };
+    return MapTapHandlerImpl;
+}(NSObject));
+var MapLongPressHandlerImpl = /** @class */ (function (_super) {
+    __extends(MapLongPressHandlerImpl, _super);
+    function MapLongPressHandlerImpl() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    MapLongPressHandlerImpl.initWithOwnerAndListenerForMap = function (owner, listener, mapView) {
+        var handler = MapLongPressHandlerImpl.new();
+        handler._owner = owner;
+        handler._listener = listener;
+        handler._mapView = mapView;
+        return handler;
+    };
+    MapLongPressHandlerImpl.prototype.longPress = function (recognizer) {
+        var longPressPoint = recognizer.locationInView(this._mapView);
+        var longPressCoordinate = this._mapView.convertPointToCoordinateFromView(longPressPoint, this._mapView);
+        this._listener({
+            lat: longPressCoordinate.latitude,
+            lng: longPressCoordinate.longitude
+        });
+    };
+    MapLongPressHandlerImpl.ObjCExposedMethods = {
+        longPress: { returns: interop.types.void, params: [interop.types.id] }
+    };
+    return MapLongPressHandlerImpl;
+}(NSObject));
+var MapPanHandlerImpl = /** @class */ (function (_super) {
+    __extends(MapPanHandlerImpl, _super);
+    function MapPanHandlerImpl() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    MapPanHandlerImpl.initWithOwnerAndListenerForMap = function (owner, listener, panState, mapView) {
+        var handler = MapPanHandlerImpl.new();
+        handler._owner = owner;
+        handler._listener = new Map([[panState, listener]]);
+        handler._mapView = mapView;
+        return handler;
+    };
+    MapPanHandlerImpl.prototype.addListener = function (panState, listener) {
+        this._listener.set(panState, listener);
+    };
+    MapPanHandlerImpl.prototype.pan = function (recognizer) {
+        var panCoordinate = this.getCoordinates(recognizer);
         if (Trace.isEnabled()) {
-            CLog(CLogTypes.info, "CustomUserLocationAnnotatinView::changeUserLocationRenderMode(): changing mode to '" + renderMode + "'");
+            CLog(CLogTypes.info, 'MapPanHandlerImpl::pan(): top with state:', recognizer.state);
         }
-        this.userLocationRenderMode = renderMode;
-        if (renderMode === 'GPS') {
-            this.drawTrackingLocationMarker();
+        if (recognizer.state === UIGestureRecognizerState.Changed) {
+            this.notifyListener(recognizer.state, panCoordinate.latitude, panCoordinate.longitude);
         }
-        else {
-            this.drawNonTrackingLocationMarker();
+    };
+    MapPanHandlerImpl.prototype.panEnd = function (recognizer) {
+        var panCoordinate = this.getCoordinates(recognizer);
+        if (Trace.isEnabled()) {
+            CLog(CLogTypes.info, 'MapPanHandlerImpl::panEnd(): top with state:', recognizer.state);
+        }
+        if (recognizer.state === UIGestureRecognizerState.Ended) {
+            this.notifyListener(recognizer.state, panCoordinate.latitude, panCoordinate.longitude);
         }
     };
-    return CustomUserLocationAnnotationView;
-}(MGLUserLocationAnnotationView));
-exports.CustomUserLocationAnnotationView = CustomUserLocationAnnotationView;
-export class Mapbox extends MapboxCommon {
-    constructor() {
-        super(...arguments);
-        this.eventCallbacks = {};
-    }
-    setMapboxViewInstance(mapboxViewInstance) {
-        this._mapboxViewInstance = mapboxViewInstance;
-    }
-    initEventHandlerShim(settings, mapboxNativeViewInstance) {
+    MapPanHandlerImpl.prototype.panBegin = function (recognizer) {
+        var panCoordinate = this.getCoordinates(recognizer);
         if (Trace.isEnabled()) {
-            CLog(CLogTypes.info, 'Mapbox:initEventHandlerShim(): top');
+            CLog(CLogTypes.info, 'MapPanHandlerImpl::panBegin(): top with state:', recognizer.state);
         }
-        this.setOnMapClickListener((point) => this.checkForClickEvent(point), mapboxNativeViewInstance);
-    }
-    onMapEvent(eventName, id, callback, nativeMapView) {
-        if (typeof this.eventCallbacks[eventName] == 'undefined') {
-            this.eventCallbacks[eventName] = [];
+        if (recognizer.state === UIGestureRecognizerState.Began) {
+            this.notifyListener(recognizer.state, panCoordinate.latitude, panCoordinate.longitude);
         }
-        this.eventCallbacks[eventName].push({
-            id,
-            callback
+    };
+    MapPanHandlerImpl.prototype.getCoordinates = function (recognizer) {
+        var panPoint = recognizer.locationInView(this._mapView);
+        return this._mapView.convertPointToCoordinateFromView(panPoint, this._mapView);
+    };
+    MapPanHandlerImpl.prototype.notifyListener = function (panState, latitude, longitude) {
+        if (this._listener.has(panState)) {
+            this._listener.get(panState)({ lat: latitude, lng: longitude });
+        }
+    };
+    MapPanHandlerImpl.ObjCExposedMethods = {
+        pan: { returns: interop.types.void, params: [interop.types.id] },
+        panEnd: { returns: interop.types.void, params: [interop.types.id] },
+        panBegin: { returns: interop.types.void, params: [interop.types.id] }
+    };
+    return MapPanHandlerImpl;
+}(NSObject));
+var MapSwipeHandlerImpl = /** @class */ (function (_super) {
+    __extends(MapSwipeHandlerImpl, _super);
+    function MapSwipeHandlerImpl() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    MapSwipeHandlerImpl.initWithOwnerAndListenerForMap = function (owner, listener, mapView) {
+        var handler = MapSwipeHandlerImpl.new();
+        handler._owner = owner;
+        handler._listener = listener;
+        handler._mapView = mapView;
+        return handler;
+    };
+    MapSwipeHandlerImpl.prototype.swipe = function (recognizer) {
+        var swipePoint = recognizer.locationInView(this._mapView);
+        var swipeCoordinate = this._mapView.convertPointToCoordinateFromView(swipePoint, this._mapView);
+        this._listener({
+            lat: swipeCoordinate.latitude,
+            lng: swipeCoordinate.longitude
         });
+    };
+    MapSwipeHandlerImpl.ObjCExposedMethods = {
+        swipe: { returns: interop.types.void, params: [interop.types.id] }
+    };
+    return MapSwipeHandlerImpl;
+}(NSObject));
+export * from './common';
+let _markers = [];
+const _markerIconDownloadCache = [];
+const _setMapboxMapOptions = (mapView, settings) => {
+    mapView.logoView.hidden = settings.hideLogo;
+    mapView.attributionButton.hidden = settings.hideAttribution;
+    mapView.compassView.hidden = settings.hideCompass;
+    mapView.rotateEnabled = !settings.disableRotation;
+    mapView.scrollEnabled = !settings.disableScroll;
+    mapView.zoomEnabled = !settings.disableZoom;
+    mapView.allowsTilting = !settings.disableTilt;
+    if (settings.center && settings.center.lat && settings.center.lng) {
+        const centerCoordinate = CLLocationCoordinate2DMake(settings.center.lat, settings.center.lng);
+        mapView.setCenterCoordinateZoomLevelAnimated(centerCoordinate, settings.zoomLevel, false);
     }
-    offMapEvent(eventName, id, nativeMapView) {
-        if (typeof this.eventCallbacks[eventName] == 'undefined') {
-            return;
-        }
-        this.eventCallbacks[eventName] = this.eventCallbacks[eventName].filter((entry) => entry.id !== id);
+    else {
+        mapView.setZoomLevelAnimated(settings.zoomLevel, false);
     }
-    checkForClickEvent(point, nativeMap) {
-        if (Trace.isEnabled()) {
-            CLog(CLogTypes.info, 'Mapbox:checkForClickEvent(): got click event with point:', point);
-        }
-        this.eventCallbacks['click'] &&
-            this.eventCallbacks['click'].forEach((eventListener) => {
-                this.queryRenderedFeatures({ point, layers: [eventListener.id] }, nativeMap)
-                    .then((response) => {
-                    if (response.length > 0) {
-                        eventListener.callback(response);
-                    }
-                })
-                    .catch((err) => {
-                    console.error('click error ', eventListener.id, err);
-                });
-            });
-        this.view && this.view.notify({ eventName: 'mapClick', object: this.view, point });
-        return false;
+    mapView.showsUserLocation = settings.showUserLocation;
+    mapView.autoresizingMask = 2 | 16;
+};
+const _getMapStyle = (input) => {
+    if (input.startsWith('mapbox://styles') || input.startsWith('http://') || input.startsWith('https://')) {
+        return NSURL.URLWithString(input);
     }
-    _addMarkers(markers, nativeMap) {
-        if (!markers) {
-            if (Trace.isEnabled()) {
-                CLog(CLogTypes.info, 'No markers passed');
-            }
-            return;
-        }
-        if (!Array.isArray(markers)) {
-            if (Trace.isEnabled()) {
-                CLog(CLogTypes.info, "markers must be passed as an Array: [{title: 'foo'}]");
-            }
-            return;
-        }
-        const theMap = nativeMap || this._mapboxViewInstance;
-        _downloadMarkerImages(markers).then((updatedMarkers) => {
-            updatedMarkers.forEach((marker) => {
-                const lat = marker.lat;
-                const lng = marker.lng;
-                const point = MGLPointAnnotation.new();
-                point.coordinate = CLLocationCoordinate2DMake(lat, lng);
-                point.title = marker.title;
-                point.subtitle = marker.subtitle;
-                _markers.push(marker);
-                theMap.addAnnotation(point);
-                if (marker.selected) {
-                    theMap.selectAnnotationAnimated(point, false);
-                }
-                marker.ios = point;
-                marker.update = (newSettings) => {
-                    _markers.forEach((_marker) => {
-                        if (marker.id === _marker.id) {
-                            if (newSettings.onTap !== undefined) {
-                                _marker.onTap = newSettings.onTap;
-                            }
-                            if (newSettings.onCalloutTap !== undefined) {
-                                _marker.onCalloutTap = newSettings.onCalloutTap;
-                            }
-                            if (newSettings.title !== undefined) {
-                                _marker.ios.title = _marker.title = newSettings.title;
-                            }
-                            if (newSettings.subtitle !== undefined) {
-                                _marker.ios.subtitle = _marker.subtitle = newSettings.subtitle;
-                            }
-                            if (newSettings.lat && newSettings.lng) {
-                                _marker.lat = newSettings.lat;
-                                _marker.lng = newSettings.lng;
-                                _marker.ios.coordinate = CLLocationCoordinate2DMake(newSettings.lat, newSettings.lng);
-                            }
-                            if (newSettings.selected) {
-                                theMap.selectAnnotationAnimated(_marker.ios, false);
-                            }
-                        }
-                    });
-                };
-            });
-        });
+    else if (input.startsWith('~/')) {
+        return NSURL.URLWithString('file://' + path.join(knownFolders.currentApp().path, input.replace('~/', '')));
     }
-    show(options) {
-        if (Trace.isEnabled()) {
-            CLog(CLogTypes.info, 'show(): top with options:', options);
-        }
-        return new Promise((resolve, reject) => {
-            try {
-                const settings = Mapbox.merge(options, Mapbox.defaults);
-                if (settings.accessToken === undefined) {
-                    reject("Please set the 'accessToken' parameter");
-                    return;
-                }
-                if (this._mapboxViewInstance) {
-                    this._mapboxViewInstance.removeFromSuperview();
-                }
-                const view = UIApplication.sharedApplication.keyWindow.rootViewController.view, frameRect = view.frame, mapFrame = CGRectMake(settings.margins.left, settings.margins.top, frameRect.size.width - settings.margins.left - settings.margins.right, frameRect.size.height - settings.margins.top - settings.margins.bottom), styleURL = _getMapStyle(settings.style);
-                MGLAccountManager.accessToken = settings.accessToken;
-                this._mapboxViewInstance = MGLMapView.alloc().initWithFrameStyleURL(mapFrame, styleURL);
-                _setMapboxMapOptions(this._mapboxViewInstance, settings);
-                this._mapboxViewInstance.delegate = MGLMapViewDelegateImpl.new().initWithCallback((mapView) => {
-                    resolve({
-                        ios: mapView
-                    });
-                });
-                _markers = [];
-                this._addMarkers(settings.markers);
-                setTimeout(() => {
-                    view.addSubview(this._mapboxViewInstance);
-                }, 500);
-            }
-            catch (ex) {
-                if (Trace.isEnabled()) {
-                    CLog(CLogTypes.info, 'Error in mapbox.show: ' + ex);
-                }
-                reject(ex);
-            }
-        });
+    else if (input === MapStyle.LIGHT) {
+        return MGLStyle.lightStyleURL;
     }
-    hide() {
-        return new Promise((resolve, reject) => {
-            try {
-                if (this._mapboxViewInstance) {
-                    this._mapboxViewInstance.removeFromSuperview();
-                }
-                resolve();
-            }
-            catch (ex) {
-                if (Trace.isEnabled()) {
-                    CLog(CLogTypes.info, 'Error in mapbox.hide: ' + ex);
-                }
-                reject(ex);
-            }
-        });
+    else if (input === MapStyle.DARK) {
+        return MGLStyle.darkStyleURL;
     }
-    unhide() {
-        return new Promise((resolve, reject) => {
-            try {
-                if (this._mapboxViewInstance) {
-                    const view = UIApplication.sharedApplication.keyWindow.rootViewController.view;
-                    view.addSubview(this._mapboxViewInstance);
-                    resolve();
-                }
-                else {
-                    reject('No map found');
-                }
-            }
-            catch (ex) {
-                if (Trace.isEnabled()) {
-                    CLog(CLogTypes.info, 'Error in mapbox.unhide: ' + ex);
-                }
-                reject(ex);
-            }
-        });
+    else if (input === MapStyle.OUTDOORS) {
+        return MGLStyle.outdoorsStyleURL;
     }
-    destroy(nativeMap) {
-        return new Promise((resolve, reject) => {
-            const theMap = nativeMap || this._mapboxViewInstance;
-            if (theMap) {
-                theMap.removeFromSuperview();
-                theMap.delegate = null;
-            }
-            resolve();
-        });
+    else if (input === MapStyle.SATELLITE) {
+        return MGLStyle.satelliteStyleURL;
     }
-    onStart(nativeMap) {
-        return Promise.resolve();
+    else if (input === MapStyle.SATELLITE_STREETS) {
+        return MGLStyle.satelliteStreetsStyleURL;
     }
-    onResume(nativeMap) {
-        return Promise.resolve();
+    else if (input === MapStyle.TRAFFIC_DAY) {
+        return NSURL.URLWithString('mapbox://styles/mapbox/traffic-day-v2');
     }
-    onPause(nativeMap) {
-        return Promise.resolve();
+    else if (input === MapStyle.TRAFFIC_NIGHT) {
+        return NSURL.URLWithString('mapbox://styles/mapbox/traffic-night-v2');
     }
-    onStop(nativeMap) {
-        return Promise.resolve();
+    else {
+        return MGLStyle.streetsStyleURL;
     }
-    onLowMemory(nativeMap) {
-        return Promise.resolve();
+};
+function _getTrackingMode(input) {
+    return 0;
+}
+function _getLocation(loc) {
+    if (loc === null) {
+        return null;
     }
-    onDestroy(nativeMap) {
-        return Promise.resolve();
+    else {
+        return {
+            location: {
+                lat: loc.coordinate.latitude,
+                lng: loc.coordinate.longitude
+            },
+            speed: loc.location ? loc.location.speed : 0
+        };
     }
-    setMapStyle(style, nativeMap) {
-        return new Promise((resolve, reject) => {
-            try {
-                const theMap = nativeMap || this._mapboxViewInstance;
-                const delegate = theMap.delegate;
-                delegate.setStyleLoadedCallback((mapView) => {
-                    if (Trace.isEnabled()) {
-                        CLog(CLogTypes.info, 'Mapbox:setMapStyle(): style loaded callback returned.');
-                    }
-                    resolve();
-                });
-                theMap.styleURL = _getMapStyle(style);
-            }
-            catch (ex) {
-                if (Trace.isEnabled()) {
-                    CLog(CLogTypes.info, 'Error in mapbox.setMapStyle: ' + ex);
-                }
-                reject(ex);
-            }
-        });
+}
+export function setLogLevel(level) {
+    let loggingLevel;
+    switch (level) {
+        case 'none':
+            loggingLevel = 0;
+            break;
+        case 'info':
+            loggingLevel = 1;
+            break;
+        case 'verbose':
+        case 'debug':
+            loggingLevel = 2;
+            break;
+        case 'error':
+            loggingLevel = 3;
+            break;
+        case 'fault':
+            loggingLevel = 4;
+            break;
     }
-    async getImage(imageId, nativeMap) {
-        return new Promise((resolve, reject) => {
-            const theMap = nativeMap || this._mapboxViewInstance;
-            if (!theMap) {
-                reject('No map has been loaded');
-                return;
-            }
-            try {
-                const nativeImage = theMap.style.imageForName(imageId);
-                const img = new ImageSource(nativeImage);
-                resolve(img);
-            }
-            catch (ex) {
-                reject('Error during getImage: ' + ex);
-                if (Trace.isEnabled()) {
-                    CLog(CLogTypes.info, 'Error in mapbox.getImage: ' + ex);
-                }
-                throw ex;
-            }
-        });
+    MGLLoggingConfiguration.sharedConfiguration.loggingLevel = loggingLevel;
+}
+export class MapboxView extends MapboxViewBase {
+    constructor() {
+        super(...arguments);
+        this.nativeMapView = null;
+        this.delegate = null;
+        this.settings = null;
+        this.initialized = false;
+        this.initCountHack = 50;
     }
-    async addImage(imageId, image, nativeMap) {
-        return new Promise((resolve, reject) => {
-            const theMap = nativeMap || this._mapboxViewInstance;
-            if (!theMap) {
-                reject('No map has been loaded');
-                return;
-            }
-            if (!image.startsWith('res://')) {
-                const appPath = knownFolders.currentApp().path;
-                image = appPath + '/' + image.replace('~/', '');
-            }
-            const img = ImageSource.fromFileOrResourceSync(image);
-            try {
-                theMap.style.setImageForName(img.ios, imageId);
-                resolve();
-            }
-            catch (ex) {
-                reject('Error during addImage: ' + ex);
-                if (Trace.isEnabled()) {
-                    CLog(CLogTypes.info, 'Error in mapbox.addImage: ' + ex);
-                }
-                throw ex;
-            }
-        });
+    setConfig(settings) {
+        if (Trace.isEnabled()) {
+            CLog(CLogTypes.info, 'setConfig(): settings:', settings);
+        }
+        this.settings = settings;
     }
-    async removeImage(imageId, nativeMap) {
-        return new Promise((resolve, reject) => {
-            const theMap = nativeMap || this._mapboxViewInstance;
-            if (!theMap) {
-                reject('No map has been loaded');
-                return;
-            }
-            try {
-                theMap.style.removeImageForName(imageId);
-                resolve();
-            }
-            catch (ex) {
-                reject('Error during removeImage: ' + ex);
-                if (Trace.isEnabled()) {
-                    CLog(CLogTypes.info, 'Error in mapbox.removeImage: ' + ex);
-                }
-                throw ex;
-            }
-        });
+    getNativeMapView() {
+        return this.nativeMapView;
     }
-    addMarkers(markers, nativeMap) {
-        return new Promise((resolve, reject) => {
-            try {
-                const theMap = nativeMap || this._mapboxViewInstance;
-                this._addMarkers(markers, theMap);
-                resolve();
+    createNativeView() {
+        if (Trace.isEnabled()) {
+            CLog(CLogTypes.info, 'createNativeView(): top');
+        }
+        const v = super.createNativeView();
+        return v;
+    }
+    onLoaded() {
+        super.onLoaded();
+        if (Trace.isEnabled()) {
+            CLog(CLogTypes.info, 'initNativeView(): on - loaded');
+        }
+        if (this.telemetry === false) {
+            NSUserDefaults.standardUserDefaults.setBoolForKey(false, 'MGLMapboxMetricsEnabled');
+        }
+        if (!this.initialized) {
+            this.initMap();
+            this.initialized = true;
+        }
+    }
+    initNativeView() {
+        super.initNativeView();
+        this.nativeView.owner = this;
+    }
+    async disposeNativeView() {
+        if (Trace.isEnabled()) {
+            CLog(CLogTypes.info, 'disposeNativeView(): top');
+        }
+        this.nativeView.owner = null;
+        await this.mapbox.destroy();
+        if (Trace.isEnabled()) {
+            CLog(CLogTypes.info, 'disposeNativeView(): after mapbox.destroy()');
+        }
+        super.disposeNativeView();
+        if (Trace.isEnabled()) {
+            CLog(CLogTypes.info, 'disposeNativeView(): bottom');
+        }
+    }
+    getMapboxApi() {
+        return this.mapbox;
+    }
+    initMap() {
+        if (Trace.isEnabled()) {
+            CLog(CLogTypes.info, 'initMap() top with settings:', this.settings);
+        }
+        if (!this.settings && !this.config.accessToken) {
+            if (Trace.isEnabled()) {
+                CLog(CLogTypes.info, 'initMap() no access token. Race condition on XML property evaluation?');
             }
-            catch (ex) {
-                if (Trace.isEnabled()) {
-                    CLog(CLogTypes.info, 'Error in mapbox.addMarkers: ' + ex);
-                }
-                reject(ex);
+            if (this.initCountHack > 50) {
+                return;
             }
-        });
-    }
-    removeMarkers(ids, nativeMap) {
-        return new Promise((resolve, reject) => {
-            try {
-                const theMap = nativeMap || this._mapboxViewInstance;
-                const markersToRemove = [];
-                _markers.forEach((marker) => {
-                    if (!ids || (marker.id && ids.indexOf(marker.id) > -1)) {
-                        markersToRemove.push(marker.ios);
+            setTimeout(() => {
+                this.initMap();
+            }, 50);
+            this.initCountHack++;
+            return;
+        }
+        if (!this.settings) {
+            this.settings = Mapbox.merge(this.config, Mapbox.defaults);
+        }
+        else {
+            this.settings = Mapbox.merge(this.settings, Mapbox.defaults);
+        }
+        if (!this.nativeMapView) {
+            this.mapbox = new Mapbox(this);
+            if (Trace.isEnabled()) {
+                CLog(CLogTypes.info, 'initMap(): after new Mapbox()');
+            }
+            const drawMap = () => {
+                MGLAccountManager.accessToken = this.settings.accessToken;
+                this.nativeMapView = MGLMapView.alloc().initWithFrameStyleURL(CGRectMake(0, 0, this.nativeView.frame.size.width, this.nativeView.frame.size.height), _getMapStyle(this.settings.style));
+                this.nativeMapView.delegate = this.delegate = MGLMapViewDelegateImpl.new().initWithCallback(() => {
+                    if (Trace.isEnabled()) {
+                        CLog(CLogTypes.info, 'initMap(): MLMapViewDeleteImpl onMapReady callback');
                     }
+                    this.mapbox.setMapboxViewInstance(this.nativeMapView);
+                    this.mapbox.initEventHandlerShim(this.settings, this.nativeMapView);
+                    this.notify({
+                        eventName: MapboxViewBase.mapReadyEvent,
+                        object: this,
+                        map: this,
+                        ios: this.nativeMapView
+                    });
+                    this.notify({
+                        eventName: MapboxViewBase.locationPermissionGrantedEvent,
+                        object: this,
+                        map: this,
+                        ios: this.nativeMapView
+                    });
                 });
-                if (ids) {
-                    _markers = _markers.filter((marker) => ids.indexOf(marker.id) < 0);
-                }
-                else {
-                    _markers = [];
-                }
-                if (markersToRemove.length > 0) {
-                    theMap.removeAnnotations(markersToRemove);
-                }
-                resolve();
+                _setMapboxMapOptions(this.nativeMapView, this.settings);
+                _markers = [];
+                this.nativeView.addSubview(this.nativeMapView);
+                this.mapbox.setOnMoveBeginListener((data) => {
+                    if (Trace.isEnabled()) {
+                        CLog(CLogTypes.info, 'initMap(): onMoveBegin listener');
+                    }
+                    this.notify({
+                        eventName: MapboxViewBase.moveBeginEvent,
+                        object: this,
+                        map: this,
+                        ios: this.nativeMapView
+                    });
+                }, this.nativeMapView);
+                this.mapbox.setOnMoveEndListener((data) => {
+                    if (Trace.isEnabled()) {
+                        CLog(CLogTypes.info, 'initMap(): onMoveEnd listener');
+                    }
+                    this.notify({
+                        eventName: MapboxViewBase.moveEndEvent,
+                        object: this,
+                        map: this,
+                        ios: this.nativeMapView
+                    });
+                }, this.nativeMapView);
+                this.mapbox.setOnScrollListener((data) => {
+                    if (Trace.isEnabled()) {
+                        CLog(CLogTypes.info, 'initMap(): onScroll listener');
+                    }
+                    this.notify({
+                        eventName: MapboxViewBase.scrollEvent,
+                        object: this,
+                        map: this,
+                        ios: this.nativeMapView
+                    });
+                }, this.nativeMapView);
+            };
+            setTimeout(drawMap, this.settings.delay ? this.settings.delay : 0);
+        }
+    }
+    onLayout(left, top, right, bottom) {
+        super.onLayout(left, top, right, bottom);
+        if (this.nativeMapView) {
+            this.nativeMapView.layer.frame = this.ios.layer.bounds;
+        }
+    }
+    [telemetryProperty.setNative](value) {
+        NSUserDefaults.standardUserDefaults.setBoolForKey(false, 'MGLMapboxMetricsEnabled');
+    }
+}
+var CustomUserLocationAnnotationView = /** @class */ (function (_super) {
+    __extends(CustomUserLocationAnnotationView, _super);
+    function CustomUserLocationAnnotationView() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    /**
+     * init
+     *
+     * @link https://docs.nativescript.org/core-concepts/ios-runtime/HelloWorld
+     */
+    CustomUserLocationAnnotationView.prototype.init = function () {
+        this.size = 48;
+        _super.prototype.initWithFrame.call(this, CGRectMake(0, 0, this.size, this.size));
+        this.renderModeChanged = true;
+        this.userLocationRenderMode = 'NORMAL';
+        return this;
+    };
+    /**
+     * update
+     *
+     * The note from the Objective-C sample indicates this method may be called quite
+     * often so it needs to be kept lightweight.
+     */
+    CustomUserLocationAnnotationView.prototype.update = function () {
+        if (CLLocationCoordinate2DIsValid(this.userLocation.coordinate)) {
+            // if it's the first time here, setup the layers that make up the
+            // location marker.
+            if (!this.dot) {
+                this.drawNonTrackingLocationMarker();
             }
-            catch (ex) {
-                if (Trace.isEnabled()) {
-                    CLog(CLogTypes.info, 'Error in mapbox.removeMarkers: ' + ex);
-                }
-                reject(ex);
+            if (this.userLocationRenderMode === 'GPS') {
+                this.updateHeading();
             }
-        });
+        }
+    };
+    /**
+     * Draw the GPS tracking arrow.
+     *
+     * @link https://docs.nativescript.org/ns-framework-modules/color
+     */
+    CustomUserLocationAnnotationView.prototype.drawTrackingLocationMarker = function () {
+        if (Trace.isEnabled()) {
+            CLog(CLogTypes.info, 'CustomerUserLocationAnnotatinView::drawTrackingLocationMarker()');
+        }
+        this.drawTrackingDot();
+        this.drawArrow();
+    }; // end of setupLayers()
+    /**
+     * draw the non-tracking marker
+     */
+    CustomUserLocationAnnotationView.prototype.drawNonTrackingLocationMarker = function () {
+        if (Trace.isEnabled()) {
+            CLog(CLogTypes.info, 'CustomerUserLocationAnnotatinView::drawNonTrackingLocationMarker()');
+        }
+        this.drawNonTrackingDot();
+        if (this.arrow) {
+            this.arrow.removeFromSuperlayer();
+            this.arrow = null;
+        }
+    };
+    /**
+     * draw the tracking dot.
+     */
+    CustomUserLocationAnnotationView.prototype.drawTrackingDot = function () {
+        this.size = 48;
+        // we need to adjust the size of the bounds of the marker. The Tracking marker
+        // is larger than the non tracking marker.
+        this.bounds = CGRectMake(0, 0, this.size, this.size);
+        var dot = CALayer.layer();
+        dot.frame = this.bounds;
+        // user corner radius to turn the layer into a circle
+        dot.cornerRadius = this.size / 2;
+        dot.backgroundColor = this.tintColor.CGColor;
+        dot.borderWidth = 4;
+        var whiteColor = new Color('#FFFFFF');
+        dot.borderColor = whiteColor.ios.CGColor;
+        if (!this.dot) {
+            this.layer.addSublayer(dot);
+        }
+        else {
+            this.layer.replaceSublayerWith(this.dot, dot);
+        }
+        // QUESTION: does GC catch this?
+        this.dot = dot;
+    };
+    /**
+     * draw the non-tracking dot.
+     */
+    CustomUserLocationAnnotationView.prototype.drawNonTrackingDot = function () {
+        this.size = 24;
+        this.bounds = CGRectMake(0, 0, this.size, this.size);
+        var dot = CALayer.layer();
+        dot.frame = this.bounds;
+        // user corner radius to turn the layer into a circle
+        dot.cornerRadius = this.size / 2;
+        dot.backgroundColor = this.tintColor.CGColor;
+        dot.borderWidth = 1;
+        var whiteColor = new Color('#FFFFFF');
+        dot.borderColor = whiteColor.ios.CGColor;
+        if (!this.dot) {
+            this.layer.addSublayer(dot);
+        }
+        else {
+            this.layer.replaceSublayerWith(this.dot, dot);
+        }
+        // QUESTION: does GC catch this?
+        this.dot = dot;
+    };
+    /**
+     * draw an arrow
+     */
+    CustomUserLocationAnnotationView.prototype.drawArrow = function () {
+        var arrow = CAShapeLayer.layer();
+        arrow.path = this.arrowPath();
+        arrow.frame = CGRectMake(0, 0, this.size / 2, this.size / 2);
+        arrow.position = CGPointMake(CGRectGetMidX(this.dot.frame), CGRectGetMidY(this.dot.frame));
+        arrow.fillColor = this.dot.borderColor;
+        if (!this.arrow) {
+            this.layer.addSublayer(arrow);
+        }
+        else {
+            this.layer.replaceSublayerWith(this.arrow, arrow);
+        }
+        // QUESTION: Does GC catch this?
+        this.arrow = arrow;
+    };
+    /**
+     * update arrow heading
+     *
+     * @link https://docs.nativescript.org/core-concepts/ios-runtime/types/C-Functions
+     */
+    CustomUserLocationAnnotationView.prototype.updateHeading = function () {
+        // just to avoid a possible race condition where the arrow isnt' drawn yet
+        if (!this.arrow) {
+            return;
+        }
+        if (typeof this.userLocation == 'undefined') {
+            return;
+        }
+        if (typeof this.userLocation.heading == 'undefined' || this.userLocation.heading === null) {
+            return;
+        }
+        if (typeof this.userLocation.heading.trueHeading == 'undefined' || this.userLocation.heading.trueHeading === null) {
+            return;
+        }
+        if (this.userLocation.heading.trueHeading > 0) {
+            this.arrow.hidden = false;
+            // get the difference between the map's current direction and the
+            // user's heading, then convert it from degrees to radians
+            //
+            // The original Objective-C example uses the inline C function MGLRadiansFromDegrees but because
+            // it's declared as inline it is not available for NativeScript. See linked article above.
+            // let rotation : number = MGLRadiansFromDegrees( this.mapView.direction - this.userLocation.heading.trueHeading );
+            var degrees = this.mapView.direction - this.userLocation.heading.trueHeading;
+            // in radians
+            var rotation = (degrees * Math.PI) / 180;
+            rotation = -rotation;
+            // if the difference would be perceptible, rotate the arrow.
+            if (fabs(rotation) > 0.01) {
+                // Disable implicit animations of this rotation, which reduces lag between updates
+                CATransaction.begin();
+                CATransaction.setDisableActions(true);
+                this.arrow.setAffineTransform(CGAffineTransformRotate(CGAffineTransformIdentity, rotation));
+                CATransaction.commit();
+            }
+        }
+        else {
+            this.arrow.hidden = true;
+        }
+    };
+    /**
+     * Calculate the vector path for an arrow
+     */
+    CustomUserLocationAnnotationView.prototype.arrowPath = function () {
+        var max = this.size / 2;
+        var pad = 3;
+        var top = CGPointMake(max * 0.5, 0);
+        var left = CGPointMake(0 + pad, max - pad);
+        var right = CGPointMake(max - pad, max - pad);
+        var center = CGPointMake(max * 0.5, max * 0.6);
+        var bezierPath = UIBezierPath.bezierPath();
+        bezierPath.moveToPoint(top);
+        bezierPath.addLineToPoint(left);
+        bezierPath.addLineToPoint(center);
+        bezierPath.addLineToPoint(right);
+        bezierPath.addLineToPoint(top);
+        bezierPath.closePath();
+        return bezierPath.CGPath;
+    };
+    /**
+     * change Render mode
+     *
+     * @param {string} renderMode
+     */
+    CustomUserLocationAnnotationView.prototype.changeUserLocationRenderMode = function (renderMode) {
+        if (Trace.isEnabled()) {
+            CLog(CLogTypes.info, "CustomUserLocationAnnotatinView::changeUserLocationRenderMode(): changing mode to '" + renderMode + "'");
+        }
+        this.userLocationRenderMode = renderMode;
+        if (renderMode === 'GPS') {
+            this.drawTrackingLocationMarker();
+        }
+        else {
+            this.drawNonTrackingLocationMarker();
+        }
+    };
+    return CustomUserLocationAnnotationView;
+}(MGLUserLocationAnnotationView));
+export class Mapbox extends MapboxCommon {
+    constructor() {
+        super(...arguments);
+        this.eventCallbacks = {};
     }
-    setCenter(options, nativeMap) {
-        return new Promise((resolve, reject) => {
-            try {
-                const theMap = nativeMap || this._mapboxViewInstance;
-                const animated = options.animated === undefined || options.animated;
-                const coordinate = CLLocationCoordinate2DMake(options.lat, options.lng);
-                theMap.setCenterCoordinateAnimated(coordinate, animated);
-                resolve();
-            }
-            catch (ex) {
-                if (Trace.isEnabled()) {
-                    CLog(CLogTypes.info, 'Error in mapbox.setCenter: ' + ex);
-                }
-                reject(ex);
-            }
-        });
+    setMapboxViewInstance(mapboxViewInstance) {
+        this._mapboxViewInstance = mapboxViewInstance;
     }
-    getCenter(nativeMap) {
-        return new Promise((resolve, reject) => {
-            try {
-                const theMap = nativeMap || this._mapboxViewInstance;
-                const coordinate = theMap.centerCoordinate;
-                resolve({
-                    lat: coordinate.latitude,
-                    lng: coordinate.longitude
-                });
-            }
-            catch (ex) {
-                if (Trace.isEnabled()) {
-                    CLog(CLogTypes.info, 'Error in mapbox.getCenter: ' + ex);
-                }
-                reject(ex);
-            }
-        });
+    initEventHandlerShim(settings, mapboxNativeViewInstance) {
+        if (Trace.isEnabled()) {
+            CLog(CLogTypes.info, 'Mapbox:initEventHandlerShim(): top');
+        }
+        this.setOnMapClickListener((point) => this.checkForClickEvent(point), mapboxNativeViewInstance);
     }
-    setZoomLevel(options, nativeMap) {
-        return new Promise((resolve, reject) => {
-            try {
-                const theMap = nativeMap || this._mapboxViewInstance;
-                const animated = options.animated === undefined || options.animated;
-                const level = options.level;
-                if (level >= 0 && level <= 20) {
-                    theMap.setZoomLevelAnimated(level, animated);
-                    resolve();
-                }
-                else {
-                    reject('invalid ZoomLevel, use any double value from 0 to 20 (like 8.3)');
-                }
-            }
-            catch (ex) {
-                if (Trace.isEnabled()) {
-                    CLog(CLogTypes.info, 'Error in mapbox.setZoomLevel: ' + ex);
-                }
-                reject(ex);
-            }
+    onMapEvent(eventName, id, callback, nativeMapView) {
+        if (typeof this.eventCallbacks[eventName] == 'undefined') {
+            this.eventCallbacks[eventName] = [];
+        }
+        this.eventCallbacks[eventName].push({
+            id,
+            callback
         });
     }
-    getZoomLevel(nativeMap) {
-        return new Promise((resolve, reject) => {
-            try {
-                const theMap = nativeMap || this._mapboxViewInstance;
-                resolve(theMap.zoomLevel);
-            }
-            catch (ex) {
-                if (Trace.isEnabled()) {
-                    CLog(CLogTypes.info, 'Error in mapbox.getZoomLevel: ' + ex);
-                }
-                reject(ex);
-            }
-        });
+    offMapEvent(eventName, id, nativeMapView) {
+        if (typeof this.eventCallbacks[eventName] == 'undefined') {
+            return;
+        }
+        this.eventCallbacks[eventName] = this.eventCallbacks[eventName].filter((entry) => entry.id !== id);
     }
-    setTilt(options, nativeMap) {
-        return new Promise((resolve, reject) => {
-            try {
-                const theMap = nativeMap || this._mapboxViewInstance;
-                const cam = theMap.camera;
-                cam.pitch = options.tilt;
-                const durationMs = options.duration ? options.duration : 5000;
-                theMap.setCameraWithDurationAnimationTimingFunction(cam, durationMs / 1000, CAMediaTimingFunction.functionWithName(kCAMediaTimingFunctionEaseInEaseOut));
-                setTimeout(() => {
-                    resolve();
-                }, durationMs);
-            }
-            catch (ex) {
-                if (Trace.isEnabled()) {
-                    CLog(CLogTypes.info, 'Error in mapbox.setTilt: ' + ex);
-                }
-                reject(ex);
-            }
-        });
+    checkForClickEvent(point, nativeMap) {
+        if (Trace.isEnabled()) {
+            CLog(CLogTypes.info, 'Mapbox:checkForClickEvent(): got click event with point:', point);
+        }
+        this.eventCallbacks['click'] &&
+            this.eventCallbacks['click'].forEach((eventListener) => {
+                this.queryRenderedFeatures({ point, layers: [eventListener.id] }, nativeMap)
+                    .then((response) => {
+                    if (response.length > 0) {
+                        eventListener.callback(response);
+                    }
+                })
+                    .catch((err) => {
+                    console.error('click error ', eventListener.id, err);
+                });
+            });
+        this.view && this.view.notify({ eventName: 'mapClick', object: this.view, point });
+        return false;
     }
-    getTilt(nativeMap) {
-        return new Promise((resolve, reject) => {
-            try {
-                const theMap = nativeMap || this._mapboxViewInstance;
-                resolve(theMap.camera.pitch);
-            }
-            catch (ex) {
-                if (Trace.isEnabled()) {
-                    CLog(CLogTypes.info, 'Error in mapbox.getTilt: ' + ex);
-                }
-                reject(ex);
+    _addMarkers(markers, nativeMap) {
+        if (!markers) {
+            if (Trace.isEnabled()) {
+                CLog(CLogTypes.info, 'No markers passed');
             }
-        });
-    }
-    getUserLocation(nativeMap) {
-        return new Promise((resolve, reject) => {
-            try {
-                const theMap = nativeMap || this._mapboxViewInstance;
-                const loc = theMap.userLocation;
-                if (loc === null) {
-                    reject('Location not available');
-                }
-                else {
-                    resolve(_getLocation(loc));
-                }
+            return;
+        }
+        if (!Array.isArray(markers)) {
+            if (Trace.isEnabled()) {
+                CLog(CLogTypes.info, "markers must be passed as an Array: [{title: 'foo'}]");
             }
-            catch (ex) {
-                if (Trace.isEnabled()) {
-                    CLog(CLogTypes.info, 'Error in mapbox.getUserLocation: ' + ex);
+            return;
+        }
+        const theMap = nativeMap || this._mapboxViewInstance;
+        _downloadMarkerImages(markers).then((updatedMarkers) => {
+            updatedMarkers.forEach((marker) => {
+                const lat = marker.lat;
+                const lng = marker.lng;
+                const point = MGLPointAnnotation.new();
+                point.coordinate = CLLocationCoordinate2DMake(lat, lng);
+                point.title = marker.title;
+                point.subtitle = marker.subtitle;
+                _markers.push(marker);
+                theMap.addAnnotation(point);
+                if (marker.selected) {
+                    theMap.selectAnnotationAnimated(point, false);
                 }
-                reject(ex);
-            }
+                marker.ios = point;
+                marker.update = (newSettings) => {
+                    _markers.forEach((_marker) => {
+                        if (marker.id === _marker.id) {
+                            if (newSettings.onTap !== undefined) {
+                                _marker.onTap = newSettings.onTap;
+                            }
+                            if (newSettings.onCalloutTap !== undefined) {
+                                _marker.onCalloutTap = newSettings.onCalloutTap;
+                            }
+                            if (newSettings.title !== undefined) {
+                                _marker.ios.title = _marker.title = newSettings.title;
+                            }
+                            if (newSettings.subtitle !== undefined) {
+                                _marker.ios.subtitle = _marker.subtitle = newSettings.subtitle;
+                            }
+                            if (newSettings.lat && newSettings.lng) {
+                                _marker.lat = newSettings.lat;
+                                _marker.lng = newSettings.lng;
+                                _marker.ios.coordinate = CLLocationCoordinate2DMake(newSettings.lat, newSettings.lng);
+                            }
+                            if (newSettings.selected) {
+                                theMap.selectAnnotationAnimated(_marker.ios, false);
+                            }
+                        }
+                    });
+                };
+            });
         });
     }
-    _stringToCameraMode(mode) {
-        switch (mode) {
-            case 'NONE':
-                return 0;
-            case 'NONE_COMPASS':
-                if (Trace.isEnabled()) {
-                    CLog(CLogTypes.info, '_stringToCameraMode(): NONE_COMPASS unsupported on iOS');
-                }
-                return 0;
-            case 'NONE_GPS':
-                if (Trace.isEnabled()) {
-                    CLog(CLogTypes.info, '_stringToCameraMode(): NONE_GPS unsupported on iOS');
-                }
-                return 0;
-            case 'TRACKING':
-                return 1;
-            case 'TRACK_COMPASS':
-                return 2;
-            case 'TRACKING_GPS':
-                return 1;
-            case 'TRACK_GPS_NORTH':
-                return 3;
-        }
-    }
-    _stringToRenderMode(mode) {
-        let renderMode;
-        switch (mode) {
-            case 'NORMAL':
-                return 'NORMAL';
-            case 'COMPASS':
-                return 'COMPASS';
-            case 'GPS':
-                return 'GPS';
+    show(options) {
+        if (Trace.isEnabled()) {
+            CLog(CLogTypes.info, 'show(): top with options:', options);
         }
-    }
-    showUserLocationMarker(options, nativeMap) {
         return new Promise((resolve, reject) => {
             try {
-                const theMap = nativeMap || this._mapboxViewInstance;
-                theMap.showsUserLocation = true;
-                theMap.userTrackingMode = this._stringToCameraMode(options.cameraMode);
-                theMap.showsUserHeadingIndicator = true;
-                this.userLocationRenderMode = this._stringToRenderMode(options.renderMode);
-                const delegate = theMap.delegate;
-                delegate.changeUserLocationRenderMode(this.userLocationRenderMode);
-                if (typeof options.clickListener != 'undefined') {
-                    delegate.setUserLocationClickListener(options.clickListener);
+                const settings = Mapbox.merge(options, Mapbox.defaults);
+                if (settings.accessToken === undefined) {
+                    reject("Please set the 'accessToken' parameter");
+                    return;
                 }
-                resolve();
+                if (this._mapboxViewInstance) {
+                    this._mapboxViewInstance.removeFromSuperview();
+                }
+                const view = UIApplication.sharedApplication.keyWindow.rootViewController.view, frameRect = view.frame, mapFrame = CGRectMake(settings.margins.left, settings.margins.top, frameRect.size.width - settings.margins.left - settings.margins.right, frameRect.size.height - settings.margins.top - settings.margins.bottom), styleURL = _getMapStyle(settings.style);
+                MGLAccountManager.accessToken = settings.accessToken;
+                this._mapboxViewInstance = MGLMapView.alloc().initWithFrameStyleURL(mapFrame, styleURL);
+                _setMapboxMapOptions(this._mapboxViewInstance, settings);
+                this._mapboxViewInstance.delegate = MGLMapViewDelegateImpl.new().initWithCallback((mapView) => {
+                    resolve({
+                        ios: mapView
+                    });
+                });
+                _markers = [];
+                this._addMarkers(settings.markers);
+                setTimeout(() => {
+                    view.addSubview(this._mapboxViewInstance);
+                }, 500);
             }
             catch (ex) {
                 if (Trace.isEnabled()) {
-                    CLog(CLogTypes.info, 'Error in mapbox.getUserLocation: ' + ex);
+                    CLog(CLogTypes.info, 'Error in mapbox.show: ' + ex);
                 }
                 reject(ex);
             }
         });
     }
-    hideUserLocationMarker(nativeMap) {
+    hide() {
         return new Promise((resolve, reject) => {
             try {
+                if (this._mapboxViewInstance) {
+                    this._mapboxViewInstance.removeFromSuperview();
+                }
                 resolve();
             }
             catch (ex) {
                 if (Trace.isEnabled()) {
-                    CLog(CLogTypes.info, 'Error in mapbox.getUserLocation: ' + ex);
+                    CLog(CLogTypes.info, 'Error in mapbox.hide: ' + ex);
                 }
                 reject(ex);
             }
         });
     }
-    changeUserLocationMarkerMode(renderModeString, cameraModeString, nativeMap) {
+    unhide() {
         return new Promise((resolve, reject) => {
             try {
-                const theMap = nativeMap || this._mapboxViewInstance;
-                if (Trace.isEnabled()) {
-                    CLog(CLogTypes.info, "Mapbox::changeUserLocationMarkerMode(): changing renderMode to '" + renderModeString + "' cameraMode '" + cameraModeString + "'");
+                if (this._mapboxViewInstance) {
+                    const view = UIApplication.sharedApplication.keyWindow.rootViewController.view;
+                    view.addSubview(this._mapboxViewInstance);
+                    resolve();
+                }
+                else {
+                    reject('No map found');
                 }
-                theMap.userTrackingMode = this._stringToCameraMode(cameraModeString);
-                const delegate = theMap.delegate;
-                const renderMode = this._stringToRenderMode(renderModeString);
-                delegate.changeUserLocationRenderMode(renderMode);
             }
             catch (ex) {
                 if (Trace.isEnabled()) {
-                    CLog(CLogTypes.info, 'Error in mapbox.showUserLocationMarker: ' + ex);
+                    CLog(CLogTypes.info, 'Error in mapbox.unhide: ' + ex);
                 }
                 reject(ex);
             }
         });
     }
-    forceUserLocationUpdate(location, nativeMap) { }
-    queryRenderedFeatures(options, nativeMap) {
+    destroy(nativeMap) {
+        return new Promise((resolve, reject) => {
+            const theMap = nativeMap || this._mapboxViewInstance;
+            if (theMap) {
+                theMap.removeFromSuperview();
+                theMap.delegate = null;
+            }
+            resolve();
+        });
+    }
+    onStart(nativeMap) {
+        return Promise.resolve();
+    }
+    onResume(nativeMap) {
+        return Promise.resolve();
+    }
+    onPause(nativeMap) {
+        return Promise.resolve();
+    }
+    onStop(nativeMap) {
+        return Promise.resolve();
+    }
+    onLowMemory(nativeMap) {
+        return Promise.resolve();
+    }
+    onDestroy(nativeMap) {
+        return Promise.resolve();
+    }
+    setMapStyle(style, nativeMap) {
         return new Promise((resolve, reject) => {
             try {
                 const theMap = nativeMap || this._mapboxViewInstance;
-                if (options.point === undefined) {
-                    reject("Please set the 'point' parameter");
-                    return;
-                }
-                if (!options) {
-                    options = {};
-                }
-                const { x, y } = theMap.convertCoordinateToPointToView({ latitude: options.point.lat, longitude: options.point.lng }, theMap);
-                const queryLayerIds = options.layers ? NSSet.setWithArray(iOSNativeHelper.collections.jsArrayToNSArray(options.layers)) : null;
-                const queryFilter = options.filter ? FilterParser.parseJson(options.filter) : null;
-                const features = theMap.visibleFeaturesAtPointInStyleLayersWithIdentifiersPredicate({ x, y }, queryLayerIds, queryFilter);
-                const result = [];
-                for (let i = 0; i < features.count; i++) {
-                    const feature = features.objectAtIndex(i);
-                    const featureJson = NSJSONSerialization.dataWithJSONObjectOptionsError(feature.geoJSONDictionary(), 0);
-                    result.push(JSON.parse(NSString.alloc().initWithDataEncoding(featureJson, NSUTF8StringEncoding)));
-                }
-                resolve(result);
+                const delegate = theMap.delegate;
+                delegate.setStyleLoadedCallback((mapView) => {
+                    if (Trace.isEnabled()) {
+                        CLog(CLogTypes.info, 'Mapbox:setMapStyle(): style loaded callback returned.');
+                    }
+                    resolve();
+                });
+                theMap.styleURL = _getMapStyle(style);
             }
             catch (ex) {
                 if (Trace.isEnabled()) {
-                    CLog(CLogTypes.info, 'Error in mapbox.queryRenderedFeatures: ' + ex);
+                    CLog(CLogTypes.info, 'Error in mapbox.setMapStyle: ' + ex);
                 }
                 reject(ex);
             }
         });
     }
-    querySourceFeatures(sourceId, options, nativeMap) {
+    async getImage(imageId, nativeMap) {
         return new Promise((resolve, reject) => {
+            const theMap = nativeMap || this._mapboxViewInstance;
+            if (!theMap) {
+                reject('No map has been loaded');
+                return;
+            }
             try {
-                const theMap = nativeMap || this._mapboxViewInstance;
-                if (!options) {
-                    options = {};
-                }
-                const source = theMap.style.sourceWithIdentifier(sourceId);
-                if (!source) {
-                    throw new Error(`Source with id "${sourceId}" not found.`);
-                }
-                let features;
-                const queryFilter = options.filter ? FilterParser.parseJson(options.filter) : null;
-                if (source instanceof MGLShapeSource) {
-                    features = source.featuresMatchingPredicate(queryFilter);
-                }
-                else if (source instanceof MGLVectorTileSource) {
-                    if (!options.sourceLayer) {
-                        throw new Error('The option "sourceLayer" is required for vector sources.');
-                    }
-                    const sourceLayerIds = options.sourceLayer ? NSSet.setWithArray(iOSNativeHelper.collections.jsArrayToNSArray([options.sourceLayer])) : null;
-                    features = source.featuresInSourceLayersWithIdentifiersPredicate(sourceLayerIds, queryFilter);
-                }
-                else {
-                    throw new Error('Only sources from type "vector" or "geojson" are supported.');
-                }
-                const result = [];
-                for (let i = 0; i < features.count; i++) {
-                    const feature = features.objectAtIndex(i);
-                    const featureJson = NSJSONSerialization.dataWithJSONObjectOptionsError(feature.geoJSONDictionary(), 0);
-                    result.push(JSON.parse(NSString.alloc().initWithDataEncoding(featureJson, NSUTF8StringEncoding)));
-                }
-                resolve(result);
+                const nativeImage = theMap.style.imageForName(imageId);
+                const img = new ImageSource(nativeImage);
+                resolve(img);
             }
             catch (ex) {
+                reject('Error during getImage: ' + ex);
                 if (Trace.isEnabled()) {
-                    CLog(CLogTypes.info, 'Error in mapbox.querySourceFeatures: ' + ex);
+                    CLog(CLogTypes.info, 'Error in mapbox.getImage: ' + ex);
                 }
-                reject(ex);
+                throw ex;
             }
         });
     }
-    addPolygon(options, nativeMap) {
+    async addImage(imageId, image, nativeMap) {
         return new Promise((resolve, reject) => {
             const theMap = nativeMap || this._mapboxViewInstance;
-            const points = options.points;
-            if (points === undefined) {
-                reject("Please set the 'points' parameter");
+            if (!theMap) {
+                reject('No map has been loaded');
                 return;
             }
-            const coordinateArray = [];
-            points.forEach((point) => coordinateArray.push([point.lng, point.lat]));
-            const polygonID = `polygon_${options.id || new Date().getTime()}`;
-            if (theMap.style.sourceWithIdentifier(polygonID)) {
-                reject("Remove the polygon with this id first with 'removePolygons': " + polygonID);
-                return;
+            if (!image.startsWith('res://')) {
+                const appPath = knownFolders.currentApp().path;
+                image = appPath + '/' + image.replace('~/', '');
             }
-            const geoJSON = `{
-                "type": "FeatureCollection",
-                "features": [
-                {
-                    "id": ${JSON.stringify(polygonID)},
-                    "type": "Feature",
-                    "properties": {
-                    },
-                    "geometry": {
-                    "type": "Polygon",
-                    "coordinates": [${JSON.stringify(coordinateArray)}]
-                    }
+            const img = ImageSource.fromFileOrResourceSync(image);
+            try {
+                theMap.style.setImageForName(img.ios, imageId);
+                resolve();
+            }
+            catch (ex) {
+                reject('Error during addImage: ' + ex);
+                if (Trace.isEnabled()) {
+                    CLog(CLogTypes.info, 'Error in mapbox.addImage: ' + ex);
                 }
-                ]
-            }`;
-            const geoDataStr = NSString.stringWithString(geoJSON);
-            const geoData = geoDataStr.dataUsingEncoding(NSUTF8StringEncoding);
-            const geoDataBase64Enc = geoData.base64EncodedStringWithOptions(0);
-            const geo = NSData.alloc().initWithBase64EncodedStringOptions(geoDataBase64Enc, null);
-            const shape = MGLShape.shapeWithDataEncodingError(geo, NSUTF8StringEncoding);
-            const source = MGLShapeSource.alloc().initWithIdentifierShapeOptions(polygonID, shape, null);
-            theMap.style.addSource(source);
-            if (options.strokeColor || options.strokeWidth || options.strokeOpacity) {
-                const strokeLayer = MGLLineStyleLayer.alloc().initWithIdentifierSource(polygonID + '_stroke', source);
-                strokeLayer.lineColor = NSExpression.expressionForConstantValue(!options.strokeColor ? UIColor.blackColor : options.strokeColor instanceof Color ? options.strokeColor.ios : new Color(options.strokeColor).ios);
-                strokeLayer.lineWidth = NSExpression.expressionForConstantValue(options.strokeWidth || 5);
-                strokeLayer.lineOpacity = NSExpression.expressionForConstantValue(options.strokeOpacity === undefined ? 1 : options.strokeOpacity);
-                theMap.style.addLayer(strokeLayer);
+                throw ex;
             }
-            const layer = MGLFillStyleLayer.alloc().initWithIdentifierSource(polygonID, source);
-            layer.fillColor = NSExpression.expressionForConstantValue(!options.fillColor ? UIColor.blackColor : options.fillColor instanceof Color ? options.fillColor.ios : new Color(options.fillColor).ios);
-            layer.fillOpacity = NSExpression.expressionForConstantValue(options.fillOpacity === undefined ? 1 : options.fillOpacity);
-            theMap.style.addLayer(layer);
-            resolve();
         });
     }
-    addPolyline(options, nativeMap) {
+    async removeImage(imageId, nativeMap) {
         return new Promise((resolve, reject) => {
             const theMap = nativeMap || this._mapboxViewInstance;
-            const points = options.points;
-            if (points === undefined) {
-                reject("Please set the 'points' parameter");
+            if (!theMap) {
+                reject('No map has been loaded');
                 return;
             }
-            const coordinateArray = [];
-            points.forEach((point) => coordinateArray.push([point.lng, point.lat]));
-            const polylineID = 'polyline_' + (options.id || new Date().getTime());
-            if (theMap.style.sourceWithIdentifier(polylineID)) {
-                reject("Remove the polyline with this id first with 'removePolylines': " + polylineID);
-                return;
+            try {
+                theMap.style.removeImageForName(imageId);
+                resolve();
+            }
+            catch (ex) {
+                reject('Error during removeImage: ' + ex);
+                if (Trace.isEnabled()) {
+                    CLog(CLogTypes.info, 'Error in mapbox.removeImage: ' + ex);
+                }
+                throw ex;
             }
-            const geoJSON = `{"type": "FeatureCollection", "features": [{"type": "Feature","properties": {},"geometry": {"type": "LineString", "coordinates": ${JSON.stringify(coordinateArray)}}}]}`;
-            const geoDataStr = NSString.stringWithString(geoJSON);
-            const geoData = geoDataStr.dataUsingEncoding(NSUTF8StringEncoding);
-            const geoDataBase64Enc = geoData.base64EncodedStringWithOptions(0);
-            const geo = NSData.alloc().initWithBase64EncodedStringOptions(geoDataBase64Enc, null);
-            const shape = MGLShape.shapeWithDataEncodingError(geo, NSUTF8StringEncoding);
-            const source = MGLShapeSource.alloc().initWithIdentifierShapeOptions(polylineID, shape, null);
-            theMap.style.addSource(source);
-            const layer = MGLLineStyleLayer.alloc().initWithIdentifierSource(polylineID, source);
-            layer.lineColor = NSExpression.expressionForConstantValue(!options.color ? UIColor.blackColor : options.color instanceof Color ? options.color.ios : new Color(options.color).ios);
-            layer.lineWidth = NSExpression.expressionForConstantValue(options.width || 5);
-            layer.lineOpacity = NSExpression.expressionForConstantValue(options.opacity === undefined ? 1 : options.opacity);
-            theMap.style.addLayer(layer);
-            resolve();
-        });
-    }
-    removePolyById(theMap, id) {
-        let layer = theMap.style.layerWithIdentifier(id);
-        if (layer !== null) {
-            theMap.style.removeLayer(layer);
-        }
-        layer = theMap.style.layerWithIdentifier(id + '_stroke');
-        if (layer !== null) {
-            theMap.style.removeLayer(layer);
-        }
-        const source = theMap.style.sourceWithIdentifier(id);
-        if (source !== null) {
-            theMap.style.removeSource(source);
-        }
-    }
-    removePolys(polyType, ids, nativeMap) {
-        return new Promise((resolve) => {
-            const theMap = nativeMap || this._mapboxViewInstance;
-            ids.forEach((id) => this.removePolyById(theMap, polyType + id));
-            resolve();
         });
     }
-    removePolygons(ids, nativeMap) {
-        return this.removePolys('polygon_', ids, nativeMap);
-    }
-    removePolylines(ids, nativeMap) {
-        return this.removePolys('polyline_', ids, nativeMap);
-    }
-    animateCamera(options, nativeMap) {
+    addMarkers(markers, nativeMap) {
         return new Promise((resolve, reject) => {
             try {
                 const theMap = nativeMap || this._mapboxViewInstance;
-                let cam;
-                if (options.bounds) {
-                    const padding = options.padding || 0;
-                    const insets = {
-                        top: padding,
-                        left: padding,
-                        bottom: padding,
-                        right: padding
-                    };
-                    const bounds = {
-                        sw: CLLocationCoordinate2DMake(options.bounds.south, options.bounds.west),
-                        ne: CLLocationCoordinate2DMake(options.bounds.north, options.bounds.east)
-                    };
-                    cam = theMap.cameraThatFitsCoordinateBoundsEdgePadding(bounds, insets);
+                this._addMarkers(markers, theMap);
+                resolve();
+            }
+            catch (ex) {
+                if (Trace.isEnabled()) {
+                    CLog(CLogTypes.info, 'Error in mapbox.addMarkers: ' + ex);
                 }
-                else {
-                    const target = options.target;
-                    if (target === undefined) {
-                        reject("Please set the 'target' parameter");
-                        return;
+                reject(ex);
+            }
+        });
+    }
+    removeMarkers(ids, nativeMap) {
+        return new Promise((resolve, reject) => {
+            try {
+                const theMap = nativeMap || this._mapboxViewInstance;
+                const markersToRemove = [];
+                _markers.forEach((marker) => {
+                    if (!ids || (marker.id && ids.indexOf(marker.id) > -1)) {
+                        markersToRemove.push(marker.ios);
                     }
-                    cam = theMap.camera;
-                    cam.centerCoordinate = CLLocationCoordinate2DMake(target.lat, target.lng);
+                });
+                if (ids) {
+                    _markers = _markers.filter((marker) => ids.indexOf(marker.id) < 0);
                 }
-                if (options.altitude) {
-                    cam.altitude = options.altitude;
+                else {
+                    _markers = [];
                 }
-                if (options.bearing) {
-                    cam.heading = options.bearing;
+                if (markersToRemove.length > 0) {
+                    theMap.removeAnnotations(markersToRemove);
                 }
-                if (options.tilt) {
-                    cam.pitch = options.tilt;
+                resolve();
+            }
+            catch (ex) {
+                if (Trace.isEnabled()) {
+                    CLog(CLogTypes.info, 'Error in mapbox.removeMarkers: ' + ex);
                 }
-                if (options.zoomLevel && options.target) {
-                    cam.altitude = MGLAltitudeForZoomLevel(options.zoomLevel, cam.pitch, options.target.lat, theMap.frame.size);
+                reject(ex);
+            }
+        });
+    }
+    setCenter(options, nativeMap) {
+        return new Promise((resolve, reject) => {
+            try {
+                const theMap = nativeMap || this._mapboxViewInstance;
+                const animated = options.animated === undefined || options.animated;
+                const coordinate = CLLocationCoordinate2DMake(options.lat, options.lng);
+                theMap.setCenterCoordinateAnimated(coordinate, animated);
+                resolve();
+            }
+            catch (ex) {
+                if (Trace.isEnabled()) {
+                    CLog(CLogTypes.info, 'Error in mapbox.setCenter: ' + ex);
                 }
-                const durationMs = options.duration ? options.duration : 10000;
-                theMap.setCameraWithDurationAnimationTimingFunction(cam, durationMs / 1000, CAMediaTimingFunction.functionWithName(kCAMediaTimingFunctionEaseInEaseOut));
-                setTimeout(() => {
-                    resolve();
-                }, durationMs);
+                reject(ex);
+            }
+        });
+    }
+    getCenter(nativeMap) {
+        return new Promise((resolve, reject) => {
+            try {
+                const theMap = nativeMap || this._mapboxViewInstance;
+                const coordinate = theMap.centerCoordinate;
+                resolve({
+                    lat: coordinate.latitude,
+                    lng: coordinate.longitude
+                });
             }
             catch (ex) {
                 if (Trace.isEnabled()) {
-                    CLog(CLogTypes.info, 'Error in mapbox.animateCamera: ' + ex);
+                    CLog(CLogTypes.info, 'Error in mapbox.getCenter: ' + ex);
                 }
                 reject(ex);
             }
         });
     }
-    setOnMapClickListener(listener, nativeMap) {
+    setZoomLevel(options, nativeMap) {
         return new Promise((resolve, reject) => {
             try {
                 const theMap = nativeMap || this._mapboxViewInstance;
-                if (!theMap) {
-                    reject('No map has been loaded');
-                    return;
+                const animated = options.animated === undefined || options.animated;
+                const level = options.level;
+                if (level >= 0 && level <= 20) {
+                    theMap.setZoomLevelAnimated(level, animated);
+                    resolve();
                 }
-                theMap['mapTapHandler'] = MapTapHandlerImpl.initWithOwnerAndListenerForMap(new WeakRef(this), listener, theMap);
-                const tapGestureRecognizer = UITapGestureRecognizer.alloc().initWithTargetAction(theMap['mapTapHandler'], 'tap');
-                for (let i = 0; i < theMap.gestureRecognizers.count; i++) {
-                    const recognizer = theMap.gestureRecognizers.objectAtIndex(i);
-                    if (recognizer instanceof UITapGestureRecognizer) {
-                        tapGestureRecognizer.requireGestureRecognizerToFail(recognizer);
-                    }
+                else {
+                    reject('invalid ZoomLevel, use any double value from 0 to 20 (like 8.3)');
                 }
-                theMap.addGestureRecognizer(tapGestureRecognizer);
-                resolve();
             }
             catch (ex) {
                 if (Trace.isEnabled()) {
-                    CLog(CLogTypes.info, 'Error in mapbox.setOnMapClickListener: ' + ex);
+                    CLog(CLogTypes.info, 'Error in mapbox.setZoomLevel: ' + ex);
                 }
                 reject(ex);
             }
         });
     }
-    setOnMapLongClickListener(listener, nativeMap) {
+    getZoomLevel(nativeMap) {
         return new Promise((resolve, reject) => {
             try {
                 const theMap = nativeMap || this._mapboxViewInstance;
-                if (!theMap) {
-                    reject('No map has been loaded');
-                    return;
+                resolve(theMap.zoomLevel);
+            }
+            catch (ex) {
+                if (Trace.isEnabled()) {
+                    CLog(CLogTypes.info, 'Error in mapbox.getZoomLevel: ' + ex);
                 }
-                theMap['mapLongPressHandler'] = MapLongPressHandlerImpl.initWithOwnerAndListenerForMap(new WeakRef(this), listener, theMap);
-                const longPressGestureRecognizer = UILongPressGestureRecognizer.alloc().initWithTargetAction(theMap['mapLongPressHandler'], 'longPress');
-                for (let i = 0; i < theMap.gestureRecognizers.count; i++) {
-                    const recognizer = theMap.gestureRecognizers.objectAtIndex(i);
-                    if (recognizer instanceof UILongPressGestureRecognizer) {
-                        longPressGestureRecognizer.requireGestureRecognizerToFail(recognizer);
-                    }
+                reject(ex);
+            }
+        });
+    }
+    setTilt(options, nativeMap) {
+        return new Promise((resolve, reject) => {
+            try {
+                const theMap = nativeMap || this._mapboxViewInstance;
+                const cam = theMap.camera;
+                cam.pitch = options.tilt;
+                const durationMs = options.duration ? options.duration : 5000;
+                theMap.setCameraWithDurationAnimationTimingFunction(cam, durationMs / 1000, CAMediaTimingFunction.functionWithName(kCAMediaTimingFunctionEaseInEaseOut));
+                setTimeout(() => {
+                    resolve();
+                }, durationMs);
+            }
+            catch (ex) {
+                if (Trace.isEnabled()) {
+                    CLog(CLogTypes.info, 'Error in mapbox.setTilt: ' + ex);
                 }
-                theMap.addGestureRecognizer(longPressGestureRecognizer);
-                resolve();
+                reject(ex);
+            }
+        });
+    }
+    getTilt(nativeMap) {
+        return new Promise((resolve, reject) => {
+            try {
+                const theMap = nativeMap || this._mapboxViewInstance;
+                resolve(theMap.camera.pitch);
             }
             catch (ex) {
                 if (Trace.isEnabled()) {
-                    CLog(CLogTypes.info, 'Error in mapbox.setOnMapClickListener: ' + ex);
+                    CLog(CLogTypes.info, 'Error in mapbox.getTilt: ' + ex);
                 }
                 reject(ex);
             }
         });
     }
-    setOnScrollListener(listener, nativeMap) {
+    getUserLocation(nativeMap) {
         return new Promise((resolve, reject) => {
             try {
                 const theMap = nativeMap || this._mapboxViewInstance;
-                if (!theMap) {
-                    reject('No map has been loaded');
-                    return;
+                const loc = theMap.userLocation;
+                if (loc === null) {
+                    reject('Location not available');
                 }
-                theMap['mapPanHandler'] = MapPanHandlerImpl.initWithOwnerAndListenerForMap(new WeakRef(this), listener, theMap);
-                for (let i = 0; i < theMap.gestureRecognizers.count; i++) {
-                    const recognizer = theMap.gestureRecognizers.objectAtIndex(i);
-                    if (recognizer instanceof UIPanGestureRecognizer) {
-                        recognizer.addTargetAction(theMap['mapPanHandler'], 'pan');
-                        break;
-                    }
+                else {
+                    resolve(_getLocation(loc));
                 }
-                resolve();
             }
             catch (ex) {
                 if (Trace.isEnabled()) {
-                    CLog(CLogTypes.info, 'Error in mapbox.setOnScrollListener: ' + ex);
+                    CLog(CLogTypes.info, 'Error in mapbox.getUserLocation: ' + ex);
                 }
                 reject(ex);
             }
         });
     }
-    setOnMoveBeginListener(listener, nativeMap) {
+    _stringToCameraMode(mode) {
+        switch (mode) {
+            case 'NONE':
+                return 0;
+            case 'NONE_COMPASS':
+                if (Trace.isEnabled()) {
+                    CLog(CLogTypes.info, '_stringToCameraMode(): NONE_COMPASS unsupported on iOS');
+                }
+                return 0;
+            case 'NONE_GPS':
+                if (Trace.isEnabled()) {
+                    CLog(CLogTypes.info, '_stringToCameraMode(): NONE_GPS unsupported on iOS');
+                }
+                return 0;
+            case 'TRACKING':
+                return 1;
+            case 'TRACKING_COMPASS':
+                return 2;
+            case 'TRACKING_GPS':
+                return 1;
+            case 'TRACKING_GPS_NORTH':
+                return 3;
+        }
+    }
+    _stringToRenderMode(mode) {
+        let renderMode;
+        switch (mode) {
+            case 'NORMAL':
+                return 'NORMAL';
+            case 'COMPASS':
+                return 'COMPASS';
+            case 'GPS':
+                return 'GPS';
+        }
+    }
+    showUserLocationMarker(options, nativeMap) {
         return new Promise((resolve, reject) => {
             try {
                 const theMap = nativeMap || this._mapboxViewInstance;
-                if (!theMap) {
-                    reject('No map has been loaded');
-                    return;
+                theMap.showsUserLocation = true;
+                theMap.userTrackingMode = this._stringToCameraMode(options.cameraMode);
+                theMap.showsUserHeadingIndicator = true;
+                this.userLocationRenderMode = this._stringToRenderMode(options.renderMode);
+                const delegate = theMap.delegate;
+                delegate.changeUserLocationRenderMode(this.userLocationRenderMode);
+                if (typeof options.clickListener != 'undefined') {
+                    delegate.setUserLocationClickListener(options.clickListener);
                 }
-                theMap['mapOnMoveBeginHandler'] = MapPanHandlerImpl.initWithOwnerAndListenerForMap(new WeakRef(this), listener, theMap);
-                theMap['mapOnMoveBeginHandler'].setOnMoveBegin();
-                for (let i = 0; i < theMap.gestureRecognizers.count; i++) {
-                    const recognizer = theMap.gestureRecognizers.objectAtIndex(i);
-                    if (recognizer instanceof UIPanGestureRecognizer) {
-                        recognizer.addTargetAction(theMap['mapOnMoveBeginHandler'], 'pan');
-                        break;
-                    }
+                resolve();
+            }
+            catch (ex) {
+                if (Trace.isEnabled()) {
+                    CLog(CLogTypes.info, 'Error in mapbox.getUserLocation: ' + ex);
                 }
+                reject(ex);
+            }
+        });
+    }
+    hideUserLocationMarker(nativeMap) {
+        return new Promise((resolve, reject) => {
+            try {
                 resolve();
             }
             catch (ex) {
                 if (Trace.isEnabled()) {
-                    CLog(CLogTypes.info, 'Error in mapbox.setOnScrollListener: ' + ex);
+                    CLog(CLogTypes.info, 'Error in mapbox.getUserLocation: ' + ex);
                 }
                 reject(ex);
             }
         });
     }
-    setOnFlingListener(listener, nativeMap) {
-        return Promise.reject("'setOnFlingListener' is not supported on iOS");
-    }
-    async setOnCameraMoveListener(listener, nativeMap) {
-        const theMap = nativeMap || this._mapboxViewInstance;
-        if (theMap) {
-            theMap.delegate.setCameraChangedListener(listener);
-        }
-        else {
-            return Promise.reject('No map has been loaded');
-        }
-    }
-    setOnCameraMoveCancelListener(listener, nativeMap) {
-        return Promise.reject("'setOnCameraMoveCancelListener' not currently supported on iOS");
-    }
-    async setOnCameraIdleListener(listener, nativeMap) {
-        const theMap = nativeMap || this._mapboxViewInstance;
-        if (theMap) {
-            theMap.delegate.setCameraIdledListener(listener);
-        }
-        else {
-            return Promise.reject('No map has been loaded');
-        }
-    }
-    getViewport(nativeMap) {
+    changeUserLocationMarkerMode(renderModeString, cameraModeString, nativeMap) {
         return new Promise((resolve, reject) => {
             try {
                 const theMap = nativeMap || this._mapboxViewInstance;
-                if (!theMap) {
-                    reject('No map has been loaded');
-                    return;
+                if (Trace.isEnabled()) {
+                    CLog(CLogTypes.info, "Mapbox::changeUserLocationMarkerMode(): changing renderMode to '" + renderModeString + "' cameraMode '" + cameraModeString + "'");
                 }
-                const visibleBounds = theMap.visibleCoordinateBounds;
-                const bounds = {
-                    north: visibleBounds.ne.latitude,
-                    east: visibleBounds.ne.longitude,
-                    south: visibleBounds.sw.latitude,
-                    west: visibleBounds.sw.longitude
-                };
-                resolve({
-                    bounds,
-                    zoomLevel: theMap.zoomLevel
-                });
+                theMap.userTrackingMode = this._stringToCameraMode(cameraModeString);
+                const delegate = theMap.delegate;
+                const renderMode = this._stringToRenderMode(renderModeString);
+                delegate.changeUserLocationRenderMode(renderMode);
             }
             catch (ex) {
                 if (Trace.isEnabled()) {
-                    CLog(CLogTypes.info, 'Error in mapbox.getViewport: ' + ex);
+                    CLog(CLogTypes.info, 'Error in mapbox.showUserLocationMarker: ' + ex);
                 }
                 reject(ex);
             }
         });
     }
-    setViewport(options, nativeMap) {
+    forceUserLocationUpdate(location, nativeMap) { }
+    queryRenderedFeatures(options, nativeMap) {
         return new Promise((resolve, reject) => {
             try {
                 const theMap = nativeMap || this._mapboxViewInstance;
-                if (!theMap) {
-                    reject('No map has been loaded');
+                if (options.point === undefined) {
+                    reject("Please set the 'point' parameter");
                     return;
                 }
-                const bounds = {
-                    sw: CLLocationCoordinate2DMake(options.bounds.south, options.bounds.west),
-                    ne: CLLocationCoordinate2DMake(options.bounds.north, options.bounds.east)
-                };
-                const animated = options.animated === undefined || options.animated;
-                const padding = options.padding !== undefined ? { top: options.padding, left: options.padding, bottom: options.padding, right: options.padding } : { top: 25, left: 25, bottom: 25, right: 25 };
-                theMap.setVisibleCoordinateBoundsEdgePaddingAnimated(bounds, padding, animated);
-                resolve();
+                if (!options) {
+                    options = {};
+                }
+                const { x, y } = theMap.convertCoordinateToPointToView({ latitude: options.point.lat, longitude: options.point.lng }, theMap);
+                const queryLayerIds = options.layers ? NSSet.setWithArray(Utils.ios.collections.jsArrayToNSArray(options.layers)) : null;
+                const queryFilter = options.filter ? ExpressionParser.parseJson(options.filter) : null;
+                const features = theMap.visibleFeaturesAtPointInStyleLayersWithIdentifiersPredicate({ x, y }, queryLayerIds, queryFilter);
+                const result = [];
+                for (let i = 0; i < features.count; i++) {
+                    const feature = features.objectAtIndex(i);
+                    const featureJson = NSJSONSerialization.dataWithJSONObjectOptionsError(feature.geoJSONDictionary(), 0);
+                    result.push(JSON.parse(NSString.alloc().initWithDataEncoding(featureJson, NSUTF8StringEncoding)));
+                }
+                resolve(result);
             }
             catch (ex) {
                 if (Trace.isEnabled()) {
-                    CLog(CLogTypes.info, 'Error in mapbox.setViewport: ' + ex);
+                    CLog(CLogTypes.info, 'Error in mapbox.queryRenderedFeatures: ' + ex);
                 }
                 reject(ex);
             }
         });
     }
-    downloadOfflineRegion(options) {
+    querySourceFeatures(sourceId, options, nativeMap) {
         return new Promise((resolve, reject) => {
             try {
-                const styleURL = _getMapStyle(options.style);
-                const swCoordinate = CLLocationCoordinate2DMake(options.bounds.south, options.bounds.west);
-                const neCoordinate = CLLocationCoordinate2DMake(options.bounds.north, options.bounds.east);
-                const bounds = {
-                    sw: swCoordinate,
-                    ne: neCoordinate
-                };
-                const region = MGLTilePyramidOfflineRegion.alloc().initWithStyleURLBoundsFromZoomLevelToZoomLevel(styleURL, bounds, options.minZoom, options.maxZoom);
-                if (options.accessToken) {
-                    MGLAccountManager.accessToken = options.accessToken;
+                const theMap = nativeMap || this._mapboxViewInstance;
+                if (!options) {
+                    options = {};
                 }
-                if (options.onProgress) {
-                    _addObserver(MGLOfflinePackProgressChangedNotification, (notification) => {
-                        const offlinePack = notification.object;
-                        const offlinePackProgress = offlinePack.progress;
-                        const userInfo = NSKeyedUnarchiver.unarchiveObjectWithData(offlinePack.context);
-                        const complete = offlinePackProgress.countOfResourcesCompleted === offlinePackProgress.countOfResourcesExpected;
-                        options.onProgress({
-                            name: userInfo.objectForKey('name'),
-                            completed: offlinePackProgress.countOfResourcesCompleted,
-                            expected: offlinePackProgress.countOfResourcesExpected,
-                            percentage: Math.round((offlinePackProgress.countOfResourcesCompleted / offlinePackProgress.countOfResourcesExpected) * 10000) / 100,
-                            complete
-                        });
-                        if (complete) {
-                            resolve();
-                        }
-                    });
+                const source = theMap.style.sourceWithIdentifier(sourceId);
+                if (!source) {
+                    throw new Error(`Source with id "${sourceId}" not found.`);
                 }
-                _addObserver(MGLOfflinePackErrorNotification, (notification) => {
-                    const offlinePack = notification.object;
-                    const userInfo = NSKeyedUnarchiver.unarchiveObjectWithData(offlinePack.context);
-                    const error = notification.userInfo[MGLOfflinePackUserInfoKeyError];
-                    reject({
-                        name: userInfo.objectForKey('name'),
-                        error: 'Download error. ' + error
-                    });
-                });
-                _addObserver(MGLOfflinePackMaximumMapboxTilesReachedNotification, (notification) => {
-                    const offlinePack = notification.object;
-                    const userInfo = NSKeyedUnarchiver.unarchiveObjectWithData(offlinePack.context);
-                    const maximumCount = notification.userInfo[MGLOfflinePackUserInfoKeyMaximumCount];
-                    console.log(`Offline region '${userInfo.objectForKey('name')}' reached the tile limit of ${maximumCount}`);
-                });
-                const userInfo = { name: options.name };
-                const context = NSKeyedArchiver.archivedDataWithRootObject(userInfo);
-                MGLOfflineStorage.sharedOfflineStorage.addPackForRegionWithContextCompletionHandler(region, context, (pack, error) => {
-                    if (error) {
-                        reject(error.localizedFailureReason);
-                    }
-                    else {
-                        pack.resume();
+                let features;
+                const queryFilter = options.filter ? ExpressionParser.parseJson(options.filter) : null;
+                if (source instanceof MGLShapeSource) {
+                    features = source.featuresMatchingPredicate(queryFilter);
+                }
+                else if (source instanceof MGLVectorTileSource) {
+                    if (!options.sourceLayer) {
+                        throw new Error('The option "sourceLayer" is required for vector sources.');
                     }
-                });
+                    const sourceLayerIds = options.sourceLayer ? NSSet.setWithArray(Utils.ios.collections.jsArrayToNSArray([options.sourceLayer])) : null;
+                    features = source.featuresInSourceLayersWithIdentifiersPredicate(sourceLayerIds, queryFilter);
+                }
+                else {
+                    throw new Error('Only sources from type "vector" or "geojson" are supported.');
+                }
+                const result = [];
+                for (let i = 0; i < features.count; i++) {
+                    const feature = features.objectAtIndex(i);
+                    const featureJson = NSJSONSerialization.dataWithJSONObjectOptionsError(feature.geoJSONDictionary(), 0);
+                    result.push(JSON.parse(NSString.alloc().initWithDataEncoding(featureJson, NSUTF8StringEncoding)));
+                }
+                resolve(result);
             }
             catch (ex) {
                 if (Trace.isEnabled()) {
-                    CLog(CLogTypes.info, 'Error in mapbox.downloadOfflineRegion: ' + ex);
+                    CLog(CLogTypes.info, 'Error in mapbox.querySourceFeatures: ' + ex);
                 }
                 reject(ex);
             }
         });
     }
-    listOfflineRegions(options) {
+    addPolygon(options, nativeMap) {
+        return new Promise((resolve, reject) => {
+            const theMap = nativeMap || this._mapboxViewInstance;
+            const points = options.points;
+            if (points === undefined) {
+                reject("Please set the 'points' parameter");
+                return;
+            }
+            const coordinateArray = [];
+            points.forEach((point) => coordinateArray.push([point.lng, point.lat]));
+            const polygonID = `polygon_${options.id || new Date().getTime()}`;
+            if (theMap.style.sourceWithIdentifier(polygonID)) {
+                reject("Remove the polygon with this id first with 'removePolygons': " + polygonID);
+                return;
+            }
+            const geoJSON = `{
+                "type": "FeatureCollection",
+                "features": [
+                {
+                    "id": ${JSON.stringify(polygonID)},
+                    "type": "Feature",
+                    "properties": {
+                    },
+                    "geometry": {
+                    "type": "Polygon",
+                    "coordinates": [${JSON.stringify(coordinateArray)}]
+                    }
+                }
+                ]
+            }`;
+            const geoDataStr = NSString.stringWithString(geoJSON);
+            const geoData = geoDataStr.dataUsingEncoding(NSUTF8StringEncoding);
+            const geoDataBase64Enc = geoData.base64EncodedStringWithOptions(0);
+            const geo = NSData.alloc().initWithBase64EncodedStringOptions(geoDataBase64Enc, null);
+            const shape = MGLShape.shapeWithDataEncodingError(geo, NSUTF8StringEncoding);
+            const source = MGLShapeSource.alloc().initWithIdentifierShapeOptions(polygonID, shape, null);
+            theMap.style.addSource(source);
+            if (options.strokeColor || options.strokeWidth || options.strokeOpacity) {
+                const strokeLayer = MGLLineStyleLayer.alloc().initWithIdentifierSource(polygonID + '_stroke', source);
+                strokeLayer.lineColor = NSExpression.expressionForConstantValue(!options.strokeColor ? UIColor.blackColor : options.strokeColor instanceof Color ? options.strokeColor.ios : new Color(options.strokeColor).ios);
+                strokeLayer.lineWidth = NSExpression.expressionForConstantValue(options.strokeWidth || 5);
+                strokeLayer.lineOpacity = NSExpression.expressionForConstantValue(options.strokeOpacity === undefined ? 1 : options.strokeOpacity);
+                theMap.style.addLayer(strokeLayer);
+            }
+            const layer = MGLFillStyleLayer.alloc().initWithIdentifierSource(polygonID, source);
+            layer.fillColor = NSExpression.expressionForConstantValue(!options.fillColor ? UIColor.blackColor : options.fillColor instanceof Color ? options.fillColor.ios : new Color(options.fillColor).ios);
+            layer.fillOpacity = NSExpression.expressionForConstantValue(options.fillOpacity === undefined ? 1 : options.fillOpacity);
+            theMap.style.addLayer(layer);
+            resolve();
+        });
+    }
+    addPolyline(options, nativeMap) {
+        return new Promise((resolve, reject) => {
+            const theMap = nativeMap || this._mapboxViewInstance;
+            const points = options.points;
+            if (points === undefined) {
+                reject("Please set the 'points' parameter");
+                return;
+            }
+            const coordinateArray = [];
+            points.forEach((point) => coordinateArray.push([point.lng, point.lat]));
+            const polylineID = 'polyline_' + (options.id || new Date().getTime());
+            if (theMap.style.sourceWithIdentifier(polylineID)) {
+                reject("Remove the polyline with this id first with 'removePolylines': " + polylineID);
+                return;
+            }
+            const geoJSON = `{"type": "FeatureCollection", "features": [{"type": "Feature","properties": {},"geometry": {"type": "LineString", "coordinates": ${JSON.stringify(coordinateArray)}}}]}`;
+            const geoDataStr = NSString.stringWithString(geoJSON);
+            const geoData = geoDataStr.dataUsingEncoding(NSUTF8StringEncoding);
+            const geoDataBase64Enc = geoData.base64EncodedStringWithOptions(0);
+            const geo = NSData.alloc().initWithBase64EncodedStringOptions(geoDataBase64Enc, null);
+            const shape = MGLShape.shapeWithDataEncodingError(geo, NSUTF8StringEncoding);
+            const source = MGLShapeSource.alloc().initWithIdentifierShapeOptions(polylineID, shape, null);
+            theMap.style.addSource(source);
+            const layer = MGLLineStyleLayer.alloc().initWithIdentifierSource(polylineID, source);
+            layer.lineColor = NSExpression.expressionForConstantValue(!options.color ? UIColor.blackColor : options.color instanceof Color ? options.color.ios : new Color(options.color).ios);
+            layer.lineWidth = NSExpression.expressionForConstantValue(options.width || 5);
+            layer.lineOpacity = NSExpression.expressionForConstantValue(options.opacity === undefined ? 1 : options.opacity);
+            theMap.style.addLayer(layer);
+            resolve();
+        });
+    }
+    removePolyById(theMap, id) {
+        let layer = theMap.style.layerWithIdentifier(id);
+        if (layer !== null) {
+            theMap.style.removeLayer(layer);
+        }
+        layer = theMap.style.layerWithIdentifier(id + '_stroke');
+        if (layer !== null) {
+            theMap.style.removeLayer(layer);
+        }
+        const source = theMap.style.sourceWithIdentifier(id);
+        if (source !== null) {
+            theMap.style.removeSource(source);
+        }
+    }
+    removePolys(polyType, ids, nativeMap) {
+        return new Promise((resolve) => {
+            const theMap = nativeMap || this._mapboxViewInstance;
+            ids.forEach((id) => this.removePolyById(theMap, polyType + id));
+            resolve();
+        });
+    }
+    removePolygons(ids, nativeMap) {
+        return this.removePolys('polygon_', ids, nativeMap);
+    }
+    removePolylines(ids, nativeMap) {
+        return this.removePolys('polyline_', ids, nativeMap);
+    }
+    animateCamera(options, nativeMap) {
         return new Promise((resolve, reject) => {
             try {
-                const packs = MGLOfflineStorage.sharedOfflineStorage.packs;
-                if (!packs) {
-                    reject('No packs found or Mapbox not ready yet');
-                    return;
+                const theMap = nativeMap || this._mapboxViewInstance;
+                let cam;
+                if (options.bounds) {
+                    const padding = options.padding || 0;
+                    const insets = {
+                        top: padding,
+                        left: padding,
+                        bottom: padding,
+                        right: padding
+                    };
+                    const bounds = {
+                        sw: CLLocationCoordinate2DMake(options.bounds.south, options.bounds.west),
+                        ne: CLLocationCoordinate2DMake(options.bounds.north, options.bounds.east)
+                    };
+                    cam = theMap.cameraThatFitsCoordinateBoundsEdgePadding(bounds, insets);
                 }
-                const regions = [];
-                for (let i = 0; i < packs.count; i++) {
-                    const pack = packs.objectAtIndex(i);
-                    const region = pack.region;
-                    const userInfo = NSKeyedUnarchiver.unarchiveObjectWithData(pack.context);
-                    regions.push({
-                        name: userInfo.objectForKey('name'),
-                        style: '' + region.styleURL,
-                        minZoom: region.minimumZoomLevel,
-                        maxZoom: region.maximumZoomLevel,
-                        bounds: {
-                            north: region.bounds.ne.latitude,
-                            east: region.bounds.ne.longitude,
-                            south: region.bounds.sw.latitude,
-                            west: region.bounds.sw.longitude
-                        }
-                    });
+                else {
+                    const target = options.target;
+                    if (target === undefined) {
+                        reject("Please set the 'target' parameter");
+                        return;
+                    }
+                    cam = theMap.camera;
+                    cam.centerCoordinate = CLLocationCoordinate2DMake(target.lat, target.lng);
                 }
-                resolve(regions);
-            }
-            catch (ex) {
-                if (Trace.isEnabled()) {
-                    CLog(CLogTypes.info, 'Error in mapbox.listOfflineRegions: ' + ex);
+                if (options.altitude) {
+                    cam.altitude = options.altitude;
                 }
-                reject(ex);
-            }
-        });
-    }
-    deleteOfflineRegion(options) {
-        return new Promise((resolve, reject) => {
-            try {
-                if (!options || !options.name) {
-                    reject("Pass in the 'name' param");
-                    return;
+                if (options.bearing) {
+                    cam.heading = options.bearing;
                 }
-                const packs = MGLOfflineStorage.sharedOfflineStorage.packs;
-                let found = false;
-                for (let i = 0; i < packs.count; i++) {
-                    const pack = packs.objectAtIndex(i);
-                    const userInfo = NSKeyedUnarchiver.unarchiveObjectWithData(pack.context);
-                    const name = userInfo.objectForKey('name');
-                    if (name === options.name) {
-                        found = true;
-                        MGLOfflineStorage.sharedOfflineStorage.removePackWithCompletionHandler(pack, (error) => {
-                            if (error) {
-                                reject(error.localizedFailureReason);
-                            }
-                            else {
-                                resolve();
-                            }
-                        });
-                    }
+                if (options.tilt) {
+                    cam.pitch = options.tilt;
                 }
-                if (!found) {
-                    reject('Region not found');
+                if (options.zoomLevel && options.target) {
+                    cam.altitude = MGLAltitudeForZoomLevel(options.zoomLevel, cam.pitch, options.target.lat, theMap.frame.size);
                 }
+                const durationMs = options.duration ? options.duration : 10000;
+                theMap.setCameraWithDurationAnimationTimingFunction(cam, durationMs / 1000, CAMediaTimingFunction.functionWithName(kCAMediaTimingFunctionEaseInEaseOut));
+                setTimeout(() => {
+                    resolve();
+                }, durationMs);
             }
             catch (ex) {
                 if (Trace.isEnabled()) {
-                    CLog(CLogTypes.info, 'Error in mapbox.deleteOfflineRegion: ' + ex);
+                    CLog(CLogTypes.info, 'Error in mapbox.animateCamera: ' + ex);
                 }
                 reject(ex);
             }
         });
     }
-    addExtrusion(options, nativeMap) {
+    setOnMapClickListener(listener, nativeMap) {
         return new Promise((resolve, reject) => {
             try {
                 const theMap = nativeMap || this._mapboxViewInstance;
@@ -1566,17 +1667,26 @@ export class Mapbox extends MapboxCommon {
                     reject('No map has been loaded');
                     return;
                 }
+                theMap['mapTapHandler'] = MapTapHandlerImpl.initWithOwnerAndListenerForMap(new WeakRef(this), listener, theMap);
+                const tapGestureRecognizer = UITapGestureRecognizer.alloc().initWithTargetAction(theMap['mapTapHandler'], 'tap');
+                for (let i = 0; i < theMap.gestureRecognizers.count; i++) {
+                    const recognizer = theMap.gestureRecognizers.objectAtIndex(i);
+                    if (recognizer instanceof UITapGestureRecognizer) {
+                        tapGestureRecognizer.requireGestureRecognizerToFail(recognizer);
+                    }
+                }
+                theMap.addGestureRecognizer(tapGestureRecognizer);
                 resolve();
             }
             catch (ex) {
                 if (Trace.isEnabled()) {
-                    CLog(CLogTypes.info, 'Error in mapbox.deleteOfflineRegion: ' + ex);
+                    CLog(CLogTypes.info, 'Error in mapbox.setOnMapClickListener: ' + ex);
                 }
                 reject(ex);
             }
         });
     }
-    updateSource(id, options, nativeMap) {
+    setOnMapLongClickListener(listener, nativeMap) {
         return new Promise((resolve, reject) => {
             try {
                 const theMap = nativeMap || this._mapboxViewInstance;
@@ -1584,159 +1694,57 @@ export class Mapbox extends MapboxCommon {
                     reject('No map has been loaded');
                     return;
                 }
-                const source = theMap.style.sourceWithIdentifier(id);
-                if (!source) {
-                    reject('Source does not exists: ' + id);
-                    return;
-                }
-                switch (options.type) {
-                    case 'geojson':
-                        const content = NSString.stringWithString(JSON.stringify(options.data));
-                        const nsData = content.dataUsingEncoding(NSUTF8StringEncoding);
-                        const geoJsonShape = MGLShape.shapeWithDataEncodingError(nsData, NSUTF8StringEncoding);
-                        source.shape = geoJsonShape;
-                        break;
-                    default:
-                        reject('Invalid source type: ' + options['type']);
-                        return;
+                theMap['mapLongPressHandler'] = MapLongPressHandlerImpl.initWithOwnerAndListenerForMap(new WeakRef(this), listener, theMap);
+                const longPressGestureRecognizer = UILongPressGestureRecognizer.alloc().initWithTargetAction(theMap['mapLongPressHandler'], 'longPress');
+                for (let i = 0; i < theMap.gestureRecognizers.count; i++) {
+                    const recognizer = theMap.gestureRecognizers.objectAtIndex(i);
+                    if (recognizer instanceof UILongPressGestureRecognizer) {
+                        longPressGestureRecognizer.requireGestureRecognizerToFail(recognizer);
+                    }
                 }
+                theMap.addGestureRecognizer(longPressGestureRecognizer);
+                resolve();
             }
             catch (ex) {
                 if (Trace.isEnabled()) {
-                    CLog(CLogTypes.info, 'Error in mapbox.addSource: ' + ex);
+                    CLog(CLogTypes.info, 'Error in mapbox.setOnMapClickListener: ' + ex);
                 }
                 reject(ex);
             }
         });
     }
-    addSource(id, options, nativeMap) {
+    setOnScrollListener(listener, nativeMap) {
         return new Promise((resolve, reject) => {
             try {
                 const theMap = nativeMap || this._mapboxViewInstance;
-                let source;
                 if (!theMap) {
                     reject('No map has been loaded');
                     return;
                 }
-                if (theMap.style.sourceWithIdentifier(id)) {
-                    reject('Source exists: ' + id);
-                    return;
+                if (theMap['mapPanHandler'] === undefined) {
+                    theMap['mapPanHandler'] = MapPanHandlerImpl.initWithOwnerAndListenerForMap(new WeakRef(this), listener, 2, theMap);
                 }
-                switch (options.type) {
-                    case 'vector': {
-                        if (options.url) {
-                            source = MGLVectorTileSource.alloc().initWithIdentifierConfigurationURL(id, NSURL.URLWithString(options.url));
-                        }
-                        else {
-                            const sourceOptions = {};
-                            if (options.minzoom !== undefined) {
-                                sourceOptions[MGLTileSourceOptionMinimumZoomLevel] = options.minzoom;
-                            }
-                            if (options.maxzoom !== undefined) {
-                                sourceOptions[MGLTileSourceOptionMaximumZoomLevel] = options.maxzoom;
-                            }
-                            if (options.scheme) {
-                                switch (options.scheme) {
-                                    case 'xyz':
-                                        sourceOptions[MGLTileSourceOptionTileCoordinateSystem] = 0;
-                                        break;
-                                    case 'tms':
-                                        sourceOptions[MGLTileSourceOptionTileCoordinateSystem] = 1;
-                                        break;
-                                    default:
-                                        throw new Error('Unknown raster tile scheme.');
-                                }
-                            }
-                            if (options.bounds) {
-                                sourceOptions[MGLTileSourceOptionCoordinateBounds] = NSValue.valueWithMGLCoordinateBounds({
-                                    sw: CLLocationCoordinate2DMake(options.bounds[1], options.bounds[0]),
-                                    ne: CLLocationCoordinate2DMake(options.bounds[3], options.bounds[2])
-                                });
-                            }
-                            source = MGLVectorTileSource.alloc().initWithIdentifierTileURLTemplatesOptions(id, options.tiles, sourceOptions);
-                        }
-                        break;
-                    }
-                    case 'geojson':
-                        if (theMap.style.sourceWithIdentifier(id)) {
-                            reject("Remove the layer with this id first with 'removeLayer': " + id);
-                            return;
-                        }
-                        let geoJsonShape;
-                        if (options.data) {
-                            const content = NSString.stringWithString(JSON.stringify(options.data));
-                            const nsData = content.dataUsingEncoding(NSUTF8StringEncoding);
-                            geoJsonShape = MGLShape.shapeWithDataEncodingError(nsData, NSUTF8StringEncoding);
-                        }
-                        const sourceOptions = {};
-                        if (options.minzoom !== undefined) {
-                            sourceOptions[MGLShapeSourceOptionMinimumZoomLevel] = options.minzoom;
-                        }
-                        if (options.maxzoom !== undefined) {
-                            sourceOptions[MGLShapeSourceOptionMaximumZoomLevel] = options.maxzoom;
-                        }
-                        if (options.cluster) {
-                            sourceOptions[MGLShapeSourceOptionClustered] = true;
-                            sourceOptions[MGLShapeSourceOptionClusterRadius] = options.cluster.radius || 40;
-                            sourceOptions[MGLShapeSourceOptionMaximumZoomLevelForClustering] = options.cluster.maxZoom || 13;
-                        }
-                        source = MGLShapeSource.alloc().initWithIdentifierShapeOptions(id, geoJsonShape, sourceOptions);
-                        break;
-                    case 'raster': {
-                        const sourceOptions = {
-                            [MGLTileSourceOptionTileSize]: options.tileSize || 256
-                        };
-                        if (options.minzoom !== undefined) {
-                            sourceOptions[MGLTileSourceOptionMinimumZoomLevel] = options.minzoom;
-                        }
-                        if (options.maxzoom !== undefined) {
-                            sourceOptions[MGLTileSourceOptionMaximumZoomLevel] = options.maxzoom;
-                        }
-                        if (options.scheme) {
-                            switch (options.scheme || 'xyz') {
-                                case 'xyz':
-                                    sourceOptions[MGLTileSourceOptionTileCoordinateSystem] = 0;
-                                    break;
-                                case 'tms':
-                                    sourceOptions[MGLTileSourceOptionTileCoordinateSystem] = 1;
-                                    break;
-                                default:
-                                    throw new Error('Unknown raster tile scheme.');
-                            }
-                        }
-                        if (options.bounds) {
-                            sourceOptions[MGLTileSourceOptionCoordinateBounds] = NSValue.valueWithMGLCoordinateBounds({
-                                sw: CLLocationCoordinate2DMake(options.bounds[1], options.bounds[0]),
-                                ne: CLLocationCoordinate2DMake(options.bounds[3], options.bounds[2])
-                            });
-                        }
-                        source = MGLRasterTileSource.alloc().initWithIdentifierTileURLTemplatesOptions(id, options.tiles, sourceOptions);
-                        break;
-                    }
-                    default:
-                        reject('Invalid source type: ' + options['type']);
-                        return;
+                else {
+                    theMap['mapPanHandler'].addListener(2, listener);
                 }
-                if (!source) {
-                    const ex = 'No source to add';
-                    if (Trace.isEnabled()) {
-                        CLog(CLogTypes.info, 'Error in mapbox.addSource: ' + ex);
+                for (let i = 0; i < theMap.gestureRecognizers.count; i++) {
+                    const recognizer = theMap.gestureRecognizers.objectAtIndex(i);
+                    if (recognizer instanceof UIPanGestureRecognizer) {
+                        recognizer.addTargetAction(theMap['mapPanHandler'], 'pan');
+                        break;
                     }
-                    reject(ex);
-                    return;
                 }
-                theMap.style.addSource(source);
                 resolve();
             }
             catch (ex) {
                 if (Trace.isEnabled()) {
-                    CLog(CLogTypes.info, 'Error in mapbox.addSource: ' + ex);
+                    CLog(CLogTypes.info, 'Error in mapbox.setOnScrollListener: ' + ex);
                 }
                 reject(ex);
             }
         });
     }
-    removeSource(id, nativeMap) {
+    setOnMoveBeginListener(listener, nativeMap) {
         return new Promise((resolve, reject) => {
             try {
                 const theMap = nativeMap || this._mapboxViewInstance;
@@ -1744,109 +1752,277 @@ export class Mapbox extends MapboxCommon {
                     reject('No map has been loaded');
                     return;
                 }
-                const source = theMap.style.sourceWithIdentifier(id);
-                if (!source) {
-                    reject('Source does not exist');
+                if (theMap['mapPanHandler'] === undefined) {
+                    theMap['mapPanHandler'] = MapPanHandlerImpl.initWithOwnerAndListenerForMap(new WeakRef(this), listener, 1, theMap);
+                }
+                else {
+                    theMap['mapPanHandler'].addListener(1, listener);
+                }
+                for (let i = 0; i < theMap.gestureRecognizers.count; i++) {
+                    const recognizer = theMap.gestureRecognizers.objectAtIndex(i);
+                    if (recognizer instanceof UIPanGestureRecognizer) {
+                        recognizer.addTargetAction(theMap['mapPanHandler'], 'panBegin');
+                        break;
+                    }
+                }
+                resolve();
+            }
+            catch (ex) {
+                if (Trace.isEnabled()) {
+                    CLog(CLogTypes.info, 'Error in mapbox.setOnMoveBeginListener: ' + ex);
+                }
+                reject(ex);
+            }
+        });
+    }
+    setOnMoveEndListener(listener, nativeMap) {
+        return new Promise((resolve, reject) => {
+            try {
+                const theMap = nativeMap || this._mapboxViewInstance;
+                if (!theMap) {
+                    reject('No map has been loaded');
                     return;
                 }
-                theMap.style.removeSource(source);
+                if (theMap['mapPanHandler'] === undefined) {
+                    theMap['mapPanHandler'] = MapPanHandlerImpl.initWithOwnerAndListenerForMap(new WeakRef(this), listener, 3, theMap);
+                }
+                else {
+                    theMap['mapPanHandler'].addListener(3, listener);
+                }
+                for (let i = 0; i < theMap.gestureRecognizers.count; i++) {
+                    const recognizer = theMap.gestureRecognizers.objectAtIndex(i);
+                    if (recognizer instanceof UIPanGestureRecognizer) {
+                        recognizer.addTargetAction(theMap['mapPanHandler'], 'panEnd');
+                        break;
+                    }
+                }
                 resolve();
             }
             catch (ex) {
                 if (Trace.isEnabled()) {
-                    CLog(CLogTypes.info, 'Error in mapbox.removeSource: ' + ex);
+                    CLog(CLogTypes.info, 'Error in mapbox.setOnMoveEndListener: ' + ex);
                 }
                 reject(ex);
             }
         });
     }
-    async addLayer(style, belowLayerId, nativeMapView) {
-        const theMap = nativeMapView || this._mapboxViewInstance;
-        let source = null;
-        if (typeof style.source != 'string') {
-            await this.addSource(style.id + '_source', style.source);
-            source = theMap.style.sourceWithIdentifier(style.id + '_source');
+    setOnFlingListener(listener, nativeMap) {
+        return Promise.reject("'setOnFlingListener' is not supported on iOS");
+    }
+    async setOnCameraMoveListener(listener, nativeMap) {
+        const theMap = nativeMap || this._mapboxViewInstance;
+        if (theMap) {
+            theMap.delegate.setCameraChangedListener(listener);
         }
         else {
-            source = theMap.style.sourceWithIdentifier(style.source);
-        }
-        const layer = await LayerFactory.createLayer(style, source);
-        if (belowLayerId) {
-            const belowlayer = theMap.style.layerWithIdentifier(belowLayerId);
-            if (belowlayer) {
-                theMap.style.insertLayerBelowLayer(layer.getNativeInstance(), belowlayer);
-                return;
-            }
+            return Promise.reject('No map has been loaded');
         }
-        theMap.style.addLayer(layer.getNativeInstance());
     }
-    async removeLayer(id, nativeMapViewInstance) {
-        const theMap = nativeMapViewInstance || this._mapboxViewInstance;
-        if (Trace.isEnabled()) {
-            CLog(CLogTypes.info, "Mapbox::removeLayer(): attempting to remove layer '" + id + "'");
-        }
-        const layer = theMap.style.layerWithIdentifier(id);
-        if (Trace.isEnabled()) {
-            CLog(CLogTypes.info, 'Mapbox:removeLayer(): got layer object: ', layer);
-        }
-        if (!layer) {
-            throw new Error("Layer '" + id + "' not found when attempting to remove it.");
+    setOnCameraMoveCancelListener(listener, nativeMap) {
+        return Promise.reject("'setOnCameraMoveCancelListener' not currently supported on iOS");
+    }
+    async setOnCameraIdleListener(listener, nativeMap) {
+        const theMap = nativeMap || this._mapboxViewInstance;
+        if (theMap) {
+            theMap.delegate.setCameraIdledListener(listener);
         }
-        theMap.style.removeLayer(layer);
-        if (Trace.isEnabled()) {
-            CLog(CLogTypes.info, 'Mapbox:removeLayer(): after removing layer ' + id);
+        else {
+            return Promise.reject('No map has been loaded');
         }
     }
-    async addLinePoint(id, lnglat, sourceId, nativeMapView) {
-        const theMap = nativeMapView || this._mapboxViewInstance;
-        const sId = !!sourceId ? sourceId : id + '_source';
-        const lineSource = theMap.style.sourceWithIdentifier(sId);
-        if (!lineSource) {
-            throw new Error(`no source found with id: ${sId}`);
-        }
-        try {
-            const lineFeatures = lineSource.featuresMatchingPredicate(FilterParser.parseJson(['==', '$type', 'LineString']));
-            if (lineFeatures.count === 0) {
-                throw new Error('no line string feature found');
+    getViewport(nativeMap) {
+        return new Promise((resolve, reject) => {
+            try {
+                const theMap = nativeMap || this._mapboxViewInstance;
+                if (!theMap) {
+                    reject('No map has been loaded');
+                    return;
+                }
+                const visibleBounds = theMap.visibleCoordinateBounds;
+                const bounds = {
+                    north: visibleBounds.ne.latitude,
+                    east: visibleBounds.ne.longitude,
+                    south: visibleBounds.sw.latitude,
+                    west: visibleBounds.sw.longitude
+                };
+                resolve({
+                    bounds,
+                    zoomLevel: theMap.zoomLevel
+                });
+            }
+            catch (ex) {
+                if (Trace.isEnabled()) {
+                    CLog(CLogTypes.info, 'Error in mapbox.getViewport: ' + ex);
+                }
+                reject(ex);
+            }
+        });
+    }
+    setViewport(options, nativeMap) {
+        return new Promise((resolve, reject) => {
+            try {
+                const theMap = nativeMap || this._mapboxViewInstance;
+                if (!theMap) {
+                    reject('No map has been loaded');
+                    return;
+                }
+                const bounds = {
+                    sw: CLLocationCoordinate2DMake(options.bounds.south, options.bounds.west),
+                    ne: CLLocationCoordinate2DMake(options.bounds.north, options.bounds.east)
+                };
+                const animated = options.animated === undefined || options.animated;
+                const padding = options.padding !== undefined ? { top: options.padding, left: options.padding, bottom: options.padding, right: options.padding } : { top: 25, left: 25, bottom: 25, right: 25 };
+                theMap.setVisibleCoordinateBoundsEdgePaddingAnimated(bounds, padding, animated);
+                resolve();
+            }
+            catch (ex) {
+                if (Trace.isEnabled()) {
+                    CLog(CLogTypes.info, 'Error in mapbox.setViewport: ' + ex);
+                }
+                reject(ex);
+            }
+        });
+    }
+    downloadOfflineRegion(options) {
+        return new Promise((resolve, reject) => {
+            try {
+                const styleURL = _getMapStyle(options.style);
+                const swCoordinate = CLLocationCoordinate2DMake(options.bounds.south, options.bounds.west);
+                const neCoordinate = CLLocationCoordinate2DMake(options.bounds.north, options.bounds.east);
+                const bounds = {
+                    sw: swCoordinate,
+                    ne: neCoordinate
+                };
+                const region = MGLTilePyramidOfflineRegion.alloc().initWithStyleURLBoundsFromZoomLevelToZoomLevel(styleURL, bounds, options.minZoom, options.maxZoom);
+                if (options.accessToken) {
+                    MGLAccountManager.accessToken = options.accessToken;
+                }
+                if (options.onProgress) {
+                    _addObserver(MGLOfflinePackProgressChangedNotification, (notification) => {
+                        const offlinePack = notification.object;
+                        const offlinePackProgress = offlinePack.progress;
+                        const userInfo = NSKeyedUnarchiver.unarchiveObjectWithData(offlinePack.context);
+                        const complete = offlinePackProgress.countOfResourcesCompleted === offlinePackProgress.countOfResourcesExpected;
+                        options.onProgress({
+                            name: userInfo.objectForKey('name'),
+                            completed: offlinePackProgress.countOfResourcesCompleted,
+                            expected: offlinePackProgress.countOfResourcesExpected,
+                            percentage: Math.round((offlinePackProgress.countOfResourcesCompleted / offlinePackProgress.countOfResourcesExpected) * 10000) / 100,
+                            complete
+                        });
+                        if (complete) {
+                            resolve();
+                        }
+                    });
+                }
+                _addObserver(MGLOfflinePackErrorNotification, (notification) => {
+                    const offlinePack = notification.object;
+                    const userInfo = NSKeyedUnarchiver.unarchiveObjectWithData(offlinePack.context);
+                    const error = notification.userInfo[MGLOfflinePackUserInfoKeyError];
+                    reject({
+                        name: userInfo.objectForKey('name'),
+                        error: 'Download error. ' + error
+                    });
+                });
+                _addObserver(MGLOfflinePackMaximumMapboxTilesReachedNotification, (notification) => {
+                    const offlinePack = notification.object;
+                    const userInfo = NSKeyedUnarchiver.unarchiveObjectWithData(offlinePack.context);
+                    const maximumCount = notification.userInfo[MGLOfflinePackUserInfoKeyMaximumCount];
+                    console.log(`Offline region '${userInfo.objectForKey('name')}' reached the tile limit of ${maximumCount}`);
+                });
+                const userInfo = { name: options.name };
+                const context = NSKeyedArchiver.archivedDataWithRootObject(userInfo);
+                MGLOfflineStorage.sharedOfflineStorage.addPackForRegionWithContextCompletionHandler(region, context, (pack, error) => {
+                    if (error) {
+                        reject(error.localizedFailureReason);
+                    }
+                    else {
+                        pack.resume();
+                    }
+                });
+            }
+            catch (ex) {
+                if (Trace.isEnabled()) {
+                    CLog(CLogTypes.info, 'Error in mapbox.downloadOfflineRegion: ' + ex);
+                }
+                reject(ex);
+            }
+        });
+    }
+    listOfflineRegions(options) {
+        return new Promise((resolve, reject) => {
+            try {
+                const packs = MGLOfflineStorage.sharedOfflineStorage.packs;
+                if (!packs) {
+                    reject('No packs found or Mapbox not ready yet');
+                    return;
+                }
+                const regions = [];
+                for (let i = 0; i < packs.count; i++) {
+                    const pack = packs.objectAtIndex(i);
+                    const region = pack.region;
+                    const userInfo = NSKeyedUnarchiver.unarchiveObjectWithData(pack.context);
+                    regions.push({
+                        name: userInfo.objectForKey('name'),
+                        style: '' + region.styleURL,
+                        minZoom: region.minimumZoomLevel,
+                        maxZoom: region.maximumZoomLevel,
+                        bounds: {
+                            north: region.bounds.ne.latitude,
+                            east: region.bounds.ne.longitude,
+                            south: region.bounds.sw.latitude,
+                            west: region.bounds.sw.longitude
+                        }
+                    });
+                }
+                resolve(regions);
+            }
+            catch (ex) {
+                if (Trace.isEnabled()) {
+                    CLog(CLogTypes.info, 'Error in mapbox.listOfflineRegions: ' + ex);
+                }
+                reject(ex);
             }
-            const lineFeature = lineFeatures.objectAtIndex(0);
-            const newCoord = CLLocationCoordinate2DMake(lnglat[1], lnglat[0]);
-            const newCoordPointer = new interop.Reference(newCoord);
-            lineFeature.appendCoordinatesCount(newCoordPointer, 1);
-            lineSource.shape = lineFeature;
-        }
-        catch (error) {
-            console.log(error);
-            throw error;
-        }
-    }
-    addGeoJsonClustered(options, nativeMapViewInstance) {
-        throw new Error('Method not implemented.');
+        });
     }
-    trackUser(options, nativeMap) {
+    deleteOfflineRegion(options) {
         return new Promise((resolve, reject) => {
             try {
-                const theMap = nativeMap || this._mapboxViewInstance;
-                if (!theMap) {
-                    reject('No map has been loaded');
+                if (!options || (!options.id && !options.name)) {
+                    reject("Pass in the 'id' or 'name' param");
                     return;
                 }
-                if (!theMap.showsUserLocation) {
-                    reject('The map is not currently showing the user location');
-                    return;
+                const packs = MGLOfflineStorage.sharedOfflineStorage.packs;
+                let found = false;
+                for (let i = 0; i < packs.count; i++) {
+                    const pack = packs.objectAtIndex(i);
+                    const userInfo = NSKeyedUnarchiver.unarchiveObjectWithData(pack.context);
+                    const regionId = options.id ? userInfo.objectForKey('id') : userInfo.objectForKey('name');
+                    if (regionId === (options.id || options.name)) {
+                        found = true;
+                        MGLOfflineStorage.sharedOfflineStorage.removePackWithCompletionHandler(pack, (error) => {
+                            if (error) {
+                                reject(error.localizedFailureReason);
+                            }
+                            else {
+                                resolve();
+                            }
+                        });
+                    }
+                }
+                if (!found) {
+                    reject('Region not found');
                 }
-                theMap.setUserTrackingModeAnimated(_getTrackingMode(options.mode), options.animated !== false);
-                resolve();
             }
             catch (ex) {
                 if (Trace.isEnabled()) {
-                    CLog(CLogTypes.info, 'Error in mapbox.trackUser: ' + ex);
+                    CLog(CLogTypes.info, 'Error in mapbox.deleteOfflineRegion: ' + ex);
                 }
                 reject(ex);
             }
         });
     }
-    getLayer(name, nativeMap) {
+    addExtrusion(options, nativeMap) {
         return new Promise((resolve, reject) => {
             try {
                 const theMap = nativeMap || this._mapboxViewInstance;
@@ -1854,18 +2030,17 @@ export class Mapbox extends MapboxCommon {
                     reject('No map has been loaded');
                     return;
                 }
-                const layer = theMap.style.layerWithIdentifier(name);
-                resolve(new Layer(layer));
+                resolve();
             }
             catch (ex) {
                 if (Trace.isEnabled()) {
-                    CLog(CLogTypes.info, 'Error in mapbox.getLayer: ' + ex);
+                    CLog(CLogTypes.info, 'Error in mapbox.deleteOfflineRegion: ' + ex);
                 }
                 reject(ex);
             }
         });
     }
-    getLayers(nativeMap) {
+    updateSource(id, options, nativeMap) {
         return new Promise((resolve, reject) => {
             try {
                 const theMap = nativeMap || this._mapboxViewInstance;
@@ -1873,489 +2048,379 @@ export class Mapbox extends MapboxCommon {
                     reject('No map has been loaded');
                     return;
                 }
-                const layers = theMap.style.layers;
-                const result = [];
-                for (let i = 0; i < layers.count; i++) {
-                    result.push(new Layer(layers[i]));
-                }
-                resolve(result);
-            }
-            catch (ex) {
-                if (Trace.isEnabled()) {
-                    CLog(CLogTypes.info, 'Error in mapbox.getLayers: ' + ex);
+                const source = theMap.style.sourceWithIdentifier(id);
+                if (!source) {
+                    reject('Source does not exists: ' + id);
+                    return;
                 }
-                reject(ex);
-            }
-        });
-    }
-    project(data) {
-        const theMap = this._mapboxViewInstance;
-        const { x, y } = theMap.convertCoordinateToPointToView({ latitude: data.lat, longitude: data.lng }, theMap);
-        return { x, y };
-    }
-}
-const _addObserver = (eventName, callback) => NSNotificationCenter.defaultCenter.addObserverForNameObjectQueueUsingBlock(eventName, null, NSOperationQueue.mainQueue, callback);
-function _downloadImage(marker) {
-    return new Promise((resolve, reject) => {
-        if (Trace.isEnabled()) {
-            CLog(CLogTypes.info, '>> _downloadImage');
-        }
-        if (_markerIconDownloadCache[marker.icon]) {
-            marker.iconDownloaded = _markerIconDownloadCache[marker.icon];
-            if (Trace.isEnabled()) {
-                CLog(CLogTypes.info, '>> marker.iconDownloaded: ' + marker.iconDownloaded);
-            }
-            resolve(marker);
-            return;
-        }
-        getImage(marker.icon).then((output) => {
-            marker.iconDownloaded = output.ios;
-            _markerIconDownloadCache[marker.icon] = marker.iconDownloaded;
-            resolve(marker);
-        }, (ignoredError) => {
-            console.log(`Download failed for ${marker.icon} with error: ${ignoredError}`);
-            resolve(marker);
-        });
-    });
-}
-const _downloadMarkerImages = (markers) => {
-    const iterations = [];
-    const result = [];
-    markers.forEach((marker) => {
-        if (marker.icon && marker.icon.startsWith('http')) {
-            const p = _downloadImage(marker).then((mark) => result.push(mark));
-            iterations.push(p);
-        }
-        else {
-            result.push(marker);
-        }
-    });
-    return Promise.all(iterations).then(() => result);
-};
-var MGLMapViewDelegateImpl = /** @class */ (function (_super) {
-    __extends(MGLMapViewDelegateImpl, _super);
-    function MGLMapViewDelegateImpl() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    MGLMapViewDelegateImpl.new = function () {
-        return _super.new.call(this);
-    };
-    /**
-     * initialize with the mapReady callback
-     */
-    MGLMapViewDelegateImpl.prototype.initWithCallback = function (mapLoadedCallback) {
-        if (Trace.isEnabled()) {
-            CLog(CLogTypes.info, 'MGLMapViewDelegateImpl::initWithCallback()');
-        }
-        this.mapLoadedCallback = mapLoadedCallback;
-        return this;
-    };
-    /**
-     * set a reference to the mapboxAPI instance
-     */
-    MGLMapViewDelegateImpl.prototype.setMapboxApi = function (api) {
-        this.mapboxApi = api;
-    };
-    /**
-     * set the user location click listener callback
-     */
-    MGLMapViewDelegateImpl.prototype.setUserLocationClickListener = function (callback) {
-        this.userLocationClickListener = callback;
-    };
-    /**
-     * set the user location click listener callback
-     */
-    MGLMapViewDelegateImpl.prototype.setUserLocationChangedistener = function (callback) {
-        this.userLocationChangedListener = callback;
-    };
-    /**
-     * set user location marker modes
-     */
-    MGLMapViewDelegateImpl.prototype.changeUserLocationRenderMode = function (userLocationRenderMode) {
-        this.userLocationAnnotationView.changeUserLocationRenderMode(userLocationRenderMode);
-    };
-    /**
-     * set the camera changd listener callback
-     */
-    MGLMapViewDelegateImpl.prototype.setCameraChangedListener = function (callback) {
-        this.cameraChangedListener = callback;
-    };
-    /**
-     * set the camera idled listener callback
-     */
-    MGLMapViewDelegateImpl.prototype.setCameraIdledListener = function (callback) {
-        this.cameraIdledListener = callback;
-    };
-    /**
-     * set style loaded callback.
-     *
-     * set an optional callback to be invoked when a style set with
-     * setMapStyle() is finished loading
-     *
-     * @param {function} callback function with loaded style as parameter.
-     *
-     * @see Mapbox:setMapStyle()
-     */
-    MGLMapViewDelegateImpl.prototype.setStyleLoadedCallback = function (callback) {
-        this.styleLoadedCallback = callback;
-    };
-    /**
-     * map ready callback
-     */
-    MGLMapViewDelegateImpl.prototype.mapViewDidFinishLoadingMap = function (mapView) {
-        if (Trace.isEnabled()) {
-            CLog(CLogTypes.info, 'MGLMapViewDelegateImpl:mapViewDidFinishLoadingMap(): top');
-        }
-        if (this.mapLoadedCallback !== undefined) {
-            this.mapLoadedCallback(mapView);
-            // this should be fired only once, but it's also fired when the style changes, so just remove the callback
-            this.mapLoadedCallback = undefined;
-        }
-    };
-    MGLMapViewDelegateImpl.prototype.mapViewDidFinishRenderingMapFullyRendered = function (mapView, fullyRendered) {
-        if (Trace.isEnabled()) {
-            CLog(CLogTypes.info, 'MGLMapViewDelegateImpl:mapViewDidFinishRenderingMapFullyRendered(): rendered is:', fullyRendered);
-        }
-    };
-    /**
-     * Callback when the style has been loaded.
-     *
-     * Based on my testing, it looks like this callback is invoked multiple times.
-     *
-     * @see Mapbox:setMapStyle()
-     *
-     * @link https://mapbox.github.io/mapbox-gl-native/macos/0.3.0/Protocols/MGLMapViewDelegate.html#/c:objc(pl)MGLMapViewDelegate(im)mapView:didFinishLoadingStyle:
-     */
-    MGLMapViewDelegateImpl.prototype.mapViewDidFinishLoadingStyle = function (mapView, style) {
-        if (Trace.isEnabled()) {
-            CLog(CLogTypes.info, 'MGLMapViewDelegateImpl:mapViewDidFinishLoadingStyle(): callback called.');
-        }
-        if (this.styleLoadedCallback !== undefined) {
-            this.styleLoadedCallback(mapView, style);
-            // to avoid multiple calls. This is only invoked from setMapStyle().
-            this.styleLoadedCallback = undefined;
-        }
-    };
-    /**
-     * disable the default user location callout
-     *
-     * This took forever to find. The default iOS click handler for the user location
-     * marker is about useless. It just displays "You Are Here". The examples do not
-     * show how to disable it.
-     */
-    MGLMapViewDelegateImpl.prototype.mapViewAnnotationCanShowCallout = function (mapView, annotation) {
-        if (annotation.isKindOfClass(MGLUserLocation.class())) {
-            return false;
-        }
-        else {
-            return true;
-        }
-    };
-    MGLMapViewDelegateImpl.prototype.mapViewDidFailLoadingMapWithError = function (mapView, error) {
-        if (Trace.isEnabled()) {
-            CLog(CLogTypes.info, 'mapViewDidFailLoadingMapWithError: ' + error);
-        }
-    };
-    MGLMapViewDelegateImpl.prototype.mapViewDidChangeUserTrackingModeAnimated = function (mapView, mode, animated) {
-        if (Trace.isEnabled()) {
-            CLog(CLogTypes.info, 'mapViewDidChangeUserTrackingModeAnimated: ' + mode);
-        }
-    };
-    /**
-     * fired when the marker icon is about to be rendered - return null for the default icon
-     */
-    MGLMapViewDelegateImpl.prototype.mapViewImageForAnnotation = function (mapView, annotation) {
-        var cachedMarker = this.getTappedMarkerDetails(annotation);
-        if (cachedMarker) {
-            if (cachedMarker.reuseIdentifier) {
-                var reusedImage = mapView.dequeueReusableAnnotationImageWithIdentifier(cachedMarker.reuseIdentifier);
-                if (reusedImage) {
-                    return reusedImage;
+                switch (options.type) {
+                    case 'geojson':
+                        const content = NSString.stringWithString(JSON.stringify(options.data));
+                        const nsData = content.dataUsingEncoding(NSUTF8StringEncoding);
+                        const geoJsonShape = MGLShape.shapeWithDataEncodingError(nsData, NSUTF8StringEncoding);
+                        source.shape = geoJsonShape;
+                        break;
+                    default:
+                        reject('Invalid source type: ' + options['type']);
+                        return;
                 }
             }
-            // TODO try adding .rotatesToMatchCamera = true;
-            // .. for instance in the mapViewDidDeselectAnnotationView / mapViewDidSelectAnnotationView / mapViewViewForAnnotation delegate
-            if (cachedMarker.icon) {
-                if (cachedMarker.icon.startsWith('res://')) {
-                    var resourceName = cachedMarker.icon.substring('res://'.length);
-                    var imageSource = ImageSource.fromResourceSync(resourceName);
-                    if (imageSource === null) {
-                        console.log("Unable to locate " + resourceName);
-                    }
-                    else {
-                        cachedMarker.reuseIdentifier = cachedMarker.icon;
-                        return MGLAnnotationImage.annotationImageWithImageReuseIdentifier(imageSource.ios, cachedMarker.reuseIdentifier);
-                    }
+            catch (ex) {
+                if (Trace.isEnabled()) {
+                    CLog(CLogTypes.info, 'Error in mapbox.addSource: ' + ex);
                 }
-                else if (cachedMarker.icon.startsWith('http')) {
-                    if (cachedMarker.iconDownloaded !== null) {
-                        cachedMarker.reuseIdentifier = cachedMarker.icon;
-                        return MGLAnnotationImage.annotationImageWithImageReuseIdentifier(cachedMarker.iconDownloaded, cachedMarker.reuseIdentifier);
+                reject(ex);
+            }
+        });
+    }
+    addSource(id, options, nativeMap) {
+        return new Promise((resolve, reject) => {
+            try {
+                const theMap = nativeMap || this._mapboxViewInstance;
+                let source;
+                if (!theMap) {
+                    reject('No map has been loaded');
+                    return;
+                }
+                if (theMap.style.sourceWithIdentifier(id)) {
+                    reject('Source exists: ' + id);
+                    return;
+                }
+                switch (options.type) {
+                    case 'vector': {
+                        if (options.url) {
+                            source = MGLVectorTileSource.alloc().initWithIdentifierConfigurationURL(id, NSURL.URLWithString(options.url));
+                        }
+                        else {
+                            const sourceOptions = {};
+                            if (options.minzoom !== undefined) {
+                                sourceOptions[MGLTileSourceOptionMinimumZoomLevel] = options.minzoom;
+                            }
+                            if (options.maxzoom !== undefined) {
+                                sourceOptions[MGLTileSourceOptionMaximumZoomLevel] = options.maxzoom;
+                            }
+                            if (options.scheme) {
+                                switch (options.scheme) {
+                                    case 'xyz':
+                                        sourceOptions[MGLTileSourceOptionTileCoordinateSystem] = 0;
+                                        break;
+                                    case 'tms':
+                                        sourceOptions[MGLTileSourceOptionTileCoordinateSystem] = 1;
+                                        break;
+                                    default:
+                                        throw new Error('Unknown raster tile scheme.');
+                                }
+                            }
+                            if (options.bounds) {
+                                sourceOptions[MGLTileSourceOptionCoordinateBounds] = NSValue.valueWithMGLCoordinateBounds({
+                                    sw: CLLocationCoordinate2DMake(options.bounds[1], options.bounds[0]),
+                                    ne: CLLocationCoordinate2DMake(options.bounds[3], options.bounds[2])
+                                });
+                            }
+                            source = MGLVectorTileSource.alloc().initWithIdentifierTileURLTemplatesOptions(id, options.tiles, sourceOptions);
+                        }
+                        break;
+                    }
+                    case 'geojson':
+                        if (theMap.style.sourceWithIdentifier(id)) {
+                            reject("Remove the layer with this id first with 'removeLayer': " + id);
+                            return;
+                        }
+                        let geoJsonShape;
+                        if (options.data) {
+                            const content = NSString.stringWithString(JSON.stringify(options.data));
+                            const nsData = content.dataUsingEncoding(NSUTF8StringEncoding);
+                            geoJsonShape = MGLShape.shapeWithDataEncodingError(nsData, NSUTF8StringEncoding);
+                        }
+                        const sourceOptions = {};
+                        if (options.minzoom !== undefined) {
+                            sourceOptions[MGLShapeSourceOptionMinimumZoomLevel] = options.minzoom;
+                        }
+                        if (options.maxzoom !== undefined) {
+                            sourceOptions[MGLShapeSourceOptionMaximumZoomLevel] = options.maxzoom;
+                        }
+                        if (options.lineMetrics !== undefined) {
+                            sourceOptions[MGLShapeSourceOptionLineDistanceMetrics] = options.lineMetrics;
+                        }
+                        if (options.cluster) {
+                            sourceOptions[MGLShapeSourceOptionClustered] = true;
+                            sourceOptions[MGLShapeSourceOptionClusterRadius] = options.cluster.radius || 40;
+                            sourceOptions[MGLShapeSourceOptionMaximumZoomLevelForClustering] = options.cluster.maxZoom || 13;
+                            if (options.cluster.properties) {
+                                const clusterProperties = {};
+                                for (const property of Object.keys(options.cluster.properties)) {
+                                    let [operator, operand] = options.cluster.properties[property];
+                                    if (!Array.isArray(operator)) {
+                                        operator = [operator];
+                                    }
+                                    const expressions = Utils.ios.collections.jsArrayToNSArray([ExpressionParser.parseJson(operator), ExpressionParser.parseJson(operand)]);
+                                    clusterProperties[property] = expressions;
+                                }
+                                sourceOptions[MGLShapeSourceOptionClusterProperties] = clusterProperties;
+                            }
+                        }
+                        source = MGLShapeSource.alloc().initWithIdentifierShapeOptions(id, geoJsonShape, sourceOptions);
+                        break;
+                    case 'raster': {
+                        const sourceOptions = {
+                            [MGLTileSourceOptionTileSize]: options.tileSize || 256
+                        };
+                        if (options.minzoom !== undefined) {
+                            sourceOptions[MGLTileSourceOptionMinimumZoomLevel] = options.minzoom;
+                        }
+                        if (options.maxzoom !== undefined) {
+                            sourceOptions[MGLTileSourceOptionMaximumZoomLevel] = options.maxzoom;
+                        }
+                        if (options.scheme) {
+                            switch (options.scheme || 'xyz') {
+                                case 'xyz':
+                                    sourceOptions[MGLTileSourceOptionTileCoordinateSystem] = 0;
+                                    break;
+                                case 'tms':
+                                    sourceOptions[MGLTileSourceOptionTileCoordinateSystem] = 1;
+                                    break;
+                                default:
+                                    throw new Error('Unknown raster tile scheme.');
+                            }
+                        }
+                        if (options.bounds) {
+                            sourceOptions[MGLTileSourceOptionCoordinateBounds] = NSValue.valueWithMGLCoordinateBounds({
+                                sw: CLLocationCoordinate2DMake(options.bounds[1], options.bounds[0]),
+                                ne: CLLocationCoordinate2DMake(options.bounds[3], options.bounds[2])
+                            });
+                        }
+                        source = MGLRasterTileSource.alloc().initWithIdentifierTileURLTemplatesOptions(id, options.tiles, sourceOptions);
+                        break;
                     }
+                    default:
+                        reject('Invalid source type: ' + options['type']);
+                        return;
                 }
-                else {
+                if (!source) {
+                    const ex = 'No source to add';
                     if (Trace.isEnabled()) {
-                        CLog(CLogTypes.info, 'Please use res://resourceName, http(s)://imageUrl or iconPath to use a local path');
+                        CLog(CLogTypes.info, 'Error in mapbox.addSource: ' + ex);
                     }
+                    reject(ex);
+                    return;
                 }
+                theMap.style.addSource(source);
+                resolve();
             }
-            else if (cachedMarker.iconPath) {
-                var appPath = knownFolders.currentApp().path;
-                var iconFullPath = appPath + '/' + cachedMarker.iconPath.replace('~/', '');
-                if (File.exists(iconFullPath)) {
-                    var image = ImageSource.fromFileSync(iconFullPath).ios;
-                    // perhaps add resize options for nice retina rendering (although you can now use the 'icon' param instead)
-                    cachedMarker.reuseIdentifier = cachedMarker.iconPath;
-                    return MGLAnnotationImage.annotationImageWithImageReuseIdentifier(image, cachedMarker.reuseIdentifier);
+            catch (ex) {
+                if (Trace.isEnabled()) {
+                    CLog(CLogTypes.info, 'Error in mapbox.addSource: ' + ex);
                 }
+                reject(ex);
             }
-        }
-        return null;
-    };
-    /**
-     * fired when one of the callout's accessoryviews is tapped (not currently used)
-     */
-    MGLMapViewDelegateImpl.prototype.mapViewAnnotationCalloutAccessoryControlTapped = function (mapView, annotation, control) { };
-    /**
-     * fired when a marker is tapped
-     */
-    MGLMapViewDelegateImpl.prototype.mapViewDidSelectAnnotation = function (mapView, annotation) {
-        if (Trace.isEnabled()) {
-            CLog(CLogTypes.info, 'MGLMapViewDelegateImpl::mapViewDidSelectAnntation()');
-        }
-        if (annotation.isKindOfClass(MGLUserLocation.class())) {
-            if (Trace.isEnabled()) {
-                CLog(CLogTypes.info, 'MGLMapViewDelegateImpl::mapViewDidSelectAnnotation(): tapped the user location button');
+        });
+    }
+    removeSource(id, nativeMap) {
+        return new Promise((resolve, reject) => {
+            try {
+                const theMap = nativeMap || this._mapboxViewInstance;
+                if (!theMap) {
+                    reject('No map has been loaded');
+                    return;
+                }
+                const source = theMap.style.sourceWithIdentifier(id);
+                if (!source) {
+                    reject('Source does not exist');
+                    return;
+                }
+                theMap.style.removeSource(source);
+                resolve();
             }
-            if (typeof this.userLocationClickListener != 'undefined') {
-                this.userLocationClickListener(annotation);
-                return;
+            catch (ex) {
+                if (Trace.isEnabled()) {
+                    CLog(CLogTypes.info, 'Error in mapbox.removeSource: ' + ex);
+                }
+                reject(ex);
             }
-            mapView.deselectAnnotationAnimated(annotation, false);
-        }
-        var cachedMarker = this.getTappedMarkerDetails(annotation);
-        if (cachedMarker && cachedMarker.onTap) {
-            cachedMarker.onTap(cachedMarker);
+        });
+    }
+    async addLayer(style, belowLayerId, nativeMapView) {
+        const theMap = nativeMapView || this._mapboxViewInstance;
+        let source = null;
+        if (typeof style.source != 'string') {
+            await this.addSource(style.id + '_source', style.source);
+            source = theMap.style.sourceWithIdentifier(style.id + '_source');
         }
-    };
-    /**
-     * fired when a callout is tapped
-     */
-    MGLMapViewDelegateImpl.prototype.mapViewTapOnCalloutForAnnotation = function (mapView, annotation) {
-        var cachedMarker = this.getTappedMarkerDetails(annotation);
-        if (cachedMarker && cachedMarker.onCalloutTap) {
-            cachedMarker.onCalloutTap(cachedMarker);
+        else {
+            source = theMap.style.sourceWithIdentifier(style.source);
         }
-    };
-    MGLMapViewDelegateImpl.prototype.getTappedMarkerDetails = function (tapped) {
-        for (var m in _markers) {
-            var cached = _markers[m];
-            // don't compare lat/lng types as they're not the same (same for (sub)title, they may be null vs undefined)
-            if (
-            // eslint-disable-next-line eqeqeq
-            cached.lat == tapped.coordinate.latitude &&
-                // eslint-disable-next-line eqeqeq
-                cached.lng == tapped.coordinate.longitude &&
-                // eslint-disable-next-line eqeqeq
-                cached.title == tapped.title &&
-                // eslint-disable-next-line eqeqeq
-                cached.subtitle == tapped.subtitle) {
-                return cached;
+        const layer = await LayerFactory.createLayer(style, source);
+        if (belowLayerId) {
+            const belowlayer = theMap.style.layerWithIdentifier(belowLayerId);
+            if (belowlayer) {
+                theMap.style.insertLayerBelowLayer(layer.getNativeInstance(), belowlayer);
+                return;
             }
         }
-    };
-    /**
-     * override the standard location marker
-     */
-    MGLMapViewDelegateImpl.prototype.mapViewViewForAnnotation = function (mapView, annotation) {
+        theMap.style.addLayer(layer.getNativeInstance());
+    }
+    async removeLayer(id, nativeMapViewInstance) {
+        const theMap = nativeMapViewInstance || this._mapboxViewInstance;
         if (Trace.isEnabled()) {
-            CLog(CLogTypes.info, 'MGLMapViewDelegateImpl::mapViewViewForAnnotation() top');
-        }
-        if (annotation.isKindOfClass(MGLUserLocation.class())) {
-            this.userLocationAnnotationView = CustomUserLocationAnnotationView.alloc().init();
-            return this.userLocationAnnotationView;
+            CLog(CLogTypes.info, "Mapbox::removeLayer(): attempting to remove layer '" + id + "'");
         }
-        return null;
-    };
-    MGLMapViewDelegateImpl.prototype.mapViewRegionIsChangingWithReason = function (mapView, reason) {
+        const layer = theMap.style.layerWithIdentifier(id);
         if (Trace.isEnabled()) {
-            CLog(CLogTypes.info, 'MGLMapViewDelegateImpl::mapViewRegionIsChanging()');
+            CLog(CLogTypes.info, 'Mapbox:removeLayer(): got layer object: ', layer);
         }
-        if (this.cameraChangedListener) {
-            this.cameraChangedListener(reason);
+        if (!layer) {
+            throw new Error("Layer '" + id + "' not found when attempting to remove it.");
         }
-    };
-    MGLMapViewDelegateImpl.prototype.mapViewRegionDidChangeWithReasonAnimated = function (mapView, reason, animated) {
+        theMap.style.removeLayer(layer);
         if (Trace.isEnabled()) {
-            CLog(CLogTypes.info, 'MGLMapViewDelegateImpl::mapViewRegionDidChangeAnimated()');
-        }
-        if (this.cameraChangedListener) {
-            this.cameraChangedListener(reason, animated);
+            CLog(CLogTypes.info, 'Mapbox:removeLayer(): after removing layer ' + id);
         }
-        if (this.cameraIdledListener) {
-            this.cameraIdledListener();
+    }
+    async addLinePoint(id, lnglat, sourceId, nativeMapView) {
+        const theMap = nativeMapView || this._mapboxViewInstance;
+        const sId = !!sourceId ? sourceId : id + '_source';
+        const lineSource = theMap.style.sourceWithIdentifier(sId);
+        if (!lineSource) {
+            throw new Error(`no source found with id: ${sId}`);
         }
-    };
-    MGLMapViewDelegateImpl.prototype.mapViewDidUpdateUserLocation = function (mapView, userLocation) {
-        if (Trace.isEnabled()) {
-            CLog(CLogTypes.info, 'MGLMapViewDelegateImpl::mapViewDidUpdateUserLocation()');
+        try {
+            const lineFeatures = lineSource.featuresMatchingPredicate(ExpressionParser.parseJson(['==', '$type', 'LineString']));
+            if (lineFeatures.count === 0) {
+                throw new Error('no line string feature found');
+            }
+            const lineFeature = lineFeatures.objectAtIndex(0);
+            const newCoord = CLLocationCoordinate2DMake(lnglat[1], lnglat[0]);
+            const newCoordPointer = new interop.Reference(newCoord);
+            lineFeature.appendCoordinatesCount(newCoordPointer, 1);
+            lineSource.shape = lineFeature;
         }
-        if (this.userLocationChangedListener) {
-            this.userLocationChangedListener(_getLocation(userLocation));
+        catch (error) {
+            console.log(error);
+            throw error;
         }
-    };
-    MGLMapViewDelegateImpl.ObjCProtocols = [MGLMapViewDelegate];
-    return MGLMapViewDelegateImpl;
-}(NSObject));
-var MapTapHandlerImpl = /** @class */ (function (_super) {
-    __extends(MapTapHandlerImpl, _super);
-    function MapTapHandlerImpl() {
-        return _super !== null && _super.apply(this, arguments) || this;
     }
-    MapTapHandlerImpl.initWithOwnerAndListenerForMap = function (owner, listener, mapView) {
-        var handler = MapTapHandlerImpl.new();
-        handler._owner = owner;
-        handler._listener = listener;
-        handler._mapView = mapView;
-        return handler;
-    };
-    MapTapHandlerImpl.prototype.tap = function (recognizer) {
-        var tapPoint = recognizer.locationInView(this._mapView);
-        var tapCoordinate = this._mapView.convertPointToCoordinateFromView(tapPoint, this._mapView);
-        this._listener({
-            lat: tapCoordinate.latitude,
-            lng: tapCoordinate.longitude
-        });
-    };
-    MapTapHandlerImpl.ObjCExposedMethods = {
-        tap: { returns: interop.types.void, params: [interop.types.id] }
-    };
-    return MapTapHandlerImpl;
-}(NSObject));
-var MapLongPressHandlerImpl = /** @class */ (function (_super) {
-    __extends(MapLongPressHandlerImpl, _super);
-    function MapLongPressHandlerImpl() {
-        return _super !== null && _super.apply(this, arguments) || this;
+    addGeoJsonClustered(options, nativeMapViewInstance) {
+        throw new Error('Method not implemented.');
     }
-    MapLongPressHandlerImpl.initWithOwnerAndListenerForMap = function (owner, listener, mapView) {
-        var handler = MapLongPressHandlerImpl.new();
-        handler._owner = owner;
-        handler._listener = listener;
-        handler._mapView = mapView;
-        return handler;
-    };
-    MapLongPressHandlerImpl.prototype.longPress = function (recognizer) {
-        var longPressPoint = recognizer.locationInView(this._mapView);
-        var longPressCoordinate = this._mapView.convertPointToCoordinateFromView(longPressPoint, this._mapView);
-        this._listener({
-            lat: longPressCoordinate.latitude,
-            lng: longPressCoordinate.longitude
+    trackUser(options, nativeMap) {
+        return new Promise((resolve, reject) => {
+            try {
+                const theMap = nativeMap || this._mapboxViewInstance;
+                if (!theMap) {
+                    reject('No map has been loaded');
+                    return;
+                }
+                if (!theMap.showsUserLocation) {
+                    reject('The map is not currently showing the user location');
+                    return;
+                }
+                theMap.setUserTrackingModeAnimated(_getTrackingMode(options.cameraMode), options.animated !== false);
+                resolve();
+            }
+            catch (ex) {
+                if (Trace.isEnabled()) {
+                    CLog(CLogTypes.info, 'Error in mapbox.trackUser: ' + ex);
+                }
+                reject(ex);
+            }
         });
-    };
-    MapLongPressHandlerImpl.ObjCExposedMethods = {
-        longPress: { returns: interop.types.void, params: [interop.types.id] }
-    };
-    return MapLongPressHandlerImpl;
-}(NSObject));
-var MapPanHandlerImpl = /** @class */ (function (_super) {
-    __extends(MapPanHandlerImpl, _super);
-    function MapPanHandlerImpl() {
-        return _super !== null && _super.apply(this, arguments) || this;
     }
-    MapPanHandlerImpl.initWithOwnerAndListenerForMap = function (owner, listener, mapView) {
-        var handler = MapPanHandlerImpl.new();
-        handler._owner = owner;
-        handler._listener = listener;
-        handler._mapView = mapView;
-        handler.onMoveBegin = false;
-        return handler;
-    };
-    MapPanHandlerImpl.prototype.setOnMoveBegin = function () {
-        this.onMoveBegin = true;
-    };
-    MapPanHandlerImpl.prototype.pan = function (recognizer) {
-        var panPoint = recognizer.locationInView(this._mapView);
-        var panCoordinate = this._mapView.convertPointToCoordinateFromView(panPoint, this._mapView);
-        if (Trace.isEnabled()) {
-            CLog(CLogTypes.info, 'MapPanHandlerImpl::pan(): top with state:', recognizer.state);
-        }
-        // if this is the beginning of the pan simulate the Android onMoveBegin
-        //
-        // See the objc platform declarations in objc!UIKit.d.ts. It doesn't quite match the apple documention
-        if (this.onMoveBegin) {
-            if (recognizer.state === UIGestureRecognizerState.Began) {
+    getLayer(name, nativeMap) {
+        return new Promise((resolve, reject) => {
+            try {
+                const theMap = nativeMap || this._mapboxViewInstance;
+                if (!theMap) {
+                    reject('No map has been loaded');
+                    return;
+                }
+                const layer = theMap.style.layerWithIdentifier(name);
+                resolve(new Layer(layer));
+            }
+            catch (ex) {
                 if (Trace.isEnabled()) {
-                    CLog(CLogTypes.info, 'MapPanHandlerImpl::pan(): calling onMoveBegin listener');
+                    CLog(CLogTypes.info, 'Error in mapbox.getLayer: ' + ex);
                 }
-                this._listener({
-                    lat: panCoordinate.latitude,
-                    lng: panCoordinate.longitude
-                });
+                reject(ex);
             }
-            return;
-        }
-        this._listener({
-            lat: panCoordinate.latitude,
-            lng: panCoordinate.longitude
         });
-    };
-    MapPanHandlerImpl.ObjCExposedMethods = {
-        pan: { returns: interop.types.void, params: [interop.types.id] }
-    };
-    return MapPanHandlerImpl;
-}(NSObject));
-var MapSwipeHandlerImpl = /** @class */ (function (_super) {
-    __extends(MapSwipeHandlerImpl, _super);
-    function MapSwipeHandlerImpl() {
-        return _super !== null && _super.apply(this, arguments) || this;
     }
-    MapSwipeHandlerImpl.initWithOwnerAndListenerForMap = function (owner, listener, mapView) {
-        var handler = MapSwipeHandlerImpl.new();
-        handler._owner = owner;
-        handler._listener = listener;
-        handler._mapView = mapView;
-        return handler;
-    };
-    MapSwipeHandlerImpl.prototype.swipe = function (recognizer) {
-        var swipePoint = recognizer.locationInView(this._mapView);
-        var swipeCoordinate = this._mapView.convertPointToCoordinateFromView(swipePoint, this._mapView);
-        this._listener({
-            lat: swipeCoordinate.latitude,
-            lng: swipeCoordinate.longitude
+    getLayers(nativeMap) {
+        return new Promise((resolve, reject) => {
+            try {
+                const theMap = nativeMap || this._mapboxViewInstance;
+                if (!theMap) {
+                    reject('No map has been loaded');
+                    return;
+                }
+                const layers = theMap.style.layers;
+                const result = [];
+                for (let i = 0; i < layers.count; i++) {
+                    result.push(new Layer(layers[i]));
+                }
+                resolve(result);
+            }
+            catch (ex) {
+                if (Trace.isEnabled()) {
+                    CLog(CLogTypes.info, 'Error in mapbox.getLayers: ' + ex);
+                }
+                reject(ex);
+            }
         });
-    };
-    MapSwipeHandlerImpl.ObjCExposedMethods = {
-        swipe: { returns: interop.types.void, params: [interop.types.id] }
-    };
-    return MapSwipeHandlerImpl;
-}(NSObject));
-export class Layer {
-    constructor(instance) {
-        this.instance = instance;
-        this.id = instance.identifier;
-    }
-    visibility() {
-        return this.instance.visible;
     }
-    show() {
-        this.instance.visible = true;
-    }
-    hide() {
-        this.instance.visible = false;
+    project(data) {
+        const theMap = this._mapboxViewInstance;
+        const { x, y } = theMap.convertCoordinateToPointToView({ latitude: data.lat, longitude: data.lng }, theMap);
+        return { x, y };
     }
-    getNativeInstance() {
-        return this.instance;
+    projectBack(screenCoordinate) {
+        const theMap = this._mapboxViewInstance;
+        const cgPoint = {
+            x: screenCoordinate.x,
+            y: screenCoordinate.y
+        };
+        const coordinate = theMap.convertPointToCoordinateFromView(cgPoint, theMap);
+        return {
+            lat: coordinate.latitude,
+            lng: coordinate.longitude
+        };
     }
-    setFilter(filter) {
-        if (this.instance instanceof MGLVectorStyleLayer) {
-            this.instance.predicate = FilterParser.parseJson(filter);
+}
+const _addObserver = (eventName, callback) => NSNotificationCenter.defaultCenter.addObserverForNameObjectQueueUsingBlock(eventName, null, NSOperationQueue.mainQueue, callback);
+function _downloadImage(marker) {
+    return new Promise((resolve, reject) => {
+        if (Trace.isEnabled()) {
+            CLog(CLogTypes.info, '>> _downloadImage');
         }
-        else {
-            throw new Error('Set filter only support for vector layer.');
+        if (_markerIconDownloadCache[marker.icon]) {
+            marker.iconDownloaded = _markerIconDownloadCache[marker.icon];
+            if (Trace.isEnabled()) {
+                CLog(CLogTypes.info, '>> marker.iconDownloaded: ' + marker.iconDownloaded);
+            }
+            resolve(marker);
+            return;
         }
-    }
-    getFilter() {
-        return FilterParser.toJson(this.instance.predicate);
-    }
+        Http.getImage(marker.icon).then((output) => {
+            marker.iconDownloaded = output.ios;
+            _markerIconDownloadCache[marker.icon] = marker.iconDownloaded;
+            resolve(marker);
+        }, (ignoredError) => {
+            console.log(`Download failed for ${marker.icon} with error: ${ignoredError}`);
+            resolve(marker);
+        });
+    });
 }
-//# sourceMappingURL=mapbox.ios.js.map
+const _downloadMarkerImages = (markers) => {
+    const iterations = [];
+    const result = [];
+    markers.forEach((marker) => {
+        if (marker.icon && marker.icon.startsWith('http')) {
+            const p = _downloadImage(marker).then((mark) => result.push(mark));
+            iterations.push(p);
+        }
+        else {
+            result.push(marker);
+        }
+    });
+    return Promise.all(iterations).then(() => result);
+};
+//# sourceMappingURL=index.ios.js.map