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

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

@@ -25,116 +25,136 @@ namespace margelo::nitro::rngooglemapsplus::views {
                                                                    const HybridRNGoogleMapsPlusViewProps& sourceProps,
                                                                    const react::RawProps& rawProps):
     react::ViewProps(context, sourceProps, rawProps, filterObjectKeys),
-    buildingEnabled([&]() -> CachedProp<bool> {
+    initialProps([&]() -> CachedProp<std::optional<RNInitialProps>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("initialProps", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.initialProps;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<RNInitialProps>>::fromRawValue(*runtime, value, sourceProps.initialProps);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("RNGoogleMapsPlusView.initialProps: ") + exc.what());
+      }
+    }()),
+    buildingEnabled([&]() -> CachedProp<std::optional<bool>> {
       try {
         const react::RawValue* rawValue = rawProps.at("buildingEnabled", nullptr, nullptr);
         if (rawValue == nullptr) return sourceProps.buildingEnabled;
         const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
-        return CachedProp<bool>::fromRawValue(*runtime, value, sourceProps.buildingEnabled);
+        return CachedProp<std::optional<bool>>::fromRawValue(*runtime, value, sourceProps.buildingEnabled);
       } catch (const std::exception& exc) {
         throw std::runtime_error(std::string("RNGoogleMapsPlusView.buildingEnabled: ") + exc.what());
       }
     }()),
-    trafficEnabled([&]() -> CachedProp<bool> {
+    trafficEnabled([&]() -> CachedProp<std::optional<bool>> {
       try {
         const react::RawValue* rawValue = rawProps.at("trafficEnabled", nullptr, nullptr);
         if (rawValue == nullptr) return sourceProps.trafficEnabled;
         const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
-        return CachedProp<bool>::fromRawValue(*runtime, value, sourceProps.trafficEnabled);
+        return CachedProp<std::optional<bool>>::fromRawValue(*runtime, value, sourceProps.trafficEnabled);
       } catch (const std::exception& exc) {
         throw std::runtime_error(std::string("RNGoogleMapsPlusView.trafficEnabled: ") + exc.what());
       }
     }()),
-    customMapStyle([&]() -> CachedProp<std::string> {
+    customMapStyle([&]() -> CachedProp<std::optional<std::string>> {
       try {
         const react::RawValue* rawValue = rawProps.at("customMapStyle", nullptr, nullptr);
         if (rawValue == nullptr) return sourceProps.customMapStyle;
         const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
-        return CachedProp<std::string>::fromRawValue(*runtime, value, sourceProps.customMapStyle);
+        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());
       }
     }()),
-    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("RNGoogleMapsPlusView.initialCamera: ") + exc.what());
-      }
-    }()),
-    userInterfaceStyle([&]() -> CachedProp<RNUserInterfaceStyle> {
+    userInterfaceStyle([&]() -> CachedProp<std::optional<RNUserInterfaceStyle>> {
       try {
         const react::RawValue* rawValue = rawProps.at("userInterfaceStyle", nullptr, nullptr);
         if (rawValue == nullptr) return sourceProps.userInterfaceStyle;
         const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
-        return CachedProp<RNUserInterfaceStyle>::fromRawValue(*runtime, value, sourceProps.userInterfaceStyle);
+        return CachedProp<std::optional<RNUserInterfaceStyle>>::fromRawValue(*runtime, value, sourceProps.userInterfaceStyle);
       } catch (const std::exception& exc) {
         throw std::runtime_error(std::string("RNGoogleMapsPlusView.userInterfaceStyle: ") + exc.what());
       }
     }()),
-    minZoomLevel([&]() -> CachedProp<double> {
+    minZoomLevel([&]() -> CachedProp<std::optional<double>> {
       try {
         const react::RawValue* rawValue = rawProps.at("minZoomLevel", nullptr, nullptr);
         if (rawValue == nullptr) return sourceProps.minZoomLevel;
         const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
-        return CachedProp<double>::fromRawValue(*runtime, value, sourceProps.minZoomLevel);
+        return CachedProp<std::optional<double>>::fromRawValue(*runtime, value, sourceProps.minZoomLevel);
       } catch (const std::exception& exc) {
         throw std::runtime_error(std::string("RNGoogleMapsPlusView.minZoomLevel: ") + exc.what());
       }
     }()),
-    maxZoomLevel([&]() -> CachedProp<double> {
+    maxZoomLevel([&]() -> CachedProp<std::optional<double>> {
       try {
         const react::RawValue* rawValue = rawProps.at("maxZoomLevel", nullptr, nullptr);
         if (rawValue == nullptr) return sourceProps.maxZoomLevel;
         const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
-        return CachedProp<double>::fromRawValue(*runtime, value, sourceProps.maxZoomLevel);
+        return CachedProp<std::optional<double>>::fromRawValue(*runtime, value, sourceProps.maxZoomLevel);
       } catch (const std::exception& exc) {
         throw std::runtime_error(std::string("RNGoogleMapsPlusView.maxZoomLevel: ") + exc.what());
       }
     }()),
-    mapPadding([&]() -> CachedProp<RNMapPadding> {
+    mapPadding([&]() -> CachedProp<std::optional<RNMapPadding>> {
       try {
         const react::RawValue* rawValue = rawProps.at("mapPadding", nullptr, nullptr);
         if (rawValue == nullptr) return sourceProps.mapPadding;
         const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
-        return CachedProp<RNMapPadding>::fromRawValue(*runtime, value, sourceProps.mapPadding);
+        return CachedProp<std::optional<RNMapPadding>>::fromRawValue(*runtime, value, sourceProps.mapPadding);
       } catch (const std::exception& exc) {
         throw std::runtime_error(std::string("RNGoogleMapsPlusView.mapPadding: ") + exc.what());
       }
     }()),
-    markers([&]() -> CachedProp<std::vector<RNMarker>> {
+    mapType([&]() -> CachedProp<std::optional<RNMapType>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("mapType", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.mapType;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<RNMapType>>::fromRawValue(*runtime, value, sourceProps.mapType);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("RNGoogleMapsPlusView.mapType: ") + exc.what());
+      }
+    }()),
+    markers([&]() -> CachedProp<std::optional<std::vector<RNMarker>>> {
       try {
         const react::RawValue* rawValue = rawProps.at("markers", nullptr, nullptr);
         if (rawValue == nullptr) return sourceProps.markers;
         const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
-        return CachedProp<std::vector<RNMarker>>::fromRawValue(*runtime, value, sourceProps.markers);
+        return CachedProp<std::optional<std::vector<RNMarker>>>::fromRawValue(*runtime, value, sourceProps.markers);
       } catch (const std::exception& exc) {
         throw std::runtime_error(std::string("RNGoogleMapsPlusView.markers: ") + exc.what());
       }
     }()),
-    polygons([&]() -> CachedProp<std::vector<RNPolygon>> {
+    polygons([&]() -> CachedProp<std::optional<std::vector<RNPolygon>>> {
       try {
         const react::RawValue* rawValue = rawProps.at("polygons", nullptr, nullptr);
         if (rawValue == nullptr) return sourceProps.polygons;
         const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
-        return CachedProp<std::vector<RNPolygon>>::fromRawValue(*runtime, value, sourceProps.polygons);
+        return CachedProp<std::optional<std::vector<RNPolygon>>>::fromRawValue(*runtime, value, sourceProps.polygons);
       } catch (const std::exception& exc) {
         throw std::runtime_error(std::string("RNGoogleMapsPlusView.polygons: ") + exc.what());
       }
     }()),
-    polylines([&]() -> CachedProp<std::vector<RNPolyline>> {
+    polylines([&]() -> CachedProp<std::optional<std::vector<RNPolyline>>> {
       try {
         const react::RawValue* rawValue = rawProps.at("polylines", nullptr, nullptr);
         if (rawValue == nullptr) return sourceProps.polylines;
         const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
-        return CachedProp<std::vector<RNPolyline>>::fromRawValue(*runtime, value, sourceProps.polylines);
+        return CachedProp<std::optional<std::vector<RNPolyline>>>::fromRawValue(*runtime, value, sourceProps.polylines);
       } catch (const std::exception& exc) {
         throw std::runtime_error(std::string("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);
@@ -195,6 +215,36 @@ namespace margelo::nitro::rngooglemapsplus::views {
         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);
@@ -238,23 +288,28 @@ namespace margelo::nitro::rngooglemapsplus::views {
 
   HybridRNGoogleMapsPlusViewProps::HybridRNGoogleMapsPlusViewProps(const HybridRNGoogleMapsPlusViewProps& other):
     react::ViewProps(),
+    initialProps(other.initialProps),
     buildingEnabled(other.buildingEnabled),
     trafficEnabled(other.trafficEnabled),
     customMapStyle(other.customMapStyle),
-    initialCamera(other.initialCamera),
     userInterfaceStyle(other.userInterfaceStyle),
     minZoomLevel(other.minZoomLevel),
     maxZoomLevel(other.maxZoomLevel),
     mapPadding(other.mapPadding),
+    mapType(other.mapType),
     markers(other.markers),
     polygons(other.polygons),
     polylines(other.polylines),
+    circles(other.circles),
     onMapError(other.onMapError),
     onMapReady(other.onMapReady),
     onLocationUpdate(other.onLocationUpdate),
     onLocationError(other.onLocationError),
     onMapPress(other.onMapPress),
     onMarkerPress(other.onMarkerPress),
+    onPolylinePress(other.onPolylinePress),
+    onPolygonPress(other.onPolygonPress),
+    onCirclePress(other.onCirclePress),
     onCameraChangeStart(other.onCameraChangeStart),
     onCameraChange(other.onCameraChange),
     onCameraChangeComplete(other.onCameraChangeComplete),
@@ -262,23 +317,28 @@ namespace margelo::nitro::rngooglemapsplus::views {
 
   bool HybridRNGoogleMapsPlusViewProps::filterObjectKeys(const std::string& propName) {
     switch (hashString(propName)) {
+      case hashString("initialProps"): return true;
       case hashString("buildingEnabled"): return true;
       case hashString("trafficEnabled"): return true;
       case hashString("customMapStyle"): return true;
-      case hashString("initialCamera"): return true;
       case hashString("userInterfaceStyle"): return true;
       case hashString("minZoomLevel"): return true;
       case hashString("maxZoomLevel"): return true;
       case hashString("mapPadding"): return true;
+      case hashString("mapType"): return true;
       case hashString("markers"): return true;
       case hashString("polygons"): return true;
       case hashString("polylines"): return true;
+      case hashString("circles"): return true;
       case hashString("onMapError"): return true;
       case hashString("onMapReady"): return true;
       case hashString("onLocationUpdate"): return true;
       case hashString("onLocationError"): return true;
       case hashString("onMapPress"): return true;
       case hashString("onMarkerPress"): return true;
+      case hashString("onPolylinePress"): return true;
+      case hashString("onPolygonPress"): return true;
+      case hashString("onCirclePress"): return true;
       case hashString("onCameraChangeStart"): return true;
       case hashString("onCameraChange"): return true;
       case hashString("onCameraChangeComplete"): return true;

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

@@ -16,21 +16,24 @@
 #include <react/renderer/components/view/ConcreteViewShadowNode.h>
 #include <react/renderer/components/view/ViewProps.h>
 
+#include "RNInitialProps.hpp"
+#include <optional>
 #include <string>
-#include "RNCamera.hpp"
 #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 <optional>
 #include "RNLocation.hpp"
 #include "RNLocationErrorCode.hpp"
 #include "RNLatLng.hpp"
 #include "RNRegion.hpp"
+#include "RNCamera.hpp"
 #include <memory>
 #include "HybridRNGoogleMapsPlusViewSpec.hpp"
 
@@ -55,23 +58,28 @@ namespace margelo::nitro::rngooglemapsplus::views {
                                     const react::RawProps& rawProps);
 
   public:
-    CachedProp<bool> buildingEnabled;
-    CachedProp<bool> trafficEnabled;
-    CachedProp<std::string> customMapStyle;
-    CachedProp<RNCamera> initialCamera;
-    CachedProp<RNUserInterfaceStyle> userInterfaceStyle;
-    CachedProp<double> minZoomLevel;
-    CachedProp<double> maxZoomLevel;
-    CachedProp<RNMapPadding> mapPadding;
-    CachedProp<std::vector<RNMarker>> markers;
-    CachedProp<std::vector<RNPolygon>> polygons;
-    CachedProp<std::vector<RNPolyline>> polylines;
+    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;

package/nitrogen/generated/shared/json/RNGoogleMapsPlusViewConfig.json

@@ -4,23 +4,28 @@
   "bubblingEventTypes": {},
   "directEventTypes": {},
   "validAttributes": {
+    "initialProps": true,
     "buildingEnabled": true,
     "trafficEnabled": true,
     "customMapStyle": true,
-    "initialCamera": true,
     "userInterfaceStyle": true,
     "minZoomLevel": true,
     "maxZoomLevel": true,
     "mapPadding": true,
+    "mapType": true,
     "markers": true,
     "polygons": true,
     "polylines": true,
+    "circles": true,
     "onMapError": true,
     "onMapReady": true,
     "onLocationUpdate": true,
     "onLocationError": true,
     "onMapPress": true,
     "onMarkerPress": true,
+    "onPolylinePress": true,
+    "onPolygonPress": true,
+    "onCirclePress": true,
     "onCameraChangeStart": true,
     "onCameraChange": true,
     "onCameraChangeComplete": true,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-google-maps-plus",
-  "version": "1.0.2",
+  "version": "1.0.3-dev.1",
   "description": "React-native wrapper for android & IOS google maps sdk",
   "main": "./lib/module/index.js",
   "module": "./lib/module/index.js",
@@ -11,17 +11,17 @@
     "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 nitrogen && bob build",
-    "nitrogen": "nitrogen --logLevel=\"debug\" && node scripts/post-script.js",
+    "nitrogen": "nitrogen --logLevel=\"debug\" && node scripts/nitrogen-patch.js",
     "prepare": "bob build"
   },
   "keywords": [

package/src/RNGoogleMapsPlusView.nitro.ts

@@ -16,26 +16,34 @@ import type {
   RNRegion,
   RNLocation,
   RNMapErrorCode,
+  RNMapType,
+  RNInitialProps,
+  RNCircle,
 } from './types';
 
 export interface RNGoogleMapsPlusViewProps extends HybridViewProps {
-  buildingEnabled: boolean;
-  trafficEnabled: boolean;
-  customMapStyle: string;
-  initialCamera: RNCamera;
-  userInterfaceStyle: RNUserInterfaceStyle;
-  minZoomLevel: number;
-  maxZoomLevel: number;
-  mapPadding: RNMapPadding;
-  markers: RNMarker[];
-  polygons: RNPolygon[];
-  polylines: RNPolyline[];
+  initialProps?: RNInitialProps;
+  buildingEnabled?: boolean;
+  trafficEnabled?: boolean;
+  customMapStyle?: string;
+  userInterfaceStyle?: RNUserInterfaceStyle;
+  minZoomLevel?: number;
+  maxZoomLevel?: number;
+  mapPadding?: RNMapPadding;
+  mapType?: RNMapType;
+  markers?: RNMarker[];
+  polygons?: RNPolygon[];
+  polylines?: RNPolyline[];
+  circles?: RNCircle[];
   onMapError?: (error: RNMapErrorCode) => void;
   onMapReady?: (ready: boolean) => void;
   onLocationUpdate?: (location: RNLocation) => void;
   onLocationError?: (error: RNLocationErrorCode) => void;
   onMapPress?: (coordinate: RNLatLng) => void;
   onMarkerPress?: (id: string) => void;
+  onPolylinePress?: (id: string) => void;
+  onPolygonPress?: (id: string) => void;
+  onCirclePress?: (id: string) => void;
   onCameraChangeStart?: (
     region: RNRegion,
     camera: RNCamera,

package/src/types.ts

@@ -3,6 +3,12 @@ import type { HybridView } from 'react-native-nitro-modules';
 
 export type GoogleMapsViewRef = HybridView<RNGoogleMapsPlusViewMethods>;
 
+export type RNInitialProps = {
+  mapId?: string;
+  liteMode?: boolean;
+  initialCamera?: RNCamera;
+};
+
 export type RNLatLng = { latitude: number; longitude: number };
 
 export type RNBoundingBox = { northEast: RNLatLng; southWest: RNLatLng };
@@ -14,6 +20,8 @@ export type RNMapPadding = {
   right: number;
 };
 
+export type RNMapType = 'none' | 'normal' | 'hybrid' | 'satellite' | 'terrain';
+
 export type RNUserInterfaceStyle = 'light' | 'dark' | 'default';
 
 export type RNFeatureType = string;
@@ -106,7 +114,7 @@ export type RNLineJoinType = 'miter' | 'round' | 'bevel';
 
 export type RNMarker = {
   id: string;
-  zIndex: number;
+  zIndex?: number;
   coordinate: RNLatLng;
   anchor?: RNPosition;
   width: number;
@@ -116,7 +124,8 @@ export type RNMarker = {
 
 export type RNPolygon = {
   id: string;
-  zIndex: number;
+  zIndex?: number;
+  pressable?: boolean;
   coordinates: RNLatLng[];
   fillColor?: string;
   strokeColor?: string;
@@ -125,7 +134,8 @@ export type RNPolygon = {
 
 export type RNPolyline = {
   id: string;
-  zIndex: number;
+  zIndex?: number;
+  pressable?: boolean;
   coordinates: RNLatLng[];
   lineCap?: RNLineCapType;
   lineJoin?: RNLineJoinType;
@@ -133,6 +143,17 @@ export type RNPolyline = {
   width?: number;
 };
 
+export type RNCircle = {
+  id: string;
+  pressable?: boolean;
+  zIndex?: number;
+  center: RNLatLng;
+  radius?: number;
+  strokeWidth?: number;
+  strokeColor?: string;
+  fillColor?: string;
+};
+
 export type RNLocationPermissionResult = {
   android?: RNAndroidLocationPermissionResult;
   ios?: RNIOSPermissionResult;