kepler.gl.geoiq/dist/layers/boundary-layer/boundary-layer.js

kepler.gl is a webgl based application to visualize large scale location data in the browser

"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = exports.geojsonVisConfigs = exports.pointVisConfigs = exports.boundaryRequiredColumns = exports.pointLabelResolver = exports.pointLabelAccessor = exports.pointHeightPosResolver = exports.pointHeightPosAccessor = exports.pointPosResolver = exports.pointPosAccessor = void 0;

var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));

var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));

var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));

var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));

var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));

var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));

var _get2 = _interopRequireDefault(require("@babel/runtime/helpers/get"));

var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));

var _baseLayer = _interopRequireDefault(require("../base-layer"));

var _deck = require("deck.gl");

var _lodash = _interopRequireDefault(require("lodash.memoize"));

var _solidPolygonLayer = _interopRequireDefault(require("../../deckgl-layers/geojson-layer/solid-polygon-layer"));

var _aggregateUtils = require("../../utils/aggregate-utils");

var _scatterplotBrushingLayer = _interopRequireDefault(require("../../deckgl-layers/scatterplot-brushing-layer/scatterplot-brushing-layer"));

var _lodash2 = _interopRequireDefault(require("lodash.uniq"));

var _colorUtils = require("../../utils/color-utils");

var _boundaryLayerIcon = _interopRequireDefault(require("./boundary-layer-icon"));

var _defaultSettings = require("../../constants/default-settings");

var _axios = _interopRequireDefault(require("axios"));

var _collect = _interopRequireDefault(require("@turf/collect"));

var _helpers = require("@turf/helpers");

var _d3Array = require("d3-array");

var _dataUtils = require("../../utils/data-utils");

function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2["default"])(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

function onlyUnique(value, index, self) {
  return self.indexOf(value) === index;
}

function filterNull(arr) {
  return arr > 0 || isNaN(arr) === true;
}

function saveText(text, filename) {
  var a = document.createElement('a');
  a.setAttribute('href', 'data:text/plain;charset=utf-u,' + encodeURIComponent(text));
  a.setAttribute('download', filename);
  a.click();
}

var pointPosAccessor = function pointPosAccessor(_ref) {
  var columns = _ref.columns,
      colorField = _ref.colorField;
  return function (d) {
    var lat = columns.lat,
        lng = columns.lng,
        altitude = columns.altitude;
    var data;

    if (colorField) {
      data = d.data[colorField.tableFieldIndex - 1];
    } else {
      data = 1;
    }

    if (d.data[lng.fieldIdx] && d.data[lat.fieldIdx] //  &&
    // !is.NaN(d.data[lat.fieldIdx]) &&
    // !is.NaN(d.data[lat.fieldIdx])
    ) {
        return [(0, _helpers.point)([d.data[lng.fieldIdx], d.data[lat.fieldIdx]], {
          aggregationData: data
        })];
      }
  };
};

exports.pointPosAccessor = pointPosAccessor;

var pointPosResolver = function pointPosResolver(_ref2) {
  var columns = _ref2.columns,
      colorField = _ref2.colorField;
  return "".concat(columns.lat.fieldIdx, "-").concat(columns.lng.fieldIdx, "-").concat(columns.altitude ? columns.altitude.fieldIdx : 'z', "-").concat(colorField ? colorField.tableFieldIndex : null);
};

exports.pointPosResolver = pointPosResolver;

var pointHeightPosAccessor = function pointHeightPosAccessor(_ref3) {
  var columns = _ref3.columns,
      heightField = _ref3.heightField;
  return function (d) {
    var lat = columns.lat,
        lng = columns.lng,
        altitude = columns.altitude;
    var data;

    if (heightField) {
      data = d.data[heightField.tableFieldIndex - 1];
    } else {
      data = 1;
    }

    if (d.data[lng.fieldIdx] && d.data[lat.fieldIdx] //  &&
    // !is.NaN(d.data[lat.fieldIdx]) &&
    // !is.NaN(d.data[lat.fieldIdx])
    ) {
        return [(0, _helpers.point)([d.data[lng.fieldIdx], d.data[lat.fieldIdx]], {
          heightAggregationData: data
        })];
      }
  };
};

exports.pointHeightPosAccessor = pointHeightPosAccessor;

var pointHeightPosResolver = function pointHeightPosResolver(_ref4) {
  var columns = _ref4.columns,
      heightField = _ref4.heightField;
  return "".concat(columns.lat.fieldIdx, "-").concat(columns.lng.fieldIdx, "-").concat(columns.altitude ? columns.altitude.fieldIdx : 'z', "-").concat(heightField ? heightField.tableFieldIndex : null);
};

exports.pointHeightPosResolver = pointHeightPosResolver;

var getLayerColorRange = function getLayerColorRange(colorRange) {
  return colorRange.colors.map(_colorUtils.hexToRgb);
};

var pointLabelAccessor = function pointLabelAccessor(textLabel) {
  return function (d) {
    return String(d.data[textLabel.field.tableFieldIndex - 1]);
  };
};

exports.pointLabelAccessor = pointLabelAccessor;

var pointLabelResolver = function pointLabelResolver(textLabel) {
  return textLabel.field && textLabel.field.tableFieldIndex;
};

exports.pointLabelResolver = pointLabelResolver;
var boundaryRequiredColumns = ['lat', 'lng']; // export const pointOptionalColumns = ['altitude'];

exports.boundaryRequiredColumns = boundaryRequiredColumns;
var pointVisConfigs = {
  radius: 'radius',
  fixedRadius: 'fixedRadius',
  opacity: 'opacity',
  outline: 'outline',
  thickness: 'thickness',
  colorRange: 'colorRange',
  radiusRange: 'radiusRange',
  'hi-precision': 'hi-precision'
};
exports.pointVisConfigs = pointVisConfigs;
var geojsonVisConfigs = {
  opacity: 'opacity',
  thickness: {
    type: 'number',
    defaultValue: 0.5,
    label: 'Stroke Width',
    isRanged: false,
    range: [0, 100],
    step: 0.1,
    group: 'stroke',
    property: 'thickness'
  },
  colorRange: 'colorRange',
  radius: 'radius',
  colorAggregation: 'aggregation',
  heightAggregation: 'heightAggregation',
  sizeRange: 'strokeWidthRange',
  radiusRange: 'radiusRange',
  heightRange: 'elevationRange',
  elevationScale: 'elevationScale',
  'hi-precision': 'hi-precision',
  stroked: 'stroked',
  filled: 'filled',
  enable3d: 'enable3d',
  wireframe: 'wireframe'
};
exports.geojsonVisConfigs = geojsonVisConfigs;

var BoundaryLayer =
/*#__PURE__*/
function (_Layer) {
  (0, _inherits2["default"])(BoundaryLayer, _Layer);

  function BoundaryLayer(props) {
    var _this;

    (0, _classCallCheck2["default"])(this, BoundaryLayer);
    _this = (0, _possibleConstructorReturn2["default"])(this, (0, _getPrototypeOf2["default"])(BoundaryLayer).call(this, props));

    _this.registerVisConfig(geojsonVisConfigs);

    _this.getPosition = (0, _lodash["default"])(pointPosAccessor, pointPosResolver);
    _this.getHeightPosition = (0, _lodash["default"])(pointHeightPosAccessor, pointHeightPosResolver);
    _this.getText = (0, _lodash["default"])(pointLabelAccessor, pointLabelResolver); // this.getColorValue = memoize(getValueAggr, aggrResolver);

    _this.getColorRange = (0, _lodash["default"])(getLayerColorRange);
    return _this;
  }

  (0, _createClass2["default"])(BoundaryLayer, [{
    key: "getVisualChannelDescription",

    /**
     * Get the description of a visualChannel config
     * @param key
     * @returns {{label: string, measure: (string|string)}}
     */
    value: function getVisualChannelDescription(key) {
      // e.g. label: Color, measure: Average of ETA
      var _this$visualChannels$ = this.visualChannels[key],
          range = _this$visualChannels$.range,
          field = _this$visualChannels$.field,
          defaultMeasure = _this$visualChannels$.defaultMeasure,
          aggregation = _this$visualChannels$.aggregation;
      return {
        label: this.visConfigSettings[range].label,
        measure: this.config[field] ? "".concat(this.config.visConfig[aggregation], " of ").concat(this.config[field].name) : defaultMeasure
      };
    }
  }, {
    key: "getHoverData",
    value: function getHoverData(object, allData) {
      // index of allData is saved to feature.properties
      return object;
    }
  }, {
    key: "getDefaultLayerConfig",
    value: function getDefaultLayerConfig() {
      var props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
      return _objectSpread({}, (0, _get2["default"])((0, _getPrototypeOf2["default"])(BoundaryLayer.prototype), "getDefaultLayerConfig", this).call(this, props), {
        // add height visual channel
        heightField: null,
        heightDomain: [0, 1],
        heightScale: 'linear'
      });
    }
    /**
     * Aggregation layer handles visual channel aggregation inside deck.gl layer
     */

  }, {
    key: "updateLayerVisualChannel",
    value: function updateLayerVisualChannel(_ref5, channel) {
      var data = _ref5.data,
          allData = _ref5.allData;
      this.validateVisualChannel(channel);
    } // /**
    //  * Validate aggregation type on top of basic layer visual channel validation
    //  * @param channel
    //  */

  }, {
    key: "validateVisualChannel",
    value: function validateVisualChannel(channel) {
      // field type decides aggregation type decides scale type
      this.validateFieldType(channel);
      this.validateAggregationType(channel);
      this.validateScale(channel);
    }
    /**
     * Validate aggregation type based on selected field
     */

  }, {
    key: "validateAggregationType",
    value: function validateAggregationType(channel) {
      var visualChannel = this.visualChannels[channel];
      var field = visualChannel.field,
          aggregation = visualChannel.aggregation;
      var aggregationOptions = this.getAggregationOptions(channel);

      if (!aggregation) {
        return;
      }

      if (!aggregationOptions.length) {
        // if field cannot be aggregated, set field to null
        this.updateLayerConfig((0, _defineProperty2["default"])({}, field, null));
      } else if (!aggregationOptions.includes(this.config.visConfig[aggregation])) {
        // current aggregation type is not supported by this field
        // set aggregation to the first supported option
        this.updateLayerVisConfig((0, _defineProperty2["default"])({}, aggregation, aggregationOptions[0]));
      }
    }
  }, {
    key: "getAggregationOptions",
    value: function getAggregationOptions(channel) {
      var visualChannel = this.visualChannels[channel];
      var field = visualChannel.field,
          channelScaleType = visualChannel.channelScaleType;
      return Object.keys(this.config[field] ? _defaultSettings.FIELD_OPTS[this.config[field].type].scale[channelScaleType] : _defaultSettings.DEFAULT_AGGREGATION[channelScaleType]);
    }
    /**
     * Get scale options based on current field and aggregation type
     * @param {string} channel
     * @returns {string[]}
     */

  }, {
    key: "getScaleOptions",
    value: function getScaleOptions(channel) {
      var visualChannel = this.visualChannels[channel];
      var field = visualChannel.field,
          aggregation = visualChannel.aggregation,
          channelScaleType = visualChannel.channelScaleType,
          scale = visualChannel.scale;
      var aggregationType = this.config.visConfig[aggregation];

      if (channel === 'height') {
        return this.getDefaultLayerConfig()[scale];
      }

      return this.config[field] ? // scale options based on aggregation
      _defaultSettings.FIELD_OPTS[this.config[field].type].scale[channelScaleType][aggregationType] : // default scale options for point count
      _defaultSettings.DEFAULT_AGGREGATION[channelScaleType][aggregationType];
    }
  }, {
    key: "axiosApiCall",
    value: function axiosApiCall(datasets) {
      var _this$config = this.config,
          dataId = _this$config.dataId,
          columns = _this$config.columns;
      var allData = datasets[dataId].allData;
      var latIdx = columns.lat.fieldIdx;
      var longIdx = columns.lng.fieldIdx;
      allData = allData.map(function (d) {
        if (!d[latIdx] || !d[longIdx]) {
          return null;
        }

        var lat = d[latIdx].toFixed(4);
        var lng = d[longIdx].toFixed(4);
        return lat + '_' + lng;
      });
      var uniqueAllData = allData.filter(onlyUnique);
      var uniqueAllData = allData.filter(filterNull);
      var uniqueAllData = uniqueAllData.map(function (d) {
        d = d.split('_');
        return d.map(function (d) {
          return Number(d);
        });
      });
      var boundaryAggregation = this.config.boundaryAggregation;
      var config = {
        headers: {
          'Content-Type': 'application/json',
          Authorization: 'Bearer ' + localStorage.getItem('accessToken')
        }
      };
      var data = {
        type: boundaryAggregation,
        coordinates: uniqueAllData
      };
      var url = 'https://app.geoiq.io/boundary/v1.0/boundary_query';

      var response = _axios["default"].post(url, data, config).then(function (response) {
        return response.data.result;
      })["catch"]();

      return response;
    }
    /**
     * helper function to update one layer domain when state.data changed
     * if state.data change is due ot update filter, newFiler will be passed
     * called by updateAllLayerDomainData
     * @param {Object} dataset
     * @param {Object} newFilter
     * @returns {object} layer
     * @returns {object} widget
     */

  }, {
    key: "updateLayerDomain",
    value: function updateLayerDomain(dataset, layerData, newFilter) {
      var _this2 = this;

      Object.values(this.visualChannels).forEach(function (channel) {
        var scale = channel.scale;
        var scaleType = _this2.config[scale]; // ordinal domain is based on allData, if only filter changed
        // no need to update ordinal domain

        if (!newFilter || scaleType !== _defaultSettings.SCALE_TYPES.ordinal) {
          var domain = channel.domain;

          var updatedDomain = _this2.calculateLayerDomain(dataset, layerData, channel);

          _this2.updateLayerConfig((0, _defineProperty2["default"])({}, domain, updatedDomain));
        }
      });
      return this;
    }
  }, {
    key: "calculateLayerDomain",
    value: function calculateLayerDomain(dataset, layerData, visualChannel) {
      var allData = dataset.allData,
          filteredIndexForDomain = dataset.filteredIndexForDomain;
      var colorField = this.config.colorField; // const defaultDomain = [0, 1];

      var defaultDomain;
      var values;

      if (layerData && colorField && layerData.collected) {
        values = layerData.collected.map(function (c) {
          return c.properties.aggregatedData;
        });
        return (0, _dataUtils.unique)(values).filter(_dataUtils.notNullorUndefined).sort();
      } else if (layerData && layerData.collected) {
        values = layerData.collected.map(function (c) {
          return c.properties.count;
        });
        return (0, _dataUtils.unique)(values).filter(_dataUtils.notNullorUndefined).sort();
      } else {
        defaultDomain = [0, 1];
      }

      var scale = visualChannel.scale;
      var scaleType = this.config[scale];
      var field = this.config[visualChannel.field];

      if (!field) {
        // if colorField or sizeField were set back to null
        return defaultDomain;
      }

      if (!_defaultSettings.SCALE_TYPES[scaleType]) {
        Console.error("scale type ".concat(scaleType, " not supported"));
        return defaultDomain;
      } // TODO: refactor to add valueAccessor to field


      var fieldIdx = field.tableFieldIndex - 1;
      var isTime = field.type === _defaultSettings.ALL_FIELD_TYPES.timestamp;

      var valueAccessor = _dataUtils.maybeToDate.bind(null, isTime, fieldIdx, field.format);

      var indexValueAccessor = function indexValueAccessor(i) {
        return valueAccessor(allData[i]);
      };

      var sortFunction = (0, _dataUtils.getSortingFunction)(field.type);

      if (!values) {
        return defaultDomain;
      }

      switch (scaleType) {
        case _defaultSettings.SCALE_TYPES.ordinal:
        case _defaultSettings.SCALE_TYPES.point:
          // do not recalculate ordinal domain based on filtered data
          // don't need to update ordinal domain every time
          return defaultDomain;

        case _defaultSettings.SCALE_TYPES.quantile:
          return values.filter(_dataUtils.notNullorUndefined).sort(sortFunction);

        case _defaultSettings.SCALE_TYPES.quantize:
        case _defaultSettings.SCALE_TYPES.linear:
        case _defaultSettings.SCALE_TYPES.sqrt:
        default:
          return (0, _d3Array.extent)(values).map(function (d, i) {
            return d === undefined ? i : d;
          });
      }
    }
  }, {
    key: "getEncodedChannelValue",
    value: function getEncodedChannelValue(scale, data, field) {
      var defaultValue = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : _defaultSettings.NO_VALUE_COLOR;
      var type = field.type;
      var value = data;
      var attributeValue;

      if (type === _defaultSettings.ALL_FIELD_TYPES.timestamp) {
        // shouldn't need to convert here
        // scale Function should take care of it
        attributeValue = scale(new Date(value));
      } else {
        attributeValue = scale(value);
      }

      if (!attributeValue) {
        attributeValue = defaultValue;
      }

      return attributeValue;
    }
  }, {
    key: "calculateHeightDomain",
    value: function calculateHeightDomain(value, minMax) {
      if (!minMax.length) {
        return [value, value];
      }

      var min = (0, _aggregateUtils.aggregate)([value, minMax[0]], 'minimum');
      var max = (0, _aggregateUtils.aggregate)([value, minMax[1]], 'maximum');
      return [min, max];
    }
  }, {
    key: "calculateBoundaryAggregatedData",
    value: function calculateBoundaryAggregatedData(collected, pointFC, heightPointFC, colorAggregation, heightAggregation, colorField, heightField) {
      var _this3 = this;

      var colorDomain = [];
      var heightDomain = [];

      if (collected && colorAggregation) {
        var minMax = []; //converting collected data into feature collection

        collected = (0, _helpers.featureCollection)(collected);
        var heightCollected = (0, _collect["default"])(collected, pointFC, 'aggregationData', 'values').features;
        collected = (0, _collect["default"])(collected, pointFC, 'aggregationData', 'values').features;
        collected.map(function (c, i) {
          var aggregatedData = 0;
          var values = c.properties.values;

          if (values.length) {
            aggregatedData = (0, _aggregateUtils.aggregate)(values, colorAggregation);
          } else {
            aggregatedData = 0;
          }

          if (!heightField) {
            minMax = _this3.calculateHeightDomain(values.length, minMax);
          }

          c.properties.count = values.length;
          c.properties.aggregatedData = aggregatedData;
          colorDomain[i] = colorField ? aggregatedData : values.length;
          heightDomain = [minMax[0], minMax[1]];
        });
      }

      var heightCollected;

      if (collected && heightField && heightAggregation) {
        var _minMax = [];
        heightCollected = (0, _helpers.featureCollection)(collected);
        heightCollected = (0, _collect["default"])(heightCollected, heightPointFC, 'heightAggregationData', 'values').features;
        heightCollected.map(function (c, i) {
          var heightAggregatedData = 0;
          var values = c.properties.values;

          if (values.length) {
            heightAggregatedData = (0, _aggregateUtils.aggregate)(values, heightAggregation);
          } else {
            heightAggregatedData = 0;
          }

          _minMax = heightField ? _this3.calculateHeightDomain(heightAggregatedData, _minMax) : _this3.calculateHeightDomain(values.length, _minMax);
          collected[i].properties.heightAggregatedData = heightAggregatedData;
          heightDomain = [_minMax[0], _minMax[1]];
        });
      }

      return {
        collected: collected,
        colorDomain: colorDomain,
        heightDomain: heightDomain
      };
    } // TODO: fix complexity

    /* eslint-disable complexity */

  }, {
    key: "formatLayerData",
    value: function formatLayerData(_, allData, filteredIndex, oldLayerData, response, opt) {
      var _this4 = this;

      var _this$config2 = this.config,
          colorScale = _this$config2.colorScale,
          colorField = _this$config2.colorField,
          color = _this$config2.color,
          sizeScale = _this$config2.sizeScale,
          sizeDomain = _this$config2.sizeDomain,
          sizeField = _this$config2.sizeField,
          textLabel = _this$config2.textLabel,
          heightField = _this$config2.heightField,
          heightScale = _this$config2.heightScale,
          radiusField = _this$config2.radiusField,
          radiusDomain = _this$config2.radiusDomain,
          radiusScale = _this$config2.radiusScale,
          visConfig = _this$config2.visConfig,
          columns = _this$config2.columns;
      var _this$config3 = this.config,
          heightDomain = _this$config3.heightDomain,
          colorDomain = _this$config3.colorDomain; // const {
      //   colorScale,
      //   colorDomain,
      //   colorField,
      //   color,
      //   columns,
      //   sizeField,
      //   sizeScale,
      //   sizeDomain,
      //   textLabel,
      //   visConfig: {radiusRange, fixedRadius, colorRange}
      // } = this.config;

      var enable3d = visConfig.enable3d,
          stroked = visConfig.stroked,
          colorRange = visConfig.colorRange,
          heightRange = visConfig.heightRange,
          sizeRange = visConfig.sizeRange,
          radiusRange = visConfig.radiusRange,
          colorAggregation = visConfig.colorAggregation,
          heightAggregation = visConfig.heightAggregation; // this.getPosition.cache.delete();

      var getPosition = this.getPosition({
        columns: columns,
        colorField: colorField
      });
      var getHeightPosition = this.getHeightPosition({
        columns: columns,
        heightField: heightField
      }); // if (!oldLayerData || oldLayerData.getHeightPosition !== getHeightPosition) {
      //   this.updateLayerMeta(allData, getHeightPositon);
      // }

      if (!oldLayerData || oldLayerData.getPosition !== getPosition) {
        this.updateLayerMeta(allData, getPosition);
      }

      if (oldLayerData && oldLayerData.collected) {
        var collected = oldLayerData.collected;
      }

      var data, heightData;

      if (oldLayerData && oldLayerData.data && opt.sameData && oldLayerData.getPosition === getPosition && oldLayerData.getHeightPosition === getHeightPosition) {
        data = oldLayerData.data;
        heightData = oldLayerData.heightData;
      } else {
        data = filteredIndex.reduce(function (accu, index) {
          var pos = getPosition({
            data: allData[index]
          }); // if doesn't have point lat or lng, do not add the point
          // deck.gl can't handle position = null
          // if (!pos.every(Number.isFinite)) {
          //   return accu;
          // }

          if (pos) {
            accu.push.apply(accu, (0, _toConsumableArray2["default"])(pos));
          }

          return accu;
        }, []);
        heightData = filteredIndex.reduce(function (accu, index) {
          var pos = getHeightPosition({
            data: allData[index]
          }); // if doesn't have point lat or lng, do not add the point
          // deck.gl can't handle position = null
          // if (!pos.every(Number.isFinite)) {
          //   return accu;
          // }

          if (pos) {
            accu.push.apply(accu, (0, _toConsumableArray2["default"])(pos));
          }

          return accu;
        }, []);
      }

      var pointFC = (0, _helpers.featureCollection)(data);
      var heightPointFC = heightField ? (0, _helpers.featureCollection)(heightData) : [];
      colorDomain = [];

      if (response) {
        collected = (0, _collect["default"])(response, pointFC, 'aggregationData', 'values').features;
        collected.map(function (c) {
          var values = c.properties.values;
          c.properties.count = values.length;
          colorDomain.push(values.length);
        });
      }

      var _this$calculateBounda = this.calculateBoundaryAggregatedData(collected, pointFC, heightPointFC, colorAggregation, heightAggregation, colorField, heightField),
          collected = _this$calculateBounda.collected,
          colorDomain = _this$calculateBounda.colorDomain,
          heightDomain = _this$calculateBounda.heightDomain;

      Object.values(this.visualChannels).forEach(function (channel) {
        var scale = channel.scale,
            domain = channel.domain; // ordinal domain is based on allData, if only filter changed
        // no need to update ordinal domain

        if (collected) {
          var updatedDomain = _this4.calculateLayerDomain({}, {
            collected: collected
          }, channel);

          _this4.updateLayerConfig((0, _defineProperty2["default"])({}, domain, updatedDomain));
        }
      }); //used for saving geoJson
      // if (collected) {
      //   saveText(JSON.stringify(featureCollection(collected)), 'filename.json');
      // }
      // }

      var cScale = this.getVisChannelScale(colorScale, colorDomain, colorRange.colors.map(_colorUtils.hexToRgb)); // calculate stroke scale - if stroked = true

      var sScale = sizeField && stroked && this.getVisChannelScale(sizeScale, sizeDomain, sizeRange); // calculate elevation scale - if extruded = true

      var eScale = this.getVisChannelScale(heightScale, heightDomain, heightRange);
      return {
        collected: collected,
        data: data,
        heightData: heightData,
        getPosition: getPosition,
        getHeightPosition: getHeightPosition,
        getFillColor: function getFillColor(d) {
          return colorField ? _this4.getEncodedChannelValue(cScale, d.properties.aggregatedData, colorField) : _this4.getEncodedChannelValue(cScale, d.properties.count, {
            type: 'real'
          });
        },
        getLineColor: function getLineColor(d) {
          return colorField ? _this4.getEncodedChannelValue(cScale, d.properties.aggregatedData, colorField) : _this4.getEncodedChannelValue(cScale, d.properties.count, {
            type: 'real'
          });
        },
        getLineWidth: function getLineWidth(d) {
          return sScale ? _this4.getEncodedChannelValue(sScale, allData[d.properties.index], sizeField, 0) : d.properties.lineWidth || 1;
        },
        getElevation: function getElevation(d) {
          return heightField ? _this4.getEncodedChannelValue(eScale, d.properties.heightAggregatedData, heightField, 0) : _this4.getEncodedChannelValue(eScale, d.properties.count, {
            type: 'real'
          }, 0);
        }
      };
    }
    /* eslint-enable complexity */

  }, {
    key: "updateLayerMeta",
    value: function updateLayerMeta(allData, getPosition) {
      var bounds = this.getPointsBounds(allData, function (d) {
        return getPosition({
          data: d
        });
      }); // get bounds from features
      // const bounds = getGeojsonBounds(allFeatures);
      // get lightSettings from points

      var lightSettings = this.getLightSettingsFromBounds(bounds); // if any of the feature has properties.hi-precision set to be true

      var fp64 = false;
      var fixedRadius = false; // keep a record of what type of geometry the collection has

      var featureTypes = {
        polygon: true
      };
      this.updateMeta({
        bounds: bounds,
        lightSettings: lightSettings,
        fp64: fp64,
        fixedRadius: fixedRadius,
        featureTypes: featureTypes
      });
    }
  }, {
    key: "renderLayer",
    value: function renderLayer(_ref6) {
      var data = _ref6.data,
          idx = _ref6.idx,
          objectHovered = _ref6.objectHovered,
          mapState = _ref6.mapState,
          interactionConfig = _ref6.interactionConfig;
      var _this$meta = this.meta,
          fp64 = _this$meta.fp64,
          lightSettings = _this$meta.lightSettings,
          fixedRadius = _this$meta.fixedRadius;
      var radiusScale = this.getRadiusScaleByZoom(mapState, fixedRadius);
      var zoomFactor = this.getZoomFactor(mapState);
      var visConfig = this.config.visConfig; // console.log(this.config.apiCallRequest);

      var layerProps = {
        // multiplier applied just so it being consistent with previously saved maps
        lineWidthScale: visConfig.thickness * zoomFactor * 8,
        lineWidthMinPixels: 1,
        elevationScale: visConfig.elevationScale,
        pointRadiusScale: radiusScale,
        fp64: fp64 || visConfig['hi-precision'],
        lineMiterLimit: 4
      };
      var updateTriggers = {
        getElevation: {
          heightField: this.config.heightField,
          heightScale: this.config.heightScale,
          aggregationType: visConfig.heightAggregation,
          heightDomain: this.config.heightDomain,
          heightRange: visConfig.heightRange
        },
        getFillColor: {
          color: this.config.color,
          colorField: this.config.colorField,
          colorRange: visConfig.colorRange,
          colorScale: this.config.colorScale,
          aggregationType: visConfig.colorAggregation,
          colorDomain: this.config.colorDomain,
          apiCall: this.config.apiCallRequest,
          boundary: this.config.boundaryAggregation
        },
        getLineColor: {
          color: this.config.color,
          colorField: this.config.colorField,
          colorRange: visConfig.colorRange,
          colorScale: this.config.colorScale,
          aggregationType: visConfig.colorAggregation,
          colorDomain: this.config.colorDomain,
          apiCallComplete: this.config.apiCallComplete,
          apiCall: this.config.apiCallRequest,
          boundary: this.config.boundaryAggregation
        },
        getLineWidth: {
          sizeField: this.config.sizeField,
          sizeRange: visConfig.sizeRange
        }
      }; // this.config.apiCallComplete = false;
      // this.config.apiCallRequest = false;

      return [new _deck.GeoJsonLayer(_objectSpread({}, layerProps, {
        id: this.id,
        idx: idx,
        data: data.collected,
        getFillColor: data.getFillColor,
        getLineColor: data.getLineColor,
        getLineWidth: data.getLineWidth,
        getElevation: data.getElevation,
        // highlight
        pickable: true,
        // highlightColor: this.config.highlightColor,
        autoHighlight: visConfig.enable3d,
        // parameters
        parameters: {
          depthTest: Boolean(visConfig.enable3d || mapState.dragRotate)
        },
        opacity: visConfig.opacity,
        stroked: visConfig.stroked,
        filled: visConfig.filled,
        extruded: visConfig.enable3d,
        wireframe: visConfig.wireframe,
        lightSettings: lightSettings,
        updateTriggers: updateTriggers,
        subLayers: _objectSpread({}, _deck.GeoJsonLayer.defaultProps.subLayers, {
          PolygonLayer: _solidPolygonLayer["default"]
        })
      }))].concat((0, _toConsumableArray2["default"])(this.isLayerHovered(objectHovered) && !visConfig.enable3d ? [new _deck.GeoJsonLayer(_objectSpread({}, layerProps, {
        id: "".concat(this.id, "-hovered"),
        data: [objectHovered.object],
        getLineWidth: data.getLineWidth,
        getElevation: data.getElevation,
        getLineColor: this.config.highlightColor,
        getFillColor: this.config.highlightColor,
        updateTriggers: updateTriggers,
        stroked: true,
        pickable: false,
        filled: false
      }))] : []));
    }
  }, {
    key: "type",
    get: function get() {
      return 'boundary';
    }
  }, {
    key: "isAggregated",
    get: function get() {
      return true;
    }
  }, {
    key: "layerIcon",
    get: function get() {
      return _boundaryLayerIcon["default"];
    }
  }, {
    key: "requiredLayerColumns",
    get: function get() {
      return boundaryRequiredColumns;
    }
  }, {
    key: "columnPairs",
    get: function get() {
      return this.defaultPointColumnPairs;
    }
  }, {
    key: "noneLayerDataAffectingProps",
    get: function get() {
      return [].concat((0, _toConsumableArray2["default"])((0, _get2["default"])((0, _getPrototypeOf2["default"])(BoundaryLayer.prototype), "noneLayerDataAffectingProps", this)), ['radius']);
    }
  }, {
    key: "visualChannels",
    get: function get() {
      var _objectSpread2;

      return _objectSpread({}, (0, _get2["default"])((0, _getPrototypeOf2["default"])(BoundaryLayer.prototype), "visualChannels", this), {
        color: _objectSpread({}, (0, _get2["default"])((0, _getPrototypeOf2["default"])(BoundaryLayer.prototype), "visualChannels", this).color, {
          aggregation: 'colorAggregation',
          channelScaleType: _defaultSettings.CHANNEL_SCALES.colorAggr,
          defaultMeasure: 'Point Count',
          domain: 'colorDomain',
          field: 'colorField',
          key: 'color',
          property: 'color',
          range: 'colorRange',
          scale: 'colorScale'
        }),
        size: _objectSpread({}, (0, _get2["default"])((0, _getPrototypeOf2["default"])(BoundaryLayer.prototype), "visualChannels", this).size, (_objectSpread2 = {
          property: 'stroke',
          aggregation: 'sizeAggregation',
          channelScaleType: _defaultSettings.CHANNEL_SCALES.sizeAggr,
          condition: function condition(config) {
            return config.visConfig.enable3d;
          },
          defaultMeasure: 'Point Count',
          domain: 'sizeDomain',
          field: 'sizeField',
          key: 'size'
        }, (0, _defineProperty2["default"])(_objectSpread2, "property", 'stroke'), (0, _defineProperty2["default"])(_objectSpread2, "range", 'sizeRange'), (0, _defineProperty2["default"])(_objectSpread2, "scale", 'sizeScale'), _objectSpread2)),
        height: {
          aggregation: 'heightAggregation',
          defaultMeasure: 'Point Count',
          property: 'height',
          field: 'heightField',
          scale: 'heightScale',
          domain: 'heightDomain',
          range: 'heightRange',
          key: 'height',
          channelScaleType: 'sizeAggr',
          condition: function condition(config) {
            return config.visConfig.enable3d;
          }
        }
      });
    }
  }]);
  return BoundaryLayer;
}(_baseLayer["default"]);

exports["default"] = BoundaryLayer;
//# sourceMappingURL=data:application/json;charset=utf-8;base64,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