@pensasystems/pensa-react-native 0.1.0-beta.1 → 0.1.1

package/PensaSdkReactNative.podspec

@@ -21,5 +21,5 @@ Pod::Spec.new do |s|
     s.dependency "React-Core"
   end
 
-  s.dependency "PensaSdk", "~> 1.0.4"
+  s.dependency "PensaSdk"
 end

package/README.md

@@ -7,17 +7,18 @@ The Pensa Mobile App SDK is a developer toolkit designed to simplify adding Pens
 Integrating the Pensa SDK into your React Native project is simple. Follow the steps below to add the SDK and enable advanced shelf recognition features in your app:
 
 ### 1- Install the SDK Package
+Registry: https://www.npmjs.com/package/@pensasystems/pensa-react-native
 
 Add the npm package to your project:
 
 ```bash
-npm install pensa-sdk-react-native
+npm install @pensasystems/pensa-react-native
 ```
 
 or
 
 ```bash
-yarn add pensa-sdk-react-native
+yarn add @pensasystems/pensa-react-native
 ```
 
 ### 2- Install Native Dependencies (iOS)
@@ -44,7 +45,7 @@ Initializing the Pensa SDK is straightforward. Follow the steps below to set up
 Call `initPensa()` at the startup of your app, preferably in a root file like `index.js` before calling `AppRegistry.registerComponent`.
 
 ```tsx
-import {initPensa} from 'pensa-sdk-react-native';
+import {initPensa} from '@pensasystems/pensa-react-native';
 
 initPensa({
   clientId: 'YOUR_CLIENT_ID',
@@ -71,7 +72,7 @@ To listen to SDK events such as upload progress, success, or failure, you can cr
 ```tsx
 // hooks/usePensaListeners.ts
 import {useEffect} from 'react';
-import {PensaEvents} from 'pensa-sdk-react-native';
+import {PensaEvents} from '@pensasystems/pensa-react-native';
 
 export const usePensaListeners = () => {
   useEffect(() => {
@@ -151,7 +152,7 @@ import {
   showScanArea,
   showStockingScreen,
   showStoreChecklist,
-} from 'pensa-sdk-react-native';
+} from '@pensasystems/pensa-react-native';
 ```
 
 ### Searching stores
@@ -273,6 +274,99 @@ showScanArea(scanId, storeId, globalStoreId)
 
 This method allows you to navigate directly to a scan area without going through the store selection flow.
 
+# Troubleshooting (Android)
+
+## 1. Core Library Desugaring Required
+
+If you see an error mentioning that `core library desugaring` must be enabled (typically referencing `AAR metadata` or `desugar_jdk_libs`), update your Android project as follows:
+
+### **Step 1 — Add desugaring dependency**
+
+In your app-level `build.gradle`:
+
+```gradle
+dependencies {
+    coreLibraryDesugaring 'com.android.tools:desugar_jdk_libs:2.1.5'
+}
+```
+
+### **Step 2 — Enable desugaring & set Java 17**
+
+Inside `android { compileOptions { ... } }`:
+
+```gradle
+compileOptions {
+    sourceCompatibility JavaVersion.VERSION_17
+    targetCompatibility JavaVersion.VERSION_17
+    coreLibraryDesugaringEnabled true
+}
+```
+
+This configuration is required because the native Pensa Android SDK uses Java 17 language features.
+
+---
+
+## 2. Min SDK Version Requirement
+
+If your Android build fails with a message indicating:
+
+> *minSdkVersion cannot be smaller than 26 for library com.pensasystems:pensasdk*
+
+Then your `minSdkVersion` must be updated.
+
+### **Fix**
+
+In your app-level `build.gradle`:
+
+```gradle
+defaultConfig {
+    minSdkVersion 26
+}
+```
+
+The native Pensa Android SDK requires **minSdk 26**.
+
+---
+
+## 3. Metro Bundler Cannot Connect in Debug Mode (Android Only)
+
+If the Android app cannot connect to Metro (e.g., blank screen, “Unable to load script from assets”), update your debug network rules.
+
+### **Step 1 — Create `network_security_config.xml`**
+
+Create a file:
+
+```
+android/app/src/main/res/xml/network_security_config.xml
+```
+
+With the following content:
+
+```xml
+<?xml version="1.0" encoding="utf-8"?>
+<network-security-config>
+    <domain-config cleartextTrafficPermitted="true">
+        <domain includeSubdomains="true">10.0.2.2</domain>
+        <domain includeSubdomains="true">localhost</domain>
+        <domain includeSubdomains="true">127.0.0.1</domain>
+    </domain-config>
+</network-security-config>
+```
+
+### **Step 2 — Reference it in `AndroidManifest.xml`**
+
+Inside your `<application>` tag:
+
+```xml
+<application
+    android:networkSecurityConfig="@xml/network_security_config"
+    ... >
+```
+
+This allows the Android emulator to access the React Native bundler during development.
+
+---
+
 ### Example Project
 
 For code examples and integration best practices, refer to our GitHub repository.

package/android/build.gradle

@@ -1,3 +1,4 @@
+
 buildscript {
   ext.getExtOrDefault = {name ->
     return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties['PensaSdkReactNative_' + name]
@@ -83,7 +84,7 @@ def kotlin_version = getExtOrDefault("kotlinVersion")
 
 dependencies {
   coreLibraryDesugaring 'com.android.tools:desugar_jdk_libs:2.1.5'
-  implementation "com.pensasystems:pensasdk:1.0.8"
+  implementation "com.pensasystems:pensasdk:1.0.23"
   implementation "com.facebook.react:react-android"
   implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
 }

package/android/src/main/java/com/pensasdkreactnative/PensaListeners.kt

@@ -2,9 +2,10 @@ package com.pensasdkreactnative
 
 import com.facebook.react.bridge.ReactApplicationContext
 import com.pensasystems.pensasdk.listener.CantScanEventListener
+import com.pensasystems.pensasdk.listener.CompletedScanWithGuidListener
 import com.pensasystems.pensasdk.listener.ScanUploadListener
 
-object PensaListeners : ScanUploadListener, CantScanEventListener {
+object PensaListeners : ScanUploadListener, CantScanEventListener, CompletedScanWithGuidListener {
 
   private var emitter: PensaEventEmitterModule? = null
 
@@ -41,4 +42,12 @@ object PensaListeners : ScanUploadListener, CantScanEventListener {
       "reason" to cantScanReason
     ))
   }
+
+  override fun onScanCompletedWithGuid(guid: String?, tdlinxId: String, scanId: Int) {
+    emitter?.sendEvent("onScanCompletedWithGuid", mapOf(
+      "guid" to guid,
+      "tdlinxId" to tdlinxId,
+      "scanId" to scanId
+    ))
+  }
 }

package/android/src/main/java/com/pensasdkreactnative/PensaSdkReactNativeModule.kt

@@ -1,14 +1,17 @@
 package com.pensasdkreactnative
 
+import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReactContextBaseJavaModule
 import com.facebook.react.bridge.ReactMethod
 import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReadableArray
 import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.ReadableType
 import com.pensasystems.pensasdk.PensaSdk
 import com.pensasystems.pensasdk.PensaSdkConfiguration
-import com.pensasystems.pensasdk.listener.CantScanEventListener
-import com.pensasystems.pensasdk.listener.ScanUploadListener
+import com.pensasystems.pensasdk.model.PensaReportType
+import com.pensasystems.pensasdk.model.PensaShelfItem
 
 class PensaSdkReactNativeModule(reactContext: ReactApplicationContext) :
   ReactContextBaseJavaModule(reactContext) {
@@ -40,6 +43,7 @@ class PensaSdkReactNativeModule(reactContext: ReactApplicationContext) :
         .enableLogging(isLoggingEnabled)
         .setScanUploadListener(PensaListeners)
         .setCantScanEventListener(PensaListeners)
+        .setCompletedScanWithGuidListener(PensaListeners)
         .build()
 
       PensaSdk.initPensa(
@@ -69,7 +73,7 @@ class PensaSdkReactNativeModule(reactContext: ReactApplicationContext) :
 
   @ReactMethod
   fun showShelfScans(promise: Promise) {
-    val activity = currentActivity
+    val activity = reactApplicationContext.currentActivity
     if (activity != null) {
       PensaSdk.showShelfScans(
         context = activity,
@@ -82,7 +86,7 @@ class PensaSdkReactNativeModule(reactContext: ReactApplicationContext) :
   }
   @ReactMethod
   fun showProductScans(promise: Promise) {
-    val activity = currentActivity
+    val activity = reactApplicationContext.currentActivity
     if (activity != null) {
       PensaSdk.showProductScans(
         context = activity,
@@ -96,7 +100,7 @@ class PensaSdkReactNativeModule(reactContext: ReactApplicationContext) :
 
   @ReactMethod
   fun showStoreSearchView(promise: Promise) {
-    val activity = currentActivity
+    val activity = reactApplicationContext.currentActivity
     if (activity != null) {
       PensaSdk.showStoreSearchView(
         context = activity,
@@ -110,7 +114,7 @@ class PensaSdkReactNativeModule(reactContext: ReactApplicationContext) :
 
   @ReactMethod
   fun showStoresScreen(promise: Promise) {
-    val activity = currentActivity
+    val activity = reactApplicationContext.currentActivity
     if (activity != null) {
       PensaSdk.showStoresScreen(
         context = activity,
@@ -124,7 +128,7 @@ class PensaSdkReactNativeModule(reactContext: ReactApplicationContext) :
 
   @ReactMethod
   fun showScanArea(scanId: Int, storeId: Int?, globalStoreId: String?, promise: Promise) {
-    val activity = currentActivity
+    val activity = reactApplicationContext.currentActivity
     if (activity != null) {
       PensaSdk.showScanArea(
         context = activity,
@@ -141,7 +145,7 @@ class PensaSdkReactNativeModule(reactContext: ReactApplicationContext) :
 
   @ReactMethod
   fun showStockingScreen(promise: Promise) {
-    val activity = currentActivity
+    val activity = reactApplicationContext.currentActivity
     if (activity != null) {
       PensaSdk.showStockingScreen(
         context = activity,
@@ -155,7 +159,7 @@ class PensaSdkReactNativeModule(reactContext: ReactApplicationContext) :
 
   @ReactMethod
   fun showStoreChecklist(globalStoreId: String, guid: String?, sectionKey: String?, promise: Promise) {
-    val activity = currentActivity
+    val activity = reactApplicationContext.currentActivity
     if (activity != null) {
       PensaSdk.showStoreChecklist(
         context = activity,
@@ -169,4 +173,350 @@ class PensaSdkReactNativeModule(reactContext: ReactApplicationContext) :
       promise.reject("NO_ACTIVITY", "Current activity is null")
     }
   }
+
+  @ReactMethod
+  fun showStoreChecklistWithGuid(globalStoreId: String, guid: String, promise: Promise) {
+    val activity = reactApplicationContext.currentActivity
+    if (activity != null) {
+      PensaSdk.showStoreChecklistWithGuid(
+        context = activity,
+        globalStoreId = globalStoreId,
+        guid = guid,
+        onError = { error -> promise.reject("SHOW_STORE_CHECKLIST_WITH_GUID_FAILED", error) }
+      )
+      promise.resolve(null)
+    } else {
+      promise.reject("NO_ACTIVITY", "Current activity is null")
+    }
+  }
+
+  @ReactMethod
+  fun fetchScanStatuses(scanIds: ReadableArray, promise: Promise) {
+    try {
+      val ids = mutableListOf<Int>()
+      for (i in 0 until scanIds.size()) {
+        ids.add(scanIds.getInt(i))
+      }
+
+      PensaSdk.fetchScanStatuses(
+        scanIds = ids,
+        onSuccess = { statuses ->
+          val rnList = statuses.map { status ->
+            val map = Arguments.createMap()
+            map.putInt("id", status.id)
+            map.putString("created", status.created)
+            map.putString("fastStatus", status.fastStatus)
+            map.putString("scanTimestamp", status.scanTimestamp)
+            map.putString("scannerId", status.scannerId)
+            map.putString("status", status.status)
+
+            val metadata = Arguments.createMap()
+            metadata.putString("guid", status.metadata?.guid)
+            metadata.putString("serverUploadStarted", status.metadata?.serverUploadStarted)
+            map.putMap("metadata", metadata)
+
+            map
+          }
+
+          val result = Arguments.createArray()
+          rnList.forEach { result.pushMap(it) }
+          promise.resolve(result)
+
+        },
+        onError = { error ->
+          promise.reject("FETCH_SCAN_STATUSES_FAILED", error)
+        }
+      )
+    } catch (e: Exception) {
+      promise.reject("FETCH_SCAN_STATUSES_EXCEPTION", e)
+    }
+  }
+
+  @ReactMethod
+  fun fetchVisitScansStatus(guid: String, promise: Promise) {
+    try {
+      PensaSdk.fetchVisitScansStatus(
+        guid = guid,
+        onSuccess = { result ->
+          val scans = result.scans
+          val map = Arguments.createMap().apply {
+            result.guid?.let { putString("guid", it) }
+            result.visitStatus?.let { putString("visitStatus", it) }
+            if (scans == null) {
+            } else {
+              val scansArray = Arguments.createArray()
+              scans.forEach { scan ->
+                val uploadCompleted = scan.uploadCompleted
+                scansArray.pushMap(
+                  Arguments.createMap().apply {
+                    scan.created?.let { putString("created", it) }
+                    scan.fastStatus?.let { putString("fastStatus", it) }
+                    scan.scanId?.let { putInt("scanId", it) }
+                    scan.status?.let { putString("status", it) }
+                    when (uploadCompleted) {
+                      null -> {}
+                      else -> putBoolean("uploadCompleted", uploadCompleted)
+                    }
+                  }
+                )
+              }
+              putArray("scans", scansArray)
+            }
+          }
+
+          promise.resolve(map)
+        },
+        onError = { error ->
+          promise.reject("FETCH_VISIT_SCANS_STATUS_FAILED", error)
+        }
+      )
+    } catch (e: Exception) {
+      promise.reject("FETCH_VISIT_SCANS_STATUS_EXCEPTION", e)
+    }
+  }
+
+  @ReactMethod
+  fun fetchOnDemandReports(
+    scanId: Double?,
+    guid: String?,
+    projectId: Double?,
+    reportTypes: ReadableArray?,
+    promise: Promise
+  ) {
+    try {
+      val finalReportTypes = parseReportTypes(reportTypes)
+      val normalizedScanId = scanId?.toInt()
+      val normalizedProjectId = projectId?.toInt()
+
+      PensaSdk.fetchOnDemandReports(
+        scanId = normalizedScanId,
+        guid = guid,
+        projectId = normalizedProjectId,
+        reportTypes = finalReportTypes,
+        onSuccess = { report ->
+          val result = Arguments.createMap()
+
+          fun toProductMap(p: com.pensasystems.pensasdk.model.PensaOnDemandProduct) =
+            Arguments.createMap().apply {
+              p.brand?.let { putString("brand", it) }
+              p.brandId?.let { putInt("brandId", it) }
+
+              p.category?.let { putString("category", it) }
+              p.categoryId?.let { putInt("categoryId", it) }
+
+              p.expectedFacings?.let { putInt("expectedFacings", it) }
+              p.facings?.let { putInt("facings", it) }
+
+              p.manufacturer?.let { putString("manufacturer", it) }
+              p.manufacturerId?.let { putInt("manufacturerId", it) }
+
+              p.product?.let { putString("product", it) }
+              p.productId?.let { putInt("productId", it) }
+
+              p.upc?.let { putString("upc", it) }
+            }
+
+          fun toBucketMap(b: com.pensasystems.pensasdk.model.PensaOnDemandReportBucket) =
+            Arguments.createMap().apply {
+              val arr = Arguments.createArray()
+              b.productList.forEach { arr.pushMap(toProductMap(it)) }
+              putArray("productList", arr)
+            }
+
+          fun putBucket(target: com.facebook.react.bridge.WritableMap, key: String, bucket: com.pensasystems.pensasdk.model.PensaOnDemandReportBucket?) {
+            if (bucket != null) target.putMap(key, toBucketMap(bucket))
+          }
+
+          fun fillReportBuckets(
+            target: com.facebook.react.bridge.WritableMap,
+            facingsSeen: com.pensasystems.pensasdk.model.PensaOnDemandReportBucket?,
+            fullFacings: com.pensasystems.pensasdk.model.PensaOnDemandReportBucket?,
+            fullFacingsAndProductPositions: com.pensasystems.pensasdk.model.PensaOnDemandReportBucket?,
+            itemsSeen: com.pensasystems.pensasdk.model.PensaOnDemandReportBucket?,
+            newProducts: com.pensasystems.pensasdk.model.PensaOnDemandReportBucket?,
+            newProductPackaging: com.pensasystems.pensasdk.model.PensaOnDemandReportBucket?,
+            missingPriceTag: com.pensasystems.pensasdk.model.PensaOnDemandReportBucket?,
+            noOos: com.pensasystems.pensasdk.model.PensaOnDemandReportBucket?,
+            oos: com.pensasystems.pensasdk.model.PensaOnDemandReportBucket?,
+            productPositions: com.pensasystems.pensasdk.model.PensaOnDemandReportBucket?,
+            scanFailed: com.pensasystems.pensasdk.model.PensaOnDemandReportBucket?,
+            scanRejected: com.pensasystems.pensasdk.model.PensaOnDemandReportBucket?,
+            scanSkipped: com.pensasystems.pensasdk.model.PensaOnDemandReportBucket?,
+          ) {
+            finalReportTypes.distinct().forEach { t ->
+              when (t) {
+                PensaReportType.FACINGS_SEEN -> putBucket(target, "facingsSeen", facingsSeen)
+                PensaReportType.FULL_FACINGS -> putBucket(target, "fullFacings", fullFacings)
+                PensaReportType.FULL_FACINGS_AND_PRODUCT_POSITIONS ->
+                  putBucket(target, "fullFacingsAndProductPositions", fullFacingsAndProductPositions)
+                PensaReportType.ITEMS_SEEN -> putBucket(target, "itemsSeen", itemsSeen)
+                PensaReportType.NEW_PRODUCTS -> putBucket(target, "newProducts", newProducts)
+                PensaReportType.NEW_PRODUCT_PACKAGING -> putBucket(target, "newProductPackaging", newProductPackaging)
+                PensaReportType.MISSING_PRICE_TAG -> putBucket(target, "missingPriceTag", missingPriceTag)
+                PensaReportType.NO_OOS -> putBucket(target, "noOos", noOos)
+                PensaReportType.OOS -> putBucket(target, "oos", oos)
+                PensaReportType.PRODUCT_POSITIONS -> putBucket(target, "productPositions", productPositions)
+                PensaReportType.SCAN_FAILED -> putBucket(target, "scanFailed", scanFailed)
+                PensaReportType.SCAN_REJECTED -> putBucket(target, "scanRejected", scanRejected)
+                PensaReportType.SCAN_SKIPPED -> putBucket(target, "scanSkipped", scanSkipped)
+              }
+            }
+          }
+
+          fillReportBuckets(
+            result,
+            report.facingsSeen,
+            report.fullFacings,
+            report.fullFacingsAndProductPositions,
+            report.itemsSeen,
+            report.newProducts,
+            report.newProductPackaging,
+            report.missingPriceTag,
+            report.noOos,
+            report.oos,
+            report.productPositions,
+            report.scanFailed,
+            report.scanRejected,
+            report.scanSkipped
+          )
+
+          // Other fields
+          report.projectId?.let { result.putInt("projectId", it) }
+          report.projectName?.let { result.putString("projectName", it) }
+          report.projectReportId?.let { result.putInt("projectReportId", it) }
+          report.projectReportName?.let { result.putString("projectReportName", it) }
+          report.realogramSignedUrl?.let { result.putString("realogramSignedUrl", it) }
+          report.shelfId?.let { result.putInt("shelfId", it) }
+          report.shelfName?.let { result.putString("shelfName", it) }
+          report.status?.let { result.putString("status", it) }
+          val scans = report.scans
+          if (scans != null) {
+            val scansArray = Arguments.createArray()
+            scans.forEach { scan ->
+              scansArray.pushMap(
+                Arguments.createMap().apply {
+                  fillReportBuckets(
+                    this,
+                    scan.facingsSeen,
+                    scan.fullFacings,
+                    scan.fullFacingsAndProductPositions,
+                    scan.itemsSeen,
+                    scan.newProducts,
+                    scan.newProductPackaging,
+                    scan.missingPriceTag,
+                    scan.noOos,
+                    scan.oos,
+                    scan.productPositions,
+                    scan.scanFailed,
+                    scan.scanRejected,
+                    scan.scanSkipped
+                  )
+                  scan.projectId?.let { putInt("projectId", it) }
+                  scan.projectName?.let { putString("projectName", it) }
+                  scan.projectReportId?.let { putInt("projectReportId", it) }
+                  scan.projectReportName?.let { putString("projectReportName", it) }
+                  scan.realogramSignedUrl?.let { putString("realogramSignedUrl", it) }
+                  scan.scanId?.let { putInt("scanId", it) }
+                  scan.shelfId?.let { putInt("shelfId", it) }
+                  scan.shelfName?.let { putString("shelfName", it) }
+                  scan.status?.let { putString("status", it) }
+                }
+              )
+            }
+            result.putArray("scans", scansArray)
+          }
+
+          val visit = report.visit
+          if (visit != null) {
+            result.putMap(
+              "visit",
+              Arguments.createMap().apply {
+                visit.endTime?.let { putString("endTime", it) }
+                visit.identifier?.let { putString("identifier", it) }
+                visit.startTime?.let { putString("startTime", it) }
+                visit.storeName?.let { putString("storeName", it) }
+                visit.storeTdlinx?.let { putString("storeTdlinx", it) }
+              }
+            )
+          }
+
+          promise.resolve(result)
+        },
+        onError = { error ->
+          promise.reject("FETCH_ON_DEMAND_REPORTS_FAILED", error)
+        }
+      )
+    } catch (e: Exception) {
+      promise.reject("ON_DEMAND_EXCEPTION", e)
+    }
+  }
+
+  @ReactMethod
+  fun fetchProductImageBase64(productId: Int, promise: Promise) {
+    try {
+      val activity = reactApplicationContext.currentActivity
+      if (activity != null) {
+        PensaSdk.fetchProductImageBase64(
+          context = activity,
+          productId = productId,
+          onSuccess = { base64 ->
+            promise.resolve(base64)
+          },
+          onError = { error ->
+            promise.reject("FETCH_PRODUCT_IMAGE_FAILED", error)
+          }
+        )
+      } else {
+        promise.reject("NO_ACTIVITY", "Current activity is null")
+      }
+    } catch (e: Exception) {
+      promise.reject("FETCH_PRODUCT_IMAGE_EXCEPTION", e)
+    }
+  }
+
+  @ReactMethod
+  fun fetchShelves(globalStoreId: String, promise: Promise) {
+    try {
+      PensaSdk.fetchShelves(
+        globalStoreId = globalStoreId,
+        onSuccess = { shelves ->
+          val result = Arguments.createArray()
+
+          shelves.forEach { shelf ->
+            val map = Arguments.createMap()
+            map.putInt("id", shelf.id)
+            map.putString("name", shelf.name)
+            result.pushMap(map)
+          }
+
+          promise.resolve(result)
+        },
+        onError = { error ->
+          promise.reject("FETCH_SHELVES_FAILED", error)
+        }
+      )
+    } catch (e: Exception) {
+      promise.reject("FETCH_SHELVES_EXCEPTION", e)
+    }
+  }
+
+  // Helpers
+
+  private fun parseReportTypes(reportTypes: ReadableArray?): List<PensaReportType> {
+    if (reportTypes == null || reportTypes.size() == 0) return listOf(PensaReportType.ITEMS_SEEN)
+
+    val list = mutableListOf<PensaReportType>()
+    for (i in 0 until reportTypes.size()) {
+      if (reportTypes.getType(i) != ReadableType.String) continue
+      val raw = reportTypes.getString(i) ?: continue
+      val parsed = try {
+        PensaReportType.valueOf(raw)
+      } catch (e: Exception) {
+        null
+      }
+      if (parsed != null) list.add(parsed)
+    }
+
+    return if (list.isEmpty()) listOf(PensaReportType.ITEMS_SEEN) else list.distinct()
+  }
 }

package/ios/PensaEventEmitter.swift

@@ -20,7 +20,8 @@ class PensaEventEmitter: RCTEventEmitter {
       "onScanUploadProgressUpdate",
       "onScanUploadCompleted",
       "onScanUploadFailed",
-      "onCantScanReported"
+      "onCantScanReported",
+      "onScanCompletedWithGuid"
     ]
   }
 }

package/ios/PensaListeners.swift

@@ -1,7 +1,7 @@
 import Foundation
 import PensaSdk
 
-class PensaListeners: NSObject, ScanUploadListener, CantScanEventListener {
+class PensaListeners: NSObject, ScanUploadListener, CantScanEventListener, CompletedScanWithGuidListener {
 
   static let shared = PensaListeners()
 
@@ -34,4 +34,15 @@ class PensaListeners: NSObject, ScanUploadListener, CantScanEventListener {
       body: ["tdlinxId": tdlinxId, "scanAreaId": scanAreaId, "reason": cantScanReason]
     )
   }
+
+  func onScanCompletedWithGuid(guid: String?, tdlinxId: String, scanId: Int) {
+    PensaEventEmitter.shared?.sendEvent(
+      withName: "onScanCompletedWithGuid",
+      body: [
+        "guid": guid ?? NSNull(),
+        "tdlinxId": tdlinxId,
+        "scanId": scanId
+      ]
+    )
+  }
 }

package/ios/PensaSdkReactNative-Bridging-Header.h

@@ -37,6 +37,10 @@ RCT_EXTERN_METHOD(showStoreChecklist:(NSString *)globalStoreId
                   withResolver:(RCTPromiseResolveBlock)resolve
                   withRejecter:(RCTPromiseRejectBlock)reject)
 
+RCT_EXTERN_METHOD(fetchShelves:(NSString *)globalStoreId
+                  withResolver:(RCTPromiseResolveBlock)resolve
+                  withRejecter:(RCTPromiseRejectBlock)reject)
+
 @end
 
 @interface RCT_EXTERN_MODULE(PensaEventEmitter, RCTEventEmitter)