hypertrack-sdk-react-native 13.3.5 → 13.5.0

package/src/HyperTrack/HyperTrack.ts

@@ -2,7 +2,7 @@ import {
   NativeModules,
   Platform,
   NativeEventEmitter,
-  EmitterSubscription,
+  type EmitterSubscription,
 } from 'react-native';
 import { HyperTrackError } from './data_types/HyperTrackError';
 import type { IsAvailable } from './data_types/internal/IsAvailable';
@@ -22,12 +22,17 @@ import type { Metadata } from './data_types/internal/Metadata';
 import type { DynamicPublishableKey } from './data_types/internal/DynamicPublishableKey';
 import type { OrderStatus } from './data_types/OrderStatus';
 import type { OrderHandle } from './data_types/internal/OrderHandle';
+import type { WorkerHandle } from './data_types/internal/WorkerHandle';
+import type { Order } from './data_types/Order';
+import type { OrdersInternal } from './data_types/internal/OrdersInternal';
+import type { OrderInternal } from './data_types/internal/OrderInternal';
 
 const EVENT_ERRORS = 'errors';
 const EVENT_IS_AVAILABLE = 'isAvailable';
 const EVENT_IS_TRACKING = 'isTracking';
 const EVENT_LOCATE = 'locate';
 const EVENT_LOCATION = 'location';
+const EVENT_ORDERS = 'orders';
 
 const LINKING_ERROR =
   `The package 'hypertrack-sdk-react-native' doesn't seem to be linked. Make sure: \n\n` +
@@ -292,6 +297,31 @@ export default class HyperTrack {
     });
   }
 
+  /**
+   * Gets the active orders for the worker. The orders are sorted with the ordering in 
+   * which the worker should complete them.
+   *
+   * @returns {Map<string, Order>} Map of orders
+   */
+  static async getOrders(): Promise<Map<string, Order>> {
+    return HyperTrackSdk.getOrders().then((orders: OrdersInternal) => {
+      return this.deserializeOrders(orders);
+    });
+  }
+
+  /**
+   * A primary identifier that uniquely identifies the worker outside of HyperTrack.
+   * Example: email, phone number, database id
+   * It is usually obtained and set when the worker logs into the app.
+   * Set it to an empty string "" when the worker logs out of the app to un-bind the device from the worker and
+   * avoid unintentional tracking.
+   */
+  static async getWorkerHandle(): Promise<string> {
+    return HyperTrackSdk.getWorkerHandle().then(
+      (workerHandle: WorkerHandle) => workerHandle.value
+    );
+  }
+
   /**
    * Requests one-time location update and returns the location once it is available, or error.
    *
@@ -338,7 +368,7 @@ export default class HyperTrack {
   /**
    * Sets the availability of the device for the Nearby search
    *
-   * @param availability true when is available or false when unavailable
+   * @param isAvailable true when is available or false when unavailable
    */
   static setIsAvailable(isAvailable: boolean) {
     HyperTrackSdk.setIsAvailable({
@@ -383,6 +413,22 @@ export default class HyperTrack {
     } as Name);
   }
 
+  /**
+   * A primary identifier that uniquely identifies the worker outside of HyperTrack.
+   * Example: email, phone number, database id
+   * It is usually obtained and set when the worker logs into the app.
+   * Set it to an empty string "" when the worker logs out of the app to un-bind the device from the worker and
+   * avoid unintentional tracking.
+   *
+   * @param {string} workerHandle
+   */
+  static setWorkerHandle(workerHandle: string) {
+    HyperTrackSdk.setWorkerHandle({
+      type: 'workerHandle',
+      value: workerHandle,
+    } as WorkerHandle);
+  }
+
   /**
    * Subscribe to tracking errors
    *
@@ -493,6 +539,29 @@ export default class HyperTrack {
     );
   }
 
+  /**
+   * Subscribe to changes in the orders assigned to the worker
+   *
+   * @param listener
+   * @returns EmitterSubscription
+   * @example
+   * ```js
+   * const subscription = HyperTrack.subscribeToOrders(orders => {
+   *   ...
+   * })
+   *
+   * // later, to stop listening
+   * subscription.remove()
+   * ```
+   */
+  static subscribeToOrders(
+    listener: (orders: Map<string, Order>) => void
+  ): EmitterSubscription {
+    return EventEmitter.addListener(EVENT_ORDERS, (orders: OrdersInternal) => {
+      listener(this.deserializeOrders(orders));
+    });
+  }
+
   /** @ignore */
   private static deserializeDynamicPublishableKey(
     dynamicPublishableKey: DynamicPublishableKey
@@ -523,6 +592,24 @@ export default class HyperTrack {
     return res;
   }
 
+  /** @ignore */
+  private static deserializeIsInsideGeofence(
+    isInsideGeofence: Result<boolean, LocationErrorInternal>
+  ): Result<boolean, LocationError> {
+    switch (isInsideGeofence.type) {
+      case 'success':
+        return {
+          type: 'success',
+          value: isInsideGeofence.value,
+        };
+      case 'failure':
+        return {
+          type: 'failure',
+          value: this.deserializeLocationError(isInsideGeofence.value),
+        };
+    }
+  }
+
   /** @ignore */
   private static deserializeLocateResponse(
     response: Result<LocationInternal, HyperTrackErrorInternal[]>
@@ -617,6 +704,31 @@ export default class HyperTrack {
     return name.value;
   }
 
+  /** @ignore */
+  private static deserializeOrders(orders: OrdersInternal): Map<string, Order> {
+    if (orders.type !== 'orders') {
+      throw new Error(`Invalid orders: ${JSON.stringify(orders)}`);
+    }
+    let result = new Map<string, Order>();
+    Object.entries(orders.value)
+      .map(([_, value]: [string, OrderInternal]) => {
+        return value;
+      })
+      .sort(
+        (first: OrderInternal, second: OrderInternal) =>
+          first.index - second.index
+      )
+      .forEach((orderInternal: OrderInternal) => {
+        result.set(orderInternal.orderHandle, {
+          orderHandle: orderInternal.orderHandle,
+          isInsideGeofence: this.deserializeIsInsideGeofence(
+            orderInternal.isInsideGeofence
+          ),
+        } as Order);
+      });
+    return result;
+  }
+
   /** @ignore */
   private static isLocation(obj: Location): obj is Location {
     return (

package/src/HyperTrack/data_types/Order.ts

@@ -0,0 +1,7 @@
+import type { Result } from './Result';
+import type { LocationError } from './LocationError';
+
+export type Order = {
+  orderHandle: string;
+  isInsideGeofence: Result<boolean, LocationError>;
+};

package/src/HyperTrack/data_types/internal/OrderInternal.ts

@@ -0,0 +1,8 @@
+import type { Result } from '../Result';
+import type { LocationErrorInternal } from './LocationErrorInternal';
+
+export type OrderInternal = {
+  orderHandle: string;
+  isInsideGeofence: Result<boolean, LocationErrorInternal>;
+  index: number;
+};

package/src/HyperTrack/data_types/internal/OrdersInternal.ts

@@ -0,0 +1,4 @@
+export type OrdersInternal = {
+  type: 'orders';
+  value: object;
+};

package/src/HyperTrack/data_types/internal/WorkerHandle.ts

@@ -0,0 +1,4 @@
+export type WorkerHandle = {
+  type: 'workerHandle';
+  value: string;
+};

package/src/index.tsx

@@ -1,14 +1,17 @@
 import HyperTrack from './HyperTrack/HyperTrack';
 export default HyperTrack;
 export { HyperTrack };
-
 export { HyperTrackError } from './HyperTrack/data_types/HyperTrackError';
-export {
+export type {
   NotRunning,
   Starting,
 } from './HyperTrack/data_types/internal/LocationErrorInternal';
-export { LocationError, Errors } from './HyperTrack/data_types/LocationError';
-export { LocationWithDeviation } from './HyperTrack/data_types/LocationWithDeviation';
-export { Location } from './HyperTrack/data_types/Location';
-export { Result, Success, Failure } from './HyperTrack/data_types/Result';
-export { OrderStatus } from './HyperTrack/data_types/OrderStatus';
+export type {
+  LocationError,
+  Errors,
+} from './HyperTrack/data_types/LocationError';
+export type { LocationWithDeviation } from './HyperTrack/data_types/LocationWithDeviation';
+export type { Location } from './HyperTrack/data_types/Location';
+export type { Order } from './HyperTrack/data_types/Order';
+export type { OrderStatus } from './HyperTrack/data_types/OrderStatus';
+export type { Result, Success, Failure } from './HyperTrack/data_types/Result';