constants initialized lazily, js testing support

integration/redux/Redux.test.js

 require('react-native');
 const renderer = require('react-test-renderer');
 const { Provider } = require('react-redux');
+const { Navigation } = require('../../lib/dist/index');
 
 describe('redux support', () => {
   let MyConnectedComponent;
   });
 
   it('renders normally', () => {
-    const tree = renderer.create(
-      <Provider store={store.reduxStore}>
-        <MyConnectedComponent />
-      </Provider>
-    );
+    const HOC = class extends React.Component {
+      render() {
+        return (
+          <Provider store={store.reduxStore}>
+            <MyConnectedComponent />
+          </Provider>
+        );
+      }
+    };
+    Navigation.registerComponent('ComponentName', () => HOC);
+
+    const tree = renderer.create(<HOC />);
     expect(tree.toJSON().children).toEqual(['no name']);
   });
 

lib/src/Navigation.ts

 import { Element } from './adapters/Element';
 import { ComponentEventsObserver } from './events/ComponentEventsObserver';
 import { CommandsObserver } from './events/CommandsObserver';
-import { Constants } from './constants/Constants';
-import { NativeModules } from 'react-native';
-
-const NavigationModule = NativeModules.RNNBridgeModule;
+import { Constants } from './adapters/Constants';
 
 export class Navigation {
   public readonly Element: React.ComponentType<{ elementId: any; resizeMode: any; }>;
-  public readonly constants = new Constants(NavigationModule);
-
-  private readonly store;
-  private readonly nativeEventsReceiver;
-  private readonly uniqueIdProvider;
-  private readonly componentRegistry;
-  private readonly layoutTreeParser;
-  private readonly layoutTreeCrawler;
-  private readonly nativeCommandsSender;
-  private readonly commands;
-  private readonly eventsRegistry;
-  private readonly commandsObserver;
-  private readonly componentEventsObserver;
+  public readonly store: Store;
+  private readonly nativeEventsReceiver: NativeEventsReceiver;
+  private readonly uniqueIdProvider: UniqueIdProvider;
+  private readonly componentRegistry: ComponentRegistry;
+  private readonly layoutTreeParser: LayoutTreeParser;
+  private readonly layoutTreeCrawler: LayoutTreeCrawler;
+  private readonly nativeCommandsSender: NativeCommandsSender;
+  private readonly commands: Commands;
+  private readonly eventsRegistry: EventsRegistry;
+  private readonly commandsObserver: CommandsObserver;
+  private readonly componentEventsObserver: ComponentEventsObserver;
 
   constructor() {
     this.Element = Element;
-
     this.store = new Store();
     this.nativeEventsReceiver = new NativeEventsReceiver();
     this.uniqueIdProvider = new UniqueIdProvider();
    * Every navigation component in your app must be registered with a unique name.
    * The component itself is a traditional React component extending React.Component.
    */
-  public registerComponent(componentName: string, getComponentClassFunc: ComponentProvider): React.ComponentType<any> {
-    return this.componentRegistry.registerComponent(componentName, getComponentClassFunc);
+  public registerComponent(componentName: string, getComponentClassFunc: ComponentProvider): void {
+    this.componentRegistry.registerComponent(componentName, getComponentClassFunc);
   }
 
   /**
   public events(): EventsRegistry {
     return this.eventsRegistry;
   }
+
+  /**
+   * Constants coming from native
+   */
+  public constants(): Constants {
+    return Constants.get();
+  }
 }

lib/src/adapters/Constants.ts

+import { NativeModules } from 'react-native';
+
+export class Constants {
+  static get(): Constants {
+    if (!this.instance) {
+      this.instance = new Constants();
+    }
+    return this.instance;
+  }
+
+  private static instance: Constants;
+
+  public readonly statusBarHeight: number;
+  public readonly backButtonId: string;
+
+  private constructor() {
+    const m = NativeModules.RNNBridgeModule;
+    this.statusBarHeight = m.statusBarHeight;
+    this.backButtonId = m.backButtonId;
+  }
+}

lib/src/adapters/NativeCommandsSender.ts

 import { NativeModules } from 'react-native';
 
 export class NativeCommandsSender {
-  private nativeCommandsModule;
+  private readonly nativeCommandsModule;
   constructor() {
     this.nativeCommandsModule = NativeModules.RNNBridgeModule;
   }

lib/src/adapters/NativeEventsReceiver.ts

+// tslint:disable:no-console
 import { NativeModules, NativeEventEmitter } from 'react-native';
 import { EventSubscription } from '../interfaces/EventSubscription';
 
 export class NativeEventsReceiver {
-  private emitter: NativeEventEmitter;
+  private emitter;
   constructor() {
-    this.emitter = new NativeEventEmitter(NativeModules.RNNEventEmitter);
+    if (NativeModules.RNNEventEmitter) {
+      this.emitter = new NativeEventEmitter(NativeModules.RNNEventEmitter);
+    } else {
+      console.log('Using mock NativeEventEmitter module');
+      this.emitter = {
+        addListener: () => {
+          return {
+            remove: () => undefined
+          };
+        }
+      };
+    }
   }
 
   public registerAppLaunchedListener(callback: () => void): EventSubscription {

lib/src/constants/Constants.test.ts

-import { Constants } from './Constants';
-
-const NavigationModule = {
-  backButton: 'RNN.back',
-  statusBarHeight: 63
-};
-
-describe('Constants', () => {
-  let uut: Constants;
-
-  beforeEach(() => {
-    uut = new Constants(NavigationModule);
-  });
-
-  it('backButton', () => {
-    expect(uut.backButton).toEqual(NavigationModule.backButton);
-  });
-
-  it('statusBarHeight', () => {
-    expect(uut.statusBarHeight).toEqual(NavigationModule.statusBarHeight);
-  });
-});

lib/src/constants/Constants.ts

-export class Constants {
-  public readonly backButton;
-  public readonly statusBarHeight;
-
-  constructor(navigationModule) {
-    this.backButton = navigationModule.backButton;
-    this.statusBarHeight = navigationModule.statusBarHeight;
-  }
-}