react-native-google-maps-plus 0.1.0 → 1.0.1

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

@@ -0,0 +1,71 @@
+///
+/// RNPosition.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+
+
+
+
+namespace margelo::nitro::googlemapsnitro {
+
+  /**
+   * A struct which can be represented as a JavaScript object (RNPosition).
+   */
+  struct RNPosition {
+  public:
+    double x     SWIFT_PRIVATE;
+    double y     SWIFT_PRIVATE;
+
+  public:
+    RNPosition() = default;
+    explicit RNPosition(double x, double y): x(x), y(y) {}
+  };
+
+} // namespace margelo::nitro::googlemapsnitro
+
+namespace margelo::nitro {
+
+  // C++ RNPosition <> JS RNPosition (object)
+  template <>
+  struct JSIConverter<margelo::nitro::googlemapsnitro::RNPosition> final {
+    static inline margelo::nitro::googlemapsnitro::RNPosition fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return margelo::nitro::googlemapsnitro::RNPosition(
+        JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, "x")),
+        JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, "y"))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::googlemapsnitro::RNPosition& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, "x", JSIConverter<double>::toJSI(runtime, arg.x));
+      obj.setProperty(runtime, "y", JSIConverter<double>::toJSI(runtime, arg.y));
+      return obj;
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isObject()) {
+        return false;
+      }
+      jsi::Object obj = value.getObject(runtime);
+      if (!JSIConverter<double>::canConvert(runtime, obj.getProperty(runtime, "x"))) return false;
+      if (!JSIConverter<double>::canConvert(runtime, obj.getProperty(runtime, "y"))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro

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

@@ -0,0 +1,76 @@
+///
+/// RNRegion.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `RNLatLng` to properly resolve imports.
+namespace margelo::nitro::googlemapsnitro { struct RNLatLng; }
+
+#include "RNLatLng.hpp"
+
+namespace margelo::nitro::googlemapsnitro {
+
+  /**
+   * A struct which can be represented as a JavaScript object (RNRegion).
+   */
+  struct RNRegion {
+  public:
+    RNLatLng center     SWIFT_PRIVATE;
+    double latitudeDelta     SWIFT_PRIVATE;
+    double longitudeDelta     SWIFT_PRIVATE;
+
+  public:
+    RNRegion() = default;
+    explicit RNRegion(RNLatLng center, double latitudeDelta, double longitudeDelta): center(center), latitudeDelta(latitudeDelta), longitudeDelta(longitudeDelta) {}
+  };
+
+} // namespace margelo::nitro::googlemapsnitro
+
+namespace margelo::nitro {
+
+  // C++ RNRegion <> JS RNRegion (object)
+  template <>
+  struct JSIConverter<margelo::nitro::googlemapsnitro::RNRegion> final {
+    static inline margelo::nitro::googlemapsnitro::RNRegion fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return margelo::nitro::googlemapsnitro::RNRegion(
+        JSIConverter<margelo::nitro::googlemapsnitro::RNLatLng>::fromJSI(runtime, obj.getProperty(runtime, "center")),
+        JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, "latitudeDelta")),
+        JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, "longitudeDelta"))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::googlemapsnitro::RNRegion& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, "center", JSIConverter<margelo::nitro::googlemapsnitro::RNLatLng>::toJSI(runtime, arg.center));
+      obj.setProperty(runtime, "latitudeDelta", JSIConverter<double>::toJSI(runtime, arg.latitudeDelta));
+      obj.setProperty(runtime, "longitudeDelta", JSIConverter<double>::toJSI(runtime, arg.longitudeDelta));
+      return obj;
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isObject()) {
+        return false;
+      }
+      jsi::Object obj = value.getObject(runtime);
+      if (!JSIConverter<margelo::nitro::googlemapsnitro::RNLatLng>::canConvert(runtime, obj.getProperty(runtime, "center"))) return false;
+      if (!JSIConverter<double>::canConvert(runtime, obj.getProperty(runtime, "latitudeDelta"))) return false;
+      if (!JSIConverter<double>::canConvert(runtime, obj.getProperty(runtime, "longitudeDelta"))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro

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

@@ -0,0 +1,80 @@
+///
+/// RNUserInterfaceStyle.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/NitroHash.hpp>)
+#include <NitroModules/NitroHash.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+namespace margelo::nitro::googlemapsnitro {
+
+  /**
+   * An enum which can be represented as a JavaScript union (RNUserInterfaceStyle).
+   */
+  enum class RNUserInterfaceStyle {
+    LIGHT      SWIFT_NAME(light) = 0,
+    DARK      SWIFT_NAME(dark) = 1,
+    DEFAULT      SWIFT_NAME(default) = 2,
+  } CLOSED_ENUM;
+
+} // namespace margelo::nitro::googlemapsnitro
+
+namespace margelo::nitro {
+
+  // C++ RNUserInterfaceStyle <> JS RNUserInterfaceStyle (union)
+  template <>
+  struct JSIConverter<margelo::nitro::googlemapsnitro::RNUserInterfaceStyle> final {
+    static inline margelo::nitro::googlemapsnitro::RNUserInterfaceStyle fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, arg);
+      switch (hashString(unionValue.c_str(), unionValue.size())) {
+        case hashString("light"): return margelo::nitro::googlemapsnitro::RNUserInterfaceStyle::LIGHT;
+        case hashString("dark"): return margelo::nitro::googlemapsnitro::RNUserInterfaceStyle::DARK;
+        case hashString("default"): return margelo::nitro::googlemapsnitro::RNUserInterfaceStyle::DEFAULT;
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert \"" + unionValue + "\" to enum RNUserInterfaceStyle - invalid value!");
+      }
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, margelo::nitro::googlemapsnitro::RNUserInterfaceStyle arg) {
+      switch (arg) {
+        case margelo::nitro::googlemapsnitro::RNUserInterfaceStyle::LIGHT: return JSIConverter<std::string>::toJSI(runtime, "light");
+        case margelo::nitro::googlemapsnitro::RNUserInterfaceStyle::DARK: return JSIConverter<std::string>::toJSI(runtime, "dark");
+        case margelo::nitro::googlemapsnitro::RNUserInterfaceStyle::DEFAULT: return JSIConverter<std::string>::toJSI(runtime, "default");
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert RNUserInterfaceStyle to JS - invalid value: "
+                                    + std::to_string(static_cast<int>(arg)) + "!");
+      }
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isString()) {
+        return false;
+      }
+      std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, value);
+      switch (hashString(unionValue.c_str(), unionValue.size())) {
+        case hashString("light"):
+        case hashString("dark"):
+        case hashString("default"):
+          return true;
+        default:
+          return false;
+      }
+    }
+  };
+
+} // namespace margelo::nitro

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

@@ -0,0 +1,315 @@
+///
+/// HybridGoogleMapsNitroViewComponent.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 <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::googlemapsnitro::views {
+
+  extern const char HybridGoogleMapsNitroViewComponentName[] = "GoogleMapsNitroView";
+
+  HybridGoogleMapsNitroViewProps::HybridGoogleMapsNitroViewProps(const react::PropsParserContext& context,
+                                                                 const HybridGoogleMapsNitroViewProps& sourceProps,
+                                                                 const react::RawProps& rawProps):
+    react::ViewProps(context, sourceProps, rawProps, filterObjectKeys),
+    buildingEnabled([&]() -> CachedProp<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);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("GoogleMapsNitroView.buildingEnabled: ") + exc.what());
+      }
+    }()),
+    trafficEnabled([&]() -> CachedProp<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);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("GoogleMapsNitroView.trafficEnabled: ") + exc.what());
+      }
+    }()),
+    customMapStyle([&]() -> CachedProp<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);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("GoogleMapsNitroView.initialCamera: ") + exc.what());
+      }
+    }()),
+    userInterfaceStyle([&]() -> CachedProp<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);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("GoogleMapsNitroView.userInterfaceStyle: ") + exc.what());
+      }
+    }()),
+    minZoomLevel([&]() -> CachedProp<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);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("GoogleMapsNitroView.minZoomLevel: ") + exc.what());
+      }
+    }()),
+    maxZoomLevel([&]() -> CachedProp<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);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("GoogleMapsNitroView.maxZoomLevel: ") + exc.what());
+      }
+    }()),
+    mapPadding([&]() -> CachedProp<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);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("GoogleMapsNitroView.mapPadding: ") + exc.what());
+      }
+    }()),
+    markers([&]() -> CachedProp<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);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("GoogleMapsNitroView.markers: ") + exc.what());
+      }
+    }()),
+    polygons([&]() -> CachedProp<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);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("GoogleMapsNitroView.polygons: ") + exc.what());
+      }
+    }()),
+    polylines([&]() -> CachedProp<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);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("GoogleMapsNitroView.polylines: ") + 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("GoogleMapsNitroView.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("GoogleMapsNitroView.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("GoogleMapsNitroView.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("GoogleMapsNitroView.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("GoogleMapsNitroView.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("GoogleMapsNitroView.onMarkerPress: ") + 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("GoogleMapsNitroView.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("GoogleMapsNitroView.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("GoogleMapsNitroView.onCameraChangeComplete: ") + exc.what());
+      }
+    }()),
+    hybridRef([&]() -> CachedProp<std::optional<std::function<void(const std::shared_ptr<HybridGoogleMapsNitroViewSpec>& /* 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);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("GoogleMapsNitroView.hybridRef: ") + exc.what());
+      }
+    }()) { }
+
+  HybridGoogleMapsNitroViewProps::HybridGoogleMapsNitroViewProps(const HybridGoogleMapsNitroViewProps& other):
+    react::ViewProps(),
+    buildingEnabled(other.buildingEnabled),
+    trafficEnabled(other.trafficEnabled),
+    customMapStyle(other.customMapStyle),
+    initialCamera(other.initialCamera),
+    userInterfaceStyle(other.userInterfaceStyle),
+    minZoomLevel(other.minZoomLevel),
+    maxZoomLevel(other.maxZoomLevel),
+    mapPadding(other.mapPadding),
+    markers(other.markers),
+    polygons(other.polygons),
+    polylines(other.polylines),
+    onMapError(other.onMapError),
+    onMapReady(other.onMapReady),
+    onLocationUpdate(other.onLocationUpdate),
+    onLocationError(other.onLocationError),
+    onMapPress(other.onMapPress),
+    onMarkerPress(other.onMarkerPress),
+    onCameraChangeStart(other.onCameraChangeStart),
+    onCameraChange(other.onCameraChange),
+    onCameraChangeComplete(other.onCameraChangeComplete),
+    hybridRef(other.hybridRef) { }
+
+  bool HybridGoogleMapsNitroViewProps::filterObjectKeys(const std::string& propName) {
+    switch (hashString(propName)) {
+      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("markers"): return true;
+      case hashString("polygons"): return true;
+      case hashString("polylines"): 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("onCameraChangeStart"): return true;
+      case hashString("onCameraChange"): return true;
+      case hashString("onCameraChangeComplete"): return true;
+      case hashString("hybridRef"): return true;
+      default: return false;
+    }
+  }
+
+  HybridGoogleMapsNitroViewComponentDescriptor::HybridGoogleMapsNitroViewComponentDescriptor(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 {
+    // 1. Prepare raw props parser
+    rawProps.parse(rawPropsParser_);
+    // 2. Copy props with Nitro's cached copy constructor
+    return HybridGoogleMapsNitroViewShadowNode::Props(context, /* & */ rawProps, props);
+  }
+
+#ifdef ANDROID
+  void HybridGoogleMapsNitroViewComponentDescriptor::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;
+    state.setProps(props);
+    concreteShadowNode.setStateData(std::move(state));
+  }
+#endif
+
+} // namespace margelo::nitro::googlemapsnitro::views