@situm/react-native 3.0.10 → 3.1.0

package/src/wayfinding/store/index.tsx

@@ -4,15 +4,12 @@ import React, { createContext, type MutableRefObject, useReducer } from "react";
 import {
   type Building,
   type Directions,
+  type Error,
   type Location,
+  type NavigationProgress,
   type Poi,
-  type SDKError,
-  type SDKNavigation,
 } from "../../sdk/types";
-import {
-  LocationStatusName,
-  NavigationStatus,
-} from "../../sdk/types/constants";
+import { LocationStatusName } from "../../sdk/types/constants";
 import { useSitumInternal } from "../hooks";
 import { createStore } from "./utils";
 
@@ -30,9 +27,10 @@ export interface State {
   currentBuilding: Building;
   pois: Poi[];
   directions?: Directions;
-  navigation?: SDKNavigation;
+  navigation?: NavigationProgress;
   destinationPoiID?: number;
-  error?: SDKError;
+  error?: Error;
+  buildingIdentifier: string;
 }
 
 export const initialState: State = {
@@ -44,9 +42,10 @@ export const initialState: State = {
   currentBuilding: undefined,
   pois: [],
   directions: undefined,
-  navigation: { status: NavigationStatus.STOP },
+  navigation: undefined,
   destinationPoiID: undefined,
   error: undefined,
+  buildingIdentifier: "-1",
 };
 
 export const SitumContext = createContext<
@@ -98,6 +97,12 @@ const store = createStore<State>({
     setError: (state: State, payload: State["error"]) => {
       return { ...state, error: payload };
     },
+    setBuildingIdentifier: (
+      state: State,
+      payload: State["buildingIdentifier"]
+    ) => {
+      return { ...state, buildingIdentifier: payload };
+    },
   },
 });
 
@@ -149,6 +154,10 @@ export const selectError = (state: State) => {
   return state.error;
 };
 
+export const selectBuildingIdentifier = (state: State) => {
+  return state.buildingIdentifier;
+};
+
 export const {
   setWebViewRef,
   setSdkInitialized,
@@ -163,6 +172,7 @@ export const {
   setNavigation,
   setDestinationPoiID,
   setError,
+  setBuildingIdentifier,
 } = store.actions;
 
 /**

package/src/wayfinding/types/index.ts

@@ -1,4 +1,6 @@
-import type { DirectionPoint, Poi } from "../../sdk/types";
+import { AccessibilityMode } from "src/sdk";
+
+import type { Point } from "../../sdk/types";
 import { ErrorName } from "./constants";
 
 export interface MapViewError {
@@ -8,7 +10,26 @@ export interface MapViewError {
 
 export interface MapViewRef {
   selectPoi: (poiId: number) => void;
-  navigateToPoi: ({ poi, poiId }: { poi?: Poi; poiId?: number }) => void;
+  navigateToPoi: ({
+    identifier,
+    accessibilityMode = AccessibilityMode.CHOOSE_SHORTEST,
+  }: {
+    identifier: number;
+    accessibilityMode?: AccessibilityMode;
+  }) => void;
+  navigateToPoint: ({
+    lat,
+    lng,
+    floorIdentifier,
+    navigationName,
+    accessibilityMode = AccessibilityMode.CHOOSE_SHORTEST,
+  }: {
+    lat: number;
+    lng: number;
+    floorIdentifier: string;
+    navigationName?: string;
+    accessibilityMode?: AccessibilityMode;
+  }) => void;
   cancelNavigation: () => void;
 }
 
@@ -18,17 +39,13 @@ export interface WayfindingResult {
 }
 
 export interface OnPoiSelectedResult {
-  buildingId: string;
-  buildingName: string;
-  floorId: string;
-  floorName: string;
-  poiId: string;
-  poiName: string;
+  identifier: string;
+  buildingIdentifier: string;
 }
 
 export interface OnPoiDeselectedResult {
-  buildingId: string;
-  buildingName: string;
+  identifier: string;
+  buildingIdentifier: string;
 }
 
 export interface OnFloorChangedResult {
@@ -44,7 +61,7 @@ export interface Destination {
   category: string;
   identifier?: string;
   name?: string;
-  point: DirectionPoint;
+  point: Point;
 }
 
 export interface Navigation {
@@ -53,11 +70,28 @@ export interface Navigation {
 }
 
 export interface OnNavigationResult {
-  navigation: Navigation;
+  navigation?: Navigation;
   error?: Error;
 }
 
-export type NavigateToPoiType = {
-  navigationTo: number;
-  type?: string;
+export type NavigateToPoiPayload = {
+  identifier: number;
+  accessibilityMode?: AccessibilityMode;
+};
+
+export type NavigateToPointPayload = {
+  lat: number;
+  lng: number;
+  floorIdentifier: string;
+  navigationName?: string;
+  accessibilityMode?: AccessibilityMode;
+};
+
+export type DirectionsMessage = {
+  buildingIdentifier: string;
+  originIdentifier: string;
+  originCategory: string;
+  destinationIdentifier: string;
+  destinationCategory: string;
+  identifier: string;
 };

package/src/wayfinding/utils/mapper.ts

@@ -1,18 +1,102 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
+import { AccessibilityMode } from "../../sdk";
 import type {
-  DirectionPoint,
   Directions,
+  DirectionsRequest,
   Location,
-  SDKNavigation,
+  NavigationProgress,
+  NavigationRequest,
+  Point,
 } from "../../sdk/types";
-import type { Destination, NavigateToPoiType, Navigation } from "../types";
+import type {
+  DirectionsMessage,
+  NavigateToPointPayload,
+  NavigateToPoiPayload,
+  Navigation,
+  OnNavigationResult,
+} from "../types";
+
+export const createPoint = (payload: any): Point => {
+  return {
+    buildingIdentifier: payload.buildingIdentifier,
+    floorIdentifier: payload.floorIdentifier,
+    cartesianCoordinate: payload.cartesianCoordinate,
+    coordinate: payload.coordinate,
+  };
+};
 
-const mapperWrapper = (type: string, payload: unknown) =>
-  JSON.stringify({ type, payload });
+export const createDirectionsMessage = (payload: any): DirectionsMessage => {
+  return {
+    buildingIdentifier: payload.buildingIdentifier,
+    originIdentifier: (payload.originIdentifier || -1).toString(),
+    originCategory: payload.originCategory,
+    destinationIdentifier: (payload.destinationIdentifier || -1).toString(),
+    destinationCategory: payload.destinationCategory,
+    identifier: (payload.identifier || "").toString(),
+  };
+};
+
+export const createDirectionsRequest = (payload: any): DirectionsRequest => {
+  return {
+    buildingIdentifier: payload.from.buildingIdentifier,
+    to: createPoint(payload.to),
+    from: createPoint(payload.from),
+    bearingFrom: payload.bearingFrom || 0,
+    accessibilityMode:
+      payload.accessibilityMode || AccessibilityMode.CHOOSE_SHORTEST,
+    minimizeFloorChanges: payload.minimizeFloorChanges || false,
+  };
+};
+
+export const createNavigationRequest = (payload: any): NavigationRequest => {
+  const navigationRequest = {
+    distanceToGoalThreshold: payload.distanceToGoalThreshold,
+    outsideRouteThreshold: payload.outsideRouteThreshold,
+    distanceToIgnoreFirstIndication: payload.distanceToIgnoreFirstIndication,
+    distanceToFloorChangeThreshold: payload.distanceToFloorChangeThreshold,
+    distanceToChangeIndicationThreshold:
+      payload.distanceToChangeIndicationThreshold,
+    indicationsInterval: payload.indicationsInterval,
+    timeToFirstIndication: payload.timeToFirstIndication,
+    roundIndicationsStep: payload.roundIndicationsStep,
+    timeToIgnoreUnexpectedFloorChanges:
+      payload.timeToIgnoreUnexpectedFloorChanges,
+    ignoreLowQualityLocations: payload.ignoreLowQualityLocations,
+  };
+
+  return Object.fromEntries(
+    Object.entries(navigationRequest || {}).filter(
+      ([_, value]) => value !== undefined
+    )
+  );
+};
+
+const mapperWrapper = (type: string, payload: unknown) => {
+  return JSON.stringify({ type, payload });
+};
 
-const Mapper = {
-  location: (location: Location) =>
-    mapperWrapper("location.update", {
+const ViewerMapper = {
+  // Configuration
+  followUser: (follow: boolean) => {
+    return mapperWrapper("camera.follow_user", follow);
+  },
+  setLanguage: (lang: string) => {
+    return mapperWrapper("ui.set_language", lang);
+  },
+  initialConfiguration: (style: any) => {
+    return mapperWrapper("ui.initial_configuration", {
+      ...(style && {
+        style: style,
+      }),
+    });
+  },
+  // Cartography
+  selectPoi: (poiId: number | null) => {
+    return mapperWrapper(`cartography.select_poi`, { identifier: poiId });
+  },
+  // Location
+  location: (location: Location) => {
+    return mapperWrapper("location.update", {
       ...(location.position && {
         latitude: location.position.coordinate.latitude,
         longitude: location.position.coordinate.longitude,
@@ -27,106 +111,63 @@ const Mapper = {
         hasBearing: location.hasBearing,
       }),
       status: location.status,
-    }),
-  locationStatus: (locationStatus: Location["status"]) =>
-    mapperWrapper("location_status.update", locationStatus),
-
-  route: (directions: Directions) =>
-    mapperWrapper("directions.update", directions),
-
-  navigation: (navigation: Navigation) =>
-    mapperWrapper(`navigation.${navigation.status}`, navigation),
-
-  navigateToPoi: (navigate: NavigateToPoiType) =>
-    mapperWrapper(`navigation.start`, { navigationTo: navigate?.navigationTo }),
-
-  cancelNavigation: () => mapperWrapper(`navigation.cancel`, {}),
-
-  selectPoi: (poiId: number | null) =>
-    mapperWrapper(`cartography.select_poi`, { identifier: poiId }),
-
-  followUser: (follow: boolean) => mapperWrapper("camera.follow_user", follow),
-  setLanguage: (lang: string) => mapperWrapper("ui.set_language", lang),
-
-  initialConfiguration: (
-    style: any,
-    enablePoiClustering: any,
-    showPoiNames: any,
-    minZoom: any,
-    maxZoom: any,
-    initialZoom: any,
-    useDashboardTheme: any
-  ) =>
-    mapperWrapper("ui.initial_configuration", {
-      ...(style && {
-        style: style,
-      }),
-      ...(enablePoiClustering && {
-        enablePoiClustering: enablePoiClustering,
-      }),
-      ...(showPoiNames && {
-        showPoiNames: showPoiNames,
-      }),
-      ...(minZoom && {
-        minZoom: minZoom,
-      }),
-      ...(maxZoom && {
-        maxZoom: maxZoom,
-      }),
-      ...(initialZoom && {
-        initialZoom: initialZoom,
-      }),
-      ...(useDashboardTheme && {
-        useDashboardTheme: useDashboardTheme,
-      }),
-    }),
-
-  routeToResult: (navigation: any): Navigation => {
-    //console.log('navigation/route to be mapped:', navigation);
+    });
+  },
+  locationStatus: (locationStatus: Location["status"]) => {
+    return mapperWrapper("location_status.update", locationStatus);
+  },
+  // Directions
+  route: (directions: Directions) => {
+    return mapperWrapper("directions.update", directions);
+  },
+  routeToResult: (route: any): OnNavigationResult => {
     return {
-      status: navigation.status,
-      destination: {
-        category: navigation?.destinationId ? "POI" : "COORDINATE",
-        identifier: navigation?.destinationId,
-        //name:, //TODO
-        point: {
-          buildingIdentifier:
-            navigation.to.buildingIdentifier ||
-            navigation.TO.buildingIdentifier,
-          floorIdentifier:
-            navigation.to.floorIdentifier || navigation.TO.floorIdentifier,
-          coordinate: {
-            latitude:
-              navigation.to.coordinate.latitude ||
-              navigation.TO.coordinate.latitude,
-            longitude:
-              navigation.to.coordinate.longitude ||
-              navigation.TO.coordinate.longitude,
-          },
-        } as DirectionPoint,
-      } as Destination,
-    } as Navigation;
+      navigation: {
+        status: route.status,
+        destination: {
+          category: route?.destinationId ? "POI" : "COORDINATE",
+          identifier: route?.destinationId,
+          //name:, //TODO
+          point: route.to ? createPoint(route.to) : createPoint(route.TO),
+        },
+      },
+    };
   },
-
-  navigationToResult: (navigation: SDKNavigation): Navigation => {
+  // Navigation
+  navigation: (navigation: Navigation) => {
+    return mapperWrapper(`navigation.${navigation.status}`, navigation);
+  },
+  navigateToPoi: (navigate: NavigateToPoiPayload) => {
+    return mapperWrapper(`navigation.start`, {
+      navigationTo: navigate?.identifier,
+      type: navigate.accessibilityMode,
+    });
+  },
+  navigateToPoint: ({
+    lat,
+    lng,
+    floorIdentifier,
+    navigationName,
+    accessibilityMode,
+  }: NavigateToPointPayload) => {
+    return mapperWrapper(`navigation.start`, {
+      lat,
+      lng,
+      floorIdentifier,
+      navigationName,
+      type: accessibilityMode,
+    });
+  },
+  cancelNavigation: () => {
+    return mapperWrapper(`navigation.cancel`, {});
+  },
+  navigationToResult: (navigation: NavigationProgress): OnNavigationResult => {
     return {
-      status: navigation?.type,
+      navigation: {
+        status: navigation?.type,
+      },
     };
-    // return {
-    //   status: navigation.status,
-    //   destination: {
-    //     category: navigation.routeStep.TO.destinationId ? 'POI' : 'COORDINATE',
-    //     identifier: navigation.routeStep.TO.destinationId,
-    //     //name:, //TODO
-    //     point: {
-    //       buildingId: navigation.routeStep.TO.buildingIdentifier,
-    //       floorId: navigation.routeStep.TO.floorIdentifier,
-    //       latitude: navigation.routeStep.TO.coordinate.latitude,
-    //       longitude: navigation.routeStep.TO.coordinate.longitude,
-    //     } as Point,
-    //   } as Destination,
-    // } as Navigation;
   },
 };
 
-export default Mapper;
+export default ViewerMapper;