@rnmapbox/maps 10.1.0-beta.8 → 10.1.0-rc.0

package/ios/RNMBX/{RNMBXCameraManager.swift → RNMBXCameraViewManager.swift}

@@ -1,8 +1,8 @@
 import Foundation
 import MapboxMaps
 
-@objc(RNMBXCameraManager)
-class RNMBXCameraManager  : RCTViewManager {
+@objc(RNMBXCameraViewManager)
+class RNMBXCameraViewManager  : RCTViewManager {
     @objc
     override static func requiresMainQueueSetup() -> Bool {
         return true

package/ios/RNMBX/RNMBXCircleLayer.swift

@@ -1,7 +1,7 @@
 import MapboxMaps
 
 @objc(RNMBXCircleLayer)
-class RNMBXCircleLayer: RNMBXVectorLayer {
+public class RNMBXCircleLayer: RNMBXVectorLayer {
   
   typealias LayerType = CircleLayer
 

package/ios/RNMBX/RNMBXCircleLayerComponentView.h

@@ -0,0 +1,15 @@
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#import <UIKit/UIKit.h>
+
+#import <React/RCTUIManager.h>
+#import <React/RCTViewComponentView.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface RNMBXCircleLayerComponentView : RCTViewComponentView
+@end
+
+NS_ASSUME_NONNULL_END
+
+#endif // RCT_NEW_ARCH_ENABLED

package/ios/RNMBX/RNMBXCircleLayerComponentView.mm

@@ -0,0 +1,70 @@
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#import "RNMBXCircleLayerComponentView.h"
+#import "RNMBXFabricHelpers.h"
+
+#import <React/RCTConversions.h>
+#import <React/RCTFabricComponentsPlugins.h>
+#import <React/RCTBridge+Private.h>
+
+#import <react/renderer/components/rnmapbox_maps_specs/ComponentDescriptors.h>
+#import <react/renderer/components/rnmapbox_maps_specs/EventEmitters.h>
+#import <react/renderer/components/rnmapbox_maps_specs/Props.h>
+#import <react/renderer/components/rnmapbox_maps_specs/RCTComponentViewHelpers.h>
+
+using namespace facebook::react;
+
+@interface RNMBXCircleLayerComponentView () <RCTRNMBXCircleLayerViewProtocol>
+@end
+
+@implementation RNMBXCircleLayerComponentView {
+    RNMBXCircleLayer *_view;
+}
+
+- (instancetype)initWithFrame:(CGRect)frame
+{
+  if (self = [super initWithFrame:frame]) {
+    static const auto defaultProps = std::make_shared<const RNMBXCircleLayerProps>();
+    _props = defaultProps;
+      [self prepareView];
+  }
+
+  return self;
+}
+
+- (void)prepareView
+{
+  _view =  [[RNMBXCircleLayer alloc] init];
+  _view.bridge = [RCTBridge currentBridge];
+  self.contentView = _view;
+}
+
+#pragma mark - RCTComponentViewProtocol
+
++ (ComponentDescriptorProvider)componentDescriptorProvider
+{
+  return concreteComponentDescriptorProvider<RNMBXCircleLayerComponentDescriptor>();
+}
+
+- (void)updateProps:(const Props::Shared &)props oldProps:(const Props::Shared &)oldProps
+{
+  const auto &newProps = static_cast<const RNMBXCircleLayerProps &>(*props);
+  RNMBXSetCommonLayerProps(newProps, _view);
+
+  [super updateProps:props oldProps:oldProps];
+}
+
+- (void)prepareForRecycle
+{
+    [super prepareForRecycle];
+    [self prepareView];
+}
+
+@end
+
+Class<RCTComponentViewProtocol> RNMBXCircleLayerCls(void)
+{
+  return RNMBXCircleLayerComponentView.class;
+}
+
+#endif // RCT_NEW_ARCH_ENABLED

package/ios/RNMBX/{RNMBXFillLayerManager.m → RNMBXCircleLayerViewManager.m}

@@ -1,7 +1,7 @@
 #import <React/RCTBridgeModule.h>
 #import <React/RCTViewManager.h>
 
-@interface RCT_EXTERN_MODULE(RNMBXFillLayerManager, RCTViewManager)
+@interface RCT_EXTERN_REMAP_MODULE(RNMBXCircleLayer, RNMBXCircleLayerViewManager, RCTViewManager)
 
 // circle layer props
 RCT_EXPORT_VIEW_PROPERTY(sourceLayerID, NSString)

package/ios/RNMBX/{RNMBXCircleLayerManager.swift → RNMBXCircleLayerViewManager.swift}

@@ -1,5 +1,5 @@
-@objc(RNMBXCircleLayerManager)
-class RNMBXCircleLayerManager: RCTViewManager {
+@objc(RNMBXCircleLayerViewManager)
+class RNMBXCircleLayerViewManager: RCTViewManager {
     @objc
     override static func requiresMainQueueSetup() -> Bool {
         return true

package/ios/RNMBX/RNMBXCustomLocationProvider.swift

@@ -0,0 +1,274 @@
+import MapboxMaps
+
+@objc
+public class RNMBXCustomLocationProvider: UIView, RNMBXMapComponent {
+  var map: RNMBXMapView? = nil
+  
+  let changes : PropertyChanges<RNMBXCustomLocationProvider> = PropertyChanges()
+  
+  enum Property: String {
+    case coordinate
+    case heading
+    
+    func apply(locationProvider: RNMBXCustomLocationProvider) {
+      switch self {
+        case .coordinate: locationProvider.applyCoordinate()
+        case .heading: locationProvider.applyHeading()
+      }
+    }
+  }
+  
+  @objc
+  public var coordinate: [Double] = [] {
+    didSet { changed(.coordinate) }
+  }
+    
+  @objc
+  public var heading: NSNumber = 0.0 {
+    didSet { changed(.heading) }
+  }
+  
+  func changed(_ property: Property) {
+    changes.add(name: property.rawValue, update: property.apply)
+  }
+  
+  @objc
+  override public func didSetProps(_ props: [String]) {
+    changes.apply(self)
+  }
+  
+  var customLocationProvider: CustomLocationProvider? = nil
+  #if RNMBX_11
+  #else
+  var defaultLocationProvider: LocationProvider?
+  #endif
+
+  func addToMap(_ map: RNMBXMapView, style: Style) {
+    self.map = map
+    if let mapView = map.mapView {
+      installCustomeLocationProviderIfNeeded(mapView: mapView)
+    }
+  }
+  
+  private func applyCoordinate() {
+    updateCoordinate(latitude: coordinate[1], longitude: coordinate[0])
+  }
+  
+  private func applyHeading() {
+    updateHeading(heading: heading.doubleValue)
+  }
+  
+  func removeFromMap(_ map: RNMBXMapView, reason: RemovalReason) -> Bool {
+    if let mapView = map.mapView {
+      removeCustomLocationProvider(mapView: mapView)
+    }
+    self.map = nil
+    return true
+  }
+
+  func waitForStyleLoad() -> Bool {
+    false
+  }
+}
+
+#if RNMBX_11
+// MARK: V11 location provider
+extension RNMBXCustomLocationProvider {
+  func installCustomeLocationProviderIfNeeded(mapView: MapView) {
+    if (customLocationProvider == nil) {
+      let customLocationProvider = CustomLocationProvider()
+      self.customLocationProvider = customLocationProvider
+      
+      if let locationModule = RNMBXLocationModule.shared {
+        locationModule.locationProvider = customLocationProvider
+        locationModule.override(for: mapView.location)
+        //locationModule.locationProvider = customLocationProvider
+        // mapView.location.overrideLocationProvider(with: customLocationProvider!)
+      }
+      
+      // customHeadingProvider = CustomHeadingProvider()
+      mapView.location.override(locationProvider: customLocationProvider, headingProvider: customLocationProvider)
+    }
+  }
+  
+  func removeCustomLocationProvider(mapView: MapView) {
+    mapView.location.override(provider: AppleLocationProvider())
+    if let locationModule = RNMBXLocationModule.shared {
+      locationModule.locationProvider = AppleLocationProvider()
+    }
+    customLocationProvider = nil
+  }
+  
+  func updateCoordinate(latitude: Double, longitude: Double) {
+    customLocationProvider?.setLocation(latitude: NSNumber(floatLiteral: latitude), longitude: NSNumber(floatLiteral: longitude))
+  }
+  
+  func updateHeading(heading: Double) {
+    customLocationProvider?.setHeading(heading: NSNumber(floatLiteral: heading))
+  }
+}
+#else
+// MARK: V10 location provider
+extension RNMBXCustomLocationProvider {
+  func installCustomeLocationProviderIfNeeded(mapView: MapView) {
+    if (customLocationProvider == nil) {
+      if (defaultLocationProvider == nil) {
+        defaultLocationProvider = mapView.location.locationProvider
+      }
+      let customLocationProvider = CustomLocationProvider()
+      self.customLocationProvider = customLocationProvider
+      if let locationModule = RNMBXLocationModule.shared {
+        locationModule.override(for: mapView.location)
+        locationModule.locationProvider = customLocationProvider
+        // mapView.location.overrideLocationProvider(with: customLocationProvider!)
+      }
+      
+    }
+  }
+  
+  func removeCustomLocationProvider(mapView: MapView) {
+    if let provider = defaultLocationProvider {
+      mapView.location.overrideLocationProvider(with: provider)
+    }
+    customLocationProvider = nil
+  }
+  
+  func updareCoordinate(latitude: Double, longitude: Double) {
+    customLocationProvider?.setLocation(latitude: NSNumber(floatLiteral: latitude), longitude: NSNumber(floatLiteral: longitude))
+  }
+  
+  func updateCoordinate(latitude: Double, longitude: Double) {
+    customLocationProvider?.setLocation(latitude: NSNumber(floatLiteral: latitude), longitude: NSNumber(floatLiteral: longitude))
+  }
+  
+  func updateHeading(heading: Double) {
+    customLocationProvider?.setHeading(heading: NSNumber(floatLiteral: heading))
+  }
+}
+#endif
+
+
+#if RNMBX_11
+class CustomLocationProvider: LocationProvider & HeadingProvider {
+  // MARK: LocationProvider
+  private var observers: NSHashTable<AnyObject> = .weakObjects()
+  private var location: Location? = nil
+
+  func addLocationObserver(for observer: LocationObserver) {
+    observers.add(observer)
+  }
+
+  func removeLocationObserver(for observer: LocationObserver) {
+    observers.remove(observer)
+  }
+
+  func getLastObservedLocation() -> Location? {
+    return location
+  }
+
+  func setLocation(latitude: NSNumber, longitude: NSNumber) {
+    let lat = CLLocationDegrees(truncating: latitude)
+    let lon = CLLocationDegrees(truncating: longitude)
+    self.location = Location(clLocation: CLLocation(latitude: lat, longitude: lon))
+    for observer in observers.allObjects {
+      (observer as? LocationObserver)?.onLocationUpdateReceived(for: [self.location!])
+    }
+  }
+  
+  // MARK: HeadingProvider
+  var latestHeading: Heading?
+  private let headingObservers: NSHashTable<AnyObject> = .weakObjects()
+
+  func add(headingObserver: HeadingObserver) {
+    headingObservers.add(headingObserver)
+  }
+
+  func remove(headingObserver: HeadingObserver) {
+    headingObservers.remove(headingObserver)
+  }
+    
+  func setHeading(heading: NSNumber) {
+    let latestHeading = Heading(direction: CLLocationDirection(truncating: heading), accuracy: CLLocationDirection(truncating: 1))
+    self.latestHeading = latestHeading
+    for observer in headingObservers.allObjects {
+      (observer as? HeadingObserver)?.onHeadingUpdate(latestHeading)
+    }
+  }
+}
+#else
+final public class CustomHeading: CLHeading {
+    private var _magneticHeading: CLLocationDirection = 0
+    
+    public override var trueHeading: CLLocationDirection {
+        get { -1 }
+    }
+    
+    public override var magneticHeading: CLLocationDirection {
+        get { _magneticHeading }
+        set { _magneticHeading = newValue }
+    }
+}
+
+class CustomLocationProvider: LocationProvider {
+    var locationProviderOptions: MapboxMaps.LocationOptions = .init()
+    
+    var authorizationStatus: CLAuthorizationStatus = .authorizedAlways
+    
+    var accuracyAuthorization: CLAccuracyAuthorization = .fullAccuracy
+    
+    var heading: CLHeading?
+    var location: CLLocation?
+    var updateLocation = false
+    var updateHeading = false
+    
+    var locationProviderDelegate: MapboxMaps.LocationProviderDelegate?
+    
+    func setDelegate(_ delegate: MapboxMaps.LocationProviderDelegate) {
+        locationProviderDelegate = delegate
+    }
+    
+    func setLocation(latitude: NSNumber, longitude: NSNumber) {
+        let lat = CLLocationDegrees(truncating: latitude)
+        let lon = CLLocationDegrees(truncating: longitude)
+        self.location = CLLocation(latitude: lat, longitude: lon)
+        if (updateLocation) {
+          locationProviderDelegate?.locationProvider(self, didUpdateLocations: [self.location!])
+        }
+    }
+    
+    func setHeading(heading: NSNumber) {
+        let latestHeading = CustomHeading()
+        latestHeading.magneticHeading = CLLocationDirection(truncating: heading)
+        self.heading = latestHeading
+        if (self.updateHeading) {
+          locationProviderDelegate?.locationProvider(self, didUpdateHeading: self.heading!)
+        }
+    }
+    
+    func requestAlwaysAuthorization() { }
+    
+    func requestWhenInUseAuthorization() { }
+    
+    func requestTemporaryFullAccuracyAuthorization(withPurposeKey purposeKey: String) { }
+    
+    func startUpdatingLocation() {
+        self.updateLocation = true
+    }
+    
+    func stopUpdatingLocation() {
+        self.updateLocation = false
+    }
+    
+    var headingOrientation: CLDeviceOrientation = .unknown
+    
+    func startUpdatingHeading() {
+        self.updateHeading = true
+    }
+    
+    func stopUpdatingHeading() {
+        self.updateHeading = false
+    }
+    
+    func dismissHeadingCalibrationDisplay() { }
+}
+#endif

package/ios/RNMBX/RNMBXCustomLocationProviderComponentView.h

@@ -0,0 +1,15 @@
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#import <UIKit/UIKit.h>
+
+#import <React/RCTUIManager.h>
+#import <React/RCTViewComponentView.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface RNMBXCustomLocationProviderComponentView : RCTViewComponentView
+@end
+
+NS_ASSUME_NONNULL_END
+
+#endif // RCT_NEW_ARCH_ENABLED

package/ios/RNMBX/RNMBXCustomLocationProviderComponentView.mm

@@ -0,0 +1,67 @@
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#import "RNMBXCustomLocationProviderComponentView.h"
+#import "RNMBXFabricHelpers.h"
+
+#import <React/RCTConversions.h>
+#import <React/RCTFabricComponentsPlugins.h>
+#import <React/RCTBridge+Private.h>
+
+#import <react/renderer/components/rnmapbox_maps_specs/ComponentDescriptors.h>
+#import <react/renderer/components/rnmapbox_maps_specs/EventEmitters.h>
+#import <react/renderer/components/rnmapbox_maps_specs/Props.h>
+#import <react/renderer/components/rnmapbox_maps_specs/RCTComponentViewHelpers.h>
+
+using namespace facebook::react;
+
+@interface RNMBXCustomLocationProviderComponentView () <RCTRNMBXCustomLocationProviderViewProtocol>
+@end
+
+@implementation RNMBXCustomLocationProviderComponentView {
+    RNMBXCustomLocationProvider *_view;
+}
+
+- (instancetype)initWithFrame:(CGRect)frame
+{
+  if (self = [super initWithFrame:frame]) {
+    static const auto defaultProps = std::make_shared<const RNMBXCircleLayerProps>();
+    _props = defaultProps;
+      [self prepareView];
+  }
+
+  return self;
+}
+
+- (void)prepareView
+{
+  _view =  [[RNMBXCustomLocationProvider alloc] init];
+  //_view.bridge = [RCTBridge currentBridge];
+  self.contentView = _view;
+}
+
+#pragma mark - RCTComponentViewProtocol
+
++ (ComponentDescriptorProvider)componentDescriptorProvider
+{
+  return concreteComponentDescriptorProvider<RNMBXCircleLayerComponentDescriptor>();
+}
+
+- (void)updateProps:(const Props::Shared &)props oldProps:(const Props::Shared &)oldProps
+{
+  [super updateProps:props oldProps:oldProps];
+}
+
+- (void)prepareForRecycle
+{
+    [super prepareForRecycle];
+    [self prepareView];
+}
+
+@end
+
+Class<RCTComponentViewProtocol> RNMBXCustomLocationProviderCls(void)
+{
+  return RNMBXCustomLocationProviderComponentView.class;
+}
+
+#endif // RCT_NEW_ARCH_ENABLED

package/ios/RNMBX/RNMBXCustomLocationProviderVIewManager.swift

@@ -0,0 +1,13 @@
+@objc(RNMBXCustomLocationProviderViewManager)
+class RNMBXCustomLocationProviderViewManager: RCTViewManager {
+    @objc
+    override static func requiresMainQueueSetup() -> Bool {
+        return true
+    }
+  
+    override func view() -> UIView! {
+      let layer = RNMBXCustomLocationProvider()
+      //layer.bridge = self.bridge
+      return layer
+    }
+}

package/ios/RNMBX/RNMBXCustomLocationProviderViewManager.m

@@ -0,0 +1,10 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTViewManager.h>
+
+@interface RCT_EXTERN_REMAP_MODULE(RNMBXCustomLocationProvider, RNMBXCustomLocationProviderViewManager, RCTViewManager)
+
+// circle layer props
+RCT_EXPORT_VIEW_PROPERTY(coordinate, NSArray)
+RCT_EXPORT_VIEW_PROPERTY(heading, NSNumber)
+
+@end

package/ios/RNMBX/RNMBXFabricHelpers.h

@@ -0,0 +1,119 @@
+#import <React/RCTConversions.h>
+#import <folly/dynamic.h>
+#import <react/renderer/components/rnmapbox_maps_specs/Props.h>
+
+#import "rnmapbox_maps-Swift.pre.h"
+
+// copied from RCTFollyConvert
+static id RNMBXConvertFollyDynamicToId(const folly::dynamic &dyn)
+{
+  // I could imagine an implementation which avoids copies by wrapping the
+  // dynamic in a derived class of NSDictionary.  We can do that if profiling
+  // implies it will help.
+
+  switch (dyn.type()) {
+    case folly::dynamic::NULLT:
+      return nil;
+    case folly::dynamic::BOOL:
+      return dyn.getBool() ? @YES : @NO;
+    case folly::dynamic::INT64:
+      return @(dyn.getInt());
+    case folly::dynamic::DOUBLE:
+      return @(dyn.getDouble());
+    case folly::dynamic::STRING:
+      return [[NSString alloc] initWithBytes:dyn.c_str() length:dyn.size() encoding:NSUTF8StringEncoding];
+    case folly::dynamic::ARRAY: {
+      NSMutableArray *array = [[NSMutableArray alloc] initWithCapacity:dyn.size()];
+      for (const auto &elem : dyn) {
+        id value = RNMBXConvertFollyDynamicToId(elem);
+        if (value) {
+          [array addObject:value];
+        }
+      }
+      return array;
+    }
+    case folly::dynamic::OBJECT: {
+      NSMutableDictionary *dict = [[NSMutableDictionary alloc] initWithCapacity:dyn.size()];
+      for (const auto &elem : dyn.items()) {
+        id key = RNMBXConvertFollyDynamicToId(elem.first);
+        id value = RNMBXConvertFollyDynamicToId(elem.second);
+        if (key && value) {
+          dict[key] = value;
+        }
+      }
+      return dict;
+    }
+  }
+}
+
+static std::tuple<std::string, std::string> RNMBXStringifyEventData(NSDictionary* event) {
+    std::string type = [event valueForKey:@"type"] == nil ? "" : std::string([[event valueForKey:@"type"] UTF8String]);
+    std::string json = "{}";
+
+    NSError *error;
+    NSData *jsonData = nil;
+
+    if ([event valueForKey:@"payload"] != nil) {
+        jsonData = [NSJSONSerialization dataWithJSONObject:[event valueForKey:@"payload"]
+                                                           options:0
+                                                             error:&error];
+    }
+
+    if (jsonData) {
+        json = std::string([[[NSString alloc] initWithData:jsonData encoding:NSUTF8StringEncoding] UTF8String]);
+    }
+
+    return {type, json};
+}
+
+template <typename T>
+void RNMBXSetCommonLayerPropsWithoutSourceID(T newProps, RNMBXLayer *_view)
+{
+    id idx = RNMBXConvertFollyDynamicToId(newProps.id);
+    if (idx != nil) {
+        _view.id = idx;
+    }
+    id sourceID = RNMBXConvertFollyDynamicToId(newProps.sourceID);
+    if (sourceID != nil) {
+        _view.sourceID = sourceID;
+    }
+    id filter = RNMBXConvertFollyDynamicToId(newProps.filter);
+    if (filter != nil) {
+        _view.filter = filter;
+    }
+    id aboveLayerID = RNMBXConvertFollyDynamicToId(newProps.aboveLayerID);
+    if (aboveLayerID != nil) {
+        _view.aboveLayerID = aboveLayerID;
+    }
+    id belowLayerID = RNMBXConvertFollyDynamicToId(newProps.belowLayerID);
+    if (belowLayerID != nil) {
+        _view.belowLayerID = belowLayerID;
+    }
+    id layerIndex = RNMBXConvertFollyDynamicToId(newProps.layerIndex);
+    if (layerIndex != nil) {
+        _view.layerIndex = layerIndex;
+    }
+    id reactStyle = RNMBXConvertFollyDynamicToId(newProps.reactStyle);
+    if (reactStyle != nil) {
+        _view.reactStyle = reactStyle;
+    }
+    id maxZoomLevel = RNMBXConvertFollyDynamicToId(newProps.maxZoomLevel);
+    if (maxZoomLevel != nil) {
+        _view.maxZoomLevel = maxZoomLevel;
+    }
+    id minZoomLevel = RNMBXConvertFollyDynamicToId(newProps.minZoomLevel);
+    if (minZoomLevel != nil) {
+        _view.minZoomLevel = minZoomLevel;
+    }
+}
+
+template <typename T>
+void RNMBXSetCommonLayerProps(T newProps, RNMBXLayer *_view)
+{
+    RNMBXSetCommonLayerPropsWithoutSourceID(newProps, _view);
+    id sourceLayerID = RNMBXConvertFollyDynamicToId(newProps.sourceLayerID);
+    if (sourceLayerID != nil) {
+        _view.sourceLayerID = sourceLayerID;
+    }
+}
+

package/ios/RNMBX/RNMBXFabricPropConvert.h

@@ -0,0 +1,47 @@
+#pragma once
+
+/**
+ *
+ * 1. Requirest the following prelude
+ * const auto &oldViewProps = static_cast<const RNMBXNativeUserLocationProps &>(*oldProps);
+ * const auto &newViewProps = static_cast<const RNMBXNativeUserLocationProps &>(*props);
+ *
+ * 2. OPTION_PROPS are not set when the prop is undefined/null
+ */
+
+NSNumber* RNMBXPropConvert_Optional_BOOL_NSNumber(const folly::dynamic &dyn, NSString* propertyName);
+BOOL RNMBXPropConvert_Optional_BOOL(const folly::dynamic &dyn, NSString* propertyName);
+NSString* RNMBXPropConvert_Optional_NSString(const folly::dynamic &dyn, NSString* propertyName);
+id RNMBXPropConvert_Optional_ExpressionDouble(const folly::dynamic &dyn, NSString* propertyName);
+BOOL RNMBXPropConvert_BOOL(const folly::dynamic &dyn, NSString* propertyName);
+NSDictionary* RNMBXPropConvert_Optional_NSDictionary(const folly::dynamic &dyn, NSString* propertyName);
+
+#define RNMBX_OPTIONAL_PROP_BOOL_NSNumber(name) \
+  if ((!oldProps.get() || oldViewProps.name != newViewProps.name) && !newViewProps.name.isNull()) { \
+    _view.name = RNMBXPropConvert_Optional_BOOL_NSNumber(newViewProps.name, @#name); \
+  }
+
+#define RNMBX_OPTIONAL_PROP_BOOL(name) \
+  if ((!oldProps.get() || oldViewProps.name != newViewProps.name) && !newViewProps.name.isNull()) { \
+    _view.name = RNMBXPropConvert_Optional_BOOL(newViewProps.name, @#name); \
+  }
+
+#define RNMBX_OPTIONAL_PROP_NSString(name) \
+  if ((!oldProps.get() || oldViewProps.name != newViewProps.name) && !newViewProps.name.isNull()) { \
+    _view.name = RNMBXPropConvert_Optional_NSString(newViewProps.name, @#name); \
+  }
+
+#define RNMBX_OPTIONAL_PROP_ExpressionDouble(name) \
+  if ((!oldProps.get() || oldViewProps.name != newViewProps.name) && !newViewProps.name.isNull()) { \
+    _view.name = RNMBXPropConvert_Optional_ExpressionDouble(newViewProps.name, @#name); \
+  }
+
+#define RNMBX_PROP_BOOL(name) \
+  if ((!oldProps.get() || oldViewProps.name != newViewProps.name)) { \
+    _view.name = RNMBXPropConvert_BOOL(newViewProps.name, @#name); \
+  }
+
+#define RNMBX_OPTIONAL_PROP_NSDictionary(name) \
+  if ((!oldProps.get() || oldViewProps.name != newViewProps.name)) { \
+    _view.name = RNMBXPropConvert_Optional_NSDictionary(newViewProps.name, @#name); \
+  }