@json-eval-rs/react-native 0.0.28 → 0.0.29

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

@@ -347,14 +347,16 @@ Java_com_jsonevalrs_JsonEvalRsModule_nativeGetEvaluatedSchemaByPathsAsync(
     jstring handle,
     jstring pathsJson,
     jboolean skipLayout,
+    jint format,
     jobject promise
 ) {
     std::string handleStr = jstringToString(env, handle);
     std::string pathsJsonStr = jstringToString(env, pathsJson);
     bool skipLayoutBool = (skipLayout == JNI_TRUE);
+    int formatInt = static_cast<int>(format);
     
-    runAsyncWithPromise(env, promise, "GET_EVALUATED_SCHEMA_BY_PATHS_ERROR", [handleStr, pathsJsonStr, skipLayoutBool](auto callback) {
-        JsonEvalBridge::getEvaluatedSchemaByPathsAsync(handleStr, pathsJsonStr, skipLayoutBool, callback);
+    runAsyncWithPromise(env, promise, "GET_EVALUATED_SCHEMA_BY_PATHS_ERROR", [handleStr, pathsJsonStr, skipLayoutBool, formatInt](auto callback) {
+        JsonEvalBridge::getEvaluatedSchemaByPathsAsync(handleStr, pathsJsonStr, skipLayoutBool, formatInt, callback);
     });
 }
 
@@ -380,13 +382,15 @@ Java_com_jsonevalrs_JsonEvalRsModule_nativeGetSchemaByPathsAsync(
     jobject /* this */,
     jstring handle,
     jstring pathsJson,
+    jint format,
     jobject promise
 ) {
     std::string handleStr = jstringToString(env, handle);
     std::string pathsJsonStr = jstringToString(env, pathsJson);
+    int formatInt = static_cast<int>(format);
     
-    runAsyncWithPromise(env, promise, "GET_SCHEMA_BY_PATHS_ERROR", [handleStr, pathsJsonStr](auto callback) {
-        JsonEvalBridge::getSchemaByPathsAsync(handleStr, pathsJsonStr, callback);
+    runAsyncWithPromise(env, promise, "GET_SCHEMA_BY_PATHS_ERROR", [handleStr, pathsJsonStr, formatInt](auto callback) {
+        JsonEvalBridge::getSchemaByPathsAsync(handleStr, pathsJsonStr, formatInt, callback);
     });
 }
 
@@ -794,15 +798,17 @@ Java_com_jsonevalrs_JsonEvalRsModule_nativeGetEvaluatedSchemaByPathsSubformAsync
     jstring subformPath,
     jstring schemaPathsJson,
     jboolean skipLayout,
+    jint format,
     jobject promise
 ) {
     std::string handleStr = jstringToString(env, handle);
     std::string subformPathStr = jstringToString(env, subformPath);
     std::string schemaPathsJsonStr = jstringToString(env, schemaPathsJson);
     bool skipLayoutBool = (skipLayout == JNI_TRUE);
+    int formatInt = static_cast<int>(format);
     
-    runAsyncWithPromise(env, promise, "GET_SCHEMA_BY_PATHS_SUBFORM_ERROR", [handleStr, subformPathStr, schemaPathsJsonStr, skipLayoutBool](auto callback) {
-        JsonEvalBridge::getEvaluatedSchemaByPathsSubformAsync(handleStr, subformPathStr, schemaPathsJsonStr, skipLayoutBool, callback);
+    runAsyncWithPromise(env, promise, "GET_SCHEMA_BY_PATHS_SUBFORM_ERROR", [handleStr, subformPathStr, schemaPathsJsonStr, skipLayoutBool, formatInt](auto callback) {
+        JsonEvalBridge::getEvaluatedSchemaByPathsSubformAsync(handleStr, subformPathStr, schemaPathsJsonStr, skipLayoutBool, formatInt, callback);
     });
 }
 
@@ -845,14 +851,16 @@ Java_com_jsonevalrs_JsonEvalRsModule_nativeGetSchemaByPathsSubformAsync(
     jstring handle,
     jstring subformPath,
     jstring schemaPathsJson,
+    jint format,
     jobject promise
 ) {
     std::string handleStr = jstringToString(env, handle);
     std::string subformPathStr = jstringToString(env, subformPath);
     std::string schemaPathsJsonStr = jstringToString(env, schemaPathsJson);
+    int formatInt = static_cast<int>(format);
     
-    runAsyncWithPromise(env, promise, "GET_SCHEMA_BY_PATHS_SUBFORM_ERROR", [handleStr, subformPathStr, schemaPathsJsonStr](auto callback) {
-        JsonEvalBridge::getSchemaByPathsSubformAsync(handleStr, subformPathStr, schemaPathsJsonStr, callback);
+    runAsyncWithPromise(env, promise, "GET_SCHEMA_BY_PATHS_SUBFORM_ERROR", [handleStr, subformPathStr, schemaPathsJsonStr, formatInt](auto callback) {
+        JsonEvalBridge::getSchemaByPathsSubformAsync(handleStr, subformPathStr, schemaPathsJsonStr, formatInt, callback);
     });
 }
 

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

@@ -106,9 +106,10 @@ class JsonEvalRsModule(reactContext: ReactApplicationContext) :
         handle: String,
         pathsJson: String,
         skipLayout: Boolean,
+        format: Int,
         promise: Promise
     ) {
-        nativeGetEvaluatedSchemaByPathsAsync(handle, pathsJson, skipLayout, promise)
+        nativeGetEvaluatedSchemaByPathsAsync(handle, pathsJson, skipLayout, format, promise)
     }
 
     @ReactMethod
@@ -124,9 +125,10 @@ class JsonEvalRsModule(reactContext: ReactApplicationContext) :
     fun getSchemaByPaths(
         handle: String,
         pathsJson: String,
+        format: Int,
         promise: Promise
     ) {
-        nativeGetSchemaByPathsAsync(handle, pathsJson, promise)
+        nativeGetSchemaByPathsAsync(handle, pathsJson, format, promise)
     }
 
     @ReactMethod
@@ -404,17 +406,17 @@ class JsonEvalRsModule(reactContext: ReactApplicationContext) :
         subformPath: String,
         schemaPathsJson: String,
         skipLayout: Boolean,
+        format: Int,
         promise: Promise
     ) {
-        nativeGetEvaluatedSchemaByPathsSubformAsync(handle, subformPath, schemaPathsJson, skipLayout, promise)
-    }
-
-    @ReactMethod
-    fun getSubformPaths(
-        handle: String,
-        promise: Promise
-    ) {
-        nativeGetSubformPathsAsync(handle, promise)
+        nativeGetEvaluatedSchemaByPathsSubformAsync(
+            handle,
+            subformPath,
+            schemaPathsJson,
+            skipLayout,
+            format,
+            promise
+        )
     }
 
     @ReactMethod
@@ -432,9 +434,24 @@ class JsonEvalRsModule(reactContext: ReactApplicationContext) :
         handle: String,
         subformPath: String,
         schemaPathsJson: String,
+        format: Int,
         promise: Promise
     ) {
-        nativeGetSchemaByPathsSubformAsync(handle, subformPath, schemaPathsJson, promise)
+        nativeGetSchemaByPathsSubformAsync(
+            handle,
+            subformPath,
+            schemaPathsJson,
+            format,
+            promise
+        )
+    }
+
+    @ReactMethod
+    fun getSubformPaths(
+        handle: String,
+        promise: Promise
+    ) {
+        nativeGetSubformPathsAsync(handle, promise)
     }
 
     @ReactMethod
@@ -494,9 +511,9 @@ class JsonEvalRsModule(reactContext: ReactApplicationContext) :
     private external fun nativeGetSchemaValueAsync(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, promise: Promise)
+    private external fun nativeGetEvaluatedSchemaByPathsAsync(handle: String, pathsJson: String, skipLayout: Boolean, format: Int, promise: Promise)
     private external fun nativeGetSchemaByPathAsync(handle: String, path: String, promise: Promise)
-    private external fun nativeGetSchemaByPathsAsync(handle: String, pathsJson: String, promise: Promise)
+    private external fun nativeGetSchemaByPathsAsync(handle: String, pathsJson: String, format: Int, promise: Promise)
     private external fun nativeReloadSchemaAsync(handle: String, schema: String, context: String, data: String, promise: Promise)
     private external fun nativeReloadSchemaMsgpackAsync(handle: String, schemaMsgpack: ByteArray, context: String, data: String, promise: Promise)
     private external fun nativeReloadSchemaFromCacheAsync(handle: String, cacheKey: String, context: String, data: String, promise: Promise)
@@ -521,9 +538,9 @@ class JsonEvalRsModule(reactContext: ReactApplicationContext) :
     private external fun nativeGetSchemaValueSubformAsync(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, promise: Promise)
+    private external fun nativeGetEvaluatedSchemaByPathsSubformAsync(handle: String, subformPath: String, schemaPathsJson: String, skipLayout: Boolean, format: Int, promise: Promise)
     private external fun nativeGetSchemaByPathSubformAsync(handle: String, subformPath: String, schemaPath: String, promise: Promise)
-    private external fun nativeGetSchemaByPathsSubformAsync(handle: String, subformPath: String, schemaPathsJson: String, promise: Promise)
+    private external fun nativeGetSchemaByPathsSubformAsync(handle: String, subformPath: String, schemaPathsJson: String, format: Int, promise: Promise)
     private external fun nativeGetSubformPathsAsync(handle: String, promise: Promise)
     private external fun nativeHasSubformAsync(handle: String, subformPath: String, promise: Promise)
     

package/cpp/json-eval-bridge.cpp

@@ -27,9 +27,9 @@ extern "C" {
     FFIResult json_eval_get_schema_value(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);
+    FFIResult json_eval_get_evaluated_schema_by_paths(JSONEvalHandle* handle, const char* paths_json, bool skip_layout, uint8_t format);
     FFIResult json_eval_get_schema_by_path(JSONEvalHandle* handle, const char* path);
-    FFIResult json_eval_get_schema_by_paths(JSONEvalHandle* handle, const char* paths_json);
+    FFIResult json_eval_get_schema_by_paths(JSONEvalHandle* handle, const char* paths_json, uint8_t format);
     FFIResult json_eval_resolve_layout(JSONEvalHandle* handle, bool evaluate);
     FFIResult json_eval_compile_and_run_logic(JSONEvalHandle* handle, const char* logic_str, const char* data, const char* context);
     uint64_t json_eval_compile_logic(JSONEvalHandle* handle, const char* logic_str);
@@ -55,9 +55,9 @@ extern "C" {
     FFIResult json_eval_get_schema_value_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);
+    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);
     FFIResult json_eval_get_schema_by_path_subform(JSONEvalHandle* handle, const char* subform_path, const char* schema_path);
-    FFIResult json_eval_get_schema_by_paths_subform(JSONEvalHandle* handle, const char* subform_path, const char* schema_paths_json);
+    FFIResult json_eval_get_schema_by_paths_subform(JSONEvalHandle* handle, const char* subform_path, const char* schema_paths_json, uint8_t format);
     FFIResult json_eval_get_subform_paths(JSONEvalHandle* handle);
     FFIResult json_eval_has_subform(JSONEvalHandle* handle, const char* subform_path);
     
@@ -501,16 +501,17 @@ void JsonEvalBridge::getEvaluatedSchemaByPathsAsync(
     const std::string& handleId,
     const std::string& pathsJson,
     bool skipLayout,
+    int format,
     std::function<void(const std::string&, const std::string&)> callback
 ) {
-    runAsync([handleId, pathsJson, skipLayout]() -> std::string {
+    runAsync([handleId, pathsJson, skipLayout, format]() -> 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_evaluated_schema_by_paths(it->second, pathsJson.c_str(), skipLayout);
+        FFIResult result = json_eval_get_evaluated_schema_by_paths(it->second, pathsJson.c_str(), skipLayout, static_cast<uint8_t>(format));
         
         if (!result.success) {
             std::string error = result.error ? result.error : "Unknown error";
@@ -565,16 +566,17 @@ void JsonEvalBridge::getSchemaByPathAsync(
 void JsonEvalBridge::getSchemaByPathsAsync(
     const std::string& handleId,
     const std::string& pathsJson,
+    int format,
     std::function<void(const std::string&, const std::string&)> callback
 ) {
-    runAsync([handleId, pathsJson]() -> std::string {
+    runAsync([handleId, pathsJson, format]() -> 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_by_paths(it->second, pathsJson.c_str());
+        FFIResult result = json_eval_get_schema_by_paths(it->second, pathsJson.c_str(), static_cast<uint8_t>(format));
         
         if (!result.success) {
             std::string error = result.error ? result.error : "Unknown error";
@@ -1195,16 +1197,17 @@ void JsonEvalBridge::getEvaluatedSchemaByPathsSubformAsync(
     const std::string& subformPath,
     const std::string& schemaPathsJson,
     bool skipLayout,
+    int format,
     std::function<void(const std::string&, const std::string&)> callback
 ) {
-    runAsync([handleId, subformPath, schemaPathsJson, skipLayout]() -> std::string {
+    runAsync([handleId, subformPath, schemaPathsJson, skipLayout, format]() -> 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_evaluated_schema_by_paths_subform(it->second, subformPath.c_str(), schemaPathsJson.c_str(), skipLayout);
+        FFIResult result = json_eval_get_evaluated_schema_by_paths_subform(it->second, subformPath.c_str(), schemaPathsJson.c_str(), skipLayout, static_cast<uint8_t>(format));
         
         if (!result.success) {
             std::string error = result.error ? result.error : "Unknown error";
@@ -1289,16 +1292,17 @@ void JsonEvalBridge::getSchemaByPathsSubformAsync(
     const std::string& handleId,
     const std::string& subformPath,
     const std::string& schemaPathsJson,
+    int format,
     std::function<void(const std::string&, const std::string&)> callback
 ) {
-    runAsync([handleId, subformPath, schemaPathsJson]() -> std::string {
+    runAsync([handleId, subformPath, schemaPathsJson, format]() -> 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_by_paths_subform(it->second, subformPath.c_str(), schemaPathsJson.c_str());
+        FFIResult result = json_eval_get_schema_by_paths_subform(it->second, subformPath.c_str(), schemaPathsJson.c_str(), static_cast<uint8_t>(format));
         
         if (!result.success) {
             std::string error = result.error ? result.error : "Unknown error";

package/cpp/json-eval-bridge.h

@@ -163,12 +163,14 @@ public:
      * @param handle Instance handle
      * @param pathsJson JSON array of dotted paths to retrieve
      * @param skipLayout Whether to skip layout resolution
+     * @param format Return format (0=Nested, 1=Flat, 2=Array)
      * @param callback Result callback
      */
     static void getEvaluatedSchemaByPathsAsync(
         const std::string& handle,
         const std::string& pathsJson,
         bool skipLayout,
+        int format,
         std::function<void(const std::string&, const std::string&)> callback
     );
 
@@ -188,11 +190,13 @@ public:
      * Get values from schema using multiple dotted path notations (async)
      * @param handle Instance handle
      * @param pathsJson JSON array of dotted paths to retrieve
+     * @param format Return format (0=Nested, 1=Flat, 2=Array)
      * @param callback Result callback
      */
     static void getSchemaByPathsAsync(
         const std::string& handle,
         const std::string& pathsJson,
+        int format,
         std::function<void(const std::string&, const std::string&)> callback
     );
 
@@ -502,6 +506,7 @@ public:
      * @param subformPath Path to the subform
      * @param schemaPathsJson JSON array of dotted paths to retrieve within the subform
      * @param skipLayout Whether to skip layout resolution
+     * @param format Return format (0=Nested, 1=Flat, 2=Array)
      * @param callback Result callback
      */
     static void getEvaluatedSchemaByPathsSubformAsync(
@@ -509,6 +514,7 @@ public:
         const std::string& subformPath,
         const std::string& schemaPathsJson,
         bool skipLayout,
+        int format,
         std::function<void(const std::string&, const std::string&)> callback
     );
 
@@ -541,12 +547,14 @@ public:
      * @param handleId Instance handle
      * @param subformPath Path to the subform
      * @param schemaPathsJson JSON array of dotted paths to retrieve within the subform
+     * @param format Return format (0=Nested, 1=Flat, 2=Array)
      * @param callback Result callback
      */
     static void getSchemaByPathsSubformAsync(
         const std::string& handleId,
         const std::string& subformPath,
         const std::string& schemaPathsJson,
+        int format,
         std::function<void(const std::string&, const std::string&)> callback
     );
 

package/ios/JsonEvalRs.mm

@@ -260,13 +260,14 @@ RCT_EXPORT_METHOD(getEvaluatedSchemaByPath:(NSString *)handle
 RCT_EXPORT_METHOD(getEvaluatedSchemaByPaths:(NSString *)handle
                   pathsJson:(NSString *)pathsJson
                   skipLayout:(BOOL)skipLayout
+                  format:(NSInteger)format
                   resolver:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject)
 {
     std::string handleStr = [self stdStringFromNSString:handle];
     std::string pathsJsonStr = [self stdStringFromNSString:pathsJson];
     
-    JsonEvalBridge::getEvaluatedSchemaByPathsAsync(handleStr, pathsJsonStr, skipLayout,
+    JsonEvalBridge::getEvaluatedSchemaByPathsAsync(handleStr, pathsJsonStr, skipLayout, static_cast<int>(format),
         [resolve, reject](const std::string& result, const std::string& error) {
             if (error.empty()) {
                 resolve([NSString stringWithUTF8String:result.c_str()]);
@@ -298,13 +299,14 @@ RCT_EXPORT_METHOD(getSchemaByPath:(NSString *)handle
 
 RCT_EXPORT_METHOD(getSchemaByPaths:(NSString *)handle
                   pathsJson:(NSString *)pathsJson
+                  format:(NSInteger)format
                   resolver:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject)
 {
     std::string handleStr = [self stdStringFromNSString:handle];
     std::string pathsJsonStr = [self stdStringFromNSString:pathsJson];
     
-    JsonEvalBridge::getSchemaByPathsAsync(handleStr, pathsJsonStr,
+    JsonEvalBridge::getSchemaByPathsAsync(handleStr, pathsJsonStr, static_cast<int>(format),
         [resolve, reject](const std::string& result, const std::string& error) {
             if (error.empty()) {
                 resolve([NSString stringWithUTF8String:result.c_str()]);
@@ -727,6 +729,7 @@ RCT_EXPORT_METHOD(getEvaluatedSchemaByPathsSubform:(NSString *)handle
                   subformPath:(NSString *)subformPath
                   schemaPathsJson:(NSString *)schemaPathsJson
                   skipLayout:(BOOL)skipLayout
+                  format:(NSInteger)format
                   resolver:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject)
 {
@@ -734,7 +737,7 @@ RCT_EXPORT_METHOD(getEvaluatedSchemaByPathsSubform:(NSString *)handle
     std::string subformPathStr = [self stdStringFromNSString:subformPath];
     std::string schemaPathsJsonStr = [self stdStringFromNSString:schemaPathsJson];
     
-    JsonEvalBridge::getEvaluatedSchemaByPathsSubformAsync(handleStr, subformPathStr, schemaPathsJsonStr, skipLayout,
+    JsonEvalBridge::getEvaluatedSchemaByPathsSubformAsync(handleStr, subformPathStr, schemaPathsJsonStr, skipLayout, static_cast<int>(format),
         [resolve, reject](const std::string& result, const std::string& error) {
             if (error.empty()) {
                 resolve([NSString stringWithUTF8String:result.c_str()]);
@@ -786,6 +789,7 @@ RCT_EXPORT_METHOD(getSchemaByPathSubform:(NSString *)handle
 RCT_EXPORT_METHOD(getSchemaByPathsSubform:(NSString *)handle
                   subformPath:(NSString *)subformPath
                   schemaPathsJson:(NSString *)schemaPathsJson
+                  format:(NSInteger)format
                   resolver:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject)
 {
@@ -793,7 +797,7 @@ RCT_EXPORT_METHOD(getSchemaByPathsSubform:(NSString *)handle
     std::string subformPathStr = [self stdStringFromNSString:subformPath];
     std::string schemaPathsJsonStr = [self stdStringFromNSString:schemaPathsJson];
     
-    JsonEvalBridge::getSchemaByPathsSubformAsync(handleStr, subformPathStr, schemaPathsJsonStr,
+    JsonEvalBridge::getSchemaByPathsSubformAsync(handleStr, subformPathStr, schemaPathsJsonStr, static_cast<int>(format),
         [resolve, reject](const std::string& result, const std::string& error) {
             if (error.empty()) {
                 resolve([NSString stringWithUTF8String:result.c_str()]);

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_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>
 		<dict>
 			<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>
 	</array>
 	<key>CFBundlePackageType</key>

package/lib/commonjs/index.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.multiply = exports.default = exports.JSONEval = void 0;
+exports.multiply = exports.default = exports.ReturnFormat = exports.JSONEval = void 0;
 exports.useJSONEval = useJSONEval;
 var _react = _interopRequireDefault(require("react"));
 var _reactNative = require("react-native");
@@ -18,78 +18,72 @@ const JsonEvalRs = _reactNative.NativeModules.JsonEvalRs ? _reactNative.NativeMo
   }
 });
 
+/**
+ * Return format for path-based methods
+ */
+let ReturnFormat = exports.ReturnFormat = /*#__PURE__*/function (ReturnFormat) {
+  /** Nested object preserving the path hierarchy (default) */
+  ReturnFormat[ReturnFormat["Nested"] = 0] = "Nested";
+  /** Flat object with dotted keys */
+  ReturnFormat[ReturnFormat["Flat"] = 1] = "Flat";
+  /** Array of values in the order of requested paths */
+  ReturnFormat[ReturnFormat["Array"] = 2] = "Array";
+  return ReturnFormat;
+}({});
 /**
  * Validation error for a specific field
  */
-
 /**
  * Result of validation operation
  */
-
 /**
  * Dependent field change from evaluateDependents
  */
-
 /**
  * Options for creating a JSONEval instance
  */
-
 /**
  * Options for evaluation
  */
-
 /**
  * Options for validation with path filtering
  */
-
 /**
  * Cache statistics
  */
-
 /**
  * Options for evaluating dependents
  */
-
 /**
  * Options for evaluating a subform
  */
-
 /**
  * Options for validating a subform
  */
-
 /**
  * Options for evaluating dependents in a subform
  */
-
 /**
  * Options for resolving layout in a subform
  */
-
 /**
  * Options for getting evaluated schema from a subform
  */
-
 /**
  * Options for getting schema value from a subform
  */
-
 /**
  * Options for getting evaluated schema by path from a subform
  */
-
 /**
  * Options for getting evaluated schema by multiple paths from a subform
  */
-
 /**
  * Options for getting schema by path from a subform
  */
-
 /**
  * Options for getting schema by multiple paths from a subform
  */
-
 /**
  * High-performance JSON Logic evaluator with schema validation for React Native
  * 
@@ -315,16 +309,17 @@ class JSONEval {
 
   /**
    * Get values from the evaluated schema using multiple dotted path notations
-   * Returns a merged object containing all requested paths (skips paths that are not found)
+   * Returns data in the specified format (skips paths that are not found)
    * @param paths - Array of dotted paths to retrieve
    * @param skipLayout - Whether to skip layout resolution
-   * @returns Promise resolving to merged object containing all found paths
+   * @param format - Return format (Nested, Flat, or Array)
+   * @returns Promise resolving to data in the specified format
    * @throws {Error} If operation fails
    */
-  async getEvaluatedSchemaByPaths(paths, skipLayout = false) {
+  async getEvaluatedSchemaByPaths(paths, skipLayout = false, format = ReturnFormat.Nested) {
     this.throwIfDisposed();
     const pathsJson = JSON.stringify(paths);
-    const resultStr = await JsonEvalRs.getEvaluatedSchemaByPaths(this.handle, pathsJson, skipLayout);
+    const resultStr = await JsonEvalRs.getEvaluatedSchemaByPaths(this.handle, pathsJson, skipLayout, format);
     return JSON.parse(resultStr);
   }
 
@@ -342,15 +337,16 @@ class JSONEval {
 
   /**
    * Get values from the schema using multiple dotted path notations
-   * Returns a merged object containing all requested paths (skips paths that are not found)
+   * Returns data in the specified format (skips paths that are not found)
    * @param paths - Array of dotted paths to retrieve
-   * @returns Promise resolving to merged object containing all found paths
+   * @param format - Return format (Nested, Flat, or Array)
+   * @returns Promise resolving to data in the specified format
    * @throws {Error} If operation fails
    */
-  async getSchemaByPaths(paths) {
+  async getSchemaByPaths(paths, format = ReturnFormat.Nested) {
     this.throwIfDisposed();
     const pathsJson = JSON.stringify(paths);
-    const resultStr = await JsonEvalRs.getSchemaByPaths(this.handle, pathsJson);
+    const resultStr = await JsonEvalRs.getSchemaByPaths(this.handle, pathsJson, format);
     return JSON.parse(resultStr);
   }
 
@@ -661,15 +657,15 @@ class JSONEval {
 
   /**
    * Get evaluated schema by multiple paths from subform
-   * Returns a merged object containing all requested paths (skips paths that are not found)
-   * @param options - Options including subform path, array of schema paths, and skipLayout flag
-   * @returns Promise resolving to merged object containing all found paths
+   * Returns data in the specified format (skips paths that are not found)
+   * @param options - Options including subform path, array of schema paths, skipLayout flag, and format
+   * @returns Promise resolving to data in the specified format
    * @throws {Error} If operation fails
    */
   async getEvaluatedSchemaByPathsSubform(options) {
     this.throwIfDisposed();
     const pathsJson = JSON.stringify(options.schemaPaths);
-    const resultStr = await JsonEvalRs.getEvaluatedSchemaByPathsSubform(this.handle, options.subformPath, pathsJson, options.skipLayout || false);
+    const resultStr = await JsonEvalRs.getEvaluatedSchemaByPathsSubform(this.handle, options.subformPath, pathsJson, options.skipLayout || false, options.format !== undefined ? options.format : ReturnFormat.Nested);
     return JSON.parse(resultStr);
   }
 
@@ -698,15 +694,15 @@ class JSONEval {
 
   /**
    * Get schema values by multiple paths from subform
-   * Returns a merged object containing all requested paths (skips paths that are not found)
-   * @param options - Options including subform path and array of schema paths
-   * @returns Promise resolving to merged object containing all found paths
+   * Returns data in the specified format (skips paths that are not found)
+   * @param options - Options including subform path, array of schema paths, and format
+   * @returns Promise resolving to data in the specified format
    * @throws {Error} If operation fails
    */
   async getSchemaByPathsSubform(options) {
     this.throwIfDisposed();
     const pathsJson = JSON.stringify(options.schemaPaths);
-    const resultStr = await JsonEvalRs.getSchemaByPathsSubform(this.handle, options.subformPath, pathsJson);
+    const resultStr = await JsonEvalRs.getSchemaByPathsSubform(this.handle, options.subformPath, pathsJson, options.format !== undefined ? options.format : ReturnFormat.Nested);
     return JSON.parse(resultStr);
   }