react-native-google-maps-plus 1.0.1 → 1.0.3-dev.1

package/nitrogen/generated/shared/c++/views/{HybridGoogleMapsNitroViewComponent.cpp → HybridRNGoogleMapsPlusViewComponent.cpp}

@@ -1,11 +1,11 @@
 ///
-/// HybridGoogleMapsNitroViewComponent.cpp
+/// HybridRNGoogleMapsPlusViewComponent.cpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
 /// Copyright © 2025 Marc Rousavy @ Margelo
 ///
 
-#include "HybridGoogleMapsNitroViewComponent.hpp"
+#include "HybridRNGoogleMapsPlusViewComponent.hpp"
 
 #include <string>
 #include <exception>
@@ -17,122 +17,142 @@
 #include <react/renderer/core/ComponentDescriptor.h>
 #include <react/renderer/components/view/ViewProps.h>
 
-namespace margelo::nitro::googlemapsnitro::views {
+namespace margelo::nitro::rngooglemapsplus::views {
 
-  extern const char HybridGoogleMapsNitroViewComponentName[] = "GoogleMapsNitroView";
+  extern const char HybridRNGoogleMapsPlusViewComponentName[] = "RNGoogleMapsPlusView";
 
-  HybridGoogleMapsNitroViewProps::HybridGoogleMapsNitroViewProps(const react::PropsParserContext& context,
-                                                                 const HybridGoogleMapsNitroViewProps& sourceProps,
-                                                                 const react::RawProps& rawProps):
+  HybridRNGoogleMapsPlusViewProps::HybridRNGoogleMapsPlusViewProps(const react::PropsParserContext& context,
+                                                                   const HybridRNGoogleMapsPlusViewProps& sourceProps,
+                                                                   const react::RawProps& rawProps):
     react::ViewProps(context, sourceProps, rawProps, filterObjectKeys),
-    buildingEnabled([&]() -> CachedProp<bool> {
+    initialProps([&]() -> CachedProp<std::optional<RNInitialProps>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("initialProps", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.initialProps;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<RNInitialProps>>::fromRawValue(*runtime, value, sourceProps.initialProps);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("RNGoogleMapsPlusView.initialProps: ") + exc.what());
+      }
+    }()),
+    buildingEnabled([&]() -> CachedProp<std::optional<bool>> {
       try {
         const react::RawValue* rawValue = rawProps.at("buildingEnabled", nullptr, nullptr);
         if (rawValue == nullptr) return sourceProps.buildingEnabled;
         const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
-        return CachedProp<bool>::fromRawValue(*runtime, value, sourceProps.buildingEnabled);
+        return CachedProp<std::optional<bool>>::fromRawValue(*runtime, value, sourceProps.buildingEnabled);
       } catch (const std::exception& exc) {
-        throw std::runtime_error(std::string("GoogleMapsNitroView.buildingEnabled: ") + exc.what());
+        throw std::runtime_error(std::string("RNGoogleMapsPlusView.buildingEnabled: ") + exc.what());
       }
     }()),
-    trafficEnabled([&]() -> CachedProp<bool> {
+    trafficEnabled([&]() -> CachedProp<std::optional<bool>> {
       try {
         const react::RawValue* rawValue = rawProps.at("trafficEnabled", nullptr, nullptr);
         if (rawValue == nullptr) return sourceProps.trafficEnabled;
         const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
-        return CachedProp<bool>::fromRawValue(*runtime, value, sourceProps.trafficEnabled);
+        return CachedProp<std::optional<bool>>::fromRawValue(*runtime, value, sourceProps.trafficEnabled);
       } catch (const std::exception& exc) {
-        throw std::runtime_error(std::string("GoogleMapsNitroView.trafficEnabled: ") + exc.what());
+        throw std::runtime_error(std::string("RNGoogleMapsPlusView.trafficEnabled: ") + exc.what());
       }
     }()),
-    customMapStyle([&]() -> CachedProp<std::string> {
+    customMapStyle([&]() -> CachedProp<std::optional<std::string>> {
       try {
         const react::RawValue* rawValue = rawProps.at("customMapStyle", nullptr, nullptr);
         if (rawValue == nullptr) return sourceProps.customMapStyle;
         const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
-        return CachedProp<std::string>::fromRawValue(*runtime, value, sourceProps.customMapStyle);
-      } catch (const std::exception& exc) {
-        throw std::runtime_error(std::string("GoogleMapsNitroView.customMapStyle: ") + exc.what());
-      }
-    }()),
-    initialCamera([&]() -> CachedProp<RNCamera> {
-      try {
-        const react::RawValue* rawValue = rawProps.at("initialCamera", nullptr, nullptr);
-        if (rawValue == nullptr) return sourceProps.initialCamera;
-        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
-        return CachedProp<RNCamera>::fromRawValue(*runtime, value, sourceProps.initialCamera);
+        return CachedProp<std::optional<std::string>>::fromRawValue(*runtime, value, sourceProps.customMapStyle);
       } catch (const std::exception& exc) {
-        throw std::runtime_error(std::string("GoogleMapsNitroView.initialCamera: ") + exc.what());
+        throw std::runtime_error(std::string("RNGoogleMapsPlusView.customMapStyle: ") + exc.what());
       }
     }()),
-    userInterfaceStyle([&]() -> CachedProp<RNUserInterfaceStyle> {
+    userInterfaceStyle([&]() -> CachedProp<std::optional<RNUserInterfaceStyle>> {
       try {
         const react::RawValue* rawValue = rawProps.at("userInterfaceStyle", nullptr, nullptr);
         if (rawValue == nullptr) return sourceProps.userInterfaceStyle;
         const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
-        return CachedProp<RNUserInterfaceStyle>::fromRawValue(*runtime, value, sourceProps.userInterfaceStyle);
+        return CachedProp<std::optional<RNUserInterfaceStyle>>::fromRawValue(*runtime, value, sourceProps.userInterfaceStyle);
       } catch (const std::exception& exc) {
-        throw std::runtime_error(std::string("GoogleMapsNitroView.userInterfaceStyle: ") + exc.what());
+        throw std::runtime_error(std::string("RNGoogleMapsPlusView.userInterfaceStyle: ") + exc.what());
       }
     }()),
-    minZoomLevel([&]() -> CachedProp<double> {
+    minZoomLevel([&]() -> CachedProp<std::optional<double>> {
       try {
         const react::RawValue* rawValue = rawProps.at("minZoomLevel", nullptr, nullptr);
         if (rawValue == nullptr) return sourceProps.minZoomLevel;
         const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
-        return CachedProp<double>::fromRawValue(*runtime, value, sourceProps.minZoomLevel);
+        return CachedProp<std::optional<double>>::fromRawValue(*runtime, value, sourceProps.minZoomLevel);
       } catch (const std::exception& exc) {
-        throw std::runtime_error(std::string("GoogleMapsNitroView.minZoomLevel: ") + exc.what());
+        throw std::runtime_error(std::string("RNGoogleMapsPlusView.minZoomLevel: ") + exc.what());
       }
     }()),
-    maxZoomLevel([&]() -> CachedProp<double> {
+    maxZoomLevel([&]() -> CachedProp<std::optional<double>> {
       try {
         const react::RawValue* rawValue = rawProps.at("maxZoomLevel", nullptr, nullptr);
         if (rawValue == nullptr) return sourceProps.maxZoomLevel;
         const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
-        return CachedProp<double>::fromRawValue(*runtime, value, sourceProps.maxZoomLevel);
+        return CachedProp<std::optional<double>>::fromRawValue(*runtime, value, sourceProps.maxZoomLevel);
       } catch (const std::exception& exc) {
-        throw std::runtime_error(std::string("GoogleMapsNitroView.maxZoomLevel: ") + exc.what());
+        throw std::runtime_error(std::string("RNGoogleMapsPlusView.maxZoomLevel: ") + exc.what());
       }
     }()),
-    mapPadding([&]() -> CachedProp<RNMapPadding> {
+    mapPadding([&]() -> CachedProp<std::optional<RNMapPadding>> {
       try {
         const react::RawValue* rawValue = rawProps.at("mapPadding", nullptr, nullptr);
         if (rawValue == nullptr) return sourceProps.mapPadding;
         const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
-        return CachedProp<RNMapPadding>::fromRawValue(*runtime, value, sourceProps.mapPadding);
+        return CachedProp<std::optional<RNMapPadding>>::fromRawValue(*runtime, value, sourceProps.mapPadding);
       } catch (const std::exception& exc) {
-        throw std::runtime_error(std::string("GoogleMapsNitroView.mapPadding: ") + exc.what());
+        throw std::runtime_error(std::string("RNGoogleMapsPlusView.mapPadding: ") + exc.what());
       }
     }()),
-    markers([&]() -> CachedProp<std::vector<RNMarker>> {
+    mapType([&]() -> CachedProp<std::optional<RNMapType>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("mapType", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.mapType;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<RNMapType>>::fromRawValue(*runtime, value, sourceProps.mapType);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("RNGoogleMapsPlusView.mapType: ") + exc.what());
+      }
+    }()),
+    markers([&]() -> CachedProp<std::optional<std::vector<RNMarker>>> {
       try {
         const react::RawValue* rawValue = rawProps.at("markers", nullptr, nullptr);
         if (rawValue == nullptr) return sourceProps.markers;
         const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
-        return CachedProp<std::vector<RNMarker>>::fromRawValue(*runtime, value, sourceProps.markers);
+        return CachedProp<std::optional<std::vector<RNMarker>>>::fromRawValue(*runtime, value, sourceProps.markers);
       } catch (const std::exception& exc) {
-        throw std::runtime_error(std::string("GoogleMapsNitroView.markers: ") + exc.what());
+        throw std::runtime_error(std::string("RNGoogleMapsPlusView.markers: ") + exc.what());
       }
     }()),
-    polygons([&]() -> CachedProp<std::vector<RNPolygon>> {
+    polygons([&]() -> CachedProp<std::optional<std::vector<RNPolygon>>> {
       try {
         const react::RawValue* rawValue = rawProps.at("polygons", nullptr, nullptr);
         if (rawValue == nullptr) return sourceProps.polygons;
         const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
-        return CachedProp<std::vector<RNPolygon>>::fromRawValue(*runtime, value, sourceProps.polygons);
+        return CachedProp<std::optional<std::vector<RNPolygon>>>::fromRawValue(*runtime, value, sourceProps.polygons);
       } catch (const std::exception& exc) {
-        throw std::runtime_error(std::string("GoogleMapsNitroView.polygons: ") + exc.what());
+        throw std::runtime_error(std::string("RNGoogleMapsPlusView.polygons: ") + exc.what());
       }
     }()),
-    polylines([&]() -> CachedProp<std::vector<RNPolyline>> {
+    polylines([&]() -> CachedProp<std::optional<std::vector<RNPolyline>>> {
       try {
         const react::RawValue* rawValue = rawProps.at("polylines", nullptr, nullptr);
         if (rawValue == nullptr) return sourceProps.polylines;
         const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
-        return CachedProp<std::vector<RNPolyline>>::fromRawValue(*runtime, value, sourceProps.polylines);
+        return CachedProp<std::optional<std::vector<RNPolyline>>>::fromRawValue(*runtime, value, sourceProps.polylines);
       } catch (const std::exception& exc) {
-        throw std::runtime_error(std::string("GoogleMapsNitroView.polylines: ") + exc.what());
+        throw std::runtime_error(std::string("RNGoogleMapsPlusView.polylines: ") + exc.what());
+      }
+    }()),
+    circles([&]() -> CachedProp<std::optional<std::vector<RNCircle>>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("circles", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.circles;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<std::vector<RNCircle>>>::fromRawValue(*runtime, value, sourceProps.circles);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("RNGoogleMapsPlusView.circles: ") + exc.what());
       }
     }()),
     onMapError([&]() -> CachedProp<std::optional<std::function<void(RNMapErrorCode /* error */)>>> {
@@ -142,7 +162,7 @@ namespace margelo::nitro::googlemapsnitro::views {
         const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
         return CachedProp<std::optional<std::function<void(RNMapErrorCode /* error */)>>>::fromRawValue(*runtime, value.asObject(*runtime).getProperty(*runtime, "f"), sourceProps.onMapError);
       } catch (const std::exception& exc) {
-        throw std::runtime_error(std::string("GoogleMapsNitroView.onMapError: ") + exc.what());
+        throw std::runtime_error(std::string("RNGoogleMapsPlusView.onMapError: ") + exc.what());
       }
     }()),
     onMapReady([&]() -> CachedProp<std::optional<std::function<void(bool /* ready */)>>> {
@@ -152,7 +172,7 @@ namespace margelo::nitro::googlemapsnitro::views {
         const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
         return CachedProp<std::optional<std::function<void(bool /* ready */)>>>::fromRawValue(*runtime, value.asObject(*runtime).getProperty(*runtime, "f"), sourceProps.onMapReady);
       } catch (const std::exception& exc) {
-        throw std::runtime_error(std::string("GoogleMapsNitroView.onMapReady: ") + exc.what());
+        throw std::runtime_error(std::string("RNGoogleMapsPlusView.onMapReady: ") + exc.what());
       }
     }()),
     onLocationUpdate([&]() -> CachedProp<std::optional<std::function<void(const RNLocation& /* location */)>>> {
@@ -162,7 +182,7 @@ namespace margelo::nitro::googlemapsnitro::views {
         const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
         return CachedProp<std::optional<std::function<void(const RNLocation& /* location */)>>>::fromRawValue(*runtime, value.asObject(*runtime).getProperty(*runtime, "f"), sourceProps.onLocationUpdate);
       } catch (const std::exception& exc) {
-        throw std::runtime_error(std::string("GoogleMapsNitroView.onLocationUpdate: ") + exc.what());
+        throw std::runtime_error(std::string("RNGoogleMapsPlusView.onLocationUpdate: ") + exc.what());
       }
     }()),
     onLocationError([&]() -> CachedProp<std::optional<std::function<void(RNLocationErrorCode /* error */)>>> {
@@ -172,7 +192,7 @@ namespace margelo::nitro::googlemapsnitro::views {
         const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
         return CachedProp<std::optional<std::function<void(RNLocationErrorCode /* error */)>>>::fromRawValue(*runtime, value.asObject(*runtime).getProperty(*runtime, "f"), sourceProps.onLocationError);
       } catch (const std::exception& exc) {
-        throw std::runtime_error(std::string("GoogleMapsNitroView.onLocationError: ") + exc.what());
+        throw std::runtime_error(std::string("RNGoogleMapsPlusView.onLocationError: ") + exc.what());
       }
     }()),
     onMapPress([&]() -> CachedProp<std::optional<std::function<void(const RNLatLng& /* coordinate */)>>> {
@@ -182,7 +202,7 @@ namespace margelo::nitro::googlemapsnitro::views {
         const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
         return CachedProp<std::optional<std::function<void(const RNLatLng& /* coordinate */)>>>::fromRawValue(*runtime, value.asObject(*runtime).getProperty(*runtime, "f"), sourceProps.onMapPress);
       } catch (const std::exception& exc) {
-        throw std::runtime_error(std::string("GoogleMapsNitroView.onMapPress: ") + exc.what());
+        throw std::runtime_error(std::string("RNGoogleMapsPlusView.onMapPress: ") + exc.what());
       }
     }()),
     onMarkerPress([&]() -> CachedProp<std::optional<std::function<void(const std::string& /* id */)>>> {
@@ -192,7 +212,37 @@ namespace margelo::nitro::googlemapsnitro::views {
         const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
         return CachedProp<std::optional<std::function<void(const std::string& /* id */)>>>::fromRawValue(*runtime, value.asObject(*runtime).getProperty(*runtime, "f"), sourceProps.onMarkerPress);
       } catch (const std::exception& exc) {
-        throw std::runtime_error(std::string("GoogleMapsNitroView.onMarkerPress: ") + exc.what());
+        throw std::runtime_error(std::string("RNGoogleMapsPlusView.onMarkerPress: ") + exc.what());
+      }
+    }()),
+    onPolylinePress([&]() -> CachedProp<std::optional<std::function<void(const std::string& /* id */)>>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("onPolylinePress", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.onPolylinePress;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<std::function<void(const std::string& /* id */)>>>::fromRawValue(*runtime, value.asObject(*runtime).getProperty(*runtime, "f"), sourceProps.onPolylinePress);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("RNGoogleMapsPlusView.onPolylinePress: ") + exc.what());
+      }
+    }()),
+    onPolygonPress([&]() -> CachedProp<std::optional<std::function<void(const std::string& /* id */)>>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("onPolygonPress", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.onPolygonPress;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<std::function<void(const std::string& /* id */)>>>::fromRawValue(*runtime, value.asObject(*runtime).getProperty(*runtime, "f"), sourceProps.onPolygonPress);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("RNGoogleMapsPlusView.onPolygonPress: ") + exc.what());
+      }
+    }()),
+    onCirclePress([&]() -> CachedProp<std::optional<std::function<void(const std::string& /* id */)>>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("onCirclePress", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.onCirclePress;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<std::function<void(const std::string& /* id */)>>>::fromRawValue(*runtime, value.asObject(*runtime).getProperty(*runtime, "f"), sourceProps.onCirclePress);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("RNGoogleMapsPlusView.onCirclePress: ") + exc.what());
       }
     }()),
     onCameraChangeStart([&]() -> CachedProp<std::optional<std::function<void(const RNRegion& /* region */, const RNCamera& /* camera */, bool /* isGesture */)>>> {
@@ -202,7 +252,7 @@ namespace margelo::nitro::googlemapsnitro::views {
         const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
         return CachedProp<std::optional<std::function<void(const RNRegion& /* region */, const RNCamera& /* camera */, bool /* isGesture */)>>>::fromRawValue(*runtime, value.asObject(*runtime).getProperty(*runtime, "f"), sourceProps.onCameraChangeStart);
       } catch (const std::exception& exc) {
-        throw std::runtime_error(std::string("GoogleMapsNitroView.onCameraChangeStart: ") + exc.what());
+        throw std::runtime_error(std::string("RNGoogleMapsPlusView.onCameraChangeStart: ") + exc.what());
       }
     }()),
     onCameraChange([&]() -> CachedProp<std::optional<std::function<void(const RNRegion& /* region */, const RNCamera& /* camera */, bool /* isGesture */)>>> {
@@ -212,7 +262,7 @@ namespace margelo::nitro::googlemapsnitro::views {
         const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
         return CachedProp<std::optional<std::function<void(const RNRegion& /* region */, const RNCamera& /* camera */, bool /* isGesture */)>>>::fromRawValue(*runtime, value.asObject(*runtime).getProperty(*runtime, "f"), sourceProps.onCameraChange);
       } catch (const std::exception& exc) {
-        throw std::runtime_error(std::string("GoogleMapsNitroView.onCameraChange: ") + exc.what());
+        throw std::runtime_error(std::string("RNGoogleMapsPlusView.onCameraChange: ") + exc.what());
       }
     }()),
     onCameraChangeComplete([&]() -> CachedProp<std::optional<std::function<void(const RNRegion& /* region */, const RNCamera& /* camera */, bool /* isGesture */)>>> {
@@ -222,63 +272,73 @@ namespace margelo::nitro::googlemapsnitro::views {
         const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
         return CachedProp<std::optional<std::function<void(const RNRegion& /* region */, const RNCamera& /* camera */, bool /* isGesture */)>>>::fromRawValue(*runtime, value.asObject(*runtime).getProperty(*runtime, "f"), sourceProps.onCameraChangeComplete);
       } catch (const std::exception& exc) {
-        throw std::runtime_error(std::string("GoogleMapsNitroView.onCameraChangeComplete: ") + exc.what());
+        throw std::runtime_error(std::string("RNGoogleMapsPlusView.onCameraChangeComplete: ") + exc.what());
       }
     }()),
-    hybridRef([&]() -> CachedProp<std::optional<std::function<void(const std::shared_ptr<HybridGoogleMapsNitroViewSpec>& /* ref */)>>> {
+    hybridRef([&]() -> CachedProp<std::optional<std::function<void(const std::shared_ptr<HybridRNGoogleMapsPlusViewSpec>& /* ref */)>>> {
       try {
         const react::RawValue* rawValue = rawProps.at("hybridRef", nullptr, nullptr);
         if (rawValue == nullptr) return sourceProps.hybridRef;
         const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
-        return CachedProp<std::optional<std::function<void(const std::shared_ptr<HybridGoogleMapsNitroViewSpec>& /* ref */)>>>::fromRawValue(*runtime, value.asObject(*runtime).getProperty(*runtime, "f"), sourceProps.hybridRef);
+        return CachedProp<std::optional<std::function<void(const std::shared_ptr<HybridRNGoogleMapsPlusViewSpec>& /* ref */)>>>::fromRawValue(*runtime, value.asObject(*runtime).getProperty(*runtime, "f"), sourceProps.hybridRef);
       } catch (const std::exception& exc) {
-        throw std::runtime_error(std::string("GoogleMapsNitroView.hybridRef: ") + exc.what());
+        throw std::runtime_error(std::string("RNGoogleMapsPlusView.hybridRef: ") + exc.what());
       }
     }()) { }
 
-  HybridGoogleMapsNitroViewProps::HybridGoogleMapsNitroViewProps(const HybridGoogleMapsNitroViewProps& other):
+  HybridRNGoogleMapsPlusViewProps::HybridRNGoogleMapsPlusViewProps(const HybridRNGoogleMapsPlusViewProps& other):
     react::ViewProps(),
+    initialProps(other.initialProps),
     buildingEnabled(other.buildingEnabled),
     trafficEnabled(other.trafficEnabled),
     customMapStyle(other.customMapStyle),
-    initialCamera(other.initialCamera),
     userInterfaceStyle(other.userInterfaceStyle),
     minZoomLevel(other.minZoomLevel),
     maxZoomLevel(other.maxZoomLevel),
     mapPadding(other.mapPadding),
+    mapType(other.mapType),
     markers(other.markers),
     polygons(other.polygons),
     polylines(other.polylines),
+    circles(other.circles),
     onMapError(other.onMapError),
     onMapReady(other.onMapReady),
     onLocationUpdate(other.onLocationUpdate),
     onLocationError(other.onLocationError),
     onMapPress(other.onMapPress),
     onMarkerPress(other.onMarkerPress),
+    onPolylinePress(other.onPolylinePress),
+    onPolygonPress(other.onPolygonPress),
+    onCirclePress(other.onCirclePress),
     onCameraChangeStart(other.onCameraChangeStart),
     onCameraChange(other.onCameraChange),
     onCameraChangeComplete(other.onCameraChangeComplete),
     hybridRef(other.hybridRef) { }
 
-  bool HybridGoogleMapsNitroViewProps::filterObjectKeys(const std::string& propName) {
+  bool HybridRNGoogleMapsPlusViewProps::filterObjectKeys(const std::string& propName) {
     switch (hashString(propName)) {
+      case hashString("initialProps"): return true;
       case hashString("buildingEnabled"): return true;
       case hashString("trafficEnabled"): return true;
       case hashString("customMapStyle"): return true;
-      case hashString("initialCamera"): return true;
       case hashString("userInterfaceStyle"): return true;
       case hashString("minZoomLevel"): return true;
       case hashString("maxZoomLevel"): return true;
       case hashString("mapPadding"): return true;
+      case hashString("mapType"): return true;
       case hashString("markers"): return true;
       case hashString("polygons"): return true;
       case hashString("polylines"): return true;
+      case hashString("circles"): return true;
       case hashString("onMapError"): return true;
       case hashString("onMapReady"): return true;
       case hashString("onLocationUpdate"): return true;
       case hashString("onLocationError"): return true;
       case hashString("onMapPress"): return true;
       case hashString("onMarkerPress"): return true;
+      case hashString("onPolylinePress"): return true;
+      case hashString("onPolygonPress"): return true;
+      case hashString("onCirclePress"): return true;
       case hashString("onCameraChangeStart"): return true;
       case hashString("onCameraChange"): return true;
       case hashString("onCameraChangeComplete"): return true;
@@ -287,29 +347,29 @@ namespace margelo::nitro::googlemapsnitro::views {
     }
   }
 
-  HybridGoogleMapsNitroViewComponentDescriptor::HybridGoogleMapsNitroViewComponentDescriptor(const react::ComponentDescriptorParameters& parameters)
+  HybridRNGoogleMapsPlusViewComponentDescriptor::HybridRNGoogleMapsPlusViewComponentDescriptor(const react::ComponentDescriptorParameters& parameters)
     : ConcreteComponentDescriptor(parameters,
                                   react::RawPropsParser(/* enableJsiParser */ true)) {}
 
-  std::shared_ptr<const react::Props> HybridGoogleMapsNitroViewComponentDescriptor::cloneProps(const react::PropsParserContext& context,
-                                                                                               const std::shared_ptr<const react::Props>& props,
-                                                                                               react::RawProps rawProps) const {
+  std::shared_ptr<const react::Props> HybridRNGoogleMapsPlusViewComponentDescriptor::cloneProps(const react::PropsParserContext& context,
+                                                                                                const std::shared_ptr<const react::Props>& props,
+                                                                                                react::RawProps rawProps) const {
     // 1. Prepare raw props parser
     rawProps.parse(rawPropsParser_);
     // 2. Copy props with Nitro's cached copy constructor
-    return HybridGoogleMapsNitroViewShadowNode::Props(context, /* & */ rawProps, props);
+    return HybridRNGoogleMapsPlusViewShadowNode::Props(context, /* & */ rawProps, props);
   }
 
 #ifdef ANDROID
-  void HybridGoogleMapsNitroViewComponentDescriptor::adopt(react::ShadowNode& shadowNode) const {
+  void HybridRNGoogleMapsPlusViewComponentDescriptor::adopt(react::ShadowNode& shadowNode) const {
     // This is called immediately after `ShadowNode` is created, cloned or in progress.
     // On Android, we need to wrap props in our state, which gets routed through Java and later unwrapped in JNI/C++.
-    auto& concreteShadowNode = dynamic_cast<HybridGoogleMapsNitroViewShadowNode&>(shadowNode);
-    const HybridGoogleMapsNitroViewProps& props = concreteShadowNode.getConcreteProps();
-    HybridGoogleMapsNitroViewState state;
+    auto& concreteShadowNode = dynamic_cast<HybridRNGoogleMapsPlusViewShadowNode&>(shadowNode);
+    const HybridRNGoogleMapsPlusViewProps& props = concreteShadowNode.getConcreteProps();
+    HybridRNGoogleMapsPlusViewState state;
     state.setProps(props);
     concreteShadowNode.setStateData(std::move(state));
   }
 #endif
 
-} // namespace margelo::nitro::googlemapsnitro::views
+} // namespace margelo::nitro::rngooglemapsplus::views

package/nitrogen/generated/shared/c++/views/HybridRNGoogleMapsPlusViewComponent.hpp

@@ -0,0 +1,147 @@
+///
+/// HybridRNGoogleMapsPlusViewComponent.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <optional>
+#include <NitroModules/NitroDefines.hpp>
+#include <NitroModules/NitroHash.hpp>
+#include <NitroModules/CachedProp.hpp>
+#include <react/renderer/core/ConcreteComponentDescriptor.h>
+#include <react/renderer/core/PropsParserContext.h>
+#include <react/renderer/components/view/ConcreteViewShadowNode.h>
+#include <react/renderer/components/view/ViewProps.h>
+
+#include "RNInitialProps.hpp"
+#include <optional>
+#include <string>
+#include "RNUserInterfaceStyle.hpp"
+#include "RNMapPadding.hpp"
+#include "RNMapType.hpp"
+#include "RNMarker.hpp"
+#include <vector>
+#include "RNPolygon.hpp"
+#include "RNPolyline.hpp"
+#include "RNCircle.hpp"
+#include "RNMapErrorCode.hpp"
+#include <functional>
+#include "RNLocation.hpp"
+#include "RNLocationErrorCode.hpp"
+#include "RNLatLng.hpp"
+#include "RNRegion.hpp"
+#include "RNCamera.hpp"
+#include <memory>
+#include "HybridRNGoogleMapsPlusViewSpec.hpp"
+
+namespace margelo::nitro::rngooglemapsplus::views {
+
+  using namespace facebook;
+
+  /**
+   * The name of the actual native View.
+   */
+  extern const char HybridRNGoogleMapsPlusViewComponentName[];
+
+  /**
+   * Props for the "RNGoogleMapsPlusView" View.
+   */
+  class HybridRNGoogleMapsPlusViewProps final: public react::ViewProps {
+  public:
+    HybridRNGoogleMapsPlusViewProps() = default;
+    HybridRNGoogleMapsPlusViewProps(const HybridRNGoogleMapsPlusViewProps&);
+    HybridRNGoogleMapsPlusViewProps(const react::PropsParserContext& context,
+                                    const HybridRNGoogleMapsPlusViewProps& sourceProps,
+                                    const react::RawProps& rawProps);
+
+  public:
+    CachedProp<std::optional<RNInitialProps>> initialProps;
+    CachedProp<std::optional<bool>> buildingEnabled;
+    CachedProp<std::optional<bool>> trafficEnabled;
+    CachedProp<std::optional<std::string>> customMapStyle;
+    CachedProp<std::optional<RNUserInterfaceStyle>> userInterfaceStyle;
+    CachedProp<std::optional<double>> minZoomLevel;
+    CachedProp<std::optional<double>> maxZoomLevel;
+    CachedProp<std::optional<RNMapPadding>> mapPadding;
+    CachedProp<std::optional<RNMapType>> mapType;
+    CachedProp<std::optional<std::vector<RNMarker>>> markers;
+    CachedProp<std::optional<std::vector<RNPolygon>>> polygons;
+    CachedProp<std::optional<std::vector<RNPolyline>>> polylines;
+    CachedProp<std::optional<std::vector<RNCircle>>> circles;
+    CachedProp<std::optional<std::function<void(RNMapErrorCode /* error */)>>> onMapError;
+    CachedProp<std::optional<std::function<void(bool /* ready */)>>> onMapReady;
+    CachedProp<std::optional<std::function<void(const RNLocation& /* location */)>>> onLocationUpdate;
+    CachedProp<std::optional<std::function<void(RNLocationErrorCode /* error */)>>> onLocationError;
+    CachedProp<std::optional<std::function<void(const RNLatLng& /* coordinate */)>>> onMapPress;
+    CachedProp<std::optional<std::function<void(const std::string& /* id */)>>> onMarkerPress;
+    CachedProp<std::optional<std::function<void(const std::string& /* id */)>>> onPolylinePress;
+    CachedProp<std::optional<std::function<void(const std::string& /* id */)>>> onPolygonPress;
+    CachedProp<std::optional<std::function<void(const std::string& /* id */)>>> onCirclePress;
+    CachedProp<std::optional<std::function<void(const RNRegion& /* region */, const RNCamera& /* camera */, bool /* isGesture */)>>> onCameraChangeStart;
+    CachedProp<std::optional<std::function<void(const RNRegion& /* region */, const RNCamera& /* camera */, bool /* isGesture */)>>> onCameraChange;
+    CachedProp<std::optional<std::function<void(const RNRegion& /* region */, const RNCamera& /* camera */, bool /* isGesture */)>>> onCameraChangeComplete;
+    CachedProp<std::optional<std::function<void(const std::shared_ptr<HybridRNGoogleMapsPlusViewSpec>& /* ref */)>>> hybridRef;
+
+  private:
+    static bool filterObjectKeys(const std::string& propName);
+  };
+
+  /**
+   * State for the "RNGoogleMapsPlusView" View.
+   */
+  class HybridRNGoogleMapsPlusViewState final {
+  public:
+    HybridRNGoogleMapsPlusViewState() = default;
+
+  public:
+    void setProps(const HybridRNGoogleMapsPlusViewProps& props) { _props.emplace(props); }
+    const std::optional<HybridRNGoogleMapsPlusViewProps>& getProps() const { return _props; }
+
+  public:
+#ifdef ANDROID
+  HybridRNGoogleMapsPlusViewState(const HybridRNGoogleMapsPlusViewState& /* previousState */, folly::dynamic /* data */) {}
+  folly::dynamic getDynamic() const {
+    throw std::runtime_error("HybridRNGoogleMapsPlusViewState does not support folly!");
+  }
+  react::MapBuffer getMapBuffer() const {
+    throw std::runtime_error("HybridRNGoogleMapsPlusViewState does not support MapBuffer!");
+  };
+#endif
+
+  private:
+    std::optional<HybridRNGoogleMapsPlusViewProps> _props;
+  };
+
+  /**
+   * The Shadow Node for the "RNGoogleMapsPlusView" View.
+   */
+  using HybridRNGoogleMapsPlusViewShadowNode = react::ConcreteViewShadowNode<HybridRNGoogleMapsPlusViewComponentName /* "HybridRNGoogleMapsPlusView" */,
+                                                                             HybridRNGoogleMapsPlusViewProps /* custom props */,
+                                                                             react::ViewEventEmitter /* default */,
+                                                                             HybridRNGoogleMapsPlusViewState /* custom state */>;
+
+  /**
+   * The Component Descriptor for the "RNGoogleMapsPlusView" View.
+   */
+  class HybridRNGoogleMapsPlusViewComponentDescriptor final: public react::ConcreteComponentDescriptor<HybridRNGoogleMapsPlusViewShadowNode> {
+  public:
+    HybridRNGoogleMapsPlusViewComponentDescriptor(const react::ComponentDescriptorParameters& parameters);
+
+  public:
+    /**
+     * A faster path for cloning props - reuses the caching logic from `HybridRNGoogleMapsPlusViewProps`.
+     */
+    std::shared_ptr<const react::Props> cloneProps(const react::PropsParserContext& context,
+                                                   const std::shared_ptr<const react::Props>& props,
+                                                   react::RawProps rawProps) const override;
+#ifdef ANDROID
+    void adopt(react::ShadowNode& shadowNode) const override;
+#endif
+  };
+
+  /* The actual view for "RNGoogleMapsPlusView" needs to be implemented in platform-specific code. */
+
+} // namespace margelo::nitro::rngooglemapsplus::views

package/nitrogen/generated/shared/json/{GoogleMapsNitroViewConfig.json → RNGoogleMapsPlusViewConfig.json}

@@ -1,26 +1,31 @@
 {
-  "uiViewClassName": "GoogleMapsNitroView",
+  "uiViewClassName": "RNGoogleMapsPlusView",
   "supportsRawText": false,
   "bubblingEventTypes": {},
   "directEventTypes": {},
   "validAttributes": {
+    "initialProps": true,
     "buildingEnabled": true,
     "trafficEnabled": true,
     "customMapStyle": true,
-    "initialCamera": true,
     "userInterfaceStyle": true,
     "minZoomLevel": true,
     "maxZoomLevel": true,
     "mapPadding": true,
+    "mapType": true,
     "markers": true,
     "polygons": true,
     "polylines": true,
+    "circles": true,
     "onMapError": true,
     "onMapReady": true,
     "onLocationUpdate": true,
     "onLocationError": true,
     "onMapPress": true,
     "onMarkerPress": true,
+    "onPolylinePress": true,
+    "onPolygonPress": true,
+    "onCirclePress": true,
     "onCameraChangeStart": true,
     "onCameraChange": true,
     "onCameraChangeComplete": true,