@maydon_tech/react-native-nitro-maps 0.1.0

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

@@ -0,0 +1,410 @@
+///
+/// HybridNitroMapSpecSwift.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include "HybridNitroMapSpec.hpp"
+
+// Forward declaration of `HybridNitroMapSpec_cxx` to properly resolve imports.
+namespace NitroMap { class HybridNitroMapSpec_cxx; }
+
+// Forward declaration of `MapProvider` to properly resolve imports.
+namespace margelo::nitro::nitromap { enum class MapProvider; }
+// Forward declaration of `Region` to properly resolve imports.
+namespace margelo::nitro::nitromap { struct Region; }
+// Forward declaration of `MapType` to properly resolve imports.
+namespace margelo::nitro::nitromap { enum class MapType; }
+// Forward declaration of `MapStyleElement` to properly resolve imports.
+namespace margelo::nitro::nitromap { struct MapStyleElement; }
+// Forward declaration of `MapStyler` to properly resolve imports.
+namespace margelo::nitro::nitromap { struct MapStyler; }
+// Forward declaration of `ClusterConfig` to properly resolve imports.
+namespace margelo::nitro::nitromap { struct ClusterConfig; }
+// Forward declaration of `ClusterStrategy` to properly resolve imports.
+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 `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.
+namespace margelo::nitro::nitromap { struct MarkerPressEvent; }
+// Forward declaration of `MarkerDragEvent` to properly resolve imports.
+namespace margelo::nitro::nitromap { struct MarkerDragEvent; }
+// Forward declaration of `ClusterPressEvent` to properly resolve imports.
+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 `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 `MarkerConfig` to properly resolve imports.
+namespace margelo::nitro::nitromap { struct MarkerConfig; }
+// Forward declaration of `MarkerStyle` to properly resolve imports.
+namespace margelo::nitro::nitromap { enum class MarkerStyle; }
+// Forward declaration of `ImageMarkerConfig` to properly resolve imports.
+namespace margelo::nitro::nitromap { struct ImageMarkerConfig; }
+// Forward declaration of `PriceMarkerStyle` to properly resolve imports.
+namespace margelo::nitro::nitromap { struct PriceMarkerStyle; }
+// Forward declaration of `MarkerAnimation` to properly resolve imports.
+namespace margelo::nitro::nitromap { enum class MarkerAnimation; }
+
+#include "MapProvider.hpp"
+#include <optional>
+#include "Region.hpp"
+#include "MapType.hpp"
+#include "MapStyleElement.hpp"
+#include <vector>
+#include <string>
+#include "MapStyler.hpp"
+#include "ClusterConfig.hpp"
+#include "ClusterStrategy.hpp"
+#include "MarkerColor.hpp"
+#include <variant>
+#include "ClusterAnimationStyle.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 "Camera.hpp"
+#include <NitroModules/Promise.hpp>
+#include "MapBoundaries.hpp"
+#include "MarkerData.hpp"
+#include "MarkerConfig.hpp"
+#include "MarkerStyle.hpp"
+#include "ImageMarkerConfig.hpp"
+#include "PriceMarkerStyle.hpp"
+#include "MarkerAnimation.hpp"
+
+#include "NitroMap-Swift-Cxx-Umbrella.hpp"
+
+namespace margelo::nitro::nitromap {
+
+  /**
+   * The C++ part of HybridNitroMapSpec_cxx.swift.
+   *
+   * HybridNitroMapSpecSwift (C++) accesses HybridNitroMapSpec_cxx (Swift), and might
+   * contain some additional bridging code for C++ <> Swift interop.
+   *
+   * Since this obviously introduces an overhead, I hope at some point in
+   * the future, HybridNitroMapSpec_cxx can directly inherit from the C++ class HybridNitroMapSpec
+   * to simplify the whole structure and memory management.
+   */
+  class HybridNitroMapSpecSwift: public virtual HybridNitroMapSpec {
+  public:
+    // Constructor from a Swift instance
+    explicit HybridNitroMapSpecSwift(const NitroMap::HybridNitroMapSpec_cxx& swiftPart):
+      HybridObject(HybridNitroMapSpec::TAG),
+      _swiftPart(swiftPart) { }
+
+  public:
+    // Get the Swift part
+    inline NitroMap::HybridNitroMapSpec_cxx& getSwiftPart() noexcept {
+      return _swiftPart;
+    }
+
+  public:
+    inline size_t getExternalMemorySize() noexcept override {
+      return _swiftPart.getMemorySize();
+    }
+    void dispose() noexcept override {
+      _swiftPart.dispose();
+    }
+    std::string toString() override {
+      return _swiftPart.toString();
+    }
+
+  public:
+    // Properties
+    inline std::optional<MapProvider> getProvider() noexcept override {
+      auto __result = _swiftPart.getProvider();
+      return __result;
+    }
+    inline void setProvider(std::optional<MapProvider> provider) noexcept override {
+      _swiftPart.setProvider(provider);
+    }
+    inline std::optional<Region> getInitialRegion() noexcept override {
+      auto __result = _swiftPart.getInitialRegion();
+      return __result;
+    }
+    inline void setInitialRegion(const std::optional<Region>& initialRegion) noexcept override {
+      _swiftPart.setInitialRegion(initialRegion);
+    }
+    inline std::optional<bool> getShowsUserLocation() noexcept override {
+      auto __result = _swiftPart.getShowsUserLocation();
+      return __result;
+    }
+    inline void setShowsUserLocation(std::optional<bool> showsUserLocation) noexcept override {
+      _swiftPart.setShowsUserLocation(showsUserLocation);
+    }
+    inline std::optional<bool> getZoomEnabled() noexcept override {
+      auto __result = _swiftPart.getZoomEnabled();
+      return __result;
+    }
+    inline void setZoomEnabled(std::optional<bool> zoomEnabled) noexcept override {
+      _swiftPart.setZoomEnabled(zoomEnabled);
+    }
+    inline std::optional<bool> getScrollEnabled() noexcept override {
+      auto __result = _swiftPart.getScrollEnabled();
+      return __result;
+    }
+    inline void setScrollEnabled(std::optional<bool> scrollEnabled) noexcept override {
+      _swiftPart.setScrollEnabled(scrollEnabled);
+    }
+    inline std::optional<bool> getRotateEnabled() noexcept override {
+      auto __result = _swiftPart.getRotateEnabled();
+      return __result;
+    }
+    inline void setRotateEnabled(std::optional<bool> rotateEnabled) noexcept override {
+      _swiftPart.setRotateEnabled(rotateEnabled);
+    }
+    inline std::optional<bool> getPitchEnabled() noexcept override {
+      auto __result = _swiftPart.getPitchEnabled();
+      return __result;
+    }
+    inline void setPitchEnabled(std::optional<bool> pitchEnabled) noexcept override {
+      _swiftPart.setPitchEnabled(pitchEnabled);
+    }
+    inline std::optional<MapType> getMapType() noexcept override {
+      auto __result = _swiftPart.getMapType();
+      return __result;
+    }
+    inline void setMapType(std::optional<MapType> mapType) noexcept override {
+      _swiftPart.setMapType(mapType);
+    }
+    inline std::optional<std::vector<MapStyleElement>> getCustomMapStyle() noexcept override {
+      auto __result = _swiftPart.getCustomMapStyle();
+      return __result;
+    }
+    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;
+    }
+    inline void setClusterConfig(const std::optional<ClusterConfig>& clusterConfig) noexcept override {
+      _swiftPart.setClusterConfig(clusterConfig);
+    }
+    inline std::optional<bool> getDarkMode() noexcept override {
+      auto __result = _swiftPart.getDarkMode();
+      return __result;
+    }
+    inline void setDarkMode(std::optional<bool> darkMode) noexcept override {
+      _swiftPart.setDarkMode(darkMode);
+    }
+    inline std::optional<std::function<void(const MapPressEvent& /* event */)>> getOnPress() noexcept override {
+      auto __result = _swiftPart.getOnPress();
+      return __result;
+    }
+    inline void setOnPress(const std::optional<std::function<void(const MapPressEvent& /* event */)>>& onPress) noexcept override {
+      _swiftPart.setOnPress(onPress);
+    }
+    inline std::optional<std::function<void(const MapPressEvent& /* event */)>> getOnLongPress() noexcept override {
+      auto __result = _swiftPart.getOnLongPress();
+      return __result;
+    }
+    inline void setOnLongPress(const std::optional<std::function<void(const MapPressEvent& /* event */)>>& onLongPress) noexcept override {
+      _swiftPart.setOnLongPress(onLongPress);
+    }
+    inline std::optional<std::function<void()>> getOnMapReady() noexcept override {
+      auto __result = _swiftPart.getOnMapReady();
+      return __result;
+    }
+    inline void setOnMapReady(const std::optional<std::function<void()>>& onMapReady) noexcept override {
+      _swiftPart.setOnMapReady(onMapReady);
+    }
+    inline std::optional<std::function<void(const RegionChangeEvent& /* region */)>> getOnRegionChange() noexcept override {
+      auto __result = _swiftPart.getOnRegionChange();
+      return __result;
+    }
+    inline void setOnRegionChange(const std::optional<std::function<void(const RegionChangeEvent& /* region */)>>& onRegionChange) noexcept override {
+      _swiftPart.setOnRegionChange(onRegionChange);
+    }
+    inline std::optional<std::function<void(const RegionChangeEvent& /* region */)>> getOnRegionChangeComplete() noexcept override {
+      auto __result = _swiftPart.getOnRegionChangeComplete();
+      return __result;
+    }
+    inline void setOnRegionChangeComplete(const std::optional<std::function<void(const RegionChangeEvent& /* region */)>>& onRegionChangeComplete) noexcept override {
+      _swiftPart.setOnRegionChangeComplete(onRegionChangeComplete);
+    }
+    inline std::optional<std::function<void(const MarkerPressEvent& /* event */)>> getOnMarkerPress() noexcept override {
+      auto __result = _swiftPart.getOnMarkerPress();
+      return __result;
+    }
+    inline void setOnMarkerPress(const std::optional<std::function<void(const MarkerPressEvent& /* event */)>>& onMarkerPress) noexcept override {
+      _swiftPart.setOnMarkerPress(onMarkerPress);
+    }
+    inline std::optional<std::function<void(const MarkerDragEvent& /* event */)>> getOnMarkerDragStart() noexcept override {
+      auto __result = _swiftPart.getOnMarkerDragStart();
+      return __result;
+    }
+    inline void setOnMarkerDragStart(const std::optional<std::function<void(const MarkerDragEvent& /* event */)>>& onMarkerDragStart) noexcept override {
+      _swiftPart.setOnMarkerDragStart(onMarkerDragStart);
+    }
+    inline std::optional<std::function<void(const MarkerDragEvent& /* event */)>> getOnMarkerDrag() noexcept override {
+      auto __result = _swiftPart.getOnMarkerDrag();
+      return __result;
+    }
+    inline void setOnMarkerDrag(const std::optional<std::function<void(const MarkerDragEvent& /* event */)>>& onMarkerDrag) noexcept override {
+      _swiftPart.setOnMarkerDrag(onMarkerDrag);
+    }
+    inline std::optional<std::function<void(const MarkerDragEvent& /* event */)>> getOnMarkerDragEnd() noexcept override {
+      auto __result = _swiftPart.getOnMarkerDragEnd();
+      return __result;
+    }
+    inline void setOnMarkerDragEnd(const std::optional<std::function<void(const MarkerDragEvent& /* event */)>>& onMarkerDragEnd) noexcept override {
+      _swiftPart.setOnMarkerDragEnd(onMarkerDragEnd);
+    }
+    inline std::optional<std::function<void(const ClusterPressEvent& /* event */)>> getOnClusterPress() noexcept override {
+      auto __result = _swiftPart.getOnClusterPress();
+      return __result;
+    }
+    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 MapError& /* error */)>> getOnError() noexcept override {
+      auto __result = _swiftPart.getOnError();
+      return __result;
+    }
+    inline void setOnError(const std::optional<std::function<void(const MapError& /* error */)>>& onError) noexcept override {
+      _swiftPart.setOnError(onError);
+    }
+
+  public:
+    // Methods
+    inline void animateToRegion(const Region& region, std::optional<double> duration) override {
+      auto __result = _swiftPart.animateToRegion(std::forward<decltype(region)>(region), duration);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void fitToCoordinates(const std::vector<Coordinate>& coordinates, const std::optional<EdgePadding>& edgePadding, std::optional<bool> animated) override {
+      auto __result = _swiftPart.fitToCoordinates(coordinates, 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]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline std::shared_ptr<Promise<Camera>> getCamera() override {
+      auto __result = _swiftPart.getCamera();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline void setCamera(const Camera& camera) override {
+      auto __result = _swiftPart.setCamera(std::forward<decltype(camera)>(camera));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void setMapStyle(const std::optional<std::vector<MapStyleElement>>& style) override {
+      auto __result = _swiftPart.setMapStyle(style);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline std::shared_ptr<Promise<MapBoundaries>> getMapBoundaries() override {
+      auto __result = _swiftPart.getMapBoundaries();
+      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]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void addMarker(const MarkerData& marker) override {
+      auto __result = _swiftPart.addMarker(std::forward<decltype(marker)>(marker));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void addMarkers(const std::vector<MarkerData>& markers) override {
+      auto __result = _swiftPart.addMarkers(markers);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void updateMarker(const MarkerData& marker) override {
+      auto __result = _swiftPart.updateMarker(std::forward<decltype(marker)>(marker));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void removeMarker(const std::string& id) override {
+      auto __result = _swiftPart.removeMarker(id);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void selectMarker(const std::string& id) override {
+      auto __result = _swiftPart.selectMarker(id);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void clearMarkers() override {
+      auto __result = _swiftPart.clearMarkers();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void setClusteringEnabled(bool enabled) override {
+      auto __result = _swiftPart.setClusteringEnabled(std::forward<decltype(enabled)>(enabled));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void refreshClusters() override {
+      auto __result = _swiftPart.refreshClusters();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+
+  private:
+    NitroMap::HybridNitroMapSpec_cxx _swiftPart;
+  };
+
+} // namespace margelo::nitro::nitromap

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

@@ -0,0 +1,206 @@
+///
+/// HybridNitroMapComponent.mm
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#import "HybridNitroMapComponent.hpp"
+#import <memory>
+#import <react/renderer/componentregistry/ComponentDescriptorProvider.h>
+#import <React/RCTViewComponentView.h>
+#import <React/RCTComponentViewFactory.h>
+#import <React/UIView+ComponentViewProtocol.h>
+#import <NitroModules/NitroDefines.hpp>
+#import <UIKit/UIKit.h>
+
+#import "HybridNitroMapSpecSwift.hpp"
+#import "NitroMap-Swift-Cxx-Umbrella.hpp"
+
+using namespace facebook;
+using namespace margelo::nitro::nitromap;
+using namespace margelo::nitro::nitromap::views;
+
+/**
+ * Represents the React Native View holder for the Nitro "NitroMap" HybridView.
+ */
+@interface HybridNitroMapComponent: RCTViewComponentView
+@end
+
+@implementation HybridNitroMapComponent {
+  std::shared_ptr<HybridNitroMapSpecSwift> _hybridView;
+}
+
++ (void) load {
+  [super load];
+  [RCTComponentViewFactory.currentComponentViewFactory registerComponentViewClass:[HybridNitroMapComponent class]];
+}
+
++ (react::ComponentDescriptorProvider) componentDescriptorProvider {
+  return react::concreteComponentDescriptorProvider<HybridNitroMapComponentDescriptor>();
+}
+
+- (instancetype) init {
+  if (self = [super init]) {
+    std::shared_ptr<HybridNitroMapSpec> hybridView = NitroMap::NitroMapAutolinking::createNitroMap();
+    _hybridView = std::dynamic_pointer_cast<HybridNitroMapSpecSwift>(hybridView);
+    [self updateView];
+  }
+  return self;
+}
+
+- (void) updateView {
+  // 1. Get Swift part
+  NitroMap::HybridNitroMapSpec_cxx& swiftPart = _hybridView->getSwiftPart();
+
+  // 2. Get UIView*
+  void* viewUnsafe = swiftPart.getView();
+  UIView* view = (__bridge_transfer UIView*) viewUnsafe;
+
+  // 3. Update RCTViewComponentView's [contentView]
+  [self setContentView:view];
+}
+
+- (void) updateProps:(const std::shared_ptr<const react::Props>&)props
+            oldProps:(const std::shared_ptr<const react::Props>&)oldProps {
+  // 1. Downcast props
+  const auto& newViewPropsConst = *std::static_pointer_cast<HybridNitroMapProps const>(props);
+  auto& newViewProps = const_cast<HybridNitroMapProps&>(newViewPropsConst);
+  NitroMap::HybridNitroMapSpec_cxx& swiftPart = _hybridView->getSwiftPart();
+
+  // 2. Update each prop individually
+  swiftPart.beforeUpdate();
+
+  // provider: optional
+  if (newViewProps.provider.isDirty) {
+    swiftPart.setProvider(newViewProps.provider.value);
+    newViewProps.provider.isDirty = false;
+  }
+  // initialRegion: optional
+  if (newViewProps.initialRegion.isDirty) {
+    swiftPart.setInitialRegion(newViewProps.initialRegion.value);
+    newViewProps.initialRegion.isDirty = false;
+  }
+  // showsUserLocation: optional
+  if (newViewProps.showsUserLocation.isDirty) {
+    swiftPart.setShowsUserLocation(newViewProps.showsUserLocation.value);
+    newViewProps.showsUserLocation.isDirty = false;
+  }
+  // zoomEnabled: optional
+  if (newViewProps.zoomEnabled.isDirty) {
+    swiftPart.setZoomEnabled(newViewProps.zoomEnabled.value);
+    newViewProps.zoomEnabled.isDirty = false;
+  }
+  // scrollEnabled: optional
+  if (newViewProps.scrollEnabled.isDirty) {
+    swiftPart.setScrollEnabled(newViewProps.scrollEnabled.value);
+    newViewProps.scrollEnabled.isDirty = false;
+  }
+  // rotateEnabled: optional
+  if (newViewProps.rotateEnabled.isDirty) {
+    swiftPart.setRotateEnabled(newViewProps.rotateEnabled.value);
+    newViewProps.rotateEnabled.isDirty = false;
+  }
+  // pitchEnabled: optional
+  if (newViewProps.pitchEnabled.isDirty) {
+    swiftPart.setPitchEnabled(newViewProps.pitchEnabled.value);
+    newViewProps.pitchEnabled.isDirty = false;
+  }
+  // mapType: optional
+  if (newViewProps.mapType.isDirty) {
+    swiftPart.setMapType(newViewProps.mapType.value);
+    newViewProps.mapType.isDirty = false;
+  }
+  // customMapStyle: optional
+  if (newViewProps.customMapStyle.isDirty) {
+    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;
+  }
+  // darkMode: optional
+  if (newViewProps.darkMode.isDirty) {
+    swiftPart.setDarkMode(newViewProps.darkMode.value);
+    newViewProps.darkMode.isDirty = false;
+  }
+  // onPress: optional
+  if (newViewProps.onPress.isDirty) {
+    swiftPart.setOnPress(newViewProps.onPress.value);
+    newViewProps.onPress.isDirty = false;
+  }
+  // onLongPress: optional
+  if (newViewProps.onLongPress.isDirty) {
+    swiftPart.setOnLongPress(newViewProps.onLongPress.value);
+    newViewProps.onLongPress.isDirty = false;
+  }
+  // onMapReady: optional
+  if (newViewProps.onMapReady.isDirty) {
+    swiftPart.setOnMapReady(newViewProps.onMapReady.value);
+    newViewProps.onMapReady.isDirty = false;
+  }
+  // onRegionChange: optional
+  if (newViewProps.onRegionChange.isDirty) {
+    swiftPart.setOnRegionChange(newViewProps.onRegionChange.value);
+    newViewProps.onRegionChange.isDirty = false;
+  }
+  // onRegionChangeComplete: optional
+  if (newViewProps.onRegionChangeComplete.isDirty) {
+    swiftPart.setOnRegionChangeComplete(newViewProps.onRegionChangeComplete.value);
+    newViewProps.onRegionChangeComplete.isDirty = false;
+  }
+  // onMarkerPress: optional
+  if (newViewProps.onMarkerPress.isDirty) {
+    swiftPart.setOnMarkerPress(newViewProps.onMarkerPress.value);
+    newViewProps.onMarkerPress.isDirty = false;
+  }
+  // onMarkerDragStart: optional
+  if (newViewProps.onMarkerDragStart.isDirty) {
+    swiftPart.setOnMarkerDragStart(newViewProps.onMarkerDragStart.value);
+    newViewProps.onMarkerDragStart.isDirty = false;
+  }
+  // onMarkerDrag: optional
+  if (newViewProps.onMarkerDrag.isDirty) {
+    swiftPart.setOnMarkerDrag(newViewProps.onMarkerDrag.value);
+    newViewProps.onMarkerDrag.isDirty = false;
+  }
+  // onMarkerDragEnd: optional
+  if (newViewProps.onMarkerDragEnd.isDirty) {
+    swiftPart.setOnMarkerDragEnd(newViewProps.onMarkerDragEnd.value);
+    newViewProps.onMarkerDragEnd.isDirty = false;
+  }
+  // onClusterPress: optional
+  if (newViewProps.onClusterPress.isDirty) {
+    swiftPart.setOnClusterPress(newViewProps.onClusterPress.value);
+    newViewProps.onClusterPress.isDirty = false;
+  }
+  // onError: optional
+  if (newViewProps.onError.isDirty) {
+    swiftPart.setOnError(newViewProps.onError.value);
+    newViewProps.onError.isDirty = false;
+  }
+
+  swiftPart.afterUpdate();
+
+  // 3. Update hybridRef if it changed
+  if (newViewProps.hybridRef.isDirty) {
+    // hybridRef changed - call it with new this
+    const auto& maybeFunc = newViewProps.hybridRef.value;
+    if (maybeFunc.has_value()) {
+      maybeFunc.value()(_hybridView);
+    }
+    newViewProps.hybridRef.isDirty = false;
+  }
+
+  // 4. Continue in base class
+  [super updateProps:props oldProps:oldProps];
+}
+
+@end

package/nitrogen/generated/ios/swift/Camera.swift

@@ -0,0 +1,80 @@
+///
+/// Camera.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 `Camera`, backed by a C++ struct.
+ */
+public typealias Camera = margelo.nitro.nitromap.Camera
+
+public extension Camera {
+  private typealias bridge = margelo.nitro.nitromap.bridge.swift
+
+  /**
+   * Create a new instance of `Camera`.
+   */
+  init(center: Coordinate, pitch: Double, heading: Double, altitude: Double, zoom: Double) {
+    self.init(center, pitch, heading, altitude, zoom)
+  }
+
+  var center: Coordinate {
+    @inline(__always)
+    get {
+      return self.__center
+    }
+    @inline(__always)
+    set {
+      self.__center = newValue
+    }
+  }
+  
+  var pitch: Double {
+    @inline(__always)
+    get {
+      return self.__pitch
+    }
+    @inline(__always)
+    set {
+      self.__pitch = newValue
+    }
+  }
+  
+  var heading: Double {
+    @inline(__always)
+    get {
+      return self.__heading
+    }
+    @inline(__always)
+    set {
+      self.__heading = newValue
+    }
+  }
+  
+  var altitude: Double {
+    @inline(__always)
+    get {
+      return self.__altitude
+    }
+    @inline(__always)
+    set {
+      self.__altitude = newValue
+    }
+  }
+  
+  var zoom: Double {
+    @inline(__always)
+    get {
+      return self.__zoom
+    }
+    @inline(__always)
+    set {
+      self.__zoom = newValue
+    }
+  }
+}