@nativescript-community/ui-mapbox 6.2.31 → 7.0.0-alpha.14.3191a7b

package/index.d.ts

@@ -1,5 +1,36 @@
 import { ImageSource } from '@nativescript/core';
-import { AddExtrusionOptions, AddGeoJsonClusteredOptions, AddPolygonOptions, AddPolylineOptions, AddSourceOptions, AnimateCameraOptions, DeleteOfflineRegionOptions, DownloadOfflineRegionOptions, Feature, LatLng, LayerCommon, ListOfflineRegionsOptions, MapboxApi, MapboxCommon, MapboxMarker, MapboxViewBase, MapStyle, OfflineRegion, QueryRenderedFeaturesOptions, QuerySourceFeaturesOptions, SetCenterOptions, SetTiltOptions, SetViewportOptions, SetZoomLevelOptions, ShowOptions, TrackUserOptions, UpdateSourceOptions, UserLocation, UserLocationCameraMode, Viewport } from './common';
+import {
+    AddExtrusionOptions,
+    AddGeoJsonClusteredOptions,
+    AddPolygonOptions,
+    AddPolylineOptions,
+    AddSourceOptions,
+    AnimateCameraOptions,
+    DeleteOfflineRegionOptions,
+    DownloadOfflineRegionOptions,
+    Feature,
+    LatLng,
+    LayerCommon,
+    ListOfflineRegionsOptions,
+    MapStyle,
+    MapboxApi,
+    MapboxCommon,
+    MapboxMarker,
+    MapboxViewBase,
+    OfflineRegion,
+    QueryRenderedFeaturesOptions,
+    QuerySourceFeaturesOptions,
+    SetCenterOptions,
+    SetTiltOptions,
+    SetViewportOptions,
+    SetZoomLevelOptions,
+    ShowOptions,
+    TrackUserOptions,
+    UpdateSourceOptions,
+    UserLocation,
+    UserLocationCameraMode,
+    Viewport
+} from './common';
 
 // Export any shared classes, constants, etc.
 export * from './common';
@@ -13,7 +44,7 @@ export declare class MapboxView extends MapboxViewBase {
     private initCountHack;
     setConfig(settings: any): void;
     getNativeMapView(): any;
-    createNativeView(): Object;
+    createNativeView(): object;
     onLoaded(): void;
     initNativeView(): void;
     disposeNativeView(): Promise<void>;
@@ -58,7 +89,7 @@ export declare class Mapbox extends MapboxCommon implements MapboxApi {
     _stringToRenderMode(mode: any): any;
     showUserLocationMarker(options: any, nativeMap?: any): Promise<void>;
     hideUserLocationMarker(nativeMap?: any): Promise<void>;
-    changeUserLocationMarkerMode(renderModeString: any, cameraModeString: UserLocationCameraMode, nativeMap?: any): Promise<void>;
+    // changeUserLocationMarkerMode(renderModeString: any, cameraModeString: UserLocationCameraMode, nativeMap?: any): Promise<void>;
     forceUserLocationUpdate(location: any, nativeMap?: any): void;
     queryRenderedFeatures(options: QueryRenderedFeaturesOptions, nativeMap?: any): Promise<Feature[]>;
     querySourceFeatures(sourceId: string, options?: QuerySourceFeaturesOptions, nativeMap?: any): Promise<Feature[]>;
@@ -76,7 +107,7 @@ export declare class Mapbox extends MapboxCommon implements MapboxApi {
     setOnFlingListener(listener: () => void, nativeMap?: any): Promise<void>;
     setOnCameraMoveListener(listener: (reason: any, animated?: any) => void, nativeMap?: any): Promise<void>;
     setOnCameraMoveCancelListener(listener: () => void, nativeMap?: any): Promise<void>;
-    setOnCameraIdleListener(listener: () => void, nativeMap?: any): Promise<void>;
+    setOnMapIdleListener(listener: () => void, nativeMap?: any): Promise<void>;
     getViewport(nativeMap?: any): Promise<Viewport>;
     setViewport(options: SetViewportOptions, nativeMap?: any): Promise<void>;
     downloadOfflineRegion(options: DownloadOfflineRegionOptions): Promise<void>;
@@ -97,5 +128,5 @@ export declare class Mapbox extends MapboxCommon implements MapboxApi {
         x: number;
         y: number;
     };
-    projectBack(screenCoordinate: { x: number, y: number }): LatLng;
+    projectBack(screenCoordinate: { x: number; y: number }): LatLng;
 }

package/index.ios.d.ts

@@ -1,5 +1,5 @@
 import { ImageSource } from '@nativescript/core';
-import { AddExtrusionOptions, AddGeoJsonClusteredOptions, AddPolygonOptions, AddPolylineOptions, AddSourceOptions, AnimateCameraOptions, DeleteOfflineRegionOptions, DownloadOfflineRegionOptions, Feature, LatLng, LayerCommon, ListOfflineRegionsOptions, MapStyle, MapboxApi, MapboxCommon, MapboxMarker, MapboxViewBase, OfflineRegion, QueryRenderedFeaturesOptions, QuerySourceFeaturesOptions, SetCenterOptions, SetTiltOptions, SetViewportOptions, SetZoomLevelOptions, ShowOptions, TrackUserOptions, UpdateSourceOptions, UserLocation, UserLocationCameraMode, Viewport } from './common';
+import { AddExtrusionOptions, AddGeoJsonClusteredOptions, AddPolygonOptions, AddPolylineOptions, AddSourceOptions, AnimateCameraOptions, DeleteOfflineRegionOptions, DownloadOfflineRegionOptions, Feature, LatLng, LayerCommon, ListOfflineRegionsOptions, MapStyle, MapboxApi, MapboxCommon, MapboxMarker, MapboxViewBase, OfflineRegion, QueryRenderedFeaturesOptions, QuerySourceFeaturesOptions, SetCenterOptions, SetTiltOptions, SetViewportOptions, SetZoomLevelOptions, ShowOptions, TrackUserOptions, UpdateSourceOptions, UserLocation, UserLocationCameraMode, Viewport, telemetryProperty } from './common';
 export * from './common';
 export declare function setLogLevel(level: 'none' | 'info' | 'debug' | 'error' | 'fault' | 'verbose'): void;
 /**
@@ -9,8 +9,10 @@ export declare function setLogLevel(level: 'none' | 'info' | 'debug' | 'error' |
  * code.
  */
 export declare class MapboxView extends MapboxViewBase {
+    [telemetryProperty.setNative]: (value: boolean) => void;
     private nativeMapView;
     private delegate;
+    mapbox: Mapbox;
     private settings;
     private initialized;
     private initCountHack;
@@ -19,7 +21,7 @@ export declare class MapboxView extends MapboxViewBase {
      */
     setConfig(settings: any): void;
     getNativeMapView(): any;
-    createNativeView(): Object;
+    createNativeView(): object;
     /**
      * init the native view.
      *
@@ -197,9 +199,9 @@ export declare class Mapbox extends MapboxCommon implements MapboxApi {
     setOnMoveBeginListener(listener: (data?: LatLng) => void, nativeMap?: any): Promise<void>;
     setOnMoveEndListener(listener: () => void, nativeMap?: any): Promise<void>;
     setOnFlingListener(listener: () => void, nativeMap?: any): Promise<void>;
-    setOnCameraMoveListener(listener: (reason: any, animated?: any) => void, nativeMap?: any): Promise<void>;
+    setOnCameraChangeListener(listener: (reason: any, animated?: any) => void, nativeMap?: any): Promise<void>;
     setOnCameraMoveCancelListener(listener: () => void, nativeMap?: any): Promise<void>;
-    setOnCameraIdleListener(listener: () => void, nativeMap?: any): Promise<void>;
+    setOnMapIdleListener(listener: () => void, nativeMap?: any): Promise<void>;
     getViewport(nativeMap?: any): Promise<Viewport>;
     setViewport(options: SetViewportOptions, nativeMap?: any): Promise<void>;
     downloadOfflineRegion(options: DownloadOfflineRegionOptions): Promise<void>;

package/index.ios.js

@@ -123,7 +123,7 @@ var MGLMapViewDelegateImpl = /** @class */ (function (_super) {
     };
     MGLMapViewDelegateImpl.prototype.mapViewDidFailLoadingMapWithError = function (mapView, error) {
         if (Trace.isEnabled()) {
-            CLog(CLogTypes.info, 'mapViewDidFailLoadingMapWithError: ' + error);
+            CLog(CLogTypes.info, 'mapViewDidFailLoadingMapWithError: ' + error.localizedDescription);
         }
     };
     MGLMapViewDelegateImpl.prototype.mapViewDidChangeUserTrackingModeAnimated = function (mapView, mode, animated) {
@@ -218,8 +218,7 @@ var MGLMapViewDelegateImpl = /** @class */ (function (_super) {
         }
     };
     MGLMapViewDelegateImpl.prototype.getTappedMarkerDetails = function (tapped) {
-        for (var m in _markers) {
-            var cached = _markers[m];
+        _markers.forEach(function (cached) {
             // 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
@@ -232,7 +231,7 @@ var MGLMapViewDelegateImpl = /** @class */ (function (_super) {
                 cached.subtitle == tapped.subtitle) {
                 return cached;
             }
-        }
+        });
     };
     MGLMapViewDelegateImpl.prototype.mapViewRegionIsChangingWithReason = function (mapView, reason) {
         if (Trace.isEnabled()) {
@@ -1063,7 +1062,7 @@ export class Mapbox extends MapboxCommon {
             }
             catch (ex) {
                 if (Trace.isEnabled()) {
-                    CLog(CLogTypes.info, 'Error in mapbox.addMarkers: ' + ex);
+                    CLog(CLogTypes.error, 'Error in mapbox.addMarkers: ' + ex);
                 }
                 reject(ex);
             }
@@ -1566,7 +1565,7 @@ export class Mapbox extends MapboxCommon {
                 if (options.bounds) {
                     const padding = options.padding || 0;
                     // ensure padding is an object and assign default values
-                    const { top = 0, left = 0, bottom = 0, right = 0 } = typeof padding === 'object' ? padding : { top: padding, left: padding, bottom: padding, right: padding };
+                    const { bottom = 0, left = 0, right = 0, top = 0 } = typeof padding === 'object' ? padding : { top: padding, left: padding, bottom: padding, right: padding };
                     // support defined padding
                     const insets = { top, left, bottom, right };
                     const bounds = {
@@ -1778,7 +1777,7 @@ export class Mapbox extends MapboxCommon {
         // there's no swipe event we can bind to
         return Promise.reject("'setOnFlingListener' is not supported on iOS");
     }
-    async setOnCameraMoveListener(listener, nativeMap) {
+    async setOnCameraChangeListener(listener, nativeMap) {
         const theMap = nativeMap || this._mapboxViewInstance;
         if (theMap) {
             theMap.delegate.setCameraChangedListener(listener);
@@ -1790,7 +1789,7 @@ export class Mapbox extends MapboxCommon {
     setOnCameraMoveCancelListener(listener, nativeMap) {
         return Promise.reject("'setOnCameraMoveCancelListener' not currently supported on iOS");
     }
-    async setOnCameraIdleListener(listener, nativeMap) {
+    async setOnMapIdleListener(listener, nativeMap) {
         const theMap = nativeMap || this._mapboxViewInstance;
         if (theMap) {
             theMap.delegate.setCameraIdledListener(listener);
@@ -1960,7 +1959,7 @@ export class Mapbox extends MapboxCommon {
                     const userInfo = NSKeyedUnarchiver.unarchiveObjectWithData(pack.context);
                     regions.push({
                         name: userInfo.objectForKey('name'),
-                        style: '' + region.styleURL,
+                        style: region.styleURL.absoluteString,
                         minZoom: region.minimumZoomLevel,
                         maxZoom: region.maximumZoomLevel,
                         bounds: {

package/layers/layer-factory.android.d.ts

@@ -1,12 +1,13 @@
-import { LayerCommon, LayerType } from "../common";
+import { LayerCommon, LayerType } from '../common';
+type ILayer = com.mapbox.maps.extension.style.layers.generated.FillLayer | com.mapbox.maps.extension.style.layers.generated.LineLayer | com.mapbox.maps.extension.style.layers.generated.SymbolLayer | com.mapbox.maps.extension.style.layers.generated.CircleLayer | com.mapbox.maps.extension.style.layers.generated.HeatmapLayer | com.mapbox.maps.extension.style.layers.generated.FillExtrusionLayer | com.mapbox.maps.extension.style.layers.generated.RasterLayer | com.mapbox.maps.extension.style.layers.generated.HillshadeLayer;
 export declare class Layer implements LayerCommon {
     id: string;
     private instance;
-    constructor(instance: any);
+    constructor(instance: ILayer);
     visibility(): boolean;
     show(): void;
     hide(): void;
-    getNativeInstance(): any;
+    getNativeInstance(): ILayer;
     setFilter(filter: any[]): void;
     getFilter(): any[];
     setProperty(name: string, value: any): void;
@@ -14,6 +15,7 @@ export declare class Layer implements LayerCommon {
     type(): LayerType;
 }
 export declare class LayerFactory {
-    static createLayer(style: any, source: any): Promise<LayerCommon>;
-    private static parseProperties;
+    static applyLayerProperties(layer: com.mapbox.maps.extension.style.layers.Layer, properties: Record<string, any>): void;
+    static createLayer(style: any, source: com.mapbox.maps.extension.style.sources.Source): Promise<LayerCommon>;
 }
+export {};

package/layers/layer-factory.android.js

@@ -1,105 +1,135 @@
 import { ExpressionParser } from '../expression/expression-parser';
 import { PropertyParser } from './parser/property-parser';
+import { toCamelCase, transformValue } from './parser/property-parser.android';
 export class Layer {
     constructor(instance) {
         this.instance = instance;
-        this.id = instance.getId();
+        this.id = instance.getSourceId();
     }
     visibility() {
         return this.instance.getVisibility().getValue() === 'visible' ? true : false;
     }
     show() {
-        this.instance.setProperties([new com.mapbox.mapboxsdk.style.layers.PropertyValue('visibility', 'visible')]);
+        LayerFactory.applyLayerProperties(this.instance, {
+            visibility: 'visible'
+        });
+        // this.instance.setProperties([new com.mapbox.maps.extension.style.layers.generated.PropertyValue('visibility', 'visible')]);
     }
     hide() {
-        this.instance.setProperties([new com.mapbox.mapboxsdk.style.layers.PropertyValue('visibility', 'none')]);
+        LayerFactory.applyLayerProperties(this.instance, {
+            visibility: 'none'
+        });
+        // this.instance.setProperties([new com.mapbox.maps.extension.style.layers.generated.PropertyValue('visibility', 'none')]);
     }
     getNativeInstance() {
         return this.instance;
     }
     setFilter(filter) {
-        this.instance.setFilter(ExpressionParser.parseJson(filter));
+        if (this.instance['setFilter']) {
+            this.instance['setFilter'](ExpressionParser.parseJson(filter));
+        }
     }
     getFilter() {
-        return ExpressionParser.toJson(this.instance.getFilter());
+        if (this.instance['getFilter']) {
+            return ExpressionParser.toJson(this.instance['getFilter']());
+        }
+        return [];
     }
     setProperty(name, value) {
-        const properties = PropertyParser.parsePropertiesForLayer({ [name]: value });
-        this.instance.setProperties(properties);
+        LayerFactory.applyLayerProperties(this.instance, {
+            [name]: value
+        });
     }
     getProperty(name) {
         return PropertyParser.propertyValueFromLayer(this.instance, name);
     }
     type() {
-        if (this.instance instanceof com.mapbox.mapboxsdk.style.layers.FillLayer) {
-            return "fill";
+        if (this.instance instanceof com.mapbox.maps.extension.style.layers.generated.FillLayer) {
+            return 'fill';
         }
-        if (this.instance instanceof com.mapbox.mapboxsdk.style.layers.LineLayer) {
-            return "line";
+        if (this.instance instanceof com.mapbox.maps.extension.style.layers.generated.LineLayer) {
+            return 'line';
         }
-        if (this.instance instanceof com.mapbox.mapboxsdk.style.layers.SymbolLayer) {
-            return "symbol";
+        if (this.instance instanceof com.mapbox.maps.extension.style.layers.generated.SymbolLayer) {
+            return 'symbol';
         }
-        if (this.instance instanceof com.mapbox.mapboxsdk.style.layers.CircleLayer) {
-            return "circle";
+        if (this.instance instanceof com.mapbox.maps.extension.style.layers.generated.CircleLayer) {
+            return 'circle';
         }
-        if (this.instance instanceof com.mapbox.mapboxsdk.style.layers.HeatmapLayer) {
-            return "heatmap";
+        if (this.instance instanceof com.mapbox.maps.extension.style.layers.generated.HeatmapLayer) {
+            return 'heatmap';
         }
-        if (this.instance instanceof com.mapbox.mapboxsdk.style.layers.FillExtrusionLayer) {
-            return "fill-extrusion";
+        if (this.instance instanceof com.mapbox.maps.extension.style.layers.generated.FillExtrusionLayer) {
+            return 'fill-extrusion';
         }
-        if (this.instance instanceof com.mapbox.mapboxsdk.style.layers.RasterLayer) {
-            return "raster";
+        if (this.instance instanceof com.mapbox.maps.extension.style.layers.generated.RasterLayer) {
+            return 'raster';
         }
-        if (this.instance instanceof com.mapbox.mapboxsdk.style.layers.HillshadeLayer) {
-            return "hillshade";
-        }
-        if (this.instance instanceof com.mapbox.mapboxsdk.style.layers.BackgroundLayer) {
-            return "background";
+        if (this.instance instanceof com.mapbox.maps.extension.style.layers.generated.HillshadeLayer) {
+            return 'hillshade';
         }
+        // if (this.instance instanceof com.mapbox.maps.extension.style.layers.generated.BackgroundLayer) {
+        //     return 'background';
+        // }
         // there is no sky layer in the Android Mapbox SDK
         return null;
     }
 }
 export class LayerFactory {
+    static applyLayerProperties(layer, properties) {
+        for (const key in properties) {
+            if (!properties.hasOwnProperty(key))
+                continue;
+            const value = properties[key];
+            const actualKey = toCamelCase(key);
+            const nValue = transformValue(actualKey, value);
+            // Mapbox v11 setters are named after the property, e.g., circleColor(), circleRadius()
+            const setterName = actualKey;
+            // Call the setter dynamically
+            if (typeof layer[setterName] === 'function') {
+                layer[setterName](nValue);
+            }
+            else {
+                console.warn(`Layer has no setter for ${setterName}`);
+            }
+        }
+    }
     static async createLayer(style, source) {
-        const layerProperties = this.parseProperties(style.type, Object.assign(style.paint || {}, style.layout || {})); // TODO: handle defaults
-        const sourceId = source.getId();
+        // const layerProperties = this.parseProperties(style.type, Object.assign(style.paint || {}, style.layout || {})); // TODO: handle defaults
+        const layerProperties = Object.assign(style.paint || {}, style.layout || {}); // TODO: handle defaults
+        const sourceId = source.getSourceId();
         let nativeLayer;
         switch (style.type) {
             case 'line':
-                nativeLayer = new com.mapbox.mapboxsdk.style.layers.LineLayer(style.id, sourceId).withProperties(layerProperties);
+                nativeLayer = new com.mapbox.maps.extension.style.layers.generated.LineLayer(style.id, sourceId);
                 break;
             case 'circle':
-                nativeLayer = new com.mapbox.mapboxsdk.style.layers.CircleLayer(style.id, sourceId).withProperties(layerProperties);
+                nativeLayer = new com.mapbox.maps.extension.style.layers.generated.CircleLayer(style.id, sourceId);
                 break;
             case 'fill':
-                nativeLayer = new com.mapbox.mapboxsdk.style.layers.FillLayer(style.id, sourceId).withProperties(layerProperties);
+                nativeLayer = new com.mapbox.maps.extension.style.layers.generated.FillLayer(style.id, sourceId);
                 break;
             case 'symbol':
-                nativeLayer = new com.mapbox.mapboxsdk.style.layers.SymbolLayer(style.id, sourceId).withProperties(layerProperties);
+                nativeLayer = new com.mapbox.maps.extension.style.layers.generated.SymbolLayer(style.id, sourceId);
                 break;
             case 'raster':
-                nativeLayer = new com.mapbox.mapboxsdk.style.layers.RasterLayer(style.id, sourceId).withProperties(layerProperties);
+                nativeLayer = new com.mapbox.maps.extension.style.layers.generated.RasterLayer(style.id, sourceId);
                 break;
             default:
                 throw new Error(`Unknown layer type: ${style.type}`);
         }
+        LayerFactory.applyLayerProperties(nativeLayer, layerProperties);
         const layer = new Layer(nativeLayer);
         if (style.minzoom !== undefined) {
-            nativeLayer.setMinZoom(style.minzoom);
+            nativeLayer.minZoom(style.minzoom);
         }
         if (style.maxzoom !== undefined) {
-            nativeLayer.setMaxZoom(style.maxzoom);
-        }
-        if (style['source-layer'] && nativeLayer.withSourceLayer) {
-            nativeLayer.withSourceLayer(style['source-layer']);
+            nativeLayer.maxZoom(style.maxzoom);
         }
+        // if (style['source-layer'] && (nativeLayer as any).withSourceLayer) {
+        //     (nativeLayer as any).withSourceLayer(style['source-layer']);
+        // }
         return layer;
     }
-    static parseProperties(layerType, propertiesObject) {
-        return PropertyParser.parsePropertiesForLayer(propertiesObject);
-    }
 }
 //# sourceMappingURL=layer-factory.android.js.map

package/layers/layer-factory.d.ts

@@ -1,7 +1,8 @@
-import { LayerCommon, LayerType } from "../common"
+import { LayerCommon, LayerType } from '../common';
 
 declare class LayerFactory {
     static createLayer(style, source): Promise<LayerCommon>;
+    static applyLayerProperties(layer: any, properties: Record<string, any>);
 }
 
 export declare class Layer implements LayerCommon {

package/layers/layer-factory.ios.d.ts

@@ -1,4 +1,4 @@
-import { LayerCommon, LayerType } from "../common";
+import { LayerCommon, LayerType } from '../common';
 export declare class LayerFactory {
     static createLayer(style: any, source: any): Promise<LayerCommon>;
     private static parseProperties;

package/layers/layer-factory.ios.js

@@ -51,31 +51,31 @@ export class Layer {
     }
     type() {
         if (this.instance instanceof MGLFillStyleLayer) {
-            return "fill";
+            return 'fill';
         }
         if (this.instance instanceof MGLLineStyleLayer) {
-            return "line";
+            return 'line';
         }
         if (this.instance instanceof MGLSymbolStyleLayer) {
-            return "symbol";
+            return 'symbol';
         }
         if (this.instance instanceof MGLCircleStyleLayer) {
-            return "circle";
+            return 'circle';
         }
         if (this.instance instanceof MGLHeatmapStyleLayer) {
-            return "heatmap";
+            return 'heatmap';
         }
         if (this.instance instanceof MGLFillExtrusionStyleLayer) {
-            return "fill-extrusion";
+            return 'fill-extrusion';
         }
         if (this.instance instanceof MGLRasterStyleLayer) {
-            return "raster";
+            return 'raster';
         }
         if (this.instance instanceof MGLHillshadeStyleLayer) {
-            return "hillshade";
+            return 'hillshade';
         }
         if (this.instance instanceof MGLBackgroundStyleLayer) {
-            return "background";
+            return 'background';
         }
         // there is no sky layer in the Mapbox iOS SDK
         return null;

package/layers/parser/property-parser.android.d.ts

@@ -1,4 +1,6 @@
+export declare function toCamelCase(s: any): any;
+export declare function toPascalCase(s: any): any;
+export declare function transformValue(key: any, value: any): any;
 export declare class PropertyParser {
-    static parsePropertiesForLayer(propertiesObject: any): any[];
     static propertyValueFromLayer(layer: any, key: string): any;
 }

package/layers/parser/property-parser.android.js

@@ -1,42 +1,43 @@
 import { Color } from '@nativescript/core';
-function toCamelCase(s) {
+export function toCamelCase(s) {
     return s.replace(/([-_][a-z])/gi, ($1) => $1.toUpperCase().replace('-', '').replace('_', ''));
 }
-function toPascalCase(s) {
+export function toPascalCase(s) {
     return s.replace(/(^[a-z]|[-_][a-z])/gi, ($1) => $1.toUpperCase().replace('-', '').replace('_', ''));
 }
-const Expression = com.mapbox.mapboxsdk.style.expressions.Expression;
-function transformValue(key, value) {
+const Expression = com.mapbox.maps.extension.style.expressions.generated.Expression;
+export function transformValue(key, value) {
     let nValue = value;
     if (Array.isArray(value)) {
-        nValue = Expression.Converter.convert(JSON.stringify(value));
+        nValue = Expression.fromRaw(JSON.stringify(value));
     }
     if (key.indexOf('-color') !== -1 && !Array.isArray(value)) {
         const color = value instanceof Color ? value : new Color(value);
         nValue = color.android;
     }
-    else if (typeof value === 'number') {
-        nValue = new java.lang.Float(value);
+    else if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+        nValue = Expression.literal(value);
     }
-    else if (typeof value === 'boolean') {
-        nValue = new java.lang.Boolean(value);
+    else if (Array.isArray(value)) {
+        // assume it's a JSON-style expression
+        nValue = Expression.fromRaw(JSON.stringify(value));
     }
     return nValue;
 }
 export class PropertyParser {
-    static parsePropertiesForLayer(propertiesObject) {
-        const nProperties = [];
-        const PropertyFactory = com.mapbox.mapboxsdk.style.layers.PropertyFactory;
-        if (propertiesObject) {
-            Object.keys(propertiesObject).forEach((k) => {
-                const actualKey = toCamelCase(k);
-                const value = propertiesObject[k];
-                const nValue = transformValue(k, value);
-                nProperties.push(PropertyFactory[actualKey](nValue));
-            });
-        }
-        return nProperties;
-    }
+    // static parsePropertiesForLayer(propertiesObject) {
+    //     const nProperties = [];
+    //     const PropertyFactory = com.mapbox.maps.extension.style.layers.PropertyFactory;
+    //     if (propertiesObject) {
+    //         Object.keys(propertiesObject).forEach((k) => {
+    //             const actualKey = toCamelCase(k);
+    //             const value = propertiesObject[k];
+    //             const nValue = transformValue(k, value);
+    //             nProperties.push(PropertyFactory[actualKey](nValue));
+    //         });
+    //     }
+    //     return nProperties;
+    // }
     static propertyValueFromLayer(layer, key) {
         const getterMethodName = `get${toPascalCase(key)}`;
         let nValue;
@@ -47,11 +48,11 @@ export class PropertyParser {
             // native method seems not exist
             return null;
         }
-        if (!nValue || nValue.isNull()) {
+        if (nValue === null || nValue === undefined) {
             return null;
         }
         if (nValue.isExpression()) {
-            return JSON.parse(nValue.getExpression().toString());
+            return JSON.parse(nValue.toString());
         }
         else if (!!nValue.getColorInt()) {
             return new Color(nValue.getColorInt().intValue());

package/markers/Marker.android.d.ts

@@ -0,0 +1,35 @@
+import { StackLayout } from '@nativescript/core';
+/**
+ * Hybrid Marker — uses native Mapbox annotation APIs, but NativeScript view for info window.
+ */
+export declare class AndroidMarker {
+    position: com.mapbox.geojson.Point;
+    icon: android.graphics.Bitmap;
+    title?: string;
+    snippet?: string;
+    preventNextUpdateOffsetX?: boolean;
+    pointAnnotation: com.mapbox.maps.plugin.annotation.generated.PointAnnotation;
+    viewAnnotation: android.view.View;
+    view: StackLayout;
+    anchor: com.mapbox.maps.ViewAnnotationAnchorConfig;
+    layerId: string;
+    prepared: boolean;
+    private static readonly MARKER_PADDING_PX;
+    constructor(opts: {
+        position: com.mapbox.geojson.Point;
+        icon: android.graphics.Bitmap;
+        title?: string;
+        snippet?: string;
+    });
+    /**
+     * Create the native PointAnnotation
+     */
+    prepareAnnotationMarker(pointAnnotationManager: com.mapbox.maps.plugin.annotation.generated.PointAnnotationManager, layerId: string): void;
+    update(pointAnnotationManager: com.mapbox.maps.plugin.annotation.generated.PointAnnotationManager): void;
+    /**
+     * Build a NativeScript view to use as info window.
+     * Then attach it to Mapbox via ViewAnnotationManager.
+     */
+    prepareViewAnnotation(mapView: com.mapbox.maps.MapView, onInfoWindowClick: any): void;
+    destroy(): void;
+}