migrating

lib/src/Navigation.js

 
 import { Element } from './adapters/Element';
 
-/** @constructor */
 class Navigation {
   constructor() {
     this.store = new Store();

lib/src/adapters/NativeCommandsSender.mock.js

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

lib/src/adapters/NativeCommandsSender.mock.ts

+export const { NativeCommandsSender } = jest.genMockFromModule('./NativeCommandsSender');

lib/src/adapters/NativeCommandsSender.js → lib/src/adapters/NativeCommandsSender.ts

-const { NativeModules } = require('react-native');
+import { NativeModules } from 'react-native';
+
+export class NativeCommandsSender {
+  private nativeCommandsModule: any;
 
-class NativeCommandsSender {
   constructor() {
     this.nativeCommandsModule = NativeModules.RNNBridgeModule;
   }
 
-  setRoot(layoutTree) {
+  setRoot(layoutTree: object) {
     return this.nativeCommandsModule.setRoot(layoutTree);
   }
 
-  setDefaultOptions(options) {
+  setDefaultOptions(options: object) {
     this.nativeCommandsModule.setDefaultOptions(options);
   }
 
-  setOptions(componentId, options) {
+  setOptions(componentId: string, options: object) {
     this.nativeCommandsModule.setOptions(componentId, options);
   }
 
-  async push(onComponentId, layout) {
+  async push(onComponentId: string, layout: object) {
     const pushedComponentId = await this.nativeCommandsModule.push(onComponentId, layout);
     return pushedComponentId;
   }
 
-  pop(componentId, options) {
+  pop(componentId: string, options: object) {
     return this.nativeCommandsModule.pop(componentId, options);
   }
 
-  popTo(componentId) {
+  popTo(componentId: string) {
     return this.nativeCommandsModule.popTo(componentId);
   }
 
-  popToRoot(componentId) {
+  popToRoot(componentId: string) {
     return this.nativeCommandsModule.popToRoot(componentId);
   }
 
-  async showModal(layout) {
+  async showModal(layout: object) {
     const completed = await this.nativeCommandsModule.showModal(layout);
     return completed;
   }
 
-  dismissModal(componentId) {
+  dismissModal(componentId: string) {
     return this.nativeCommandsModule.dismissModal(componentId);
   }
 
     return this.nativeCommandsModule.dismissAllModals();
   }
 
-  showOverlay(type, options) {
+  showOverlay(type: any, options: object) {
     return this.nativeCommandsModule.showOverlay(type, options);
   }
 
     return Promise.resolve(true);
   }
 }
-
-module.exports = NativeCommandsSender;

lib/src/adapters/NativeEventsReceiver.mock.js

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

lib/src/adapters/NativeEventsReceiver.mock.ts

+export const { NativeEventsReceiver } = jest.genMockFromModule('./NativeEventsReceiver');

lib/src/adapters/NativeEventsReceiver.js → lib/src/adapters/NativeEventsReceiver.ts

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

lib/src/adapters/UniqueIdProvider.js

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

lib/src/adapters/UniqueIdProvider.mock.js

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

lib/src/adapters/UniqueIdProvider.mock.ts

+export class UniqueIdProvider {
+  generate(prefix: string): string {
+    return `${prefix}+UNIQUE_ID`;
+  }
+}

lib/src/adapters/UniqueIdProvider.ts

+import * as _ from 'lodash';
+
+export class UniqueIdProvider {
+  generate(prefix: string): string {
+    return _.uniqueId(prefix);
+  }
+}

lib/src/commands/Commands.test.js

 const LayoutTreeParser = require('./LayoutTreeParser');
 const LayoutTreeCrawler = require('./LayoutTreeCrawler');
 const Store = require('../components/Store');
-const UniqueIdProvider = require('../adapters/UniqueIdProvider.mock');
-const NativeCommandsSender = require('../adapters/NativeCommandsSender.mock');
+const { UniqueIdProvider } = require('../adapters/UniqueIdProvider.mock');
+const { NativeCommandsSender } = require('../adapters/NativeCommandsSender.mock');
 const Commands = require('./Commands');
 
 describe('Commands', () => {

lib/src/commands/LayoutTreeCrawler.js

+import { LayoutTypes } from './LayoutTypes';
+
 const _ = require('lodash');
-const LayoutTypes = require('./LayoutTypes');
 const OptionsProcessor = require('./OptionsProcessor');
 
 class LayoutTreeCrawler {

lib/src/commands/LayoutTreeParser.js

+import { LayoutTypes } from './LayoutTypes';
+
 const _ = require('lodash');
-const LayoutTypes = require('./LayoutTypes');
 
 class LayoutTreeParser {
   constructor() {

lib/src/commands/LayoutTypes.js

-module.exports = {
-  Component: 'Component',
-  Stack: 'Stack',
-  BottomTabs: 'BottomTabs',
-  SideMenuRoot: 'SideMenuRoot',
-  SideMenuCenter: 'SideMenuCenter',
-  SideMenuLeft: 'SideMenuLeft',
-  SideMenuRight: 'SideMenuRight',
-  TopTabs: 'TopTabs'
-};

lib/src/commands/LayoutTypes.ts

+export const enum LayoutTypes {
+  Component = 'Component',
+  Stack = 'Stack',
+  BottomTabs = 'BottomTabs',
+  SideMenuRoot = 'SideMenuRoot',
+  SideMenuCenter = 'SideMenuCenter',
+  SideMenuLeft = 'SideMenuLeft',
+  SideMenuRight = 'SideMenuRight',
+  TopTabs = 'TopTabs'
+};

lib/src/commands/OptionsProcessor.test.js → lib/src/commands/OptionsProcessor.test.ts

-const OptionsProcessor = require('./OptionsProcessor');
+import { OptionsProcessor } from './OptionsProcessor';
 
 describe('navigation options', () => {
-  let options;
+  let options: any;
 
   beforeEach(() => {
     options = {};

lib/src/commands/OptionsProcessor.js → lib/src/commands/OptionsProcessor.ts

-const _ = require('lodash');
-const { processColor } = require('react-native');
-const resolveAssetSource = require('react-native/Libraries/Image/resolveAssetSource');
+import * as _ from 'lodash';
+import { processColor } from 'react-native';
+import * as resolveAssetSource from 'react-native/Libraries/Image/resolveAssetSource';
 
-class OptionsProcessor {
-  static processOptions(options) {
+export class OptionsProcessor {
+  static processOptions(options: any) {
     _.forEach(options, (value, key) => {
       if (value) {
         if (_.endsWith(key, 'Color')) {
     });
   }
 }
-
-module.exports = OptionsProcessor;

lib/src/events/PrivateEventsListener.test.js → lib/src/events/PrivateEventsListener.test.ts

-const PrivateEventsListener = require('./PrivateEventsListener');
-const NativeEventsReceiver = require('../adapters/NativeEventsReceiver.mock');
-const Store = require('../components/Store');
+import { PrivateEventsListener } from './PrivateEventsListener';
+import { NativeEventsReceiver } from '../adapters/NativeEventsReceiver.mock';
+import * as  Store from '../components/Store';
 
 describe('PrivateEventsListener', () => {
-  let uut;
-  let nativeEventsReceiver;
-  let store;
+  let uut: PrivateEventsListener;
+  let nativeEventsReceiver: any;
+  let store: any;
 
   beforeEach(() => {
     nativeEventsReceiver = new NativeEventsReceiver();

lib/src/events/PrivateEventsListener.js → lib/src/events/PrivateEventsListener.ts

-const Lifecycle = require('../components/Lifecycle');
+import * as Lifecycle from '../components/Lifecycle';
 
-class PrivateEventsListener {
-  constructor(nativeEventsReceiver, store) {
+export class PrivateEventsListener {
+  private nativeEventsReceiver: any;
+  private lifecycle: any;
+
+  constructor(nativeEventsReceiver: any, store: any) {
     this.nativeEventsReceiver = nativeEventsReceiver;
     this.lifecycle = new Lifecycle(store);
   }
     this.nativeEventsReceiver.registerNavigationButtonPressed(this.lifecycle.onNavigationButtonPressed);
   }
 }
-
-module.exports = PrivateEventsListener;

lib/src/globals.d.ts

+declare module 'react-native/Libraries/Image/resolveAssetSource';

tsconfig.json

 {
-  "extends": "./tsconfig-strict",
   "compilerOptions": {
     "outDir": "./lib/dist",
     "allowJs": true,