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

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

@@ -16,21 +16,26 @@
 #include <react/renderer/components/view/ConcreteViewShadowNode.h>
 #include <react/renderer/components/view/ViewProps.h>
 
+#include "RNInitialProps.hpp"
+#include <optional>
+#include "RNMapUiSettings.hpp"
 #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 "RNLocationConfig.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 +60,32 @@ 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<RNMapUiSettings>> uiSettings;
+    CachedProp<std::optional<bool>> myLocationEnabled;
+    CachedProp<std::optional<bool>> buildingEnabled;
+    CachedProp<std::optional<bool>> trafficEnabled;
+    CachedProp<std::optional<bool>> indoorEnabled;
+    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<RNLocationConfig>> locationConfig;
     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,32 @@
   "bubblingEventTypes": {},
   "directEventTypes": {},
   "validAttributes": {
+    "initialProps": true,
+    "uiSettings": true,
+    "myLocationEnabled": true,
     "buildingEnabled": true,
     "trafficEnabled": true,
+    "indoorEnabled": true,
     "customMapStyle": true,
-    "initialCamera": true,
     "userInterfaceStyle": true,
     "minZoomLevel": true,
     "maxZoomLevel": true,
     "mapPadding": true,
+    "mapType": true,
     "markers": true,
     "polygons": true,
     "polylines": true,
+    "circles": true,
+    "locationConfig": 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.1.0-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,40 @@ import type {
   RNRegion,
   RNLocation,
   RNMapErrorCode,
+  RNMapType,
+  RNInitialProps,
+  RNCircle,
+  RNMapUiSettings,
+  RNLocationConfig,
 } 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;
+  uiSettings?: RNMapUiSettings;
+  myLocationEnabled?: boolean;
+  buildingEnabled?: boolean;
+  trafficEnabled?: boolean;
+  indoorEnabled?: boolean;
+  customMapStyle?: string;
+  userInterfaceStyle?: RNUserInterfaceStyle;
+  minZoomLevel?: number;
+  maxZoomLevel?: number;
+  mapPadding?: RNMapPadding;
+  mapType?: RNMapType;
+  markers?: RNMarker[];
+  polygons?: RNPolygon[];
+  polylines?: RNPolyline[];
+  circles?: RNCircle[];
+  locationConfig?: RNLocationConfig;
   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,26 @@ import type { HybridView } from 'react-native-nitro-modules';
 
 export type GoogleMapsViewRef = HybridView<RNGoogleMapsPlusViewMethods>;
 
+export type RNInitialProps = {
+  mapId?: string;
+  liteMode?: boolean;
+  camera?: RNCamera;
+};
+
+export type RNMapUiSettings = {
+  allGesturesEnabled?: boolean;
+  compassEnabled?: boolean;
+  indoorLevelPickerEnabled?: boolean;
+  mapToolbarEnabled?: boolean;
+  myLocationButtonEnabled?: boolean;
+  rotateEnabled?: boolean;
+  scrollEnabled?: boolean;
+  scrollDuringRotateOrZoomEnabled?: boolean;
+  tiltEnabled?: boolean;
+  zoomControlsEnabled?: boolean;
+  zoomGesturesEnabled?: boolean;
+};
+
 export type RNLatLng = { latitude: number; longitude: number };
 
 export type RNBoundingBox = { northEast: RNLatLng; southWest: RNLatLng };
@@ -14,6 +34,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 +128,7 @@ export type RNLineJoinType = 'miter' | 'round' | 'bevel';
 
 export type RNMarker = {
   id: string;
-  zIndex: number;
+  zIndex?: number;
   coordinate: RNLatLng;
   anchor?: RNPosition;
   width: number;
@@ -116,7 +138,8 @@ export type RNMarker = {
 
 export type RNPolygon = {
   id: string;
-  zIndex: number;
+  zIndex?: number;
+  pressable?: boolean;
   coordinates: RNLatLng[];
   fillColor?: string;
   strokeColor?: string;
@@ -125,7 +148,8 @@ export type RNPolygon = {
 
 export type RNPolyline = {
   id: string;
-  zIndex: number;
+  zIndex?: number;
+  pressable?: boolean;
   coordinates: RNLatLng[];
   lineCap?: RNLineCapType;
   lineJoin?: RNLineJoinType;
@@ -133,6 +157,46 @@ 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 RNLocationConfig = {
+  android?: RNAndroidLocationConfig;
+  ios?: RNIOSLocationConfig;
+};
+export type RNAndroidLocationConfig = {
+  priority?: RNAndroidLocationPriority;
+  interval?: number;
+  minUpdateInterval?: number;
+};
+
+export enum RNAndroidLocationPriority {
+  PRIORITY_HIGH_ACCURACY = 0,
+  PRIORITY_BALANCED_POWER_ACCURACY = 1,
+  PRIORITY_LOW_POWER = 2,
+  PRIORITY_PASSIVE = 3,
+}
+
+export type RNIOSLocationConfig = {
+  desiredAccuracy?: RNIOSLocationAccuracy;
+  distanceFilterMeters?: number;
+};
+
+export enum RNIOSLocationAccuracy {
+  ACCURACY_BEST = 0,
+  ACCURACY_NEAREST_TEN_METER = 1,
+  ACCURACY_NEAREST_HUNDRED_METER = 2,
+  ACCURACY_KILOMETER = 3,
+}
+
 export type RNLocationPermissionResult = {
   android?: RNAndroidLocationPermissionResult;
   ios?: RNIOSPermissionResult;

package/ios/MapPolyline.swift

@@ -1,83 +0,0 @@
-import GoogleMaps
-
-class MapPolylineOptions {
-  func buildPolyline(_ p: RNPolyline) -> GMSPolyline {
-    let path = GMSMutablePath()
-    p.coordinates.forEach {
-      path.add(
-        CLLocationCoordinate2D(latitude: $0.latitude, longitude: $0.longitude)
-      )
-    }
-    let pl = GMSPolyline(path: path)
-    if let w = p.width { pl.strokeWidth = CGFloat(w) }
-    if let c = p.color?.toUIColor() { pl.strokeColor = c }
-    pl.zIndex = Int32(p.zIndex)
-    if let cap = p.lineCap {
-      /// pl.lineCap = mapLineCap(cap)
-    }
-    if let join = p.lineJoin {
-      /// pl.strokeJoin = mapLineJoin(join)
-    }
-    return pl
-  }
-}
-
-func mapLineCap(_ t: RNLineCapType?) -> CGLineCap {
-  switch t {
-  case .round: return .round
-  case .square: return .square
-  default: return .butt
-  }
-}
-
-func mapLineJoin(_ t: RNLineJoinType?) -> CGLineJoin {
-  switch t {
-  case .round: return .round
-  case .bevel: return .bevel
-  default: return .miter
-  }
-}
-
-extension RNPolyline {
-  func updatePolyline(_ next: RNPolyline, _ pl: GMSPolyline) {
-    let path = GMSMutablePath()
-    next.coordinates.forEach {
-      path.add(
-        CLLocationCoordinate2D(
-          latitude: $0.latitude,
-          longitude: $0.longitude
-        )
-      )
-    }
-    pl.path = path
-    if let w = next.width { pl.strokeWidth = CGFloat(w) }
-    if let cap = next.lineCap {
-      pl.spans = nil
-      /// gms.lineCap = mapLineCap(cap)
-    }
-    if let join = next.lineJoin {
-      /// gms.strokeJoin = mapLineJoin(join)
-    }
-    if let c = next.color?.toUIColor() {
-      pl.strokeColor = c
-    }
-    pl.zIndex = Int32(next.zIndex)
-  }
-
-  func polylineEquals(_ b: RNPolyline) -> Bool {
-    guard zIndex == b.zIndex,
-      (width ?? 0) == (b.width ?? 0),
-      lineCap == b.lineCap,
-      lineJoin == b.lineJoin,
-      color == b.color,
-      coordinates.count == b.coordinates.count
-    else { return false }
-    for i in 0..<coordinates.count {
-      if coordinates[i].latitude != b.coordinates[i].latitude
-        || coordinates[i].longitude != b.coordinates[i].longitude {
-        return false
-      }
-    }
-    return true
-  }
-}