refactor eventListener

lib/src/adapters/NativeEventsReceiver.js

     this.emitter = new NativeEventEmitter(NativeModules.RNNEventEmitter);
   }
 
-  componentDidAppear(callback) {
+  registerComponentDidAppear(callback) {
     this.emitter.addListener('RNN.componentDidAppear', callback);
   }
 
-  componentDidDisappear(callback) {
+  registerComponentDidDisappear(callback) {
     this.emitter.addListener('RNN.componentDidDisappear', callback);
   }
 
-  appLaunched(callback) {
+  registerAppLaunched(callback) {
     this.emitter.addListener('RNN.appLaunched', callback);
   }
 
-  navigationButtonPressed(callback) {
+  registerNavigationButtonPressed(callback) {
     this.emitter.addListener('RNN.navigationButtonPressed', callback);
   }
 }

lib/src/events/PrivateEventsListener.js

   }
 
   listenAndHandlePrivateEvents() {
-    this.nativeEventsReceiver.componentDidAppear(this.lifecycle.componentDidAppear);
-    this.nativeEventsReceiver.componentDidDisappear(this.lifecycle.componentDidDisappear);
-    this.nativeEventsReceiver.navigationButtonPressed(this.lifecycle.onNavigationButtonPressed);
+    this.nativeEventsReceiver.registerComponentDidAppear(this.lifecycle.componentDidAppear);
+    this.nativeEventsReceiver.registerComponentDidDisappear(this.lifecycle.componentDidDisappear);
+    this.nativeEventsReceiver.registerNavigationButtonPressed(this.lifecycle.onNavigationButtonPressed);
   }
 }
 

lib/src/events/PrivateEventsListener.test.js

     };
     store.setRefForComponentId('myComponentId', mockRef);
     uut.listenAndHandlePrivateEvents();
-    expect(nativeEventsReceiver.componentDidAppear).toHaveBeenCalledTimes(1);
-    const callbackFunction = nativeEventsReceiver.componentDidAppear.mock.calls[0][0];
+    expect(nativeEventsReceiver.registerComponentDidAppear).toHaveBeenCalledTimes(1);
+    const callbackFunction = nativeEventsReceiver.registerComponentDidAppear.mock.calls[0][0];
     expect(callbackFunction).toBeInstanceOf(Function);
 
     expect(mockRef.didAppear).not.toHaveBeenCalled();
 
   it('register and listen componentDidDisappear', () => {
     uut.listenAndHandlePrivateEvents();
-    expect(nativeEventsReceiver.componentDidDisappear).toHaveBeenCalledTimes(1);
+    expect(nativeEventsReceiver.registerComponentDidDisappear).toHaveBeenCalledTimes(1);
   });
 
   it('register and handle onNavigationButtonPressed', () => {
     };
     store.setRefForComponentId('myComponentId', mockRef);
     uut.listenAndHandlePrivateEvents();
-    expect(nativeEventsReceiver.navigationButtonPressed).toHaveBeenCalledTimes(1);
-    const callbackFunction = nativeEventsReceiver.navigationButtonPressed.mock.calls[0][0];
+    expect(nativeEventsReceiver.registerNavigationButtonPressed).toHaveBeenCalledTimes(1);
+    const callbackFunction = nativeEventsReceiver.registerNavigationButtonPressed.mock.calls[0][0];
     expect(callbackFunction).toBeInstanceOf(Function);
 
     expect(mockRef.onNavigationButtonPressed).not.toHaveBeenCalled();

lib/src/events/PublicEventsRegistry.js

   }
 
   onAppLaunched(callback) {
-    this.nativeEventsReceiver.appLaunched(callback);
+    this.nativeEventsReceiver.registerAppLaunched(callback);
   }
 }
 

lib/src/events/PublicEventsRegistry.test.js

   it('exposes onAppLaunch event', () => {
     const cb = jest.fn();
     uut.onAppLaunched(cb);
-    expect(nativeEventsReceiver.appLaunched).toHaveBeenCalledTimes(1);
-    expect(nativeEventsReceiver.appLaunched).toHaveBeenCalledWith(cb);
+    expect(nativeEventsReceiver.registerAppLaunched).toHaveBeenCalledTimes(1);
+    expect(nativeEventsReceiver.registerAppLaunched).toHaveBeenCalledWith(cb);
   });
 });

scripts/generate-js-doc.js

-throw new Error('temporarily disabled, until newAPI is complete')
+throw new Error('temporarily disabled, until newAPI is complete');
+/*
 const jsdoc2md = require('jsdoc-to-markdown');
 const fs = require('fs');
 const path = require('path');
       };
     }),
     ...fs.readdirSync(CONTAINERS_DIR)
-        .map((file) => {
-          return {
-            file: CONTAINERS_DIR + file,
-            outputDir: OUTPUT_DIR,
-            partial: PARAMS_PARTIALS,
-            separator: false
-          };
-        }),
+      .map((file) => {
+        return {
+          file: CONTAINERS_DIR + file,
+          outputDir: OUTPUT_DIR,
+          partial: PARAMS_PARTIALS,
+          separator: false
+        };
+      }),
     ...fs.readdirSync(BASE_DIR)
-        .filter((file) => fs.statSync(BASE_DIR + file).isFile())
-        .map((file) => {
-          return {
-            file: BASE_DIR + file,
-            outputDir: OUTPUT_DIR
-          };
-        })
+      .filter((file) => fs.statSync(BASE_DIR + file).isFile())
+      .map((file) => {
+        return {
+          file: BASE_DIR + file,
+          outputDir: OUTPUT_DIR
+        };
+      })
   ];
 }
 
-inputFiles().forEach((inputFile) => generateMarkdownForFile(inputFile));
+inputFiles().forEach((inputFile) => generateMarkdownForFile(inputFile)); */