scandit-react-native-datacapture-parser 8.2.1 → 8.3.0

package/ios/Sources/NewArch/ScanditDataCaptureParser.mm

@@ -0,0 +1,83 @@
+/*
+ * This file is part of the Scandit Data Capture SDK
+ *
+ * Copyright (C) 2026- Scandit AG. All rights reserved.
+ */
+
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+#import <ScanditReactNativeDatacaptureParserSpec/ScanditReactNativeDatacaptureParserSpec.h>
+#import <ReactCommon/RCTTurboModule.h>
+#import "ScanditDataCaptureParser.h"
+#import "ScanditDataCaptureParser-Swift.h"
+
+// Forward declare and import the shared method queue from Core module
+// The actual implementation is in ScanditDataCaptureCore Swift module
+@interface SDCSharedMethodQueue : NSObject
++ (dispatch_queue_t)queue;
+@end
+
+/// New Architecture (TurboModule) adapter for the Parser native module.
+/// Inherits from the generated spec base class and uses direct method declarations.
+@implementation NativeScanditDataCaptureParser {
+    ScanditDataCaptureParserImpl *_impl;
+}
+
+RCT_EXPORT_MODULE(ScanditDataCaptureParser)
+
+- (instancetype)init {
+    if (self = [super init]) {
+        _impl = [[ScanditDataCaptureParserImpl alloc] init];
+    }
+    return self;
+}
+
++ (BOOL)requiresMainQueueSetup {
+    return YES;
+}
+
+- (void)initialize {
+    __weak NativeScanditDataCaptureParser *weakSelf = self;
+    SDCEventEmitBlock emitterBlock = ^(NSDictionary *_Nonnull payload) {
+        __strong NativeScanditDataCaptureParser *strongSelf = weakSelf;
+        if (strongSelf) {
+            [strongSelf emitOnScanditEvent:payload];
+        }
+    };
+    [_impl setupWith:nil turboEmitter:emitterBlock];
+}
+
+- (dispatch_queue_t)methodQueue {
+    return [SDCSharedMethodQueue queue];
+}
+
+- (NSDictionary *)constantsToExport {
+    return [_impl getConstants];
+}
+
+- (NSDictionary *)getConstants {
+    return [_impl getConstants];
+}
+
+- (NSArray<NSString *> *)supportedEvents {
+    return [_impl supportedEvents];
+}
+
+- (void)invalidate {
+    [_impl invalidate];
+}
+
+// MARK: - Native Module Methods
+
+- (void)executeParser:(NSDictionary *)data
+              resolve:(RCTPromiseResolveBlock)resolve
+               reject:(RCTPromiseRejectBlock)reject {
+    [_impl executeParserWithData:data resolve:resolve reject:reject];
+}
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params {
+    return std::make_shared<facebook::react::NativeScanditDataCaptureParserSpecJSI>(params);
+}
+
+@end

package/ios/Sources/OldArch/ScanditDataCaptureParser.mm

@@ -0,0 +1,71 @@
+/*
+ * This file is part of the Scandit Data Capture SDK
+ *
+ * Copyright (C) 2026- Scandit AG. All rights reserved.
+ */
+
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+#import "ScanditDataCaptureParser.h"
+#import "ScanditDataCaptureParser-Swift.h"
+
+// Forward declare and import the shared method queue from Core module
+// The actual implementation is in ScanditDataCaptureCore Swift module
+@interface SDCSharedMethodQueue : NSObject
++ (dispatch_queue_t)queue;
+@end
+
+/// Old Architecture (Paper/Bridge) adapter for the Parser native module.
+/// Inherits from RCTEventEmitter and exports methods via RCT_EXPORT_METHOD macros.
+@implementation NativeScanditDataCaptureParser {
+    ScanditDataCaptureParserImpl *_impl;
+}
+
+RCT_EXPORT_MODULE(ScanditDataCaptureParser)
+
+- (instancetype)init {
+    if (self = [super init]) {
+        _impl = [[ScanditDataCaptureParserImpl alloc] init];
+    }
+    return self;
+}
+
++ (BOOL)requiresMainQueueSetup {
+    return YES;
+}
+
+- (void)initialize {
+    [_impl setupWith:self];
+}
+
+- (dispatch_queue_t)methodQueue {
+    return [SDCSharedMethodQueue queue];
+}
+
+- (NSDictionary *)constantsToExport {
+    return [_impl getConstants];
+}
+
+- (NSDictionary *)getConstants {
+    return [_impl getConstants];
+}
+
+- (NSArray<NSString *> *)supportedEvents {
+    return [_impl supportedEvents];
+}
+
+- (void)invalidate {
+    [super invalidate];
+    [_impl invalidate];
+}
+
+// MARK: - Native Module Methods
+
+RCT_EXPORT_METHOD(executeParser
+                  : (NSDictionary *)data resolve
+                  : (RCTPromiseResolveBlock)resolve reject
+                  : (RCTPromiseRejectBlock)reject) {
+    [_impl executeParserWithData:data resolve:resolve reject:reject];
+}
+
+@end

package/ios/Sources/ScanditDataCaptureParser.h

@@ -0,0 +1,29 @@
+/*
+ * This file is part of the Scandit Data Capture SDK
+ *
+ * Copyright (C) 2020- Scandit AG. All rights reserved.
+ */
+
+#import <Foundation/Foundation.h>
+#import <React/RCTEventEmitter.h>
+
+// Block type for TurboModule event emission (Swift interop)
+// Defined unconditionally for Swift header generation, used only in new arch
+typedef void (^SDCEventEmitBlock)(NSDictionary *_Nonnull payload);
+
+#ifdef RCT_NEW_ARCH_ENABLED
+#import <ScanditReactNativeDatacaptureParserSpec/ScanditReactNativeDatacaptureParserSpec.h>
+#import <React/RCTInitializing.h>
+#import <React/RCTInvalidating.h>
+#endif
+
+/// Obj-C++ adapter class that conforms to TurboModule spec and delegates to Swift implementation.
+/// Following the Adapter Pattern from React Native's TurboModule Swift guide.
+#ifdef RCT_NEW_ARCH_ENABLED
+@interface NativeScanditDataCaptureParser
+    : NativeScanditDataCaptureParserSpecBase <NativeScanditDataCaptureParserSpec, RCTInitializing,
+                                              RCTInvalidating>
+#else
+@interface NativeScanditDataCaptureParser : RCTEventEmitter <RCTBridgeModule>
+#endif
+@end

package/ios/Sources/ScanditDataCaptureParser.swift

@@ -9,39 +9,64 @@ import ScanditDataCaptureCore
 import ScanditFrameworksCore
 import ScanditFrameworksParser
 
-@objc(ScanditDataCaptureParser)
-class ScanditDataCaptureParser: RCTEventEmitter {
-    var parserModule: ParserModule
+/// Swift implementation for the Parser native module.
+/// This class contains all business logic and is used by the Obj-C++ adapter (NativeScanditDataCaptureParser).
+/// Following the Adapter Pattern from React Native's TurboModule Swift guide.
+@objcMembers
+public class ScanditDataCaptureParserImpl: NSObject {
+    var parserModule: ParserModule!
 
-    override init() {
-        parserModule = ParserModule()
+    /// Reference to the RCTEventEmitter adapter.
+    weak var emitter: RCTEventEmitter?
+
+    public override init() {
         super.init()
-        parserModule.didStart()
     }
 
-    @objc override class func requiresMainQueueSetup() -> Bool {
-        true
+    /// Called by the Obj-C++ adapter to set up the emitter reference and initialize modules.
+    public func setup(with emitter: RCTEventEmitter) {
+        self.emitter = emitter
+        initializeModules()
+    }
+
+    /// Called by the Obj-C++ adapter to set up the emitter reference and initialize modules (new architecture).
+    /// - Parameters:
+    ///   - emitter: The RCTEventEmitter (nil in new arch since we don't inherit from RCTEventEmitter).
+    ///   - turboEmitter: TurboModule emitter block for new architecture.
+    @objc(setupWith:turboEmitter:)
+    public func setup(with emitter: RCTEventEmitter?, turboEmitter: SDCEventEmitBlock?) {
+        self.emitter = emitter
+        guard
+            let reactEmitter = ScanditDataCaptureCore.ReactNativeEmitterFactory.create(
+                emitter: emitter,
+                turboEmitter: turboEmitter
+            )
+        else {
+            fatalError("Failed to create ReactNativeEmitter")
+        }
+        initializeModules()
     }
 
-    @objc override var methodQueue: DispatchQueue! {
-        sdcSharedMethodQueue
+    private func initializeModules() {
+        // Note: ParserModule doesn't emit events
+        parserModule = ParserModule()
+        parserModule.didStart()
+
     }
 
-    override func supportedEvents() -> [String]! {
+    public func supportedEvents() -> [String] {
         []
     }
 
-    override func constantsToExport() -> [AnyHashable: Any]! {
+    public func getConstants() -> [AnyHashable: Any] {
         [:]
     }
 
-    @objc(executeParser:resolve:reject:)
-    func executeParser(
+    public func executeParser(
         data: [String: Any],
         resolve: @escaping RCTPromiseResolveBlock,
         reject: @escaping RCTPromiseRejectBlock
     ) {
-
         let coreModuleName = String(describing: CoreModule.self)
         guard let coreModule = DefaultServiceLocator.shared.resolve(clazzName: coreModuleName) as? CoreModule else {
             reject("-1", "Unable to retrieve the CoreModule from the locator.", nil)
@@ -61,12 +86,7 @@ class ScanditDataCaptureParser: RCTEventEmitter {
         }
     }
 
-    @objc override func invalidate() {
+    public func invalidate() {
         parserModule.didStop()
-        super.invalidate()
-    }
-
-    deinit {
-        invalidate()
     }
 }

package/ios/generated/ScanditReactNativeDatacaptureParserSpec/ScanditReactNativeDatacaptureParserSpec-generated.mm

@@ -0,0 +1,53 @@
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * @generated by codegen project: GenerateModuleObjCpp
+ *
+ * We create an umbrella header (and corresponding implementation) here since
+ * Cxx compilation in BUCK has a limitation: source-code producing genrule()s
+ * must have a single output. More files => more genrule()s => slower builds.
+ */
+
+#import "ScanditReactNativeDatacaptureParserSpec.h"
+
+
+@implementation NativeScanditDataCaptureParserSpecBase
+- (void)emitOnScanditEvent:(NSDictionary *)value
+{
+  _eventEmitterCallback("onScanditEvent", value);
+}
+
+- (void)setEventEmitterCallback:(EventEmitterCallbackWrapper *)eventEmitterCallbackWrapper
+{
+  _eventEmitterCallback = std::move(eventEmitterCallbackWrapper->_eventEmitterCallback);
+}
+@end
+
+
+namespace facebook::react {
+  
+    static facebook::jsi::Value __hostFunction_NativeScanditDataCaptureParserSpecJSI_executeParser(facebook::jsi::Runtime& rt, TurboModule &turboModule, const facebook::jsi::Value* args, size_t count) {
+      return static_cast<ObjCTurboModule&>(turboModule).invokeObjCMethod(rt, PromiseKind, "executeParser", @selector(executeParser:resolve:reject:), args, count);
+    }
+
+    static facebook::jsi::Value __hostFunction_NativeScanditDataCaptureParserSpecJSI_getConstants(facebook::jsi::Runtime& rt, TurboModule &turboModule, const facebook::jsi::Value* args, size_t count) {
+      return static_cast<ObjCTurboModule&>(turboModule).invokeObjCMethod(rt, ObjectKind, "getConstants", @selector(getConstants), args, count);
+    }
+
+  NativeScanditDataCaptureParserSpecJSI::NativeScanditDataCaptureParserSpecJSI(const ObjCTurboModule::InitParams &params)
+    : ObjCTurboModule(params) {
+      
+        methodMap_["executeParser"] = MethodMetadata {1, __hostFunction_NativeScanditDataCaptureParserSpecJSI_executeParser};
+        
+        
+        methodMap_["getConstants"] = MethodMetadata {0, __hostFunction_NativeScanditDataCaptureParserSpecJSI_getConstants};
+        
+        eventEmitterMap_["onScanditEvent"] = std::make_shared<AsyncEventEmitter<id>>();
+        setEventEmitterCallback([&](const std::string &name, id value) {
+          static_cast<AsyncEventEmitter<id> &>(*eventEmitterMap_[name]).emit(value);
+        });
+  }
+} // namespace facebook::react

package/ios/generated/ScanditReactNativeDatacaptureParserSpec/ScanditReactNativeDatacaptureParserSpec.h

@@ -0,0 +1,103 @@
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * @generated by codegen project: GenerateModuleObjCpp
+ *
+ * We create an umbrella header (and corresponding implementation) here since
+ * Cxx compilation in BUCK has a limitation: source-code producing genrule()s
+ * must have a single output. More files => more genrule()s => slower builds.
+ */
+
+#ifndef __cplusplus
+#error This file must be compiled as Obj-C++. If you are importing it, you must change your file extension to .mm.
+#endif
+
+// Avoid multiple includes of ScanditReactNativeDatacaptureParserSpec symbols
+#ifndef ScanditReactNativeDatacaptureParserSpec_H
+#define ScanditReactNativeDatacaptureParserSpec_H
+
+#import <Foundation/Foundation.h>
+#import <RCTRequired/RCTRequired.h>
+#import <RCTTypeSafety/RCTConvertHelpers.h>
+#import <RCTTypeSafety/RCTTypedModuleConstants.h>
+#import <React/RCTBridgeModule.h>
+#import <React/RCTCxxConvert.h>
+#import <React/RCTManagedPointer.h>
+#import <ReactCommon/RCTTurboModule.h>
+#import <optional>
+#import <vector>
+
+
+NS_ASSUME_NONNULL_BEGIN
+namespace JS {
+  namespace NativeScanditDataCaptureParser {
+    struct Constants {
+
+      struct Builder {
+        // Backwards compat for RCTTypedModuleConstants
+        using ResultT = Constants;
+
+        struct Input {
+          RCTRequired<id<NSObject>> Defaults;
+        };
+
+        /** Initialize with a set of values */
+        Builder(const Input i);
+        /** Initialize with an existing Constants */
+        Builder(Constants i);
+        /** Builds the object. Generally used only by the infrastructure. */
+        NSDictionary *buildUnsafeRawValue() const { return _factory(); };
+      private:
+        NSDictionary *(^_factory)(void);
+      };
+
+      static Constants fromUnsafeRawValue(NSDictionary *const v) { return {v}; }
+      NSDictionary *unsafeRawValue() const { return _v; }
+    private:
+      Constants(NSDictionary *const v) : _v(v) {}
+      NSDictionary *_v;
+    };
+  }
+}
+@protocol NativeScanditDataCaptureParserSpec <RCTBridgeModule, RCTTurboModule>
+
+- (void)executeParser:(NSDictionary *)data
+              resolve:(RCTPromiseResolveBlock)resolve
+               reject:(RCTPromiseRejectBlock)reject;
+- (facebook::react::ModuleConstants<JS::NativeScanditDataCaptureParser::Constants::Builder>)constantsToExport;
+- (facebook::react::ModuleConstants<JS::NativeScanditDataCaptureParser::Constants::Builder>)getConstants;
+
+@end
+
+@interface NativeScanditDataCaptureParserSpecBase : NSObject {
+@protected
+facebook::react::EventEmitterCallback _eventEmitterCallback;
+}
+- (void)setEventEmitterCallback:(EventEmitterCallbackWrapper *)eventEmitterCallbackWrapper;
+
+- (void)emitOnScanditEvent:(NSDictionary *)value;
+@end
+
+namespace facebook::react {
+  /**
+   * ObjC++ class for module 'NativeScanditDataCaptureParser'
+   */
+  class JSI_EXPORT NativeScanditDataCaptureParserSpecJSI : public ObjCTurboModule {
+  public:
+    NativeScanditDataCaptureParserSpecJSI(const ObjCTurboModule::InitParams &params);
+  };
+} // namespace facebook::react
+inline JS::NativeScanditDataCaptureParser::Constants::Builder::Builder(const Input i) : _factory(^{
+  NSMutableDictionary *d = [NSMutableDictionary new];
+  auto Defaults = i.Defaults.get();
+  d[@"Defaults"] = Defaults;
+  return d;
+}) {}
+inline JS::NativeScanditDataCaptureParser::Constants::Builder::Builder(Constants i) : _factory(^{
+  return i.unsafeRawValue();
+}) {}
+NS_ASSUME_NONNULL_END
+#endif // ScanditReactNativeDatacaptureParserSpec_H

package/ios/generated/ScanditReactNativeDatacaptureParserSpecJSI-generated.cpp

@@ -0,0 +1,33 @@
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * @generated by codegen project: GenerateModuleCpp.js
+ */
+
+#include "ScanditReactNativeDatacaptureParserSpecJSI.h"
+
+namespace facebook::react {
+
+static jsi::Value __hostFunction_NativeScanditDataCaptureParserCxxSpecJSI_getConstants(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
+  return static_cast<NativeScanditDataCaptureParserCxxSpecJSI *>(&turboModule)->getConstants(
+    rt
+  );
+}
+static jsi::Value __hostFunction_NativeScanditDataCaptureParserCxxSpecJSI_executeParser(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
+  return static_cast<NativeScanditDataCaptureParserCxxSpecJSI *>(&turboModule)->executeParser(
+    rt,
+    count <= 0 ? throw jsi::JSError(rt, "Expected argument in position 0 to be passed") : args[0].asObject(rt)
+  );
+}
+
+NativeScanditDataCaptureParserCxxSpecJSI::NativeScanditDataCaptureParserCxxSpecJSI(std::shared_ptr<CallInvoker> jsInvoker)
+  : TurboModule("ScanditDataCaptureParser", jsInvoker) {
+  methodMap_["getConstants"] = MethodMetadata {0, __hostFunction_NativeScanditDataCaptureParserCxxSpecJSI_getConstants};
+  methodMap_["executeParser"] = MethodMetadata {1, __hostFunction_NativeScanditDataCaptureParserCxxSpecJSI_executeParser};
+}
+
+
+} // namespace facebook::react

package/ios/generated/ScanditReactNativeDatacaptureParserSpecJSI.h

@@ -0,0 +1,151 @@
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * @generated by codegen project: GenerateModuleH.js
+ */
+
+#pragma once
+
+#include <ReactCommon/TurboModule.h>
+#include <react/bridging/Bridging.h>
+
+namespace facebook::react {
+
+
+  
+#pragma mark - NativeScanditDataCaptureParserScanditEventPayload
+
+template <typename P0, typename P1, typename P2, typename P3>
+struct NativeScanditDataCaptureParserScanditEventPayload {
+  P0 name;
+  P1 data;
+  P2 viewId;
+  P3 modeId;
+  bool operator==(const NativeScanditDataCaptureParserScanditEventPayload &other) const {
+    return name == other.name && data == other.data && viewId == other.viewId && modeId == other.modeId;
+  }
+};
+
+template <typename T>
+struct NativeScanditDataCaptureParserScanditEventPayloadBridging {
+  static T types;
+
+  static T fromJs(
+      jsi::Runtime &rt,
+      const jsi::Object &value,
+      const std::shared_ptr<CallInvoker> &jsInvoker) {
+    T result{
+      bridging::fromJs<decltype(types.name)>(rt, value.getProperty(rt, "name"), jsInvoker),
+      bridging::fromJs<decltype(types.data)>(rt, value.getProperty(rt, "data"), jsInvoker),
+      bridging::fromJs<decltype(types.viewId)>(rt, value.getProperty(rt, "viewId"), jsInvoker),
+      bridging::fromJs<decltype(types.modeId)>(rt, value.getProperty(rt, "modeId"), jsInvoker)};
+    return result;
+  }
+
+#ifdef DEBUG
+  static jsi::String nameToJs(jsi::Runtime &rt, decltype(types.name) value) {
+    return bridging::toJs(rt, value);
+  }
+
+  static jsi::String dataToJs(jsi::Runtime &rt, decltype(types.data) value) {
+    return bridging::toJs(rt, value);
+  }
+
+  static double viewIdToJs(jsi::Runtime &rt, decltype(types.viewId) value) {
+    return bridging::toJs(rt, value);
+  }
+
+  static double modeIdToJs(jsi::Runtime &rt, decltype(types.modeId) value) {
+    return bridging::toJs(rt, value);
+  }
+#endif
+
+  static jsi::Object toJs(
+      jsi::Runtime &rt,
+      const T &value,
+      const std::shared_ptr<CallInvoker> &jsInvoker) {
+    auto result = facebook::jsi::Object(rt);
+    result.setProperty(rt, "name", bridging::toJs(rt, value.name, jsInvoker));
+    result.setProperty(rt, "data", bridging::toJs(rt, value.data, jsInvoker));
+    if (value.viewId) {
+      result.setProperty(rt, "viewId", bridging::toJs(rt, value.viewId.value(), jsInvoker));
+    }
+    if (value.modeId) {
+      result.setProperty(rt, "modeId", bridging::toJs(rt, value.modeId.value(), jsInvoker));
+    }
+    return result;
+  }
+};
+
+class JSI_EXPORT NativeScanditDataCaptureParserCxxSpecJSI : public TurboModule {
+protected:
+  NativeScanditDataCaptureParserCxxSpecJSI(std::shared_ptr<CallInvoker> jsInvoker);
+
+public:
+  virtual jsi::Object getConstants(jsi::Runtime &rt) = 0;
+  virtual jsi::Value executeParser(jsi::Runtime &rt, jsi::Object data) = 0;
+
+};
+
+template <typename T>
+class JSI_EXPORT NativeScanditDataCaptureParserCxxSpec : public TurboModule {
+public:
+  jsi::Value create(jsi::Runtime &rt, const jsi::PropNameID &propName) override {
+    return delegate_.create(rt, propName);
+  }
+
+  std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime& runtime) override {
+    return delegate_.getPropertyNames(runtime);
+  }
+
+  static constexpr std::string_view kModuleName = "ScanditDataCaptureParser";
+
+protected:
+  NativeScanditDataCaptureParserCxxSpec(std::shared_ptr<CallInvoker> jsInvoker)
+    : TurboModule(std::string{NativeScanditDataCaptureParserCxxSpec::kModuleName}, jsInvoker),
+      delegate_(reinterpret_cast<T*>(this), jsInvoker) {}
+
+  template <typename OnScanditEventType> void emitOnScanditEvent(OnScanditEventType value) {
+    static_assert(bridging::supportsFromJs<OnScanditEventType, jsi::Object>, "value cannnot be converted to jsi::Object");
+    static_cast<AsyncEventEmitter<jsi::Value>&>(*delegate_.eventEmitterMap_["onScanditEvent"]).emit([jsInvoker = jsInvoker_, eventValue = value](jsi::Runtime& rt) -> jsi::Value {
+      return bridging::toJs(rt, eventValue, jsInvoker);
+    });
+  }
+
+private:
+  class Delegate : public NativeScanditDataCaptureParserCxxSpecJSI {
+  public:
+    Delegate(T *instance, std::shared_ptr<CallInvoker> jsInvoker) :
+      NativeScanditDataCaptureParserCxxSpecJSI(std::move(jsInvoker)), instance_(instance) {
+      eventEmitterMap_["onScanditEvent"] = std::make_shared<AsyncEventEmitter<jsi::Value>>();
+    }
+
+    jsi::Object getConstants(jsi::Runtime &rt) override {
+      static_assert(
+          bridging::getParameterCount(&T::getConstants) == 1,
+          "Expected getConstants(...) to have 1 parameters");
+
+      return bridging::callFromJs<jsi::Object>(
+          rt, &T::getConstants, jsInvoker_, instance_);
+    }
+    jsi::Value executeParser(jsi::Runtime &rt, jsi::Object data) override {
+      static_assert(
+          bridging::getParameterCount(&T::executeParser) == 2,
+          "Expected executeParser(...) to have 2 parameters");
+
+      return bridging::callFromJs<jsi::Value>(
+          rt, &T::executeParser, jsInvoker_, instance_, std::move(data));
+    }
+
+  private:
+    friend class NativeScanditDataCaptureParserCxxSpec;
+    T *instance_;
+  };
+
+  Delegate delegate_;
+};
+
+} // namespace facebook::react

package/package.json

@@ -1,18 +1,16 @@
 {
   "name": "scandit-react-native-datacapture-parser",
-  "version": "8.2.1",
+  "version": "8.3.0",
   "description": "Scandit Data Capture SDK for React Native",
   "homepage": "https://github.com/Scandit/scandit-react-native-datacapture-parser",
   "main": "dist/index.js",
   "types": "dist/dts/index.d.ts",
   "flow": "dist/index.js.flow",
   "scripts": {
-    "test": "pnpm run lint",
-    "lint": "eslint --debug ts",
-    "build": "pnpm run rollup && pnpm run generate-flow",
-    "rollup": "rollup -c rollup.config.js --bundleConfigAsCjs",
+    "build": "rollup -c ../../rollup.config.js --bundleConfigAsCjs",
     "generate-flow": "flowgen dist/dts/index.d.ts -o dist/index.js.flow",
-    "start": "pnpm build -- --watch"
+    "test": "pnpm run lint",
+    "lint": "eslint ts"
   },
   "keywords": [
     "scandit",
@@ -33,13 +31,28 @@
     "@rollup/plugin-typescript": "11.1.3",
     "flowgen": "^1.21.0",
     "rollup": "3.29.2",
-    "rollup-plugin-modify": "3.0.0",
     "typescript": "4.9.5"
   },
   "dependencies": {
-    "scandit-datacapture-frameworks-core": "8.2.1",
-    "scandit-datacapture-frameworks-parser": "8.2.1",
-    "scandit-react-native-datacapture-core": "8.2.1"
+    "scandit-datacapture-frameworks-core": "8.3.0",
+    "scandit-datacapture-frameworks-parser": "8.3.0",
+    "scandit-react-native-datacapture-core": "8.3.0"
   },
-  "packageManager": "pnpm@10.15.0"
+  "packageManager": "pnpm@10.15.0",
+  "codegenConfig": {
+    "name": "ScanditReactNativeDatacaptureParserSpec",
+    "type": "modules",
+    "jsSrcsDir": "specs",
+    "outputDir": {
+      "ios": "ios/generated",
+      "android": "android/generated"
+    },
+    "includesGeneratedCode": true,
+    "android": {
+      "javaPackageName": "com.scandit.datacapture.reactnative.parser"
+    },
+    "ios": {
+      "unstableRequiresMainQueueSetup": true
+    }
+  }
 }