@lugg/maps 1.0.0-beta.0 → 1.0.0-beta.10

package/android/src/main/java/com/luggmaps/core/MapProviderDelegate.kt

@@ -1,9 +1,12 @@
 package com.luggmaps.core
 
 import android.view.View
+import com.luggmaps.LuggCircleView
+import com.luggmaps.LuggGroundOverlayView
 import com.luggmaps.LuggMarkerView
 import com.luggmaps.LuggPolygonView
 import com.luggmaps.LuggPolylineView
+import com.luggmaps.LuggTileOverlayView
 
 data class EdgeInsets(val top: Int = 0, val left: Int = 0, val bottom: Int = 0, val right: Int = 0)
 
@@ -29,11 +32,16 @@ interface MapProvider {
   fun setPitchEnabled(enabled: Boolean)
   fun setUserLocationEnabled(enabled: Boolean)
   fun setUserLocationButtonEnabled(enabled: Boolean)
+  fun setMapType(value: String)
   fun setTheme(value: String)
   fun setMinZoom(zoom: Double)
   fun setMaxZoom(zoom: Double)
   fun setEdgeInsets(edgeInsets: EdgeInsets)
   fun setEdgeInsets(edgeInsets: EdgeInsets, duration: Int)
+  fun setInsetAdjustment(value: String)
+  fun setPoiEnabled(enabled: Boolean)
+  fun setPoiFilterMode(mode: String)
+  fun setPoiFilterCategories(categories: List<String>)
 
   // Children
   fun addMarkerView(markerView: LuggMarkerView)
@@ -42,6 +50,12 @@ interface MapProvider {
   fun removePolylineView(polylineView: LuggPolylineView)
   fun addPolygonView(polygonView: LuggPolygonView)
   fun removePolygonView(polygonView: LuggPolygonView)
+  fun addCircleView(circleView: LuggCircleView)
+  fun removeCircleView(circleView: LuggCircleView)
+  fun addGroundOverlayView(groundOverlayView: LuggGroundOverlayView)
+  fun removeGroundOverlayView(groundOverlayView: LuggGroundOverlayView)
+  fun addTileOverlayView(tileOverlayView: LuggTileOverlayView)
+  fun removeTileOverlayView(tileOverlayView: LuggTileOverlayView)
 
   // Lifecycle
   fun pauseAnimations()

package/android/src/main/java/com/luggmaps/core/PolylineAnimator.kt

@@ -15,6 +15,7 @@ import kotlin.math.min
 class PolylineAnimator {
   companion object {
     private const val MAX_ANIMATION_SPANS = 16
+    private const val MAX_GRADIENT_SPANS = 512
   }
 
   var polyline: Polyline? = null
@@ -209,8 +210,9 @@ class PolylineAnimator {
     }
 
     if (headDist <= tailDist) {
-      poly.points = listOf(coordinates.firstOrNull() ?: LatLng(0.0, 0.0))
+      val point = coordinates.firstOrNull() ?: LatLng(0.0, 0.0)
       poly.color = strokeColors.firstOrNull() ?: Color.BLACK
+      poly.points = listOf(point, point)
       return
     }
 
@@ -234,11 +236,12 @@ class PolylineAnimator {
 
     if (reusablePoints.size < 2) return
 
+    // Clear spans before setting points to prevent IndexOutOfBoundsException
+    // when the new points list is shorter than what existing spans reference
+    poly.color = strokeColors.firstOrNull() ?: Color.BLACK
     poly.points = ArrayList(reusablePoints)
 
-    if (strokeColors.size <= 1) {
-      poly.color = strokeColors.firstOrNull() ?: Color.BLACK
-    } else {
+    if (strokeColors.size > 1) {
       val segmentCount = reusablePoints.size - 1
       val spanCount = min(segmentCount, MAX_ANIMATION_SPANS)
       val segmentsPerSpan = segmentCount.toDouble() / spanCount
@@ -255,10 +258,12 @@ class PolylineAnimator {
 
   private fun createGradientSpans(): List<StyleSpan> {
     val segmentCount = coordinates.size - 1
-    return (0 until segmentCount).map { i ->
-      val position = i.toFloat() / segmentCount
+    val spanCount = min(segmentCount, MAX_GRADIENT_SPANS)
+    val segmentsPerSpan = segmentCount.toDouble() / spanCount
+    return (0 until spanCount).map { i ->
+      val position = (i + 0.5f) / spanCount
       val color = colorAtGradientPosition(position)
-      StyleSpan(StrokeStyle.colorBuilder(color).build())
+      StyleSpan(StrokeStyle.colorBuilder(color).build(), segmentsPerSpan)
     }
   }
 

package/android/src/main/java/com/luggmaps/events/CirclePressEvent.kt

@@ -0,0 +1,12 @@
+package com.luggmaps.events
+
+import android.view.View
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.uimanager.UIManagerHelper
+import com.facebook.react.uimanager.events.Event
+
+class CirclePressEvent(view: View) : Event<CirclePressEvent>(UIManagerHelper.getSurfaceId(view), view.id) {
+  override fun getEventName() = "topCirclePress"
+
+  override fun getEventData() = Arguments.createMap()
+}

package/android/src/main/java/com/luggmaps/events/GroundOverlayPressEvent.kt

@@ -0,0 +1,12 @@
+package com.luggmaps.events
+
+import android.view.View
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.uimanager.UIManagerHelper
+import com.facebook.react.uimanager.events.Event
+
+class GroundOverlayPressEvent(view: View) : Event<GroundOverlayPressEvent>(UIManagerHelper.getSurfaceId(view), view.id) {
+  override fun getEventName() = "topGroundOverlayPress"
+
+  override fun getEventData() = Arguments.createMap()
+}

package/android/src/main/java/com/luggmaps/events/TileOverlayPressEvent.kt

@@ -0,0 +1,12 @@
+package com.luggmaps.events
+
+import android.view.View
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.uimanager.UIManagerHelper
+import com.facebook.react.uimanager.events.Event
+
+class TileOverlayPressEvent(view: View) : Event<TileOverlayPressEvent>(UIManagerHelper.getSurfaceId(view), view.id) {
+  override fun getEventName() = "topTileOverlayPress"
+
+  override fun getEventData() = Arguments.createMap()
+}

package/android/src/main/java/com/luggmaps/extensions/ViewExtensions.kt

@@ -1,6 +1,7 @@
 package com.luggmaps.extensions
 
 import android.view.View
+import android.view.ViewGroup
 import com.facebook.react.uimanager.ThemedReactContext
 import com.facebook.react.uimanager.UIManagerHelper
 import com.facebook.react.uimanager.events.Event
@@ -12,3 +13,13 @@ fun View.dispatchEvent(event: Event<*>) {
   )
   eventDispatcher?.dispatchEvent(event)
 }
+
+fun View.findViewByTag(tag: String): View? {
+  if (this.tag?.toString() == tag) return this
+  if (this !is ViewGroup) return null
+  for (i in 0 until childCount) {
+    val found = getChildAt(i).findViewByTag(tag)
+    if (found != null) return found
+  }
+  return null
+}

package/ios/LuggCalloutView.h

@@ -0,0 +1,23 @@
+#import <React/RCTViewComponentView.h>
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@class LuggCalloutView;
+
+@protocol LuggCalloutViewDelegate <NSObject>
+@optional
+- (void)calloutViewDidUpdate:(LuggCalloutView *)calloutView;
+@end
+
+@interface LuggCalloutView : RCTViewComponentView
+
+@property(nonatomic, readonly) BOOL bubbled;
+@property(nonatomic, readonly) CGPoint offset;
+@property(nonatomic, readonly) BOOL hasCustomContent;
+@property(nonatomic, readonly) UIView *contentView;
+@property(nonatomic, weak, nullable) id<LuggCalloutViewDelegate> delegate;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/LuggCalloutView.mm

@@ -0,0 +1,155 @@
+#import "LuggCalloutView.h"
+
+#import <react/renderer/components/RNMapsSpec/ComponentDescriptors.h>
+#import <react/renderer/components/RNMapsSpec/Props.h>
+#import <react/renderer/components/RNMapsSpec/RCTComponentViewHelpers.h>
+
+#import "RCTFabricComponentsPlugins.h"
+
+using namespace facebook::react;
+
+@interface LuggCalloutContentView : UIView
+- (void)updateContentSize;
+@end
+
+@implementation LuggCalloutContentView
+
+- (CGSize)intrinsicContentSize {
+  CGFloat width = 0;
+  CGFloat height = 0;
+  for (UIView *subview in self.subviews) {
+    width = MAX(width, CGRectGetMaxX(subview.frame));
+    height = MAX(height, CGRectGetMaxY(subview.frame));
+  }
+  if (width > 0 && height > 0) {
+    return CGSizeMake(width, height);
+  }
+  return CGSizeMake(UIViewNoIntrinsicMetric, UIViewNoIntrinsicMetric);
+}
+
+- (void)updateContentSize {
+  CGSize size = [self intrinsicContentSize];
+  if (size.width > 0 && size.height > 0) {
+    self.frame = CGRectMake(0, 0, size.width, size.height);
+  }
+  [self invalidateIntrinsicContentSize];
+}
+
+@end
+
+@interface LuggCalloutView () <RCTLuggCalloutViewViewProtocol>
+@end
+
+@implementation LuggCalloutView {
+  LuggCalloutContentView *_contentView;
+  BOOL _bubbled;
+  CGPoint _offset;
+}
+
++ (ComponentDescriptorProvider)componentDescriptorProvider {
+  return concreteComponentDescriptorProvider<
+      LuggCalloutViewComponentDescriptor>();
+}
+
+- (instancetype)initWithFrame:(CGRect)frame {
+  if (self = [super initWithFrame:frame]) {
+    static const auto defaultProps =
+        std::make_shared<const LuggCalloutViewProps>();
+    _props = defaultProps;
+
+    _bubbled = YES;
+    _offset = CGPointZero;
+    _contentView = [[LuggCalloutContentView alloc] init];
+    _contentView.backgroundColor = [UIColor clearColor];
+
+    self.backgroundColor = [UIColor clearColor];
+    self.hidden = YES;
+  }
+
+  return self;
+}
+
+- (void)updateProps:(const Props::Shared &)props
+           oldProps:(const Props::Shared &)oldProps {
+  const auto &newViewProps =
+      *std::static_pointer_cast<LuggCalloutViewProps const>(props);
+
+  BOOL changed = NO;
+
+  if (_bubbled != newViewProps.bubbled) {
+    _bubbled = newViewProps.bubbled;
+    changed = YES;
+  }
+
+  if (oldProps) {
+    const auto &oldViewProps =
+        *std::static_pointer_cast<LuggCalloutViewProps const>(oldProps);
+    if (newViewProps.offset.x != oldViewProps.offset.x ||
+        newViewProps.offset.y != oldViewProps.offset.y) {
+      _offset = CGPointMake(newViewProps.offset.x, newViewProps.offset.y);
+      changed = YES;
+    }
+  } else if (newViewProps.offset.x != 0 || newViewProps.offset.y != 0) {
+    _offset = CGPointMake(newViewProps.offset.x, newViewProps.offset.y);
+    changed = YES;
+  }
+
+  [super updateProps:props oldProps:oldProps];
+
+  if (changed) {
+    [_delegate calloutViewDidUpdate:self];
+  }
+}
+
+- (BOOL)bubbled {
+  return _bubbled;
+}
+
+- (CGPoint)offset {
+  return _offset;
+}
+
+- (void)mountChildComponentView:
+            (UIView<RCTComponentViewProtocol> *)childComponentView
+                          index:(NSInteger)index {
+  [_contentView insertSubview:childComponentView atIndex:index];
+  [_contentView updateContentSize];
+}
+
+- (void)unmountChildComponentView:
+            (UIView<RCTComponentViewProtocol> *)childComponentView
+                            index:(NSInteger)index {
+  [childComponentView removeFromSuperview];
+  [_contentView updateContentSize];
+}
+
+- (void)layoutSubviews {
+  [super layoutSubviews];
+  CGSize oldSize = _contentView.bounds.size;
+  [_contentView updateContentSize];
+  CGSize newSize = _contentView.bounds.size;
+  if (!CGSizeEqualToSize(oldSize, newSize)) {
+    [_delegate calloutViewDidUpdate:self];
+  }
+}
+
+- (BOOL)hasCustomContent {
+  return _contentView.subviews.count > 0;
+}
+
+- (UIView *)contentView {
+  return _contentView;
+}
+
+- (void)prepareForRecycle {
+  [super prepareForRecycle];
+  for (UIView *subview in _contentView.subviews) {
+    [subview removeFromSuperview];
+  }
+}
+
+Class<RCTComponentViewProtocol> LuggCalloutViewCls(void) {
+  return LuggCalloutView.class;
+}
+
+@end

package/ios/LuggCircleView.h

@@ -0,0 +1,31 @@
+#import <CoreLocation/CoreLocation.h>
+#import <React/RCTViewComponentView.h>
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@class LuggCircleView;
+
+@protocol LuggCircleViewDelegate <NSObject>
+@optional
+- (void)circleViewDidUpdate:(LuggCircleView *)circleView;
+@end
+
+@interface LuggCircleView : RCTViewComponentView
+
+@property(nonatomic, readonly) CLLocationCoordinate2D center;
+@property(nonatomic, readonly) CLLocationDistance radius;
+@property(nonatomic, readonly) UIColor *strokeColor;
+@property(nonatomic, readonly) UIColor *fillColor;
+@property(nonatomic, readonly) CGFloat strokeWidth;
+@property(nonatomic, readonly) NSInteger zIndex;
+@property(nonatomic, readonly) BOOL tappable;
+@property(nonatomic, weak, nullable) id<LuggCircleViewDelegate> delegate;
+@property(nonatomic, strong, nullable) NSObject *circle;
+@property(nonatomic, weak, nullable) NSObject *renderer;
+
+- (void)emitPressEvent;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/LuggCircleView.mm

@@ -0,0 +1,133 @@
+#import "LuggCircleView.h"
+#import "events/CirclePressEvent.h"
+
+#import <react/renderer/components/RNMapsSpec/ComponentDescriptors.h>
+#import <react/renderer/components/RNMapsSpec/EventEmitters.h>
+#import <react/renderer/components/RNMapsSpec/Props.h>
+#import <react/renderer/components/RNMapsSpec/RCTComponentViewHelpers.h>
+
+#import "RCTFabricComponentsPlugins.h"
+#import <React/RCTConversions.h>
+
+using namespace facebook::react;
+using namespace luggmaps::events;
+
+@interface LuggCircleView () <RCTLuggCircleViewViewProtocol>
+@end
+
+@implementation LuggCircleView {
+  CLLocationCoordinate2D _center;
+  CLLocationDistance _radius;
+  UIColor *_strokeColor;
+  UIColor *_fillColor;
+  CGFloat _strokeWidth;
+  NSInteger _zIndex;
+  BOOL _tappable;
+}
+
++ (ComponentDescriptorProvider)componentDescriptorProvider {
+  return concreteComponentDescriptorProvider<
+      LuggCircleViewComponentDescriptor>();
+}
+
+- (instancetype)initWithFrame:(CGRect)frame {
+  if (self = [super initWithFrame:frame]) {
+    static const auto defaultProps =
+        std::make_shared<const LuggCircleViewProps>();
+    _props = defaultProps;
+
+    _center = CLLocationCoordinate2DMake(0, 0);
+    _radius = 0;
+    _strokeColor = [UIColor blackColor];
+    _fillColor = [UIColor colorWithRed:0 green:0 blue:0 alpha:0.3];
+    _strokeWidth = 1.0;
+
+    self.hidden = YES;
+  }
+
+  return self;
+}
+
+- (void)updateProps:(Props::Shared const &)props
+           oldProps:(Props::Shared const &)oldProps {
+  [super updateProps:props oldProps:oldProps];
+  const auto &newViewProps =
+      *std::static_pointer_cast<LuggCircleViewProps const>(props);
+
+  _center = CLLocationCoordinate2DMake(newViewProps.center.latitude,
+                                       newViewProps.center.longitude);
+  _radius = newViewProps.radius;
+
+  if (newViewProps.strokeColor) {
+    UIColor *color = RCTUIColorFromSharedColor(newViewProps.strokeColor);
+    if (color) {
+      _strokeColor = color;
+    }
+  }
+
+  if (newViewProps.fillColor) {
+    UIColor *color = RCTUIColorFromSharedColor(newViewProps.fillColor);
+    if (color) {
+      _fillColor = color;
+    }
+  }
+
+  _strokeWidth = newViewProps.strokeWidth > 0 ? newViewProps.strokeWidth : 1.0;
+  _zIndex = newViewProps.zIndex.value_or(0);
+  _tappable = newViewProps.tappable;
+}
+
+- (void)finalizeUpdates:(RNComponentViewUpdateMask)updateMask {
+  [super finalizeUpdates:updateMask];
+
+  if (updateMask & RNComponentViewUpdateMaskProps) {
+    if ([self.delegate respondsToSelector:@selector(circleViewDidUpdate:)]) {
+      [self.delegate circleViewDidUpdate:self];
+    }
+  }
+}
+
+- (CLLocationCoordinate2D)center {
+  return _center;
+}
+
+- (CLLocationDistance)radius {
+  return _radius;
+}
+
+- (UIColor *)strokeColor {
+  return _strokeColor;
+}
+
+- (UIColor *)fillColor {
+  return _fillColor;
+}
+
+- (CGFloat)strokeWidth {
+  return _strokeWidth;
+}
+
+- (NSInteger)zIndex {
+  return _zIndex;
+}
+
+- (BOOL)tappable {
+  return _tappable;
+}
+
+- (void)emitPressEvent {
+  CirclePressEvent::emit<LuggCircleViewEventEmitter>(_eventEmitter);
+}
+
+- (void)prepareForRecycle {
+  [super prepareForRecycle];
+  self.circle = nil;
+  self.renderer = nil;
+  self.delegate = nil;
+}
+
+Class<RCTComponentViewProtocol> LuggCircleViewCls(void) {
+  return LuggCircleView.class;
+}
+
+@end

package/ios/LuggGroundOverlayView.h

@@ -0,0 +1,30 @@
+#import <CoreLocation/CoreLocation.h>
+#import <React/RCTViewComponentView.h>
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@class LuggGroundOverlayView;
+
+@protocol LuggGroundOverlayViewDelegate <NSObject>
+@optional
+- (void)groundOverlayViewDidUpdate:(LuggGroundOverlayView *)groundOverlayView;
+@end
+
+@interface LuggGroundOverlayView : RCTViewComponentView
+
+@property(nonatomic, readonly) NSString *imageUri;
+@property(nonatomic, readonly) CLLocationCoordinate2D northeast;
+@property(nonatomic, readonly) CLLocationCoordinate2D southwest;
+@property(nonatomic, readonly) CGFloat opacity;
+@property(nonatomic, readonly) CGFloat bearing;
+@property(nonatomic, readonly) NSInteger zIndex;
+@property(nonatomic, readonly) BOOL tappable;
+@property(nonatomic, weak, nullable) id<LuggGroundOverlayViewDelegate> delegate;
+@property(nonatomic, strong, nullable) NSObject *overlay;
+
+- (void)emitPressEvent;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/LuggGroundOverlayView.mm

@@ -0,0 +1,125 @@
+#import "LuggGroundOverlayView.h"
+#import "events/GroundOverlayPressEvent.h"
+
+#import <react/renderer/components/RNMapsSpec/ComponentDescriptors.h>
+#import <react/renderer/components/RNMapsSpec/EventEmitters.h>
+#import <react/renderer/components/RNMapsSpec/Props.h>
+#import <react/renderer/components/RNMapsSpec/RCTComponentViewHelpers.h>
+
+#import "RCTFabricComponentsPlugins.h"
+
+using namespace facebook::react;
+using namespace luggmaps::events;
+
+@interface LuggGroundOverlayView () <RCTLuggGroundOverlayViewViewProtocol>
+@end
+
+@implementation LuggGroundOverlayView {
+  NSString *_imageUri;
+  CLLocationCoordinate2D _northeast;
+  CLLocationCoordinate2D _southwest;
+  CGFloat _opacity;
+  CGFloat _bearing;
+  NSInteger _zIndex;
+  BOOL _tappable;
+}
+
++ (ComponentDescriptorProvider)componentDescriptorProvider {
+  return concreteComponentDescriptorProvider<
+      LuggGroundOverlayViewComponentDescriptor>();
+}
+
+- (instancetype)initWithFrame:(CGRect)frame {
+  if (self = [super initWithFrame:frame]) {
+    static const auto defaultProps =
+        std::make_shared<const LuggGroundOverlayViewProps>();
+    _props = defaultProps;
+
+    _imageUri = @"";
+    _northeast = CLLocationCoordinate2DMake(0, 0);
+    _southwest = CLLocationCoordinate2DMake(0, 0);
+    _opacity = 1.0;
+    _bearing = 0.0;
+
+    self.hidden = YES;
+  }
+
+  return self;
+}
+
+- (void)updateProps:(Props::Shared const &)props
+           oldProps:(Props::Shared const &)oldProps {
+  [super updateProps:props oldProps:oldProps];
+  const auto &newViewProps =
+      *std::static_pointer_cast<LuggGroundOverlayViewProps const>(props);
+
+  _imageUri = [NSString stringWithUTF8String:newViewProps.image.c_str()];
+
+  _northeast =
+      CLLocationCoordinate2DMake(newViewProps.bounds.northeast.latitude,
+                                 newViewProps.bounds.northeast.longitude);
+  _southwest =
+      CLLocationCoordinate2DMake(newViewProps.bounds.southwest.latitude,
+                                 newViewProps.bounds.southwest.longitude);
+
+  _opacity = newViewProps.opacity;
+  _bearing = newViewProps.bearing;
+  _zIndex = newViewProps.zIndex.value_or(0);
+  _tappable = newViewProps.tappable;
+}
+
+- (void)finalizeUpdates:(RNComponentViewUpdateMask)updateMask {
+  [super finalizeUpdates:updateMask];
+
+  if (updateMask & RNComponentViewUpdateMaskProps) {
+    if ([self.delegate
+            respondsToSelector:@selector(groundOverlayViewDidUpdate:)]) {
+      [self.delegate groundOverlayViewDidUpdate:self];
+    }
+  }
+}
+
+- (NSString *)imageUri {
+  return _imageUri;
+}
+
+- (CLLocationCoordinate2D)northeast {
+  return _northeast;
+}
+
+- (CLLocationCoordinate2D)southwest {
+  return _southwest;
+}
+
+- (CGFloat)opacity {
+  return _opacity;
+}
+
+- (CGFloat)bearing {
+  return _bearing;
+}
+
+- (NSInteger)zIndex {
+  return _zIndex;
+}
+
+- (BOOL)tappable {
+  return _tappable;
+}
+
+- (void)emitPressEvent {
+  GroundOverlayPressEvent::emit<LuggGroundOverlayViewEventEmitter>(
+      _eventEmitter);
+}
+
+- (void)prepareForRecycle {
+  [super prepareForRecycle];
+  self.overlay = nil;
+  self.delegate = nil;
+}
+
+Class<RCTComponentViewProtocol> LuggGroundOverlayViewCls(void) {
+  return LuggGroundOverlayView.class;
+}
+
+@end