tslint instead of xo and eslint

lib/src/Navigation.ts

    * @param {string} componentName Unique component name
    * @param {function} getComponentClassFunc generator function, typically `() => require('./myComponent')`
    */
-  registerComponent(componentName: string, getComponentClassFunc: ComponentProvider) {
+  public registerComponent(componentName: string, getComponentClassFunc: ComponentProvider) {
     this.componentRegistry.registerComponent(componentName, getComponentClassFunc);
   }
 
    * Reset the navigation stack to a new component (the stack root is changed).
    * @param {Root} root
    */
-  setRoot(params) {
+  public setRoot(params) {
     return this.commands.setRoot(params);
   }
 
    * Set default options to all screens. Useful for declaring a consistent style across the app.
    * @param {options:Options} options
    */
-  setDefaultOptions(options) {
+  public setDefaultOptions(options) {
     this.commands.setDefaultOptions(options);
   }
 
    * @param {string} componentId The component's id.
    * @param {options:Options} options
    */
-  setOptions(componentId, options) {
+  public setOptions(componentId, options) {
     this.commands.setOptions(componentId, options);
   }
 
    * Show a screen as a modal.
    * @param {object} params
    */
-  showModal(params) {
+  public showModal(params) {
     return this.commands.showModal(params);
   }
 
    * Dismiss a modal by componentId. The dismissed modal can be anywhere in the stack.
    * @param {string} componentId The component's id.
    */
-  dismissModal(componentId) {
+  public dismissModal(componentId) {
     return this.commands.dismissModal(componentId);
   }
 
   /**
    * Dismiss all Modals
    */
-  dismissAllModals() {
+  public dismissAllModals() {
     return this.commands.dismissAllModals();
   }
 
    * @param {string} componentId The component's id.
    * @param {Component} component
    */
-  push(componentId, component) {
+  public push(componentId, component) {
     return this.commands.push(componentId, component);
   }
 
    * @param {string} componentId The component's id.
    * @param {*} params
    */
-  pop(componentId, params) {
+  public pop(componentId, params) {
     return this.commands.pop(componentId, params);
   }
 
    * Pop the stack to a given component
    * @param {string} componentId The component's id.
    */
-  popTo(componentId: string) {
+  public popTo(componentId: string) {
     return this.commands.popTo(componentId);
   }
 
    * Pop the component's stack to root.
    * @param {*} componentId
    */
-  popToRoot(componentId: string) {
+  public popToRoot(componentId: string) {
     return this.commands.popToRoot(componentId);
   }
 
    * Show overlay on top of the window
    * @param {*} params
    */
-  showOverlay(params) {
+  public showOverlay(params) {
     return this.commands.showOverlay(params);
   }
 
    * dismiss overlay by componentId
    * @param {string} componentId
    */
-  dismissOverlay(componentId: string) {
+  public dismissOverlay(componentId: string) {
     return this.commands.dismissOverlay(componentId);
   }
 
   /**
    * Obtain the events registry instance
    */
-  events() {
+  public events() {
     return this.publicEventsRegistry;
   }
 }

lib/src/adapters/Element.tsx

   static propTypes = {
     elementId: PropTypes.string.isRequired,
     resizeMode: PropTypes.string
-  }
+  };
+
   static defaultProps = {
     resizeMode: ''
-  }
+  };
 
   render() {
     return (
 }
 
 RNNElement = requireNativeComponent('RNNElement', Element);
-

lib/src/commands/LayoutTreeCrawler.ts

   id?: string;
   type: LayoutType;
   data: object;
-  children: Array<LayoutNode>;
+  children: LayoutNode[];
 }
 
 interface IdProvider {
 }
 
 export class LayoutTreeCrawler {
-  private uniqueIdProvider: IdProvider
-  private store: Store
+  private uniqueIdProvider: IdProvider;
+  private store: Store;
 
   constructor(uniqueIdProvider: IdProvider, store: Store) {
     this.uniqueIdProvider = uniqueIdProvider;
     node.id = this.uniqueIdProvider.generate(node.type);
     node.data = node.data || {};
     node.children = node.children || [];
-    if (node.type == LayoutType.Component) {
+    if (node.type === LayoutType.Component) {
       this._handleComponent(node);
     }
     _.forEach(node.children, this.crawl);

lib/src/commands/LayoutTreeParser.test.ts

   });
 
   it('options for all containing types', () => {
-    const options = {};
     expect(uut.parse({ component: { options } }).data.options).toBe(options);
     expect(uut.parse({ stack: { options } }).data.options).toBe(options);
     expect(uut.parse({ bottomTabs: { options } }).data.options).toBe(options);

lib/src/commands/LayoutTreeParser.ts

     };
   }
 
-  _sideMenuChildren(api): Array<LayoutNode> {
+  _sideMenuChildren(api): LayoutNode[] {
     if (!api.center) {
       throw new Error(`sideMenu.center is required`);
     }
-    const children: Array<LayoutNode> = [];
+    const children: LayoutNode[] = [];
     if (api.left) {
       children.push({
         type: LayoutType.SideMenuLeft,

lib/src/commands/LayoutType.test.ts

 
     const name = 'Stack';
     expect(LayoutType[name]).toEqual(LayoutType.Stack);
-    expect(LayoutType['asdasd']).toEqual(undefined);
+    expect(LayoutType['asdasd']).toEqual(undefined); //tslint:disable-line
   });
 
   it('isLayoutType', () => {

lib/src/commands/LayoutType.ts

   SideMenuLeft = 'SideMenuLeft',
   SideMenuRight = 'SideMenuRight',
   TopTabs = 'TopTabs'
-};
+}
 
 export function isLayoutType(name: string): boolean {
   return !!LayoutType[name];

lib/src/commands/OptionsProcessor.ts

 export class OptionsProcessor {
   static processOptions(options) {
     _.forEach(options, (value, key) => {
-      if (!value) return
+      if (!value) { return; }
 
       if (_.isEqual(key, 'color') || _.endsWith(key, 'Color')) {
         options[key] = processColor(value);

lib/src/components/ComponentRegistry.test.tsx

   it('resulting in a normal component', () => {
     uut.registerComponent('example.MyComponent.name', () => MyComponent);
     const Component = mockRegistry.mock.calls[0][1]();
-    const tree = renderer.create(<Component componentId="123" />);
+    const tree = renderer.create(<Component componentId='123' />);
     expect(tree.toJSON()!.children).toEqual(['Hello, World!']);
   });
 });

lib/src/components/ComponentWrapper.test.tsx

     }
   }
 
-
-
   class TestParent extends React.Component<any, { propsFromState: {} }> {
     private ChildClass;
 
       return (
         <this.ChildClass
           ref={(r) => childRef = r}
-          componentId="component1"
+          componentId='component1'
           {...this.state.propsFromState}
         />
       );

lib/src/components/ComponentWrapper.tsx

 import * as  _ from 'lodash';
 
 interface State {
-  componentId: string,
-  allProps: {}
+  componentId: string;
+  allProps: {};
 }
 
 export class ComponentWrapper {
           />
         );
       }
-    };
+    }
 
     return WrappedComponent;
   }

lib/src/components/Store.test.ts

     expect(uut.getPropsForComponentId('refUniqueId')).toEqual({});
   });
 });
-

lib/src/events/PrivateEventsListener.ts

     this.lifecycle = new Lifecycle(store);
   }
 
-  listenAndHandlePrivateEvents() {
+  public listenAndHandlePrivateEvents() {
     this.nativeEventsReceiver.registerComponentDidAppear(this.lifecycle.componentDidAppear);
     this.nativeEventsReceiver.registerComponentDidDisappear(this.lifecycle.componentDidDisappear);
     this.nativeEventsReceiver.registerNavigationButtonPressed(this.lifecycle.onNavigationButtonPressed);

lib/src/events/PublicEventsRegistry.ts

     this.nativeEventsReceiver = nativeEventsReceiver;
   }
 
-  onAppLaunched(callback) {
+  public onAppLaunched(callback) {
     this.nativeEventsReceiver.registerAppLaunched(callback);
   }
 
-  navigationCommands(callback) {
+  public navigationCommands(callback) {
     this.nativeEventsReceiver.registerNavigationCommands(callback);
   }
 
-  componentLifecycle(callback) {
+  public componentLifecycle(callback) {
     this.nativeEventsReceiver.registerComponentLifecycle(callback);
   }
 }

lib/src/index.ts

-import { singleton } from "./Navigation";
+import { singleton } from './Navigation';
 
 export const Navigation = singleton;

package.json

   "dependencies": {
     "lodash": "4.x.x",
     "prop-types": "15.x.x",
-    "tslib": "1.x.x"
+    "tslib": "1.x.x",
+    "@types/react": "16.x.x",
+    "@types/react-native": "0.49.x",
+    "@types/lodash": "4.x.x",
+    "@types/prop-types": "15.x.x",
+    "@types/react-test-renderer": "16.x.x",
+    "@types/jest": "22.x.x"
   },
   "devDependencies": {
     "detox": "6.x.x",
-    "eslint-config-xo": "0.18.x",
-    "eslint-config-xo-react": "0.13.x",
-    "eslint-plugin-react": "7.x.x",
     "jest": "22.x.x",
     "mocha": "4.x.x",
     "react": "16.0.0-beta.5",
     "remx": "2.x.x",
     "semver": "5.x.x",
     "shell-utils": "1.x.x",
-    "xo": "0.18.x",
-    "typescript": "2.x.x",
-    "@types/react": "16.x.x",
-    "@types/react-native": "0.49.x",
-    "@types/lodash": "4.x.x",
-    "@types/prop-types": "15.x.x",
-    "@types/react-test-renderer": "16.x.x",
-    "@types/jest": "22.x.x"
+    "tslint": "5.x.x",
+    "typescript": "2.x.x"
   },
   "babel": {
     "env": {
         "name": "iPhone SE"
       }
     }
-  },
-  "xo": {
-    "extends": "xo-react",
-    "space": true,
-    "env": [
-      "node",
-      "jest",
-      "es6"
-    ],
-    "globals": [
-      "alert"
-    ],
-    "overrides": [
-      {
-        "files": "e2e/**/*",
-        "env": [
-          "mocha"
-        ],
-        "globals": [
-          "before",
-          "after",
-          "beforeEach",
-          "afterEach",
-          "expect",
-          "element",
-          "by",
-          "device"
-        ]
-      }
-    ],
-    "settings": {
-      "import/core-modules": [
-        "react-native-navigation"
-      ]
-    },
-    "rules": {
-      "unicorn/filename-case": 0,
-      "unicorn/number-literal-case": 0,
-      "import/order": 0,
-      "import/named": 0,
-      "import/no-unassigned-import": 0,
-      "import/prefer-default-export": 0,
-      "import/no-unresolved": [
-        2,
-        {
-          "ignore": [
-            "react-native-navigation"
-          ]
-        }
-      ],
-      "react/jsx-tag-spacing": 0,
-      "react/jsx-sort-props": 0,
-      "react/jsx-boolean-value": 0,
-      "react/prop-types": 0,
-      "react/jsx-no-bind": 0,
-      "react/jsx-handler-names": 0,
-      "react/forbid-component-props": 0,
-      "react/jsx-curly-brace-presence": 0,
-      "capitalized-comments": 0,
-      "no-use-before-define": [
-        2,
-        {
-          "functions": false,
-          "variables": false
-        }
-      ],
-      "promise/param-names": 0,
-      "no-return-assign": 0,
-      "arrow-parens": [
-        2,
-        "always"
-      ],
-      "object-curly-spacing": [
-        2,
-        "always"
-      ]
-    }
   }
 }

scripts/release.js

-/* eslint-disable no-console */
+/* tslint:disable: no-console */
 const exec = require('shell-utils').exec;
 const semver = require('semver');
 const fs = require('fs');

scripts/test-js.js

 const fix = _.includes(process.argv, '--fix') ? '--fix' : '';
 
 const dirs = [
-  'lib/dist',
+  'lib/src',
   'integration',
   'e2e',
   'scripts',
 run();
 
 function run() {
-  const paths = _.chain(dirs).map((d) => `'${d}/**'`).join(' ').value();
-  exec.execSync(`xo ${paths} ${fix}`);
+  const paths = _.chain(dirs).map((d) => `'${d}/**/*.[tj]s*'`).join(' ').value();
+  exec.execSync(`tslint ${paths} ${fix} --format verbose`);
   exec.execSync(`jest --coverage`);
 }

scripts/test.all.js

-/* eslint-disable no-console */
+/* tslint:disable: no-console */
 const exec = require('shell-utils').exec;
 
 async function run() {

scripts/test.e2e.android.js

-/* eslint-disable no-console */
+/* tslint:disable: no-console */
 const _ = require('lodash');
 const exec = require('shell-utils').exec;
 

tsconfig-strict.json

     "strictFunctionTypes": true,
     "strictNullChecks": true,
     "strict": true,
-    "noImplicitAny": true
+    "noImplicitAny": false
   }
 }

tslint.json

+{
+  "defaultSeverity": "error",
+  "extends": [
+    "tslint:recommended"
+  ],
+  "jsRules": {
+    "quotemark": [
+      true,
+      "single"
+    ],
+    "max-line-length": [
+      true,
+      180
+    ],
+    "ordered-imports": false,
+    "trailing-comma": [
+      true,
+      "never"
+    ],
+    "member-access": false,
+    "interface-name": false,
+    "object-literal-sort-keys": false,
+    "max-classes-per-file": false
+  },
+  "rules": {
+    "quotemark": [
+      true,
+      "single"
+    ],
+    "max-line-length": [
+      true,
+      180
+    ],
+    "ordered-imports": false,
+    "trailing-comma": [
+      true,
+      "never"
+    ],
+    "member-access": false,
+    "interface-name": false,
+    "object-literal-sort-keys": false,
+    "max-classes-per-file": false
+  },
+  "rulesDirectory": []
+}