@maydon_tech/react-native-nitro-maps 0.1.4 → 0.2.1

package/nitrogen/generated/ios/c++/HybridNitroMapSpecSwift.hpp

@@ -28,14 +28,16 @@ namespace margelo::nitro::nitromap { struct ClusterConfig; }
 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; }
+// 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 `Coordinate` to properly resolve imports.
 namespace margelo::nitro::nitromap { struct Coordinate; }
-// Forward declaration of `Point` to properly resolve imports.
-namespace margelo::nitro::nitromap { struct Point; }
 // Forward declaration of `RegionChangeEvent` to properly resolve imports.
 namespace margelo::nitro::nitromap { struct RegionChangeEvent; }
 // Forward declaration of `MarkerPressEvent` to properly resolve imports.
@@ -46,8 +48,8 @@ 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 `EdgePadding` to properly resolve imports.
-namespace margelo::nitro::nitromap { struct EdgePadding; }
+// Forward declaration of `UserLocationChangeEvent` to properly resolve imports.
+namespace margelo::nitro::nitromap { struct UserLocationChangeEvent; }
 // Forward declaration of `Camera` to properly resolve imports.
 namespace margelo::nitro::nitromap { struct Camera; }
 // Forward declaration of `MapBoundaries` to properly resolve imports.
@@ -64,6 +66,14 @@ namespace margelo::nitro::nitromap { struct ImageMarkerConfig; }
 namespace margelo::nitro::nitromap { struct PriceMarkerStyle; }
 // Forward declaration of `MarkerAnimation` to properly resolve imports.
 namespace margelo::nitro::nitromap { enum class MarkerAnimation; }
+// 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 `CoordinateRing` to properly resolve imports.
+namespace margelo::nitro::nitromap { struct CoordinateRing; }
+// Forward declaration of `CircleData` to properly resolve imports.
+namespace margelo::nitro::nitromap { struct CircleData; }
 
 #include "MapProvider.hpp"
 #include <optional>
@@ -77,17 +87,18 @@ namespace margelo::nitro::nitromap { enum class MarkerAnimation; }
 #include "ClusterStrategy.hpp"
 #include "MarkerColor.hpp"
 #include <variant>
-#include "ClusterAnimationStyle.hpp"
+#include "EdgePadding.hpp"
+#include "UserTrackingMode.hpp"
+#include "Point.hpp"
 #include "MapPressEvent.hpp"
 #include <functional>
 #include "Coordinate.hpp"
-#include "Point.hpp"
 #include "RegionChangeEvent.hpp"
 #include "MarkerPressEvent.hpp"
 #include "MarkerDragEvent.hpp"
 #include "ClusterPressEvent.hpp"
 #include "MapError.hpp"
-#include "EdgePadding.hpp"
+#include "UserLocationChangeEvent.hpp"
 #include "Camera.hpp"
 #include <NitroModules/Promise.hpp>
 #include "MapBoundaries.hpp"
@@ -97,6 +108,10 @@ namespace margelo::nitro::nitromap { enum class MarkerAnimation; }
 #include "ImageMarkerConfig.hpp"
 #include "PriceMarkerStyle.hpp"
 #include "MarkerAnimation.hpp"
+#include "PolylineData.hpp"
+#include "PolygonData.hpp"
+#include "CoordinateRing.hpp"
+#include "CircleData.hpp"
 
 #include "NitroMap-Swift-Cxx-Umbrella.hpp"
 
@@ -152,6 +167,13 @@ namespace margelo::nitro::nitromap {
     inline void setInitialRegion(const std::optional<Region>& initialRegion) noexcept override {
       _swiftPart.setInitialRegion(initialRegion);
     }
+    inline std::optional<Region> getRegion() noexcept override {
+      auto __result = _swiftPart.getRegion();
+      return __result;
+    }
+    inline void setRegion(const std::optional<Region>& region) noexcept override {
+      _swiftPart.setRegion(region);
+    }
     inline std::optional<bool> getShowsUserLocation() noexcept override {
       auto __result = _swiftPart.getShowsUserLocation();
       return __result;
@@ -201,13 +223,6 @@ namespace margelo::nitro::nitromap {
     inline void setCustomMapStyle(const std::optional<std::vector<MapStyleElement>>& customMapStyle) noexcept override {
       _swiftPart.setCustomMapStyle(customMapStyle);
     }
-    inline std::optional<bool> getShowsMyLocationButton() noexcept override {
-      auto __result = _swiftPart.getShowsMyLocationButton();
-      return __result;
-    }
-    inline void setShowsMyLocationButton(std::optional<bool> showsMyLocationButton) noexcept override {
-      _swiftPart.setShowsMyLocationButton(showsMyLocationButton);
-    }
     inline std::optional<ClusterConfig> getClusterConfig() noexcept override {
       auto __result = _swiftPart.getClusterConfig();
       return __result;
@@ -215,6 +230,45 @@ namespace margelo::nitro::nitromap {
     inline void setClusterConfig(const std::optional<ClusterConfig>& clusterConfig) noexcept override {
       _swiftPart.setClusterConfig(clusterConfig);
     }
+    inline EdgePadding getMapPadding() noexcept override {
+      return _swiftPart.getMapPadding();
+    }
+    inline void setMapPadding(const EdgePadding& mapPadding) noexcept override {
+      _swiftPart.setMapPadding(std::forward<decltype(mapPadding)>(mapPadding));
+    }
+    inline std::optional<bool> getShowsTraffic() noexcept override {
+      auto __result = _swiftPart.getShowsTraffic();
+      return __result;
+    }
+    inline void setShowsTraffic(std::optional<bool> showsTraffic) noexcept override {
+      _swiftPart.setShowsTraffic(showsTraffic);
+    }
+    inline std::optional<bool> getShowsBuildings() noexcept override {
+      auto __result = _swiftPart.getShowsBuildings();
+      return __result;
+    }
+    inline void setShowsBuildings(std::optional<bool> showsBuildings) noexcept override {
+      _swiftPart.setShowsBuildings(showsBuildings);
+    }
+    inline std::optional<bool> getShowsCompass() noexcept override {
+      auto __result = _swiftPart.getShowsCompass();
+      return __result;
+    }
+    inline void setShowsCompass(std::optional<bool> showsCompass) noexcept override {
+      _swiftPart.setShowsCompass(showsCompass);
+    }
+    inline double getMinZoom() noexcept override {
+      return _swiftPart.getMinZoom();
+    }
+    inline void setMinZoom(double minZoom) noexcept override {
+      _swiftPart.setMinZoom(std::forward<decltype(minZoom)>(minZoom));
+    }
+    inline double getMaxZoom() noexcept override {
+      return _swiftPart.getMaxZoom();
+    }
+    inline void setMaxZoom(double maxZoom) noexcept override {
+      _swiftPart.setMaxZoom(std::forward<decltype(maxZoom)>(maxZoom));
+    }
     inline std::optional<bool> getDarkMode() noexcept override {
       auto __result = _swiftPart.getDarkMode();
       return __result;
@@ -222,6 +276,33 @@ namespace margelo::nitro::nitromap {
     inline void setDarkMode(std::optional<bool> darkMode) noexcept override {
       _swiftPart.setDarkMode(darkMode);
     }
+    inline std::optional<UserTrackingMode> getUserTrackingMode() noexcept override {
+      auto __result = _swiftPart.getUserTrackingMode();
+      return __result;
+    }
+    inline void setUserTrackingMode(std::optional<UserTrackingMode> userTrackingMode) noexcept override {
+      _swiftPart.setUserTrackingMode(userTrackingMode);
+    }
+    inline std::string getUserLocationImage() noexcept override {
+      auto __result = _swiftPart.getUserLocationImage();
+      return __result;
+    }
+    inline void setUserLocationImage(const std::string& userLocationImage) noexcept override {
+      _swiftPart.setUserLocationImage(userLocationImage);
+    }
+    inline double getUserLocationSize() noexcept override {
+      return _swiftPart.getUserLocationSize();
+    }
+    inline void setUserLocationSize(double userLocationSize) noexcept override {
+      _swiftPart.setUserLocationSize(std::forward<decltype(userLocationSize)>(userLocationSize));
+    }
+    inline std::optional<Point> getUserLocationAnchor() noexcept override {
+      auto __result = _swiftPart.getUserLocationAnchor();
+      return __result;
+    }
+    inline void setUserLocationAnchor(const std::optional<Point>& userLocationAnchor) noexcept override {
+      _swiftPart.setUserLocationAnchor(userLocationAnchor);
+    }
     inline std::optional<std::function<void(const MapPressEvent& /* event */)>> getOnPress() noexcept override {
       auto __result = _swiftPart.getOnPress();
       return __result;
@@ -292,6 +373,27 @@ namespace margelo::nitro::nitromap {
     inline void setOnClusterPress(const std::optional<std::function<void(const ClusterPressEvent& /* event */)>>& onClusterPress) noexcept override {
       _swiftPart.setOnClusterPress(onClusterPress);
     }
+    inline std::optional<std::function<void(const std::string& /* id */)>> getOnPolylinePress() noexcept override {
+      auto __result = _swiftPart.getOnPolylinePress();
+      return __result;
+    }
+    inline void setOnPolylinePress(const std::optional<std::function<void(const std::string& /* id */)>>& onPolylinePress) noexcept override {
+      _swiftPart.setOnPolylinePress(onPolylinePress);
+    }
+    inline std::optional<std::function<void(const std::string& /* id */)>> getOnPolygonPress() noexcept override {
+      auto __result = _swiftPart.getOnPolygonPress();
+      return __result;
+    }
+    inline void setOnPolygonPress(const std::optional<std::function<void(const std::string& /* id */)>>& onPolygonPress) noexcept override {
+      _swiftPart.setOnPolygonPress(onPolygonPress);
+    }
+    inline std::optional<std::function<void(const std::string& /* id */)>> getOnCirclePress() noexcept override {
+      auto __result = _swiftPart.getOnCirclePress();
+      return __result;
+    }
+    inline void setOnCirclePress(const std::optional<std::function<void(const std::string& /* id */)>>& onCirclePress) noexcept override {
+      _swiftPart.setOnCirclePress(onCirclePress);
+    }
     inline std::optional<std::function<void(const MapError& /* error */)>> getOnError() noexcept override {
       auto __result = _swiftPart.getOnError();
       return __result;
@@ -299,6 +401,34 @@ namespace margelo::nitro::nitromap {
     inline void setOnError(const std::optional<std::function<void(const MapError& /* error */)>>& onError) noexcept override {
       _swiftPart.setOnError(onError);
     }
+    inline std::optional<std::function<void(const UserLocationChangeEvent& /* event */)>> getOnUserLocationChange() noexcept override {
+      auto __result = _swiftPart.getOnUserLocationChange();
+      return __result;
+    }
+    inline void setOnUserLocationChange(const std::optional<std::function<void(const UserLocationChangeEvent& /* event */)>>& onUserLocationChange) noexcept override {
+      _swiftPart.setOnUserLocationChange(onUserLocationChange);
+    }
+    inline std::optional<std::function<void(UserTrackingMode /* mode */)>> getOnUserTrackingModeChange() noexcept override {
+      auto __result = _swiftPart.getOnUserTrackingModeChange();
+      return __result;
+    }
+    inline void setOnUserTrackingModeChange(const std::optional<std::function<void(UserTrackingMode /* mode */)>>& onUserTrackingModeChange) noexcept override {
+      _swiftPart.setOnUserTrackingModeChange(onUserTrackingModeChange);
+    }
+    inline std::optional<std::function<void(const MapError& /* error */)>> getOnUserLocationError() noexcept override {
+      auto __result = _swiftPart.getOnUserLocationError();
+      return __result;
+    }
+    inline void setOnUserLocationError(const std::optional<std::function<void(const MapError& /* error */)>>& onUserLocationError) noexcept override {
+      _swiftPart.setOnUserLocationError(onUserLocationError);
+    }
+    inline std::optional<std::function<void()>> getOnMapIdle() noexcept override {
+      auto __result = _swiftPart.getOnMapIdle();
+      return __result;
+    }
+    inline void setOnMapIdle(const std::optional<std::function<void()>>& onMapIdle) noexcept override {
+      _swiftPart.setOnMapIdle(onMapIdle);
+    }
 
   public:
     // Methods
@@ -314,6 +444,12 @@ namespace margelo::nitro::nitromap {
         std::rethrow_exception(__result.error());
       }
     }
+    inline void fitToSuppliedMarkers(const std::vector<std::string>& markerIds, const std::optional<EdgePadding>& edgePadding, std::optional<bool> animated) override {
+      auto __result = _swiftPart.fitToSuppliedMarkers(markerIds, edgePadding, animated);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
     inline void animateCamera(const Camera& camera, std::optional<double> duration) override {
       auto __result = _swiftPart.animateCamera(std::forward<decltype(camera)>(camera), duration);
       if (__result.hasError()) [[unlikely]] {
@@ -348,6 +484,28 @@ namespace margelo::nitro::nitromap {
       auto __value = std::move(__result.value());
       return __value;
     }
+    inline void centerOnUserLocation() override {
+      auto __result = _swiftPart.centerOnUserLocation();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline Point pointForCoordinate(const Coordinate& coordinate) override {
+      auto __result = _swiftPart.pointForCoordinate(std::forward<decltype(coordinate)>(coordinate));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline Coordinate coordinateForPoint(const Point& point) override {
+      auto __result = _swiftPart.coordinateForPoint(std::forward<decltype(point)>(point));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
     inline void setIsDarkMode(bool enabled) override {
       auto __result = _swiftPart.setIsDarkMode(std::forward<decltype(enabled)>(enabled));
       if (__result.hasError()) [[unlikely]] {
@@ -384,6 +542,12 @@ namespace margelo::nitro::nitromap {
         std::rethrow_exception(__result.error());
       }
     }
+    inline void deselectMarker() override {
+      auto __result = _swiftPart.deselectMarker();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
     inline void clearMarkers() override {
       auto __result = _swiftPart.clearMarkers();
       if (__result.hasError()) [[unlikely]] {
@@ -402,6 +566,78 @@ namespace margelo::nitro::nitromap {
         std::rethrow_exception(__result.error());
       }
     }
+    inline void addPolyline(const PolylineData& polyline) override {
+      auto __result = _swiftPart.addPolyline(std::forward<decltype(polyline)>(polyline));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void updatePolyline(const PolylineData& polyline) override {
+      auto __result = _swiftPart.updatePolyline(std::forward<decltype(polyline)>(polyline));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void removePolyline(const std::string& id) override {
+      auto __result = _swiftPart.removePolyline(id);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void clearPolylines() override {
+      auto __result = _swiftPart.clearPolylines();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void addPolygon(const PolygonData& polygon) override {
+      auto __result = _swiftPart.addPolygon(std::forward<decltype(polygon)>(polygon));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void updatePolygon(const PolygonData& polygon) override {
+      auto __result = _swiftPart.updatePolygon(std::forward<decltype(polygon)>(polygon));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void removePolygon(const std::string& id) override {
+      auto __result = _swiftPart.removePolygon(id);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void clearPolygons() override {
+      auto __result = _swiftPart.clearPolygons();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void addCircle(const CircleData& circle) override {
+      auto __result = _swiftPart.addCircle(std::forward<decltype(circle)>(circle));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void updateCircle(const CircleData& circle) override {
+      auto __result = _swiftPart.updateCircle(std::forward<decltype(circle)>(circle));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void removeCircle(const std::string& id) override {
+      auto __result = _swiftPart.removeCircle(id);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void clearCircles() override {
+      auto __result = _swiftPart.clearCircles();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
 
   private:
     NitroMap::HybridNitroMapSpec_cxx _swiftPart;

package/nitrogen/generated/ios/c++/views/HybridNitroMapComponent.mm

@@ -81,6 +81,11 @@ using namespace margelo::nitro::nitromap::views;
     swiftPart.setInitialRegion(newViewProps.initialRegion.value);
     newViewProps.initialRegion.isDirty = false;
   }
+  // region: optional
+  if (newViewProps.region.isDirty) {
+    swiftPart.setRegion(newViewProps.region.value);
+    newViewProps.region.isDirty = false;
+  }
   // showsUserLocation: optional
   if (newViewProps.showsUserLocation.isDirty) {
     swiftPart.setShowsUserLocation(newViewProps.showsUserLocation.value);
@@ -116,21 +121,66 @@ using namespace margelo::nitro::nitromap::views;
     swiftPart.setCustomMapStyle(newViewProps.customMapStyle.value);
     newViewProps.customMapStyle.isDirty = false;
   }
-  // showsMyLocationButton: optional
-  if (newViewProps.showsMyLocationButton.isDirty) {
-    swiftPart.setShowsMyLocationButton(newViewProps.showsMyLocationButton.value);
-    newViewProps.showsMyLocationButton.isDirty = false;
-  }
   // clusterConfig: optional
   if (newViewProps.clusterConfig.isDirty) {
     swiftPart.setClusterConfig(newViewProps.clusterConfig.value);
     newViewProps.clusterConfig.isDirty = false;
   }
+  // mapPadding: struct
+  if (newViewProps.mapPadding.isDirty) {
+    swiftPart.setMapPadding(newViewProps.mapPadding.value);
+    newViewProps.mapPadding.isDirty = false;
+  }
+  // showsTraffic: optional
+  if (newViewProps.showsTraffic.isDirty) {
+    swiftPart.setShowsTraffic(newViewProps.showsTraffic.value);
+    newViewProps.showsTraffic.isDirty = false;
+  }
+  // showsBuildings: optional
+  if (newViewProps.showsBuildings.isDirty) {
+    swiftPart.setShowsBuildings(newViewProps.showsBuildings.value);
+    newViewProps.showsBuildings.isDirty = false;
+  }
+  // showsCompass: optional
+  if (newViewProps.showsCompass.isDirty) {
+    swiftPart.setShowsCompass(newViewProps.showsCompass.value);
+    newViewProps.showsCompass.isDirty = false;
+  }
+  // minZoom: number
+  if (newViewProps.minZoom.isDirty) {
+    swiftPart.setMinZoom(newViewProps.minZoom.value);
+    newViewProps.minZoom.isDirty = false;
+  }
+  // maxZoom: number
+  if (newViewProps.maxZoom.isDirty) {
+    swiftPart.setMaxZoom(newViewProps.maxZoom.value);
+    newViewProps.maxZoom.isDirty = false;
+  }
   // darkMode: optional
   if (newViewProps.darkMode.isDirty) {
     swiftPart.setDarkMode(newViewProps.darkMode.value);
     newViewProps.darkMode.isDirty = false;
   }
+  // userTrackingMode: optional
+  if (newViewProps.userTrackingMode.isDirty) {
+    swiftPart.setUserTrackingMode(newViewProps.userTrackingMode.value);
+    newViewProps.userTrackingMode.isDirty = false;
+  }
+  // userLocationImage: string
+  if (newViewProps.userLocationImage.isDirty) {
+    swiftPart.setUserLocationImage(newViewProps.userLocationImage.value);
+    newViewProps.userLocationImage.isDirty = false;
+  }
+  // userLocationSize: number
+  if (newViewProps.userLocationSize.isDirty) {
+    swiftPart.setUserLocationSize(newViewProps.userLocationSize.value);
+    newViewProps.userLocationSize.isDirty = false;
+  }
+  // userLocationAnchor: optional
+  if (newViewProps.userLocationAnchor.isDirty) {
+    swiftPart.setUserLocationAnchor(newViewProps.userLocationAnchor.value);
+    newViewProps.userLocationAnchor.isDirty = false;
+  }
   // onPress: optional
   if (newViewProps.onPress.isDirty) {
     swiftPart.setOnPress(newViewProps.onPress.value);
@@ -181,11 +231,46 @@ using namespace margelo::nitro::nitromap::views;
     swiftPart.setOnClusterPress(newViewProps.onClusterPress.value);
     newViewProps.onClusterPress.isDirty = false;
   }
+  // onPolylinePress: optional
+  if (newViewProps.onPolylinePress.isDirty) {
+    swiftPart.setOnPolylinePress(newViewProps.onPolylinePress.value);
+    newViewProps.onPolylinePress.isDirty = false;
+  }
+  // onPolygonPress: optional
+  if (newViewProps.onPolygonPress.isDirty) {
+    swiftPart.setOnPolygonPress(newViewProps.onPolygonPress.value);
+    newViewProps.onPolygonPress.isDirty = false;
+  }
+  // onCirclePress: optional
+  if (newViewProps.onCirclePress.isDirty) {
+    swiftPart.setOnCirclePress(newViewProps.onCirclePress.value);
+    newViewProps.onCirclePress.isDirty = false;
+  }
   // onError: optional
   if (newViewProps.onError.isDirty) {
     swiftPart.setOnError(newViewProps.onError.value);
     newViewProps.onError.isDirty = false;
   }
+  // onUserLocationChange: optional
+  if (newViewProps.onUserLocationChange.isDirty) {
+    swiftPart.setOnUserLocationChange(newViewProps.onUserLocationChange.value);
+    newViewProps.onUserLocationChange.isDirty = false;
+  }
+  // onUserTrackingModeChange: optional
+  if (newViewProps.onUserTrackingModeChange.isDirty) {
+    swiftPart.setOnUserTrackingModeChange(newViewProps.onUserTrackingModeChange.value);
+    newViewProps.onUserTrackingModeChange.isDirty = false;
+  }
+  // onUserLocationError: optional
+  if (newViewProps.onUserLocationError.isDirty) {
+    swiftPart.setOnUserLocationError(newViewProps.onUserLocationError.value);
+    newViewProps.onUserLocationError.isDirty = false;
+  }
+  // onMapIdle: optional
+  if (newViewProps.onMapIdle.isDirty) {
+    swiftPart.setOnMapIdle(newViewProps.onMapIdle.value);
+    newViewProps.onMapIdle.isDirty = false;
+  }
 
   swiftPart.afterUpdate();
 

package/nitrogen/generated/ios/swift/CircleData.swift

@@ -0,0 +1,143 @@
+///
+/// CircleData.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+import Foundation
+import NitroModules
+
+/**
+ * Represents an instance of `CircleData`, backed by a C++ struct.
+ */
+public typealias CircleData = margelo.nitro.nitromap.CircleData
+
+public extension CircleData {
+  private typealias bridge = margelo.nitro.nitromap.bridge.swift
+
+  /**
+   * Create a new instance of `CircleData`.
+   */
+  init(id: String, center: Coordinate, radius: Double, fillColor: MarkerColor, strokeColor: MarkerColor, strokeWidth: Double, zIndex: Double, tappable: Bool, accessibilityLabel: String?) {
+    self.init(std.string(id), center, radius, fillColor, strokeColor, strokeWidth, zIndex, tappable, { () -> bridge.std__optional_std__string_ in
+      if let __unwrappedValue = accessibilityLabel {
+        return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
+      } else {
+        return .init()
+      }
+    }())
+  }
+
+  var id: String {
+    @inline(__always)
+    get {
+      return String(self.__id)
+    }
+    @inline(__always)
+    set {
+      self.__id = std.string(newValue)
+    }
+  }
+  
+  var center: Coordinate {
+    @inline(__always)
+    get {
+      return self.__center
+    }
+    @inline(__always)
+    set {
+      self.__center = newValue
+    }
+  }
+  
+  var radius: Double {
+    @inline(__always)
+    get {
+      return self.__radius
+    }
+    @inline(__always)
+    set {
+      self.__radius = newValue
+    }
+  }
+  
+  var fillColor: MarkerColor {
+    @inline(__always)
+    get {
+      return self.__fillColor
+    }
+    @inline(__always)
+    set {
+      self.__fillColor = newValue
+    }
+  }
+  
+  var strokeColor: MarkerColor {
+    @inline(__always)
+    get {
+      return self.__strokeColor
+    }
+    @inline(__always)
+    set {
+      self.__strokeColor = newValue
+    }
+  }
+  
+  var strokeWidth: Double {
+    @inline(__always)
+    get {
+      return self.__strokeWidth
+    }
+    @inline(__always)
+    set {
+      self.__strokeWidth = newValue
+    }
+  }
+  
+  var zIndex: Double {
+    @inline(__always)
+    get {
+      return self.__zIndex
+    }
+    @inline(__always)
+    set {
+      self.__zIndex = newValue
+    }
+  }
+  
+  var tappable: Bool {
+    @inline(__always)
+    get {
+      return self.__tappable
+    }
+    @inline(__always)
+    set {
+      self.__tappable = newValue
+    }
+  }
+  
+  var accessibilityLabel: String? {
+    @inline(__always)
+    get {
+      return { () -> String? in
+        if bridge.has_value_std__optional_std__string_(self.__accessibilityLabel) {
+          let __unwrapped = bridge.get_std__optional_std__string_(self.__accessibilityLabel)
+          return String(__unwrapped)
+        } else {
+          return nil
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__accessibilityLabel = { () -> bridge.std__optional_std__string_ in
+        if let __unwrappedValue = newValue {
+          return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
+        } else {
+          return .init()
+        }
+      }()
+    }
+  }
+}