@carto/kepler.gl 0.0.1-alpha.map-libre

package/dist/layers/geojson-layer/geojson-layer.js

@@ -0,0 +1,446 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = exports.defaultRadius = exports.defaultLineWidth = exports.defaultElevation = exports.featureAccessor = exports.geoJsonRequiredColumns = exports.geojsonVisConfigs = void 0;
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _get2 = _interopRequireDefault(require("@babel/runtime/helpers/get"));
+
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _lodash = _interopRequireDefault(require("lodash.uniq"));
+
+var _typeAnalyzer = require("type-analyzer");
+
+var _baseLayer = _interopRequireWildcard(require("../base-layer"));
+
+var _layers = require("@deck.gl/layers");
+
+var _geojsonUtils = require("./geojson-utils");
+
+var _geojsonLayerIcon = _interopRequireDefault(require("./geojson-layer-icon"));
+
+var _defaultSettings = require("../../constants/default-settings");
+
+var _layerFactory = require("../layer-factory");
+
+var _SUPPORTED_ANALYZER_T;
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2["default"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2["default"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2["default"])(this, result); }; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+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; }
+
+var SUPPORTED_ANALYZER_TYPES = (_SUPPORTED_ANALYZER_T = {}, (0, _defineProperty2["default"])(_SUPPORTED_ANALYZER_T, _typeAnalyzer.DATA_TYPES.GEOMETRY, true), (0, _defineProperty2["default"])(_SUPPORTED_ANALYZER_T, _typeAnalyzer.DATA_TYPES.GEOMETRY_FROM_STRING, true), _SUPPORTED_ANALYZER_T);
+var geojsonVisConfigs = {
+  opacity: 'opacity',
+  strokeOpacity: _objectSpread(_objectSpread({}, _layerFactory.LAYER_VIS_CONFIGS.opacity), {}, {
+    property: 'strokeOpacity'
+  }),
+  thickness: _objectSpread(_objectSpread({}, _layerFactory.LAYER_VIS_CONFIGS.thickness), {}, {
+    defaultValue: 1
+  }),
+  strokeColor: 'strokeColor',
+  colorRange: 'colorRange',
+  strokeColorRange: 'strokeColorRange',
+  radius: 'radius',
+  sizeRange: 'strokeWidthRange',
+  radiusRange: 'radiusRange',
+  heightRange: 'elevationRange',
+  elevationScale: 'elevationScale',
+  enableElevationZoomFactor: 'enableElevationZoomFactor',
+  stroked: 'stroked',
+  filled: 'filled',
+  enable3d: 'enable3d',
+  wireframe: 'wireframe'
+};
+exports.geojsonVisConfigs = geojsonVisConfigs;
+var geoJsonRequiredColumns = ['geojson'];
+exports.geoJsonRequiredColumns = geoJsonRequiredColumns;
+
+var featureAccessor = function featureAccessor(_ref) {
+  var geojson = _ref.geojson;
+  return function (dc) {
+    return function (d) {
+      return dc.valueAt(d.index, geojson.fieldIdx);
+    };
+  };
+}; // access feature properties from geojson sub layer
+
+
+exports.featureAccessor = featureAccessor;
+var defaultElevation = 500;
+exports.defaultElevation = defaultElevation;
+var defaultLineWidth = 1;
+exports.defaultLineWidth = defaultLineWidth;
+var defaultRadius = 1;
+exports.defaultRadius = defaultRadius;
+
+var GeoJsonLayer = /*#__PURE__*/function (_Layer) {
+  (0, _inherits2["default"])(GeoJsonLayer, _Layer);
+
+  var _super = _createSuper(GeoJsonLayer);
+
+  function GeoJsonLayer(props) {
+    var _this;
+
+    (0, _classCallCheck2["default"])(this, GeoJsonLayer);
+    _this = _super.call(this, props);
+    _this.dataToFeature = [];
+
+    _this.registerVisConfig(geojsonVisConfigs);
+
+    _this.getPositionAccessor = function (dataContainer) {
+      return featureAccessor(_this.config.columns)(dataContainer);
+    };
+
+    return _this;
+  }
+
+  (0, _createClass2["default"])(GeoJsonLayer, [{
+    key: "type",
+    get: function get() {
+      return 'geojson';
+    }
+  }, {
+    key: "name",
+    get: function get() {
+      return 'Polygon';
+    }
+  }, {
+    key: "layerIcon",
+    get: function get() {
+      return _geojsonLayerIcon["default"];
+    }
+  }, {
+    key: "requiredLayerColumns",
+    get: function get() {
+      return geoJsonRequiredColumns;
+    }
+  }, {
+    key: "visualChannels",
+    get: function get() {
+      var visualChannels = (0, _get2["default"])((0, _getPrototypeOf2["default"])(GeoJsonLayer.prototype), "visualChannels", this);
+      return {
+        color: _objectSpread(_objectSpread({}, visualChannels.color), {}, {
+          accessor: 'getFillColor',
+          condition: function condition(config) {
+            return config.visConfig.filled;
+          },
+          nullValue: visualChannels.color.nullValue,
+          getAttributeValue: function getAttributeValue(config) {
+            return function (d) {
+              return d.properties.fillColor || config.color;
+            };
+          },
+          // used this to get updateTriggers
+          defaultValue: function defaultValue(config) {
+            return config.color;
+          }
+        }),
+        strokeColor: {
+          property: 'strokeColor',
+          field: 'strokeColorField',
+          scale: 'strokeColorScale',
+          domain: 'strokeColorDomain',
+          range: 'strokeColorRange',
+          key: 'strokeColor',
+          channelScaleType: _defaultSettings.CHANNEL_SCALES.color,
+          accessor: 'getLineColor',
+          condition: function condition(config) {
+            return config.visConfig.stroked;
+          },
+          nullValue: visualChannels.color.nullValue,
+          getAttributeValue: function getAttributeValue(config) {
+            return function (d) {
+              return d.properties.lineColor || config.visConfig.strokeColor || config.color;
+            };
+          },
+          // used this to get updateTriggers
+          defaultValue: function defaultValue(config) {
+            return config.visConfig.strokeColor || config.color;
+          }
+        },
+        size: _objectSpread(_objectSpread({}, visualChannels.size), {}, {
+          property: 'stroke',
+          accessor: 'getLineWidth',
+          condition: function condition(config) {
+            return config.visConfig.stroked;
+          },
+          nullValue: 0,
+          getAttributeValue: function getAttributeValue() {
+            return function (d) {
+              return d.properties.lineWidth || defaultLineWidth;
+            };
+          }
+        }),
+        height: {
+          property: 'height',
+          field: 'heightField',
+          scale: 'heightScale',
+          domain: 'heightDomain',
+          range: 'heightRange',
+          key: 'height',
+          channelScaleType: _defaultSettings.CHANNEL_SCALES.size,
+          accessor: 'getElevation',
+          condition: function condition(config) {
+            return config.visConfig.enable3d;
+          },
+          nullValue: 0,
+          getAttributeValue: function getAttributeValue() {
+            return function (d) {
+              return d.properties.elevation || defaultElevation;
+            };
+          }
+        },
+        radius: {
+          property: 'radius',
+          field: 'radiusField',
+          scale: 'radiusScale',
+          domain: 'radiusDomain',
+          range: 'radiusRange',
+          key: 'radius',
+          channelScaleType: _defaultSettings.CHANNEL_SCALES.radius,
+          accessor: 'getRadius',
+          nullValue: 0,
+          getAttributeValue: function getAttributeValue() {
+            return function (d) {
+              return d.properties.radius || defaultRadius;
+            };
+          }
+        }
+      };
+    }
+  }, {
+    key: "getDefaultLayerConfig",
+    value: function getDefaultLayerConfig() {
+      var props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      return _objectSpread(_objectSpread({}, (0, _get2["default"])((0, _getPrototypeOf2["default"])(GeoJsonLayer.prototype), "getDefaultLayerConfig", this).call(this, props)), {}, {
+        // add height visual channel
+        heightField: null,
+        heightDomain: [0, 1],
+        heightScale: 'linear',
+        // add radius visual channel
+        radiusField: null,
+        radiusDomain: [0, 1],
+        radiusScale: 'linear',
+        // add stroke color visual channel
+        strokeColorField: null,
+        strokeColorDomain: [0, 1],
+        strokeColorScale: 'quantile'
+      });
+    }
+  }, {
+    key: "getHoverData",
+    value: function getHoverData(object, dataContainer) {
+      // index of dataContainer is saved to feature.properties
+      return dataContainer.row(object.properties.index);
+    }
+  }, {
+    key: "calculateDataAttribute",
+    value: function calculateDataAttribute(_ref2, getPosition) {
+      var _this2 = this;
+
+      var dataContainer = _ref2.dataContainer,
+          filteredIndex = _ref2.filteredIndex;
+      return filteredIndex.map(function (i) {
+        return _this2.dataToFeature[i];
+      }).filter(function (d) {
+        return d;
+      });
+    }
+  }, {
+    key: "formatLayerData",
+    value: function formatLayerData(datasets, oldLayerData) {
+      var _datasets$this$config = datasets[this.config.dataId],
+          gpuFilter = _datasets$this$config.gpuFilter,
+          dataContainer = _datasets$this$config.dataContainer;
+
+      var _this$updateData = this.updateData(datasets, oldLayerData),
+          data = _this$updateData.data;
+
+      var customFilterValueAccessor = function customFilterValueAccessor(dc, d, fieldIndex) {
+        return dc.valueAt(d.properties.index, fieldIndex);
+      };
+
+      var indexAccessor = function indexAccessor(f) {
+        return f.properties.index;
+      };
+
+      var dataAccessor = function dataAccessor(dc) {
+        return function (d) {
+          return {
+            index: d.properties.index
+          };
+        };
+      };
+
+      var accessors = this.getAttributeAccessors({
+        dataAccessor: dataAccessor,
+        dataContainer: dataContainer
+      });
+      return _objectSpread({
+        data: data,
+        getFilterValue: gpuFilter.filterValueAccessor(dataContainer)(indexAccessor, customFilterValueAccessor)
+      }, accessors);
+    }
+  }, {
+    key: "updateLayerMeta",
+    value: function updateLayerMeta(dataContainer) {
+      var getFeature = this.getPositionAccessor(dataContainer);
+      this.dataToFeature = (0, _geojsonUtils.getGeojsonDataMaps)(dataContainer, getFeature); // get bounds from features
+
+      var bounds = (0, _geojsonUtils.getGeojsonBounds)(this.dataToFeature); // keep a record of what type of geometry the collection has
+
+      var featureTypes = (0, _geojsonUtils.getGeojsonFeatureTypes)(this.dataToFeature);
+      this.updateMeta({
+        bounds: bounds,
+        featureTypes: featureTypes
+      });
+    }
+  }, {
+    key: "setInitialLayerConfig",
+    value: function setInitialLayerConfig(_ref3) {
+      var dataContainer = _ref3.dataContainer;
+      this.updateLayerMeta(dataContainer);
+      var featureTypes = this.meta.featureTypes; // default settings is stroke: true, filled: false
+
+      if (featureTypes && featureTypes.polygon) {
+        // set both fill and stroke to true
+        return this.updateLayerVisConfig({
+          filled: true,
+          stroked: true,
+          strokeColor: _baseLayer.colorMaker.next().value
+        });
+      } else if (featureTypes && featureTypes.point) {
+        // set fill to true if detect point
+        return this.updateLayerVisConfig({
+          filled: true,
+          stroked: false
+        });
+      }
+
+      return this;
+    }
+  }, {
+    key: "renderLayer",
+    value: function renderLayer(opts) {
+      var data = opts.data,
+          gpuFilter = opts.gpuFilter,
+          objectHovered = opts.objectHovered;
+      var featureTypes = this.meta.featureTypes;
+      var radiusScale = this.getRadiusScale();
+      var visConfig = this.config.visConfig;
+      var layerProps = {
+        lineWidthScale: visConfig.thickness,
+        elevationScale: visConfig.elevationScale,
+        pointRadiusScale: radiusScale,
+        lineMiterLimit: 4
+      };
+
+      var updateTriggers = _objectSpread(_objectSpread({}, this.getVisualChannelUpdateTriggers()), {}, {
+        getFilterValue: gpuFilter.filterValueUpdateTriggers
+      });
+
+      var defaultLayerProps = this.getDefaultDeckLayerProps(opts);
+      var opaOverwrite = {
+        opacity: visConfig.strokeOpacity
+      };
+      var pickable = this.hasInteractivity;
+      var hoveredObject = this.hasHoveredObject(objectHovered);
+      return [new _layers.GeoJsonLayer(_objectSpread(_objectSpread(_objectSpread(_objectSpread({}, defaultLayerProps), layerProps), data), {}, {
+        pickable: pickable,
+        highlightColor: _defaultSettings.HIGHLIGH_COLOR_3D,
+        autoHighlight: visConfig.enable3d && pickable,
+        stroked: visConfig.stroked,
+        filled: visConfig.filled,
+        extruded: visConfig.enable3d,
+        wireframe: visConfig.wireframe,
+        wrapLongitude: false,
+        lineMiterLimit: 2,
+        rounded: true,
+        radiusUnits: 'pixels',
+        lineWidthUnits: 'pixels',
+        updateTriggers: updateTriggers,
+        _subLayerProps: _objectSpread(_objectSpread(_objectSpread({}, featureTypes.polygon ? {
+          'polygons-stroke': opaOverwrite
+        } : {}), featureTypes.line ? {
+          linestrings: opaOverwrite
+        } : {}), featureTypes.point ? {
+          points: {
+            lineOpacity: visConfig.strokeOpacity
+          }
+        } : {})
+      }))].concat((0, _toConsumableArray2["default"])(hoveredObject && !visConfig.enable3d ? [new _layers.GeoJsonLayer(_objectSpread(_objectSpread(_objectSpread({}, this.getDefaultHoverLayerProps()), layerProps), {}, {
+        wrapLongitude: false,
+        data: [hoveredObject],
+        getLineWidth: data.getLineWidth,
+        getRadius: data.getRadius,
+        getElevation: data.getElevation,
+        getLineColor: this.config.highlightColor,
+        getFillColor: this.config.highlightColor,
+        // always draw outline
+        stroked: true,
+        filled: false
+      }))] : []));
+    }
+  }], [{
+    key: "findDefaultLayerProps",
+    value: function findDefaultLayerProps(_ref4) {
+      var _this3 = this;
+
+      var label = _ref4.label,
+          _ref4$fields = _ref4.fields,
+          fields = _ref4$fields === void 0 ? [] : _ref4$fields;
+      var geojsonColumns = fields.filter(function (f) {
+        return f.type === 'geojson' && SUPPORTED_ANALYZER_TYPES[f.analyzerType];
+      }).map(function (f) {
+        return f.name;
+      });
+      var defaultColumns = {
+        geojson: (0, _lodash["default"])([].concat((0, _toConsumableArray2["default"])(_defaultSettings.GEOJSON_FIELDS.geojson), (0, _toConsumableArray2["default"])(geojsonColumns)))
+      };
+      var foundColumns = this.findDefaultColumnField(defaultColumns, fields);
+
+      if (!foundColumns || !foundColumns.length) {
+        return {
+          props: []
+        };
+      }
+
+      return {
+        props: foundColumns.map(function (columns) {
+          return {
+            label: typeof label === 'string' && label.replace(/\.[^/.]+$/, '') || _this3.type,
+            columns: columns,
+            isVisible: true
+          };
+        })
+      };
+    }
+  }]);
+  return GeoJsonLayer;
+}(_baseLayer["default"]);
+
+exports["default"] = GeoJsonLayer;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../src/layers/geojson-layer/geojson-layer.js"],"names":["SUPPORTED_ANALYZER_TYPES","DATA_TYPES","GEOMETRY","GEOMETRY_FROM_STRING","geojsonVisConfigs","opacity","strokeOpacity","LAYER_VIS_CONFIGS","property","thickness","defaultValue","strokeColor","colorRange","strokeColorRange","radius","sizeRange","radiusRange","heightRange","elevationScale","enableElevationZoomFactor","stroked","filled","enable3d","wireframe","geoJsonRequiredColumns","featureAccessor","geojson","dc","d","valueAt","index","fieldIdx","defaultElevation","defaultLineWidth","defaultRadius","GeoJsonLayer","props","dataToFeature","registerVisConfig","getPositionAccessor","dataContainer","config","columns","GeojsonLayerIcon","visualChannels","color","accessor","condition","visConfig","nullValue","getAttributeValue","properties","fillColor","field","scale","domain","range","key","channelScaleType","CHANNEL_SCALES","lineColor","size","lineWidth","height","elevation","heightField","heightDomain","heightScale","radiusField","radiusDomain","radiusScale","strokeColorField","strokeColorDomain","strokeColorScale","object","row","getPosition","filteredIndex","map","i","filter","datasets","oldLayerData","dataId","gpuFilter","updateData","data","customFilterValueAccessor","fieldIndex","indexAccessor","f","dataAccessor","accessors","getAttributeAccessors","getFilterValue","filterValueAccessor","getFeature","bounds","featureTypes","updateMeta","updateLayerMeta","meta","polygon","updateLayerVisConfig","colorMaker","next","value","point","opts","objectHovered","getRadiusScale","layerProps","lineWidthScale","pointRadiusScale","lineMiterLimit","updateTriggers","getVisualChannelUpdateTriggers","filterValueUpdateTriggers","defaultLayerProps","getDefaultDeckLayerProps","opaOverwrite","pickable","hasInteractivity","hoveredObject","hasHoveredObject","DeckGLGeoJsonLayer","highlightColor","HIGHLIGH_COLOR_3D","autoHighlight","extruded","wrapLongitude","rounded","radiusUnits","lineWidthUnits","_subLayerProps","line","linestrings","points","lineOpacity","getDefaultHoverLayerProps","getLineWidth","getRadius","getElevation","getLineColor","getFillColor","label","fields","geojsonColumns","type","analyzerType","name","defaultColumns","GEOJSON_FIELDS","foundColumns","findDefaultColumnField","length","replace","isVisible","Layer"],"mappings":"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","sourcesContent":["// Copyright (c) 2022 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\nimport uniq from 'lodash.uniq';\nimport {DATA_TYPES} from 'type-analyzer';\n\nimport Layer, {colorMaker} from '../base-layer';\nimport {GeoJsonLayer as DeckGLGeoJsonLayer} from '@deck.gl/layers';\nimport {getGeojsonDataMaps, getGeojsonBounds, getGeojsonFeatureTypes} from './geojson-utils';\nimport GeojsonLayerIcon from './geojson-layer-icon';\nimport {GEOJSON_FIELDS, HIGHLIGH_COLOR_3D, CHANNEL_SCALES} from 'constants/default-settings';\nimport {LAYER_VIS_CONFIGS} from 'layers/layer-factory';\n\nconst SUPPORTED_ANALYZER_TYPES = {\n  [DATA_TYPES.GEOMETRY]: true,\n  [DATA_TYPES.GEOMETRY_FROM_STRING]: true\n};\n\nexport const geojsonVisConfigs = {\n  opacity: 'opacity',\n  strokeOpacity: {\n    ...LAYER_VIS_CONFIGS.opacity,\n    property: 'strokeOpacity'\n  },\n  thickness: {\n    ...LAYER_VIS_CONFIGS.thickness,\n    defaultValue: 1\n  },\n  strokeColor: 'strokeColor',\n  colorRange: 'colorRange',\n  strokeColorRange: 'strokeColorRange',\n  radius: 'radius',\n\n  sizeRange: 'strokeWidthRange',\n  radiusRange: 'radiusRange',\n  heightRange: 'elevationRange',\n  elevationScale: 'elevationScale',\n  enableElevationZoomFactor: 'enableElevationZoomFactor',\n  stroked: 'stroked',\n  filled: 'filled',\n  enable3d: 'enable3d',\n  wireframe: 'wireframe'\n};\n\nexport const geoJsonRequiredColumns = ['geojson'];\nexport const featureAccessor = ({geojson}) => dc => d => dc.valueAt(d.index, geojson.fieldIdx);\n\n// access feature properties from geojson sub layer\nexport const defaultElevation = 500;\nexport const defaultLineWidth = 1;\nexport const defaultRadius = 1;\n\nexport default class GeoJsonLayer extends Layer {\n  constructor(props) {\n    super(props);\n\n    this.dataToFeature = [];\n    this.registerVisConfig(geojsonVisConfigs);\n    this.getPositionAccessor = dataContainer => featureAccessor(this.config.columns)(dataContainer);\n  }\n\n  get type() {\n    return 'geojson';\n  }\n\n  get name() {\n    return 'Polygon';\n  }\n\n  get layerIcon() {\n    return GeojsonLayerIcon;\n  }\n\n  get requiredLayerColumns() {\n    return geoJsonRequiredColumns;\n  }\n\n  get visualChannels() {\n    const visualChannels = super.visualChannels;\n    return {\n      color: {\n        ...visualChannels.color,\n        accessor: 'getFillColor',\n        condition: config => config.visConfig.filled,\n        nullValue: visualChannels.color.nullValue,\n        getAttributeValue: config => d => d.properties.fillColor || config.color,\n        // used this to get updateTriggers\n        defaultValue: config => config.color\n      },\n      strokeColor: {\n        property: 'strokeColor',\n        field: 'strokeColorField',\n        scale: 'strokeColorScale',\n        domain: 'strokeColorDomain',\n        range: 'strokeColorRange',\n        key: 'strokeColor',\n        channelScaleType: CHANNEL_SCALES.color,\n        accessor: 'getLineColor',\n        condition: config => config.visConfig.stroked,\n        nullValue: visualChannels.color.nullValue,\n        getAttributeValue: config => d =>\n          d.properties.lineColor || config.visConfig.strokeColor || config.color,\n        // used this to get updateTriggers\n        defaultValue: config => config.visConfig.strokeColor || config.color\n      },\n      size: {\n        ...visualChannels.size,\n        property: 'stroke',\n        accessor: 'getLineWidth',\n        condition: config => config.visConfig.stroked,\n        nullValue: 0,\n        getAttributeValue: () => d => d.properties.lineWidth || defaultLineWidth\n      },\n      height: {\n        property: 'height',\n        field: 'heightField',\n        scale: 'heightScale',\n        domain: 'heightDomain',\n        range: 'heightRange',\n        key: 'height',\n        channelScaleType: CHANNEL_SCALES.size,\n        accessor: 'getElevation',\n        condition: config => config.visConfig.enable3d,\n        nullValue: 0,\n        getAttributeValue: () => d => d.properties.elevation || defaultElevation\n      },\n      radius: {\n        property: 'radius',\n        field: 'radiusField',\n        scale: 'radiusScale',\n        domain: 'radiusDomain',\n        range: 'radiusRange',\n        key: 'radius',\n        channelScaleType: CHANNEL_SCALES.radius,\n        accessor: 'getRadius',\n        nullValue: 0,\n        getAttributeValue: () => d => d.properties.radius || defaultRadius\n      }\n    };\n  }\n\n  static findDefaultLayerProps({label, fields = []}) {\n    const geojsonColumns = fields\n      .filter(f => f.type === 'geojson' && SUPPORTED_ANALYZER_TYPES[f.analyzerType])\n      .map(f => f.name);\n\n    const defaultColumns = {\n      geojson: uniq([...GEOJSON_FIELDS.geojson, ...geojsonColumns])\n    };\n\n    const foundColumns = this.findDefaultColumnField(defaultColumns, fields);\n    if (!foundColumns || !foundColumns.length) {\n      return {props: []};\n    }\n\n    return {\n      props: foundColumns.map(columns => ({\n        label: (typeof label === 'string' && label.replace(/\\.[^/.]+$/, '')) || this.type,\n        columns,\n        isVisible: true\n      }))\n    };\n  }\n\n  getDefaultLayerConfig(props = {}) {\n    return {\n      ...super.getDefaultLayerConfig(props),\n\n      // add height visual channel\n      heightField: null,\n      heightDomain: [0, 1],\n      heightScale: 'linear',\n\n      // add radius visual channel\n      radiusField: null,\n      radiusDomain: [0, 1],\n      radiusScale: 'linear',\n\n      // add stroke color visual channel\n      strokeColorField: null,\n      strokeColorDomain: [0, 1],\n      strokeColorScale: 'quantile'\n    };\n  }\n\n  getHoverData(object, dataContainer) {\n    // index of dataContainer is saved to feature.properties\n    return dataContainer.row(object.properties.index);\n  }\n\n  calculateDataAttribute({dataContainer, filteredIndex}, getPosition) {\n    return filteredIndex.map(i => this.dataToFeature[i]).filter(d => d);\n  }\n\n  formatLayerData(datasets, oldLayerData) {\n    const {gpuFilter, dataContainer} = datasets[this.config.dataId];\n    const {data} = this.updateData(datasets, oldLayerData);\n\n    const customFilterValueAccessor = (dc, d, fieldIndex) => {\n      return dc.valueAt(d.properties.index, fieldIndex);\n    };\n    const indexAccessor = f => f.properties.index;\n\n    const dataAccessor = dc => d => ({index: d.properties.index});\n    const accessors = this.getAttributeAccessors({dataAccessor, dataContainer});\n\n    return {\n      data,\n      getFilterValue: gpuFilter.filterValueAccessor(dataContainer)(\n        indexAccessor,\n        customFilterValueAccessor\n      ),\n      ...accessors\n    };\n  }\n\n  updateLayerMeta(dataContainer) {\n    const getFeature = this.getPositionAccessor(dataContainer);\n    this.dataToFeature = getGeojsonDataMaps(dataContainer, getFeature);\n\n    // get bounds from features\n    const bounds = getGeojsonBounds(this.dataToFeature);\n\n    // keep a record of what type of geometry the collection has\n    const featureTypes = getGeojsonFeatureTypes(this.dataToFeature);\n\n    this.updateMeta({bounds, featureTypes});\n  }\n\n  setInitialLayerConfig({dataContainer}) {\n    this.updateLayerMeta(dataContainer);\n\n    const {featureTypes} = this.meta;\n    // default settings is stroke: true, filled: false\n    if (featureTypes && featureTypes.polygon) {\n      // set both fill and stroke to true\n      return this.updateLayerVisConfig({\n        filled: true,\n        stroked: true,\n        strokeColor: colorMaker.next().value\n      });\n    } else if (featureTypes && featureTypes.point) {\n      // set fill to true if detect point\n      return this.updateLayerVisConfig({filled: true, stroked: false});\n    }\n\n    return this;\n  }\n\n  renderLayer(opts) {\n    const {data, gpuFilter, objectHovered} = opts;\n\n    const {featureTypes} = this.meta;\n    const radiusScale = this.getRadiusScale();\n    const {visConfig} = this.config;\n\n    const layerProps = {\n      lineWidthScale: visConfig.thickness,\n      elevationScale: visConfig.elevationScale,\n      pointRadiusScale: radiusScale,\n      lineMiterLimit: 4\n    };\n\n    const updateTriggers = {\n      ...this.getVisualChannelUpdateTriggers(),\n      getFilterValue: gpuFilter.filterValueUpdateTriggers\n    };\n\n    const defaultLayerProps = this.getDefaultDeckLayerProps(opts);\n    const opaOverwrite = {\n      opacity: visConfig.strokeOpacity\n    };\n\n    const pickable = this.hasInteractivity;\n    const hoveredObject = this.hasHoveredObject(objectHovered);\n\n    return [\n      new DeckGLGeoJsonLayer({\n        ...defaultLayerProps,\n        ...layerProps,\n        ...data,\n        pickable,\n        highlightColor: HIGHLIGH_COLOR_3D,\n        autoHighlight: visConfig.enable3d && pickable,\n        stroked: visConfig.stroked,\n        filled: visConfig.filled,\n        extruded: visConfig.enable3d,\n        wireframe: visConfig.wireframe,\n        wrapLongitude: false,\n        lineMiterLimit: 2,\n        rounded: true,\n        radiusUnits: 'pixels',\n        lineWidthUnits: 'pixels',\n        updateTriggers,\n        _subLayerProps: {\n          ...(featureTypes.polygon ? {'polygons-stroke': opaOverwrite} : {}),\n          ...(featureTypes.line ? {linestrings: opaOverwrite} : {}),\n          ...(featureTypes.point\n            ? {\n                points: {\n                  lineOpacity: visConfig.strokeOpacity\n                }\n              }\n            : {})\n        }\n      }),\n      ...(hoveredObject && !visConfig.enable3d\n        ? [\n            new DeckGLGeoJsonLayer({\n              ...this.getDefaultHoverLayerProps(),\n              ...layerProps,\n              wrapLongitude: false,\n              data: [hoveredObject],\n              getLineWidth: data.getLineWidth,\n              getRadius: data.getRadius,\n              getElevation: data.getElevation,\n              getLineColor: this.config.highlightColor,\n              getFillColor: this.config.highlightColor,\n              // always draw outline\n              stroked: true,\n              filled: false\n            })\n          ]\n        : [])\n    ];\n  }\n}\n"]}