@hackoregon/component-library/dist/MultiLayerMap/createLayers.js

Official repo for Hack Oregon React component library

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.createSizeScale = exports.createColorScale = exports.updateQuantileScale = exports.updateEqualScale = void 0;

var _d = require("d3");

var _mapStyles = _interopRequireDefault(require("./mapStyles"));

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

function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread(); }

function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance"); }

function _iterableToArray(iter) { if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter); }

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

var white = "#fff";

var convertToRGB = function convertToRGB(colorArray) {
  return colorArray.map(function (d) {
    return (0, _d.color)(d) ? (0, _d.color)(d) : (0, _d.color)(white);
  }).map(function (d) {
    return [d.r, d.g, d.b];
  });
};

var createRange = function createRange(civicColor, colorRange) {
  if (colorRange.length) {
    if ((0, _d.color)(colorRange[0])) {
      return convertToRGB(colorRange);
    }

    return colorRange;
  }

  if (civicColor && _mapStyles["default"][civicColor]) {
    return _mapStyles["default"][civicColor];
  }

  return _mapStyles["default"].earth;
};

var createEqualScale = function createEqualScale() {
  return (0, _d.scaleQuantize)();
};

var updateEqualScale = function updateEqualScale(featuresData, equalScale, civicColorSelection, equalDomain, equalRange, field) {
  var colorFieldName = field.color;
  var domain = equalDomain.length ? equalDomain : (0, _d.extent)(featuresData, function (d) {
    return +d.properties[colorFieldName];
  });
  var range = createRange(civicColorSelection, equalRange);
  return equalScale.domain(domain).range(range).nice();
};

exports.updateEqualScale = updateEqualScale;

var createQuantileScale = function createQuantileScale() {
  return (0, _d.scaleQuantile)();
};

var updateQuantileScale = function updateQuantileScale(featuresData, quantileScale, civicColorSelection, quantileRange, field) {
  var colorFieldName = field.color;
  var domain = featuresData.map(function (d) {
    return +d.properties[colorFieldName];
  }).reduce(function (a, c) {
    return a.indexOf(c) === -1 ? [].concat(_toConsumableArray(a), [c]) : a;
  }, []);
  var colorRange = quantileRange.length ? quantileRange : _mapStyles["default"][civicColorSelection] ? _mapStyles["default"][civicColorSelection] : _mapStyles["default"].earth;
  return quantileScale.domain(domain).range(colorRange);
};

exports.updateQuantileScale = updateQuantileScale;

var createThresholdScale = function createThresholdScale(civicColorSelection, categories, customColors) {
  var range = createRange(civicColorSelection, customColors);
  return (0, _d.scaleThreshold)().domain(categories).range(range);
};

var createDiscreteScale = function createDiscreteScale(categories, colorRange) {
  var range = createRange("", colorRange);
  return (0, _d.scaleOrdinal)().domain(categories).range(range).unknown([255, 255, 255, 128]);
};

var createColorScale = function createColorScale(colorSelection) {
  var scaleType = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
  var dataRange = arguments.length > 2 ? arguments[2] : undefined;
  var colorRange = arguments.length > 3 ? arguments[3] : undefined;
  var colorScaleType = scaleType.color;

  if (scaleType && colorScaleType === "equal") {
    return createEqualScale();
  }

  if (scaleType && colorScaleType === "quantile") {
    return createQuantileScale();
  }

  if (scaleType && colorScaleType === "threshold") {
    return createThresholdScale(colorSelection, dataRange, colorRange);
  }

  if (scaleType && colorScaleType === "ordinal") {
    return createDiscreteScale(dataRange, colorRange);
  }

  return function () {
    return _mapStyles["default"][colorSelection];
  };
};

exports.createColorScale = createColorScale;

var createSizeScale = function createSizeScale(width) {
  var scaleType = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
  var fieldName = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
  var areaScaleType = scaleType.area;
  var areaFieldName = fieldName.area;

  if (scaleType && areaScaleType === "circle area") {
    return function (feature) {
      return Math.sqrt(feature.properties[areaFieldName] / Math.PI);
    };
  }

  return function () {
    return width;
  };
};

exports.createSizeScale = createSizeScale;