@nativescript-community/ui-mapbox 6.2.9 → 6.2.13

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

@@ -1,10 +1,416 @@
-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 };
+import { Color, File, Http, ImageSource, Trace, Utils, knownFolders, path } from '@nativescript/core';
+import { CLog, CLogTypes, MapStyle, MapboxCommon, MapboxViewBase, telemetryProperty } from './common';
+import { Layer, LayerFactory } from './layers/layer-factory';
+import { ExpressionParser } from './expression/expression-parser';
+var MGLMapViewDelegateImpl = /** @class */ (function (_super) {
+    __extends(MGLMapViewDelegateImpl, _super);
+    function MGLMapViewDelegateImpl() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    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;
+                }
+            }
+            // 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));
+                    }
+                    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, 'Please use res://resourceName, http(s)://imageUrl or iconPath to use a local path');
+                    }
+                }
+            }
+            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;
+    };
+    /**
+     * 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');
+            }
+            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);
+        }
+    };
+    /**
+     * fired when a callout is tapped
+     */
+    MGLMapViewDelegateImpl.prototype.mapViewTapOnCalloutForAnnotation = function (mapView, annotation) {
+        var cachedMarker = this.getTappedMarkerDetails(annotation);
+        if (cachedMarker && cachedMarker.onCalloutTap) {
+            cachedMarker.onCalloutTap(cachedMarker);
+        }
+    };
+    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;
+            }
+        }
+    };
+    /**
+     * override the standard location marker
+     */
+    MGLMapViewDelegateImpl.prototype.mapViewViewForAnnotation = function (mapView, annotation) {
+        if (Trace.isEnabled()) {
+            CLog(CLogTypes.info, 'MGLMapViewDelegateImpl::mapViewViewForAnnotation() top');
+        }
+        if (annotation.isKindOfClass(MGLUserLocation.class())) {
+            this.userLocationAnnotationView = CustomUserLocationAnnotationView.alloc().init();
+            return this.userLocationAnnotationView;
+        }
+        return null;
+    };
+    MGLMapViewDelegateImpl.prototype.mapViewRegionIsChangingWithReason = function (mapView, reason) {
+        if (Trace.isEnabled()) {
+            CLog(CLogTypes.info, 'MGLMapViewDelegateImpl::mapViewRegionIsChanging()');
+        }
+        if (this.cameraChangedListener) {
+            this.cameraChangedListener(reason);
+        }
+    };
+    MGLMapViewDelegateImpl.prototype.mapViewRegionDidChangeWithReasonAnimated = function (mapView, reason, animated) {
+        if (Trace.isEnabled()) {
+            CLog(CLogTypes.info, 'MGLMapViewDelegateImpl::mapViewRegionDidChangeAnimated()');
+        }
+        if (this.cameraChangedListener) {
+            this.cameraChangedListener(reason, animated);
+        }
+        if (this.cameraIdledListener) {
+            this.cameraIdledListener();
+        }
+    };
+    MGLMapViewDelegateImpl.prototype.mapViewDidUpdateUserLocation = function (mapView, userLocation) {
+        if (Trace.isEnabled()) {
+            CLog(CLogTypes.info, 'MGLMapViewDelegateImpl::mapViewDidUpdateUserLocation()');
+        }
+        if (this.userLocationChangedListener) {
+            this.userLocationChangedListener(_getLocation(userLocation));
+        }
+    };
+    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;
+    }
+    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, 'MapPanHandlerImpl::pan(): top with state:', recognizer.state);
+        }
+        if (recognizer.state === UIGestureRecognizerState.Changed) {
+            this.notifyListener(recognizer.state, panCoordinate.latitude, panCoordinate.longitude);
+        }
+    };
+    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);
+        }
+    };
+    MapPanHandlerImpl.prototype.panBegin = function (recognizer) {
+        var panCoordinate = this.getCoordinates(recognizer);
+        if (Trace.isEnabled()) {
+            CLog(CLogTypes.info, 'MapPanHandlerImpl::panBegin(): top with state:', recognizer.state);
+        }
+        if (recognizer.state === UIGestureRecognizerState.Began) {
+            this.notifyListener(recognizer.state, panCoordinate.latitude, panCoordinate.longitude);
+        }
+    };
+    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) => {
@@ -219,6 +625,28 @@ export class MapboxView extends MapboxViewBase {
                         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);
         }
@@ -233,9 +661,6 @@ export class MapboxView extends MapboxViewBase {
         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() {
@@ -444,7 +869,6 @@ var CustomUserLocationAnnotationView = /** @class */ (function (_super) {
     };
     return CustomUserLocationAnnotationView;
 }(MGLUserLocationAnnotationView));
-exports.CustomUserLocationAnnotationView = CustomUserLocationAnnotationView;
 export class Mapbox extends MapboxCommon {
     constructor() {
         super(...arguments);
@@ -825,403 +1249,41 @@ export class Mapbox extends MapboxCommon {
                 const level = options.level;
                 if (level >= 0 && level <= 20) {
                     theMap.setZoomLevelAnimated(level, animated);
-                    resolve();
-                }
-                else {
-                    reject('invalid ZoomLevel, use any double value from 0 to 20 (like 8.3)');
-                }
-            }
-            catch (ex) {
-                if (Trace.isEnabled()) {
-                    CLog(CLogTypes.info, 'Error in mapbox.setZoomLevel: ' + ex);
-                }
-                reject(ex);
-            }
-        });
-    }
-    getZoomLevel(nativeMap) {
-        return new Promise((resolve, reject) => {
-            try {
-                const theMap = nativeMap || this._mapboxViewInstance;
-                resolve(theMap.zoomLevel);
-            }
-            catch (ex) {
-                if (Trace.isEnabled()) {
-                    CLog(CLogTypes.info, 'Error in mapbox.getZoomLevel: ' + ex);
-                }
-                reject(ex);
-            }
-        });
-    }
-    setTilt(options, nativeMap) {
-        return new Promise((resolve, reject) => {
-            try {
-                const theMap = nativeMap || this._mapboxViewInstance;
-                const cam = theMap.camera;
-                cam.pitch = options.tilt;
-                const durationMs = options.duration ? options.duration : 5000;
-                theMap.setCameraWithDurationAnimationTimingFunction(cam, durationMs / 1000, CAMediaTimingFunction.functionWithName(kCAMediaTimingFunctionEaseInEaseOut));
-                setTimeout(() => {
-                    resolve();
-                }, durationMs);
-            }
-            catch (ex) {
-                if (Trace.isEnabled()) {
-                    CLog(CLogTypes.info, 'Error in mapbox.setTilt: ' + ex);
-                }
-                reject(ex);
-            }
-        });
-    }
-    getTilt(nativeMap) {
-        return new Promise((resolve, reject) => {
-            try {
-                const theMap = nativeMap || this._mapboxViewInstance;
-                resolve(theMap.camera.pitch);
-            }
-            catch (ex) {
-                if (Trace.isEnabled()) {
-                    CLog(CLogTypes.info, 'Error in mapbox.getTilt: ' + ex);
-                }
-                reject(ex);
-            }
-        });
-    }
-    getUserLocation(nativeMap) {
-        return new Promise((resolve, reject) => {
-            try {
-                const theMap = nativeMap || this._mapboxViewInstance;
-                const loc = theMap.userLocation;
-                if (loc === null) {
-                    reject('Location not available');
-                }
-                else {
-                    resolve(_getLocation(loc));
-                }
-            }
-            catch (ex) {
-                if (Trace.isEnabled()) {
-                    CLog(CLogTypes.info, 'Error in mapbox.getUserLocation: ' + 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;
-        }
-    }
-    _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;
-                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.getUserLocation: ' + ex);
-                }
-                reject(ex);
-            }
-        });
-    }
-    hideUserLocationMarker(nativeMap) {
-        return new Promise((resolve, reject) => {
-            try {
-                resolve();
-            }
-            catch (ex) {
-                if (Trace.isEnabled()) {
-                    CLog(CLogTypes.info, 'Error in mapbox.getUserLocation: ' + ex);
-                }
-                reject(ex);
-            }
-        });
-    }
-    changeUserLocationMarkerMode(renderModeString, cameraModeString, nativeMap) {
-        return new Promise((resolve, reject) => {
-            try {
-                const theMap = nativeMap || this._mapboxViewInstance;
-                if (Trace.isEnabled()) {
-                    CLog(CLogTypes.info, "Mapbox::changeUserLocationMarkerMode(): changing renderMode to '" + renderModeString + "' cameraMode '" + cameraModeString + "'");
-                }
-                theMap.userTrackingMode = this._stringToCameraMode(cameraModeString);
-                const delegate = theMap.delegate;
-                const renderMode = this._stringToRenderMode(renderModeString);
-                delegate.changeUserLocationRenderMode(renderMode);
-            }
-            catch (ex) {
-                if (Trace.isEnabled()) {
-                    CLog(CLogTypes.info, 'Error in mapbox.showUserLocationMarker: ' + ex);
-                }
-                reject(ex);
-            }
-        });
-    }
-    forceUserLocationUpdate(location, nativeMap) { }
-    queryRenderedFeatures(options, nativeMap) {
-        return new Promise((resolve, reject) => {
-            try {
-                const theMap = nativeMap || this._mapboxViewInstance;
-                if (options.point === undefined) {
-                    reject("Please set the 'point' parameter");
-                    return;
-                }
-                if (!options) {
-                    options = {};
-                }
-                const { x, y } = theMap.convertCoordinateToPointToView({ latitude: options.point.lat, longitude: options.point.lng }, theMap);
-                const queryLayerIds = options.layers ? NSSet.setWithArray(iOSNativeHelper.collections.jsArrayToNSArray(options.layers)) : null;
-                const queryFilter = options.filter ? FilterParser.parseJson(options.filter) : null;
-                const features = theMap.visibleFeaturesAtPointInStyleLayersWithIdentifiersPredicate({ x, y }, queryLayerIds, queryFilter);
-                const result = [];
-                for (let i = 0; i < features.count; i++) {
-                    const feature = features.objectAtIndex(i);
-                    const featureJson = NSJSONSerialization.dataWithJSONObjectOptionsError(feature.geoJSONDictionary(), 0);
-                    result.push(JSON.parse(NSString.alloc().initWithDataEncoding(featureJson, NSUTF8StringEncoding)));
-                }
-                resolve(result);
-            }
-            catch (ex) {
-                if (Trace.isEnabled()) {
-                    CLog(CLogTypes.info, 'Error in mapbox.queryRenderedFeatures: ' + ex);
-                }
-                reject(ex);
-            }
-        });
-    }
-    querySourceFeatures(sourceId, options, 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);
+                    resolve();
                 }
                 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)));
+                    reject('invalid ZoomLevel, use any double value from 0 to 20 (like 8.3)');
                 }
-                resolve(result);
             }
             catch (ex) {
                 if (Trace.isEnabled()) {
-                    CLog(CLogTypes.info, 'Error in mapbox.querySourceFeatures: ' + ex);
+                    CLog(CLogTypes.info, 'Error in mapbox.setZoomLevel: ' + ex);
                 }
                 reject(ex);
             }
         });
     }
-    addPolygon(options, nativeMap) {
+    getZoomLevel(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;
+            try {
+                const theMap = nativeMap || this._mapboxViewInstance;
+                resolve(theMap.zoomLevel);
             }
-            const geoJSON = `{
-                "type": "FeatureCollection",
-                "features": [
-                {
-                    "id": ${JSON.stringify(polygonID)},
-                    "type": "Feature",
-                    "properties": {
-                    },
-                    "geometry": {
-                    "type": "Polygon",
-                    "coordinates": [${JSON.stringify(coordinateArray)}]
-                    }
+            catch (ex) {
+                if (Trace.isEnabled()) {
+                    CLog(CLogTypes.info, 'Error in mapbox.getZoomLevel: ' + ex);
                 }
-                ]
-            }`;
-            const geoDataStr = NSString.stringWithString(geoJSON);
-            const geoData = geoDataStr.dataUsingEncoding(NSUTF8StringEncoding);
-            const geoDataBase64Enc = geoData.base64EncodedStringWithOptions(0);
-            const geo = NSData.alloc().initWithBase64EncodedStringOptions(geoDataBase64Enc, null);
-            const shape = MGLShape.shapeWithDataEncodingError(geo, NSUTF8StringEncoding);
-            const source = MGLShapeSource.alloc().initWithIdentifierShapeOptions(polygonID, shape, null);
-            theMap.style.addSource(source);
-            if (options.strokeColor || options.strokeWidth || options.strokeOpacity) {
-                const strokeLayer = MGLLineStyleLayer.alloc().initWithIdentifierSource(polygonID + '_stroke', source);
-                strokeLayer.lineColor = NSExpression.expressionForConstantValue(!options.strokeColor ? UIColor.blackColor : options.strokeColor instanceof Color ? options.strokeColor.ios : new Color(options.strokeColor).ios);
-                strokeLayer.lineWidth = NSExpression.expressionForConstantValue(options.strokeWidth || 5);
-                strokeLayer.lineOpacity = NSExpression.expressionForConstantValue(options.strokeOpacity === undefined ? 1 : options.strokeOpacity);
-                theMap.style.addLayer(strokeLayer);
-            }
-            const layer = MGLFillStyleLayer.alloc().initWithIdentifierSource(polygonID, source);
-            layer.fillColor = NSExpression.expressionForConstantValue(!options.fillColor ? UIColor.blackColor : options.fillColor instanceof Color ? options.fillColor.ios : new Color(options.fillColor).ios);
-            layer.fillOpacity = NSExpression.expressionForConstantValue(options.fillOpacity === undefined ? 1 : options.fillOpacity);
-            theMap.style.addLayer(layer);
-            resolve();
-        });
-    }
-    addPolyline(options, nativeMap) {
-        return new Promise((resolve, reject) => {
-            const theMap = nativeMap || this._mapboxViewInstance;
-            const points = options.points;
-            if (points === undefined) {
-                reject("Please set the 'points' parameter");
-                return;
-            }
-            const coordinateArray = [];
-            points.forEach((point) => coordinateArray.push([point.lng, point.lat]));
-            const polylineID = 'polyline_' + (options.id || new Date().getTime());
-            if (theMap.style.sourceWithIdentifier(polylineID)) {
-                reject("Remove the polyline with this id first with 'removePolylines': " + polylineID);
-                return;
+                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();
-        });
-    }
-    removePolygons(ids, nativeMap) {
-        return this.removePolys('polygon_', ids, nativeMap);
-    }
-    removePolylines(ids, nativeMap) {
-        return this.removePolys('polyline_', ids, nativeMap);
-    }
-    animateCamera(options, nativeMap) {
+    setTilt(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);
-                }
-                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;
-                }
-                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;
+                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,336 +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 = options.padding !== undefined ? { top: options.padding, left: options.padding, bottom: options.padding, right: options.padding } : { top: 25, left: 25, bottom: 25, right: 25 };
-                theMap.setVisibleCoordinateBoundsEdgePaddingAnimated(bounds, padding, animated);
-                resolve();
+                if (!options) {
+                    options = {};
+                }
+                const { x, y } = theMap.convertCoordinateToPointToView({ latitude: options.point.lat, longitude: options.point.lng }, theMap);
+                const queryLayerIds = options.layers ? NSSet.setWithArray(Utils.ios.collections.jsArrayToNSArray(options.layers)) : null;
+                const queryFilter = options.filter ? ExpressionParser.parseJson(options.filter) : null;
+                const features = theMap.visibleFeaturesAtPointInStyleLayersWithIdentifiersPredicate({ x, y }, queryLayerIds, queryFilter);
+                const result = [];
+                for (let i = 0; i < features.count; i++) {
+                    const feature = features.objectAtIndex(i);
+                    const featureJson = NSJSONSerialization.dataWithJSONObjectOptionsError(feature.geoJSONDictionary(), 0);
+                    result.push(JSON.parse(NSString.alloc().initWithDataEncoding(featureJson, NSUTF8StringEncoding)));
+                }
+                resolve(result);
             }
             catch (ex) {
                 if (Trace.isEnabled()) {
-                    CLog(CLogTypes.info, 'Error in mapbox.setViewport: ' + ex);
+                    CLog(CLogTypes.info, 'Error in mapbox.queryRenderedFeatures: ' + ex);
                 }
                 reject(ex);
             }
         });
     }
-    downloadOfflineRegion(options) {
+    querySourceFeatures(sourceId, options, nativeMap) {
         return new Promise((resolve, reject) => {
             try {
-                const styleURL = _getMapStyle(options.style);
-                const swCoordinate = CLLocationCoordinate2DMake(options.bounds.south, options.bounds.west);
-                const neCoordinate = CLLocationCoordinate2DMake(options.bounds.north, options.bounds.east);
-                const bounds = {
-                    sw: swCoordinate,
-                    ne: neCoordinate
-                };
-                const region = MGLTilePyramidOfflineRegion.alloc().initWithStyleURLBoundsFromZoomLevelToZoomLevel(styleURL, bounds, options.minZoom, options.maxZoom);
-                if (options.accessToken) {
-                    MGLAccountManager.accessToken = options.accessToken;
+                const theMap = nativeMap || this._mapboxViewInstance;
+                if (!options) {
+                    options = {};
                 }
-                if (options.onProgress) {
-                    _addObserver(MGLOfflinePackProgressChangedNotification, (notification) => {
-                        const offlinePack = notification.object;
-                        const offlinePackProgress = offlinePack.progress;
-                        const userInfo = NSKeyedUnarchiver.unarchiveObjectWithData(offlinePack.context);
-                        const complete = offlinePackProgress.countOfResourcesCompleted === offlinePackProgress.countOfResourcesExpected;
-                        options.onProgress({
-                            name: userInfo.objectForKey('name'),
-                            completed: offlinePackProgress.countOfResourcesCompleted,
-                            expected: offlinePackProgress.countOfResourcesExpected,
-                            percentage: Math.round((offlinePackProgress.countOfResourcesCompleted / offlinePackProgress.countOfResourcesExpected) * 10000) / 100,
-                            complete
-                        });
-                        if (complete) {
-                            resolve();
-                        }
-                    });
+                const source = theMap.style.sourceWithIdentifier(sourceId);
+                if (!source) {
+                    throw new Error(`Source with id "${sourceId}" not found.`);
                 }
-                _addObserver(MGLOfflinePackErrorNotification, (notification) => {
-                    const offlinePack = notification.object;
-                    const userInfo = NSKeyedUnarchiver.unarchiveObjectWithData(offlinePack.context);
-                    const error = notification.userInfo[MGLOfflinePackUserInfoKeyError];
-                    reject({
-                        name: userInfo.objectForKey('name'),
-                        error: 'Download error. ' + error
-                    });
-                });
-                _addObserver(MGLOfflinePackMaximumMapboxTilesReachedNotification, (notification) => {
-                    const offlinePack = notification.object;
-                    const userInfo = NSKeyedUnarchiver.unarchiveObjectWithData(offlinePack.context);
-                    const maximumCount = notification.userInfo[MGLOfflinePackUserInfoKeyMaximumCount];
-                    console.log(`Offline region '${userInfo.objectForKey('name')}' reached the tile limit of ${maximumCount}`);
-                });
-                const userInfo = { name: options.name };
-                const context = NSKeyedArchiver.archivedDataWithRootObject(userInfo);
-                MGLOfflineStorage.sharedOfflineStorage.addPackForRegionWithContextCompletionHandler(region, context, (pack, error) => {
-                    if (error) {
-                        reject(error.localizedFailureReason);
-                    }
-                    else {
-                        pack.resume();
+                let features;
+                const queryFilter = options.filter ? ExpressionParser.parseJson(options.filter) : null;
+                if (source instanceof MGLShapeSource) {
+                    features = source.featuresMatchingPredicate(queryFilter);
+                }
+                else if (source instanceof MGLVectorTileSource) {
+                    if (!options.sourceLayer) {
+                        throw new Error('The option "sourceLayer" is required for vector sources.');
                     }
-                });
+                    const sourceLayerIds = options.sourceLayer ? NSSet.setWithArray(Utils.ios.collections.jsArrayToNSArray([options.sourceLayer])) : null;
+                    features = source.featuresInSourceLayersWithIdentifiersPredicate(sourceLayerIds, queryFilter);
+                }
+                else {
+                    throw new Error('Only sources from type "vector" or "geojson" are supported.');
+                }
+                const result = [];
+                for (let i = 0; i < features.count; i++) {
+                    const feature = features.objectAtIndex(i);
+                    const featureJson = NSJSONSerialization.dataWithJSONObjectOptionsError(feature.geoJSONDictionary(), 0);
+                    result.push(JSON.parse(NSString.alloc().initWithDataEncoding(featureJson, NSUTF8StringEncoding)));
+                }
+                resolve(result);
             }
             catch (ex) {
                 if (Trace.isEnabled()) {
-                    CLog(CLogTypes.info, 'Error in mapbox.downloadOfflineRegion: ' + ex);
+                    CLog(CLogTypes.info, 'Error in mapbox.querySourceFeatures: ' + ex);
                 }
                 reject(ex);
             }
         });
     }
-    listOfflineRegions(options) {
+    addPolygon(options, nativeMap) {
         return new Promise((resolve, reject) => {
-            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;
@@ -1566,17 +1667,26 @@ export class Mapbox extends MapboxCommon {
                     reject('No map has been loaded');
                     return;
                 }
+                theMap['mapTapHandler'] = MapTapHandlerImpl.initWithOwnerAndListenerForMap(new WeakRef(this), listener, theMap);
+                const tapGestureRecognizer = UITapGestureRecognizer.alloc().initWithTargetAction(theMap['mapTapHandler'], 'tap');
+                for (let i = 0; i < theMap.gestureRecognizers.count; i++) {
+                    const recognizer = theMap.gestureRecognizers.objectAtIndex(i);
+                    if (recognizer instanceof UITapGestureRecognizer) {
+                        tapGestureRecognizer.requireGestureRecognizerToFail(recognizer);
+                    }
+                }
+                theMap.addGestureRecognizer(tapGestureRecognizer);
                 resolve();
             }
             catch (ex) {
                 if (Trace.isEnabled()) {
-                    CLog(CLogTypes.info, 'Error in mapbox.deleteOfflineRegion: ' + ex);
+                    CLog(CLogTypes.info, 'Error in mapbox.setOnMapClickListener: ' + ex);
                 }
                 reject(ex);
             }
         });
     }
-    updateSource(id, options, nativeMap) {
+    setOnMapLongClickListener(listener, nativeMap) {
         return new Promise((resolve, reject) => {
             try {
                 const theMap = nativeMap || this._mapboxViewInstance;
@@ -1584,159 +1694,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) {
+    setOnScrollListener(listener, nativeMap) {
         return new Promise((resolve, reject) => {
             try {
                 const theMap = nativeMap || this._mapboxViewInstance;
-                let source;
                 if (!theMap) {
                     reject('No map has been loaded');
                     return;
                 }
-                if (theMap.style.sourceWithIdentifier(id)) {
-                    reject('Source exists: ' + id);
-                    return;
+                if (theMap['mapPanHandler'] === undefined) {
+                    theMap['mapPanHandler'] = MapPanHandlerImpl.initWithOwnerAndListenerForMap(new WeakRef(this), listener, 2, theMap);
                 }
-                switch (options.type) {
-                    case 'vector': {
-                        if (options.url) {
-                            source = MGLVectorTileSource.alloc().initWithIdentifierConfigurationURL(id, NSURL.URLWithString(options.url));
-                        }
-                        else {
-                            const sourceOptions = {};
-                            if (options.minzoom !== undefined) {
-                                sourceOptions[MGLTileSourceOptionMinimumZoomLevel] = options.minzoom;
-                            }
-                            if (options.maxzoom !== undefined) {
-                                sourceOptions[MGLTileSourceOptionMaximumZoomLevel] = options.maxzoom;
-                            }
-                            if (options.scheme) {
-                                switch (options.scheme) {
-                                    case 'xyz':
-                                        sourceOptions[MGLTileSourceOptionTileCoordinateSystem] = 0;
-                                        break;
-                                    case 'tms':
-                                        sourceOptions[MGLTileSourceOptionTileCoordinateSystem] = 1;
-                                        break;
-                                    default:
-                                        throw new Error('Unknown raster tile scheme.');
-                                }
-                            }
-                            if (options.bounds) {
-                                sourceOptions[MGLTileSourceOptionCoordinateBounds] = NSValue.valueWithMGLCoordinateBounds({
-                                    sw: CLLocationCoordinate2DMake(options.bounds[1], options.bounds[0]),
-                                    ne: CLLocationCoordinate2DMake(options.bounds[3], options.bounds[2])
-                                });
-                            }
-                            source = MGLVectorTileSource.alloc().initWithIdentifierTileURLTemplatesOptions(id, options.tiles, sourceOptions);
-                        }
-                        break;
-                    }
-                    case 'geojson':
-                        if (theMap.style.sourceWithIdentifier(id)) {
-                            reject("Remove the layer with this id first with 'removeLayer': " + id);
-                            return;
-                        }
-                        let geoJsonShape;
-                        if (options.data) {
-                            const content = NSString.stringWithString(JSON.stringify(options.data));
-                            const nsData = content.dataUsingEncoding(NSUTF8StringEncoding);
-                            geoJsonShape = MGLShape.shapeWithDataEncodingError(nsData, NSUTF8StringEncoding);
-                        }
-                        const sourceOptions = {};
-                        if (options.minzoom !== undefined) {
-                            sourceOptions[MGLShapeSourceOptionMinimumZoomLevel] = options.minzoom;
-                        }
-                        if (options.maxzoom !== undefined) {
-                            sourceOptions[MGLShapeSourceOptionMaximumZoomLevel] = options.maxzoom;
-                        }
-                        if (options.cluster) {
-                            sourceOptions[MGLShapeSourceOptionClustered] = true;
-                            sourceOptions[MGLShapeSourceOptionClusterRadius] = options.cluster.radius || 40;
-                            sourceOptions[MGLShapeSourceOptionMaximumZoomLevelForClustering] = options.cluster.maxZoom || 13;
-                        }
-                        source = MGLShapeSource.alloc().initWithIdentifierShapeOptions(id, geoJsonShape, sourceOptions);
-                        break;
-                    case 'raster': {
-                        const sourceOptions = {
-                            [MGLTileSourceOptionTileSize]: options.tileSize || 256
-                        };
-                        if (options.minzoom !== undefined) {
-                            sourceOptions[MGLTileSourceOptionMinimumZoomLevel] = options.minzoom;
-                        }
-                        if (options.maxzoom !== undefined) {
-                            sourceOptions[MGLTileSourceOptionMaximumZoomLevel] = options.maxzoom;
-                        }
-                        if (options.scheme) {
-                            switch (options.scheme || 'xyz') {
-                                case 'xyz':
-                                    sourceOptions[MGLTileSourceOptionTileCoordinateSystem] = 0;
-                                    break;
-                                case 'tms':
-                                    sourceOptions[MGLTileSourceOptionTileCoordinateSystem] = 1;
-                                    break;
-                                default:
-                                    throw new Error('Unknown raster tile scheme.');
-                            }
-                        }
-                        if (options.bounds) {
-                            sourceOptions[MGLTileSourceOptionCoordinateBounds] = NSValue.valueWithMGLCoordinateBounds({
-                                sw: CLLocationCoordinate2DMake(options.bounds[1], options.bounds[0]),
-                                ne: CLLocationCoordinate2DMake(options.bounds[3], options.bounds[2])
-                            });
-                        }
-                        source = MGLRasterTileSource.alloc().initWithIdentifierTileURLTemplatesOptions(id, options.tiles, sourceOptions);
+                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;
@@ -1744,109 +1783,246 @@ 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.");
+    setOnCameraMoveCancelListener(listener, nativeMap) {
+        return Promise.reject("'setOnCameraMoveCancelListener' not currently supported on iOS");
+    }
+    async setOnCameraIdleListener(listener, nativeMap) {
+        const theMap = nativeMap || this._mapboxViewInstance;
+        if (theMap) {
+            theMap.delegate.setCameraIdledListener(listener);
         }
-        theMap.style.removeLayer(layer);
-        if (Trace.isEnabled()) {
-            CLog(CLogTypes.info, 'Mapbox:removeLayer(): after removing layer ' + id);
+        else {
+            return Promise.reject('No map has been loaded');
         }
     }
-    async addLinePoint(id, lnglat, sourceId, nativeMapView) {
-        const theMap = nativeMapView || this._mapboxViewInstance;
-        const sId = !!sourceId ? sourceId : id + '_source';
-        const lineSource = theMap.style.sourceWithIdentifier(sId);
-        if (!lineSource) {
-            throw new Error(`no source found with id: ${sId}`);
-        }
-        try {
-            const lineFeatures = lineSource.featuresMatchingPredicate(FilterParser.parseJson(['==', '$type', 'LineString']));
-            if (lineFeatures.count === 0) {
-                throw new Error('no line string feature found');
+    getViewport(nativeMap) {
+        return new Promise((resolve, reject) => {
+            try {
+                const theMap = nativeMap || this._mapboxViewInstance;
+                if (!theMap) {
+                    reject('No map has been loaded');
+                    return;
+                }
+                const visibleBounds = theMap.visibleCoordinateBounds;
+                const bounds = {
+                    north: visibleBounds.ne.latitude,
+                    east: visibleBounds.ne.longitude,
+                    south: visibleBounds.sw.latitude,
+                    west: visibleBounds.sw.longitude
+                };
+                resolve({
+                    bounds,
+                    zoomLevel: theMap.zoomLevel
+                });
+            }
+            catch (ex) {
+                if (Trace.isEnabled()) {
+                    CLog(CLogTypes.info, 'Error in mapbox.getViewport: ' + ex);
+                }
+                reject(ex);
+            }
+        });
+    }
+    setViewport(options, nativeMap) {
+        return new Promise((resolve, reject) => {
+            try {
+                const theMap = nativeMap || this._mapboxViewInstance;
+                if (!theMap) {
+                    reject('No map has been loaded');
+                    return;
+                }
+                const bounds = {
+                    sw: CLLocationCoordinate2DMake(options.bounds.south, options.bounds.west),
+                    ne: CLLocationCoordinate2DMake(options.bounds.north, options.bounds.east)
+                };
+                const animated = options.animated === undefined || options.animated;
+                const padding = options.padding !== undefined ? { top: options.padding, left: options.padding, bottom: options.padding, right: options.padding } : { top: 25, left: 25, bottom: 25, right: 25 };
+                theMap.setVisibleCoordinateBoundsEdgePaddingAnimated(bounds, padding, animated);
+                resolve();
+            }
+            catch (ex) {
+                if (Trace.isEnabled()) {
+                    CLog(CLogTypes.info, 'Error in mapbox.setViewport: ' + ex);
+                }
+                reject(ex);
+            }
+        });
+    }
+    downloadOfflineRegion(options) {
+        return new Promise((resolve, reject) => {
+            try {
+                const styleURL = _getMapStyle(options.style);
+                const swCoordinate = CLLocationCoordinate2DMake(options.bounds.south, options.bounds.west);
+                const neCoordinate = CLLocationCoordinate2DMake(options.bounds.north, options.bounds.east);
+                const bounds = {
+                    sw: swCoordinate,
+                    ne: neCoordinate
+                };
+                const region = MGLTilePyramidOfflineRegion.alloc().initWithStyleURLBoundsFromZoomLevelToZoomLevel(styleURL, bounds, options.minZoom, options.maxZoom);
+                if (options.accessToken) {
+                    MGLAccountManager.accessToken = options.accessToken;
+                }
+                if (options.onProgress) {
+                    _addObserver(MGLOfflinePackProgressChangedNotification, (notification) => {
+                        const offlinePack = notification.object;
+                        const offlinePackProgress = offlinePack.progress;
+                        const userInfo = NSKeyedUnarchiver.unarchiveObjectWithData(offlinePack.context);
+                        const complete = offlinePackProgress.countOfResourcesCompleted === offlinePackProgress.countOfResourcesExpected;
+                        options.onProgress({
+                            name: userInfo.objectForKey('name'),
+                            completed: offlinePackProgress.countOfResourcesCompleted,
+                            expected: offlinePackProgress.countOfResourcesExpected,
+                            percentage: Math.round((offlinePackProgress.countOfResourcesCompleted / offlinePackProgress.countOfResourcesExpected) * 10000) / 100,
+                            complete
+                        });
+                        if (complete) {
+                            resolve();
+                        }
+                    });
+                }
+                _addObserver(MGLOfflinePackErrorNotification, (notification) => {
+                    const offlinePack = notification.object;
+                    const userInfo = NSKeyedUnarchiver.unarchiveObjectWithData(offlinePack.context);
+                    const error = notification.userInfo[MGLOfflinePackUserInfoKeyError];
+                    reject({
+                        name: userInfo.objectForKey('name'),
+                        error: 'Download error. ' + error
+                    });
+                });
+                _addObserver(MGLOfflinePackMaximumMapboxTilesReachedNotification, (notification) => {
+                    const offlinePack = notification.object;
+                    const userInfo = NSKeyedUnarchiver.unarchiveObjectWithData(offlinePack.context);
+                    const maximumCount = notification.userInfo[MGLOfflinePackUserInfoKeyMaximumCount];
+                    console.log(`Offline region '${userInfo.objectForKey('name')}' reached the tile limit of ${maximumCount}`);
+                });
+                const userInfo = { name: options.name };
+                const context = NSKeyedArchiver.archivedDataWithRootObject(userInfo);
+                MGLOfflineStorage.sharedOfflineStorage.addPackForRegionWithContextCompletionHandler(region, context, (pack, error) => {
+                    if (error) {
+                        reject(error.localizedFailureReason);
+                    }
+                    else {
+                        pack.resume();
+                    }
+                });
+            }
+            catch (ex) {
+                if (Trace.isEnabled()) {
+                    CLog(CLogTypes.info, 'Error in mapbox.downloadOfflineRegion: ' + ex);
+                }
+                reject(ex);
+            }
+        });
+    }
+    listOfflineRegions(options) {
+        return new Promise((resolve, reject) => {
+            try {
+                const packs = MGLOfflineStorage.sharedOfflineStorage.packs;
+                if (!packs) {
+                    reject('No packs found or Mapbox not ready yet');
+                    return;
+                }
+                const regions = [];
+                for (let i = 0; i < packs.count; i++) {
+                    const pack = packs.objectAtIndex(i);
+                    const region = pack.region;
+                    const userInfo = NSKeyedUnarchiver.unarchiveObjectWithData(pack.context);
+                    regions.push({
+                        name: userInfo.objectForKey('name'),
+                        style: '' + region.styleURL,
+                        minZoom: region.minimumZoomLevel,
+                        maxZoom: region.maximumZoomLevel,
+                        bounds: {
+                            north: region.bounds.ne.latitude,
+                            east: region.bounds.ne.longitude,
+                            south: region.bounds.sw.latitude,
+                            west: region.bounds.sw.longitude
+                        }
+                    });
+                }
+                resolve(regions);
+            }
+            catch (ex) {
+                if (Trace.isEnabled()) {
+                    CLog(CLogTypes.info, 'Error in mapbox.listOfflineRegions: ' + ex);
+                }
+                reject(ex);
             }
-            const lineFeature = lineFeatures.objectAtIndex(0);
-            const newCoord = CLLocationCoordinate2DMake(lnglat[1], lnglat[0]);
-            const newCoordPointer = new interop.Reference(newCoord);
-            lineFeature.appendCoordinatesCount(newCoordPointer, 1);
-            lineSource.shape = lineFeature;
-        }
-        catch (error) {
-            console.log(error);
-            throw error;
-        }
-    }
-    addGeoJsonClustered(options, nativeMapViewInstance) {
-        throw new Error('Method not implemented.');
+        });
     }
-    trackUser(options, nativeMap) {
+    deleteOfflineRegion(options) {
         return new Promise((resolve, reject) => {
             try {
-                const theMap = nativeMap || this._mapboxViewInstance;
-                if (!theMap) {
-                    reject('No map has been loaded');
+                if (!options || (!options.id && !options.name)) {
+                    reject("Pass in the 'id' or 'name' param");
                     return;
                 }
-                if (!theMap.showsUserLocation) {
-                    reject('The map is not currently showing the user location');
-                    return;
+                const packs = MGLOfflineStorage.sharedOfflineStorage.packs;
+                let found = false;
+                for (let i = 0; i < packs.count; i++) {
+                    const pack = packs.objectAtIndex(i);
+                    const userInfo = NSKeyedUnarchiver.unarchiveObjectWithData(pack.context);
+                    const regionId = options.id ? userInfo.objectForKey('id') : userInfo.objectForKey('name');
+                    if (regionId === (options.id || options.name)) {
+                        found = true;
+                        MGLOfflineStorage.sharedOfflineStorage.removePackWithCompletionHandler(pack, (error) => {
+                            if (error) {
+                                reject(error.localizedFailureReason);
+                            }
+                            else {
+                                resolve();
+                            }
+                        });
+                    }
+                }
+                if (!found) {
+                    reject('Region not found');
                 }
-                theMap.setUserTrackingModeAnimated(_getTrackingMode(options.mode), options.animated !== false);
-                resolve();
             }
             catch (ex) {
                 if (Trace.isEnabled()) {
-                    CLog(CLogTypes.info, 'Error in mapbox.trackUser: ' + ex);
+                    CLog(CLogTypes.info, 'Error in mapbox.deleteOfflineRegion: ' + ex);
                 }
                 reject(ex);
             }
         });
     }
-    getLayer(name, nativeMap) {
+    addExtrusion(options, nativeMap) {
         return new Promise((resolve, reject) => {
             try {
                 const theMap = nativeMap || this._mapboxViewInstance;
@@ -1854,18 +2030,17 @@ export class Mapbox extends MapboxCommon {
                     reject('No map has been loaded');
                     return;
                 }
-                const layer = theMap.style.layerWithIdentifier(name);
-                resolve(new Layer(layer));
+                resolve();
             }
             catch (ex) {
                 if (Trace.isEnabled()) {
-                    CLog(CLogTypes.info, 'Error in mapbox.getLayer: ' + ex);
+                    CLog(CLogTypes.info, 'Error in mapbox.deleteOfflineRegion: ' + ex);
                 }
                 reject(ex);
             }
         });
     }
-    getLayers(nativeMap) {
+    updateSource(id, options, nativeMap) {
         return new Promise((resolve, reject) => {
             try {
                 const theMap = nativeMap || this._mapboxViewInstance;
@@ -1873,489 +2048,364 @@ export class Mapbox extends MapboxCommon {
                     reject('No map has been loaded');
                     return;
                 }
-                const layers = theMap.style.layers;
-                const result = [];
-                for (let i = 0; i < layers.count; i++) {
-                    result.push(new Layer(layers[i]));
-                }
-                resolve(result);
-            }
-            catch (ex) {
-                if (Trace.isEnabled()) {
-                    CLog(CLogTypes.info, 'Error in mapbox.getLayers: ' + ex);
+                const source = theMap.style.sourceWithIdentifier(id);
+                if (!source) {
+                    reject('Source does not exists: ' + id);
+                    return;
                 }
-                reject(ex);
-            }
-        });
-    }
-    project(data) {
-        const theMap = this._mapboxViewInstance;
-        const { x, y } = theMap.convertCoordinateToPointToView({ latitude: data.lat, longitude: data.lng }, theMap);
-        return { x, y };
-    }
-}
-const _addObserver = (eventName, callback) => NSNotificationCenter.defaultCenter.addObserverForNameObjectQueueUsingBlock(eventName, null, NSOperationQueue.mainQueue, callback);
-function _downloadImage(marker) {
-    return new Promise((resolve, reject) => {
-        if (Trace.isEnabled()) {
-            CLog(CLogTypes.info, '>> _downloadImage');
-        }
-        if (_markerIconDownloadCache[marker.icon]) {
-            marker.iconDownloaded = _markerIconDownloadCache[marker.icon];
-            if (Trace.isEnabled()) {
-                CLog(CLogTypes.info, '>> marker.iconDownloaded: ' + marker.iconDownloaded);
-            }
-            resolve(marker);
-            return;
-        }
-        getImage(marker.icon).then((output) => {
-            marker.iconDownloaded = output.ios;
-            _markerIconDownloadCache[marker.icon] = marker.iconDownloaded;
-            resolve(marker);
-        }, (ignoredError) => {
-            console.log(`Download failed for ${marker.icon} with error: ${ignoredError}`);
-            resolve(marker);
-        });
-    });
-}
-const _downloadMarkerImages = (markers) => {
-    const iterations = [];
-    const result = [];
-    markers.forEach((marker) => {
-        if (marker.icon && marker.icon.startsWith('http')) {
-            const p = _downloadImage(marker).then((mark) => result.push(mark));
-            iterations.push(p);
-        }
-        else {
-            result.push(marker);
-        }
-    });
-    return Promise.all(iterations).then(() => result);
-};
-var MGLMapViewDelegateImpl = /** @class */ (function (_super) {
-    __extends(MGLMapViewDelegateImpl, _super);
-    function MGLMapViewDelegateImpl() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    MGLMapViewDelegateImpl.new = function () {
-        return _super.new.call(this);
-    };
-    /**
-     * initialize with the mapReady callback
-     */
-    MGLMapViewDelegateImpl.prototype.initWithCallback = function (mapLoadedCallback) {
-        if (Trace.isEnabled()) {
-            CLog(CLogTypes.info, 'MGLMapViewDelegateImpl::initWithCallback()');
-        }
-        this.mapLoadedCallback = mapLoadedCallback;
-        return this;
-    };
-    /**
-     * set a reference to the mapboxAPI instance
-     */
-    MGLMapViewDelegateImpl.prototype.setMapboxApi = function (api) {
-        this.mapboxApi = api;
-    };
-    /**
-     * set the user location click listener callback
-     */
-    MGLMapViewDelegateImpl.prototype.setUserLocationClickListener = function (callback) {
-        this.userLocationClickListener = callback;
-    };
-    /**
-     * set the user location click listener callback
-     */
-    MGLMapViewDelegateImpl.prototype.setUserLocationChangedistener = function (callback) {
-        this.userLocationChangedListener = callback;
-    };
-    /**
-     * set user location marker modes
-     */
-    MGLMapViewDelegateImpl.prototype.changeUserLocationRenderMode = function (userLocationRenderMode) {
-        this.userLocationAnnotationView.changeUserLocationRenderMode(userLocationRenderMode);
-    };
-    /**
-     * set the camera changd listener callback
-     */
-    MGLMapViewDelegateImpl.prototype.setCameraChangedListener = function (callback) {
-        this.cameraChangedListener = callback;
-    };
-    /**
-     * set the camera idled listener callback
-     */
-    MGLMapViewDelegateImpl.prototype.setCameraIdledListener = function (callback) {
-        this.cameraIdledListener = callback;
-    };
-    /**
-     * set style loaded callback.
-     *
-     * set an optional callback to be invoked when a style set with
-     * setMapStyle() is finished loading
-     *
-     * @param {function} callback function with loaded style as parameter.
-     *
-     * @see Mapbox:setMapStyle()
-     */
-    MGLMapViewDelegateImpl.prototype.setStyleLoadedCallback = function (callback) {
-        this.styleLoadedCallback = callback;
-    };
-    /**
-     * map ready callback
-     */
-    MGLMapViewDelegateImpl.prototype.mapViewDidFinishLoadingMap = function (mapView) {
-        if (Trace.isEnabled()) {
-            CLog(CLogTypes.info, 'MGLMapViewDelegateImpl:mapViewDidFinishLoadingMap(): top');
-        }
-        if (this.mapLoadedCallback !== undefined) {
-            this.mapLoadedCallback(mapView);
-            // this should be fired only once, but it's also fired when the style changes, so just remove the callback
-            this.mapLoadedCallback = undefined;
-        }
-    };
-    MGLMapViewDelegateImpl.prototype.mapViewDidFinishRenderingMapFullyRendered = function (mapView, fullyRendered) {
-        if (Trace.isEnabled()) {
-            CLog(CLogTypes.info, 'MGLMapViewDelegateImpl:mapViewDidFinishRenderingMapFullyRendered(): rendered is:', fullyRendered);
-        }
-    };
-    /**
-     * Callback when the style has been loaded.
-     *
-     * Based on my testing, it looks like this callback is invoked multiple times.
-     *
-     * @see Mapbox:setMapStyle()
-     *
-     * @link https://mapbox.github.io/mapbox-gl-native/macos/0.3.0/Protocols/MGLMapViewDelegate.html#/c:objc(pl)MGLMapViewDelegate(im)mapView:didFinishLoadingStyle:
-     */
-    MGLMapViewDelegateImpl.prototype.mapViewDidFinishLoadingStyle = function (mapView, style) {
-        if (Trace.isEnabled()) {
-            CLog(CLogTypes.info, 'MGLMapViewDelegateImpl:mapViewDidFinishLoadingStyle(): callback called.');
-        }
-        if (this.styleLoadedCallback !== undefined) {
-            this.styleLoadedCallback(mapView, style);
-            // to avoid multiple calls. This is only invoked from setMapStyle().
-            this.styleLoadedCallback = undefined;
-        }
-    };
-    /**
-     * disable the default user location callout
-     *
-     * This took forever to find. The default iOS click handler for the user location
-     * marker is about useless. It just displays "You Are Here". The examples do not
-     * show how to disable it.
-     */
-    MGLMapViewDelegateImpl.prototype.mapViewAnnotationCanShowCallout = function (mapView, annotation) {
-        if (annotation.isKindOfClass(MGLUserLocation.class())) {
-            return false;
-        }
-        else {
-            return true;
-        }
-    };
-    MGLMapViewDelegateImpl.prototype.mapViewDidFailLoadingMapWithError = function (mapView, error) {
-        if (Trace.isEnabled()) {
-            CLog(CLogTypes.info, 'mapViewDidFailLoadingMapWithError: ' + error);
-        }
-    };
-    MGLMapViewDelegateImpl.prototype.mapViewDidChangeUserTrackingModeAnimated = function (mapView, mode, animated) {
-        if (Trace.isEnabled()) {
-            CLog(CLogTypes.info, 'mapViewDidChangeUserTrackingModeAnimated: ' + mode);
-        }
-    };
-    /**
-     * fired when the marker icon is about to be rendered - return null for the default icon
-     */
-    MGLMapViewDelegateImpl.prototype.mapViewImageForAnnotation = function (mapView, annotation) {
-        var cachedMarker = this.getTappedMarkerDetails(annotation);
-        if (cachedMarker) {
-            if (cachedMarker.reuseIdentifier) {
-                var reusedImage = mapView.dequeueReusableAnnotationImageWithIdentifier(cachedMarker.reuseIdentifier);
-                if (reusedImage) {
-                    return reusedImage;
+                switch (options.type) {
+                    case 'geojson':
+                        const content = NSString.stringWithString(JSON.stringify(options.data));
+                        const nsData = content.dataUsingEncoding(NSUTF8StringEncoding);
+                        const geoJsonShape = MGLShape.shapeWithDataEncodingError(nsData, NSUTF8StringEncoding);
+                        source.shape = geoJsonShape;
+                        break;
+                    default:
+                        reject('Invalid source type: ' + options['type']);
+                        return;
                 }
             }
-            // TODO try adding .rotatesToMatchCamera = true;
-            // .. for instance in the mapViewDidDeselectAnnotationView / mapViewDidSelectAnnotationView / mapViewViewForAnnotation delegate
-            if (cachedMarker.icon) {
-                if (cachedMarker.icon.startsWith('res://')) {
-                    var resourceName = cachedMarker.icon.substring('res://'.length);
-                    var imageSource = ImageSource.fromResourceSync(resourceName);
-                    if (imageSource === null) {
-                        console.log("Unable to locate " + resourceName);
-                    }
-                    else {
-                        cachedMarker.reuseIdentifier = cachedMarker.icon;
-                        return MGLAnnotationImage.annotationImageWithImageReuseIdentifier(imageSource.ios, cachedMarker.reuseIdentifier);
-                    }
+            catch (ex) {
+                if (Trace.isEnabled()) {
+                    CLog(CLogTypes.info, 'Error in mapbox.addSource: ' + ex);
                 }
-                else if (cachedMarker.icon.startsWith('http')) {
-                    if (cachedMarker.iconDownloaded !== null) {
-                        cachedMarker.reuseIdentifier = cachedMarker.icon;
-                        return MGLAnnotationImage.annotationImageWithImageReuseIdentifier(cachedMarker.iconDownloaded, cachedMarker.reuseIdentifier);
+                reject(ex);
+            }
+        });
+    }
+    addSource(id, options, nativeMap) {
+        return new Promise((resolve, reject) => {
+            try {
+                const theMap = nativeMap || this._mapboxViewInstance;
+                let source;
+                if (!theMap) {
+                    reject('No map has been loaded');
+                    return;
+                }
+                if (theMap.style.sourceWithIdentifier(id)) {
+                    reject('Source exists: ' + id);
+                    return;
+                }
+                switch (options.type) {
+                    case 'vector': {
+                        if (options.url) {
+                            source = MGLVectorTileSource.alloc().initWithIdentifierConfigurationURL(id, NSURL.URLWithString(options.url));
+                        }
+                        else {
+                            const sourceOptions = {};
+                            if (options.minzoom !== undefined) {
+                                sourceOptions[MGLTileSourceOptionMinimumZoomLevel] = options.minzoom;
+                            }
+                            if (options.maxzoom !== undefined) {
+                                sourceOptions[MGLTileSourceOptionMaximumZoomLevel] = options.maxzoom;
+                            }
+                            if (options.scheme) {
+                                switch (options.scheme) {
+                                    case 'xyz':
+                                        sourceOptions[MGLTileSourceOptionTileCoordinateSystem] = 0;
+                                        break;
+                                    case 'tms':
+                                        sourceOptions[MGLTileSourceOptionTileCoordinateSystem] = 1;
+                                        break;
+                                    default:
+                                        throw new Error('Unknown raster tile scheme.');
+                                }
+                            }
+                            if (options.bounds) {
+                                sourceOptions[MGLTileSourceOptionCoordinateBounds] = NSValue.valueWithMGLCoordinateBounds({
+                                    sw: CLLocationCoordinate2DMake(options.bounds[1], options.bounds[0]),
+                                    ne: CLLocationCoordinate2DMake(options.bounds[3], options.bounds[2])
+                                });
+                            }
+                            source = MGLVectorTileSource.alloc().initWithIdentifierTileURLTemplatesOptions(id, options.tiles, sourceOptions);
+                        }
+                        break;
+                    }
+                    case 'geojson':
+                        if (theMap.style.sourceWithIdentifier(id)) {
+                            reject("Remove the layer with this id first with 'removeLayer': " + id);
+                            return;
+                        }
+                        let geoJsonShape;
+                        if (options.data) {
+                            const content = NSString.stringWithString(JSON.stringify(options.data));
+                            const nsData = content.dataUsingEncoding(NSUTF8StringEncoding);
+                            geoJsonShape = MGLShape.shapeWithDataEncodingError(nsData, NSUTF8StringEncoding);
+                        }
+                        const sourceOptions = {};
+                        if (options.minzoom !== undefined) {
+                            sourceOptions[MGLShapeSourceOptionMinimumZoomLevel] = options.minzoom;
+                        }
+                        if (options.maxzoom !== undefined) {
+                            sourceOptions[MGLShapeSourceOptionMaximumZoomLevel] = options.maxzoom;
+                        }
+                        if (options.cluster) {
+                            sourceOptions[MGLShapeSourceOptionClustered] = true;
+                            sourceOptions[MGLShapeSourceOptionClusterRadius] = options.cluster.radius || 40;
+                            sourceOptions[MGLShapeSourceOptionMaximumZoomLevelForClustering] = options.cluster.maxZoom || 13;
+                            if (options.cluster.properties) {
+                                const clusterProperties = {};
+                                for (const property of Object.keys(options.cluster.properties)) {
+                                    let [operator, operand] = options.cluster.properties[property];
+                                    if (!Array.isArray(operator)) {
+                                        operator = [operator];
+                                    }
+                                    const expressions = Utils.ios.collections.jsArrayToNSArray([ExpressionParser.parseJson(operator), ExpressionParser.parseJson(operand)]);
+                                    clusterProperties[property] = expressions;
+                                }
+                                sourceOptions[MGLShapeSourceOptionClusterProperties] = clusterProperties;
+                            }
+                        }
+                        source = MGLShapeSource.alloc().initWithIdentifierShapeOptions(id, geoJsonShape, sourceOptions);
+                        break;
+                    case 'raster': {
+                        const sourceOptions = {
+                            [MGLTileSourceOptionTileSize]: options.tileSize || 256
+                        };
+                        if (options.minzoom !== undefined) {
+                            sourceOptions[MGLTileSourceOptionMinimumZoomLevel] = options.minzoom;
+                        }
+                        if (options.maxzoom !== undefined) {
+                            sourceOptions[MGLTileSourceOptionMaximumZoomLevel] = options.maxzoom;
+                        }
+                        if (options.scheme) {
+                            switch (options.scheme || 'xyz') {
+                                case 'xyz':
+                                    sourceOptions[MGLTileSourceOptionTileCoordinateSystem] = 0;
+                                    break;
+                                case 'tms':
+                                    sourceOptions[MGLTileSourceOptionTileCoordinateSystem] = 1;
+                                    break;
+                                default:
+                                    throw new Error('Unknown raster tile scheme.');
+                            }
+                        }
+                        if (options.bounds) {
+                            sourceOptions[MGLTileSourceOptionCoordinateBounds] = NSValue.valueWithMGLCoordinateBounds({
+                                sw: CLLocationCoordinate2DMake(options.bounds[1], options.bounds[0]),
+                                ne: CLLocationCoordinate2DMake(options.bounds[3], options.bounds[2])
+                            });
+                        }
+                        source = MGLRasterTileSource.alloc().initWithIdentifierTileURLTemplatesOptions(id, options.tiles, sourceOptions);
+                        break;
                     }
+                    default:
+                        reject('Invalid source type: ' + options['type']);
+                        return;
                 }
-                else {
+                if (!source) {
+                    const ex = 'No source to add';
                     if (Trace.isEnabled()) {
-                        CLog(CLogTypes.info, 'Please use res://resourceName, http(s)://imageUrl or iconPath to use a local path');
+                        CLog(CLogTypes.info, 'Error in mapbox.addSource: ' + ex);
                     }
+                    reject(ex);
+                    return;
                 }
+                theMap.style.addSource(source);
+                resolve();
             }
-            else if (cachedMarker.iconPath) {
-                var appPath = knownFolders.currentApp().path;
-                var iconFullPath = appPath + '/' + cachedMarker.iconPath.replace('~/', '');
-                if (File.exists(iconFullPath)) {
-                    var image = ImageSource.fromFileSync(iconFullPath).ios;
-                    // perhaps add resize options for nice retina rendering (although you can now use the 'icon' param instead)
-                    cachedMarker.reuseIdentifier = cachedMarker.iconPath;
-                    return MGLAnnotationImage.annotationImageWithImageReuseIdentifier(image, cachedMarker.reuseIdentifier);
+            catch (ex) {
+                if (Trace.isEnabled()) {
+                    CLog(CLogTypes.info, 'Error in mapbox.addSource: ' + ex);
                 }
+                reject(ex);
             }
-        }
-        return null;
-    };
-    /**
-     * fired when one of the callout's accessoryviews is tapped (not currently used)
-     */
-    MGLMapViewDelegateImpl.prototype.mapViewAnnotationCalloutAccessoryControlTapped = function (mapView, annotation, control) { };
-    /**
-     * fired when a marker is tapped
-     */
-    MGLMapViewDelegateImpl.prototype.mapViewDidSelectAnnotation = function (mapView, annotation) {
-        if (Trace.isEnabled()) {
-            CLog(CLogTypes.info, 'MGLMapViewDelegateImpl::mapViewDidSelectAnntation()');
-        }
-        if (annotation.isKindOfClass(MGLUserLocation.class())) {
-            if (Trace.isEnabled()) {
-                CLog(CLogTypes.info, 'MGLMapViewDelegateImpl::mapViewDidSelectAnnotation(): tapped the user location button');
+        });
+    }
+    removeSource(id, nativeMap) {
+        return new Promise((resolve, reject) => {
+            try {
+                const theMap = nativeMap || this._mapboxViewInstance;
+                if (!theMap) {
+                    reject('No map has been loaded');
+                    return;
+                }
+                const source = theMap.style.sourceWithIdentifier(id);
+                if (!source) {
+                    reject('Source does not exist');
+                    return;
+                }
+                theMap.style.removeSource(source);
+                resolve();
             }
-            if (typeof this.userLocationClickListener != 'undefined') {
-                this.userLocationClickListener(annotation);
-                return;
+            catch (ex) {
+                if (Trace.isEnabled()) {
+                    CLog(CLogTypes.info, 'Error in mapbox.removeSource: ' + ex);
+                }
+                reject(ex);
             }
-            mapView.deselectAnnotationAnimated(annotation, false);
-        }
-        var cachedMarker = this.getTappedMarkerDetails(annotation);
-        if (cachedMarker && cachedMarker.onTap) {
-            cachedMarker.onTap(cachedMarker);
+        });
+    }
+    async addLayer(style, belowLayerId, nativeMapView) {
+        const theMap = nativeMapView || this._mapboxViewInstance;
+        let source = null;
+        if (typeof style.source != 'string') {
+            await this.addSource(style.id + '_source', style.source);
+            source = theMap.style.sourceWithIdentifier(style.id + '_source');
         }
-    };
-    /**
-     * fired when a callout is tapped
-     */
-    MGLMapViewDelegateImpl.prototype.mapViewTapOnCalloutForAnnotation = function (mapView, annotation) {
-        var cachedMarker = this.getTappedMarkerDetails(annotation);
-        if (cachedMarker && cachedMarker.onCalloutTap) {
-            cachedMarker.onCalloutTap(cachedMarker);
+        else {
+            source = theMap.style.sourceWithIdentifier(style.source);
         }
-    };
-    MGLMapViewDelegateImpl.prototype.getTappedMarkerDetails = function (tapped) {
-        for (var m in _markers) {
-            var cached = _markers[m];
-            // don't compare lat/lng types as they're not the same (same for (sub)title, they may be null vs undefined)
-            if (
-            // eslint-disable-next-line eqeqeq
-            cached.lat == tapped.coordinate.latitude &&
-                // eslint-disable-next-line eqeqeq
-                cached.lng == tapped.coordinate.longitude &&
-                // eslint-disable-next-line eqeqeq
-                cached.title == tapped.title &&
-                // eslint-disable-next-line eqeqeq
-                cached.subtitle == tapped.subtitle) {
-                return cached;
+        const layer = await LayerFactory.createLayer(style, source);
+        if (belowLayerId) {
+            const belowlayer = theMap.style.layerWithIdentifier(belowLayerId);
+            if (belowlayer) {
+                theMap.style.insertLayerBelowLayer(layer.getNativeInstance(), belowlayer);
+                return;
             }
         }
-    };
-    /**
-     * override the standard location marker
-     */
-    MGLMapViewDelegateImpl.prototype.mapViewViewForAnnotation = function (mapView, annotation) {
-        if (Trace.isEnabled()) {
-            CLog(CLogTypes.info, 'MGLMapViewDelegateImpl::mapViewViewForAnnotation() top');
-        }
-        if (annotation.isKindOfClass(MGLUserLocation.class())) {
-            this.userLocationAnnotationView = CustomUserLocationAnnotationView.alloc().init();
-            return this.userLocationAnnotationView;
+        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 + "'");
         }
-        return null;
-    };
-    MGLMapViewDelegateImpl.prototype.mapViewRegionIsChangingWithReason = function (mapView, reason) {
+        const layer = theMap.style.layerWithIdentifier(id);
         if (Trace.isEnabled()) {
-            CLog(CLogTypes.info, 'MGLMapViewDelegateImpl::mapViewRegionIsChanging()');
+            CLog(CLogTypes.info, 'Mapbox:removeLayer(): got layer object: ', layer);
         }
-        if (this.cameraChangedListener) {
-            this.cameraChangedListener(reason);
+        if (!layer) {
+            throw new Error("Layer '" + id + "' not found when attempting to remove it.");
         }
-    };
-    MGLMapViewDelegateImpl.prototype.mapViewRegionDidChangeWithReasonAnimated = function (mapView, reason, animated) {
+        theMap.style.removeLayer(layer);
         if (Trace.isEnabled()) {
-            CLog(CLogTypes.info, 'MGLMapViewDelegateImpl::mapViewRegionDidChangeAnimated()');
-        }
-        if (this.cameraChangedListener) {
-            this.cameraChangedListener(reason, animated);
+            CLog(CLogTypes.info, 'Mapbox:removeLayer(): after removing layer ' + id);
         }
-        if (this.cameraIdledListener) {
-            this.cameraIdledListener();
+    }
+    async addLinePoint(id, lnglat, sourceId, nativeMapView) {
+        const theMap = nativeMapView || this._mapboxViewInstance;
+        const sId = !!sourceId ? sourceId : id + '_source';
+        const lineSource = theMap.style.sourceWithIdentifier(sId);
+        if (!lineSource) {
+            throw new Error(`no source found with id: ${sId}`);
         }
-    };
-    MGLMapViewDelegateImpl.prototype.mapViewDidUpdateUserLocation = function (mapView, userLocation) {
-        if (Trace.isEnabled()) {
-            CLog(CLogTypes.info, 'MGLMapViewDelegateImpl::mapViewDidUpdateUserLocation()');
+        try {
+            const lineFeatures = lineSource.featuresMatchingPredicate(ExpressionParser.parseJson(['==', '$type', 'LineString']));
+            if (lineFeatures.count === 0) {
+                throw new Error('no line string feature found');
+            }
+            const lineFeature = lineFeatures.objectAtIndex(0);
+            const newCoord = CLLocationCoordinate2DMake(lnglat[1], lnglat[0]);
+            const newCoordPointer = new interop.Reference(newCoord);
+            lineFeature.appendCoordinatesCount(newCoordPointer, 1);
+            lineSource.shape = lineFeature;
         }
-        if (this.userLocationChangedListener) {
-            this.userLocationChangedListener(_getLocation(userLocation));
+        catch (error) {
+            console.log(error);
+            throw error;
         }
-    };
-    MGLMapViewDelegateImpl.ObjCProtocols = [MGLMapViewDelegate];
-    return MGLMapViewDelegateImpl;
-}(NSObject));
-var MapTapHandlerImpl = /** @class */ (function (_super) {
-    __extends(MapTapHandlerImpl, _super);
-    function MapTapHandlerImpl() {
-        return _super !== null && _super.apply(this, arguments) || this;
     }
-    MapTapHandlerImpl.initWithOwnerAndListenerForMap = function (owner, listener, mapView) {
-        var handler = MapTapHandlerImpl.new();
-        handler._owner = owner;
-        handler._listener = listener;
-        handler._mapView = mapView;
-        return handler;
-    };
-    MapTapHandlerImpl.prototype.tap = function (recognizer) {
-        var tapPoint = recognizer.locationInView(this._mapView);
-        var tapCoordinate = this._mapView.convertPointToCoordinateFromView(tapPoint, this._mapView);
-        this._listener({
-            lat: tapCoordinate.latitude,
-            lng: tapCoordinate.longitude
-        });
-    };
-    MapTapHandlerImpl.ObjCExposedMethods = {
-        tap: { returns: interop.types.void, params: [interop.types.id] }
-    };
-    return MapTapHandlerImpl;
-}(NSObject));
-var MapLongPressHandlerImpl = /** @class */ (function (_super) {
-    __extends(MapLongPressHandlerImpl, _super);
-    function MapLongPressHandlerImpl() {
-        return _super !== null && _super.apply(this, arguments) || this;
+    addGeoJsonClustered(options, nativeMapViewInstance) {
+        throw new Error('Method not implemented.');
     }
-    MapLongPressHandlerImpl.initWithOwnerAndListenerForMap = function (owner, listener, mapView) {
-        var handler = MapLongPressHandlerImpl.new();
-        handler._owner = owner;
-        handler._listener = listener;
-        handler._mapView = mapView;
-        return handler;
-    };
-    MapLongPressHandlerImpl.prototype.longPress = function (recognizer) {
-        var longPressPoint = recognizer.locationInView(this._mapView);
-        var longPressCoordinate = this._mapView.convertPointToCoordinateFromView(longPressPoint, this._mapView);
-        this._listener({
-            lat: longPressCoordinate.latitude,
-            lng: longPressCoordinate.longitude
+    trackUser(options, nativeMap) {
+        return new Promise((resolve, reject) => {
+            try {
+                const theMap = nativeMap || this._mapboxViewInstance;
+                if (!theMap) {
+                    reject('No map has been loaded');
+                    return;
+                }
+                if (!theMap.showsUserLocation) {
+                    reject('The map is not currently showing the user location');
+                    return;
+                }
+                theMap.setUserTrackingModeAnimated(_getTrackingMode(options.cameraMode), options.animated !== false);
+                resolve();
+            }
+            catch (ex) {
+                if (Trace.isEnabled()) {
+                    CLog(CLogTypes.info, 'Error in mapbox.trackUser: ' + ex);
+                }
+                reject(ex);
+            }
         });
-    };
-    MapLongPressHandlerImpl.ObjCExposedMethods = {
-        longPress: { returns: interop.types.void, params: [interop.types.id] }
-    };
-    return MapLongPressHandlerImpl;
-}(NSObject));
-var MapPanHandlerImpl = /** @class */ (function (_super) {
-    __extends(MapPanHandlerImpl, _super);
-    function MapPanHandlerImpl() {
-        return _super !== null && _super.apply(this, arguments) || this;
     }
-    MapPanHandlerImpl.initWithOwnerAndListenerForMap = function (owner, listener, mapView) {
-        var handler = MapPanHandlerImpl.new();
-        handler._owner = owner;
-        handler._listener = listener;
-        handler._mapView = mapView;
-        handler.onMoveBegin = false;
-        return handler;
-    };
-    MapPanHandlerImpl.prototype.setOnMoveBegin = function () {
-        this.onMoveBegin = true;
-    };
-    MapPanHandlerImpl.prototype.pan = function (recognizer) {
-        var panPoint = recognizer.locationInView(this._mapView);
-        var panCoordinate = this._mapView.convertPointToCoordinateFromView(panPoint, this._mapView);
-        if (Trace.isEnabled()) {
-            CLog(CLogTypes.info, 'MapPanHandlerImpl::pan(): top with state:', recognizer.state);
-        }
-        // if this is the beginning of the pan simulate the Android onMoveBegin
-        //
-        // See the objc platform declarations in objc!UIKit.d.ts. It doesn't quite match the apple documention
-        if (this.onMoveBegin) {
-            if (recognizer.state === UIGestureRecognizerState.Began) {
+    getLayer(name, nativeMap) {
+        return new Promise((resolve, reject) => {
+            try {
+                const theMap = nativeMap || this._mapboxViewInstance;
+                if (!theMap) {
+                    reject('No map has been loaded');
+                    return;
+                }
+                const layer = theMap.style.layerWithIdentifier(name);
+                resolve(new Layer(layer));
+            }
+            catch (ex) {
                 if (Trace.isEnabled()) {
-                    CLog(CLogTypes.info, 'MapPanHandlerImpl::pan(): calling onMoveBegin listener');
+                    CLog(CLogTypes.info, 'Error in mapbox.getLayer: ' + ex);
                 }
-                this._listener({
-                    lat: panCoordinate.latitude,
-                    lng: panCoordinate.longitude
-                });
+                reject(ex);
             }
-            return;
-        }
-        this._listener({
-            lat: panCoordinate.latitude,
-            lng: panCoordinate.longitude
         });
-    };
-    MapPanHandlerImpl.ObjCExposedMethods = {
-        pan: { returns: interop.types.void, params: [interop.types.id] }
-    };
-    return MapPanHandlerImpl;
-}(NSObject));
-var MapSwipeHandlerImpl = /** @class */ (function (_super) {
-    __extends(MapSwipeHandlerImpl, _super);
-    function MapSwipeHandlerImpl() {
-        return _super !== null && _super.apply(this, arguments) || this;
     }
-    MapSwipeHandlerImpl.initWithOwnerAndListenerForMap = function (owner, listener, mapView) {
-        var handler = MapSwipeHandlerImpl.new();
-        handler._owner = owner;
-        handler._listener = listener;
-        handler._mapView = mapView;
-        return handler;
-    };
-    MapSwipeHandlerImpl.prototype.swipe = function (recognizer) {
-        var swipePoint = recognizer.locationInView(this._mapView);
-        var swipeCoordinate = this._mapView.convertPointToCoordinateFromView(swipePoint, this._mapView);
-        this._listener({
-            lat: swipeCoordinate.latitude,
-            lng: swipeCoordinate.longitude
+    getLayers(nativeMap) {
+        return new Promise((resolve, reject) => {
+            try {
+                const theMap = nativeMap || this._mapboxViewInstance;
+                if (!theMap) {
+                    reject('No map has been loaded');
+                    return;
+                }
+                const layers = theMap.style.layers;
+                const result = [];
+                for (let i = 0; i < layers.count; i++) {
+                    result.push(new Layer(layers[i]));
+                }
+                resolve(result);
+            }
+            catch (ex) {
+                if (Trace.isEnabled()) {
+                    CLog(CLogTypes.info, 'Error in mapbox.getLayers: ' + ex);
+                }
+                reject(ex);
+            }
         });
-    };
-    MapSwipeHandlerImpl.ObjCExposedMethods = {
-        swipe: { returns: interop.types.void, params: [interop.types.id] }
-    };
-    return MapSwipeHandlerImpl;
-}(NSObject));
-export class Layer {
-    constructor(instance) {
-        this.instance = instance;
-        this.id = instance.identifier;
-    }
-    visibility() {
-        return this.instance.visible;
-    }
-    show() {
-        this.instance.visible = true;
     }
-    hide() {
-        this.instance.visible = false;
-    }
-    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