npm - @nativescript-community/ui-mapbox - Versions diffs - 6.2.8 → 6.2.12 - Mend

@nativescript-community/ui-mapbox 6.2.8 → 6.2.12

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (27) hide show

package/CHANGELOG.md +36 -0
package/README.md +199 -99
package/{mapbox.common.d.ts → common.d.ts} +17 -3
package/{mapbox.common.js → common.js} +18 -1
package/filter/filter-parser.d.ts +4 -0
package/{mapbox.android.d.ts → index.android.d.ts} +5 -14
package/{mapbox.android.js → index.android.js} +130 -64
package/index.d.ts +98 -6
package/{mapbox.ios.d.ts → index.ios.d.ts} +3 -30
package/{mapbox.ios.js → index.ios.js} +1926 -1893
package/layers/layer-factory.android.d.ts +14 -1
package/layers/layer-factory.android.js +33 -2
package/layers/layer-factory.d.ts +15 -1
package/layers/layer-factory.ios.d.ts +14 -1
package/layers/layer-factory.ios.js +42 -2
package/layers/parser/property-parser.android.d.ts +1 -0
package/layers/parser/property-parser.android.js +25 -0
package/layers/parser/property-parser.d.ts +4 -0
package/layers/parser/property-parser.ios.d.ts +1 -0
package/layers/parser/property-parser.ios.js +21 -0
package/package.json +55 -49
package/platforms/android/include.gradle +4 -1
package/platforms/android/ui_mapbox.aar +0 -0
package/platforms/ios/Podfile +2 -2
package/LICENSE +0 -21
package/pnpm-lock.yaml +0 -10
package/typings/index.d.ts +0 -8

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

@@ -1,1227 +1,1289 @@
-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 { FilterParser } from './filter/filter-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('~/', '');
+    setConfig(settings) {
+        if (Trace.isEnabled()) {
+            CLog(CLogTypes.info, 'setConfig(): settings:', settings);
+        }
+        this.settings = settings;
+    }
+    getNativeMapView() {
+        return this.nativeMapView;
+    }
+    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?');
             }
-            const img = ImageSource.fromFileOrResourceSync(image);
-            try {
-                theMap.style.setImageForName(img.ios, imageId);
-                resolve();
+            if (this.initCountHack > 50) {
+                return;
             }
-            catch (ex) {
-                reject('Error during addImage: ' + ex);
-                if (Trace.isEnabled()) {
-                    CLog(CLogTypes.info, 'Error in mapbox.addImage: ' + ex);
-                }
-                throw ex;
+            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
+                    });
+                });
+                _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();
+            }
+            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 = {};
     }
-    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;
-            }
-        });
+    setMapboxViewInstance(mapboxViewInstance) {
+        this._mapboxViewInstance = mapboxViewInstance;
     }
-    addMarkers(markers, nativeMap) {
-        return new Promise((resolve, reject) => {
-            try {
-                const theMap = nativeMap || this._mapboxViewInstance;
-                this._addMarkers(markers, theMap);
-                resolve();
-            }
-            catch (ex) {
-                if (Trace.isEnabled()) {
-                    CLog(CLogTypes.info, 'Error in mapbox.addMarkers: ' + ex);
-                }
-                reject(ex);
-            }
+    initEventHandlerShim(settings, mapboxNativeViewInstance) {
+        if (Trace.isEnabled()) {
+            CLog(CLogTypes.info, 'Mapbox:initEventHandlerShim(): top');
+        }
+        this.setOnMapClickListener((point) => this.checkForClickEvent(point), mapboxNativeViewInstance);
+    }
+    onMapEvent(eventName, id, callback, nativeMapView) {
+        if (typeof this.eventCallbacks[eventName] == 'undefined') {
+            this.eventCallbacks[eventName] = [];
+        }
+        this.eventCallbacks[eventName].push({
+            id,
+            callback
         });
     }
-    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);
+    offMapEvent(eventName, id, nativeMapView) {
+        if (typeof this.eventCallbacks[eventName] == 'undefined') {
+            return;
+        }
+        this.eventCallbacks[eventName] = this.eventCallbacks[eventName].filter((entry) => entry.id !== id);
+    }
+    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);
                 });
-                if (ids) {
-                    _markers = _markers.filter((marker) => ids.indexOf(marker.id) < 0);
-                }
-                else {
-                    _markers = [];
-                }
-                if (markersToRemove.length > 0) {
-                    theMap.removeAnnotations(markersToRemove);
-                }
-                resolve();
-            }
-            catch (ex) {
-                if (Trace.isEnabled()) {
-                    CLog(CLogTypes.info, 'Error in mapbox.removeMarkers: ' + ex);
-                }
-                reject(ex);
-            }
-        });
+            });
+        this.view && this.view.notify({ eventName: 'mapClick', object: this.view, point });
+        return false;
     }
-    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);
+    _addMarkers(markers, nativeMap) {
+        if (!markers) {
+            if (Trace.isEnabled()) {
+                CLog(CLogTypes.info, 'No markers passed');
             }
-        });
-    }
-    getCenter(nativeMap) {
-        return new Promise((resolve, reject) => {
-            try {
-                const theMap = nativeMap || this._mapboxViewInstance;
-                const coordinate = theMap.centerCoordinate;
-                resolve({
-                    lat: coordinate.latitude,
-                    lng: coordinate.longitude
-                });
+            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.getCenter: ' + 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);
+                            }
+                        }
+                    });
+                };
+            });
         });
     }
-    setZoomLevel(options, nativeMap) {
+    show(options) {
+        if (Trace.isEnabled()) {
+            CLog(CLogTypes.info, 'show(): top with options:', options);
+        }
         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);
+                const settings = Mapbox.merge(options, Mapbox.defaults);
+                if (settings.accessToken === undefined) {
+                    reject("Please set the 'accessToken' parameter");
+                    return;
                 }
-                reject(ex);
-            }
-        });
-    }
-    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);
+                if (this._mapboxViewInstance) {
+                    this._mapboxViewInstance.removeFromSuperview();
                 }
-                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));
+                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(() => {
-                    resolve();
-                }, durationMs);
+                    view.addSubview(this._mapboxViewInstance);
+                }, 500);
             }
             catch (ex) {
                 if (Trace.isEnabled()) {
-                    CLog(CLogTypes.info, 'Error in mapbox.setTilt: ' + ex);
+                    CLog(CLogTypes.info, 'Error in mapbox.show: ' + ex);
                 }
                 reject(ex);
             }
         });
     }
-    getTilt(nativeMap) {
+    hide() {
         return new Promise((resolve, reject) => {
             try {
-                const theMap = nativeMap || this._mapboxViewInstance;
-                resolve(theMap.camera.pitch);
+                if (this._mapboxViewInstance) {
+                    this._mapboxViewInstance.removeFromSuperview();
+                }
+                resolve();
             }
             catch (ex) {
                 if (Trace.isEnabled()) {
-                    CLog(CLogTypes.info, 'Error in mapbox.getTilt: ' + ex);
+                    CLog(CLogTypes.info, 'Error in mapbox.hide: ' + ex);
                 }
                 reject(ex);
             }
         });
     }
-    getUserLocation(nativeMap) {
+    unhide() {
         return new Promise((resolve, reject) => {
             try {
-                const theMap = nativeMap || this._mapboxViewInstance;
-                const loc = theMap.userLocation;
-                if (loc === null) {
-                    reject('Location not available');
+                if (this._mapboxViewInstance) {
+                    const view = UIApplication.sharedApplication.keyWindow.rootViewController.view;
+                    view.addSubview(this._mapboxViewInstance);
+                    resolve();
                 }
                 else {
-                    resolve(_getLocation(loc));
+                    reject('No map found');
                 }
             }
             catch (ex) {
                 if (Trace.isEnabled()) {
-                    CLog(CLogTypes.info, 'Error in mapbox.getUserLocation: ' + ex);
+                    CLog(CLogTypes.info, 'Error in mapbox.unhide: ' + ex);
                 }
                 reject(ex);
             }
         });
     }
-    _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;
-        }
+    destroy(nativeMap) {
+        return new Promise((resolve, reject) => {
+            const theMap = nativeMap || this._mapboxViewInstance;
+            if (theMap) {
+                theMap.removeFromSuperview();
+                theMap.delegate = null;
+            }
+            resolve();
+        });
     }
-    _stringToRenderMode(mode) {
-        let renderMode;
-        switch (mode) {
-            case 'NORMAL':
-                return 'NORMAL';
-            case 'COMPASS':
-                return 'COMPASS';
-            case 'GPS':
-                return 'GPS';
-        }
+    onStart(nativeMap) {
+        return Promise.resolve();
     }
-    showUserLocationMarker(options, nativeMap) {
+    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;
-                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);
-                }
-                resolve();
+                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.getUserLocation: ' + ex);
+                    CLog(CLogTypes.info, 'Error in mapbox.setMapStyle: ' + ex);
                 }
                 reject(ex);
             }
         });
     }
-    hideUserLocationMarker(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 {
-                resolve();
+                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.getUserLocation: ' + ex);
+                    CLog(CLogTypes.info, 'Error in mapbox.getImage: ' + ex);
                 }
-                reject(ex);
+                throw ex;
             }
         });
     }
-    changeUserLocationMarkerMode(renderModeString, cameraModeString, nativeMap) {
+    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 {
-                const theMap = nativeMap || this._mapboxViewInstance;
-                if (Trace.isEnabled()) {
-                    CLog(CLogTypes.info, "Mapbox::changeUserLocationMarkerMode(): changing renderMode to '" + renderModeString + "' cameraMode '" + cameraModeString + "'");
-                }
-                theMap.userTrackingMode = this._stringToCameraMode(cameraModeString);
-                const delegate = theMap.delegate;
-                const renderMode = this._stringToRenderMode(renderModeString);
-                delegate.changeUserLocationRenderMode(renderMode);
+                theMap.style.setImageForName(img.ios, imageId);
+                resolve();
             }
             catch (ex) {
+                reject('Error during addImage: ' + ex);
                 if (Trace.isEnabled()) {
-                    CLog(CLogTypes.info, 'Error in mapbox.showUserLocationMarker: ' + ex);
+                    CLog(CLogTypes.info, 'Error in mapbox.addImage: ' + ex);
                 }
-                reject(ex);
+                throw ex;
             }
         });
     }
-    forceUserLocationUpdate(location, nativeMap) { }
-    queryRenderedFeatures(options, nativeMap) {
+    async removeImage(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.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);
+                theMap.style.removeImageForName(imageId);
+                resolve();
             }
             catch (ex) {
+                reject('Error during removeImage: ' + ex);
                 if (Trace.isEnabled()) {
-                    CLog(CLogTypes.info, 'Error in mapbox.queryRenderedFeatures: ' + ex);
+                    CLog(CLogTypes.info, 'Error in mapbox.removeImage: ' + ex);
                 }
-                reject(ex);
+                throw ex;
             }
         });
     }
-    querySourceFeatures(sourceId, options, nativeMap) {
+    addMarkers(markers, nativeMap) {
         return new Promise((resolve, reject) => {
             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);
+                this._addMarkers(markers, theMap);
+                resolve();
             }
             catch (ex) {
                 if (Trace.isEnabled()) {
-                    CLog(CLogTypes.info, 'Error in mapbox.querySourceFeatures: ' + ex);
+                    CLog(CLogTypes.info, 'Error in mapbox.addMarkers: ' + ex);
                 }
                 reject(ex);
             }
         });
     }
-    addPolygon(options, nativeMap) {
+    removeMarkers(ids, 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)}]
+            try {
+                const theMap = nativeMap || this._mapboxViewInstance;
+                const markersToRemove = [];
+                _markers.forEach((marker) => {
+                    if (!ids || (marker.id && ids.indexOf(marker.id) > -1)) {
+                        markersToRemove.push(marker.ios);
                     }
+                });
+                if (ids) {
+                    _markers = _markers.filter((marker) => ids.indexOf(marker.id) < 0);
                 }
-                ]
-            }`;
-            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);
+                else {
+                    _markers = [];
+                }
+                if (markersToRemove.length > 0) {
+                    theMap.removeAnnotations(markersToRemove);
+                }
+                resolve();
+            }
+            catch (ex) {
+                if (Trace.isEnabled()) {
+                    CLog(CLogTypes.info, 'Error in mapbox.removeMarkers: ' + ex);
+                }
+                reject(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) {
+    setCenter(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;
+            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();
             }
-            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;
+            catch (ex) {
+                if (Trace.isEnabled()) {
+                    CLog(CLogTypes.info, 'Error in mapbox.setCenter: ' + ex);
+                }
+                reject(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();
+    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);
+            }
         });
     }
-    removePolygons(ids, nativeMap) {
-        return this.removePolys('polygon_', ids, nativeMap);
-    }
-    removePolylines(ids, nativeMap) {
-        return this.removePolys('polyline_', ids, nativeMap);
-    }
-    animateCamera(options, nativeMap) {
+    setZoomLevel(options, 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);
+                const animated = options.animated === undefined || options.animated;
+                const level = options.level;
+                if (level >= 0 && level <= 20) {
+                    theMap.setZoomLevelAnimated(level, animated);
+                    resolve();
                 }
                 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);
-                }
-                if (options.altitude) {
-                    cam.altitude = options.altitude;
-                }
-                if (options.bearing) {
-                    cam.heading = options.bearing;
+                    reject('invalid ZoomLevel, use any double value from 0 to 20 (like 8.3)');
                 }
-                if (options.tilt) {
-                    cam.pitch = options.tilt;
+            }
+            catch (ex) {
+                if (Trace.isEnabled()) {
+                    CLog(CLogTypes.info, 'Error in mapbox.setZoomLevel: ' + ex);
                 }
-                if (options.zoomLevel && options.target) {
-                    cam.altitude = MGLAltitudeForZoomLevel(options.zoomLevel, cam.pitch, options.target.lat, theMap.frame.size);
+                reject(ex);
+            }
+        });
+    }
+    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);
                 }
-                const durationMs = options.duration ? options.duration : 10000;
+                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();
@@ -1229,341 +1291,375 @@ export class Mapbox extends MapboxCommon {
             }
             catch (ex) {
                 if (Trace.isEnabled()) {
-                    CLog(CLogTypes.info, 'Error in mapbox.animateCamera: ' + ex);
+                    CLog(CLogTypes.info, 'Error in mapbox.setTilt: ' + ex);
                 }
                 reject(ex);
             }
         });
     }
-    setOnMapClickListener(listener, nativeMap) {
+    getTilt(nativeMap) {
         return new Promise((resolve, reject) => {
             try {
                 const theMap = nativeMap || this._mapboxViewInstance;
-                if (!theMap) {
-                    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();
+                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);
             }
         });
     }
-    setOnMapLongClickListener(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['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);
-                    }
+                else {
+                    resolve(_getLocation(loc));
                 }
-                theMap.addGestureRecognizer(longPressGestureRecognizer);
-                resolve();
             }
             catch (ex) {
                 if (Trace.isEnabled()) {
-                    CLog(CLogTypes.info, 'Error in mapbox.setOnMapClickListener: ' + ex);
+                    CLog(CLogTypes.info, 'Error in mapbox.getUserLocation: ' + ex);
                 }
                 reject(ex);
             }
         });
     }
-    setOnScrollListener(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['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;
-                    }
+                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);
                 }
                 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) {
+    hideUserLocationMarker(nativeMap) {
         return new Promise((resolve, reject) => {
             try {
-                const theMap = nativeMap || this._mapboxViewInstance;
-                if (!theMap) {
-                    reject('No map has been loaded');
-                    return;
-                }
-                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.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 = Mapbox.merge(options.padding === undefined ? {} : 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 ? 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);
             }
             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 ? 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(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) => {
-            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
-                        }
-                    });
+            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)}]
+                    }
                 }
-                resolve(regions);
+                ]
+            }`;
+            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;
             }
-            catch (ex) {
-                if (Trace.isEnabled()) {
-                    CLog(CLogTypes.info, 'Error in mapbox.listOfflineRegions: ' + ex);
-                }
-                reject(ex);
+            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();
         });
     }
-    deleteOfflineRegion(options) {
+    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 {
-                if (!options || !options.name) {
-                    reject("Pass in the 'name' param");
-                    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 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();
-                            }
-                        });
+                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);
                 }
-                if (!found) {
-                    reject('Region not found');
+                if (options.altitude) {
+                    cam.altitude = options.altitude;
+                }
+                if (options.bearing) {
+                    cam.heading = options.bearing;
+                }
+                if (options.tilt) {
+                    cam.pitch = options.tilt;
+                }
+                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;
@@ -1571,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;
@@ -1589,159 +1694,88 @@ 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) {
-        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.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);
+        });
+    }
+    setOnScrollListener(listener, nativeMap) {
+        return new Promise((resolve, reject) => {
+            try {
+                const theMap = nativeMap || this._mapboxViewInstance;
+                if (!theMap) {
+                    reject('No map has been loaded');
+                    return;
+                }
+                if (theMap['mapPanHandler'] === undefined) {
+                    theMap['mapPanHandler'] = MapPanHandlerImpl.initWithOwnerAndListenerForMap(new WeakRef(this), listener, 2, theMap);
+                }
+                else {
+                    theMap['mapPanHandler'].addListener(2, listener);
+                }
+                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;
                     }
-                    default:
-                        reject('Invalid source type: ' + options['type']);
-                        return;
                 }
-                if (!source) {
-                    const ex = 'No source to add';
-                    if (Trace.isEnabled()) {
-                        CLog(CLogTypes.info, 'Error in mapbox.addSource: ' + ex);
-                    }
-                    reject(ex);
+                resolve();
+            }
+            catch (ex) {
+                if (Trace.isEnabled()) {
+                    CLog(CLogTypes.info, 'Error in mapbox.setOnScrollListener: ' + ex);
+                }
+                reject(ex);
+            }
+        });
+    }
+    setOnMoveBeginListener(listener, nativeMap) {
+        return new Promise((resolve, reject) => {
+            try {
+                const theMap = nativeMap || this._mapboxViewInstance;
+                if (!theMap) {
+                    reject('No map has been loaded');
                     return;
                 }
-                theMap.style.addSource(source);
+                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.addSource: ' + ex);
+                    CLog(CLogTypes.info, 'Error in mapbox.setOnMoveBeginListener: ' + ex);
                 }
                 reject(ex);
             }
         });
     }
-    removeSource(id, nativeMap) {
+    setOnMoveEndListener(listener, nativeMap) {
         return new Promise((resolve, reject) => {
             try {
                 const theMap = nativeMap || this._mapboxViewInstance;
@@ -1749,86 +1783,82 @@ 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');
-                    return;
+                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;
+                    }
                 }
-                theMap.style.removeSource(source);
                 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.");
-        }
-        theMap.style.removeLayer(layer);
-        if (Trace.isEnabled()) {
-            CLog(CLogTypes.info, 'Mapbox:removeLayer(): after removing layer ' + id);
-        }
+    setOnCameraMoveCancelListener(listener, nativeMap) {
+        return Promise.reject("'setOnCameraMoveCancelListener' not currently supported on iOS");
     }
-    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');
-            }
-            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;
+    async setOnCameraIdleListener(listener, nativeMap) {
+        const theMap = nativeMap || this._mapboxViewInstance;
+        if (theMap) {
+            theMap.delegate.setCameraIdledListener(listener);
         }
-        catch (error) {
-            console.log(error);
-            throw error;
+        else {
+            return Promise.reject('No map has been loaded');
         }
     }
-    addGeoJsonClustered(options, nativeMapViewInstance) {
-        throw new Error('Method not implemented.');
+    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);
+            }
+        });
     }
-    trackUser(options, nativeMap) {
+    setViewport(options, nativeMap) {
         return new Promise((resolve, reject) => {
             try {
                 const theMap = nativeMap || this._mapboxViewInstance;
@@ -1836,41 +1866,163 @@ export class Mapbox extends MapboxCommon {
                     reject('No map has been loaded');
                     return;
                 }
-                if (!theMap.showsUserLocation) {
-                    reject('The map is not currently showing the user location');
-                    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
+                        }
+                    });
                 }
-                theMap.setUserTrackingModeAnimated(_getTrackingMode(options.mode), options.animated !== false);
-                resolve();
+                resolve(regions);
             }
             catch (ex) {
                 if (Trace.isEnabled()) {
-                    CLog(CLogTypes.info, 'Error in mapbox.trackUser: ' + ex);
+                    CLog(CLogTypes.info, 'Error in mapbox.listOfflineRegions: ' + ex);
                 }
                 reject(ex);
             }
         });
     }
-    getLayer(name, 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;
                 }
-                const layer = theMap.style.layerWithIdentifier(name);
-                resolve(new Layer(layer));
+                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');
+                }
             }
             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) {
+    addExtrusion(options, nativeMap) {
         return new Promise((resolve, reject) => {
             try {
                 const theMap = nativeMap || this._mapboxViewInstance;
@@ -1878,489 +2030,370 @@ 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);
+                resolve();
             }
             catch (ex) {
                 if (Trace.isEnabled()) {
-                    CLog(CLogTypes.info, 'Error in mapbox.getLayers: ' + ex);
+                    CLog(CLogTypes.info, 'Error in mapbox.deleteOfflineRegion: ' + ex);
                 }
                 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;
+    updateSource(id, options, 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 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;
                 }
             }
-            // 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.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 {
+                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(FilterParser.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;
-    }
-    getNativeInstance() {
-        return this.instance;
+    project(data) {
+        const theMap = this._mapboxViewInstance;
+        const { x, y } = theMap.convertCoordinateToPointToView({ latitude: data.lat, longitude: data.lng }, theMap);
+        return { x, y };
     }
-    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