react-native-maps 0.31.0-beta.6 → 1.0.0-beta.1

package/ios/AirGoogleMaps/AIRGoogleMapManager.m

@@ -163,29 +163,6 @@ RCT_EXPORT_METHOD(animateCamera:(nonnull NSNumber *)reactTag
     }];
 }
 
-RCT_EXPORT_METHOD(animateToNavigation:(nonnull NSNumber *)reactTag
-                  withRegion:(MKCoordinateRegion)region
-                  withBearing:(CGFloat)bearing
-                  withAngle:(double)angle
-                  withDuration:(CGFloat)duration)
-{
-  [self.bridge.uiManager addUIBlock:^(__unused RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
-    id view = viewRegistry[reactTag];
-    if (![view isKindOfClass:[AIRGoogleMap class]]) {
-      RCTLogError(@"Invalid view returned from registry, expecting AIRGoogleMap, got: %@", view);
-    } else {
-      [CATransaction begin];
-      [CATransaction setAnimationDuration:duration/1000];
-      AIRGoogleMap *mapView = (AIRGoogleMap *)view;
-      GMSCameraPosition *camera = [AIRGoogleMap makeGMSCameraPositionFromMap:mapView andMKCoordinateRegion:region];
-      [mapView animateToCameraPosition:camera];
-      [mapView animateToViewingAngle:angle];
-      [mapView animateToBearing:bearing];
-      [CATransaction commit];
-    }
-  }];
-}
-
 RCT_EXPORT_METHOD(animateToRegion:(nonnull NSNumber *)reactTag
                   withRegion:(MKCoordinateRegion)region
                   withDuration:(CGFloat)duration)
@@ -207,59 +184,6 @@ RCT_EXPORT_METHOD(animateToRegion:(nonnull NSNumber *)reactTag
   }];
 }
 
-RCT_EXPORT_METHOD(animateToCoordinate:(nonnull NSNumber *)reactTag
-                  withRegion:(CLLocationCoordinate2D)latlng
-                  withDuration:(CGFloat)duration)
-{
-  [self.bridge.uiManager addUIBlock:^(__unused RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
-    id view = viewRegistry[reactTag];
-    if (![view isKindOfClass:[AIRGoogleMap class]]) {
-      RCTLogError(@"Invalid view returned from registry, expecting AIRGoogleMap, got: %@", view);
-    } else {
-      [CATransaction begin];
-      [CATransaction setAnimationDuration:duration/1000];
-      [(AIRGoogleMap *)view animateToLocation:latlng];
-      [CATransaction commit];
-    }
-  }];
-}
-
-RCT_EXPORT_METHOD(animateToViewingAngle:(nonnull NSNumber *)reactTag
-                  withAngle:(double)angle
-                  withDuration:(CGFloat)duration)
-{
-  [self.bridge.uiManager addUIBlock:^(__unused RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
-    id view = viewRegistry[reactTag];
-    if (![view isKindOfClass:[AIRGoogleMap class]]) {
-      RCTLogError(@"Invalid view returned from registry, expecting AIRGoogleMap, got: %@", view);
-    } else {
-      [CATransaction begin];
-      [CATransaction setAnimationDuration:duration/1000];
-      AIRGoogleMap *mapView = (AIRGoogleMap *)view;
-      [mapView animateToViewingAngle:angle];
-      [CATransaction commit];
-    }
-  }];
-}
-
-RCT_EXPORT_METHOD(animateToBearing:(nonnull NSNumber *)reactTag
-                  withBearing:(CGFloat)bearing
-                  withDuration:(CGFloat)duration)
-{
-  [self.bridge.uiManager addUIBlock:^(__unused RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
-    id view = viewRegistry[reactTag];
-    if (![view isKindOfClass:[AIRGoogleMap class]]) {
-      RCTLogError(@"Invalid view returned from registry, expecting AIRGoogleMap, got: %@", view);
-    } else {
-      [CATransaction begin];
-      [CATransaction setAnimationDuration:duration/1000];
-      AIRGoogleMap *mapView = (AIRGoogleMap *)view;
-      [mapView animateToBearing:bearing];
-      [CATransaction commit];
-    }
-  }];
-}
-
 RCT_EXPORT_METHOD(fitToElements:(nonnull NSNumber *)reactTag
                   edgePadding:(nonnull NSDictionary *)edgePadding
                   animated:(BOOL)animated)
@@ -418,25 +342,6 @@ RCT_EXPORT_METHOD(takeSnapshot:(nonnull NSNumber *)reactTag
         else if ([result isEqualToString:@"base64"]) {
             callback(@[[NSNull null], [data base64EncodedStringWithOptions:NSDataBase64EncodingEndLineWithCarriageReturn]]);
         }
-        else if ([result isEqualToString:@"legacy"]) {
-
-            // In the initial (iOS only) implementation of takeSnapshot,
-            // both the uri and the base64 encoded string were returned.
-            // Returning both is rarely useful and in fact causes a
-            // performance penalty when only the file URI is desired.
-            // In that case the base64 encoded string was always marshalled
-            // over the JS-bridge (which is quite slow).
-            // A new more flexible API was created to cover this.
-            // This code should be removed in a future release when the
-            // old API is fully deprecated.
-            [data writeToFile:filePath atomically:YES];
-            NSDictionary *snapshotData = @{
-                                           @"uri": filePath,
-                                           @"data": [data base64EncodedStringWithOptions:NSDataBase64EncodingEndLineWithCarriageReturn]
-                                           };
-            callback(@[[NSNull null], snapshotData]);
-        }
-
     }
     UIGraphicsEndImageContext();
   }];

package/ios/AirMaps/AIRMap.m

@@ -48,7 +48,6 @@ const NSInteger AIRMapMaxZoomLevel = 20;
 @implementation AIRMap
 {
     UIView *_legalLabel;
-    CLLocationManager *_locationManager;
     BOOL _initialRegionSet;
     BOOL _initialCameraSet;
 
@@ -350,12 +349,6 @@ const NSInteger AIRMapMaxZoomLevel = 20;
 - (void)setShowsUserLocation:(BOOL)showsUserLocation
 {
     if (self.showsUserLocation != showsUserLocation) {
-        if (showsUserLocation && !_locationManager) {
-            _locationManager = [CLLocationManager new];
-            if ([_locationManager respondsToSelector:@selector(requestWhenInUseAuthorization)]) {
-                [_locationManager requestWhenInUseAuthorization];
-            }
-        }
         super.showsUserLocation = showsUserLocation;
     }
 }

package/ios/AirMaps/AIRMapManager.m

@@ -278,31 +278,6 @@ RCT_EXPORT_METHOD(animateCamera:(nonnull NSNumber *)reactTag
     }];
 }
 
-
-RCT_EXPORT_METHOD(animateToNavigation:(nonnull NSNumber *)reactTag
-        withRegion:(MKCoordinateRegion)region
-        withBearing:(CGFloat)bearing
-        withAngle:(double)angle
-        withDuration:(CGFloat)duration)
-{
-    [self.bridge.uiManager addUIBlock:^(__unused RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
-        id view = viewRegistry[reactTag];
-        if (![view isKindOfClass:[AIRMap class]]) {
-            RCTLogError(@"Invalid view returned from registry, expecting AIRMap, got: %@", view);
-        } else {
-            AIRMap *mapView = (AIRMap *)view;
-            MKMapCamera *mapCamera = [[mapView camera] copy];
-             [mapCamera setPitch:angle];
-             [mapCamera setHeading:bearing];
-
-            [AIRMap animateWithDuration:duration/1000 animations:^{
-                [(AIRMap *)view setRegion:region animated:YES];
-                [mapView setCamera:mapCamera animated:YES];
-            }];
-        }
-    }];
-}
-
 RCT_EXPORT_METHOD(animateToRegion:(nonnull NSNumber *)reactTag
         withRegion:(MKCoordinateRegion)region
         withDuration:(CGFloat)duration)
@@ -319,68 +294,6 @@ RCT_EXPORT_METHOD(animateToRegion:(nonnull NSNumber *)reactTag
     }];
 }
 
-RCT_EXPORT_METHOD(animateToCoordinate:(nonnull NSNumber *)reactTag
-        withRegion:(CLLocationCoordinate2D)latlng
-        withDuration:(CGFloat)duration)
-{
-    [self.bridge.uiManager addUIBlock:^(__unused RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
-        id view = viewRegistry[reactTag];
-        if (![view isKindOfClass:[AIRMap class]]) {
-            RCTLogError(@"Invalid view returned from registry, expecting AIRMap, got: %@", view);
-        } else {
-            AIRMap *mapView = (AIRMap *)view;
-            MKCoordinateRegion region;
-            region.span = mapView.region.span;
-            region.center = latlng;
-            [AIRMap animateWithDuration:duration/1000 animations:^{
-                [mapView setRegion:region animated:YES];
-            }];
-        }
-    }];
-}
-
-RCT_EXPORT_METHOD(animateToViewingAngle:(nonnull NSNumber *)reactTag
-                  withAngle:(double)angle
-                  withDuration:(CGFloat)duration)
-{
-  [self.bridge.uiManager addUIBlock:^(__unused RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
-      id view = viewRegistry[reactTag];
-      if (![view isKindOfClass:[AIRMap class]]) {
-          RCTLogError(@"Invalid view returned from registry, expecting AIRMap, got: %@", view);
-      } else {
-          AIRMap *mapView = (AIRMap *)view;
-
-          MKMapCamera *mapCamera = [[mapView camera] copy];
-          [mapCamera setPitch:angle];
-
-          [AIRMap animateWithDuration:duration/1000 animations:^{
-              [mapView setCamera:mapCamera animated:YES];
-          }];
-      }
-  }];
-}
-
-RCT_EXPORT_METHOD(animateToBearing:(nonnull NSNumber *)reactTag
-                  withBearing:(CGFloat)bearing
-                  withDuration:(CGFloat)duration)
-{
-  [self.bridge.uiManager addUIBlock:^(__unused RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
-      id view = viewRegistry[reactTag];
-      if (![view isKindOfClass:[AIRMap class]]) {
-          RCTLogError(@"Invalid view returned from registry, expecting AIRMap, got: %@", view);
-      } else {
-          AIRMap *mapView = (AIRMap *)view;
-
-          MKMapCamera *mapCamera = [[mapView camera] copy];
-          [mapCamera setHeading:bearing];
-
-          [AIRMap animateWithDuration:duration/1000 animations:^{
-              [mapView setCamera:mapCamera animated:YES];
-          }];
-      }
-  }];
-}
-
 RCT_EXPORT_METHOD(fitToElements:(nonnull NSNumber *)reactTag
         edgePadding:(nonnull NSDictionary *)edgePadding
         animated:(BOOL)animated)
@@ -677,24 +590,6 @@ RCT_EXPORT_METHOD(getAddressFromCoordinates:(nonnull NSNumber *)reactTag
                       else if ([result isEqualToString:@"base64"]) {
                           callback(@[[NSNull null], [data base64EncodedStringWithOptions:NSDataBase64EncodingEndLineWithCarriageReturn]]);
                       }
-                      else if ([result isEqualToString:@"legacy"]) {
-
-                          // In the initial (iOS only) implementation of takeSnapshot,
-                          // both the uri and the base64 encoded string were returned.
-                          // Returning both is rarely useful and in fact causes a
-                          // performance penalty when only the file URI is desired.
-                          // In that case the base64 encoded string was always marshalled
-                          // over the JS-bridge (which is quite slow).
-                          // A new more flexible API was created to cover this.
-                          // This code should be removed in a future release when the
-                          // old API is fully deprecated.
-                          [data writeToFile:filePath atomically:YES];
-                          NSDictionary *snapshotData = @{
-                                                         @"uri": filePath,
-                                                         @"data": [data base64EncodedStringWithOptions:NSDataBase64EncodingEndLineWithCarriageReturn]
-                                                         };
-                          callback(@[[NSNull null], snapshotData]);
-                      }
                   }
                   UIGraphicsEndImageContext();
               }];

package/lib/AnimatedRegion.d.ts

@@ -0,0 +1,19 @@
+import { Animated } from 'react-native';
+import { Region } from './sharedTypes';
+declare const AnimatedWithChildren: any;
+declare type Props = Partial<Region> | undefined;
+export default class AnimatedMapRegion extends AnimatedWithChildren {
+    constructor(valueIn?: Props);
+    setValue(value: Region): void;
+    setOffset(offset: Region): void;
+    flattenOffset(): void;
+    private __getValue;
+    private __attach;
+    private __detach;
+    stopAnimation(callback: (region: Region) => void): void;
+    addListener(callback: (region: Region) => void): string;
+    removeListener(id: string): void;
+    spring(config: Animated.SpringAnimationConfig & Region): Animated.CompositeAnimation;
+    timing(config: Animated.TimingAnimationConfig & Region): Animated.CompositeAnimation;
+}
+export {};

package/lib/AnimatedRegion.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_native_1 = require("react-native");
+const AnimatedWithChildren = Object.getPrototypeOf(react_native_1.Animated.ValueXY);
+if (__DEV__) {
+    if (AnimatedWithChildren.name !== 'AnimatedWithChildren') {
+        console.error('AnimatedRegion could not obtain AnimatedWithChildren base class');
+    }
+}
+const configTypes = [
+    'latitude',
+    'longitude',
+    'latitudeDelta',
+    'longitudeDelta',
+];
+const defaultValues = {
+    // probably want to come up with better defaults
+    latitude: 0,
+    longitude: 0,
+    latitudeDelta: 0,
+    longitudeDelta: 0,
+};
+let _uniqueId = 1;
+const getAnimatedValue = (valueIn, fallback) => {
+    if (valueIn instanceof react_native_1.Animated.Value) {
+        return valueIn;
+    }
+    else if (typeof valueIn === 'number') {
+        return new react_native_1.Animated.Value(valueIn);
+    }
+    return new react_native_1.Animated.Value(fallback);
+};
+class AnimatedMapRegion extends AnimatedWithChildren {
+    constructor(valueIn = {}) {
+        super();
+        this.latitude = getAnimatedValue(valueIn.latitude, defaultValues.latitude);
+        this.longitude = getAnimatedValue(valueIn.longitude, defaultValues.longitude);
+        this.latitudeDelta = getAnimatedValue(valueIn.latitudeDelta, defaultValues.latitudeDelta);
+        this.longitudeDelta = getAnimatedValue(valueIn.longitudeDelta, defaultValues.longitudeDelta);
+        this._regionListeners = {};
+    }
+    setValue(value) {
+        this.latitude._value = value.latitude;
+        this.longitude._value = value.longitude;
+        this.latitudeDelta._value = value.latitudeDelta;
+        this.longitudeDelta._value = value.longitudeDelta;
+    }
+    setOffset(offset) {
+        this.latitude.setOffset(offset.latitude);
+        this.longitude.setOffset(offset.longitude);
+        this.latitudeDelta.setOffset(offset.latitudeDelta);
+        this.longitudeDelta.setOffset(offset.longitudeDelta);
+    }
+    flattenOffset() {
+        this.latitude.flattenOffset();
+        this.longitude.flattenOffset();
+        this.latitudeDelta.flattenOffset();
+        this.longitudeDelta.flattenOffset();
+    }
+    __getValue() {
+        return {
+            latitude: this.latitude.__getValue(),
+            longitude: this.longitude.__getValue(),
+            latitudeDelta: this.latitudeDelta.__getValue(),
+            longitudeDelta: this.longitudeDelta.__getValue(),
+        };
+    }
+    __attach() {
+        this.latitude.__addChild(this);
+        this.longitude.__addChild(this);
+        this.latitudeDelta.__addChild(this);
+        this.longitudeDelta.__addChild(this);
+    }
+    __detach() {
+        this.latitude.__removeChild(this);
+        this.longitude.__removeChild(this);
+        this.latitudeDelta.__removeChild(this);
+        this.longitudeDelta.__removeChild(this);
+    }
+    stopAnimation(callback) {
+        this.latitude.stopAnimation();
+        this.longitude.stopAnimation();
+        this.latitudeDelta.stopAnimation();
+        this.longitudeDelta.stopAnimation();
+        callback && callback(this.__getValue());
+    }
+    addListener(callback) {
+        const id = String(_uniqueId++);
+        const jointCallback = () => /*{value}*/ callback(this.__getValue());
+        this._regionListeners[id] = {
+            latitude: this.latitude.addListener(jointCallback),
+            longitude: this.longitude.addListener(jointCallback),
+            latitudeDelta: this.latitudeDelta.addListener(jointCallback),
+            longitudeDelta: this.longitudeDelta.addListener(jointCallback),
+        };
+        return id;
+    }
+    removeListener(id) {
+        this.latitude.removeListener(this._regionListeners[id].latitude);
+        this.longitude.removeListener(this._regionListeners[id].longitude);
+        this.latitudeDelta.removeListener(this._regionListeners[id].latitudeDelta);
+        this.longitudeDelta.removeListener(this._regionListeners[id].longitudeDelta);
+        delete this._regionListeners[id];
+    }
+    spring(config) {
+        const animations = [];
+        for (const type of configTypes) {
+            if (config.hasOwnProperty(type)) {
+                animations.push(react_native_1.Animated.spring(this[type], {
+                    ...config,
+                    toValue: config[type],
+                    // may help to eliminate some dev warnings and perf issues
+                    useNativeDriver: !!config?.useNativeDriver,
+                }));
+            }
+        }
+        return react_native_1.Animated.parallel(animations);
+    }
+    timing(config) {
+        const animations = [];
+        for (const type of configTypes) {
+            if (config.hasOwnProperty(type)) {
+                animations.push(react_native_1.Animated.timing(this[type], {
+                    ...config,
+                    toValue: config[type],
+                    // may help to eliminate some dev warnings and perf issues
+                    useNativeDriver: !!config?.useNativeDriver,
+                }));
+            }
+        }
+        return react_native_1.Animated.parallel(animations);
+    }
+}
+exports.default = AnimatedMapRegion;

package/lib/Geojson.d.ts

@@ -0,0 +1,166 @@
+/// <reference types="react" />
+import { Feature, FeatureCollection, Point, MultiPoint, LineString, MultiLineString, Polygon, MultiPolygon } from 'geojson';
+import { Props as MarkerProps } from './MapMarker';
+import { Props as PolygonProps } from './MapPolygon';
+import { Props as PolylineProps } from './MapPolyline';
+import { LatLng } from './sharedTypes';
+declare type Props = {
+    /**
+     * The pincolor used on markers
+     *
+     * @platform iOS: Supported
+     * @platform Android: Supported
+     */
+    color?: MarkerProps['pinColor'];
+    /**
+     * The fill color to use for the path.
+     *
+     * @platform iOS: Supported
+     * @platform Android: Supported
+     */
+    fillColor?: PolygonProps['fillColor'];
+    /**
+     * [Geojson](https://geojson.org/) description of object.
+     *
+     * @platform iOS: Supported
+     * @platform Android: Supported
+     */
+    geojson: FeatureCollection;
+    /**
+     * A custom image to be used as the marker's icon. Only local image resources are allowed to be
+     * used.
+     *
+     * @platform iOS: Supported
+     * @platform Android: Supported
+     */
+    image?: MarkerProps['image'];
+    /**
+     * The line cap style to apply to the open ends of the path.
+     * The default style is `round`.
+     *
+     * @platform iOS: Apple Maps only
+     * @platform Android: Supported
+     */
+    lineCap?: PolylineProps['lineCap'];
+    /**
+     * An array of numbers specifying the dash pattern to use for the path.
+     *
+     * The array contains one or more numbers that indicate the lengths (measured in points) of the
+     * line segments and gaps in the pattern. The values in the array alternate, starting with the
+     * first line segment length, followed by the first gap length, followed by the second line
+     * segment length, and so on.
+     *
+     * This property is set to `null` by default, which indicates no line dash pattern.
+     *
+     * @platform iOS: Supported
+     * @platform Android: Supported
+     */
+    lineDashPattern?: PolylineProps['lineDashPattern'];
+    /**
+     * The offset (in points) at which to start drawing the dash pattern.
+     *
+     * Use this property to start drawing a dashed line partway through a segment or gap. For
+     * example, a phase value of 6 for the patter 5-2-3-2 would cause drawing to begin in the
+     * middle of the first gap.
+     *
+     * The default value of this property is 0.
+     *
+     * @platform iOS: Apple Maps only
+     * @platform Android: Not supported
+     */
+    lineDashPhase?: PolylineProps['lineDashPhase'];
+    /**
+     * The line join style to apply to corners of the path.
+     * The default style is `round`.
+     *
+     * @platform iOS: Apple Maps only
+     * @platform Android: Not supported
+     */
+    lineJoin?: PolylineProps['lineJoin'];
+    /**
+     * Component to render in place of the default marker when the overlay type is a `point`
+     *
+     * @platform iOS: Supported
+     * @platform Android: Supported
+     */
+    markerComponent?: MarkerProps['children'];
+    /**
+     * The limiting value that helps avoid spikes at junctions between connected line segments.
+     * The miter limit helps you avoid spikes in paths that use the `miter` `lineJoin` style. If
+     * the ratio of the miter length—that is, the diagonal length of the miter join—to the line
+     * thickness exceeds the miter limit, the joint is converted to a bevel join. The default
+     * miter limit is 10, which results in the conversion of miters whose angle at the joint
+     * is less than 11 degrees.
+     *
+     * @platform iOS: Apple Maps only
+     * @platform Android: Not supported
+     */
+    miterLimit?: PolylineProps['miterLimit'];
+    /**
+     * Callback that is called when the user presses any of the overlays
+     */
+    onPress?: (event: OverlayPressEvent) => void;
+    /**
+     * The stroke color to use for the path.
+     *
+     * @platform — iOS: Supported
+     * @platform — Android: Supported
+     */
+    strokeColor?: PolygonProps['strokeColor'] | PolylineProps['strokeColor'];
+    /**
+     * The stroke width to use for the path.
+     *
+     * @platform — iOS: Supported
+     * @platform — Android: Supported
+     */
+    strokeWidth?: PolygonProps['strokeWidth'] | PolylineProps['strokeWidth'];
+    /**
+     * Make the `Polygon` or `Polyline` tappable
+     *
+     * @platform — iOS: Google Maps only
+     * @platform — Android: Supported
+     */
+    tappable?: PolygonProps['tappable'] | PolylineProps['tappable'];
+    /**
+     * The title of the marker. This is only used if the <Marker /> component has no children that
+     * are a `<Callout />`, in which case the default callout behavior will be used, which
+     * will show both the `title` and the `description`, if provided.
+     *
+     * @platform — iOS: Supported
+     * @platform — Android: Supported
+     */
+    title?: MarkerProps['title'];
+    /**
+     * The order in which this tile overlay is drawn with respect to other overlays. An overlay
+     * with a larger z-index is drawn over overlays with smaller z-indices. The order of overlays
+     * with the same z-index is arbitrary. The default zIndex is 0.
+     *
+     * @platform iOS: Apple Maps: [Marker], Google Maps: [Marker, Polygon, Polyline]
+     * @platform Android: Supported
+     */
+    zIndex?: MarkerProps['zIndex'] | PolygonProps['zIndex'] | PolylineProps['zIndex'];
+};
+declare const Geojson: (props: Props) => JSX.Element;
+export default Geojson;
+declare type OverlayPressEvent = {
+    type: AnyPointOverlay['type'] | AnyLineStringOverlay['type'] | AnyPolygonOverlay['type'];
+    feature: AnyPointOverlay['feature'] | AnyLineStringOverlay['feature'] | AnyPolygonOverlay['feature'];
+    coordinates: AnyPointOverlay['coordinates'] | AnyLineStringOverlay['coordinates'] | AnyPolygonOverlay['coordinates'];
+    holes?: AnyPolygonOverlay['holes'];
+};
+declare type AnyPointOverlay = {
+    type: 'point';
+    feature: Feature<Point | MultiPoint>;
+    coordinates: LatLng;
+};
+declare type AnyLineStringOverlay = {
+    type: 'polyline';
+    feature: Feature<LineString | MultiLineString>;
+    coordinates: LatLng[];
+};
+declare type AnyPolygonOverlay = {
+    type: 'polygon';
+    feature: Feature<Polygon | MultiPolygon>;
+    coordinates: LatLng[];
+    holes?: LatLng[][];
+};