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

package/nitrogen/generated/ios/c++/views/HybridRNGoogleMapsPlusViewComponent.mm

@@ -71,61 +71,71 @@ using namespace margelo::nitro::rngooglemapsplus::views;
   // 2. Update each prop individually
   swiftPart.beforeUpdate();
 
-  // buildingEnabled: boolean
+  // initialProps: optional
+  if (newViewProps.initialProps.isDirty) {
+    swiftPart.setInitialProps(newViewProps.initialProps.value);
+    newViewProps.initialProps.isDirty = false;
+  }
+  // buildingEnabled: optional
   if (newViewProps.buildingEnabled.isDirty) {
     swiftPart.setBuildingEnabled(newViewProps.buildingEnabled.value);
     newViewProps.buildingEnabled.isDirty = false;
   }
-  // trafficEnabled: boolean
+  // trafficEnabled: optional
   if (newViewProps.trafficEnabled.isDirty) {
     swiftPart.setTrafficEnabled(newViewProps.trafficEnabled.value);
     newViewProps.trafficEnabled.isDirty = false;
   }
-  // customMapStyle: string
+  // customMapStyle: optional
   if (newViewProps.customMapStyle.isDirty) {
     swiftPart.setCustomMapStyle(newViewProps.customMapStyle.value);
     newViewProps.customMapStyle.isDirty = false;
   }
-  // initialCamera: struct
-  if (newViewProps.initialCamera.isDirty) {
-    swiftPart.setInitialCamera(newViewProps.initialCamera.value);
-    newViewProps.initialCamera.isDirty = false;
-  }
-  // userInterfaceStyle: enum
+  // userInterfaceStyle: optional
   if (newViewProps.userInterfaceStyle.isDirty) {
-    swiftPart.setUserInterfaceStyle(static_cast<int>(newViewProps.userInterfaceStyle.value));
+    swiftPart.setUserInterfaceStyle(newViewProps.userInterfaceStyle.value);
     newViewProps.userInterfaceStyle.isDirty = false;
   }
-  // minZoomLevel: number
+  // minZoomLevel: optional
   if (newViewProps.minZoomLevel.isDirty) {
     swiftPart.setMinZoomLevel(newViewProps.minZoomLevel.value);
     newViewProps.minZoomLevel.isDirty = false;
   }
-  // maxZoomLevel: number
+  // maxZoomLevel: optional
   if (newViewProps.maxZoomLevel.isDirty) {
     swiftPart.setMaxZoomLevel(newViewProps.maxZoomLevel.value);
     newViewProps.maxZoomLevel.isDirty = false;
   }
-  // mapPadding: struct
+  // mapPadding: optional
   if (newViewProps.mapPadding.isDirty) {
     swiftPart.setMapPadding(newViewProps.mapPadding.value);
     newViewProps.mapPadding.isDirty = false;
   }
-  // markers: array
+  // mapType: optional
+  if (newViewProps.mapType.isDirty) {
+    swiftPart.setMapType(newViewProps.mapType.value);
+    newViewProps.mapType.isDirty = false;
+  }
+  // markers: optional
   if (newViewProps.markers.isDirty) {
     swiftPart.setMarkers(newViewProps.markers.value);
     newViewProps.markers.isDirty = false;
   }
-  // polygons: array
+  // polygons: optional
   if (newViewProps.polygons.isDirty) {
     swiftPart.setPolygons(newViewProps.polygons.value);
     newViewProps.polygons.isDirty = false;
   }
-  // polylines: array
+  // polylines: optional
   if (newViewProps.polylines.isDirty) {
     swiftPart.setPolylines(newViewProps.polylines.value);
     newViewProps.polylines.isDirty = false;
   }
+  // circles: optional
+  if (newViewProps.circles.isDirty) {
+    swiftPart.setCircles(newViewProps.circles.value);
+    newViewProps.circles.isDirty = false;
+  }
   // onMapError: optional
   if (newViewProps.onMapError.isDirty) {
     swiftPart.setOnMapError(newViewProps.onMapError.value);
@@ -156,6 +166,21 @@ using namespace margelo::nitro::rngooglemapsplus::views;
     swiftPart.setOnMarkerPress(newViewProps.onMarkerPress.value);
     newViewProps.onMarkerPress.isDirty = false;
   }
+  // onPolylinePress: optional
+  if (newViewProps.onPolylinePress.isDirty) {
+    swiftPart.setOnPolylinePress(newViewProps.onPolylinePress.value);
+    newViewProps.onPolylinePress.isDirty = false;
+  }
+  // onPolygonPress: optional
+  if (newViewProps.onPolygonPress.isDirty) {
+    swiftPart.setOnPolygonPress(newViewProps.onPolygonPress.value);
+    newViewProps.onPolygonPress.isDirty = false;
+  }
+  // onCirclePress: optional
+  if (newViewProps.onCirclePress.isDirty) {
+    swiftPart.setOnCirclePress(newViewProps.onCirclePress.value);
+    newViewProps.onCirclePress.isDirty = false;
+  }
   // onCameraChangeStart: optional
   if (newViewProps.onCameraChangeStart.isDirty) {
     swiftPart.setOnCameraChangeStart(newViewProps.onCameraChangeStart.value);

package/nitrogen/generated/ios/swift/HybridRNGoogleMapsPlusViewSpec.swift

@@ -11,23 +11,28 @@ import NitroModules
 /// See ``HybridRNGoogleMapsPlusViewSpec``
 public protocol HybridRNGoogleMapsPlusViewSpec_protocol: HybridObject, HybridView {
   // Properties
-  var buildingEnabled: Bool { get set }
-  var trafficEnabled: Bool { get set }
-  var customMapStyle: String { get set }
-  var initialCamera: RNCamera { get set }
-  var userInterfaceStyle: RNUserInterfaceStyle { get set }
-  var minZoomLevel: Double { get set }
-  var maxZoomLevel: Double { get set }
-  var mapPadding: RNMapPadding { get set }
-  var markers: [RNMarker] { get set }
-  var polygons: [RNPolygon] { get set }
-  var polylines: [RNPolyline] { get set }
+  var initialProps: RNInitialProps? { get set }
+  var buildingEnabled: Bool? { get set }
+  var trafficEnabled: Bool? { get set }
+  var customMapStyle: String? { get set }
+  var userInterfaceStyle: RNUserInterfaceStyle? { get set }
+  var minZoomLevel: Double? { get set }
+  var maxZoomLevel: Double? { get set }
+  var mapPadding: RNMapPadding? { get set }
+  var mapType: RNMapType? { get set }
+  var markers: [RNMarker]? { get set }
+  var polygons: [RNPolygon]? { get set }
+  var polylines: [RNPolyline]? { get set }
+  var circles: [RNCircle]? { get set }
   var onMapError: ((_ error: RNMapErrorCode) -> Void)? { get set }
   var onMapReady: ((_ ready: Bool) -> Void)? { get set }
   var onLocationUpdate: ((_ location: RNLocation) -> Void)? { get set }
   var onLocationError: ((_ error: RNLocationErrorCode) -> Void)? { get set }
   var onMapPress: ((_ coordinate: RNLatLng) -> Void)? { get set }
   var onMarkerPress: ((_ id: String) -> Void)? { get set }
+  var onPolylinePress: ((_ id: String) -> Void)? { get set }
+  var onPolygonPress: ((_ id: String) -> Void)? { get set }
+  var onCirclePress: ((_ id: String) -> Void)? { get set }
   var onCameraChangeStart: ((_ region: RNRegion, _ camera: RNCamera, _ isGesture: Bool) -> Void)? { get set }
   var onCameraChange: ((_ region: RNRegion, _ camera: RNCamera, _ isGesture: Bool) -> Void)? { get set }
   var onCameraChangeComplete: ((_ region: RNRegion, _ camera: RNCamera, _ isGesture: Bool) -> Void)? { get set }

package/nitrogen/generated/ios/swift/HybridRNGoogleMapsPlusViewSpec_cxx.swift

@@ -106,142 +106,297 @@ open class HybridRNGoogleMapsPlusViewSpec_cxx {
   }
 
   // Properties
-  public final var buildingEnabled: Bool {
+  public final var initialProps: bridge.std__optional_RNInitialProps_ {
     @inline(__always)
     get {
-      return self.__implementation.buildingEnabled
+      return { () -> bridge.std__optional_RNInitialProps_ in
+        if let __unwrappedValue = self.__implementation.initialProps {
+          return bridge.create_std__optional_RNInitialProps_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
     }
     @inline(__always)
     set {
-      self.__implementation.buildingEnabled = newValue
+      self.__implementation.initialProps = { () -> RNInitialProps? in
+        if bridge.has_value_std__optional_RNInitialProps_(newValue) {
+          let __unwrapped = bridge.get_std__optional_RNInitialProps_(newValue)
+          return __unwrapped
+        } else {
+          return nil
+        }
+      }()
     }
   }
   
-  public final var trafficEnabled: Bool {
+  public final var buildingEnabled: bridge.std__optional_bool_ {
     @inline(__always)
     get {
-      return self.__implementation.trafficEnabled
+      return { () -> bridge.std__optional_bool_ in
+        if let __unwrappedValue = self.__implementation.buildingEnabled {
+          return bridge.create_std__optional_bool_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
     }
     @inline(__always)
     set {
-      self.__implementation.trafficEnabled = newValue
+      self.__implementation.buildingEnabled = newValue.value
     }
   }
   
-  public final var customMapStyle: std.string {
+  public final var trafficEnabled: bridge.std__optional_bool_ {
     @inline(__always)
     get {
-      return std.string(self.__implementation.customMapStyle)
+      return { () -> bridge.std__optional_bool_ in
+        if let __unwrappedValue = self.__implementation.trafficEnabled {
+          return bridge.create_std__optional_bool_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
     }
     @inline(__always)
     set {
-      self.__implementation.customMapStyle = String(newValue)
+      self.__implementation.trafficEnabled = newValue.value
     }
   }
   
-  public final var initialCamera: RNCamera {
+  public final var customMapStyle: bridge.std__optional_std__string_ {
     @inline(__always)
     get {
-      return self.__implementation.initialCamera
+      return { () -> bridge.std__optional_std__string_ in
+        if let __unwrappedValue = self.__implementation.customMapStyle {
+          return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
+        } else {
+          return .init()
+        }
+      }()
     }
     @inline(__always)
     set {
-      self.__implementation.initialCamera = newValue
+      self.__implementation.customMapStyle = { () -> String? in
+        if bridge.has_value_std__optional_std__string_(newValue) {
+          let __unwrapped = bridge.get_std__optional_std__string_(newValue)
+          return String(__unwrapped)
+        } else {
+          return nil
+        }
+      }()
     }
   }
   
-  public final var userInterfaceStyle: Int32 {
+  public final var userInterfaceStyle: bridge.std__optional_RNUserInterfaceStyle_ {
     @inline(__always)
     get {
-      return self.__implementation.userInterfaceStyle.rawValue
+      return { () -> bridge.std__optional_RNUserInterfaceStyle_ in
+        if let __unwrappedValue = self.__implementation.userInterfaceStyle {
+          return bridge.create_std__optional_RNUserInterfaceStyle_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
     }
     @inline(__always)
     set {
-      self.__implementation.userInterfaceStyle = margelo.nitro.rngooglemapsplus.RNUserInterfaceStyle(rawValue: newValue)!
+      self.__implementation.userInterfaceStyle = newValue.value
     }
   }
   
-  public final var minZoomLevel: Double {
+  public final var minZoomLevel: bridge.std__optional_double_ {
     @inline(__always)
     get {
-      return self.__implementation.minZoomLevel
+      return { () -> bridge.std__optional_double_ in
+        if let __unwrappedValue = self.__implementation.minZoomLevel {
+          return bridge.create_std__optional_double_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
     }
     @inline(__always)
     set {
-      self.__implementation.minZoomLevel = newValue
+      self.__implementation.minZoomLevel = newValue.value
     }
   }
   
-  public final var maxZoomLevel: Double {
+  public final var maxZoomLevel: bridge.std__optional_double_ {
     @inline(__always)
     get {
-      return self.__implementation.maxZoomLevel
+      return { () -> bridge.std__optional_double_ in
+        if let __unwrappedValue = self.__implementation.maxZoomLevel {
+          return bridge.create_std__optional_double_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.maxZoomLevel = newValue.value
+    }
+  }
+  
+  public final var mapPadding: bridge.std__optional_RNMapPadding_ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_RNMapPadding_ in
+        if let __unwrappedValue = self.__implementation.mapPadding {
+          return bridge.create_std__optional_RNMapPadding_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
     }
     @inline(__always)
     set {
-      self.__implementation.maxZoomLevel = newValue
+      self.__implementation.mapPadding = { () -> RNMapPadding? in
+        if bridge.has_value_std__optional_RNMapPadding_(newValue) {
+          let __unwrapped = bridge.get_std__optional_RNMapPadding_(newValue)
+          return __unwrapped
+        } else {
+          return nil
+        }
+      }()
     }
   }
   
-  public final var mapPadding: RNMapPadding {
+  public final var mapType: bridge.std__optional_RNMapType_ {
     @inline(__always)
     get {
-      return self.__implementation.mapPadding
+      return { () -> bridge.std__optional_RNMapType_ in
+        if let __unwrappedValue = self.__implementation.mapType {
+          return bridge.create_std__optional_RNMapType_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
     }
     @inline(__always)
     set {
-      self.__implementation.mapPadding = newValue
+      self.__implementation.mapType = newValue.value
     }
   }
   
-  public final var markers: bridge.std__vector_RNMarker_ {
+  public final var markers: bridge.std__optional_std__vector_RNMarker__ {
     @inline(__always)
     get {
-      return { () -> bridge.std__vector_RNMarker_ in
-        var __vector = bridge.create_std__vector_RNMarker_(self.__implementation.markers.count)
-        for __item in self.__implementation.markers {
-          __vector.push_back(__item)
+      return { () -> bridge.std__optional_std__vector_RNMarker__ in
+        if let __unwrappedValue = self.__implementation.markers {
+          return bridge.create_std__optional_std__vector_RNMarker__({ () -> bridge.std__vector_RNMarker_ in
+            var __vector = bridge.create_std__vector_RNMarker_(__unwrappedValue.count)
+            for __item in __unwrappedValue {
+              __vector.push_back(__item)
+            }
+            return __vector
+          }())
+        } else {
+          return .init()
         }
-        return __vector
       }()
     }
     @inline(__always)
     set {
-      self.__implementation.markers = newValue.map({ __item in __item })
+      self.__implementation.markers = { () -> [RNMarker]? in
+        if bridge.has_value_std__optional_std__vector_RNMarker__(newValue) {
+          let __unwrapped = bridge.get_std__optional_std__vector_RNMarker__(newValue)
+          return __unwrapped.map({ __item in __item })
+        } else {
+          return nil
+        }
+      }()
     }
   }
   
-  public final var polygons: bridge.std__vector_RNPolygon_ {
+  public final var polygons: bridge.std__optional_std__vector_RNPolygon__ {
     @inline(__always)
     get {
-      return { () -> bridge.std__vector_RNPolygon_ in
-        var __vector = bridge.create_std__vector_RNPolygon_(self.__implementation.polygons.count)
-        for __item in self.__implementation.polygons {
-          __vector.push_back(__item)
+      return { () -> bridge.std__optional_std__vector_RNPolygon__ in
+        if let __unwrappedValue = self.__implementation.polygons {
+          return bridge.create_std__optional_std__vector_RNPolygon__({ () -> bridge.std__vector_RNPolygon_ in
+            var __vector = bridge.create_std__vector_RNPolygon_(__unwrappedValue.count)
+            for __item in __unwrappedValue {
+              __vector.push_back(__item)
+            }
+            return __vector
+          }())
+        } else {
+          return .init()
         }
-        return __vector
       }()
     }
     @inline(__always)
     set {
-      self.__implementation.polygons = newValue.map({ __item in __item })
+      self.__implementation.polygons = { () -> [RNPolygon]? in
+        if bridge.has_value_std__optional_std__vector_RNPolygon__(newValue) {
+          let __unwrapped = bridge.get_std__optional_std__vector_RNPolygon__(newValue)
+          return __unwrapped.map({ __item in __item })
+        } else {
+          return nil
+        }
+      }()
     }
   }
   
-  public final var polylines: bridge.std__vector_RNPolyline_ {
+  public final var polylines: bridge.std__optional_std__vector_RNPolyline__ {
     @inline(__always)
     get {
-      return { () -> bridge.std__vector_RNPolyline_ in
-        var __vector = bridge.create_std__vector_RNPolyline_(self.__implementation.polylines.count)
-        for __item in self.__implementation.polylines {
-          __vector.push_back(__item)
+      return { () -> bridge.std__optional_std__vector_RNPolyline__ in
+        if let __unwrappedValue = self.__implementation.polylines {
+          return bridge.create_std__optional_std__vector_RNPolyline__({ () -> bridge.std__vector_RNPolyline_ in
+            var __vector = bridge.create_std__vector_RNPolyline_(__unwrappedValue.count)
+            for __item in __unwrappedValue {
+              __vector.push_back(__item)
+            }
+            return __vector
+          }())
+        } else {
+          return .init()
         }
-        return __vector
       }()
     }
     @inline(__always)
     set {
-      self.__implementation.polylines = newValue.map({ __item in __item })
+      self.__implementation.polylines = { () -> [RNPolyline]? in
+        if bridge.has_value_std__optional_std__vector_RNPolyline__(newValue) {
+          let __unwrapped = bridge.get_std__optional_std__vector_RNPolyline__(newValue)
+          return __unwrapped.map({ __item in __item })
+        } else {
+          return nil
+        }
+      }()
+    }
+  }
+  
+  public final var circles: bridge.std__optional_std__vector_RNCircle__ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_std__vector_RNCircle__ in
+        if let __unwrappedValue = self.__implementation.circles {
+          return bridge.create_std__optional_std__vector_RNCircle__({ () -> bridge.std__vector_RNCircle_ in
+            var __vector = bridge.create_std__vector_RNCircle_(__unwrappedValue.count)
+            for __item in __unwrappedValue {
+              __vector.push_back(__item)
+            }
+            return __vector
+          }())
+        } else {
+          return .init()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.circles = { () -> [RNCircle]? in
+        if bridge.has_value_std__optional_std__vector_RNCircle__(newValue) {
+          let __unwrapped = bridge.get_std__optional_std__vector_RNCircle__(newValue)
+          return __unwrapped.map({ __item in __item })
+        } else {
+          return nil
+        }
+      }()
     }
   }
   
@@ -437,6 +592,102 @@ open class HybridRNGoogleMapsPlusViewSpec_cxx {
     }
   }
   
+  public final var onPolylinePress: bridge.std__optional_std__function_void_const_std__string_____id______ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_std__function_void_const_std__string_____id______ in
+        if let __unwrappedValue = self.__implementation.onPolylinePress {
+          return bridge.create_std__optional_std__function_void_const_std__string_____id______({ () -> bridge.Func_void_std__string in
+            let __closureWrapper = Func_void_std__string(__unwrappedValue)
+            return bridge.create_Func_void_std__string(__closureWrapper.toUnsafe())
+          }())
+        } else {
+          return .init()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.onPolylinePress = { () -> ((_ id: String) -> Void)? in
+        if bridge.has_value_std__optional_std__function_void_const_std__string_____id______(newValue) {
+          let __unwrapped = bridge.get_std__optional_std__function_void_const_std__string_____id______(newValue)
+          return { () -> (String) -> Void in
+            let __wrappedFunction = bridge.wrap_Func_void_std__string(__unwrapped)
+            return { (__id: String) -> Void in
+              __wrappedFunction.call(std.string(__id))
+            }
+          }()
+        } else {
+          return nil
+        }
+      }()
+    }
+  }
+  
+  public final var onPolygonPress: bridge.std__optional_std__function_void_const_std__string_____id______ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_std__function_void_const_std__string_____id______ in
+        if let __unwrappedValue = self.__implementation.onPolygonPress {
+          return bridge.create_std__optional_std__function_void_const_std__string_____id______({ () -> bridge.Func_void_std__string in
+            let __closureWrapper = Func_void_std__string(__unwrappedValue)
+            return bridge.create_Func_void_std__string(__closureWrapper.toUnsafe())
+          }())
+        } else {
+          return .init()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.onPolygonPress = { () -> ((_ id: String) -> Void)? in
+        if bridge.has_value_std__optional_std__function_void_const_std__string_____id______(newValue) {
+          let __unwrapped = bridge.get_std__optional_std__function_void_const_std__string_____id______(newValue)
+          return { () -> (String) -> Void in
+            let __wrappedFunction = bridge.wrap_Func_void_std__string(__unwrapped)
+            return { (__id: String) -> Void in
+              __wrappedFunction.call(std.string(__id))
+            }
+          }()
+        } else {
+          return nil
+        }
+      }()
+    }
+  }
+  
+  public final var onCirclePress: bridge.std__optional_std__function_void_const_std__string_____id______ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_std__function_void_const_std__string_____id______ in
+        if let __unwrappedValue = self.__implementation.onCirclePress {
+          return bridge.create_std__optional_std__function_void_const_std__string_____id______({ () -> bridge.Func_void_std__string in
+            let __closureWrapper = Func_void_std__string(__unwrappedValue)
+            return bridge.create_Func_void_std__string(__closureWrapper.toUnsafe())
+          }())
+        } else {
+          return .init()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.onCirclePress = { () -> ((_ id: String) -> Void)? in
+        if bridge.has_value_std__optional_std__function_void_const_std__string_____id______(newValue) {
+          let __unwrapped = bridge.get_std__optional_std__function_void_const_std__string_____id______(newValue)
+          return { () -> (String) -> Void in
+            let __wrappedFunction = bridge.wrap_Func_void_std__string(__unwrapped)
+            return { (__id: String) -> Void in
+              __wrappedFunction.call(std.string(__id))
+            }
+          }()
+        } else {
+          return nil
+        }
+      }()
+    }
+  }
+  
   public final var onCameraChangeStart: bridge.std__optional_std__function_void_const_RNRegion_____region_____const_RNCamera_____camera_____bool____isGesture______ {
     @inline(__always)
     get {