radar-sdk-js 4.5.0-beta.0 → 4.5.0

package/dist/radar.js.map

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

package/dist/types.d.ts

@@ -27,7 +27,7 @@ export interface RadarResponse {
     response?: any;
 }
 export type RadarTravelMode = 'car' | 'foot' | 'bike' | 'motorbike' | 'truck';
-export type RadarAvoidOption = 'tolls' | 'highways' | 'ferries';
+export type RadarAvoidOption = 'tolls' | 'highways' | 'ferries' | 'borderCrossings';
 export interface RadarTripOptions {
     userId?: string;
     externalId?: string;
@@ -54,8 +54,15 @@ export interface RadarTrackParams {
     desiredAccuracy?: 'high' | 'medium' | 'low';
     fraud?: boolean;
 }
+export interface RadarTrackVerifiedParams {
+    userId?: string;
+    description?: string;
+    metadata?: RadarMetadata;
+    skipVerifyApp?: boolean;
+}
 export interface RadarStartTrackingVerifiedParams {
     interval: number;
+    skipVerifyApp?: boolean;
 }
 export declare enum RadarEventConfidence {
     none = 0,
@@ -188,7 +195,7 @@ export interface RadarCustomEvent {
 export interface RadarConversionResponse extends RadarResponse {
     event: RadarCustomEvent;
 }
-export type RadarGeocodeLayer = 'place' | 'address' | 'postalCode' | 'locality' | 'county' | 'state' | 'country' | 'coarse' | 'fine';
+export type RadarGeocodeLayer = 'place' | 'address' | 'postalCode' | 'locality' | 'neighborhood' | 'county' | 'state' | 'country' | 'coarse' | 'fine';
 export interface RadarAddress {
     addressLabel?: string;
     borough?: string;
@@ -214,9 +221,21 @@ export interface RadarAddress {
     stateCode?: string;
     street?: string;
 }
+export interface RadarTimeZone {
+    id: string;
+    name: string;
+    code: string;
+    currentTime: string;
+    utcOffset: number;
+    dstOffset: number;
+}
 export interface RadarAutocompleteAddress extends RadarAddress {
     unit?: string;
 }
+export interface RadarGeocodeAddress extends RadarAddress {
+    unit?: string;
+    timeZone?: RadarTimeZone;
+}
 export type RadarValidationRecordType = 'S' | 'R' | 'P' | 'M' | 'H' | 'G' | 'F' | undefined;
 export type RadarValidationPropertyType = 'commercial' | 'residential' | undefined;
 export type RadarVerificationStatus = 'verified' | 'partially verified' | 'ambiguous' | 'unverified';
@@ -232,6 +251,7 @@ export interface RadarForwardGeocodeParams {
     query: string;
     layers?: RadarGeocodeLayer[];
     country?: string;
+    lang?: string;
 }
 export interface RadarReverseGeocodeParams {
     latitude?: number;
@@ -239,11 +259,11 @@ export interface RadarReverseGeocodeParams {
     layers?: RadarGeocodeLayer[];
 }
 export interface RadarGeocodeResponse extends RadarResponse {
-    addresses: RadarAddress[];
+    addresses: RadarGeocodeAddress[];
 }
 export interface RadarIPGeocodeResponse extends RadarResponse {
     ip: string;
-    address?: RadarAddress;
+    address?: RadarGeocodeAddress;
     proxy?: boolean;
 }
 export interface RadarAutocompleteParams {
@@ -255,6 +275,8 @@ export interface RadarAutocompleteParams {
     /** @deprecated this is always true, regardless of the value passed here */
     expandUnits?: boolean;
     mailable?: boolean;
+    lang?: string;
+    postalCode?: string;
 }
 export interface RadarAutocompleteResponse extends RadarResponse {
     addresses: RadarAutocompleteAddress[];
@@ -273,13 +295,14 @@ export interface RadarSearchPlace extends RadarPlace {
 export interface RadarSearchPlacesResponse extends RadarResponse {
     places: RadarSearchPlace[];
 }
+export type RadarDistanceGeometryType = 'polyline' | 'polyline5' | 'polyline6' | 'linestring';
 export interface RadarDistanceParams {
     origin?: Location | string;
     destination: Location | string;
     modes: RadarTravelMode[] | string;
     units?: 'metric' | 'imperial';
-    geometry?: boolean;
-    geometryPoints?: boolean;
+    geometry?: RadarDistanceGeometryType;
+    geometryPoints?: number;
     avoid?: RadarAvoidOption[] | string;
 }
 export interface RadarRouteDistance {
@@ -405,17 +428,12 @@ export interface RadarPolygonOptions {
         'border-opacity'?: number;
     };
 }
-export interface RadarAutocompleteUIOptions {
+export interface RadarAutocompleteUIOptions extends Omit<RadarAutocompleteParams, 'query'> {
     container: string | HTMLElement;
-    near?: string | Location;
     debounceMS?: number;
+    /** @deprecated use minCharacters instead */
     threshold?: number;
     minCharacters?: number;
-    limit?: number;
-    layers?: RadarGeocodeLayer[];
-    countryCode?: string;
-    expandUnits?: boolean;
-    mailable?: boolean;
     placeholder?: string;
     onSelection?: (selection: any) => void;
     onRequest?: (params: RadarAutocompleteParams) => void;
@@ -430,7 +448,6 @@ export interface RadarAutocompleteUIOptions {
     hideResultsOnBlur?: boolean;
 }
 export interface RadarAutocompleteConfig extends RadarAutocompleteUIOptions {
-    container: string | HTMLElement;
     debounceMS: number;
     threshold: number;
     minCharacters: number;

package/dist/ui/RadarMap.d.ts

@@ -7,7 +7,6 @@ import type { RadarMapOptions, RadarLineOptions, RadarPolylineOptions, RadarPoly
 declare class RadarMap extends maplibregl.Map {
     _markers: RadarMarker[];
     _features: RadarMapFeature[];
-    _defaultMarker?: string;
     constructor(radarMapOptions: RadarMapOptions);
     addMarker(marker: RadarMarker): void;
     removeMarker(marker: RadarMarker): void;

package/dist/ui/RadarMarker.d.ts

@@ -2,10 +2,8 @@ import maplibregl from 'maplibre-gl';
 import type RadarMap from './RadarMap';
 import type { RadarMarkerOptions } from '../types';
 declare class RadarMarker extends maplibregl.Marker {
-    _options: RadarMarkerOptions;
     _map: RadarMap;
     constructor(markerOptions: RadarMarkerOptions);
-    getCustomImage(markerOptions: RadarMarkerOptions): void;
     addTo(map: RadarMap): this;
     remove(): this;
 }

package/dist/ui/autocomplete.d.ts

@@ -28,10 +28,12 @@ declare class AutocompleteUI {
     setPlaceholder(placeholder: string): this;
     setDisabled(disabled: boolean): this;
     setResponsive(responsive: boolean): this;
-    setWidth(width: number | string): this;
-    setMaxHeight(height: number | string): this;
+    setWidth(width: number | string | null): this;
+    setMaxHeight(height: number | string | null): this;
     setMinCharacters(minCharacters: number): this;
     setLimit(limit: number): this;
+    setLang(lang: string | null): this;
+    setPostalCode(postalCode: string | null): this;
     setShowMarkers(showMarkers: boolean): this;
     setMarkerColor(color: string): this;
     setHideResultsOnBlur(hideResultsOnBlur: boolean): this;

package/dist/version.d.ts

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "radar-sdk-js",
-  "version": "4.5.0-beta.0",
+  "version": "4.5.0",
   "description": "Web Javascript SDK for Radar, location infrastructure for mobile and web apps.",
   "homepage": "https://radar.com",
   "type": "module",
@@ -23,7 +23,9 @@
     "test": "jest --collect-coverage --runInBand",
     "test:watch": "jest --watch",
     "demo": "npm run build && node ./demo/server.cjs",
-    "compile-site": "node ./scripts/compile-site.cjs"
+    "compile-site": "node ./scripts/compile-site.cjs",
+    "spell-check": "cspell **/*.md -c cspell.json",
+    "prepare": "husky"
   },
   "author": "",
   "license": "ISC",
@@ -33,11 +35,14 @@
     "@rollup/plugin-node-resolve": "^15.1.0",
     "@rollup/plugin-terser": "^0.4.3",
     "@types/jest": "^29.5.1",
+    "cspell": "^8.15.3",
     "express": "^4.18.2",
     "express-handlebars": "^7.0.7",
     "handlebars": "^4.7.7",
+    "husky": "^9.1.6",
     "jest": "^29.5.0",
     "jest-environment-jsdom": "^29.5.0",
+    "lint-staged": "^15.2.10",
     "maplibre-gl": "^4.3.2",
     "mock-xmlhttprequest": "^8.2.0",
     "nodemon": "^2.0.22",
@@ -52,6 +57,11 @@
     "@types/geojson": "^7946.0.10"
   },
   "peerDependencies": {
-    "maplibre-gl": "^2.4.0 || ^3.0.0 || ^4.0.0"
+    "maplibre-gl": "^2.4.0 || ^3.0.0 || ^4.0.0 || ^5.0.1"
+  },
+  "husky": {
+    "hooks": {
+      "pre-commit": "lint-staged"
+    }
   }
 }

package/src/api/geocoding.ts

@@ -13,7 +13,7 @@ class Geocoding {
   static async forwardGeocode(params: RadarForwardGeocodeParams): Promise<RadarGeocodeResponse> {
     const options = Config.get();
 
-    const { query, layers, country } = params;
+    const { query, layers, country, lang } = params;
 
     const response: any = await Http.request({
       method: 'GET',
@@ -22,6 +22,7 @@ class Geocoding {
         query,
         layers,
         country,
+        lang,
       },
     });
 

package/src/api/search.ts

@@ -23,6 +23,8 @@ class SearchAPI {
       countryCode,
       expandUnits,
       mailable,
+      lang,
+      postalCode,
     } = params;
 
     // near can be provided as a string or Location object
@@ -44,6 +46,8 @@ class SearchAPI {
         countryCode,
         expandUnits,
         mailable,
+        lang,
+        postalCode,
       },
       requestId,
     });

package/src/api/track.ts

@@ -89,7 +89,6 @@ class TrackAPI {
     let response: any;
     if (fraud) {
       const host = 'https://api-verified.radar.io';
-      const pingHost = 'ping.radar-verify.com';
 
       const lang = navigator.language;
       const langs = navigator.languages;
@@ -109,29 +108,9 @@ class TrackAPI {
         },
       });
 
-      let sclVal = -1;
-      let cslVal = -1;
-      try {
-        const [sclRes, csl] = await Promise.all([
-          Http.request({
-            host: `https://${pingHost}`,
-            method: 'GET',
-            path: 'ping',
-          }),
-          ping(`wss://${pingHost}`),
-        ]);
-        const { scl }: any = sclRes;
-        sclVal = scl;
-        cslVal = csl;
-      } catch (err) {
-        // do nothing, send scl = -1 and csl = -1
-      }
-
       const payload = {
         payload: JSON.stringify({
           ...body,
-          scl: sclVal,
-          csl: cslVal,
           lang,
           langs,
         }),
@@ -151,17 +130,6 @@ class TrackAPI {
         },
       });
 
-      if (options.debug && response && response.user) {
-        if (!response.user.metadata) {
-          response.user.metadata = {};
-        }
-        
-        response.user.metadata['radar:debug'] = {
-          sclVal,
-          cslVal,
-        };
-      }
-
       let { user, events, token, expiresAt, expiresIn, passed, failureReasons, _id } = response;
       const location = { latitude, longitude, accuracy };
       if (expiresAt) {

package/src/api/verify.ts

@@ -5,8 +5,9 @@ import Http from '../http';
 import Logger from '../logger';
 import Session from '../session';
 import Storage from '../storage';
+import TrackAPI from './track';
 
-import type { RadarStartTrackingVerifiedParams, RadarTrackParams, RadarTrackVerifiedResponse } from '../types';
+import type { RadarStartTrackingVerifiedParams, RadarTrackVerifiedParams, RadarTrackVerifiedResponse } from '../types';
 
 let tokenTimeoutId: any | null = null;
 let tokenCallback: ((token: RadarTrackVerifiedResponse) => void) | null = null;
@@ -16,13 +17,15 @@ let expectedCountryCode: string | null = null;
 let expectedStateCode: string | null = null;
 
 class VerifyAPI {
-  static async trackVerified(params: RadarTrackParams, encrypted: Boolean = false) {
+  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 = params.deviceId || Device.getDeviceId();
-    const installId = params.installId || Device.getInstallId();
+    const deviceId = Device.getDeviceId();
+    const installId = Device.getInstallId();
     const sessionId = Session.getSessionId();
     const description = params.description || Storage.getItem(Storage.DESCRIPTION);
 
@@ -36,59 +39,69 @@ class VerifyAPI {
     // other info
     const metadata = params.metadata || Storage.getJSON(Storage.METADATA);
 
-    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,
+    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,
       };
-    }
-    if (expiresAt) {
-      expiresAt = new Date(expiresAt);
-    }
-
-    const trackRes = {
-      user,
-      events,
-      location,
-      token,
-      expiresAt,
-      expiresIn,
-      passed,
-      failureReasons,
-      _id,
-    } as RadarTrackVerifiedResponse;
-
-    if (options.debug) {
-      trackRes.response = response;
+  
+      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;
+      }
     }
 
     lastToken = trackRes;
@@ -101,26 +114,23 @@ class VerifyAPI {
     return trackRes;
   }
 
-  static async startTrackingVerified(params: RadarStartTrackingVerifiedParams) {
-    const doTrackVerified = async () => {
-      const trackRes = await this.trackVerified({});
-
+  static startTrackingVerified(params: RadarStartTrackingVerifiedParams) {
+    const scheduleNextIntervalWithLastToken = async () => {
       const { interval } = params;
 
-      let expiresIn = 0;
       let minInterval = interval;
 
-      if (trackRes) {
-        expiresIn = (trackRes.expiresIn || expiresIn);
+      if (lastToken) {
+        const lastTokenElapsed = (performance.now() - lastTokenNow) / 1000;
+
+        const expiresIn = (lastToken.expiresIn || 0);
 
         // if expiresIn is shorter than interval, override interval
-        minInterval = Math.min(expiresIn, interval);
+        // re-request early to maximize the likelihood that a cached token is available
+        minInterval = Math.min(expiresIn - lastTokenElapsed, interval);
       }
 
-      // re-request early to maximize the likelihood that a cached token is available
-      if (minInterval > 20) {
-        minInterval = minInterval - 10;
-      }
+      minInterval = minInterval - 10;
 
       // min interval is 10 seconds
       if (minInterval < 10) {
@@ -132,9 +142,23 @@ class VerifyAPI {
       }
 
       tokenTimeoutId = setTimeout(doTrackVerified, minInterval * 1000);
+    }
+
+    const doTrackVerified = async () => {
+      try {
+        await this.trackVerified(params);
+      } catch (err: any) {
+        Logger.error(`trackVerified error: ${err.message}`);
+      }
+
+      scheduleNextIntervalWithLastToken();
     };
 
-    doTrackVerified();
+    if (this.isLastTokenValid()) {
+      scheduleNextIntervalWithLastToken();
+    } else {
+      doTrackVerified();
+    }
   }
 
   static stopTrackingVerified() {
@@ -143,16 +167,26 @@ class VerifyAPI {
     }
   }
 
-  static async getVerifiedLocationToken() {
-    const lastTokenElapsed = (performance.now() - lastTokenNow) / 1000;
+  static async getVerifiedLocationToken(params: RadarTrackVerifiedParams) {
+    if (this.isLastTokenValid()) {
+      return lastToken;
+    }
 
-    if (lastToken) {
-      if (lastTokenElapsed < (lastToken.expiresIn || 0)) {
-        return lastToken;
-      }
+    return this.trackVerified(params);
+  }
+
+  static clearVerifiedLocationToken() {
+    lastToken = null;
+  }
+
+  static isLastTokenValid() {
+    if (!lastToken) {
+      return false;
     }
 
-    return this.trackVerified({});
+    const lastTokenElapsed = (performance.now() - lastTokenNow) / 1000;
+
+    return lastToken.passed && lastTokenElapsed < (lastToken.expiresIn || 0);
   }
 
   static setExpectedJurisdiction(countryCode?: string, stateCode?: string) {

package/src/api.ts

@@ -31,6 +31,7 @@ import type {
   RadarSearchPlacesParams,
   RadarStartTrackingVerifiedParams,
   RadarTrackParams,
+  RadarTrackVerifiedParams,
   RadarTrackVerifiedResponse,
   RadarTripOptions,
   RadarValidateAddressParams,
@@ -75,7 +76,7 @@ class Radar {
 
     Logger.info(`initialized with ${live ? 'live' : 'test'} publishableKey.`);
     if (options.debug) {
-      Logger.info(`using options: ${JSON.stringify(options)}`);
+      Logger.debug('using options', options);
     }
 
     // NOTE(jasonl): this allows us to run jest tests
@@ -129,20 +130,24 @@ class Radar {
     }
   }
 
-  public static trackVerified(params: RadarTrackParams = {}) {
+  public static trackVerified(params: RadarTrackVerifiedParams = {}) {
     return VerifyAPI.trackVerified(params);
   }
 
   public static startTrackingVerified(params: RadarStartTrackingVerifiedParams) {
-    return VerifyAPI.startTrackingVerified(params);
+    VerifyAPI.startTrackingVerified(params);
   }
 
   public static stopTrackingVerified() {
-    return VerifyAPI.stopTrackingVerified();
+    VerifyAPI.stopTrackingVerified();
   }
 
-  public static getVerifiedLocationToken() {
-    return VerifyAPI.getVerifiedLocationToken();
+  public static getVerifiedLocationToken(params: RadarTrackVerifiedParams = {}) {
+    return VerifyAPI.getVerifiedLocationToken(params);
+  }
+
+  public static clearVerifiedLocationToken() {
+    VerifyAPI.clearVerifiedLocationToken();
   }
 
   public static setExpectedJurisdiction(countryCode?: string, stateCode?: string) {

package/src/http.ts

@@ -189,12 +189,16 @@ class Http {
         if (host && (host === 'http://localhost:52516' || host === 'https://radar-verify.com:52516')) {
           reject(new RadarVerifyAppError());
         } else {
-          reject(new RadarServerError());
+          reject(new RadarNetworkError());
         }
       }
 
       xhr.ontimeout = function () {
-        reject(new RadarVerifyAppError());
+        if (host && (host === 'http://localhost:52516' || host === 'https://radar-verify.com:52516')) {
+          reject(new RadarVerifyAppError());
+        } else {
+          reject(new RadarNetworkError());
+        }
       }
 
       xhr.send(JSON.stringify(body));

package/src/logger.ts

@@ -27,9 +27,9 @@ const getLevel = (): number => {
 }
 
 class Logger {
-  public static debug(message: string) {
+  public static debug(message: string, options?: any) {
     if (getLevel() === LOG_LEVELS.debug) {
-      console.log(`Radar SDK (debug): ${message.trim()}`);
+      console.log(`Radar SDK (debug): ${message.trim()}`, options);
     }
   }
 

package/src/navigator.ts

@@ -11,7 +11,7 @@ interface PositionOptionOverrides {
 
 const DEFAULT_POSITION_OPTIONS: PositionOptions = {
   maximumAge: 0,
-  timeout: 1000 * 30, // 30 seconds
+  timeout: 1000 * 10, // 10 seconds
   enableHighAccuracy: true,
 };