react-native-maps 1.28.2 → 1.29.0

package/android/src/main/jni/react/renderer/components/RNMapsSpecs/ComponentDescriptors.cpp

@@ -19,10 +19,12 @@ void RNMapsSpecs_registerComponentDescriptorsFromCodegen(
 registry->add(concreteComponentDescriptorProvider<RNMapsCalloutComponentDescriptor>());
 registry->add(concreteComponentDescriptorProvider<RNMapsCircleComponentDescriptor>());
 registry->add(concreteComponentDescriptorProvider<RNMapsGoogleMapViewComponentDescriptor>());
+registry->add(concreteComponentDescriptorProvider<RNMapsGoogleMarkerComponentDescriptor>());
 registry->add(concreteComponentDescriptorProvider<RNMapsGooglePolygonComponentDescriptor>());
 registry->add(concreteComponentDescriptorProvider<RNMapsMapViewComponentDescriptor>());
 registry->add(concreteComponentDescriptorProvider<RNMapsMarkerComponentDescriptor>());
 registry->add(concreteComponentDescriptorProvider<RNMapsOverlayComponentDescriptor>());
+registry->add(concreteComponentDescriptorProvider<RNMapsPolygonComponentDescriptor>());
 registry->add(concreteComponentDescriptorProvider<RNMapsPolylineComponentDescriptor>());
 registry->add(concreteComponentDescriptorProvider<RNMapsUrlTileComponentDescriptor>());
 registry->add(concreteComponentDescriptorProvider<RNMapsWMSTileComponentDescriptor>());

package/android/src/main/jni/react/renderer/components/RNMapsSpecs/ComponentDescriptors.h

@@ -19,10 +19,12 @@ namespace facebook::react {
 using RNMapsCalloutComponentDescriptor = ConcreteComponentDescriptor<RNMapsCalloutShadowNode>;
 using RNMapsCircleComponentDescriptor = ConcreteComponentDescriptor<RNMapsCircleShadowNode>;
 using RNMapsGoogleMapViewComponentDescriptor = ConcreteComponentDescriptor<RNMapsGoogleMapViewShadowNode>;
+using RNMapsGoogleMarkerComponentDescriptor = ConcreteComponentDescriptor<RNMapsGoogleMarkerShadowNode>;
 using RNMapsGooglePolygonComponentDescriptor = ConcreteComponentDescriptor<RNMapsGooglePolygonShadowNode>;
 using RNMapsMapViewComponentDescriptor = ConcreteComponentDescriptor<RNMapsMapViewShadowNode>;
 using RNMapsMarkerComponentDescriptor = ConcreteComponentDescriptor<RNMapsMarkerShadowNode>;
 using RNMapsOverlayComponentDescriptor = ConcreteComponentDescriptor<RNMapsOverlayShadowNode>;
+using RNMapsPolygonComponentDescriptor = ConcreteComponentDescriptor<RNMapsPolygonShadowNode>;
 using RNMapsPolylineComponentDescriptor = ConcreteComponentDescriptor<RNMapsPolylineShadowNode>;
 using RNMapsUrlTileComponentDescriptor = ConcreteComponentDescriptor<RNMapsUrlTileShadowNode>;
 using RNMapsWMSTileComponentDescriptor = ConcreteComponentDescriptor<RNMapsWMSTileShadowNode>;

package/android/src/main/jni/react/renderer/components/RNMapsSpecs/EventEmitters.cpp

@@ -384,6 +384,159 @@ void RNMapsGoogleMapViewEventEmitter::onUserLocationChange(OnUserLocationChange
 }
 
 
+void RNMapsGoogleMarkerEventEmitter::onCalloutPress(OnCalloutPress event) const {
+  dispatchEvent("calloutPress", [event=std::move(event)](jsi::Runtime &runtime) {
+    auto payload = jsi::Object(runtime);
+    payload.setProperty(runtime, "action", event.action);
+payload.setProperty(runtime, "id", event.id);
+{
+  auto frame = jsi::Object(runtime);
+  frame.setProperty(runtime, "x", event.frame.x);
+  frame.setProperty(runtime, "y", event.frame.y);
+  frame.setProperty(runtime, "width", event.frame.width);
+  frame.setProperty(runtime, "height", event.frame.height);
+  payload.setProperty(runtime, "frame", frame);
+}
+{
+  auto point = jsi::Object(runtime);
+  point.setProperty(runtime, "x", event.point.x);
+  point.setProperty(runtime, "y", event.point.y);
+  payload.setProperty(runtime, "point", point);
+}
+    return payload;
+  });
+}
+
+
+void RNMapsGoogleMarkerEventEmitter::onDrag(OnDrag event) const {
+  dispatchEvent("drag", [event=std::move(event)](jsi::Runtime &runtime) {
+    auto payload = jsi::Object(runtime);
+    payload.setProperty(runtime, "id", event.id);
+{
+  auto coordinate = jsi::Object(runtime);
+  coordinate.setProperty(runtime, "latitude", event.coordinate.latitude);
+  coordinate.setProperty(runtime, "longitude", event.coordinate.longitude);
+  payload.setProperty(runtime, "coordinate", coordinate);
+}
+{
+  auto position = jsi::Object(runtime);
+  position.setProperty(runtime, "x", event.position.x);
+  position.setProperty(runtime, "y", event.position.y);
+  payload.setProperty(runtime, "position", position);
+}
+    return payload;
+  });
+}
+
+
+void RNMapsGoogleMarkerEventEmitter::onDragEnd(OnDragEnd event) const {
+  dispatchEvent("dragEnd", [event=std::move(event)](jsi::Runtime &runtime) {
+    auto payload = jsi::Object(runtime);
+    payload.setProperty(runtime, "id", event.id);
+{
+  auto coordinate = jsi::Object(runtime);
+  coordinate.setProperty(runtime, "latitude", event.coordinate.latitude);
+  coordinate.setProperty(runtime, "longitude", event.coordinate.longitude);
+  payload.setProperty(runtime, "coordinate", coordinate);
+}
+{
+  auto position = jsi::Object(runtime);
+  position.setProperty(runtime, "x", event.position.x);
+  position.setProperty(runtime, "y", event.position.y);
+  payload.setProperty(runtime, "position", position);
+}
+    return payload;
+  });
+}
+
+
+void RNMapsGoogleMarkerEventEmitter::onDragStart(OnDragStart event) const {
+  dispatchEvent("dragStart", [event=std::move(event)](jsi::Runtime &runtime) {
+    auto payload = jsi::Object(runtime);
+    payload.setProperty(runtime, "id", event.id);
+{
+  auto coordinate = jsi::Object(runtime);
+  coordinate.setProperty(runtime, "latitude", event.coordinate.latitude);
+  coordinate.setProperty(runtime, "longitude", event.coordinate.longitude);
+  payload.setProperty(runtime, "coordinate", coordinate);
+}
+{
+  auto position = jsi::Object(runtime);
+  position.setProperty(runtime, "x", event.position.x);
+  position.setProperty(runtime, "y", event.position.y);
+  payload.setProperty(runtime, "position", position);
+}
+    return payload;
+  });
+}
+
+
+void RNMapsGoogleMarkerEventEmitter::onPress(OnPress event) const {
+  dispatchEvent("press", [event=std::move(event)](jsi::Runtime &runtime) {
+    auto payload = jsi::Object(runtime);
+    payload.setProperty(runtime, "action", event.action);
+payload.setProperty(runtime, "id", event.id);
+{
+  auto coordinate = jsi::Object(runtime);
+  coordinate.setProperty(runtime, "latitude", event.coordinate.latitude);
+  coordinate.setProperty(runtime, "longitude", event.coordinate.longitude);
+  payload.setProperty(runtime, "coordinate", coordinate);
+}
+{
+  auto position = jsi::Object(runtime);
+  position.setProperty(runtime, "x", event.position.x);
+  position.setProperty(runtime, "y", event.position.y);
+  payload.setProperty(runtime, "position", position);
+}
+    return payload;
+  });
+}
+
+
+void RNMapsGoogleMarkerEventEmitter::onSelect(OnSelect event) const {
+  dispatchEvent("select", [event=std::move(event)](jsi::Runtime &runtime) {
+    auto payload = jsi::Object(runtime);
+    payload.setProperty(runtime, "action", event.action);
+payload.setProperty(runtime, "id", event.id);
+{
+  auto coordinate = jsi::Object(runtime);
+  coordinate.setProperty(runtime, "latitude", event.coordinate.latitude);
+  coordinate.setProperty(runtime, "longitude", event.coordinate.longitude);
+  payload.setProperty(runtime, "coordinate", coordinate);
+}
+{
+  auto position = jsi::Object(runtime);
+  position.setProperty(runtime, "x", event.position.x);
+  position.setProperty(runtime, "y", event.position.y);
+  payload.setProperty(runtime, "position", position);
+}
+    return payload;
+  });
+}
+
+
+void RNMapsGoogleMarkerEventEmitter::onDeselect(OnDeselect event) const {
+  dispatchEvent("deselect", [event=std::move(event)](jsi::Runtime &runtime) {
+    auto payload = jsi::Object(runtime);
+    payload.setProperty(runtime, "action", event.action);
+payload.setProperty(runtime, "id", event.id);
+{
+  auto coordinate = jsi::Object(runtime);
+  coordinate.setProperty(runtime, "latitude", event.coordinate.latitude);
+  coordinate.setProperty(runtime, "longitude", event.coordinate.longitude);
+  payload.setProperty(runtime, "coordinate", coordinate);
+}
+{
+  auto position = jsi::Object(runtime);
+  position.setProperty(runtime, "x", event.position.x);
+  position.setProperty(runtime, "y", event.position.y);
+  payload.setProperty(runtime, "position", position);
+}
+    return payload;
+  });
+}
+
+
 void RNMapsGooglePolygonEventEmitter::onPress(OnPress event) const {
   dispatchEvent("press", [event=std::move(event)](jsi::Runtime &runtime) {
     auto payload = jsi::Object(runtime);
@@ -953,6 +1106,28 @@ payload.setProperty(runtime, "id", event.id);
 }
 
 
+void RNMapsPolygonEventEmitter::onPress(OnPress event) const {
+  dispatchEvent("press", [event=std::move(event)](jsi::Runtime &runtime) {
+    auto payload = jsi::Object(runtime);
+    payload.setProperty(runtime, "action", event.action);
+payload.setProperty(runtime, "id", event.id);
+{
+  auto coordinate = jsi::Object(runtime);
+  coordinate.setProperty(runtime, "latitude", event.coordinate.latitude);
+  coordinate.setProperty(runtime, "longitude", event.coordinate.longitude);
+  payload.setProperty(runtime, "coordinate", coordinate);
+}
+{
+  auto position = jsi::Object(runtime);
+  position.setProperty(runtime, "x", event.position.x);
+  position.setProperty(runtime, "y", event.position.y);
+  payload.setProperty(runtime, "position", position);
+}
+    return payload;
+  });
+}
+
+
 void RNMapsPolylineEventEmitter::onPress(OnPress event) const {
   dispatchEvent("press", [event=std::move(event)](jsi::Runtime &runtime) {
     auto payload = jsi::Object(runtime);

package/android/src/main/jni/react/renderer/components/RNMapsSpecs/EventEmitters.h

@@ -330,6 +330,141 @@ class RNMapsGoogleMapViewEventEmitter : public ViewEventEmitter {
 
   void onUserLocationChange(OnUserLocationChange value) const;
 };
+class RNMapsGoogleMarkerEventEmitter : public ViewEventEmitter {
+ public:
+  using ViewEventEmitter::ViewEventEmitter;
+
+  struct OnCalloutPressFrame {
+      double x;
+    double y;
+    double width;
+    double height;
+    };
+
+  struct OnCalloutPressPoint {
+      double x;
+    double y;
+    };
+
+  struct OnCalloutPress {
+      std::string action;
+    std::string id;
+    OnCalloutPressFrame frame;
+    OnCalloutPressPoint point;
+    };
+
+  struct OnDragCoordinate {
+      double latitude;
+    double longitude;
+    };
+
+  struct OnDragPosition {
+      double x;
+    double y;
+    };
+
+  struct OnDrag {
+      std::string id;
+    OnDragCoordinate coordinate;
+    OnDragPosition position;
+    };
+
+  struct OnDragEndCoordinate {
+      double latitude;
+    double longitude;
+    };
+
+  struct OnDragEndPosition {
+      double x;
+    double y;
+    };
+
+  struct OnDragEnd {
+      std::string id;
+    OnDragEndCoordinate coordinate;
+    OnDragEndPosition position;
+    };
+
+  struct OnDragStartCoordinate {
+      double latitude;
+    double longitude;
+    };
+
+  struct OnDragStartPosition {
+      double x;
+    double y;
+    };
+
+  struct OnDragStart {
+      std::string id;
+    OnDragStartCoordinate coordinate;
+    OnDragStartPosition position;
+    };
+
+  struct OnPressCoordinate {
+      double latitude;
+    double longitude;
+    };
+
+  struct OnPressPosition {
+      double x;
+    double y;
+    };
+
+  struct OnPress {
+      std::string action;
+    std::string id;
+    OnPressCoordinate coordinate;
+    OnPressPosition position;
+    };
+
+  struct OnSelectCoordinate {
+      double latitude;
+    double longitude;
+    };
+
+  struct OnSelectPosition {
+      double x;
+    double y;
+    };
+
+  struct OnSelect {
+      std::string action;
+    std::string id;
+    OnSelectCoordinate coordinate;
+    OnSelectPosition position;
+    };
+
+  struct OnDeselectCoordinate {
+      double latitude;
+    double longitude;
+    };
+
+  struct OnDeselectPosition {
+      double x;
+    double y;
+    };
+
+  struct OnDeselect {
+      std::string action;
+    std::string id;
+    OnDeselectCoordinate coordinate;
+    OnDeselectPosition position;
+    };
+  void onCalloutPress(OnCalloutPress value) const;
+
+  void onDrag(OnDrag value) const;
+
+  void onDragEnd(OnDragEnd value) const;
+
+  void onDragStart(OnDragStart value) const;
+
+  void onPress(OnPress value) const;
+
+  void onSelect(OnSelect value) const;
+
+  void onDeselect(OnDeselect value) const;
+};
 class RNMapsGooglePolygonEventEmitter : public ViewEventEmitter {
  public:
   using ViewEventEmitter::ViewEventEmitter;
@@ -821,6 +956,28 @@ class RNMapsOverlayEventEmitter : public ViewEventEmitter {
     };
   void onPress(OnPress value) const;
 };
+class RNMapsPolygonEventEmitter : public ViewEventEmitter {
+ public:
+  using ViewEventEmitter::ViewEventEmitter;
+
+  struct OnPressCoordinate {
+      double latitude;
+    double longitude;
+    };
+
+  struct OnPressPosition {
+      double x;
+    double y;
+    };
+
+  struct OnPress {
+      std::string action;
+    std::string id;
+    OnPressCoordinate coordinate;
+    OnPressPosition position;
+    };
+  void onPress(OnPress value) const;
+};
 class RNMapsPolylineEventEmitter : public ViewEventEmitter {
  public:
   using ViewEventEmitter::ViewEventEmitter;

package/android/src/main/jni/react/renderer/components/RNMapsSpecs/Props.cpp

@@ -292,6 +292,110 @@ folly::dynamic RNMapsGoogleMapViewProps::getDiffProps(
   return result;
 }
 #endif
+RNMapsGoogleMarkerProps::RNMapsGoogleMarkerProps(
+    const PropsParserContext &context,
+    const RNMapsGoogleMarkerProps &sourceProps,
+    const RawProps &rawProps): ViewProps(context, sourceProps, rawProps),
+
+    anchor(convertRawProp(context, rawProps, "anchor", sourceProps.anchor, {})),
+    calloutAnchor(convertRawProp(context, rawProps, "calloutAnchor", sourceProps.calloutAnchor, {})),
+    image(convertRawProp(context, rawProps, "image", sourceProps.image, {})),
+    icon(convertRawProp(context, rawProps, "icon", sourceProps.icon, {})),
+    coordinate(convertRawProp(context, rawProps, "coordinate", sourceProps.coordinate, {})),
+    description(convertRawProp(context, rawProps, "description", sourceProps.description, {})),
+    draggable(convertRawProp(context, rawProps, "draggable", sourceProps.draggable, {false})),
+    title(convertRawProp(context, rawProps, "title", sourceProps.title, {})),
+    tracksViewChanges(convertRawProp(context, rawProps, "tracksViewChanges", sourceProps.tracksViewChanges, {true})),
+    tracksInfoWindowChanges(convertRawProp(context, rawProps, "tracksInfoWindowChanges", sourceProps.tracksInfoWindowChanges, {false})),
+    flat(convertRawProp(context, rawProps, "flat", sourceProps.flat, {false})),
+    rotation(convertRawProp(context, rawProps, "rotation", sourceProps.rotation, {0.0})),
+    identifier(convertRawProp(context, rawProps, "identifier", sourceProps.identifier, {})),
+    tappable(convertRawProp(context, rawProps, "tappable", sourceProps.tappable, {true})),
+    opacity(convertRawProp(context, rawProps, "opacity", sourceProps.opacity, {1.0})),
+    pinColor(convertRawProp(context, rawProps, "pinColor", sourceProps.pinColor, {})) {}
+    
+#ifdef RN_SERIALIZABLE_STATE
+ComponentName RNMapsGoogleMarkerProps::getDiffPropsImplementationTarget() const {
+  return "RNMapsGoogleMarker";
+}
+
+folly::dynamic RNMapsGoogleMarkerProps::getDiffProps(
+    const Props* prevProps) const {
+  static const auto defaultProps = RNMapsGoogleMarkerProps();
+  const RNMapsGoogleMarkerProps* oldProps = prevProps == nullptr
+      ? &defaultProps
+      : static_cast<const RNMapsGoogleMarkerProps*>(prevProps);
+  if (this == oldProps) {
+    return folly::dynamic::object();
+  }
+  folly::dynamic result = HostPlatformViewProps::getDiffProps(prevProps);
+  
+  if (anchor != oldProps->anchor) {
+    result["anchor"] = toDynamic(anchor);
+  }
+    
+  if (calloutAnchor != oldProps->calloutAnchor) {
+    result["calloutAnchor"] = toDynamic(calloutAnchor);
+  }
+    
+  if (image != oldProps->image) {
+    result["image"] = toDynamic(image);
+  }
+    
+  if (icon != oldProps->icon) {
+    result["icon"] = toDynamic(icon);
+  }
+    
+  if (coordinate != oldProps->coordinate) {
+    result["coordinate"] = toDynamic(coordinate);
+  }
+    
+  if (description != oldProps->description) {
+    result["description"] = description;
+  }
+    
+  if (draggable != oldProps->draggable) {
+    result["draggable"] = draggable;
+  }
+    
+  if (title != oldProps->title) {
+    result["title"] = title;
+  }
+    
+  if (tracksViewChanges != oldProps->tracksViewChanges) {
+    result["tracksViewChanges"] = tracksViewChanges;
+  }
+    
+  if (tracksInfoWindowChanges != oldProps->tracksInfoWindowChanges) {
+    result["tracksInfoWindowChanges"] = tracksInfoWindowChanges;
+  }
+    
+  if (flat != oldProps->flat) {
+    result["flat"] = flat;
+  }
+    
+  if ((rotation != oldProps->rotation) && !(std::isnan(rotation) && std::isnan(oldProps->rotation))) {
+    result["rotation"] = rotation;
+  }
+    
+  if (identifier != oldProps->identifier) {
+    result["identifier"] = identifier;
+  }
+    
+  if (tappable != oldProps->tappable) {
+    result["tappable"] = tappable;
+  }
+    
+  if ((opacity != oldProps->opacity) && !(std::isnan(opacity) && std::isnan(oldProps->opacity))) {
+    result["opacity"] = opacity;
+  }
+    
+  if (pinColor != oldProps->pinColor) {
+    result["pinColor"] = *pinColor;
+  }
+  return result;
+}
+#endif
 RNMapsGooglePolygonProps::RNMapsGooglePolygonProps(
     const PropsParserContext &context,
     const RNMapsGooglePolygonProps &sourceProps,
@@ -365,6 +469,7 @@ RNMapsMapViewProps::RNMapsMapViewProps(
     initialRegion(convertRawProp(context, rawProps, "initialRegion", sourceProps.initialRegion, {})),
     kmlSrc(convertRawProp(context, rawProps, "kmlSrc", sourceProps.kmlSrc, {})),
     legalLabelInsets(convertRawProp(context, rawProps, "legalLabelInsets", sourceProps.legalLabelInsets, {})),
+    appleLogoInsets(convertRawProp(context, rawProps, "appleLogoInsets", sourceProps.appleLogoInsets, {})),
     liteMode(convertRawProp(context, rawProps, "liteMode", sourceProps.liteMode, {false})),
     googleMapId(convertRawProp(context, rawProps, "googleMapId", sourceProps.googleMapId, {})),
     googleRenderer(convertRawProp(context, rawProps, "googleRenderer", sourceProps.googleRenderer, {RNMapsMapViewGoogleRenderer::LATEST})),
@@ -461,6 +566,10 @@ folly::dynamic RNMapsMapViewProps::getDiffProps(
     result["legalLabelInsets"] = toDynamic(legalLabelInsets);
   }
     
+  if (appleLogoInsets != oldProps->appleLogoInsets) {
+    result["appleLogoInsets"] = toDynamic(appleLogoInsets);
+  }
+    
   if (liteMode != oldProps->liteMode) {
     result["liteMode"] = liteMode;
   }
@@ -798,6 +907,80 @@ folly::dynamic RNMapsOverlayProps::getDiffProps(
   return result;
 }
 #endif
+RNMapsPolygonProps::RNMapsPolygonProps(
+    const PropsParserContext &context,
+    const RNMapsPolygonProps &sourceProps,
+    const RawProps &rawProps): ViewProps(context, sourceProps, rawProps),
+
+    coordinates(convertRawProp(context, rawProps, "coordinates", sourceProps.coordinates, {})),
+    fillColor(convertRawProp(context, rawProps, "fillColor", sourceProps.fillColor, {})),
+    strokeColor(convertRawProp(context, rawProps, "strokeColor", sourceProps.strokeColor, {})),
+    strokeWidth(convertRawProp(context, rawProps, "strokeWidth", sourceProps.strokeWidth, {1.0})),
+    holes(convertRawProp(context, rawProps, "holes", sourceProps.holes, {})),
+    lineCap(convertRawProp(context, rawProps, "lineCap", sourceProps.lineCap, {RNMapsPolygonLineCap::Round})),
+    lineJoin(convertRawProp(context, rawProps, "lineJoin", sourceProps.lineJoin, {RNMapsPolygonLineJoin::Round})),
+    miterLimit(convertRawProp(context, rawProps, "miterLimit", sourceProps.miterLimit, {10.0})),
+    lineDashPhase(convertRawProp(context, rawProps, "lineDashPhase", sourceProps.lineDashPhase, {0.0})),
+    lineDashPattern(convertRawProp(context, rawProps, "lineDashPattern", sourceProps.lineDashPattern, {})) {}
+    
+#ifdef RN_SERIALIZABLE_STATE
+ComponentName RNMapsPolygonProps::getDiffPropsImplementationTarget() const {
+  return "RNMapsPolygon";
+}
+
+folly::dynamic RNMapsPolygonProps::getDiffProps(
+    const Props* prevProps) const {
+  static const auto defaultProps = RNMapsPolygonProps();
+  const RNMapsPolygonProps* oldProps = prevProps == nullptr
+      ? &defaultProps
+      : static_cast<const RNMapsPolygonProps*>(prevProps);
+  if (this == oldProps) {
+    return folly::dynamic::object();
+  }
+  folly::dynamic result = HostPlatformViewProps::getDiffProps(prevProps);
+  
+  if (coordinates != oldProps->coordinates) {
+    result["coordinates"] = toDynamic(coordinates);
+  }
+    
+  if (fillColor != oldProps->fillColor) {
+    result["fillColor"] = *fillColor;
+  }
+    
+  if (strokeColor != oldProps->strokeColor) {
+    result["strokeColor"] = *strokeColor;
+  }
+    
+  if ((strokeWidth != oldProps->strokeWidth) && !(std::isnan(strokeWidth) && std::isnan(oldProps->strokeWidth))) {
+    result["strokeWidth"] = strokeWidth;
+  }
+    
+  if (holes != oldProps->holes) {
+    result["holes"] = toDynamic(holes);
+  }
+    
+  if (lineCap != oldProps->lineCap) {
+    result["lineCap"] = toDynamic(lineCap);
+  }
+    
+  if (lineJoin != oldProps->lineJoin) {
+    result["lineJoin"] = toDynamic(lineJoin);
+  }
+    
+  if ((miterLimit != oldProps->miterLimit) && !(std::isnan(miterLimit) && std::isnan(oldProps->miterLimit))) {
+    result["miterLimit"] = miterLimit;
+  }
+    
+  if ((lineDashPhase != oldProps->lineDashPhase) && !(std::isnan(lineDashPhase) && std::isnan(oldProps->lineDashPhase))) {
+    result["lineDashPhase"] = lineDashPhase;
+  }
+    
+  if (lineDashPattern != oldProps->lineDashPattern) {
+    result["lineDashPattern"] = toDynamic(lineDashPattern);
+  }
+  return result;
+}
+#endif
 RNMapsPolylineProps::RNMapsPolylineProps(
     const PropsParserContext &context,
     const RNMapsPolylineProps &sourceProps,