@maplibre/maplibre-react-native 10.0.0-beta.8 → 10.0.0

package/src/modules/offline/{offlineManager.ts → OfflineManager.ts}

@@ -4,13 +4,14 @@ import {
   type EventSubscription,
 } from "react-native";
 
-import OfflineCreatePackOptions, {
+import {
+  OfflineCreatePackOptions,
   type OfflineCreatePackInputOptions,
 } from "./OfflineCreatePackOptions";
-import OfflinePack, { type OfflinePackStatus } from "./OfflinePack";
+import { OfflinePack, type OfflinePackStatus } from "./OfflinePack";
 import { isUndefined, isFunction, isAndroid } from "../../utils";
 
-const MapLibreRN = NativeModules.MLRNModule;
+const MLRNModule = NativeModules.MLRNModule;
 const MLRNOfflineModule = NativeModules.MLRNOfflineModule;
 export const OfflineModuleEventEmitter = new NativeEventEmitter(
   MLRNOfflineModule,
@@ -67,7 +68,7 @@ class OfflineManager {
    * const progressListener = (offlineRegion, status) => console.log(offlineRegion, status);
    * const errorListener = (offlineRegion, err) => console.log(offlineRegion, err);
    *
-   * await MapLibreGL.offlineManager.createPack({
+   * await OfflineManager.createPack({
    *   name: 'offlinePack',
    *   styleURL: 'https://demotiles.maplibre.org/tiles/tiles.json',
    *   minZoom: 14,
@@ -106,9 +107,9 @@ class OfflineManager {
    * This is more efficient than deleting the offline pack and downloading it again. If the data stored locally matches that on the server, new data will not be downloaded.
    *
    * @example
-   * await MapLibreGL.offlineManager.invalidatePack('packName')
+   * await OfflineManager.invalidatePack('packName')
    *
-   * @param  {String}  name  Name of the offline pack.
+   * @param  {string}  name  Name of the offline pack.
    * @return {void}
    */
   async invalidatePack(name: string): Promise<void> {
@@ -128,9 +129,9 @@ class OfflineManager {
    * Unregisters the given offline pack and allows resources that are no longer required by any remaining packs to be potentially freed.
    *
    * @example
-   * await MapLibreGL.offlineManager.deletePack('packName')
+   * await OfflineManager.deletePack('packName')
    *
-   * @param  {String}  name  Name of the offline pack.
+   * @param  {string}  name  Name of the offline pack.
    * @return {void}
    */
   async deletePack(name: string): Promise<void> {
@@ -154,7 +155,7 @@ class OfflineManager {
    * It does not erase resources from the ambient cache or delete the database, which can be computationally expensive operations that may carry unintended side effects.
    *
    * @example
-   * await MapLibreGL.offlineManager.invalidateAmbientCache();
+   * await OfflineManager.invalidateAmbientCache();
    *
    * @return {void}
    */
@@ -168,7 +169,7 @@ class OfflineManager {
    * This method clears the cache and decreases the amount of space that map resources take up on the device.
    *
    * @example
-   * await MapLibreGL.offlineManager.clearAmbientCache();
+   * await OfflineManager.clearAmbientCache();
    *
    * @return {void}
    */
@@ -182,9 +183,9 @@ class OfflineManager {
    * This method may be computationally expensive because it will erase resources from the ambient cache if its size is decreased.
    *
    * @example
-   * await MapLibreGL.offlineManager.setMaximumAmbientCacheSize(5000000);
+   * await OfflineManager.setMaximumAmbientCacheSize(5000000);
    *
-   * @param  {Number}  size  Size of ambient cache.
+   * @param  {number}  size  Size of ambient cache.
    * @return {void}
    */
   async setMaximumAmbientCacheSize(size: number): Promise<void> {
@@ -196,7 +197,7 @@ class OfflineManager {
    * Deletes the existing database, which includes both the ambient cache and offline packs, then reinitializes it.
    *
    * @example
-   * await MapLibreGL.offlineManager.resetDatabase();
+   * await OfflineManager.resetDatabase();
    *
    * @return {void}
    */
@@ -209,7 +210,7 @@ class OfflineManager {
    * Retrieves all the current offline packs that are stored in the database.
    *
    * @example
-   * const offlinePacks = await MapLibreGL.offlineManager.getPacks();
+   * const offlinePacks = await OfflineManager.getPacks();
    *
    * @return {Array<OfflinePack>}
    */
@@ -225,9 +226,9 @@ class OfflineManager {
    * Retrieves an offline pack that is stored in the database by name.
    *
    * @example
-   * const offlinePack = await MapLibreGL.offlineManager.getPack();
+   * const offlinePack = await OfflineManager.getPack();
    *
-   * @param  {String}  name  Name of the offline pack.
+   * @param  {string}  name  Name of the offline pack.
    * @return {OfflinePack}
    */
   async getPack(name: string) {
@@ -239,9 +240,9 @@ class OfflineManager {
    * Sideloads offline db
    *
    * @example
-   * await MapLibreGL.offlineManager.mergeOfflineRegions(path);
+   * await OfflineManager.mergeOfflineRegions(path);
    *
-   * @param {String} path Path to offline tile db on file system.
+   * @param {string} path Path to offline tile db on file system.
    * @return {void}
    */
   async mergeOfflineRegions(path: string): Promise<void> {
@@ -254,9 +255,9 @@ class OfflineManager {
    * Consult the Terms of Service for your map tile host before changing this value.
    *
    * @example
-   * MapLibreGL.offlineManager.setTileCountLimit(1000);
+   * OfflineManager.setTileCountLimit(1000);
    *
-   * @param {Number} limit Map tile limit count.
+   * @param {number} limit Map tile limit count.
    * @return {void}
    */
   setTileCountLimit(limit: number): void {
@@ -268,9 +269,9 @@ class OfflineManager {
    * The default is 500ms.
    *
    * @example
-   * MapLibreGL.offlineManager.setProgressEventThrottle(500);
+   * OfflineManager.setProgressEventThrottle(500);
    *
-   * @param {Number} throttleValue event throttle value in ms.
+   * @param {number} throttleValue event throttle value in ms.
    * @return {void}
    */
   setProgressEventThrottle(throttleValue: number): void {
@@ -284,7 +285,7 @@ class OfflineManager {
    * @example
    * const progressListener = (offlinePack, status) => console.log(offlinePack, status)
    * const errorListener = (offlinePack, err) => console.log(offlinePack, err)
-   * MapLibreGL.offlineManager.subscribe('packName', progressListener, errorListener)
+   * OfflineManager.subscribe('packName', progressListener, errorListener)
    *
    * @param  {string} packName           Name of the offline pack.
    * @param  {ProgressListener} progressListener Callback that listens for status events while downloading the offline resource.
@@ -300,7 +301,7 @@ class OfflineManager {
     if (isFunction(progressListener)) {
       if (totalProgressListeners === 0) {
         this.subscriptionProgress = OfflineModuleEventEmitter.addListener(
-          MapLibreRN.OfflineCallbackName.Progress,
+          MLRNModule.OfflineCallbackName.Progress,
           this._onProgress,
         );
       }
@@ -311,7 +312,7 @@ class OfflineManager {
     if (isFunction(errorListener)) {
       if (totalErrorListeners === 0) {
         this.subscriptionError = OfflineModuleEventEmitter.addListener(
-          MapLibreRN.OfflineCallbackName.Error,
+          MLRNModule.OfflineCallbackName.Error,
           this._onError,
         );
       }
@@ -335,9 +336,9 @@ class OfflineManager {
    * It's a good idea to call this on componentWillUnmount.
    *
    * @example
-   * MapLibreGL.offlineManager.unsubscribe('packName')
+   * OfflineManager.unsubscribe('packName')
    *
-   * @param  {String} packName Name of the offline pack.
+   * @param  {string} packName Name of the offline pack.
    * @return {void}
    */
   unsubscribe(packName: string): void {
@@ -390,7 +391,7 @@ class OfflineManager {
     }
 
     // cleanup listeners now that they are no longer needed
-    if (state === MapLibreRN.OfflinePackDownloadState.Complete) {
+    if (state === MLRNModule.OfflinePackDownloadState.Complete) {
       this.unsubscribe(name);
     }
   }
@@ -421,4 +422,4 @@ class OfflineManager {
 }
 
 const offlineManager = new OfflineManager();
-export default offlineManager;
+export { offlineManager as OfflineManager };

package/src/modules/offline/OfflinePack.ts

@@ -1,6 +1,6 @@
 import { NativeModules } from "react-native";
 
-import OfflineCreatePackOptions from "./OfflineCreatePackOptions";
+import { OfflineCreatePackOptions } from "./OfflineCreatePackOptions";
 
 const MLRNOfflineModule = NativeModules.MLRNOfflineModule;
 
@@ -15,7 +15,7 @@ export type OfflinePackStatus = {
   requiredResourceCount: number;
 };
 
-class OfflinePack {
+export class OfflinePack {
   private pack: OfflineCreatePackOptions;
   private _metadata: Record<string, any> | null;
 
@@ -52,5 +52,3 @@ class OfflinePack {
     return MLRNOfflineModule.pausePackDownload(this.name);
   }
 }
-
-export default OfflinePack;

package/src/modules/snapshot/{snapshotManager.ts → SnapshotManager.ts}

@@ -1,11 +1,11 @@
 import { NativeModules } from "react-native";
 
-import SnapshotOptions, { type SnapshotInputOptions } from "./SnapshotOptions";
+import { SnapshotOptions, type SnapshotInputOptions } from "./SnapshotOptions";
 
 const MLRNSnapshotModule = NativeModules.MLRNSnapshotModule;
 
 /**
- * The snapshotManager generates static raster images of the map.
+ * The SnapshotManager generates static raster images of the map.
  * Each snapshot image depicts a portion of a map defined by an SnapshotOptions object you provide.
  * The snapshotter generates the snapshot asynchronous.
  */
@@ -16,35 +16,35 @@ class SnapshotManager {
    * @example
    *
    * // creates a temp file png of base map
-   * const uri = await MapLibreGL.snapshotManager.takeSnap({
+   * const uri = await SnapshotManager.takeSnap({
    *   centerCoordinate: [-74.126410, 40.797968],
    *   width: width,
    *   height: height,
    *   zoomLevel: 12,
    *   pitch: 30,
    *   heading: 20,
-   *   styleURL: MapLibreGL.StyleURL.Default,
+   *   styleURL: StyleURL.Default,
    *   writeToDisk: true, // Create a temporary file
    * });
    *
    * // creates base64 png of base map without logo
-   * const uri = await MapLibreGL.snapshotManager.takeSnap({
+   * const uri = await SnapshotManager.takeSnap({
    *   centerCoordinate: [-74.126410, 40.797968],
    *   width: width,
    *   height: height,
    *   zoomLevel: 12,
    *   pitch: 30,
    *   heading: 20,
-   *   styleURL: MapLibreGL.StyleURL.Default,
+   *   styleURL: StyleURL.Default,
    *   withLogo: false, // Disable Mapbox logo (Android only)
    * });
    *
    * // creates snapshot with bounds
-   * const uri = await MapLibreGL.snapshotManager.takeSnap({
+   * const uri = await SnapshotManager.takeSnap({
    *   bounds: [[-74.126410, 40.797968], [-74.143727, 40.772177]],
    *   width: width,
    *   height: height,
-   *   styleURL: MapLibreGL.StyleURL.Default,
+   *   styleURL: StyleURL.Default,
    * });
    *
    * @param  {SnapshotOptions}  options Snapshot options for create a static image of the base map
@@ -59,4 +59,4 @@ class SnapshotManager {
 }
 
 const snapshotManager = new SnapshotManager();
-export default snapshotManager;
+export { snapshotManager as SnapshotManager };

package/src/modules/snapshot/SnapshotOptions.ts

@@ -3,7 +3,7 @@ import { NativeModules } from "react-native";
 
 import { toJSONString } from "../../utils";
 
-const MapLibreRN = NativeModules.MLRNModule;
+const MLRNModule = NativeModules.MLRNModule;
 
 export interface SnapshotInputOptions {
   centerCoordinate?: GeoJSON.Position;
@@ -50,7 +50,7 @@ export class SnapshotOptions {
       );
     }
 
-    this.styleURL = options.styleURL || MapLibreRN.StyleURL.Default;
+    this.styleURL = options.styleURL || MLRNModule.StyleURL.Default;
     this.heading = options.heading || 0.0;
     this.pitch = options.pitch || 0.0;
     this.zoomLevel = options.zoomLevel || 16.0;
@@ -99,5 +99,3 @@ export class SnapshotOptions {
     return toJSONString(featureCollection(features));
   }
 }
-
-export default SnapshotOptions;

package/src/plugin/MapLibrePluginProps.ts

@@ -0,0 +1,83 @@
+type VersionString =
+  | `${number}.${number}.${number}`
+  | `${number}.${number}.${number}-${string}`;
+
+export type MapLibrePluginProps =
+  | {
+      /**
+       * Properties relevant only for Android
+       *
+       * @platform android
+       */
+      android?: {
+        /**
+         * Version for `org.maplibre.gl:android-sdk`
+         */
+        nativeVersion?: VersionString;
+        /**
+         * Version for `org.maplibre.gl:android-plugin-*-v9`
+         */
+        pluginVersion?: VersionString;
+        /**
+         * Version for `org.maplibre.gl:android-sdk-turf`
+         */
+        turfVersion?: VersionString;
+        /**
+         * Version for `com.squareup.okhttp3:okhttp`
+         */
+        okhttpVersion?: VersionString;
+
+        /**
+         * Location engine to be used
+         *
+         * - `default`: Used per default from MapLibre; F-Droid compatible
+         * - `google`: Google Play Services Location Engine for higher precision; F-Droid incompatible
+         *
+         * @default "default"
+         */
+        locationEngine?: "default" | "google";
+        /**
+         * Version for `com.google.android.gms:play-services-location`, only used with `locationEngine: "google"`
+         */
+        googlePlayServicesLocationVersion?: VersionString;
+      };
+
+      /**
+       * Properties relevant only for iOS
+       *
+       * @platform ios
+       */
+      ios?: {
+        /**
+         * Version for `maplibre-gl-native-distribution`
+         */
+        nativeVersion?: VersionString;
+
+        /**
+         * Swift Package Manager spec to override the selected version range
+         *
+         * @default `{
+         *   url: "https://github.com/maplibre/maplibre-gl-native-distribution",
+         *   requirement: {
+         *     kind: "exactVersion",
+         *     version: $MLRN_NATIVE_VERSION
+         *   },
+         *   product_name: "MapLibre"
+         * }`
+         *
+         * @example
+         * ```ts
+         * spmSpec: `{
+         *   url: "https://github.com/maplibre/maplibre-gl-native-distribution",
+         *   requirement: {
+         *     kind: "upToNextMajorVersion",
+         *     minimumVersion: "x.x.x"
+         *   },
+         *   product_name: "MapLibre"
+         * }`
+         * ```
+         */
+        spmSpec?: string;
+      };
+    }
+  | undefined;

package/src/plugin/android.ts

@@ -0,0 +1,64 @@
+import {
+  type ConfigPlugin,
+  withGradleProperties as withGradlePropertiesExpo,
+} from "@expo/config-plugins";
+import type { PropertiesItem } from "@expo/config-plugins/build/android/Properties";
+
+import type { MapLibrePluginProps } from "./MapLibrePluginProps";
+
+type PropertyItem = {
+  type: "property";
+  key: string;
+  value: string;
+};
+
+export const getGradleProperties = (
+  props: MapLibrePluginProps,
+): PropertyItem[] => {
+  return Object.entries(props?.android || {}).reduce(
+    (properties, [key, value]) => {
+      if (key && value) {
+        properties.push({
+          type: "property",
+          key: `org.maplibre.reactnative.${key}`,
+          value: value.toString(),
+        });
+      }
+
+      return properties;
+    },
+    [] as PropertyItem[],
+  );
+};
+
+export const mergeGradleProperties = (
+  oldProperties: PropertiesItem[],
+  newProperties: PropertyItem[],
+): PropertiesItem[] => {
+  const newPropertiesKeys = newProperties.map(({ key }) => key);
+  const merged = oldProperties.filter(
+    (item) =>
+      !(item.type === "property" && newPropertiesKeys.includes(item.key)),
+  );
+
+  merged.push(...newProperties);
+
+  return merged;
+};
+
+export const withGradleProperties: ConfigPlugin<MapLibrePluginProps> = (
+  config,
+  props,
+) => {
+  const gradleProperties = getGradleProperties(props);
+
+  return withGradlePropertiesExpo(config, (c) => {
+    c.modResults = mergeGradleProperties(c.modResults, gradleProperties);
+
+    return c;
+  });
+};
+
+export const android = {
+  withGradleProperties,
+};

package/src/plugin/ios.ts

@@ -0,0 +1,166 @@
+import {
+  type ConfigPlugin,
+  withPodfile,
+  withXcodeProject,
+  type XcodeProject,
+} from "@expo/config-plugins";
+import {
+  mergeContents,
+  removeGeneratedContents,
+} from "@expo/config-plugins/build/utils/generateCode";
+
+import type { MapLibrePluginProps } from "./MapLibrePluginProps";
+
+const TAG_PREFIX = `@maplibre/maplibre-react-native`;
+
+/**
+ * Only the post-install block is required, the post installer block is used for SPM (Swift Package Manager) which Expo
+ * doesn't currently support.
+ */
+export function applyPodfilePostInstall(contents: string): string {
+  const result = mergeContents({
+    tag: `${TAG_PREFIX}:post-install`,
+    src: contents,
+    newSrc: `    $MLRN.post_install(installer)`,
+    anchor: /post_install do \|installer\|/,
+    offset: 1,
+    comment: "#",
+  });
+
+  if (result.didMerge || result.didClear) {
+    return result.contents;
+  }
+
+  return contents;
+}
+
+const withPodfilePostInstall: ConfigPlugin = (config) => {
+  return withPodfile(config, (c) => {
+    c.modResults.contents = applyPodfilePostInstall(c.modResults.contents);
+
+    return c;
+  });
+};
+
+export const applyPodfileGlobalVariables = (
+  contents: string,
+  props: MapLibrePluginProps,
+): string => {
+  const tag = `${TAG_PREFIX}:global-variables`;
+
+  const globalVariables = [];
+
+  if (props?.ios?.nativeVersion) {
+    globalVariables.push(`$MLRN_NATIVE_VERSION = "${props.ios.nativeVersion}"`);
+  }
+
+  if (props?.ios?.spmSpec) {
+    globalVariables.push(`$MLRN_SPM_SPEC = ${props.ios.spmSpec}`);
+  }
+
+  if (globalVariables.length > 0) {
+    return mergeContents({
+      tag,
+      src: contents,
+      newSrc: globalVariables.join("\n"),
+      anchor: /target .+ do/,
+      offset: 0,
+      comment: "#",
+    }).contents;
+  }
+
+  const modified = removeGeneratedContents(contents, tag);
+
+  return modified ?? contents;
+};
+
+export const withPodfileGlobalVariables: ConfigPlugin<MapLibrePluginProps> = (
+  config,
+  props,
+) => {
+  return withPodfile(config, (c) => {
+    c.modResults.contents = applyPodfileGlobalVariables(
+      c.modResults.contents,
+      props,
+    );
+
+    return c;
+  });
+};
+
+/**
+ * Exclude building for arm64 on simulator devices in the pbxproj project.
+ * Without this, production builds targeting simulators will fail.
+ */
+function setExcludedArchitectures(project: XcodeProject): XcodeProject {
+  const configurations = project.pbxXCBuildConfigurationSection();
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-ignore
+  for (const { name, buildSettings } of Object.values(configurations || {})) {
+    // Guessing that this is the best way to emulate Xcode.
+    // Using `project.addToBuildSettings` modifies too many targets.
+    if (
+      name === "Release" &&
+      typeof buildSettings?.PRODUCT_NAME !== "undefined"
+    ) {
+      buildSettings['"EXCLUDED_ARCHS[sdk=iphonesimulator*]"'] = '"arm64"';
+    }
+  }
+
+  return project;
+}
+
+const withoutSignatures: ConfigPlugin = (config) => {
+  return withXcodeProject(config, async (c) => {
+    c.modResults.addBuildPhase(
+      [],
+      "PBXShellScriptBuildPhase",
+      "Remove signature files (Xcode workaround)",
+      null,
+      {
+        shellPath: "/bin/sh",
+        shellScript: `
+          echo "Remove signature files (Xcode workaround)";
+          rm -rf "$CONFIGURATION_BUILD_DIR/MapLibre.xcframework-ios.signature";
+        `,
+      },
+    );
+
+    return c;
+  });
+};
+
+/**
+ *  Set the Debug Information Format to DWARF with dSYM File during EAS Build for Managed App
+ *  https://github.com/expo/eas-cli/issues/968
+ *
+ *  Set `artifactPath` in `eas.json`:
+ *  ```json
+ *  "ios": {
+ *    "artifactPath": "ios/build/*"
+ *  }
+ *  ```
+ */
+const withDwarfDsym: ConfigPlugin = (config) => {
+  return withXcodeProject(config, async (c) => {
+    c.modResults.debugInformationFormat = "dwarf-with-dsym";
+
+    return c;
+  });
+};
+
+const withExcludedSimulatorArchitectures: ConfigPlugin = (config) => {
+  return withXcodeProject(config, (c) => {
+    c.modResults = setExcludedArchitectures(c.modResults);
+
+    return c;
+  });
+};
+
+export const ios = {
+  withPodfilePostInstall,
+  withPodfileGlobalVariables,
+  withoutSignatures,
+  withDwarfDsym,
+  withExcludedSimulatorArchitectures,
+};

package/src/plugin/withMapLibre.ts

@@ -0,0 +1,30 @@
+import { type ConfigPlugin, createRunOncePlugin } from "@expo/config-plugins";
+
+import type { MapLibrePluginProps } from "./MapLibrePluginProps";
+import { android } from "./android";
+import { ios } from "./ios";
+
+let pkg: { name: string; version?: string } = {
+  name: "@maplibre/maplibre-react-native",
+};
+try {
+  pkg = require("@maplibre/maplibre-react-native/package.json");
+} catch {
+  // empty catch block
+}
+
+const withMapLibre: ConfigPlugin<MapLibrePluginProps> = (config, props) => {
+  // Android
+  config = android.withGradleProperties(config, props);
+
+  // iOS
+  config = ios.withExcludedSimulatorArchitectures(config);
+  config = ios.withDwarfDsym(config);
+  config = ios.withoutSignatures(config);
+  config = ios.withPodfileGlobalVariables(config, props);
+  config = ios.withPodfilePostInstall(config);
+
+  return config;
+};
+
+export default createRunOncePlugin(withMapLibre, pkg.name, pkg.version);