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

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

@@ -0,0 +1,114 @@
+///
+/// PolylineData.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 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
+#if __has_include(<NitroModules/JSIHelpers.hpp>)
+#include <NitroModules/JSIHelpers.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `Coordinate` to properly resolve imports.
+namespace margelo::nitro::nitromap { struct Coordinate; }
+// Forward declaration of `MarkerColor` to properly resolve imports.
+namespace margelo::nitro::nitromap { struct MarkerColor; }
+
+#include <string>
+#include "Coordinate.hpp"
+#include <vector>
+#include "MarkerColor.hpp"
+#include <optional>
+
+namespace margelo::nitro::nitromap {
+
+  /**
+   * A struct which can be represented as a JavaScript object (PolylineData).
+   */
+  struct PolylineData {
+  public:
+    std::string id     SWIFT_PRIVATE;
+    std::vector<Coordinate> coordinates     SWIFT_PRIVATE;
+    MarkerColor strokeColor     SWIFT_PRIVATE;
+    double strokeWidth     SWIFT_PRIVATE;
+    bool geodesic     SWIFT_PRIVATE;
+    bool dashed     SWIFT_PRIVATE;
+    double zIndex     SWIFT_PRIVATE;
+    bool tappable     SWIFT_PRIVATE;
+    std::optional<std::string> accessibilityLabel     SWIFT_PRIVATE;
+
+  public:
+    PolylineData() = default;
+    explicit PolylineData(std::string id, std::vector<Coordinate> coordinates, MarkerColor strokeColor, double strokeWidth, bool geodesic, bool dashed, double zIndex, bool tappable, std::optional<std::string> accessibilityLabel): id(id), coordinates(coordinates), strokeColor(strokeColor), strokeWidth(strokeWidth), geodesic(geodesic), dashed(dashed), zIndex(zIndex), tappable(tappable), accessibilityLabel(accessibilityLabel) {}
+  };
+
+} // namespace margelo::nitro::nitromap
+
+namespace margelo::nitro {
+
+  // C++ PolylineData <> JS PolylineData (object)
+  template <>
+  struct JSIConverter<margelo::nitro::nitromap::PolylineData> final {
+    static inline margelo::nitro::nitromap::PolylineData fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return margelo::nitro::nitromap::PolylineData(
+        JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, "id")),
+        JSIConverter<std::vector<margelo::nitro::nitromap::Coordinate>>::fromJSI(runtime, obj.getProperty(runtime, "coordinates")),
+        JSIConverter<margelo::nitro::nitromap::MarkerColor>::fromJSI(runtime, obj.getProperty(runtime, "strokeColor")),
+        JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, "strokeWidth")),
+        JSIConverter<bool>::fromJSI(runtime, obj.getProperty(runtime, "geodesic")),
+        JSIConverter<bool>::fromJSI(runtime, obj.getProperty(runtime, "dashed")),
+        JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, "zIndex")),
+        JSIConverter<bool>::fromJSI(runtime, obj.getProperty(runtime, "tappable")),
+        JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, "accessibilityLabel"))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::nitromap::PolylineData& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, "id", JSIConverter<std::string>::toJSI(runtime, arg.id));
+      obj.setProperty(runtime, "coordinates", JSIConverter<std::vector<margelo::nitro::nitromap::Coordinate>>::toJSI(runtime, arg.coordinates));
+      obj.setProperty(runtime, "strokeColor", JSIConverter<margelo::nitro::nitromap::MarkerColor>::toJSI(runtime, arg.strokeColor));
+      obj.setProperty(runtime, "strokeWidth", JSIConverter<double>::toJSI(runtime, arg.strokeWidth));
+      obj.setProperty(runtime, "geodesic", JSIConverter<bool>::toJSI(runtime, arg.geodesic));
+      obj.setProperty(runtime, "dashed", JSIConverter<bool>::toJSI(runtime, arg.dashed));
+      obj.setProperty(runtime, "zIndex", JSIConverter<double>::toJSI(runtime, arg.zIndex));
+      obj.setProperty(runtime, "tappable", JSIConverter<bool>::toJSI(runtime, arg.tappable));
+      obj.setProperty(runtime, "accessibilityLabel", JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.accessibilityLabel));
+      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 (!nitro::isPlainObject(runtime, obj)) {
+        return false;
+      }
+      if (!JSIConverter<std::string>::canConvert(runtime, obj.getProperty(runtime, "id"))) return false;
+      if (!JSIConverter<std::vector<margelo::nitro::nitromap::Coordinate>>::canConvert(runtime, obj.getProperty(runtime, "coordinates"))) return false;
+      if (!JSIConverter<margelo::nitro::nitromap::MarkerColor>::canConvert(runtime, obj.getProperty(runtime, "strokeColor"))) return false;
+      if (!JSIConverter<double>::canConvert(runtime, obj.getProperty(runtime, "strokeWidth"))) return false;
+      if (!JSIConverter<bool>::canConvert(runtime, obj.getProperty(runtime, "geodesic"))) return false;
+      if (!JSIConverter<bool>::canConvert(runtime, obj.getProperty(runtime, "dashed"))) return false;
+      if (!JSIConverter<double>::canConvert(runtime, obj.getProperty(runtime, "zIndex"))) return false;
+      if (!JSIConverter<bool>::canConvert(runtime, obj.getProperty(runtime, "tappable"))) return false;
+      if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, "accessibilityLabel"))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro

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

@@ -0,0 +1,88 @@
+///
+/// UserLocationChangeEvent.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 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
+#if __has_include(<NitroModules/JSIHelpers.hpp>)
+#include <NitroModules/JSIHelpers.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `Coordinate` to properly resolve imports.
+namespace margelo::nitro::nitromap { struct Coordinate; }
+
+#include "Coordinate.hpp"
+
+namespace margelo::nitro::nitromap {
+
+  /**
+   * A struct which can be represented as a JavaScript object (UserLocationChangeEvent).
+   */
+  struct UserLocationChangeEvent {
+  public:
+    Coordinate coordinate     SWIFT_PRIVATE;
+    double accuracy     SWIFT_PRIVATE;
+    double heading     SWIFT_PRIVATE;
+    double speed     SWIFT_PRIVATE;
+
+  public:
+    UserLocationChangeEvent() = default;
+    explicit UserLocationChangeEvent(Coordinate coordinate, double accuracy, double heading, double speed): coordinate(coordinate), accuracy(accuracy), heading(heading), speed(speed) {}
+  };
+
+} // namespace margelo::nitro::nitromap
+
+namespace margelo::nitro {
+
+  // C++ UserLocationChangeEvent <> JS UserLocationChangeEvent (object)
+  template <>
+  struct JSIConverter<margelo::nitro::nitromap::UserLocationChangeEvent> final {
+    static inline margelo::nitro::nitromap::UserLocationChangeEvent fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return margelo::nitro::nitromap::UserLocationChangeEvent(
+        JSIConverter<margelo::nitro::nitromap::Coordinate>::fromJSI(runtime, obj.getProperty(runtime, "coordinate")),
+        JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, "accuracy")),
+        JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, "heading")),
+        JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, "speed"))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::nitromap::UserLocationChangeEvent& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, "coordinate", JSIConverter<margelo::nitro::nitromap::Coordinate>::toJSI(runtime, arg.coordinate));
+      obj.setProperty(runtime, "accuracy", JSIConverter<double>::toJSI(runtime, arg.accuracy));
+      obj.setProperty(runtime, "heading", JSIConverter<double>::toJSI(runtime, arg.heading));
+      obj.setProperty(runtime, "speed", JSIConverter<double>::toJSI(runtime, arg.speed));
+      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 (!nitro::isPlainObject(runtime, obj)) {
+        return false;
+      }
+      if (!JSIConverter<margelo::nitro::nitromap::Coordinate>::canConvert(runtime, obj.getProperty(runtime, "coordinate"))) return false;
+      if (!JSIConverter<double>::canConvert(runtime, obj.getProperty(runtime, "accuracy"))) return false;
+      if (!JSIConverter<double>::canConvert(runtime, obj.getProperty(runtime, "heading"))) return false;
+      if (!JSIConverter<double>::canConvert(runtime, obj.getProperty(runtime, "speed"))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro

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

@@ -0,0 +1,80 @@
+///
+/// UserTrackingMode.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 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::nitromap {
+
+  /**
+   * An enum which can be represented as a JavaScript union (UserTrackingMode).
+   */
+  enum class UserTrackingMode {
+    NONE      SWIFT_NAME(none) = 0,
+    FOLLOW      SWIFT_NAME(follow) = 1,
+    FOLLOWWITHHEADING      SWIFT_NAME(followwithheading) = 2,
+  } CLOSED_ENUM;
+
+} // namespace margelo::nitro::nitromap
+
+namespace margelo::nitro {
+
+  // C++ UserTrackingMode <> JS UserTrackingMode (union)
+  template <>
+  struct JSIConverter<margelo::nitro::nitromap::UserTrackingMode> final {
+    static inline margelo::nitro::nitromap::UserTrackingMode 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("none"): return margelo::nitro::nitromap::UserTrackingMode::NONE;
+        case hashString("follow"): return margelo::nitro::nitromap::UserTrackingMode::FOLLOW;
+        case hashString("followWithHeading"): return margelo::nitro::nitromap::UserTrackingMode::FOLLOWWITHHEADING;
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert \"" + unionValue + "\" to enum UserTrackingMode - invalid value!");
+      }
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, margelo::nitro::nitromap::UserTrackingMode arg) {
+      switch (arg) {
+        case margelo::nitro::nitromap::UserTrackingMode::NONE: return JSIConverter<std::string>::toJSI(runtime, "none");
+        case margelo::nitro::nitromap::UserTrackingMode::FOLLOW: return JSIConverter<std::string>::toJSI(runtime, "follow");
+        case margelo::nitro::nitromap::UserTrackingMode::FOLLOWWITHHEADING: return JSIConverter<std::string>::toJSI(runtime, "followWithHeading");
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert UserTrackingMode 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("none"):
+        case hashString("follow"):
+        case hashString("followWithHeading"):
+          return true;
+        default:
+          return false;
+      }
+    }
+  };
+
+} // namespace margelo::nitro

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

@@ -45,6 +45,16 @@ namespace margelo::nitro::nitromap::views {
         throw std::runtime_error(std::string("NitroMap.initialRegion: ") + exc.what());
       }
     }()),
+    region([&]() -> CachedProp<std::optional<Region>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("region", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.region;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<Region>>::fromRawValue(*runtime, value, sourceProps.region);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("NitroMap.region: ") + exc.what());
+      }
+    }()),
     showsUserLocation([&]() -> CachedProp<std::optional<bool>> {
       try {
         const react::RawValue* rawValue = rawProps.at("showsUserLocation", nullptr, nullptr);
@@ -115,16 +125,6 @@ namespace margelo::nitro::nitromap::views {
         throw std::runtime_error(std::string("NitroMap.customMapStyle: ") + exc.what());
       }
     }()),
-    showsMyLocationButton([&]() -> CachedProp<std::optional<bool>> {
-      try {
-        const react::RawValue* rawValue = rawProps.at("showsMyLocationButton", nullptr, nullptr);
-        if (rawValue == nullptr) return sourceProps.showsMyLocationButton;
-        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
-        return CachedProp<std::optional<bool>>::fromRawValue(*runtime, value, sourceProps.showsMyLocationButton);
-      } catch (const std::exception& exc) {
-        throw std::runtime_error(std::string("NitroMap.showsMyLocationButton: ") + exc.what());
-      }
-    }()),
     clusterConfig([&]() -> CachedProp<std::optional<ClusterConfig>> {
       try {
         const react::RawValue* rawValue = rawProps.at("clusterConfig", nullptr, nullptr);
@@ -135,6 +135,66 @@ namespace margelo::nitro::nitromap::views {
         throw std::runtime_error(std::string("NitroMap.clusterConfig: ") + exc.what());
       }
     }()),
+    mapPadding([&]() -> CachedProp<EdgePadding> {
+      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<EdgePadding>::fromRawValue(*runtime, value, sourceProps.mapPadding);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("NitroMap.mapPadding: ") + exc.what());
+      }
+    }()),
+    showsTraffic([&]() -> CachedProp<std::optional<bool>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("showsTraffic", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.showsTraffic;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<bool>>::fromRawValue(*runtime, value, sourceProps.showsTraffic);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("NitroMap.showsTraffic: ") + exc.what());
+      }
+    }()),
+    showsBuildings([&]() -> CachedProp<std::optional<bool>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("showsBuildings", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.showsBuildings;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<bool>>::fromRawValue(*runtime, value, sourceProps.showsBuildings);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("NitroMap.showsBuildings: ") + exc.what());
+      }
+    }()),
+    showsCompass([&]() -> CachedProp<std::optional<bool>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("showsCompass", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.showsCompass;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<bool>>::fromRawValue(*runtime, value, sourceProps.showsCompass);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("NitroMap.showsCompass: ") + exc.what());
+      }
+    }()),
+    minZoom([&]() -> CachedProp<double> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("minZoom", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.minZoom;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<double>::fromRawValue(*runtime, value, sourceProps.minZoom);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("NitroMap.minZoom: ") + exc.what());
+      }
+    }()),
+    maxZoom([&]() -> CachedProp<double> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("maxZoom", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.maxZoom;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<double>::fromRawValue(*runtime, value, sourceProps.maxZoom);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("NitroMap.maxZoom: ") + exc.what());
+      }
+    }()),
     darkMode([&]() -> CachedProp<std::optional<bool>> {
       try {
         const react::RawValue* rawValue = rawProps.at("darkMode", nullptr, nullptr);
@@ -145,6 +205,46 @@ namespace margelo::nitro::nitromap::views {
         throw std::runtime_error(std::string("NitroMap.darkMode: ") + exc.what());
       }
     }()),
+    userTrackingMode([&]() -> CachedProp<std::optional<UserTrackingMode>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("userTrackingMode", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.userTrackingMode;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<UserTrackingMode>>::fromRawValue(*runtime, value, sourceProps.userTrackingMode);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("NitroMap.userTrackingMode: ") + exc.what());
+      }
+    }()),
+    userLocationImage([&]() -> CachedProp<std::string> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("userLocationImage", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.userLocationImage;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::string>::fromRawValue(*runtime, value, sourceProps.userLocationImage);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("NitroMap.userLocationImage: ") + exc.what());
+      }
+    }()),
+    userLocationSize([&]() -> CachedProp<double> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("userLocationSize", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.userLocationSize;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<double>::fromRawValue(*runtime, value, sourceProps.userLocationSize);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("NitroMap.userLocationSize: ") + exc.what());
+      }
+    }()),
+    userLocationAnchor([&]() -> CachedProp<std::optional<Point>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("userLocationAnchor", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.userLocationAnchor;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<Point>>::fromRawValue(*runtime, value, sourceProps.userLocationAnchor);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("NitroMap.userLocationAnchor: ") + exc.what());
+      }
+    }()),
     onPress([&]() -> CachedProp<std::optional<std::function<void(const MapPressEvent& /* event */)>>> {
       try {
         const react::RawValue* rawValue = rawProps.at("onPress", nullptr, nullptr);
@@ -245,6 +345,36 @@ namespace margelo::nitro::nitromap::views {
         throw std::runtime_error(std::string("NitroMap.onClusterPress: ") + 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("NitroMap.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("NitroMap.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("NitroMap.onCirclePress: ") + exc.what());
+      }
+    }()),
     onError([&]() -> CachedProp<std::optional<std::function<void(const MapError& /* error */)>>> {
       try {
         const react::RawValue* rawValue = rawProps.at("onError", nullptr, nullptr);
@@ -255,6 +385,46 @@ namespace margelo::nitro::nitromap::views {
         throw std::runtime_error(std::string("NitroMap.onError: ") + exc.what());
       }
     }()),
+    onUserLocationChange([&]() -> CachedProp<std::optional<std::function<void(const UserLocationChangeEvent& /* event */)>>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("onUserLocationChange", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.onUserLocationChange;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<std::function<void(const UserLocationChangeEvent& /* event */)>>>::fromRawValue(*runtime, value.asObject(*runtime).getProperty(*runtime, "f"), sourceProps.onUserLocationChange);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("NitroMap.onUserLocationChange: ") + exc.what());
+      }
+    }()),
+    onUserTrackingModeChange([&]() -> CachedProp<std::optional<std::function<void(UserTrackingMode /* mode */)>>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("onUserTrackingModeChange", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.onUserTrackingModeChange;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<std::function<void(UserTrackingMode /* mode */)>>>::fromRawValue(*runtime, value.asObject(*runtime).getProperty(*runtime, "f"), sourceProps.onUserTrackingModeChange);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("NitroMap.onUserTrackingModeChange: ") + exc.what());
+      }
+    }()),
+    onUserLocationError([&]() -> CachedProp<std::optional<std::function<void(const MapError& /* error */)>>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("onUserLocationError", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.onUserLocationError;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<std::function<void(const MapError& /* error */)>>>::fromRawValue(*runtime, value.asObject(*runtime).getProperty(*runtime, "f"), sourceProps.onUserLocationError);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("NitroMap.onUserLocationError: ") + exc.what());
+      }
+    }()),
+    onMapIdle([&]() -> CachedProp<std::optional<std::function<void()>>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("onMapIdle", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.onMapIdle;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<std::function<void()>>>::fromRawValue(*runtime, value.asObject(*runtime).getProperty(*runtime, "f"), sourceProps.onMapIdle);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("NitroMap.onMapIdle: ") + exc.what());
+      }
+    }()),
     hybridRef([&]() -> CachedProp<std::optional<std::function<void(const std::shared_ptr<HybridNitroMapSpec>& /* ref */)>>> {
       try {
         const react::RawValue* rawValue = rawProps.at("hybridRef", nullptr, nullptr);
@@ -270,6 +440,7 @@ namespace margelo::nitro::nitromap::views {
     react::ViewProps(),
     provider(other.provider),
     initialRegion(other.initialRegion),
+    region(other.region),
     showsUserLocation(other.showsUserLocation),
     zoomEnabled(other.zoomEnabled),
     scrollEnabled(other.scrollEnabled),
@@ -277,9 +448,18 @@ namespace margelo::nitro::nitromap::views {
     pitchEnabled(other.pitchEnabled),
     mapType(other.mapType),
     customMapStyle(other.customMapStyle),
-    showsMyLocationButton(other.showsMyLocationButton),
     clusterConfig(other.clusterConfig),
+    mapPadding(other.mapPadding),
+    showsTraffic(other.showsTraffic),
+    showsBuildings(other.showsBuildings),
+    showsCompass(other.showsCompass),
+    minZoom(other.minZoom),
+    maxZoom(other.maxZoom),
     darkMode(other.darkMode),
+    userTrackingMode(other.userTrackingMode),
+    userLocationImage(other.userLocationImage),
+    userLocationSize(other.userLocationSize),
+    userLocationAnchor(other.userLocationAnchor),
     onPress(other.onPress),
     onLongPress(other.onLongPress),
     onMapReady(other.onMapReady),
@@ -290,13 +470,21 @@ namespace margelo::nitro::nitromap::views {
     onMarkerDrag(other.onMarkerDrag),
     onMarkerDragEnd(other.onMarkerDragEnd),
     onClusterPress(other.onClusterPress),
+    onPolylinePress(other.onPolylinePress),
+    onPolygonPress(other.onPolygonPress),
+    onCirclePress(other.onCirclePress),
     onError(other.onError),
+    onUserLocationChange(other.onUserLocationChange),
+    onUserTrackingModeChange(other.onUserTrackingModeChange),
+    onUserLocationError(other.onUserLocationError),
+    onMapIdle(other.onMapIdle),
     hybridRef(other.hybridRef) { }
 
   bool HybridNitroMapProps::filterObjectKeys(const std::string& propName) {
     switch (hashString(propName)) {
       case hashString("provider"): return true;
       case hashString("initialRegion"): return true;
+      case hashString("region"): return true;
       case hashString("showsUserLocation"): return true;
       case hashString("zoomEnabled"): return true;
       case hashString("scrollEnabled"): return true;
@@ -304,9 +492,18 @@ namespace margelo::nitro::nitromap::views {
       case hashString("pitchEnabled"): return true;
       case hashString("mapType"): return true;
       case hashString("customMapStyle"): return true;
-      case hashString("showsMyLocationButton"): return true;
       case hashString("clusterConfig"): return true;
+      case hashString("mapPadding"): return true;
+      case hashString("showsTraffic"): return true;
+      case hashString("showsBuildings"): return true;
+      case hashString("showsCompass"): return true;
+      case hashString("minZoom"): return true;
+      case hashString("maxZoom"): return true;
       case hashString("darkMode"): return true;
+      case hashString("userTrackingMode"): return true;
+      case hashString("userLocationImage"): return true;
+      case hashString("userLocationSize"): return true;
+      case hashString("userLocationAnchor"): return true;
       case hashString("onPress"): return true;
       case hashString("onLongPress"): return true;
       case hashString("onMapReady"): return true;
@@ -317,7 +514,14 @@ namespace margelo::nitro::nitromap::views {
       case hashString("onMarkerDrag"): return true;
       case hashString("onMarkerDragEnd"): return true;
       case hashString("onClusterPress"): return true;
+      case hashString("onPolylinePress"): return true;
+      case hashString("onPolygonPress"): return true;
+      case hashString("onCirclePress"): return true;
       case hashString("onError"): return true;
+      case hashString("onUserLocationChange"): return true;
+      case hashString("onUserTrackingModeChange"): return true;
+      case hashString("onUserLocationError"): return true;
+      case hashString("onMapIdle"): return true;
       case hashString("hybridRef"): return true;
       default: return false;
     }

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

@@ -23,6 +23,10 @@
 #include "MapStyleElement.hpp"
 #include <vector>
 #include "ClusterConfig.hpp"
+#include "EdgePadding.hpp"
+#include "UserTrackingMode.hpp"
+#include <string>
+#include "Point.hpp"
 #include "MapPressEvent.hpp"
 #include <functional>
 #include "RegionChangeEvent.hpp"
@@ -30,6 +34,7 @@
 #include "MarkerDragEvent.hpp"
 #include "ClusterPressEvent.hpp"
 #include "MapError.hpp"
+#include "UserLocationChangeEvent.hpp"
 #include <memory>
 #include "HybridNitroMapSpec.hpp"
 
@@ -56,6 +61,7 @@ namespace margelo::nitro::nitromap::views {
   public:
     CachedProp<std::optional<MapProvider>> provider;
     CachedProp<std::optional<Region>> initialRegion;
+    CachedProp<std::optional<Region>> region;
     CachedProp<std::optional<bool>> showsUserLocation;
     CachedProp<std::optional<bool>> zoomEnabled;
     CachedProp<std::optional<bool>> scrollEnabled;
@@ -63,9 +69,18 @@ namespace margelo::nitro::nitromap::views {
     CachedProp<std::optional<bool>> pitchEnabled;
     CachedProp<std::optional<MapType>> mapType;
     CachedProp<std::optional<std::vector<MapStyleElement>>> customMapStyle;
-    CachedProp<std::optional<bool>> showsMyLocationButton;
     CachedProp<std::optional<ClusterConfig>> clusterConfig;
+    CachedProp<EdgePadding> mapPadding;
+    CachedProp<std::optional<bool>> showsTraffic;
+    CachedProp<std::optional<bool>> showsBuildings;
+    CachedProp<std::optional<bool>> showsCompass;
+    CachedProp<double> minZoom;
+    CachedProp<double> maxZoom;
     CachedProp<std::optional<bool>> darkMode;
+    CachedProp<std::optional<UserTrackingMode>> userTrackingMode;
+    CachedProp<std::string> userLocationImage;
+    CachedProp<double> userLocationSize;
+    CachedProp<std::optional<Point>> userLocationAnchor;
     CachedProp<std::optional<std::function<void(const MapPressEvent& /* event */)>>> onPress;
     CachedProp<std::optional<std::function<void(const MapPressEvent& /* event */)>>> onLongPress;
     CachedProp<std::optional<std::function<void()>>> onMapReady;
@@ -76,7 +91,14 @@ namespace margelo::nitro::nitromap::views {
     CachedProp<std::optional<std::function<void(const MarkerDragEvent& /* event */)>>> onMarkerDrag;
     CachedProp<std::optional<std::function<void(const MarkerDragEvent& /* event */)>>> onMarkerDragEnd;
     CachedProp<std::optional<std::function<void(const ClusterPressEvent& /* event */)>>> onClusterPress;
+    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 MapError& /* error */)>>> onError;
+    CachedProp<std::optional<std::function<void(const UserLocationChangeEvent& /* event */)>>> onUserLocationChange;
+    CachedProp<std::optional<std::function<void(UserTrackingMode /* mode */)>>> onUserTrackingModeChange;
+    CachedProp<std::optional<std::function<void(const MapError& /* error */)>>> onUserLocationError;
+    CachedProp<std::optional<std::function<void()>>> onMapIdle;
     CachedProp<std::optional<std::function<void(const std::shared_ptr<HybridNitroMapSpec>& /* ref */)>>> hybridRef;
 
   private: