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

package/dist/src/index.native.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_native_1 = require("react-native");
+const package_json_1 = require("../package.json");
+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 eventEmitter = new react_native_1.NativeEventEmitter(react_native_1.NativeModules.RNRadar);
+const initialize = (publishableKey, fraud = false) => {
+    react_native_1.NativeModules.RNRadar.initialize(publishableKey, fraud);
+};
+const setLogLevel = (level) => {
+    react_native_1.NativeModules.RNRadar.setLogLevel(level);
+};
+const setUserId = (userId) => {
+    react_native_1.NativeModules.RNRadar.setUserId(userId);
+};
+const getUserId = () => react_native_1.NativeModules.RNRadar.getUserId();
+const setDescription = (description) => {
+    react_native_1.NativeModules.RNRadar.setDescription(description);
+};
+const getDescription = () => react_native_1.NativeModules.RNRadar.getDescription();
+const setMetadata = (metadata) => {
+    react_native_1.NativeModules.RNRadar.setMetadata(metadata);
+};
+const getMetadata = () => react_native_1.NativeModules.RNRadar.getMetadata();
+const setAnonymousTrackingEnabled = (enabled) => react_native_1.NativeModules.RNRadar.setAnonymousTrackingEnabled(enabled);
+const getPermissionsStatus = () => react_native_1.NativeModules.RNRadar.getPermissionsStatus();
+const requestPermissions = (background) => react_native_1.NativeModules.RNRadar.requestPermissions(background);
+const getLocation = (desiredAccuracy) => react_native_1.NativeModules.RNRadar.getLocation(desiredAccuracy);
+const trackOnce = (options) => {
+    let backCompatibleOptions = options;
+    if (options && "latitude" in options) {
+        backCompatibleOptions = {
+            location: {
+                ...options,
+            },
+        };
+    }
+    return react_native_1.NativeModules.RNRadar.trackOnce(backCompatibleOptions);
+};
+const trackVerified = () => react_native_1.NativeModules.RNRadar.trackVerified();
+const trackVerifiedToken = () => react_native_1.NativeModules.RNRadar.trackVerifiedToken();
+const startTrackingEfficient = () => react_native_1.NativeModules.RNRadar.startTrackingEfficient();
+const startTrackingResponsive = () => react_native_1.NativeModules.RNRadar.startTrackingResponsive();
+const startTrackingContinuous = () => react_native_1.NativeModules.RNRadar.startTrackingContinuous();
+const startTrackingCustom = (options) => react_native_1.NativeModules.RNRadar.startTrackingCustom(options);
+const mockTracking = (options) => react_native_1.NativeModules.RNRadar.mockTracking(options);
+const stopTracking = () => react_native_1.NativeModules.RNRadar.stopTracking();
+const getTrackingOptions = () => react_native_1.NativeModules.RNRadar.getTrackingOptions();
+const isUsingRemoteTrackingOptions = () => react_native_1.NativeModules.RNRadar.isUsingRemoteTrackingOptions();
+const isTracking = () => react_native_1.NativeModules.RNRadar.isTracking();
+const setForegroundServiceOptions = (options) => react_native_1.NativeModules.RNRadar.setForegroundServiceOptions(options);
+const setNotificationOptions = (options) => react_native_1.NativeModules.RNRadar.setNotificationOptions(options);
+const getTripOptions = () => react_native_1.NativeModules.RNRadar.getTripOptions();
+const startTrip = (options) => react_native_1.NativeModules.RNRadar.startTrip(options);
+const completeTrip = () => react_native_1.NativeModules.RNRadar.completeTrip();
+const cancelTrip = () => react_native_1.NativeModules.RNRadar.cancelTrip();
+const updateTrip = (options) => react_native_1.NativeModules.RNRadar.updateTrip(options);
+const acceptEvent = (eventId, verifiedPlaceId) => react_native_1.NativeModules.RNRadar.acceptEvent(eventId, verifiedPlaceId);
+const rejectEvent = (eventId) => react_native_1.NativeModules.RNRadar.rejectEvent(eventId);
+const getContext = (location) => react_native_1.NativeModules.RNRadar.getContext(location);
+const searchPlaces = (options) => react_native_1.NativeModules.RNRadar.searchPlaces(options);
+const searchGeofences = (options) => react_native_1.NativeModules.RNRadar.searchGeofences(options);
+const autocomplete = (options) => react_native_1.NativeModules.RNRadar.autocomplete(options);
+const geocode = (address) => react_native_1.NativeModules.RNRadar.geocode(address);
+const reverseGeocode = (location) => react_native_1.NativeModules.RNRadar.reverseGeocode(location);
+const ipGeocode = () => react_native_1.NativeModules.RNRadar.ipGeocode();
+const getDistance = (options) => react_native_1.NativeModules.RNRadar.getDistance(options);
+const getMatrix = (options) => react_native_1.NativeModules.RNRadar.getMatrix(options);
+const logConversion = (options) => react_native_1.NativeModules.RNRadar.logConversion(options);
+const sendEvent = (name, metadata) => react_native_1.NativeModules.RNRadar.sendEvent(name, metadata);
+const on = (event, callback) => eventEmitter.addListener(event, callback);
+const off = (event, callback) => {
+    if (callback) {
+        // @ts-ignore
+        eventEmitter.removeListener(event, callback);
+    }
+    else {
+        eventEmitter.removeAllListeners(event);
+    }
+};
+const nativeSdkVersion = () => react_native_1.NativeModules.RNRadar.nativeSdkVersion();
+const rnSdkVersion = () => package_json_1.version;
+const Radar = {
+    initialize,
+    setLogLevel,
+    setUserId,
+    getUserId,
+    setDescription,
+    getDescription,
+    setMetadata,
+    getMetadata,
+    setAnonymousTrackingEnabled,
+    isUsingRemoteTrackingOptions,
+    getPermissionsStatus,
+    requestPermissions,
+    getLocation,
+    trackOnce,
+    trackVerified,
+    trackVerifiedToken,
+    startTrackingEfficient,
+    startTrackingResponsive,
+    startTrackingContinuous,
+    startTrackingCustom,
+    mockTracking,
+    stopTracking,
+    isTracking,
+    getTrackingOptions,
+    setForegroundServiceOptions,
+    setNotificationOptions,
+    acceptEvent,
+    rejectEvent,
+    getTripOptions,
+    startTrip,
+    updateTrip,
+    completeTrip,
+    cancelTrip,
+    getContext,
+    searchPlaces,
+    searchGeofences,
+    autocomplete,
+    geocode,
+    reverseGeocode,
+    ipGeocode,
+    getDistance,
+    getMatrix,
+    logConversion,
+    sendEvent,
+    on,
+    off,
+    nativeSdkVersion,
+    rnSdkVersion,
+};
+exports.default = Radar;

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

@@ -0,0 +1,73 @@
+export default Radar;
+declare namespace Radar {
+    export { initialize };
+    export { setLogLevel };
+    export { setUserId };
+    export { setDescription };
+    export { setMetadata };
+    export { getPermissionsStatus };
+    export { requestPermissions };
+    export { getLocation };
+    export { trackOnce };
+    export { trackVerified };
+    export { trackVerifiedToken };
+    export { startTrackingEfficient };
+    export { startTrackingResponsive };
+    export { startTrackingContinuous };
+    export { startTrackingCustom };
+    export { mockTracking };
+    export { stopTracking };
+    export { setForegroundServiceOptions };
+    export { acceptEvent };
+    export { rejectEvent };
+    export { startTrip };
+    export { updateTrip };
+    export { completeTrip };
+    export { cancelTrip };
+    export { getContext };
+    export { searchPlaces };
+    export { searchGeofences };
+    export { autocomplete };
+    export { geocode };
+    export { reverseGeocode };
+    export { ipGeocode };
+    export { getDistance };
+    export { getMatrix };
+    export { on };
+    export { off };
+}
+declare function initialize(publishableKey: any): void;
+declare function setLogLevel(level: any): void;
+declare function setUserId(userId: any): void;
+declare function setDescription(description: any): void;
+declare function setMetadata(metadata: any): void;
+declare function getPermissionsStatus(): Promise<any>;
+declare function requestPermissions(background: any): void;
+declare function getLocation(): Promise<any>;
+declare function trackOnce(options: any): Promise<any>;
+declare function trackVerified(): void;
+declare function trackVerifiedToken(): void;
+declare function startTrackingEfficient(): void;
+declare function startTrackingResponsive(): void;
+declare function startTrackingContinuous(): void;
+declare function startTrackingCustom(options: any): void;
+declare function mockTracking(options: any): void;
+declare function stopTracking(): void;
+declare function setForegroundServiceOptions(options: any): void;
+declare function acceptEvent(eventId: any, verifiedPlaceId: any): void;
+declare function rejectEvent(eventId: any): void;
+declare function startTrip(options: any): Promise<any>;
+declare function updateTrip(tripOptions: any): Promise<any>;
+declare function completeTrip(): Promise<any>;
+declare function cancelTrip(): Promise<any>;
+declare function getContext(options: any): Promise<any>;
+declare function searchPlaces(options: any): Promise<any>;
+declare function searchGeofences(options: any): Promise<any>;
+declare function autocomplete(options: any): Promise<any>;
+declare function geocode(options: any): Promise<any>;
+declare function reverseGeocode(options: any): Promise<any>;
+declare function ipGeocode(): Promise<any>;
+declare function getDistance(options: any): Promise<any>;
+declare function getMatrix(options: any): Promise<any>;
+declare function on(event: any, callback: any): void;
+declare function off(event: any, callback: any): void;

package/dist/src/index.web.js

@@ -0,0 +1,385 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const radar_sdk_js_1 = __importDefault(require("radar-sdk-js"));
+const initialize = (publishableKey) => {
+    radar_sdk_js_1.default.initialize(publishableKey);
+};
+const setLogLevel = (level) => {
+    // not implemented
+};
+const setUserId = (userId) => {
+    radar_sdk_js_1.default.setUserId(userId);
+};
+const setDeviceId = (deviceId, installId) => {
+    radar_sdk_js_1.default.setDeviceId(deviceId, installId);
+};
+const setDeviceType = (deviceType) => {
+    radar_sdk_js_1.default.setDeviceType(deviceType);
+};
+const setRequestHeaders = (headers) => {
+    radar_sdk_js_1.default.setRequestHeaders(headers);
+};
+const setDescription = (description) => {
+    radar_sdk_js_1.default.setDescription(description);
+};
+const setMetadata = (metadata) => {
+    radar_sdk_js_1.default.setMetadata(metadata);
+};
+const getPermissionsStatus = () => {
+    return new Promise(resolve => {
+        const navigator = window.navigator;
+        if (!navigator.permissions) {
+            resolve({
+                status: 'UNKNOWN'
+            });
+        }
+        else {
+            navigator.permissions.query({ name: 'geolocation' }).then((result) => {
+                resolve({
+                    status: result.state === 'granted' ? 'GRANTED_FOREGROUND' : 'DENIED',
+                });
+            });
+        }
+    });
+};
+const requestPermissions = background => {
+    // not implemented
+};
+const getLocation = () => {
+    return new Promise((resolve, reject) => {
+        radar_sdk_js_1.default.getLocation((err, result) => {
+            if (err)
+                reject(err);
+            else
+                resolve(result);
+        });
+    });
+};
+const trackOnce = options => {
+    return new Promise((resolve, reject) => {
+        const callback = (err, { status, location, user, events }) => {
+            if (err) {
+                reject(err);
+            }
+            else {
+                resolve({
+                    status,
+                    location,
+                    user,
+                    events,
+                });
+            }
+        };
+        if (options) {
+            radar_sdk_js_1.default.trackOnce(options.location ? options.location : options, callback);
+        }
+        else {
+            radar_sdk_js_1.default.trackOnce(callback);
+        }
+    });
+};
+const trackVerified = () => {
+    // not implemented
+};
+const trackVerifiedToken = () => {
+    // not implemented
+};
+const startTrackingEfficient = () => {
+    // not implemented
+};
+const startTrackingResponsive = () => {
+    // not implemented
+};
+const startTrackingContinuous = () => {
+    // not implemented
+};
+const startTrackingCustom = options => {
+    // not implemented
+};
+const mockTracking = options => {
+    // not implemented
+};
+const stopTracking = () => {
+    // not implemented
+};
+const setForegroundServiceOptions = options => {
+    // not implemented
+};
+const startTrip = options => {
+    return new Promise((resolve, reject) => {
+        const callback = (err, { trip, events, status }) => {
+            if (err) {
+                reject(err);
+            }
+            else {
+                resolve({
+                    trip,
+                    events,
+                    status
+                });
+            }
+        };
+        radar_sdk_js_1.default.startTrip(options, callback);
+    });
+};
+const completeTrip = () => {
+    return new Promise((resolve, reject) => {
+        const callback = (err, { trip, events, status }) => {
+            if (err) {
+                reject(err);
+            }
+            else {
+                resolve({
+                    trip,
+                    events,
+                    status
+                });
+            }
+        };
+        radar_sdk_js_1.default.completeTrip(callback);
+    });
+};
+const cancelTrip = () => {
+    return new Promise((resolve, reject) => {
+        const callback = (err, { trip, events, status }) => {
+            if (err) {
+                reject(err);
+            }
+            else {
+                resolve({
+                    trip,
+                    events,
+                    status
+                });
+            }
+        };
+        radar_sdk_js_1.default.cancelTrip(callback);
+    });
+};
+const updateTrip = (tripOptions) => {
+    return new Promise((resolve, reject) => {
+        const callback = (err, { trip, events, status }) => {
+            if (err) {
+                reject(err);
+            }
+            else {
+                resolve({
+                    trip,
+                    events,
+                    status
+                });
+            }
+        };
+        radar_sdk_js_1.default.updateTrip(tripOptions.options, tripOptions.status, callback);
+    });
+};
+const acceptEvent = (eventId, verifiedPlaceId) => {
+    // not implemented
+};
+const rejectEvent = eventId => {
+    // not implemented
+};
+const getContext = options => {
+    return new Promise((resolve, reject) => {
+        const callback = (err, { status, location, context }) => {
+            if (err) {
+                reject(err);
+            }
+            else {
+                resolve({
+                    status,
+                    location,
+                    context,
+                });
+            }
+        };
+        if (options) {
+            radar_sdk_js_1.default.getContext(options, callback);
+        }
+        else {
+            radar_sdk_js_1.default.getContext(callback);
+        }
+    });
+};
+const searchPlaces = options => {
+    return new Promise((resolve, reject) => {
+        radar_sdk_js_1.default.searchPlaces(options, (err, { status, location, places }) => {
+            if (err) {
+                reject(err);
+            }
+            else {
+                resolve({
+                    status,
+                    location,
+                    places,
+                });
+            }
+        });
+    });
+};
+const searchGeofences = options => {
+    return new Promise((resolve, reject) => {
+        radar_sdk_js_1.default.searchGeofences(options, (err, { status, location, geofences }) => {
+            if (err) {
+                reject(err);
+            }
+            else {
+                resolve({
+                    status,
+                    location,
+                    geofences,
+                });
+            }
+        });
+    });
+};
+const autocomplete = options => {
+    return new Promise((resolve, reject) => {
+        radar_sdk_js_1.default.autocomplete(options, (err, { status, addresses }) => {
+            if (err) {
+                reject(err);
+            }
+            else {
+                resolve({
+                    status,
+                    addresses,
+                });
+            }
+        });
+    });
+};
+const geocode = options => {
+    return new Promise((resolve, reject) => {
+        let newOptions = options;
+        if (typeof options === 'string')
+            newOptions = {
+                query: options
+            };
+        radar_sdk_js_1.default.geocode(newOptions, (err, { status, addresses }) => {
+            if (err) {
+                reject(err);
+            }
+            else {
+                resolve({
+                    status,
+                    addresses,
+                });
+            }
+        });
+    });
+};
+const reverseGeocode = options => {
+    return new Promise((resolve, reject) => {
+        const callback = (err, { status, addresses }) => {
+            if (err) {
+                reject(err);
+            }
+            else {
+                resolve({
+                    status,
+                    addresses,
+                });
+            }
+        };
+        if (options) {
+            radar_sdk_js_1.default.reverseGeocode(options, callback);
+        }
+        else {
+            radar_sdk_js_1.default.reverseGeocode(callback);
+        }
+    });
+};
+const ipGeocode = () => {
+    return new Promise((resolve, reject) => {
+        radar_sdk_js_1.default.ipGeocode((err, { status, address }) => {
+            if (err) {
+                reject(err);
+            }
+            else {
+                resolve({
+                    status,
+                    address,
+                });
+            }
+        });
+    });
+};
+const getDistance = options => {
+    return new Promise((resolve, reject) => {
+        radar_sdk_js_1.default.getDistance(options, (err, { status, routes }) => {
+            if (err) {
+                reject(err);
+            }
+            else {
+                resolve({
+                    status,
+                    routes,
+                });
+            }
+        });
+    });
+};
+const getMatrix = options => {
+    return new Promise((resolve, reject) => {
+        radar_sdk_js_1.default.getMatrix(options, (err, { origins, destinations, matrix, status }) => {
+            if (err) {
+                reject(err);
+            }
+            else {
+                resolve({
+                    origins,
+                    destinations,
+                    matrix,
+                    status,
+                });
+            }
+        });
+    });
+};
+const on = (event, callback) => {
+    // not implemented
+};
+const off = (event, callback) => {
+    // not implemented
+};
+const Radar = {
+    initialize,
+    setLogLevel,
+    setUserId,
+    setDescription,
+    setMetadata,
+    getPermissionsStatus,
+    requestPermissions,
+    getLocation,
+    trackOnce,
+    trackVerified,
+    trackVerifiedToken,
+    startTrackingEfficient,
+    startTrackingResponsive,
+    startTrackingContinuous,
+    startTrackingCustom,
+    mockTracking,
+    stopTracking,
+    setForegroundServiceOptions,
+    acceptEvent,
+    rejectEvent,
+    startTrip,
+    updateTrip,
+    completeTrip,
+    cancelTrip,
+    getContext,
+    searchPlaces,
+    searchGeofences,
+    autocomplete,
+    geocode,
+    reverseGeocode,
+    ipGeocode,
+    getDistance,
+    getMatrix,
+    on,
+    off,
+};
+exports.default = Radar;

package/dist/src/ui/autocomplete.d.ts

@@ -0,0 +1,4 @@
+export default autocompleteUI;
+declare function autocompleteUI({ options }: {
+    options?: {} | undefined;
+}): any;