npm - radar-sdk-js - Versions diffs - 4.5.3 → 4.5.5-beta.0 - Mend

radar-sdk-js 4.5.3 → 4.5.5-beta.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (17) hide show

package/README.md CHANGED Viewed

@@ -56,7 +56,7 @@ Radar.initialize('prj_test_pk_...', { /* options */ });
 Add the following script in your `html` file
 ```html
-<script src="https://js.radar.com/v4.5.3/radar.min.js"></script>
+<script src="https://js.radar.com/v4.5.5-beta.0/radar.min.js"></script>
 ```
 Then initialize the Radar SDK
@@ -73,8 +73,8 @@ To create a map, first initialize the Radar SDK with your publishable key. Then
 ```html
 <html>
   <head>
-    <link href="https://js.radar.com/v4.5.3/radar.css" rel="stylesheet">
-    <script src="https://js.radar.com/v4.5.3/radar.min.js"></script>
+    <link href="https://js.radar.com/v4.5.5-beta.0/radar.css" rel="stylesheet">
+    <script src="https://js.radar.com/v4.5.5-beta.0/radar.min.js"></script>
   </head>
   <body>
@@ -98,8 +98,8 @@ To create an autocomplete input, first initialize the Radar SDK with your publis
 ```html
 <html>
   <head>
-    <link href="https://js.radar.com/v4.5.3/radar.css" rel="stylesheet">
-    <script src="https://js.radar.com/v4.5.3/radar.min.js"></script>
+    <link href="https://js.radar.com/v4.5.5-beta.0/radar.css" rel="stylesheet">
+    <script src="https://js.radar.com/v4.5.5-beta.0/radar.min.js"></script>
   </head>
   <body>
@@ -130,8 +130,8 @@ To power [geofencing](https://radar.com/documentation/geofencing/overview) exper
 ```html
 <html>
   <head>
-    <link href="https://js.radar.com/v4.5.3/radar.css" rel="stylesheet">
-    <script src="https://js.radar.com/v4.5.3/radar.min.js"></script>
+    <link href="https://js.radar.com/v4.5.5-beta.0/radar.css" rel="stylesheet">
+    <script src="https://js.radar.com/v4.5.5-beta.0/radar.min.js"></script>
   </head>
   <body>

package/dist/api.d.ts CHANGED Viewed

@@ -1,3 +1,4 @@
+import { RadarError } from './errors';
 import type { Location, RadarAutocompleteParams, RadarConversionParams, RadarDistanceParams, RadarForwardGeocodeParams, RadarMatrixParams, RadarMetadata, RadarOptions, RadarReverseGeocodeParams, RadarSearchGeofencesParams, RadarSearchPlacesParams, RadarStartTrackingVerifiedParams, RadarTrackParams, RadarTrackVerifiedParams, RadarTrackVerifiedResponse, RadarTripOptions, RadarValidateAddressParams } from './types';
 declare class Radar {
     static get VERSION(): string;
@@ -25,6 +26,7 @@ declare class Radar {
     static logConversion(params: RadarConversionParams): Promise<import("./types").RadarConversionResponse>;
     static setProduct(product?: string): void;
     static onTokenUpdated(callback: (token: RadarTrackVerifiedResponse) => void): void;
+    static onError(callback: (error: RadarError) => void): void;
     static forwardGeocode(params: RadarForwardGeocodeParams): Promise<import("./types").RadarGeocodeResponse>;
     static reverseGeocode(params: RadarReverseGeocodeParams): Promise<import("./types").RadarGeocodeResponse>;
     static ipGeocode(): Promise<import("./types").RadarIPGeocodeResponse>;

package/dist/config.d.ts CHANGED Viewed

@@ -1,3 +1,4 @@
+import { RadarError } from './errors';
 import type { RadarOptions } from './types';
 declare class Config {
     static options: RadarOptions;
@@ -11,5 +12,7 @@ declare class Config {
     static setup(options?: RadarOptions): void;
     static get(): RadarOptions;
     static clear(): void;
+    static onError(callback: (error: RadarError) => void): void;
+    static sendError(error: any): void;
 }
 export default Config;

package/dist/errors.d.ts CHANGED Viewed

@@ -1,4 +1,4 @@
-declare class RadarError extends Error {
+export declare class RadarError extends Error {
     status: string;
     constructor(message: string);
 }
@@ -59,4 +59,3 @@ export declare class RadarUnknownError extends RadarError {
 export declare class RadarAutocompleteContainerNotFound extends RadarError {
     constructor(message: string);
 }
-export {};

package/dist/radar.js CHANGED Viewed

@@ -1,5 +1,6 @@
 import maplibregl from 'maplibre-gl';
+let errorCallback = null;
 class Config {
     static setup(options = {}) {
         Config.options = options;
@@ -10,6 +11,14 @@ class Config {
     static clear() {
         Config.options = {};
     }
+    static onError(callback) {
+        errorCallback = callback;
+    }
+    static sendError(error) {
+        if (errorCallback && error) {
+            errorCallback(error);
+        }
+    }
 }
 Config.defaultOptions = {
     live: false,
@@ -384,12 +393,12 @@ class Navigator {
     }
     static getPermissionStatus() {
         return __awaiter(this, void 0, void 0, function* () {
-            return new Promise((resolve, reject) => {
+            return new Promise((resolve) => {
+                let locationAuthorization = 'NOT_DETERMINED';
                 if (!navigator || !navigator.permissions) {
-                    return reject(new RadarLocationError('navigator.permissions is not available.'));
+                    return resolve(locationAuthorization);
                 }
                 navigator.permissions.query({ name: 'geolocation' }).then((permissionsStatus) => {
-                    let locationAuthorization = 'NOT_DETERMINED';
                     switch (permissionsStatus.state) {
                         case 'granted':
                             locationAuthorization = 'GRANTED_FOREGROUND';
@@ -408,7 +417,7 @@ class Navigator {
     }
 }
-var SDK_VERSION = '4.5.3';
+var SDK_VERSION = '4.5.5-beta.0';
 const inFlightRequests = new Map();
 class Http {
@@ -537,7 +546,7 @@ class Http {
                 };
                 xhr.onerror = function () {
                     if (host && (host === 'http://localhost:52516' || host === 'https://radar-verify.com:52516')) {
-                        reject(new RadarVerifyAppError());
+                        reject(navigator.onLine ? new RadarVerifyAppError() : new RadarNetworkError());
                     }
                     else {
                         reject(new RadarNetworkError());
@@ -545,7 +554,7 @@ class Http {
                 };
                 xhr.ontimeout = function () {
                     if (host && (host === 'http://localhost:52516' || host === 'https://radar-verify.com:52516')) {
-                        reject(new RadarVerifyAppError());
+                        reject(navigator.onLine ? new RadarVerifyAppError() : new RadarNetworkError());
                     }
                     else {
                         reject(new RadarNetworkError());
@@ -644,7 +653,14 @@ class ConfigAPI {
             const deviceId = params.deviceId || Device.getDeviceId();
             const installId = params.installId || Device.getInstallId();
             const sessionId = Session.getSessionId();
-            const locationAuthorization = yield Navigator.getPermissionStatus();
+            // location authorization
+            let locationAuthorization;
+            try {
+                locationAuthorization = yield Navigator.getPermissionStatus();
+            }
+            catch (err) {
+                Logger.warn(`Location authorization error: ${err.message}`);
+            }
             const data = {
                 deviceId,
                 installId,
@@ -1190,13 +1206,7 @@ class TrackAPI {
                 accuracy = deviceLocation.accuracy;
             }
             // location authorization
-            let locationAuthorization;
-            try {
-                locationAuthorization = yield Navigator.getPermissionStatus();
-            }
-            catch (err) {
-                Logger.warn(`Location authorization error: ${err.message}`);
-            }
+            const locationAuthorization = yield Navigator.getPermissionStatus();
             // user indentification fields
             const userId = params.userId || Storage.getItem(Storage.USER_ID);
             const deviceId = params.deviceId || Device.getDeviceId();
@@ -1318,6 +1328,7 @@ class TrackAPI {
 }
 let tokenTimeoutId = null;
+let isTrackingVerified = true;
 let tokenCallback = null;
 let lastToken = null;
 let lastTokenNow = 0;
@@ -1326,86 +1337,96 @@ let expectedStateCode = null;
 class VerifyAPI {
     static trackVerified(params, encrypted = false) {
         return __awaiter(this, void 0, void 0, function* () {
-            const options = Config.get();
-            const { skipVerifyApp } = params;
-            // user indentification fields
-            const userId = params.userId || Storage.getItem(Storage.USER_ID);
-            const deviceId = Device.getDeviceId();
-            const installId = Device.getInstallId();
-            const sessionId = Session.getSessionId();
-            const description = params.description || Storage.getItem(Storage.DESCRIPTION);
-            // save userId
-            if (!userId) {
-                Logger.warn('userId not provided for trackVerified.');
-            }
-            else {
-                Storage.setItem(Storage.USER_ID, userId);
-            }
-            // other info
-            const metadata = params.metadata || Storage.getJSON(Storage.METADATA);
-            let trackRes;
-            if (skipVerifyApp) {
-                trackRes = yield TrackAPI.trackOnce({
-                    userId: userId !== null && userId !== void 0 ? userId : undefined,
-                    description: description !== null && description !== void 0 ? description : undefined,
-                    metadata: metadata,
-                    fraud: true,
-                });
-            }
-            else {
-                const body = Object.assign(Object.assign({}, params), { description,
-                    deviceId, foreground: true, installId,
-                    sessionId,
-                    metadata, sdkVersion: SDK_VERSION, stopped: true, userId,
-                    encrypted,
-                    expectedCountryCode,
-                    expectedStateCode });
-                let userAgent = navigator.userAgent;
-                const apple = userAgent && (userAgent.toLowerCase().includes('mac') || userAgent.toLowerCase().includes('iphone') || userAgent.toLowerCase().includes('ipod') || userAgent.toLowerCase().includes('ipad'));
-                const response = yield Http.request({
-                    method: 'GET',
-                    path: 'verify',
-                    data: body,
-                    host: apple ? 'https://radar-verify.com:52516' : 'http://localhost:52516',
-                });
-                let { user, events, token, expiresAt, expiresIn, passed, failureReasons, _id } = response;
-                let location;
-                if (user && user.location && user.location.coordinates && user.locationAccuracy) {
-                    location = {
-                        latitude: user.location.coordinates[1],
-                        longitude: user.location.coordinates[0],
-                        accuracy: user.locationAccuracy,
-                    };
+            try {
+                const options = Config.get();
+                const { skipVerifyApp } = params;
+                // user indentification fields
+                const userId = params.userId || Storage.getItem(Storage.USER_ID);
+                const deviceId = Device.getDeviceId();
+                const installId = Device.getInstallId();
+                const sessionId = Session.getSessionId();
+                const description = params.description || Storage.getItem(Storage.DESCRIPTION);
+                // save userId
+                if (!userId) {
+                    Logger.warn('userId not provided for trackVerified.');
                 }
-                if (expiresAt) {
-                    expiresAt = new Date(expiresAt);
+                else {
+                    Storage.setItem(Storage.USER_ID, userId);
                 }
-                trackRes = {
-                    user,
-                    events,
-                    location,
-                    token,
-                    expiresAt,
-                    expiresIn,
-                    passed,
-                    failureReasons,
-                    _id,
-                };
-                if (options.debug) {
-                    trackRes.response = response;
+                // other info
+                const metadata = params.metadata || Storage.getJSON(Storage.METADATA);
+                let trackRes;
+                if (skipVerifyApp) {
+                    trackRes = yield TrackAPI.trackOnce({
+                        userId: userId !== null && userId !== void 0 ? userId : undefined,
+                        description: description !== null && description !== void 0 ? description : undefined,
+                        metadata: metadata,
+                        fraud: true,
+                    });
                 }
+                else {
+                    const body = Object.assign(Object.assign({}, params), { description,
+                        deviceId, foreground: true, installId,
+                        sessionId,
+                        metadata, sdkVersion: SDK_VERSION, stopped: true, userId,
+                        encrypted,
+                        expectedCountryCode,
+                        expectedStateCode });
+                    let userAgent = navigator.userAgent;
+                    const apple = userAgent && (userAgent.toLowerCase().includes('mac') || userAgent.toLowerCase().includes('iphone') || userAgent.toLowerCase().includes('ipod') || userAgent.toLowerCase().includes('ipad'));
+                    const response = yield Http.request({
+                        method: 'GET',
+                        path: 'verify',
+                        data: body,
+                        host: apple ? 'https://radar-verify.com:52516' : 'http://localhost:52516',
+                    });
+                    let { user, events, token, expiresAt, expiresIn, passed, failureReasons, _id } = response;
+                    let location;
+                    if (user && user.location && user.location.coordinates && user.locationAccuracy) {
+                        location = {
+                            latitude: user.location.coordinates[1],
+                            longitude: user.location.coordinates[0],
+                            accuracy: user.locationAccuracy,
+                        };
+                    }
+                    if (expiresAt) {
+                        expiresAt = new Date(expiresAt);
+                    }
+                    trackRes = {
+                        user,
+                        events,
+                        location,
+                        token,
+                        expiresAt,
+                        expiresIn,
+                        passed,
+                        failureReasons,
+                        _id,
+                    };
+                    if (options.debug) {
+                        trackRes.response = response;
+                    }
+                }
+                lastToken = trackRes;
+                lastTokenNow = performance.now();
+                if (tokenCallback) {
+                    tokenCallback(trackRes);
+                }
+                return trackRes;
             }
-            lastToken = trackRes;
-            lastTokenNow = performance.now();
-            if (tokenCallback) {
-                tokenCallback(trackRes);
+            catch (err) {
+                Config.sendError(err);
+                throw err;
             }
-            return trackRes;
         });
     }
     static startTrackingVerified(params) {
+        isTrackingVerified = true;
         const scheduleNextIntervalWithLastToken = () => __awaiter(this, void 0, void 0, function* () {
-            const { interval } = params;
+            let { interval } = params;
+            if (!interval) {
+                interval = 20;
+            }
             let minInterval = interval;
             if (lastToken) {
                 const lastTokenElapsed = (performance.now() - lastTokenNow) / 1000;
@@ -1422,7 +1443,9 @@ class VerifyAPI {
             if (tokenTimeoutId) {
                 clearTimeout(tokenTimeoutId);
             }
-            tokenTimeoutId = setTimeout(doTrackVerified, minInterval * 1000);
+            if (isTrackingVerified) {
+                tokenTimeoutId = setTimeout(doTrackVerified, minInterval * 1000);
+            }
         });
         const doTrackVerified = () => __awaiter(this, void 0, void 0, function* () {
             try {
@@ -1441,6 +1464,7 @@ class VerifyAPI {
         }
     }
     static stopTrackingVerified() {
+        isTrackingVerified = false;
         if (tokenTimeoutId) {
             clearTimeout(tokenTimeoutId);
         }
@@ -1602,6 +1626,9 @@ let Radar$1 = class Radar {
     static onTokenUpdated(callback) {
         VerifyAPI.onTokenUpdated(callback);
     }
+    static onError(callback) {
+        Config.onError(callback);
+    }
     /////////////////
     // Maps Platform
     /////////////////

package/dist/radar.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"radar.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
1	+ {"version":3,"file":"radar.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/version.d.ts CHANGED Viewed

@@ -1,2 +1,2 @@
-declare const _default: "4.5.3";
+declare const _default: "4.5.5-beta.0";
 export default _default;

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "radar-sdk-js",
-  "version": "4.5.3",
+  "version": "4.5.5-beta.0",
   "description": "Web Javascript SDK for Radar, location infrastructure for mobile and web apps.",
   "homepage": "https://radar.com",
   "type": "module",

package/src/api/config.ts CHANGED Viewed

@@ -19,7 +19,14 @@ class ConfigAPI {
     const deviceId = params.deviceId || Device.getDeviceId();
     const installId = params.installId || Device.getInstallId();
     const sessionId = Session.getSessionId();
-    const locationAuthorization = await Navigator.getPermissionStatus();
+    // location authorization
+    let locationAuthorization;
+    try {
+      locationAuthorization = await Navigator.getPermissionStatus();
+    } catch (err: any) {
+      Logger.warn(`Location authorization error: ${err.message}`);
+    }
     const data = {
       deviceId,

package/src/api/track.ts CHANGED Viewed

@@ -8,7 +8,6 @@ import Session from '../session';
 import Storage from '../storage';
 import TripsAPI from './trips';
 import { signJWT } from '../util/jwt';
-import { ping } from '../util/net';
 import type { RadarTrackParams, RadarTrackResponse, RadarTrackVerifiedResponse } from '../types';
@@ -33,12 +32,7 @@ class TrackAPI {
     }
     // location authorization
-    let locationAuthorization;
-    try {
-      locationAuthorization = await Navigator.getPermissionStatus();
-    } catch (err: any) {
-      Logger.warn(`Location authorization error: ${err.message}`);
-    }
+    const locationAuthorization = await Navigator.getPermissionStatus();
     // user indentification fields
     const userId = params.userId || Storage.getItem(Storage.USER_ID);

package/src/api/verify.ts CHANGED Viewed

@@ -7,9 +7,11 @@ import Session from '../session';
 import Storage from '../storage';
 import TrackAPI from './track';
+import type { RadarError } from '../errors';
 import type { RadarStartTrackingVerifiedParams, RadarTrackVerifiedParams, RadarTrackVerifiedResponse } from '../types';
 let tokenTimeoutId: any | null = null;
+let isTrackingVerified = true;
 let tokenCallback: ((token: RadarTrackVerifiedResponse) => void) | null = null;
 let lastToken: RadarTrackVerifiedResponse | null = null;
 let lastTokenNow: number = 0;
@@ -18,105 +20,116 @@ let expectedStateCode: string | null = null;
 class VerifyAPI {
   static async trackVerified(params: RadarTrackVerifiedParams, encrypted: Boolean = false) {
-    const options = Config.get();
-    const { skipVerifyApp } = params;
-    // user indentification fields
-    const userId = params.userId || Storage.getItem(Storage.USER_ID);
-    const deviceId = Device.getDeviceId();
-    const installId = Device.getInstallId();
-    const sessionId = Session.getSessionId();
-    const description = params.description || Storage.getItem(Storage.DESCRIPTION);
-    // save userId
-    if (!userId) {
-      Logger.warn('userId not provided for trackVerified.');
-    } else {
-      Storage.setItem(Storage.USER_ID, userId);
-    }
+    try {
+      const options = Config.get();
+      const { skipVerifyApp } = params;
+      // user indentification fields
+      const userId = params.userId || Storage.getItem(Storage.USER_ID);
+      const deviceId = Device.getDeviceId();
+      const installId = Device.getInstallId();
+      const sessionId = Session.getSessionId();
+      const description = params.description || Storage.getItem(Storage.DESCRIPTION);
+      // save userId
+      if (!userId) {
+        Logger.warn('userId not provided for trackVerified.');
+      } else {
+        Storage.setItem(Storage.USER_ID, userId);
+      }
-    // other info
-    const metadata = params.metadata || Storage.getJSON(Storage.METADATA);
-    let trackRes: RadarTrackVerifiedResponse;
-    if (skipVerifyApp) {
-      trackRes = await TrackAPI.trackOnce({
-        userId: userId ?? undefined,
-        description: description ?? undefined,
-        metadata: metadata,
-        fraud: true,
-      });
-    } else {
-      const body = {
-        ...params,
-        description,
-        deviceId,
-        foreground: true,
-        installId,
-        sessionId,
-        metadata,
-        sdkVersion: SDK_VERSION,
-        stopped: true,
-        userId,
-        encrypted,
-        expectedCountryCode,
-        expectedStateCode,
-      };
-      let userAgent = navigator.userAgent;
-      const apple = userAgent && (userAgent.toLowerCase().includes('mac') || userAgent.toLowerCase().includes('iphone') || userAgent.toLowerCase().includes('ipod') || userAgent.toLowerCase().includes('ipad'));
-      const response: any = await Http.request({
-        method: 'GET',
-        path: 'verify',
-        data: body,
-        host: apple ? 'https://radar-verify.com:52516' : 'http://localhost:52516',
-      });
-      let { user, events, token, expiresAt, expiresIn, passed, failureReasons, _id } = response;
-      let location;
-      if (user && user.location && user.location.coordinates && user.locationAccuracy) {
-        location = {
-          latitude: user.location.coordinates[1],
-          longitude: user.location.coordinates[0],
-          accuracy: user.locationAccuracy,
+      // other info
+      const metadata = params.metadata || Storage.getJSON(Storage.METADATA);
+      let trackRes: RadarTrackVerifiedResponse;
+      if (skipVerifyApp) {
+        trackRes = await TrackAPI.trackOnce({
+          userId: userId ?? undefined,
+          description: description ?? undefined,
+          metadata: metadata,
+          fraud: true,
+        });
+      } else {
+        const body = {
+          ...params,
+          description,
+          deviceId,
+          foreground: true,
+          installId,
+          sessionId,
+          metadata,
+          sdkVersion: SDK_VERSION,
+          stopped: true,
+          userId,
+          encrypted,
+          expectedCountryCode,
+          expectedStateCode,
         };
+        let userAgent = navigator.userAgent;
+        const apple = userAgent && (userAgent.toLowerCase().includes('mac') || userAgent.toLowerCase().includes('iphone') || userAgent.toLowerCase().includes('ipod') || userAgent.toLowerCase().includes('ipad'));
+        const response: any = await Http.request({
+          method: 'GET',
+          path: 'verify',
+          data: body,
+          host: apple ? 'https://radar-verify.com:52516' : 'http://localhost:52516',
+        });
+        let { user, events, token, expiresAt, expiresIn, passed, failureReasons, _id } = response;
+        let location;
+        if (user && user.location && user.location.coordinates && user.locationAccuracy) {
+          location = {
+            latitude: user.location.coordinates[1],
+            longitude: user.location.coordinates[0],
+            accuracy: user.locationAccuracy,
+          };
+        }
+        if (expiresAt) {
+          expiresAt = new Date(expiresAt);
+        }
+        trackRes = {
+          user,
+          events,
+          location,
+          token,
+          expiresAt,
+          expiresIn,
+          passed,
+          failureReasons,
+          _id,
+        } as RadarTrackVerifiedResponse;
+        if (options.debug) {
+          trackRes.response = response;
+        }
       }
-      if (expiresAt) {
-        expiresAt = new Date(expiresAt);
-      }
-      trackRes = {
-        user,
-        events,
-        location,
-        token,
-        expiresAt,
-        expiresIn,
-        passed,
-        failureReasons,
-        _id,
-      } as RadarTrackVerifiedResponse;
-      if (options.debug) {
-        trackRes.response = response;
-      }
-    }
-    lastToken = trackRes;
-    lastTokenNow = performance.now();
+      lastToken = trackRes;
+      lastTokenNow = performance.now();
-    if (tokenCallback) {
-      tokenCallback(trackRes);
-    }
+      if (tokenCallback) {
+        tokenCallback(trackRes);
+      }
-    return trackRes;
+      return trackRes;
+    } catch (err: any) {
+      Config.sendError(err);
+      throw err;
+    }
   }
   static startTrackingVerified(params: RadarStartTrackingVerifiedParams) {
+    isTrackingVerified = true;
     const scheduleNextIntervalWithLastToken = async () => {
-      const { interval } = params;
+      let { interval } = params;
+      if (!interval) {
+        interval = 20;
+      }
       let minInterval = interval;
@@ -141,8 +154,10 @@ class VerifyAPI {
         clearTimeout(tokenTimeoutId);
       }
-      tokenTimeoutId = setTimeout(doTrackVerified, minInterval * 1000);
-    }
+      if (isTrackingVerified) {
+        tokenTimeoutId = setTimeout(doTrackVerified, minInterval * 1000);
+      }
+    };
     const doTrackVerified = async () => {
       try {
@@ -162,6 +177,8 @@ class VerifyAPI {
   }
   static stopTrackingVerified() {
+    isTrackingVerified = false;
     if (tokenTimeoutId) {
       clearTimeout(tokenTimeoutId);
     }

package/src/api.ts CHANGED Viewed

@@ -2,7 +2,7 @@ import Config from './config';
 import Logger from './logger';
 import Storage from './storage';
 import Navigator from './navigator';
-import { RadarPublishableKeyError } from './errors';
+import { RadarError, RadarPublishableKeyError } from './errors';
 import AddressesAPI from './api/addresses';
 import ConfigAPI from './api/config';
@@ -201,10 +201,14 @@ class Radar {
   ///////////////////////
   // Listeners
   ///////////////////////
   public static onTokenUpdated(callback: (token: RadarTrackVerifiedResponse) => void) {
     VerifyAPI.onTokenUpdated(callback);
   }
+  public static onError(callback: (error: RadarError) => void) {
+    Config.onError(callback);
+  }
   /////////////////
   // Maps Platform

package/src/config.ts CHANGED Viewed

@@ -1,5 +1,8 @@
+import { RadarError } from './errors';
 import type { RadarOptions } from './types';
+let errorCallback: ((error: RadarError) => void) | null = null;
 class Config {
   static options: RadarOptions;
@@ -22,6 +25,16 @@ class Config {
   public static clear() {
     Config.options = {};
   }
+  public static onError(callback: (error: RadarError) => void) {
+    errorCallback = callback;
+  }
+  public static sendError(error: any) {
+    if (errorCallback && error) {
+      errorCallback(error);
+    }
+  }
 }
 export default Config

package/src/errors.ts CHANGED Viewed

@@ -1,4 +1,4 @@
-class RadarError extends Error {
+export class RadarError extends Error {
   status: string;
   constructor(message: string) {

package/src/http.ts CHANGED Viewed

@@ -187,7 +187,7 @@ class Http {
       xhr.onerror = function () {
         if (host && (host === 'http://localhost:52516' || host === 'https://radar-verify.com:52516')) {
-          reject(new RadarVerifyAppError());
+          reject(navigator.onLine ? new RadarVerifyAppError() : new RadarNetworkError());
         } else {
           reject(new RadarNetworkError());
         }
@@ -195,7 +195,7 @@ class Http {
       xhr.ontimeout = function () {
         if (host && (host === 'http://localhost:52516' || host === 'https://radar-verify.com:52516')) {
-          reject(new RadarVerifyAppError());
+          reject(navigator.onLine ? new RadarVerifyAppError() : new RadarNetworkError());
         } else {
           reject(new RadarNetworkError());
         }

package/src/navigator.ts CHANGED Viewed

@@ -102,14 +102,14 @@ class Navigator {
   }
   public static async getPermissionStatus(): Promise<LocationAuthorization> {
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve) => {
+      let locationAuthorization: LocationAuthorization = 'NOT_DETERMINED';
       if (!navigator || !navigator.permissions) {
-        return reject(new RadarLocationError('navigator.permissions is not available.'));
+        return resolve(locationAuthorization);
       }
       navigator.permissions.query({ name: 'geolocation' }).then((permissionsStatus) => {
-        let locationAuthorization: LocationAuthorization = 'NOT_DETERMINED';
         switch(permissionsStatus.state) {
           case 'granted':
             locationAuthorization = 'GRANTED_FOREGROUND'
@@ -124,7 +124,7 @@ class Navigator {
             break;
         }
-        return resolve(locationAuthorization)
+        return resolve(locationAuthorization);
       });
     });
   }

package/src/version.ts CHANGED Viewed

	@@ -1 +1 @@
1	- export default '4.5.3';
1	+ export default '4.5.5-beta.0';