@maydon_tech/react-native-nitro-maps 0.1.4 → 0.2.0

package/nitrogen/generated/ios/swift/HybridNitroMapSpec_cxx.swift

@@ -148,6 +148,23 @@ open class HybridNitroMapSpec_cxx {
     }
   }
   
+  public final var region: bridge.std__optional_Region_ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_Region_ in
+        if let __unwrappedValue = self.__implementation.region {
+          return bridge.create_std__optional_Region_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.region = newValue.value
+    }
+  }
+  
   public final var showsUserLocation: bridge.std__optional_bool_ {
     @inline(__always)
     get {
@@ -315,11 +332,39 @@ open class HybridNitroMapSpec_cxx {
     }
   }
   
-  public final var showsMyLocationButton: bridge.std__optional_bool_ {
+  public final var clusterConfig: bridge.std__optional_ClusterConfig_ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_ClusterConfig_ in
+        if let __unwrappedValue = self.__implementation.clusterConfig {
+          return bridge.create_std__optional_ClusterConfig_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.clusterConfig = newValue.value
+    }
+  }
+  
+  public final var mapPadding: EdgePadding {
+    @inline(__always)
+    get {
+      return self.__implementation.mapPadding
+    }
+    @inline(__always)
+    set {
+      self.__implementation.mapPadding = newValue
+    }
+  }
+  
+  public final var showsTraffic: bridge.std__optional_bool_ {
     @inline(__always)
     get {
       return { () -> bridge.std__optional_bool_ in
-        if let __unwrappedValue = self.__implementation.showsMyLocationButton {
+        if let __unwrappedValue = self.__implementation.showsTraffic {
           return bridge.create_std__optional_bool_(__unwrappedValue)
         } else {
           return .init()
@@ -328,7 +373,7 @@ open class HybridNitroMapSpec_cxx {
     }
     @inline(__always)
     set {
-      self.__implementation.showsMyLocationButton = { () -> Bool? in
+      self.__implementation.showsTraffic = { () -> Bool? in
         if bridge.has_value_std__optional_bool_(newValue) {
           let __unwrapped = bridge.get_std__optional_bool_(newValue)
           return __unwrapped
@@ -339,12 +384,12 @@ open class HybridNitroMapSpec_cxx {
     }
   }
   
-  public final var clusterConfig: bridge.std__optional_ClusterConfig_ {
+  public final var showsBuildings: bridge.std__optional_bool_ {
     @inline(__always)
     get {
-      return { () -> bridge.std__optional_ClusterConfig_ in
-        if let __unwrappedValue = self.__implementation.clusterConfig {
-          return bridge.create_std__optional_ClusterConfig_(__unwrappedValue)
+      return { () -> bridge.std__optional_bool_ in
+        if let __unwrappedValue = self.__implementation.showsBuildings {
+          return bridge.create_std__optional_bool_(__unwrappedValue)
         } else {
           return .init()
         }
@@ -352,7 +397,60 @@ open class HybridNitroMapSpec_cxx {
     }
     @inline(__always)
     set {
-      self.__implementation.clusterConfig = newValue.value
+      self.__implementation.showsBuildings = { () -> Bool? in
+        if bridge.has_value_std__optional_bool_(newValue) {
+          let __unwrapped = bridge.get_std__optional_bool_(newValue)
+          return __unwrapped
+        } else {
+          return nil
+        }
+      }()
+    }
+  }
+  
+  public final var showsCompass: bridge.std__optional_bool_ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_bool_ in
+        if let __unwrappedValue = self.__implementation.showsCompass {
+          return bridge.create_std__optional_bool_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.showsCompass = { () -> Bool? in
+        if bridge.has_value_std__optional_bool_(newValue) {
+          let __unwrapped = bridge.get_std__optional_bool_(newValue)
+          return __unwrapped
+        } else {
+          return nil
+        }
+      }()
+    }
+  }
+  
+  public final var minZoom: Double {
+    @inline(__always)
+    get {
+      return self.__implementation.minZoom
+    }
+    @inline(__always)
+    set {
+      self.__implementation.minZoom = newValue
+    }
+  }
+  
+  public final var maxZoom: Double {
+    @inline(__always)
+    get {
+      return self.__implementation.maxZoom
+    }
+    @inline(__always)
+    set {
+      self.__implementation.maxZoom = newValue
     }
   }
   
@@ -380,6 +478,62 @@ open class HybridNitroMapSpec_cxx {
     }
   }
   
+  public final var userTrackingMode: bridge.std__optional_UserTrackingMode_ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_UserTrackingMode_ in
+        if let __unwrappedValue = self.__implementation.userTrackingMode {
+          return bridge.create_std__optional_UserTrackingMode_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.userTrackingMode = newValue.value
+    }
+  }
+  
+  public final var userLocationImage: std.string {
+    @inline(__always)
+    get {
+      return std.string(self.__implementation.userLocationImage)
+    }
+    @inline(__always)
+    set {
+      self.__implementation.userLocationImage = String(newValue)
+    }
+  }
+  
+  public final var userLocationSize: Double {
+    @inline(__always)
+    get {
+      return self.__implementation.userLocationSize
+    }
+    @inline(__always)
+    set {
+      self.__implementation.userLocationSize = newValue
+    }
+  }
+  
+  public final var userLocationAnchor: bridge.std__optional_Point_ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_Point_ in
+        if let __unwrappedValue = self.__implementation.userLocationAnchor {
+          return bridge.create_std__optional_Point_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.userLocationAnchor = newValue.value
+    }
+  }
+  
   public final var onPress: bridge.std__optional_std__function_void_const_MapPressEvent_____event______ {
     @inline(__always)
     get {
@@ -700,6 +854,102 @@ open class HybridNitroMapSpec_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 onError: bridge.std__optional_std__function_void_const_MapError_____error______ {
     @inline(__always)
     get {
@@ -731,6 +981,134 @@ open class HybridNitroMapSpec_cxx {
       }()
     }
   }
+  
+  public final var onUserLocationChange: bridge.std__optional_std__function_void_const_UserLocationChangeEvent_____event______ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_std__function_void_const_UserLocationChangeEvent_____event______ in
+        if let __unwrappedValue = self.__implementation.onUserLocationChange {
+          return bridge.create_std__optional_std__function_void_const_UserLocationChangeEvent_____event______({ () -> bridge.Func_void_UserLocationChangeEvent in
+            let __closureWrapper = Func_void_UserLocationChangeEvent(__unwrappedValue)
+            return bridge.create_Func_void_UserLocationChangeEvent(__closureWrapper.toUnsafe())
+          }())
+        } else {
+          return .init()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.onUserLocationChange = { () -> ((_ event: UserLocationChangeEvent) -> Void)? in
+        if bridge.has_value_std__optional_std__function_void_const_UserLocationChangeEvent_____event______(newValue) {
+          let __unwrapped = bridge.get_std__optional_std__function_void_const_UserLocationChangeEvent_____event______(newValue)
+          return { () -> (UserLocationChangeEvent) -> Void in
+            let __wrappedFunction = bridge.wrap_Func_void_UserLocationChangeEvent(__unwrapped)
+            return { (__event: UserLocationChangeEvent) -> Void in
+              __wrappedFunction.call(__event)
+            }
+          }()
+        } else {
+          return nil
+        }
+      }()
+    }
+  }
+  
+  public final var onUserTrackingModeChange: bridge.std__optional_std__function_void_UserTrackingMode____mode______ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_std__function_void_UserTrackingMode____mode______ in
+        if let __unwrappedValue = self.__implementation.onUserTrackingModeChange {
+          return bridge.create_std__optional_std__function_void_UserTrackingMode____mode______({ () -> bridge.Func_void_UserTrackingMode in
+            let __closureWrapper = Func_void_UserTrackingMode(__unwrappedValue)
+            return bridge.create_Func_void_UserTrackingMode(__closureWrapper.toUnsafe())
+          }())
+        } else {
+          return .init()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.onUserTrackingModeChange = { () -> ((_ mode: UserTrackingMode) -> Void)? in
+        if bridge.has_value_std__optional_std__function_void_UserTrackingMode____mode______(newValue) {
+          let __unwrapped = bridge.get_std__optional_std__function_void_UserTrackingMode____mode______(newValue)
+          return { () -> (UserTrackingMode) -> Void in
+            let __wrappedFunction = bridge.wrap_Func_void_UserTrackingMode(__unwrapped)
+            return { (__mode: UserTrackingMode) -> Void in
+              __wrappedFunction.call(__mode.rawValue)
+            }
+          }()
+        } else {
+          return nil
+        }
+      }()
+    }
+  }
+  
+  public final var onUserLocationError: bridge.std__optional_std__function_void_const_MapError_____error______ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_std__function_void_const_MapError_____error______ in
+        if let __unwrappedValue = self.__implementation.onUserLocationError {
+          return bridge.create_std__optional_std__function_void_const_MapError_____error______({ () -> bridge.Func_void_MapError in
+            let __closureWrapper = Func_void_MapError(__unwrappedValue)
+            return bridge.create_Func_void_MapError(__closureWrapper.toUnsafe())
+          }())
+        } else {
+          return .init()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.onUserLocationError = { () -> ((_ error: MapError) -> Void)? in
+        if bridge.has_value_std__optional_std__function_void_const_MapError_____error______(newValue) {
+          let __unwrapped = bridge.get_std__optional_std__function_void_const_MapError_____error______(newValue)
+          return { () -> (MapError) -> Void in
+            let __wrappedFunction = bridge.wrap_Func_void_MapError(__unwrapped)
+            return { (__error: MapError) -> Void in
+              __wrappedFunction.call(__error)
+            }
+          }()
+        } else {
+          return nil
+        }
+      }()
+    }
+  }
+  
+  public final var onMapIdle: bridge.std__optional_std__function_void____ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_std__function_void____ in
+        if let __unwrappedValue = self.__implementation.onMapIdle {
+          return bridge.create_std__optional_std__function_void____({ () -> bridge.Func_void in
+            let __closureWrapper = Func_void(__unwrappedValue)
+            return bridge.create_Func_void(__closureWrapper.toUnsafe())
+          }())
+        } else {
+          return .init()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.onMapIdle = { () -> (() -> Void)? in
+        if bridge.has_value_std__optional_std__function_void____(newValue) {
+          let __unwrapped = bridge.get_std__optional_std__function_void____(newValue)
+          return { () -> () -> Void in
+            let __wrappedFunction = bridge.wrap_Func_void(__unwrapped)
+            return { () -> Void in
+              __wrappedFunction.call()
+            }
+          }()
+        } else {
+          return nil
+        }
+      }()
+    }
+  }
 
   // Methods
   @inline(__always)
@@ -762,6 +1140,24 @@ open class HybridNitroMapSpec_cxx {
     }
   }
   
+  @inline(__always)
+  public final func fitToSuppliedMarkers(markerIds: bridge.std__vector_std__string_, edgePadding: bridge.std__optional_EdgePadding_, animated: bridge.std__optional_bool_) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.fitToSuppliedMarkers(markerIds: markerIds.map({ __item in String(__item) }), edgePadding: edgePadding.value, animated: { () -> Bool? in
+        if bridge.has_value_std__optional_bool_(animated) {
+          let __unwrapped = bridge.get_std__optional_bool_(animated)
+          return __unwrapped
+        } else {
+          return nil
+        }
+      }())
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
   @inline(__always)
   public final func animateCamera(camera: Camera, duration: bridge.std__optional_double_) -> bridge.Result_void_ {
     do {
@@ -840,6 +1236,41 @@ open class HybridNitroMapSpec_cxx {
     }
   }
   
+  @inline(__always)
+  public final func centerOnUserLocation() -> bridge.Result_void_ {
+    do {
+      try self.__implementation.centerOnUserLocation()
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func pointForCoordinate(coordinate: Coordinate) -> bridge.Result_Point_ {
+    do {
+      let __result = try self.__implementation.pointForCoordinate(coordinate: coordinate)
+      let __resultCpp = __result
+      return bridge.create_Result_Point_(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_Point_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func coordinateForPoint(point: Point) -> bridge.Result_Coordinate_ {
+    do {
+      let __result = try self.__implementation.coordinateForPoint(point: point)
+      let __resultCpp = __result
+      return bridge.create_Result_Coordinate_(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_Coordinate_(__exceptionPtr)
+    }
+  }
+  
   @inline(__always)
   public final func setIsDarkMode(enabled: Bool) -> bridge.Result_void_ {
     do {
@@ -906,6 +1337,17 @@ open class HybridNitroMapSpec_cxx {
     }
   }
   
+  @inline(__always)
+  public final func deselectMarker() -> bridge.Result_void_ {
+    do {
+      try self.__implementation.deselectMarker()
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
   @inline(__always)
   public final func clearMarkers() -> bridge.Result_void_ {
     do {
@@ -939,6 +1381,138 @@ open class HybridNitroMapSpec_cxx {
     }
   }
   
+  @inline(__always)
+  public final func addPolyline(polyline: PolylineData) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.addPolyline(polyline: polyline)
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func updatePolyline(polyline: PolylineData) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.updatePolyline(polyline: polyline)
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func removePolyline(id: std.string) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.removePolyline(id: String(id))
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func clearPolylines() -> bridge.Result_void_ {
+    do {
+      try self.__implementation.clearPolylines()
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func addPolygon(polygon: PolygonData) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.addPolygon(polygon: polygon)
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func updatePolygon(polygon: PolygonData) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.updatePolygon(polygon: polygon)
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func removePolygon(id: std.string) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.removePolygon(id: String(id))
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func clearPolygons() -> bridge.Result_void_ {
+    do {
+      try self.__implementation.clearPolygons()
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func addCircle(circle: CircleData) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.addCircle(circle: circle)
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func updateCircle(circle: CircleData) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.updateCircle(circle: circle)
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func removeCircle(id: std.string) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.removeCircle(id: String(id))
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func clearCircles() -> bridge.Result_void_ {
+    do {
+      try self.__implementation.clearCircles()
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
   public final func getView() -> UnsafeMutableRawPointer {
     return Unmanaged.passRetained(__implementation.view).toOpaque()
   }

package/nitrogen/generated/ios/swift/MarkerAnimation.swift

@@ -19,10 +19,8 @@ public extension MarkerAnimation {
     switch string {
       case "none":
         self = .none
-      case "pop":
-        self = .pop
-      case "fadeIn":
-        self = .fadein
+      case "appear":
+        self = .appear
       default:
         return nil
     }
@@ -35,10 +33,8 @@ public extension MarkerAnimation {
     switch self {
       case .none:
         return "none"
-      case .pop:
-        return "pop"
-      case .fadein:
-        return "fadeIn"
+      case .appear:
+        return "appear"
     }
   }
 }