containers

src2/Navigation.js

@@ -1,7 +1,7 @@
-import * as ScreenRegistry from './screens/ScreenRegistry';
+import * as ContainerRegistry from './containers/ContainerRegistry';
 
-export function registerScreen(screenKey, getScreenFunc) {
-  ScreenRegistry.registerScreen(screenKey, getScreenFunc);
+export function registerContainer(containerKey, getContainerFunc) {
+  ContainerRegistry.registerContainer(containerKey, getContainerFunc);
 }
 
 export function startApp(params) {

src2/Navigation.test.js

@@ -3,18 +3,18 @@ import _ from 'lodash';
 describe('Navigation', () => {
   let Navigation;
   let Commands;
-  let ScreenRegistry;
+  let ContainerRegistry;
 
   beforeEach(() => {
-    jest.mock('./screens/ScreenRegistry');
+    jest.mock('./containers/ContainerRegistry');
     Navigation = require('./Navigation');
     Commands = require('./commands/Commands');
-    ScreenRegistry = require('./screens/ScreenRegistry');
+    ContainerRegistry = require('./containers/ContainerRegistry');
   });
 
   it('exposes static commands', () => {
     _.forEach([
-      Navigation.registerScreen,
+      Navigation.registerContainer,
       Navigation.startApp,
       Navigation.push,
       Navigation.pop,
@@ -30,11 +30,11 @@ describe('Navigation', () => {
     ], (f) => expect(f).toBeInstanceOf(Function));
   });
 
-  it('delegates register screen to screen registry', () => {
-    expect(ScreenRegistry.registerScreen).not.toHaveBeenCalled();
+  it('delegates register container to container registry', () => {
+    expect(ContainerRegistry.registerContainer).not.toHaveBeenCalled();
     const fn = jest.fn();
-    Navigation.registerScreen('key', fn);
-    expect(ScreenRegistry.registerScreen).toHaveBeenCalledTimes(1);
-    expect(ScreenRegistry.registerScreen).toHaveBeenCalledWith('key', fn);
+    Navigation.registerContainer('key', fn);
+    expect(ContainerRegistry.registerContainer).toHaveBeenCalledTimes(1);
+    expect(ContainerRegistry.registerContainer).toHaveBeenCalledWith('key', fn);
   });
 });

src2/commands/Commands.js

@@ -9,10 +9,10 @@ function validateParams(params) {
   if (!params) {
     throw new Error(msg);
   }
-  if (params.screenKey) {
+  if (params.containerKey) {
     return true;
   }
-  if (params.tabs && params.tabs.length > 0 && _.every(params.tabs, (t) => t.screenKey)) {
+  if (params.tabs && params.tabs.length > 0 && _.every(params.tabs, (t) => t.containerKey)) {
     return true;
   }
   throw new Error(msg);

src2/commands/Commands.test.js

@@ -8,25 +8,25 @@ describe('Commands', () => {
   describe('startApp', () => {
     it('receives params object', () => {
       uut.startApp({
-        screenKey: {
-          screen: 'example.MyScreen'
+        containerKey: {
+          container: 'example.MyContainer'
         },
         drawer: {
           left: {
-            screen: 'example.SideMenu'
+            container: 'example.SideMenu'
           }
         }
       });
     });
 
-    it('expects to get screenKey, or tabs with screenKeys', () => {
-      expect(() => uut.startApp({screenKey: 'example.MyScreen'})).not.toThrow();
-      expect(() => uut.startApp({tabs: [{screenKey: 'example.Tab1'}]})).not.toThrow();
+    it('expects to get containerKey, or tabs with containerKeys', () => {
+      expect(() => uut.startApp({containerKey: 'example.MyContainer'})).not.toThrow();
+      expect(() => uut.startApp({tabs: [{containerKey: 'example.Tab1'}]})).not.toThrow();
       expect(() => uut.startApp()).toThrow();
       expect(() => uut.startApp({})).toThrow();
       expect(() => uut.startApp({tabs: []})).toThrow();
       expect(() => uut.startApp({tabs: [{}]})).toThrow();
-      expect(() => uut.startApp({tabs: [{screenKey: 'example.Tab1'}, {}]})).toThrow();
+      expect(() => uut.startApp({tabs: [{containerKey: 'example.Tab1'}, {}]})).toThrow();
     });
   });
 });

src2/commands/valid-commands.js

@@ -1,32 +1,32 @@
-export const singleScreenApp = {
-  screen: {
-    key: 'com.example.FirstTabScreen'
+export const singleContainerApp = {
+  container: {
+    key: 'com.example.FirstTabContainer'
   }
 };
 
 export const tabBasedApp = {
   tabs: [
     {
-      screen: {
-        key: 'com.example.FirstTabScreen'
+      container: {
+        key: 'com.example.FirstTabContainer'
       }
     },
     {
-      screen: {
-        key: 'com.example.SecondTabScreen'
+      container: {
+        key: 'com.example.SecondTabContainer'
       }
     },
     {
-      screen: {
-        key: 'com.example.FirstTabScreen'
+      container: {
+        key: 'com.example.FirstTabContainer'
       }
     }
   ]
 };
 
 export const singleWithSideMenu = {
-  screen: {
-    key: 'com.example.MyScreen'
+  container: {
+    key: 'com.example.MyContainer'
   },
   sideMenu: {
     left: {
@@ -36,8 +36,8 @@ export const singleWithSideMenu = {
 };
 
 export const singleWithRightSideMenu = {
-  screen: {
-    key: 'com.example.MyScreen'
+  container: {
+    key: 'com.example.MyContainer'
   },
   sideMenu: {
     right: {
@@ -47,8 +47,8 @@ export const singleWithRightSideMenu = {
 };
 
 export const singleWithBothMenus = {
-  screen: {
-    key: 'com.example.MyScreen'
+  container: {
+    key: 'com.example.MyContainer'
   },
   sideMenu: {
     left: {
@@ -63,18 +63,18 @@ export const singleWithBothMenus = {
 export const tabBasedWithSideMenu = {
   tabs: [
     {
-      screen: {
-        key: 'com.example.FirstTabScreen'
+      container: {
+        key: 'com.example.FirstTabContainer'
       }
     },
     {
-      screen: {
-        key: 'com.example.SecondTabScreen'
+      container: {
+        key: 'com.example.SecondTabContainer'
       }
     },
     {
-      screen: {
-        key: 'com.example.FirstTabScreen'
+      container: {
+        key: 'com.example.FirstTabContainer'
       }
     }
   ],

src2/containers/ContainerRegistry.js

@@ -0,0 +1,44 @@
+import React, {Component} from 'react';
+import {AppRegistry} from 'react-native';
+import * as PropsStore from './PropsStore';
+import * as ContainerStore from './ContainerStore';
+
+export function registerContainer(containerKey, getContainerFunc) {
+  const OriginalContainer = getContainerFunc();
+  const NavigationContainer = wrapContainer(containerKey, OriginalContainer);
+  ContainerStore.setContainerClass(containerKey, NavigationContainer);
+  AppRegistry.registerComponent(containerKey, () => NavigationContainer);
+}
+
+export const bla = {};
+
+function wrapContainer(containerKey, OriginalContainer) {
+  return class extends Component {
+    constructor(props) {
+      super(props);
+      if (!props.containerId) {
+        throw new Error(`Container ${containerKey} does not have a containerId!`);
+      }
+      this.state = {
+        containerId: props.containerId,
+        allProps: {...props, ...PropsStore.getPropsForContainerId(props.containerId)}
+      };
+    }
+
+    componentWillReceiveProps(nextProps) {
+      this.setState({
+        allProps: {...nextProps, ...PropsStore.getPropsForContainerId(this.state.containerId)}
+      });
+    }
+
+    render() {
+      return (
+        <OriginalContainer
+          ref={(r) => bla.ref = r}
+          {...this.state.allProps}
+          containerId={this.state.containerId}
+        />
+      );
+    }
+  };
+}

src2/containers/ContainerRegistry.test.js

@@ -0,0 +1,130 @@
+import React, {Component} from 'react';
+import {AppRegistry, Text} from 'react-native';
+import renderer from 'react-test-renderer';
+
+describe('ComponentRegistry', () => {
+  let uut;
+  let myContainerRef;
+  let testParentRef;
+  let containerStore;
+
+  class MyContainer extends Component {
+    constructor(props) {
+      super(props);
+      myContainerRef = this; //eslint-disable-line
+    }
+
+    render() {
+      return <Text>{'Hello, World!'}</Text>;
+    }
+  }
+
+  class TestParent extends Component { //eslint-disable-line
+    constructor(props) {
+      super(props);
+      testParentRef = this; //eslint-disable-line
+      this.ChildClass = props.ChildClass;
+      this.state = {propsFromState: {}};
+    }
+
+    render() {
+      const Child = this.ChildClass;
+      return (
+        <Child containerId="container1" {...this.state.propsFromState}/>
+      );
+    }
+  }
+
+  beforeEach(() => {
+    uut = require('./ContainerRegistry');
+    containerStore = require('./ContainerStore');
+  });
+
+  afterEach(() => {
+    myContainerRef = null;
+    testParentRef = null;
+  });
+
+  describe('registerContainer', () => {
+    beforeEach(() => {
+      AppRegistry.registerComponent = jest.fn(AppRegistry.registerComponent);
+    });
+
+    it('registers container component by containerKey into AppRegistry', () => {
+      expect(AppRegistry.registerComponent).not.toHaveBeenCalled();
+      uut.registerContainer('example.MyContainer.key', () => MyContainer);
+      expect(AppRegistry.registerComponent).toHaveBeenCalledTimes(1);
+      expect(AppRegistry.registerComponent.mock.calls[0][0]).toEqual('example.MyContainer.key');
+    });
+
+    it('resulting in a normal component', () => {
+      uut.registerContainer('example.MyContainer.key', () => MyContainer);
+      const Container = AppRegistry.registerComponent.mock.calls[0][1]();
+      const tree = renderer.create(<Container containerId="123"/>);
+      expect(tree.toJSON().children).toEqual(['Hello, World!']);
+    });
+  });
+
+  describe('NavigationContainer wrapping', () => {
+    const containerKey = 'example.MyContainer';
+
+    beforeEach(() => {
+      uut.registerContainer(containerKey, () => MyContainer);
+    });
+
+    it('must have containerId as prop', () => {
+      const NavigationContainer = containerStore.getContainerClass(containerKey);
+      expect(() => {
+        renderer.create(<NavigationContainer/>);
+      }).toThrow(new Error('Container example.MyContainer does not have a containerId!'));
+    });
+
+    it('wraps the container and saves to store', () => {
+      const NavigationContainer = containerStore.getContainerClass(containerKey);
+      expect(NavigationContainer).not.toBeInstanceOf(MyContainer);
+      const tree = renderer.create(<NavigationContainer containerId={'container1'}/>);
+      expect(tree.toJSON().children).toEqual(['Hello, World!']);
+      expect(myContainerRef).toBeInstanceOf(MyContainer);
+    });
+
+    it('injects props from wrapper into original container', () => {
+      const NavigationContainer = containerStore.getContainerClass(containerKey);
+      renderer.create(<NavigationContainer containerId={'container1'} myProp={'yo'}/>);
+      expect(myContainerRef.props.myProp).toEqual('yo');
+    });
+
+    it('updates props from wrapper into original container', () => {
+      const NavigationContainer = containerStore.getContainerClass(containerKey);
+      renderer.create(<TestParent ChildClass={NavigationContainer}/>);
+      expect(myContainerRef.props.foo).toEqual(undefined);
+      testParentRef.setState({propsFromState: {foo: 'yo'}});
+      expect(myContainerRef.props.foo).toEqual('yo');
+    });
+
+    it('pulls props from the PropsStore and injects them into the inner container', () => {
+      require('./PropsStore').setPropsForContainerId('container123', {numberProp: 1, stringProp: 'hello', objectProp: {a: 2}});
+      const NavigationContainer = containerStore.getContainerClass(containerKey);
+      renderer.create(<NavigationContainer containerId={'container123'}/>);
+      expect(myContainerRef.props).toEqual({containerId: 'container123', numberProp: 1, stringProp: 'hello', objectProp: {a: 2}});
+    });
+
+    it('updates props from PropsStore into inner container', () => {
+      const NavigationContainer = containerStore.getContainerClass(containerKey);
+      renderer.create(<TestParent ChildClass={NavigationContainer}/>);
+      require('./PropsStore').setPropsForContainerId('container1', {myProp: 'hello'});
+      expect(myContainerRef.props.foo).toEqual(undefined);
+      expect(myContainerRef.props.myProp).toEqual(undefined);
+      testParentRef.setState({propsFromState: {foo: 'yo'}});
+      expect(myContainerRef.props.foo).toEqual('yo');
+      expect(myContainerRef.props.myProp).toEqual('hello');
+    });
+
+    it('protects containerId from change', () => {
+      const NavigationContainer = containerStore.getContainerClass(containerKey);
+      renderer.create(<TestParent ChildClass={NavigationContainer}/>);
+      expect(myContainerRef.props.containerId).toEqual('container1');
+      testParentRef.setState({propsFromState: {containerId: 'ERROR'}});
+      expect(myContainerRef.props.containerId).toEqual('container1');
+    });
+  });
+});

src2/containers/ContainerStore.js

@@ -0,0 +1,11 @@
+const state = {
+  containersByKey: {}
+};
+
+export function setContainerClass(containerKey, ContainerClass) {
+  state.containersByKey[containerKey] = ContainerClass;
+}
+
+export function getContainerClass(containerKey) {
+  return state.containersByKey[containerKey];
+}

src2/containers/ContainerStore.test.js

@@ -0,0 +1,19 @@
+describe('ContainerStore', () => {
+  let uut;
+
+  beforeEach(() => {
+    uut = require('./ContainerStore');
+  });
+
+  class Component {
+    //
+  }
+  class MyComponent extends Component {
+    //
+  }
+
+  it('holds containers classes by containerKey', () => {
+    uut.setContainerClass('example.mykey', MyComponent);
+    expect(uut.getContainerClass('example.mykey')).toEqual(MyComponent);
+  });
+});

src2/containers/PropsStore.js

@@ -0,0 +1,11 @@
+import _ from 'lodash';
+
+const propsByContainerId = {};
+
+export function setPropsForContainerId(containerId, props) {
+  _.set(propsByContainerId, containerId, props);
+}
+
+export function getPropsForContainerId(containerId) {
+  return _.get(propsByContainerId, containerId, {});
+}

src2/containers/PropsStore.test.js

@@ -0,0 +1,22 @@
+describe('PropsStore', () => {
+  let uut;
+
+  beforeEach(() => {
+    uut = require('./PropsStore');
+  });
+
+  it('initial state', () => {
+    expect(uut.getPropsForContainerId('container1')).toEqual({});
+  });
+
+  it('holds props by containerId', () => {
+    uut.setPropsForContainerId('container1', {a: 1, b: 2});
+    expect(uut.getPropsForContainerId('container1')).toEqual({a: 1, b: 2});
+  });
+
+  it('defensive for invalid containerId and props', () => {
+    uut.setPropsForContainerId('container1', undefined);
+    uut.setPropsForContainerId(undefined, undefined);
+    expect(uut.getPropsForContainerId('container1')).toEqual({});
+  });
+});

src2/integration/remx-support-component.js

@@ -5,7 +5,7 @@ import {connect} from 'remx/react-native';
 
 import * as store from './remx-support-store';
 
-class MyScreen extends Component {
+class MyContainer extends Component {
   constructor(props) {
     super(props);
     this.renders = 0;
@@ -19,4 +19,4 @@ class MyScreen extends Component {
   }
 }
 
-export default MyScreen;
+export default MyContainer;

src2/integration/remx-support.test.js

@@ -1,24 +1,24 @@
 xdescribe('remx support', () => {
   let React;
   let renderer;
-  let MyConnectedScreen;
+  let MyConnectedContainer;
   let store;
 
   beforeEach(() => {
     require('react-native');
     React = require('react');
     renderer = require('react-test-renderer');
-    MyConnectedScreen = require('./remx-support-component').default;
+    MyConnectedContainer = require('./remx-support-component').default;
     store = require('./remx-support-store');
   });
 
   it('renders normally', () => {
-    const tree = renderer.create(<MyConnectedScreen/>);
+    const tree = renderer.create(<MyConnectedContainer/>);
     expect(tree.toJSON().children).toEqual(['no name']);
   });
 
   it('rerenders as a result of an underlying state change (by selector)', () => {
-    const tree = renderer.create(<MyConnectedScreen/>);
+    const tree = renderer.create(<MyConnectedContainer/>);
     const instance = tree.getInstance();
     expect(tree.toJSON().children).toEqual(['no name']);
     expect(instance.renders).toEqual(1);

src2/screens/PropsStore.js

@@ -1,11 +0,0 @@
-import _ from 'lodash';
-
-const propsByScreenId = {};
-
-export function setPropsForScreenId(screenId, props) {
-  _.set(propsByScreenId, screenId, props);
-}
-
-export function getPropsForScreenId(screenId) {
-  return _.get(propsByScreenId, screenId, {});
-}

src2/screens/PropsStore.test.js

@@ -1,22 +0,0 @@
-describe('PropsStore', () => {
-  let uut;
-
-  beforeEach(() => {
-    uut = require('./PropsStore');
-  });
-
-  it('initial state', () => {
-    expect(uut.getPropsForScreenId('screen1')).toEqual({});
-  });
-
-  it('holds props by screenId', () => {
-    uut.setPropsForScreenId('screen1', {a: 1, b: 2});
-    expect(uut.getPropsForScreenId('screen1')).toEqual({a: 1, b: 2});
-  });
-
-  it('defensive for invalid screenId and props', () => {
-    uut.setPropsForScreenId('screen1', undefined);
-    uut.setPropsForScreenId(undefined, undefined);
-    expect(uut.getPropsForScreenId('screen1')).toEqual({});
-  });
-});

src2/screens/ScreenRegistry.js

@@ -1,44 +0,0 @@
-import React, {Component} from 'react';
-import {AppRegistry} from 'react-native';
-import * as PropsStore from './PropsStore';
-import * as ScreenStore from './ScreenStore';
-
-export function registerScreen(screenKey, getScreenFunc) {
-  const OriginalScreen = getScreenFunc();
-  const NavigationScreen = wrapScreen(screenKey, OriginalScreen);
-  ScreenStore.saveScreenClass(screenKey, NavigationScreen);
-  AppRegistry.registerComponent(screenKey, () => NavigationScreen);
-}
-
-export const bla = {};
-
-function wrapScreen(screenKey, OriginalScreen) {
-  return class extends Component {
-    constructor(props) {
-      super(props);
-      if (!props.screenId) {
-        throw new Error(`Screen ${screenKey} does not have a screenId!`);
-      }
-      this.state = {
-        screenId: props.screenId,
-        allProps: {...props, ...PropsStore.getPropsForScreenId(props.screenId)}
-      };
-    }
-
-    componentWillReceiveProps(nextProps) {
-      this.setState({
-        allProps: {...nextProps, ...PropsStore.getPropsForScreenId(this.state.screenId)}
-      });
-    }
-
-    render() {
-      return (
-        <OriginalScreen
-          ref={(r) => bla.ref = r}
-          {...this.state.allProps}
-          screenId={this.state.screenId}
-        />
-      );
-    }
-  };
-}

src2/screens/ScreenRegistry.test.js

@@ -1,130 +0,0 @@
-import React, {Component} from 'react';
-import {AppRegistry, Text} from 'react-native';
-import renderer from 'react-test-renderer';
-
-describe('ComponentRegistry', () => {
-  let uut;
-  let myScreenRef;
-  let testParentRef;
-  let screenStore;
-
-  class MyScreen extends Component {
-    constructor(props) {
-      super(props);
-      myScreenRef = this; //eslint-disable-line
-    }
-
-    render() {
-      return <Text>{'Hello, World!'}</Text>;
-    }
-  }
-
-  class TestParent extends Component { //eslint-disable-line
-    constructor(props) {
-      super(props);
-      testParentRef = this; //eslint-disable-line
-      this.ChildClass = props.ChildClass;
-      this.state = {propsFromState: {}};
-    }
-
-    render() {
-      const Child = this.ChildClass;
-      return (
-        <Child screenId="screen1" {...this.state.propsFromState}/>
-      );
-    }
-  }
-
-  beforeEach(() => {
-    uut = require('./ScreenRegistry');
-    screenStore = require('./ScreenStore');
-  });
-
-  afterEach(() => {
-    myScreenRef = null;
-    testParentRef = null;
-  });
-
-  describe('registerScreen', () => {
-    beforeEach(() => {
-      AppRegistry.registerComponent = jest.fn(AppRegistry.registerComponent);
-    });
-
-    it('registers screen component by screenKey into AppRegistry', () => {
-      expect(AppRegistry.registerComponent).not.toHaveBeenCalled();
-      uut.registerScreen('example.MyScreen.key', () => MyScreen);
-      expect(AppRegistry.registerComponent).toHaveBeenCalledTimes(1);
-      expect(AppRegistry.registerComponent.mock.calls[0][0]).toEqual('example.MyScreen.key');
-    });
-
-    it('resulting in a normal component', () => {
-      uut.registerScreen('example.MyScreen.key', () => MyScreen);
-      const Screen = AppRegistry.registerComponent.mock.calls[0][1]();
-      const tree = renderer.create(<Screen screenId="123"/>);
-      expect(tree.toJSON().children).toEqual(['Hello, World!']);
-    });
-  });
-
-  describe('NavigationScreen wrapping', () => {
-    const screenKey = 'example.MyScreen';
-
-    beforeEach(() => {
-      uut.registerScreen(screenKey, () => MyScreen);
-    });
-
-    it('must have screenId as prop', () => {
-      const NavigationScreen = screenStore.getScreenClass(screenKey);
-      expect(() => {
-        renderer.create(<NavigationScreen/>);
-      }).toThrow(new Error('Screen example.MyScreen does not have a screenId!'));
-    });
-
-    it('wraps the screen and saves to store', () => {
-      const NavigationScreen = screenStore.getScreenClass(screenKey);
-      expect(NavigationScreen).not.toBeInstanceOf(MyScreen);
-      const tree = renderer.create(<NavigationScreen screenId={'screen1'}/>);
-      expect(tree.toJSON().children).toEqual(['Hello, World!']);
-      expect(myScreenRef).toBeInstanceOf(MyScreen);
-    });
-
-    it('injects props from wrapper into original screen', () => {
-      const NavigationScreen = screenStore.getScreenClass(screenKey);
-      renderer.create(<NavigationScreen screenId={'screen1'} myProp={'yo'}/>);
-      expect(myScreenRef.props.myProp).toEqual('yo');
-    });
-
-    it('updates props from wrapper into original screen', () => {
-      const NavigationScreen = screenStore.getScreenClass(screenKey);
-      renderer.create(<TestParent ChildClass={NavigationScreen}/>);
-      expect(myScreenRef.props.foo).toEqual(undefined);
-      testParentRef.setState({propsFromState: {foo: 'yo'}});
-      expect(myScreenRef.props.foo).toEqual('yo');
-    });
-
-    it('pulls props from the PropsStore and injects them into the inner screen', () => {
-      require('./PropsStore').setPropsForScreenId('screen123', {numberProp: 1, stringProp: 'hello', objectProp: {a: 2}});
-      const NavigationScreen = screenStore.getScreenClass(screenKey);
-      renderer.create(<NavigationScreen screenId={'screen123'}/>);
-      expect(myScreenRef.props).toEqual({screenId: 'screen123', numberProp: 1, stringProp: 'hello', objectProp: {a: 2}});
-    });
-
-    it('updates props from PropsStore into inner screen', () => {
-      const NavigationScreen = screenStore.getScreenClass(screenKey);
-      renderer.create(<TestParent ChildClass={NavigationScreen}/>);
-      require('./PropsStore').setPropsForScreenId('screen1', {myProp: 'hello'});
-      expect(myScreenRef.props.foo).toEqual(undefined);
-      expect(myScreenRef.props.myProp).toEqual(undefined);
-      testParentRef.setState({propsFromState: {foo: 'yo'}});
-      expect(myScreenRef.props.foo).toEqual('yo');
-      expect(myScreenRef.props.myProp).toEqual('hello');
-    });
-
-    it('protects screenId from change', () => {
-      const NavigationScreen = screenStore.getScreenClass(screenKey);
-      renderer.create(<TestParent ChildClass={NavigationScreen}/>);
-      expect(myScreenRef.props.screenId).toEqual('screen1');
-      testParentRef.setState({propsFromState: {screenId: 'ERROR'}});
-      expect(myScreenRef.props.screenId).toEqual('screen1');
-    });
-  });
-});

src2/screens/ScreenStore.js

@@ -1,11 +0,0 @@
-const state = {
-  screensByKey: {}
-};
-
-export function saveScreenClass(screenKey, ScreenClass) {
-  state.screensByKey[screenKey] = ScreenClass;
-}
-
-export function getScreenClass(screenKey) {
-  return state.screensByKey[screenKey];
-}

src2/screens/ScreenStore.test.js

@@ -1,19 +0,0 @@
-describe('ScreenStore', () => {
-  let uut;
-
-  beforeEach(() => {
-    uut = require('./ScreenStore');
-  });
-
-  class Component {
-    //
-  }
-  class MyComponent extends Component {
-    //
-  }
-
-  it('holds screens classes by screenKey', () => {
-    uut.saveScreenClass('example.mykey', MyComponent);
-    expect(uut.getScreenClass('example.mykey')).toEqual(MyComponent);
-  });
-});