@json-eval-rs/react-native 0.0.55 → 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,
@@ -788,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,
@@ -397,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,
@@ -495,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)
@@ -524,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)
@@ -594,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);
@@ -54,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);
@@ -467,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,
@@ -1171,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
@@ -488,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

@@ -242,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
@@ -714,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
@@ -876,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/lib/commonjs/index.js

@@ -18,6 +18,9 @@ const JsonEvalRs = _reactNative.NativeModules.JsonEvalRs ? _reactNative.NativeMo
   }
 });
 
+/**
+ * Item for get schema value array results
+ */
 /**
  * Return format for path-based methods
  */
@@ -86,22 +89,22 @@ let ReturnFormat = exports.ReturnFormat = /*#__PURE__*/function (ReturnFormat) {
  */
 /**
  * High-performance JSON Logic evaluator with schema validation for React Native
- * 
+ *
  * ## Zero-Copy Architecture
- * 
+ *
  * This binding is optimized for minimal memory copies:
  * - **Rust FFI Layer**: Returns raw pointers (zero-copy)
  * - **C++ Bridge**: Uses direct pointer access with single-copy string construction
  * - **Native Platform**: Minimizes intermediate conversions
  * - **JS Bridge**: React Native's architecture requires serialization (unavoidable)
- * 
+ *
  * While true zero-copy across JS/Native boundary is not possible due to React Native's
  * architecture, we minimize copies within the native layer to maximize performance.
- * 
+ *
  * @example
  * ```typescript
  * import { JSONEval } from '@json-eval-rs/react-native';
- * 
+ *
  * const schema = {
  *   type: 'object',
  *   properties: {
@@ -118,18 +121,18 @@ let ReturnFormat = exports.ReturnFormat = /*#__PURE__*/function (ReturnFormat) {
  *     }
  *   }
  * };
- * 
+ *
  * const eval = new JSONEval({ schema });
- * 
+ *
  * const data = { user: { name: 'John' } };
  * const result = await eval.evaluate({ data });
  * console.log(result);
- * 
+ *
  * const validation = await eval.validate({ data });
  * if (validation.hasError) {
  *   console.error('Validation errors:', validation.errors);
  * }
- * 
+ *
  * await eval.dispose();
  * ```
  */
@@ -212,7 +215,7 @@ class JSONEval {
 
   /**
    * Cancel any running evaluation
-   * The generic auto-cancellation on new evaluation will still work, 
+   * The generic auto-cancellation on new evaluation will still work,
    * but this allows manual cancellation.
    */
   async cancel() {
@@ -308,6 +311,30 @@ class JSONEval {
     return JSON.parse(resultStr);
   }
 
+  /**
+   * Get all schema values as array of path-value pairs
+   * Returns [{path: "", value: ""}, ...]
+   * @returns Promise resolving to array of SchemaValueItem objects
+   * @throws {Error} If operation fails
+   */
+  async getSchemaValueArray() {
+    this.throwIfDisposed();
+    const resultStr = await JsonEvalRs.getSchemaValueArray(this.handle);
+    return JSON.parse(resultStr);
+  }
+
+  /**
+   * Get all schema values as object with dotted path keys
+   * Returns {path: value, ...}
+   * @returns Promise resolving to flat object with dotted paths as keys
+   * @throws {Error} If operation fails
+   */
+  async getSchemaValueObject() {
+    this.throwIfDisposed();
+    const resultStr = await JsonEvalRs.getSchemaValueObject(this.handle);
+    return JSON.parse(resultStr);
+  }
+
   /**
    * Get the evaluated schema without $params field
    * @param skipLayout - Whether to skip layout resolution (default: false)
@@ -520,15 +547,15 @@ class JSONEval {
    *                        Pass null to reset to UTC
    * @returns Promise that resolves when timezone is set
    * @throws {Error} If operation fails
-   * 
+   *
    * @example
    * ```typescript
    * // Set to UTC+7 (Jakarta, Bangkok)
    * await eval.setTimezoneOffset(420);
-   * 
+   *
    * // Set to UTC-5 (New York, EST)
    * await eval.setTimezoneOffset(-300);
-   * 
+   *
    * // Reset to UTC
    * await eval.setTimezoneOffset(null);
    * ```
@@ -681,6 +708,32 @@ class JSONEval {
     return JSON.parse(resultStr);
   }
 
+  /**
+   * Get schema values from subform as a flat array of path-value pairs.
+   * Returns an array like `[{path: "field.sub", value: 123}, ...]`.
+   * @param options - Options including subform path
+   * @returns Promise resolving to array of SchemaValueItem objects
+   * @throws {Error} If operation fails
+   */
+  async getSchemaValueArraySubform(options) {
+    this.throwIfDisposed();
+    const resultStr = await JsonEvalRs.getSchemaValueArraySubform(this.handle, options.subformPath);
+    return JSON.parse(resultStr);
+  }
+
+  /**
+   * Get schema values from subform as a flat object with dotted path keys.
+   * Returns an object like `{"field.sub": 123, ...}`.
+   * @param options - Options including subform path
+   * @returns Promise resolving to flat object with dotted paths
+   * @throws {Error} If operation fails
+   */
+  async getSchemaValueObjectSubform(options) {
+    this.throwIfDisposed();
+    const resultStr = await JsonEvalRs.getSchemaValueObjectSubform(this.handle, options.subformPath);
+    return JSON.parse(resultStr);
+  }
+
   /**
    * Get evaluated schema without $params from subform
    * @param options - Options including subform path and resolveLayout flag
@@ -791,20 +844,20 @@ class JSONEval {
  * Hook for using JSONEval in React components with automatic cleanup
  * @param options - Configuration options
  * @returns JSONEval instance or null if not yet initialized
- * 
+ *
  * @example
  * ```typescript
  * import { useJSONEval } from '@json-eval-rs/react-native';
- * 
+ *
  * function MyComponent() {
  *   const eval = useJSONEval({ schema: mySchema });
- *   
+ *
  *   const handleValidate = async () => {
  *     if (!eval) return;
  *     const result = await eval.validate({ data: myData });
  *     console.log(result);
  *   };
- *   
+ *
  *   return <Button onPress={handleValidate} title="Validate" />;
  * }
  * ```