@nativescript-community/ui-mapbox 6.2.31 → 7.0.0

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,13 +1,8 @@
-import { LayerCommon, LayerType } from "../common";
-export declare class LayerFactory {
-    static createLayer(style: any, source: any): Promise<LayerCommon>;
-    private static parseProperties;
-}
+import { LayerCommon, LayerType } from '../common';
 export declare class Layer implements LayerCommon {
+    mapboxView: MapView;
     id: string;
-    private instance;
-    constructor(instance: MGLStyleLayer);
-    type(): LayerType;
+    constructor(mapboxView: MapView, id: string);
     visibility(): boolean;
     show(): void;
     hide(): void;
@@ -16,4 +11,9 @@ export declare class Layer implements LayerCommon {
     getFilter(): any[];
     setProperty(name: string, value: any): void;
     getProperty(name: string): any;
+    type(): LayerType;
+}
+export declare class LayerFactory {
+    static createLayer(mapboxView: MapView, style: any, belowLayerId: string): Promise<LayerCommon>;
+    static applyLayerProperties(mapboxView: MapView, layer: any, properties: Record<string, any>): void;
 }

package/layers/layer-factory.ios.js

@@ -1,120 +1,66 @@
-import { ExpressionParser } from '../expression/expression-parser';
-import { PropertyParser } from './parser/property-parser';
-export class LayerFactory {
-    static async createLayer(style, source) {
-        let nativeLayer;
-        switch (style.type) {
-            case 'line':
-                nativeLayer = MGLLineStyleLayer.alloc().initWithIdentifierSource(style.id, source);
-                break;
-            case 'circle':
-                nativeLayer = MGLCircleStyleLayer.alloc().initWithIdentifierSource(style.id, source);
-                break;
-            case 'fill':
-                nativeLayer = MGLFillStyleLayer.alloc().initWithIdentifierSource(style.id, source);
-                break;
-            case 'symbol':
-                nativeLayer = MGLSymbolStyleLayer.alloc().initWithIdentifierSource(style.id, source);
-                break;
-            case 'raster':
-                nativeLayer = MGLRasterStyleLayer.alloc().initWithIdentifierSource(style.id, source);
-                break;
-            default:
-                throw new Error(`Unknown layer type: ${style.type}`);
-        }
-        if (style.minzoom !== undefined) {
-            nativeLayer.minimumZoomLevel = style.minzoom;
-        }
-        if (style.maxzoom !== undefined) {
-            nativeLayer.maximumZoomLevel = style.maxzoom;
-        }
-        if (style['source-layer']) {
-            nativeLayer.sourceLayerIdentifier = style['source-layer'];
-        }
-        const layerProperties = this.parseProperties(style.type, Object.assign(style.paint || {}, style.layout || {})); // TODO: handle defaults
-        for (const propKey in layerProperties) {
-            if (Object.prototype.hasOwnProperty.call(layerProperties, propKey)) {
-                nativeLayer[propKey] = layerProperties[propKey];
-            }
-        }
-        const layer = new Layer(nativeLayer);
-        return layer;
-    }
-    static parseProperties(layerType, propertiesObject) {
-        return PropertyParser.parsePropertiesForLayer(propertiesObject);
-    }
-}
+// src/ui-mapbox/layer-factory.ios.ts
+// TypeScript shim that exports LayerFactory (TS API) while delegating to native NativeLayerFactory when available.
+// This preserves the TS export name 'LayerFactory' as requested.
+import { Trace } from '@nativescript/core';
+import { CLog, CLogTypes } from '../common';
 export class Layer {
-    constructor(instance) {
-        this.instance = instance;
-        this.id = instance.identifier;
-    }
-    type() {
-        if (this.instance instanceof MGLFillStyleLayer) {
-            return "fill";
-        }
-        if (this.instance instanceof MGLLineStyleLayer) {
-            return "line";
-        }
-        if (this.instance instanceof MGLSymbolStyleLayer) {
-            return "symbol";
-        }
-        if (this.instance instanceof MGLCircleStyleLayer) {
-            return "circle";
-        }
-        if (this.instance instanceof MGLHeatmapStyleLayer) {
-            return "heatmap";
-        }
-        if (this.instance instanceof MGLFillExtrusionStyleLayer) {
-            return "fill-extrusion";
-        }
-        if (this.instance instanceof MGLRasterStyleLayer) {
-            return "raster";
-        }
-        if (this.instance instanceof MGLHillshadeStyleLayer) {
-            return "hillshade";
-        }
-        if (this.instance instanceof MGLBackgroundStyleLayer) {
-            return "background";
-        }
-        // there is no sky layer in the Mapbox iOS SDK
-        return null;
+    constructor(mapboxView, id) {
+        this.mapboxView = mapboxView;
+        this.id = id;
     }
     visibility() {
-        return this.instance.visible;
+        return true;
     }
     show() {
-        this.instance.visible = true;
+        NativeLayerFactory.setLayerVisibility(this.mapboxView, this.id, true);
     }
     hide() {
-        this.instance.visible = false;
+        NativeLayerFactory.setLayerVisibility(this.mapboxView, this.id, false);
     }
     getNativeInstance() {
-        return this.instance;
+        return null;
     }
     setFilter(filter) {
-        if (this.instance instanceof MGLVectorStyleLayer) {
-            // MGLVectorStyleLayer is the base type of many layer types. Predicates only supported on vector style layers.
-            // See https://docs.mapbox.com/ios/maps/api/6.3.0/Classes/MGLVectorStyleLayer.html
-            this.instance.predicate = ExpressionParser.parseJson(filter);
-        }
-        else {
-            throw new Error('Set filter only support for vector layer.');
-        }
+        // Not implemented here - recommend using addLayer with JSON via Mapbox.addLayer
     }
     getFilter() {
-        return ExpressionParser.toJson(this.instance.predicate);
+        return null;
     }
     setProperty(name, value) {
-        const properties = PropertyParser.parsePropertiesForLayer({ [name]: value });
-        for (const propKey in properties) {
-            if (Object.prototype.hasOwnProperty.call(properties, propKey)) {
-                this.instance[propKey] = properties[propKey];
-            }
-        }
+        NativeLayerFactory.setLayerProperty(this.mapboxView, this.id, name, value);
     }
     getProperty(name) {
-        return PropertyParser.propertyValueFromLayer(this.instance, name);
+        return NativeLayerFactory.getLayerProperty(this.mapboxView, this.id, name);
+    }
+    type() {
+        return NativeLayerFactory.getLayerType(this.mapboxView, this.id);
+    }
+}
+// Export a TS LayerFactory that matches the old TS API but delegates to NativeLayerFactory
+export class LayerFactory {
+    static async createLayer(mapboxView, style, belowLayerId) {
+        const styleJson = typeof style === 'string' ? style : JSON.stringify(style);
+        if (Trace.isEnabled()) {
+            CLog(CLogTypes.info, 'createLayer:', belowLayerId, JSON.stringify(style));
+        }
+        const id = style.id || 'layer_' + Date.now();
+        if (NativeLayerFactory.createLayer(mapboxView, id, styleJson, belowLayerId)) {
+            return new Layer(mapboxView, id);
+        }
+        else {
+            throw new Error('failed to create layer');
+        }
+    }
+    static applyLayerProperties(mapboxView, layer, properties) {
+        try {
+            // NativeLayerFactory.applyLayerProperties(layer.id, properties);
+            // if ((global as any).NativeLayerFactory && (global as any).NativeLayerFactory.setLayerProperty) {
+            for (const k of Object.keys(properties)) {
+                NativeLayerFactory.setLayerProperty(mapboxView, layer.id, k, properties[k]);
+            }
+            // }
+        }
+        catch (e) { }
     }
 }
 //# sourceMappingURL=layer-factory.ios.js.map

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/layers/parser/property-parser.d.ts

@@ -1,4 +1,4 @@
 export declare class PropertyParser {
-    static parsePropertiesForLayer(propertiesObject: any): any;
+    // static parsePropertiesForLayer(propertiesObject: any): any;
     static propertyValueFromLayer(layer, key: string): any;
 }

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

@@ -1,4 +1,2 @@
 export declare class PropertyParser {
-    static parsePropertiesForLayer(propertiesObject: any): {};
-    static propertyValueFromLayer(layer: any, key: string): any;
 }

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

@@ -1,152 +1,3 @@
-import { Color } from '@nativescript/core';
-function toCamelCase(s) {
-    return s.replace(/([-_][a-z])/gi, ($1) => $1.toUpperCase().replace('-', '').replace('_', ''));
-}
-const styleExtras = {
-    // padding
-    iconTextFitPadding: {
-        iosType: 'edgeinsets'
-    },
-    // offsets
-    iconOffset: {
-        iosType: 'vector'
-    },
-    textOffset: {
-        iosType: 'vector'
-    },
-    lineOffset: {
-        iosType: 'vector'
-    },
-    // translates
-    fillTranslate: {
-        iosType: 'vector'
-    },
-    lineTranslate: {
-        iosType: 'vector'
-    },
-    iconTranslate: {
-        iosType: 'vector'
-    },
-    textTranslate: {
-        iosType: 'vector'
-    },
-    circleTranslate: {
-        iosType: 'vector'
-    },
-    fillExtrusionTranslate: {
-        iosType: 'vector'
-    }
-};
-const keysMap = {
-    'circle-pitch-scale': 'circleScaleAlignment',
-    'circle-translate': 'circleTranslation',
-    'circle-translate-anchor': 'circleTranslationAnchor',
-    'fill-antialias': 'fillAntialiased',
-    'fill-translate': 'fillTranslation',
-    'fill-translate-anchor': 'fillTranslationAnchor',
-    'icon-allow-overlap': 'iconAllowsOverlap',
-    'icon-keep-upright': 'keepsIconUpright',
-    'icon-ignore-placement': 'iconIgnoresPlacement',
-    'icon-image': 'iconImageName',
-    'icon-rotate': 'iconRotation',
-    'icon-rotate-alignment': 'iconRotationAlignment',
-    'icon-translate': 'iconTranslation',
-    'icon-translate-anchor': 'iconTranslationAnchor',
-    'icon-size': 'iconScale',
-    'line-translate': 'lineTranslation',
-    'line-translate-anchor': 'lineTranslationAnchor',
-    'line-dasharray': 'lineDashPattern',
-    'text-allow-overlap': 'textAllowsOverlap',
-    'text-field': 'text',
-    'text-font': 'textFontNames',
-    'text-justify': 'textJustification',
-    'text-ignore-placement': 'textIgnoresPlacement',
-    'text-keep-upright': 'keepsTextUpright',
-    'text-max-angle': 'maximumTextAngle',
-    'text-max-width': 'maximumTextWidth',
-    'text-rotate': 'textRotation',
-    'text-rotate-alignment': 'textRotationAlignment',
-    'text-size': 'textFontSize',
-    'text-translate': 'textTranslation',
-    'text-translate-anchor': 'textTranslationAnchor',
-    'raster-hue-rotate': 'rasterHueRotation',
-    'raster-resampling': 'rasterResamplingMode',
-    'raster-brightness-min': 'maximumRasterBrightness',
-    'raster-brightness-max': 'minimumRasterBrightness'
-};
-function transformValue(key, value, _styleType) {
-    if (_styleType === 'color') {
-        const color = value instanceof Color ? value : new Color(value);
-        return color.ios;
-    }
-    else if (_styleType === 'vector') {
-        const vector = CGVectorMake(value[0], value[1]);
-        return NSExpression.expressionWithMGLJSONObject(NSValue.valueWithCGVector(vector));
-    }
-    else if (_styleType === 'edgeinsets') {
-        const edgeInsets = new UIEdgeInsets({
-            top: value[0],
-            left: value[1],
-            bottom: value[2],
-            right: value[3]
-        });
-        return NSExpression.expressionWithMGLJSONObject(NSValue.valueWithUIEdgeInsets(edgeInsets));
-    }
-    else {
-        switch (key) {
-            case 'raster-resampling':
-                if (value === 'linear') {
-                    return 0 /* MGLRasterResamplingMode.Linear */;
-                }
-                else if (value === 'nearest') {
-                    return 1 /* MGLRasterResamplingMode.Nearest */;
-                }
-                else {
-                    return value;
-                }
-            default:
-                return value;
-        }
-    }
-}
 export class PropertyParser {
-    static parsePropertiesForLayer(propertiesObject) {
-        const nProperties = {};
-        if (propertiesObject) {
-            Object.keys(propertiesObject).forEach((k) => {
-                const actualKey = keysMap[k] || toCamelCase(k);
-                const value = propertiesObject[k];
-                const rValue = transformValue(k, value, styleExtras[k]?.iosType);
-                if (Array.isArray(value)) {
-                    nProperties[actualKey] = NSExpression.expressionWithMGLJSONObject(rValue);
-                }
-                else {
-                    nProperties[actualKey] = NSExpression.expressionForConstantValue(rValue);
-                }
-            });
-        }
-        return nProperties;
-    }
-    static propertyValueFromLayer(layer, key) {
-        const actualKey = keysMap[key] || toCamelCase(key);
-        const nValue = layer[actualKey];
-        if (!nValue) {
-            return null;
-        }
-        if (nValue.expressionType === 0 /* NSExpressionType.ConstantValueExpressionType */) {
-            if (nValue.constantValue instanceof UIColor) {
-                return Color.fromIosColor(nValue.constantValue);
-            }
-            else {
-                return nValue.constantValue;
-            }
-        }
-        else {
-            const expressionObj = nValue.mgl_jsonExpressionObject;
-            const data = NSJSONSerialization.dataWithJSONObjectOptionsError(expressionObj, 0);
-            const expression = NSString.alloc().initWithDataEncoding(data, NSUTF8StringEncoding);
-            return JSON.parse(expression);
-        }
-    }
 }
 //# sourceMappingURL=property-parser.ios.js.map