linted

.eslintrc

     "no-whitespace-before-property": "error",
     "object-curly-spacing": [
       "error",
-      "never"
+      "always"
     ],
     "one-var": 0,
     "one-var-declaration-per-line": 0,
      *                              react-native plugin
      */
     "react-native/no-unused-styles": "error",
-    "react-native/split-platform-components": "error",
-    /*
-     *                              babel plugin
-     */
-    "babel/new-cap": [
-      "error",
-      {
-        "capIsNewExceptions": [
-          "Immutable"
-        ]
-      }
-    ],
-    "babel/object-curly-spacing": [
-      "error",
-      "never"
-    ],
-    "babel/object-shorthand": 0,
-    "babel/no-await-in-loop": 0
+    "react-native/split-platform-components": "error"
   }
 }

integration/env.test.js

 describe('test environment', () => {
   it('handles object spread', () => {
-    const {x, y, ...z} = {x: 1, y: 2, a: 3, b: 4};
+    const { x, y, ...z } = { x: 1, y: 2, a: 3, b: 4 };
     expect(x).toEqual(1);
     expect(y).toEqual(2);
-    expect(z).toEqual({a: 3, b: 4});
+    expect(z).toEqual({ a: 3, b: 4 });
   });
 
-  it('handles async await', async() => {
+  it('handles async await', async () => {
     const result = await new Promise((r) => r('hello'));
     expect(result).toEqual('hello');
   });

integration/remx/component.js

-import {Text} from 'react-native';
-import React, {Component} from 'react';
+import { Text } from 'react-native';
+import React, { Component } from 'react';
 
-import {connect} from 'remx/react-native';
+import { connect } from 'remx/react-native';
 
-import {selectors} from './store';
+import { selectors } from './store';
 
 class MyContainer extends Component {
   constructor(props) {

integration/remx/store.js

   },
 
   setAge(age) {
-    state.merge({person: {age}});
+    state.merge({ person: { age } });
   }
 });
 

jsconfig.json

 {
     "compilerOptions": {
         "allowJs": true,
-        "allowSyntheticDefaultImports": true
+        "allowSyntheticDefaultImports": true,
+        "target": "ES6"
     },
     "exclude": [
-        "node_modules"
-    ]
-}
+        "node_modules",
+        "playground/node_modules"
+    ],
+    "react-native-tools": {
+        "projectRoot": "./"
+    }
+}

package.json

   "main": "src/index.js",
   "scripts": {
     "build": ":",
-    "lint": "eslint src",
+    "lint": "eslint src integration scripts playground/src playground/e2e playground/scripts",
     "test-js": "BABEL_ENV=test jest --coverage",
     "test-android": "node ./scripts/test.android.js",
     "test-ios": "node ./scripts/test.ios.js",

playground/e2e/app.test.js

     expect(elementByLabel('React Native Navigation!')).toBeVisible();
   });
 
-  xit('switch to tab based app', () => {
+  it('switch to tab based app', () => {
     elementByLabel('Switch to tab based app').tap();
     expect(elementByLabel('This is a tab screen')).toBeVisible();
   });

playground/e2e/init.js

 
 detoxConfig['ios-simulator'].app = process.env.detoxAppBuildPath;
 
-before(function(done) {
+before(function (done) {
   detox.config(detoxConfig);
   detox.start(done);
 });
 
-afterEach(function(done) {
+afterEach(function (done) {
   detox.waitForTestResult(done);
 });
 
-after(function(done) {
+after(function (done) {
   detox.cleanup(done);
 });

playground/src/app.js

 import Navigation from 'react-native-navigation';
 
-import {registerContainers} from './containers';
+import { registerContainers } from './containers';
 
 export function start() {
   registerContainers();

playground/src/containers/SimpleTabScreen.js

-import React, {Component} from 'react';
-import {View, Text} from 'react-native';
+import React, { Component } from 'react';
+import { View, Text } from 'react-native';
 
 export default class SimpleTabScreen extends Component {
   render() {

playground/src/containers/WelcomeScreen.js

-import React, {Component} from 'react';
-import {View, Text} from 'react-native';
+import React, { Component } from 'react';
+import { View, Text, Button } from 'react-native';
 
 export default class WelcomeScreen extends Component {
   render() {
     return (
       <View style={styles.root}>
         <Text style={styles.h1}>{`React Native Navigation!`}</Text>
+        <Button>
+          <Text style={styles.h1}>{`Switch to tab based app`}</Text>
+        </Button>
       </View>
     );
   }

playground/src/index.js

-import {start} from './app';
+import { start } from './app';
 
 start();

scripts/release.js

+/*eslint-disable no-console*/
 const shellUtils = require('shell-utils');
 const p = require('path');
 const semver = require('semver');

src/adapters/NativeCommandsSender.js

-import {NativeModules} from 'react-native';
+import { NativeModules } from 'react-native';
 
 export default class NativeCommandsSender {
   constructor() {

src/adapters/NativeEventsReceiver.js

-import {NativeModules, NativeEventEmitter} from 'react-native';
+import { NativeModules, NativeEventEmitter } from 'react-native';
 
 export default class NativeEventsReceiver {
   constructor() {

src/adapters/NativeEventsReceiver.test.js

 describe('NativeEventsReceiver', () => {
   let uut;
-  const eventEmitterMock = {addListener: jest.fn()};
+  const eventEmitterMock = { addListener: jest.fn() };
 
   beforeEach(() => {
     require('react-native').NativeModules.RNNEventEmitter = {};

src/commands/LayoutTreeParser.test.js

   let uut;
 
   beforeEach(() => {
-    const uniqueIdProvider = {generate: (prefix) => `${prefix}+UNIQUE_ID`};
+    const uniqueIdProvider = { generate: (prefix) => `${prefix}+UNIQUE_ID` };
     const LayoutTreeParser = require('./LayoutTreeParser').default;
     uut = new LayoutTreeParser(uniqueIdProvider);
   });
   });
 
   xit('adds uniqueId to containers', () => {
-    const input = {container: {}};
-    expect(uut.parse(input)).toEqual({container: {id: 'Container+UNIQUE_ID'}});
+    const input = { container: {} };
+    expect(uut.parse(input)).toEqual({ container: { id: 'Container+UNIQUE_ID' } });
   });
 
   xit('parses side menus', () => {

src/containers/ContainerRegistry.js

-import {AppRegistry} from 'react-native';
+import { AppRegistry } from 'react-native';
 import ContainerWrapper from './ContainerWrapper';
 
 export default class ContainerRegistry {

src/containers/ContainerRegistry.test.js

-import React, {Component} from 'react';
-import {AppRegistry, Text} from 'react-native';
+import React, { Component } from 'react';
+import { AppRegistry, Text } from 'react-native';
 import renderer from 'react-test-renderer';
 
 describe('ContainerRegistry', () => {
   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"/>);
+    const tree = renderer.create(<Container containerId="123" />);
     expect(tree.toJSON().children).toEqual(['Hello, World!']);
   });
 });

src/containers/ContainerWrapper.js

-import React, {Component} from 'react';
+import React, { Component } from 'react';
 
 export default class ContainerWrapper {
   static wrap(containerName, OriginalContainer, propStore) {
         }
         this.state = {
           containerId: props.containerId,
-          allProps: {...props, ...propStore.getPropsForContainerId(props.containerId)}
+          allProps: { ...props, ...propStore.getPropsForContainerId(props.containerId) }
         };
       }
 
       componentWillReceiveProps(nextProps) {
         this.setState({
-          allProps: {...nextProps, ...propStore.getPropsForContainerId(this.state.containerId)}
+          allProps: { ...nextProps, ...propStore.getPropsForContainerId(this.state.containerId) }
         });
       }
 

src/containers/ContainerWrapper.test.js

-import React, {Component} from 'react';
-import {AppRegistry, Text} from 'react-native';
+import React, { Component } from 'react';
+import { AppRegistry, Text } from 'react-native';
 import renderer from 'react-test-renderer';
 
 describe('ContainerWrapper', () => {
       super(props);
       testParentRef = this; //eslint-disable-line
       this.ChildClass = props.ChildClass;
-      this.state = {propsFromState: {}};
+      this.state = { propsFromState: {} };
     }
 
     render() {
       const Child = this.ChildClass;
       return (
-        <Child containerId="container1" {...this.state.propsFromState}/>
+        <Child containerId="container1" {...this.state.propsFromState} />
       );
     }
   }
   it('must have containerId as prop', () => {
     const NavigationContainer = ContainerWrapper.wrap(containerName, MyContainer, store);
     expect(() => {
-      renderer.create(<NavigationContainer/>);
+      renderer.create(<NavigationContainer />);
     }).toThrow(new Error('Container example.MyContainer does not have a containerId!'));
   });
 
   it('wraps the container and saves to store', () => {
     const NavigationContainer = ContainerWrapper.wrap(containerName, MyContainer, store);
     expect(NavigationContainer).not.toBeInstanceOf(MyContainer);
-    const tree = renderer.create(<NavigationContainer containerId={'container1'}/>);
+    const tree = renderer.create(<NavigationContainer containerId={'container1'} />);
     expect(tree.toJSON().children).toEqual(['Hello, World!']);
     expect(myContainerRef).toBeInstanceOf(MyContainer);
   });
 
   it('injects props from wrapper into original container', () => {
     const NavigationContainer = ContainerWrapper.wrap(containerName, MyContainer, store);
-    renderer.create(<NavigationContainer containerId={'container1'} myProp={'yo'}/>);
+    renderer.create(<NavigationContainer containerId={'container1'} myProp={'yo'} />);
     expect(myContainerRef.props.myProp).toEqual('yo');
   });
 
   it('updates props from wrapper into original container', () => {
     const NavigationContainer = ContainerWrapper.wrap(containerName, MyContainer, store);
-    renderer.create(<TestParent ChildClass={NavigationContainer}/>);
+    renderer.create(<TestParent ChildClass={NavigationContainer} />);
     expect(myContainerRef.props.foo).toEqual(undefined);
-    testParentRef.setState({propsFromState: {foo: 'yo'}});
+    testParentRef.setState({ propsFromState: { foo: 'yo' } });
     expect(myContainerRef.props.foo).toEqual('yo');
   });
 
   it('pulls props from the store and injects them into the inner container', () => {
-    store.setPropsForContainerId('container123', {numberProp: 1, stringProp: 'hello', objectProp: {a: 2}});
+    store.setPropsForContainerId('container123', { numberProp: 1, stringProp: 'hello', objectProp: { a: 2 } });
     const NavigationContainer = ContainerWrapper.wrap(containerName, MyContainer, store);
-    renderer.create(<NavigationContainer containerId={'container123'}/>);
-    expect(myContainerRef.props).toEqual({containerId: 'container123', numberProp: 1, stringProp: 'hello', objectProp: {a: 2}});
+    renderer.create(<NavigationContainer containerId={'container123'} />);
+    expect(myContainerRef.props).toEqual({ containerId: 'container123', numberProp: 1, stringProp: 'hello', objectProp: { a: 2 } });
   });
 
   it('updates props from store into inner container', () => {
     const NavigationContainer = ContainerWrapper.wrap(containerName, MyContainer, store);
-    renderer.create(<TestParent ChildClass={NavigationContainer}/>);
-    store.setPropsForContainerId('container1', {myProp: 'hello'});
+    renderer.create(<TestParent ChildClass={NavigationContainer} />);
+    store.setPropsForContainerId('container1', { myProp: 'hello' });
     expect(myContainerRef.props.foo).toEqual(undefined);
     expect(myContainerRef.props.myProp).toEqual(undefined);
-    testParentRef.setState({propsFromState: {foo: 'yo'}});
+    testParentRef.setState({ propsFromState: { foo: 'yo' } });
     expect(myContainerRef.props.foo).toEqual('yo');
     expect(myContainerRef.props.myProp).toEqual('hello');
   });
 
   it('protects containerId from change', () => {
     const NavigationContainer = ContainerWrapper.wrap(containerName, MyContainer, store);
-    renderer.create(<TestParent ChildClass={NavigationContainer}/>);
+    renderer.create(<TestParent ChildClass={NavigationContainer} />);
     expect(myContainerRef.props.containerId).toEqual('container1');
-    testParentRef.setState({propsFromState: {containerId: 'ERROR'}});
+    testParentRef.setState({ propsFromState: { containerId: 'ERROR' } });
     expect(myContainerRef.props.containerId).toEqual('container1');
   });
 });

src/containers/Store.test.js

   });
 
   it('holds props by containerId', () => {
-    uut.setPropsForContainerId('container1', {a: 1, b: 2});
-    expect(uut.getPropsForContainerId('container1')).toEqual({a: 1, b: 2});
+    uut.setPropsForContainerId('container1', { a: 1, b: 2 });
+    expect(uut.getPropsForContainerId('container1')).toEqual({ a: 1, b: 2 });
   });
 
   it('defensive for invalid containerId and props', () => {

src/index.test.js

-jest.mock('./Navigation', () => ({startApp: () => 'import'}));
+jest.mock('./Navigation', () => ({ startApp: () => 'import' }));
 import Navigation from './index';
 
 describe('index', () => {
   let uut;
 
   beforeEach(() => {
-    jest.mock('./Navigation', () => ({startApp: () => 'require'}));
+    jest.mock('./Navigation', () => ({ startApp: () => 'require' }));
     uut = require('./index');
   });