Set stack root refactor (#4460)

This PR adds support for setting stack root with multiple children, which is to be expected as stack can be initialised with multiple children.
Closes #4441

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

 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.ReactContextBaseJavaModule;
 import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReadableArray;
 import com.facebook.react.bridge.ReadableMap;
 import com.facebook.react.bridge.WritableMap;
 import com.reactnativenavigation.NavigationActivity;
 import com.reactnativenavigation.viewcontrollers.externalcomponent.ExternalComponentCreator;
 import com.reactnativenavigation.viewcontrollers.navigator.Navigator;
 
+import java.util.ArrayList;
 import java.util.Map;
 
 public class NavigationModule extends ReactContextBaseJavaModule {
 	}
 
     @ReactMethod
-    public void setStackRoot(String commandId, String onComponentId, ReadableMap rawLayoutTree, Promise promise) {
-        final LayoutNode layoutTree = LayoutNodeParser.parse(JSONParser.parse(rawLayoutTree));
+    public void setStackRoot(String commandId, String onComponentId, ReadableArray children, Promise promise) {
         handle(() -> {
-            final ViewController viewController = newLayoutFactory().create(layoutTree);
-            navigator().setStackRoot(onComponentId, viewController, new NativeCommandListener(commandId, promise, eventEmitter, now));
+            ArrayList<ViewController> _children = new ArrayList();
+            for (int i = 0; i < children.size(); i++) {
+                final LayoutNode layoutTree = LayoutNodeParser.parse(JSONParser.parse(children.getMap(i)));
+                _children.add(newLayoutFactory().create(layoutTree));
+            }
+            navigator().setStackRoot(onComponentId, _children, new NativeCommandListener(commandId, promise, eventEmitter, now));
         });
     }
 

lib/android/app/src/main/java/com/reactnativenavigation/utils/CollectionUtils.java

         return null;
     }
 
+    public static <T> T last(@Nullable List<T> items) {
+        return CollectionUtils.isNullOrEmpty(items) ? null : items.get(items.size() - 1);
+    }
+
+    public static <T> T removeLast(@NonNull List<T> items) {
+        return items.remove(items.size() - 1);
+    }
+
     private static @NonNull <T> Collection<T> get(@Nullable Collection<T> t) {
         return t == null ? Collections.EMPTY_LIST : t;
     }

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

 
 import com.reactnativenavigation.utils.StringUtils;
 
-import java.util.ArrayDeque;
+import java.util.ArrayList;
 import java.util.Collection;
 import java.util.HashMap;
 import java.util.Iterator;
+import java.util.Map;
+
+import static com.reactnativenavigation.utils.CollectionUtils.last;
+import static com.reactnativenavigation.utils.CollectionUtils.removeLast;
 
 public class IdStack<E> implements Iterable<String> {
 
-	private final ArrayDeque<String> deque = new ArrayDeque<>();
-	private final HashMap<String, E> map = new HashMap<>();
+	private final ArrayList<String> deque = new ArrayList();
+	private final Map<String, E> map = new HashMap<>();
 
 	public void push(String id, E item) {
-		deque.push(id);
+		deque.add(id);
 		map.put(id, item);
 	}
 
+    public void set(String id, E item, int index) {
+        deque.add(index, id);
+        map.put(id, item);
+    }
+
 	public E peek() {
 		if (isEmpty()) {
 			return null;
 		}
-		return map.get(deque.peek());
+		return map.get(last(deque));
 	}
 
 	public E pop() {
 		if (isEmpty()) {
 			return null;
 		}
-		return map.remove(deque.pop());
+		return map.remove(removeLast(deque));
 	}
 
 	public boolean isEmpty() {
 	}
 
 	public String peekId() {
-		return deque.peek();
+		return last(deque);
 	}
 
 	public void clear() {
 		return map.get(id);
 	}
 
+	public E get(final int index) {
+        return map.get(deque.get(index));
+    }
+
 	public boolean containsId(final String id) {
 		return deque.contains(id);
 	}
 	public Collection<E> values() {
 		return map.values();
 	}
+
+    public void remove(Iterator<String> iterator, String id) {
+        iterator.remove();
+        map.remove(id);
+    }
 }

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

 import android.widget.FrameLayout;
 
 import com.reactnativenavigation.parse.Options;
-import com.reactnativenavigation.presentation.Presenter;
 import com.reactnativenavigation.presentation.OverlayManager;
+import com.reactnativenavigation.presentation.Presenter;
 import com.reactnativenavigation.react.EventEmitter;
 import com.reactnativenavigation.utils.CommandListener;
 import com.reactnativenavigation.utils.CompatUtils;
 
 import java.util.Collection;
 import java.util.Collections;
+import java.util.List;
 
 public class Navigator extends ParentController {
 
         applyOnStack(id, listener, stack -> stack.push(viewController, listener));
     }
 
-    public void setStackRoot(String id, ViewController viewController, CommandListener listener) {
-        applyOnStack(id, listener, stack -> stack.setRoot(viewController, listener));
+    public void setStackRoot(String id, List<ViewController> children, CommandListener listener) {
+        applyOnStack(id, listener, stack -> stack.setRoot(children, listener));
     }
 
     public void pop(String id, Options mergeOptions, CommandListener listener) {

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

 import com.reactnativenavigation.presentation.Presenter;
 import com.reactnativenavigation.presentation.StackPresenter;
 import com.reactnativenavigation.react.Constants;
+import com.reactnativenavigation.utils.CollectionUtils;
 import com.reactnativenavigation.utils.CommandListener;
 import com.reactnativenavigation.utils.CommandListenerAdapter;
 import com.reactnativenavigation.viewcontrollers.ChildControllersRegistry;
         getView().addView(view, getView().getChildCount() - 1);
     }
 
-    public void setRoot(ViewController child, CommandListener listener) {
-        backButtonHelper.clear(child);
-        push(child, new CommandListenerAdapter() {
-            @Override
-            public void onSuccess(String childId) {
-                removeChildrenBellowTop();
-                listener.onSuccess(childId);
-            }
-        });
+    public void setRoot(List<ViewController> children, CommandListener listener) {
+        if (children.size() == 1) {
+            backButtonHelper.clear(CollectionUtils.last(children));
+            push(CollectionUtils.last(children), new CommandListenerAdapter() {
+                @Override
+                public void onSuccess(String childId) {
+                    removeChildrenBellowTop();
+                    listener.onSuccess(childId);
+                }
+            });
+        } else {
+            push(CollectionUtils.last(children), new CommandListenerAdapter() {
+                @Override
+                public void onSuccess(String childId) {
+                    removeChildrenBellowTop();
+                    for (int i = 0; i < children.size() - 1; i++) {
+                        stack.set(children.get(i).getId(), children.get(i), i);
+                        children.get(i).setParentController(StackController.this);
+                        if (i == 0) {
+                            backButtonHelper.clear(children.get(i));
+                        } else {
+                            backButtonHelper.addToPushedChild(children.get(i));
+                        }
+                    }
+                    listener.onSuccess(childId);
+                }
+            });
+        }
     }
 
     private void removeChildrenBellowTop() {
         while (stack.size() > 1) {
             ViewController controller = stack.get(iterator.next());
             if (!stack.isTop(controller.getId())) {
-                removeAndDestroyController(controller);
+                stack.remove(iterator, controller.getId());
+                controller.destroy();
             }
         }
     }
             return;
         }
 
-        Iterator<String> iterator = stack.iterator();
-        String currentControlId = iterator.next();
-        while (!viewController.getId().equals(currentControlId)) {
-            if (stack.isTop(currentControlId)) {
-                currentControlId = iterator.next();
-                continue;
+
+        String currentControlId;
+        for (int i = stack.size() - 2; i >= 0; i--) {
+            currentControlId = stack.get(i).getId();
+            if (currentControlId.equals(viewController.getId())) {
+                break;
             }
-            removeAndDestroyController(stack.get(currentControlId));
-            currentControlId = iterator.next();
+
+            ViewController controller = stack.get(currentControlId);
+            stack.remove(controller.getId());
+            controller.destroy();
         }
 
         pop(mergeOptions, listener);
         }
 
         Iterator<String> iterator = stack.iterator();
+        iterator.next();
         while (stack.size() > 2) {
             ViewController controller = stack.get(iterator.next());
             if (!stack.isTop(controller.getId())) {
-                removeAndDestroyController(controller);
+                stack.remove(iterator, controller.getId());
+                controller.destroy();
             }
         }
 

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

     }
 
     @Test
-    public void isEmpty() throws Exception {
+    public void isEmpty() {
         assertThat(uut.isEmpty()).isTrue();
         uut.push("123", 123);
         assertThat(uut.isEmpty()).isFalse();
     }
 
     @Test
-    public void size() throws Exception {
+    public void size() {
         assertThat(uut.size()).isEqualTo(0);
         uut.push("123", 123);
         assertThat(uut.size()).isEqualTo(1);
     }
 
     @Test
-    public void peek() throws Exception {
+    public void peek() {
         assertThat(uut.peek()).isNull();
         uut.push("123", 123);
         uut.push("456", 456);
     }
 
     @Test
-    public void pop() throws Exception {
+    public void pop() {
         assertThat(uut.pop()).isNull();
         uut.push("123", 123);
         uut.push("456", 456);
     }
 
     @Test
-    public void peekId() throws Exception {
+    public void peekId() {
         assertThat(uut.peekId()).isNull();
         uut.push("123", 123);
         assertThat(uut.peekId()).isEqualTo("123");
     }
 
     @Test
-    public void clear() throws Exception {
+    public void clear() {
         uut.push("123", 123);
         uut.push("456", 456);
         uut.clear();
     }
 
     @Test
-    public void getById() throws Exception {
+    public void getById() {
         assertThat(uut.get("123")).isNull();
         uut.push("123", 123);
         uut.push("456", 456);
     }
 
     @Test
-    public void containsId() throws Exception {
+    public void containsId() {
         assertThat(uut.containsId("123")).isFalse();
         uut.push("123", 123);
         assertThat(uut.containsId("123")).isTrue();
     }
 
     @Test
-    public void remove() throws Exception {
+    public void remove() {
         assertThat(uut.remove("123")).isNull();
 
         uut.push("123", 123);
     }
 
     @Test
-    public void iterableIds() throws Exception {
+    public void iterableIds() {
         assertThat(uut).isInstanceOf(Iterable.class);
         assertThat(uut).isEmpty();
         uut.push("123", 123);
         uut.push("456", 456);
-        assertThat(uut).containsExactly("456", "123");
+        assertThat(uut).containsExactly("123", "456");
     }
 
     @Test
-    public void isTop() throws Exception {
+    public void isTop() {
         assertThat(uut.isTop("123")).isFalse();
         uut.push("123", 123);
         assertThat(uut.isTop("123")).isTrue();
     }
 
     @Test
-    public void values() throws Exception {
+    public void values() {
         assertThat(uut.values()).isNotNull().isEmpty();
         uut.push("123", 123);
         uut.push("456", 456);

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

 import org.robolectric.annotation.Config;
 
 import java.util.Arrays;
+import java.util.Collections;
 import java.util.List;
 
 import static org.assertj.core.api.Java6Assertions.assertThat;
 
         stack.push(child1, new CommandListenerAdapter());
         stack.push(child2, new CommandListenerAdapter());
-        stack.setRoot(child3, new CommandListenerAdapter());
+        stack.setRoot(Collections.singletonList(child3), new CommandListenerAdapter());
 
         assertThat(stack.getChildControllers()).containsOnly(child3);
     }

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

     public void childrenAreAssignedParent() {
         StackController uut = createStack(Arrays.asList(child1, child2));
         for (ViewController child : uut.getChildControllers()) {
-            assertThat(child.getParentController().equals(uut));
+            assertThat(child.getParentController().equals(uut)).isTrue();
         }
     }
 
         assertThat(uut.isEmpty()).isTrue();
         uut.push(child1, new CommandListenerAdapter());
         uut.push(child2, new CommandListenerAdapter());
-        uut.setRoot(child3, new CommandListenerAdapter() {
+        uut.setRoot(Collections.singletonList(child3), new CommandListenerAdapter() {
             @Override
             public void onSuccess(String childId) {
                 assertContainsOnlyId(child3.getId());
     }
 
     @Test
-    public void setRoot() {
+    public void setRoot_singleChild() {
         activity.setContentView(uut.getView());
         disablePushAnimation(child1, child2, child3);
 
         uut.push(child1, new CommandListenerAdapter());
         uut.push(child2, new CommandListenerAdapter());
         assertThat(uut.getTopBar().getTitleBar().getNavigationIcon()).isNotNull();
-        uut.setRoot(child3, new CommandListenerAdapter() {
+        uut.setRoot(Collections.singletonList(child3), new CommandListenerAdapter() {
             @Override
             public void onSuccess(String childId) {
                 assertContainsOnlyId(child3.getId());
         });
     }
 
+    @Test
+    public void setRoot_multipleChildren() {
+        activity.setContentView(uut.getView());
+        disablePushAnimation(child1, child2, child3, child4);
+        disablePopAnimation(child4);
+
+        assertThat(uut.isEmpty()).isTrue();
+        uut.push(child1, new CommandListenerAdapter());
+        uut.push(child2, new CommandListenerAdapter());
+        assertThat(uut.getTopBar().getTitleBar().getNavigationIcon()).isNotNull();
+        uut.setRoot(Arrays.asList(child3, child4), new CommandListenerAdapter() {
+            @Override
+            public void onSuccess(String childId) {
+                assertContainsOnlyId(child3.getId(), child4.getId());
+                assertThat(uut.getTopBar().getTitleBar().getNavigationIcon()).isNotNull();
+                assertThat(child4.isViewShown()).isTrue();
+                assertThat(child3.isViewShown()).isFalse();
+
+                assertThat(uut.getCurrentChild()).isEqualTo(child4);
+                uut.pop(Options.EMPTY, new CommandListenerAdapter());
+                assertThat(uut.getTopBar().getTitleBar().getNavigationIcon()).isNull();
+                assertThat(uut.getCurrentChild()).isEqualTo(child3);
+            }
+        });
+    }
+
     @Test
     public synchronized void pop() {
         disablePushAnimation(child1, child2);

lib/ios/RNNBridgeModule.m

 	} rejection:reject];
 }
 
-RCT_EXPORT_METHOD(setStackRoot:(NSString*)commandId componentId:(NSString*)componentId layout:(NSDictionary*)layout resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject) {
-	[_commandsHandler setStackRoot:componentId layout:layout completion:^{
+RCT_EXPORT_METHOD(setStackRoot:(NSString*)commandId componentId:(NSString*)componentId children:(NSArray*)children resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject) {
+	[_commandsHandler setStackRoot:componentId children:children completion:^{
 		resolve(componentId);
 	} rejection:reject];
 }

lib/ios/RNNCommandsHandler.h

 
 - (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 children:(NSArray*)children completion:(RNNTransitionCompletionBlock)completion rejection:(RCTPromiseRejectBlock)rejection;
 
 - (void)showModal:(NSDictionary*)layout completion:(RNNTransitionWithComponentIdCompletionBlock)completion;
 

lib/ios/RNNCommandsHandler.m

 	}
 }
 
-- (void)setStackRoot:(NSString*)componentId layout:(NSDictionary*)layout completion:(RNNTransitionCompletionBlock)completion rejection:(RCTPromiseRejectBlock)rejection {
+- (void)setStackRoot:(NSString*)componentId children:(NSArray*)children completion:(RNNTransitionCompletionBlock)completion rejection:(RCTPromiseRejectBlock)rejection {
 	[self assertReady];
 	
-	UIViewController<RNNParentProtocol> *newVC = [_controllerFactory createLayout:layout saveToStore:_store];
-	RNNNavigationOptions* options = [newVC getCurrentChild].resolveOptions;
+ 	NSArray<RNNLayoutProtocol> *childViewControllers = [_controllerFactory createChildrenLayout:children saveToStore:_store];
+	RNNNavigationOptions* options = [childViewControllers.lastObject getCurrentChild].resolveOptions;
 	UIViewController *fromVC = [_store findComponentForId:componentId];
 	__weak typeof(RNNEventEmitter*) weakEventEmitter = _eventEmitter;
-	[_stackManager setStackRoot:newVC fromViewController:fromVC animated:options.animations.setStackRoot.enable completion:^{
+	[_stackManager setStackChildren:childViewControllers fromViewController:fromVC animated:options.animations.setStackRoot.enable completion:^{
 		[weakEventEmitter sendOnNavigationCommandCompletion:setStackRoot params:@{@"componentId": componentId}];
 		completion();
 	} rejection:rejection];

lib/ios/RNNControllerFactory.h

 
 - (UIViewController<RNNParentProtocol> *)createLayout:(NSDictionary*)layout saveToStore:(RNNStore *)store;
 
+- (NSArray<RNNLayoutProtocol> *)createChildrenLayout:(NSArray*)children saveToStore:(RNNStore *)store;
+
 @property (nonatomic, strong) RNNEventEmitter *eventEmitter;
 
 @property (nonatomic, strong) RNNNavigationOptions* defaultOptions;

lib/ios/RNNControllerFactory.m

 	return layoutViewController;
 }
 
+- (NSArray<RNNLayoutProtocol> *)createChildrenLayout:(NSArray*)children saveToStore:(RNNStore *)store {
+	_store = store;
+	NSMutableArray<RNNLayoutProtocol>* childViewControllers = [NSMutableArray<RNNLayoutProtocol> new];
+	for (NSDictionary* layout in children) {
+		[childViewControllers addObject:[self fromTree:layout]];
+	}
+	_store = nil;
+	return childViewControllers;
+}
+
 # pragma mark private
 
 - (UIViewController<RNNParentProtocol> *)fromTree:(NSDictionary*)json {

lib/ios/RNNNavigationStackManager.h

 
 - (void)popToRoot:(UIViewController*)viewController animated:(BOOL)animated completion:(RNNPopCompletionBlock)completion rejection:(RNNTransitionRejectionBlock)rejection;
 
-- (void)setStackRoot:(UIViewController *)newRoot fromViewController:(UIViewController *)fromViewController animated:(BOOL)animated completion:(RNNTransitionCompletionBlock)completion rejection:(RNNTransitionRejectionBlock)rejection;
+- (void)setStackChildren:(NSArray<UIViewController *> *)children fromViewController:(UIViewController *)fromViewController animated:(BOOL)animated completion:(RNNTransitionCompletionBlock)completion rejection:(RNNTransitionRejectionBlock)rejection;
 
 @end

lib/ios/RNNNavigationStackManager.m

 	}];
 }
 
-- (void)setStackRoot:(UIViewController *)newRoot fromViewController:(UIViewController *)fromViewController animated:(BOOL)animated completion:(RNNTransitionCompletionBlock)completion rejection:(RNNTransitionRejectionBlock)rejection {
+- (void)setStackChildren:(NSArray<UIViewController *> *)children fromViewController:(UIViewController *)fromViewController animated:(BOOL)animated completion:(RNNTransitionCompletionBlock)completion rejection:(RNNTransitionRejectionBlock)rejection {
 	UINavigationController* nvc = fromViewController.navigationController;
 	
 	[self performAnimationBlock:^{
-		[nvc setViewControllers:@[newRoot] animated:animated];
+		[nvc setViewControllers:children animated:animated];
 	} completion:completion];
 }
 

lib/ios/ReactNativeNavigationTests/RNNCommandsHandlerTest.m

 	[self.store verify];
 }
 
+- (void)testSetStackRoot_resetStackWithSingleComponent {
+	OCMStub([self.controllerFactory createChildrenLayout:[OCMArg any] saveToStore:self.store]).andReturn(@[self.vc2]);
+	[self.store setReadyToReceiveCommands:true];
+	[self.uut setStackRoot:@"vc1" children:nil completion:^{
+		
+	} rejection:^(NSString *code, NSString *message, NSError *error) {
+		
+	}];
+	XCTAssertEqual(_nvc.viewControllers.firstObject, self.vc2);
+	XCTAssertEqual(_nvc.viewControllers.count, 1);
+}
+
+- (void)testSetStackRoot_setMultipleChildren {
+	NSArray* newViewControllers = @[_vc1, _vc3];
+	OCMStub([self.controllerFactory createChildrenLayout:[OCMArg any] saveToStore:self.store]).andReturn(newViewControllers);
+	[self.store setReadyToReceiveCommands:true];
+	[self.uut setStackRoot:@"vc1" children:nil completion:^{
+		
+	} rejection:^(NSString *code, NSString *message, NSError *error) {
+		
+	}];
+	XCTAssertTrue([_nvc.viewControllers isEqual:newViewControllers]);
+}
+
 @end

lib/ios/ReactNativeNavigationTests/RNNNavigationStackManagerTest.m

 
 - (void)testStackRoot_shouldUpdateNavigationControllerChildrenViewControllers {
 	XCTestExpectation *expectation = [self expectationWithDescription:@"Testing Async Method"];
-	[_stackManager setStackRoot:self.vc2 fromViewController:self.vc1 animated:NO completion:^{
+	[_stackManager setStackChildren:@[self.vc2] fromViewController:self.vc1 animated:NO completion:^{
 		XCTAssertTrue(self.nvc.childViewControllers.count == 1);
 		XCTAssertTrue([self.nvc.topViewController isEqual:self.vc2]);
 		[expectation fulfill];

lib/src/Navigation.ts

+import { isArray } from 'lodash';
 import { NativeCommandsSender } from './adapters/NativeCommandsSender';
 import { NativeEventsReceiver } from './adapters/NativeEventsReceiver';
 import { UniqueIdProvider } from './adapters/UniqueIdProvider';
   /**
    * Sets new root component to stack.
    */
-  public setStackRoot(componentId: string, layout: Layout): Promise<any> {
-    return this.commands.setStackRoot(componentId, layout);
+  public setStackRoot(componentId: string, layout: Layout | Layout[]): Promise<any> {
+    const children: Layout[] = isArray(layout) ? layout : [layout];
+    return this.commands.setStackRoot(componentId, children);
   }
 
   /**

lib/src/commands/Commands.test.ts

 
   describe('setStackRoot', () => {
     it('parses into correct layout node and sends to native', () => {
-      uut.setStackRoot('theComponentId', { component: { name: 'com.example.MyScreen' } });
-      verify(mockedNativeCommandsSender.setStackRoot('setStackRoot+UNIQUE_ID', 'theComponentId', deepEqual({
-        type: 'Component',
-        id: 'Component+UNIQUE_ID',
-        data: {
-          name: 'com.example.MyScreen',
-          options: {},
-          passProps: undefined
-        },
-        children: []
-      }))).called();
+      uut.setStackRoot('theComponentId', [{ component: { name: 'com.example.MyScreen' } }]);
+      verify(mockedNativeCommandsSender.setStackRoot('setStackRoot+UNIQUE_ID', 'theComponentId', deepEqual([
+        {
+          type: 'Component',
+          id: 'Component+UNIQUE_ID',
+          data: {
+            name: 'com.example.MyScreen',
+            options: {},
+            passProps: undefined
+          },
+          children: []
+        }
+      ]))).called();
     });
   });
 
         pop: ['id', {}],
         popTo: ['id', {}],
         popToRoot: ['id', {}],
-        setStackRoot: ['id', {}],
+        setStackRoot: ['id', [{}]],
         showOverlay: [{}],
         dismissOverlay: ['id'],
         getLaunchArgs: ['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' },
+        setStackRoot: { commandId: 'setStackRoot+UNIQUE_ID', componentId: 'id', layout: ['parsed'] },
         showOverlay: { commandId: 'showOverlay+UNIQUE_ID', layout: 'parsed' },
         dismissOverlay: { commandId: 'dismissOverlay+UNIQUE_ID', componentId: 'id' },
         getLaunchArgs: { commandId: 'getLaunchArgs+UNIQUE_ID' },

lib/src/commands/Commands.ts

     return result;
   }
 
-  public setStackRoot(componentId: string, simpleApi: Layout) {
-    const input = _.cloneDeep(simpleApi);
-
-    const layout = this.layoutTreeParser.parse(input);
-    this.layoutTreeCrawler.crawl(layout);
-
+  public setStackRoot(componentId: string, children: Layout[]) {
+    const input = _.map(_.cloneDeep(children), (simpleApi) => {
+      const layout = this.layoutTreeParser.parse(simpleApi);
+      this.layoutTreeCrawler.crawl(layout);
+      return layout;
+    });
     const commandId = this.uniqueIdProvider.generate('setStackRoot');
-    const result = this.nativeCommandsSender.setStackRoot(commandId, componentId, layout);
-    this.commandsObserver.notify('setStackRoot', { commandId, componentId, layout });
+    const result = this.nativeCommandsSender.setStackRoot(commandId, componentId, input);
+    this.commandsObserver.notify('setStackRoot', { commandId, componentId, layout: input });
     return result;
   }
 

playground/src/screens/PushedScreen.js

   }
 
   async onClickSetStackRoot() {
-    await Navigation.setStackRoot(this.props.componentId, {
-      component: {
-        name: 'navigation.playground.PushedScreen',
-        passProps: {
-          stackPosition: this.getStackPosition() + 1,
-          previousScreenIds: _.concat([], this.props.previousScreenIds || [], this.props.componentId)
-        },
-        options: {
-          animations: {
-            setStackRoot: {
-              enabled: false
+    await Navigation.setStackRoot(this.props.componentId, [
+      {
+        component: {
+          name: 'navigation.playground.PushedScreen',
+          passProps: {
+            stackPosition: this.getStackPosition() + 1,
+            previousScreenIds: _.concat([], this.props.previousScreenIds || [], this.props.componentId)
+          },
+          options: {
+            animations: {
+              setStackRoot: {
+                enabled: false
+              }
+            },
+            topBar: {
+              title: {
+                text: `Pushed ${this.getStackPosition() + 1} a`
+              }
             }
+          }
+        }
+      },
+      {
+        component: {
+          name: 'navigation.playground.PushedScreen',
+          passProps: {
+            stackPosition: this.getStackPosition() + 1,
+            previousScreenIds: _.concat([], this.props.previousScreenIds || [], this.props.componentId)
           },
-          topBar: {
-            title: {
-              text: `Pushed ${this.getStackPosition() + 1}`
+          options: {
+            animations: {
+              setStackRoot: {
+                enabled: false
+              }
+            },
+            topBar: {
+              title: {
+                text: `Pushed ${this.getStackPosition() + 1} b`
+              }
             }
           }
         }
       }
-    });
+    ]);
   }
 
   onClickPushWaitForRender = async () => {