Merge options (#3930)

mergeOptions support for 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

 package com.reactnativenavigation.react;
 
 import android.support.annotation.NonNull;
+import android.support.annotation.Nullable;
 
 import com.facebook.react.ReactInstanceManager;
 import com.facebook.react.bridge.Arguments;
 
 	@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));
+	public void mergeOptions(String onComponentId, @Nullable ReadableMap options) {
+		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, @Nullable 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, @Nullable 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, @Nullable 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, @Nullable 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, @Nullable ReadableMap mergeOptions, Promise promise) {
+		handle(() -> navigator().dismissAllModals(parse(mergeOptions), new NativeCommandListener(commandId, promise, eventEmitter, now)));
 	}
 
 	@ReactMethod
         );
 	}
 
+    private  Options parse(@Nullable ReadableMap mergeOptions) {
+        return mergeOptions == null ? Options.EMPTY : 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/ChildController.java

 
     @Override
     public void mergeOptions(Options options) {
+        if (options == Options.EMPTY) return;
         presenter.mergeOptions(getView(), options);
         super.mergeOptions(options);
     }

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

 
     @Override
     public void mergeOptions(Options options) {
+        if (options == Options.EMPTY) return;
         performOnParentController(parentController -> parentController.mergeChildOptions(options, this, getView()));
         super.mergeOptions(options);
     }

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.pop(mergeOptions, 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

         this.parentController = parentController;
     }
 
-    boolean performOnParentStack(Task<StackController> task) {
+    void performOnParentStack(Task<StackController> task) {
         if (parentController instanceof StackController) {
             task.run((StackController) parentController);
-            return true;
-        }
-        if (this instanceof StackController) {
+        } else if (this instanceof StackController) {
             task.run((StackController) this);
-            return true;
-        }
-        return false;
-    }
-
-    void performOnParentStack(Task 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

         }
     }
 
-    public void pop(CommandListener listener) {
+    public void pop(Options mergeOptions, CommandListener listener) {
         if (!canPop()) {
             listener.onError("Nothing to pop");
             return;
 
         final ViewController disappearing = stack.pop();
         final ViewController appearing = stack.peek();
+        disappearing.mergeOptions(mergeOptions);
         disappearing.onViewWillDisappear();
         appearing.onViewWillAppear();
         Options resolvedOptions = resolveCurrentOptions();
         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;
         }
             currentControlId = iterator.next();
         }
 
-        pop(listener);
+        pop(mergeOptions, listener);
     }
 
-    public void popToRoot(CommandListener listener) {
+    public void popToRoot(Options mergeOptions, CommandListener listener) {
         if (!canPop()) {
             listener.onError("Nothing to pop");
             return;
             }
         }
 
-        pop(listener);
+        pop(mergeOptions, listener);
     }
 
     private void removeAndDestroyController(ViewController controller) {
     @Override
     public boolean handleBack(CommandListener listener) {
         if (canPop()) {
-            pop(listener);
+            pop(Options.EMPTY, listener);
             return true;
         }
         return false;
 
     private void onNavigationButtonPressed(String buttonId) {
         if (Constants.BACK_BUTTON_ID.equals(buttonId)) {
-            pop(new CommandListenerAdapter());
+            pop(Options.EMPTY, new CommandListenerAdapter());
         } else {
             sendOnNavigationButtonPressed(buttonId);
         }

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

 import org.junit.Test;
 
 import static org.assertj.core.api.Java6Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.spy;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
         uut.sendOnNavigationButtonPressed("btn1");
         verify(view, times(1)).sendOnNavigationButtonPressed("btn1");
     }
+
+    @Test
+    public void mergeOptions_emptyOptionsAreIgnored() {
+        ComponentViewController spy = spy(uut);
+        spy.mergeOptions(Options.EMPTY);
+        verify(spy, times(0)).performOnParentController(any());
+    }
 }

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

         stackController.push(childFab, new CommandListenerAdapter());
         childFab.onViewAppeared();
         assertThat(hasFab()).isTrue();
-        stackController.pop(new CommandListenerAdapter());
+        stackController.pop(Options.EMPTY, new CommandListenerAdapter());
         childNoFab.onViewAppeared();
         assertThat(hasFab()).isFalse();
     }
         stackController.push(childNoFab, new CommandListenerAdapter());
         childNoFab.onViewAppeared();
         assertThat(hasFab()).isFalse();
-        stackController.pop(new CommandListenerAdapter());
+        stackController.pop(Options.EMPTY, new CommandListenerAdapter());
         childFab.onViewAppeared();
         assertThat(hasFab()).isTrue();
     }

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);
-        verify(spy, times(1)).pop(listener);
+        uut.pop("child2", Options.EMPTY, listener);
+        verify(spy, times(1)).pop(Options.EMPTY, listener);
     }
 
     @Test
         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/TopTabsViewControllerTest.java

         uut.onViewAppeared();
 
         assertThat(ViewHelper.isVisible(stackController.getTopBar().getTopTabs())).isTrue();
-        stackController.pop(new CommandListenerAdapter() {
+        stackController.pop(Options.EMPTY, new CommandListenerAdapter() {
             @Override
             public void onSuccess(String childId) {
                 assertThat(ViewHelper.isVisible(stackController.getTopBar().getTopTabs())).isFalse();

lib/android/app/src/test/java/com/reactnativenavigation/viewcontrollers/child/ChildControllerTest.java

 import org.junit.Test;
 import org.mockito.Mockito;
 
+import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.spy;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
         uut.mergeOptions(options);
         verify(presenter).mergeOptions(uut.getView(), options);
     }
+
+    @Test
+    public void mergeOptions_emptyOptionsAreIgnored() {
+        uut.mergeOptions(Options.EMPTY);
+        verify(presenter, times(0)).mergeOptions(any(), any());
+    }
 }

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

             @Override
             public void onSuccess(String childId) {
                 assertContainsOnlyId(child2.getId(), child1.getId());
-                uut.pop(new CommandListenerAdapter());
+                uut.pop(Options.EMPTY, new CommandListenerAdapter());
                 assertContainsOnlyId(child1.getId());
             }
         });
         uut.push(child2, new CommandListenerAdapter() {
             @Override
             public void onSuccess(String childId) {
-                uut.pop(new CommandListenerAdapter());
+                uut.pop(Options.EMPTY, new CommandListenerAdapter());
                 verify(uut, times(1)).applyChildOptions(uut.options, eq((ReactComponent) child1.getView()));
             }
         });
         uut.push(child2, new CommandListenerAdapter() {
             @Override
             public void onSuccess(String childId) {
-                uut.pop(new CommandListenerAdapter() {
+                uut.pop(Options.EMPTY, new CommandListenerAdapter() {
                     @Override
                     public void onSuccess(String childId) {
                         verify(presenter, times(1)).onChildWillAppear(child1.options, child2.options);
     @Test
     public void popDoesNothingWhenZeroOrOneChild() {
         assertThat(uut.isEmpty()).isTrue();
-        uut.pop(new CommandListenerAdapter());
+        uut.pop(Options.EMPTY, new CommandListenerAdapter());
         assertThat(uut.isEmpty()).isTrue();
 
         uut.push(child1, new CommandListenerAdapter());
-        uut.pop(new CommandListenerAdapter());
+        uut.pop(Options.EMPTY, new CommandListenerAdapter());
         assertContainsOnlyId(child1.getId());
     }
 
             public void onSuccess(String childId) {
                 assertIsChild(uut.getView(), child2View);
                 assertNotChildOf(uut.getView(), child1View);
-                uut.pop(new CommandListenerAdapter());
+                uut.pop(Options.EMPTY, new CommandListenerAdapter());
                 assertNotChildOf(uut.getView(), child2View);
                 assertIsChild(uut.getView(), child1View);
             }
         uut.ensureViewIsCreated();
 
         assertThat(child2.getView().getParent()).isEqualTo(uut.getView());
-        uut.pop(new CommandListenerAdapter());
+        uut.pop(Options.EMPTY, new CommandListenerAdapter());
         assertThat(child1.getView().getParent()).isEqualTo(uut.getView());
 
         assertThat(child1.getView().getLayoutParams().width).isEqualTo(ViewGroup.LayoutParams.MATCH_PARENT);
                 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();
             @Override
             public void onSuccess(String childId) {
                 verify(child3, times(0)).destroy();
-                uut.pop(new CommandListenerAdapter());
+                uut.pop(Options.EMPTY, new CommandListenerAdapter());
                 verify(child3, times(1)).destroy();
             }
         });
         child2 = spy(child2);
         uut.push(child1, new CommandListenerAdapter());
         uut.push(child2, new CommandListenerAdapter());
-        uut.pop(new CommandListenerAdapter());
+        uut.pop(Options.EMPTY, new CommandListenerAdapter());
         verify(child1, times(1)).onViewWillAppear();
         verify(child2, times(1)).onViewWillDisappear();
     }
                 uut.push(child2, new CommandListenerAdapter() {
                     @Override
                     public void onSuccess(String childId) {
-                        uut.pop(new CommandListenerAdapter() {
+                        uut.pop(Options.EMPTY, new CommandListenerAdapter() {
                             @Override
                             public void onSuccess(String childId) {
                                 verify(uut.getTopBar(), times(1)).hideAnimate(child2.options.animations.pop.topBar);
                 uut.push(child2, new CommandListenerAdapter());
                 assertThat(uut.getTopBar().getVisibility()).isEqualTo(View.VISIBLE);
 
-                uut.pop(new CommandListenerAdapter());
+                uut.pop(Options.EMPTY, new CommandListenerAdapter());
                 verify(uut.getTopBar(), times(0)).hideAnimate(child2.options.animations.pop.topBar);
                 assertThat(uut.getTopBar().getVisibility()).isEqualTo(View.GONE);
             }
                 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/ios/RNNBridgeModule.m

 	} rejection:reject];
 }
 
-RCT_EXPORT_METHOD(pop:(NSString*)commandId componentId:(NSString*)componentId options:(NSDictionary*)options resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject) {
-	[_commandsHandler pop:componentId options:(NSDictionary*)options completion:^{
+RCT_EXPORT_METHOD(pop:(NSString*)commandId componentId:(NSString*)componentId mergeOptions:(NSDictionary*)options resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject) {
+	[_commandsHandler pop:componentId mergeOptions:(NSDictionary*)options completion:^{
 		resolve(componentId);
 	} rejection:reject];
 }
 	} rejection:reject];
 }
 
-RCT_EXPORT_METHOD(popTo:(NSString*)commandId componentId:(NSString*)componentId resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject) {
-	[_commandsHandler popTo:componentId completion:^{
+RCT_EXPORT_METHOD(popTo:(NSString*)commandId componentId:(NSString*)componentId mergeOptions:(NSDictionary*)options resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject) {
+	[_commandsHandler popTo:componentId mergeOptions:options completion:^{
 		resolve(componentId);
 	} rejection:reject];
 }
 
-RCT_EXPORT_METHOD(popToRoot:(NSString*)commandId componentId:(NSString*)componentId resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject) {
-	[_commandsHandler popToRoot:componentId completion:^{
+RCT_EXPORT_METHOD(popToRoot:(NSString*)commandId componentId:(NSString*)componentId mergeOptions:(NSDictionary*)options resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject) {
+	[_commandsHandler popToRoot:componentId mergeOptions:options completion:^{
 		resolve(componentId);
 	} rejection:reject];
 }
 	}];
 }
 
-RCT_EXPORT_METHOD(dismissModal:(NSString*)commandId componentId:(NSString*)componentId resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject) {
-	[_commandsHandler dismissModal:componentId completion:^{
+RCT_EXPORT_METHOD(dismissModal:(NSString*)commandId componentId:(NSString*)componentId mergeOptions:(NSDictionary*)options resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject) {
+	[_commandsHandler dismissModal:componentId mergeOptions:options completion:^{
 		resolve(componentId);
 	}];
 }
 
-RCT_EXPORT_METHOD(dismissAllModals:(NSString*)commandId resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject) {
-	[_commandsHandler dismissAllModalsWithCompletion:^{
+RCT_EXPORT_METHOD(dismissAllModals:(NSString*)commandId mergeOptions:(NSDictionary*)options resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject) {
+	[_commandsHandler dismissAllModals:options completion:^{
 		resolve(nil);
 	}];
 }

lib/ios/RNNCommandsHandler.h

 
 @interface RNNCommandsHandler : NSObject
 
--(instancetype)initWithStore:(RNNStore*)store controllerFactory:(RNNControllerFactory*)controllerFactory eventEmitter:(RNNEventEmitter*)eventEmitter;
+- (instancetype)initWithStore:(RNNStore*)store controllerFactory:(RNNControllerFactory*)controllerFactory eventEmitter:(RNNEventEmitter*)eventEmitter;
 
--(void)setRoot:(NSDictionary*)layout completion:(RNNTransitionCompletionBlock)completion;
+- (void)setRoot:(NSDictionary*)layout completion:(RNNTransitionCompletionBlock)completion;
 
--(void)mergeOptions:(NSString*)componentId options:(NSDictionary*)options completion:(RNNTransitionCompletionBlock)completion;
+- (void)mergeOptions:(NSString*)componentId options:(NSDictionary*)options completion:(RNNTransitionCompletionBlock)completion;
 
--(void)setDefaultOptions:(NSDictionary*)options completion:(RNNTransitionCompletionBlock)completion;
+- (void)setDefaultOptions:(NSDictionary*)options completion:(RNNTransitionCompletionBlock)completion;
 
--(void)push:(NSString*)componentId layout:(NSDictionary*)layout completion:(RNNTransitionCompletionBlock)completion rejection:(RCTPromiseRejectBlock)rejection;
+- (void)push:(NSString*)componentId layout:(NSDictionary*)layout completion:(RNNTransitionCompletionBlock)completion rejection:(RCTPromiseRejectBlock)rejection;
 
--(void)pop:(NSString*)componentId options:(NSDictionary*)options completion:(RNNTransitionCompletionBlock)completion rejection:(RCTPromiseRejectBlock)rejection;
+- (void)pop:(NSString*)componentId mergeOptions:(NSDictionary*)options completion:(RNNTransitionCompletionBlock)completion rejection:(RCTPromiseRejectBlock)rejection;
 
--(void)popTo:(NSString*)componentId completion:(RNNTransitionCompletionBlock)completion rejection:(RCTPromiseRejectBlock)rejection;
+- (void)popTo:(NSString*)componentId mergeOptions:(NSDictionary*)options completion:(RNNTransitionCompletionBlock)completion rejection:(RCTPromiseRejectBlock)rejection;
 
--(void)popToRoot:(NSString*)componentId completion:(RNNTransitionCompletionBlock)completion rejection:(RCTPromiseRejectBlock)rejection;
+- (void)popToRoot:(NSString*)componentId mergeOptions:(NSDictionary*)options completion:(RNNTransitionCompletionBlock)completion rejection:(RCTPromiseRejectBlock)rejection;
 
--(void)setStackRoot:(NSString*)componentId layout:(NSDictionary*)layout completion:(RNNTransitionCompletionBlock)completion rejection:(RCTPromiseRejectBlock)rejection;
+- (void)setStackRoot:(NSString*)componentId layout:(NSDictionary*)layout completion:(RNNTransitionCompletionBlock)completion rejection:(RCTPromiseRejectBlock)rejection;
 
--(void)showModal:(NSDictionary*)layout completion:(RNNTransitionWithComponentIdCompletionBlock)completion;
+- (void)showModal:(NSDictionary*)layout completion:(RNNTransitionWithComponentIdCompletionBlock)completion;
 
--(void)dismissModal:(NSString*)componentId completion:(RNNTransitionCompletionBlock)completion;
+- (void)dismissModal:(NSString*)componentId mergeOptions:(NSDictionary*)options completion:(RNNTransitionCompletionBlock)completion;
 
--(void)dismissAllModalsWithCompletion:(RNNTransitionCompletionBlock)completion;
+- (void)dismissAllModals:(NSDictionary *)options completion:(RNNTransitionCompletionBlock)completion;
 
--(void)showOverlay:(NSDictionary *)layout completion:(RNNTransitionCompletionBlock)completion;
+- (void)showOverlay:(NSDictionary *)layout completion:(RNNTransitionCompletionBlock)completion;
 
--(void)dismissOverlay:(NSString*)componentId completion:(RNNTransitionCompletionBlock)completion rejection:(RNNTransitionRejectionBlock)reject;
+- (void)dismissOverlay:(NSString*)componentId completion:(RNNTransitionCompletionBlock)completion rejection:(RNNTransitionRejectionBlock)reject;
 
 @end

lib/ios/RNNCommandsHandler.m

 - (void)setRoot:(NSDictionary*)layout completion:(RNNTransitionCompletionBlock)completion {
 	[self assertReady];
 	
-	[_modalManager dismissAllModals];
+	[_modalManager dismissAllModalsAnimated:NO];
 	
 	UIViewController *vc = [_controllerFactory createLayoutAndSaveToStore:layout[@"root"]];
 	
 	} rejection:rejection];
 }
 
-- (void)pop:(NSString*)componentId options:(NSDictionary*)optionsDict completion:(RNNTransitionCompletionBlock)completion rejection:(RCTPromiseRejectBlock)rejection {
+- (void)pop:(NSString*)componentId mergeOptions:(NSDictionary*)options completion:(RNNTransitionCompletionBlock)completion rejection:(RCTPromiseRejectBlock)rejection {
 	[self assertReady];
 	
 	RNNRootViewController *vc = (RNNRootViewController*)[_store findComponentForId:componentId];
-	[vc.options mergeWith:optionsDict];
+	[vc.options mergeWith:options];
 	
 	UINavigationController *nvc = vc.navigationController;
 	
 	}];
 }
 
-- (void)popTo:(NSString*)componentId completion:(RNNTransitionCompletionBlock)completion rejection:(RCTPromiseRejectBlock)rejection {
+- (void)popTo:(NSString*)componentId mergeOptions:(NSDictionary *)options completion:(RNNTransitionCompletionBlock)completion rejection:(RCTPromiseRejectBlock)rejection {
 	[self assertReady];
 	RNNRootViewController *vc = (RNNRootViewController*)[_store findComponentForId:componentId];
+	[vc.options mergeWith:options];
 	
 	[_stackManager popTo:vc animated:vc.options.animations.pop.enable completion:^(NSArray *poppedViewControllers) {
 		[_eventEmitter sendOnNavigationCommandCompletion:popTo params:@{@"componentId": componentId}];
 	} rejection:rejection];
 }
 
--(void) popToRoot:(NSString*)componentId completion:(RNNTransitionCompletionBlock)completion rejection:(RCTPromiseRejectBlock)rejection {
+- (void)popToRoot:(NSString*)componentId mergeOptions:(NSDictionary *)options completion:(RNNTransitionCompletionBlock)completion rejection:(RCTPromiseRejectBlock)rejection {
 	[self assertReady];
-	RNNRootViewController *newVc = (RNNRootViewController*)[_store findComponentForId:componentId];
+	RNNRootViewController *vc = (RNNRootViewController*)[_store findComponentForId:componentId];
+	[vc.options mergeWith:options];
 	
 	[CATransaction begin];
 	[CATransaction setCompletionBlock:^{
 		completion();
 	}];
 	
-	[_stackManager popToRoot:newVc animated:newVc.options.animations.pop.enable completion:^(NSArray *poppedViewControllers) {
+	[_stackManager popToRoot:vc animated:vc.options.animations.pop.enable completion:^(NSArray *poppedViewControllers) {
 		[self removePopedViewControllers:poppedViewControllers];
 	} rejection:^(NSString *code, NSString *message, NSError *error) {
 		
 	}];
 }
 
-- (void)dismissModal:(NSString*)componentId completion:(RNNTransitionCompletionBlock)completion {
+- (void)dismissModal:(NSString*)componentId mergeOptions:(NSDictionary *)options completion:(RNNTransitionCompletionBlock)completion {
 	[self assertReady];
 	
 	[CATransaction begin];
 		[_eventEmitter sendOnNavigationCommandCompletion:dismissModal params:@{@"componentId": componentId}];
 	}];
 	UIViewController<RNNRootViewProtocol> *modalToDismiss = (UIViewController<RNNRootViewProtocol>*)[_store findComponentForId:componentId];
+	[modalToDismiss.getLeafViewController.options mergeWith:options];
+	
 	[self removePopedViewControllers:modalToDismiss.navigationController.viewControllers];
 	
 	[_modalManager dismissModal:modalToDismiss completion:completion];
 	[CATransaction commit];
 }
 
-- (void)dismissAllModalsWithCompletion:(RNNTransitionCompletionBlock)completion {
+- (void)dismissAllModals:(NSDictionary *)mergeOptions completion:(RNNTransitionCompletionBlock)completion {
 	[self assertReady];
 	
 	[CATransaction begin];
 		[_eventEmitter sendOnNavigationCommandCompletion:dismissAllModals params:@{}];
 		completion();
 	}];
-	
-	[_modalManager dismissAllModals];
+	RNNNavigationOptions* options = [[RNNNavigationOptions alloc] initWithDict:mergeOptions];
+	[_modalManager dismissAllModalsAnimated:options.animations.dismissModal.enable];
 	
 	[CATransaction commit];
 }

lib/ios/RNNModalManager.h

 
 - (void)showModal:(UIViewController*)viewController animated:(BOOL)animated completion:(RNNTransitionWithComponentIdCompletionBlock)completion;
 - (void)dismissModal:(UIViewController *)viewController completion:(RNNTransitionCompletionBlock)completion;
-- (void)dismissAllModals;
+- (void)dismissAllModalsAnimated:(BOOL)animated;
 
 @end

lib/ios/RNNModalManager.m

 	}
 }
 
--(void)dismissAllModals {
+-(void)dismissAllModalsAnimated:(BOOL)animated {
 	UIViewController *root = UIApplication.sharedApplication.delegate.window.rootViewController;
-	[root dismissViewControllerAnimated:YES completion:nil];
+	[root dismissViewControllerAnimated:animated completion:nil];
 	[_delegate dismissedMultipleModals:_presentedModals];
 	[_pendingModalIdsToDismiss removeAllObjects];
 	[_presentedModals removeAllObjects];

lib/ios/ReactNativeNavigationTests/RNNCommandsHandlerTest.m

 	[self.store setReadyToReceiveCommands:true];
 	XCTestExpectation *expectation = [self expectationWithDescription:@"Testing Async Method"];
 
-	[self.uut pop:@"vc3" options:nil completion:^{
+	[self.uut pop:@"vc3" mergeOptions:nil completion:^{
 		XCTAssertNil([self.store findComponentForId:@"vc3"]);
 		XCTAssertNotNil([self.store findComponentForId:@"vc2"]);
 		XCTAssertNotNil([self.store findComponentForId:@"vc1"]);
 	[self.store setReadyToReceiveCommands:true];
 	XCTestExpectation *expectation = [self expectationWithDescription:@"Testing Async Method"];
 	_nvc.willReturnVCs = @[self.vc2, self.vc3];
-	[self.uut popTo:@"vc1" completion:^{
+	[self.uut popTo:@"vc1" mergeOptions:nil completion:^{
 		XCTAssertNil([self.store findComponentForId:@"vc2"]);
 		XCTAssertNil([self.store findComponentForId:@"vc3"]);
 		XCTAssertNotNil([self.store findComponentForId:@"vc1"]);
 	[self.store setReadyToReceiveCommands:true];
 	_nvc.willReturnVCs = @[self.vc2, self.vc3];
 	XCTestExpectation *expectation = [self expectationWithDescription:@"Testing Async Method"];
-	[self.uut popToRoot:@"vc3" completion:^{
+	[self.uut popToRoot:@"vc3" mergeOptions:nil completion:^{
 		XCTAssertNil([self.store findComponentForId:@"vc2"]);
 		XCTAssertNil([self.store findComponentForId:@"vc3"]);
 		XCTAssertNotNil([self.store findComponentForId:@"vc1"]);

lib/ios/ReactNativeNavigationTests/RNNModalManagerTest.m

 	[_modalManager showModal:_vc3 animated:NO completion:nil];
 	
 	_modalManager.delegate = self;
-	[_modalManager dismissAllModals];
+	[_modalManager dismissAllModalsAnimated:NO];
 	
 	XCTAssertTrue(_modalDismissedCount == 3);
 }
 	XCTAssertTrue(_modalDismissedCount == 1);
 }
 
-- (void)testDismissAllModalsAfterDismissingPreviousModal_InvokeDelegateWithCorrectParameters {
+- (void)testDismissAllModals_AfterDismissingPreviousModal_InvokeDelegateWithCorrectParameters {
 	[_modalManager showModal:_vc1 animated:NO completion:nil];
 	[_modalManager showModal:_vc2 animated:NO completion:nil];
 	[_modalManager showModal:_vc3 animated:NO completion:nil];
 	[_modalManager dismissModal:_vc2 completion:nil];
 	
 	XCTAssertTrue(_modalDismissedCount == 1);
-	[_modalManager dismissAllModals];
+	[_modalManager dismissAllModalsAnimated:NO];
 	XCTAssertTrue(_modalDismissedCount == 2);
 }
 
-- (void)testDismissNilModal_doesntCrash {
+- (void)testDismissModal_DismissNilModalDoesntCrash {
 	_modalManager.delegate = self;
 	[_modalManager dismissModal:nil completion:nil];
 	

lib/src/Navigation.ts

   /**
    * Dismiss a modal by componentId. The dismissed modal can be anywhere in the stack.
    */
-  public dismissModal(componentId: string): Promise<any> {
-    return this.commands.dismissModal(componentId);
+  public dismissModal(componentId: string, mergeOptions?): Promise<any> {
+    return this.commands.dismissModal(componentId, mergeOptions);
   }
 
   /**
    * Dismiss all Modals
    */
-  public dismissAllModals(): Promise<any> {
-    return this.commands.dismissAllModals();
+  public dismissAllModals(mergeOptions?): Promise<any> {
+    return this.commands.dismissAllModals(mergeOptions);
   }
 
   /**
   /**
    * Pop a component from the stack, regardless of it's position.
    */
-  public pop(componentId: string, params?): Promise<any> {
-    return this.commands.pop(componentId, params);
+  public pop(componentId: string, mergeOptions?): Promise<any> {
+    return this.commands.pop(componentId, mergeOptions);
   }
 
   /**
    * Pop the stack to a given component
    */
-  public popTo(componentId: string): Promise<any> {
-    return this.commands.popTo(componentId);
+  public popTo(componentId: string, mergeOptions?): Promise<any> {
+    return this.commands.popTo(componentId, mergeOptions);
   }
 
   /**
    * Pop the component's stack to root.
    */
-  public popToRoot(componentId: string): Promise<any> {
-    return this.commands.popToRoot(componentId);
+  public popToRoot(componentId: string, mergeOptions?): Promise<any> {
+    return this.commands.popToRoot(componentId, mergeOptions);
   }
 
   /**

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.test.ts

 
   describe('dismissModal', () => {
     it('sends command to native', () => {
-      uut.dismissModal('myUniqueId');
+      uut.dismissModal('myUniqueId', {});
       expect(mockCommandsSender.dismissModal).toHaveBeenCalledTimes(1);
-      expect(mockCommandsSender.dismissModal).toHaveBeenCalledWith('dismissModal+UNIQUE_ID', 'myUniqueId');
+      expect(mockCommandsSender.dismissModal).toHaveBeenCalledWith('dismissModal+UNIQUE_ID', 'myUniqueId', {});
     });
 
     it('returns a promise with the id', async () => {
 
   describe('dismissAllModals', () => {
     it('sends command to native', () => {
-      uut.dismissAllModals();
+      uut.dismissAllModals({});
       expect(mockCommandsSender.dismissAllModals).toHaveBeenCalledTimes(1);
-      expect(mockCommandsSender.dismissAllModals).toHaveBeenCalledWith('dismissAllModals+UNIQUE_ID');
+      expect(mockCommandsSender.dismissAllModals).toHaveBeenCalledWith('dismissAllModals+UNIQUE_ID', {});
     });
 
     it('returns a promise with the id', async () => {
 
   describe('popTo', () => {
     it('pops all components until the passed Id is top', () => {
-      uut.popTo('theComponentId');
+      uut.popTo('theComponentId', {});
       expect(mockCommandsSender.popTo).toHaveBeenCalledTimes(1);
-      expect(mockCommandsSender.popTo).toHaveBeenCalledWith('popTo+UNIQUE_ID', 'theComponentId');
+      expect(mockCommandsSender.popTo).toHaveBeenCalledWith('popTo+UNIQUE_ID', 'theComponentId', {});
     });
 
     it('returns a promise that resolves to targetId', async () => {
 
   describe('popToRoot', () => {
     it('pops all components to root', () => {
-      uut.popToRoot('theComponentId');
+      uut.popToRoot('theComponentId', {});
       expect(mockCommandsSender.popToRoot).toHaveBeenCalledTimes(1);
-      expect(mockCommandsSender.popToRoot).toHaveBeenCalledWith('popToRoot+UNIQUE_ID', 'theComponentId');
+      expect(mockCommandsSender.popToRoot).toHaveBeenCalledWith('popToRoot+UNIQUE_ID', 'theComponentId', {});
     });
 
     it('returns a promise that resolves to targetId', async () => {
         setDefaultOptions: [{}],
         mergeOptions: ['id', {}],
         showModal: [{}],
-        dismissModal: ['id'],
-        dismissAllModals: [],
+        dismissModal: ['id', {}],
+        dismissAllModals: [{}],
         push: ['id', {}],
         pop: ['id', {}],
-        popTo: ['id'],
-        popToRoot: ['id'],
+        popTo: ['id', {}],
+        popToRoot: ['id', {}],
         setStackRoot: ['id', {}],
         showOverlay: [{}],
         dismissOverlay: ['id'],
         setDefaultOptions: { options: {} },
         mergeOptions: { componentId: 'id', options: {} },
         showModal: { commandId: 'showModal+UNIQUE_ID', layout: 'parsed' },
-        dismissModal: { commandId: 'dismissModal+UNIQUE_ID', componentId: 'id' },
-        dismissAllModals: { commandId: 'dismissAllModals+UNIQUE_ID' },
+        dismissModal: { commandId: 'dismissModal+UNIQUE_ID', componentId: 'id', mergeOptions: {} },
+        dismissAllModals: { commandId: 'dismissAllModals+UNIQUE_ID', mergeOptions: {} },
         push: { commandId: 'push+UNIQUE_ID', componentId: 'id', layout: 'parsed' },
-        pop: { commandId: 'pop+UNIQUE_ID', componentId: 'id', options: {} },
-        popTo: { commandId: 'popTo+UNIQUE_ID', componentId: 'id' },
-        popToRoot: { commandId: 'popToRoot+UNIQUE_ID', componentId: 'id' },
+        pop: { commandId: 'pop+UNIQUE_ID', componentId: 'id', mergeOptions: {} },
+        popTo: { commandId: 'popTo+UNIQUE_ID', componentId: 'id', mergeOptions: {} },
+        popToRoot: { commandId: 'popToRoot+UNIQUE_ID', componentId: 'id', mergeOptions: {} },
         setStackRoot: { commandId: 'setStackRoot+UNIQUE_ID', componentId: 'id', layout: 'parsed' },
         showOverlay: { commandId: 'showOverlay+UNIQUE_ID', layout: 'parsed' },
         dismissOverlay: { commandId: 'dismissOverlay+UNIQUE_ID', componentId: 'id' },

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);
-    this.commandsObserver.notify('dismissAllModals', { commandId });
+    const result = this.nativeCommandsSender.dismissAllModals(commandId, mergeOptions);
+    this.commandsObserver.notify('dismissAllModals', { commandId, mergeOptions });
     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;
   }