fix: update to latest native SDK

# Conflicts:
#	src/layers/vector.android.ts
#	src/layers/vector.ios.ts
#	src/typings/carto.android.d.ts

Author: farfromrefug

src/datasources/cache.android.ts

@@ -1,7 +1,7 @@
 import { TileDownloadListener as ITileDownloadListener, MemoryCacheTileDataSourceOptions, PersistentCacheTileDataSourceOptions } from './cache';
 import { TileDataSource } from '.';
 import { MapBounds, toNativeMapBounds } from '../core';
-import { nativeProperty } from '../index.common';
+import { nativeProperty } from '..';
 
 export class PersistentCacheTileDataSource extends TileDataSource<com.carto.datasources.PersistentCacheTileDataSource, PersistentCacheTileDataSourceOptions> {
     @nativeProperty capacity: number;

src/datasources/cache.ios.ts

@@ -1,7 +1,7 @@
 import { MemoryCacheTileDataSourceOptions, PersistentCacheTileDataSourceOptions, TileDownloadListener } from './cache';
 import { TileDataSource } from '.';
 import { MapBounds, toNativeMapBounds } from '../core';
-import { nativeProperty } from '../index.common';
+import { nativeProperty } from '..';
 
 @NativeClass
 class NTTileDownloadListenerImpl extends NTTileDownloadListener {

src/datasources/http.android.ts

@@ -1,6 +1,6 @@
 import { HTTPTileDataSourceOptions } from './http';
 import { TileDataSource } from '.';
-import { nativeProperty } from '../index.common';
+import { nativeProperty } from '..';
 
 export class HTTPTileDataSource extends TileDataSource<com.carto.datasources.HTTPTileDataSource, HTTPTileDataSourceOptions> {
     @nativeProperty({

src/datasources/http.ios.ts

@@ -1,6 +1,6 @@
 import { HTTPTileDataSourceOptions } from './http';
 import { TileDataSource } from '.';
-import { nativeProperty } from '../index.common';
+import { nativeProperty } from '..';
 
 export class HTTPTileDataSource extends TileDataSource<NTHTTPTileDataSource, HTTPTileDataSourceOptions> {
     @nativeProperty({

src/index.d.ts

@@ -6,6 +6,8 @@ import { FeatureCollection } from './geometry/feature';
 export abstract class BaseNative<T, U extends {}> extends Observable {
     options: U;
     native: T;
+
+    duringInit: boolean;
     constructor(options?: U, native?: T);
     initNativeView(native: T, options: U): void;
     getNative(): T;

src/layers/index.ios.ts

@@ -1,6 +1,6 @@
 import { BaseLayer } from './index.common';
 import { LayerOptions, TileLayerOptions } from '.';
-import { nativeProperty } from '../index.common';
+import { nativeProperty } from '..';
 import { TileDataSource } from '../datasources';
 import { Projection } from '../projections';
 

src/layers/vector.android.ts

@@ -1,5 +1,5 @@
 import { BaseNative } from '..';
-import { nativeProperty, nonenumerable } from '../index.common';
+import { nativeProperty } from '..';
 import { fromNativeMapPos, fromNativeScreenPos } from '../core';
 import { VectorDataSource } from '../datasources/vector';
 import { Projection } from '../projections';
@@ -16,6 +16,7 @@ import {
     VectorTileEventListener as IVectorTileEventListener,
     VectorLayerOptions,
     VectorTileLayerOptions,
+    VectorTileRenderOrder as IVectorTileRenderOrder,
 } from './vector';
 import { Line } from '../vectorelements/line';
 
@@ -61,15 +62,31 @@ function getGeojsonWriter() {
 }
 
 export abstract class BaseVectorTileLayer<T extends com.carto.layers.VectorTileLayer, U extends VectorTileLayerOptions> extends TileLayer<T, U> {
+    projection?: Projection;
+    listener?: IVectorTileEventListener;
+    nListener?: com.akylas.carto.additions.AKVectorTileEventListener;
+    
+    @nativeProperty layerBlendingSpeed:number
+    @nativeProperty labelBlendingSpeed:number
+    @nativeProperty tileCacheCapacity:number
+    @nativeProperty clickRadius:number
+    @nativeProperty labelRenderOrder: IVectorTileRenderOrder
+    @nativeProperty buildingRenderOrder: IVectorTileRenderOrder
+    constructor(options) {
+        super(options);
+        for (const property of ['listener', 'nListener']) {
+            const descriptor = Object.getOwnPropertyDescriptor(BaseVectorTileLayer.prototype, property);
+            if (descriptor) {
+                descriptor.enumerable = false;
+            }
+        }
+    }
     setLabelRenderOrder(order: com.carto.layers.VectorTileRenderOrder) {
         this.getNative().setLabelRenderOrder(order);
     }
     setBuildingRenderOrder(order: com.carto.layers.VectorTileRenderOrder) {
         this.getNative().setBuildingRenderOrder(order);
     }
-    projection?: Projection;
-    @nonenumerable listener?: IVectorTileEventListener;
-    @nonenumerable nListener?: com.akylas.carto.additions.AKVectorTileEventListener;
     setVectorTileEventListener(listener: IVectorTileEventListener, projection?: Projection) {
         this.listener = listener;
         this.projection = projection;
@@ -161,8 +178,8 @@ export class CartoOfflineVectorTileLayer extends TileLayer<com.carto.layers.Cart
 
 export abstract class BaseVectorLayer<T extends com.carto.layers.VectorLayer, U extends VectorLayerOptions> extends Layer<T, U> {
     projection?: Projection;
-    @nonenumerable elementListener?: IVectorElementEventListener;
-    @nonenumerable nElementListener?: com.akylas.carto.additions.AKVectorElementEventListener;
+    elementListener?: IVectorElementEventListener;
+    nElementListener?: com.akylas.carto.additions.AKVectorElementEventListener;
     setVectorElementEventListener(listener: IVectorElementEventListener, projection?: Projection) {
         this.elementListener = listener;
         this.projection = projection;
@@ -242,8 +259,8 @@ export class EditableVectorLayer extends BaseVectorLayer<com.carto.layers.Editab
             this.native.setSelectedVectorElement(element instanceof BaseNative ? element.getNative() : element);
         }
     }
-    @nonenumerable editListener?: IVectorEditEventListener;
-    @nonenumerable nEditListener?: com.akylas.carto.additions.AKVectorEditEventListener;
+    editListener?: IVectorEditEventListener;
+    nEditListener?: com.akylas.carto.additions.AKVectorEditEventListener;
     projection?: Projection;
     setVectorEditEventListener(listener: IVectorEditEventListener, projection?: Projection) {
         this.editListener = listener;

src/layers/vector.d.ts

@@ -71,6 +71,39 @@ export interface VectorLayerOptions extends LayerOptions {
 export interface VectorTileLayerOptions extends TileLayerOptions {
     dataSource?: TileDataSource<any, any>;
     decoder?: VectorTileDecoder;
+    /**
+     * Sets the relative layer blending speed.
+     * Default is 1.0. Use zero or negative values to disable blending.
+     */
+    layerBlendingSpeed?: number;
+    /**
+     * Sets the relative label blending speed.
+     * Default is 1.0. Use zero or negative values to disable blending.
+     */
+    labelBlendingSpeed?: number;
+    /**
+     * display order of the labels. Default is VECTOR_TILE_RENDER_ORDER_LAYER
+     */
+    clickRadius?: number;
+
+    /**
+     * the vector tile cache capacity in bytes. Tile cache is the primary storage for vector data,
+     * all tiles contained within the cache are stored as uncompressed vertex buffers and can immediately be
+     * drawn to the screen. Setting the cache size too small may cause artifacts, such as disappearing tiles.
+     * The more tiles are visible on the screen, the larger this cache should be.
+     * The default is 10MB, which should be enough for most use cases with preloading enabled. If preloading is
+     * disabled, the cache size should be reduced by the user to conserve memory.
+     */
+    tileCacheCapacity?: number;
+    /**
+     * display order of the labels. Default is VECTOR_TILE_RENDER_ORDER_LAYER
+     */
+    labelRenderOrder?: VectorTileRenderOrder;
+    /**
+     * Sets the current display order of the buildings.
+     * Default is VECTOR_TILE_RENDER_ORDER_LAYER.
+     */
+    buildingRenderOrder?: VectorTileRenderOrder;
 }
 
 export interface CartoOnlineVectorTileLayerOptions extends VectorTileLayerOptions {
@@ -90,6 +123,42 @@ export interface ClusteredVectorLayerLayerOptions extends VectorTileLayerOptions
 }
 
 export abstract class BaseVectorTileLayer<T, U extends TileLayerOptions> extends TileLayer<T, U> {
+    /**
+     * Sets the relative layer blending speed.
+     * Default is 1.0. Use zero or negative values to disable blending.
+     */
+    layerBlendingSpeed: number;
+    /**
+     * Sets the relative label blending speed.
+     * Default is 1.0. Use zero or negative values to disable blending.
+     */
+    labelBlendingSpeed: number;
+
+    /**
+     * Sets the click radius of vector tile features.
+     * The click radius is applied as an extra buffer to the vector tile features to make clicking on small features less sensitive.
+     * Units are screen density independent pixels (DP or DIP).
+     *The default value is 4.
+     */
+    clickRadius: number;
+    /**
+     * display order of the labels. Default is VECTOR_TILE_RENDER_ORDER_LAYER
+     */
+    labelRenderOrder: VectorTileRenderOrder;
+    /**
+     * Sets the current display order of the buildings.
+     * Default is VECTOR_TILE_RENDER_ORDER_LAYER.
+     */
+    buildingRenderOrder: VectorTileRenderOrder;
+    /**
+     * the vector tile cache capacity in bytes. Tile cache is the primary storage for vector data,
+     * all tiles contained within the cache are stored as uncompressed vertex buffers and can immediately be
+     * drawn to the screen. Setting the cache size too small may cause artifacts, such as disappearing tiles.
+     * The more tiles are visible on the screen, the larger this cache should be.
+     * The default is 10MB, which should be enough for most use cases with preloading enabled. If preloading is
+     * disabled, the cache size should be reduced by the user to conserve memory.
+     */
+    tileCacheCapacity: number;
     setLabelRenderOrder(order: VectorTileRenderOrder): void;
     setBuildingRenderOrder(order: VectorTileRenderOrder);
     setVectorTileEventListener<T = DefaultLatLonKeys>(listener: VectorTileEventListener<T>, projection?: Projection): void;

src/layers/vector.ios.ts

@@ -5,13 +5,14 @@ import {
     VectorElementEventListener as IVectorElementEventListener,
     VectorTileEventListener as IVectorTileEventListener,
     VectorLayerOptions,
-    VectorTileLayerOptions
+    VectorTileRenderOrder as IVectorTileRenderOrder, 
+    VectorTileLayerOptions,
 } from './vector';
 import { Layer, TileLayer } from '.';
 import { BaseNative } from '..';
 import { VectorDataSource } from '../datasources/vector';
 import { MBVectorTileDecoder } from '../vectortiles';
-import { nativeProperty } from '../index.common';
+import { nativeProperty } from '..';
 import { fromNativeMapPos } from '../core';
 import { Projection } from '../projections';
 import { VectorElement } from '../vectorelements';
@@ -148,6 +149,13 @@ export class NTVectorTileEventListenerImpl extends NTVectorTileEventListener {
 }
 
 export abstract class BaseVectorTileLayer<T extends NTVectorTileLayer, U extends VectorTileLayerOptions> extends TileLayer<T, U> {
+
+    @nativeProperty layerBlendingSpeed:number
+    @nativeProperty labelBlendingSpeed:number
+    @nativeProperty tileCacheCapacity:number
+    @nativeProperty clickRadius:number
+    @nativeProperty labelRenderOrder: IVectorTileRenderOrder
+    @nativeProperty buildingRenderOrder: IVectorTileRenderOrder
     setLabelRenderOrder(order: NTVectorTileRenderOrder) {
         this.getNative().setLabelRenderOrder(order);
     }