@de./sdk-rn 1.0.0

package/src/backend/Auth.ts

@@ -0,0 +1,112 @@
+import type { AuthCredentials, AuthOptions, AuthRequestOptions } from '../types/auth'
+
+const ACCESS_TOKEN_EXPIRY = 3.75 // in 3 minutes 45 seconds
+
+type AuthResponse = {
+  error: boolean
+  message: string
+  token: string
+}
+
+export default class Auth {
+  private version: number
+  protected creds: AuthCredentials
+  private expiryTime?: any
+  private autorefresh?: boolean
+  private baseURL: string
+  public accessToken?: string
+
+  constructor( creds: AuthCredentials, options?: AuthOptions ){
+    if( !creds ) throw new Error('Undefined Credentials. Check https://doc.dedot.io/sdk/auth')
+    if( !creds.workspace ) throw new Error('Undefined Workspace Reference. Check https://doc.dedot.io/sdk/auth')
+    if( !creds.remoteOrigin ) throw new Error('Undefined Remote Origin. Check https://doc.dedot.io/sdk/auth')
+    if( !creds.cid ) throw new Error('Undefined Connector ID. Check https://doc.dedot.io/sdk/auth')
+    if( !creds.secret ) throw new Error('Undefined Connector Secret. Check https://doc.dedot.io/sdk/auth')
+
+    this.creds = creds
+    this.version = options?.version || 1
+    this.baseURL = options?.env === 'prod' ? 'https://api.dedot.io' : 'http://api.dedot.io:24800'
+    this.autorefresh = options?.autorefresh || false
+  }
+
+  private async request<T>( options: AuthRequestOptions ): Promise<T>{
+    const rawOptions: any = {
+      method: 'GET',
+      headers: {
+        /**
+         * Default User agent for SDK request calls
+         * 
+         * NOTE: Later replace by latest SDK version
+         */
+        'origin': this.creds.remoteOrigin,
+        'x-user-agent': `De.remote/${this.version}.0`
+      }
+    }
+
+    if( this.accessToken )
+      rawOptions.headers.authorization = `Bearer ${this.accessToken}`
+
+    if( options.body )
+      rawOptions.headers['content-type'] = 'application/json'
+
+    options = { ...rawOptions, ...options }
+    if( !options.url )
+      throw new Error('Undefined request <url>')
+
+    console.log('Auth request', `${this.baseURL}/v${this.version}/${options.url.replace(/^\//, '')}`, options )
+    
+    const response = await fetch(`${this.baseURL}/v${this.version}/${options.url.replace(/^\//, '')}`, options )
+    
+    return await response.json() as T
+  }
+
+  async getToken(): Promise<string>{
+    const
+    { workspace, cid, secret } = this.creds,
+    options: AuthRequestOptions = {
+      url: '/access/token',
+      method: 'POST',
+      body: this.creds
+    },
+    { error, message, token } = await this.request<AuthResponse>( options )
+    if( error ) throw new Error( message )
+
+    // Set auto-refresh token every 4 mins
+    if( this.autorefresh ){
+      clearTimeout( this.expiryTime )
+      this.expiryTime = setTimeout( () => this.rotateToken(), ACCESS_TOKEN_EXPIRY * 60 * 1000 )
+    }
+    
+    this.accessToken = token
+    return token
+  }
+
+  async rotateToken(){
+    if( !this.accessToken )
+      throw new Error('No access token found')
+
+    try {
+      const
+      options: AuthRequestOptions = {
+        url: '/access/token/rotate',
+        method: 'PATCH',
+        body: { secret: this.creds.secret }
+      },
+      { error, message, token } = await this.request<AuthResponse>( options )
+      if( error ) throw new Error( message )
+
+      // Set auto-refresh token every 4 mins
+      if( this.autorefresh ){
+        clearTimeout( this.expiryTime )
+        this.expiryTime = setTimeout( () => this.rotateToken(), ACCESS_TOKEN_EXPIRY * 60 * 1000 )
+      }
+      
+      this.accessToken = token
+      return token
+    }
+    catch( error: any ){
+      console.error(`Refresh access token failed: ${error.message}`)
+      return await this.getToken() // Get new token instead
+    }
+  }
+}

package/src/index.ts

@@ -0,0 +1,18 @@
+import Utils from './utils'
+import MSI from './allend/MSI'
+import Auth from './backend/Auth'
+import Order from './allend/DClient/Order'
+import Event from './allend/DClient/Event'
+import Client from './allend/DClient/Client'
+
+// export const Auth = _Auth
+// export const MSI = _MSI
+// export const Utils = _Utils
+const DClient = { Client, Order, Event }
+
+export {
+  Auth,
+  MSI,
+  Utils,
+  DClient
+}

package/src/types/access.d.ts

@@ -0,0 +1,7 @@
+export type AccessOptions = {
+  env?: 'dev' | 'prod'
+  version?: number
+  workspace: string
+  accessToken: string
+  remoteOrigin?: string
+}

package/src/types/auth.d.ts

@@ -0,0 +1,26 @@
+export type AuthOptions = {
+  env?: 'dev' | 'prod'
+  version?: number
+  autorefresh?: boolean
+}
+
+export type AuthCredentials = {
+  workspace: string
+  remoteOrigin: string
+  cid: string
+  secret: string
+}
+
+export type SocketAuthCredentials = {
+  utype: string
+  id: string
+  remoteOrigin: string
+  accessToken: string
+}
+
+export type AuthRequestOptions = {
+  url: string
+  method: 'GET' | 'POST' | 'PATCH' | 'PUT' | 'DELETE'
+  headers?: { [index: string]: string }
+  body?: any
+}

package/src/types/index.d.ts

@@ -0,0 +1,275 @@
+export type HTTPRequestOptions = {
+  url: string
+  method: 'GET' | 'POST' | 'PATCH' | 'PUT' | 'DELETE'
+  headers?: { [index: string]: string }
+  body?: any
+}
+export type HTTPResponse = {
+  error: boolean
+  message?: string
+}
+
+export type LngLat = [number, number]
+export type Coordinates = {
+  lng: number
+  lat: number
+}
+export type PickedLocation = {
+  point: {
+    x: number,
+    y: number
+  }
+  coordinates: Coordinates
+}
+export type GPSLocation = Coordinates & {
+  heading?: number
+}
+export type ActivePosition = {
+  id: string
+  position: GPSLocation
+  caption?: Caption
+}
+
+/**
+ * Configuration options for AnimatedPolyline
+ */
+export type AnimatedRouteNativePathType = 'dot' | 'solid'
+export type AnimatedRouteNativeMethods = 'dot:flow'
+                                          | 'dot:fade'
+                                          | 'dot:pulse'
+                                          | 'dot:directional'
+                                          | 'solid:flow'
+                                          | 'solid:fade'
+                                          | 'solid:pulse'
+                                          | 'solid:directional'
+export interface AnimatedRouteRules {
+  styles?: any;
+  speed?: number; // pixels per frame
+  fadeLength?: number; // length of fade effect in pixels
+}
+export interface AnimatedRoute {
+  key: number | null
+  currentOffset: number
+  rules: Required<AnimatedRouteRules>
+  startTime?: number;
+  polyline?: any
+  engine: any
+  path: Coordinates[]
+
+  /**
+   * Create the polyline
+   */
+  create( pathType?: AnimatedRouteNativePathType ): void;
+
+  /**
+   * Animation methods
+   */
+  apply: Record<string, () => void>;
+
+  /**
+   * Stop the current animation
+   */
+  stop(): void;
+
+  /**
+   * Remove the polyline from the map and stop animation
+   */
+  remove(): void;
+}
+export type AnimatedRouteOptions = AnimatedRouteNativeMethods | {
+  handler?: new (engine: Engine, path: Coordinates[], rules?: AnimatedRouteRules) => AnimatedRoute
+  method?: string
+  rules?: AnimatedRouteRules
+}
+
+export type Journey = {
+  routeId: string | number
+  origin?: MapWaypoint
+  destination?: MapWaypoint
+  waypoints?: MapWaypoint[]
+  options?: RouteOptions
+}
+export type ActiveDirection = {
+  routeId: string | number
+  profile: string
+  origin?: Coordinates
+  destination?: Coordinates
+  waypoints: Coordinates[]
+  route: any
+}
+export type RouteOptions = {
+  id?: string | number
+  mode?: 'default' | 'navigation'
+  profile?: 'driving-traffic' | 'driving' | 'cycling' | 'biking' | 'walking' | 'transit'
+  unit?: 'metric' | 'imperial',
+  preference?: 'TRAFFIC_AWARE' | 'TRAFFIC_UNAWARE'
+  pointless?: boolean
+  styles?: any
+  animation?: AnimatedRouteOptions
+}
+
+export type SearchPlace = {
+  name: string
+  location: Coordinates,
+  address: string
+}
+
+export type Waypoint = {
+  no: number
+  type: 'pickup' | 'dropoff'
+  description: string
+  coordinates: Coordinates
+  address?: string
+  contact: {
+    type: string
+    reference: string
+    phone?: string
+    email?: string
+  }
+}
+export type WaypointIndex = 'origin' | 'destination' | number
+export type WaypointOptions = {
+  no?: number
+  type?: 'pickup' | 'dropoff'
+  description?: string
+  coordinates?: Coordinates
+  address?: string
+  'contact.type'?: string
+  'contact.reference'?: string
+  'contact.phone'?: string
+  'contact.email'?: string
+}
+
+export type Package = {
+  waypointNo: number
+  careLevel: number
+  category: string
+  weight: number
+  note?: string
+}
+export type PackageOptions = {
+  waypointNo?: number
+  careLevel?: number
+  category?: string
+  weight?: number
+  note?: string
+}
+
+export type PaymentMode = 'cash' | 'card' | 'momo' | 'wigo'
+export type OrderService = {
+  fees: {
+    total: {
+      amount: number
+      currency: string
+    },
+    tax: number
+    discount: number
+  }
+  payment: {
+    mode: PaymentMode
+    paid: boolean
+  }
+  xpress: string
+}
+export type OrderServiceOptions = {
+  'fees.total.amount'?: number
+  'fees.total.currency'?: string
+  'fees.tax'?: string
+  'fees.discount'?: string
+  'payment.mode'?: PaymentMode
+  'payment.option'?: string
+  'payment.paid'?: boolean
+  xpress?: string
+}
+export type OrderOperator = {}
+export type OrderStage = {
+  current: string
+  status: string
+}
+
+export type Message = {
+  type: 'text' | 'location' | 'media'
+  sender: string
+  content: string
+  timestamp: string
+}
+export type Caption = {
+	duration?: number
+	unit?: string
+	label?: string
+}
+export type Peer = {
+  utype: string
+  id: string
+}
+
+export type MapOptions = {
+  element: string
+  accessToken: string
+  version?: number
+  env?: 'dev' | 'prod'
+}
+export type MapLayerStyle = 'streets' | 'outdoors' | 'light' | 'dark' | 'satellite'
+export type MapWaypoint = {
+  index?: number
+  coords: Coordinates
+  caption?: Caption
+}
+
+export type Entity = {
+  id: string
+  status: 'ACTIVE' | 'BUSY'
+  grade: '1H' | '2H' | '3H'
+  currentLocation: GPSLocation
+  static?: boolean
+  type: 'moto' | 'car' | 'bike' | 'truck' | 'plane' | 'ship' | 'restaurant' | 'hotel' | 'store' | 'office' | 'warehouse'
+}
+export type EntitySpecs = {
+  id: string
+  status: 'ACTIVE' | 'BUSY'
+  grade: '1H' | '2H' | '3H'
+  currentLocation: GPSLocation
+  static?: boolean
+  type: 'moto' | 'car' | 'bike' | 'truck' | 'plane' | 'ship' | 'restaurant' | 'hotel' | 'store' | 'office' | 'warehouse'
+}
+
+export interface UserLocationOptions {
+  // Base point styling options
+  borderRadius?: number
+  borderColor?: string
+  borderOpacity?: number
+  dotColor?: string
+  showInnerDot?: boolean
+  noRing?: boolean
+  
+  // User location specific options
+  showDirectionArrow?: boolean
+  arrowColor?: string
+  arrowSize?: number
+  pulseAnimation?: boolean
+  accuracyCircle?: boolean
+  accuracyColor?: string
+  accuracyOpacity?: number
+  
+  // Callbacks
+  onLocationUpdate?: ( location: GPSLocation ) => void
+  onLocationError?: ( error: GeolocationPositionError ) => void
+}
+export type DragPickOptions = {
+  snapToRoad?: boolean
+  pinPoints?: boolean
+  pointOptions?: CustomPointOptions
+}
+export type DragPickContentType = 'duration' | 'distance' | 'preloader'
+export type DragPickContent = {
+  time?: number
+  unit?: 'min' | 'sec' | 'hr' | 'km' | 'mi' | 'm'
+  distance?: number
+  preloader?: boolean
+}
+export type DragPickEvent = 'dragstart' | 'dragend' | 'zoom_changed' | 'idle'
+export interface DragPickInterface {
+  enable( origin?: Coordinates ): void
+  disable(): void
+  content( type: DragPickContentType, content: DragPickContent ): void
+}

package/src/utils/index.ts

@@ -0,0 +1,4 @@
+
+import Stream from './stream'
+
+export default { Stream }

package/src/utils/stream.ts

@@ -0,0 +1,68 @@
+
+export type StreamDataListener = ( data: string ) => void
+
+export default class Stream {
+  private _STALED: boolean = false
+  private _CLOSED: boolean = false
+  private _fns: StreamDataListener[] = []
+  private _exitFn = (() => {})
+  private _errorFn = (( error: Error ) => {})
+  private _downStream?: Stream
+  private _upStream?: Stream
+
+  private _upstream( stream: Stream ){
+    this._upStream = stream
+    return this
+  }
+  private _backpressure( data: any ){
+    !this._CLOSED && this._fns.map( fn => fn( data ) )
+  }
+
+  sync( data: any ){
+    !this._CLOSED && this._downStream?._backpressure( data )
+  }
+
+  on( _event: 'data', fn: StreamDataListener ){
+    if( this._CLOSED ) throw new Error('Stream closed')
+
+    this._fns.push( fn )
+    return this
+  }
+
+  pipe( stream: Stream ){
+    stream._upstream( this )
+    this._downStream = stream
+    return this
+  }
+
+  error( error: Error | string  ){
+    // Throw error to self
+    this._errorFn( typeof error == 'string' ? new Error( error ) :  error )
+    // Throw error to downstream pipe
+    this._downStream?.error( error )
+    
+    return this
+  }
+
+  close(){
+    if( this._CLOSED ) return
+    this._CLOSED = true
+
+    this._fns = []
+    this._exitFn()
+
+    this._downStream?.close() // Close down streams
+    // this._upStream?.close() // Close up streams: Recursive loop call effect
+  }
+
+  isActive(){ return !this._CLOSED }
+  
+  onerror( fn: ( error: Error ) => void ){
+    this._errorFn = fn
+    return this
+  }
+  onclose( fn: () => void ){ 
+    this._exitFn = fn
+    return this
+  }
+}