react-native-maps 1.26.11 → 1.26.12

package/dist/plugin/src/android.d.ts

@@ -0,0 +1,4 @@
+import { type ConfigPlugin } from '@expo/config-plugins';
+import type { ConfigPluginProps } from './types';
+declare const withMapsAndroid: ConfigPlugin<ConfigPluginProps>;
+export default withMapsAndroid;

package/dist/plugin/src/index.d.ts

@@ -0,0 +1,4 @@
+import type { ConfigPlugin } from '@expo/config-plugins';
+import type { ConfigPluginProps } from './types';
+declare const withMaps: ConfigPlugin<ConfigPluginProps>;
+export default withMaps;

package/dist/plugin/src/ios.d.ts

@@ -0,0 +1,15 @@
+import type { ConfigPlugin } from '@expo/config-plugins/build/Plugin.types';
+import { type MergeResults } from '@expo/config-plugins/build/utils/generateCode';
+import type { ConfigPluginProps } from './types';
+export declare const MATCH_INIT: RegExp;
+export declare const withMapsIOS: ConfigPlugin<ConfigPluginProps>;
+export declare function addGoogleMapsAppDelegateImport(src: string): MergeResults;
+export declare function removeGoogleMapsAppDelegateImport(src: string): MergeResults;
+export declare function addGoogleMapsAppDelegateInit(src: string, apiKey: string): MergeResults;
+export declare function removeGoogleMapsAppDelegateInit(src: string): MergeResults;
+/**
+ * @param src The contents of the Podfile.
+ * @param useGoogleMaps if GoogleMaps for iOS is used
+ * @returns Podfile with react-native-maps integration configured.
+ */
+export declare function addMapsCocoapods(src: string, useGoogleMaps: boolean): MergeResults;

package/dist/plugin/src/types.d.ts

@@ -0,0 +1,4 @@
+export type ConfigPluginProps = {
+    iosGoogleMapsApiKey?: string;
+    androidGoogleMapsApiKey?: string;
+};

package/dist/src/AnimatedRegion.d.ts

@@ -0,0 +1,19 @@
+import { Animated } from 'react-native';
+import type { Region } from './sharedTypes';
+declare const AnimatedWithChildren: any;
+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/dist/src/Geojson.d.ts

@@ -0,0 +1,204 @@
+import * as React from 'react';
+import type { Feature, FeatureCollection, Point, MultiPoint, LineString, MultiLineString, Polygon, MultiPolygon } from 'geojson';
+import { type MapMarkerProps as MarkerProps } from './MapMarker';
+import type { MapPolygonProps as PolygonProps } from './MapPolygon';
+import type { MapPolylineProps as PolylineProps } from './MapPolyline';
+import type { LatLng } from './sharedTypes';
+export type GeojsonProps = {
+    /**
+     * Sets the anchor point for the marker.
+     * The anchor specifies the point in the icon image that is anchored to the marker's position on the Earth's surface.
+     *
+     * The anchor point is specified in the continuous space [0.0, 1.0] x [0.0, 1.0],
+     * where (0, 0) is the top-left corner of the image, and (1, 1) is the bottom-right corner.
+     *
+     * The anchoring point in a W x H image is the nearest discrete grid point in a (W + 1) x (H + 1) grid, obtained by scaling the then rounding.
+     * For example, in a 4 x 2 image, the anchor point (0.7, 0.6) resolves to the grid point at (3, 1).
+     *
+     * @default {x: 0.5, y: 1.0}
+     * @platform iOS: Google Maps only. For Apple Maps, see the `centerOffset` prop
+     * @platform Android: Supported
+     */
+    anchor?: MarkerProps['anchor'];
+    /**
+     * The offset (in points) at which to display the annotation view.
+     *
+     * By default, the center point of an annotation view is placed at the coordinate point of the associated annotation.
+     *
+     * Positive offset values move the annotation view down and to the right, while negative values move it up and to the left.
+     *
+     * @default {x: 0.0, y: 0.0}
+     * @platform iOS: Apple Maps only. For Google Maps, see the `anchor` prop
+     * @platform Android: Not supported. See see the `anchor` prop
+     */
+    centerOffset?: MarkerProps['centerOffset'];
+    /**
+     * 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?: PolygonProps['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'];
+    /**
+     * Sets whether this marker should track view changes.
+     * It's recommended to turn it off whenever it's possible to improve custom marker performance.
+     * This is the default value for all point markers in your geojson data. It can be overriden
+     * on a per point basis by adding a `trackViewChanges` property to the `properties` object on the point.
+     *
+     * @default true
+     * @platform iOS: Google Maps only
+     * @platform Android: Supported
+     */
+    tracksViewChanges?: boolean;
+    /**
+     * 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: GeojsonProps) => React.JSX.Element;
+export default Geojson;
+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'];
+};
+type AnyPointOverlay = {
+    type: 'point';
+    feature: Feature<Point | MultiPoint>;
+    coordinates: LatLng;
+};
+type AnyLineStringOverlay = {
+    type: 'polyline';
+    feature: Feature<LineString | MultiLineString>;
+    coordinates: LatLng[];
+};
+type AnyPolygonOverlay = {
+    type: 'polygon';
+    feature: Feature<Polygon | MultiPolygon>;
+    coordinates: LatLng[];
+    holes?: LatLng[][];
+};

package/dist/src/MapCallout.d.ts

@@ -0,0 +1,40 @@
+import * as React from 'react';
+import { type ViewProps } from 'react-native';
+import { ProviderContext, type MapManagerCommand, type NativeComponent, type UIManagerCommand } from './decorateMapComponent';
+import type { CalloutPressEvent } from './sharedTypes';
+export type MapCalloutProps = 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;
+};
+type NativeProps = MapCalloutProps;
+export declare class MapCallout extends React.Component<MapCalloutProps> {
+    context: React.ContextType<typeof ProviderContext>;
+    getNativeComponent: () => NativeComponent<NativeProps>;
+    getMapManagerCommand: (name: string) => MapManagerCommand;
+    getUIManagerCommand: (name: string) => UIManagerCommand;
+    render(): React.JSX.Element;
+}
+declare const _default: typeof MapCallout;
+export default _default;

package/dist/src/MapCalloutSubview.d.ts

@@ -0,0 +1,34 @@
+import * as React from 'react';
+import { type NativeSyntheticEvent, type ViewProps } from 'react-native';
+import { ProviderContext, type NativeComponent, type MapManagerCommand, type UIManagerCommand } from './decorateMapComponent';
+import type { Frame, Point } from './sharedTypes';
+export type MapCalloutSubviewProps = 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;
+};
+type NativeProps = MapCalloutSubviewProps;
+export declare class MapCalloutSubview extends React.Component<MapCalloutSubviewProps> {
+    context: React.ContextType<typeof ProviderContext>;
+    getNativeComponent: () => NativeComponent<NativeProps>;
+    getMapManagerCommand: (name: string) => MapManagerCommand;
+    getUIManagerCommand: (name: string) => UIManagerCommand;
+    render(): React.JSX.Element;
+}
+declare const _default: typeof MapCalloutSubview;
+export default _default;
+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/dist/src/MapCircle.d.ts

@@ -0,0 +1,117 @@
+import * as React from 'react';
+import { View, type ViewProps } from 'react-native';
+import { ProviderContext, type NativeComponent, type MapManagerCommand, type UIManagerCommand } from './decorateMapComponent';
+import type { LatLng, LineCapType, LineJoinType } from './sharedTypes';
+export type MapCircleProps = ViewProps & {
+    /**
+     * The coordinates of the center of the circle.
+     *
+     * @platform iOS: Supported
+     * @platform Android: Supported
+     */
+    center: LatLng;
+    /**
+     * The fill color to use for the path.
+     *
+     * @default `#000`, `rgba(r,g,b,0.5)`
+     * @platform iOS: Supported
+     * @platform Android: Supported
+     */
+    fillColor?: string;
+    /**
+     * The line cap style to apply to the open ends of the path
+     *
+     * @default `round`
+     * @platform iOS: Apple Maps only
+     * @platform Android: Not supported
+     */
+    lineCap?: LineCapType;
+    /**
+     * 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.
+     *
+     * @platform iOS: Apple Maps only
+     * @platform Android: Not supported
+     */
+    lineDashPattern?: number[];
+    /**
+     * 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.
+     *
+     * @default 0
+     * @platform iOS: Apple Maps only
+     * @platform Android: Not supported
+     */
+    lineDashPhase?: number;
+    /**
+     * The line join style to apply to corners of the path.
+     *
+     * @platform iOS: Apple Maps only
+     * @platform Android: Not supported
+     */
+    lineJoin?: LineJoinType;
+    /**
+     * 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.
+     *
+     * @default 10
+     * @platform iOS: Apple Maps only
+     * @platform Android: Not supported
+     */
+    miterLimit?: number;
+    /**
+     * The radius of the circle to be drawn (in meters)
+     *
+     * @platform iOS: Supported
+     * @platform Android: Supported
+     */
+    radius: number;
+    /**
+     * The stroke color to use for the path.
+     *
+     * @default `#000`, `rgba(r,g,b,0.5)`
+     * @platform iOS: Supported
+     * @platform Android: Supported
+     */
+    strokeColor?: string;
+    /**
+     * The stroke width to use for the path.
+     *
+     * @default 1
+     * @platform iOS: Supported
+     * @platform Android: Supported
+     */
+    strokeWidth?: number;
+    /**
+     * 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.
+     *
+     * @default 0
+     * @platform iOS: Google Maps only
+     * @platform Android: Supported
+     */
+    zIndex?: number;
+};
+type NativeProps = MapCircleProps & {
+    ref: React.RefObject<View | null>;
+};
+export declare class MapCircle extends React.Component<MapCircleProps> {
+    context: React.ContextType<typeof ProviderContext>;
+    getNativeComponent: () => NativeComponent<NativeProps>;
+    getMapManagerCommand: (name: string) => MapManagerCommand;
+    getUIManagerCommand: (name: string) => UIManagerCommand;
+    private circle;
+    constructor(props: MapCircleProps);
+    setNativeProps(props: Partial<NativeProps>): void;
+    render(): React.JSX.Element;
+}
+declare const _default: typeof MapCircle;
+export default _default;

package/dist/src/MapHeatmap.d.ts

@@ -0,0 +1,78 @@
+import * as React from 'react';
+import { View, type ProcessedColorValue, type ViewProps } from 'react-native';
+import { ProviderContext, type MapManagerCommand, type NativeComponent, type UIManagerCommand } from './decorateMapComponent';
+import type { LatLng } from './sharedTypes';
+import type { Modify } from './sharedTypesInternal';
+export type MapHeatmapProps = ViewProps & {
+    gradient?: {
+        /**
+         * Resolution of color map -- number corresponding to the number of steps colors are interpolated into.
+         *
+         * @default 256
+         * @platform iOS: Google Maps only
+         * @platform Android: Supported
+         */
+        colorMapSize: number;
+        /**
+         * Colors (one or more) to used for gradient.
+         *
+         * @platform iOS: Google Maps only
+         * @platform Android: Supported
+         */
+        colors: string[];
+        /**
+         * Array of floating point values from 0 to 1 representing where each color starts.
+         *
+         * Array length must be equal to `colors` array length.
+         *
+         * @platform iOS: Google Maps only
+         * @platform Android: Supported
+         */
+        startPoints: number[];
+    };
+    /**
+     * The opacity of the heatmap.
+     *
+     * @default 0.7
+     * @platform iOS: Google Maps only
+     * @platform Android: Supported
+     */
+    opacity?: number;
+    /**
+     * Array of heatmap entries to apply towards density.
+     *
+     * @platform iOS: Google Maps only
+     * @platform Android: Supported
+     */
+    points?: WeightedLatLng[];
+    /**
+     * The radius of the heatmap points in pixels, between 10 and 50.
+     *
+     * @default 20
+     * @platform iOS: Google Maps only
+     * @platform Android: Supported
+     */
+    radius?: number;
+};
+type NativeProps = Modify<MapHeatmapProps, {
+    gradient?: Modify<MapHeatmapProps['gradient'], {
+        colors: (ProcessedColorValue | null | undefined)[];
+    }>;
+}> & {
+    ref: React.RefObject<View | null>;
+};
+export declare class MapHeatmap extends React.Component<MapHeatmapProps | null> {
+    context: React.ContextType<typeof ProviderContext>;
+    getNativeComponent: () => NativeComponent<NativeProps>;
+    getMapManagerCommand: (name: string) => MapManagerCommand;
+    getUIManagerCommand: (name: string) => UIManagerCommand;
+    private heatmap;
+    constructor(props: MapHeatmapProps);
+    setNativeProps(props: Partial<NativeProps>): void;
+    render(): React.JSX.Element;
+}
+declare const _default: typeof MapHeatmap;
+export default _default;
+type WeightedLatLng = LatLng & {
+    weight?: number;
+};

package/dist/src/MapLocalTile.d.ts

@@ -0,0 +1,35 @@
+import * as React from 'react';
+import type { ViewProps } from 'react-native';
+import { ProviderContext, type NativeComponent, type MapManagerCommand, type UIManagerCommand } from './decorateMapComponent';
+export type MapLocalTileProps = ViewProps & {
+    /**
+     * @platform iOS: Apple Maps only
+     * @platform Android: Supported
+     */
+    pathTemplate: string;
+    /**
+     * @platform iOS: Apple Maps only
+     * @platform Android: Supported
+     */
+    tileSize?: number;
+    /**
+     * Set to true to use pathTemplate to open files from Android's AssetManager. The default is false.
+     * @platform android
+     */
+    useAssets?: boolean;
+    /**
+     * @platform iOS: Not supported
+     * @platform Android: Supported
+     */
+    zIndex?: number;
+};
+type NativeProps = MapLocalTileProps;
+export declare class MapLocalTile extends React.Component<MapLocalTileProps> {
+    context: React.ContextType<typeof ProviderContext>;
+    getNativeComponent: () => NativeComponent<NativeProps>;
+    getMapManagerCommand: (name: string) => MapManagerCommand;
+    getUIManagerCommand: (name: string) => UIManagerCommand;
+    render(): React.JSX.Element;
+}
+declare const _default: typeof MapLocalTile;
+export default _default;