react-native-navigation 7.45.0 → 7.47.0

package/lib/dist/Mock/Components/BottomTabs.d.ts

@@ -1,12 +1,14 @@
 import React from 'react';
 import { ComponentProps } from '../ComponentProps';
 export declare const BottomTabs: {
-    new (props: ComponentProps): {
-        render(): React.JSX.Element[];
-        context: unknown;
+    new (props: Readonly<ComponentProps>): {
+        render(): JSX.Element[];
+        context: any;
         setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<ComponentProps>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
         forceUpdate(callback?: (() => void) | undefined): void;
-        readonly props: Readonly<ComponentProps>;
+        readonly props: Readonly<ComponentProps> & Readonly<{
+            children?: React.ReactNode;
+        }>;
         state: Readonly<{}>;
         refs: {
             [key: string]: React.ReactInstance;
@@ -24,12 +26,14 @@ export declare const BottomTabs: {
         componentWillUpdate?(nextProps: Readonly<ComponentProps>, nextState: Readonly<{}>, nextContext: any): void;
         UNSAFE_componentWillUpdate?(nextProps: Readonly<ComponentProps>, nextState: Readonly<{}>, nextContext: any): void;
     };
-    new (props: ComponentProps, context: any): {
-        render(): React.JSX.Element[];
-        context: unknown;
+    new (props: ComponentProps, context?: any): {
+        render(): JSX.Element[];
+        context: any;
         setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<ComponentProps>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
         forceUpdate(callback?: (() => void) | undefined): void;
-        readonly props: Readonly<ComponentProps>;
+        readonly props: Readonly<ComponentProps> & Readonly<{
+            children?: React.ReactNode;
+        }>;
         state: Readonly<{}>;
         refs: {
             [key: string]: React.ReactInstance;
@@ -47,5 +51,5 @@ export declare const BottomTabs: {
         componentWillUpdate?(nextProps: Readonly<ComponentProps>, nextState: Readonly<{}>, nextContext: any): void;
         UNSAFE_componentWillUpdate?(nextProps: Readonly<ComponentProps>, nextState: Readonly<{}>, nextContext: any): void;
     };
-    contextType?: React.Context<any> | undefined;
+    contextType?: React.Context<any>;
 };

package/lib/dist/Mock/Components/ComponentScreen.d.ts

@@ -4,12 +4,14 @@ export declare const ComponentScreen: {
     new (props: ComponentProps): {
         componentDidMount(): void;
         isVisible(): boolean;
-        renderTabBar(): React.JSX.Element | null;
-        render(): React.JSX.Element;
-        context: unknown;
+        renderTabBar(): JSX.Element | null;
+        render(): JSX.Element;
+        context: any;
         setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<ComponentProps>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
         forceUpdate(callback?: (() => void) | undefined): void;
-        readonly props: Readonly<ComponentProps>;
+        readonly props: Readonly<ComponentProps> & Readonly<{
+            children?: React.ReactNode;
+        }>;
         state: Readonly<{}>;
         refs: {
             [key: string]: React.ReactInstance;
@@ -26,5 +28,5 @@ export declare const ComponentScreen: {
         componentWillUpdate?(nextProps: Readonly<ComponentProps>, nextState: Readonly<{}>, nextContext: any): void;
         UNSAFE_componentWillUpdate?(nextProps: Readonly<ComponentProps>, nextState: Readonly<{}>, nextContext: any): void;
     };
-    contextType?: React.Context<any> | undefined;
+    contextType?: React.Context<any>;
 };

package/lib/dist/Mock/Components/ComponentScreen.js

@@ -23,7 +23,8 @@ exports.ComponentScreen = (0, connect_1.connect)(class extends react_1.Component
         this.props.layoutNode.componentDidMount();
     }
     isVisible() {
-        return LayoutStore_1.LayoutStore.isVisibleLayout(this.props.layoutNode);
+        const isVisible = LayoutStore_1.LayoutStore.isVisibleLayout(this.props.layoutNode);
+        return isVisible;
     }
     renderTabBar() {
         const bottomTabs = this.props.layoutNode.getBottomTabs();

package/lib/dist/Mock/Components/LayoutComponent.d.ts

@@ -1,13 +1,15 @@
 import React from 'react';
 import { ComponentProps } from '../ComponentProps';
 export declare const LayoutComponent: {
-    new (props: ComponentProps): {
-        render(): React.JSX.Element;
+    new (props: Readonly<ComponentProps>): {
+        render(): JSX.Element;
         componentDidCatch(error: Error, errorInfo: React.ErrorInfo): void;
-        context: unknown;
+        context: any;
         setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<ComponentProps>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
         forceUpdate(callback?: (() => void) | undefined): void;
-        readonly props: Readonly<ComponentProps>;
+        readonly props: Readonly<ComponentProps> & Readonly<{
+            children?: React.ReactNode;
+        }>;
         state: Readonly<{}>;
         refs: {
             [key: string]: React.ReactInstance;
@@ -24,13 +26,15 @@ export declare const LayoutComponent: {
         componentWillUpdate?(nextProps: Readonly<ComponentProps>, nextState: Readonly<{}>, nextContext: any): void;
         UNSAFE_componentWillUpdate?(nextProps: Readonly<ComponentProps>, nextState: Readonly<{}>, nextContext: any): void;
     };
-    new (props: ComponentProps, context: any): {
-        render(): React.JSX.Element;
+    new (props: ComponentProps, context?: any): {
+        render(): JSX.Element;
         componentDidCatch(error: Error, errorInfo: React.ErrorInfo): void;
-        context: unknown;
+        context: any;
         setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<ComponentProps>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
         forceUpdate(callback?: (() => void) | undefined): void;
-        readonly props: Readonly<ComponentProps>;
+        readonly props: Readonly<ComponentProps> & Readonly<{
+            children?: React.ReactNode;
+        }>;
         state: Readonly<{}>;
         refs: {
             [key: string]: React.ReactInstance;
@@ -47,5 +51,5 @@ export declare const LayoutComponent: {
         componentWillUpdate?(nextProps: Readonly<ComponentProps>, nextState: Readonly<{}>, nextContext: any): void;
         UNSAFE_componentWillUpdate?(nextProps: Readonly<ComponentProps>, nextState: Readonly<{}>, nextContext: any): void;
     };
-    contextType?: React.Context<any> | undefined;
+    contextType?: React.Context<any>;
 };

package/lib/dist/Mock/Components/LayoutComponent.js

@@ -7,6 +7,7 @@ const react_native_1 = require("react-native");
 const BottomTabs_1 = require("./BottomTabs");
 const ComponentScreen_1 = require("./ComponentScreen");
 const Stack_1 = require("./Stack");
+const SideMenu_1 = require("./SideMenu");
 const LayoutComponent = class extends react_1.Component {
     render() {
         switch (this.props.layoutNode.type) {
@@ -16,6 +17,14 @@ const LayoutComponent = class extends react_1.Component {
                 return react_1.default.createElement(Stack_1.Stack, { layoutNode: this.props.layoutNode });
             case 'Component':
                 return react_1.default.createElement(ComponentScreen_1.ComponentScreen, { layoutNode: this.props.layoutNode });
+            case 'SideMenuRoot':
+                return react_1.default.createElement(SideMenu_1.SideMenuRoot, { layoutNode: this.props.layoutNode });
+            case 'SideMenuLeft':
+                return react_1.default.createElement(SideMenu_1.SideMenuLeft, { layoutNode: this.props.layoutNode });
+            case 'SideMenuCenter':
+                return react_1.default.createElement(SideMenu_1.SideMenuCenter, { layoutNode: this.props.layoutNode });
+            case 'SideMenuRight':
+                return react_1.default.createElement(SideMenu_1.SideMenuRight, { layoutNode: this.props.layoutNode });
         }
         return react_1.default.createElement(react_native_1.View, null);
     }

package/lib/dist/Mock/Components/Modals.d.ts

@@ -1,12 +1,14 @@
 import React from 'react';
 import { ComponentProps } from '../ComponentProps';
 export declare const Modals: {
-    new (props: ComponentProps): {
-        render(): React.JSX.Element;
-        context: unknown;
+    new (props: Readonly<ComponentProps>): {
+        render(): JSX.Element;
+        context: any;
         setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<ComponentProps>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
         forceUpdate(callback?: (() => void) | undefined): void;
-        readonly props: Readonly<ComponentProps>;
+        readonly props: Readonly<ComponentProps> & Readonly<{
+            children?: React.ReactNode;
+        }>;
         state: Readonly<{}>;
         refs: {
             [key: string]: React.ReactInstance;
@@ -24,12 +26,14 @@ export declare const Modals: {
         componentWillUpdate?(nextProps: Readonly<ComponentProps>, nextState: Readonly<{}>, nextContext: any): void;
         UNSAFE_componentWillUpdate?(nextProps: Readonly<ComponentProps>, nextState: Readonly<{}>, nextContext: any): void;
     };
-    new (props: ComponentProps, context: any): {
-        render(): React.JSX.Element;
-        context: unknown;
+    new (props: ComponentProps, context?: any): {
+        render(): JSX.Element;
+        context: any;
         setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<ComponentProps>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
         forceUpdate(callback?: (() => void) | undefined): void;
-        readonly props: Readonly<ComponentProps>;
+        readonly props: Readonly<ComponentProps> & Readonly<{
+            children?: React.ReactNode;
+        }>;
         state: Readonly<{}>;
         refs: {
             [key: string]: React.ReactInstance;
@@ -47,5 +51,5 @@ export declare const Modals: {
         componentWillUpdate?(nextProps: Readonly<ComponentProps>, nextState: Readonly<{}>, nextContext: any): void;
         UNSAFE_componentWillUpdate?(nextProps: Readonly<ComponentProps>, nextState: Readonly<{}>, nextContext: any): void;
     };
-    contextType?: React.Context<any> | undefined;
+    contextType?: React.Context<any>;
 };

package/lib/dist/Mock/Components/NavigationButton.d.ts

@@ -5,15 +5,17 @@ interface ButtonProps {
     componentId: string;
 }
 export declare const NavigationButton: {
-    new (props: ButtonProps): {
+    new (props: Readonly<ButtonProps>): {
         ref: undefined;
-        render(): React.JSX.Element;
-        renderButtonComponent(): React.JSX.Element;
+        render(): JSX.Element;
+        renderButtonComponent(): JSX.Element;
         invokeOnClick(stateNode: any): void;
-        context: unknown;
+        context: any;
         setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<ButtonProps>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
         forceUpdate(callback?: (() => void) | undefined): void;
-        readonly props: Readonly<ButtonProps>;
+        readonly props: Readonly<ButtonProps> & Readonly<{
+            children?: React.ReactNode;
+        }>;
         state: Readonly<{}>;
         refs: {
             [key: string]: React.ReactInstance;
@@ -31,15 +33,17 @@ export declare const NavigationButton: {
         componentWillUpdate?(nextProps: Readonly<ButtonProps>, nextState: Readonly<{}>, nextContext: any): void;
         UNSAFE_componentWillUpdate?(nextProps: Readonly<ButtonProps>, nextState: Readonly<{}>, nextContext: any): void;
     };
-    new (props: ButtonProps, context: any): {
+    new (props: ButtonProps, context?: any): {
         ref: undefined;
-        render(): React.JSX.Element;
-        renderButtonComponent(): React.JSX.Element;
+        render(): JSX.Element;
+        renderButtonComponent(): JSX.Element;
         invokeOnClick(stateNode: any): void;
-        context: unknown;
+        context: any;
         setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<ButtonProps>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
         forceUpdate(callback?: (() => void) | undefined): void;
-        readonly props: Readonly<ButtonProps>;
+        readonly props: Readonly<ButtonProps> & Readonly<{
+            children?: React.ReactNode;
+        }>;
         state: Readonly<{}>;
         refs: {
             [key: string]: React.ReactInstance;
@@ -57,6 +61,6 @@ export declare const NavigationButton: {
         componentWillUpdate?(nextProps: Readonly<ButtonProps>, nextState: Readonly<{}>, nextContext: any): void;
         UNSAFE_componentWillUpdate?(nextProps: Readonly<ButtonProps>, nextState: Readonly<{}>, nextContext: any): void;
     };
-    contextType?: React.Context<any> | undefined;
+    contextType?: React.Context<any>;
 };
 export {};

package/lib/dist/Mock/Components/Overlays.d.ts

@@ -1,12 +1,14 @@
 import React from 'react';
 import { ComponentProps } from '../ComponentProps';
 export declare const Overlays: {
-    new (props: ComponentProps): {
-        render(): React.JSX.Element;
-        context: unknown;
+    new (props: Readonly<ComponentProps>): {
+        render(): JSX.Element;
+        context: any;
         setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<ComponentProps>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
         forceUpdate(callback?: (() => void) | undefined): void;
-        readonly props: Readonly<ComponentProps>;
+        readonly props: Readonly<ComponentProps> & Readonly<{
+            children?: React.ReactNode;
+        }>;
         state: Readonly<{}>;
         refs: {
             [key: string]: React.ReactInstance;
@@ -24,12 +26,14 @@ export declare const Overlays: {
         componentWillUpdate?(nextProps: Readonly<ComponentProps>, nextState: Readonly<{}>, nextContext: any): void;
         UNSAFE_componentWillUpdate?(nextProps: Readonly<ComponentProps>, nextState: Readonly<{}>, nextContext: any): void;
     };
-    new (props: ComponentProps, context: any): {
-        render(): React.JSX.Element;
-        context: unknown;
+    new (props: ComponentProps, context?: any): {
+        render(): JSX.Element;
+        context: any;
         setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<ComponentProps>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
         forceUpdate(callback?: (() => void) | undefined): void;
-        readonly props: Readonly<ComponentProps>;
+        readonly props: Readonly<ComponentProps> & Readonly<{
+            children?: React.ReactNode;
+        }>;
         state: Readonly<{}>;
         refs: {
             [key: string]: React.ReactInstance;
@@ -47,5 +51,5 @@ export declare const Overlays: {
         componentWillUpdate?(nextProps: Readonly<ComponentProps>, nextState: Readonly<{}>, nextContext: any): void;
         UNSAFE_componentWillUpdate?(nextProps: Readonly<ComponentProps>, nextState: Readonly<{}>, nextContext: any): void;
     };
-    contextType?: React.Context<any> | undefined;
+    contextType?: React.Context<any>;
 };

package/lib/dist/Mock/Components/SideMenu.d.ts

@@ -0,0 +1,62 @@
+import React, { Component } from 'react';
+import { ComponentProps } from '../ComponentProps';
+export declare const SideMenuRoot: {
+    new (props: Readonly<ComponentProps>): {
+        render(): JSX.Element[];
+        context: any;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<ComponentProps>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<ComponentProps> & Readonly<{
+            children?: React.ReactNode;
+        }>;
+        state: Readonly<{}>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<ComponentProps>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<ComponentProps>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<ComponentProps>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<ComponentProps>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<ComponentProps>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<ComponentProps>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<ComponentProps>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    new (props: ComponentProps, context?: any): {
+        render(): JSX.Element[];
+        context: any;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<ComponentProps>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<ComponentProps> & Readonly<{
+            children?: React.ReactNode;
+        }>;
+        state: Readonly<{}>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<ComponentProps>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<ComponentProps>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<ComponentProps>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<ComponentProps>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<ComponentProps>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<ComponentProps>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<ComponentProps>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    contextType?: React.Context<any>;
+};
+declare class SideMenuComponent extends Component<ComponentProps> {
+    render(): JSX.Element;
+}
+export declare const SideMenuLeft: typeof SideMenuComponent;
+export declare const SideMenuCenter: typeof SideMenuComponent;
+export declare const SideMenuRight: typeof SideMenuComponent;
+export {};

package/lib/dist/Mock/Components/SideMenu.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SideMenuRight = exports.SideMenuCenter = exports.SideMenuLeft = exports.SideMenuRoot = void 0;
+const tslib_1 = require("tslib");
+const react_1 = tslib_1.__importStar(require("react"));
+const connect_1 = require("../connect");
+const LayoutComponent_1 = require("./LayoutComponent");
+exports.SideMenuRoot = (0, connect_1.connect)(class extends react_1.Component {
+    render() {
+        const children = this.props.layoutNode.children;
+        return children.map((child) => {
+            return react_1.default.createElement(LayoutComponent_1.LayoutComponent, { key: child.nodeId, layoutNode: child });
+        });
+    }
+});
+class SideMenuComponent extends react_1.Component {
+    render() {
+        const children = this.props.layoutNode.children;
+        const component = children[0];
+        return react_1.default.createElement(LayoutComponent_1.LayoutComponent, { key: component.nodeId, layoutNode: component });
+    }
+}
+exports.SideMenuLeft = (0, connect_1.connect)(SideMenuComponent);
+exports.SideMenuCenter = (0, connect_1.connect)(SideMenuComponent);
+exports.SideMenuRight = (0, connect_1.connect)(SideMenuComponent);

package/lib/dist/Mock/Components/Stack.d.ts

@@ -1,12 +1,14 @@
 import React from 'react';
 import { ComponentProps } from '../ComponentProps';
 export declare const Stack: {
-    new (props: ComponentProps): {
-        render(): React.JSX.Element[];
-        context: unknown;
+    new (props: Readonly<ComponentProps>): {
+        render(): JSX.Element[];
+        context: any;
         setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<ComponentProps>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
         forceUpdate(callback?: (() => void) | undefined): void;
-        readonly props: Readonly<ComponentProps>;
+        readonly props: Readonly<ComponentProps> & Readonly<{
+            children?: React.ReactNode;
+        }>;
         state: Readonly<{}>;
         refs: {
             [key: string]: React.ReactInstance;
@@ -24,12 +26,14 @@ export declare const Stack: {
         componentWillUpdate?(nextProps: Readonly<ComponentProps>, nextState: Readonly<{}>, nextContext: any): void;
         UNSAFE_componentWillUpdate?(nextProps: Readonly<ComponentProps>, nextState: Readonly<{}>, nextContext: any): void;
     };
-    new (props: ComponentProps, context: any): {
-        render(): React.JSX.Element[];
-        context: unknown;
+    new (props: ComponentProps, context?: any): {
+        render(): JSX.Element[];
+        context: any;
         setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<ComponentProps>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
         forceUpdate(callback?: (() => void) | undefined): void;
-        readonly props: Readonly<ComponentProps>;
+        readonly props: Readonly<ComponentProps> & Readonly<{
+            children?: React.ReactNode;
+        }>;
         state: Readonly<{}>;
         refs: {
             [key: string]: React.ReactInstance;
@@ -47,5 +51,5 @@ export declare const Stack: {
         componentWillUpdate?(nextProps: Readonly<ComponentProps>, nextState: Readonly<{}>, nextContext: any): void;
         UNSAFE_componentWillUpdate?(nextProps: Readonly<ComponentProps>, nextState: Readonly<{}>, nextContext: any): void;
     };
-    contextType?: React.Context<any> | undefined;
+    contextType?: React.Context<any>;
 };

package/lib/dist/Mock/Components/TopBar.d.ts

@@ -8,15 +8,17 @@ export interface TopBarProps {
 }
 export declare const TopBar: {
     new (props: TopBarProps): {
-        render(): React.JSX.Element | null;
+        render(): JSX.Element | null;
         shouldRenderBackButton(layoutNode: ParentNode): boolean;
-        renderButtons(buttons?: OptionsTopBarButton[]): React.JSX.Element[];
-        renderBackButton(): React.JSX.Element;
-        renderComponent(id: string, name: string, testID?: string): React.JSX.Element;
-        context: unknown;
+        renderButtons(buttons?: OptionsTopBarButton[]): JSX.Element[];
+        renderBackButton(): JSX.Element;
+        renderComponent(id: string, name: string, testID?: string): JSX.Element;
+        context: any;
         setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<TopBarProps>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
         forceUpdate(callback?: (() => void) | undefined): void;
-        readonly props: Readonly<TopBarProps>;
+        readonly props: Readonly<TopBarProps> & Readonly<{
+            children?: React.ReactNode;
+        }>;
         state: Readonly<{}>;
         refs: {
             [key: string]: React.ReactInstance;
@@ -34,5 +36,5 @@ export declare const TopBar: {
         componentWillUpdate?(nextProps: Readonly<TopBarProps>, nextState: Readonly<{}>, nextContext: any): void;
         UNSAFE_componentWillUpdate?(nextProps: Readonly<TopBarProps>, nextState: Readonly<{}>, nextContext: any): void;
     };
-    contextType?: React.Context<any> | undefined;
+    contextType?: React.Context<any>;
 };

package/lib/dist/Mock/Layouts/BottomTabsNode.d.ts

@@ -3,6 +3,6 @@ import ParentNode from './ParentNode';
 export default class BottomTabsNode extends ParentNode {
     selectedIndex: number;
     constructor(layout: any, parentNode?: ParentNode);
-    mergeOptions(options: Options): void;
+    mergeOptions(_options: Options): void;
     getVisibleLayout(): import("./ComponentNode").default;
 }

package/lib/dist/Mock/Layouts/BottomTabsNode.js

@@ -10,8 +10,9 @@ class BottomTabsNode extends ParentNode_1.default {
         super(layout, 'BottomTabs', parentNode);
         this.selectedIndex = layout.data?.options?.bottomTabs?.currentTabIndex || 0;
     }
-    mergeOptions(options) {
-        super.mergeOptions(options);
+    mergeOptions(_options) {
+        super.mergeOptions(_options);
+        const { options } = this.data;
         if (options.bottomTabs?.currentTabIndex) {
             this.selectedIndex = options.bottomTabs?.currentTabIndex;
             (0, layoutActions_1.switchTabByIndex)(this, this.selectedIndex);

package/lib/dist/Mock/Layouts/LayoutNodeFactory.d.ts

@@ -2,6 +2,7 @@ import BottomTabs from './BottomTabsNode';
 import ComponentNode from './ComponentNode';
 import Stack from './StackNode';
 import ParentNode from './ParentNode';
+import SideMenuRootNode, { SideMenuLeftNode, SideMenuRightNode, SideMenuCenterNode } from './SideMenu';
 export default class LayoutNodeFactory {
-    static create(layout: any, parentNode?: ParentNode): Stack | BottomTabs | ComponentNode;
+    static create(layout: any, parentNode?: ParentNode): ComponentNode | SideMenuRootNode | SideMenuLeftNode | SideMenuRightNode | SideMenuCenterNode | Stack | BottomTabs;
 }

package/lib/dist/Mock/Layouts/LayoutNodeFactory.js

@@ -4,6 +4,7 @@ const tslib_1 = require("tslib");
 const BottomTabsNode_1 = tslib_1.__importDefault(require("./BottomTabsNode"));
 const ComponentNode_1 = tslib_1.__importDefault(require("./ComponentNode"));
 const StackNode_1 = tslib_1.__importDefault(require("./StackNode"));
+const SideMenu_1 = tslib_1.__importStar(require("./SideMenu"));
 class LayoutNodeFactory {
     static create(layout, parentNode) {
         switch (layout.type) {
@@ -11,7 +12,15 @@ class LayoutNodeFactory {
                 return new ComponentNode_1.default(layout, parentNode);
             case 'Stack':
                 return new StackNode_1.default(layout, parentNode);
-            default:
+            case 'SideMenuRoot':
+                return new SideMenu_1.default(layout, parentNode);
+            case 'SideMenuLeft':
+                return new SideMenu_1.SideMenuLeftNode(layout, parentNode);
+            case 'SideMenuCenter':
+                return new SideMenu_1.SideMenuCenterNode(layout, parentNode);
+            case 'SideMenuRight':
+                return new SideMenu_1.SideMenuRightNode(layout, parentNode);
+            default: // TODO Undo
             case 'BottomTabs':
                 return new BottomTabsNode_1.default(layout, parentNode);
         }

package/lib/dist/Mock/Layouts/ParentNode.d.ts

@@ -10,6 +10,7 @@ export default class ParentNode extends Node {
     componentDidDisappear(): void;
     getVisibleLayout(): ComponentNode;
     getTopParent(): Node;
+    applyOptions(_options: Options): void;
     mergeOptions(options: Options): void;
     buttonsChanged(_oldButtons: OptionsTopBarButton[], _newButtons: OptionsTopBarButton[]): void;
     titleChanged(_oldComponent: any, _newComponent: any): void;

package/lib/dist/Mock/Layouts/ParentNode.js

@@ -26,6 +26,9 @@ class ParentNode extends Node_1.default {
             return this.parentNode.getTopParent();
         return this;
     }
+    applyOptions(_options) {
+        this.parentNode?.applyOptions(_options);
+    }
     mergeOptions(options) {
         this.data.options = lodash_1.default.mergeWith(this.data.options, options, (objValue, srcValue, key) => {
             if (lodash_1.default.isArray(objValue)) {

package/lib/dist/Mock/Layouts/SideMenu.d.ts

@@ -0,0 +1,31 @@
+import ParentNode from './ParentNode';
+import ComponentNode from './ComponentNode';
+import { Options } from '../../src/index';
+import { NodeType } from './Node';
+export default class SideMenuRootNode extends ParentNode {
+    visibleChild: ParentNode;
+    constructor(layout: any, parentNode?: ParentNode);
+    applyOptions(_options: Options): void;
+    mergeOptions(options: Options): void;
+    /**
+     * @override
+     */
+    getVisibleLayout(): ComponentNode;
+    _updateVisibility(options: Options): void;
+    _getCenterChild: () => ParentNode;
+    _getLeftChild: () => ParentNode;
+    _getRightChild: () => ParentNode;
+}
+export declare class SideMenuNode extends ParentNode {
+    constructor(layout: any, type: NodeType, parentNode?: ParentNode);
+    getVisibleLayout(): ComponentNode;
+}
+export declare class SideMenuLeftNode extends SideMenuNode {
+    constructor(layout: any, parentNode?: ParentNode);
+}
+export declare class SideMenuRightNode extends SideMenuNode {
+    constructor(layout: any, parentNode?: ParentNode);
+}
+export declare class SideMenuCenterNode extends SideMenuNode {
+    constructor(layout: any, parentNode?: ParentNode);
+}