react-native-google-maps-plus 0.1.0 → 1.0.0-dev.1

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

@@ -0,0 +1,375 @@
+///
+/// HybridRNGoogleMapsPlusViewComponent.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#include "HybridRNGoogleMapsPlusViewComponent.hpp"
+
+#include <string>
+#include <exception>
+#include <utility>
+#include <NitroModules/NitroDefines.hpp>
+#include <NitroModules/JSIConverter.hpp>
+#include <react/renderer/core/RawValue.h>
+#include <react/renderer/core/ShadowNode.h>
+#include <react/renderer/core/ComponentDescriptor.h>
+#include <react/renderer/components/view/ViewProps.h>
+
+namespace margelo::nitro::rngooglemapsplus::views {
+
+  extern const char HybridRNGoogleMapsPlusViewComponentName[] = "RNGoogleMapsPlusView";
+
+  HybridRNGoogleMapsPlusViewProps::HybridRNGoogleMapsPlusViewProps(const react::PropsParserContext& context,
+                                                                   const HybridRNGoogleMapsPlusViewProps& sourceProps,
+                                                                   const react::RawProps& rawProps):
+    react::ViewProps(context, sourceProps, rawProps, filterObjectKeys),
+    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<std::optional<bool>>::fromRawValue(*runtime, value, sourceProps.buildingEnabled);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("RNGoogleMapsPlusView.buildingEnabled: ") + exc.what());
+      }
+    }()),
+    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<std::optional<bool>>::fromRawValue(*runtime, value, sourceProps.trafficEnabled);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("RNGoogleMapsPlusView.trafficEnabled: ") + exc.what());
+      }
+    }()),
+    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::optional<std::string>>::fromRawValue(*runtime, value, sourceProps.customMapStyle);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("RNGoogleMapsPlusView.customMapStyle: ") + exc.what());
+      }
+    }()),
+    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<std::optional<RNUserInterfaceStyle>>::fromRawValue(*runtime, value, sourceProps.userInterfaceStyle);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("RNGoogleMapsPlusView.userInterfaceStyle: ") + exc.what());
+      }
+    }()),
+    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<std::optional<double>>::fromRawValue(*runtime, value, sourceProps.minZoomLevel);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("RNGoogleMapsPlusView.minZoomLevel: ") + exc.what());
+      }
+    }()),
+    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<std::optional<double>>::fromRawValue(*runtime, value, sourceProps.maxZoomLevel);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("RNGoogleMapsPlusView.maxZoomLevel: ") + exc.what());
+      }
+    }()),
+    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<std::optional<RNMapPadding>>::fromRawValue(*runtime, value, sourceProps.mapPadding);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("RNGoogleMapsPlusView.mapPadding: ") + exc.what());
+      }
+    }()),
+    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::optional<std::vector<RNMarker>>>::fromRawValue(*runtime, value, sourceProps.markers);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("RNGoogleMapsPlusView.markers: ") + exc.what());
+      }
+    }()),
+    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::optional<std::vector<RNPolygon>>>::fromRawValue(*runtime, value, sourceProps.polygons);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("RNGoogleMapsPlusView.polygons: ") + exc.what());
+      }
+    }()),
+    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::optional<std::vector<RNPolyline>>>::fromRawValue(*runtime, value, sourceProps.polylines);
+      } catch (const std::exception& exc) {
+        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 */)>>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("onMapError", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.onMapError;
+        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("RNGoogleMapsPlusView.onMapError: ") + exc.what());
+      }
+    }()),
+    onMapReady([&]() -> CachedProp<std::optional<std::function<void(bool /* ready */)>>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("onMapReady", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.onMapReady;
+        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("RNGoogleMapsPlusView.onMapReady: ") + exc.what());
+      }
+    }()),
+    onLocationUpdate([&]() -> CachedProp<std::optional<std::function<void(const RNLocation& /* location */)>>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("onLocationUpdate", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.onLocationUpdate;
+        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("RNGoogleMapsPlusView.onLocationUpdate: ") + exc.what());
+      }
+    }()),
+    onLocationError([&]() -> CachedProp<std::optional<std::function<void(RNLocationErrorCode /* error */)>>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("onLocationError", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.onLocationError;
+        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("RNGoogleMapsPlusView.onLocationError: ") + exc.what());
+      }
+    }()),
+    onMapPress([&]() -> CachedProp<std::optional<std::function<void(const RNLatLng& /* coordinate */)>>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("onMapPress", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.onMapPress;
+        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("RNGoogleMapsPlusView.onMapPress: ") + exc.what());
+      }
+    }()),
+    onMarkerPress([&]() -> CachedProp<std::optional<std::function<void(const std::string& /* id */)>>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("onMarkerPress", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.onMarkerPress;
+        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("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 */)>>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("onCameraChangeStart", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.onCameraChangeStart;
+        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("RNGoogleMapsPlusView.onCameraChangeStart: ") + exc.what());
+      }
+    }()),
+    onCameraChange([&]() -> CachedProp<std::optional<std::function<void(const RNRegion& /* region */, const RNCamera& /* camera */, bool /* isGesture */)>>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("onCameraChange", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.onCameraChange;
+        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("RNGoogleMapsPlusView.onCameraChange: ") + exc.what());
+      }
+    }()),
+    onCameraChangeComplete([&]() -> CachedProp<std::optional<std::function<void(const RNRegion& /* region */, const RNCamera& /* camera */, bool /* isGesture */)>>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("onCameraChangeComplete", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.onCameraChangeComplete;
+        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("RNGoogleMapsPlusView.onCameraChangeComplete: ") + exc.what());
+      }
+    }()),
+    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<HybridRNGoogleMapsPlusViewSpec>& /* ref */)>>>::fromRawValue(*runtime, value.asObject(*runtime).getProperty(*runtime, "f"), sourceProps.hybridRef);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("RNGoogleMapsPlusView.hybridRef: ") + exc.what());
+      }
+    }()) { }
+
+  HybridRNGoogleMapsPlusViewProps::HybridRNGoogleMapsPlusViewProps(const HybridRNGoogleMapsPlusViewProps& other):
+    react::ViewProps(),
+    initialProps(other.initialProps),
+    buildingEnabled(other.buildingEnabled),
+    trafficEnabled(other.trafficEnabled),
+    customMapStyle(other.customMapStyle),
+    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 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("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;
+      case hashString("hybridRef"): return true;
+      default: return false;
+    }
+  }
+
+  HybridRNGoogleMapsPlusViewComponentDescriptor::HybridRNGoogleMapsPlusViewComponentDescriptor(const react::ComponentDescriptorParameters& parameters)
+    : ConcreteComponentDescriptor(parameters,
+                                  react::RawPropsParser(/* enableJsiParser */ true)) {}
+
+  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 HybridRNGoogleMapsPlusViewShadowNode::Props(context, /* & */ rawProps, props);
+  }
+
+#ifdef ANDROID
+  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<HybridRNGoogleMapsPlusViewShadowNode&>(shadowNode);
+    const HybridRNGoogleMapsPlusViewProps& props = concreteShadowNode.getConcreteProps();
+    HybridRNGoogleMapsPlusViewState state;
+    state.setProps(props);
+    concreteShadowNode.setStateData(std::move(state));
+  }
+#endif
+
+} // 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/RNGoogleMapsPlusViewConfig.json

@@ -0,0 +1,34 @@
+{
+  "uiViewClassName": "RNGoogleMapsPlusView",
+  "supportsRawText": false,
+  "bubblingEventTypes": {},
+  "directEventTypes": {},
+  "validAttributes": {
+    "initialProps": true,
+    "buildingEnabled": true,
+    "trafficEnabled": true,
+    "customMapStyle": 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,
+    "hybridRef": true
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-google-maps-plus",
-  "version": "0.1.0",
+  "version": "1.0.0-dev.1",
   "description": "React-native wrapper for android & IOS google maps sdk",
   "main": "./lib/module/index.js",
   "module": "./lib/module/index.js",
@@ -11,21 +11,28 @@
     "lint": "yarn lint:js && yarn lint:android && yarn lint:ios",
     "lint:js": "eslint . --max-warnings 0 && yarn prettier --check .",
     "lint:android": "cd android && ktlint -F ./**/*.kt*",
-    "lint:ios": "cd ios && swiftlint --quiet",
+    "lint:ios": "cd ios && swiftlint --quiet && swiftformat . --lint",
     "format": "yarn format:js && yarn format:ios && yarn format:android",
     "format:js": "prettier --write .",
-    "format:android": "cd android && ktlint ./**/*.kt*",
-    "format:ios": "cd ios && swiftlint --quiet --fix",
+    "format:android": "cd android && ktlint --format ./**/*.kt*",
+    "format:ios": "cd ios && swiftformat .",
     "clean": "del-cli android/build example/android/build example/android/app/build example/ios/build lib",
     "test": "jest",
     "git:clean": "git clean -dfX",
     "release": "semantic-release",
-    "build": "yarn typecheck && yarn nitrogen && bob build",
-    "nitrogen": "nitrogen --logLevel=\"debug\" && node scripts/post-script.js"
+    "build": "yarn nitrogen && bob build",
+    "nitrogen": "nitrogen --logLevel=\"debug\" && node scripts/nitrogen-patch.js",
+    "prepare": "bob build"
   },
   "keywords": [
     "react-native",
-    "react-native-google-maps-plus"
+    "google-maps",
+    "react-native-google-maps",
+    "react-native-google-maps-plus",
+    "google-maps-sdk",
+    "android",
+    "ios",
+    "maps"
   ],
   "files": [
     "src",
@@ -59,6 +66,10 @@
   "license": "MIT",
   "bugs": "https://github.com/pinpong/react-native-google-maps-plus/issues",
   "homepage": "https://github.com/pinpong/react-native-google-maps-plus#readme",
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
   "devDependencies": {
     "@commitlint/cli": "20.0.0",
     "@commitlint/config-conventional": "20.0.0",
@@ -70,6 +81,7 @@
     "@react-native/eslint-config": "0.82.0-rc.4",
     "@semantic-release/changelog": "6.0.3",
     "@semantic-release/git": "10.0.1",
+    "@semantic-release/npm": "13.0.0-beta.1",
     "@types/jest": "30.0.0",
     "@types/react": "19.1.15",
     "clang-format-node": "2.0.1",
@@ -87,9 +99,13 @@
     "react-native": "0.82.0-rc.4",
     "react-native-builder-bob": "0.40.13",
     "react-native-nitro-modules": "0.29.6",
-    "semantic-release": "24.2.9",
+    "semantic-release": "25.0.0-beta.6",
     "typescript": "5.9.2"
   },
+  "overrides": {
+    "@semantic-release/npm": "13.0.0-beta.1",
+    "semantic-release": "25.0.0-beta.6"
+  },
   "peerDependencies": {
     "react": "*",
     "react-native": "*",

package/src/RNGoogleMapsPlusModule.nitro.ts

@@ -0,0 +1,13 @@
+import { type HybridObject } from 'react-native-nitro-modules';
+import type { RNLocationPermissionResult } from './types';
+
+export interface RNGoogleMapsPlusModule
+  extends HybridObject<{ ios: 'swift'; android: 'kotlin' }> {
+  showLocationDialog(): void;
+
+  openLocationSettings(): void;
+
+  requestLocationPermission(): Promise<RNLocationPermissionResult>;
+
+  isGooglePlayServicesAvailable(): boolean;
+}