sg-heatmap/dist/index.js

Open-source all-in-one Swiss Army knife tool for creating Choropleth maps

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.Feature = undefined;

var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };

var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _minBy = require('lodash/minBy');

var _minBy2 = _interopRequireDefault(_minBy);

var _maxBy = require('lodash/maxBy');

var _maxBy2 = _interopRequireDefault(_maxBy);

var _cloneDeep = require('lodash/cloneDeep');

var _cloneDeep2 = _interopRequireDefault(_cloneDeep);

var _isEqual = require('lodash/isEqual');

var _isEqual2 = _interopRequireDefault(_isEqual);

var _partition3 = require('lodash/partition');

var _partition4 = _interopRequireDefault(_partition3);

var _geometry2 = require('./helpers/geometry');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }

function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var SgHeatmap = function () {
  function SgHeatmap(data) {
    _classCallCheck(this, SgHeatmap);

    var _data = typeof data === 'string' ? JSON.parse(data) : data;
    if (!(_data instanceof Array)) throw new Error('Expects an array of feature objects');
    this.children = _data.map(function (f) {
      return new Feature(f);
    });
    this._defaultState = {};
    this._updaters = [];
    this._stats = {};
  }

  _createClass(SgHeatmap, [{
    key: 'setDefaultState',
    value: function setDefaultState(_key, value) {
      this._defaultState[_key] = value;
      this.children.forEach(function (c) {
        if (_key in c.state) return;
        c.state[_key] = (0, _cloneDeep2.default)(value);
      });
      return this;
    }
  }, {
    key: 'resetState',
    value: function resetState() {
      var _this = this;

      this.children.forEach(function (c) {
        c.state = (0, _cloneDeep2.default)(_this._defaultState);
      });
      return this;
    }
  }, {
    key: 'registerUpdater',
    value: function registerUpdater(fn) {
      this._updaters.push(fn);
      return this;
    }
  }, {
    key: 'inspectUpdaters',
    value: function inspectUpdaters() {
      this._updaters.map(function (fn, i) {
        console.log('Inspecting updater "' + (i + 1) + '"');
        console.log(fn);
      });
    }
  }, {
    key: 'registerStat',
    value: function registerStat(key, fn) {
      this._stats[key] = fn;
      return this;
    }
  }, {
    key: 'inspectStats',
    value: function inspectStats() {
      var _this2 = this;

      Object.keys(this._stats).forEach(function (key, i) {
        console.log('Inspecting stat "' + key + '"');
        console.log(_this2._stats[key]);
      });
    }
  }, {
    key: 'bin',
    value: function bin(lnglat) {
      return this.children.filter(function (c) {
        return c.inside(lnglat);
      });
    }
  }, {
    key: 'update',
    value: function update(lnglat, weight) {
      var _this3 = this;

      this.bin(lnglat).forEach(function (c) {
        c.state = _this3._updaters.reduce(function (nextState, fn) {
          return Object.assign(nextState, fn(weight, c.state));
        }, {});
      });
      return this;
    }
  }, {
    key: 'getStat',
    value: function getStat(stat) {
      var _this4 = this;

      var fn = typeof stat === 'function' ? stat : this._stats[stat];

      var _partition = (0, _partition4.default)(this.children, function (c) {
        return !(0, _isEqual2.default)(_this4._defaultState, c.state);
      }),
          _partition2 = _slicedToArray(_partition, 2),
          changed = _partition2[0],
          unchanged = _partition2[1];

      var listedValues = [];
      var values = changed.reduce(function (stats, c) {
        var value = fn(c.state, c.properties);
        listedValues.push(value);
        return Object.assign(stats, _defineProperty({}, c.id, value));
      }, {});
      return {
        stat: stat,
        values: values,
        unchanged: unchanged.map(function (c) {
          return c.id;
        }),
        min: (0, _minBy2.default)(listedValues),
        max: (0, _maxBy2.default)(listedValues)
      };
    }
  }, {
    key: 'initializeRenderer',
    value: function initializeRenderer(colorScale) {
      var _this5 = this;

      var defaultStyle = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
      var addonStyle = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};

      if (!window) throw new Error('Method initializeRenderer should only be called browser-side');
      if (!window.google) throw new Error('Google Maps not loaded');
      if ('renderer' in this) {
        console.log('Existing renderer replaced');
        this.renderer.setMap(null);
      }

      this.colorScale = colorScale;

      this.renderer = new window.google.maps.Data({
        style: function style(feature) {
          var styleOptions = Object.assign({}, defaultStyle);
          var color = feature.getProperty('color');
          if (color) Object.assign(styleOptions, addonStyle, { fillColor: color });
          return styleOptions;
        }
      });
      this.children.forEach(function (c) {
        _this5.renderer.addGeoJson({
          id: c.id,
          type: 'Feature',
          geometry: c.geometry,
          properties: Object.assign({}, c.properties, { color: null })
        });
      });

      return this.renderer;
    }
  }, {
    key: 'render',
    value: function render(stat) {
      var _this6 = this;

      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};

      if (!this.renderer) throw new Error('Renderer has not been initialized');

      var colorScale = options.colorScale || this.colorScale;

      var _getStat = this.getStat(stat),
          statValues = _getStat.values,
          unchanged = _getStat.unchanged,
          min = _getStat.min,
          max = _getStat.max;

      var domain = options.domain || [min, max];
      function normalize(value) {
        return (value - domain[0]) / (domain[1] - domain[0]);
      }

      Object.keys(statValues).forEach(function (key) {
        var normalized = normalize(statValues[key]);
        var transformed = Math.pow(normalized, options.transform || 1);
        var color = colorScale(transformed);
        _this6.renderer.getFeatureById(key).setProperty('color', color);
      });
      unchanged.forEach(function (key) {
        _this6.renderer.getFeatureById(key).setProperty('color', null);
      });
    }
  }, {
    key: 'clone',
    value: function clone() {
      var includeState = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;

      var cloned = new SgHeatmap(this.children);
      cloned._updaters = [].concat(_toConsumableArray(this._updaters));
      cloned._stats = _extends({}, this._stats);
      if (includeState) {
        cloned._defaultState = this._defaultState;
      } else {
        cloned.children.forEach(function (c) {
          c.state = {};
        });
      }
      return cloned;
    }
  }, {
    key: 'serialize',
    value: function serialize() {
      var includeState = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;

      return '[' + this.children.map(function (c) {
        return c.serialize(includeState);
      }).join(',') + ']';
    }
  }]);

  return SgHeatmap;
}();

exports.default = SgHeatmap;

var Feature = exports.Feature = function () {
  function Feature(data) {
    _classCallCheck(this, Feature);

    if (!('id' in data)) throw new Error('Feature object requires id');
    if (!('geometry' in data)) throw new Error('Geometry not specified in feature object');
    this.type = 'Feature';
    this.id = data.id;
    this.properties = data.properties ? (0, _cloneDeep2.default)(data.properties) : {};

    this.geometry = {};
    this.geometry.type = data.geometry.type;
    if (this.geometry.type === 'Polygon') {
      this.geometry.coordinates = data.geometry.coordinates.map(_geometry2.toLinearRing);
      this.geometry.bbox = 'bbox' in data.geometry ? (0, _cloneDeep2.default)(data.geometry.bbox) : [(0, _minBy2.default)(this.geometry.coordinates[0], function (v) {
        return v[0];
      })[0], (0, _minBy2.default)(this.geometry.coordinates[0], function (v) {
        return v[1];
      })[1], (0, _maxBy2.default)(this.geometry.coordinates[0], function (v) {
        return v[0];
      })[0], (0, _maxBy2.default)(this.geometry.coordinates[0], function (v) {
        return v[1];
      })[1]];
    } else if (this.geometry.type === 'MultiPolygon') {
      this.geometry.coordinates = data.geometry.coordinates.map(function (polygon) {
        return polygon.map(_geometry2.toLinearRing);
      });
      if ('bbox' in data.geometry) {
        this.geometry.bbox = (0, _cloneDeep2.default)(data.geometry.bbox);
      } else {
        var bboxs = this.geometry.coordinates.map(function (polygon) {
          return [(0, _minBy2.default)(polygon[0], function (v) {
            return v[0];
          })[0], (0, _minBy2.default)(polygon[0], function (v) {
            return v[1];
          })[1], (0, _maxBy2.default)(polygon[0], function (v) {
            return v[0];
          })[0], (0, _maxBy2.default)(polygon[0], function (v) {
            return v[1];
          })[1]];
        });
        this.geometry.bbox = [(0, _minBy2.default)(bboxs, function (v) {
          return v[0];
        })[0], (0, _minBy2.default)(bboxs, function (v) {
          return v[1];
        })[1], (0, _maxBy2.default)(bboxs, function (v) {
          return v[2];
        })[2], (0, _maxBy2.default)(bboxs, function (v) {
          return v[3];
        })[3]];
      }
    } else {
      throw new Error('Feature geometry must be of type Polygon or MultiPolygon');
    }

    this.state = 'state' in data ? (0, _cloneDeep2.default)(data.state) : {};
  }

  _createClass(Feature, [{
    key: 'inside',
    value: function inside(location) {
      var _location = _slicedToArray(location, 2),
          lng = _location[0],
          lat = _location[1];

      if (lng < this.geometry.bbox[0]) return false;
      if (lat < this.geometry.bbox[1]) return false;
      if (lng > this.geometry.bbox[2]) return false;
      if (lat > this.geometry.bbox[3]) return false;

      if (this.geometry.type === 'Polygon') {
        return (0, _geometry2.inside)([lng, lat], this.geometry.coordinates[0]);
      } else {
        return this.geometry.coordinates.some(function (polygon) {
          return (0, _geometry2.inside)([lng, lat], polygon[0]);
        });
      }
    }
  }, {
    key: 'serialize',
    value: function serialize() {
      var includeState = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
      var id = this.id,
          properties = this.properties,
          geometry = this.geometry,
          state = this.state;

      var _geometry = {
        type: geometry.type,
        bbox: geometry.bbox,
        coordinates: geometry.type === 'Polygon' ? geometry.coordinates.map(_geometry2.encodePolyline) : geometry.coordinates.map(function (polygon) {
          return polygon.map(_geometry2.encodePolyline);
        })
      };
      var _state = includeState ? state : {};
      return JSON.stringify({ id: id, properties: properties, geometry: _geometry, state: _state });
    }
  }]);

  return Feature;
}();