react-native-scanbot-barcode-scanner-sdk 4.2.0 → 4.3.0-beta.1

package/android/src/main/java/io/scanbot/barcodesdk/plugin/reactnative/components/barcode_scanner_view/ScanbotBarcodeScannerViewManager.kt

@@ -0,0 +1,256 @@
+package io.scanbot.barcodesdk.plugin.reactnative.components.barcode_scanner_view
+
+import android.content.res.Resources
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.annotations.ReactProp
+import io.scanbot.barcodesdk.plugin.reactnative.ScanbotBarcodeScannerViewManagerSpec
+import io.scanbot.barcodesdk.plugin.reactnative.extensions.toJSON
+import io.scanbot.sdk.AspectRatio
+import io.scanbot.sdk.barcode.BarcodeEanUpcNoExtensionsFilter
+import io.scanbot.sdk.barcode.BarcodeExtensionsFilter
+import io.scanbot.sdk.barcode.entity.BarcodeDensity
+import io.scanbot.sdk.barcode.entity.BarcodeDocumentFormat
+import io.scanbot.sdk.barcode.entity.BarcodeFormat
+import io.scanbot.sdk.barcode.entity.EngineMode
+import io.scanbot.sdk.barcode.entity.Gs1Handling
+import io.scanbot.sdk.barcode.entity.MSIPlesseyChecksumAlgorithm
+import io.scanbot.sdk.camera.CameraModule
+import io.scanbot.sdk.camera.ZoomRange
+import io.scanbot.sdk.ui.configuration.json.JsonBarcodesExtensionFilter
+import io.scanbot.sdk_wrapper.SBWrapper.gson
+import java.util.EnumSet
+import kotlin.math.floor
+
+
+@ReactModule(name = ScanbotBarcodeScannerViewManager.NAME)
+class ScanbotBarcodeScannerViewManager :
+  ScanbotBarcodeScannerViewManagerSpec<ScanbotBarcodeScannerView>() {
+
+  companion object {
+    const val NAME = "ScanbotBarcodeScannerView"
+  }
+
+  override fun getName(): String {
+    return NAME
+  }
+
+  public override fun createViewInstance(context: ThemedReactContext): ScanbotBarcodeScannerView {
+    return ScanbotBarcodeScannerView(context)
+  }
+
+  override fun getExportedCustomDirectEventTypeConstants(): MutableMap<String, Any>? {
+    return mutableMapOf(
+      BarcodeScannerResultEvent.NAME to mapOf("registrationName" to "onBarcodeScannerResult")
+    )
+  }
+
+  //region Commands
+
+  override fun unfreezeCamera(view: ScanbotBarcodeScannerView) {
+    view.barcodeScanner.viewController.startPreview()
+  }
+
+  override fun freezeCamera(view: ScanbotBarcodeScannerView) {
+    view.barcodeScanner.viewController.stopPreview()
+  }
+
+  override fun receiveCommand(
+    root: ScanbotBarcodeScannerView,
+    commandId: String?,
+    args: ReadableArray?
+  ) {
+    when (commandId) {
+      "freezeCamera" -> freezeCamera(root)
+      "unfreezeCamera" -> unfreezeCamera(root)
+      else -> throw Error("Unrecognized command $commandId")
+    }
+  }
+
+  //endregion
+
+  @ReactProp(name = "cameraModule")
+  override fun setCameraModule(view: ScanbotBarcodeScannerView, value: String?) {
+    value?.let {
+      view.barcodeScanner.cameraConfiguration.setCameraModule(
+        gson.fromJson(it, CameraModule::class.java)
+      )
+      view.barcodeScanner.viewController.restartPreview()
+    }
+  }
+
+  @ReactProp(name = "cameraZoomRange")
+  override fun setCameraZoomRange(view: ScanbotBarcodeScannerView, value: ReadableMap?) {
+    value?.let {
+      val zoomRange = gson.fromJson(
+        value.toJSON().toString(),
+        ZoomRangeConfig::class.java
+      )
+      view.barcodeScanner.cameraConfiguration.setPhysicalZoomRange(
+        ZoomRange(
+          maxZoomRatio = zoomRange.maxZoom,
+          minZoomRatio = zoomRange.minZoom,
+        )
+      )
+    }
+  }
+
+  @ReactProp(name = "minFocusDistanceLock")
+  override fun setMinFocusDistanceLock(view: ScanbotBarcodeScannerView, value: Boolean) {
+    view.barcodeScanner.cameraConfiguration.lockMinFocusDistance(value)
+    view.barcodeScanner.viewController.restartPreview()
+  }
+
+  @ReactProp(name = "detectorConfig")
+  override fun setDetectorConfig(view: ScanbotBarcodeScannerView, value: ReadableMap?) {
+    value?.let {
+      val config = gson.fromJson(
+        value.toJSON().toString(),
+        DetectorConfig::class.java
+      )
+      view.barcodeDetector.modifyConfig {
+        config.barcodeFormats?.let { this.setBarcodeFormats(it) }
+        config.acceptedDocumentFormats?.let { this.setAcceptedDocumentFormats(it) }
+        config.engineMode?.let { this.setEngineMode(it) }
+        this.modifyAdditionalConfig {
+          config.lowPowerMode?.let { this.setLowPowerMode(it) }
+          config.codeDensity?.let { this.setCodeDensity(it) }
+          config.gs1HandlingMode?.let { this.setGs1HandlingMode(it) }
+          config.minimumTextLength?.let { this.setMinimumTextLength(it) }
+          config.maximumTextLength?.let { this.setMaximumTextLength(it) }
+          config.minimum1DBarcodesQuietZone?.let { this.setMinimum1DQuietZoneSize(it) }
+          config.stripCheckDigits?.let { this.setStripCheckDigits(true) }
+          config.msiPlesseyChecksumAlgorithm?.let {
+            this.setMsiPlesseyChecksumAlgorithms(
+              EnumSet.of(
+                it
+              )
+            )
+          }
+        }
+      }
+
+      config.barcodesExtensionFilter?.let {
+        view.barcodeScanner.viewController.setBarcodeFilter(
+          when (it) {
+            JsonBarcodesExtensionFilter.NO_FILTER -> null
+            JsonBarcodesExtensionFilter.ONLY_WITH_EXTENSIONS -> BarcodeExtensionsFilter()
+            JsonBarcodesExtensionFilter.ONLY_WITHOUT_EXTENSIONS -> BarcodeEanUpcNoExtensionsFilter()
+          }
+        )
+      }
+
+    }
+  }
+
+  @ReactProp(name = "scanningEnabled")
+  override fun setScanningEnabled(view: ScanbotBarcodeScannerView, value: Boolean) {
+    view.barcodeDetector.enableBarcodeScan(value)
+  }
+
+  @ReactProp(name = "cameraZoomFactor")
+  override fun setCameraZoomFactor(view: ScanbotBarcodeScannerView, value: Float) {
+    view.barcodeScanner.cameraConfiguration.setPhysicalZoomRatio(value)
+  }
+
+  @ReactProp(name = "finderRequiredAspectRatios")
+  override fun setFinderRequiredAspectRatios(
+    view: ScanbotBarcodeScannerView,
+    value: ReadableMap?
+  ) {
+    value?.let {
+      val aspectRatios = gson.fromJson<AspectRatio>(
+        value.toJSON().toString(),
+        AspectRatio::class.java
+      )
+      view.barcodeScanner.finderViewController.setRequiredAspectRatios(listOf(aspectRatios))
+    }
+  }
+
+  @ReactProp(name = "finderInset")
+  override fun setFinderInset(view: ScanbotBarcodeScannerView, value: ReadableMap?) {
+    value?.let {
+      val insets = gson.fromJson(
+        value.toJSON().toString(),
+        FinderInsets::class.java
+      )
+      view.barcodeScanner.finderViewController.setFinderInset(
+        left = insets.left?.let { convertDpToPx(view.resources, it) },
+        right = insets.right?.let { convertDpToPx(view.resources, it) },
+        top = insets.top?.let { convertDpToPx(view.resources, it) },
+        bottom = insets.bottom?.let { convertDpToPx(view.resources, it) },
+      )
+    }
+  }
+
+  @ReactProp(name = "flashEnabled")
+  override fun setFlashEnabled(view: ScanbotBarcodeScannerView, value: Boolean) {
+    view.flashState = value
+    view.barcodeScanner.viewController.useFlash(value)
+  }
+
+  @ReactProp(name = "finderEnabled")
+  override fun setFinderEnabled(view: ScanbotBarcodeScannerView, value: Boolean) {
+    view.barcodeScanner.finderViewController.setFinderEnabled(value)
+  }
+
+  @ReactProp(name = "finderStrokeWidth")
+  override fun setFinderStrokeWidth(view: ScanbotBarcodeScannerView, value: Int) {
+    view.barcodeScanner.finderViewController.setStrokeWidth(convertDpToPx(view.resources, value))
+  }
+
+  @ReactProp(name = "finderStrokeColor", customType = "Color")
+  override fun setFinderStrokeColor(view: ScanbotBarcodeScannerView, value: Int?) {
+    value?.let {
+      view.barcodeScanner.finderViewController.setStrokeColor(it)
+    }
+  }
+
+  @ReactProp(name = "finderOverlayColor", customType = "Color")
+  override fun setFinderOverlayColor(view: ScanbotBarcodeScannerView, value: Int?) {
+    value?.let {
+      view.barcodeScanner.finderViewController.setOverlayColor(value)
+    }
+  }
+
+  @ReactProp(name = "finderMinPadding")
+  override fun setFinderMinPadding(view: ScanbotBarcodeScannerView, value: Int) {
+    view.barcodeScanner.finderViewController.setFinderMinPadding(value)
+  }
+
+  private fun convertDpToPx(resources: Resources, dp: Int): Int {
+    return floor((dp * resources.displayMetrics.density)).toInt()
+  }
+
+}
+
+data class DetectorConfig(
+  var barcodeFormats: List<BarcodeFormat>?,
+  var acceptedDocumentFormats: List<BarcodeDocumentFormat>?,
+  var engineMode: EngineMode?,
+  var barcodesExtensionFilter: JsonBarcodesExtensionFilter?,
+  // Additional Config
+  var lowPowerMode: Boolean?,
+  var minimumTextLength: Int?,
+  var maximumTextLength: Int?,
+  var minimum1DBarcodesQuietZone: Int?,
+  var stripCheckDigits: Boolean?,
+  var gs1HandlingMode: Gs1Handling?,
+  var msiPlesseyChecksumAlgorithm: MSIPlesseyChecksumAlgorithm?,
+  var codeDensity: BarcodeDensity?,
+)
+
+data class FinderInsets(
+  val left: Int?,
+  val right: Int?,
+  val top: Int?,
+  val bottom: Int?
+)
+
+data class ZoomRangeConfig(
+  val minZoom: Float,
+  val maxZoom: Float,
+)
+

package/android/src/main/java/io/scanbot/barcodesdk/plugin/reactnative/extensions/JSONObject.kt

@@ -33,16 +33,24 @@ fun JSONObject.toWritableMap(): WritableMap {
                 map.putInt(key, value)
             }
 
+            is Long -> {
+                map.putInt(key, value.toInt())
+            }
+
             is Double -> {
                 map.putDouble(key, value)
             }
 
+            is Float -> {
+                map.putDouble(key, value.toDouble())
+            }
+
             is String -> {
                 map.putString(key, value)
             }
 
             else -> {
-                map.putString(key, value.toString())
+                map.putNull(key)
             }
         }
     }
@@ -72,16 +80,24 @@ fun JSONArray.toWritableArray(): WritableArray {
                 array.pushInt(value)
             }
 
+            is Long -> {
+                array.pushInt(value.toInt())
+            }
+
             is Double -> {
                 array.pushDouble(value)
             }
 
+            is Float -> {
+                array.pushDouble(value.toDouble())
+            }
+
             is String -> {
                 array.pushString(value)
             }
 
             else -> {
-                array.pushString(value.toString())
+                array.pushNull()
             }
         }
     }

package/android/src/main/java/io/scanbot/barcodesdk/plugin/reactnative/extensions/ReadableMap.kt

@@ -7,7 +7,6 @@ import org.json.JSONArray
 import org.json.JSONException
 import org.json.JSONObject
 
-
 @Throws(JSONException::class)
 fun ReadableMap.toJSON(): JSONObject {
     val jsonResult = JSONObject()
@@ -24,7 +23,7 @@ fun ReadableMap.toJSON(): JSONObject {
             ReadableType.Map -> jsonResult.put(key, this.getMap(key)?.toJSON())
             ReadableType.Array -> jsonResult.put(key, this.getArray(key)?.toJSONArray())
             ReadableType.Null -> {
-                // NO-OP
+                jsonResult.put(key, JSONObject.NULL)
             }
         }
     }
@@ -44,10 +43,10 @@ fun ReadableArray.toJSONArray(): JSONArray {
             ReadableType.Map -> jsonResult.put(this.getMap(i).toJSON())
             ReadableType.Array -> jsonResult.put(this.getArray(i).toJSONArray())
             ReadableType.Null -> {
-                // NO-OP
+                jsonResult.put(JSONObject.NULL)
             }
         }
     }
 
     return jsonResult
-}
+}

package/android/src/newarch/ScanbotBarcodeScannerViewManagerSpec.kt

@@ -0,0 +1,19 @@
+package io.scanbot.barcodesdk.plugin.reactnative
+
+import android.view.View
+import com.facebook.react.uimanager.SimpleViewManager
+import com.facebook.react.uimanager.ViewManagerDelegate
+import com.facebook.react.viewmanagers.ScanbotBarcodeScannerViewManagerDelegate
+import com.facebook.react.viewmanagers.ScanbotBarcodeScannerViewManagerInterface
+
+abstract class ScanbotBarcodeScannerViewManagerSpec<T : View> : SimpleViewManager<T>(), ScanbotBarcodeScannerViewManagerInterface<T> {
+  private val mDelegate: ViewManagerDelegate<T>
+
+  init {
+    mDelegate = ScanbotBarcodeScannerViewManagerDelegate(this)
+  }
+
+  override fun getDelegate(): ViewManagerDelegate<T>? {
+    return mDelegate
+  }
+}

package/android/src/oldarch/ScanbotBarcodeScannerViewManagerSpec.kt

@@ -0,0 +1,29 @@
+package io.scanbot.barcodesdk.plugin.reactnative
+
+import android.view.View
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.uimanager.SimpleViewManager
+import io.scanbot.barcodesdk.plugin.reactnative.components.barcode_scanner_view.ScanbotBarcodeScannerView
+
+abstract class ScanbotBarcodeScannerViewManagerSpec<T : View> : SimpleViewManager<T>() {
+  abstract fun setCameraModule(view: ScanbotBarcodeScannerView, value: String?)
+  abstract fun setCameraZoomRange(view: ScanbotBarcodeScannerView, value: ReadableMap?)
+  abstract fun setMinFocusDistanceLock(view: ScanbotBarcodeScannerView, value: Boolean)
+  abstract fun setDetectorConfig(view: ScanbotBarcodeScannerView, value: ReadableMap?)
+  abstract fun setScanningEnabled(view: ScanbotBarcodeScannerView, value: Boolean)
+  abstract fun setCameraZoomFactor(view: ScanbotBarcodeScannerView, value: Float)
+  abstract fun setFinderRequiredAspectRatios(
+    view: ScanbotBarcodeScannerView,
+    value: ReadableMap?
+  )
+  abstract fun setFinderInset(view: ScanbotBarcodeScannerView, value: ReadableMap?)
+  abstract fun setFlashEnabled(view: ScanbotBarcodeScannerView, value: Boolean)
+  abstract fun setFinderEnabled(view: ScanbotBarcodeScannerView, value: Boolean)
+  abstract fun setFinderStrokeWidth(view: ScanbotBarcodeScannerView, value: Int)
+  abstract fun setFinderStrokeColor(view: ScanbotBarcodeScannerView, value: Int?)
+  abstract fun setFinderOverlayColor(view: ScanbotBarcodeScannerView, value: Int?)
+  abstract fun setFinderMinPadding(view: ScanbotBarcodeScannerView, value: Int)
+  abstract fun freezeCamera(view: ScanbotBarcodeScannerView)
+  abstract fun unfreezeCamera(view: ScanbotBarcodeScannerView)
+}

package/dist/components/barcode-camera-view/ScanbotBarcodeCameraView.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+import { ScanbotBarcodeCameraViewHandle, ScanbotBarcodeCameraViewProperties } from './ScanbotBarcodeCameraViewProperties';
+export declare const ScanbotBarcodeCameraView: React.ForwardRefExoticComponent<ScanbotBarcodeCameraViewProperties & React.RefAttributes<ScanbotBarcodeCameraViewHandle>>;

package/dist/components/barcode-camera-view/ScanbotBarcodeCameraView.js

@@ -0,0 +1,122 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScanbotBarcodeCameraView = void 0;
+var react_1 = __importStar(require("react"));
+var ScanbotBarcodeScannerViewNativeComponent_1 = __importStar(require("../spec/ScanbotBarcodeScannerViewNativeComponent"));
+var react_native_1 = require("react-native");
+exports.ScanbotBarcodeCameraView = (0, react_1.forwardRef)(function (_a, forwardedRef) {
+    var _b = _a.flashEnabled, flashEnabled = _b === void 0 ? false : _b, _c = _a.scanningEnabled, scanningEnabled = _c === void 0 ? true : _c, props = __rest(_a, ["flashEnabled", "scanningEnabled"]);
+    var finderConfig = __assign({
+        viewFinderEnabled: true,
+        finderLineWidth: 2,
+        finderLineColor: '#ffffffff',
+        overlayColor: '#000000A9',
+        finderInset: {
+            bottom: 20,
+            top: 20,
+            left: 20,
+            right: 20,
+        },
+        requiredAspectRatio: {
+            height: 3,
+            width: 4,
+        },
+        minPadding: 60,
+    }, props.finderConfig);
+    var cameraConfig = __assign({
+        cameraZoomRange: {
+            minZoom: 1,
+            maxZoom: 12,
+        },
+        cameraZoomFactor: 0.0,
+        minFocusDistanceLock: false,
+    }, props.cameraConfig);
+    var viewRef = (0, react_1.useRef)(null);
+    (0, react_1.useImperativeHandle)(forwardedRef, function () {
+        return {
+            freezeCamera: function () {
+                if (viewRef.current) {
+                    //@ts-ignore
+                    ScanbotBarcodeScannerViewNativeComponent_1.Commands.freezeCamera(viewRef.current);
+                }
+            },
+            unfreezeCamera: function () {
+                if (viewRef.current) {
+                    //@ts-ignore
+                    ScanbotBarcodeScannerViewNativeComponent_1.Commands.unfreezeCamera(viewRef.current);
+                }
+            },
+        };
+    }, []);
+    var _onBarcodeScannerResult = (0, react_1.useCallback)(function (event) {
+        var result = react_native_1.Platform.select({
+            ios: JSON.parse(event.nativeEvent.result),
+            android: event.nativeEvent.result
+        });
+        if (props.onBarcodeScannerResult && result) {
+            props.onBarcodeScannerResult(result);
+        }
+    }, [props.onBarcodeScannerResult]);
+    return <ScanbotBarcodeScannerViewNativeComponent_1.default 
+    //FinderConfigs
+    finderEnabled={finderConfig.viewFinderEnabled} finderStrokeWidth={finderConfig.finderLineWidth} finderMinPadding={finderConfig.minPadding} finderStrokeColor={finderConfig.finderLineColor} finderOverlayColor={finderConfig.overlayColor} finderInset={finderConfig.finderInset} finderRequiredAspectRatios={finderConfig.requiredAspectRatio} 
+    //CameraConfigs
+    cameraZoomFactor={react_native_1.Platform.select({
+            ios: parseFloat(cameraConfig.cameraZoomFactor.toFixed(2)),
+            android: cameraConfig.cameraZoomRange.minZoom +
+                (cameraConfig.cameraZoomRange.maxZoom - cameraConfig.cameraZoomRange.minZoom) * cameraConfig.cameraZoomFactor,
+        })} cameraZoomRange={cameraConfig.cameraZoomRange} minFocusDistanceLock={cameraConfig.minFocusDistanceLock} cameraModule={cameraConfig.cameraModule} 
+    //DetectorConfigs
+    detectorConfig={props.detectorConfig} 
+    //Other
+    flashEnabled={flashEnabled} scanningEnabled={scanningEnabled} 
+    //View
+    style={[{ flex: 1 }, props.style]} ref={viewRef} 
+    //Result
+    onBarcodeScannerResult={_onBarcodeScannerResult}/>;
+});

package/dist/components/barcode-camera-view/ScanbotBarcodeCameraViewProperties.d.ts

@@ -0,0 +1,89 @@
+import { ColorValue, ViewStyle } from 'react-native';
+import { BarcodeScannerResult } from '../../results';
+import { AspectRatio, BarcodeDocumentFormat, BarcodeFormat, BarcodesExtensionFilter, CameraModule, CodeDensity, EngineMode, Gs1HandlingMode, MSIPlesseyChecksumAlgorithm, ZoomRange } from '../../types';
+import { StyleProp } from 'react-native/Libraries/StyleSheet/StyleSheet';
+export interface ScanbotBarcodeCameraViewProperties {
+    /** Configuration properties of the finder overlay */
+    finderConfig?: FinderConfig;
+    /** Configuration properties of the camera device */
+    cameraConfig?: CameraConfig;
+    /** An interface that defines parameters for barcodes detection and filtering */
+    detectorConfig?: DetectorConfig;
+    /** Whether flash is toggled on or off. */
+    flashEnabled?: boolean;
+    /**
+     * Enable or disable barcode detection.
+     * If disabled, the camera preview is active but no barcodes will be detected.
+     * Default is enabled.
+     */
+    scanningEnabled?: boolean;
+    onBarcodeScannerResult: (result: BarcodeScannerResult) => void;
+    style?: StyleProp<ViewStyle>;
+}
+/** Configuration properties of the finder overlay */
+export interface FinderConfig {
+    /** Display the region of interest. The default value is TRUE. */
+    viewFinderEnabled?: boolean;
+    /** Width of finder frame border. */
+    finderLineWidth?: number;
+    /** Color of finder frame border. */
+    finderLineColor?: ColorValue;
+    /** Background color of the detection overlay. */
+    overlayColor?: ColorValue;
+    /** The minimum space from view finders outer edges to the view edges. */
+    finderInset?: FinderInset;
+    /** Initial padding for insets. Android only. */
+    minPadding?: number;
+    /** Aspect ratio of finder frame (width \ height), which is used to build actual finder frame. */
+    requiredAspectRatio?: AspectRatio;
+}
+/** Configuration properties of the camera device */
+export interface CameraConfig {
+    /** The relative initial zoom level of the camera in the range (0,1), where 0 is zoomed out and 1 is zoomed in. Default value is 0.0. */
+    cameraZoomFactor?: number;
+    /** The range of valid camera zoom factors. Default value is (1.0; 12.0). */
+    cameraZoomRange?: ZoomRange;
+    /** The camera module to be used for barcode scanning */
+    cameraModule?: CameraModule;
+    /** Lock focus distance withing minimum possible range */
+    minFocusDistanceLock?: boolean;
+}
+/** An interface that defines parameters for barcodes detection and filtering */
+export interface DetectorConfig {
+    /** Accepted barcode formats */
+    barcodeFormats?: BarcodeFormat[];
+    /** An optional array of barcode document formats that act as a detection filter. By default all supported document formats will be detected. */
+    acceptedDocumentFormats?: BarcodeDocumentFormat[];
+    /** The engine mode to be used for barcode scanning. The default value is NEXT_GEN. */
+    engineMode?: EngineMode;
+    /** The extension filter for EAN and UPC barcodes. */
+    barcodesExtensionFilter?: BarcodesExtensionFilter;
+    /** If `true`, enabled the mode which slightly decreases the scanning quality and the energy consumption, and increases the scanning speed. If `false` - mode is disabled. The default is `false` */
+    lowPowerMode?: boolean;
+    /** Optional minimum required text length of the detected barcode. The default is 0 (setting is turned off). NOTE - This feature works on ITF barcodes only. */
+    minimumTextLength?: number;
+    /** Optional maximum text length of the detected barcode. The default is 0 (setting is turned off). NOTE - This feature works on ITF barcodes only. */
+    maximumTextLength?: number;
+    /** Optional minimum required quiet zone on the barcode. Measured in modules (the size of minimal bar on the barcode). The default is 10. NOTE - This feature works on ITF barcodes only. */
+    minimum1DBarcodesQuietZone?: number;
+    /** With this option enabled, the scanner removes checks digits for UPC, EAN and MSI Plessey codes. Has no effect if both single and double digit MSI Plessey checksums are enabled. The default is `false` */
+    stripCheckDigits?: boolean;
+    /** The GS1 handling mode. The default value is PARSE. */
+    gs1HandlingMode?: Gs1HandlingMode;
+    /** The checksum algorithm for MSI Plessey barcodes. The default value is MOD_10. */
+    msiPlesseyChecksumAlgorithm?: MSIPlesseyChecksumAlgorithm;
+    /** The expected density of QR codes in an image. */
+    codeDensity?: CodeDensity;
+}
+export interface FinderInset {
+    left: number;
+    top: number;
+    bottom: number;
+    right: number;
+}
+export interface ScanbotBarcodeCameraViewHandle {
+    /** Freezes the cameras preview */
+    freezeCamera(): void;
+    /** Unfreezes the previously frozen cameras preview */
+    unfreezeCamera(): void;
+}

package/dist/components/barcode-camera-view/ScanbotBarcodeCameraViewProperties.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/components/spec/ScanbotBarcodeScannerViewNativeComponent.d.ts

@@ -0,0 +1,54 @@
+/// <reference types="react-native/types/modules/Codegen" />
+import type { ColorValue, ViewProps } from 'react-native';
+import type { DirectEventHandler, Double, Float, Int32, WithDefault } from 'react-native/Libraries/Types/CodegenTypes';
+import { ComponentType } from 'react';
+export interface NativeProps extends ViewProps {
+    onBarcodeScannerResult?: DirectEventHandler<Readonly<{
+        result: string;
+    }>>;
+    flashEnabled?: WithDefault<boolean, false>;
+    finderEnabled?: WithDefault<boolean, false>;
+    finderStrokeWidth?: WithDefault<Int32, 2>;
+    finderStrokeColor?: ColorValue;
+    finderOverlayColor?: ColorValue;
+    finderMinPadding?: WithDefault<Int32, 0>;
+    finderInset?: {
+        left?: WithDefault<Int32, 10>;
+        top?: WithDefault<Int32, 10>;
+        bottom?: WithDefault<Int32, 10>;
+        right?: WithDefault<Int32, 10>;
+    };
+    finderRequiredAspectRatios?: {
+        width?: WithDefault<Double, 4>;
+        height?: WithDefault<Double, 3>;
+    };
+    cameraZoomFactor?: WithDefault<Float, 0.0>;
+    cameraZoomRange?: {
+        minZoom?: WithDefault<Float, 1.0>;
+        maxZoom?: WithDefault<Float, 12.0>;
+    };
+    cameraModule?: WithDefault<string, 'BACK'>;
+    scanningEnabled?: WithDefault<boolean, true>;
+    detectorConfig?: {
+        barcodeFormats?: ReadonlyArray<string>;
+        acceptedDocumentFormats?: ReadonlyArray<string>;
+        engineMode?: WithDefault<string, 'NEXT_GEN'>;
+        barcodesExtensionFilter?: WithDefault<string, 'NO_FILTER'>;
+        lowPowerMode?: WithDefault<boolean, false>;
+        minimumTextLength?: WithDefault<Int32, 0>;
+        maximumTextLength?: WithDefault<Int32, 0>;
+        minimum1DBarcodesQuietZone?: WithDefault<Int32, 10>;
+        stripCheckDigits?: WithDefault<boolean, false>;
+        gs1HandlingMode?: WithDefault<string, 'PARSE'>;
+        msiPlesseyChecksumAlgorithm?: WithDefault<string, 'MOD_10'>;
+        codeDensity?: WithDefault<string, 'LOW'>;
+    };
+    minFocusDistanceLock?: WithDefault<boolean, false>;
+}
+declare const _default: import("react-native/Libraries/Utilities/codegenNativeComponent").NativeComponentType<NativeProps>;
+export default _default;
+interface NativeCommands {
+    freezeCamera: (viewRef: React.ElementRef<ComponentType>) => void;
+    unfreezeCamera: (viewRef: React.ElementRef<ComponentType>) => void;
+}
+export declare const Commands: NativeCommands;

package/dist/components/spec/ScanbotBarcodeScannerViewNativeComponent.js

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Commands = void 0;
+var codegenNativeComponent_1 = __importDefault(require("react-native/Libraries/Utilities/codegenNativeComponent"));
+var codegenNativeCommands_1 = __importDefault(require("react-native/Libraries/Utilities/codegenNativeCommands"));
+exports.default = (0, codegenNativeComponent_1.default)('ScanbotBarcodeScannerView');
+exports.Commands = (0, codegenNativeCommands_1.default)({
+    supportedCommands: ['freezeCamera', 'unfreezeCamera'],
+});