react-native-radar 3.9.0 → 3.10.0-beta.1

package/android/build.gradle

@@ -18,7 +18,7 @@ android {
         minSdkVersion 16
         targetSdkVersion 31
         versionCode 1
-        versionName '3.9.0'
+        versionName '3.10.0-beta.1'
     }
     lintOptions {
         abortOnError false
@@ -45,5 +45,5 @@ repositories {
 
 dependencies {
     api 'com.facebook.react:react-native:+'
-    api 'io.radar:sdk:3.9.0'
+    api 'io.radar:sdk:3.9.1'
 }

package/dist/package.json

@@ -0,0 +1,79 @@
+{
+    "name": "react-native-radar",
+    "description": "React Native module for Radar, the leading geofencing and location tracking platform",
+    "homepage": "https://radar.com",
+    "license": "Apache-2.0",
+    "version": "3.10.0-beta.1",
+    "main": "dist/src/index.ts",
+    "files": [
+        "android",
+        "ios",
+        "src",
+        "README.md",
+        "react-native-radar.podspec",
+        "/dist"
+    ],
+    "types": "dist/src/index.d.ts",
+    "scripts": {
+        "test": "jest ./test/*.test.js",
+        "check-latest-tag": "node ./scripts/check-latest-tag.cjs",
+        "check-beta-tag": "node ./scripts/check-beta-tag.cjs",
+        "build": "tsc"
+    },
+    "jest": {
+        "preset": "react-native",
+        "clearMocks": true,
+        "reporters": [
+            "default",
+            "jest-junit"
+        ]
+    },
+    "peerDependencies": {
+        "@maplibre/maplibre-react-native": "^9.0.1",
+        "react": ">= 16.8.6",
+        "react-native": ">= 0.60.0"
+    },
+    "peerDependenciesMeta": {
+        "@maplibre/maplibre-react-native": {
+            "optional": true
+        }
+    },
+    "devDependencies": {
+        "@babel/core": "^7.2.2",
+        "@babel/preset-env": "^7.2.3",
+        "@babel/preset-react": "^7.0.0",
+        "@babel/register": "^7.0.0",
+        "@types/node": "^20.11.7",
+        "@types/react-native": "^0.73.0",
+        "babel-core": "^7.0.0-bridge.0",
+        "babel-eslint": "^10.0.1",
+        "babel-jest": "^23.4.2",
+        "braces": ">=2.3.2",
+        "eslint": "^5.6.1",
+        "eslint-config-airbnb": "^17.1.0",
+        "eslint-plugin-import": "^2.14.0",
+        "eslint-plugin-jest": "^22.1.2",
+        "eslint-plugin-jsx-a11y": "^6.1.1",
+        "eslint-plugin-react": "^7.11.1",
+        "jest": "^23.6.0",
+        "jest-junit": "^5.2.0",
+        "logkitty": ">=0.7.1",
+        "metro-react-native-babel-preset": "^0.51.1",
+        "npm-run-all": "^4.1.5",
+        "react": "16.8.6",
+        "react-native": "0.60.0",
+        "typescript": "^5.3.3"
+    },
+    "bugs": {
+        "url": "https://github.com/radarlabs/react-native-radar/issues"
+    },
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/radarlabs/react-native-radar.git"
+    },
+    "dependencies": {
+        "@babel/runtime": "^7.21.0",
+        "@react-native-community/netinfo": "^7.1.3",
+        "radar-sdk-js": "^3.6.0"
+    }
+}

package/dist/src/@types/RadarNativeInterface.d.ts

@@ -0,0 +1,51 @@
+import { Location, RadarAutocompleteOptions, RadarContextCallback, RadarGeocodeCallback, RadarGetDistanceOptions, RadarLocationCallback, RadarLogConversionCallback, RadarLogConversionOptions, RadarLogLevel, RadarMockTrackingOptions, RadarNotificationOptions, RadarPermissionsStatus, RadarRouteCallback, RadarRouteMatrix, RadarSearchGeofencesCallback, RadarSearchGeofencesOptions, RadarSearchPlacesCallback, RadarSearchPlacesOptions, RadarStartTripOptions, RadarTrackCallback, RadarTrackOnceOptions, RadarTrackTokenCallback, RadarTrackingOptions, RadarTrackingOptionsDesiredAccuracy, RadarTrackingOptionsForegroundService, RadarTripCallback, RadarTripOptions, RadarUpdateTripOptions, Event } from "./types";
+export interface RadarNativeInterface {
+    initialize: (publishableKey: string, fraud: boolean) => void;
+    setLogLevel: (level: RadarLogLevel) => void;
+    setUserId: (userId: string) => void;
+    getUserId: () => Promise<string>;
+    setDescription: (description: string) => void;
+    getDescription: () => Promise<string>;
+    setMetadata: (metadata: object) => void;
+    getMetadata: () => Promise<object>;
+    setAnonymousTrackingEnabled: (enabled: boolean) => void;
+    getPermissionsStatus: () => Promise<RadarPermissionsStatus>;
+    requestPermissions: (background: boolean) => Promise<RadarPermissionsStatus>;
+    getLocation: (desiredAccuracy?: RadarTrackingOptionsDesiredAccuracy) => Promise<RadarLocationCallback>;
+    trackOnce: (options?: RadarTrackOnceOptions | Location) => Promise<RadarTrackCallback>;
+    trackVerifiedToken: () => Promise<RadarTrackTokenCallback>;
+    trackVerified: () => Promise<RadarTrackCallback>;
+    startTrackingEfficient: () => void;
+    startTrackingResponsive: () => void;
+    startTrackingContinuous: () => void;
+    startTrackingCustom: (options: RadarTrackingOptions) => void;
+    mockTracking: (options: RadarMockTrackingOptions) => void;
+    stopTracking: () => void;
+    getTrackingOptions: () => Promise<RadarTrackingOptions>;
+    isUsingRemoteTrackingOptions: () => Promise<boolean>;
+    isTracking: () => boolean;
+    setForegroundServiceOptions: (options: RadarTrackingOptionsForegroundService) => void;
+    setNotificationOptions: (options: RadarNotificationOptions) => void;
+    getTripOptions: () => Promise<RadarTripOptions>;
+    startTrip: (options: RadarStartTripOptions) => Promise<RadarTripCallback>;
+    completeTrip: () => Promise<RadarTripCallback>;
+    cancelTrip: () => Promise<RadarTripCallback>;
+    updateTrip: (options: RadarUpdateTripOptions) => Promise<RadarTripCallback>;
+    acceptEvent: (eventId: string, verifiedPlaceId: string) => void;
+    rejectEvent: (eventId: string) => void;
+    getContext: (location?: Location) => Promise<RadarContextCallback>;
+    searchPlaces: (options: RadarSearchPlacesOptions) => Promise<RadarSearchPlacesCallback>;
+    searchGeofences: (options: RadarSearchGeofencesOptions) => Promise<RadarSearchGeofencesCallback>;
+    autocomplete: (options: RadarAutocompleteOptions) => Promise<RadarGeocodeCallback>;
+    geocode: (address: string) => Promise<RadarGeocodeCallback>;
+    reverseGeocode: (location: any) => Promise<RadarGeocodeCallback>;
+    ipGeocode: () => Promise<RadarGeocodeCallback>;
+    getDistance: (option: RadarGetDistanceOptions) => Promise<RadarRouteCallback>;
+    getMatrix: (option: RadarGetDistanceOptions) => Promise<RadarRouteMatrix>;
+    logConversion: (options: RadarLogConversionOptions) => Promise<RadarLogConversionCallback>;
+    sendEvent: (name: string, metadata: Object) => void;
+    on: (event: Event, callback: Function | undefined) => void;
+    off: (event: Event, callback: Function | undefined) => void;
+    nativeSdkVersion: () => Promise<string>;
+    rnSdkVersion: () => string;
+}

package/dist/src/@types/RadarNativeInterface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,379 @@
+export interface RadarTrackOnceOptions {
+    location?: Location;
+    desiredAccuracy?: RadarTrackingOptionsDesiredAccuracy;
+    beacons?: boolean;
+}
+export interface RadarGetDistanceOptions {
+    origin?: Location;
+    destination?: Location;
+    modes: string[];
+    units: string;
+}
+export interface RadarUpdateTripOptions {
+    options: RadarTripOptions;
+    status: RadarTripStatus;
+}
+export interface RadarStartTripOptions {
+    tripOptions: RadarTripOptions;
+    trackingOptions: RadarTrackingOptions;
+}
+export interface RadarLocationCallback {
+    status: string;
+    location?: Location;
+    stopped?: boolean;
+}
+export interface RadarTrackCallback {
+    status: string;
+    location?: Location;
+    user?: RadarUser;
+    events?: RadarEvent[];
+}
+export type RadarPermissionsStatus = "GRANTED_FOREGROUND" | "GRANTED_FOREGROUND" | "DENIED" | "NOT_DETERMINED" | "UNKNOWN";
+export type Event = "clientLocation" | "location" | "error" | "events";
+export type RadarLogLevel = "info" | "debug" | "warning" | "error" | "none";
+export interface RadarTrackTokenCallback {
+    status: string;
+    token?: String;
+}
+export interface RadarTripCallback {
+    status: string;
+    trip?: RadarTrip;
+    events?: RadarEvent[];
+}
+export interface RadarContextCallback {
+    status: string;
+    location?: Location;
+    context?: RadarContext;
+}
+export interface RadarSearchPlacesCallback {
+    status: string;
+    location?: Location;
+    places?: RadarPlace[];
+}
+export interface RadarSearchGeofencesCallback {
+    status: string;
+    location?: Location;
+    geofences?: RadarGeofence[];
+}
+export interface RadarSearchGeofencesOptions {
+    near?: Location;
+    radius: number;
+    metadata?: object;
+    tags?: string[];
+    limit: number;
+}
+export interface RadarGeocodeCallback {
+    status: string;
+    addresses?: RadarAddress[];
+}
+export interface RadarValidateAddressCallback {
+    status: string;
+    address?: RadarAddress;
+    verificationStatus?: RadarAddressVerificationStatus;
+}
+export interface RadarIPGeocodeCallback {
+    status: string;
+    address?: RadarAddress;
+}
+export interface RadarTrackingOptionsForegroundServiceOptions {
+    text?: string;
+    title?: string;
+    updatesOnly: boolean;
+    activity?: string;
+    importance?: number;
+    id?: number;
+    channelName?: string;
+    iconString?: string;
+    iconColor?: string;
+}
+export interface RadarRouteCallback {
+    status: string;
+    routes?: RadarRoutes;
+}
+export interface RadarLogConversionCallback {
+    status: string;
+    event: RadarEvent;
+}
+export interface RadarRouteMatrix {
+    status: string;
+    matrix?: object;
+}
+export interface RadarSearchPlacesOptions {
+    near?: Location;
+    radius: number;
+    chains?: string[];
+    chainMetadata?: object;
+    categories?: string[];
+    groups?: string[];
+    limit: number;
+}
+export interface Location {
+    latitude: number;
+    longitude: number;
+    accuracy?: number;
+    speed?: number;
+    altitude?: number;
+    course?: number;
+    verticalAccuracy?: number;
+    speedAccuracy?: number;
+    courseAccuracy?: number;
+}
+export interface RadarUser {
+    _id: string;
+    userId?: string;
+    deviceId?: string;
+    description?: string;
+    metadata?: object;
+    location?: RadarCoordinate;
+    geofences?: RadarGeofence[];
+    place?: RadarPlace;
+    beacons?: RadarBeacon[];
+    stopped?: boolean;
+    foreground?: boolean;
+    country?: RadarRegion;
+    state?: RadarRegion;
+    dma?: RadarRegion;
+    postalCode?: RadarRegion;
+    nearbyPlaceChains?: RadarPlace[];
+    segments?: RadarSegment[];
+    topChains?: RadarPlace[];
+    source?: LocationSource;
+    trip?: RadarTrip;
+    debug?: boolean;
+    fraud?: RadarFraud;
+}
+export interface RadarAutocompleteOptions {
+    query: string;
+    near?: Location;
+    layers?: string[];
+    limit: number;
+    country?: string;
+    expandUnits?: boolean;
+}
+export interface RadarCoordinate {
+    type: string;
+    coordinates: [number, number];
+}
+export type LocationSource = "FOREGROUND_LOCATION" | "BACKGROUND_LOCATION" | "MANUAL_LOCATION" | "VISIT_ARRIVAL" | "VISIT_DEPARTURE" | "GEOFENCE_ENTER" | "GEOFENCE_EXIT" | "MOCK_LOCATION" | "BEACON_ENTER" | "BEACON_EXIT" | "UNKNOWN";
+export interface RadarTrip {
+    _id: string;
+    externalId: string;
+    metadata?: object;
+    destinationGeofenceTag?: string;
+    destinationGeofenceExternalId?: string;
+    mode?: string;
+    eta?: RadarTripEta;
+    status: string;
+    scheduledArrivalAt?: Date;
+}
+export interface RadarSegment {
+    description: string;
+    externalId: string;
+}
+export interface RadarContext {
+    geofences?: RadarGeofence[];
+    place?: RadarPlace;
+    country?: RadarRegion;
+    state?: RadarRegion;
+    dma?: RadarRegion;
+    postalCode?: RadarRegion;
+}
+export interface RadarEvent {
+    _id: string;
+    live: boolean;
+    type: RadarEventType;
+    geofence?: RadarGeofence;
+    place?: RadarPlace;
+    region?: RadarRegion;
+    confidence: RadarEventConfidence;
+    duration?: number;
+    beacon?: RadarBeacon;
+    trip?: RadarTrip;
+    alternatePlaces?: RadarPlace[];
+    location?: RadarCoordinate;
+    metadata?: object;
+}
+export declare enum RadarEventConfidence {
+    none = 0,
+    low = 1,
+    medium = 2,
+    high = 3
+}
+export type RadarEventType = "unknown" | "user.entered_geofence" | "user.entered_beacon" | "user.dwelled_in_geofence" | "user.entered_place" | "user.entered_region_country" | "user.entered_region_dma" | "user.entered_region_state" | "user.entered_region_postal_code" | "user.exited_geofence" | "user.exited_beacon" | "user.exited_place" | "user.exited_region_country" | "user.exited_region_dma" | "user.exited_region_state" | "user.exited_region_postal_code" | "user.nearby_place_chain" | "user.started_trip" | "user.updated_trip" | "user.approaching_trip_destination" | "user.arrived_at_trip_destination" | "user.stopped_trip";
+export type RadarTrackingOptionsDesiredAccuracy = "high" | "medium" | "low" | "none";
+export declare enum RadarEventVerification {
+    accept = 1,
+    unverify = 0,
+    reject = -1
+}
+export type RadarBeaconType = "eddystone" | "ibeacon";
+export interface RadarGeofence {
+    _id: string;
+    description: string;
+    tag?: string;
+    externalId?: string;
+    metadata?: object;
+    type?: string;
+    geometryRadius?: number;
+    geometryCenter?: RadarCoordinate;
+    coordinates?: number[][];
+}
+export interface RadarBeacon {
+    _id: string;
+    metadata?: object;
+    type: RadarBeaconType;
+    uuid?: string;
+    instance?: string;
+    major?: string;
+    minor?: string;
+    geometry?: RadarCoordinate;
+    rss?: number;
+}
+export interface RadarPlace {
+    _id: string;
+    name: string;
+    categories: string[];
+    chain?: RadarChain;
+}
+export interface RadarChain {
+    name: string;
+    slug: string;
+    externalId?: string;
+    metadata?: object;
+}
+export interface RadarRegion {
+    _id: string;
+    type: string;
+    code: string;
+    name: string;
+    allowed?: boolean;
+    flag?: string;
+}
+export interface RadarLocationPermissionsCallback {
+    status: string;
+}
+export interface RadarAddress {
+    latitude: number;
+    longitude: number;
+    placeLabel?: string;
+    addressLabel?: string;
+    formattedAddress?: string;
+    country?: string;
+    countryCode?: string;
+    countryFlag?: string;
+    state?: string;
+    stateCode?: string;
+    postalCode?: string;
+    city?: string;
+    borough?: string;
+    county?: string;
+    neighborhood?: string;
+    number?: string;
+    distance?: number;
+    confidence?: string;
+    layer?: string;
+    plus4?: string;
+}
+export interface RadarAddressVerificationStatus {
+    status: string;
+}
+export interface RadarRoutes {
+    geodesic: RadarRoute;
+    foot?: RadarRoute;
+    bike?: RadarRoute;
+    car?: RadarRoute;
+}
+export interface RadarRoute {
+    distance?: RadarRouteDistance;
+    duration?: RadarRouteDuration;
+}
+export interface RadarRouteDistance {
+    value: number;
+    text: string;
+}
+export interface RadarNotificationOptions {
+    iconString?: string;
+    iconColor?: string;
+    foregroundServiceIconString?: string;
+    foregroundServiceIconColor?: string;
+    eventIconString?: string;
+    eventIconColor?: string;
+}
+export interface RadarRouteDuration {
+    value: number;
+    text: string;
+}
+export interface RadarTripEta {
+    distance?: number;
+    duration?: number;
+}
+export interface RadarFraud {
+    passed: boolean;
+    bypassed: boolean;
+    verified: boolean;
+    proxy: boolean;
+    mocked: boolean;
+    compromised: boolean;
+    jumped: boolean;
+}
+export interface RadarMockTrackingOptions {
+    origin: Location;
+    destination: Location;
+    mode: RadarRouteMode;
+    steps: number;
+    interval: number;
+}
+export type RadarTrackingOptionsReplay = "all" | "stops" | "none";
+export type RadarTrackingOptionsSync = "none" | "stopsAndExits" | "all";
+export interface RadarTrackingOptions {
+    desiredStoppedUpdateInterval: number;
+    fastestStoppedUpdateInterval: number;
+    desiredMovingUpdateInterval: number;
+    fastestMovingUpdateInterval: number;
+    desiredSyncInterval: number;
+    desiredAccuracy: RadarTrackingOptionsDesiredAccuracy;
+    stopDuration: number;
+    stopDistance: number;
+    startTrackingAfter?: Date;
+    stopTrackingAfter?: Date;
+    replay: RadarTrackingOptionsReplay;
+    sync: RadarTrackingOptionsSync;
+    showBlueBar: boolean;
+    useStoppedGeofence: boolean;
+    stoppedGeofenceRadius: number;
+    useMovingGeofence: boolean;
+    movingGeofenceRadius: number;
+    syncGeofences: boolean;
+    syncGeofencesLimit: number;
+    foregroundServiceEnabled: boolean;
+    beacons: boolean;
+}
+export interface RadarLogConversionOptions {
+    name: string;
+    revenue?: number;
+    metadata?: object;
+}
+export type RadarRouteMode = "foot" | "bike" | "car";
+export interface RadarTrackingStatus {
+    isTracking: string;
+}
+export interface RadarTrackingOptionsForegroundService {
+    text?: string;
+    title?: string;
+    icon?: number;
+    updatesOnly?: boolean;
+    activity?: string;
+    importance?: number;
+    id?: number;
+    channelName?: string;
+}
+export interface RadarTripOptions {
+    externalId: string;
+    metadata?: object;
+    destinationGeofenceTag?: string;
+    destinationGeofenceExternalId?: string;
+    mode?: RadarRouteMode;
+    scheduledArrivalAt?: Date;
+    approachingThreshold?: number;
+}
+export type RadarTripStatus = "unknown" | "started" | "approaching" | "arrived" | "expired" | "completed" | "canceled";

package/dist/src/@types/types.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RadarEventVerification = exports.RadarEventConfidence = void 0;
+var RadarEventConfidence;
+(function (RadarEventConfidence) {
+    RadarEventConfidence[RadarEventConfidence["none"] = 0] = "none";
+    RadarEventConfidence[RadarEventConfidence["low"] = 1] = "low";
+    RadarEventConfidence[RadarEventConfidence["medium"] = 2] = "medium";
+    RadarEventConfidence[RadarEventConfidence["high"] = 3] = "high";
+})(RadarEventConfidence || (exports.RadarEventConfidence = RadarEventConfidence = {}));
+var RadarEventVerification;
+(function (RadarEventVerification) {
+    RadarEventVerification[RadarEventVerification["accept"] = 1] = "accept";
+    RadarEventVerification[RadarEventVerification["unverify"] = 0] = "unverify";
+    RadarEventVerification[RadarEventVerification["reject"] = -1] = "reject";
+})(RadarEventVerification || (exports.RadarEventVerification = RadarEventVerification = {}));

package/dist/src/helpers.d.ts

@@ -0,0 +1,2 @@
+export function getHost(): any;
+export function getPublishableKey(): any;

package/dist/src/helpers.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPublishableKey = exports.getHost = void 0;
+const react_native_1 = require("react-native");
+if (!react_native_1.NativeModules.RNRadar && (react_native_1.Platform.OS === 'ios' || react_native_1.Platform.OS === 'android')) {
+    throw new Error('NativeModules.RNRadar is undefined');
+}
+const getHost = () => (react_native_1.NativeModules.RNRadar.getHost());
+exports.getHost = getHost;
+const getPublishableKey = () => (react_native_1.NativeModules.RNRadar.getPublishableKey());
+exports.getPublishableKey = getPublishableKey;

package/dist/src/index.d.ts

@@ -0,0 +1,8 @@
+import { RadarNativeInterface } from "./@types/RadarNativeInterface";
+declare let module: RadarNativeInterface;
+export default module;
+export { default as RadarRNWeb } from "./index.web";
+export { default as Autocomplete } from "./ui/autocomplete";
+export { default as Map } from "./ui/map";
+export * from "./@types/types";
+export * from "./@types/RadarNativeInterface";

package/dist/src/index.js

@@ -0,0 +1,37 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Map = exports.Autocomplete = exports.RadarRNWeb = void 0;
+//type RadarInterface = Platform["OS"] extends "web" ? RadarNativeInterface : any;
+//type RadarInterface = RadarNativeInterface;
+let module;
+// if (Platform.OS === "web") {
+//   module = require("./index.web").default;
+// } else {
+module = require("./index.native").default;
+//}
+exports.default = module;
+var index_web_1 = require("./index.web");
+Object.defineProperty(exports, "RadarRNWeb", { enumerable: true, get: function () { return __importDefault(index_web_1).default; } });
+var autocomplete_1 = require("./ui/autocomplete");
+Object.defineProperty(exports, "Autocomplete", { enumerable: true, get: function () { return __importDefault(autocomplete_1).default; } });
+var map_1 = require("./ui/map");
+Object.defineProperty(exports, "Map", { enumerable: true, get: function () { return __importDefault(map_1).default; } });
+__exportStar(require("./@types/types"), exports);
+__exportStar(require("./@types/RadarNativeInterface"), exports);

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

@@ -0,0 +1,3 @@
+import { RadarNativeInterface } from "./@types/RadarNativeInterface";
+declare const Radar: RadarNativeInterface;
+export default Radar;