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

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 anchor;
+@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,145 @@
+#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 _anchor;
+}
+
++ (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;
+    _anchor = CGPointMake(0.5, 1.0);
+    _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);
+
+  _bubbled = newViewProps.bubbled;
+
+  if (oldProps) {
+    const auto &oldViewProps =
+        *std::static_pointer_cast<LuggCalloutViewProps const>(oldProps);
+    if (newViewProps.anchor.x != oldViewProps.anchor.x ||
+        newViewProps.anchor.y != oldViewProps.anchor.y) {
+      _anchor = CGPointMake(newViewProps.anchor.x, newViewProps.anchor.y);
+    }
+  } else if (newViewProps.anchor.x != 0 || newViewProps.anchor.y != 0) {
+    _anchor = CGPointMake(newViewProps.anchor.x, newViewProps.anchor.y);
+  }
+
+  [super updateProps:props oldProps:oldProps];
+  [_delegate calloutViewDidUpdate:self];
+}
+
+- (BOOL)bubbled {
+  return _bubbled;
+}
+
+- (CGPoint)anchor {
+  return _anchor;
+}
+
+- (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/LuggMarkerView.h

@@ -5,6 +5,7 @@
 NS_ASSUME_NONNULL_BEGIN
 
 @class LuggMarkerView;
+@class LuggCalloutView;
 
 @protocol LuggMarkerViewDelegate <NSObject>
 @optional
@@ -27,6 +28,7 @@ NS_ASSUME_NONNULL_BEGIN
 @property(nonatomic, readonly) BOOL hasCustomView;
 @property(nonatomic, readonly) BOOL didLayout;
 @property(nonatomic, readonly) UIView *iconView;
+@property(nonatomic, readonly, nullable) LuggCalloutView *calloutView;
 @property(nonatomic, weak, nullable) id<LuggMarkerViewDelegate> delegate;
 @property(nonatomic, strong, nullable) NSObject *marker;
 

package/ios/LuggMarkerView.mm

@@ -1,4 +1,5 @@
 #import "LuggMarkerView.h"
+#import "LuggCalloutView.h"
 #import "events/MarkerDragEvent.h"
 #import "events/MarkerPressEvent.h"
 
@@ -28,6 +29,7 @@ using namespace luggmaps::events;
   BOOL _draggable;
   BOOL _didLayout;
   UIView *_iconView;
+  LuggCalloutView *_calloutView;
 }
 
 + (ComponentDescriptorProvider)componentDescriptorProvider {
@@ -92,14 +94,22 @@ using namespace luggmaps::events;
 - (void)mountChildComponentView:
             (UIView<RCTComponentViewProtocol> *)childComponentView
                           index:(NSInteger)index {
-  [_iconView insertSubview:childComponentView atIndex:index];
+  if ([childComponentView isKindOfClass:[LuggCalloutView class]]) {
+    _calloutView = (LuggCalloutView *)childComponentView;
+  } else {
+    [_iconView insertSubview:childComponentView atIndex:index];
+  }
   _didLayout = NO;
 }
 
 - (void)unmountChildComponentView:
             (UIView<RCTComponentViewProtocol> *)childComponentView
                             index:(NSInteger)index {
-  [childComponentView removeFromSuperview];
+  if ([childComponentView isKindOfClass:[LuggCalloutView class]]) {
+    _calloutView = nil;
+  } else {
+    [childComponentView removeFromSuperview];
+  }
   _didLayout = NO;
 }
 
@@ -180,6 +190,10 @@ using namespace luggmaps::events;
   return _iconView;
 }
 
+- (LuggCalloutView *)calloutView {
+  return _calloutView;
+}
+
 - (UIImage *)createIconImage {
   CGSize size = _iconView.bounds.size;
   if (size.width <= 0 || size.height <= 0) {
@@ -271,6 +285,7 @@ using namespace luggmaps::events;
 - (void)prepareForRecycle {
   [super prepareForRecycle];
   _didLayout = NO;
+  _calloutView = nil;
   self.marker = nil;
   self.delegate = nil;
   [self resetIconViewTransform];

package/ios/core/AppleMapProvider.mm

@@ -1,8 +1,10 @@
 #import "AppleMapProvider.h"
+#import "../LuggCalloutView.h"
 #import "../LuggMarkerView.h"
 #import "../LuggPolygonView.h"
 #import "../LuggPolylineView.h"
 #import "../extensions/MKMapView+Zoom.h"
+#import "LuggAnnotationView.h"
 #import "MKPolylineAnimator.h"
 
 @interface AppleMarkerAnnotation : NSObject <MKAnnotation>
@@ -11,6 +13,7 @@
 @property(nonatomic, copy, nullable) NSString *subtitle;
 @property(nonatomic, strong) LuggMarkerView *markerView;
 @property(nonatomic, weak) MKAnnotationView *annotationView;
+@property(nonatomic, copy, nullable) dispatch_block_t pendingScaleAnimation;
 @end
 
 @implementation AppleMarkerAnnotation
@@ -20,11 +23,12 @@
 @end
 
 @interface AppleMapProvider () <
-    LuggMarkerViewDelegate, LuggPolylineViewDelegate, LuggPolygonViewDelegate,
-    UIGestureRecognizerDelegate>
+    LuggMarkerViewDelegate, LuggCalloutViewDelegate, LuggPolylineViewDelegate,
+    LuggPolygonViewDelegate, UIGestureRecognizerDelegate>
 @end
 
 @implementation AppleMapProvider {
+  UIView *_wrapperView;
   LuggAppleMapViewContent *_mapView;
   BOOL _isMapReady;
   BOOL _isDragging;
@@ -34,6 +38,8 @@
   NSMapTable<id<MKOverlay>, LuggPolygonView *> *_overlayToPolygonMap;
   UITapGestureRecognizer *_tapGesture;
   UILongPressGestureRecognizer *_longPressGesture;
+  LuggMarkerView *_activeNonBubbledMarker;
+  BOOL _isReselectingAnnotation;
   // Edge insets animation
   CADisplayLink *_edgeInsetsDisplayLink;
   UIEdgeInsets _edgeInsetsFrom;
@@ -91,6 +97,7 @@
 
   [_tapGesture requireGestureRecognizerToFail:_longPressGesture];
 
+  _wrapperView = wrapperView;
   [wrapperView addSubview:_mapView];
 
   MKCoordinateRegion region = [_mapView regionForCenterCoordinate:coordinate
@@ -103,6 +110,7 @@
 }
 
 - (void)destroy {
+  [self dismissNonBubbledCallout];
   [self stopEdgeInsetsAnimation];
   if (_tapGesture) {
     [_mapView removeGestureRecognizer:_tapGesture];
@@ -319,11 +327,24 @@
   return NO;
 }
 
+- (BOOL)hitTestCalloutAtPoint:(CGPoint)point {
+  if (!_activeNonBubbledMarker)
+    return NO;
+
+  UIView *contentView = _activeNonBubbledMarker.calloutView.contentView;
+  CGPoint local = [contentView convertPoint:point fromView:_mapView];
+  return [contentView pointInside:local withEvent:nil];
+}
+
 - (void)handleTap:(UITapGestureRecognizer *)gesture {
   if (gesture.state != UIGestureRecognizerStateEnded)
     return;
 
   CGPoint point = [gesture locationInView:_mapView];
+  if ([self hitTestCalloutAtPoint:point])
+    return;
+
+  [self dismissNonBubbledCallout];
 
   if ([self hitTestAnnotationAtPoint:point])
     return;
@@ -390,6 +411,7 @@
                             longitude:mapView.centerCoordinate.longitude
                                  zoom:mapView.zoomLevel
                               gesture:_isDragging];
+  [self positionNonBubbledCallout];
 }
 
 - (void)mapView:(MKMapView *)mapView regionDidChangeAnimated:(BOOL)animated {
@@ -423,22 +445,23 @@
   }
 
   if (!markerView.hasCustomView) {
-    MKMarkerAnnotationView *markerAnnotationView =
-        [[MKMarkerAnnotationView alloc] initWithAnnotation:annotation
-                                           reuseIdentifier:nil];
+    LuggMarkerAnnotationView *markerAnnotationView =
+        [[LuggMarkerAnnotationView alloc] initWithAnnotation:annotation
+                                             reuseIdentifier:nil];
     markerAnnotationView.canShowCallout = YES;
     markerAnnotationView.displayPriority = MKFeatureDisplayPriorityRequired;
     markerAnnotationView.layer.zPosition = markerView.zIndex;
     markerAnnotationView.zPriority = markerView.zIndex;
     markerAnnotationView.draggable = markerView.draggable;
+    [self applyCalloutView:markerView annotationView:markerAnnotationView];
     [self addCenterTapGesture:markerAnnotationView];
     markerAnnotation.annotationView = markerAnnotationView;
     return markerAnnotationView;
   }
 
-  MKAnnotationView *annotationView =
-      [[MKAnnotationView alloc] initWithAnnotation:annotation
-                                   reuseIdentifier:nil];
+  LuggAnnotationView *annotationView =
+      [[LuggAnnotationView alloc] initWithAnnotation:annotation
+                                     reuseIdentifier:nil];
   annotationView.canShowCallout = YES;
   annotationView.displayPriority = MKFeatureDisplayPriorityRequired;
   annotationView.layer.zPosition = markerView.zIndex;
@@ -446,6 +469,8 @@
   annotationView.draggable = markerView.draggable;
   [self addCenterTapGesture:annotationView];
 
+  [self applyCalloutView:markerView annotationView:annotationView];
+
   if (!markerView.rasterize) {
     UIView *iconView = markerView.iconView;
     [iconView removeFromSuperview];
@@ -516,6 +541,108 @@
     CGPoint point = [_mapView convertCoordinate:markerView.coordinate
                                   toPointToView:_mapView];
     [markerView emitPressEventWithPoint:point];
+
+    LuggCalloutView *calloutView = markerView.calloutView;
+    if (calloutView && !calloutView.bubbled && calloutView.hasCustomContent) {
+      [self showNonBubbledCallout:markerView];
+    }
+  }
+}
+
+- (void)mapView:(MKMapView *)mapView
+    didDeselectAnnotationView:(MKAnnotationView *)view {
+  if (![view.annotation isKindOfClass:[AppleMarkerAnnotation class]])
+    return;
+
+  AppleMarkerAnnotation *annotation = (AppleMarkerAnnotation *)view.annotation;
+  LuggMarkerView *markerView = annotation.markerView;
+
+  if (markerView && _activeNonBubbledMarker == markerView &&
+      !_isReselectingAnnotation) {
+    _isReselectingAnnotation = YES;
+    [_mapView selectAnnotation:annotation animated:NO];
+    _isReselectingAnnotation = NO;
+  }
+}
+
+- (void)showNonBubbledCallout:(LuggMarkerView *)markerView {
+  [self dismissNonBubbledCallout];
+
+  LuggCalloutView *calloutView = markerView.calloutView;
+  UIView *contentView = calloutView.contentView;
+  [contentView removeFromSuperview];
+
+  contentView.userInteractionEnabled = YES;
+  contentView.hidden = YES;
+  calloutView.delegate = self;
+
+  AppleMarkerAnnotation *annotation =
+      (AppleMarkerAnnotation *)markerView.marker;
+  MKAnnotationView *annotationView = annotation.annotationView;
+  if (annotationView) {
+    annotationView.clipsToBounds = NO;
+    [annotationView addSubview:contentView];
+  } else {
+    [_wrapperView addSubview:contentView];
+  }
+
+  _activeNonBubbledMarker = markerView;
+  dispatch_async(dispatch_get_main_queue(), ^{
+    [self positionNonBubbledCallout];
+    contentView.hidden = NO;
+  });
+}
+
+- (void)calloutViewDidUpdate:(LuggCalloutView *)calloutView {
+  [self positionNonBubbledCallout];
+}
+
+- (void)positionNonBubbledCallout {
+  if (!_activeNonBubbledMarker)
+    return;
+
+  LuggCalloutView *calloutView = _activeNonBubbledMarker.calloutView;
+  UIView *contentView = calloutView.contentView;
+  CGSize contentSize = contentView.bounds.size;
+  if (contentSize.width <= 0 || contentSize.height <= 0)
+    return;
+
+  CGPoint anchor = calloutView.anchor;
+
+  AppleMarkerAnnotation *annotation =
+      (AppleMarkerAnnotation *)_activeNonBubbledMarker.marker;
+  MKAnnotationView *annotationView = annotation.annotationView;
+
+  if (annotationView && contentView.superview == annotationView) {
+    CGPoint center = CGPointMake(annotationView.bounds.size.width / 2.0 +
+                                     contentSize.width * (0.5 - anchor.x),
+                                 annotationView.bounds.size.height / 2.0 +
+                                     contentSize.height * (0.5 - anchor.y));
+    contentView.center = center;
+  } else {
+    CGPoint point =
+        [_mapView convertCoordinate:_activeNonBubbledMarker.coordinate
+                      toPointToView:_wrapperView];
+    contentView.center =
+        CGPointMake(point.x + contentSize.width * (0.5 - anchor.x),
+                    point.y + contentSize.height * (0.5 - anchor.y));
+  }
+}
+
+- (void)dismissNonBubbledCallout {
+  if (!_activeNonBubbledMarker)
+    return;
+
+  LuggMarkerView *markerView = _activeNonBubbledMarker;
+  _activeNonBubbledMarker = nil;
+
+  markerView.calloutView.delegate = nil;
+  [markerView.calloutView.contentView removeFromSuperview];
+
+  AppleMarkerAnnotation *annotation =
+      (AppleMarkerAnnotation *)markerView.marker;
+  if (annotation) {
+    [_mapView deselectAnnotation:annotation animated:NO];
   }
 }
 
@@ -574,6 +701,27 @@
   }
 }
 
+- (void)applyCalloutView:(LuggMarkerView *)markerView
+          annotationView:(MKAnnotationView *)annotationView {
+  LuggCalloutView *calloutView = markerView.calloutView;
+  if (!calloutView) {
+    annotationView.detailCalloutAccessoryView = nil;
+    annotationView.rightCalloutAccessoryView = nil;
+    return;
+  }
+
+  annotationView.rightCalloutAccessoryView = nil;
+
+  if (!calloutView.bubbled) {
+    annotationView.canShowCallout = NO;
+    annotationView.detailCalloutAccessoryView = nil;
+    return;
+  }
+
+  annotationView.detailCalloutAccessoryView =
+      calloutView.hasCustomContent ? calloutView.contentView : nil;
+}
+
 #pragma mark - MarkerViewDelegate
 
 - (void)markerViewDidLayout:(LuggMarkerView *)markerView {
@@ -600,6 +748,7 @@
     annotationView.draggable = markerView.draggable;
     annotationView.layer.zPosition = markerView.zIndex;
     annotationView.zPriority = markerView.zIndex;
+    [self applyCalloutView:markerView annotationView:annotationView];
   }
 
   [self updateAnnotationViewFrame:annotation];
@@ -640,6 +789,10 @@
       (AppleMarkerAnnotation *)markerView.marker;
 
   if (annotation) {
+    if (annotation.pendingScaleAnimation) {
+      dispatch_block_cancel(annotation.pendingScaleAnimation);
+      annotation.pendingScaleAnimation = nil;
+    }
     annotation.annotationView.transform = CGAffineTransformIdentity;
     annotation.markerView = nil;
     annotation.annotationView = nil;
@@ -658,31 +811,65 @@
   annotationView.transform = CGAffineTransformIdentity;
 
   UIView *iconView = markerView.iconView;
-  CGRect frame = iconView.frame;
-  if (frame.size.width <= 0 || frame.size.height <= 0)
+  iconView.transform = CGAffineTransformIdentity;
+
+  // Clean up iconView from in-progress rasterize animation
+  if (markerView.rasterize && [iconView superview] == annotationView) {
+    [iconView removeFromSuperview];
+    iconView.layer.anchorPoint = CGPointMake(0.5, 0.5);
+  }
+
+  CGSize size = iconView.bounds.size;
+  if (size.width <= 0 || size.height <= 0)
     return;
 
   CGFloat scale = markerView.scale;
   CGPoint anchor = markerView.anchor;
+  CGFloat scaledWidth = size.width * scale;
+  CGFloat scaledHeight = size.height * scale;
 
-  if (markerView.rasterize) {
-    annotationView.image = [markerView createScaledIconImage];
-  } else {
-    iconView.layer.anchorPoint = anchor;
-    iconView.transform = CGAffineTransformMakeScale(scale, scale);
-    iconView.frame =
-        CGRectMake(frame.size.width * (0.5 - anchor.x) * (scale - 1),
-                   frame.size.height * (0.5 - anchor.y) * (scale - 1),
-                   frame.size.width, frame.size.height);
+  AppleMarkerAnnotation *annotation =
+      (AppleMarkerAnnotation *)markerView.marker;
+
+  // Cancel any pending rasterize
+  if (annotation.pendingScaleAnimation) {
+    dispatch_block_cancel(annotation.pendingScaleAnimation);
+    annotation.pendingScaleAnimation = nil;
+  }
+
+  // Use live iconView during rapid updates (skip expensive rasterize per frame)
+  if (markerView.rasterize && [iconView superview] != annotationView) {
+    annotationView.image = nil;
+    [annotationView addSubview:iconView];
   }
 
-  annotationView.bounds =
-      CGRectMake(0, 0, frame.size.width * scale, frame.size.height * scale);
-  annotationView.centerOffset =
-      CGPointMake(frame.size.width * scale * (anchor.x - 0.5),
-                  -frame.size.height * scale * (anchor.y - 0.5));
+  iconView.layer.anchorPoint = anchor;
+  iconView.bounds = CGRectMake(0, 0, size.width, size.height);
+  iconView.center =
+      CGPointMake(scaledWidth * anchor.x, scaledHeight * anchor.y);
+  iconView.transform = CGAffineTransformMakeScale(scale, scale);
+
+  annotationView.bounds = CGRectMake(0, 0, scaledWidth, scaledHeight);
+  annotationView.centerOffset = CGPointMake(scaledWidth * (0.5 - anchor.x),
+                                            scaledHeight * (0.5 - anchor.y));
   annotationView.transform =
       CGAffineTransformMakeRotation(markerView.rotate * M_PI / 180.0);
+
+  // Debounce: rasterize once updates settle
+  if (markerView.rasterize) {
+    dispatch_block_t rasterizeBlock =
+        dispatch_block_create((dispatch_block_flags_t)0, ^{
+          annotation.pendingScaleAnimation = nil;
+          annotationView.image = [markerView createScaledIconImage];
+          [iconView removeFromSuperview];
+          [markerView resetIconViewTransform];
+        });
+
+    annotation.pendingScaleAnimation = rasterizeBlock;
+    dispatch_after(
+        dispatch_time(DISPATCH_TIME_NOW, (int64_t)(150 * NSEC_PER_MSEC)),
+        dispatch_get_main_queue(), rasterizeBlock);
+  }
 }
 
 - (void)updateAnnotationViewFrame:(AppleMarkerAnnotation *)annotation {