remove privateEvents, rename appLaunched, rename componentId to id

lib/src/Navigation.ts

 import { Commands } from './commands/Commands';
 import { LayoutTreeParser } from './commands/LayoutTreeParser';
 import { LayoutTreeCrawler } from './commands/LayoutTreeCrawler';
-import { PublicEventsRegistry } from './events/PublicEventsRegistry';
+import { EventsRegistry } from './events/EventsRegistry';
 import { ComponentProvider } from 'react-native';
 import { Element } from './adapters/Element';
-import { PrivateEventsListener } from './events/PrivateEventsListener';
 
 export class Navigation {
   public readonly Element;
     this.layoutTreeCrawler = new LayoutTreeCrawler(this.uniqueIdProvider, this.store);
     this.nativeCommandsSender = new NativeCommandsSender();
     this.commands = new Commands(this.nativeCommandsSender, this.layoutTreeParser, this.layoutTreeCrawler);
-    this.publicEventsRegistry = new PublicEventsRegistry(this.nativeEventsReceiver);
-
-    new PrivateEventsListener(this.nativeEventsReceiver, this.store).listenAndHandlePrivateEvents();
+    this.publicEventsRegistry = new EventsRegistry(this.nativeEventsReceiver);
   }
 
   /**
   /**
    * Obtain the events registry instance
    */
-  public events(): PublicEventsRegistry {
+  public events(): EventsRegistry {
     return this.publicEventsRegistry;
   }
 }

lib/src/adapters/NativeCommandsSender.ts

 
 export class NativeCommandsSender {
   private nativeCommandsModule;
-
   constructor() {
     this.nativeCommandsModule = NativeModules.RNNBridgeModule;
   }
   }
 
   setDefaultOptions(options: object) {
-    this.nativeCommandsModule.setDefaultOptions(options);
+    return this.nativeCommandsModule.setDefaultOptions(options);
   }
 
   setOptions(componentId: string, options: object) {
-    this.nativeCommandsModule.setOptions(componentId, options);
+    return this.nativeCommandsModule.setOptions(componentId, options);
   }
 
-  async push(onComponentId: string, layout: object) {
-    const pushedComponentId = await this.nativeCommandsModule.push(onComponentId, layout);
-    return pushedComponentId;
+  push(onComponentId: string, layout: object) {
+    return this.nativeCommandsModule.push(onComponentId, layout);
   }
 
   pop(componentId: string, options: object) {
     return this.nativeCommandsModule.popToRoot(componentId);
   }
 
-  async showModal(layout: object) {
-    const completed = await this.nativeCommandsModule.showModal(layout);
-    return completed;
+  showModal(layout: object) {
+    return this.nativeCommandsModule.showModal(layout);
   }
 
   dismissModal(componentId: string) {

lib/src/adapters/NativeEventsReceiver.ts

-import { NativeModules, NativeEventEmitter } from 'react-native';
+import { NativeModules, NativeEventEmitter, EmitterSubscription } from 'react-native';
 
 export class NativeEventsReceiver {
-  private emitter;
-
+  private emitter: NativeEventEmitter;
   constructor() {
     this.emitter = new NativeEventEmitter(NativeModules.RNNEventEmitter);
   }
 
-  registerComponentDidAppear(callback) {
-    this.emitter.addListener('RNN.componentDidAppear', callback);
+  registerAppLaunched(callback): EmitterSubscription {
+    return this.emitter.addListener('RNN.appLaunched', callback);
   }
 
-  registerComponentDidDisappear(callback) {
-    this.emitter.addListener('RNN.componentDidDisappear', callback);
+  registerComponentDidAppear(callback): EmitterSubscription {
+    return this.emitter.addListener('RNN.componentDidAppear', callback);
   }
 
-  registerAppLaunched(callback) {
-    this.emitter.addListener('RNN.appLaunched', callback);
+  registerComponentDidDisappear(callback): EmitterSubscription {
+    return this.emitter.addListener('RNN.componentDidDisappear', callback);
   }
 
-  registerNavigationButtonPressed(callback) {
-    this.emitter.addListener('RNN.navigationButtonPressed', callback);
+  registerInteraction(callback): EmitterSubscription {
+    return this.emitter.addListener('RNN.interaction', callback);
   }
 }

lib/src/commands/OptionsProcessor.ts

   static processArrayOptions(key, array, store) {
     _.forEach(array, (value) => {
       if (_.endsWith(key, 'Buttons') && value.passProps) {
-        store.setPropsForComponentId(value.id, value.passProps);
+        store.setPropsForId(value.id, value.passProps);
       }
     });
   }

lib/src/components/ComponentWrapper.tsx

         this._assertComponentId(props);
         this.state = {
           componentId: props.componentId,
-          allProps: _.merge({}, props, store.getPropsForComponentId(props.componentId))
+          allProps: _.merge({}, props, store.getPropsForId(props.componentId))
         };
       }
 
       }
 
       componentWillMount() {
-        store.setRefForComponentId(this.state.componentId, this);
+        store.setRefForId(this.state.componentId, this);
       }
 
       componentWillUnmount() {
 
       componentWillReceiveProps(nextProps) {
         this.setState({
-          allProps: _.merge({}, nextProps, store.getPropsForComponentId(this.state.componentId))
+          allProps: _.merge({}, nextProps, store.getPropsForId(this.state.componentId))
         });
       }
 

lib/src/components/Lifecycle.test.ts

-import { Lifecycle } from './Lifecycle';
-import { Store } from '../components/Store';
-
-describe('Lifecycle', () => {
-  let store;
-  let uut;
-  let mockRef;
-
-  beforeEach(() => {
-    mockRef = {
-      didAppear: jest.fn(),
-      didDisappear: jest.fn(),
-      onNavigationButtonPressed: jest.fn()
-    };
-    store = new Store();
-    store.setRefForComponentId('myUniqueId', mockRef);
-
-    uut = new Lifecycle(store);
-  });
-
-  describe('componentDidAppear', () => {
-    it('calls didAppear on component ref from store', () => {
-      uut.componentDidAppear('myUniqueId');
-      expect(mockRef.didAppear).toHaveBeenCalledTimes(1);
-    });
-
-    it('skips undefined refs', () => {
-      uut.componentDidAppear('myUniqueId2');
-      expect(mockRef.didAppear).not.toHaveBeenCalled();
-    });
-
-    it('skips unimplemented didAppear', () => {
-      mockRef = {};
-      expect(mockRef.didAppear).toBeUndefined();
-      store.setRefForComponentId('myUniqueId', mockRef);
-      uut.componentDidAppear('myUniqueId');
-    });
-  });
-
-  describe('componentDidDisappear', () => {
-    it('calls didDisappear on component ref from store', () => {
-      uut.componentDidDisappear('myUniqueId');
-      expect(mockRef.didDisappear).toHaveBeenCalledTimes(1);
-    });
-
-    it('skips undefined refs', () => {
-      uut.componentDidDisappear('myUniqueId2');
-      expect(mockRef.didDisappear).not.toHaveBeenCalled();
-    });
-
-    it('skips unimplemented didDisappear', () => {
-      mockRef = {};
-      expect(mockRef.didDisappear).toBeUndefined();
-      store.setRefForComponentId('myUniqueId', mockRef);
-      uut.componentDidDisappear('myUniqueId');
-    });
-  });
-
-  describe('onNavigationButtonPressed', () => {
-    it('calls onNavigationButtonPressed on component ref from store', () => {
-      uut.onNavigationButtonPressed({
-        componentId: 'myUniqueId',
-        buttonId: 'myButtonId'
-      });
-      expect(mockRef.onNavigationButtonPressed).toHaveBeenCalledTimes(1);
-    });
-
-    it('skips undefined refs', () => {
-      uut.onNavigationButtonPressed('myButtonId');
-      expect(mockRef.didDisappear).not.toHaveBeenCalled();
-    });
-
-    it('skips unimplemented onNavigationButtonPressed', () => {
-      mockRef = {};
-      expect(mockRef.onNavigationButtonPressed).toBeUndefined();
-      store.setRefForComponentId('myUniqueId', mockRef);
-      uut.componentDidAppear('myUniqueId');
-    });
-  });
-});

lib/src/components/Store.test.ts

   });
 
   it('initial state', () => {
-    expect(uut.getPropsForComponentId('component1')).toEqual({});
+    expect(uut.getPropsForId('component1')).toEqual({});
   });
 
-  it('holds props by componentId', () => {
-    uut.setPropsForComponentId('component1', { a: 1, b: 2 });
-    expect(uut.getPropsForComponentId('component1')).toEqual({ a: 1, b: 2 });
+  it('holds props by id', () => {
+    uut.setPropsForId('component1', { a: 1, b: 2 });
+    expect(uut.getPropsForId('component1')).toEqual({ a: 1, b: 2 });
   });
 
-  it('defensive for invalid componentId and props', () => {
-    uut.setPropsForComponentId('component1', undefined);
-    uut.setPropsForComponentId(undefined, undefined);
-    expect(uut.getPropsForComponentId('component1')).toEqual({});
+  it('defensive for invalid Id and props', () => {
+    uut.setPropsForId('component1', undefined);
+    uut.setPropsForId(undefined, undefined);
+    expect(uut.getPropsForId('component1')).toEqual({});
   });
 
   it('holds original components classes by componentName', () => {
 
   it('holds component refs by id', () => {
     const ref = {};
-    uut.setRefForComponentId('refUniqueId', ref);
-    expect(uut.getRefForComponentId('other')).toBeUndefined();
-    expect(uut.getRefForComponentId('refUniqueId')).toBe(ref);
+    uut.setRefForId('refUniqueId', ref);
+    expect(uut.getRefForId('other')).toBeUndefined();
+    expect(uut.getRefForId('refUniqueId')).toBe(ref);
   });
 
   it('clean by id', () => {
-    uut.setRefForComponentId('refUniqueId', {});
-    uut.setPropsForComponentId('refUniqueId', { foo: 'bar' });
+    uut.setRefForId('refUniqueId', {});
+    uut.setPropsForId('refUniqueId', { foo: 'bar' });
 
     uut.cleanId('refUniqueId');
 
-    expect(uut.getRefForComponentId('refUniqueId')).toBeUndefined();
-    expect(uut.getPropsForComponentId('refUniqueId')).toEqual({});
+    expect(uut.getRefForId('refUniqueId')).toBeUndefined();
+    expect(uut.getPropsForId('refUniqueId')).toEqual({});
   });
 });

lib/src/components/Store.ts

 import * as _ from 'lodash';
 
 export class Store {
-  private propsByComponentId: {};
-  private componentsByName: {};
-  private refsById: {};
-
-  constructor() {
-    this.propsByComponentId = {};
-    this.componentsByName = {};
-    this.refsById = {};
-  }
+  private componentsByName = {};
+  private propsById = {};
+  private refsById = {};
 
-  setPropsForComponentId(componentId, props) {
-    _.set(this.propsByComponentId, componentId, props);
+  setPropsForId(componentId: string, props) {
+    _.set(this.propsById, componentId, props);
   }
 
-  getPropsForComponentId(componentId) {
-    return _.get(this.propsByComponentId, componentId, {});
+  getPropsForId(componentId: string) {
+    return _.get(this.propsById, componentId, {});
   }
 
-  setOriginalComponentClassForName(componentName, ComponentClass) {
+  setOriginalComponentClassForName(componentName: string, ComponentClass) {
     _.set(this.componentsByName, componentName, ComponentClass);
   }
 
-  getOriginalComponentClassForName(componentName) {
+  getOriginalComponentClassForName(componentName: string) {
     return _.get(this.componentsByName, componentName);
   }
 
-  setRefForComponentId(id, ref) {
+  setRefForId(id: string, ref) {
     _.set(this.refsById, id, ref);
   }
 
-  getRefForComponentId(id) {
+  getRefForId(id: string) {
     return _.get(this.refsById, id);
   }
 
-  cleanId(id) {
+  cleanId(id: string) {
     _.unset(this.refsById, id);
-    _.unset(this.propsByComponentId, id);
+    _.unset(this.propsById, id);
   }
 }

lib/src/events/EventsRegistry.test.ts

+import { EventsRegistry } from './EventsRegistry';
+import { NativeEventsReceiver } from '../adapters/NativeEventsReceiver.mock';
+
+describe('EventsRegistry', () => {
+  let uut: EventsRegistry;
+  let mockNativeEventsReceiver;
+
+  beforeEach(() => {
+    mockNativeEventsReceiver = new NativeEventsReceiver();
+    uut = new EventsRegistry(mockNativeEventsReceiver);
+  });
+
+  it('exposes appLaunch event', () => {
+    const subscription = {};
+    mockNativeEventsReceiver.registerAppLaunched.mockReturnValueOnce(subscription);
+    const cb = jest.fn();
+    const result = uut.appLaunched(cb);
+    expect(mockNativeEventsReceiver.registerAppLaunched).toHaveBeenCalledTimes(1);
+    expect(mockNativeEventsReceiver.registerAppLaunched).toHaveBeenCalledWith(cb);
+    expect(subscription).toBe(result);
+  });
+});

lib/src/events/EventsRegistry.ts

+import { EventSubscription } from 'react-native';
+
+export class EventsRegistry {
+  private nativeEventsReceiver;
+
+  constructor(nativeEventsReceiver) {
+    this.nativeEventsReceiver = nativeEventsReceiver;
+  }
+
+  public appLaunched(callback): EventSubscription {
+    return this.nativeEventsReceiver.registerAppLaunched(callback);
+  }
+}

lib/src/events/PrivateEventsListener.test.ts

-import { PrivateEventsListener } from './PrivateEventsListener';
-import { NativeEventsReceiver } from '../adapters/NativeEventsReceiver.mock';
-import { Store } from '../components/Store';
-
-describe('PrivateEventsListener', () => {
-  let uut: PrivateEventsListener;
-  let nativeEventsReceiver;
-  let store;
-
-  beforeEach(() => {
-    nativeEventsReceiver = new NativeEventsReceiver();
-    store = new Store();
-    uut = new PrivateEventsListener(nativeEventsReceiver, store);
-  });
-
-  it('register and handle componentDidAppear', () => {
-    const mockRef = {
-      didAppear: jest.fn()
-    };
-    store.setRefForComponentId('myComponentId', mockRef);
-    uut.listenAndHandlePrivateEvents();
-    expect(nativeEventsReceiver.registerComponentDidAppear).toHaveBeenCalledTimes(1);
-    const callbackFunction = nativeEventsReceiver.registerComponentDidAppear.mock.calls[0][0];
-    expect(callbackFunction).toBeInstanceOf(Function);
-
-    expect(mockRef.didAppear).not.toHaveBeenCalled();
-    callbackFunction('myComponentId');
-
-    expect(mockRef.didAppear).toHaveBeenCalledTimes(1);
-  });
-
-  it('register and listen componentDidDisappear', () => {
-    uut.listenAndHandlePrivateEvents();
-    expect(nativeEventsReceiver.registerComponentDidDisappear).toHaveBeenCalledTimes(1);
-  });
-
-  it('register and handle onNavigationButtonPressed', () => {
-    const mockRef = {
-      onNavigationButtonPressed: jest.fn()
-    };
-    store.setRefForComponentId('myComponentId', mockRef);
-    uut.listenAndHandlePrivateEvents();
-    expect(nativeEventsReceiver.registerNavigationButtonPressed).toHaveBeenCalledTimes(1);
-    const callbackFunction = nativeEventsReceiver.registerNavigationButtonPressed.mock.calls[0][0];
-    expect(callbackFunction).toBeInstanceOf(Function);
-
-    expect(mockRef.onNavigationButtonPressed).not.toHaveBeenCalled();
-    callbackFunction({ componentId: 'myComponentId', buttonId: 'myButtonId' });
-
-    expect(mockRef.onNavigationButtonPressed).toHaveBeenCalledTimes(1);
-  });
-});

lib/src/events/PrivateEventsListener.ts

-import { Lifecycle } from '../components/Lifecycle';
-
-export class PrivateEventsListener {
-  private lifecycle;
-
-  constructor(
-    private readonly nativeEventsReceiver,
-    private readonly store) {
-    this.lifecycle = new Lifecycle(this.store);
-  }
-
-  public listenAndHandlePrivateEvents() {
-    this.nativeEventsReceiver.registerComponentDidAppear(this.lifecycle.componentDidAppear);
-    this.nativeEventsReceiver.registerComponentDidDisappear(this.lifecycle.componentDidDisappear);
-    this.nativeEventsReceiver.registerNavigationButtonPressed(this.lifecycle.onNavigationButtonPressed);
-  }
-}

lib/src/events/PublicEventsRegistry.test.ts

-import { PublicEventsRegistry } from './PublicEventsRegistry';
-import { NativeEventsReceiver } from '../adapters/NativeEventsReceiver.mock';
-
-describe('PublicEventsRegistry', () => {
-  let uut;
-  let nativeEventsReceiver;
-
-  beforeEach(() => {
-    nativeEventsReceiver = new NativeEventsReceiver();
-    uut = new PublicEventsRegistry(nativeEventsReceiver);
-  });
-
-  it('exposes onAppLaunch event', () => {
-    const cb = jest.fn();
-    uut.onAppLaunched(cb);
-    expect(nativeEventsReceiver.registerAppLaunched).toHaveBeenCalledTimes(1);
-    expect(nativeEventsReceiver.registerAppLaunched).toHaveBeenCalledWith(cb);
-  });
-
-  it('exposes navigationCommands events', () => {
-    const cb = jest.fn();
-    uut.navigationCommands(cb);
-    expect(nativeEventsReceiver.registerNavigationCommands).toHaveBeenCalledTimes(1);
-    expect(nativeEventsReceiver.registerNavigationCommands).toHaveBeenCalledWith(cb);
-  });
-
-  it('exposes componentLifecycle events', () => {
-    const cb = jest.fn();
-    uut.componentLifecycle(cb);
-    expect(nativeEventsReceiver.registerComponentLifecycle).toHaveBeenCalledTimes(1);
-    expect(nativeEventsReceiver.registerComponentLifecycle).toHaveBeenCalledWith(cb);
-  });
-});

lib/src/events/PublicEventsRegistry.ts

-export class PublicEventsRegistry {
-  private nativeEventsReceiver;
-
-  constructor(nativeEventsReceiver) {
-    this.nativeEventsReceiver = nativeEventsReceiver;
-  }
-
-  public onAppLaunched(callback) {
-    this.nativeEventsReceiver.registerAppLaunched(callback);
-  }
-
-  public navigationCommands(callback) {
-    this.nativeEventsReceiver.registerNavigationCommands(callback);
-  }
-
-  public componentLifecycle(callback) {
-    this.nativeEventsReceiver.registerComponentLifecycle(callback);
-  }
-}