react-native-radar 3.21.0-beta.2 → 3.21.0

package/src/index.native.ts

@@ -1,40 +1,102 @@
-import type { EventSubscription } from 'react-native';
-import type { RadarNativeInterface } from './@types/RadarNativeInterface';
-import type { RadarTrackCallback, RadarTrackOnceOptions, RadarLocationUpdateCallback, RadarPermissionsStatus, RadarClientLocationUpdateCallback, RadarLocationSource, RadarErrorCallback, RadarLogUpdateCallback, RadarTokenUpdateCallback, RadarEventUpdateCallback, RadarLogLevel, RadarMetadata, RadarLocationCallback, RadarTrackingOptionsDesiredAccuracy, RadarTrackVerifiedCallback, RadarTrackVerifiedOptions, RadarMockTrackingOptions, RadarTrackingOptions, RadarVerifiedTrackingOptions, RadarContextCallback, RadarNotificationOptions, RadarStartTripOptions, RadarTrackingOptionsForegroundService, RadarTripCallback, RadarTripOptions, RadarUpdateTripOptions, RadarAddress, RadarAddressCallback, RadarAutocompleteOptions, RadarGeocodeOptions, RadarGetDistanceOptions, RadarGetMatrixOptions, RadarIPGeocodeCallback, RadarLogConversionCallback, RadarLogConversionOptions, RadarReverseGeocodeOptions, RadarRouteCallback, RadarRouteMatrix, RadarSearchGeofencesCallback, RadarSearchGeofencesOptions, RadarSearchPlacesCallback, RadarSearchPlacesOptions, RadarValidateAddressCallback,
-  } from './@types/types';
-import { NativeEventEmitter, NativeModules } from 'react-native';
-import { VERSION } from './version';
-
-declare global {
-  var __turboModuleProxy: any;
-}
-
-const isNewArchitecture = global.__turboModuleProxy != null;
-
-let NativeRadar: any;
-
-try {
-  if (isNewArchitecture) {
-    const NativeRadarModule = require('./NativeRadar');
-    NativeRadar = NativeRadarModule.default;
-  } else {
-    NativeRadar = NativeModules.RNRadar;
+import type { EventSubscription } from "react-native";
+import type { RadarNativeInterface } from "./@types/RadarNativeInterface";
+import type {
+  RadarTrackCallback,
+  RadarTrackOnceOptions,
+  RadarLocationUpdateCallback,
+  RadarPermissionsStatus,
+  RadarClientLocationUpdateCallback,
+  RadarLocationSource,
+  RadarErrorCallback,
+  RadarLogUpdateCallback,
+  RadarTokenUpdateCallback,
+  RadarEventUpdateCallback,
+  RadarLogLevel,
+  RadarMetadata,
+  RadarLocationCallback,
+  RadarTrackingOptionsDesiredAccuracy,
+  RadarTrackVerifiedCallback,
+  RadarTrackVerifiedOptions,
+  RadarMockTrackingOptions,
+  RadarTrackingOptions,
+  RadarVerifiedTrackingOptions,
+  RadarContextCallback,
+  RadarNotificationOptions,
+  RadarStartTripOptions,
+  RadarTrackingOptionsForegroundService,
+  RadarTripCallback,
+  RadarTripOptions,
+  RadarUpdateTripOptions,
+  RadarAddress,
+  RadarAddressCallback,
+  RadarAutocompleteOptions,
+  RadarGeocodeOptions,
+  RadarGetDistanceOptions,
+  RadarGetMatrixOptions,
+  RadarIPGeocodeCallback,
+  RadarLogConversionCallback,
+  RadarLogConversionOptions,
+  RadarReverseGeocodeOptions,
+  RadarRouteCallback,
+  RadarRouteMatrix,
+  RadarSearchGeofencesCallback,
+  RadarSearchGeofencesOptions,
+  RadarSearchPlacesCallback,
+  RadarSearchPlacesOptions,
+  RadarValidateAddressCallback,
+  RadarUser,
+  Location,
+  RadarEvent,
+} from "./@types/types";
+import { NativeEventEmitter, NativeModules } from "react-native";
+import { VERSION } from "./version";
+import NativeRadarMod, {
+  ClientLocationEmitter,
+  ErrorEmitter,
+  EventsEmitter,
+  LocationEmitter,
+  LogEmitter,
+  TokenEmitter,
+} from "./NativeRadar";
+
+const NativeRadar = NativeRadarMod;
+// Comment above and uncomment below for QA logging
+// const NativeRadar = new Proxy(NativeRadarMod, {
+//   get: function (target, name, receiver) {
+//     if (typeof target[name] == "function") {
+//       return function () {
+//         console.log("rn native:", name, "(", ...arguments, ")");
+//         return target[name].apply(target, arguments);
+//       };
+//     } else {
+//       return target[name];
+//     }
+//   },
+// });
+
+const compatEventEmitter =
+  NativeRadar.locationEmitter == null
+    ? new NativeEventEmitter(NativeModules.RNRadar)
+    : null;
+
+type Events =
+  | "locationEmitter"
+  | "clientLocationEmitter"
+  | "errorEmitter"
+  | "logEmitter"
+  | "eventsEmitter"
+  | "tokenEmitter";
+
+export function addListener<EventT extends Events>(
+  event: EventT,
+  handler: Parameters<(typeof NativeRadar)[EventT]>[0]
+): EventSubscription {
+  if (compatEventEmitter != null) {
+    return compatEventEmitter.addListener(event, handler);
   }
-} catch (error) {
-  console.error('[Radar] Error loading NativeRadar module:', error);
-  throw error;
+  return NativeRadar[event](handler as any);
 }
 
-// For old architecture, create a NativeEventEmitter
-const eventEmitter = isNewArchitecture ? null : new NativeEventEmitter(NativeModules.RNRadar);
-
-const locationEmitter = isNewArchitecture ? NativeRadar?.locationEmitter : null;
-const clientLocationEmitter = isNewArchitecture ? NativeRadar?.clientLocationEmitter : null;
-const errorEmitter = isNewArchitecture ? NativeRadar?.errorEmitter : null;
-const logEmitter = isNewArchitecture ? NativeRadar?.logEmitter : null;
-const eventsEmitter = isNewArchitecture ? NativeRadar?.eventsEmitter : null;
-const tokenEmitter = isNewArchitecture ? NativeRadar?.tokenEmitter : null;
-
 let locationUpdateSubscription: EventSubscription | null = null;
 let clientLocationUpdateSubscription: EventSubscription | null = null;
 let errorUpdateSubscription: EventSubscription | null = null;
@@ -48,220 +110,142 @@ const Radar: RadarNativeInterface = {
   },
 
   trackOnce: async (options?: RadarTrackOnceOptions) => {
-    return NativeRadar.trackOnce(options || null) as Promise<RadarTrackCallback>;
+    return NativeRadar.trackOnce(
+      options || null
+    ) as Promise<RadarTrackCallback>;
   },
 
-  onLocationUpdate: (callback: RadarLocationUpdateCallback) => {
+  onLocationUpdated: (callback: RadarLocationUpdateCallback | null) => {
     // Clear any existing subscription
     if (locationUpdateSubscription) {
       locationUpdateSubscription.remove();
-      locationUpdateSubscription = null;
     }
 
-    if (isNewArchitecture && locationEmitter) {
-      locationUpdateSubscription = locationEmitter((event: { type: string; location: any; user: any; }) => {
-        try {
-          const locationUpdate = {
-            location: event.location,
-            user: event.user
-          };
+    if (!callback) {
+      return;
+    }
 
-          callback(locationUpdate);
-        } catch (error) {
-          console.error('[Radar] Error in location update callback:', error);
-        }
-      });
-    } else if (!isNewArchitecture && eventEmitter) {
-      locationUpdateSubscription = eventEmitter.addListener('location', (event: { location: any; user: any; }) => {
+    locationUpdateSubscription = addListener(
+      "locationEmitter",
+      (event: LocationEmitter) => {
         try {
           const locationUpdate = {
-            location: event.location,
-            user: event.user
+            location: event.location as Location,
+            user: event.user as RadarUser,
           };
-
           callback(locationUpdate);
         } catch (error) {
-          console.error('[Radar] Error in location update callback:', error);
+          console.error("[Radar] Error in location update callback:", error);
         }
-      });
-    } else {
-      console.warn('[Radar] No event emitter available for location updates');
-    }
-  },
-
-  clearLocationUpdate: () => {
-    if (locationUpdateSubscription) {
-      locationUpdateSubscription.remove();
-      locationUpdateSubscription = null;
-    }
+      }
+    );
   },
 
-  onClientLocationUpdate: (callback: RadarClientLocationUpdateCallback) => {
+  onClientLocationUpdated: (
+    callback: RadarClientLocationUpdateCallback | null
+  ) => {
     if (clientLocationUpdateSubscription) {
       clientLocationUpdateSubscription.remove();
       clientLocationUpdateSubscription = null;
     }
 
-    if (isNewArchitecture && clientLocationEmitter) {
-      clientLocationUpdateSubscription = clientLocationEmitter((event: { location: any; stopped: boolean; source: string; }) => {
-        try {
-          const clientLocationUpdate = {
-            location: event.location,
-            stopped: event.stopped,
-            source: event.source as RadarLocationSource
-          };
-          callback(clientLocationUpdate);
-        } catch (error) {
-          console.error('[Radar] Error in client location update callback:', error);
-        }
-      });
-    } else if (!isNewArchitecture && eventEmitter) {
-      clientLocationUpdateSubscription = eventEmitter.addListener('clientLocation', (event: { location: any; stopped: boolean; source: string; }) => {
-        try {
-          const clientLocationUpdate = {
-            location: event.location,
-            stopped: event.stopped,
-            source: event.source as RadarLocationSource
-          };
-          callback(clientLocationUpdate);
-        } catch (error) {
-          console.error('[Radar] Error in client location update callback:', error);
-        }
-      });
-    } else {
-      console.warn('[Radar] No event emitter available for client location updates');
+    if (!callback) {
+      return;
     }
-  },
 
-  clearClientLocationUpdate: () => {
-    if (clientLocationUpdateSubscription) {
-      clientLocationUpdateSubscription.remove();
-      clientLocationUpdateSubscription = null;
-    }
+    clientLocationUpdateSubscription = addListener(
+      "clientLocationEmitter",
+      (event: ClientLocationEmitter) => {
+        const clientLocationUpdate = {
+          location: event.location as Location,
+          stopped: event.stopped,
+          source: event.source as RadarLocationSource,
+        };
+        callback(clientLocationUpdate);
+      }
+    );
   },
 
-  onError: (callback: RadarErrorCallback) => {
+  onError: (callback: RadarErrorCallback | null) => {
     if (errorUpdateSubscription) {
       errorUpdateSubscription.remove();
       errorUpdateSubscription = null;
     }
 
-    if (isNewArchitecture && errorEmitter) {
-      errorUpdateSubscription = errorEmitter((event: { status: string; }) => {
-        callback(event.status);
-      });
-    } else if (!isNewArchitecture && eventEmitter) {
-      errorUpdateSubscription = eventEmitter.addListener('error', (event: { status: string; }) => {
-        callback(event.status);
-      });
-    } else {
-      console.warn('[Radar] No event emitter available for error updates');
+    if (!callback) {
+      return;
     }
-  },
 
-  clearError: () => {
-    if (errorUpdateSubscription) {
-      errorUpdateSubscription.remove();
-      errorUpdateSubscription = null;
-    }
+    errorUpdateSubscription = addListener(
+      "errorEmitter",
+      (event: ErrorEmitter) => {
+        const errorUpdate = {
+          status: event.status,
+        };
+        callback(errorUpdate.status);
+      }
+    );
   },
 
-  onLog: (callback: RadarLogUpdateCallback) => {
+  onLog: (callback: RadarLogUpdateCallback | null) => {
     if (logUpdateSubscription) {
       logUpdateSubscription.remove();
       logUpdateSubscription = null;
     }
 
-    if (isNewArchitecture && logEmitter) {
-      logUpdateSubscription = logEmitter((event: { message: string; }) => {
-        callback(event.message);
-      });
-    } else if (!isNewArchitecture && eventEmitter) {
-      logUpdateSubscription = eventEmitter.addListener('log', (event: { message: string; }) => {
-        callback(event.message);
-      });
-    } else {
-      console.warn('[Radar] No event emitter available for log updates');
+    if (!callback) {
+      return;
     }
-  },
 
-  clearLog: () => {
-    if (logUpdateSubscription) {
-      logUpdateSubscription.remove();
-      logUpdateSubscription = null;
-    }
+    logUpdateSubscription = addListener("logEmitter", (event: LogEmitter) => {
+      callback(event.message);
+    });
   },
 
-  onEventUpdate: (callback: RadarEventUpdateCallback) => {
+  onEventsReceived: (callback: RadarEventUpdateCallback | null) => {
     if (eventsUpdateSubscription) {
       eventsUpdateSubscription.remove();
       eventsUpdateSubscription = null;
     }
 
-    if (isNewArchitecture && eventsEmitter) {
-      eventsUpdateSubscription = eventsEmitter((event: { events: any[]; user: any; }) => {
-        try {
-          const eventUpdate = {
-            user: event.user,
-            events: event.events
-          };
-          callback(eventUpdate);
-        } catch (error) {
-          console.error('[Radar] Error in event update callback:', error);
-        }
-      });
-    } else if (!isNewArchitecture && eventEmitter) {
-      eventsUpdateSubscription = eventEmitter.addListener('events', (event: { events: any[]; user: any; }) => {
-        try {
-          const eventUpdate = {
-            user: event.user,
-            events: event.events
-          };
-          callback(eventUpdate);
-        } catch (error) {
-          console.error('[Radar] Error in event update callback:', error);
-        }
-      });
-    } else {
-      console.warn('[Radar] No event emitter available for event updates');
+    if (!callback) {
+      return;
     }
-  },
 
-  clearEventUpdate: () => {
-    if (eventsUpdateSubscription) {
-      eventsUpdateSubscription.remove();
-      eventsUpdateSubscription = null;
-    }
+    eventsUpdateSubscription = addListener(
+      "eventsEmitter",
+      (event: EventsEmitter) => {
+        const eventUpdate = {
+          user: event.user as RadarUser,
+          events: event.events as RadarEvent[],
+        };
+        callback(eventUpdate);
+      }
+    );
   },
 
-  onTokenUpdate: (callback: RadarTokenUpdateCallback) => {
+  onTokenUpdated: (callback: RadarTokenUpdateCallback | null) => {
     if (tokenUpdateSubscription) {
       tokenUpdateSubscription.remove();
       tokenUpdateSubscription = null;
     }
 
-    if (isNewArchitecture && tokenEmitter) {
-      tokenUpdateSubscription = tokenEmitter((event: { token: any; }) => {
-        callback(event.token);
-      });
-    } else if (!isNewArchitecture && eventEmitter) {
-      tokenUpdateSubscription = eventEmitter.addListener('token', (event: { token: any; }) => {
-        callback(event.token);
-      });
-    } else {
-      console.warn('[Radar] No event emitter available for token updates');
+    if (!callback) {
+      return;
     }
-  },
 
-  clearTokenUpdate: () => {
-    if (tokenUpdateSubscription) {
-      tokenUpdateSubscription.remove();
-      tokenUpdateSubscription = null;
-    }
+    tokenUpdateSubscription = addListener(
+      "tokenEmitter",
+      (event: TokenEmitter) => {
+        callback(event.token);
+      }
+    );
   },
 
   requestPermissions: (background: boolean) => {
-    return NativeRadar.requestPermissions(background) as Promise<RadarPermissionsStatus>;
+    return NativeRadar.requestPermissions(
+      background
+    ) as Promise<RadarPermissionsStatus>;
   },
   setLogLevel: function (level: RadarLogLevel): void {
     return NativeRadar.setLogLevel(level);
@@ -282,22 +266,36 @@ const Radar: RadarNativeInterface = {
     return NativeRadar.setMetadata(metadata);
   },
   getMetadata: function (): Promise<RadarMetadata> {
-    return NativeRadar.getMetadata();
+    return NativeRadar.getMetadata() as Promise<RadarMetadata>;
+  },
+  setProduct: function (product: string): void {
+    return NativeRadar.setProduct(product);
+  },
+  getProduct: function (): Promise<string> {
+    return NativeRadar.getProduct();
   },
   setAnonymousTrackingEnabled: function (enabled: boolean): void {
     return NativeRadar.setAnonymousTrackingEnabled(enabled);
   },
   getPermissionsStatus: function (): Promise<RadarPermissionsStatus> {
-    return NativeRadar.getPermissionsStatus();
-  },
-  getLocation: function (desiredAccuracy?: RadarTrackingOptionsDesiredAccuracy): Promise<RadarLocationCallback> {
-    return NativeRadar.getLocation(desiredAccuracy);
-  },
-  trackVerified: function (options?: RadarTrackVerifiedOptions): Promise<RadarTrackVerifiedCallback> {
-    return NativeRadar.trackVerified(options);
+    return NativeRadar.getPermissionsStatus() as Promise<RadarPermissionsStatus>;
+  },
+  getLocation: function (
+    desiredAccuracy?: RadarTrackingOptionsDesiredAccuracy
+  ): Promise<RadarLocationCallback> {
+    return NativeRadar.getLocation(
+      desiredAccuracy || null
+    ) as Promise<RadarLocationCallback>;
+  },
+  trackVerified: function (
+    options?: RadarTrackVerifiedOptions
+  ): Promise<RadarTrackVerifiedCallback> {
+    return NativeRadar.trackVerified(
+      options || null
+    ) as Promise<RadarTrackVerifiedCallback>;
   },
   getVerifiedLocationToken: function (): Promise<RadarTrackVerifiedCallback> {
-    return NativeRadar.getVerifiedLocationToken();
+    return NativeRadar.getVerifiedLocationToken() as Promise<RadarTrackVerifiedCallback>;
   },
   clearVerifiedLocationToken: function (): void {
     return NativeRadar.clearVerifiedLocationToken();
@@ -314,15 +312,14 @@ const Radar: RadarNativeInterface = {
   startTrackingCustom: function (options: RadarTrackingOptions): void {
     return NativeRadar.startTrackingCustom(options);
   },
-  startTrackingVerified: function (options?: RadarVerifiedTrackingOptions): void {
-    return NativeRadar.startTrackingVerified(options);
+  startTrackingVerified: function (
+    options?: RadarVerifiedTrackingOptions
+  ): void {
+    return NativeRadar.startTrackingVerified(options || null);
   },
   isTrackingVerified: function (): Promise<boolean> {
     return NativeRadar.isTrackingVerified();
   },
-  setProduct: function (product: string): void {
-    return NativeRadar.setProduct(product);
-  },
   mockTracking: function (options: RadarMockTrackingOptions): void {
     return NativeRadar.mockTracking(options);
   },
@@ -333,7 +330,7 @@ const Radar: RadarNativeInterface = {
     return NativeRadar.stopTrackingVerified();
   },
   getTrackingOptions: function (): Promise<RadarTrackingOptions> {
-    return NativeRadar.getTrackingOptions();
+    return NativeRadar.getTrackingOptions() as Promise<RadarTrackingOptions>;
   },
   isUsingRemoteTrackingOptions: function (): Promise<boolean> {
     return NativeRadar.isUsingRemoteTrackingOptions();
@@ -341,26 +338,32 @@ const Radar: RadarNativeInterface = {
   isTracking: function (): Promise<boolean> {
     return NativeRadar.isTracking();
   },
-  setForegroundServiceOptions: function (options: RadarTrackingOptionsForegroundService): void {
+  setForegroundServiceOptions: function (
+    options: RadarTrackingOptionsForegroundService
+  ): void {
     return NativeRadar.setForegroundServiceOptions(options);
   },
   setNotificationOptions: function (options: RadarNotificationOptions): void {
     return NativeRadar.setNotificationOptions(options);
   },
   getTripOptions: function (): Promise<RadarTripOptions> {
-    return NativeRadar.getTripOptions();
+    return NativeRadar.getTripOptions() as Promise<RadarTripOptions>;
   },
-  startTrip: function (options: RadarStartTripOptions): Promise<RadarTripCallback> {
-    return NativeRadar.startTrip(options);
+  startTrip: function (
+    options: RadarStartTripOptions
+  ): Promise<RadarTripCallback> {
+    return NativeRadar.startTrip(options) as Promise<RadarTripCallback>;
   },
   completeTrip: function (): Promise<RadarTripCallback> {
-    return NativeRadar.completeTrip();
+    return NativeRadar.completeTrip() as Promise<RadarTripCallback>;
   },
   cancelTrip: function (): Promise<RadarTripCallback> {
-    return NativeRadar.cancelTrip();
+    return NativeRadar.cancelTrip() as Promise<RadarTripCallback>;
   },
-  updateTrip: function (options: RadarUpdateTripOptions): Promise<RadarTripCallback> {
-    return NativeRadar.updateTrip(options);
+  updateTrip: function (
+    options: RadarUpdateTripOptions
+  ): Promise<RadarTripCallback> {
+    return NativeRadar.updateTrip(options) as Promise<RadarTripCallback>;
   },
   acceptEvent: function (eventId: string, verifiedPlaceId: string): void {
     return NativeRadar.acceptEvent(eventId, verifiedPlaceId);
@@ -369,37 +372,67 @@ const Radar: RadarNativeInterface = {
     return NativeRadar.rejectEvent(eventId);
   },
   getContext: function (location?: Location): Promise<RadarContextCallback> {
-    return NativeRadar.getContext(location);
-  },
-  searchPlaces: function (options: RadarSearchPlacesOptions): Promise<RadarSearchPlacesCallback> {
-    return NativeRadar.searchPlaces(options);
-  },
-  searchGeofences: function (options: RadarSearchGeofencesOptions): Promise<RadarSearchGeofencesCallback> {
-    return NativeRadar.searchGeofences(options);
-  },
-  autocomplete: function (options: RadarAutocompleteOptions): Promise<RadarAddressCallback> {
-    return NativeRadar.autocomplete(options);
-  },
-  geocode: function (options: RadarGeocodeOptions): Promise<RadarAddressCallback> {
-    return NativeRadar.geocode(options);
-  },
-  reverseGeocode: function (options?: RadarReverseGeocodeOptions): Promise<RadarAddressCallback> {
-    return NativeRadar.reverseGeocode(options);
+    return NativeRadar.getContext(
+      location || null
+    ) as Promise<RadarContextCallback>;
+  },
+  searchPlaces: function (
+    options: RadarSearchPlacesOptions
+  ): Promise<RadarSearchPlacesCallback> {
+    return NativeRadar.searchPlaces(
+      options
+    ) as Promise<RadarSearchPlacesCallback>;
+  },
+  searchGeofences: function (
+    options: RadarSearchGeofencesOptions
+  ): Promise<RadarSearchGeofencesCallback> {
+    return NativeRadar.searchGeofences(
+      options
+    ) as Promise<RadarSearchGeofencesCallback>;
+  },
+  autocomplete: function (
+    options: RadarAutocompleteOptions
+  ): Promise<RadarAddressCallback> {
+    return NativeRadar.autocomplete(options) as Promise<RadarAddressCallback>;
+  },
+  geocode: function (
+    options: RadarGeocodeOptions
+  ): Promise<RadarAddressCallback> {
+    return NativeRadar.geocode(options) as Promise<RadarAddressCallback>;
+  },
+  reverseGeocode: function (
+    options?: RadarReverseGeocodeOptions
+  ): Promise<RadarAddressCallback> {
+    return NativeRadar.reverseGeocode(
+      options || null
+    ) as Promise<RadarAddressCallback>;
   },
   ipGeocode: function (): Promise<RadarIPGeocodeCallback> {
-    return NativeRadar.ipGeocode();
+    return NativeRadar.ipGeocode() as Promise<RadarIPGeocodeCallback>;
   },
-  validateAddress: function (address: RadarAddress): Promise<RadarValidateAddressCallback> {
-    return NativeRadar.validateAddress(address);
+  validateAddress: function (
+    address: RadarAddress
+  ): Promise<RadarValidateAddressCallback> {
+    return NativeRadar.validateAddress(
+      address
+    ) as Promise<RadarValidateAddressCallback>;
   },
-  getDistance: function (option: RadarGetDistanceOptions): Promise<RadarRouteCallback> {
-    return NativeRadar.getDistance(option);
+  getDistance: function (
+    option: RadarGetDistanceOptions
+  ): Promise<RadarRouteCallback> {
+    return NativeRadar.getDistance(option) as Promise<RadarRouteCallback>;
   },
-  getMatrix: function (option: RadarGetMatrixOptions): Promise<RadarRouteMatrix> {
-    return NativeRadar.getMatrix(option);
+  getMatrix: function (
+    option: RadarGetMatrixOptions
+  ): Promise<RadarRouteMatrix> {
+    return NativeRadar.getMatrix(option) as Promise<RadarRouteMatrix>;
   },
-  logConversion: function (options: RadarLogConversionOptions): Promise<RadarLogConversionCallback> {
-    return NativeRadar.logConversion(options);
+  logConversion: function (
+    options: RadarLogConversionOptions
+  ): Promise<RadarLogConversionCallback> {
+    return NativeRadar.logConversion(
+      options
+    ) as Promise<RadarLogConversionCallback>;
   },
 
   nativeSdkVersion: function (): Promise<string> {
@@ -413,7 +446,7 @@ const Radar: RadarNativeInterface = {
   },
   getPublishableKey: function (): Promise<string> {
     return NativeRadar.getPublishableKey();
-  }
-}
+  },
+};
 
 export default Radar;

package/src/index.tsx

@@ -3,7 +3,10 @@ import { Platform } from "react-native";
 
 let nativeModule: RadarNativeInterface;
 
-nativeModule = Platform.OS === "web" ? require("./index.web").default : require("./index.native").default;
+nativeModule =
+  Platform.OS === "web"
+    ? require("./index.web").default
+    : require("./index.native").default;
 
 export default nativeModule;
 

package/src/version.ts

@@ -1,3 +1,3 @@
 // This file contains the version of the react-native-radar package
 // It should be updated to match the version in package.json
-export const VERSION = '3.21.0-beta.2';
+export const VERSION = '3.21.0';