@json-eval-rs/react-native 0.0.54 → 0.0.56

package/android/src/main/cpp/json-eval-rn.cpp

@@ -330,6 +330,82 @@ Java_com_jsonevalrs_JsonEvalRsModule_nativeGetSchemaValueAsync(
     });
 }
 
+JNIEXPORT void JNICALL
+Java_com_jsonevalrs_JsonEvalRsModule_nativeGetSchemaValueArrayAsync(
+    JNIEnv* env,
+    jobject /* this */,
+    jstring handle,
+    jobject promise
+) {
+    std::string handleStr = jstringToString(env, handle);
+    
+    runAsyncWithPromise(env, promise, "GET_SCHEMA_VALUE_ARRAY_ERROR", [handleStr](auto callback) {
+        JsonEvalBridge::getSchemaValueArrayAsync(handleStr, callback);
+    });
+}
+
+JNIEXPORT void JNICALL
+Java_com_jsonevalrs_JsonEvalRsModule_nativeGetSchemaValueObjectAsync(
+    JNIEnv* env,
+    jobject /* this */,
+    jstring handle,
+    jobject promise
+) {
+    std::string handleStr = jstringToString(env, handle);
+    
+    runAsyncWithPromise(env, promise, "GET_SCHEMA_VALUE_OBJECT_ERROR", [handleStr](auto callback) {
+        JsonEvalBridge::getSchemaValueObjectAsync(handleStr, callback);
+    });
+}
+
+JNIEXPORT void JNICALL
+Java_com_jsonevalrs_JsonEvalRsModule_nativeGetSchemaValueSubformAsync(
+    JNIEnv* env,
+    jobject /* this */,
+    jstring handle,
+    jstring subformPath,
+    jobject promise
+) {
+    std::string handleStr = jstringToString(env, handle);
+    std::string subformPathStr = jstringToString(env, subformPath);
+    
+    runAsyncWithPromise(env, promise, "GET_SCHEMA_VALUE_SUBFORM_ERROR", [handleStr, subformPathStr](auto callback) {
+        JsonEvalBridge::getSchemaValueSubformAsync(handleStr, subformPathStr, callback);
+    });
+}
+
+JNIEXPORT void JNICALL
+Java_com_jsonevalrs_JsonEvalRsModule_nativeGetSchemaValueArraySubformAsync(
+    JNIEnv* env,
+    jobject /* this */,
+    jstring handle,
+    jstring subformPath,
+    jobject promise
+) {
+    std::string handleStr = jstringToString(env, handle);
+    std::string subformPathStr = jstringToString(env, subformPath);
+    
+    runAsyncWithPromise(env, promise, "GET_SCHEMA_VALUE_ARRAY_SUBFORM_ERROR", [handleStr, subformPathStr](auto callback) {
+        JsonEvalBridge::getSchemaValueArraySubformAsync(handleStr, subformPathStr, callback);
+    });
+}
+
+JNIEXPORT void JNICALL
+Java_com_jsonevalrs_JsonEvalRsModule_nativeGetSchemaValueObjectSubformAsync(
+    JNIEnv* env,
+    jobject /* this */,
+    jstring handle,
+    jstring subformPath,
+    jobject promise
+) {
+    std::string handleStr = jstringToString(env, handle);
+    std::string subformPathStr = jstringToString(env, subformPath);
+    
+    runAsyncWithPromise(env, promise, "GET_SCHEMA_VALUE_OBJECT_SUBFORM_ERROR", [handleStr, subformPathStr](auto callback) {
+        JsonEvalBridge::getSchemaValueObjectSubformAsync(handleStr, subformPathStr, callback);
+    });
+}
+
 JNIEXPORT void JNICALL
 Java_com_jsonevalrs_JsonEvalRsModule_nativeGetEvaluatedSchemaWithoutParamsAsync(
     JNIEnv* env,
@@ -684,6 +760,24 @@ Java_com_jsonevalrs_JsonEvalRsModule_nativeCompileAndRunLogicAsync(
     });
 }
 
+JNIEXPORT void JNICALL
+Java_com_jsonevalrs_JsonEvalRsModule_nativeEvaluateLogicAsync(
+    JNIEnv* env,
+    jobject /* this */,
+    jstring logicStr,
+    jstring data,
+    jstring context,
+    jobject promise
+) {
+    std::string logicStrCpp = jstringToString(env, logicStr);
+    std::string dataStr = jstringToString(env, data);
+    std::string contextStr = jstringToString(env, context);
+    
+    runAsyncWithPromise(env, promise, "EVALUATE_LOGIC_ERROR", [logicStrCpp, dataStr, contextStr](auto callback) {
+        JsonEvalBridge::evaluateLogicAsync(logicStrCpp, dataStr, contextStr, callback);
+    });
+}
+
 // ============================================================================
 // Subform Methods
 // ============================================================================
@@ -770,22 +864,6 @@ Java_com_jsonevalrs_JsonEvalRsModule_nativeGetEvaluatedSchemaSubformAsync(
     });
 }
 
-JNIEXPORT void JNICALL
-Java_com_jsonevalrs_JsonEvalRsModule_nativeGetSchemaValueSubformAsync(
-    JNIEnv* env,
-    jobject /* this */,
-    jstring handle,
-    jstring subformPath,
-    jobject promise
-) {
-    std::string handleStr = jstringToString(env, handle);
-    std::string subformPathStr = jstringToString(env, subformPath);
-    
-    runAsyncWithPromise(env, promise, "GET_SCHEMA_VALUE_SUBFORM_ERROR", [handleStr, subformPathStr](auto callback) {
-        JsonEvalBridge::getSchemaValueSubformAsync(handleStr, subformPathStr, callback);
-    });
-}
-
 JNIEXPORT void JNICALL
 Java_com_jsonevalrs_JsonEvalRsModule_nativeGetEvaluatedSchemaWithoutParamsSubformAsync(
     JNIEnv* env,

package/android/src/main/java/com/jsonevalrs/JsonEvalRsModule.kt

@@ -83,6 +83,22 @@ class JsonEvalRsModule(reactContext: ReactApplicationContext) :
         nativeGetSchemaValueAsync(handle, promise)
     }
 
+    @ReactMethod
+    fun getSchemaValueArray(
+        handle: String,
+        promise: Promise
+    ) {
+        nativeGetSchemaValueArrayAsync(handle, promise)
+    }
+
+    @ReactMethod
+    fun getSchemaValueObject(
+        handle: String,
+        promise: Promise
+    ) {
+        nativeGetSchemaValueObjectAsync(handle, promise)
+    }
+
     @ReactMethod
     fun getEvaluatedSchemaWithoutParams(
         handle: String,
@@ -300,6 +316,16 @@ class JsonEvalRsModule(reactContext: ReactApplicationContext) :
         nativeCompileAndRunLogicAsync(handle, logicStr, data ?: "", context ?: "", promise)
     }
 
+    @ReactMethod
+    fun evaluateLogic(
+        logicStr: String,
+        data: String?,
+        context: String?,
+        promise: Promise
+    ) {
+        nativeEvaluateLogicAsync(logicStr, data ?: "", context ?: "", promise)
+    }
+
     @ReactMethod
     fun compileLogic(
         handle: String,
@@ -387,6 +413,24 @@ class JsonEvalRsModule(reactContext: ReactApplicationContext) :
         nativeGetSchemaValueSubformAsync(handle, subformPath, promise)
     }
 
+    @ReactMethod
+    fun getSchemaValueArraySubform(
+        handle: String,
+        subformPath: String,
+        promise: Promise
+    ) {
+        nativeGetSchemaValueArraySubformAsync(handle, subformPath, promise)
+    }
+
+    @ReactMethod
+    fun getSchemaValueObjectSubform(
+        handle: String,
+        subformPath: String,
+        promise: Promise
+    ) {
+        nativeGetSchemaValueObjectSubformAsync(handle, subformPath, promise)
+    }
+
     @ReactMethod
     fun getEvaluatedSchemaWithoutParamsSubform(
         handle: String,
@@ -485,6 +529,16 @@ class JsonEvalRsModule(reactContext: ReactApplicationContext) :
         nativeCancel(handle)
     }
 
+    @ReactMethod
+    fun version(promise: Promise) {
+        try {
+            val version = nativeVersion()
+            promise.resolve(version)
+        } catch (e: Exception) {
+            promise.reject("VERSION_ERROR", e.message, e)
+        }
+    }
+
     @ReactMethod
     fun multiply(a: Double, b: Double, promise: Promise) {
         promise.resolve(a * b)
@@ -514,6 +568,8 @@ class JsonEvalRsModule(reactContext: ReactApplicationContext) :
     )
     private external fun nativeGetEvaluatedSchemaAsync(handle: String, skipLayout: Boolean, promise: Promise)
     private external fun nativeGetSchemaValueAsync(handle: String, promise: Promise)
+    private external fun nativeGetSchemaValueArrayAsync(handle: String, promise: Promise)
+    private external fun nativeGetSchemaValueObjectAsync(handle: String, promise: Promise)
     private external fun nativeGetEvaluatedSchemaWithoutParamsAsync(handle: String, skipLayout: Boolean, promise: Promise)
     private external fun nativeGetEvaluatedSchemaByPathAsync(handle: String, path: String, skipLayout: Boolean, promise: Promise)
     private external fun nativeGetEvaluatedSchemaByPathsAsync(handle: String, pathsJson: String, skipLayout: Boolean, format: Int, promise: Promise)
@@ -531,6 +587,7 @@ class JsonEvalRsModule(reactContext: ReactApplicationContext) :
     private external fun nativeValidatePathsAsync(handle: String, data: String, context: String, pathsJson: String, promise: Promise)
     private external fun nativeResolveLayoutAsync(handle: String, evaluate: Boolean, promise: Promise)
     private external fun nativeCompileAndRunLogicAsync(handle: String, logicStr: String, data: String, context: String, promise: Promise)
+    private external fun nativeEvaluateLogicAsync(logicStr: String, data: String, context: String, promise: Promise)
     private external fun nativeCompileLogic(handle: String, logicStr: String): Double
     private external fun nativeRunLogicAsync(handle: String, logicId: Double, data: String, context: String, promise: Promise)
     private external fun nativeSetTimezoneOffset(handle: String, offsetMinutes: Int)
@@ -583,6 +640,8 @@ class JsonEvalRsModule(reactContext: ReactApplicationContext) :
     private external fun nativeResolveLayoutSubformAsync(handle: String, subformPath: String, evaluate: Boolean, promise: Promise)
     private external fun nativeGetEvaluatedSchemaSubformAsync(handle: String, subformPath: String, resolveLayout: Boolean, promise: Promise)
     private external fun nativeGetSchemaValueSubformAsync(handle: String, subformPath: String, promise: Promise)
+    private external fun nativeGetSchemaValueArraySubformAsync(handle: String, subformPath: String, promise: Promise)
+    private external fun nativeGetSchemaValueObjectSubformAsync(handle: String, subformPath: String, promise: Promise)
     private external fun nativeGetEvaluatedSchemaWithoutParamsSubformAsync(handle: String, subformPath: String, resolveLayout: Boolean, promise: Promise)
     private external fun nativeGetEvaluatedSchemaByPathSubformAsync(handle: String, subformPath: String, schemaPath: String, skipLayout: Boolean, promise: Promise)
     private external fun nativeGetEvaluatedSchemaByPathsSubformAsync(handle: String, subformPath: String, schemaPathsJson: String, skipLayout: Boolean, format: Int, promise: Promise)

package/cpp/json-eval-bridge.cpp

@@ -25,6 +25,8 @@ extern "C" {
     FFIResult json_eval_evaluate_dependents(JSONEvalHandle* handle, const char* changed_path, const char* data, const char* context, int re_evaluate);
     FFIResult json_eval_get_evaluated_schema(JSONEvalHandle* handle, bool skip_layout);
     FFIResult json_eval_get_schema_value(JSONEvalHandle* handle);
+    FFIResult json_eval_get_schema_value_array(JSONEvalHandle* handle);
+    FFIResult json_eval_get_schema_value_object(JSONEvalHandle* handle);
     FFIResult json_eval_get_evaluated_schema_without_params(JSONEvalHandle* handle, bool skip_layout);
     FFIResult json_eval_get_evaluated_schema_by_path(JSONEvalHandle* handle, const char* path, bool skip_layout);
     FFIResult json_eval_get_evaluated_schema_by_paths(JSONEvalHandle* handle, const char* paths_json, bool skip_layout, uint8_t format);
@@ -45,6 +47,7 @@ extern "C" {
     FFIResult json_eval_disable_cache(JSONEvalHandle* handle);
     int json_eval_is_cache_enabled(JSONEvalHandle* handle);
     FFIResult json_eval_validate_paths(JSONEvalHandle* handle, const char* data, const char* context, const char* paths_json);
+    FFIResult json_eval_evaluate_logic_pure(const char* logic_str, const char* data, const char* context);
     
     // Subform FFI methods
     FFIResult json_eval_evaluate_subform(JSONEvalHandle* handle, const char* subform_path, const char* data, const char* context, const char* paths_json);
@@ -53,6 +56,8 @@ extern "C" {
     FFIResult json_eval_resolve_layout_subform(JSONEvalHandle* handle, const char* subform_path, bool evaluate);
     FFIResult json_eval_get_evaluated_schema_subform(JSONEvalHandle* handle, const char* subform_path, bool resolve_layout);
     FFIResult json_eval_get_schema_value_subform(JSONEvalHandle* handle, const char* subform_path);
+    FFIResult json_eval_get_schema_value_array_subform(JSONEvalHandle* handle, const char* subform_path);
+    FFIResult json_eval_get_schema_value_object_subform(JSONEvalHandle* handle, const char* subform_path);
     FFIResult json_eval_get_evaluated_schema_without_params_subform(JSONEvalHandle* handle, const char* subform_path, bool resolve_layout);
     FFIResult json_eval_get_evaluated_schema_by_path_subform(JSONEvalHandle* handle, const char* subform_path, const char* schema_path, bool skip_layout);
     FFIResult json_eval_get_evaluated_schema_by_paths_subform(JSONEvalHandle* handle, const char* subform_path, const char* schema_paths_json, bool skip_layout, uint8_t format);
@@ -299,6 +304,35 @@ void JsonEvalBridge::validateAsync(
     }, callback);
 }
 
+void JsonEvalBridge::evaluateLogicAsync(
+    const std::string& logicStr,
+    const std::string& data,
+    const std::string& context,
+    std::function<void(const std::string&, const std::string&)> callback
+) {
+    runAsync([logicStr, data, context]() -> std::string {
+        const char* dt = data.empty() ? nullptr : data.c_str();
+        const char* ctx = context.empty() ? nullptr : context.c_str();
+        
+        FFIResult result = json_eval_evaluate_logic_pure(logicStr.c_str(), dt, ctx);
+        
+        if (!result.success) {
+            std::string error = result.error ? result.error : "Unknown error";
+            json_eval_free_result(result);
+            throw std::runtime_error(error);
+        }
+        
+        std::string resultStr;
+        if (result.data_ptr && result.data_len > 0) {
+            resultStr.assign(reinterpret_cast<const char*>(result.data_ptr), result.data_len);
+        } else {
+            resultStr = "null";
+        }
+        json_eval_free_result(result);
+        return resultStr;
+    }, callback);
+}
+
 void JsonEvalBridge::evaluateDependentsAsync(
     const std::string& handleId,
     const std::string& changedPathsJson,
@@ -437,6 +471,66 @@ void JsonEvalBridge::getSchemaValueAsync(
     }, callback);
 }
 
+void JsonEvalBridge::getSchemaValueArrayAsync(
+    const std::string& handleId,
+    std::function<void(const std::string&, const std::string&)> callback
+) {
+    runAsync([handleId]() -> std::string {
+        std::lock_guard<std::mutex> lock(handlesMutex);
+        auto it = handles.find(handleId);
+        if (it == handles.end()) {
+            throw std::runtime_error("Invalid handle");
+        }
+        
+        FFIResult result = json_eval_get_schema_value_array(it->second);
+        
+        if (!result.success) {
+            std::string error = result.error ? result.error : "Unknown error";
+            json_eval_free_result(result);
+            throw std::runtime_error(error);
+        }
+        
+        std::string resultStr;
+        if (result.data_ptr && result.data_len > 0) {
+            resultStr.assign(reinterpret_cast<const char*>(result.data_ptr), result.data_len);
+        } else {
+            resultStr = "[]";
+        }
+        json_eval_free_result(result);
+        return resultStr;
+    }, callback);
+}
+
+void JsonEvalBridge::getSchemaValueObjectAsync(
+    const std::string& handleId,
+    std::function<void(const std::string&, const std::string&)> callback
+) {
+    runAsync([handleId]() -> std::string {
+        std::lock_guard<std::mutex> lock(handlesMutex);
+        auto it = handles.find(handleId);
+        if (it == handles.end()) {
+            throw std::runtime_error("Invalid handle");
+        }
+        
+        FFIResult result = json_eval_get_schema_value_object(it->second);
+        
+        if (!result.success) {
+            std::string error = result.error ? result.error : "Unknown error";
+            json_eval_free_result(result);
+            throw std::runtime_error(error);
+        }
+        
+        std::string resultStr;
+        if (result.data_ptr && result.data_len > 0) {
+            resultStr.assign(reinterpret_cast<const char*>(result.data_ptr), result.data_len);
+        } else {
+            resultStr = "{}";
+        }
+        json_eval_free_result(result);
+        return resultStr;
+    }, callback);
+}
+
 void JsonEvalBridge::getEvaluatedSchemaWithoutParamsAsync(
     const std::string& handleId,
     bool skipLayout,
@@ -1141,6 +1235,68 @@ void JsonEvalBridge::getSchemaValueSubformAsync(
     }, callback);
 }
 
+void JsonEvalBridge::getSchemaValueArraySubformAsync(
+    const std::string& handleId,
+    const std::string& subformPath,
+    std::function<void(const std::string&, const std::string&)> callback
+) {
+    runAsync([handleId, subformPath]() -> std::string {
+        std::lock_guard<std::mutex> lock(handlesMutex);
+        auto it = handles.find(handleId);
+        if (it == handles.end()) {
+            throw std::runtime_error("Invalid handle");
+        }
+        
+        FFIResult result = json_eval_get_schema_value_array_subform(it->second, subformPath.c_str());
+        
+        if (!result.success) {
+            std::string error = result.error ? result.error : "Unknown error";
+            json_eval_free_result(result);
+            throw std::runtime_error(error);
+        }
+        
+        std::string resultStr;
+        if (result.data_ptr && result.data_len > 0) {
+            resultStr.assign(reinterpret_cast<const char*>(result.data_ptr), result.data_len);
+        } else {
+            resultStr = "[]";
+        }
+        json_eval_free_result(result);
+        return resultStr;
+    }, callback);
+}
+
+void JsonEvalBridge::getSchemaValueObjectSubformAsync(
+    const std::string& handleId,
+    const std::string& subformPath,
+    std::function<void(const std::string&, const std::string&)> callback
+) {
+    runAsync([handleId, subformPath]() -> std::string {
+        std::lock_guard<std::mutex> lock(handlesMutex);
+        auto it = handles.find(handleId);
+        if (it == handles.end()) {
+            throw std::runtime_error("Invalid handle");
+        }
+        
+        FFIResult result = json_eval_get_schema_value_object_subform(it->second, subformPath.c_str());
+        
+        if (!result.success) {
+            std::string error = result.error ? result.error : "Unknown error";
+            json_eval_free_result(result);
+            throw std::runtime_error(error);
+        }
+        
+        std::string resultStr;
+        if (result.data_ptr && result.data_len > 0) {
+            resultStr.assign(reinterpret_cast<const char*>(result.data_ptr), result.data_len);
+        } else {
+            resultStr = "{}";
+        }
+        json_eval_free_result(result);
+        return resultStr;
+    }, callback);
+}
+
 void JsonEvalBridge::getEvaluatedSchemaWithoutParamsSubformAsync(
     const std::string& handleId,
     const std::string& subformPath,

package/cpp/json-eval-bridge.h

@@ -134,6 +134,28 @@ public:
         std::function<void(const std::string&, const std::string&)> callback
     );
 
+    /**
+     * Get all schema values as array of path-value pairs (async)
+     * Returns [{path: "", value: ""}, ...]
+     * @param handle Instance handle
+     * @param callback Result callback
+     */
+    static void getSchemaValueArrayAsync(
+        const std::string& handle,
+        std::function<void(const std::string&, const std::string&)> callback
+    );
+
+    /**
+     * Get all schema values as object with dotted path keys (async)
+     * Returns {path: value, ...}
+     * @param handle Instance handle
+     * @param callback Result callback
+     */
+    static void getSchemaValueObjectAsync(
+        const std::string& handle,
+        std::function<void(const std::string&, const std::string&)> callback
+    );
+
     /**
      * Get evaluated schema without $params field (async)
      * @param handle Instance handle
@@ -378,6 +400,20 @@ public:
         std::function<void(const std::string&, const std::string&)> callback
     );
 
+    /**
+     * Evaluate independent logic expression (async) - No schema required
+     * @param logicStr JSON logic expression
+     * @param data Optional JSON data (can be empty/null)
+     * @param context Optional context data (can be empty/null)
+     * @param callback Result callback
+     */
+    static void evaluateLogicAsync(
+        const std::string& logicStr,
+        const std::string& data,
+        const std::string& context,
+        std::function<void(const std::string&, const std::string&)> callback
+    );
+
     // ========================================================================
     // Subform Methods
     // ========================================================================
@@ -474,6 +510,32 @@ public:
         std::function<void(const std::string&, const std::string&)> callback
     );
 
+    /**
+     * Get all schema values as array of path-value pairs from subform (async)
+     * Returns [{path: "", value: ""}, ...]
+     * @param handleId Instance handle
+     * @param subformPath Path to the subform
+     * @param callback Result callback
+     */
+    static void getSchemaValueArraySubformAsync(
+        const std::string& handleId,
+        const std::string& subformPath,
+        std::function<void(const std::string&, const std::string&)> callback
+    );
+
+    /**
+     * Get all schema values as object with dotted path keys from subform (async)
+     * Returns {path: value, ...}
+     * @param handleId Instance handle
+     * @param subformPath Path to the subform
+     * @param callback Result callback
+     */
+    static void getSchemaValueObjectSubformAsync(
+        const std::string& handleId,
+        const std::string& subformPath,
+        std::function<void(const std::string&, const std::string&)> callback
+    );
+
     /**
      * Get evaluated schema without $params from subform (async)
      * @param handleId Instance handle

package/ios/JsonEvalRs.mm

@@ -141,6 +141,27 @@ RCT_EXPORT_METHOD(runLogic:(NSString *)handle
     );
 }
 
+RCT_EXPORT_METHOD(evaluateLogic:(NSString *)logicStr
+                  data:(NSString *)data
+                  context:(NSString *)context
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+{
+    std::string logicString = [self stdStringFromNSString:logicStr];
+    std::string dataStr = [self stdStringFromNSString:data];
+    std::string contextStr = [self stdStringFromNSString:context];
+
+    JsonEvalBridge::evaluateLogicAsync(logicString, dataStr, contextStr,
+        [resolve, reject](const std::string& result, const std::string& error) {
+            if (error.empty()) {
+                resolve([NSString stringWithUTF8String:result.c_str()]);
+            } else {
+                reject(@"EVALUATE_LOGIC_ERROR", [NSString stringWithUTF8String:error.c_str()], nil);
+            }
+        }
+    );
+}
+
 RCT_EXPORT_METHOD(validate:(NSString *)handle
                   data:(NSString *)data
                   context:(NSString *)context
@@ -221,6 +242,40 @@ RCT_EXPORT_METHOD(getSchemaValue:(NSString *)handle
     );
 }
 
+RCT_EXPORT_METHOD(getSchemaValueArray:(NSString *)handle
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+{
+    std::string handleStr = [self stdStringFromNSString:handle];
+    
+    JsonEvalBridge::getSchemaValueArrayAsync(handleStr,
+        [resolve, reject](const std::string& result, const std::string& error) {
+            if (error.empty()) {
+                resolve([NSString stringWithUTF8String:result.c_str()]);
+            } else {
+                reject(@"GET_SCHEMA_VALUE_ARRAY_ERROR", [NSString stringWithUTF8String:error.c_str()], nil);
+            }
+        }
+    );
+}
+
+RCT_EXPORT_METHOD(getSchemaValueObject:(NSString *)handle
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+{
+    std::string handleStr = [self stdStringFromNSString:handle];
+    
+    JsonEvalBridge::getSchemaValueObjectAsync(handleStr,
+        [resolve, reject](const std::string& result, const std::string& error) {
+            if (error.empty()) {
+                resolve([NSString stringWithUTF8String:result.c_str()]);
+            } else {
+                reject(@"GET_SCHEMA_VALUE_OBJECT_ERROR", [NSString stringWithUTF8String:error.c_str()], nil);
+            }
+        }
+    );
+}
+
 RCT_EXPORT_METHOD(getEvaluatedSchemaWithoutParams:(NSString *)handle
                   skipLayout:(BOOL)skipLayout
                   resolver:(RCTPromiseResolveBlock)resolve
@@ -693,6 +748,44 @@ RCT_EXPORT_METHOD(getSchemaValueSubform:(NSString *)handle
     );
 }
 
+RCT_EXPORT_METHOD(getSchemaValueArraySubform:(NSString *)handle
+                  subformPath:(NSString *)subformPath
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+{
+    std::string handleStr = [self stdStringFromNSString:handle];
+    std::string pathStr = [self stdStringFromNSString:subformPath];
+    
+    JsonEvalBridge::getSchemaValueArraySubformAsync(handleStr, pathStr,
+        [resolve, reject](const std::string& result, const std::string& error) {
+            if (error.empty()) {
+                resolve([NSString stringWithUTF8String:result.c_str()]);
+            } else {
+                reject(@"GET_SCHEMA_VALUE_ARRAY_SUBFORM_ERROR", [NSString stringWithUTF8String:error.c_str()], nil);
+            }
+        }
+    );
+}
+
+RCT_EXPORT_METHOD(getSchemaValueObjectSubform:(NSString *)handle
+                  subformPath:(NSString *)subformPath
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+{
+    std::string handleStr = [self stdStringFromNSString:handle];
+    std::string pathStr = [self stdStringFromNSString:subformPath];
+    
+    JsonEvalBridge::getSchemaValueObjectSubformAsync(handleStr, pathStr,
+        [resolve, reject](const std::string& result, const std::string& error) {
+            if (error.empty()) {
+                resolve([NSString stringWithUTF8String:result.c_str()]);
+            } else {
+                reject(@"GET_SCHEMA_VALUE_OBJECT_SUBFORM_ERROR", [NSString stringWithUTF8String:error.c_str()], nil);
+            }
+        }
+    );
+}
+
 RCT_EXPORT_METHOD(getEvaluatedSchemaWithoutParamsSubform:(NSString *)handle
                   subformPath:(NSString *)subformPath
                   resolveLayout:(BOOL)resolveLayout
@@ -855,6 +948,12 @@ RCT_EXPORT_METHOD(setTimezoneOffset:(NSString *)handle
     }
 }
 
+RCT_EXPORT_METHOD(cancel:(NSString *)handle)
+{
+    std::string handleStr = [self stdStringFromNSString:handle];
+    JsonEvalBridge::cancel(handleStr);
+}
+
 RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(dispose:(NSString *)handle)
 {
     std::string handleStr = [self stdStringFromNSString:handle];

package/ios/JsonEvalRs.xcframework/Info.plist

@@ -8,32 +8,32 @@
 			<key>BinaryPath</key>
 			<string>libjson_eval_rs.a</string>
 			<key>LibraryIdentifier</key>
-			<string>ios-arm64</string>
+			<string>ios-arm64_x86_64-simulator</string>
 			<key>LibraryPath</key>
 			<string>libjson_eval_rs.a</string>
 			<key>SupportedArchitectures</key>
 			<array>
 				<string>arm64</string>
+				<string>x86_64</string>
 			</array>
 			<key>SupportedPlatform</key>
 			<string>ios</string>
+			<key>SupportedPlatformVariant</key>
+			<string>simulator</string>
 		</dict>
 		<dict>
 			<key>BinaryPath</key>
 			<string>libjson_eval_rs.a</string>
 			<key>LibraryIdentifier</key>
-			<string>ios-arm64_x86_64-simulator</string>
+			<string>ios-arm64</string>
 			<key>LibraryPath</key>
 			<string>libjson_eval_rs.a</string>
 			<key>SupportedArchitectures</key>
 			<array>
 				<string>arm64</string>
-				<string>x86_64</string>
 			</array>
 			<key>SupportedPlatform</key>
 			<string>ios</string>
-			<key>SupportedPlatformVariant</key>
-			<string>simulator</string>
 		</dict>
 	</array>
 	<key>CFBundlePackageType</key>