react-native-pointr 9.1.0 → 9.3.1

package/ios/PTRNativeLibrary.swift

@@ -1,4 +1,3 @@
-import Foundation
 import PointrKit
 import React
 
@@ -6,6 +5,7 @@ import React
     func onPositionManagerCalculatedLocation(location: [String: Any])
     func onBuildingClicked(_ building: [String: Any])
     func onSiteClicked(_ site: [String: Any])
+    func onGeofenceEvent(_ geofenceEvent: [String: Any])
 }
 
 @objc(PTRNativePointrLibrary)
@@ -22,25 +22,28 @@ class PTRNativeLibrary: RCTEventEmitter, PTREventManagerDelegate {
     var ptrMapWidget: PTRMapWidgetViewController? = nil
     
     
-    static var configuration: Dictionary<String,Any>? = nil
-    static var mapWidgetConfiguration: PTRMapWidgetConfiguration {
-        let mapWidgetConfiguration = PTRMapWidgetConfiguration.defaultConfiguration()
-        guard let configuration else {
-            return mapWidgetConfiguration
-        }
-        let mirror = Mirror(reflecting: mapWidgetConfiguration)
-        for attr in mirror.children {
-            guard let key = attr.label else {
-                continue
+    static var configuration: Dictionary<String,Any>? = nil {
+        didSet {
+            guard let configuration else {
+                return
             }
-            // only set boolean values
-            guard let value = configuration[key] as? Bool, attr.value is Bool else {
-                continue
+            let mirror = Mirror(reflecting: mapWidgetConfiguration)
+            for attr in mirror.children {
+                guard let key = attr.label else {
+                    continue
+                }
+                // only set boolean values
+                guard let value = configuration[key] as? Bool, attr.value is Bool else {
+                    continue
+                }
+                mapWidgetConfiguration.setValue(value, forKey: key)
             }
-            mapWidgetConfiguration.setValue(value, forKey: key)
         }
-        return mapWidgetConfiguration
     }
+    
+    @objc public
+    static var mapWidgetConfiguration: PTRMapWidgetConfiguration = PTRMapWidgetConfiguration.defaultConfiguration()
+    
     private var dispatchGroupSiteManager = [DispatchGroup]()
     var rootViewController: UIViewController? = nil
     var isRouteFooterViewEnabled = true
@@ -48,6 +51,11 @@ class PTRNativeLibrary: RCTEventEmitter, PTREventManagerDelegate {
     override init() {
         super.init()
         self.eventManagerDelegate = self
+        guard let permissionManager = Pointr.shared.permissionManager else {
+            print("EDIP - Pointr permission manager not available")
+            return
+        }
+        permissionManager.delegate = self
     }
     
     override static func requiresMainQueueSetup() -> Bool {
@@ -55,7 +63,7 @@ class PTRNativeLibrary: RCTEventEmitter, PTREventManagerDelegate {
     }
     
     override func supportedEvents() -> [String]! {
-        return ["OnPositionManagerCalculatedLocation", "OnBuildingClicked", "OnSiteClicked"]
+        return ["OnPositionManagerCalculatedLocation", "OnBuildingClicked", "OnSiteClicked", "OnGeofenceEvent"]
     }
     
     override func startObserving() {
@@ -98,6 +106,48 @@ class PTRNativeLibrary: RCTEventEmitter, PTREventManagerDelegate {
         return dictionary
     }
     
+    // Converts a PTRGeofenceEvent object to [String: Any] dictionary by extracting its explicit fields
+    func convertGeofenceEventToDict(_ geofenceEvent: PTRGeofenceEvent) -> [String: Any] {
+        var dictionary = [String: Any]()
+        
+        // Event type
+        let typeString = geofenceEvent.type == .enter ? "enter" : "exit"
+        dictionary.updateValue(typeString, forKey: "eventType")
+        
+        // Event date (convert to milliseconds)
+        dictionary.updateValue(geofenceEvent.date.timeIntervalSince1970 * 1000, forKey: "timestamp")
+        
+        // Geofence information
+        var geofenceDict = [String: Any]()
+        geofenceDict.updateValue(geofenceEvent.geofence.identifier, forKey: "id")
+        geofenceDict.updateValue(geofenceEvent.geofence.externalIdentifier, forKey: "externalId")
+        geofenceDict.updateValue(geofenceEvent.geofence.name, forKey: "name")
+        
+        // Geofence type
+        let geofenceTypeString = geofenceEvent.geofence.type == .beacon ? "beacon" : "gps"
+        geofenceDict.updateValue(geofenceTypeString, forKey: "geofenceType")
+        
+        // Geofence position (if available)
+        var positionDict = [String: Any]()
+        let position = geofenceEvent.geofence.position
+        positionDict.updateValue(position.coordinate.latitude, forKey: "latitude")
+        positionDict.updateValue(position.coordinate.longitude, forKey: "longitude")
+        geofenceDict.updateValue(positionDict, forKey: "position")
+        
+        dictionary.updateValue(geofenceDict, forKey: "geofence")
+        
+        // Notification information (if available)
+        if let notification = geofenceEvent.notification {
+            var notificationDict = [String: Any]()
+            notificationDict.updateValue(notification.identifier, forKey: "id")
+            notificationDict.updateValue(notification.message, forKey: "message")
+            notificationDict.updateValue(notification.date.timeIntervalSince1970 * 1000, forKey: "timestamp")
+            dictionary.updateValue(notificationDict, forKey: "geofenceNotification")
+        }
+        
+        return dictionary
+    }
+    
     func getAnimationTypeFromInt(value: Int) -> PTRMapAnimationType {
         switch value {
         case 0:
@@ -146,7 +196,6 @@ class PTRNativeLibrary: RCTEventEmitter, PTREventManagerDelegate {
                           baseUrl: String,
                          logLevel: Int) {
         guard let presentedViewController = RCTPresentedViewController() else { return }
-        Pointr.shared.permissionManager?.delegate = self
         self.rootViewController = presentedViewController
         PTRNativeLibrary.params.mode = PointrDebugMode()
         PTRNativeLibrary.params.loggerLevel = PTRLoggerLevel.init(rawValue: Int32(logLevel)) ?? .error
@@ -169,6 +218,7 @@ class PTRNativeLibrary: RCTEventEmitter, PTREventManagerDelegate {
             dispatchGroup.wait()
             if Pointr.shared.state == .running {
                 Pointr.shared.positioningManager?.addListener(self)
+                Pointr.shared.geofenceManager?.addListener(self)
             }
             callback([getPointrStateStringFromPointrState(state: Pointr.shared.state)])
         }
@@ -176,6 +226,7 @@ class PTRNativeLibrary: RCTEventEmitter, PTREventManagerDelegate {
     
     @objc func stop() {
         Pointr.shared.positioningManager?.removeListener(self)
+        Pointr.shared.geofenceManager?.removeListener(self)
         Pointr.shared.stop()
     }
     
@@ -258,6 +309,23 @@ class PTRNativeLibrary: RCTEventEmitter, PTREventManagerDelegate {
         callback([])
     }
     
+    @objc(getPois:resolver:rejecter:)
+    func getPois(_ siteId: String,
+                 resolver resolve: @escaping RCTPromiseResolveBlock,
+                 rejecter reject: @escaping RCTPromiseRejectBlock) {
+        
+        // Ensure Pointr SDK is initialized
+        guard let site = Pointr.shared.siteManager?.site(withExternalIdentifier: siteId) else {
+            reject("ERROR", "Site not found: \(siteId)", nil)
+            return
+        }
+        // Get all POIs for the site
+        let pois = Pointr.shared.poiManager?.pois(for: site)?.getPoiList() ?? []
+        // Convert POIs to dictionary format (aligned with Kotlin implementation)
+        let poisData = pois.map { return $0.dict }
+        resolve(poisData)
+    }
+
     // MARK: - Event Manager Delegate
     
     func onPositionManagerCalculatedLocation(location: [String : Any]) {
@@ -265,6 +333,11 @@ class PTRNativeLibrary: RCTEventEmitter, PTREventManagerDelegate {
         sendEvent(withName: "OnPositionManagerCalculatedLocation", body: location)
     }
     
+    func onGeofenceEvent(_ geofenceEvent: [String: Any]) {
+        guard hasListeners else { return }
+        sendEvent(withName: "OnGeofenceEvent", body: geofenceEvent)
+    }
+    
     func onBuildingClicked(_ building: [String : Any]) {
         guard hasListeners else { return }
         sendEvent(withName: "OnBuildingClicked", body: building)
@@ -283,6 +356,12 @@ extension PTRNativeLibrary: PTRPositioningManagerDelegate {
     }
 }
 
+extension PTRNativeLibrary: PTRGeofenceManagerDelegate {
+    func onGeofenceManagerGeofenceEvent(_ event: PTRGeofenceEvent) {
+        eventManagerDelegate?.onGeofenceEvent(self.convertGeofenceEventToDict(event))
+    }
+}
+
 // MARK: - PTRExitButtonEventsListener
 extension PTRNativeLibrary: PTRExitButtonEventsListener {
     func exitButtonDidTap() {
@@ -324,14 +403,161 @@ extension PTRNativeLibrary: PTRSiteManagerDelegate {
 // MARK: - PTRPermissionManagerDelegate
 extension PTRNativeLibrary: PTRPermissionManagerDelegate {
     public func permissionManagerShouldRequestLocationAuthorizationPermission() -> Bool {
+        Plogv("Should request location permission: \(PTRNativeLibrary.shouldRequestPermissionsAtStartup)")
         return PTRNativeLibrary.shouldRequestPermissionsAtStartup
     }
     
     public func permissionManagerShouldRequestBluetoothServicesPermission() -> Bool {
+        Plogv("Should request bluetooth permission: \(PTRNativeLibrary.shouldRequestPermissionsAtStartup)")
         return PTRNativeLibrary.shouldRequestPermissionsAtStartup
     }
     
     public func permissionManagerShouldRequestUserNotificationAuthorizationPermission() -> Bool {
+        Plogv("Should request notification permission: \(PTRNativeLibrary.shouldRequestPermissionsAtStartup)")
         return PTRNativeLibrary.shouldRequestPermissionsAtStartup
     }
+    
+    public func permissionManagerShouldRequestCoreMotionAuthorizationPermission(_ permissionManager: any PTRPermissionManagerInterface) -> Bool {
+        Plogv("Should request core motion permission: \(PTRNativeLibrary.shouldRequestPermissionsAtStartup)")
+        return PTRNativeLibrary.shouldRequestPermissionsAtStartup
+    }
+    
+    func permissionManagerShouldRequestLocationAuthorizationPermissionForWhenInUse(_ permissionManager: any PTRPermissionManagerInterface) -> Bool {
+        Plogv("Should request location when in use permission: \(PTRNativeLibrary.shouldRequestPermissionsAtStartup)")
+        return PTRNativeLibrary.shouldRequestPermissionsAtStartup
+    }
+}
+
+extension PTRFeature {
+    public var dict: [String: Any] {
+        var result: [String: Any] = [
+            "identifier": identifier,
+            "externalIdentifier": externalIdentifier,
+            "typeCode": typeCode,
+            "name": name
+        ]
+        if let geometry = geometry {
+            result["geometry"] = geometry.dict
+        }
+        result["attributes"] = attributes.toDict
+        result["position"] = position.dict
+        return result
+    }
+}
+
+extension PTRPosition {
+    public var dict: [String: Any] {
+        var result: [String: Any] = [
+            "lat": coordinate.latitude,
+            "lon": coordinate.longitude,
+            "isValid": isValid(),
+        ]
+        if let site = site {
+            result["sid"] = site.identifier
+        }
+        if let building = building {
+            result["bid"] = building.identifier
+        }
+        if let level = level {
+            result["lvl"] = level.index
+        }
+        return result
+    }
+}
+
+private extension Dictionary where Key == String, Value == Any {
+    var toDict: [String: Any] {
+        var result: [String: Any] = [:]
+        for (key, value) in self {
+            switch value {
+            case let v as Int: result[key] = v
+            case let v as Double: result[key] = v
+            case let v as Bool: result[key] = v
+            case let v as String: result[key] = v
+            case let v as [Any]:
+                result[key] = v.map { ($0 as? [String: Any])?.toDict ?? $0 }
+            case let v as [String: Any]:
+                result[key] = v.toDict
+            default: break
+            }
+        }
+        return result
+    }
+}
+
+extension PTRGeometry {
+    
+    public var typeName : String {
+        switch (type) {
+        case .circle:
+            return "Circle"
+        case .multiLineString:
+            return "MultiLineString"
+        case .multiPoint:
+            return "MultiPoint"
+        case .multiPolygon:
+            return "MultiPolygon"
+        case .point:
+            return "Point"
+        case .polygon:
+            return "Polygon"
+        case .lineString:
+            return "LineString"
+        case .geometryCollection:
+            return "GeometryCollection"
+        @unknown default:
+            return "Unknown"
+        }
+        
+    }
+    
+    public var dict: [String: Any] {
+        // Default type name
+        var result: [String: Any] = ["type": typeName]
+
+        // Handle known geometry subclasses from PointrKit
+        switch self {
+        case let point as PTRGeoPoint:
+            // Single coordinate
+            let coord = point.coordinate
+            result["lat"] = coord.latitude
+            result["lon"] = coord.longitude
+
+        case let line as PTRGeoLineString:
+            // Array of coordinates
+            let coords = line.points.map { $0.dict }
+            result["points"] = coords
+
+        case let polygon as PTRGeoPolygon:
+            // Outer ring + inner rings (holes) if any
+            let exterior = polygon.outer.map { $0.dict }
+            let holes = polygon.inners.map { ring in
+                ring.map { $0.dict }
+            }
+            result["outer"] = exterior
+            result["inners"] = holes
+
+        case let multiPoint as PTRGeoMultiPoint:
+            let coords = multiPoint.points.map { $0.dict }
+            result["points"] = coords
+
+        case let multiLine as PTRGeoMultiLineString:
+            let lines = multiLine.lineStrings.map { line in
+                line.dict
+            }
+            result["lineStrings"] = lines
+
+        case let multiPolygon as PTRGeoMultiPolygon:
+            let polys = multiPolygon.polygons.map { poly in
+                poly.dict
+            }
+            result["polygons"] = polys
+
+        default:
+            // Unknown geometry type; keep only the type string
+            break
+        }
+
+        return result
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-pointr",
-  "version": "9.1.0",
+  "version": "9.3.1",
   "description": "Pointr React-Native Module",
   "main": "src/index",
   "author": " <> ()",
@@ -10,5 +10,19 @@
     "type": "module-legacy",
     "languages": "kotlin-swift",
     "version": "0.41.0"
+  },
+  "peerDependencies": {
+    "react-native": ">=0.64.0",
+    "react": ">=17.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^24.10.1",
+    "react-native": "^0.82.1"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "prepare-dist": "chmod +x prepare-distribution.sh && ./prepare-distribution.sh"
   }
-}
+}

package/prepare-distribution.sh

@@ -0,0 +1,84 @@
+#!/bin/bash
+
+# Script to prepare react-native-pointr package for distribution
+# This script cleans build artifacts, removes git history, and creates a compressed archive
+
+set -e  # Exit on error
+
+PACKAGE_NAME="react-native-pointr"
+VERSION=$(grep -o '"version": "[^"]*"' package.json | head -1 | sed 's/"version": "\(.*\)"/\1/')
+OUTPUT_NAME="${PACKAGE_NAME}-${VERSION}.zip"
+TEMP_DIR="${PACKAGE_NAME}_temp"
+
+echo "🧹 Starting package cleanup and preparation..."
+echo "📌 Package version: ${VERSION}"
+
+# Create a temporary copy of the package
+echo "📦 Creating temporary copy..."
+rsync -a --exclude=".git" \
+         --exclude="node_modules" \
+         --exclude="example" \
+         --exclude=".DS_Store" \
+         --exclude="*.log" \
+         --exclude="prepare-distribution.sh" \
+         ./ "../${TEMP_DIR}/"
+
+cd "../${TEMP_DIR}"
+
+# Clean Android build artifacts
+echo "🤖 Cleaning Android build artifacts..."
+if [ -d "android/build" ]; then
+    rm -rf android/build
+fi
+if [ -d "android/.gradle" ]; then
+    rm -rf android/.gradle
+fi
+
+# Clean iOS build artifacts
+echo "🍎 Cleaning iOS build artifacts..."
+if [ -d "ios/build" ]; then
+    rm -rf ios/build
+fi
+if [ -d "ios/Pods" ]; then
+    rm -rf ios/Pods
+fi
+if [ -f "ios/Podfile.lock" ]; then
+    rm -f ios/Podfile.lock
+fi
+
+# Remove common development files
+echo "🗑️  Removing development files..."
+rm -rf .git
+rm -rf .gitignore
+rm -rf .github
+rm -rf node_modules
+rm -rf .vscode
+rm -rf .idea
+rm -f .DS_Store
+rm -f *.log
+rm -f npm-debug.log*
+rm -f yarn-debug.log*
+rm -f yarn-error.log*
+rm -f package-lock.json
+rm -f yarn.lock
+
+# Create the zip archive
+echo "📦 Creating compressed archive..."
+cd ..
+zip -r "${OUTPUT_NAME}" "${TEMP_DIR}" -x "*.DS_Store" -q
+
+# Create dist directory if it doesn't exist
+mkdir -p "${PACKAGE_NAME}/dist"
+
+# Move the archive to dist directory
+mv "${OUTPUT_NAME}" "${PACKAGE_NAME}/dist/"
+
+# Clean up temporary directory
+echo "🧼 Cleaning up temporary files..."
+rm -rf "${TEMP_DIR}"
+
+cd "${PACKAGE_NAME}"
+
+echo "✅ Distribution package created successfully!"
+echo "📦 Output file: ${OUTPUT_NAME}"
+echo "📍 Location: $(pwd)/dist/${OUTPUT_NAME}"

package/react-native-pointr.podspec

@@ -16,7 +16,7 @@ Pod::Spec.new do |s|
 
   s.source_files = "ios/**/*.{h,m,mm,swift}"
 
-  s.dependency 'PointrKit', '9.1.0'
+  s.dependency 'PointrKit', '9.3.0'
 
   # Use install_modules_dependencies helper to install the dependencies if React Native version >=0.71.0.
   # See https://github.com/facebook/react-native/blob/febf6b7f33fdb4904669f99d795eba4c0f95d7bf/scripts/cocoapods/new_architecture.rb#L79.

package/src/PTRCommand.ts

@@ -8,9 +8,11 @@ export enum PTRCommandType {
     POI = "poi",
     PATH = "path",
     STATIC_PATH = "staticPath",
+    STATIC_WAYFINDING = "staticWayfinding",
     MARK_MY_CAR_LEVEL = "markMyCarForLevel",
     MARK_MY_CAR_SITE = "markMyCarForSite",
-    SHOW_MY_CAR_SITE = "showMyCarForSite"
+    SHOW_MY_CAR_SITE = "showMyCarForSite",
+    START_AND_FOCUS = "startAndFocus"
 }
 /**
  * Base class for all Pointr SDK commands
@@ -81,6 +83,18 @@ export class PTRStaticPathCommand extends PTRCommand {
     }
 }
 
+/**
+ * Command to show static wayfinding using PTRMapWidgetStaticWayfindingAction
+ * @param site - the site that has the POIs
+ * @param sourcePoi - the source POI location to start the path from
+ * @param destinationPoi - the destination POI location to end the path at
+ */
+export class PTRStaticWayfindingCommand extends PTRCommand {
+    constructor(public site: string, public sourcePoi: string, public destinationPoi: string) {
+        super(PTRCommandType.STATIC_WAYFINDING);
+    }
+}
+
 /**
  * Command to show mark my car details
  * @param site - the site to show mark my car details
@@ -117,4 +131,23 @@ export class PTRShowMyCarSiteCommand extends PTRCommand {
     constructor(public site: string, public shouldShowPopup: boolean = true, public animationType: number = 1) {
         super(PTRCommandType.SHOW_MY_CAR_SITE);
     }
+}
+
+/**
+ * Command to start the SDK and focus on a location using an existing PTR command
+ * This command is not a PTRCommand itself, but wraps SDK initialization with a focus command
+ * @param clientId - the client ID for SDK initialization
+ * @param licenseKey - the license key for SDK initialization  
+ * @param baseUrl - the base URL for SDK initialization
+ * @param logLevel - the log level for SDK initialization
+ * @param command - the PTR command to execute after SDK initialization (PTRSiteCommand, PTRBuildingCommand, PTRLevelCommand, or PTRPoiCommand)
+ */
+export class PTRStartAndFocusCommand {
+    constructor(
+        public clientId: string,
+        public licenseKey: string,
+        public baseUrl: string,
+        public logLevel: number = 4,
+        public command: PTRSiteCommand | PTRBuildingCommand | PTRLevelCommand | PTRPoiCommand
+    ) {}
 }

package/src/PTRMapWidgetUtils.ts

@@ -1,13 +1,104 @@
 import { UIManager } from 'react-native';
-import { PTRSiteCommand, PTRBuildingCommand, PTRLevelCommand, PTRPoiCommand, PTRPathCommand, PTRStaticPathCommand, PTRCommand, PTRCommandType, PTRMarkMyCarLevelCommand, PTRMarkMyCarSiteCommand, PTRShowMyCarSiteCommand } from 'react-native-pointr/src/PTRCommand';
+import { PTRSiteCommand, PTRBuildingCommand, PTRLevelCommand, PTRPoiCommand, PTRPathCommand, PTRStaticPathCommand, PTRStaticWayfindingCommand, PTRCommand, PTRCommandType, PTRMarkMyCarLevelCommand, PTRMarkMyCarSiteCommand, PTRShowMyCarSiteCommand, PTRStartAndFocusCommand } from 'react-native-pointr/src/PTRCommand';
+/**
+ * Handle PTRStartAndFocusCommand specifically
+ * @param reactTag view tag of the map widget
+ * @param startAndFocusCommand the start and focus command
+ */
+const handleStartAndFocusCommand = (reactTag: number, startAndFocusCommand: PTRStartAndFocusCommand) => {
+  const innerCommand = startAndFocusCommand.command;
+  console.info('Handling PTRStartAndFocusCommand with type:', innerCommand.type);
+  // Build arguments based on the inner command type
+  let args: any[];
+  console.info('Inner command details:', innerCommand);
+  
+  switch (innerCommand.type) {
+    case PTRCommandType.SITE: {
+      const siteCommand = innerCommand as PTRSiteCommand;
+      args = [
+        startAndFocusCommand.clientId,
+        startAndFocusCommand.licenseKey,
+        startAndFocusCommand.baseUrl,
+        startAndFocusCommand.logLevel,
+        innerCommand.type,
+        siteCommand.site,
+        "",
+        0
+      ];
+      break;
+    }
+    case PTRCommandType.BUILDING: {
+      const buildingCommand = innerCommand as PTRBuildingCommand;
+      args = [
+        startAndFocusCommand.clientId,
+        startAndFocusCommand.licenseKey,
+        startAndFocusCommand.baseUrl,
+        startAndFocusCommand.logLevel,
+        innerCommand.type,
+        buildingCommand.site,
+        buildingCommand.building,
+        0
+      ];
+      break;
+    }
+    case PTRCommandType.LEVEL: {
+      const levelCommand = innerCommand as PTRLevelCommand;
+      args = [
+        startAndFocusCommand.clientId,
+        startAndFocusCommand.licenseKey,
+        startAndFocusCommand.baseUrl,
+        startAndFocusCommand.logLevel,
+        innerCommand.type,
+        levelCommand.site,
+        levelCommand.building,
+        levelCommand.level
+      ];
+      break;
+    }
+    case PTRCommandType.POI: {
+      const poiCommand = innerCommand as PTRPoiCommand;
+      args = [
+        startAndFocusCommand.clientId,
+        startAndFocusCommand.licenseKey,
+        startAndFocusCommand.baseUrl,
+        startAndFocusCommand.logLevel,
+        innerCommand.type,
+        poiCommand.site,
+        poiCommand.poi,
+        0
+      ];
+      break;
+    }
+    default:
+      console.error('Unsupported command type in PTRStartAndFocusCommand:', innerCommand.type);
+      return;
+  }
+  console.info('Dispatching startAndFocus with args:', args);
+  UIManager.dispatchViewManagerCommand(
+    reactTag,
+    'startAndFocus',
+    args,
+  );
+};
+
 /**
  * Show the map widget with the given command
  * @param reactTag view tag of the map widget
- * @param ptrCommand command to show the map widget
+ * @param ptrCommand command to show the map widget (PTRCommand or PTRStartAndFocusCommand)
  */
-export const showMapWidget = (reactTag: number, ptrCommand: PTRCommand) => {
-  console.log(`Showing map widget with command: ${ptrCommand.type} and reactTag: ${reactTag}`);
-  switch (ptrCommand.type) {
+export const showMapWidget = (reactTag: number, ptrCommand: PTRCommand | PTRStartAndFocusCommand) => {
+  // Check if it's a PTRStartAndFocusCommand (which doesn't have a 'type' property)
+  if ('command' in ptrCommand) {
+    const startAndFocusCommand = ptrCommand as PTRStartAndFocusCommand;
+    console.log(`Showing map widget with start and focus command: ${startAndFocusCommand.command.type} and reactTag: ${reactTag}`);
+    handleStartAndFocusCommand(reactTag, startAndFocusCommand);
+    return;
+  }
+
+  // Handle regular PTRCommand
+  const command = ptrCommand as PTRCommand;
+  console.log(`Showing map widget with command: ${command.type} and reactTag: ${reactTag}`);
+  switch (command.type) {
     case PTRCommandType.SITE: {
       const siteCommand = ptrCommand as PTRSiteCommand;
       UIManager.dispatchViewManagerCommand(
@@ -62,6 +153,15 @@ export const showMapWidget = (reactTag: number, ptrCommand: PTRCommand) => {
       );
       break;
     }
+    case PTRCommandType.STATIC_WAYFINDING: {
+      const staticWayfindingCommand = ptrCommand as PTRStaticWayfindingCommand;
+      UIManager.dispatchViewManagerCommand(
+        reactTag,
+        'staticWayfinding',
+        [staticWayfindingCommand.site, staticWayfindingCommand.sourcePoi, staticWayfindingCommand.destinationPoi],
+      );
+      break;
+    }
     case PTRCommandType.MARK_MY_CAR_LEVEL: {
       const markMyCarCommand = ptrCommand as PTRMarkMyCarLevelCommand;
       UIManager.dispatchViewManagerCommand(

package/src/PTRPoiManager.ts

@@ -0,0 +1,20 @@
+import { NativeModules } from 'react-native';
+import { PTRPoi } from './types/PTRPoi';
+
+const { PTRNativePointrLibrary } = NativeModules;
+
+/**
+ * Get all Points of Interest (POIs) for a specific site
+ * @param siteId - The external identifier of the site
+ * @returns Promise that resolves with an array of POIs
+ * @throws Error if the site is not found or if the operation fails
+ */
+export async function getPois(siteId: string): Promise<PTRPoi[]> {
+  try {
+    const pois = await PTRNativePointrLibrary.getPois(siteId);
+    return pois as PTRPoi[];
+  } catch (error) {
+    console.error('Failed to get POIs:', error);
+    throw error;
+  }
+}