Add seamless support for ImmutableJS structures in select() path (#160)

* Add seamless support for ImmutableJS structures in select() path

* Do not depend upon immutablejs, only use it if the project uses it

* Add comment to make clear the purpose of the try/catch

* Add unit tests related to optional ImmutableJS support

Author: clbond

package.json

@@ -51,6 +51,7 @@
     "es6-shim": "^0.35.0",
     "expect": "^1.8.0",
     "mocha": "^2.4.5",
+    "proxyquire": "^1.7.10",
     "redux": "^3.4.0",
     "reflect-metadata": "0.1.3",
     "rimraf": "^2.5.2",

src/___tests___/utils/get-in.immutable.spec.ts

@@ -0,0 +1,41 @@
+const proxyquire = require('proxyquire');
+
+const { getIn: getInWithImmutable } = proxyquire('../../utils/get-in', {
+  immutable: {
+    Iterable: {
+      isIterable: value => typeof value.getIn === 'function',
+    },
+    '@noCallThru': true,
+  },
+});
+
+const { getIn: getInWithNoImmutable } = require('../../utils/get-in');
+
+import { expect } from 'chai';
+
+describe('getIn', () => {
+  it('should make use of immutable when available in host project', () => {
+    const getIn =
+      path => {
+        expect(path.length).to.equal(1);
+        expect(path[0]).to.equal('foo');
+        return 't';
+      };
+
+    const fakeImmutable = { getIn: getIn };
+
+    expect(getInWithImmutable(fakeImmutable, [ 'foo' ])).to.equal('t');
+  });
+
+  it('should work on regular objects even when immutable is available', () => {
+    const test = { foo: 1 };
+
+    expect(getInWithImmutable(test, [ 'foo' ])).to.equal(1);
+  });
+
+  it('should run without immutable when immutable is not available', () => {
+    const test = { foo: 1 };
+
+    expect(getInWithNoImmutable(test, [ 'foo' ])).to.equal(1);
+  });
+});

src/utils/get-in.ts

@@ -1,15 +1,28 @@
+// This may look suspicious, but the point is to add ImmutableJS integration
+// only if the project itself already has a dependency on immutable. If not,
+// then this variable is left null and no integration is attempted.
+let immutable;
+try {
+  immutable = require('immutable');
+} catch (e) {}
+
 /*
  * Gets a deeply-nested property value from an object, given a 'path'
  * of property names or array indices.
  */
 export function getIn(
   v: Object,
   pathElems: (string | number)[]): any {
-    const [ firstElem, ...restElems] = pathElems;
     if (!v) {
       return v;
     }
 
+    if (immutable && immutable.Iterable.isIterable(v)) {
+      return (<{getIn: (path: (string | number)[]) => any}>v).getIn(pathElems);
+    }
+
+    const [ firstElem, ...restElems] = pathElems;
+
     if (undefined === v[firstElem]) {
       return undefined;
     }
@@ -20,3 +33,4 @@ export function getIn(
 
     return getIn(v[firstElem], restElems);
 }
+