Immutable support

package.json

@@ -44,6 +44,7 @@
     "chai": "^3.5.0",
     "enzyme": "^3.1.0",
     "enzyme-adapter-react-16": "^1.0.3",
+    "immutable": "^3.8.2",
     "mocha": "^3.0.2",
     "prop-types": "^15.5.8",
     "react": "^16.0.0",

src/victory-util/data.js

@@ -2,6 +2,7 @@ import { assign, uniq, range, last, isFunction, property, sortBy } from "lodash"
 import Helpers from "./helpers";
 import Collection from "./collection";
 import Scale from "./scale";
+import Immutable from "./immutable";
 
 export default {
   /**
@@ -12,7 +13,7 @@ export default {
   getData(props) {
     let data;
     if (props.data) {
-      if (props.data.length < 1) {
+      if (Immutable.isIterable(props.data) ? props.data.size < 1 : props.data.length < 1) {
         return [];
       } else {
         data = this.formatData(props.data, props);
@@ -63,34 +64,45 @@ export default {
    * @returns {Array} the formatted data
    */
   formatData(dataset, props, stringMap) {
-    if (!Array.isArray(dataset)) {
+    const isArrayOrIterable = Array.isArray(dataset) || Immutable.isIterable(dataset);
+    if (!isArrayOrIterable) {
       return [];
     }
+
     stringMap = stringMap || {
       x: this.createStringMap(props, "x"),
       y: this.createStringMap(props, "y")
     };
+
     const accessor = {
       x: Helpers.createAccessor(props.x !== undefined ? props.x : "x"),
       y: Helpers.createAccessor(props.y !== undefined ? props.y : "y"),
       y0: Helpers.createAccessor(props.y0 !== undefined ? props.y0 : "y0")
     };
-    const data = dataset.map((datum, index) => {
+
+    const data = dataset.reduce((dataArr, datum, index) => { // eslint-disable-line complexity
+      datum = Immutable.isImmutable(datum) ? Immutable.shallowToJS(datum) : datum;
+
       const evaluatedX = datum._x !== undefined ? datum._x : accessor.x(datum);
       const evaluatedY = datum._y !== undefined ? datum._y : accessor.y(datum);
       const y0 = datum._y0 !== undefined ? datum._y0 : accessor.y0(datum);
       const x = evaluatedX !== undefined ? evaluatedX : index;
       const y = evaluatedY !== undefined ? evaluatedY : datum;
       const originalValues = y0 === undefined ? { x, y } : { x, y, y0 };
       const privateValues = y0 === undefined ? { _x: x, _y: y } : { _x: x, _y: y, _y0: y0 };
-      return assign(
+
+      dataArr.push(
+        assign(
           originalValues, datum, privateValues,
           // map string data to numeric values, and add names
           typeof x === "string" ? { _x: stringMap.x[x], xName: x } : {},
           typeof y === "string" ? { _y: stringMap.y[y], yName: y } : {},
           typeof y0 === "string" ? { _y0: stringMap.y[y0], yName: y0 } : {}
-        );
-    });
+        )
+      );
+
+      return dataArr;
+    }, []);
 
     const sortedData = this.sortData(data, props.sortKey, props.sortOrder);
 
@@ -196,7 +208,8 @@ export default {
    * @returns {Array} an array of strings
    */
   getStringsFromData(props, axis) {
-    if (!Array.isArray(props.data)) {
+    const isArrayOrIterable = Array.isArray(props.data) || Immutable.isIterable(props.data);
+    if (!isArrayOrIterable) {
       return [];
     }
     const key = typeof props[axis] === "undefined" ? axis : props[axis];

src/victory-util/helpers.js

@@ -1,6 +1,7 @@
+import React from "react";
 import { defaults, isFunction, property, omit, reduce } from "lodash";
 import Collection from "./collection";
-import React from "react";
+import Immutable from "./immutable";
 
 export default {
   getPoint(datum) {
@@ -144,7 +145,18 @@ export default {
       return (x) => x;
     }
     // otherwise, assume it is an array index, property key or path (_.property handles all three)
-    return property(key);
+    return (x) => {
+      if (Immutable.isImmutable(x)) {
+        if (Array.isArray(key)) {
+          return x.getIn(key);
+        } else if (typeof key === "string") {
+          return x.getIn(key.split("."));
+        } else {
+          return x.get(key);
+        }
+      }
+      return property(key)(x);
+    };
   },
 
   modifyProps(props, fallbackProps, role) {

src/victory-util/immutable.js

@@ -0,0 +1,33 @@
+export default {
+  IMMUTABLE_ITERABLE: "@@__IMMUTABLE_ITERABLE__@@",
+  IMMUTABLE_RECORD: "@@__IMMUTABLE_RECORD__@@",
+  IMMUTABLE_LIST: "@@__IMMUTABLE_LIST__@@",
+  IMMUTABLE_MAP: "@@__IMMUTABLE_MAP__@@",
+
+  isImmutable(x) {
+    return this.isIterable(x) || this.isRecord(x);
+  },
+
+  isIterable(x) {
+    return !!(x && x[this.IMMUTABLE_ITERABLE]);
+  },
+
+  isRecord(x) {
+    return !!(x && x[this.IMMUTABLE_RECORD]);
+  },
+
+  isList(x) {
+    return !!(x && x[this.IMMUTABLE_LIST]);
+  },
+
+  isMap(x) {
+    return !!(x && x[this.IMMUTABLE_MAP]);
+  },
+
+  shallowToJS(x) {
+    return this.isIterable(x) ? x.reduce((prev, curr, key) => {
+      prev[key] = curr;
+      return prev;
+    }, this.isList(x) ? [] : {}) : x;
+  }
+};