import export to ModuleJS

lib/src/Navigation.js

-import NativeCommandsSender from './adapters/NativeCommandsSender';
-import NativeEventsReceiver from './adapters/NativeEventsReceiver';
-import UniqueIdProvider from './adapters/UniqueIdProvider';
-
-import Store from './containers/Store';
-import ContainerRegistry from './containers/ContainerRegistry';
-import Commands from './commands/Commands';
-import LayoutTreeParser from './commands/LayoutTreeParser';
-import LayoutTreeCrawler from './commands/LayoutTreeCrawler';
-import PrivateEventsListener from './events/PrivateEventsListener';
-import PublicEventsRegistry from './events/PublicEventsRegistry';
+const NativeCommandsSender = require('./adapters/NativeCommandsSender');
+const NativeEventsReceiver = require('./adapters/NativeEventsReceiver');
+const UniqueIdProvider = require('./adapters/UniqueIdProvider');
+const Store = require('./containers/Store');
+const ContainerRegistry = require('./containers/ContainerRegistry');
+const Commands = require('./commands/Commands');
+const LayoutTreeParser = require('./commands/LayoutTreeParser');
+const LayoutTreeCrawler = require('./commands/LayoutTreeCrawler');
+const PrivateEventsListener = require('./events/PrivateEventsListener');
+const PublicEventsRegistry = require('./events/PublicEventsRegistry');
 
 class Navigation {
   constructor() {
 }
 
 const singleton = new Navigation();
-export default singleton;
+module.exports = singleton;

lib/src/adapters/NativeCommandsSender.js

-import { NativeModules } from 'react-native';
+const { NativeModules } = require('react-native');
 
-export default class NativeCommandsSender {
+class NativeCommandsSender {
   constructor() {
     this.nativeCommandsModule = NativeModules.RNNBridgeModule;
   }
   }
 }
 
+module.exports = NativeCommandsSender;

lib/src/adapters/NativeCommandsSender.mock.js

-export default jest.genMockFromModule('./NativeCommandsSender').default;
+module.exports = jest.genMockFromModule('./NativeCommandsSender');

lib/src/adapters/NativeEventsReceiver.js

-import { NativeModules, NativeEventEmitter } from 'react-native';
+const { NativeModules, NativeEventEmitter } = require('react-native');
 
-export default class NativeEventsReceiver {
+class NativeEventsReceiver {
   constructor() {
     this.emitter = new NativeEventEmitter(NativeModules.RNNEventEmitter);
   }
     this.emitter.addListener('RNN.appLaunched', callback);
   }
 }
+
+module.exports = NativeEventsReceiver;

lib/src/adapters/NativeEventsReceiver.mock.js

-export default jest.genMockFromModule('./NativeEventsReceiver').default;
+module.exports = jest.genMockFromModule('./NativeEventsReceiver');

lib/src/adapters/UniqueIdProvider.js

-import _ from 'lodash';
+const _ = require('lodash');
 
-export default class UniqueIdProvider {
+class UniqueIdProvider {
   generate(prefix) {
     return _.uniqueId(prefix);
   }
 }
+
+module.exports = UniqueIdProvider;

lib/src/adapters/UniqueIdProvider.mock.js

-export default class UniqueIdProvider {
+class UniqueIdProvider {
   generate(prefix) {
     return `${prefix}+UNIQUE_ID`;
   }
 }
 
+module.exports = UniqueIdProvider;

lib/src/commands/Commands.js

-import _ from 'lodash';
-import optionsProcessor from './OptionsProcessor';
+const _ = require('lodash');
+const OptionsProcessor = require('./OptionsProcessor');
 
-export default class Commands {
+class Commands {
   constructor(nativeCommandsSender, layoutTreeParser, layoutTreeCrawler) {
     this.nativeCommandsSender = nativeCommandsSender;
     this.layoutTreeParser = layoutTreeParser;
 
   setOptions(containerId, options) {
     const input = _.cloneDeep(options);
-    optionsProcessor(input);
+    OptionsProcessor.processOptions(input);
     this.nativeCommandsSender.setOptions(containerId, input);
   }
 
   }
 }
 
+module.exports = Commands;

lib/src/commands/Commands.test.js

-import * as SimpleLayouts from './SimpleLayouts';
-import LayoutTreeParser from './LayoutTreeParser';
-import LayoutTreeCrawler from './LayoutTreeCrawler';
-import Store from '../containers/Store';
-import UniqueIdProvider from '../adapters/UniqueIdProvider.mock';
-import NativeCommandsSender from '../adapters/NativeCommandsSender.mock';
-
-import Commands from './Commands';
+const SimpleLayouts = require('./SimpleLayouts');
+const LayoutTreeParser = require('./LayoutTreeParser');
+const LayoutTreeCrawler = require('./LayoutTreeCrawler');
+const Store = require('../containers/Store');
+const UniqueIdProvider = require('../adapters/UniqueIdProvider.mock');
+const NativeCommandsSender = require('../adapters/NativeCommandsSender.mock');
+const Commands = require('./Commands');
 
 describe('Commands', () => {
   let uut;

lib/src/commands/LayoutTreeCrawler.js

-import _ from 'lodash';
-import LayoutTypes from './LayoutTypes';
-import optionsProcessor from './OptionsProcessor';
+const _ = require('lodash');
+const LayoutTypes = require('./LayoutTypes');
+const OptionsProcessor = require('./OptionsProcessor');
 
-export default class LayoutTreeCrawler {
+class LayoutTreeCrawler {
   constructor(uniqueIdProvider, store) {
     this.uniqueIdProvider = uniqueIdProvider;
     this.store = store;
     this.store.setPropsForContainerId(node.id, node.data.passProps);
     const clazz = this.store.getOriginalContainerClassForName(node.data.name);
     node.data.navigationOptions = _.cloneDeep(_.get(clazz, 'navigationOptions', {}));
-    optionsProcessor(node.data.navigationOptions);
+    OptionsProcessor.processOptions(node.data.navigationOptions);
   }
 
   _assertKnownLayoutType(type) {
     }
   }
 }
+
+module.exports = LayoutTreeCrawler;

lib/src/commands/LayoutTreeCrawler.test.js

-import LayoutTypes from './LayoutTypes';
-import LayoutTreeCrawler from './LayoutTreeCrawler';
-import Store from '../containers/Store';
-import UniqueIdProvider from '../adapters/UniqueIdProvider.mock';
+const LayoutTypes = require('./LayoutTypes');
+const LayoutTreeCrawler = require('./LayoutTreeCrawler');
+const Store = require('../containers/Store');
+const UniqueIdProvider = require('../adapters/UniqueIdProvider.mock');
 
 describe('LayoutTreeCrawler', () => {
   let uut;

lib/src/commands/LayoutTreeParser.js

-import * as _ from 'lodash';
-import LayoutTypes from './LayoutTypes';
+const _ = require('lodash');
+const LayoutTypes = require('./LayoutTypes');
 
-export default class LayoutTreeParser {
+class LayoutTreeParser {
   /**
    * returns correct layout tree of {type, children, data?}
    */
     return children;
   }
 }
+
+module.exports = LayoutTreeParser;

lib/src/commands/LayoutTreeParser.test.js

-import * as SimpleLayouts from './SimpleLayouts';
-import LayoutTreeParser from './LayoutTreeParser';
+const SimpleLayouts = require('./SimpleLayouts');
+const LayoutTreeParser = require('./LayoutTreeParser');
 
 describe('LayoutTreeParser', () => {
   let uut;

lib/src/commands/LayoutTypes.js

-export default {
+module.exports = {
   Container: 'Container',
   ContainerStack: 'ContainerStack',
   BottomTabs: 'BottomTabs',

lib/src/commands/OptionsProcessor.js

-import _ from 'lodash';
-import { processColor } from 'react-native';
+const _ = require('lodash');
+const { processColor } = require('react-native');
 
-export default function optionsProcessor(navigationOptions) {
-  _.forEach(navigationOptions, (value, key) => {
-    if (_.endsWith(key, 'Color')) {
-      navigationOptions[key] = processColor(value);
-    }
-    if (_.isPlainObject(value)) {
-      optionsProcessor(value);
-    }
-  });
+class OptionsProcessor {
+  static processOptions(navigationOptions) {
+    _.forEach(navigationOptions, (value, key) => {
+      if (_.endsWith(key, 'Color')) {
+        navigationOptions[key] = processColor(value);
+      }
+      if (_.isPlainObject(value)) {
+        OptionsProcessor.processOptions(value);
+      }
+    });
+  }
 }
+
+module.exports = OptionsProcessor;

lib/src/commands/OptionsProcessor.test.js

-import optionsProcessor from './OptionsProcessor';
+const OptionsProcessor = require('./OptionsProcessor');
 
 describe('navigation options', () => {
   let navigationOptions;
 
   it('processes colors into numeric AARRGGBB', () => {
     navigationOptions.someKeyColor = 'red';
-    optionsProcessor(navigationOptions);
+    OptionsProcessor.processOptions(navigationOptions);
     expect(navigationOptions.someKeyColor).toEqual(0xffff0000);
 
     navigationOptions.someKeyColor = 'yellow';
-    optionsProcessor(navigationOptions);
+    OptionsProcessor.processOptions(navigationOptions);
     expect(navigationOptions.someKeyColor).toEqual(0xffffff00);
   });
 
   it('processes numeric colors', () => {
     navigationOptions.someKeyColor = '#123456';
-    optionsProcessor(navigationOptions);
+    OptionsProcessor.processOptions(navigationOptions);
     expect(navigationOptions.someKeyColor).toEqual(0xff123456);
 
     navigationOptions.someKeyColor = 0x123456ff; // wut
-    optionsProcessor(navigationOptions);
+    OptionsProcessor.processOptions(navigationOptions);
     expect(navigationOptions.someKeyColor).toEqual(0xff123456);
   });
 
   it('process colors with rgb functions', () => {
     navigationOptions.someKeyColor = 'rgb(255, 0, 255)';
-    optionsProcessor(navigationOptions);
+    OptionsProcessor.processOptions(navigationOptions);
     expect(navigationOptions.someKeyColor).toEqual(0xffff00ff);
   });
 
   it('process colors with special words', () => {
     navigationOptions.someKeyColor = 'fuchsia';
-    optionsProcessor(navigationOptions);
+    OptionsProcessor.processOptions(navigationOptions);
     expect(navigationOptions.someKeyColor).toEqual(0xffff00ff);
   });
 
   it('process colors with hsla functions', () => {
     navigationOptions.someKeyColor = 'hsla(360, 100%, 100%, 1.0)';
-    optionsProcessor(navigationOptions);
+    OptionsProcessor.processOptions(navigationOptions);
 
     expect(navigationOptions.someKeyColor).toEqual(0xffffffff);
   });
 
   it('unknown colors return undefined', () => {
     navigationOptions.someKeyColor = 'wut';
-    optionsProcessor(navigationOptions);
+    OptionsProcessor.processOptions(navigationOptions);
     expect(navigationOptions.someKeyColor).toEqual(undefined);
   });
 
     navigationOptions.otherKeyColor = 'red';
     navigationOptions.yetAnotherColor = 'blue';
     navigationOptions.andAnotherColor = 'rgb(0, 255, 0)';
-    optionsProcessor(navigationOptions);
+    OptionsProcessor.processOptions(navigationOptions);
     expect(navigationOptions.otherKeyColor).toEqual(0xffff0000);
     expect(navigationOptions.yetAnotherColor).toEqual(0xff0000ff);
     expect(navigationOptions.andAnotherColor).toEqual(0xff00ff00);
 
   it('keys ending with Color case sensitive', () => {
     navigationOptions.otherKey_color = 'red'; // eslint-disable-line camelcase
-    optionsProcessor(navigationOptions);
+    OptionsProcessor.processOptions(navigationOptions);
     expect(navigationOptions.otherKey_color).toEqual('red');
   });
 
   it('any nested recursive keys ending with Color', () => {
     navigationOptions.innerObj = { theKeyColor: 'red' };
     navigationOptions.innerObj.innerMostObj = { anotherColor: 'yellow' };
-    optionsProcessor(navigationOptions);
+    OptionsProcessor.processOptions(navigationOptions);
     expect(navigationOptions.innerObj.theKeyColor).toEqual(0xffff0000);
     expect(navigationOptions.innerObj.innerMostObj.anotherColor).toEqual(0xffffff00);
   });

lib/src/commands/SimpleLayouts.js

-export const singleScreenApp = {
+const singleScreenApp = {
   container: {
     name: 'com.example.MyScreen'
   }
 };
 
-export const passProps = {
+const passProps = {
   strProp: 'string prop',
   numProp: 12345,
   objProp: { inner: { foo: 'bar' } },
   fnProp: () => 'Hello from a function'
 };
 
-export const singleScreenWithAditionalParams = {
+const singleScreenWithAditionalParams = {
   container: {
     name: 'com.example.MyScreen',
     passProps,
   }
 };
 
-export const tabBasedApp = {
+const tabBasedApp = {
   bottomTabs: [
     {
       container: {
   ]
 };
 
-export const singleWithSideMenu = {
+const singleWithSideMenu = {
   container: {
     name: 'com.example.MyScreen'
   },
   }
 };
 
-export const singleWithRightSideMenu = {
+const singleWithRightSideMenu = {
   container: {
     name: 'com.example.MyScreen'
   },
   }
 };
 
-export const singleWithBothMenus = {
+const singleWithBothMenus = {
   container: {
     name: 'com.example.MyScreen'
   },
   }
 };
 
-export const tabBasedWithBothSideMenus = {
+const tabBasedWithBothSideMenus = {
   bottomTabs: [
     {
       container: {
     }
   }
 };
+
+module.exports = {
+  singleScreenApp,
+  passProps,
+  singleScreenWithAditionalParams,
+  tabBasedApp,
+  singleWithSideMenu,
+  singleWithRightSideMenu,
+  singleWithBothMenus,
+  tabBasedWithBothSideMenus
+};

lib/src/containers/ContainerRegistry.js

-import { AppRegistry } from 'react-native';
-import ContainerWrapper from './ContainerWrapper';
+const { AppRegistry } = require('react-native');
+const ContainerWrapper = require('./ContainerWrapper');
 
-export default class ContainerRegistry {
+class ContainerRegistry {
   constructor(store) {
     this.store = store;
   }
     AppRegistry.registerComponent(containerName, () => NavigationContainer);
   }
 }
+
+module.exports = ContainerRegistry;

lib/src/containers/ContainerRegistry.test.js

-import React, { Component } from 'react';
-import { AppRegistry, Text } from 'react-native';
-import renderer from 'react-test-renderer';
+const React = require('react');
+const { Component } = require('react');
+const { AppRegistry, Text } = require('react-native');
 
-import ContainerRegistry from './ContainerRegistry';
-import Store from './Store';
+const renderer = require('react-test-renderer');
+const ContainerRegistry = require('./ContainerRegistry');
+const Store = require('./Store');
 
 describe('ContainerRegistry', () => {
   let uut;

lib/src/containers/ContainerWrapper.js

-import _ from 'lodash';
-import React, { Component } from 'react';
+const _ = require('lodash');
 
-export default class ContainerWrapper {
+const React = require('react');
+const { Component } = require('react');
+
+class ContainerWrapper {
   static wrap(containerName, OriginalContainer, store) {
     return class extends Component {
       constructor(props) {
     };
   }
 }
+
+module.exports = ContainerWrapper;

lib/src/containers/ContainerWrapper.test.js

-/* eslint-disable consistent-this, react/no-multi-comp */
-import React, { Component } from 'react';
-import { Text } from 'react-native';
-import renderer from 'react-test-renderer';
+const React = require('react');
+const { Component } = require('react');
 
-import ContainerWrapper from './ContainerWrapper';
-import Store from './Store';
+const { Text } = require('react-native');
+const renderer = require('react-test-renderer');
+const ContainerWrapper = require('./ContainerWrapper');
+const Store = require('./Store');
 
 describe('ContainerWrapper', () => {
   let store;

lib/src/containers/Lifecycle.js

-export default class Lifecycle {
+class Lifecycle {
   constructor(store) {
     this.store = store;
     this.containerStart = this.containerStart.bind(this);
     }
   }
 }
+
+module.exports = Lifecycle;

lib/src/containers/Lifecycle.test.js

-import Lifecycle from './Lifecycle';
-import Store from '../containers/Store';
+const Lifecycle = require('./Lifecycle');
+const Store = require('../containers/Store');
 
 describe('Lifecycle', () => {
   let store;

lib/src/containers/Store.js

-import _ from 'lodash';
+const _ = require('lodash');
 
-export default class Store {
+class Store {
   constructor() {
     this.propsByContainerId = {};
     this.containersByName = {};
     _.unset(this.propsByContainerId, id);
   }
 }
+
+module.exports = Store;

lib/src/containers/Store.test.js

-import Store from './Store';
+const Store = require('./Store');
 
 describe('Store', () => {
   let uut;

lib/src/events/PrivateEventsListener.js

-import Lifecycle from '../containers/Lifecycle';
+const Lifecycle = require('../containers/Lifecycle');
 
-export default class PrivateEventsListener {
+class PrivateEventsListener {
   constructor(nativeEventsReceiver, store) {
     this.nativeEventsReceiver = nativeEventsReceiver;
     this.lifecycle = new Lifecycle(store);
     this.nativeEventsReceiver.containerStop(this.lifecycle.containerStop);
   }
 }
+
+module.exports = PrivateEventsListener;

lib/src/events/PrivateEventsListener.test.js

-import PrivateEventsListener from './PrivateEventsListener';
-import NativeEventsReceiver from '../adapters/NativeEventsReceiver.mock';
-import Store from '../containers/Store';
+const PrivateEventsListener = require('./PrivateEventsListener');
+const NativeEventsReceiver = require('../adapters/NativeEventsReceiver.mock');
+const Store = require('../containers/Store');
 
 describe('PrivateEventsListener', () => {
   let uut;

lib/src/events/PublicEventsRegistry.js

-export default class PublicEventsRegistry {
+class PublicEventsRegistry {
   constructor(nativeEventsReceiver) {
     this.nativeEventsReceiver = nativeEventsReceiver;
   }
     this.nativeEventsReceiver.appLaunched(callback);
   }
 }
+
+module.exports = PublicEventsRegistry;

lib/src/events/PublicEventsRegistry.test.js

-import PublicEventsRegistry from './PublicEventsRegistry';
-import NativeEventsReceiver from '../adapters/NativeEventsReceiver.mock';
+const PublicEventsRegistry = require('./PublicEventsRegistry');
+const NativeEventsReceiver = require('../adapters/NativeEventsReceiver.mock');
 
 describe('PublicEventsRegistry', () => {
   let uut;

lib/src/index.js

-import Navigation from './Navigation';
+const Navigation = require('./Navigation');
 
 module.exports = Navigation;
 module.exports.default = Navigation;