@maydon_tech/react-native-nitro-maps 0.1.0

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

@@ -0,0 +1,351 @@
+///
+/// HybridNitroMapComponent.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#include "HybridNitroMapComponent.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::nitromap::views {
+
+  extern const char HybridNitroMapComponentName[] = "NitroMap";
+
+  HybridNitroMapProps::HybridNitroMapProps(const react::PropsParserContext& context,
+                                           const HybridNitroMapProps& sourceProps,
+                                           const react::RawProps& rawProps):
+    react::ViewProps(context, sourceProps, rawProps, filterObjectKeys),
+    provider([&]() -> CachedProp<std::optional<MapProvider>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("provider", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.provider;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<MapProvider>>::fromRawValue(*runtime, value, sourceProps.provider);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("NitroMap.provider: ") + exc.what());
+      }
+    }()),
+    initialRegion([&]() -> CachedProp<std::optional<Region>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("initialRegion", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.initialRegion;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<Region>>::fromRawValue(*runtime, value, sourceProps.initialRegion);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("NitroMap.initialRegion: ") + exc.what());
+      }
+    }()),
+    showsUserLocation([&]() -> CachedProp<std::optional<bool>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("showsUserLocation", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.showsUserLocation;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<bool>>::fromRawValue(*runtime, value, sourceProps.showsUserLocation);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("NitroMap.showsUserLocation: ") + exc.what());
+      }
+    }()),
+    zoomEnabled([&]() -> CachedProp<std::optional<bool>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("zoomEnabled", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.zoomEnabled;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<bool>>::fromRawValue(*runtime, value, sourceProps.zoomEnabled);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("NitroMap.zoomEnabled: ") + exc.what());
+      }
+    }()),
+    scrollEnabled([&]() -> CachedProp<std::optional<bool>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("scrollEnabled", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.scrollEnabled;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<bool>>::fromRawValue(*runtime, value, sourceProps.scrollEnabled);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("NitroMap.scrollEnabled: ") + exc.what());
+      }
+    }()),
+    rotateEnabled([&]() -> CachedProp<std::optional<bool>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("rotateEnabled", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.rotateEnabled;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<bool>>::fromRawValue(*runtime, value, sourceProps.rotateEnabled);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("NitroMap.rotateEnabled: ") + exc.what());
+      }
+    }()),
+    pitchEnabled([&]() -> CachedProp<std::optional<bool>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("pitchEnabled", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.pitchEnabled;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<bool>>::fromRawValue(*runtime, value, sourceProps.pitchEnabled);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("NitroMap.pitchEnabled: ") + exc.what());
+      }
+    }()),
+    mapType([&]() -> CachedProp<std::optional<MapType>> {
+      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<MapType>>::fromRawValue(*runtime, value, sourceProps.mapType);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("NitroMap.mapType: ") + exc.what());
+      }
+    }()),
+    customMapStyle([&]() -> CachedProp<std::optional<std::vector<MapStyleElement>>> {
+      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::vector<MapStyleElement>>>::fromRawValue(*runtime, value, sourceProps.customMapStyle);
+      } catch (const std::exception& exc) {
+        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);
+        if (rawValue == nullptr) return sourceProps.clusterConfig;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<ClusterConfig>>::fromRawValue(*runtime, value, sourceProps.clusterConfig);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("NitroMap.clusterConfig: ") + exc.what());
+      }
+    }()),
+    darkMode([&]() -> CachedProp<std::optional<bool>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("darkMode", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.darkMode;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<bool>>::fromRawValue(*runtime, value, sourceProps.darkMode);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("NitroMap.darkMode: ") + exc.what());
+      }
+    }()),
+    onPress([&]() -> CachedProp<std::optional<std::function<void(const MapPressEvent& /* event */)>>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("onPress", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.onPress;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<std::function<void(const MapPressEvent& /* event */)>>>::fromRawValue(*runtime, value.asObject(*runtime).getProperty(*runtime, "f"), sourceProps.onPress);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("NitroMap.onPress: ") + exc.what());
+      }
+    }()),
+    onLongPress([&]() -> CachedProp<std::optional<std::function<void(const MapPressEvent& /* event */)>>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("onLongPress", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.onLongPress;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<std::function<void(const MapPressEvent& /* event */)>>>::fromRawValue(*runtime, value.asObject(*runtime).getProperty(*runtime, "f"), sourceProps.onLongPress);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("NitroMap.onLongPress: ") + exc.what());
+      }
+    }()),
+    onMapReady([&]() -> CachedProp<std::optional<std::function<void()>>> {
+      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()>>>::fromRawValue(*runtime, value.asObject(*runtime).getProperty(*runtime, "f"), sourceProps.onMapReady);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("NitroMap.onMapReady: ") + exc.what());
+      }
+    }()),
+    onRegionChange([&]() -> CachedProp<std::optional<std::function<void(const RegionChangeEvent& /* region */)>>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("onRegionChange", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.onRegionChange;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<std::function<void(const RegionChangeEvent& /* region */)>>>::fromRawValue(*runtime, value.asObject(*runtime).getProperty(*runtime, "f"), sourceProps.onRegionChange);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("NitroMap.onRegionChange: ") + exc.what());
+      }
+    }()),
+    onRegionChangeComplete([&]() -> CachedProp<std::optional<std::function<void(const RegionChangeEvent& /* region */)>>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("onRegionChangeComplete", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.onRegionChangeComplete;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<std::function<void(const RegionChangeEvent& /* region */)>>>::fromRawValue(*runtime, value.asObject(*runtime).getProperty(*runtime, "f"), sourceProps.onRegionChangeComplete);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("NitroMap.onRegionChangeComplete: ") + exc.what());
+      }
+    }()),
+    onMarkerPress([&]() -> CachedProp<std::optional<std::function<void(const MarkerPressEvent& /* event */)>>> {
+      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 MarkerPressEvent& /* event */)>>>::fromRawValue(*runtime, value.asObject(*runtime).getProperty(*runtime, "f"), sourceProps.onMarkerPress);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("NitroMap.onMarkerPress: ") + exc.what());
+      }
+    }()),
+    onMarkerDragStart([&]() -> CachedProp<std::optional<std::function<void(const MarkerDragEvent& /* event */)>>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("onMarkerDragStart", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.onMarkerDragStart;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<std::function<void(const MarkerDragEvent& /* event */)>>>::fromRawValue(*runtime, value.asObject(*runtime).getProperty(*runtime, "f"), sourceProps.onMarkerDragStart);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("NitroMap.onMarkerDragStart: ") + exc.what());
+      }
+    }()),
+    onMarkerDrag([&]() -> CachedProp<std::optional<std::function<void(const MarkerDragEvent& /* event */)>>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("onMarkerDrag", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.onMarkerDrag;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<std::function<void(const MarkerDragEvent& /* event */)>>>::fromRawValue(*runtime, value.asObject(*runtime).getProperty(*runtime, "f"), sourceProps.onMarkerDrag);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("NitroMap.onMarkerDrag: ") + exc.what());
+      }
+    }()),
+    onMarkerDragEnd([&]() -> CachedProp<std::optional<std::function<void(const MarkerDragEvent& /* event */)>>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("onMarkerDragEnd", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.onMarkerDragEnd;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<std::function<void(const MarkerDragEvent& /* event */)>>>::fromRawValue(*runtime, value.asObject(*runtime).getProperty(*runtime, "f"), sourceProps.onMarkerDragEnd);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("NitroMap.onMarkerDragEnd: ") + exc.what());
+      }
+    }()),
+    onClusterPress([&]() -> CachedProp<std::optional<std::function<void(const ClusterPressEvent& /* event */)>>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("onClusterPress", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.onClusterPress;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<std::function<void(const ClusterPressEvent& /* event */)>>>::fromRawValue(*runtime, value.asObject(*runtime).getProperty(*runtime, "f"), sourceProps.onClusterPress);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("NitroMap.onClusterPress: ") + exc.what());
+      }
+    }()),
+    onError([&]() -> CachedProp<std::optional<std::function<void(const MapError& /* error */)>>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("onError", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.onError;
+        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.onError);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("NitroMap.onError: ") + 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);
+        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<HybridNitroMapSpec>& /* ref */)>>>::fromRawValue(*runtime, value.asObject(*runtime).getProperty(*runtime, "f"), sourceProps.hybridRef);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("NitroMap.hybridRef: ") + exc.what());
+      }
+    }()) { }
+
+  HybridNitroMapProps::HybridNitroMapProps(const HybridNitroMapProps& other):
+    react::ViewProps(),
+    provider(other.provider),
+    initialRegion(other.initialRegion),
+    showsUserLocation(other.showsUserLocation),
+    zoomEnabled(other.zoomEnabled),
+    scrollEnabled(other.scrollEnabled),
+    rotateEnabled(other.rotateEnabled),
+    pitchEnabled(other.pitchEnabled),
+    mapType(other.mapType),
+    customMapStyle(other.customMapStyle),
+    showsMyLocationButton(other.showsMyLocationButton),
+    clusterConfig(other.clusterConfig),
+    darkMode(other.darkMode),
+    onPress(other.onPress),
+    onLongPress(other.onLongPress),
+    onMapReady(other.onMapReady),
+    onRegionChange(other.onRegionChange),
+    onRegionChangeComplete(other.onRegionChangeComplete),
+    onMarkerPress(other.onMarkerPress),
+    onMarkerDragStart(other.onMarkerDragStart),
+    onMarkerDrag(other.onMarkerDrag),
+    onMarkerDragEnd(other.onMarkerDragEnd),
+    onClusterPress(other.onClusterPress),
+    onError(other.onError),
+    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("showsUserLocation"): return true;
+      case hashString("zoomEnabled"): return true;
+      case hashString("scrollEnabled"): return true;
+      case hashString("rotateEnabled"): return true;
+      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("darkMode"): return true;
+      case hashString("onPress"): return true;
+      case hashString("onLongPress"): return true;
+      case hashString("onMapReady"): return true;
+      case hashString("onRegionChange"): return true;
+      case hashString("onRegionChangeComplete"): return true;
+      case hashString("onMarkerPress"): return true;
+      case hashString("onMarkerDragStart"): return true;
+      case hashString("onMarkerDrag"): return true;
+      case hashString("onMarkerDragEnd"): return true;
+      case hashString("onClusterPress"): return true;
+      case hashString("onError"): return true;
+      case hashString("hybridRef"): return true;
+      default: return false;
+    }
+  }
+
+  HybridNitroMapComponentDescriptor::HybridNitroMapComponentDescriptor(const react::ComponentDescriptorParameters& parameters)
+    : ConcreteComponentDescriptor(parameters,
+                                  react::RawPropsParser(/* enableJsiParser */ true)) {}
+
+  std::shared_ptr<const react::Props> HybridNitroMapComponentDescriptor::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 HybridNitroMapShadowNode::Props(context, /* & */ rawProps, props);
+  }
+
+#ifdef ANDROID
+  void HybridNitroMapComponentDescriptor::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<HybridNitroMapShadowNode&>(shadowNode);
+    const HybridNitroMapProps& props = concreteShadowNode.getConcreteProps();
+    HybridNitroMapState state;
+    state.setProps(props);
+    concreteShadowNode.setStateData(std::move(state));
+  }
+#endif
+
+} // namespace margelo::nitro::nitromap::views

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

@@ -0,0 +1,141 @@
+///
+/// HybridNitroMapComponent.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <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 "MapProvider.hpp"
+#include <optional>
+#include "Region.hpp"
+#include "MapType.hpp"
+#include "MapStyleElement.hpp"
+#include <vector>
+#include "ClusterConfig.hpp"
+#include "MapPressEvent.hpp"
+#include <functional>
+#include "RegionChangeEvent.hpp"
+#include "MarkerPressEvent.hpp"
+#include "MarkerDragEvent.hpp"
+#include "ClusterPressEvent.hpp"
+#include "MapError.hpp"
+#include <memory>
+#include "HybridNitroMapSpec.hpp"
+
+namespace margelo::nitro::nitromap::views {
+
+  using namespace facebook;
+
+  /**
+   * The name of the actual native View.
+   */
+  extern const char HybridNitroMapComponentName[];
+
+  /**
+   * Props for the "NitroMap" View.
+   */
+  class HybridNitroMapProps final: public react::ViewProps {
+  public:
+    HybridNitroMapProps() = default;
+    HybridNitroMapProps(const HybridNitroMapProps&);
+    HybridNitroMapProps(const react::PropsParserContext& context,
+                        const HybridNitroMapProps& sourceProps,
+                        const react::RawProps& rawProps);
+
+  public:
+    CachedProp<std::optional<MapProvider>> provider;
+    CachedProp<std::optional<Region>> initialRegion;
+    CachedProp<std::optional<bool>> showsUserLocation;
+    CachedProp<std::optional<bool>> zoomEnabled;
+    CachedProp<std::optional<bool>> scrollEnabled;
+    CachedProp<std::optional<bool>> rotateEnabled;
+    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<std::optional<bool>> darkMode;
+    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;
+    CachedProp<std::optional<std::function<void(const RegionChangeEvent& /* region */)>>> onRegionChange;
+    CachedProp<std::optional<std::function<void(const RegionChangeEvent& /* region */)>>> onRegionChangeComplete;
+    CachedProp<std::optional<std::function<void(const MarkerPressEvent& /* event */)>>> onMarkerPress;
+    CachedProp<std::optional<std::function<void(const MarkerDragEvent& /* event */)>>> onMarkerDragStart;
+    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 MapError& /* error */)>>> onError;
+    CachedProp<std::optional<std::function<void(const std::shared_ptr<HybridNitroMapSpec>& /* ref */)>>> hybridRef;
+
+  private:
+    static bool filterObjectKeys(const std::string& propName);
+  };
+
+  /**
+   * State for the "NitroMap" View.
+   */
+  class HybridNitroMapState final {
+  public:
+    HybridNitroMapState() = default;
+
+  public:
+    void setProps(const HybridNitroMapProps& props) { _props.emplace(props); }
+    const std::optional<HybridNitroMapProps>& getProps() const { return _props; }
+
+  public:
+#ifdef ANDROID
+  HybridNitroMapState(const HybridNitroMapState& /* previousState */, folly::dynamic /* data */) {}
+  folly::dynamic getDynamic() const {
+    throw std::runtime_error("HybridNitroMapState does not support folly!");
+  }
+  react::MapBuffer getMapBuffer() const {
+    throw std::runtime_error("HybridNitroMapState does not support MapBuffer!");
+  };
+#endif
+
+  private:
+    std::optional<HybridNitroMapProps> _props;
+  };
+
+  /**
+   * The Shadow Node for the "NitroMap" View.
+   */
+  using HybridNitroMapShadowNode = react::ConcreteViewShadowNode<HybridNitroMapComponentName /* "HybridNitroMap" */,
+                                                                 HybridNitroMapProps /* custom props */,
+                                                                 react::ViewEventEmitter /* default */,
+                                                                 HybridNitroMapState /* custom state */>;
+
+  /**
+   * The Component Descriptor for the "NitroMap" View.
+   */
+  class HybridNitroMapComponentDescriptor final: public react::ConcreteComponentDescriptor<HybridNitroMapShadowNode> {
+  public:
+    HybridNitroMapComponentDescriptor(const react::ComponentDescriptorParameters& parameters);
+
+  public:
+    /**
+     * A faster path for cloning props - reuses the caching logic from `HybridNitroMapProps`.
+     */
+    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 "NitroMap" needs to be implemented in platform-specific code. */
+
+} // namespace margelo::nitro::nitromap::views

package/nitrogen/generated/shared/json/NitroMapConfig.json

@@ -0,0 +1,32 @@
+{
+  "uiViewClassName": "NitroMap",
+  "supportsRawText": false,
+  "bubblingEventTypes": {},
+  "directEventTypes": {},
+  "validAttributes": {
+    "provider": true,
+    "initialRegion": true,
+    "showsUserLocation": true,
+    "zoomEnabled": true,
+    "scrollEnabled": true,
+    "rotateEnabled": true,
+    "pitchEnabled": true,
+    "mapType": true,
+    "customMapStyle": true,
+    "showsMyLocationButton": true,
+    "clusterConfig": true,
+    "darkMode": true,
+    "onPress": true,
+    "onLongPress": true,
+    "onMapReady": true,
+    "onRegionChange": true,
+    "onRegionChangeComplete": true,
+    "onMarkerPress": true,
+    "onMarkerDragStart": true,
+    "onMarkerDrag": true,
+    "onMarkerDragEnd": true,
+    "onClusterPress": true,
+    "onError": true,
+    "hybridRef": true
+  }
+}