react-native-maps 0.31.1 → 1.0.0-beta.1

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[][];
+};

package/lib/Geojson.js

@@ -0,0 +1,165 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const React = __importStar(require("react"));
+const MapMarker_1 = __importDefault(require("./MapMarker"));
+const MapPolyline_1 = __importDefault(require("./MapPolyline"));
+const MapPolygon_1 = __importDefault(require("./MapPolygon"));
+const Geojson = (props) => {
+    const { geojson, strokeColor, fillColor, strokeWidth, color, title, image, zIndex, onPress, lineCap, lineJoin, tappable, miterLimit, lineDashPhase, lineDashPattern, markerComponent, } = props;
+    const pointOverlays = makePointOverlays(geojson.features);
+    const lineOverlays = makeLineOverlays(geojson.features);
+    const polygonOverlays = makePolygonOverlays(geojson.features);
+    return (<React.Fragment>
+      {pointOverlays.map((overlay, index) => {
+            const markerColor = getColor(color, overlay, 'marker-color');
+            return (<MapMarker_1.default key={index} coordinate={overlay.coordinates} image={image} title={title} pinColor={markerColor} zIndex={zIndex} onPress={() => onPress && onPress(overlay)}>
+            {markerComponent}
+          </MapMarker_1.default>);
+        })}
+      {lineOverlays.map((overlay, index) => {
+            const lineStrokeColor = getColor(strokeColor, overlay, 'stroke');
+            const lineStrokeWidth = getStrokeWidth(strokeWidth, overlay);
+            return (<MapPolyline_1.default key={index} coordinates={overlay.coordinates} strokeColor={lineStrokeColor} strokeWidth={lineStrokeWidth} lineDashPhase={lineDashPhase} lineDashPattern={lineDashPattern} lineCap={lineCap} lineJoin={lineJoin} miterLimit={miterLimit} zIndex={zIndex} tappable={tappable} onPress={() => onPress && onPress(overlay)}/>);
+        })}
+      {polygonOverlays.map((overlay, index) => {
+            const polygonFillColor = getColor(fillColor, overlay, 'fill');
+            const lineStrokeColor = getColor(strokeColor, overlay, 'stroke');
+            const lineStrokeWidth = getStrokeWidth(strokeWidth, overlay);
+            return (<MapPolygon_1.default key={index} coordinates={overlay.coordinates} holes={overlay.holes} strokeColor={lineStrokeColor} fillColor={polygonFillColor} strokeWidth={lineStrokeWidth} tappable={tappable} onPress={() => onPress && onPress(overlay)} zIndex={zIndex}/>);
+        })}
+    </React.Fragment>);
+};
+exports.default = Geojson;
+const makePointOverlays = (features) => {
+    return features
+        .filter(isAnyPointFeature)
+        .map(feature => makeCoordinatesForAnyPoint(feature.geometry).map(coordinates => makeOverlayForAnyPoint(coordinates, feature)))
+        .reduce((prev, curr) => prev.concat(curr), [])
+        .map(overlay => ({ ...overlay, type: 'point' }));
+};
+const makeLineOverlays = (features) => {
+    return features
+        .filter(isAnyLineStringFeature)
+        .map(feature => makeCoordinatesForAnyLine(feature.geometry).map(coordinates => makeOverlayForAnyLine(coordinates, feature)))
+        .reduce((prev, curr) => prev.concat(curr), [])
+        .map(overlay => ({ ...overlay, type: 'polyline' }));
+};
+const makePolygonOverlays = (features) => {
+    const multipolygons = features
+        .filter(isMultiPolygonFeature)
+        .map(feature => makeCoordinatesForMultiPolygon(feature.geometry).map(coordinates => makeOverlayForAnyPolygon(coordinates, feature)))
+        .reduce((prev, curr) => prev.concat(curr), [])
+        .map(overlay => ({ ...overlay, type: 'polygon' }));
+    const polygons = features
+        .filter(isPolygonFeature)
+        .map(feature => makeOverlayForAnyPolygon(makeCoordinatesForPolygon(feature.geometry), feature))
+        .reduce((prev, curr) => prev.concat(curr), [])
+        .map(overlay => ({ ...overlay, type: 'polygon' }));
+    return polygons.concat(multipolygons);
+};
+const makeOverlayForAnyPoint = (coordinates, feature) => {
+    return { feature, coordinates };
+};
+const makeOverlayForAnyLine = (coordinates, feature) => {
+    return { feature, coordinates };
+};
+const makeOverlayForAnyPolygon = (coordinates, feature) => {
+    return {
+        feature,
+        coordinates: coordinates[0],
+        holes: coordinates.length > 1 ? coordinates.slice(1) : undefined,
+    };
+};
+const makePoint = (c) => ({
+    latitude: c[1],
+    longitude: c[0],
+});
+const makeLine = (l) => l.map(makePoint);
+const makeCoordinatesForAnyPoint = (geometry) => {
+    if (geometry.type === 'Point') {
+        return [makePoint(geometry.coordinates)];
+    }
+    return geometry.coordinates.map(makePoint);
+};
+const makeCoordinatesForAnyLine = (geometry) => {
+    if (geometry.type === 'LineString') {
+        return [makeLine(geometry.coordinates)];
+    }
+    return geometry.coordinates.map(makeLine);
+};
+const makeCoordinatesForPolygon = (geometry) => {
+    return geometry.coordinates.map(makeLine);
+};
+const makeCoordinatesForMultiPolygon = (geometry) => {
+    return geometry.coordinates.map(p => p.map(makeLine));
+};
+const getRgbaFromHex = (hex, alpha = 1) => {
+    const matchArray = hex.match(/\w\w/g);
+    if (!matchArray || matchArray.length < 3) {
+        throw new Error('Invalid hex string');
+    }
+    const [r, g, b] = matchArray.map(x => {
+        const subColor = parseInt(x, 16);
+        if (Number.isNaN(subColor)) {
+            throw new Error('Invalid hex string');
+        }
+        return subColor;
+    });
+    return `rgba(${r},${g},${b},${alpha})`;
+};
+const getColor = (prop, overlay, colorType) => {
+    if (prop) {
+        return prop;
+    }
+    let color = overlay.feature.properties?.[colorType];
+    if (color) {
+        const opacityProperty = colorType + '-opacity';
+        const alpha = overlay.feature.properties?.[opacityProperty];
+        if (alpha && alpha !== '0' && color[0] === '#') {
+            color = getRgbaFromHex(color, alpha);
+        }
+        return color;
+    }
+    return undefined;
+};
+const getStrokeWidth = (prop, overlay) => {
+    if (prop) {
+        return prop;
+    }
+    return overlay.feature.properties?.['stroke-width'];
+};
+// GeoJSON.Feature type-guards
+const isPointFeature = (feature) => feature.geometry.type === 'Point';
+const isMultiPointFeature = (feature) => feature.geometry.type === 'MultiPoint';
+const isAnyPointFeature = (feature) => isPointFeature(feature) || isMultiPointFeature(feature);
+const isLineStringFeature = (feature) => feature.geometry.type === 'LineString';
+const isMultiLineStringFeature = (feature) => feature.geometry.type === 'MultiLineString';
+const isAnyLineStringFeature = (feature) => isLineStringFeature(feature) || isMultiLineStringFeature(feature);
+const isPolygonFeature = (feature) => feature.geometry.type === 'Polygon';
+const isMultiPolygonFeature = (feature) => feature.geometry.type === 'MultiPolygon';

package/lib/MapCallout.d.ts

@@ -0,0 +1,40 @@
+import * as React from 'react';
+import { ViewProps } from 'react-native';
+import { MapManagerCommand, NativeComponent, ProviderContext, UIManagerCommand } from './decorateMapComponent';
+import { CalloutPressEvent } from './sharedTypes';
+declare type Props = ViewProps & {
+    /**
+     * If `true`, clicks on transparent areas in callout will be passed to map.
+     *
+     * @default false
+     * @platform iOS: Supported
+     * @platform Android: Not supported
+     */
+    alphaHitTest?: boolean;
+    /**
+     * Callback that is called when the user presses on the callout
+     *
+     * @platform iOS: Apple Maps only
+     * @platform Android: Supported
+     */
+    onPress?: (event: CalloutPressEvent) => void;
+    /**
+     * If `false`, a default "tooltip" bubble window will be drawn around this callouts children.
+     * If `true`, the child views can fully customize their appearance, including any "bubble" like styles.
+     *
+     * @default false
+     * @platform iOS: Supported
+     * @platform Android: Supported
+     */
+    tooltip?: boolean;
+};
+declare type NativeProps = Props;
+export declare class MapCallout extends React.Component<Props> {
+    context: React.ContextType<typeof ProviderContext>;
+    getNativeComponent: () => NativeComponent<NativeProps>;
+    getMapManagerCommand: (name: string) => MapManagerCommand;
+    getUIManagerCommand: (name: string) => UIManagerCommand;
+    render(): JSX.Element;
+}
+declare const _default: typeof MapCallout;
+export default _default;

package/lib/MapCallout.js

@@ -0,0 +1,51 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MapCallout = void 0;
+const React = __importStar(require("react"));
+const react_native_1 = require("react-native");
+const decorateMapComponent_1 = __importStar(require("./decorateMapComponent"));
+class MapCallout extends React.Component {
+    getNativeComponent;
+    getMapManagerCommand;
+    getUIManagerCommand;
+    render() {
+        const { tooltip = false, alphaHitTest = false } = this.props;
+        const AIRMapCallout = this.getNativeComponent();
+        return (<AIRMapCallout {...this.props} tooltip={tooltip} alphaHitTest={alphaHitTest} style={[styles.callout, this.props.style]}/>);
+    }
+}
+exports.MapCallout = MapCallout;
+const styles = react_native_1.StyleSheet.create({
+    callout: {
+        position: 'absolute',
+    },
+});
+exports.default = (0, decorateMapComponent_1.default)(MapCallout, 'Callout', {
+    google: {
+        ios: decorateMapComponent_1.SUPPORTED,
+        android: decorateMapComponent_1.USES_DEFAULT_IMPLEMENTATION,
+    },
+});

package/lib/MapCalloutSubview.d.ts

@@ -0,0 +1,34 @@
+import * as React from 'react';
+import { NativeSyntheticEvent, ViewProps } from 'react-native';
+import { ProviderContext, NativeComponent, MapManagerCommand, UIManagerCommand } from './decorateMapComponent';
+import { Frame, Point } from './sharedTypes';
+declare type Props = ViewProps & {
+    /**
+     * Callback that is called when the user presses on this subview inside callout
+     *
+     * @platform iOS: Supported
+     * @platform Android: Not supported
+     */
+    onPress?: (event: CalloutSubviewPressEvent) => void;
+};
+declare type NativeProps = Props;
+export declare class MapCalloutSubview extends React.Component<Props> {
+    context: React.ContextType<typeof ProviderContext>;
+    getNativeComponent: () => NativeComponent<NativeProps>;
+    getMapManagerCommand: (name: string) => MapManagerCommand;
+    getUIManagerCommand: (name: string) => UIManagerCommand;
+    render(): JSX.Element;
+}
+declare const _default: typeof MapCalloutSubview;
+export default _default;
+declare type CalloutSubviewPressEvent = NativeSyntheticEvent<{
+    /**
+     * Apple Maps: `callout-inside-press`
+     *
+     * Google Maps: `marker-inside-overlay-press`
+     */
+    action: 'callout-inside-press' | 'marker-inside-overlay-press';
+    frame: Frame;
+    id: string;
+    point: Point;
+}>;

package/lib/MapCalloutSubview.js

@@ -0,0 +1,48 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MapCalloutSubview = void 0;
+const React = __importStar(require("react"));
+const react_native_1 = require("react-native");
+const decorateMapComponent_1 = __importStar(require("./decorateMapComponent"));
+class MapCalloutSubview extends React.Component {
+    getNativeComponent;
+    getMapManagerCommand;
+    getUIManagerCommand;
+    render() {
+        const AIRMapCalloutSubview = this.getNativeComponent();
+        return (<AIRMapCalloutSubview {...this.props} style={[styles.calloutSubview, this.props.style]}/>);
+    }
+}
+exports.MapCalloutSubview = MapCalloutSubview;
+const styles = react_native_1.StyleSheet.create({
+    calloutSubview: {},
+});
+exports.default = (0, decorateMapComponent_1.default)(MapCalloutSubview, 'CalloutSubview', {
+    google: {
+        ios: decorateMapComponent_1.SUPPORTED,
+        android: decorateMapComponent_1.NOT_SUPPORTED,
+    },
+});