@maplibre/maplibre-react-native 11.0.0-alpha.7 → 11.0.0-alpha.9

package/src/components/map-view/NativeMapViewModule.ts

@@ -0,0 +1,83 @@
+import {
+  type CodegenTypes,
+  type TurboModule,
+  TurboModuleRegistry,
+} from "react-native";
+
+type NativeViewState = {
+  longitude: CodegenTypes.Double;
+  latitude: CodegenTypes.Double;
+  zoom: CodegenTypes.Double;
+  bearing: CodegenTypes.Double;
+  pitch: CodegenTypes.Double;
+  bounds: CodegenTypes.Double[];
+};
+
+export interface Spec extends TurboModule {
+  getCenter: (reactTag: CodegenTypes.Int32) => Promise<{
+    longitude: CodegenTypes.Double;
+    latitude: CodegenTypes.Double;
+  }>;
+
+  getZoom: (reactTag: CodegenTypes.Int32) => Promise<CodegenTypes.Double>;
+
+  getBearing: (reactTag: CodegenTypes.Int32) => Promise<CodegenTypes.Double>;
+
+  getPitch: (reactTag: CodegenTypes.Int32) => Promise<CodegenTypes.Double>;
+
+  getBounds: (reactTag: CodegenTypes.Int32) => Promise<CodegenTypes.Double[]>;
+
+  getViewState: (reactTag: CodegenTypes.Int32) => Promise<NativeViewState>;
+
+  project: (
+    reactTag: CodegenTypes.Int32,
+    coordinate: {
+      longitude: CodegenTypes.Double;
+      latitude: CodegenTypes.Double;
+    },
+  ) => Promise<{
+    locationX: CodegenTypes.Double;
+    locationY: CodegenTypes.Double;
+  }>;
+
+  unproject: (
+    reactTag: CodegenTypes.Int32,
+    point: { locationX: CodegenTypes.Double; locationY: CodegenTypes.Double },
+  ) => Promise<{
+    longitude: CodegenTypes.Double;
+    latitude: CodegenTypes.Double;
+  }>;
+
+  queryRenderedFeaturesWithCoordinate: (
+    reactTag: CodegenTypes.Int32,
+    coordinate: {
+      longitude: CodegenTypes.Double;
+      latitude: CodegenTypes.Double;
+    },
+    layers: string[],
+    filter: string[],
+  ) => Promise<object>;
+
+  queryRenderedFeaturesWithBounds: (
+    reactTag: CodegenTypes.Int32,
+    bounds: CodegenTypes.Double[],
+    layers: string[],
+    filter: string[],
+  ) => Promise<object>;
+
+  setSourceVisibility: (
+    reactTag: CodegenTypes.Int32,
+    visible: boolean,
+    sourceId: string,
+    sourceLayerId: string | null,
+  ) => Promise<void>;
+
+  takeSnap: (
+    reactTag: CodegenTypes.Int32,
+    writeToDisk: boolean,
+  ) => Promise<string>;
+
+  showAttribution: (reactTag: CodegenTypes.Int32) => Promise<void>;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>("MLRNMapViewModule");

package/src/index.ts

@@ -1 +1,86 @@
-export * from "./MapLibreRN";
+export * from "./MLRNModule";
+
+export {
+  type CameraOptions,
+  type CameraEasing,
+  type CameraAnimationOptions,
+  type CameraCenterOptions,
+  type CameraBoundsOptions,
+  type CameraCenterStop,
+  type CameraBoundsStop,
+  type CameraStop,
+  type InitialViewState,
+  type CameraRef,
+  type TrackUserLocation,
+  type TrackUserLocationChangeEvent,
+  type CameraProps,
+  Camera,
+} from "./components/camera/Camera";
+
+export {
+  MapView,
+  type MapViewRef,
+  type ViewState,
+  type ViewStateChangeEvent,
+} from "./components/map-view/MapView";
+
+export { Light } from "./components/Light";
+export { PointAnnotation } from "./components/PointAnnotation";
+export type { PointAnnotationRef } from "./components/PointAnnotation";
+export { Annotation } from "./components/Annotation";
+export { Callout } from "./components/Callout";
+export { requestAndroidLocationPermissions } from "./requestAndroidLocationPermissions";
+export {
+  UserLocation,
+  UserLocationRenderMode,
+} from "./components/UserLocation";
+export type { UserLocationRef } from "./components/UserLocation";
+export { VectorSource } from "./components/VectorSource";
+export { ShapeSource } from "./components/ShapeSource";
+export type { ShapeSourceRef } from "./components/ShapeSource";
+export { RasterSource } from "./components/RasterSource";
+export { ImageSource } from "./components/ImageSource";
+export { Images } from "./components/Images";
+export { FillLayer } from "./components/FillLayer";
+export { FillExtrusionLayer } from "./components/FillExtrusionLayer";
+export { HeatmapLayer } from "./components/HeatmapLayer";
+export { LineLayer } from "./components/LineLayer";
+export { CircleLayer } from "./components/CircleLayer";
+export { SymbolLayer } from "./components/SymbolLayer";
+export { RasterLayer } from "./components/RasterLayer";
+export { BackgroundLayer } from "./components/BackgroundLayer";
+export { MarkerView } from "./components/MarkerView";
+
+export {
+  LocationManager,
+  type Location,
+} from "./modules/location/LocationManager";
+export { OfflineManager } from "./modules/offline/OfflineManager";
+export type { OfflinePackError } from "./modules/offline/OfflineManager";
+export type { OfflinePackStatus } from "./modules/offline/OfflinePack";
+export { OfflinePack } from "./modules/offline/OfflinePack";
+export { OfflineCreatePackOptions } from "./modules/offline/OfflineCreatePackOptions";
+export { SnapshotManager } from "./modules/snapshot/SnapshotManager";
+export type { SnapshotInputOptions } from "./modules/snapshot/SnapshotOptions";
+
+export type { Bounds } from "./types/Bounds";
+export type {
+  FillLayerStyle,
+  LineLayerStyle,
+  SymbolLayerStyle,
+  CircleLayerStyle,
+  HeatmapLayerStyle,
+  FillExtrusionLayerStyle,
+  RasterLayerStyle,
+  HillshadeLayerStyle,
+  BackgroundLayerStyle,
+  LightLayerStyle,
+  Expression,
+} from "./types/MapLibreRNStyles";
+export type { PressEvent, PressEventWithFeatures } from "./types/PressEvent";
+export type { ViewPadding } from "./types/ViewPadding";
+
+export { Animated } from "./utils/animated/Animated";
+export { Logger, type LogLevel } from "./utils/Logger";
+
+export type { MapLibrePluginProps } from "./plugin/MapLibrePluginProps";

package/src/modules/snapshot/NativeSnapshotModule.ts

@@ -20,5 +20,4 @@ export interface Spec extends TurboModule {
   takeSnap(options: SnapshotJsonOptions): Promise<string>;
 }
 
-export const NativeSnapshotModule =
-  TurboModuleRegistry.getEnforcing<Spec>("MLRNSnapshotModule");
+export default TurboModuleRegistry.getEnforcing<Spec>("MLRNSnapshotModule");

package/src/modules/snapshot/SnapshotManager.ts

@@ -1,4 +1,4 @@
-import { NativeSnapshotModule } from "./NativeSnapshotModule";
+import NativeSnapshotModule from "./NativeSnapshotModule";
 import { type SnapshotInputOptions, SnapshotOptions } from "./SnapshotOptions";
 
 /**

package/src/types/Bounds.ts

@@ -0,0 +1 @@
+export type Bounds = [west: number, south: number, east: number, north: number];

package/src/types/PressEvent.ts

@@ -0,0 +1,19 @@
+export interface PressEvent {
+  longitude: number;
+
+  latitude: number;
+
+  /**
+   * Touch origin X coordinate inside touchable area (relative to the element).
+   */
+  locationX: number;
+
+  /**
+   * Touch origin Y coordinate inside touchable area (relative to the element).
+   */
+  locationY: number;
+}
+
+export interface PressEventWithFeatures extends PressEvent {
+  features: GeoJSON.Feature[];
+}

package/src/types/ViewPadding.ts

@@ -0,0 +1,6 @@
+export type ViewPadding = {
+  top?: number;
+  right?: number;
+  bottom?: number;
+  left?: number;
+};

package/src/types/codegen/UnsafeMixed.ts

@@ -0,0 +1,9 @@
+/**
+ * This type makes it possible to us strict types in TypeScript while being
+ * loose on native.
+ *
+ * RN codegen specifies `type UnsafeMixed = unknown` mapping to folly::dynamic.
+ * During codegen only the name of the type is analyzed, making it possible to
+ * override their type this way.
+ */
+export type UnsafeMixed<T> = T;

package/src/utils/index.ts

@@ -12,14 +12,7 @@ export function isAndroid(): boolean {
   return Platform.OS === "android";
 }
 
-export function existenceChange(cur: boolean, next: boolean): boolean {
-  if (!cur && !next) {
-    return false;
-  }
-  return (!cur && next) || (cur && !next);
-}
-
-export function isFunction(fn: unknown): fn is boolean {
+export function isFunction(fn: unknown): fn is Function {
   return typeof fn === "function";
 }
 
@@ -39,12 +32,6 @@ export function isBoolean(bool: unknown): bool is boolean {
   return typeof bool === "boolean";
 }
 
-export function isPrimitive(
-  value: unknown,
-): value is string | number | boolean {
-  return isString(value) || isNumber(value) || isBoolean(value);
-}
-
 export type NativeArg =
   | string
   | number

package/android/src/main/java/org/maplibre/reactnative/components/AbstractEvent.java

@@ -1,35 +0,0 @@
-package org.maplibre.reactnative.components;
-
-import com.facebook.react.bridge.WritableMap;
-import com.facebook.react.uimanager.events.Event;
-import com.facebook.react.uimanager.events.RCTEventEmitter;
-
-import javax.annotation.Nullable;
-
-public class AbstractEvent extends Event<AbstractEvent> {
-    private String mEventName;
-    private final boolean mCanCoalesce;
-    private WritableMap mEvent;
-
-    public AbstractEvent(int viewId, String eventName, boolean canCoalesce, @Nullable WritableMap event) {
-        super(viewId);
-        mEventName = eventName;
-        mCanCoalesce = canCoalesce;
-        mEvent = event;
-    }
-
-    @Override
-    public String getEventName() {
-        return mEventName;
-    }
-
-    @Override
-    public void dispatch(RCTEventEmitter rctEventEmitter) {
-        rctEventEmitter.receiveEvent(getViewTag(), getEventName(), mEvent);
-    }
-
-    @Override
-    public boolean canCoalesce() {
-        return mCanCoalesce;
-    }
-}

package/android/src/main/java/org/maplibre/reactnative/components/AbstractEventEmitter.java

@@ -1,80 +0,0 @@
-package org.maplibre.reactnative.components;
-
-import android.view.ViewGroup;
-
-import org.maplibre.reactnative.BuildConfig;
-import com.facebook.react.bridge.ReactApplicationContext;
-import com.facebook.react.common.MapBuilder;
-import com.facebook.react.uimanager.ThemedReactContext;
-import com.facebook.react.uimanager.UIManagerHelper;
-import com.facebook.react.uimanager.UIManagerModule;
-import com.facebook.react.uimanager.ViewGroupManager;
-import com.facebook.react.uimanager.events.EventDispatcher;
-import com.facebook.react.uimanager.common.UIManagerType;
-
-import org.maplibre.reactnative.events.IEvent;
-
-import java.util.HashMap;
-import java.util.Map;
-
-import javax.annotation.Nullable;
-import javax.annotation.Nonnull;
-
-abstract public class AbstractEventEmitter<T extends ViewGroup> extends ViewGroupManager<T> {
-    private static final double BRIDGE_TIMEOUT_MS = 10;
-    private Map<String, Long> mRateLimitedEvents;
-    private EventDispatcher mEventDispatcher;
-    private ReactApplicationContext mRCTAppContext;
-
-    public AbstractEventEmitter(ReactApplicationContext reactApplicationContext) {
-        mRateLimitedEvents = new HashMap<>();
-        mRCTAppContext = reactApplicationContext;
-    }
-
-    public void handleEvent(IEvent event) {
-        String eventCacheKey = getEventCacheKey(event);
-
-        // fail safe to protect bridge from being spammed
-        if (shouldDropEvent(eventCacheKey, event)) {
-            return;
-        }
-
-        mRateLimitedEvents.put(eventCacheKey, System.currentTimeMillis());
-        mEventDispatcher.dispatchEvent(new AbstractEvent(event.getID(), event.getKey(), event.canCoalesce(), event.toJSON()));
-    }
-
-    @Override
-    protected void addEventEmitters(ThemedReactContext context, @Nonnull T view) {
-        mEventDispatcher = UIManagerHelper.getUIManager(context, UIManagerType.FABRIC).getEventDispatcher();
-    }
-
-    @Nullable
-    @Override
-    public Map<String, Object> getExportedCustomDirectEventTypeConstants() {
-        Map<String, String> events = customEvents();
-
-        if (events == null) {
-            return null;
-        }
-
-        Map<String, Object> exportedEvents = new HashMap<>();
-
-        for (Map.Entry<String, String> event : events.entrySet()) {
-            exportedEvents.put(event.getKey(), MapBuilder.of("registrationName", event.getValue()));
-        }
-
-        return exportedEvents;
-    }
-
-    @Nullable
-    public abstract Map<String, String> customEvents();
-
-    private boolean shouldDropEvent(String cacheKey, IEvent event) {
-        Long lastEventTimestamp = mRateLimitedEvents.get(cacheKey);
-        return lastEventTimestamp != null && (event.getTimestamp() - lastEventTimestamp) <= BRIDGE_TIMEOUT_MS;
-    }
-
-    private String getEventCacheKey(IEvent event) {
-        return String.format("%s-%s", event.getKey(), event.getType());
-    }
-}

package/android/src/main/java/org/maplibre/reactnative/components/camera/CameraStop.java

@@ -1,245 +0,0 @@
-package org.maplibre.reactnative.components.camera;
-
-import android.content.Context;
-import androidx.annotation.NonNull;
-import android.util.DisplayMetrics;
-
-import com.facebook.react.bridge.ReadableMap;
-import org.maplibre.geojson.FeatureCollection;
-import org.maplibre.geojson.Point;
-import org.maplibre.android.camera.CameraPosition;
-import org.maplibre.android.camera.CameraUpdate;
-import org.maplibre.android.camera.CameraUpdateFactory;
-import org.maplibre.android.geometry.LatLng;
-import org.maplibre.android.geometry.LatLngBounds;
-import org.maplibre.android.maps.MapLibreMap;
-
-import org.maplibre.reactnative.components.camera.constants.CameraMode;
-import org.maplibre.reactnative.utils.GeoJSONUtils;
-import org.maplibre.reactnative.components.mapview.MLRNMapView;
-
-public class CameraStop {
-    private Double mBearing;
-    private Double mTilt;
-    private Double mZoom;
-    private LatLng mLatLng;
-
-    private LatLngBounds mBounds;
-    private int mPaddingLeft = 0;
-    private int mPaddingRight = 0;
-    private int mPaddingBottom = 0;
-    private int mPaddingTop = 0;
-
-    private int mMode = CameraMode.EASE;
-    private int mDuration = 2000;
-    private MapLibreMap.CancelableCallback mCallback;
-
-    public CameraStop() {
-    }
-
-    public void setBearing(double bearing) {
-        mBearing = bearing;
-    }
-
-    public void setTilt(double tilt) {
-        mTilt = tilt;
-    }
-
-    public void setZoom(double zoom) {
-        mZoom = zoom;
-    }
-
-    public void setLatLng(LatLng latLng) {
-        mLatLng = latLng;
-    }
-
-    public void setDuration(int duration) {
-        mDuration = duration;
-    }
-
-    public void setCallback(MapLibreMap.CancelableCallback callback) {
-        mCallback = callback;
-    }
-
-    public void setBounds(LatLngBounds bounds) {
-        mBounds = bounds;
-    }
-
-    public void setPadding(int paddingLeft, int paddingRight, int paddingTop, int paddingBottom) {
-        mPaddingLeft = paddingLeft;
-        mPaddingRight = paddingRight;
-        mPaddingTop = paddingTop;
-        mPaddingBottom = paddingBottom;
-    }
-
-    public void setMode(@CameraMode.Mode int mode) {
-        mMode = mode;
-    }
-
-    public CameraUpdateItem toCameraUpdate(MLRNMapView mapView) {
-        MapLibreMap map = mapView.getMapboxMap();
-        CameraPosition currentCamera = map.getCameraPosition();
-        CameraPosition.Builder builder = new CameraPosition.Builder(currentCamera);
-
-        // Adding map padding to the camera padding which is the same behavior as
-        // mapbox native does on iOS
-        double[] contentInset = mapView.getContentInset();
-
-        int paddingLeft = Double.valueOf(contentInset[0] + mPaddingLeft).intValue();
-        int paddingTop = Double.valueOf(contentInset[1] + mPaddingTop).intValue();
-        int paddingRight = Double.valueOf(contentInset[2] + mPaddingRight).intValue();
-        int paddingBottom = Double.valueOf(contentInset[3] + mPaddingBottom).intValue();
-
-        int[] cameraPadding = {paddingLeft, paddingTop, paddingRight, paddingBottom};
-        int[] cameraPaddingClipped = clippedPadding(cameraPadding, mapView);
-
-        boolean hasSetZoom = false;
-
-        if (mLatLng != null) {
-            builder.target(mLatLng);
-            builder.padding(
-                cameraPaddingClipped[0],
-                cameraPaddingClipped[1],
-                cameraPaddingClipped[2],
-                cameraPaddingClipped[3]
-            );
-        } else if (mBounds != null) {
-            double tilt = mTilt != null ? mTilt : currentCamera.tilt;
-            double bearing = mBearing != null ? mBearing : currentCamera.bearing;
-
-            CameraPosition boundsCamera = map.getCameraForLatLngBounds(mBounds, cameraPaddingClipped, bearing, tilt);
-            if (boundsCamera != null) {
-                builder.target(boundsCamera.target);
-                builder.zoom(boundsCamera.zoom);
-                builder.padding(boundsCamera.padding);
-            } else {
-                CameraUpdate update = CameraUpdateFactory.newLatLngBounds(
-                    mBounds,
-                    cameraPaddingClipped[0],
-                    cameraPaddingClipped[1],
-                    cameraPaddingClipped[2],
-                    cameraPaddingClipped[3]
-                );
-                return new CameraUpdateItem(map, update, mDuration, mCallback, mMode);
-            }
-            hasSetZoom = true;
-        }
-
-        if (mBearing != null) {
-            builder.bearing(mBearing);
-        }
-
-        if (mTilt != null) {
-            builder.tilt(mTilt);
-        }
-
-        if (mZoom != null && !hasSetZoom) {
-            builder.zoom(mZoom);
-        }
-
-        return new CameraUpdateItem(map, CameraUpdateFactory.newCameraPosition(builder.build()), mDuration, mCallback, mMode);
-    }
-
-    public static CameraStop fromReadableMap(Context context, @NonNull ReadableMap readableMap, MapLibreMap.CancelableCallback callback) {
-        CameraStop stop = new CameraStop();
-
-        if (readableMap.hasKey("pitch")) {
-            stop.setTilt(readableMap.getDouble("pitch"));
-        }
-
-        if (readableMap.hasKey("heading")) {
-            stop.setBearing(readableMap.getDouble("heading"));
-        }
-
-        int paddingTop = getPaddingByKey(readableMap, "paddingTop");
-        int paddingRight = getPaddingByKey(readableMap, "paddingRight");
-        int paddingBottom = getPaddingByKey(readableMap, "paddingBottom");
-        int paddingLeft = getPaddingByKey(readableMap, "paddingLeft");
-
-        // scale padding by pixel ratio
-        DisplayMetrics metrics = context.getResources().getDisplayMetrics();
-        paddingTop = Float.valueOf(paddingTop * metrics.scaledDensity).intValue();
-        paddingRight = Float.valueOf(paddingRight * metrics.scaledDensity).intValue();
-        paddingBottom = Float.valueOf(paddingBottom * metrics.scaledDensity).intValue();
-        paddingLeft = Float.valueOf(paddingLeft * metrics.scaledDensity).intValue();
-
-        stop.setPadding(
-                paddingLeft,
-                paddingRight,
-                paddingTop,
-                paddingBottom
-        );
-
-        if (readableMap.hasKey("centerCoordinate")) {
-            Point target = GeoJSONUtils.toPointGeometry(readableMap.getString("centerCoordinate"));
-            stop.setLatLng(GeoJSONUtils.toLatLng(target));
-        }
-
-        if (readableMap.hasKey("zoom")) {
-            stop.setZoom(readableMap.getDouble("zoom"));
-        }
-
-        if (readableMap.hasKey("duration")) {
-            stop.setDuration(readableMap.getInt("duration"));
-        }
-
-        if (readableMap.hasKey("bounds")) {
-            FeatureCollection collection = FeatureCollection.fromJson(readableMap.getString("bounds"));
-            stop.setBounds(GeoJSONUtils.toLatLngBounds(collection));
-        }
-
-        if (readableMap.hasKey("mode")) {
-            switch (readableMap.getInt("mode")) {
-                case CameraMode.FLIGHT:
-                    stop.setMode(CameraMode.FLIGHT);
-                    break;
-                case CameraMode.LINEAR:
-                    stop.setMode(CameraMode.LINEAR);
-                    break;
-                case CameraMode.NONE:
-                    stop.setMode(CameraMode.NONE);
-                    break;
-                default:
-                    stop.setMode(CameraMode.EASE);
-            }
-        }
-
-        stop.setCallback(callback);
-        return stop;
-    }
-
-    private static int[] clippedPadding(int[] padding, MLRNMapView mapView) {
-        int mapHeight = mapView.getHeight();
-        int mapWidth = mapView.getWidth();
-
-        int left = padding[0];
-        int top = padding[1];
-        int right = padding[2];
-        int bottom = padding[3];
-
-        int resultLeft = left;
-        int resultTop = top;
-        int resultRight = right;
-        int resultBottom = bottom;
-
-        if (top + bottom >= mapHeight) {
-            double totalPadding = top + bottom;
-            double extra = totalPadding - mapHeight + 1.0; // add 1 to compensate for floating point math
-            resultTop -= (top * extra) / totalPadding;
-            resultBottom -= (bottom * extra) / totalPadding;
-        }
-
-        if (left + right >= mapWidth) {
-            double totalPadding = left + right;
-            double extra = totalPadding - mapWidth + 1.0; // add 1 to compensate for floating point math
-            resultLeft -= (left * extra) / totalPadding;
-            resultRight -= (right * extra) / totalPadding;
-        }
-
-        return new int[] {resultLeft, resultTop, resultRight, resultBottom};
-    }
-
-    private static int getPaddingByKey(ReadableMap map, String key) {
-        return map.hasKey(key) ? map.getInt(key) : 0;
-    }
-}