Support passing mergeOptions to pop and dismissModal commands

lib/android/app/src/main/java/com/reactnativenavigation/parse/Options.java

 import org.json.JSONObject;
 
 public class Options {
+    public static final Options EMPTY = new Options();
 
     @NonNull
     public static Options parse(TypefaceLoader typefaceManager, JSONObject json) {

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

 
 	@ReactMethod
 	public void setDefaultOptions(ReadableMap options) {
-        final Options defaultOptions = Options.parse(new TypefaceLoader(activity()), JSONParser.parse(options));
-        handle(() -> navigator().setDefaultOptions(defaultOptions));
+        handle(() -> navigator().setDefaultOptions(parse(options)));
     }
 
 	@ReactMethod
 	public void mergeOptions(String onComponentId, ReadableMap options) {
-		final Options navOptions = Options.parse(new TypefaceLoader(activity()), JSONParser.parse(options));
-		handle(() -> navigator().mergeOptions(onComponentId, navOptions));
+		handle(() -> navigator().mergeOptions(onComponentId, parse(options)));
 	}
 
 	@ReactMethod
     }
 
 	@ReactMethod
-	public void pop(String commandId, String componentId, ReadableMap options, Promise promise) {
-		handle(() -> navigator().pop(componentId, new NativeCommandListener(commandId, promise, eventEmitter, now)));
+	public void pop(String commandId, String componentId, ReadableMap mergeOptions, Promise promise) {
+		handle(() -> navigator().pop(componentId, parse(mergeOptions), new NativeCommandListener(commandId, promise, eventEmitter, now)));
 	}
 
 	@ReactMethod
-	public void popTo(String commandId, String componentId, Promise promise) {
-		handle(() -> navigator().popTo(componentId, new NativeCommandListener(commandId, promise, eventEmitter, now)));
+	public void popTo(String commandId, String componentId, ReadableMap mergeOptions, Promise promise) {
+		handle(() -> navigator().popTo(componentId, parse(mergeOptions), new NativeCommandListener(commandId, promise, eventEmitter, now)));
 	}
 
 	@ReactMethod
-	public void popToRoot(String commandId, String componentId, Promise promise) {
-		handle(() -> navigator().popToRoot(componentId, new NativeCommandListener(commandId, promise, eventEmitter, now)));
+	public void popToRoot(String commandId, String componentId, ReadableMap mergeOptions, Promise promise) {
+		handle(() -> navigator().popToRoot(componentId, parse(mergeOptions), new NativeCommandListener(commandId, promise, eventEmitter, now)));
 	}
 
 	@ReactMethod
 	}
 
 	@ReactMethod
-	public void dismissModal(String commandId, String componentId, Promise promise) {
-		handle(() -> navigator().dismissModal(componentId, new NativeCommandListener(commandId, promise, eventEmitter, now)));
+	public void dismissModal(String commandId, String componentId, ReadableMap mergeOptions, Promise promise) {
+		handle(() -> {
+            navigator().mergeOptions(componentId, parse(mergeOptions));
+            navigator().dismissModal(componentId, new NativeCommandListener(commandId, promise, eventEmitter, now));
+        });
 	}
 
-	@ReactMethod
-	public void dismissAllModals(String commandId, Promise promise) {
-		handle(() -> navigator().dismissAllModals(new NativeCommandListener(commandId, promise, eventEmitter, now)));
+    @ReactMethod
+	public void dismissAllModals(String commandId, ReadableMap mergeOptions, Promise promise) {
+		handle(() -> navigator().dismissAllModals(parse(mergeOptions), new NativeCommandListener(commandId, promise, eventEmitter, now)));
 	}
 
 	@ReactMethod
         );
 	}
 
+    private Options parse(ReadableMap mergeOptions) {
+        return Options.parse(new TypefaceLoader(activity()), JSONParser.parse(mergeOptions));
+    }
+
 	private Map<String, ExternalComponentCreator> externalComponentCreator() {
         return ((NavigationApplication) activity().getApplication()).getExternalComponents();
     }

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/Navigator.java

         applyOnStack(id, listener, stack -> stack.setRoot(viewController, listener));
     }
 
-    public void pop(String id, CommandListener listener) {
-        applyOnStack(id, listener, stack -> stack.pop(listener));
+    public void pop(String id, Options mergeOptions, CommandListener listener) {
+        applyOnStack(id, listener, stack -> {
+            stack.peek().mergeOptions(mergeOptions);
+            stack.pop(listener);
+        });
     }
 
-    public void popToRoot(final String id, CommandListener listener) {
-        applyOnStack(id, listener, stack -> stack.popToRoot(listener));
+    public void popToRoot(final String id, Options mergeOptions, CommandListener listener) {
+        applyOnStack(id, listener, stack -> stack.popToRoot(mergeOptions, listener));
     }
 
-    public void popTo(final String id, CommandListener listener) {
+    public void popTo(final String id, Options mergeOptions, CommandListener listener) {
         ViewController target = findControllerById(id);
         if (target != null) {
-            target.performOnParentStack(stack -> ((StackController) stack).popTo(target, listener));
+            target.performOnParentStack(stack -> {
+                ((StackController) stack).popTo(target, mergeOptions, listener);
+            });
         } else {
             listener.onError("Failed to execute stack command. Stack by " + id + " not found.");
         }
         modalStack.dismissModal(componentId, root, listener);
     }
 
-    public void dismissAllModals(CommandListener listener) {
-        modalStack.dismissAllModals(listener, root);
+    public void dismissAllModals(Options mergeOptions, CommandListener listener) {
+        modalStack.dismissAllModals(root, mergeOptions, listener);
     }
 
     public void showOverlay(ViewController overlay, CommandListener listener) {

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/ViewController.java

         return false;
     }
 
-    void performOnParentStack(Task accept, Runnable reject) {
+    void performOnParentStack(Task<StackController> accept, Runnable reject) {
         if (!performOnParentStack(accept)) {
             reject.run();
         }

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/modal/ModalStack.java

         }
     }
 
-    public void dismissAllModals(CommandListener listener, ViewController root) {
+    public void dismissAllModals(ViewController root, Options mergeOptions, CommandListener listener) {
         if (modals.isEmpty()) {
             listener.onError("Nothing to dismiss");
             return;
         String topModalId = peek().getId();
         int modalsDismissed = size();
 
+        peek().mergeOptions(mergeOptions);
+
         while (!modals.isEmpty()) {
             if (modals.size() == 1) {
                 dismissModal(modals.get(0).getId(), root, new CommandListenerAdapter(listener) {

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/stack/StackController.java

         listener.onSuccess(disappearing.getId());
     }
 
-    public void popTo(final ViewController viewController, CommandListener listener) {
-        if (!stack.containsId(viewController.getId())) {
+    public void popTo(ViewController viewController, Options mergeOptions, CommandListener listener) {
+        if (!stack.containsId(viewController.getId()) || peek().equals(viewController)) {
             listener.onError("Nothing to pop");
             return;
         }
 
+        peek().mergeOptions(mergeOptions);
+
         Iterator<String> iterator = stack.iterator();
         String currentControlId = iterator.next();
         while (!viewController.getId().equals(currentControlId)) {
         pop(listener);
     }
 
-    public void popToRoot(CommandListener listener) {
+    public void popToRoot(Options mergeOptions, CommandListener listener) {
         if (!canPop()) {
             listener.onError("Nothing to pop");
             return;
         }
 
+        peek().mergeOptions(mergeOptions);
         Iterator<String> iterator = stack.iterator();
         while (stack.size() > 2) {
             ViewController controller = stack.get(iterator.next());

lib/android/app/src/test/java/com/reactnativenavigation/viewcontrollers/NavigatorTest.java

 
     @Test
     public void pop_InvalidDoesNothing() {
-        uut.pop("123", new CommandListenerAdapter());
+        uut.pop("123", Options.EMPTY, new CommandListenerAdapter());
         uut.setRoot(child1, new CommandListenerAdapter());
-        uut.pop(child1.getId(), new CommandListenerAdapter());
+        uut.pop(child1.getId(), Options.EMPTY, new CommandListenerAdapter());
         assertThat(uut.getChildControllers()).hasSize(1);
     }
 
                 stack2.push(child4, new CommandListenerAdapter() {
                             @Override
                             public void onSuccess(String childId) {
-                                uut.pop("child4", new CommandListenerAdapter());
+                                uut.pop("child4", Options.EMPTY, new CommandListenerAdapter());
                                 assertThat(stack2.getChildControllers()).containsOnly(child2, child3);
                             }
                         }
         stack.push(child1, new CommandListenerAdapter());
         stack.push(child2, new CommandListenerAdapter());
 
-        uut.pop(stack.getId(), new CommandListenerAdapter());
+        uut.pop(stack.getId(), Options.EMPTY, new CommandListenerAdapter());
         assertThat(stack.getChildControllers()).containsOnly(child1);
     }
 
         stack2.push(child5, new CommandListenerAdapter() {
             @Override
             public void onSuccess(String childId) {
-                uut.popTo(child2.getId(), new CommandListenerAdapter());
+                uut.popTo(child2.getId(), Options.EMPTY, new CommandListenerAdapter());
                 assertThat(stack2.getChildControllers()).containsOnly(child2);
             }
         });
         stack2.push(child5, new CommandListenerAdapter() {
             @Override
             public void onSuccess(String childId) {
-                uut.popToRoot(child3.getId(), new CommandListenerAdapter());
+                uut.popToRoot(child3.getId(), Options.EMPTY, new CommandListenerAdapter());
                 assertThat(stack2.getChildControllers()).containsOnly(child2);
             }
         });
 
     @Test
     public void pop_InvalidDoesNothing_Promise() {
-        uut.pop("123", new CommandListenerAdapter());
+        uut.pop("123", Options.EMPTY, new CommandListenerAdapter());
         uut.setRoot(child1, new CommandListenerAdapter());
-        uut.pop(child1.getId(), new CommandListenerAdapter() {
+        uut.pop(child1.getId(), Options.EMPTY, new CommandListenerAdapter() {
             @Override
             public void onError(String reason) {
                 assertThat(uut.getChildControllers()).hasSize(1);
         stack2.push(child4, new CommandListenerAdapter() {
             @Override
             public void onSuccess(String childId) {
-                uut.pop("child4", new CommandListenerAdapter());
+                uut.pop("child4", Options.EMPTY, new CommandListenerAdapter());
                 assertThat(stack2.getChildControllers()).containsOnly(child2, child3);
             }
         });
                 assertThat(spy.getChildControllers().size()).isEqualTo(1);
             }
         };
-        uut.pop("child2", listener);
+        uut.pop("child2", Options.EMPTY, listener);
         verify(spy, times(1)).pop(listener);
     }
 
         disablePushAnimation(child2);
         disableShowModalAnimation(child1);
 
-        uut.dismissAllModals(new CommandListenerAdapter());
+        uut.dismissAllModals(Options.EMPTY, new CommandListenerAdapter());
         verify(parentVisibilityListener, times(0)).onViewAppeared(parentController.getView());
 
         uut.setRoot(parentController, new CommandListenerAdapter());
 
         verify(parentVisibilityListener, times(1)).onViewAppeared(parentController.getView());
         uut.showModal(child1, new CommandListenerAdapter());
-        uut.dismissAllModals(new CommandListenerAdapter());
+        uut.dismissAllModals(Options.EMPTY, new CommandListenerAdapter());
 
         verify(parentVisibilityListener, times(2)).onViewAppeared(parentController.getView());
     }

lib/android/app/src/test/java/com/reactnativenavigation/viewcontrollers/modal/ModalStackTest.java

                 assertThat(uut.isEmpty()).isTrue();
             }
         });
-        uut.dismissAllModals(listener, rootController);
+        uut.dismissAllModals(rootController, Options.EMPTY, listener);
         verify(listener, times(1)).onSuccess(anyString());
         verifyZeroInteractions(listener);
     }
     @Test
     public void dismissAllModals_rejectIfEmpty() {
         CommandListener spy = spy(new CommandListenerAdapter());
-        uut.dismissAllModals(spy, rootController);
+        uut.dismissAllModals(rootController, Options.EMPTY, spy);
         verify(spy, times(1)).onError(any());
     }
 
+    @Test
+    public void dismissAllModals_optionsAreMergedOnTopModal() {
+        uut.showModal(modal1, rootController, new CommandListenerAdapter());
+        uut.showModal(modal2, rootController, new CommandListenerAdapter());
+        uut.showModal(modal3, rootController, new CommandListenerAdapter());
+
+        Options mergeOptions = new Options();
+        uut.dismissAllModals(rootController, mergeOptions, new CommandListenerAdapter());
+        verify(modal3).mergeOptions(mergeOptions);
+        verify(modal1, times(0)).mergeOptions(mergeOptions);
+        verify(modal2, times(0)).mergeOptions(mergeOptions);
+    }
+
     @SuppressWarnings("Convert2Lambda")
     @Test
     public void dismissAllModals_onlyTopModalIsAnimated() {
         ViewGroup view1 = modal1.getView();
         ViewGroup view2 = modal2.getView();
         CommandListener listener = spy(new CommandListenerAdapter());
-        uut.dismissAllModals(listener, rootController);
+        uut.dismissAllModals(rootController, Options.EMPTY, listener);
         verify(presenter, times(1)).dismissTopModal(eq(modal2), eq(rootController), any());
         verify(listener).onSuccess(modal2.getId());
         verify(animator, times(0)).dismiss(eq(view1), eq(modal1.options.animations.dismissModal), any());
         uut.showModal(modal1, rootController, new CommandListenerAdapter());
         uut.showModal(modal2, rootController, new CommandListenerAdapter());
 
-        uut.dismissAllModals(new CommandListenerAdapter(), rootController);
+        uut.dismissAllModals(rootController, Options.EMPTY, new CommandListenerAdapter());
 
         verify(modal1, times(1)).destroy();
         verify(modal1, times(1)).onViewDisappear();
         assertThat(uut.isEmpty()).isTrue();
         uut.showModal(modal1, rootController, new CommandListenerAdapter());
         assertThat(uut.isEmpty()).isFalse();
-        uut.dismissAllModals(new CommandListenerAdapter(), rootController);
+        uut.dismissAllModals(rootController, Options.EMPTY, new CommandListenerAdapter());
         assertThat(uut.isEmpty()).isTrue();
     }
 

lib/android/app/src/test/java/com/reactnativenavigation/viewcontrollers/stack/StackControllerTest.java

                 assertThat(uut.size()).isEqualTo(3);
                 assertThat(uut.peek()).isEqualTo(child3);
 
-                uut.popTo(child1, new CommandListenerAdapter());
+                uut.popTo(child1, Options.EMPTY, new CommandListenerAdapter());
 
                 assertThat(uut.size()).isEqualTo(1);
                 assertThat(uut.peek()).isEqualTo(child1);
         });
     }
 
+    @Test
+    public void popTo_optionsAreMergedOnTopChild() {
+        disablePushAnimation(child1, child2);
+        uut.push(child1, new CommandListenerAdapter());
+
+        Options mergeOptions = new Options();
+        uut.popTo(child2, mergeOptions, new CommandListenerAdapter());
+        uut.popTo(child1, mergeOptions, new CommandListenerAdapter());
+        verify(child1, times(0)).mergeOptions(mergeOptions);
+
+        uut.push(child2, new CommandListenerAdapter());
+        uut.popTo(child1, mergeOptions, new CommandListenerAdapter());
+        verify(child2).mergeOptions(mergeOptions);
+    }
+
     @Test
     public void popTo_NotAChildOfThisStack_DoesNothing() {
         uut.push(child1, new CommandListenerAdapter());
         uut.push(child3, new CommandListenerAdapter());
         assertThat(uut.size()).isEqualTo(2);
-        uut.popTo(child2, new CommandListenerAdapter());
+        uut.popTo(child2, Options.EMPTY, new CommandListenerAdapter());
         assertThat(uut.size()).isEqualTo(2);
     }
 
         uut.push(child4, new CommandListenerAdapter() {
             @Override
             public void onSuccess(String childId) {
-                uut.popTo(child2, new CommandListenerAdapter() {
+                uut.popTo(child2, Options.EMPTY, new CommandListenerAdapter() {
                     @Override
                     public void onSuccess(String childId) {
                         verify(animator, times(0)).pop(eq(child1.getView()), any(), any());
                 assertThat(uut.size()).isEqualTo(3);
                 assertThat(uut.peek()).isEqualTo(child3);
 
-                uut.popToRoot(new CommandListenerAdapter() {
+                uut.popToRoot(Options.EMPTY, new CommandListenerAdapter() {
                     @Override
                     public void onSuccess(String childId) {
                         assertThat(uut.size()).isEqualTo(1);
         uut.push(child3, new CommandListenerAdapter() {
             @Override
             public void onSuccess(String childId) {
-                uut.popToRoot(new CommandListenerAdapter() {
+                uut.popToRoot(Options.EMPTY, new CommandListenerAdapter() {
                     @Override
                     public void onSuccess(String childId) {
                         verify(animator, times(1)).pop(eq(child3.getView()), eq(child3.options.animations.pop), any());
         uut.push(child2, new CommandListenerAdapter());
         uut.push(child3, new CommandListenerAdapter());
 
-        uut.popToRoot(new CommandListenerAdapter() {
+        uut.popToRoot(Options.EMPTY, new CommandListenerAdapter() {
             @Override
             public void onSuccess(String childId) {
                 verify(child1, times(0)).destroy();
     public void popToRoot_EmptyStackDoesNothing() {
         assertThat(uut.isEmpty()).isTrue();
         CommandListenerAdapter listener = spy(new CommandListenerAdapter());
-        uut.popToRoot(listener);
+        uut.popToRoot(Options.EMPTY, listener);
         assertThat(uut.isEmpty()).isTrue();
         verify(listener, times(1)).onError(any());
     }
 
+    @Test
+    public void popToRoot_optionsAreMergedOnTopChild() {
+        disablePushAnimation(child1, child2);
+        uut.push(child1, new CommandListenerAdapter());
+        uut.push(child2, new CommandListenerAdapter());
+
+        Options mergeOptions = new Options();
+        uut.popToRoot(mergeOptions, new CommandListenerAdapter());
+        verify(child2).mergeOptions(mergeOptions);
+        verify(child1, times(0)).mergeOptions(mergeOptions);
+    }
+
     @Test
     public void findControllerById_ReturnsSelfOrChildrenById() {
         assertThat(uut.findControllerById("123")).isNull();
                 verify(child2, times(0)).destroy();
                 verify(child3, times(0)).destroy();
 
-                uut.popTo(child1, new CommandListenerAdapter() {
+                uut.popTo(child1, Options.EMPTY, new CommandListenerAdapter() {
                     @Override
                     public void onSuccess(String childId) {
                         verify(child2, times(1)).destroy();

lib/src/adapters/NativeCommandsSender.ts

     return this.nativeCommandsModule.pop(commandId, componentId, options);
   }
 
-  popTo(commandId: string, componentId: string) {
-    return this.nativeCommandsModule.popTo(commandId, componentId);
+  popTo(commandId: string, componentId: string, options: object) {
+    return this.nativeCommandsModule.popTo(commandId, componentId, options);
   }
 
-  popToRoot(commandId: string, componentId: string) {
-    return this.nativeCommandsModule.popToRoot(commandId, componentId);
+  popToRoot(commandId: string, componentId: string, options: object) {
+    return this.nativeCommandsModule.popToRoot(commandId, componentId, options);
   }
 
   setStackRoot(commandId: string, onComponentId: string, layout: object) {
     return this.nativeCommandsModule.showModal(commandId, layout);
   }
 
-  dismissModal(commandId: string, componentId: string) {
-    return this.nativeCommandsModule.dismissModal(commandId, componentId);
+  dismissModal(commandId: string, componentId: string, options: object) {
+    return this.nativeCommandsModule.dismissModal(commandId, componentId, options);
   }
 
-  dismissAllModals(commandId: string) {
-    return this.nativeCommandsModule.dismissAllModals(commandId);
+  dismissAllModals(commandId: string, options: object) {
+    return this.nativeCommandsModule.dismissAllModals(commandId, options);
   }
 
   showOverlay(commandId: string, layout: object) {

lib/src/commands/Commands.ts

     return result;
   }
 
-  public dismissModal(componentId) {
+  public dismissModal(componentId, mergeOptions) {
     const commandId = this.uniqueIdProvider.generate('dismissModal');
-    const result = this.nativeCommandsSender.dismissModal(commandId, componentId);
-    this.commandsObserver.notify('dismissModal', { commandId, componentId });
+    const result = this.nativeCommandsSender.dismissModal(commandId, componentId, mergeOptions);
+    this.commandsObserver.notify('dismissModal', { commandId, componentId, mergeOptions});
     return result;
   }
 
-  public dismissAllModals() {
+  public dismissAllModals(mergeOptions) {
     const commandId = this.uniqueIdProvider.generate('dismissAllModals');
-    const result = this.nativeCommandsSender.dismissAllModals(commandId);
+    const result = this.nativeCommandsSender.dismissAllModals(commandId, mergeOptions);
     this.commandsObserver.notify('dismissAllModals', { commandId });
     return result;
   }
     return result;
   }
 
-  public pop(componentId, options) {
+  public pop(componentId, mergeOptions) {
     const commandId = this.uniqueIdProvider.generate('pop');
-    const result = this.nativeCommandsSender.pop(commandId, componentId, options);
-    this.commandsObserver.notify('pop', { commandId, componentId, options });
+    const result = this.nativeCommandsSender.pop(commandId, componentId, mergeOptions);
+    this.commandsObserver.notify('pop', { commandId, componentId, mergeOptions });
     return result;
   }
 
-  public popTo(componentId) {
+  public popTo(componentId, mergeOptions) {
     const commandId = this.uniqueIdProvider.generate('popTo');
-    const result = this.nativeCommandsSender.popTo(commandId, componentId);
-    this.commandsObserver.notify('popTo', { commandId, componentId });
+    const result = this.nativeCommandsSender.popTo(commandId, componentId, mergeOptions);
+    this.commandsObserver.notify('popTo', { commandId, componentId, mergeOptions });
     return result;
   }
 
-  public popToRoot(componentId) {
+  public popToRoot(componentId, mergeOptions) {
     const commandId = this.uniqueIdProvider.generate('popToRoot');
-    const result = this.nativeCommandsSender.popToRoot(commandId, componentId);
-    this.commandsObserver.notify('popToRoot', { commandId, componentId });
+    const result = this.nativeCommandsSender.popToRoot(commandId, componentId, mergeOptions);
+    this.commandsObserver.notify('popToRoot', { commandId, componentId, mergeOptions });
     return result;
   }