dynamsoft-capture-vision-react-native 3.0.5201 → 3.2.3000

package/ios/RNDynamsoftImageManager.mm

@@ -40,7 +40,8 @@ using namespace std;
 
 RCT_EXPORT_MODULE(DynamsoftImageManagerModule)
 
-#pragma mark - Global
+#pragma mark - Global JSI
+// --- RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(install) ---
 RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(install)
 {
     RCTBridge* bridge = [RCTBridge currentBridge];
@@ -57,93 +58,306 @@ RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(install)
     return @true;
 }
 
+// --- Helper Functions and Lambdas ---
+static void installHostFunction(
+    jsi::Runtime &jsiRuntime,
+    const char* name,
+    size_t argCount,
+    HostFunctionType hostFunction) {
+    
+    auto func = Function::createFromHostFunction(
+        jsiRuntime,
+        PropNameID::forAscii(jsiRuntime, name),
+        argCount,
+        std::move(hostFunction)
+    );
+    jsiRuntime.global().setProperty(jsiRuntime, name, std::move(func));
+}
+
+// --- JSI Installation Logic ---
 static void install(jsi::Runtime &jsiRuntime, RNDynamsoftImageManager *rnManager) {
-    const char* saveToFileName = "imageManager_saveToFile";
-    auto saveToFileFunc = Function::createFromHostFunction(jsiRuntime,
-                                                          PropNameID::forAscii(jsiRuntime,
-                                                                               saveToFileName),
-                                                          3,
-                                                          [rnManager](Runtime &runtime,
-                                                                   const Value& /*thisValue*/,
-                                                                   const Value* arguments,
-                                                                   size_t count) -> Value {
-        Object obj = arguments[0].getObject(runtime);
-        if (obj.isHostObject<ImageDataHostObject>(runtime)) {
-            ImageDataHostObject hostObject = ImageDataHostObject::getHOFromObject(runtime, std::move(obj));
-            DSImageData *data = [DSImageData imageDataFromHostObject:hostObject];
-            NSString *path = convertJSIStringToNSString(runtime, arguments[1].getString(runtime));
-            bool overWrite = arguments[2].getBool();
-            NSError *error;
-            BOOL isSuccess = [rnManager.manager saveToFile:data path:path overWrite:overWrite error:&error];
-            if (isSuccess && !error) {
-                return Value(true);
-            }
+    using namespace jsi;
+
+    // 1. Helper Lambda: Extract ImageDataHostObject from JSI Value
+    auto getHostImageData = [&](Runtime &runtime, const Value &value) -> std::optional<ImageDataHostObject> {
+        // Optimization: isObject() check does not require runtime
+        if (!value.isObject()) return std::nullopt;
+        auto obj = value.getObject(runtime);
+        // isHostObject<> requires runtime
+        if (!obj.isHostObject<ImageDataHostObject>(runtime)) return std::nullopt;
+        return ImageDataHostObject::getHOFromObject(runtime, obj);
+    };
+
+    // 2. Helper Lambda: Create JSI Host Object from DSImageData and return
+    auto createJsiHostObject = [&](Runtime &runtime, DSImageData *imageData) -> Value {
+        if (!imageData) return Value::null();
+        auto host = [imageData hostObject];
+        return Object::createFromHostObject(runtime, std::make_shared<ImageDataHostObject>(host));
+    };
+
+    // imageIO_readFromFile(path)
+    installHostFunction(jsiRuntime, "imageIO_readFromFile", 1,
+        [rnManager, createJsiHostObject](Runtime &runtime, const Value &, const Value *args, size_t count) -> Value {
+            // Check count and type (isString() does not need runtime)
+            if (count < 1 || !args[0].isString()) return Value::null();
+
+            NSString *path = convertJSIStringToNSString(runtime, args[0].getString(runtime));
+            NSError *error = nil;
+            DSImageData *imageData = [rnManager.manager readFromFile:path error:&error];
+            
+            return createJsiHostObject(runtime, imageData);
         }
-        return Value(false);
-    });
-    jsiRuntime.global().setProperty(jsiRuntime, saveToFileName, std::move(saveToFileFunc));
+    );
+
+    // imageIO_saveToFile(imageData, path, overwrite)
+    installHostFunction(jsiRuntime, "imageIO_saveToFile", 3,
+        [rnManager, getHostImageData](Runtime &runtime, const Value &, const Value *args, size_t count) -> Value {
+            // Check count, data object (isObject() does not need runtime) and path (isString() does not need runtime)
+            if (count < 3 || !args[1].isString() || !args[2].isBool()) return Value(false);
+
+            auto hostOpt = getHostImageData(runtime, args[0]);
+            if (!hostOpt) return Value(false);
+
+            DSImageData *data = [DSImageData imageDataFromHostObject:*hostOpt];
+            NSString *path = convertJSIStringToNSString(runtime, args[1].getString(runtime));
+            bool overwrite = args[2].getBool();
+
+            NSError *error = nil;
+            BOOL success = [rnManager.manager saveToFile:data path:path overWrite:overwrite error:&error];
+            return Value(success && !error);
+        }
+    );
     
-    const char* drawOnImageName = "imageManager_drawOnImage";
-    auto drawOnImageFunc = Function::createFromHostFunction(jsiRuntime,
-                                                    PropNameID::forAscii(jsiRuntime,
-                                                                         drawOnImageName),
-                                                    4,
-                                                    [rnManager](Runtime &runtime,
-                                                             const Value& /*thisValue*/,
-                                                             const Value* arguments,
-                                                             size_t count) -> Value {
-        Object obj = arguments[0].getObject(runtime);
-        if (obj.isHostObject<ImageDataHostObject>(runtime)) {
-            ImageDataHostObject hostObject = ImageDataHostObject::getHOFromObject(runtime, std::move(obj));
-            DSImageData *data = [DSImageData imageDataFromHostObject:hostObject];
-            Array array = arguments[1].getObject(runtime).getArray(runtime);
-            size_t size = array.size(runtime);
-            NSMutableArray<DSQuadrilateral *> *mutableArray = [NSMutableArray array];
-            for (size_t i = 0; i < size; i++) {
-                if (array.getValueAtIndex(runtime, i).isObject()) {
-                    DSQuadrilateral *quad = convertJSIValueToDSQuadrilateral(runtime, array.getValueAtIndex(runtime, i).getObject(runtime));
-                    [mutableArray addObject:quad];
+    // imageIO_readFromMemory(arrayBuffer)
+    installHostFunction(jsiRuntime, "imageIO_readFromMemory", 1,
+        [rnManager, createJsiHostObject](Runtime &runtime, const Value &, const Value *args, size_t count) -> Value {
+            // Check count and type (isObject() does not need runtime)
+            if (count < 1 || !args[0].isObject()) return Value::null();
+
+            jsi::Object jsObj = args[0].getObject(runtime);
+            // isArrayBuffer() requires runtime
+            if (!jsObj.isArrayBuffer(runtime)) return Value::null();
+
+            jsi::ArrayBuffer buffer = jsObj.getArrayBuffer(runtime);
+            NSData *data = convertArrayBufferToNSData(runtime, buffer);
+            if (!data || data.length == 0) return Value::null();
+
+            NSError *error = nil;
+            DSImageData *imageData = [rnManager.manager readFromMemory:data error:&error];
+            
+            return createJsiHostObject(runtime, imageData);
+        }
+    );
+    
+    // imageIO_saveToMemory(imageData, format)
+    installHostFunction(jsiRuntime, "imageIO_saveToMemory", 2,
+        [rnManager, getHostImageData](Runtime &runtime, const Value &, const Value *args, size_t count) -> Value {
+            // Check count and format type (isNumber() does not need runtime)
+            if (count < 2 || !args[1].isNumber()) return Value::null();
+
+            auto hostOpt = getHostImageData(runtime, args[0]);
+            if (!hostOpt) return Value::null();
+
+            DSImageData *imageData = [DSImageData imageDataFromHostObject:*hostOpt];
+            NSInteger format = args[1].asNumber(); // Enum is passed as number
+            NSError *error = nil;
+
+            NSData *data = [rnManager.manager saveToMemory:imageData imageFormat:(DSImageFileFormat)format error:&error];
+            if (!data || error) return Value::null();
+
+            // Note: converNSDataToArrayBuffer is assumed to be defined elsewhere and is correct
+            return Value(converNSDataToArrayBuffer(runtime, data));
+        }
+    );
+
+    // Helper lambda for simple image processing functions (2 arguments: data, value)
+    auto processImageTwoArg =
+        [rnManager, getHostImageData, createJsiHostObject](
+            Runtime &runtime,
+            const Value *args,
+            size_t count,
+            std::function<DSImageData*(DSImageData*, NSInteger)> processorBlock
+        ) -> Value {
+            if (count < 2 || !args[1].isNumber()) return Value::null();
+            auto hostOpt = getHostImageData(runtime, args[0]);
+            if (!hostOpt) return Value::null();
+
+            NSInteger arg2 = args[1].asNumber();
+            DSImageData *data = [DSImageData imageDataFromHostObject:*hostOpt];
+            DSImageData *outData = processorBlock(data, arg2);
+            
+            return createJsiHostObject(runtime, outData);
+        };
+        
+    // imageProcessor_adjustBrightness(imageData, brightness)
+    installHostFunction(jsiRuntime, "imageProcessor_adjustBrightness", 2,
+        [rnManager, processImageTwoArg](Runtime &runtime, const Value &, const Value *args, size_t count) -> Value {
+            return processImageTwoArg(runtime, args, count,
+                [rnManager](DSImageData* data, NSInteger brightness) {
+                    return [rnManager.processor adjust:data brightness:brightness];
                 }
-            }
-            NSInteger hexColor = arguments[2].getNumber();
-            int thickness = arguments[3].getNumber();
-            UIColor *color = [UIColor colorWithRed:((hexColor >> 16) & 0xFF) / 255.0
-                                             green:((hexColor >> 8) & 0xFF) / 255.0
-                                              blue:(hexColor & 0xFF) / 255.0
-                                             alpha:((hexColor >> 24) & 0xFF) / 255.0];
-            DSImageData *imageData = [rnManager.drawer drawOnImage:data quads:[mutableArray copy] colour:color thickness:thickness];
-            ImageDataHostObject outImageData = [imageData hostObject];
-            Object outObj = Object::createFromHostObject(runtime, std::make_shared<ImageDataHostObject>(outImageData));
-            return outObj;
+            );
+        }
+    );
+
+    // imageProcessor_adjustContrast(imageData, contrast)
+    installHostFunction(jsiRuntime, "imageProcessor_adjustContrast", 2,
+        [rnManager, processImageTwoArg](Runtime &runtime, const Value &, const Value *args, size_t count) -> Value {
+            return processImageTwoArg(runtime, args, count,
+                [rnManager](DSImageData* data, NSInteger contrast) {
+                    return [rnManager.processor adjust:data contrast:contrast];
+                }
+            );
         }
-        return Value(false);
-    });
-    jsiRuntime.global().setProperty(jsiRuntime, drawOnImageName, std::move(drawOnImageFunc));
+    );
+
+    // imageProcessor_filterImage(imageData, filterType)
+    installHostFunction(jsiRuntime, "imageProcessor_filterImage", 2,
+        [rnManager, processImageTwoArg](Runtime &runtime, const Value &, const Value *args, size_t count) -> Value {
+            return processImageTwoArg(runtime, args, count,
+                [rnManager](DSImageData* data, NSInteger filterType) {
+                    return [rnManager.processor filterImage:data filterType:(DSFilterType)filterType];
+                }
+            );
+        }
+    );
+
+    // imageProcessor_cropImage(imageData, rect)
+    installHostFunction(jsiRuntime, "imageProcessor_cropImage", 2,
+        [rnManager, getHostImageData, createJsiHostObject](Runtime &runtime, const Value &, const Value *args, size_t count) -> Value {
+            // Check count and rect object (isObject() does not need runtime)
+            if (count < 2 || !args[1].isObject()) return Value::null();
+            auto hostOpt = getHostImageData(runtime, args[0]);
+            if (!hostOpt) return Value::null();
+
+            DSImageData *data = [DSImageData imageDataFromHostObject:*hostOpt];
+            DSRect *rect = convertJSIValueToDSRect(runtime, args[1].getObject(runtime));
+
+            NSError *error = nil;
+            DSImageData *outData = [rnManager.processor cropImage:data rect:rect error:&error];
+
+            return createJsiHostObject(runtime, outData);
+        }
+    );
+
+    // imageProcessor_cropAndDeskewImage(data, quad, dstWidth, dstHeight, padding)
+    installHostFunction(jsiRuntime, "imageProcessor_cropAndDeskewImage", 5,
+        [rnManager, getHostImageData, createJsiHostObject](Runtime &runtime, const Value &, const Value *args, size_t count) -> Value {
+            // Check count, quad object, and number types (isObject()/isNumber() do not need runtime)
+            if (count < 5 || !args[1].isObject() || !args[2].isNumber() || !args[3].isNumber() || !args[4].isNumber()) return Value::null();
+            auto hostOpt = getHostImageData(runtime, args[0]);
+            if (!hostOpt) return Value::null();
+
+            DSImageData *data = [DSImageData imageDataFromHostObject:*hostOpt];
+            DSQuadrilateral *quad = convertJSIValueToDSQuadrilateral(runtime, args[1].getObject(runtime));
+            NSInteger dstWidth = args[2].asNumber();
+            NSInteger dstHeight = args[3].asNumber();
+            NSInteger padding = args[4].asNumber();
+            
+            NSError *error = nil;
+            DSImageData *outData = [rnManager.processor cropAndDeskewImage:data quad:quad dstWidth:dstWidth dstHeight:dstHeight padding:padding error:&error];
+
+            return createJsiHostObject(runtime, outData);
+        }
+    );
     
-    const char* cropImageName = "imageManager_cropImage";
-    auto cropImageFunc = Function::createFromHostFunction(jsiRuntime,
-                                                    PropNameID::forAscii(jsiRuntime,
-                                                                         cropImageName),
-                                                    2,
-                                                    [rnManager](Runtime &runtime,
-                                                             const Value& /*thisValue*/,
-                                                             const Value* arguments,
-                                                             size_t count) -> Value {
-        Object obj = arguments[0].getObject(runtime);
-        if (obj.isHostObject<ImageDataHostObject>(runtime)) {
-            ImageDataHostObject hostObject = ImageDataHostObject::getHOFromObject(runtime, std::move(obj));
-            DSImageData *data = [DSImageData imageDataFromHostObject:hostObject];
-            Object obj = arguments[1].getObject(runtime);
-            DSQuadrilateral *quad = convertJSIValueToDSQuadrilateral(runtime, obj);
-            NSError *error;
-            DSImageData *imageData = [rnManager.processor cropAndDeskewImage:data quad:quad error:&error];
-            ImageDataHostObject outImageData = [imageData hostObject];
-            Object outObj = Object::createFromHostObject(runtime, std::make_shared<ImageDataHostObject>(outImageData));
-            return outObj;
+    // imageProcessor_convertToGray(imageData, r, g, b)
+    installHostFunction(jsiRuntime, "imageProcessor_convertToGray", 4,
+        [rnManager, getHostImageData, createJsiHostObject](Runtime &runtime, const Value &, const Value *args, size_t count) -> Value {
+            // Check count and float types
+            if (count < 4 || !args[1].isNumber() || !args[2].isNumber() || !args[3].isNumber()) return Value::null();
+            auto hostOpt = getHostImageData(runtime, args[0]);
+            if (!hostOpt) return Value::null();
+
+            CGFloat r = args[1].asNumber();
+            CGFloat g = args[2].asNumber();
+            CGFloat b = args[3].asNumber();
+
+            DSImageData *data = [DSImageData imageDataFromHostObject:*hostOpt];
+            DSImageData *outData = [rnManager.processor convertToGray:data r:r g:g b:b];
+
+            return createJsiHostObject(runtime, outData);
+        }
+    );
+
+    // imageProcessor_convertToBinaryGlobal(imageData, threshold, invert)
+    installHostFunction(jsiRuntime, "imageProcessor_convertToBinaryGlobal", 3,
+        [rnManager, getHostImageData, createJsiHostObject](Runtime &runtime, const Value &, const Value *args, size_t count) -> Value {
+            // Check count, number, and bool types
+            if (count < 3 || !args[1].isNumber() || !args[2].isBool()) return Value::null();
+            auto hostOpt = getHostImageData(runtime, args[0]);
+            if (!hostOpt) return Value::null();
+
+            NSInteger threshold = args[1].asNumber();
+            BOOL invert = args[2].getBool();
+
+            DSImageData *data = [DSImageData imageDataFromHostObject:*hostOpt];
+            DSImageData *outData = [rnManager.processor convertToBinaryGlobal:data threshold:threshold invert:invert];
+
+            return createJsiHostObject(runtime, outData);
+        }
+    );
+
+    // imageProcessor_convertToBinaryLocal(imageData, blockSize, compensation, invert)
+    installHostFunction(jsiRuntime, "imageProcessor_convertToBinaryLocal", 4,
+        [rnManager, getHostImageData, createJsiHostObject](Runtime &runtime, const Value &, const Value *args, size_t count) -> Value {
+            // Check count, number, number, and bool types
+            if (count < 4 || !args[1].isNumber() || !args[2].isNumber() || !args[3].isBool()) return Value::null();
+            auto hostOpt = getHostImageData(runtime, args[0]);
+            if (!hostOpt) return Value::null();
+
+            NSInteger blockSize = args[1].asNumber();
+            NSInteger compensation = args[2].asNumber();
+            BOOL invert = args[3].getBool();
+
+            DSImageData *data = [DSImageData imageDataFromHostObject:*hostOpt];
+            DSImageData *outData = [rnManager.processor convertToBinaryLocal:data blockSize:blockSize compensation:compensation invert:invert];
+            
+            return createJsiHostObject(runtime, outData);
+        }
+    );
+
+    // imageDrawer_drawOnImage(data, quads, hexColor, thickness)
+    installHostFunction(jsiRuntime, "imageDrawer_drawOnImage", 4,
+        [rnManager, getHostImageData, createJsiHostObject](Runtime &runtime, const Value &, const Value *args, size_t count) -> Value {
+            // Check count, quads array object, color number, and thickness number
+            if (count < 4 || !args[1].isObject() || !args[2].isNumber() || !args[3].isNumber()) return Value::null();
+            auto hostOpt = getHostImageData(runtime, args[0]);
+            if (!hostOpt) return Value::null();
+
+            DSImageData *data = [DSImageData imageDataFromHostObject:*hostOpt];
+            
+            // Validate and extract array
+            Object jsArrayObj = args[1].getObject(runtime);
+            if (!jsArrayObj.isArray(runtime)) return Value::null();
+            Array jsArray = jsArrayObj.getArray(runtime);
+            size_t size = jsArray.size(runtime);
+
+            NSMutableArray<DSQuadrilateral *> *quads = [NSMutableArray arrayWithCapacity:size];
+            for (size_t i = 0; i < size; i++) {
+                auto val = jsArray.getValueAtIndex(runtime, i);
+                // Check if element is an object before conversion
+                if (val.isObject()) {
+                    DSQuadrilateral *quad = convertJSIValueToDSQuadrilateral(runtime, val.getObject(runtime));
+                    [quads addObject:quad];
+                }
+            }
+
+            // Extract colour and thickness
+            NSInteger hex = args[2].asNumber();
+            int thickness = args[3].asNumber();
+            
+            // Original logic for color conversion is correct
+            UIColor *color = [UIColor colorWithRed:((hex >> 16) & 0xFF) / 255.0
+                                            green:((hex >> 8) & 0xFF) / 255.0
+                                             blue:(hex & 0xFF) / 255.0
+                                            alpha:((hex >> 24) & 0xFF) / 255.0];
+
+            DSImageData *outData = [rnManager.drawer drawOnImage:data quads:[quads copy] colour:color thickness:thickness];
+            
+            return createJsiHostObject(runtime, outData);
         }
-        return Value(false);
-    });
-    jsiRuntime.global().setProperty(jsiRuntime, cropImageName, std::move(cropImageFunc));
+    );
 }
 
 @end

package/ios/RNDynamsoftImageSourceAdapter.mm

@@ -114,7 +114,24 @@ RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(hasImage:(NSString *)key imageId:(NSInteg
     return @([[self.isaDictionary valueForKey:key] hasImage:imageId]);
 }
 
-#pragma mark - Global
+#pragma mark - Private
+- (NSMutableDictionary<NSString *,DSImageSourceAdapter *> *)isaDictionary {
+    if (!_isaDictionary) {
+        _isaDictionary = [[NSMutableDictionary alloc] init];
+    }
+    return _isaDictionary;
+}
+
+- (void)addImage:(DSImageData *)data toISA:(NSString *)key {
+    [[self.isaDictionary valueForKey:key] addImageToBuffer:data];
+}
+
+- (DSImageData *)imageDataFromISA:(NSString *)key {
+    return [[self.isaDictionary valueForKey:key] getImage];
+}
+
+#pragma mark - Global JSI
+// --- RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(install) ---
 RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(install)
 {
     RCTBridge* bridge = [RCTBridge currentBridge];
@@ -131,84 +148,102 @@ RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(install)
     return @true;
 }
 
+// --- Helper Functions and Lambdas ---
+static void installHostFunction(
+    jsi::Runtime &jsiRuntime,
+    const char* name,
+    size_t argCount,
+    HostFunctionType hostFunction) {
+    
+    auto func = Function::createFromHostFunction(
+        jsiRuntime,
+        PropNameID::forAscii(jsiRuntime, name),
+        argCount,
+        std::move(hostFunction)
+    );
+    jsiRuntime.global().setProperty(jsiRuntime, name, std::move(func));
+}
+
+// --- JSI Installation Logic ---
 static void install(jsi::Runtime &jsiRuntime, RNDynamsoftImageSourceAdapter *rnAdapter) {
-    const char* getImageDataName = "isaGetImageData";
-    auto getImageDataFunc = Function::createFromHostFunction(jsiRuntime,
-                                                          PropNameID::forAscii(jsiRuntime,
-                                                                               getImageDataName),
-                                                          1,
-                                                          [rnAdapter](Runtime &runtime,
-                                                                   const Value &thisValue,
-                                                                   const Value *arguments,
-                                                                   size_t count) -> Value {
-        NSString *key = convertJSIStringToNSString(runtime, arguments[0].getString(runtime));
-        ImageDataHostObject hostObject = [[rnAdapter imageDataFromISA:key] hostObject];
-        Object obj = Object::createFromHostObject(runtime, std::make_shared<ImageDataHostObject>(hostObject));
-        return obj;
-    });
-    jsiRuntime.global().setProperty(jsiRuntime, getImageDataName, std::move(getImageDataFunc));
+    using namespace jsi;
+
+    // Helper Lambda: Extract ImageDataHostObject from JSI Value
+    auto getHostImageData = [&](Runtime &runtime, const Value &value) -> std::optional<ImageDataHostObject> {
+        // Optimization: isObject() check does not require runtime
+        if (!value.isObject()) return std::nullopt;
+        auto obj = value.getObject(runtime);
+        // isHostObject<> requires runtime
+        if (!obj.isHostObject<ImageDataHostObject>(runtime)) return std::nullopt;
+        return ImageDataHostObject::getHOFromObject(runtime, obj);
+    };
+
+    // Helper Lambda: Create JSI Host Object from DSImageData and return
+    auto createJsiHostObject = [&](Runtime &runtime, DSImageData *imageData) -> Value {
+        if (!imageData) return Value::null();
+        auto host = [imageData hostObject];
+        return Object::createFromHostObject(runtime, std::make_shared<ImageDataHostObject>(host));
+    };
     
-    const char* addImageToBufferName = "isaAddImageToBuffer";
-    auto addImageToBufferFunc = Function::createFromHostFunction(jsiRuntime,
-                                                    PropNameID::forAscii(jsiRuntime,
-                                                                         addImageToBufferName),
-                                                    2,
-                                                    [rnAdapter](Runtime &runtime,
-                                                             const Value &thisValue,
-                                                             const Value *arguments,
-                                                             size_t count) -> Value {
-        NSString *key = convertJSIStringToNSString(runtime, arguments[0].getString(runtime));
-        Object obj = arguments[1].getObject(runtime);
-        if (obj.isHostObject<ImageDataHostObject>(runtime)) {
-            ImageDataHostObject hostObject = ImageDataHostObject::getHOFromObject(runtime, std::move(obj));
-            DSImageData *data = [DSImageData imageDataFromHostObject:hostObject];
+    // ---------------------- isaGetImageData ----------------------
+    // isaGetImageData(key)
+    installHostFunction(jsiRuntime, "isaGetImageData", 1,
+        [rnAdapter, createJsiHostObject](Runtime &runtime, const Value &, const Value *arguments, size_t count) -> Value {
+            // 🔍 Argument Validation: Check count and key type (isString() no runtime)
+            if (count != 1 || !arguments[0].isString()) return Value::null();
+
+            NSString *key = convertJSIStringToNSString(runtime, arguments[0].getString(runtime));
+            DSImageData *imageData = [rnAdapter imageDataFromISA:key];
+            
+            return createJsiHostObject(runtime, imageData);
+        }
+    );
+    
+    // ---------------------- isaAddImageToBuffer ----------------------
+    // isaAddImageToBuffer(key, imageData)
+    installHostFunction(jsiRuntime, "isaAddImageToBuffer", 2,
+        [rnAdapter, getHostImageData](Runtime &runtime, const Value &, const Value *arguments, size_t count) -> Value {
+            // 🔍 Argument Validation: Check count and key type (isString() no runtime)
+            if (count != 2 || !arguments[0].isString() || !arguments[1].isObject()) return Value(false);
+
+            auto hostOpt = getHostImageData(runtime, arguments[1]);
+            if (!hostOpt) return Value(false);
+            
+            NSString *key = convertJSIStringToNSString(runtime, arguments[0].getString(runtime));
+            DSImageData *data = [DSImageData imageDataFromHostObject:*hostOpt];
+            
             [rnAdapter addImage:data toISA:key];
             return Value(true);
         }
-        return Value(false);
-    });
-    jsiRuntime.global().setProperty(jsiRuntime, addImageToBufferName, std::move(addImageToBufferFunc));
+    );
     
-    const char* imageDataToBase64Name = "imageDataToBase64";
-    auto imageDataToBase64Func = Function::createFromHostFunction(jsiRuntime,
-                                                          PropNameID::forAscii(jsiRuntime,
-                                                                               imageDataToBase64Name),
-                                                          1,
-                                                          [rnAdapter](Runtime &runtime,
-                                                                   const Value &thisValue,
-                                                                   const Value *arguments,
-                                                                   size_t count) -> Value {
-        Object obj = arguments[0].getObject(runtime);
-        if (obj.isHostObject<ImageDataHostObject>(runtime)) {
-            ImageDataHostObject hostObject = ImageDataHostObject::getHOFromObject(runtime, std::move(obj));
-            DSImageData *imageData = [DSImageData imageDataFromHostObject:hostObject];
+    // ---------------------- imageDataToBase64 ----------------------
+    // imageDataToBase64(imageData)
+    installHostFunction(jsiRuntime, "imageDataToBase64", 1,
+        [getHostImageData](Runtime &runtime, const Value &, const Value *arguments, size_t count) -> Value {
+            // 🔍 Argument Validation: Check count and image object type (isObject() no runtime)
+            if (count != 1 || !arguments[0].isObject()) return Value(false);
+            
+            auto hostOpt = getHostImageData(runtime, arguments[0]);
+            if (!hostOpt) return Value(false);
+
+            DSImageData *imageData = [DSImageData imageDataFromHostObject:*hostOpt];
+            
             NSError *error;
+            // Native code to convert DSImageData to Base64 (using JPEG representation)
             UIImage *image = [imageData toUIImage:&error];
             if (!error && image) {
+                // Compression quality set to 1.0 (highest quality)
                 NSData *data = UIImageJPEGRepresentation(image, 1.0);
                 NSString *base64String = [data base64EncodedStringWithOptions:NSDataBase64Encoding64CharacterLineLength];
+                
+                // convertNSStringToJSIString is assumed to be defined elsewhere
                 return convertNSStringToJSIString(runtime, base64String);
             }
+            
+            return Value(false);
         }
-        return Value(false);
-    });
-    jsiRuntime.global().setProperty(jsiRuntime, imageDataToBase64Name, std::move(imageDataToBase64Func));
-}
-
-#pragma mark - Private
-- (NSMutableDictionary<NSString *,DSImageSourceAdapter *> *)isaDictionary {
-    if (!_isaDictionary) {
-        _isaDictionary = [[NSMutableDictionary alloc] init];
-    }
-    return _isaDictionary;
-}
-
-- (void)addImage:(DSImageData *)data toISA:(NSString *)key {
-    [[self.isaDictionary valueForKey:key] addImageToBuffer:data];
-}
-
-- (DSImageData *)imageDataFromISA:(NSString *)key {
-    return [[self.isaDictionary valueForKey:key] getImage];
+    );
 }
 
 @end

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dynamsoft-capture-vision-react-native",
   "title": "Dynamsoft Capture Vision React Native",
-  "version": "3.0.5201",
+  "version": "3.2.3000",
   "description": "The Dynamsoft Capture Vision React Native SDK provides a wrapper for building barcode scanning, document scanning and MRZ scanning applications with React Native.",
   "homepage": "https://github.com/Dynamsoft/capture-vision-react-native-samples",
   "main": "src/index.tsx",

package/src/core/EnumGrayscaleEnhancementMode.tsx

@@ -7,6 +7,7 @@ import type {SimplifiedLabelRecognizerSettings} from "../dlr";
  * @see {@link SimplifiedLabelRecognizerSettings.grayscaleEnhancementModes}
  */
 export enum EnumGrayscaleEnhancementMode {
+    GEM_END = -1,
   /**
    * Disables any grayscale image preprocessing. Selecting this mode skips the preprocessing step,
    * passing the image through to subsequent operations without modification.

package/src/core/EnumGrayscaleTransformationMode.tsx

@@ -7,6 +7,7 @@ import type {SimplifiedLabelRecognizerSettings} from "../dlr";
  * @see {@link SimplifiedLabelRecognizerSettings.grayscaleEnhancementModes}
  * */
 export enum EnumGrayscaleTransformationMode {
+    GTM_END = -1,
   /**
    * Bypasses grayscale transformation, leaving the image in its current state without any modification to its grayscale values.
    * This mode is selected when no alteration of the grayscale data is desired, passing the image through to subsequent operations without modification.

package/src/core/EnumImageFileFormat.tsx

@@ -0,0 +1,6 @@
+export enum EnumImageFileFormat {
+  IFF_JPEG = 0,
+  IFF_PNG = 1,
+  IFF_BMP = 2,
+  IFF_PDF = 3
+}

package/src/core/index.tsx

@@ -13,5 +13,6 @@ export * from "./ImageData"
 export * from "./ImageSourceAdapter"
 export * from "./Point"
 export * from "./Quadrilateral"
+export * from "./EnumImageFileFormat"