Parse ReadableMap to JSONObject without conversion to HashMap

This should fix conversion issues found in RN 0.54

lib/android/app/src/main/java/com/reactnativenavigation/parse/parsers/JSONParser.java

+package com.reactnativenavigation.parse.parsers;
+
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.ReadableMapKeySetIterator;
+
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+public class JSONParser {
+    public static JSONObject parse(ReadableMap map) {
+        try {
+            ReadableMapKeySetIterator it = map.keySetIterator();
+            JSONObject result = new JSONObject();
+            while (it.hasNextKey()) {
+                String key = it.nextKey();
+                switch (map.getType(key)) {
+                    case String:
+                        result.put(key, map.getString(key));
+                        break;
+                    case Number:
+                        result.put(key, parseNumber(map, key));
+                        break;
+                    case Boolean:
+                        result.put(key, map.getBoolean(key));
+                        break;
+                    case Array:
+                        result.put(key, parse(map.getArray(key)));
+                        break;
+                    case Map:
+                        result.put(key, parse(map.getMap(key)));
+                        break;
+                    default:
+                        break;
+                }
+            }
+            return result;
+        } catch (JSONException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public static JSONArray parse(ReadableArray arr) {
+        JSONArray result = new JSONArray();
+        for (int i = 0; i < arr.size(); i++) {
+            switch (arr.getType(i)) {
+                case String:
+                    result.put(arr.getString(i));
+                    break;
+                case Number:
+                    result.put(parseNumber(arr, i));
+                    break;
+                case Boolean:
+                    result.put(arr.getBoolean(i));
+                    break;
+                case Array:
+                    result.put(parse(arr.getArray(i)));
+                    break;
+                case Map:
+                    result.put(parse(arr.getMap(i)));
+                    break;
+                default:
+                    break;
+            }
+        }
+        return result;
+    }
+
+    private static Object parseNumber(ReadableMap map, String key) {
+        try {
+            return map.getInt(key);
+        } catch (Exception e) {
+            return map.getDouble(key);
+        }
+    }
+
+    private static Object parseNumber(ReadableArray arr, int index) {
+        try {
+            return arr.getInt(index);
+        } catch (Exception e) {
+            return arr.getDouble(index);
+        }
+    }
+}

lib/android/app/src/main/java/com/reactnativenavigation/react/NavigationModule.java

 import com.reactnativenavigation.parse.LayoutFactory;
 import com.reactnativenavigation.parse.LayoutNode;
 import com.reactnativenavigation.parse.Options;
+import com.reactnativenavigation.parse.parsers.JSONParser;
 import com.reactnativenavigation.parse.parsers.LayoutNodeParser;
 import com.reactnativenavigation.utils.NativeCommandListener;
 import com.reactnativenavigation.utils.Now;
 import com.reactnativenavigation.viewcontrollers.ViewController;
 import com.reactnativenavigation.viewcontrollers.externalcomponent.ExternalComponentCreator;
 
-import org.json.JSONObject;
-
 import java.util.HashMap;
 import java.util.Map;
 
 
 	@ReactMethod
 	public void setRoot(String commandId, ReadableMap rawLayoutTree, Promise promise) {
-		final LayoutNode layoutTree = LayoutNodeParser.parse(new JSONObject(rawLayoutTree.getMap("root").toHashMap()));
+		final LayoutNode layoutTree = LayoutNodeParser.parse(JSONParser.parse(rawLayoutTree).optJSONObject("root"));
 		handle(() -> {
             final ViewController viewController = newLayoutFactory().create(layoutTree);
             navigator().setRoot(viewController, new NativeCommandListener(commandId, promise, eventEmitter, now));
 
 	@ReactMethod
 	public void setDefaultOptions(ReadableMap options) {
-        final Options defaultOptions = Options.parse(new TypefaceLoader(activity()), new JSONObject(options.toHashMap()));
+        final Options defaultOptions = Options.parse(new TypefaceLoader(activity()), JSONParser.parse(options));
         handle(() -> navigator().setDefaultOptions(defaultOptions));
     }
 
 	@ReactMethod
 	public void mergeOptions(String onComponentId, ReadableMap options) {
-		final Options navOptions = Options.parse(new TypefaceLoader(activity()), new JSONObject(options.toHashMap()));
+		final Options navOptions = Options.parse(new TypefaceLoader(activity()), JSONParser.parse(options));
 		handle(() -> navigator().mergeOptions(onComponentId, navOptions));
 	}
 
 	@ReactMethod
 	public void push(String commandId, String onComponentId, ReadableMap rawLayoutTree, Promise promise) {
-		final LayoutNode layoutTree = LayoutNodeParser.parse(new JSONObject(rawLayoutTree.toHashMap()));
+		final LayoutNode layoutTree = LayoutNodeParser.parse(JSONParser.parse(rawLayoutTree));
 		handle(() -> {
             final ViewController viewController = newLayoutFactory().create(layoutTree);
             navigator().push(onComponentId, viewController, new NativeCommandListener(commandId, promise, eventEmitter, now));
 
     @ReactMethod
     public void setStackRoot(String commandId, String onComponentId, ReadableMap rawLayoutTree, Promise promise) {
-        final LayoutNode layoutTree = LayoutNodeParser.parse(new JSONObject(rawLayoutTree.toHashMap()));
+        final LayoutNode layoutTree = LayoutNodeParser.parse(JSONParser.parse(rawLayoutTree));
         handle(() -> {
             final ViewController viewController = newLayoutFactory().create(layoutTree);
             navigator().setStackRoot(onComponentId, viewController, new NativeCommandListener(commandId, promise, eventEmitter, now));
 
 	@ReactMethod
 	public void showModal(String commandId, ReadableMap rawLayoutTree, Promise promise) {
-		final LayoutNode layoutTree = LayoutNodeParser.parse(new JSONObject(rawLayoutTree.toHashMap()));
+		final LayoutNode layoutTree = LayoutNodeParser.parse(JSONParser.parse(rawLayoutTree));
 		handle(() -> {
             final ViewController viewController = newLayoutFactory().create(layoutTree);
             navigator().showModal(viewController, new NativeCommandListener(commandId, promise, eventEmitter, now));
 
 	@ReactMethod
 	public void showOverlay(String commandId, ReadableMap rawLayoutTree, Promise promise) {
-        final LayoutNode layoutTree = LayoutNodeParser.parse(new JSONObject(rawLayoutTree.toHashMap()));
+        final LayoutNode layoutTree = LayoutNodeParser.parse(JSONParser.parse(rawLayoutTree));
         handle(() -> {
             final ViewController viewController = newLayoutFactory().create(layoutTree);
             navigator().showOverlay(viewController, new NativeCommandListener(commandId, promise, eventEmitter, now));

lib/android/app/src/test/java/com/reactnativenavigation/parse/parsers/JSONParserTest.java

+package com.reactnativenavigation.parse.parsers;
+
+import com.facebook.react.bridge.JavaOnlyArray;
+import com.facebook.react.bridge.JavaOnlyMap;
+import com.reactnativenavigation.BaseTest;
+
+import org.json.JSONArray;
+import org.json.JSONObject;
+import org.junit.Test;
+
+import static org.assertj.core.api.Java6Assertions.assertThat;
+
+public class JSONParserTest extends BaseTest {
+    @Test
+    public void parsesMap() throws Exception {
+        JavaOnlyMap input = new JavaOnlyMap();
+        input.putString("keyString", "stringValue");
+        input.putInt("keyInt", 123);
+        input.putDouble("keyDouble", 123.456);
+        input.putBoolean("keyBoolean", true);
+        input.putArray("keyArray", new JavaOnlyArray());
+        input.putMap("keyMap", new JavaOnlyMap());
+        input.putNull("bla");
+
+        JSONObject result = JSONParser.parse(input);
+
+
+        assertThat(result.keys()).containsOnly(
+                "keyString",
+                "keyInt",
+                "keyDouble",
+                "keyBoolean",
+                "keyMap",
+                "keyArray");
+
+        assertThat(result.get("keyString")).isEqualTo("stringValue");
+        assertThat(result.get("keyInt")).isEqualTo(123);
+        assertThat(result.get("keyDouble")).isEqualTo(123.456);
+        assertThat(result.get("keyBoolean")).isEqualTo(true);
+        assertThat(result.getJSONObject("keyMap").keys()).isEmpty();
+        assertThat(result.getJSONArray("keyArray").length()).isZero();
+    }
+
+    @Test
+    public void parsesArrays() throws Exception {
+        JavaOnlyArray input = new JavaOnlyArray();
+        input.pushString("Hello");
+        input.pushInt(123);
+        input.pushDouble(123.456);
+        input.pushBoolean(true);
+        input.pushArray(new JavaOnlyArray());
+        input.pushMap(new JavaOnlyMap());
+        input.pushNull();
+
+        JSONArray result = JSONParser.parse(input);
+        assertThat(result.length()).isEqualTo(6);
+        assertThat(result.get(0)).isEqualTo("Hello");
+        assertThat(result.get(1)).isEqualTo(123);
+        assertThat(result.get(2)).isEqualTo(123.456);
+        assertThat(result.get(3)).isEqualTo(true);
+        assertThat(result.getJSONArray(4).length()).isZero();
+        assertThat(result.getJSONObject(5).keys()).isEmpty();
+    }
+}