@maydon_tech/react-native-nitro-maps 0.1.3 → 0.2.0

package/nitrogen/generated/shared/c++/ClusterConfig.hpp

@@ -27,15 +27,12 @@
 namespace margelo::nitro::nitromap { enum class ClusterStrategy; }
 // Forward declaration of `MarkerColor` to properly resolve imports.
 namespace margelo::nitro::nitromap { struct MarkerColor; }
-// Forward declaration of `ClusterAnimationStyle` to properly resolve imports.
-namespace margelo::nitro::nitromap { enum class ClusterAnimationStyle; }
 
 #include "ClusterStrategy.hpp"
 #include <optional>
 #include <string>
 #include "MarkerColor.hpp"
 #include <variant>
-#include "ClusterAnimationStyle.hpp"
 
 namespace margelo::nitro::nitromap {
 
@@ -54,15 +51,15 @@ namespace margelo::nitro::nitromap {
     std::optional<double> borderWidth     SWIFT_PRIVATE;
     std::optional<std::variant<std::string, MarkerColor>> borderColor     SWIFT_PRIVATE;
     std::optional<bool> animatesClusters     SWIFT_PRIVATE;
+    std::optional<bool> animateOnReappear     SWIFT_PRIVATE;
     std::optional<double> animationDuration     SWIFT_PRIVATE;
-    std::optional<ClusterAnimationStyle> animationStyle     SWIFT_PRIVATE;
     std::optional<bool> realtimeClustering     SWIFT_PRIVATE;
     std::optional<double> renderBuffer     SWIFT_PRIVATE;
     std::optional<double> throttleInterval     SWIFT_PRIVATE;
 
   public:
     ClusterConfig() = default;
-    explicit ClusterConfig(bool enabled, std::optional<ClusterStrategy> strategy, std::optional<double> radius, std::optional<double> minimumClusterSize, std::optional<double> maxZoom, std::optional<std::variant<std::string, MarkerColor>> backgroundColor, std::optional<std::variant<std::string, MarkerColor>> textColor, std::optional<double> borderWidth, std::optional<std::variant<std::string, MarkerColor>> borderColor, std::optional<bool> animatesClusters, std::optional<double> animationDuration, std::optional<ClusterAnimationStyle> animationStyle, std::optional<bool> realtimeClustering, std::optional<double> renderBuffer, std::optional<double> throttleInterval): enabled(enabled), strategy(strategy), radius(radius), minimumClusterSize(minimumClusterSize), maxZoom(maxZoom), backgroundColor(backgroundColor), textColor(textColor), borderWidth(borderWidth), borderColor(borderColor), animatesClusters(animatesClusters), animationDuration(animationDuration), animationStyle(animationStyle), realtimeClustering(realtimeClustering), renderBuffer(renderBuffer), throttleInterval(throttleInterval) {}
+    explicit ClusterConfig(bool enabled, std::optional<ClusterStrategy> strategy, std::optional<double> radius, std::optional<double> minimumClusterSize, std::optional<double> maxZoom, std::optional<std::variant<std::string, MarkerColor>> backgroundColor, std::optional<std::variant<std::string, MarkerColor>> textColor, std::optional<double> borderWidth, std::optional<std::variant<std::string, MarkerColor>> borderColor, std::optional<bool> animatesClusters, std::optional<bool> animateOnReappear, std::optional<double> animationDuration, std::optional<bool> realtimeClustering, std::optional<double> renderBuffer, std::optional<double> throttleInterval): enabled(enabled), strategy(strategy), radius(radius), minimumClusterSize(minimumClusterSize), maxZoom(maxZoom), backgroundColor(backgroundColor), textColor(textColor), borderWidth(borderWidth), borderColor(borderColor), animatesClusters(animatesClusters), animateOnReappear(animateOnReappear), animationDuration(animationDuration), realtimeClustering(realtimeClustering), renderBuffer(renderBuffer), throttleInterval(throttleInterval) {}
   };
 
 } // namespace margelo::nitro::nitromap
@@ -85,8 +82,8 @@ namespace margelo::nitro {
         JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, "borderWidth")),
         JSIConverter<std::optional<std::variant<std::string, margelo::nitro::nitromap::MarkerColor>>>::fromJSI(runtime, obj.getProperty(runtime, "borderColor")),
         JSIConverter<std::optional<bool>>::fromJSI(runtime, obj.getProperty(runtime, "animatesClusters")),
+        JSIConverter<std::optional<bool>>::fromJSI(runtime, obj.getProperty(runtime, "animateOnReappear")),
         JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, "animationDuration")),
-        JSIConverter<std::optional<margelo::nitro::nitromap::ClusterAnimationStyle>>::fromJSI(runtime, obj.getProperty(runtime, "animationStyle")),
         JSIConverter<std::optional<bool>>::fromJSI(runtime, obj.getProperty(runtime, "realtimeClustering")),
         JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, "renderBuffer")),
         JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, "throttleInterval"))
@@ -104,8 +101,8 @@ namespace margelo::nitro {
       obj.setProperty(runtime, "borderWidth", JSIConverter<std::optional<double>>::toJSI(runtime, arg.borderWidth));
       obj.setProperty(runtime, "borderColor", JSIConverter<std::optional<std::variant<std::string, margelo::nitro::nitromap::MarkerColor>>>::toJSI(runtime, arg.borderColor));
       obj.setProperty(runtime, "animatesClusters", JSIConverter<std::optional<bool>>::toJSI(runtime, arg.animatesClusters));
+      obj.setProperty(runtime, "animateOnReappear", JSIConverter<std::optional<bool>>::toJSI(runtime, arg.animateOnReappear));
       obj.setProperty(runtime, "animationDuration", JSIConverter<std::optional<double>>::toJSI(runtime, arg.animationDuration));
-      obj.setProperty(runtime, "animationStyle", JSIConverter<std::optional<margelo::nitro::nitromap::ClusterAnimationStyle>>::toJSI(runtime, arg.animationStyle));
       obj.setProperty(runtime, "realtimeClustering", JSIConverter<std::optional<bool>>::toJSI(runtime, arg.realtimeClustering));
       obj.setProperty(runtime, "renderBuffer", JSIConverter<std::optional<double>>::toJSI(runtime, arg.renderBuffer));
       obj.setProperty(runtime, "throttleInterval", JSIConverter<std::optional<double>>::toJSI(runtime, arg.throttleInterval));
@@ -129,8 +126,8 @@ namespace margelo::nitro {
       if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, "borderWidth"))) return false;
       if (!JSIConverter<std::optional<std::variant<std::string, margelo::nitro::nitromap::MarkerColor>>>::canConvert(runtime, obj.getProperty(runtime, "borderColor"))) return false;
       if (!JSIConverter<std::optional<bool>>::canConvert(runtime, obj.getProperty(runtime, "animatesClusters"))) return false;
+      if (!JSIConverter<std::optional<bool>>::canConvert(runtime, obj.getProperty(runtime, "animateOnReappear"))) return false;
       if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, "animationDuration"))) return false;
-      if (!JSIConverter<std::optional<margelo::nitro::nitromap::ClusterAnimationStyle>>::canConvert(runtime, obj.getProperty(runtime, "animationStyle"))) return false;
       if (!JSIConverter<std::optional<bool>>::canConvert(runtime, obj.getProperty(runtime, "realtimeClustering"))) return false;
       if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, "renderBuffer"))) return false;
       if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, "throttleInterval"))) return false;

package/nitrogen/generated/shared/c++/HybridNitroMapSpec.cpp

@@ -18,6 +18,8 @@ namespace margelo::nitro::nitromap {
       prototype.registerHybridSetter("provider", &HybridNitroMapSpec::setProvider);
       prototype.registerHybridGetter("initialRegion", &HybridNitroMapSpec::getInitialRegion);
       prototype.registerHybridSetter("initialRegion", &HybridNitroMapSpec::setInitialRegion);
+      prototype.registerHybridGetter("region", &HybridNitroMapSpec::getRegion);
+      prototype.registerHybridSetter("region", &HybridNitroMapSpec::setRegion);
       prototype.registerHybridGetter("showsUserLocation", &HybridNitroMapSpec::getShowsUserLocation);
       prototype.registerHybridSetter("showsUserLocation", &HybridNitroMapSpec::setShowsUserLocation);
       prototype.registerHybridGetter("zoomEnabled", &HybridNitroMapSpec::getZoomEnabled);
@@ -32,12 +34,30 @@ namespace margelo::nitro::nitromap {
       prototype.registerHybridSetter("mapType", &HybridNitroMapSpec::setMapType);
       prototype.registerHybridGetter("customMapStyle", &HybridNitroMapSpec::getCustomMapStyle);
       prototype.registerHybridSetter("customMapStyle", &HybridNitroMapSpec::setCustomMapStyle);
-      prototype.registerHybridGetter("showsMyLocationButton", &HybridNitroMapSpec::getShowsMyLocationButton);
-      prototype.registerHybridSetter("showsMyLocationButton", &HybridNitroMapSpec::setShowsMyLocationButton);
       prototype.registerHybridGetter("clusterConfig", &HybridNitroMapSpec::getClusterConfig);
       prototype.registerHybridSetter("clusterConfig", &HybridNitroMapSpec::setClusterConfig);
+      prototype.registerHybridGetter("mapPadding", &HybridNitroMapSpec::getMapPadding);
+      prototype.registerHybridSetter("mapPadding", &HybridNitroMapSpec::setMapPadding);
+      prototype.registerHybridGetter("showsTraffic", &HybridNitroMapSpec::getShowsTraffic);
+      prototype.registerHybridSetter("showsTraffic", &HybridNitroMapSpec::setShowsTraffic);
+      prototype.registerHybridGetter("showsBuildings", &HybridNitroMapSpec::getShowsBuildings);
+      prototype.registerHybridSetter("showsBuildings", &HybridNitroMapSpec::setShowsBuildings);
+      prototype.registerHybridGetter("showsCompass", &HybridNitroMapSpec::getShowsCompass);
+      prototype.registerHybridSetter("showsCompass", &HybridNitroMapSpec::setShowsCompass);
+      prototype.registerHybridGetter("minZoom", &HybridNitroMapSpec::getMinZoom);
+      prototype.registerHybridSetter("minZoom", &HybridNitroMapSpec::setMinZoom);
+      prototype.registerHybridGetter("maxZoom", &HybridNitroMapSpec::getMaxZoom);
+      prototype.registerHybridSetter("maxZoom", &HybridNitroMapSpec::setMaxZoom);
       prototype.registerHybridGetter("darkMode", &HybridNitroMapSpec::getDarkMode);
       prototype.registerHybridSetter("darkMode", &HybridNitroMapSpec::setDarkMode);
+      prototype.registerHybridGetter("userTrackingMode", &HybridNitroMapSpec::getUserTrackingMode);
+      prototype.registerHybridSetter("userTrackingMode", &HybridNitroMapSpec::setUserTrackingMode);
+      prototype.registerHybridGetter("userLocationImage", &HybridNitroMapSpec::getUserLocationImage);
+      prototype.registerHybridSetter("userLocationImage", &HybridNitroMapSpec::setUserLocationImage);
+      prototype.registerHybridGetter("userLocationSize", &HybridNitroMapSpec::getUserLocationSize);
+      prototype.registerHybridSetter("userLocationSize", &HybridNitroMapSpec::setUserLocationSize);
+      prototype.registerHybridGetter("userLocationAnchor", &HybridNitroMapSpec::getUserLocationAnchor);
+      prototype.registerHybridSetter("userLocationAnchor", &HybridNitroMapSpec::setUserLocationAnchor);
       prototype.registerHybridGetter("onPress", &HybridNitroMapSpec::getOnPress);
       prototype.registerHybridSetter("onPress", &HybridNitroMapSpec::setOnPress);
       prototype.registerHybridGetter("onLongPress", &HybridNitroMapSpec::getOnLongPress);
@@ -58,24 +78,55 @@ namespace margelo::nitro::nitromap {
       prototype.registerHybridSetter("onMarkerDragEnd", &HybridNitroMapSpec::setOnMarkerDragEnd);
       prototype.registerHybridGetter("onClusterPress", &HybridNitroMapSpec::getOnClusterPress);
       prototype.registerHybridSetter("onClusterPress", &HybridNitroMapSpec::setOnClusterPress);
+      prototype.registerHybridGetter("onPolylinePress", &HybridNitroMapSpec::getOnPolylinePress);
+      prototype.registerHybridSetter("onPolylinePress", &HybridNitroMapSpec::setOnPolylinePress);
+      prototype.registerHybridGetter("onPolygonPress", &HybridNitroMapSpec::getOnPolygonPress);
+      prototype.registerHybridSetter("onPolygonPress", &HybridNitroMapSpec::setOnPolygonPress);
+      prototype.registerHybridGetter("onCirclePress", &HybridNitroMapSpec::getOnCirclePress);
+      prototype.registerHybridSetter("onCirclePress", &HybridNitroMapSpec::setOnCirclePress);
       prototype.registerHybridGetter("onError", &HybridNitroMapSpec::getOnError);
       prototype.registerHybridSetter("onError", &HybridNitroMapSpec::setOnError);
+      prototype.registerHybridGetter("onUserLocationChange", &HybridNitroMapSpec::getOnUserLocationChange);
+      prototype.registerHybridSetter("onUserLocationChange", &HybridNitroMapSpec::setOnUserLocationChange);
+      prototype.registerHybridGetter("onUserTrackingModeChange", &HybridNitroMapSpec::getOnUserTrackingModeChange);
+      prototype.registerHybridSetter("onUserTrackingModeChange", &HybridNitroMapSpec::setOnUserTrackingModeChange);
+      prototype.registerHybridGetter("onUserLocationError", &HybridNitroMapSpec::getOnUserLocationError);
+      prototype.registerHybridSetter("onUserLocationError", &HybridNitroMapSpec::setOnUserLocationError);
+      prototype.registerHybridGetter("onMapIdle", &HybridNitroMapSpec::getOnMapIdle);
+      prototype.registerHybridSetter("onMapIdle", &HybridNitroMapSpec::setOnMapIdle);
       prototype.registerHybridMethod("animateToRegion", &HybridNitroMapSpec::animateToRegion);
       prototype.registerHybridMethod("fitToCoordinates", &HybridNitroMapSpec::fitToCoordinates);
+      prototype.registerHybridMethod("fitToSuppliedMarkers", &HybridNitroMapSpec::fitToSuppliedMarkers);
       prototype.registerHybridMethod("animateCamera", &HybridNitroMapSpec::animateCamera);
       prototype.registerHybridMethod("getCamera", &HybridNitroMapSpec::getCamera);
       prototype.registerHybridMethod("setCamera", &HybridNitroMapSpec::setCamera);
       prototype.registerHybridMethod("setMapStyle", &HybridNitroMapSpec::setMapStyle);
       prototype.registerHybridMethod("getMapBoundaries", &HybridNitroMapSpec::getMapBoundaries);
+      prototype.registerHybridMethod("centerOnUserLocation", &HybridNitroMapSpec::centerOnUserLocation);
+      prototype.registerHybridMethod("pointForCoordinate", &HybridNitroMapSpec::pointForCoordinate);
+      prototype.registerHybridMethod("coordinateForPoint", &HybridNitroMapSpec::coordinateForPoint);
       prototype.registerHybridMethod("setIsDarkMode", &HybridNitroMapSpec::setIsDarkMode);
       prototype.registerHybridMethod("addMarker", &HybridNitroMapSpec::addMarker);
       prototype.registerHybridMethod("addMarkers", &HybridNitroMapSpec::addMarkers);
       prototype.registerHybridMethod("updateMarker", &HybridNitroMapSpec::updateMarker);
       prototype.registerHybridMethod("removeMarker", &HybridNitroMapSpec::removeMarker);
       prototype.registerHybridMethod("selectMarker", &HybridNitroMapSpec::selectMarker);
+      prototype.registerHybridMethod("deselectMarker", &HybridNitroMapSpec::deselectMarker);
       prototype.registerHybridMethod("clearMarkers", &HybridNitroMapSpec::clearMarkers);
       prototype.registerHybridMethod("setClusteringEnabled", &HybridNitroMapSpec::setClusteringEnabled);
       prototype.registerHybridMethod("refreshClusters", &HybridNitroMapSpec::refreshClusters);
+      prototype.registerHybridMethod("addPolyline", &HybridNitroMapSpec::addPolyline);
+      prototype.registerHybridMethod("updatePolyline", &HybridNitroMapSpec::updatePolyline);
+      prototype.registerHybridMethod("removePolyline", &HybridNitroMapSpec::removePolyline);
+      prototype.registerHybridMethod("clearPolylines", &HybridNitroMapSpec::clearPolylines);
+      prototype.registerHybridMethod("addPolygon", &HybridNitroMapSpec::addPolygon);
+      prototype.registerHybridMethod("updatePolygon", &HybridNitroMapSpec::updatePolygon);
+      prototype.registerHybridMethod("removePolygon", &HybridNitroMapSpec::removePolygon);
+      prototype.registerHybridMethod("clearPolygons", &HybridNitroMapSpec::clearPolygons);
+      prototype.registerHybridMethod("addCircle", &HybridNitroMapSpec::addCircle);
+      prototype.registerHybridMethod("updateCircle", &HybridNitroMapSpec::updateCircle);
+      prototype.registerHybridMethod("removeCircle", &HybridNitroMapSpec::removeCircle);
+      prototype.registerHybridMethod("clearCircles", &HybridNitroMapSpec::clearCircles);
     });
   }
 

package/nitrogen/generated/shared/c++/HybridNitroMapSpec.hpp

@@ -23,6 +23,12 @@ namespace margelo::nitro::nitromap { enum class MapType; }
 namespace margelo::nitro::nitromap { struct MapStyleElement; }
 // Forward declaration of `ClusterConfig` to properly resolve imports.
 namespace margelo::nitro::nitromap { struct ClusterConfig; }
+// Forward declaration of `EdgePadding` to properly resolve imports.
+namespace margelo::nitro::nitromap { struct EdgePadding; }
+// Forward declaration of `UserTrackingMode` to properly resolve imports.
+namespace margelo::nitro::nitromap { enum class UserTrackingMode; }
+// Forward declaration of `Point` to properly resolve imports.
+namespace margelo::nitro::nitromap { struct Point; }
 // Forward declaration of `MapPressEvent` to properly resolve imports.
 namespace margelo::nitro::nitromap { struct MapPressEvent; }
 // Forward declaration of `RegionChangeEvent` to properly resolve imports.
@@ -35,16 +41,22 @@ namespace margelo::nitro::nitromap { struct MarkerDragEvent; }
 namespace margelo::nitro::nitromap { struct ClusterPressEvent; }
 // Forward declaration of `MapError` to properly resolve imports.
 namespace margelo::nitro::nitromap { struct MapError; }
+// Forward declaration of `UserLocationChangeEvent` to properly resolve imports.
+namespace margelo::nitro::nitromap { struct UserLocationChangeEvent; }
 // Forward declaration of `Coordinate` to properly resolve imports.
 namespace margelo::nitro::nitromap { struct Coordinate; }
-// Forward declaration of `EdgePadding` to properly resolve imports.
-namespace margelo::nitro::nitromap { struct EdgePadding; }
 // Forward declaration of `Camera` to properly resolve imports.
 namespace margelo::nitro::nitromap { struct Camera; }
 // Forward declaration of `MapBoundaries` to properly resolve imports.
 namespace margelo::nitro::nitromap { struct MapBoundaries; }
 // Forward declaration of `MarkerData` to properly resolve imports.
 namespace margelo::nitro::nitromap { struct MarkerData; }
+// Forward declaration of `PolylineData` to properly resolve imports.
+namespace margelo::nitro::nitromap { struct PolylineData; }
+// Forward declaration of `PolygonData` to properly resolve imports.
+namespace margelo::nitro::nitromap { struct PolygonData; }
+// Forward declaration of `CircleData` to properly resolve imports.
+namespace margelo::nitro::nitromap { struct CircleData; }
 
 #include "MapProvider.hpp"
 #include <optional>
@@ -53,6 +65,10 @@ namespace margelo::nitro::nitromap { struct MarkerData; }
 #include "MapStyleElement.hpp"
 #include <vector>
 #include "ClusterConfig.hpp"
+#include "EdgePadding.hpp"
+#include "UserTrackingMode.hpp"
+#include <string>
+#include "Point.hpp"
 #include "MapPressEvent.hpp"
 #include <functional>
 #include "RegionChangeEvent.hpp"
@@ -60,13 +76,15 @@ namespace margelo::nitro::nitromap { struct MarkerData; }
 #include "MarkerDragEvent.hpp"
 #include "ClusterPressEvent.hpp"
 #include "MapError.hpp"
+#include "UserLocationChangeEvent.hpp"
 #include "Coordinate.hpp"
-#include "EdgePadding.hpp"
 #include "Camera.hpp"
 #include <NitroModules/Promise.hpp>
 #include "MapBoundaries.hpp"
 #include "MarkerData.hpp"
-#include <string>
+#include "PolylineData.hpp"
+#include "PolygonData.hpp"
+#include "CircleData.hpp"
 
 namespace margelo::nitro::nitromap {
 
@@ -99,6 +117,8 @@ namespace margelo::nitro::nitromap {
       virtual void setProvider(std::optional<MapProvider> provider) = 0;
       virtual std::optional<Region> getInitialRegion() = 0;
       virtual void setInitialRegion(const std::optional<Region>& initialRegion) = 0;
+      virtual std::optional<Region> getRegion() = 0;
+      virtual void setRegion(const std::optional<Region>& region) = 0;
       virtual std::optional<bool> getShowsUserLocation() = 0;
       virtual void setShowsUserLocation(std::optional<bool> showsUserLocation) = 0;
       virtual std::optional<bool> getZoomEnabled() = 0;
@@ -113,12 +133,30 @@ namespace margelo::nitro::nitromap {
       virtual void setMapType(std::optional<MapType> mapType) = 0;
       virtual std::optional<std::vector<MapStyleElement>> getCustomMapStyle() = 0;
       virtual void setCustomMapStyle(const std::optional<std::vector<MapStyleElement>>& customMapStyle) = 0;
-      virtual std::optional<bool> getShowsMyLocationButton() = 0;
-      virtual void setShowsMyLocationButton(std::optional<bool> showsMyLocationButton) = 0;
       virtual std::optional<ClusterConfig> getClusterConfig() = 0;
       virtual void setClusterConfig(const std::optional<ClusterConfig>& clusterConfig) = 0;
+      virtual EdgePadding getMapPadding() = 0;
+      virtual void setMapPadding(const EdgePadding& mapPadding) = 0;
+      virtual std::optional<bool> getShowsTraffic() = 0;
+      virtual void setShowsTraffic(std::optional<bool> showsTraffic) = 0;
+      virtual std::optional<bool> getShowsBuildings() = 0;
+      virtual void setShowsBuildings(std::optional<bool> showsBuildings) = 0;
+      virtual std::optional<bool> getShowsCompass() = 0;
+      virtual void setShowsCompass(std::optional<bool> showsCompass) = 0;
+      virtual double getMinZoom() = 0;
+      virtual void setMinZoom(double minZoom) = 0;
+      virtual double getMaxZoom() = 0;
+      virtual void setMaxZoom(double maxZoom) = 0;
       virtual std::optional<bool> getDarkMode() = 0;
       virtual void setDarkMode(std::optional<bool> darkMode) = 0;
+      virtual std::optional<UserTrackingMode> getUserTrackingMode() = 0;
+      virtual void setUserTrackingMode(std::optional<UserTrackingMode> userTrackingMode) = 0;
+      virtual std::string getUserLocationImage() = 0;
+      virtual void setUserLocationImage(const std::string& userLocationImage) = 0;
+      virtual double getUserLocationSize() = 0;
+      virtual void setUserLocationSize(double userLocationSize) = 0;
+      virtual std::optional<Point> getUserLocationAnchor() = 0;
+      virtual void setUserLocationAnchor(const std::optional<Point>& userLocationAnchor) = 0;
       virtual std::optional<std::function<void(const MapPressEvent& /* event */)>> getOnPress() = 0;
       virtual void setOnPress(const std::optional<std::function<void(const MapPressEvent& /* event */)>>& onPress) = 0;
       virtual std::optional<std::function<void(const MapPressEvent& /* event */)>> getOnLongPress() = 0;
@@ -139,27 +177,58 @@ namespace margelo::nitro::nitromap {
       virtual void setOnMarkerDragEnd(const std::optional<std::function<void(const MarkerDragEvent& /* event */)>>& onMarkerDragEnd) = 0;
       virtual std::optional<std::function<void(const ClusterPressEvent& /* event */)>> getOnClusterPress() = 0;
       virtual void setOnClusterPress(const std::optional<std::function<void(const ClusterPressEvent& /* event */)>>& onClusterPress) = 0;
+      virtual std::optional<std::function<void(const std::string& /* id */)>> getOnPolylinePress() = 0;
+      virtual void setOnPolylinePress(const std::optional<std::function<void(const std::string& /* id */)>>& onPolylinePress) = 0;
+      virtual std::optional<std::function<void(const std::string& /* id */)>> getOnPolygonPress() = 0;
+      virtual void setOnPolygonPress(const std::optional<std::function<void(const std::string& /* id */)>>& onPolygonPress) = 0;
+      virtual std::optional<std::function<void(const std::string& /* id */)>> getOnCirclePress() = 0;
+      virtual void setOnCirclePress(const std::optional<std::function<void(const std::string& /* id */)>>& onCirclePress) = 0;
       virtual std::optional<std::function<void(const MapError& /* error */)>> getOnError() = 0;
       virtual void setOnError(const std::optional<std::function<void(const MapError& /* error */)>>& onError) = 0;
+      virtual std::optional<std::function<void(const UserLocationChangeEvent& /* event */)>> getOnUserLocationChange() = 0;
+      virtual void setOnUserLocationChange(const std::optional<std::function<void(const UserLocationChangeEvent& /* event */)>>& onUserLocationChange) = 0;
+      virtual std::optional<std::function<void(UserTrackingMode /* mode */)>> getOnUserTrackingModeChange() = 0;
+      virtual void setOnUserTrackingModeChange(const std::optional<std::function<void(UserTrackingMode /* mode */)>>& onUserTrackingModeChange) = 0;
+      virtual std::optional<std::function<void(const MapError& /* error */)>> getOnUserLocationError() = 0;
+      virtual void setOnUserLocationError(const std::optional<std::function<void(const MapError& /* error */)>>& onUserLocationError) = 0;
+      virtual std::optional<std::function<void()>> getOnMapIdle() = 0;
+      virtual void setOnMapIdle(const std::optional<std::function<void()>>& onMapIdle) = 0;
 
     public:
       // Methods
       virtual void animateToRegion(const Region& region, std::optional<double> duration) = 0;
       virtual void fitToCoordinates(const std::vector<Coordinate>& coordinates, const std::optional<EdgePadding>& edgePadding, std::optional<bool> animated) = 0;
+      virtual void fitToSuppliedMarkers(const std::vector<std::string>& markerIds, const std::optional<EdgePadding>& edgePadding, std::optional<bool> animated) = 0;
       virtual void animateCamera(const Camera& camera, std::optional<double> duration) = 0;
       virtual std::shared_ptr<Promise<Camera>> getCamera() = 0;
       virtual void setCamera(const Camera& camera) = 0;
       virtual void setMapStyle(const std::optional<std::vector<MapStyleElement>>& style) = 0;
       virtual std::shared_ptr<Promise<MapBoundaries>> getMapBoundaries() = 0;
+      virtual void centerOnUserLocation() = 0;
+      virtual Point pointForCoordinate(const Coordinate& coordinate) = 0;
+      virtual Coordinate coordinateForPoint(const Point& point) = 0;
       virtual void setIsDarkMode(bool enabled) = 0;
       virtual void addMarker(const MarkerData& marker) = 0;
       virtual void addMarkers(const std::vector<MarkerData>& markers) = 0;
       virtual void updateMarker(const MarkerData& marker) = 0;
       virtual void removeMarker(const std::string& id) = 0;
       virtual void selectMarker(const std::string& id) = 0;
+      virtual void deselectMarker() = 0;
       virtual void clearMarkers() = 0;
       virtual void setClusteringEnabled(bool enabled) = 0;
       virtual void refreshClusters() = 0;
+      virtual void addPolyline(const PolylineData& polyline) = 0;
+      virtual void updatePolyline(const PolylineData& polyline) = 0;
+      virtual void removePolyline(const std::string& id) = 0;
+      virtual void clearPolylines() = 0;
+      virtual void addPolygon(const PolygonData& polygon) = 0;
+      virtual void updatePolygon(const PolygonData& polygon) = 0;
+      virtual void removePolygon(const std::string& id) = 0;
+      virtual void clearPolygons() = 0;
+      virtual void addCircle(const CircleData& circle) = 0;
+      virtual void updateCircle(const CircleData& circle) = 0;
+      virtual void removeCircle(const std::string& id) = 0;
+      virtual void clearCircles() = 0;
 
     protected:
       // Hybrid Setup

package/nitrogen/generated/shared/c++/MarkerAnimation.hpp

@@ -30,8 +30,7 @@ namespace margelo::nitro::nitromap {
    */
   enum class MarkerAnimation {
     NONE      SWIFT_NAME(none) = 0,
-    POP      SWIFT_NAME(pop) = 1,
-    FADEIN      SWIFT_NAME(fadein) = 2,
+    APPEAR      SWIFT_NAME(appear) = 1,
   } CLOSED_ENUM;
 
 } // namespace margelo::nitro::nitromap
@@ -45,8 +44,7 @@ namespace margelo::nitro {
       std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, arg);
       switch (hashString(unionValue.c_str(), unionValue.size())) {
         case hashString("none"): return margelo::nitro::nitromap::MarkerAnimation::NONE;
-        case hashString("pop"): return margelo::nitro::nitromap::MarkerAnimation::POP;
-        case hashString("fadeIn"): return margelo::nitro::nitromap::MarkerAnimation::FADEIN;
+        case hashString("appear"): return margelo::nitro::nitromap::MarkerAnimation::APPEAR;
         default: [[unlikely]]
           throw std::invalid_argument("Cannot convert \"" + unionValue + "\" to enum MarkerAnimation - invalid value!");
       }
@@ -54,8 +52,7 @@ namespace margelo::nitro {
     static inline jsi::Value toJSI(jsi::Runtime& runtime, margelo::nitro::nitromap::MarkerAnimation arg) {
       switch (arg) {
         case margelo::nitro::nitromap::MarkerAnimation::NONE: return JSIConverter<std::string>::toJSI(runtime, "none");
-        case margelo::nitro::nitromap::MarkerAnimation::POP: return JSIConverter<std::string>::toJSI(runtime, "pop");
-        case margelo::nitro::nitromap::MarkerAnimation::FADEIN: return JSIConverter<std::string>::toJSI(runtime, "fadeIn");
+        case margelo::nitro::nitromap::MarkerAnimation::APPEAR: return JSIConverter<std::string>::toJSI(runtime, "appear");
         default: [[unlikely]]
           throw std::invalid_argument("Cannot convert MarkerAnimation to JS - invalid value: "
                                     + std::to_string(static_cast<int>(arg)) + "!");
@@ -68,8 +65,7 @@ namespace margelo::nitro {
       std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, value);
       switch (hashString(unionValue.c_str(), unionValue.size())) {
         case hashString("none"):
-        case hashString("pop"):
-        case hashString("fadeIn"):
+        case hashString("appear"):
           return true;
         default:
           return false;

package/nitrogen/generated/shared/c++/MarkerData.hpp

@@ -56,12 +56,15 @@ namespace margelo::nitro::nitromap {
     double zIndex     SWIFT_PRIVATE;
     Point anchor     SWIFT_PRIVATE;
     MarkerConfig config     SWIFT_PRIVATE;
+    std::optional<std::string> accessibilityLabel     SWIFT_PRIVATE;
     bool clusteringEnabled     SWIFT_PRIVATE;
     MarkerAnimation animation     SWIFT_PRIVATE;
+    double animationDuration     SWIFT_PRIVATE;
+    bool animateOnReappear     SWIFT_PRIVATE;
 
   public:
     MarkerData() = default;
-    explicit MarkerData(std::string id, Coordinate coordinate, std::optional<std::string> title, std::optional<std::string> description, bool draggable, double opacity, double rotation, double zIndex, Point anchor, MarkerConfig config, bool clusteringEnabled, MarkerAnimation animation): id(id), coordinate(coordinate), title(title), description(description), draggable(draggable), opacity(opacity), rotation(rotation), zIndex(zIndex), anchor(anchor), config(config), clusteringEnabled(clusteringEnabled), animation(animation) {}
+    explicit MarkerData(std::string id, Coordinate coordinate, std::optional<std::string> title, std::optional<std::string> description, bool draggable, double opacity, double rotation, double zIndex, Point anchor, MarkerConfig config, std::optional<std::string> accessibilityLabel, bool clusteringEnabled, MarkerAnimation animation, double animationDuration, bool animateOnReappear): id(id), coordinate(coordinate), title(title), description(description), draggable(draggable), opacity(opacity), rotation(rotation), zIndex(zIndex), anchor(anchor), config(config), accessibilityLabel(accessibilityLabel), clusteringEnabled(clusteringEnabled), animation(animation), animationDuration(animationDuration), animateOnReappear(animateOnReappear) {}
   };
 
 } // namespace margelo::nitro::nitromap
@@ -84,8 +87,11 @@ namespace margelo::nitro {
         JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, "zIndex")),
         JSIConverter<margelo::nitro::nitromap::Point>::fromJSI(runtime, obj.getProperty(runtime, "anchor")),
         JSIConverter<margelo::nitro::nitromap::MarkerConfig>::fromJSI(runtime, obj.getProperty(runtime, "config")),
+        JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, "accessibilityLabel")),
         JSIConverter<bool>::fromJSI(runtime, obj.getProperty(runtime, "clusteringEnabled")),
-        JSIConverter<margelo::nitro::nitromap::MarkerAnimation>::fromJSI(runtime, obj.getProperty(runtime, "animation"))
+        JSIConverter<margelo::nitro::nitromap::MarkerAnimation>::fromJSI(runtime, obj.getProperty(runtime, "animation")),
+        JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, "animationDuration")),
+        JSIConverter<bool>::fromJSI(runtime, obj.getProperty(runtime, "animateOnReappear"))
       );
     }
     static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::nitromap::MarkerData& arg) {
@@ -100,8 +106,11 @@ namespace margelo::nitro {
       obj.setProperty(runtime, "zIndex", JSIConverter<double>::toJSI(runtime, arg.zIndex));
       obj.setProperty(runtime, "anchor", JSIConverter<margelo::nitro::nitromap::Point>::toJSI(runtime, arg.anchor));
       obj.setProperty(runtime, "config", JSIConverter<margelo::nitro::nitromap::MarkerConfig>::toJSI(runtime, arg.config));
+      obj.setProperty(runtime, "accessibilityLabel", JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.accessibilityLabel));
       obj.setProperty(runtime, "clusteringEnabled", JSIConverter<bool>::toJSI(runtime, arg.clusteringEnabled));
       obj.setProperty(runtime, "animation", JSIConverter<margelo::nitro::nitromap::MarkerAnimation>::toJSI(runtime, arg.animation));
+      obj.setProperty(runtime, "animationDuration", JSIConverter<double>::toJSI(runtime, arg.animationDuration));
+      obj.setProperty(runtime, "animateOnReappear", JSIConverter<bool>::toJSI(runtime, arg.animateOnReappear));
       return obj;
     }
     static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
@@ -122,8 +131,11 @@ namespace margelo::nitro {
       if (!JSIConverter<double>::canConvert(runtime, obj.getProperty(runtime, "zIndex"))) return false;
       if (!JSIConverter<margelo::nitro::nitromap::Point>::canConvert(runtime, obj.getProperty(runtime, "anchor"))) return false;
       if (!JSIConverter<margelo::nitro::nitromap::MarkerConfig>::canConvert(runtime, obj.getProperty(runtime, "config"))) return false;
+      if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, "accessibilityLabel"))) return false;
       if (!JSIConverter<bool>::canConvert(runtime, obj.getProperty(runtime, "clusteringEnabled"))) return false;
       if (!JSIConverter<margelo::nitro::nitromap::MarkerAnimation>::canConvert(runtime, obj.getProperty(runtime, "animation"))) return false;
+      if (!JSIConverter<double>::canConvert(runtime, obj.getProperty(runtime, "animationDuration"))) return false;
+      if (!JSIConverter<bool>::canConvert(runtime, obj.getProperty(runtime, "animateOnReappear"))) return false;
       return true;
     }
   };

package/nitrogen/generated/shared/c++/PolygonData.hpp

@@ -0,0 +1,114 @@
+///
+/// PolygonData.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/JSIHelpers.hpp>)
+#include <NitroModules/JSIHelpers.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `Coordinate` to properly resolve imports.
+namespace margelo::nitro::nitromap { struct Coordinate; }
+// Forward declaration of `MarkerColor` to properly resolve imports.
+namespace margelo::nitro::nitromap { struct MarkerColor; }
+
+#include <string>
+#include "Coordinate.hpp"
+#include <vector>
+#include "MarkerColor.hpp"
+#include <optional>
+
+namespace margelo::nitro::nitromap {
+
+  /**
+   * A struct which can be represented as a JavaScript object (PolygonData).
+   */
+  struct PolygonData {
+  public:
+    std::string id     SWIFT_PRIVATE;
+    std::vector<Coordinate> coordinates     SWIFT_PRIVATE;
+    std::vector<std::vector<Coordinate>> holes     SWIFT_PRIVATE;
+    MarkerColor fillColor     SWIFT_PRIVATE;
+    MarkerColor strokeColor     SWIFT_PRIVATE;
+    double strokeWidth     SWIFT_PRIVATE;
+    double zIndex     SWIFT_PRIVATE;
+    bool tappable     SWIFT_PRIVATE;
+    std::optional<std::string> accessibilityLabel     SWIFT_PRIVATE;
+
+  public:
+    PolygonData() = default;
+    explicit PolygonData(std::string id, std::vector<Coordinate> coordinates, std::vector<std::vector<Coordinate>> holes, MarkerColor fillColor, MarkerColor strokeColor, double strokeWidth, double zIndex, bool tappable, std::optional<std::string> accessibilityLabel): id(id), coordinates(coordinates), holes(holes), fillColor(fillColor), strokeColor(strokeColor), strokeWidth(strokeWidth), zIndex(zIndex), tappable(tappable), accessibilityLabel(accessibilityLabel) {}
+  };
+
+} // namespace margelo::nitro::nitromap
+
+namespace margelo::nitro {
+
+  // C++ PolygonData <> JS PolygonData (object)
+  template <>
+  struct JSIConverter<margelo::nitro::nitromap::PolygonData> final {
+    static inline margelo::nitro::nitromap::PolygonData fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return margelo::nitro::nitromap::PolygonData(
+        JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, "id")),
+        JSIConverter<std::vector<margelo::nitro::nitromap::Coordinate>>::fromJSI(runtime, obj.getProperty(runtime, "coordinates")),
+        JSIConverter<std::vector<std::vector<margelo::nitro::nitromap::Coordinate>>>::fromJSI(runtime, obj.getProperty(runtime, "holes")),
+        JSIConverter<margelo::nitro::nitromap::MarkerColor>::fromJSI(runtime, obj.getProperty(runtime, "fillColor")),
+        JSIConverter<margelo::nitro::nitromap::MarkerColor>::fromJSI(runtime, obj.getProperty(runtime, "strokeColor")),
+        JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, "strokeWidth")),
+        JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, "zIndex")),
+        JSIConverter<bool>::fromJSI(runtime, obj.getProperty(runtime, "tappable")),
+        JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, "accessibilityLabel"))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::nitromap::PolygonData& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, "id", JSIConverter<std::string>::toJSI(runtime, arg.id));
+      obj.setProperty(runtime, "coordinates", JSIConverter<std::vector<margelo::nitro::nitromap::Coordinate>>::toJSI(runtime, arg.coordinates));
+      obj.setProperty(runtime, "holes", JSIConverter<std::vector<std::vector<margelo::nitro::nitromap::Coordinate>>>::toJSI(runtime, arg.holes));
+      obj.setProperty(runtime, "fillColor", JSIConverter<margelo::nitro::nitromap::MarkerColor>::toJSI(runtime, arg.fillColor));
+      obj.setProperty(runtime, "strokeColor", JSIConverter<margelo::nitro::nitromap::MarkerColor>::toJSI(runtime, arg.strokeColor));
+      obj.setProperty(runtime, "strokeWidth", JSIConverter<double>::toJSI(runtime, arg.strokeWidth));
+      obj.setProperty(runtime, "zIndex", JSIConverter<double>::toJSI(runtime, arg.zIndex));
+      obj.setProperty(runtime, "tappable", JSIConverter<bool>::toJSI(runtime, arg.tappable));
+      obj.setProperty(runtime, "accessibilityLabel", JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.accessibilityLabel));
+      return obj;
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isObject()) {
+        return false;
+      }
+      jsi::Object obj = value.getObject(runtime);
+      if (!nitro::isPlainObject(runtime, obj)) {
+        return false;
+      }
+      if (!JSIConverter<std::string>::canConvert(runtime, obj.getProperty(runtime, "id"))) return false;
+      if (!JSIConverter<std::vector<margelo::nitro::nitromap::Coordinate>>::canConvert(runtime, obj.getProperty(runtime, "coordinates"))) return false;
+      if (!JSIConverter<std::vector<std::vector<margelo::nitro::nitromap::Coordinate>>>::canConvert(runtime, obj.getProperty(runtime, "holes"))) return false;
+      if (!JSIConverter<margelo::nitro::nitromap::MarkerColor>::canConvert(runtime, obj.getProperty(runtime, "fillColor"))) return false;
+      if (!JSIConverter<margelo::nitro::nitromap::MarkerColor>::canConvert(runtime, obj.getProperty(runtime, "strokeColor"))) return false;
+      if (!JSIConverter<double>::canConvert(runtime, obj.getProperty(runtime, "strokeWidth"))) return false;
+      if (!JSIConverter<double>::canConvert(runtime, obj.getProperty(runtime, "zIndex"))) return false;
+      if (!JSIConverter<bool>::canConvert(runtime, obj.getProperty(runtime, "tappable"))) return false;
+      if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, "accessibilityLabel"))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro