continue rename

lib/src/adapters/NativeCommandsSender.js

@@ -13,25 +13,25 @@ class NativeCommandsSender {
     this.nativeCommandsModule.setDefaultOptions(options);
   }
 
-  setOptions(containerId, options) {
-    this.nativeCommandsModule.setOptions(containerId, options);
+  setOptions(componentId, options) {
+    this.nativeCommandsModule.setOptions(componentId, options);
   }
 
-  async push(onContainerId, layout) {
-    const pushedContainerId = await this.nativeCommandsModule.push(onContainerId, layout);
-    return pushedContainerId;
+  async push(onComponentId, layout) {
+    const pushedComponentId = await this.nativeCommandsModule.push(onComponentId, layout);
+    return pushedComponentId;
   }
 
-  pop(containerId, options) {
-    return this.nativeCommandsModule.pop(containerId, options);
+  pop(componentId, options) {
+    return this.nativeCommandsModule.pop(componentId, options);
   }
 
-  popTo(containerId) {
-    return this.nativeCommandsModule.popTo(containerId);
+  popTo(componentId) {
+    return this.nativeCommandsModule.popTo(componentId);
   }
 
-  popToRoot(containerId) {
-    return this.nativeCommandsModule.popToRoot(containerId);
+  popToRoot(componentId) {
+    return this.nativeCommandsModule.popToRoot(componentId);
   }
 
   async showModal(layout) {
@@ -39,8 +39,8 @@ class NativeCommandsSender {
     return completed;
   }
 
-  dismissModal(containerId) {
-    return this.nativeCommandsModule.dismissModal(containerId);
+  dismissModal(componentId) {
+    return this.nativeCommandsModule.dismissModal(componentId);
   }
 
   dismissAllModals() {

lib/src/adapters/NativeEventsReceiver.js

@@ -5,12 +5,12 @@ class NativeEventsReceiver {
     this.emitter = new NativeEventEmitter(NativeModules.RNNEventEmitter);
   }
 
-  containerDidAppear(callback) {
-    this.emitter.addListener('RNN.containerDidAppear', callback);
+  componentDidAppear(callback) {
+    this.emitter.addListener('RNN.componentDidAppear', callback);
   }
 
-  containerDidDisappear(callback) {
-    this.emitter.addListener('RNN.containerDidDisappear', callback);
+  componentDidDisappear(callback) {
+    this.emitter.addListener('RNN.componentDidDisappear', callback);
   }
 
   appLaunched(callback) {

lib/src/commands/Commands.js

@@ -21,10 +21,10 @@ class Commands {
     this.nativeCommandsSender.setDefaultOptions(input);
   }
 
-  setOptions(containerId, options) {
+  setOptions(componentId, options) {
     const input = _.cloneDeep(options);
     OptionsProcessor.processOptions(input);
-    this.nativeCommandsSender.setOptions(containerId, input);
+    this.nativeCommandsSender.setOptions(componentId, input);
   }
 
   showModal(simpleApi) {
@@ -42,30 +42,30 @@ class Commands {
     return this.nativeCommandsSender.dismissAllModals();
   }
 
-  push(onContainerId, containerData) {
-    const input = _.cloneDeep(containerData);
+  push(onComponentId, componentData) {
+    const input = _.cloneDeep(componentData);
     OptionsProcessor.processOptions(input);
     const layout = this.layoutTreeParser.parse(input);
     this.layoutTreeCrawler.crawl(layout);
-    return this.nativeCommandsSender.push(onContainerId, layout);
+    return this.nativeCommandsSender.push(onComponentId, layout);
   }
 
-  pop(containerId, options) {
-    return this.nativeCommandsSender.pop(containerId, options);
+  pop(componentId, options) {
+    return this.nativeCommandsSender.pop(componentId, options);
   }
 
-  popTo(containerId) {
-    return this.nativeCommandsSender.popTo(containerId);
+  popTo(componentId) {
+    return this.nativeCommandsSender.popTo(componentId);
   }
 
-  popToRoot(containerId) {
-    return this.nativeCommandsSender.popToRoot(containerId);
+  popToRoot(componentId) {
+    return this.nativeCommandsSender.popToRoot(componentId);
   }
 
   // showOverlay(type, options) {
     // let promise;
     // if (type === 'custom') {
-    //   const layout = this.layoutTreeParser.createDialogContainer({ name: options });
+    //   const layout = this.layoutTreeParser.createDialogComponent({ name: options });
     //   this.layoutTreeCrawler.crawl(layout);
     //   promise = this.nativeCommandsSender.showOverlay(type, layout);
     // } else {

lib/src/commands/Commands.test.js

@@ -1,6 +1,6 @@
 const LayoutTreeParser = require('./LayoutTreeParser');
 const LayoutTreeCrawler = require('./LayoutTreeCrawler');
-const Store = require('../containers/Store');
+const Store = require('../components/Store');
 const UniqueIdProvider = require('../adapters/UniqueIdProvider.mock');
 const NativeCommandsSender = require('../adapters/NativeCommandsSender.mock');
 const Commands = require('./Commands');
@@ -42,14 +42,14 @@ describe('Commands', () => {
       expect(mockCommandsSender.setRoot.mock.calls[0][0].data.inner).not.toBe(obj);
     });
 
-    it('passProps into containers', () => {
+    it('passProps into components', () => {
       const passProps = {
         fn: () => 'Hello'
       };
-      expect(store.getPropsForContainerId('Component+UNIQUE_ID')).toEqual({});
+      expect(store.getPropsForComponentId('Component+UNIQUE_ID')).toEqual({});
       uut.setRoot({ component: { name: 'asd', passProps } });
-      expect(store.getPropsForContainerId('Component+UNIQUE_ID')).toEqual(passProps);
-      expect(store.getPropsForContainerId('Component+UNIQUE_ID').fn()).toEqual('Hello');
+      expect(store.getPropsForComponentId('Component+UNIQUE_ID')).toEqual(passProps);
+      expect(store.getPropsForComponentId('Component+UNIQUE_ID').fn()).toEqual('Hello');
     });
 
     it('returns a promise with the resolved layout', async () => {
@@ -62,14 +62,14 @@ describe('Commands', () => {
   describe('setOptions', () => {
     it('deep clones input to avoid mutation errors', () => {
       const obj = { title: 'test' };
-      uut.setOptions('theContainerId', obj);
+      uut.setOptions('theComponentId', obj);
       expect(mockCommandsSender.setOptions.mock.calls[0][1]).not.toBe(obj);
     });
 
-    it('passes options for container', () => {
-      uut.setOptions('theContainerId', { title: '1' });
+    it('passes options for component', () => {
+      uut.setOptions('theComponentId', { title: '1' });
       expect(mockCommandsSender.setOptions).toHaveBeenCalledTimes(1);
-      expect(mockCommandsSender.setOptions).toHaveBeenCalledWith('theContainerId', { title: '1' });
+      expect(mockCommandsSender.setOptions).toHaveBeenCalledWith('theComponentId', { title: '1' });
     });
   });
 
@@ -106,18 +106,18 @@ describe('Commands', () => {
       expect(mockCommandsSender.showModal.mock.calls[0][0].data.inner).not.toBe(obj);
     });
 
-    it('passProps into containers', () => {
+    it('passProps into components', () => {
       const passProps = {
         fn: () => 'hello'
       };
-      expect(store.getPropsForContainerId('Component+UNIQUE_ID')).toEqual({});
+      expect(store.getPropsForComponentId('Component+UNIQUE_ID')).toEqual({});
       uut.showModal({
         component: {
           name: 'com.example.MyScreen',
           passProps
         }
       });
-      expect(store.getPropsForContainerId('Component+UNIQUE_ID')).toEqual(passProps);
+      expect(store.getPropsForComponentId('Component+UNIQUE_ID')).toEqual(passProps);
     });
 
     it('returns a promise with the resolved layout', async () => {
@@ -158,20 +158,20 @@ describe('Commands', () => {
   describe('push', () => {
     it('deep clones input to avoid mutation errors', () => {
       const obj = {};
-      uut.push('theContainerId', { component: { name: 'name', passProps: { foo: obj } } });
+      uut.push('theComponentId', { component: { name: 'name', passProps: { foo: obj } } });
       expect(mockCommandsSender.push.mock.calls[0][1].data.passProps.foo).not.toBe(obj);
     });
 
     it('resolves with the parsed layout', async () => {
       mockCommandsSender.push.mockReturnValue(Promise.resolve('the resolved layout'));
-      const result = await uut.push('theContainerId', { component: { name: 'com.example.MyScreen' } });
+      const result = await uut.push('theComponentId', { component: { name: 'com.example.MyScreen' } });
       expect(result).toEqual('the resolved layout');
     });
 
     it('parses into correct layout node and sends to native', () => {
-      uut.push('theContainerId', { component: { name: 'com.example.MyScreen' } });
+      uut.push('theComponentId', { component: { name: 'com.example.MyScreen' } });
       expect(mockCommandsSender.push).toHaveBeenCalledTimes(1);
-      expect(mockCommandsSender.push).toHaveBeenCalledWith('theContainerId', {
+      expect(mockCommandsSender.push).toHaveBeenCalledWith('theComponentId', {
         type: 'Component',
         id: 'Component+UNIQUE_ID',
         data: {
@@ -184,12 +184,12 @@ describe('Commands', () => {
   });
 
   describe('pop', () => {
-    it('pops a container, passing containerId', () => {
-      uut.pop('theContainerId');
+    it('pops a component, passing componentId', () => {
+      uut.pop('theComponentId');
       expect(mockCommandsSender.pop).toHaveBeenCalledTimes(1);
-      expect(mockCommandsSender.pop).toHaveBeenCalledWith('theContainerId', undefined);
+      expect(mockCommandsSender.pop).toHaveBeenCalledWith('theComponentId', undefined);
     });
-    it('pops a container, passing containerId and options', () => {
+    it('pops a component, passing componentId and options', () => {
       const options = {
         customTransition: {
           animations: [
@@ -198,43 +198,43 @@ describe('Commands', () => {
           duration: 0.8
         }
       };
-      uut.pop('theContainerId', options);
+      uut.pop('theComponentId', options);
       expect(mockCommandsSender.pop).toHaveBeenCalledTimes(1);
-      expect(mockCommandsSender.pop).toHaveBeenCalledWith('theContainerId', options);
+      expect(mockCommandsSender.pop).toHaveBeenCalledWith('theComponentId', options);
     });
 
-    it('pop returns a promise that resolves to containerId', async () => {
-      mockCommandsSender.pop.mockReturnValue(Promise.resolve('theContainerId'));
-      const result = await uut.pop('theContainerId');
-      expect(result).toEqual('theContainerId');
+    it('pop returns a promise that resolves to componentId', async () => {
+      mockCommandsSender.pop.mockReturnValue(Promise.resolve('theComponentId'));
+      const result = await uut.pop('theComponentId');
+      expect(result).toEqual('theComponentId');
     });
   });
 
   describe('popTo', () => {
-    it('pops all containers until the passed Id is top', () => {
-      uut.popTo('theContainerId');
+    it('pops all components until the passed Id is top', () => {
+      uut.popTo('theComponentId');
       expect(mockCommandsSender.popTo).toHaveBeenCalledTimes(1);
-      expect(mockCommandsSender.popTo).toHaveBeenCalledWith('theContainerId');
+      expect(mockCommandsSender.popTo).toHaveBeenCalledWith('theComponentId');
     });
 
     it('returns a promise that resolves to targetId', async () => {
-      mockCommandsSender.popTo.mockReturnValue(Promise.resolve('theContainerId'));
-      const result = await uut.popTo('theContainerId');
-      expect(result).toEqual('theContainerId');
+      mockCommandsSender.popTo.mockReturnValue(Promise.resolve('theComponentId'));
+      const result = await uut.popTo('theComponentId');
+      expect(result).toEqual('theComponentId');
     });
   });
 
   describe('popToRoot', () => {
-    it('pops all containers to root', () => {
-      uut.popToRoot('theContainerId');
+    it('pops all components to root', () => {
+      uut.popToRoot('theComponentId');
       expect(mockCommandsSender.popToRoot).toHaveBeenCalledTimes(1);
-      expect(mockCommandsSender.popToRoot).toHaveBeenCalledWith('theContainerId');
+      expect(mockCommandsSender.popToRoot).toHaveBeenCalledWith('theComponentId');
     });
 
     it('returns a promise that resolves to targetId', async () => {
-      mockCommandsSender.popToRoot.mockReturnValue(Promise.resolve('theContainerId'));
-      const result = await uut.popToRoot('theContainerId');
-      expect(result).toEqual('theContainerId');
+      mockCommandsSender.popToRoot.mockReturnValue(Promise.resolve('theComponentId'));
+      const result = await uut.popToRoot('theComponentId');
+      expect(result).toEqual('theComponentId');
     });
   });
 

lib/src/commands/LayoutTreeCrawler.js

@@ -15,24 +15,24 @@ class LayoutTreeCrawler {
     node.data = node.data || {};
     node.children = node.children || [];
     if (_.isEqual(node.type, LayoutTypes.Component)) {
-      this._handleContainer(node);
+      this._handleComponent(node);
     }
     _.forEach(node.children, this.crawl);
   }
 
-  _handleContainer(node) {
-    this._assertContainerDataName(node);
+  _handleComponent(node) {
+    this._assertComponentDataName(node);
     this._savePropsToStore(node);
     this._applyStaticOptions(node);
     OptionsProcessor.processOptions(node.data.options);
   }
 
   _savePropsToStore(node) {
-    this.store.setPropsForContainerId(node.id, node.data.passProps);
+    this.store.setPropsForComponentId(node.id, node.data.passProps);
   }
 
   _applyStaticOptions(node) {
-    const clazz = this.store.getOriginalContainerClassForName(node.data.name) || {};
+    const clazz = this.store.getOriginalComponentClassForName(node.data.name) || {};
     const staticOptions = _.cloneDeep(clazz.options) || {};
     const passedOptions = node.data.options || {};
     node.data.options = _.merge({}, staticOptions, passedOptions);
@@ -44,9 +44,9 @@ class LayoutTreeCrawler {
     }
   }
 
-  _assertContainerDataName(container) {
-    if (!container.data.name) {
-      throw new Error('Missing container data.name');
+  _assertComponentDataName(component) {
+    if (!component.data.name) {
+      throw new Error('Missing component data.name');
     }
   }
 }

lib/src/commands/LayoutTreeCrawler.test.js

@@ -1,6 +1,6 @@
 const LayoutTypes = require('./LayoutTypes');
 const LayoutTreeCrawler = require('./LayoutTreeCrawler');
-const Store = require('../containers/Store');
+const Store = require('../components/Store');
 const UniqueIdProvider = require('../adapters/UniqueIdProvider.mock');
 
 describe('LayoutTreeCrawler', () => {
@@ -42,26 +42,26 @@ describe('LayoutTreeCrawler', () => {
       type: LayoutTypes.BottomTabs, children: [
         { type: LayoutTypes.Component, data: { name: 'the name', passProps: { myProp: 123 } } }]
     };
-    expect(store.getPropsForContainerId('Component+UNIQUE_ID')).toEqual({});
+    expect(store.getPropsForComponentId('Component+UNIQUE_ID')).toEqual({});
     uut.crawl(node);
-    expect(store.getPropsForContainerId('Component+UNIQUE_ID')).toEqual({ myProp: 123 });
+    expect(store.getPropsForComponentId('Component+UNIQUE_ID')).toEqual({ myProp: 123 });
   });
 
-  it('Containers: injects options from original container class static property', () => {
+  it('Components: injects options from original component class static property', () => {
     const theStyle = {};
-    const MyContainer = class {
+    const MyComponent = class {
       static get options() {
         return theStyle;
       }
     };
 
-    const node = { type: LayoutTypes.Component, data: { name: 'theContainerName' } };
-    store.setOriginalContainerClassForName('theContainerName', MyContainer);
+    const node = { type: LayoutTypes.Component, data: { name: 'theComponentName' } };
+    store.setOriginalComponentClassForName('theComponentName', MyComponent);
     uut.crawl(node);
     expect(node.data.options).toEqual(theStyle);
   });
 
-  it('Containers: merges options from container class static property with passed options, favoring passed options', () => {
+  it('Components: merges options from component class static property with passed options, favoring passed options', () => {
     const theStyle = {
       bazz: 123,
       inner: {
@@ -69,7 +69,7 @@ describe('LayoutTreeCrawler', () => {
       },
       opt: 'exists only in static'
     };
-    const MyContainer = class {
+    const MyComponent = class {
       static get options() {
         return theStyle;
       }
@@ -83,8 +83,8 @@ describe('LayoutTreeCrawler', () => {
       }
     };
 
-    const node = { type: LayoutTypes.Component, data: { name: 'theContainerName', options: passedOptions } };
-    store.setOriginalContainerClassForName('theContainerName', MyContainer);
+    const node = { type: LayoutTypes.Component, data: { name: 'theComponentName', options: passedOptions } };
+    store.setOriginalComponentClassForName('theComponentName', MyComponent);
 
     uut.crawl(node);
 
@@ -100,28 +100,28 @@ describe('LayoutTreeCrawler', () => {
 
   it('Component: deepClones options', () => {
     const theStyle = {};
-    const MyContainer = class {
+    const MyComponent = class {
       static get options() {
         return theStyle;
       }
     };
 
-    const node = { type: LayoutTypes.Component, data: { name: 'theContainerName' } };
-    store.setOriginalContainerClassForName('theContainerName', MyContainer);
+    const node = { type: LayoutTypes.Component, data: { name: 'theComponentName' } };
+    store.setOriginalComponentClassForName('theComponentName', MyComponent);
     uut.crawl(node);
     expect(node.data.options).not.toBe(theStyle);
   });
 
-  it('Containers: must contain data name', () => {
+  it('Components: must contain data name', () => {
     const node = { type: LayoutTypes.Component, data: {} };
-    expect(() => uut.crawl(node)).toThrow(new Error('Missing container data.name'));
+    expect(() => uut.crawl(node)).toThrow(new Error('Missing component data.name'));
   });
 
-  it('Containers: options default obj', () => {
-    const MyContainer = class { };
+  it('Components: options default obj', () => {
+    const MyComponent = class { };
 
-    const node = { type: LayoutTypes.Component, data: { name: 'theContainerName' } };
-    store.setOriginalContainerClassForName('theContainerName', MyContainer);
+    const node = { type: LayoutTypes.Component, data: { name: 'theComponentName' } };
+    store.setOriginalComponentClassForName('theComponentName', MyComponent);
     uut.crawl(node);
     expect(node.data.options).toEqual({});
   });
@@ -132,7 +132,7 @@ describe('LayoutTreeCrawler', () => {
 
     beforeEach(() => {
       options = {};
-      node = { type: LayoutTypes.Component, data: { name: 'theContainerName', options } };
+      node = { type: LayoutTypes.Component, data: { name: 'theComponentName', options } };
     });
 
     it('processes colors into numeric AARRGGBB', () => {

lib/src/components/ComponentRegistry.test.js

@@ -3,14 +3,14 @@ const { Component } = require('react');
 const { AppRegistry, Text } = require('react-native');
 
 const renderer = require('react-test-renderer');
-const ContainerRegistry = require('./ContainerRegistry');
+const ComponentRegistry = require('./ComponentRegistry');
 const Store = require('./Store');
 
-describe('ContainerRegistry', () => {
+describe('ComponentRegistry', () => {
   let uut;
   let store;
 
-  class MyContainer extends Component {
+  class MyComponent extends Component {
     render() {
       return <Text>{'Hello, World!'}</Text>;
     }
@@ -19,29 +19,29 @@ describe('ContainerRegistry', () => {
   beforeEach(() => {
     store = new Store();
     AppRegistry.registerComponent = jest.fn(AppRegistry.registerComponent);
-    uut = new ContainerRegistry(store);
+    uut = new ComponentRegistry(store);
   });
 
-  it('registers container component by containerName into AppRegistry', () => {
+  it('registers component component by componentName into AppRegistry', () => {
     expect(AppRegistry.registerComponent).not.toHaveBeenCalled();
-    uut.registerContainer('example.MyContainer.name', () => MyContainer);
+    uut.registerComponent('example.MyComponent.name', () => MyComponent);
     expect(AppRegistry.registerComponent).toHaveBeenCalledTimes(1);
-    expect(AppRegistry.registerComponent.mock.calls[0][0]).toEqual('example.MyContainer.name');
+    expect(AppRegistry.registerComponent.mock.calls[0][0]).toEqual('example.MyComponent.name');
   });
 
-  it('saves the original container into the store', () => {
-    expect(store.getOriginalContainerClassForName('example.MyContainer.name')).toBeUndefined();
-    uut.registerContainer('example.MyContainer.name', () => MyContainer);
-    const Class = store.getOriginalContainerClassForName('example.MyContainer.name');
+  it('saves the original component into the store', () => {
+    expect(store.getOriginalComponentClassForName('example.MyComponent.name')).toBeUndefined();
+    uut.registerComponent('example.MyComponent.name', () => MyComponent);
+    const Class = store.getOriginalComponentClassForName('example.MyComponent.name');
     expect(Class).not.toBeUndefined();
-    expect(Class).toEqual(MyContainer);
+    expect(Class).toEqual(MyComponent);
     expect(Object.getPrototypeOf(Class)).toEqual(Component);
   });
 
   it('resulting in a normal component', () => {
-    uut.registerContainer('example.MyContainer.name', () => MyContainer);
-    const Container = AppRegistry.registerComponent.mock.calls[0][1]();
-    const tree = renderer.create(<Container containerId="123" />);
+    uut.registerComponent('example.MyComponent.name', () => MyComponent);
+    const Component = AppRegistry.registerComponent.mock.calls[0][1]();
+    const tree = renderer.create(<Component componentId="123" />);
     expect(tree.toJSON().children).toEqual(['Hello, World!']);
   });
 });

lib/src/events/PrivateEventsListener.js

@@ -1,4 +1,4 @@
-const Lifecycle = require('../containers/Lifecycle');
+const Lifecycle = require('../components/Lifecycle');
 
 class PrivateEventsListener {
   constructor(nativeEventsReceiver, store) {
@@ -7,8 +7,8 @@ class PrivateEventsListener {
   }
 
   listenAndHandlePrivateEvents() {
-    this.nativeEventsReceiver.containerDidAppear(this.lifecycle.containerDidAppear);
-    this.nativeEventsReceiver.containerDidDisappear(this.lifecycle.containerDidDisappear);
+    this.nativeEventsReceiver.componentDidAppear(this.lifecycle.componentDidAppear);
+    this.nativeEventsReceiver.componentDidDisappear(this.lifecycle.componentDidDisappear);
     this.nativeEventsReceiver.navigationButtonPressed(this.lifecycle.onNavigationButtonPressed);
   }
 }

lib/src/events/PrivateEventsListener.test.js

@@ -1,6 +1,6 @@
 const PrivateEventsListener = require('./PrivateEventsListener');
 const NativeEventsReceiver = require('../adapters/NativeEventsReceiver.mock');
-const Store = require('../containers/Store');
+const Store = require('../components/Store');
 
 describe('PrivateEventsListener', () => {
   let uut;
@@ -13,39 +13,39 @@ describe('PrivateEventsListener', () => {
     uut = new PrivateEventsListener(nativeEventsReceiver, store);
   });
 
-  it('register and handle containerDidAppear', () => {
+  it('register and handle componentDidAppear', () => {
     const mockRef = {
       didAppear: jest.fn()
     };
-    store.setRefForContainerId('myContainerId', mockRef);
+    store.setRefForComponentId('myComponentId', mockRef);
     uut.listenAndHandlePrivateEvents();
-    expect(nativeEventsReceiver.containerDidAppear).toHaveBeenCalledTimes(1);
-    const callbackFunction = nativeEventsReceiver.containerDidAppear.mock.calls[0][0];
+    expect(nativeEventsReceiver.componentDidAppear).toHaveBeenCalledTimes(1);
+    const callbackFunction = nativeEventsReceiver.componentDidAppear.mock.calls[0][0];
     expect(callbackFunction).toBeInstanceOf(Function);
 
     expect(mockRef.didAppear).not.toHaveBeenCalled();
-    callbackFunction('myContainerId');
+    callbackFunction('myComponentId');
 
     expect(mockRef.didAppear).toHaveBeenCalledTimes(1);
   });
 
-  it('register and listen containerDidDisappear', () => {
+  it('register and listen componentDidDisappear', () => {
     uut.listenAndHandlePrivateEvents();
-    expect(nativeEventsReceiver.containerDidDisappear).toHaveBeenCalledTimes(1);
+    expect(nativeEventsReceiver.componentDidDisappear).toHaveBeenCalledTimes(1);
   });
 
   it('register and handle onNavigationButtonPressed', () => {
     const mockRef = {
       onNavigationButtonPressed: jest.fn()
     };
-    store.setRefForContainerId('myContainerId', mockRef);
+    store.setRefForComponentId('myComponentId', mockRef);
     uut.listenAndHandlePrivateEvents();
     expect(nativeEventsReceiver.navigationButtonPressed).toHaveBeenCalledTimes(1);
     const callbackFunction = nativeEventsReceiver.navigationButtonPressed.mock.calls[0][0];
     expect(callbackFunction).toBeInstanceOf(Function);
 
     expect(mockRef.onNavigationButtonPressed).not.toHaveBeenCalled();
-    callbackFunction({ containerId: 'myContainerId', buttonId: 'myButtonId' });
+    callbackFunction({ componentId: 'myComponentId', buttonId: 'myButtonId' });
 
     expect(mockRef.onNavigationButtonPressed).toHaveBeenCalledTimes(1);
   });

lib/src/xparams/containers/Container.js

@@ -1,23 +0,0 @@
-const Options = require('./../options/Options');
-
-class Container {
-  /**
-   * @property {string} name The container's registered name
-   * @property {Container[]} [topTabs]
-   * @property {object} [passProps] props
-   * @property {object} [customTransition]
-   * @property {Options} options
-   */
-  constructor(params) {
-    this.name = params.name;
-    if (params.topTabs) {
-      params.topTabs.map((t) => new Container(t));
-      this.topTabs = params.topTabs;
-    }
-    this.passProps = params.passProps;
-    this.customTransition = params.customTransition;
-    this.options = params.options && new Options(params.options);
-  }
-}
-
-module.exports = Container;

lib/src/xparams/containers/Container.test.js

@@ -1,30 +0,0 @@
-const Container = require('./Container');
-
-const PASS_PROPS = {
-  number: 9
-};
-const CONTAINER = {
-  name: 'myScreen',
-  passProps: PASS_PROPS,
-  options: {}
-};
-const TOP_TABS_CONTAINER = {
-  topTabs: [
-    CONTAINER,
-    CONTAINER
-  ]
-};
-
-describe('ContainerRegistry', () => {
-  it('parses container correctly', () => {
-    const uut = new Container(CONTAINER);
-    expect(uut.name).toBe('myScreen');
-    expect(uut.passProps).toEqual(PASS_PROPS);
-    expect(uut.options).toEqual({});
-  });
-
-  it('parses TopTabs container', () => {
-    const uut = new Container(TOP_TABS_CONTAINER);
-    expect(uut.topTabs).toEqual([CONTAINER, CONTAINER]);
-  });
-});

lib/src/xparams/containers/Root.js

@@ -1,20 +0,0 @@
-const Container = require('./Container');
-const SideMenu = require('./SideMenu');
-
-class Root {
-  /**
-   * @property {Container} component
-   * @property {SideMenu} [sideMenu]
-   * @property {Container[]} [bottomTabs]
-   */
-  constructor(root) {
-    this.component = root.container && new Container(root.component);
-    this.sideMenu = root.sideMenu && new SideMenu(root.sideMenu);
-    if (root.bottomTabs) {
-      root.bottomTabs.map((t) => new Container(t.component));
-      this.bottomTabs = root.bottomTabs;
-    }
-  }
-}
-
-module.exports = Root;

lib/src/xparams/containers/Root.test.js

@@ -1,83 +0,0 @@
-const Root = require('./Root');
-
-const COMPONENT = { name: 'myScreen' };
-const SIDE_MENU = {
-  left: {
-    component: {
-      name: 'navigation.playground.TextScreen',
-      passProps: {
-        text: 'This is a left side menu screen'
-      }
-    }
-  },
-  right: {
-    component: {
-      name: 'navigation.playground.TextScreen',
-      passProps: {
-        text: 'This is a right side menu screen'
-      }
-    }
-  }
-};
-const BOTTOM_TABS = [
-  {
-    component: {
-      name: 'navigation.playground.TextScreen',
-      passProps: {
-        text: 'This is a side menu center screen tab 1'
-      }
-    }
-  },
-  {
-    component: {
-      name: 'navigation.playground.TextScreen',
-      passProps: {
-        text: 'This is a side menu center screen tab 2'
-      }
-    }
-  },
-  {
-    component: {
-      name: 'navigation.playground.TextScreen',
-      passProps: {
-        text: 'This is a side menu center screen tab 3'
-      }
-    }
-  }
-];
-
-describe('Root', () => {
-  it('Parses Root', () => {
-    const uut = new Root(simpleRoot());
-    expect(uut.component.name).toEqual(COMPONENT.name);
-  });
-
-  it('parses root with sideMenu', () => {
-    const uut = new Root(rootWithSideMenu());
-    expect(uut.component.name).toEqual(COMPONENT.name);
-    expect(uut.sideMenu).toEqual(SIDE_MENU);
-  });
-
-  it('parses root with BottomTabs', () => {
-    const uut = new Root(rootWithBottomTabs());
-    expect(uut.bottomTabs).toEqual(BOTTOM_TABS);
-  });
-});
-
-function rootWithBottomTabs() {
-  return {
-    component: COMPONENT,
-    bottomTabs: BOTTOM_TABS
-  };
-}
-
-function simpleRoot() {
-  return { component: COMPONENT };
-}
-
-function rootWithSideMenu() {
-  return {
-    component: COMPONENT,
-    sideMenu: SIDE_MENU
-  };
-}

lib/src/xparams/containers/SideMenu.js

@@ -1,14 +0,0 @@
-const Container = require('./Container');
-
-class SideMenu {
-  /**
-  * @property {Container} [left]
-  * @property {Container} [right]
-  */
-  constructor(params) {
-    this.left = params.left && { component: new Container(params.left.component) };
-    this.right = params.right && { component: new Container(params.right.component) };
-  }
-}
-
-module.exports = SideMenu;

lib/src/xparams/containers/SideMenu.test.js

@@ -1,13 +0,0 @@
-const SideMenu = require('./SideMenu');
-
-const LEFT = { component: { name: 'myLeftScreen' } };
-const RIGHT = { component: { name: 'myRightScreen' } };
-const SIDE_MENU = { left: LEFT, right: RIGHT };
-
-describe('SideMenu', () => {
-  it('parses SideMenu', () => {
-    const uut = new SideMenu(SIDE_MENU);
-    expect(uut.left).toEqual(LEFT);
-    expect(uut.right).toEqual(RIGHT);
-  });
-});

lib/src/xparams/options/BottomTab.js

@@ -1,26 +0,0 @@
-const { isEmpty } = require('lodash');
-
-class BottomTab {
-  /**
-   * @property {string} [title]
-   * @property {number} [tag]
-   * @property {object} [icon]
-   * @property {boolean} [visible]
-   * @property {string} [badge]
-   * @property {string} [testID]
-   */
-  constructor(params) {
-    if (isEmpty(params)) {
-      return;
-    }
-
-    this.badge = params.badge;
-    this.title = params.title;
-    this.icon = params.icon;
-    this.visible = params.visible;
-    this.testID = params.testID;
-    this.tag = params.tag;
-  }
-}
-
-module.exports = BottomTab;

lib/src/xparams/options/BottomTab.test.js

@@ -1,18 +0,0 @@
-const BottomTab = require('./BottomTab');
-
-const BOTTOM_TAB = {
-  title: 'title',
-  badge: 3,
-  visible: true,
-  icon: { uri: '' }
-};
-
-describe('BottomTab', () => {
-  it('parses BottomTab options', () => {
-    const uut = new BottomTab(BOTTOM_TAB);
-    expect(uut.title).toEqual('title');
-    expect(uut.badge).toEqual(3);
-    expect(uut.visible).toEqual(true);
-    expect(uut.icon).toEqual({ uri: '' });
-  });
-});

lib/src/xparams/options/BottomTabs.js

@@ -1,25 +0,0 @@
-const { isEmpty } = require('lodash');
-
-class BottomTabs {
-  /**
-   * @property {string} [currentTabId]
-   * @property {number} [currentTabIndex]
-   * @property {boolean} [hidden]
-   * @property {boolean} [animateHide]
-   * @property {string} [testID]
-   * @property {boolean} [drawUnder]
-   */
-  constructor(params) {
-    if (isEmpty(params)) {
-      return;
-    }
-    this.currentTabId = params.currentTabId;
-    this.currentTabIndex = params.currentTabIndex;
-    this.hidden = params.hidden;
-    this.animateHide = params.animateHide;
-    this.testID = params.testID;
-    this.drawUnder = params.drawUnder;
-  }
-}
-
-module.exports = BottomTabs;

lib/src/xparams/options/BottomTabs.test.js

@@ -1,18 +0,0 @@
-const BottomTabs = require('./BottomTabs');
-
-const BOTTOM_TABS = {
-  currentTabId: 1,
-  currentTabIndex: 2,
-  hidden: true,
-  animateHide: true
-};
-
-describe('BottomTabs', () => {
-  it('parses BottomTabs options', () => {
-    const uut = new BottomTabs(BOTTOM_TABS);
-    expect(uut.currentTabId).toEqual(1);
-    expect(uut.currentTabIndex).toEqual(2);
-    expect(uut.hidden).toEqual(true);
-    expect(uut.animateHide).toEqual(true);
-  });
-});

lib/src/xparams/options/Button.js

@@ -1,25 +0,0 @@
-class Button {
-  /**
-   * @property {string} id
-   * @property {string} [testID]
-   * @property {string} [title]
-   * @property {string} [buttonColor]
-   * @property {string} [showAsAction]
-   * @property {int} [buttonFontWeight]
-   * @property {boolean} [disableIconTint]
-   * @property {boolean} [disabled]
-   */
-  constructor(params) {
-    this.id = params.id;
-    this.testID = params.testID;
-    this.title = params.title;
-    this.buttonColor = params.buttonColor;
-    this.showAsAction = params.showAsAction;
-    this.buttonFontWeight = params.buttonFontWeight;
-    this.buttonFontSize = params.buttonFontSize;
-    this.disableIconTint = params.disableIconTint;
-    this.disabled = params.disabled;
-  }
-}
-
-module.exports = Button;

lib/src/xparams/options/Button.test.js

@@ -1,28 +0,0 @@
-const Button = require('./Button');
-
-const BUTTON = {
-  id: 'myBtn',
-  testID: 'BTN',
-  title: 'My Button',
-  buttonColor: 'red',
-  buttonFontSize: 16,
-  buttonFontWeight: 300,
-  showAsAction: 'never',
-  disableIconTint: true,
-  disabled: true
-};
-
-describe('Button', () => {
-  it('parses button', () => {
-    const uut = new Button(BUTTON);
-    expect(uut.id).toEqual('myBtn');
-    expect(uut.testID).toEqual('BTN');
-    expect(uut.title).toEqual('My Button');
-    expect(uut.buttonColor).toEqual('red');
-    expect(uut.showAsAction).toEqual('never');
-    expect(uut.buttonFontWeight).toEqual(300);
-    expect(uut.buttonFontSize).toEqual(16);
-    expect(uut.disableIconTint).toEqual(true);
-    expect(uut.disabled).toEqual(true);
-  });
-});

lib/src/xparams/options/Options.js

@@ -1,27 +0,0 @@
-const TopBar = require('./TopBar');
-const BottomTabs = require('./BottomTabs');
-const BottomTab = require('./BottomTab');
-const TopTabs = require('./TopTabs');
-
-class Options {
-  /**
-   * @property {options:TopBar} [topBar]
-   * @property {options:BottomTabs} [bottomTabs]
-   * @property {options:BottomTab} [bottomTab]
-   * @property {string} [orientation]
-   * @property {options:TopTabs} [topTabs]
-   */
-  constructor(options) {
-    this.topBar = options.topBar && new TopBar(options.topBar);
-    this.bottomTabs = options.bottomTabs && new BottomTabs(options.bottomTabs);
-    this.bottomTab = options.bottomTab && new BottomTab(options.bottomTab);
-    this.orientation = options.orientation;
-    this.sideMenu = options.sideMenu;
-    this.backgroundImage = options.backgroundImage;
-    this.rootBackgroundImage = options.rootBackgroundImage;
-    this.screenBackgroundColor = options.screenBackgroundColor;
-    this.topTabs = options.topTabs && new TopTabs(options.topTabs);
-  }
-}
-
-module.exports = Options;

lib/src/xparams/options/Options.test.js

@@ -1,31 +0,0 @@
-const Options = require('./Options');
-const BottomTabs = require('./BottomTabs');
-const TopBar = require('./TopBar');
-const BottomTab = require('./BottomTab');
-const TopTabs = require('./TopTabs');
-
-const TAB_BAR = {};
-const TOP_BAR = {};
-const TAB_ITEM = {};
-const TOP_TABS = {
-  selectedTabColor: 'blue',
-  unselectedTabColor: 'red'
-};
-const NAVIGATION_OPTIONS = {
-  topBar: TOP_BAR,
-  bottomTabs: TAB_BAR,
-  bottomTab: TAB_ITEM,
-  orientation: 'portrait',
-  topTabs: TOP_TABS
-};
-
-describe('Options', () => {
-  it('parses options correctly', () => {
-    const uut = new Options(NAVIGATION_OPTIONS);
-    expect(uut.bottomTabs).toBeInstanceOf(BottomTabs);
-    expect(uut.topBar).toBeInstanceOf(TopBar);
-    expect(uut.bottomTab).toBeInstanceOf(BottomTab);
-    expect(uut.orientation).toEqual('portrait');
-    expect(uut.topTabs).toBeInstanceOf(TopTabs);
-  });
-});

lib/src/xparams/options/TopBar.js

@@ -1,46 +0,0 @@
-const Button = require('./Button');
-
-class TopBar {
-  /**
-   * @property {string} [title]
-   * @property {string} [backgroundColor]
-   * @property {string} [textColor]
-   * @property {string} [buttonColor]
-   * @property {number} [textFontSize]
-   * @property {string} [textFontFamily]
-   * @property {string} [testID]
-   * @property {boolean} [hidden]
-   * @property {boolean} [animateHide]
-   * @property {boolean} [hideOnScroll]
-   * @property {boolean} [transparent]
-   * @property {boolean} [translucent]
-   * @property {boolean} [blur]
-   * @property {boolean} [noBorder]
-   * @property {boolean} [largeTitle]
-   * @property {boolean} [drawUnder]
-   * @property {options:Button[]} [rightButtons]
-   * @property {options:Button[]} [leftButtons]
-   */
-  constructor(options) {
-    this.title = options.title;
-    this.backgroundColor = options.backgroundColor;
-    this.textColor = options.textColor;
-    this.textFontSize = options.textFontSize;
-    this.textFontFamily = options.textFontFamily;
-    this.hidden = options.hidden;
-    this.animateHide = options.animateHide;
-    this.hideOnScroll = options.hideOnScroll;
-    this.transparent = options.transparent;
-    this.translucent = options.translucent;
-    this.buttonColor = options.buttonColor;
-    this.blur = options.blur;
-    this.noBorder = options.noBorder;
-    this.largeTitle = options.largeTitle;
-    this.testID = options.testID;
-    this.drawUnder = options.drawUnder;
-    this.rightButtons = options.rightButtons && options.rightButtons.map((button) => new Button(button));
-    this.leftButtons = options.leftButtons && options.leftButtons.map((button) => new Button(button));
-  }
-}
-
-module.exports = TopBar;

lib/src/xparams/options/TopBar.test.js

@@ -1,49 +0,0 @@
-const TopBar = require('./TopBar');
-const Button = require('./Button');
-
-const RIGHT_BUTTONS = [
-  {
-    id: 'myBtn',
-    testID: 'BTN',
-    title: 'My Button',
-    buttonColor: 'red'
-  }
-];
-const LEFT_BUTTONS = [
-  {
-    id: 'myBtn',
-    testID: 'BTN',
-    title: 'My Button',
-    buttonColor: 'red'
-  }
-];
-
-const TOP_BAR = {
-  title: 'something',
-  backgroundColor: 'red',
-  textColor: 'green',
-  textFontSize: 13,
-  textFontFamily: 'guttmanYadBrush',
-  hidden: true,
-  animateHide: true,
-  hideOnScroll: true,
-  transparent: true,
-  rightButtons: RIGHT_BUTTONS,
-  leftButtons: LEFT_BUTTONS
-};
-
-describe('TopBar', () => {
-  it('Parses TopBar', () => {
-    const uut = new TopBar(TOP_BAR);
-    expect(uut.title).toEqual('something');
-    expect(uut.backgroundColor).toEqual('red');
-    expect(uut.textColor).toEqual('green');
-    expect(uut.textFontSize).toEqual(13);
-    expect(uut.textFontFamily).toEqual('guttmanYadBrush');
-    expect(uut.hidden).toEqual(true);
-    expect(uut.animateHide).toEqual(true);
-    expect(uut.hideOnScroll).toEqual(true);
-    expect(uut.transparent).toEqual(true);
-    expect(uut.leftButtons[0]).toBeInstanceOf(Button);
-  });
-});

lib/src/xparams/options/TopTab.js

@@ -1,13 +0,0 @@
-class TopTab {
-  /**
-   * @property {string} title The tab's title in the TopTabs view
-   * @property {string} [titleFontFamily] Change the tab's title font family
-   */
-  constructor(topTab) {
-    this.title = topTab.title;
-    this.titleFontFamily = topTab.titleFontFamily;
-  }
-
-}
-
-module.exports = TopTab;

lib/src/xparams/options/TopTab.test.js

@@ -1,14 +0,0 @@
-const TopTab = require('./TopTab');
-
-const TOP_TAB = {
-  title: 'something',
-  titleFontFamily: 'Dosis-Regular'
-};
-
-describe('TopBar', () => {
-  it('Parses TopBar', () => {
-    const uut = new TopTab(TOP_TAB);
-    expect(uut.title).toEqual('something');
-    expect(uut.titleFontFamily).toEqual('Dosis-Regular');
-  });
-});

lib/src/xparams/options/TopTabs.js

@@ -1,14 +0,0 @@
-class TopTabs {
-  /**
-   * @property {string} [selectedTabColor] Selected tab color
-   * @property {string} unselectedTabColor Unselected tab color
-   * @property {int} fontSize
-   */
-  constructor(topTabs) {
-    this.selectedTabColor = topTabs.selectedTabColor;
-    this.unselectedTabColor = topTabs.unselectedTabColor;
-    this.fontSize = topTabs.fontSize;
-  }
-}
-
-module.exports = TopTabs;

lib/src/xparams/options/TopTabs.test.js

@@ -1,16 +0,0 @@
-const TopTabs = require('./TopTabs');
-
-const TOP_TABS = {
-  selectedTabColor: 'red',
-  unselectedTabColor: 'blue',
-  fontSize: 11
-};
-
-describe('TopTabs', () => {
-  it('Parses TopTabs', () => {
-    const uut = new TopTabs(TOP_TABS);
-    expect(uut.selectedTabColor).toEqual('red');
-    expect(uut.unselectedTabColor).toEqual('blue');
-    expect(uut.fontSize).toEqual(11);
-  });
-});