@nativescript-community/ui-mapbox 6.2.31 → 7.0.0

package/markers/Marker.android.d.ts

@@ -0,0 +1,28 @@
+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;
+    pointAnnotation: com.mapbox.maps.plugin.annotation.generated.PointAnnotation;
+    viewAnnotation: android.view.View;
+    view: StackLayout;
+    anchor: com.mapbox.maps.ViewAnnotationAnchorConfig;
+    layerId: string;
+    prepared: boolean;
+    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;
+    destroy(): void;
+}

package/markers/Marker.android.js

@@ -0,0 +1,54 @@
+import { Trace } from '@nativescript/core';
+import { CLog, CLogTypes } from '../common';
+/**
+ * Hybrid Marker — uses native Mapbox annotation APIs, but NativeScript view for info window.
+ */
+export class AndroidMarker {
+    constructor(opts) {
+        this.prepared = false;
+        if (!opts.title && !opts.snippet) {
+            throw new Error('Marker should have either title or snippet!');
+        }
+        this.position = opts.position;
+        this.icon = opts.icon;
+        this.title = opts.title;
+        this.snippet = opts.snippet;
+    }
+    /**
+     * Create the native PointAnnotation
+     */
+    prepareAnnotationMarker(pointAnnotationManager, layerId) {
+        const IconAnchor = com.mapbox.maps.extension.style.layers.properties.generated.IconAnchor;
+        const PointAnnotationOptions = com.mapbox.maps.plugin.annotation.generated.PointAnnotationOptions;
+        this.pointAnnotation = pointAnnotationManager.create(new PointAnnotationOptions().withPoint(this.position).withIconAnchor(IconAnchor.valueOf('BOTTOM')).withIconImage(this.icon));
+        this.layerId = layerId;
+        if (Trace.isEnabled()) {
+            CLog(CLogTypes.log, 'MarkerManager prepareAnnotationMarker: ' + layerId);
+        }
+    }
+    update(pointAnnotationManager) {
+        if (!this.pointAnnotation) {
+            return;
+        }
+        // const PointAnnotationOptions = com.mapbox.maps.plugin.annotation.generated.PointAnnotationOptions;
+        // const IconAnchor = com.mapbox.maps.extension.style.layers.properties.generated.IconAnchor;
+        this.pointAnnotation.setGeometry(this.position);
+        // this.pointAnnotation.setIconAnchor(IconAnchor.BOTTOM);
+        this.pointAnnotation.setIconImageBitmap(this.icon);
+        // 2. Update the annotation via the manager
+        pointAnnotationManager.update(this.pointAnnotation);
+        if (this.view) {
+            const title = this.view.getViewById('title');
+            title.text = this?.title || '';
+            const subtitle = this.view.getViewById('subtitle');
+            subtitle.text = this?.snippet;
+            subtitle.visibility = this?.snippet ? 'visible' : 'collapse';
+        }
+    }
+    destroy() {
+        this.view = null;
+        this.viewAnnotation = null;
+        this.icon = null;
+    }
+}
+//# sourceMappingURL=Marker.android.js.map

package/markers/Marker.common.d.ts

@@ -0,0 +1,2 @@
+import { StackLayout } from '@nativescript/core';
+export declare function createInfoWindowView(title: any, snippet: any): StackLayout;

package/markers/Marker.common.js

@@ -0,0 +1,31 @@
+import { Color, Label, StackLayout } from '@nativescript/core';
+const MARKER_PADDING_PX = 10;
+export function createInfoWindowView(title, snippet) {
+    const view = new StackLayout();
+    view.className = 'mapbox-info-window';
+    view.padding = MARKER_PADDING_PX;
+    view.backgroundColor = 'white';
+    view.width = 'auto'; // WRAP_CONTENT
+    view.height = 'auto'; // WRAP_CONTENT
+    view.borderRadius = 12;
+    view['shadowColor'] = '#000';
+    view['shadowOpacity'] = 0.25;
+    view['shadowRadius'] = 8;
+    const titleLabel = new Label();
+    titleLabel.id = 'title';
+    titleLabel.text = title;
+    titleLabel.className = 'mapbox-info-window-title';
+    titleLabel.fontSize = 16;
+    titleLabel.fontWeight = 'bold';
+    view.addChild(titleLabel);
+    const subtitle = new Label();
+    subtitle.id = 'subtitle';
+    subtitle.text = snippet;
+    subtitle.className = 'mapbox-info-window-snippet';
+    subtitle.fontSize = 14;
+    // subtitle.visibility = snippet ? 'visible' : 'collapse';
+    subtitle.color = new Color('#555');
+    view.addChild(subtitle);
+    return view;
+}
+//# sourceMappingURL=Marker.common.js.map

package/markers/MarkerManager.android.d.ts

@@ -0,0 +1,35 @@
+import { AndroidMarker } from './Marker.android';
+/**
+ * MarkerManager (Native Android Mapbox SDK version)
+ */
+export declare class MarkerManager {
+    private static readonly MARKER_PADDING_PX;
+    private mapView;
+    private map;
+    private pointAnnotationManager;
+    private markerList;
+    private static readonly LAYER_ID;
+    private static readonly ADDITIONAL_EDGE_PADDING_PX;
+    private selectedMarker;
+    private onInfoWindowTapped;
+    private _reusableCalloutView;
+    private onMapClickListener;
+    private onPointClickListener;
+    onViewAnnotationUpdatedListener: com.mapbox.maps.viewannotation.OnViewAnnotationUpdatedListener;
+    constructor(map: com.mapbox.maps.MapboxMap, mapView: com.mapbox.maps.MapView, onMarkerClick: any, onInfoWindowClick: any);
+    deselectAll(): void;
+    adjustViewAnnotationXOffset(marker: AndroidMarker): void;
+    updateMarker(marker: AndroidMarker): void;
+    addMarker(marker: AndroidMarker): AndroidMarker;
+    /**
+     * Build a NativeScript view to use as info window.
+     * Then attach it to Mapbox via ViewAnnotationManager.
+     */
+    prepareViewAnnotation(marker: AndroidMarker, onInfoWindowClick: any): void;
+    removeMarker(marker: AndroidMarker): void;
+    selectMarker(marker: AndroidMarker, deselectIfSelected?: boolean, update?: boolean): void;
+    deselectMarker(marker: AndroidMarker): void;
+    destroy(): void;
+    updateOffsetX(marker: AndroidMarker, leftTop: any, width: number): void;
+    isSelected(marker: AndroidMarker): boolean;
+}

package/markers/MarkerManager.android.js

@@ -0,0 +1,220 @@
+import { Application, Trace, Utils } from '@nativescript/core';
+import { CLog, CLogTypes } from '../common';
+import { createInfoWindowView } from './Marker.common';
+/**
+ * MarkerManager (Native Android Mapbox SDK version)
+ */
+export class MarkerManager {
+    constructor(map, mapView, onMarkerClick, onInfoWindowClick) {
+        this.markerList = new Set();
+        this.map = map;
+        this.mapView = mapView;
+        this.onInfoWindowTapped = onInfoWindowClick;
+        const AnnotationConfig = com.mapbox.maps.plugin.annotation.AnnotationConfig;
+        const layerConfig = new AnnotationConfig(MarkerManager.LAYER_ID);
+        const annotationPlugin = mapView.getPlugin('MAPBOX_ANNOTATION_PLUGIN_ID');
+        this.pointAnnotationManager = annotationPlugin.createAnnotationManager(com.mapbox.maps.plugin.annotation.AnnotationType.PointAnnotation, layerConfig);
+        // add click listeners
+        this.onPointClickListener = new com.mapbox.maps.plugin.annotation.generated.OnPointAnnotationClickListener({
+            onAnnotationClick: (annotation) => {
+                for (const marker of this.markerList) {
+                    if (marker.pointAnnotation === annotation) {
+                        if (onMarkerClick(marker)) {
+                            return true;
+                        }
+                        this.selectMarker(marker, true);
+                    }
+                }
+                return true;
+            }
+        });
+        this.pointAnnotationManager.addClickListener(this.onPointClickListener);
+        // Map click listener to deselect all markers
+        this.onMapClickListener = new com.mapbox.maps.plugin.gestures.OnMapClickListener({
+            onMapClick: (point) => {
+                if (this.selectedMarker) {
+                    this.deselectMarker(this.selectedMarker);
+                    return true;
+                }
+                return false;
+            }
+        });
+        com.mapbox.maps.plugin.gestures.GesturesUtils.addOnMapClickListener(map, this.onMapClickListener);
+    }
+    deselectAll() {
+        this.markerList.forEach((marker) => this.deselectMarker(marker));
+    }
+    adjustViewAnnotationXOffset(marker) {
+        const listener = new com.mapbox.maps.viewannotation.OnViewAnnotationUpdatedListener({
+            onViewAnnotationPositionUpdated: (view, leftTopCoordinate, width) => {
+                if (view === marker.viewAnnotation) {
+                    this.updateOffsetX(marker, leftTopCoordinate, width);
+                }
+                com.nativescript.mapbox.ViewAnnotationManager.removeOnViewAnnotationUpdatedListener(this.mapView, listener);
+            },
+            onViewAnnotationVisibilityUpdated(view, visible) { },
+            onViewAnnotationAnchorCoordinateUpdated(param0, param1) { },
+            onViewAnnotationAnchorUpdated(param0, param1) { }
+        });
+        com.nativescript.mapbox.ViewAnnotationManager.addOnViewAnnotationUpdatedListener(this.mapView, listener);
+    }
+    updateMarker(marker) {
+        // this.adjustViewAnnotationXOffset(marker);
+        marker.update(this.pointAnnotationManager);
+        com.nativescript.mapbox.ViewAnnotationManager.updateViewAnnotation(this.mapView, marker.viewAnnotation, new com.mapbox.maps.ViewAnnotationOptions.Builder().annotatedFeature(com.mapbox.maps.AnnotatedFeature.valueOf(marker.pointAnnotation.getGeometry())).build());
+    }
+    addMarker(marker) {
+        if (Trace.isEnabled()) {
+            CLog(CLogTypes.log, 'MarkerManager addMarker: ' + JSON.stringify(marker));
+        }
+        marker.prepareAnnotationMarker(this.pointAnnotationManager, MarkerManager.LAYER_ID);
+        this.prepareViewAnnotation(marker, (e) => {
+            // info Window tapped.
+            if (!this.onInfoWindowTapped(marker)) {
+                this.deselectMarker(marker);
+            }
+        });
+        this.markerList.add(marker);
+        // this.selectMarker(marker);
+        return marker;
+    }
+    /**
+     * Build a NativeScript view to use as info window.
+     * Then attach it to Mapbox via ViewAnnotationManager.
+     */
+    prepareViewAnnotation(marker, onInfoWindowClick) {
+        // --- Step 1: Create a NativeScript view tree
+        if (this._reusableCalloutView) {
+            const title = this._reusableCalloutView.getViewById('title');
+            title.text = marker?.title || '';
+            const subtitle = this._reusableCalloutView.getViewById('subtitle');
+            subtitle.text = marker?.snippet;
+            subtitle.visibility = marker?.snippet ? 'visible' : 'collapse';
+        }
+        else {
+            this._reusableCalloutView = createInfoWindowView(marker.title, marker.snippet);
+        }
+        this._reusableCalloutView._setupAsRootView(Utils.android.getApplicationContext());
+        this._reusableCalloutView.parent = Application.getRootView();
+        this._reusableCalloutView._isAddedToNativeVisualTree = true;
+        this._reusableCalloutView.callLoaded();
+        const nativeView = this._reusableCalloutView.nativeViewProtected;
+        this._reusableCalloutView.removeEventListener('tap');
+        this._reusableCalloutView.on('tap', onInfoWindowClick);
+        const frameLayout = new android.widget.FrameLayout(this._reusableCalloutView._context);
+        const layoutParams = new android.widget.FrameLayout.LayoutParams(android.view.ViewGroup.LayoutParams.WRAP_CONTENT, android.view.ViewGroup.LayoutParams.WRAP_CONTENT);
+        frameLayout.addView(nativeView);
+        frameLayout.setLayoutParams(layoutParams);
+        frameLayout.measure(android.view.View.MeasureSpec.makeMeasureSpec(0, android.view.View.MeasureSpec.UNSPECIFIED), android.view.View.MeasureSpec.makeMeasureSpec(0, android.view.View.MeasureSpec.UNSPECIFIED));
+        frameLayout.layout(0, 0, nativeView.getMeasuredWidth(), nativeView.getMeasuredHeight());
+        // frameLayout.setLayoutParams(new android.widget.FrameLayout.LayoutParams(nativeView.getMeasuredWidth(), nativeView.getMeasuredHeight()));
+        // --- Step 3: Prepare view annotation options
+        const ViewAnnotationAnchor = com.mapbox.maps.ViewAnnotationAnchor;
+        const ViewAnnotationAnchorConfigBuilder = com.mapbox.maps.ViewAnnotationAnchorConfig.Builder;
+        const offsetY = (marker.pointAnnotation.getIconImageBitmap()?.getHeight() ?? 0) + MarkerManager.MARKER_PADDING_PX;
+        const anchor = new ViewAnnotationAnchorConfigBuilder().anchor(ViewAnnotationAnchor.BOTTOM).offsetY(offsetY).build();
+        // marker.anchor = anchor;
+        const viewAnnotationOptions = new com.mapbox.maps.ViewAnnotationOptions.Builder()
+            .visible(java.lang.Boolean.valueOf(true))
+            // .allowOverlap(java.lang.Boolean.valueOf(true))
+            // .width(java.lang.Double.valueOf(frameLayout.getMeasuredWidth()))
+            // .height(java.lang.Double.valueOf(frameLayout.getMeasuredHeight()))
+            .allowOverlapWithPuck(java.lang.Boolean.valueOf(true))
+            .ignoreCameraPadding(java.lang.Boolean.valueOf(true))
+            // .priority(java.lang.Long.valueOf(0))
+            .selected(java.lang.Boolean.valueOf(true))
+            .annotatedFeature(com.mapbox.maps.AnnotatedFeature.valueOf(marker.pointAnnotation.getGeometry()))
+            // TODO: variableAnchors is broken for now
+            .variableAnchors(java.util.Arrays.asList([
+            anchor
+            // new ViewAnnotationAnchorConfigBuilder().anchor(ViewAnnotationAnchor.BOTTOM_RIGHT).offsetY(offsetY).build(),
+            // new ViewAnnotationAnchorConfigBuilder().anchor(ViewAnnotationAnchor.BOTTOM_LEFT).offsetY(offsetY).build()
+        ]))
+            .build();
+        // --- Step 4: Add the view to Mapbox’s ViewAnnotationManager
+        com.nativescript.mapbox.ViewAnnotationManager.addViewAnnotation(this.mapView, frameLayout, viewAnnotationOptions);
+        // --- Step 5: Store references
+        marker.viewAnnotation = frameLayout;
+        marker.view = this._reusableCalloutView;
+        marker.prepared = true;
+    }
+    removeMarker(marker) {
+        if (!marker.prepared)
+            return;
+        this.markerList.delete(marker);
+        com.nativescript.mapbox.ViewAnnotationManager.removeViewAnnotation(this.mapView, marker.viewAnnotation);
+        this.pointAnnotationManager.delete(marker.pointAnnotation);
+        marker.destroy();
+    }
+    selectMarker(marker, deselectIfSelected = false, update = false) {
+        if (this.isSelected(marker) && !update) {
+            if (deselectIfSelected)
+                this.deselectMarker(marker);
+            return;
+        }
+        if (this.selectedMarker && !this.isSelected(marker)) {
+            this.deselectMarker(this.selectedMarker);
+        }
+        this.selectedMarker = marker;
+        // this.adjustViewAnnotationXOffset(marker);
+        com.nativescript.mapbox.ViewAnnotationManager.updateViewAnnotation(this.mapView, marker.viewAnnotation, new com.mapbox.maps.ViewAnnotationOptions.Builder().visible(java.lang.Boolean.valueOf(true)).selected(java.lang.Boolean.valueOf(true)).build());
+        marker.viewAnnotation.setVisibility(android.view.View.VISIBLE);
+    }
+    deselectMarker(marker) {
+        if (!this.selectedMarker || marker.pointAnnotation !== this.selectedMarker.pointAnnotation) {
+            return;
+        }
+        this.selectedMarker = null;
+        const View = android.view.View;
+        const viewAnnotationOptionsBuilder = new com.mapbox.maps.ViewAnnotationOptions.Builder().selected(java.lang.Boolean.valueOf(false)).visible(java.lang.Boolean.valueOf(false));
+        // if (marker.anchor) {
+        //     const anchorBuilder = marker.anchor.toBuilder().offsetX(0.0).build();
+        //     viewAnnotationOptionsBuilder.variableAnchors(java.util.Collections.singletonList(anchorBuilder));
+        // }
+        com.nativescript.mapbox.ViewAnnotationManager.updateViewAnnotation(this.mapView, marker.viewAnnotation, viewAnnotationOptionsBuilder.build());
+        marker.viewAnnotation.setVisibility(View.INVISIBLE);
+    }
+    destroy() {
+        this.markerList.forEach((m) => this.removeMarker(m));
+        this.pointAnnotationManager.removeClickListener(this.onPointClickListener);
+        this.onPointClickListener = null;
+        const gesturePlugin = this.mapView.getPlugin('MAPBOX_GESTURES_PLUGIN_ID');
+        com.mapbox.maps.plugin.gestures.GesturesUtils.removeOnMapClickListener(this.map, this.onMapClickListener);
+        this.onMapClickListener = null;
+        com.nativescript.mapbox.ViewAnnotationManager.removeOnViewAnnotationUpdatedListener(this.mapView, this.onViewAnnotationUpdatedListener);
+        this.onViewAnnotationUpdatedListener = null;
+        if (this._reusableCalloutView) {
+            this._reusableCalloutView._tearDownUI();
+            this._reusableCalloutView = null;
+        }
+        this.map = null;
+        this.mapView = null;
+    }
+    updateOffsetX(marker, leftTop, width) {
+        return;
+        // if (marker.preventNextUpdateOffsetX) {
+        //     marker.preventNextUpdateOffsetX = false;
+        //     return;
+        // }
+        // const mapSize = this.mapView.getMapboxMap().getSize();
+        // let resultOffsetX = 0.0;
+        // if (leftTop.getX() < 0 && leftTop.getX() + width > 0) {
+        //     resultOffsetX = Math.abs(leftTop.getX()) + MarkerManager.ADDITIONAL_EDGE_PADDING_PX;
+        // } else if (leftTop.getX() + width > mapSize.getWidth() && leftTop.getX() < width) {
+        //     resultOffsetX = mapSize.getWidth() - leftTop.getX() - width - MarkerManager.ADDITIONAL_EDGE_PADDING_PX;
+        // }
+        // const anchor = marker.anchor ? marker.anchor.toBuilder().offsetX(resultOffsetX).build() : null;
+        // if (anchor) {
+        //     const options = new com.mapbox.maps.ViewAnnotationOptions.Builder().variableAnchors(java.util.Collections.singletonList(anchor)).build();
+        //     // marker.preventNextUpdateOffsetX = true;
+        //     com.nativescript.mapbox.ViewAnnotationManager.updateViewAnnotation(this.mapView, marker.viewAnnotation, options);
+        // }
+    }
+    isSelected(marker) {
+        return this.selectedMarker?.pointAnnotation === marker.pointAnnotation;
+    }
+}
+MarkerManager.MARKER_PADDING_PX = 10;
+MarkerManager.LAYER_ID = 'annotation-layer';
+MarkerManager.ADDITIONAL_EDGE_PADDING_PX = 20.0;
+//# sourceMappingURL=MarkerManager.android.js.map

package/package.json

@@ -1,14 +1,15 @@
 {
     "name": "@nativescript-community/ui-mapbox",
-    "version": "6.2.31",
+    "version": "7.0.0",
     "description": "Interactive, thoroughly customizable maps powered by vector tiles and OpenGL.",
     "main": "index",
     "typings": "index.d.ts",
     "scripts": {
         "build": "npm run tsc && npm run readme",
-        "readme": "../../node_modules/.bin/readme generate -c ../../tools/readme/blueprint.json",
-        "tsc": "../../node_modules/.bin/cpy '**/*.d.ts' '../../packages/ui-mapbox' --parents --cwd=../../src/ui-mapbox && ../../node_modules/.bin/tsc -skipLibCheck -d",
-        "clean": "../../node_modules/.bin/rimraf ./*.d.ts ./*.js ./*.js.map"
+        "readme": "readme generate -c ../../tools/readme/blueprint.json",
+        "tsc": "cpy '**/*.d.ts' '../../packages/ui-mapbox' --parents --cwd=../../src/ui-mapbox && tsc  --build",
+        "clean": "bin/rimraf ./*.d.ts ./*.js ./*.js.map ./*.tsbuildinfo ./*.mjs ./*.mjs.map ./angular ./svelte ./vue* ./react",
+        "build.all": "npm run build"
     },
     "nativescript": {
         "platforms": {
@@ -52,7 +53,7 @@
     },
     "readmeFilename": "README.md",
     "dependencies": {
-        "@nativescript-community/perms": "^2.3.0"
+        "@nativescript-community/perms": "^3.0.4"
     },
-    "gitHead": "e5fa6d76aae45d35f8f4bacf7617423e77130f12"
+    "gitHead": "7975da7394c6777e5a43c15f34c706803201f728"
 }

package/platforms/android/include.gradle

@@ -1,43 +1,47 @@
 repositories {
     mavenCentral()
+	def MAPBOX_DOWNLOADS_TOKEN =  project.hasProperty("MAPBOX_DOWNLOADS_TOKEN") ? project.MAPBOX_DOWNLOADS_TOKEN : "$System.env.MAPBOX_DOWNLOADS_TOKEN"
+    maven {
+      url 'https://api.mapbox.com/downloads/v2/releases/maven'
+      authentication {
+          basic(BasicAuthentication)
+      }
+      credentials {
+        // Do not change the username below.
+        // This should always be `mapbox` (not your username). 
+          username = 'mapbox'
+          // Use the secret token you stored in gradle.properties as the password
+          password = MAPBOX_DOWNLOADS_TOKEN
+      }
+    }
 }
 
 // see https://www.mapbox.com/android-sdk/
 dependencies {
-	def mapboxVersion =  project.hasProperty("mapboxVersion") ? project.mapboxVersion : "8.6.6"
-	def mapboxServicesVersion =  project.hasProperty("mapboxServicesVersion") ? project.mapboxServicesVersion : "5.6.0"
-	// def mapboxTelemetryVersion =  project.hasProperty("mapboxTelemetryVersion") ? project.mapboxTelemetryVersion : "6.1.0"
+	def mapboxVersion =  project.hasProperty("mapboxVersion") ? project.mapboxVersion : "11.15.3"
+	def mapboxServicesVersion =  project.hasProperty("mapboxServicesVersion") ? project.mapboxServicesVersion : "7.8.0"
 	def mapboxPluginsVersion =  project.hasProperty("mapboxPluginsVersion") ? project.mapboxPluginsVersion : "v9"
 	def mapboxAnnotationPluginVersion =  project.hasProperty("mapboxAnnotationPluginVersion") ? project.mapboxAnnotationPluginVersion : "0.9.0"
-	// def mapboxGesturesVersion =  project.hasProperty("mapboxGesturesVersion") ? project.mapboxGesturesVersion : "0.7.0"
 	def okHttpVersion =  project.hasProperty("okHttpVersion") ? project.okHttpVersion : "4.9.0"
-    implementation ("com.mapbox.mapboxsdk:mapbox-android-sdk:$mapboxVersion") {
-        // transitive=false
-    }
-    if (project.hasProperty("mapboxTelemetryVersion")) {
-	    def mapboxTelemetryVersion =  project.hasProperty("mapboxTelemetryVersion") ? project.mapboxTelemetryVersion : "6.1.0"
-        implementation ("com.mapbox.mapboxsdk:mapbox-android-telemetry:$mapboxTelemetryVersion") 
-    }
-    // implementation ("com.mapbox.mapboxsdk:mapbox-android-telemetry:$mapboxTelemetryVersion") {
-    //     transitive=false
-    // }
-    implementation ("com.mapbox.mapboxsdk:mapbox-sdk-geojson:$mapboxServicesVersion"){
-        // transitive=false
-    }
-    // implementation ("com.mapbox.mapboxsdk:mapbox-android-gestures:$mapboxGesturesVersion"){
-    //     transitive=false
-    // }
-    // implementation ("com.mapbox.mapboxsdk:mapbox-sdk-services:$mapboxServicesVersion"){
-    //     transitive=false
-    // }
 
-    implementation ("com.mapbox.mapboxsdk:mapbox-android-plugin-annotation-$mapboxPluginsVersion:$mapboxAnnotationPluginVersion")
-    // implementation ("com.mapbox.mapboxsdk:mapbox-android-plugin-annotation-$mapboxPluginsVersion:$mapboxAnnotationPluginVersion"){
-    // }
+    println "com.mapbox.maps:android:$mapboxVersion"
+
+    // Core Mapbox Maps SDK v11+
+    implementation "com.mapbox.maps:android:$mapboxVersion"
+
+    // GeoJSON / Annotations support (choose correct module name & version)
+    implementation "com.mapbox.mapboxsdk:mapbox-sdk-geojson:$mapboxServicesVersion"  // example version
+    // implementation "com.mapbox.plugin:maps-annotation:$mapboxVersion"  // plugin example
+
+    // Additional plugins: e.g., location component, gestures, etc.  
+    // implementation "com.mapbox.plugin:maps-locationcomponent:$mapboxVersion"
+    // implementation "com.mapbox.plugin:maps-gestures:$mapboxVersion"
 
     implementation "com.squareup.okhttp3:okhttp:$okHttpVersion"
 
-    println "com.mapbox.mapboxsdk:mapbox-android-sdk:$mapboxVersion"
+    // If you need Mapbox Search or Navigation SDKs, add here 
+    // implementation "com.mapbox.search:autofill:1.0.0-beta.39"
+    // implementation "com.mapbox.navigation:android:3.0.0"
 
 }
 

package/platforms/ios/Podfile

@@ -1,2 +1,4 @@
 # see https://github.com/CocoaPods/CocoaPods/issues/11867 for why i use podspec
-pod 'Mapbox-iOS-SDK', :podspec => 'https://raw.githubusercontent.com/nativescript-community/mapbox-gl-native-ios/refs/heads/main/Mapbox-iOS-SDK.podspec'
+# pod 'Mapbox-iOS-SDK', :podspec => 'https://raw.githubusercontent.com/nativescript-community/mapbox-gl-native-ios/refs/heads/main/Mapbox-iOS-SDK.podspec'
+platform :ios, '14.0'
+pod 'MapboxMaps', '11.16.0'