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

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

@@ -106,142 +106,379 @@ 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 uiSettings: bridge.std__optional_RNMapUiSettings_ {
     @inline(__always)
     get {
-      return self.__implementation.trafficEnabled
+      return { () -> bridge.std__optional_RNMapUiSettings_ in
+        if let __unwrappedValue = self.__implementation.uiSettings {
+          return bridge.create_std__optional_RNMapUiSettings_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
     }
     @inline(__always)
     set {
-      self.__implementation.trafficEnabled = newValue
+      self.__implementation.uiSettings = { () -> RNMapUiSettings? in
+        if bridge.has_value_std__optional_RNMapUiSettings_(newValue) {
+          let __unwrapped = bridge.get_std__optional_RNMapUiSettings_(newValue)
+          return __unwrapped
+        } else {
+          return nil
+        }
+      }()
     }
   }
   
-  public final var customMapStyle: std.string {
+  public final var myLocationEnabled: bridge.std__optional_bool_ {
     @inline(__always)
     get {
-      return std.string(self.__implementation.customMapStyle)
+      return { () -> bridge.std__optional_bool_ in
+        if let __unwrappedValue = self.__implementation.myLocationEnabled {
+          return bridge.create_std__optional_bool_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
     }
     @inline(__always)
     set {
-      self.__implementation.customMapStyle = String(newValue)
+      self.__implementation.myLocationEnabled = newValue.value
     }
   }
   
-  public final var initialCamera: RNCamera {
+  public final var buildingEnabled: bridge.std__optional_bool_ {
     @inline(__always)
     get {
-      return self.__implementation.initialCamera
+      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.initialCamera = newValue
+      self.__implementation.buildingEnabled = newValue.value
     }
   }
   
-  public final var userInterfaceStyle: Int32 {
+  public final var trafficEnabled: bridge.std__optional_bool_ {
     @inline(__always)
     get {
-      return self.__implementation.userInterfaceStyle.rawValue
+      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.userInterfaceStyle = margelo.nitro.rngooglemapsplus.RNUserInterfaceStyle(rawValue: newValue)!
+      self.__implementation.trafficEnabled = newValue.value
     }
   }
   
-  public final var minZoomLevel: Double {
+  public final var indoorEnabled: bridge.std__optional_bool_ {
     @inline(__always)
     get {
-      return self.__implementation.minZoomLevel
+      return { () -> bridge.std__optional_bool_ in
+        if let __unwrappedValue = self.__implementation.indoorEnabled {
+          return bridge.create_std__optional_bool_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
     }
     @inline(__always)
     set {
-      self.__implementation.minZoomLevel = newValue
+      self.__implementation.indoorEnabled = newValue.value
     }
   }
   
-  public final var maxZoomLevel: Double {
+  public final var customMapStyle: bridge.std__optional_std__string_ {
     @inline(__always)
     get {
-      return self.__implementation.maxZoomLevel
+      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.maxZoomLevel = 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 mapPadding: RNMapPadding {
+  public final var userInterfaceStyle: bridge.std__optional_RNUserInterfaceStyle_ {
     @inline(__always)
     get {
-      return self.__implementation.mapPadding
+      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.mapPadding = newValue
+      self.__implementation.userInterfaceStyle = newValue.value
     }
   }
   
-  public final var markers: bridge.std__vector_RNMarker_ {
+  public final var minZoomLevel: bridge.std__optional_double_ {
     @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_double_ in
+        if let __unwrappedValue = self.__implementation.minZoomLevel {
+          return bridge.create_std__optional_double_(__unwrappedValue)
+        } else {
+          return .init()
         }
-        return __vector
       }()
     }
     @inline(__always)
     set {
-      self.__implementation.markers = newValue.map({ __item in __item })
+      self.__implementation.minZoomLevel = newValue.value
     }
   }
   
-  public final var polygons: bridge.std__vector_RNPolygon_ {
+  public final var maxZoomLevel: bridge.std__optional_double_ {
     @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_double_ in
+        if let __unwrappedValue = self.__implementation.maxZoomLevel {
+          return bridge.create_std__optional_double_(__unwrappedValue)
+        } else {
+          return .init()
         }
-        return __vector
       }()
     }
     @inline(__always)
     set {
-      self.__implementation.polygons = newValue.map({ __item in __item })
+      self.__implementation.maxZoomLevel = newValue.value
     }
   }
   
-  public final var polylines: bridge.std__vector_RNPolyline_ {
+  public final var mapPadding: bridge.std__optional_RNMapPadding_ {
     @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_RNMapPadding_ in
+        if let __unwrappedValue = self.__implementation.mapPadding {
+          return bridge.create_std__optional_RNMapPadding_(__unwrappedValue)
+        } else {
+          return .init()
         }
-        return __vector
       }()
     }
     @inline(__always)
     set {
-      self.__implementation.polylines = newValue.map({ __item in __item })
+      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 mapType: bridge.std__optional_RNMapType_ {
+    @inline(__always)
+    get {
+      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.mapType = newValue.value
+    }
+  }
+  
+  public final var markers: bridge.std__optional_std__vector_RNMarker__ {
+    @inline(__always)
+    get {
+      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()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      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__optional_std__vector_RNPolygon__ {
+    @inline(__always)
+    get {
+      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()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      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__optional_std__vector_RNPolyline__ {
+    @inline(__always)
+    get {
+      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()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      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
+        }
+      }()
+    }
+  }
+  
+  public final var locationConfig: bridge.std__optional_RNLocationConfig_ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_RNLocationConfig_ in
+        if let __unwrappedValue = self.__implementation.locationConfig {
+          return bridge.create_std__optional_RNLocationConfig_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.locationConfig = { () -> RNLocationConfig? in
+        if bridge.has_value_std__optional_RNLocationConfig_(newValue) {
+          let __unwrapped = bridge.get_std__optional_RNLocationConfig_(newValue)
+          return __unwrapped
+        } else {
+          return nil
+        }
+      }()
     }
   }
   
@@ -437,6 +674,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 {

package/nitrogen/generated/ios/swift/RNAndroidLocationConfig.swift

@@ -0,0 +1,93 @@
+///
+/// RNAndroidLocationConfig.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+/**
+ * Represents an instance of `RNAndroidLocationConfig`, backed by a C++ struct.
+ */
+public typealias RNAndroidLocationConfig = margelo.nitro.rngooglemapsplus.RNAndroidLocationConfig
+
+public extension RNAndroidLocationConfig {
+  private typealias bridge = margelo.nitro.rngooglemapsplus.bridge.swift
+
+  /**
+   * Create a new instance of `RNAndroidLocationConfig`.
+   */
+  init(priority: RNAndroidLocationPriority?, interval: Double?, minUpdateInterval: Double?) {
+    self.init({ () -> bridge.std__optional_RNAndroidLocationPriority_ in
+      if let __unwrappedValue = priority {
+        return bridge.create_std__optional_RNAndroidLocationPriority_(__unwrappedValue)
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_double_ in
+      if let __unwrappedValue = interval {
+        return bridge.create_std__optional_double_(__unwrappedValue)
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_double_ in
+      if let __unwrappedValue = minUpdateInterval {
+        return bridge.create_std__optional_double_(__unwrappedValue)
+      } else {
+        return .init()
+      }
+    }())
+  }
+
+  var priority: RNAndroidLocationPriority? {
+    @inline(__always)
+    get {
+      return self.__priority.has_value() ? self.__priority.pointee : nil
+    }
+    @inline(__always)
+    set {
+      self.__priority = { () -> bridge.std__optional_RNAndroidLocationPriority_ in
+        if let __unwrappedValue = newValue {
+          return bridge.create_std__optional_RNAndroidLocationPriority_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+    }
+  }
+  
+  var interval: Double? {
+    @inline(__always)
+    get {
+      return self.__interval.value
+    }
+    @inline(__always)
+    set {
+      self.__interval = { () -> bridge.std__optional_double_ in
+        if let __unwrappedValue = newValue {
+          return bridge.create_std__optional_double_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+    }
+  }
+  
+  var minUpdateInterval: Double? {
+    @inline(__always)
+    get {
+      return self.__minUpdateInterval.value
+    }
+    @inline(__always)
+    set {
+      self.__minUpdateInterval = { () -> bridge.std__optional_double_ in
+        if let __unwrappedValue = newValue {
+          return bridge.create_std__optional_double_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+    }
+  }
+}

package/nitrogen/generated/ios/swift/RNAndroidLocationPriority.swift

@@ -0,0 +1,48 @@
+///
+/// RNAndroidLocationPriority.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+/**
+ * Represents the JS enum `RNAndroidLocationPriority`, backed by a C++ enum.
+ */
+public typealias RNAndroidLocationPriority = margelo.nitro.rngooglemapsplus.RNAndroidLocationPriority
+
+public extension RNAndroidLocationPriority {
+  /**
+   * Get a RNAndroidLocationPriority for the given String value, or
+   * return `nil` if the given value was invalid/unknown.
+   */
+  init?(fromString string: String) {
+    switch string {
+      case "PRIORITY_HIGH_ACCURACY":
+        self = .priorityHighAccuracy
+      case "PRIORITY_BALANCED_POWER_ACCURACY":
+        self = .priorityBalancedPowerAccuracy
+      case "PRIORITY_LOW_POWER":
+        self = .priorityLowPower
+      case "PRIORITY_PASSIVE":
+        self = .priorityPassive
+      default:
+        return nil
+    }
+  }
+
+  /**
+   * Get the String value this RNAndroidLocationPriority represents.
+   */
+  var stringValue: String {
+    switch self {
+      case .priorityHighAccuracy:
+        return "PRIORITY_HIGH_ACCURACY"
+      case .priorityBalancedPowerAccuracy:
+        return "PRIORITY_BALANCED_POWER_ACCURACY"
+      case .priorityLowPower:
+        return "PRIORITY_LOW_POWER"
+      case .priorityPassive:
+        return "PRIORITY_PASSIVE"
+    }
+  }
+}