react-native-maps 1.21.0-alpha.14 → 1.21.0-alpha.140

package/src/specs/NativeComponentWMSTile.ts

@@ -0,0 +1,107 @@
+import type {HostComponent, ViewProps} from 'react-native';
+
+import codegenNativeComponent from 'react-native/Libraries/Utilities/codegenNativeComponent';
+import {Int32, WithDefault} from 'react-native/Libraries/Types/CodegenTypes';
+
+export interface WMSTileFabricNativeProps extends ViewProps {
+  /**
+   * The maximum native zoom level for this tile overlay i.e. the highest zoom level that the tile server provides.
+   * Tiles are auto-scaled for higher zoom levels.
+   *
+   * @platform iOS: Apple Maps only
+   * @platform Android: Supported
+   */
+  maximumNativeZ?: WithDefault<Int32, 100>;
+
+  /**
+   * The maximum zoom level for this tile overlay.
+   *
+   * @platform iOS: Supported
+   * @platform Android: Supported
+   */
+  maximumZ?: WithDefault<Int32, 100>;
+
+  /**
+   * The minimum zoom level for this tile overlay.
+   *
+   * @platform iOS: Supported
+   * @platform Android: Supported
+   */
+  minimumZ?: Int32;
+
+  /**
+   * In offline-mode tiles are not fetched from the tile servers, rather only tiles stored in the cache directory are used.
+   * Furthermore, automated tile scaling is activated: if tile at a desired zoom level is not found from the cache directory,
+   * then lower zoom level tile is used (up to 4 levels lower) and scaled.
+   *
+   * @default false
+   * @platform iOS: Apple Maps only
+   * @platform Android: Supported
+   */
+  offlineMode?: boolean;
+
+  /**
+   * Corresponds to MKTileOverlay canReplaceMapContent i.e. if true then underlying iOS basemap is not shown.
+   *
+   * @default false
+   * @platform iOS: Apple Maps only
+   * @platform Android: Not supported
+   */
+  shouldReplaceMapContent?: boolean;
+
+  /**
+   * Defines maximum age in seconds for a cached tile before it's refreshed.
+   *
+   * NB! Refresh logic is "serve-stale-while-refresh"
+   * i.e. to ensure map availability a stale (over max age) tile is served
+   * while a tile refresh process is started in the background.
+   *
+   * @platform iOS: Apple Maps only
+   * @platform Android: Supported
+   */
+  tileCacheMaxAge?: Int32;
+
+  /**
+   * Enable caching of tiles in the specified directory.
+   * Directory can be specified either as a normal path or in URL format (`file://`).
+   *
+   * Tiles are stored in tileCachePath directory as `/{z}/{x}/{y}` i.e. in sub-directories 2-levels deep,
+   * filename is tile y-coordinate without any filetype-extension.
+   *
+   * NB! All cache management needs to be implemented by client e.g. deleting tiles to manage use of storage space etc.
+   *
+   * @platform iOS: Apple Maps only
+   * @platform Android: Supported
+   */
+  tileCachePath?: string;
+
+  /**
+   * Tile size, default size is 256 (for tiles of 256 _ 256 pixels).
+   * High-res (aka 'retina') tiles are 512 (tiles of 512 _ 512 pixels)
+   *
+   * @platform iOS: Supported
+   * @platform Android: Supported
+   */
+  tileSize?: WithDefault<Int32, 256>;
+
+  /**
+   * The url template of the map tileserver.
+   * (URLTile) The patterns {x} {y} {z} will be replaced at runtime.
+   * For example, http://c.tile.openstreetmap.org/{z}/{x}/{y}.png.
+   *
+   * It is also possible to refer to tiles in local filesystem with file:///top-level-directory/sub-directory/{z}/{x}/{y}.png URL-format.
+   * (WMSTile) The patterns {minX} {maxX} {minY} {maxY} {width} {height} will be replaced at runtime according to EPSG:900913 specification bounding box.
+   * For example, https://demo.geo-solutions.it/geoserver/tiger/wms?service=WMS&version=1.1.0&request=GetMap&layers=tiger:poi&styles=&bbox={minX},{minY},{maxX},{maxY}&width={width}&height={height}&srs=EPSG:900913&format=image/png&transparent=true&format_options=dpi:213.
+   *
+   * @platform iOS: Supported
+   * @platform Android: Supported
+   */
+  urlTemplate: string;
+}
+
+export default codegenNativeComponent<WMSTileFabricNativeProps>(
+  'RNMapsWMSTile',
+  {
+    excludedPlatforms: ['iOS'],
+  },
+) as HostComponent<WMSTileFabricNativeProps>;

package/lib/AnimatedRegion.d.ts

@@ -1,19 +0,0 @@
-import { Animated } from 'react-native';
-import { 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/lib/AnimatedRegion.js

@@ -1,134 +0,0 @@
-"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

@@ -1,204 +0,0 @@
-import * as React from 'react';
-import { Feature, FeatureCollection, Point, MultiPoint, LineString, MultiLineString, Polygon, MultiPolygon } from 'geojson';
-import { MapMarkerProps as MarkerProps } from './MapMarker';
-import { MapPolygonProps as PolygonProps } from './MapPolygon';
-import { MapPolylineProps as PolylineProps } from './MapPolyline';
-import { 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/lib/Geojson.js

@@ -1,166 +0,0 @@
-"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 { anchor, centerOffset, geojson, strokeColor, fillColor, strokeWidth, color, title, image, zIndex, onPress, lineCap, lineJoin, tappable, tracksViewChanges, 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');
-            const pointOverlayTracksViewChanges = overlay.feature.properties?.tracksViewChanges || tracksViewChanges;
-            return (<MapMarker_1.default key={index} coordinate={overlay.coordinates} tracksViewChanges={pointOverlayTracksViewChanges} image={image} title={title} pinColor={markerColor} zIndex={zIndex} anchor={anchor} centerOffset={centerOffset} 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} lineDashPhase={lineDashPhase} lineDashPattern={lineDashPattern} lineCap={lineCap} lineJoin={lineJoin} miterLimit={miterLimit} 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

@@ -1,40 +0,0 @@
-import * as React from 'react';
-import { ViewProps } from 'react-native';
-import { MapManagerCommand, NativeComponent, ProviderContext, UIManagerCommand } from './decorateMapComponent';
-import { 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;