@carto/kepler.gl 0.0.86-alpha.deck9.1 → 0.0.86

package/dist/layers/base-layer.js

@@ -4,8 +4,14 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.layerColors = exports.default = exports.colorMaker = exports.OVERLAY_TYPE = exports.LAYER_ID_LENGTH = void 0;
+exports.layerColors = exports["default"] = exports.colorMaker = exports.OVERLAY_TYPE = exports.LAYER_ID_LENGTH = void 0;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
 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 _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
 var _window = require("global/window");
 var _keymirror = _interopRequireDefault(require("keymirror"));
 var _extensions = require("@deck.gl/extensions");
@@ -24,7 +30,12 @@ var _dataContainerUtils = require("../utils/table-utils/data-container-utils");
 var _colorUtils = require("../utils/color-utils");
 var _layerUtils = require("../utils/layer-utils");
 var _d3Scale = require("d3-scale");
-// Copyright (c) 2022 Uber Technologies, Inc.
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2["default"])(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+var _marked = /*#__PURE__*/_regenerator["default"].mark(generateColor); // Copyright (c) 2022 Uber Technologies, Inc.
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
@@ -43,49 +54,67 @@ var _d3Scale = require("d3-scale");
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.
-
 /**
  * Approx. number of points to sample in a large data set
  */
-const LAYER_ID_LENGTH = exports.LAYER_ID_LENGTH = 6;
+var LAYER_ID_LENGTH = exports.LAYER_ID_LENGTH = 6;
 
 // Note, this is is SVG of solid circle encoded as data-uri
-const FALLBACK_ICON = 'data:image/svg+xml;charset=utf-8;base64,PHN2ZyB2aWV3Qm94PSIwIDAgMTAwIDEwMCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4NCiAgPGNpcmNsZSBjeD0iNTAiIGN5PSI1MCIgcj0iNTAiLz4NCjwvc3ZnPg==';
-const MAX_SAMPLE_SIZE = 5000;
-const defaultDomain = [0, 1];
-const dataFilterExtension = new _extensions.DataFilterExtension({
+var FALLBACK_ICON = 'data:image/svg+xml;charset=utf-8;base64,PHN2ZyB2aWV3Qm94PSIwIDAgMTAwIDEwMCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4NCiAgPGNpcmNsZSBjeD0iNTAiIGN5PSI1MCIgcj0iNTAiLz4NCjwvc3ZnPg==';
+var MAX_SAMPLE_SIZE = 5000;
+var defaultDomain = [0, 1];
+var dataFilterExtension = new _extensions.DataFilterExtension({
   filterSize: _defaultSettings.MAX_GPU_FILTERS
 });
-const collisionFilterExtension = new _extensions.CollisionFilterExtension();
-const defaultDataAccessor = dc => d => d;
-const defaultGetFieldValue = (field, d) => field.valueAccessor(d);
-const scaleIdentity = v => v;
-const OVERLAY_TYPE = exports.OVERLAY_TYPE = (0, _keymirror.default)({
+var collisionFilterExtension = new _extensions.CollisionFilterExtension();
+var defaultDataAccessor = function defaultDataAccessor(dc) {
+  return function (d) {
+    return d;
+  };
+};
+var defaultGetFieldValue = function defaultGetFieldValue(field, d) {
+  return field.valueAccessor(d);
+};
+var scaleIdentity = function scaleIdentity(v) {
+  return v;
+};
+var OVERLAY_TYPE = exports.OVERLAY_TYPE = (0, _keymirror["default"])({
   deckgl: null,
   mapboxgl: null
 });
-const layerColors = exports.layerColors = Object.values(_customColorRanges.DataVizColors).map(_colorUtils.hexToRgb);
-function* generateColor() {
-  let index = 0;
-  while (index < layerColors.length + 1) {
-    if (index === layerColors.length) {
-      index = 0;
-    }
-    yield layerColors[index++];
-  }
+var layerColors = exports.layerColors = Object.values(_customColorRanges.DataVizColors).map(_colorUtils.hexToRgb);
+function generateColor() {
+  var index;
+  return _regenerator["default"].wrap(function generateColor$(_context) {
+    while (1) switch (_context.prev = _context.next) {
+      case 0:
+        index = 0;
+      case 1:
+        if (!(index < layerColors.length + 1)) {
+          _context.next = 7;
+          break;
+        }
+        if (index === layerColors.length) {
+          index = 0;
+        }
+        _context.next = 5;
+        return layerColors[index++];
+      case 5:
+        _context.next = 1;
+        break;
+      case 7:
+      case "end":
+        return _context.stop();
+    }
+  }, _marked);
 }
-const colorMaker = exports.colorMaker = generateColor();
-class Layer {
-  constructor() {
-    let props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-    (0, _defineProperty2.default)(this, "id", void 0);
-    (0, _defineProperty2.default)(this, "meta", void 0);
-    (0, _defineProperty2.default)(this, "visConfigSettings", void 0);
-    (0, _defineProperty2.default)(this, "config", void 0);
-    // TODO: define _oldDataUpdateTriggers
-    (0, _defineProperty2.default)(this, "_oldDataUpdateTriggers", void 0);
-    (0, _defineProperty2.default)(this, "legendSettings", void 0);
-    (0, _defineProperty2.default)(this, "_interactivitySettings", void 0);
+var colorMaker = exports.colorMaker = generateColor();
+var Layer = /*#__PURE__*/function () {
+  // TODO: define _oldDataUpdateTriggers
+
+  function Layer() {
+    var props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    (0, _classCallCheck2["default"])(this, Layer);
     this.id = props.id || (0, _utils.generateHashId)(LAYER_ID_LENGTH);
     // meta
     this.meta = {};
@@ -98,1433 +127,1577 @@ class Layer {
 
     // interactivitySettings
     this._interactivitySettings = {};
-    this.config = this.getDefaultLayerConfig({
-      columns: this.getLayerColumns(),
-      ...props
-    });
-  }
-  get layerIcon() {
-    return _defaultLayerIcon.default;
-  }
-  get overlayType() {
-    return OVERLAY_TYPE.deckgl;
-  }
-  get type() {
-    return null;
-  }
-  get name() {
-    return this.type;
-  }
-  get isAggregated() {
-    return false;
-  }
-  get requiredLayerColumns() {
-    return [];
-  }
-  get optionalColumns() {
-    return [];
-  }
-  get noneLayerDataAffectingProps() {
-    return ['label', 'opacity', 'thickness', 'isVisible', 'hidden'];
-  }
-  get visualChannels() {
-    return {
-      color: {
-        property: 'color',
-        field: 'colorField',
-        scale: 'colorScale',
-        domain: 'colorDomain',
-        range: 'colorRange',
-        key: 'color',
-        channelScaleType: _defaultSettings.CHANNEL_SCALES.color,
-        nullValue: _defaultSettings.NO_VALUE_COLOR,
-        defaultValue: config => config.color
-      },
-      size: {
-        property: 'size',
-        field: 'sizeField',
-        scale: 'sizeScale',
-        domain: 'sizeDomain',
-        range: 'sizeRange',
-        key: 'size',
-        channelScaleType: _defaultSettings.CHANNEL_SCALES.size,
-        nullValue: 0,
-        defaultValue: 1
-      }
-    };
-  }
-  get columnValidators() {
-    return {};
-  }
-  /*
-   * Column pairs maps layer column to a specific field pairs,
-   * By default, it is set to null
-   */
-  get columnPairs() {
-    return null;
-  }
-
-  /*
-   * Default point column pairs, can be used for point based layers: point, icon etc.
-   */
-  get defaultPointColumnPairs() {
-    return {
-      lat: {
-        pair: 'lng',
-        fieldPairKey: 'lat'
-      },
-      lng: {
-        pair: 'lat',
-        fieldPairKey: 'lng'
-      }
-    };
-  }
-
-  /*
-   * Default link column pairs, can be used for link based layers: arc, line etc
-   */
-  get defaultLinkColumnPairs() {
-    return {
-      lat0: {
-        pair: 'lng0',
-        fieldPairKey: 'lat'
-      },
-      lng0: {
-        pair: 'lat0',
-        fieldPairKey: 'lng'
-      },
-      lat1: {
-        pair: 'lng1',
-        fieldPairKey: 'lat'
-      },
-      lng1: {
-        pair: 'lat1',
-        fieldPairKey: 'lng'
-      }
-    };
-  }
+    this.config = this.getDefaultLayerConfig(_objectSpread({
+      columns: this.getLayerColumns()
+    }, props));
+  }
+  return (0, _createClass2["default"])(Layer, [{
+    key: "layerIcon",
+    get: function get() {
+      return _defaultLayerIcon["default"];
+    }
+  }, {
+    key: "overlayType",
+    get: function get() {
+      return OVERLAY_TYPE.deckgl;
+    }
+  }, {
+    key: "type",
+    get: function get() {
+      return null;
+    }
+  }, {
+    key: "name",
+    get: function get() {
+      return this.type;
+    }
+  }, {
+    key: "isAggregated",
+    get: function get() {
+      return false;
+    }
+  }, {
+    key: "requiredLayerColumns",
+    get: function get() {
+      return [];
+    }
+  }, {
+    key: "optionalColumns",
+    get: function get() {
+      return [];
+    }
+  }, {
+    key: "noneLayerDataAffectingProps",
+    get: function get() {
+      return ['label', 'opacity', 'thickness', 'isVisible', 'hidden'];
+    }
+  }, {
+    key: "visualChannels",
+    get: function get() {
+      return {
+        color: {
+          property: 'color',
+          field: 'colorField',
+          scale: 'colorScale',
+          domain: 'colorDomain',
+          range: 'colorRange',
+          key: 'color',
+          channelScaleType: _defaultSettings.CHANNEL_SCALES.color,
+          nullValue: _defaultSettings.NO_VALUE_COLOR,
+          defaultValue: function defaultValue(config) {
+            return config.color;
+          }
+        },
+        size: {
+          property: 'size',
+          field: 'sizeField',
+          scale: 'sizeScale',
+          domain: 'sizeDomain',
+          range: 'sizeRange',
+          key: 'size',
+          channelScaleType: _defaultSettings.CHANNEL_SCALES.size,
+          nullValue: 0,
+          defaultValue: 1
+        }
+      };
+    }
+  }, {
+    key: "columnValidators",
+    get: function get() {
+      return {};
+    }
+    /*
+     * Column pairs maps layer column to a specific field pairs,
+     * By default, it is set to null
+     */
+  }, {
+    key: "columnPairs",
+    get: function get() {
+      return null;
+    }
 
-  /**
-   * Return a React component for to render layer instructions in a modal
-   * @returns {object} - an object
-   * @example
-   *  return {
-   *    id: 'iconInfo',
-   *    template: IconInfoModal,
-   *    modalProps: {
-   *      title: 'How to draw icons'
-   *   };
-   * }
-   */
-  get layerInfoModal() {
-    return null;
-  }
-  get interactivitySettings() {
-    return this._interactivitySettings;
-  }
-  set interactivitySettings(interactivitySettings) {
-    this._interactivitySettings = interactivitySettings;
-  }
-  get hasTooltip() {
-    var _this$interactivitySe, _this$interactivitySe2, _this$interactivitySe3, _this$interactivitySe4;
-    return Boolean(((_this$interactivitySe = this.interactivitySettings) === null || _this$interactivitySe === void 0 ? void 0 : (_this$interactivitySe2 = _this$interactivitySe.hover) === null || _this$interactivitySe2 === void 0 ? void 0 : _this$interactivitySe2.fields.length) || ((_this$interactivitySe3 = this.interactivitySettings) === null || _this$interactivitySe3 === void 0 ? void 0 : (_this$interactivitySe4 = _this$interactivitySe3.click) === null || _this$interactivitySe4 === void 0 ? void 0 : _this$interactivitySe4.fields.length));
-  }
-  get hasInteractivity() {
-    var _this$interactivitySe5;
-    return Boolean(this.hasTooltip && ((_this$interactivitySe5 = this.interactivitySettings) === null || _this$interactivitySe5 === void 0 ? void 0 : _this$interactivitySe5.enabled));
-  }
+    /*
+     * Default point column pairs, can be used for point based layers: point, icon etc.
+     */
+  }, {
+    key: "defaultPointColumnPairs",
+    get: function get() {
+      return {
+        lat: {
+          pair: 'lng',
+          fieldPairKey: 'lat'
+        },
+        lng: {
+          pair: 'lat',
+          fieldPairKey: 'lng'
+        }
+      };
+    }
 
-  /*
-   * Given a dataset, automatically find props to create layer based on it
-   * and return the props and previous found layers.
-   * By default, no layers will be found
-   */
-  static findDefaultLayerProps(dataset, foundLayers) {
-    return {
-      props: [],
-      foundLayers
-    };
-  }
+    /*
+     * Default link column pairs, can be used for link based layers: arc, line etc
+     */
+  }, {
+    key: "defaultLinkColumnPairs",
+    get: function get() {
+      return {
+        lat0: {
+          pair: 'lng0',
+          fieldPairKey: 'lat'
+        },
+        lng0: {
+          pair: 'lat0',
+          fieldPairKey: 'lng'
+        },
+        lat1: {
+          pair: 'lng1',
+          fieldPairKey: 'lat'
+        },
+        lng1: {
+          pair: 'lat1',
+          fieldPairKey: 'lng'
+        }
+      };
+    }
 
-  /**
-   * Given a array of preset required column names
-   * found field that has the same name to set as layer column
-   *
-   * @param {object} defaultFields
-   * @param {object[]} allFields
-   * @returns {object[] | null} all possible required layer column pairs
-   */
-  static findDefaultColumnField(defaultFields, allFields) {
-    // find all matched fields for each required col
-    const requiredColumns = Object.keys(defaultFields).reduce((prev, key) => {
-      const requiredFields = allFields.filter(f => f.name === defaultFields[key] || defaultFields[key].includes(f.name));
-      prev[key] = requiredFields.length ? requiredFields.map(f => ({
-        value: f.name,
-        fieldIdx: f.fieldIdx
-      })) : null;
-      return prev;
-    }, {});
-    if (!Object.values(requiredColumns).every(Boolean)) {
-      // if any field missing, return null
+    /**
+     * Return a React component for to render layer instructions in a modal
+     * @returns {object} - an object
+     * @example
+     *  return {
+     *    id: 'iconInfo',
+     *    template: IconInfoModal,
+     *    modalProps: {
+     *      title: 'How to draw icons'
+     *   };
+     * }
+     */
+  }, {
+    key: "layerInfoModal",
+    get: function get() {
       return null;
     }
-    return this.getAllPossibleColumnParis(requiredColumns);
-  }
-  static getAllPossibleColumnParis(requiredColumns) {
-    // for multiple matched field for one required column, return multiple
-    // combinations, e. g. if column a has 2 matched, column b has 3 matched
-    // 6 possible column pairs will be returned
-    const allKeys = Object.keys(requiredColumns);
-    const pointers = allKeys.map((k, i) => i === allKeys.length - 1 ? -1 : 0);
-    const countPerKey = allKeys.map(k => requiredColumns[k].length);
-    // TODO: Better typings
-    const pairs = [];
-
-    /* eslint-disable no-loop-func */
-    while (incrementPointers(pointers, countPerKey, pointers.length - 1)) {
-      const newPair = pointers.reduce((prev, cuur, i) => {
-        prev[allKeys[i]] = requiredColumns[allKeys[i]][cuur];
-        return prev;
-      }, {});
-      pairs.push(newPair);
+  }, {
+    key: "interactivitySettings",
+    get: function get() {
+      return this._interactivitySettings;
+    },
+    set: function set(interactivitySettings) {
+      this._interactivitySettings = interactivitySettings;
     }
-    /* eslint-enable no-loop-func */
-
-    // recursively increment pointers
-    function incrementPointers(pts, counts, index) {
-      if (index === 0 && pts[0] === counts[0] - 1) {
-        // nothing to increment
-        return false;
-      }
-      if (pts[index] + 1 < counts[index]) {
-        pts[index] = pts[index] + 1;
-        return true;
-      }
-      pts[index] = 0;
-      return incrementPointers(pts, counts, index - 1);
+  }, {
+    key: "hasTooltip",
+    get: function get() {
+      var _this$interactivitySe, _this$interactivitySe2, _this$interactivitySe3, _this$interactivitySe4;
+      return Boolean(((_this$interactivitySe = this.interactivitySettings) === null || _this$interactivitySe === void 0 ? void 0 : (_this$interactivitySe2 = _this$interactivitySe.hover) === null || _this$interactivitySe2 === void 0 ? void 0 : _this$interactivitySe2.fields.length) || ((_this$interactivitySe3 = this.interactivitySettings) === null || _this$interactivitySe3 === void 0 ? void 0 : (_this$interactivitySe4 = _this$interactivitySe3.click) === null || _this$interactivitySe4 === void 0 ? void 0 : _this$interactivitySe4.fields.length));
     }
-    return pairs;
-  }
-  static hexToRgb(c) {
-    return (0, _colorUtils.hexToRgb)(c);
-  }
-  getDefaultLayerConfig() {
-    var _visibilityByZoom, _visibilityByZoom2;
-    let props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-    return {
-      dataId: props.dataId || null,
-      ...{
+  }, {
+    key: "hasInteractivity",
+    get: function get() {
+      var _this$interactivitySe5;
+      return Boolean(this.hasTooltip && ((_this$interactivitySe5 = this.interactivitySettings) === null || _this$interactivitySe5 === void 0 ? void 0 : _this$interactivitySe5.enabled));
+    }
+
+    /*
+     * Given a dataset, automatically find props to create layer based on it
+     * and return the props and previous found layers.
+     * By default, no layers will be found
+     */
+  }, {
+    key: "getDefaultLayerConfig",
+    value: function getDefaultLayerConfig() {
+      var _visibilityByZoom, _visibilityByZoom2;
+      var props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      return _objectSpread(_objectSpread(_objectSpread({
+        dataId: props.dataId || null
+      }, {
         visibilityByZoom: {
           min: ((_visibilityByZoom = props.visibilityByZoom) === null || _visibilityByZoom === void 0 ? void 0 : _visibilityByZoom.min) || _defaultSettings.ZOOM_LEVEL_LIMITS.min,
           max: ((_visibilityByZoom2 = props.visibilityByZoom) === null || _visibilityByZoom2 === void 0 ? void 0 : _visibilityByZoom2.max) || _defaultSettings.ZOOM_LEVEL_LIMITS.max
         }
-      },
-      // TODO: Clean up
-      label: props.label || _layerFactory.DEFAULT_LAYER_LABEL,
-      color: props.color || colorMaker.next().value,
-      columns: props.columns || {},
-      isVisible: props.isVisible || false,
-      isConfigActive: props.isConfigActive || false,
-      highlightColor: props.highlightColor || _layerFactory.DEFAULT_HIGHLIGHT_COLOR,
-      hidden: props.hidden || false,
-      // TODO: refactor this into separate visual Channel config
-      // color by field, domain is set by filters, field, scale type
-      colorField: null,
-      colorDomain: [0, 1],
-      colorScale: _defaultSettings.SCALE_TYPES.quantile,
-      // color by size, domain is set by filters, field, scale type
-      sizeDomain: [0, 1],
-      sizeScale: _defaultSettings.SCALE_TYPES.linear,
-      sizeField: null,
-      ...{
+      }), {}, {
+        // TODO: Clean up
+        label: props.label || _layerFactory.DEFAULT_LAYER_LABEL,
+        color: props.color || colorMaker.next().value,
+        columns: props.columns || {},
+        isVisible: props.isVisible || false,
+        isConfigActive: props.isConfigActive || false,
+        highlightColor: props.highlightColor || _layerFactory.DEFAULT_HIGHLIGHT_COLOR,
+        hidden: props.hidden || false,
+        // TODO: refactor this into separate visual Channel config
+        // color by field, domain is set by filters, field, scale type
+        colorField: null,
+        colorDomain: [0, 1],
+        colorScale: _defaultSettings.SCALE_TYPES.quantile,
+        // color by size, domain is set by filters, field, scale type
+        sizeDomain: [0, 1],
+        sizeScale: _defaultSettings.SCALE_TYPES.linear,
+        sizeField: null
+      }, {
         radiusField: null
-      },
-      // TODO: Clean up
+      }), {}, {
+        // TODO: Clean up
 
-      visConfig: {},
-      textLabel: [_layerFactory.DEFAULT_TEXT_LABEL],
-      colorUI: {
-        color: _layerFactory.DEFAULT_COLOR_UI,
-        colorRange: _layerFactory.DEFAULT_COLOR_UI
-      },
-      animation: {
-        enabled: false
-      }
-    };
-  }
+        visConfig: {},
+        textLabel: [_layerFactory.DEFAULT_TEXT_LABEL],
+        colorUI: {
+          color: _layerFactory.DEFAULT_COLOR_UI,
+          colorRange: _layerFactory.DEFAULT_COLOR_UI
+        },
+        animation: {
+          enabled: false
+        }
+      });
+    }
 
-  /**
-   * Get the description of a visualChannel config
-   * @param key
-   * @returns
-   */
-  getVisualChannelDescription(key) {
-    // e.g. label: Color, measure: Vehicle Type
-    const channel = this.visualChannels[key];
-    if (!channel) return {
-      label: '',
-      measure: ''
-    };
-    const rangeSettings = this.visConfigSettings[channel.range];
-    const fieldSettings = this.config[channel.field];
-    const label = rangeSettings === null || rangeSettings === void 0 ? void 0 : rangeSettings.label;
-    return {
-      label: typeof label === 'function' ? label(this.config) : label,
-      measure: fieldSettings ? fieldSettings.displayName || fieldSettings.name : channel.defaultMeasure
-    };
-  }
+    /**
+     * Get the description of a visualChannel config
+     * @param key
+     * @returns
+     */
+  }, {
+    key: "getVisualChannelDescription",
+    value: function getVisualChannelDescription(key) {
+      // e.g. label: Color, measure: Vehicle Type
+      var channel = this.visualChannels[key];
+      if (!channel) return {
+        label: '',
+        measure: ''
+      };
+      var rangeSettings = this.visConfigSettings[channel.range];
+      var fieldSettings = this.config[channel.field];
+      var label = rangeSettings === null || rangeSettings === void 0 ? void 0 : rangeSettings.label;
+      return {
+        label: typeof label === 'function' ? label(this.config) : label,
+        measure: fieldSettings ? fieldSettings.displayName || fieldSettings.name : channel.defaultMeasure
+      };
+    }
 
-  /**
-   * Assign a field to layer column, return column config
-   * @param key - Column Key
-   * @param field - Selected field
-   * @returns {{}} - Column config
-   */
-  assignColumn(key, field) {
-    // field value could be null for optional columns
-    const update = field ? {
-      value: field.name,
-      fieldIdx: field.fieldIdx
-    } : {
-      value: null,
-      fieldIdx: -1
-    };
-    return {
-      ...this.config.columns,
-      [key]: {
-        ...this.config.columns[key],
-        ...update
-      }
-    };
-  }
+    /**
+     * Assign a field to layer column, return column config
+     * @param key - Column Key
+     * @param field - Selected field
+     * @returns {{}} - Column config
+     */
+  }, {
+    key: "assignColumn",
+    value: function assignColumn(key, field) {
+      // field value could be null for optional columns
+      var update = field ? {
+        value: field.name,
+        fieldIdx: field.fieldIdx
+      } : {
+        value: null,
+        fieldIdx: -1
+      };
+      return _objectSpread(_objectSpread({}, this.config.columns), {}, (0, _defineProperty2["default"])({}, key, _objectSpread(_objectSpread({}, this.config.columns[key]), update)));
+    }
 
-  /**
-   * Assign a field pair to column config, return column config
-   * @param key - Column Key
-   * @param pair - field Pair
-   * @returns {object} - Column config
-   */
-  assignColumnPairs(key, pair) {
-    var _this$columnPairs, _this$columnPairs2, _this$columnPairs3;
-    if (!this.columnPairs || !((_this$columnPairs = this.columnPairs) !== null && _this$columnPairs !== void 0 && _this$columnPairs[key])) {
-      // should not end in this state
-      return this.config.columns;
-    }
-    const {
-      pair: partnerKey,
-      fieldPairKey
-    } = (_this$columnPairs2 = this.columnPairs) === null || _this$columnPairs2 === void 0 ? void 0 : _this$columnPairs2[key];
-    const {
-      fieldPairKey: partnerFieldPairKey
-    } = (_this$columnPairs3 = this.columnPairs) === null || _this$columnPairs3 === void 0 ? void 0 : _this$columnPairs3[partnerKey];
-    return {
-      ...this.config.columns,
-      [key]: pair[fieldPairKey],
-      [partnerKey]: pair[partnerFieldPairKey]
-    };
-  }
+    /**
+     * Assign a field pair to column config, return column config
+     * @param key - Column Key
+     * @param pair - field Pair
+     * @returns {object} - Column config
+     */
+  }, {
+    key: "assignColumnPairs",
+    value: function assignColumnPairs(key, pair) {
+      var _this$columnPairs, _this$columnPairs2, _this$columnPairs3;
+      if (!this.columnPairs || !((_this$columnPairs = this.columnPairs) !== null && _this$columnPairs !== void 0 && _this$columnPairs[key])) {
+        // should not end in this state
+        return this.config.columns;
+      }
+      var _this$columnPairs$key = (_this$columnPairs2 = this.columnPairs) === null || _this$columnPairs2 === void 0 ? void 0 : _this$columnPairs2[key],
+        partnerKey = _this$columnPairs$key.pair,
+        fieldPairKey = _this$columnPairs$key.fieldPairKey;
+      var _this$columnPairs$par = (_this$columnPairs3 = this.columnPairs) === null || _this$columnPairs3 === void 0 ? void 0 : _this$columnPairs3[partnerKey],
+        partnerFieldPairKey = _this$columnPairs$par.fieldPairKey;
+      return _objectSpread(_objectSpread({}, this.config.columns), {}, (0, _defineProperty2["default"])((0, _defineProperty2["default"])({}, key, pair[fieldPairKey]), partnerKey, pair[partnerFieldPairKey]));
+    }
 
-  /**
-   * Calculate a radius zoom multiplier to render points, so they are visible in all zoom level
-   * @param {object} mapState
-   * @param {number} mapState.zoom - actual zoom
-   * @param {number | void} mapState.zoomOffset - zoomOffset when render in the plot container for export image
-   * @returns {number}
-   */
-  getZoomFactor(_ref) {
-    let {
-      zoom,
-      zoomOffset = 0
-    } = _ref;
-    return Math.pow(2, Math.max(14 - zoom + zoomOffset, 0));
-  }
+    /**
+     * Calculate a radius zoom multiplier to render points, so they are visible in all zoom level
+     * @param {object} mapState
+     * @param {number} mapState.zoom - actual zoom
+     * @param {number | void} mapState.zoomOffset - zoomOffset when render in the plot container for export image
+     * @returns {number}
+     */
+  }, {
+    key: "getZoomFactor",
+    value: function getZoomFactor(_ref) {
+      var zoom = _ref.zoom,
+        _ref$zoomOffset = _ref.zoomOffset,
+        zoomOffset = _ref$zoomOffset === void 0 ? 0 : _ref$zoomOffset;
+      return Math.pow(2, Math.max(14 - zoom + zoomOffset, 0));
+    }
 
-  /**
-   * Calculate a elevation zoom multiplier to render points, so they are visible in all zoom level
-   * @param {object} mapState
-   * @param {number} mapState.zoom - actual zoom
-   * @param {number | void} mapState.zoomOffset - zoomOffset when render in the plot container for export image
-   * @returns {number}
-   */
-  getElevationZoomFactor(_ref2) {
-    let {
-      zoom,
-      zoomOffset = 0
-    } = _ref2;
-    return this.config.visConfig.enableElevationZoomFactor ? Math.pow(2, Math.max(8 - zoom + zoomOffset, 0)) : 1;
-  }
-  formatLayerData(datasets, oldLayerData) {
-    return {};
-  }
-  renderLayer() {
-    return [];
-  }
-  getHoverData(object, dataContainer, fields) {
-    if (!object) {
-      return null;
+    /**
+     * Calculate a elevation zoom multiplier to render points, so they are visible in all zoom level
+     * @param {object} mapState
+     * @param {number} mapState.zoom - actual zoom
+     * @param {number | void} mapState.zoomOffset - zoomOffset when render in the plot container for export image
+     * @returns {number}
+     */
+  }, {
+    key: "getElevationZoomFactor",
+    value: function getElevationZoomFactor(_ref2) {
+      var zoom = _ref2.zoom,
+        _ref2$zoomOffset = _ref2.zoomOffset,
+        zoomOffset = _ref2$zoomOffset === void 0 ? 0 : _ref2$zoomOffset;
+      return this.config.visConfig.enableElevationZoomFactor ? Math.pow(2, Math.max(8 - zoom + zoomOffset, 0)) : 1;
+    }
+  }, {
+    key: "formatLayerData",
+    value: function formatLayerData(datasets, oldLayerData) {
+      return {};
+    }
+  }, {
+    key: "renderLayer",
+    value: function renderLayer() {
+      return [];
     }
+  }, {
+    key: "getHoverData",
+    value: function getHoverData(object, dataContainer, fields) {
+      if (!object) {
+        return null;
+      }
 
-    // By default, each entry of layerData should have an index of a row in the original data container.
-    // Each layer can implement its own getHoverData method
-    return dataContainer.row(object.index);
-  }
+      // By default, each entry of layerData should have an index of a row in the original data container.
+      // Each layer can implement its own getHoverData method
+      return dataContainer.row(object.index);
+    }
 
-  /**
-   * When change layer type, try to copy over layer configs as much as possible
-   * @param configToCopy - config to copy over
-   * @param visConfigSettings - visConfig settings of config to copy
-   */
-  assignConfigToLayer(configToCopy, visConfigSettings) {
-    // don't deep merge visualChannel field
-    // don't deep merge color range, reversed: is not a key by default
-    const shallowCopy = ['colorRange', 'strokeColorRange'].concat(Object.values(this.visualChannels).map(v => v.field));
+    /**
+     * When change layer type, try to copy over layer configs as much as possible
+     * @param configToCopy - config to copy over
+     * @param visConfigSettings - visConfig settings of config to copy
+     */
+  }, {
+    key: "assignConfigToLayer",
+    value: function assignConfigToLayer(configToCopy, visConfigSettings) {
+      var _this = this;
+      // don't deep merge visualChannel field
+      // don't deep merge color range, reversed: is not a key by default
+      var shallowCopy = ['colorRange', 'strokeColorRange'].concat(Object.values(this.visualChannels).map(function (v) {
+        return v.field;
+      }));
 
-    // don't copy over domain and animation
-    const notToCopy = ['animation'].concat(Object.values(this.visualChannels).map(v => v.domain));
-    // if range is for the same property group copy it, otherwise, not to copy
-    Object.values(this.visualChannels).forEach(v => {
-      if (configToCopy.visConfig[v.range] && this.visConfigSettings[v.range] && visConfigSettings[v.range].group !== this.visConfigSettings[v.range].group) {
-        notToCopy.push(v.range);
-      }
-    });
+      // don't copy over domain and animation
+      var notToCopy = ['animation'].concat(Object.values(this.visualChannels).map(function (v) {
+        return v.domain;
+      }));
+      // if range is for the same property group copy it, otherwise, not to copy
+      Object.values(this.visualChannels).forEach(function (v) {
+        if (configToCopy.visConfig[v.range] && _this.visConfigSettings[v.range] && visConfigSettings[v.range].group !== _this.visConfigSettings[v.range].group) {
+          notToCopy.push(v.range);
+        }
+      });
 
-    // don't copy over visualChannel range
-    const currentConfig = this.config;
-    const copied = this.copyLayerConfig(currentConfig, configToCopy, {
-      shallowCopy,
-      notToCopy
-    });
-    this.updateLayerConfig(copied);
-    // validate visualChannel field type and scale types
-    Object.keys(this.visualChannels).forEach(channel => {
-      this.validateVisualChannel(channel);
-    });
-  }
+      // don't copy over visualChannel range
+      var currentConfig = this.config;
+      var copied = this.copyLayerConfig(currentConfig, configToCopy, {
+        shallowCopy: shallowCopy,
+        notToCopy: notToCopy
+      });
+      this.updateLayerConfig(copied);
+      // validate visualChannel field type and scale types
+      Object.keys(this.visualChannels).forEach(function (channel) {
+        _this.validateVisualChannel(channel);
+      });
+    }
 
-  /*
-   * Recursively copy config over to an empty layer
-   * when received saved config, or copy config over from a different layer type
-   * make sure to only copy over value to existing keys
-   * @param {object} currentConfig - existing config to be override
-   * @param {object} configToCopy - new Config to copy over
-   * @param {string[]} shallowCopy - array of properties to not to be deep copied
-   * @param {string[]} notToCopy - array of properties not to copy
-   * @returns {object} - copied config
-   */
-  copyLayerConfig(currentConfig, configToCopy) {
-    let {
-      shallowCopy = [],
-      notToCopy = []
-    } = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-    const copied = {};
-    Object.keys(currentConfig).forEach(key => {
-      if ((0, _utils.isPlainObject)(currentConfig[key]) && (0, _utils.isPlainObject)(configToCopy[key]) && !shallowCopy.includes(key) && !notToCopy.includes(key)) {
-        // recursively assign object value
-        copied[key] = this.copyLayerConfig(currentConfig[key], configToCopy[key], {
-          shallowCopy,
-          notToCopy
-        });
-      } else if ((0, _dataUtils.notNullorUndefined)(configToCopy[key]) && !notToCopy.includes(key)) {
-        // copy
-        copied[key] = configToCopy[key];
-      } else {
-        // keep existing
-        copied[key] = currentConfig[key];
-      }
-    });
-    return copied;
-  }
-  registerVisConfig(layerVisConfigs) {
-    Object.keys(layerVisConfigs).forEach(item => {
-      const configItem = layerVisConfigs[item];
-      if (typeof configItem === 'string' && _layerFactory.LAYER_VIS_CONFIGS[configItem]) {
-        // if assigned one of default LAYER_CONFIGS
-        this.config.visConfig[item] = _layerFactory.LAYER_VIS_CONFIGS[configItem].defaultValue;
-        this.visConfigSettings[item] = _layerFactory.LAYER_VIS_CONFIGS[configItem];
-      } else if (typeof configItem === 'object' && ['type', 'defaultValue'].every(p => configItem.hasOwnProperty(p))) {
-        // if provided customized visConfig, and has type && defaultValue
-        // TODO: further check if customized visConfig is valid
-        this.config.visConfig[item] = configItem.defaultValue;
-        this.visConfigSettings[item] = configItem;
-      }
-    });
-  }
-  getLayerColumns() {
-    const columnValidators = this.columnValidators;
-    const required = this.requiredLayerColumns.reduce((accu, key) => ({
-      ...accu,
-      [key]: columnValidators[key] ? {
-        value: null,
-        fieldIdx: -1,
-        validator: columnValidators[key]
-      } : {
-        value: null,
-        fieldIdx: -1
+    /*
+     * Recursively copy config over to an empty layer
+     * when received saved config, or copy config over from a different layer type
+     * make sure to only copy over value to existing keys
+     * @param {object} currentConfig - existing config to be override
+     * @param {object} configToCopy - new Config to copy over
+     * @param {string[]} shallowCopy - array of properties to not to be deep copied
+     * @param {string[]} notToCopy - array of properties not to copy
+     * @returns {object} - copied config
+     */
+  }, {
+    key: "copyLayerConfig",
+    value: function copyLayerConfig(currentConfig, configToCopy) {
+      var _this2 = this;
+      var _ref3 = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {},
+        _ref3$shallowCopy = _ref3.shallowCopy,
+        shallowCopy = _ref3$shallowCopy === void 0 ? [] : _ref3$shallowCopy,
+        _ref3$notToCopy = _ref3.notToCopy,
+        notToCopy = _ref3$notToCopy === void 0 ? [] : _ref3$notToCopy;
+      var copied = {};
+      Object.keys(currentConfig).forEach(function (key) {
+        if ((0, _utils.isPlainObject)(currentConfig[key]) && (0, _utils.isPlainObject)(configToCopy[key]) && !shallowCopy.includes(key) && !notToCopy.includes(key)) {
+          // recursively assign object value
+          copied[key] = _this2.copyLayerConfig(currentConfig[key], configToCopy[key], {
+            shallowCopy: shallowCopy,
+            notToCopy: notToCopy
+          });
+        } else if ((0, _dataUtils.notNullorUndefined)(configToCopy[key]) && !notToCopy.includes(key)) {
+          // copy
+          copied[key] = configToCopy[key];
+        } else {
+          // keep existing
+          copied[key] = currentConfig[key];
+        }
+      });
+      return copied;
+    }
+  }, {
+    key: "registerVisConfig",
+    value: function registerVisConfig(layerVisConfigs) {
+      var _this3 = this;
+      Object.keys(layerVisConfigs).forEach(function (item) {
+        var configItem = layerVisConfigs[item];
+        if (typeof configItem === 'string' && _layerFactory.LAYER_VIS_CONFIGS[configItem]) {
+          // if assigned one of default LAYER_CONFIGS
+          _this3.config.visConfig[item] = _layerFactory.LAYER_VIS_CONFIGS[configItem].defaultValue;
+          _this3.visConfigSettings[item] = _layerFactory.LAYER_VIS_CONFIGS[configItem];
+        } else if ((0, _typeof2["default"])(configItem) === 'object' && ['type', 'defaultValue'].every(function (p) {
+          return configItem.hasOwnProperty(p);
+        })) {
+          // if provided customized visConfig, and has type && defaultValue
+          // TODO: further check if customized visConfig is valid
+          _this3.config.visConfig[item] = configItem.defaultValue;
+          _this3.visConfigSettings[item] = configItem;
+        }
+      });
+    }
+  }, {
+    key: "getLayerColumns",
+    value: function getLayerColumns() {
+      var columnValidators = this.columnValidators;
+      var required = this.requiredLayerColumns.reduce(function (accu, key) {
+        return _objectSpread(_objectSpread({}, accu), {}, (0, _defineProperty2["default"])({}, key, columnValidators[key] ? {
+          value: null,
+          fieldIdx: -1,
+          validator: columnValidators[key]
+        } : {
+          value: null,
+          fieldIdx: -1
+        }));
+      }, {});
+      var optional = this.optionalColumns.reduce(function (accu, key) {
+        return _objectSpread(_objectSpread({}, accu), {}, (0, _defineProperty2["default"])({}, key, {
+          value: null,
+          fieldIdx: -1,
+          optional: true
+        }));
+      }, {});
+      return _objectSpread(_objectSpread({}, required), optional);
+    }
+  }, {
+    key: "updateLayerConfig",
+    value: function updateLayerConfig(newConfig) {
+      this.config = _objectSpread(_objectSpread({}, this.config), newConfig);
+      return this;
+    }
+  }, {
+    key: "updateLayerVisConfig",
+    value: function updateLayerVisConfig(newVisConfig) {
+      this.config.visConfig = _objectSpread(_objectSpread({}, this.config.visConfig), newVisConfig);
+      return this;
+    }
+  }, {
+    key: "updateLayerColorUI",
+    value: function updateLayerColorUI(prop, newConfig) {
+      var _this$config = this.config,
+        previous = _this$config.colorUI,
+        visConfig = _this$config.visConfig;
+      if (!(0, _utils.isPlainObject)(newConfig) || typeof prop !== 'string') {
+        return this;
       }
-    }), {});
-    const optional = this.optionalColumns.reduce((accu, key) => ({
-      ...accu,
-      [key]: {
-        value: null,
-        fieldIdx: -1,
-        optional: true
+      var colorUIProp = Object.entries(newConfig).reduce(function (accu, _ref4) {
+        var _ref5 = (0, _slicedToArray2["default"])(_ref4, 2),
+          key = _ref5[0],
+          value = _ref5[1];
+        return _objectSpread(_objectSpread({}, accu), {}, (0, _defineProperty2["default"])({}, key, (0, _utils.isPlainObject)(accu[key]) && (0, _utils.isPlainObject)(value) ? _objectSpread(_objectSpread({}, accu[key]), value) : value));
+      }, previous[prop] || _layerFactory.DEFAULT_COLOR_UI);
+      var colorUI = _objectSpread(_objectSpread({}, previous), {}, (0, _defineProperty2["default"])({}, prop, colorUIProp));
+      this.updateLayerConfig({
+        colorUI: colorUI
+      });
+      // if colorUI[prop] is colorRange. If type is hexColor then it's also a range
+      var isColorRange = visConfig[prop] && (visConfig[prop].colors || visConfig[prop].type === _colorRanges.hexColor);
+      if (isColorRange) {
+        this.updateColorUIByColorRange(newConfig, prop);
+        this.updateColorRangeByColorUI(newConfig, previous, prop);
+        this.updateCustomPalette(newConfig, previous, prop);
       }
-    }), {});
-    return {
-      ...required,
-      ...optional
-    };
-  }
-  updateLayerConfig(newConfig) {
-    this.config = {
-      ...this.config,
-      ...newConfig
-    };
-    return this;
-  }
-  updateLayerVisConfig(newVisConfig) {
-    this.config.visConfig = {
-      ...this.config.visConfig,
-      ...newVisConfig
-    };
-    return this;
-  }
-  updateLayerColorUI(prop, newConfig) {
-    const {
-      colorUI: previous,
-      visConfig
-    } = this.config;
-    if (!(0, _utils.isPlainObject)(newConfig) || typeof prop !== 'string') {
       return this;
     }
-    const colorUIProp = Object.entries(newConfig).reduce((accu, _ref3) => {
-      let [key, value] = _ref3;
-      return {
-        ...accu,
-        [key]: (0, _utils.isPlainObject)(accu[key]) && (0, _utils.isPlainObject)(value) ? {
-          ...accu[key],
-          ...value
-        } : value
-      };
-    }, previous[prop] || _layerFactory.DEFAULT_COLOR_UI);
-    const colorUI = {
-      ...previous,
-      [prop]: colorUIProp
-    };
-    this.updateLayerConfig({
-      colorUI
-    });
-    // if colorUI[prop] is colorRange. If type is hexColor then it's also a range
-    const isColorRange = visConfig[prop] && (visConfig[prop].colors || visConfig[prop].type === _colorRanges.hexColor);
-    if (isColorRange) {
-      this.updateColorUIByColorRange(newConfig, prop);
-      this.updateColorRangeByColorUI(newConfig, previous, prop);
-      this.updateCustomPalette(newConfig, previous, prop);
-    }
-    return this;
-  }
-  updateCustomPalette(newConfig, previous, prop) {
-    if (!newConfig.colorRangeConfig || !newConfig.colorRangeConfig.custom) {
-      return;
-    }
-    const {
-      colorUI,
-      visConfig
-    } = this.config;
-    if (!visConfig[prop]) return;
-    const {
-      colors
-    } = visConfig[prop];
-    const customPalette = {
-      ...colorUI[prop].customPalette,
-      name: 'Custom Palette',
-      colors: [...colors]
-    };
-    this.updateLayerConfig({
-      colorUI: {
-        ...colorUI,
-        [prop]: {
-          ...colorUI[prop],
-          customPalette
-        }
+  }, {
+    key: "updateCustomPalette",
+    value: function updateCustomPalette(newConfig, previous, prop) {
+      if (!newConfig.colorRangeConfig || !newConfig.colorRangeConfig.custom) {
+        return;
       }
-    });
-  }
-  /**
-   * if open dropdown and prop is color range
-   * Automatically set colorRangeConfig's step, reversed and type
-   * @param {*} newConfig
-   * @param {*} prop
-   */
-  updateColorUIByColorRange(newConfig, prop) {
-    var _visConfig$prop$color;
-    if (typeof newConfig.showDropdown !== 'number') return;
-    const {
-      colorUI,
-      visConfig
-    } = this.config;
-    this.updateLayerConfig({
-      colorUI: {
-        ...colorUI,
-        [prop]: {
-          ...colorUI[prop],
-          colorRangeConfig: {
-            ...colorUI[prop].colorRangeConfig,
+      var _this$config2 = this.config,
+        colorUI = _this$config2.colorUI,
+        visConfig = _this$config2.visConfig;
+      if (!visConfig[prop]) return;
+      var colors = visConfig[prop].colors;
+      var customPalette = _objectSpread(_objectSpread({}, colorUI[prop].customPalette), {}, {
+        name: 'Custom Palette',
+        colors: (0, _toConsumableArray2["default"])(colors)
+      });
+      this.updateLayerConfig({
+        colorUI: _objectSpread(_objectSpread({}, colorUI), {}, (0, _defineProperty2["default"])({}, prop, _objectSpread(_objectSpread({}, colorUI[prop]), {}, {
+          customPalette: customPalette
+        })))
+      });
+    }
+    /**
+     * if open dropdown and prop is color range
+     * Automatically set colorRangeConfig's step, reversed and type
+     * @param {*} newConfig
+     * @param {*} prop
+     */
+  }, {
+    key: "updateColorUIByColorRange",
+    value: function updateColorUIByColorRange(newConfig, prop) {
+      var _visConfig$prop$color;
+      if (typeof newConfig.showDropdown !== 'number') return;
+      var _this$config3 = this.config,
+        colorUI = _this$config3.colorUI,
+        visConfig = _this$config3.visConfig;
+      this.updateLayerConfig({
+        colorUI: _objectSpread(_objectSpread({}, colorUI), {}, (0, _defineProperty2["default"])({}, prop, _objectSpread(_objectSpread({}, colorUI[prop]), {}, {
+          colorRangeConfig: _objectSpread(_objectSpread({}, colorUI[prop].colorRangeConfig), {}, {
             type: visConfig[prop].type,
             steps: (_visConfig$prop$color = visConfig[prop].colors) === null || _visConfig$prop$color === void 0 ? void 0 : _visConfig$prop$color.length,
             reversed: Boolean(visConfig[prop].reversed),
             hexColumn: this.getHexColumn(prop),
             isHexColumn: this.isColoredByColorColumn(prop)
+          })
+        })))
+      });
+    }
+
+    // eslint-disable-next-line complexity
+  }, {
+    key: "updateColorRangeByColorUI",
+    value: function updateColorRangeByColorUI(newConfig, previous, prop) {
+      // only update colorRange if changes in UI is made to 'reversed', 'steps' or steps
+      var shouldUpdate = newConfig.colorRangeConfig && ['reversed', 'steps'].some(function (key) {
+        return newConfig.colorRangeConfig.hasOwnProperty(key) && newConfig.colorRangeConfig[key] !== (previous[prop] || _layerFactory.DEFAULT_COLOR_UI).colorRangeConfig[key];
+      });
+      if (!shouldUpdate) return;
+      var _this$config4 = this.config,
+        colorUI = _this$config4.colorUI,
+        visConfig = _this$config4.visConfig;
+      var _colorUI$prop$colorRa = colorUI[prop].colorRangeConfig,
+        steps = _colorUI$prop$colorRa.steps,
+        reversed = _colorUI$prop$colorRa.reversed;
+      var colorRange = visConfig[prop];
+      // find based on step or reversed
+      var update;
+      if (newConfig.colorRangeConfig.hasOwnProperty('steps')) {
+        var group = (0, _colorUtils.getColorGroupByName)(colorRange);
+        if (group) {
+          var sameGroup = _colorRanges.COLOR_RANGES.filter(function (cr) {
+            return (0, _colorUtils.getColorGroupByName)(cr) === group;
+          });
+          update = sameGroup.find(function (cr) {
+            return cr.colors.length === steps;
+          });
+          if (update && colorRange.reversed) {
+            update = (0, _colorUtils.reverseColorRange)(true, update);
+          }
+          if (update && colorRange.colorMap) {
+            update = this.updateColorMap(prop, colorRange.colorMap, update);
           }
         }
       }
-    });
-  }
+      if (newConfig.colorRangeConfig.hasOwnProperty('reversed')) {
+        update = (0, _colorUtils.reverseColorRange)(reversed, update || colorRange);
+      }
+      if (update) {
+        this.updateLayerVisConfig((0, _defineProperty2["default"])({}, prop, update));
+      }
+    }
+  }, {
+    key: "updateColorMap",
+    value: function updateColorMap(prop, colorMap, colorRange) {
+      var _this$config$field;
+      // @ts-ignore
+      var _Object$values$find = Object.values(this.visualChannels).find(function (value) {
+          return value.range === prop;
+        }),
+        field = _Object$values$find.field,
+        domain = _Object$values$find.domain;
+      var type = (_this$config$field = this.config[field]) === null || _this$config$field === void 0 ? void 0 : _this$config$field.type;
+      if (type === 'string' || type === 'boolean' || type === 'date') {
+        return this.updateCategoryColorMap(colorMap, this.config[domain], colorRange);
+      }
 
-  // eslint-disable-next-line complexity
-  updateColorRangeByColorUI(newConfig, previous, prop) {
-    // only update colorRange if changes in UI is made to 'reversed', 'steps' or steps
-    const shouldUpdate = newConfig.colorRangeConfig && ['reversed', 'steps'].some(key => newConfig.colorRangeConfig.hasOwnProperty(key) && newConfig.colorRangeConfig[key] !== (previous[prop] || _layerFactory.DEFAULT_COLOR_UI).colorRangeConfig[key]);
-    if (!shouldUpdate) return;
-    const {
-      colorUI,
-      visConfig
-    } = this.config;
-    const {
-      steps,
-      reversed
-    } = colorUI[prop].colorRangeConfig;
-    const colorRange = visConfig[prop];
-    // find based on step or reversed
-    let update;
-    if (newConfig.colorRangeConfig.hasOwnProperty('steps')) {
-      const group = (0, _colorUtils.getColorGroupByName)(colorRange);
-      if (group) {
-        const sameGroup = _colorRanges.COLOR_RANGES.filter(cr => (0, _colorUtils.getColorGroupByName)(cr) === group);
-        update = sameGroup.find(cr => cr.colors.length === steps);
-        if (update && colorRange.reversed) {
-          update = (0, _colorUtils.reverseColorRange)(true, update);
-        }
-        if (update && colorRange.colorMap) {
-          update = this.updateColorMap(prop, colorRange.colorMap, update);
+      // If no type or type is not string, boolean or date
+      return this.updateNumericColorMap(colorMap, this.config[domain], colorRange);
+    }
+  }, {
+    key: "updateCategoryColorMap",
+    value: function updateCategoryColorMap(colorMap, domain, colorRange) {
+      var colors = colorRange.colors;
+      var assignedCategories = [];
+      if (colorRange.type === _colorRanges.hexColor) {
+        return _objectSpread(_objectSpread({}, colorRange), {}, {
+          colorMap: []
+        });
+      }
+      var newColorMap = colorMap.slice(0, colors.length).map(function (cMap, index) {
+        assignedCategories.push(cMap[0]);
+        return [cMap[0], colors[index]];
+      });
+      var unassignedColors = colors.slice(newColorMap.length, colors.length);
+      var _iterator = _createForOfIteratorHelper(unassignedColors),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var color = _step.value;
+          var category = domain.find(function (d) {
+            return !assignedCategories.includes(d);
+          });
+          if (!category) {
+            break;
+          }
+          assignedCategories.push(category);
+          newColorMap.push([category, color]);
         }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
       }
+      return _objectSpread(_objectSpread({}, colorRange), {}, {
+        colorMap: newColorMap
+      });
     }
-    if (newConfig.colorRangeConfig.hasOwnProperty('reversed')) {
-      update = (0, _colorUtils.reverseColorRange)(reversed, update || colorRange);
-    }
-    if (update) {
-      this.updateLayerVisConfig({
-        [prop]: update
+  }, {
+    key: "updateNumericColorMap",
+    value: function updateNumericColorMap(colorMap, domain, update) {
+      var colors = update.colors;
+      var newColorMap = colorMap.slice(0, colors.length);
+      newColorMap = newColorMap.map(function (cMap, index) {
+        var value = index === newColorMap.length - 1 ? null : cMap[0];
+        return [value, colors[index]];
+      });
+      var unassignedColors = colors.slice(newColorMap.length, colors.length);
+      if (unassignedColors.length > 0) {
+        var colorMapValues = colorMap.map(function (c) {
+          return c[0];
+        }).filter(function (c) {
+          return typeof c === 'number';
+        });
+        var maxValue = Math.max.apply(Math, (0, _toConsumableArray2["default"])(colorMapValues).concat([domain[domain.length - 1]]));
+        var prevValue = newColorMap[newColorMap.length - 2][0];
+        var step = (maxValue - prevValue) / (unassignedColors.length + 1);
+        newColorMap[newColorMap.length - 1][0] = prevValue + step;
+        var _iterator2 = _createForOfIteratorHelper(unassignedColors.entries()),
+          _step2;
+        try {
+          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+            var _step2$value = (0, _slicedToArray2["default"])(_step2.value, 2),
+              i = _step2$value[0],
+              color = _step2$value[1];
+            var value = i === unassignedColors.length - 1 ? null : prevValue + step * (i + 2);
+            newColorMap.push([value, color]);
+          }
+        } catch (err) {
+          _iterator2.e(err);
+        } finally {
+          _iterator2.f();
+        }
+      }
+      return _objectSpread(_objectSpread({}, update), {}, {
+        colorMap: newColorMap
       });
     }
-  }
-  updateColorMap(prop, colorMap, colorRange) {
-    var _this$config$field;
-    // @ts-ignore
-    const {
-      field,
-      domain
-    } = Object.values(this.visualChannels).find(value => value.range === prop);
-    const type = (_this$config$field = this.config[field]) === null || _this$config$field === void 0 ? void 0 : _this$config$field.type;
-    if (type === 'string' || type === 'boolean' || type === 'date') {
-      return this.updateCategoryColorMap(colorMap, this.config[domain], colorRange);
+
+    /**
+     * Check whether layer has all columns
+     * @returns yes or no
+     */
+  }, {
+    key: "hasAllColumns",
+    value: function hasAllColumns() {
+      var columns = this.config.columns;
+      return columns && Object.values(columns).every(function (v) {
+        return Boolean(v.optional || v.value && v.fieldIdx > -1);
+      });
     }
 
-    // If no type or type is not string, boolean or date
-    return this.updateNumericColorMap(colorMap, this.config[domain], colorRange);
-  }
-  updateCategoryColorMap(colorMap, domain, colorRange) {
-    const colors = colorRange.colors;
-    const assignedCategories = [];
-    if (colorRange.type === _colorRanges.hexColor) {
-      return {
-        ...colorRange,
-        colorMap: []
-      };
+    /**
+     * Check whether layer has data
+     *
+     * @param {Array | Object} layerData
+     * @returns {boolean} yes or no
+     */
+  }, {
+    key: "hasLayerData",
+    value: function hasLayerData(layerData) {
+      if (!layerData) {
+        return false;
+      }
+      return Boolean(layerData.data && layerData.data.length);
     }
-    const newColorMap = colorMap.slice(0, colors.length).map((cMap, index) => {
-      assignedCategories.push(cMap[0]);
-      return [cMap[0], colors[index]];
-    });
-    const unassignedColors = colors.slice(newColorMap.length, colors.length);
-    for (const color of unassignedColors) {
-      const category = domain.find(d => !assignedCategories.includes(d));
-      if (!category) {
-        break;
+  }, {
+    key: "isValidToSave",
+    value: function isValidToSave() {
+      return Boolean(this.type && this.hasAllColumns());
+    }
+  }, {
+    key: "shouldRenderLayer",
+    value: function shouldRenderLayer(data) {
+      return Boolean(this.type) && this.hasAllColumns() && this.hasLayerData(data) && typeof this.renderLayer === 'function';
+    }
+  }, {
+    key: "getColorScale",
+    value: function getColorScale(colorScale, colorDomain, colorRange) {
+      if (colorRange.type === _colorRanges.hexColor) {
+        return function (_, color) {
+          var _rgb = (0, _d3Color.rgb)(color),
+            r = _rgb.r,
+            g = _rgb.g,
+            b = _rgb.b;
+          return [r, g, b].some(isNaN) ? _defaultSettings.UNKNOWN_COLOR : [r, g, b];
+        };
+      } else if (Array.isArray(colorRange.colorMap)) {
+        var cMap = new Map();
+        colorRange.colorMap.forEach(function (_ref6) {
+          var _ref7 = (0, _slicedToArray2["default"])(_ref6, 2),
+            k = _ref7[0],
+            v = _ref7[1];
+          cMap.set(k, typeof v === 'string' ? (0, _colorUtils.hexToRgb)(v) : v);
+        });
+        var scale = _defaultSettings.SCALE_FUNC[colorScale]().domain(cMap.keys()).range(cMap.values()).unknown(_defaultSettings.UNKNOWN_COLOR);
+        return scale;
       }
-      assignedCategories.push(category);
-      newColorMap.push([category, color]);
+      return this.getVisChannelScale(colorScale, colorDomain, colorRange.colors.map(_colorUtils.hexToRgb));
     }
-    return {
-      ...colorRange,
-      colorMap: newColorMap
-    };
-  }
-  updateNumericColorMap(colorMap, domain, update) {
-    const colors = update.colors;
-    let newColorMap = colorMap.slice(0, colors.length);
-    newColorMap = newColorMap.map((cMap, index) => {
-      const value = index === newColorMap.length - 1 ? null : cMap[0];
-      return [value, colors[index]];
-    });
-    const unassignedColors = colors.slice(newColorMap.length, colors.length);
-    if (unassignedColors.length > 0) {
-      const colorMapValues = colorMap.map(c => c[0]).filter(c => typeof c === 'number');
-      const maxValue = Math.max(...colorMapValues, domain[domain.length - 1]);
-      const prevValue = newColorMap[newColorMap.length - 2][0];
-      const step = (maxValue - prevValue) / (unassignedColors.length + 1);
-      newColorMap[newColorMap.length - 1][0] = prevValue + step;
-      for (const [i, color] of unassignedColors.entries()) {
-        const value = i === unassignedColors.length - 1 ? null : prevValue + step * (i + 2);
-        newColorMap.push([value, color]);
+  }, {
+    key: "getCustomMarkersScale",
+    value: function getCustomMarkersScale(range, fallbackIcon) {
+      var unknownValue = fallbackIcon || FALLBACK_ICON;
+      if (!range) {
+        return function () {
+          return unknownValue;
+        };
       }
+      var mapping = new Map();
+      if (range.othersMarker) {
+        unknownValue = range.othersMarker;
+      }
+      var _iterator3 = _createForOfIteratorHelper(range.markerMap),
+        _step3;
+      try {
+        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+          var _step3$value = _step3.value,
+            value = _step3$value.value,
+            markerUrl = _step3$value.markerUrl;
+          if (markerUrl) {
+            mapping.set(value, markerUrl);
+          }
+        }
+
+        // @ts-ignore d3 scale
+      } catch (err) {
+        _iterator3.e(err);
+      } finally {
+        _iterator3.f();
+      }
+      var scale = (0, _d3Scale.scaleOrdinal)().domain(Array.from(mapping.keys())).range(Array.from(mapping.values())).unknown(unknownValue);
+      return scale;
     }
-    return {
-      ...update,
-      colorMap: newColorMap
-    };
-  }
 
-  /**
-   * Check whether layer has all columns
-   * @returns yes or no
-   */
-  hasAllColumns() {
-    const {
-      columns
-    } = this.config;
-    return columns && Object.values(columns).every(v => {
-      return Boolean(v.optional || v.value && v.fieldIdx > -1);
-    });
-  }
+    /**
+     * Mapping from visual channels to deck.gl accesors
+     * @param {Object} param Parameters
+     * @param {Function} param.dataAccessor Access kepler.gl layer data from deck.gl layer
+     * @param {import('utils/table-utils/data-container-interface').DataContainerInterface} param.dataContainer DataContainer to use use with dataAccessor
+     * @return {Object} attributeAccessors - deck.gl layer attribute accessors
+     */
+  }, {
+    key: "getAttributeAccessors",
+    value: function getAttributeAccessors(_ref8) {
+      var _this4 = this;
+      var _ref8$dataAccessor = _ref8.dataAccessor,
+        dataAccessor = _ref8$dataAccessor === void 0 ? defaultDataAccessor : _ref8$dataAccessor,
+        dataContainer = _ref8.dataContainer;
+      var attributeAccessors = {};
 
-  /**
-   * Check whether layer has data
-   *
-   * @param {Array | Object} layerData
-   * @returns {boolean} yes or no
-   */
-  hasLayerData(layerData) {
-    if (!layerData) {
-      return false;
-    }
-    return Boolean(layerData.data && layerData.data.length);
-  }
-  isValidToSave() {
-    return Boolean(this.type && this.hasAllColumns());
-  }
-  shouldRenderLayer(data) {
-    return Boolean(this.type) && this.hasAllColumns() && this.hasLayerData(data) && typeof this.renderLayer === 'function';
-  }
-  getColorScale(colorScale, colorDomain, colorRange) {
-    if (colorRange.type === _colorRanges.hexColor) {
-      return (_, color) => {
-        const {
-          r,
-          g,
-          b
-        } = (0, _d3Color.rgb)(color);
-        return [r, g, b].some(isNaN) ? _defaultSettings.UNKNOWN_COLOR : [r, g, b];
-      };
-    } else if (Array.isArray(colorRange.colorMap)) {
-      const cMap = new Map();
-      colorRange.colorMap.forEach(_ref4 => {
-        let [k, v] = _ref4;
-        cMap.set(k, typeof v === 'string' ? (0, _colorUtils.hexToRgb)(v) : v);
+      // eslint-disable-next-line complexity
+      Object.keys(this.visualChannels).forEach(function (channel) {
+        var _this4$visualChannels = _this4.visualChannels[channel],
+          field = _this4$visualChannels.field,
+          fixed = _this4$visualChannels.fixed,
+          scale = _this4$visualChannels.scale,
+          domain = _this4$visualChannels.domain,
+          range = _this4$visualChannels.range,
+          accessor = _this4$visualChannels.accessor,
+          defaultValue = _this4$visualChannels.defaultValue,
+          getAttributeValue = _this4$visualChannels.getAttributeValue,
+          nullValue = _this4$visualChannels.nullValue,
+          channelScaleType = _this4$visualChannels.channelScaleType,
+          aggregation = _this4$visualChannels.aggregation;
+        var shouldGetScale = Boolean((scale || channelScaleType === _defaultSettings.CHANNEL_SCALES.identity) && _this4.config[field]);
+        if (shouldGetScale) {
+          var isFixed = fixed && _this4.config.visConfig[fixed];
+          // It's important to declare as const all the parameters that we are going to be use in the getEncodedChannelValue call
+          // otherwise, the oldLayerData parameter in formatLayerData method will be wrong (you can check the formatLayerData TileLayer method in Builder as example)
+          var fieldConfig = _this4.config[field];
+          var aggregationValue = _this4.config.visConfig[aggregation];
+          var scaleFunction = channelScaleType === _defaultSettings.CHANNEL_SCALES.identity ? scaleIdentity : channelScaleType === _defaultSettings.CHANNEL_SCALES.color ? _this4.getColorScale(_this4.config[scale], _this4.config[domain], _this4.config.visConfig[range]) : channelScaleType === _defaultSettings.CHANNEL_SCALES.customMarker ? _this4.getCustomMarkersScale(_this4.config.visConfig[range], _this4.config.visConfig.customMarkersUrl) : _this4.getVisChannelScale(_this4.config[scale], _this4.config[domain], _this4.config.visConfig[range], isFixed);
+          attributeAccessors[accessor] = function (d) {
+            return _this4.getEncodedChannelValue({
+              channel: channel,
+              dataContainer: dataContainer,
+              scale: scaleFunction,
+              data: dataAccessor(dataContainer)(d),
+              field: fieldConfig,
+              aggregation: aggregationValue,
+              nullValue: nullValue
+            });
+          };
+        } else if (typeof getAttributeValue === 'function') {
+          attributeAccessors[accessor] = getAttributeValue(_this4.config);
+        } else {
+          attributeAccessors[accessor] = typeof defaultValue === 'function' ? defaultValue(_this4.config) : defaultValue;
+        }
+        if (!(accessor in attributeAccessors)) {
+          _window.console.warn("Failed to provide accessor function for ".concat(accessor || channel));
+        }
       });
-      const scale = _defaultSettings.SCALE_FUNC[colorScale]().domain(cMap.keys()).range(cMap.values()).unknown(_defaultSettings.UNKNOWN_COLOR);
-      return scale;
+      return attributeAccessors;
     }
-    return this.getVisChannelScale(colorScale, colorDomain, colorRange.colors.map(_colorUtils.hexToRgb));
-  }
-  getCustomMarkersScale(range, fallbackIcon) {
-    let unknownValue = fallbackIcon || FALLBACK_ICON;
-    if (!range) {
-      return () => unknownValue;
-    }
-    const mapping = new Map();
-    if (range.othersMarker) {
-      unknownValue = range.othersMarker;
-    }
-    for (const {
-      value,
-      markerUrl
-    } of range.markerMap) {
-      if (markerUrl) {
-        mapping.set(value, markerUrl);
+  }, {
+    key: "getVisChannelScale",
+    value: function getVisChannelScale(scale, domain, range, fixed) {
+      if (scale === _defaultSettings.SCALE_TYPES.ordinal) {
+        return _defaultSettings.SCALE_FUNC[scale]().domain(domain.slice(0, range.length)).range(range).unknown(_defaultSettings.UNKNOWN_COLOR);
       }
-    }
-
-    // @ts-ignore d3 scale
-    const scale = (0, _d3Scale.scaleOrdinal)().domain(Array.from(mapping.keys())).range(Array.from(mapping.values())).unknown(unknownValue);
-    return scale;
-  }
 
-  /**
-   * Mapping from visual channels to deck.gl accesors
-   * @param {Object} param Parameters
-   * @param {Function} param.dataAccessor Access kepler.gl layer data from deck.gl layer
-   * @param {import('utils/table-utils/data-container-interface').DataContainerInterface} param.dataContainer DataContainer to use use with dataAccessor
-   * @return {Object} attributeAccessors - deck.gl layer attribute accessors
-   */
-  getAttributeAccessors(_ref5) {
-    let {
-      dataAccessor = defaultDataAccessor,
-      dataContainer
-    } = _ref5;
-    const attributeAccessors = {};
+      // for `count` aggregation, we domain is actually `[0, Infinity]` so it doesn't make sense
+      // to use it, so skip specyfying this domains
+      var domainIsInfinite = domain && domain[0] === 0 && domain[1] === Infinity;
+      var scaleFactory = _defaultSettings.SCALE_FUNC[fixed ? 'linear' : scale];
+      // @ts-ignore d3-scale type
+      var result = scaleFactory();
+      if (domain && !domainIsInfinite) {
+        result = result.domain(domain);
+      }
+      return result.range(fixed ? domain : range);
+    }
 
-    // eslint-disable-next-line complexity
-    Object.keys(this.visualChannels).forEach(channel => {
-      const {
-        field,
-        fixed,
-        scale,
-        domain,
-        range,
-        accessor,
-        defaultValue,
-        getAttributeValue,
-        nullValue,
-        channelScaleType,
-        aggregation
-      } = this.visualChannels[channel];
-      const shouldGetScale = Boolean((scale || channelScaleType === _defaultSettings.CHANNEL_SCALES.identity) && this.config[field]);
-      if (shouldGetScale) {
-        const isFixed = fixed && this.config.visConfig[fixed];
-        // It's important to declare as const all the parameters that we are going to be use in the getEncodedChannelValue call
-        // otherwise, the oldLayerData parameter in formatLayerData method will be wrong (you can check the formatLayerData TileLayer method in Builder as example)
-        const fieldConfig = this.config[field];
-        const aggregationValue = this.config.visConfig[aggregation];
-        const scaleFunction = channelScaleType === _defaultSettings.CHANNEL_SCALES.identity ? scaleIdentity : channelScaleType === _defaultSettings.CHANNEL_SCALES.color ? this.getColorScale(this.config[scale], this.config[domain], this.config.visConfig[range]) : channelScaleType === _defaultSettings.CHANNEL_SCALES.customMarker ? this.getCustomMarkersScale(this.config.visConfig[range], this.config.visConfig.customMarkersUrl) : this.getVisChannelScale(this.config[scale], this.config[domain], this.config.visConfig[range], isFixed);
-        attributeAccessors[accessor] = d => this.getEncodedChannelValue({
-          channel,
-          dataContainer,
-          scale: scaleFunction,
-          data: dataAccessor(dataContainer)(d),
-          field: fieldConfig,
-          aggregation: aggregationValue,
-          nullValue
-        });
-      } else if (typeof getAttributeValue === 'function') {
-        attributeAccessors[accessor] = getAttributeValue(this.config);
+    /**
+     * Get longitude and latitude bounds of the data.
+     * @param {import('utils/table-utils/data-container-interface').DataContainerInterface} dataContainer DataContainer to calculate bounds for.
+     * @param {(d: {index: number}, dc: import('utils/table-utils/data-container-interface').DataContainerInterface) => number[]} getPosition Access kepler.gl layer data from deck.gl layer
+     * @return {number[]|null} bounds of the data.
+     */
+  }, {
+    key: "getPointsBounds",
+    value: function getPointsBounds(dataContainer, getPosition) {
+      // no need to loop through the entire dataset
+      // get a sample of data to calculate bounds
+      var sampleData = dataContainer.numRows() > MAX_SAMPLE_SIZE ? (0, _dataContainerUtils.getSampleData)(dataContainer, MAX_SAMPLE_SIZE) : dataContainer;
+      var points = sampleData.mapIndex(getPosition);
+      var latBounds = (0, _dataUtils.getLatLngBounds)(points, 1, [-90, 90]);
+      var lngBounds = (0, _dataUtils.getLatLngBounds)(points, 0, [-180, 180]);
+      if (!latBounds || !lngBounds) {
+        return null;
+      }
+      return [lngBounds[0], latBounds[0], lngBounds[1], latBounds[1]];
+    }
+  }, {
+    key: "getChangedTriggers",
+    value: function getChangedTriggers(dataUpdateTriggers) {
+      var triggerChanged = (0, _layerUpdate.diffUpdateTriggers)(dataUpdateTriggers, this._oldDataUpdateTriggers);
+      this._oldDataUpdateTriggers = dataUpdateTriggers;
+      return triggerChanged;
+    }
+  }, {
+    key: "getEncodedChannelValue",
+    value: function getEncodedChannelValue(_ref9) {
+      var channel = _ref9.channel,
+        scale = _ref9.scale,
+        data = _ref9.data,
+        field = _ref9.field,
+        dataContainer = _ref9.dataContainer,
+        aggregation = _ref9.aggregation,
+        _ref9$nullValue = _ref9.nullValue,
+        nullValue = _ref9$nullValue === void 0 ? _defaultSettings.NO_VALUE_COLOR : _ref9$nullValue,
+        _ref9$getValue = _ref9.getValue,
+        getValue = _ref9$getValue === void 0 ? defaultGetFieldValue : _ref9$getValue;
+      var type = field.type;
+      var value = getValue(field, data);
+      var channelConfig = this.config.visConfig[this.visualChannels[channel].range];
+      var channelField = this.config[this.visualChannels[channel].field];
+      var colorColumnValue;
+      if ((channelConfig === null || channelConfig === void 0 ? void 0 : channelConfig.type) === _colorRanges.hexColor) {
+        var columnField = {
+          id: channelField.colorColumn,
+          name: channelField.colorColumn,
+          fieldIdx: channelField.colorColumnIdx,
+          valueAccessor: function valueAccessor(d) {
+            return dataContainer.valueAt(d.index, channelField.colorColumnIdx);
+          }
+        };
+        colorColumnValue = getValue(columnField, data);
+      } else if (!(0, _dataUtils.notNullorUndefined)(value)) {
+        return nullValue;
+      }
+      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), colorColumnValue);
       } else {
-        attributeAccessors[accessor] = typeof defaultValue === 'function' ? defaultValue(this.config) : defaultValue;
+        attributeValue = scale(value, colorColumnValue);
       }
-      if (!(accessor in attributeAccessors)) {
-        _window.console.warn(`Failed to provide accessor function for ${accessor || channel}`);
+      if (!(0, _dataUtils.notNullorUndefined)(attributeValue)) {
+        attributeValue = nullValue;
       }
-    });
-    return attributeAccessors;
-  }
-  getVisChannelScale(scale, domain, range, fixed) {
-    if (scale === _defaultSettings.SCALE_TYPES.ordinal) {
-      return _defaultSettings.SCALE_FUNC[scale]().domain(domain.slice(0, range.length)).range(range).unknown(_defaultSettings.UNKNOWN_COLOR);
+      return attributeValue;
     }
-
-    // for `count` aggregation, we domain is actually `[0, Infinity]` so it doesn't make sense
-    // to use it, so skip specyfying this domains
-    const domainIsInfinite = domain && domain[0] === 0 && domain[1] === Infinity;
-    const scaleFactory = _defaultSettings.SCALE_FUNC[fixed ? 'linear' : scale];
-    // @ts-ignore d3-scale type
-    let result = scaleFactory();
-    if (domain && !domainIsInfinite) {
-      result = result.domain(domain);
-    }
-    return result.range(fixed ? domain : range);
-  }
-
-  /**
-   * Get longitude and latitude bounds of the data.
-   * @param {import('utils/table-utils/data-container-interface').DataContainerInterface} dataContainer DataContainer to calculate bounds for.
-   * @param {(d: {index: number}, dc: import('utils/table-utils/data-container-interface').DataContainerInterface) => number[]} getPosition Access kepler.gl layer data from deck.gl layer
-   * @return {number[]|null} bounds of the data.
-   */
-  getPointsBounds(dataContainer, getPosition) {
-    // no need to loop through the entire dataset
-    // get a sample of data to calculate bounds
-    const sampleData = dataContainer.numRows() > MAX_SAMPLE_SIZE ? (0, _dataContainerUtils.getSampleData)(dataContainer, MAX_SAMPLE_SIZE) : dataContainer;
-    const points = sampleData.mapIndex(getPosition);
-    const latBounds = (0, _dataUtils.getLatLngBounds)(points, 1, [-90, 90]);
-    const lngBounds = (0, _dataUtils.getLatLngBounds)(points, 0, [-180, 180]);
-    if (!latBounds || !lngBounds) {
-      return null;
+  }, {
+    key: "updateMeta",
+    value: function updateMeta(meta) {
+      this.meta = _objectSpread(_objectSpread({}, this.meta), meta);
     }
-    return [lngBounds[0], latBounds[0], lngBounds[1], latBounds[1]];
-  }
-  getChangedTriggers(dataUpdateTriggers) {
-    const triggerChanged = (0, _layerUpdate.diffUpdateTriggers)(dataUpdateTriggers, this._oldDataUpdateTriggers);
-    this._oldDataUpdateTriggers = dataUpdateTriggers;
-    return triggerChanged;
-  }
-  getEncodedChannelValue(_ref6) {
-    let {
-      channel,
-      scale,
-      data,
-      field,
-      dataContainer,
-      // In builder we overwrite the getValue function and we use the _aggregation parameter in spatial index layers as the QuadkeyLayer.
-      aggregation,
-      nullValue = _defaultSettings.NO_VALUE_COLOR,
-      getValue = defaultGetFieldValue
-    } = _ref6;
-    const {
-      type
-    } = field;
-    const value = getValue(field, data);
-    const channelConfig = this.config.visConfig[this.visualChannels[channel].range];
-    const channelField = this.config[this.visualChannels[channel].field];
-    let colorColumnValue;
-    if ((channelConfig === null || channelConfig === void 0 ? void 0 : channelConfig.type) === _colorRanges.hexColor) {
-      const columnField = {
-        id: channelField.colorColumn,
-        name: channelField.colorColumn,
-        fieldIdx: channelField.colorColumnIdx,
-        valueAccessor: d => {
-          return dataContainer.valueAt(d.index, channelField.colorColumnIdx);
+  }, {
+    key: "updateLayerLegend",
+    value: function updateLayerLegend(settings) {
+      this.legendSettings = settings;
+    }
+
+    // @ts-expect-error
+  }, {
+    key: "getDataUpdateTriggers",
+    value: function getDataUpdateTriggers(_ref10) {
+      var filteredIndex = _ref10.filteredIndex,
+        id = _ref10.id,
+        allData = _ref10.allData;
+      var columns = this.config.columns;
+      return _objectSpread({
+        getData: {
+          datasetId: id,
+          allData: allData,
+          columns: columns,
+          filteredIndex: filteredIndex
+        },
+        getMeta: {
+          datasetId: id,
+          allData: allData,
+          columns: columns
         }
+      }, (this.config.textLabel || []).reduce(function (accu, tl, i) {
+        return _objectSpread(_objectSpread({}, accu), {}, (0, _defineProperty2["default"])({}, "getLabelCharacterSet-".concat(i), tl.field ? tl.field.name : null));
+      }, {}));
+    }
+  }, {
+    key: "updateData",
+    value: function updateData(datasets, oldLayerData) {
+      if (!this.config.dataId) {
+        return {};
+      }
+      var dataset = this.getDataset(datasets);
+      var dataContainer = dataset.dataContainer;
+      this.updateVisualChannelFields(dataset);
+      this.updateHexColorDomain(dataset);
+      var getPosition = this.getPositionAccessor(dataContainer);
+      var dataUpdateTriggers = this.getDataUpdateTriggers(dataset);
+      var triggerChanged = this.getChangedTriggers(dataUpdateTriggers);
+      if (triggerChanged && triggerChanged.getMeta) {
+        this.updateLayerMeta(dataContainer, getPosition);
+      }
+      var data = [];
+      if (!(triggerChanged && triggerChanged.getData) && oldLayerData && oldLayerData.data) {
+        // same data
+        data = oldLayerData.data;
+      } else {
+        data = this.calculateDataAttribute(dataset, getPosition);
+      }
+      return {
+        data: data,
+        triggerChanged: triggerChanged
       };
-      colorColumnValue = getValue(columnField, data);
-    } else if (!(0, _dataUtils.notNullorUndefined)(value)) {
-      return nullValue;
-    }
-    let 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), colorColumnValue);
-    } else {
-      attributeValue = scale(value, colorColumnValue);
-    }
-    if (!(0, _dataUtils.notNullorUndefined)(attributeValue)) {
-      attributeValue = nullValue;
-    }
-    return attributeValue;
-  }
-  updateMeta(meta) {
-    this.meta = {
-      ...this.meta,
-      ...meta
-    };
-  }
-  updateLayerLegend(settings) {
-    this.legendSettings = settings;
-  }
-
-  // @ts-expect-error
-  getDataUpdateTriggers(_ref7) {
-    let {
-      filteredIndex,
-      id,
-      allData
-    } = _ref7;
-    const {
-      columns
-    } = this.config;
-    return {
-      getData: {
-        datasetId: id,
-        allData,
-        columns,
-        filteredIndex
-      },
-      getMeta: {
-        datasetId: id,
-        allData,
-        columns
-      },
-      ...(this.config.textLabel || []).reduce((accu, tl, i) => ({
-        ...accu,
-        [`getLabelCharacterSet-${i}`]: tl.field ? tl.field.name : null
-      }), {})
-    };
-  }
-  updateData(datasets, oldLayerData) {
-    if (!this.config.dataId) {
-      return {};
     }
-    const dataset = this.getDataset(datasets);
-    const {
-      dataContainer
-    } = dataset;
-    this.updateVisualChannelFields(dataset);
-    this.updateHexColorDomain(dataset);
-    const getPosition = this.getPositionAccessor(dataContainer);
-    const dataUpdateTriggers = this.getDataUpdateTriggers(dataset);
-    const triggerChanged = this.getChangedTriggers(dataUpdateTriggers);
-    if (triggerChanged && triggerChanged.getMeta) {
-      this.updateLayerMeta(dataContainer, getPosition);
-    }
-    let data = [];
-    if (!(triggerChanged && triggerChanged.getData) && oldLayerData && oldLayerData.data) {
-      // same data
-      data = oldLayerData.data;
-    } else {
-      data = this.calculateDataAttribute(dataset, getPosition);
-    }
-    return {
-      data,
-      triggerChanged
-    };
-  }
 
-  /**
-   * Update styled fields to match ones from new dataset.
-   *
-   * @param {Object} dataset
-   */
-  updateVisualChannelFields(dataset) {
-    for (const {
-      field,
-      range
-    } of Object.values(this.visualChannels)) {
-      var _this$config$visConfi;
-      const oldField = this.config[field];
-      const isUsingHexColorCode = (_this$config$visConfi = this.config.visConfig[range]) === null || _this$config$visConfi === void 0 ? void 0 : _this$config$visConfi.hexColor;
-      if (!oldField) {
-        return;
+    /**
+     * Update styled fields to match ones from new dataset.
+     *
+     * @param {Object} dataset
+     */
+  }, {
+    key: "updateVisualChannelFields",
+    value: function updateVisualChannelFields(dataset) {
+      var _this5 = this;
+      var _loop = function _loop() {
+          var _this5$config$visConf;
+          var _Object$values$_i = _Object$values[_i],
+            field = _Object$values$_i.field,
+            range = _Object$values$_i.range;
+          var oldField = _this5.config[field];
+          var isUsingHexColorCode = (_this5$config$visConf = _this5.config.visConfig[range]) === null || _this5$config$visConf === void 0 ? void 0 : _this5$config$visConf.hexColor;
+          if (!oldField) {
+            return {
+              v: void 0
+            };
+          }
+          var newDataSetField = dataset.fields.find(function (fd) {
+            return fd.name === oldField.name;
+          }) || null;
+          if (isUsingHexColorCode) {
+            newDataSetField = _objectSpread(_objectSpread({}, newDataSetField), {}, {
+              colorColumn: newDataSetField.colorColumn || oldField.colorColumn,
+              colorColumnIdx: newDataSetField.colorColumnIdx || oldField.colorColumnIdx
+            });
+          }
+          _this5.updateLayerConfig((0, _defineProperty2["default"])({}, field, newDataSetField));
+        },
+        _ret;
+      for (var _i = 0, _Object$values = Object.values(this.visualChannels); _i < _Object$values.length; _i++) {
+        _ret = _loop();
+        if (_ret) return _ret.v;
       }
-      let newDataSetField = dataset.fields.find(fd => fd.name === oldField.name) || null;
-      if (isUsingHexColorCode) {
-        newDataSetField = {
-          ...newDataSetField,
-          colorColumn: newDataSetField.colorColumn || oldField.colorColumn,
-          colorColumnIdx: newDataSetField.colorColumnIdx || oldField.colorColumnIdx
-        };
+    }
+
+    /**
+     * 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 datasets
+     * @param newFilter
+     * @returns layer
+     */
+  }, {
+    key: "updateLayerDomain",
+    value: function updateLayerDomain(datasets, newFilter) {
+      var _this6 = this;
+      var table = this.getDataset(datasets);
+      if (!table) {
+        return this;
       }
-      this.updateLayerConfig({
-        [field]: newDataSetField
+      Object.values(this.visualChannels).forEach(function (channel) {
+        var scale = channel.scale;
+        var scaleType = _this6.config[scale];
+
+        // ordinal domain is based on dataContainer, if only filter changed
+        // no need to update ordinal domain
+        if (!newFilter || scaleType !== _defaultSettings.SCALE_TYPES.ordinal) {
+          var domain = channel.domain;
+          var updatedDomain = _this6.calculateLayerDomain(table, channel);
+          _this6.updateLayerConfig((0, _defineProperty2["default"])({}, domain, updatedDomain));
+        }
       });
+      return this;
+    }
+  }, {
+    key: "getDataset",
+    value: function getDataset(datasets) {
+      return this.config.dataId ? datasets[this.config.dataId] : null;
     }
-  }
 
-  /**
-   * 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 datasets
-   * @param newFilter
-   * @returns layer
-   */
-  updateLayerDomain(datasets, newFilter) {
-    const table = this.getDataset(datasets);
-    if (!table) {
-      return this;
+    /**
+     * Validate visual channel field and scales based on supported field & scale type
+     * @param channel
+     */
+  }, {
+    key: "validateVisualChannel",
+    value: function validateVisualChannel(channel) {
+      this.validateFieldType(channel);
+      this.validateScale(channel);
     }
-    Object.values(this.visualChannels).forEach(channel => {
-      const {
-        scale
-      } = channel;
-      const scaleType = this.config[scale];
 
-      // ordinal domain is based on dataContainer, if only filter changed
-      // no need to update ordinal domain
-      if (!newFilter || scaleType !== _defaultSettings.SCALE_TYPES.ordinal) {
-        const {
-          domain
-        } = channel;
-        const updatedDomain = this.calculateLayerDomain(table, channel);
-        this.updateLayerConfig({
-          [domain]: updatedDomain
-        });
+    /**
+     * Validate field type based on channelScaleType
+     */
+  }, {
+    key: "validateFieldType",
+    value: function validateFieldType(channel) {
+      var visualChannel = this.visualChannels[channel];
+      var field = visualChannel.field,
+        channelScaleType = visualChannel.channelScaleType,
+        supportedFieldTypes = visualChannel.supportedFieldTypes;
+      if (this.config[field]) {
+        // if field is selected, check if field type is supported
+        var channelSupportedFieldTypes = supportedFieldTypes || _defaultSettings.CHANNEL_SCALE_SUPPORTED_FIELDS[channelScaleType];
+        if (!channelSupportedFieldTypes.includes(this.config[field].type)) {
+          // field type is not supported, set it back to null
+          // set scale back to default
+          this.updateLayerConfig((0, _defineProperty2["default"])({}, field, null));
+        }
       }
-    });
-    return this;
-  }
-  getDataset(datasets) {
-    return this.config.dataId ? datasets[this.config.dataId] : null;
-  }
-
-  /**
-   * Validate visual channel field and scales based on supported field & scale type
-   * @param channel
-   */
-  validateVisualChannel(channel) {
-    this.validateFieldType(channel);
-    this.validateScale(channel);
-  }
+    }
 
-  /**
-   * Validate field type based on channelScaleType
-   */
-  validateFieldType(channel) {
-    const visualChannel = this.visualChannels[channel];
-    const {
-      field,
-      channelScaleType,
-      supportedFieldTypes
-    } = visualChannel;
-    if (this.config[field]) {
-      // if field is selected, check if field type is supported
-      const channelSupportedFieldTypes = supportedFieldTypes || _defaultSettings.CHANNEL_SCALE_SUPPORTED_FIELDS[channelScaleType];
-      if (!channelSupportedFieldTypes.includes(this.config[field].type)) {
-        // field type is not supported, set it back to null
-        // set scale back to default
-        this.updateLayerConfig({
-          [field]: null
-        });
+    /**
+     * Validate scale type based on aggregation
+     */
+  }, {
+    key: "validateScale",
+    value: function validateScale(channel) {
+      var visualChannel = this.visualChannels[channel];
+      var scale = visualChannel.scale,
+        range = visualChannel.range;
+      if (!scale || this.isColoredByColorColumn(range) && this.config[scale] === _defaultSettings.SCALE_TYPES.identity) {
+        // visualChannel doesn't have scale
+        return;
+      }
+      var scaleOptions = this.getScaleOptions(channel);
+      // check if current selected scale is
+      // supported, if not, change to default
+      if (!scaleOptions.includes(this.config[scale])) {
+        this.updateLayerConfig((0, _defineProperty2["default"])({}, scale, scaleOptions[0]));
       }
     }
-  }
 
-  /**
-   * Validate scale type based on aggregation
-   */
-  validateScale(channel) {
-    const visualChannel = this.visualChannels[channel];
-    const {
-      scale,
-      range
-    } = visualChannel;
-    if (!scale || this.isColoredByColorColumn(range) && this.config[scale] === _defaultSettings.SCALE_TYPES.identity) {
-      // visualChannel doesn't have scale
-      return;
-    }
-    const scaleOptions = this.getScaleOptions(channel);
-    // check if current selected scale is
-    // supported, if not, change to default
-    if (!scaleOptions.includes(this.config[scale])) {
-      this.updateLayerConfig({
-        [scale]: scaleOptions[0]
+    /**
+     * Get scale options based on current field
+     * @param {string} channel
+     * @returns {string[]}
+     */
+  }, {
+    key: "getScaleOptions",
+    value: function getScaleOptions(channel) {
+      var visualChannel = this.visualChannels[channel];
+      var field = visualChannel.field,
+        scale = visualChannel.scale,
+        channelScaleType = visualChannel.channelScaleType;
+      return this.config[field] ? _defaultSettings.FIELD_OPTS[this.config[field].type].scale[channelScaleType] : [this.getDefaultLayerConfig()[scale]];
+    }
+  }, {
+    key: "updateLayerVisualChannel",
+    value: function updateLayerVisualChannel(dataset, channel) {
+      var visualChannel = this.visualChannels[channel];
+      this.validateVisualChannel(channel);
+      // calculate layer channel domain
+      var updatedDomain = this.calculateLayerDomain(dataset, visualChannel);
+      this.updateLayerConfig((0, _defineProperty2["default"])({}, visualChannel.domain, updatedDomain));
+    }
+  }, {
+    key: "getVisualChannelUpdateTriggers",
+    value: function getVisualChannelUpdateTriggers() {
+      var _this7 = this;
+      var updateTriggers = {};
+      Object.values(this.visualChannels).forEach(function (visualChannel) {
+        // field range scale domain
+        var accessor = visualChannel.accessor,
+          field = visualChannel.field,
+          scale = visualChannel.scale,
+          domain = visualChannel.domain,
+          range = visualChannel.range,
+          defaultValue = visualChannel.defaultValue,
+          fixed = visualChannel.fixed;
+        if (accessor) {
+          updateTriggers[accessor] = _objectSpread((0, _defineProperty2["default"])((0, _defineProperty2["default"])((0, _defineProperty2["default"])((0, _defineProperty2["default"])((0, _defineProperty2["default"])({}, field, _this7.config[field]), scale, _this7.config[scale]), domain, _this7.config[domain]), range, _this7.config.visConfig[range]), "defaultValue", typeof defaultValue === 'function' ? defaultValue(_this7.config) : defaultValue), fixed ? (0, _defineProperty2["default"])({}, fixed, _this7.config.visConfig[fixed]) : {});
+        }
       });
+      return updateTriggers;
     }
-  }
-
-  /**
-   * Get scale options based on current field
-   * @param {string} channel
-   * @returns {string[]}
-   */
-  getScaleOptions(channel) {
-    const visualChannel = this.visualChannels[channel];
-    const {
-      field,
-      scale,
-      channelScaleType
-    } = visualChannel;
-    return this.config[field] ? _defaultSettings.FIELD_OPTS[this.config[field].type].scale[channelScaleType] : [this.getDefaultLayerConfig()[scale]];
-  }
-  updateLayerVisualChannel(dataset, channel) {
-    const visualChannel = this.visualChannels[channel];
-    this.validateVisualChannel(channel);
-    // calculate layer channel domain
-    const updatedDomain = this.calculateLayerDomain(dataset, visualChannel);
-    this.updateLayerConfig({
-      [visualChannel.domain]: updatedDomain
-    });
-  }
-  getVisualChannelUpdateTriggers() {
-    const updateTriggers = {};
-    Object.values(this.visualChannels).forEach(visualChannel => {
-      // field range scale domain
-      const {
-        accessor,
-        field,
-        scale,
-        domain,
-        range,
-        defaultValue,
-        fixed
-      } = visualChannel;
-      if (accessor) {
-        updateTriggers[accessor] = {
-          [field]: this.config[field],
-          [scale]: this.config[scale],
-          [domain]: this.config[domain],
-          [range]: this.config.visConfig[range],
-          defaultValue: typeof defaultValue === 'function' ? defaultValue(this.config) : defaultValue,
-          ...(fixed ? {
-            [fixed]: this.config.visConfig[fixed]
-          } : {})
-        };
+  }, {
+    key: "calculateLayerDomain",
+    value: function calculateLayerDomain(dataset, visualChannel) {
+      var scale = visualChannel.scale;
+      var field = this.config[visualChannel.field];
+      if (!field || !scale) {
+        // if colorField or sizeField were set back to null
+        return defaultDomain;
       }
-    });
-    return updateTriggers;
-  }
-  calculateLayerDomain(dataset, visualChannel) {
-    const {
-      scale
-    } = visualChannel;
-    const field = this.config[visualChannel.field];
-    if (!field || !scale) {
-      // if colorField or sizeField were set back to null
-      return defaultDomain;
-    }
-    const scaleType = this.config[scale];
-    const dataSetField = dataset.fields.find(f => f.name === field.name);
-    if (!scaleType || !dataSetField) {
-      // if new dataset doesn't contain previously set field
-      return defaultDomain;
-    }
-    return dataset.getColumnLayerDomain(dataSetField, scaleType) || defaultDomain;
-  }
-  updateHexColorDomain(dataset) {
-    if (!dataset) {
+      var scaleType = this.config[scale];
+      var dataSetField = dataset.fields.find(function (f) {
+        return f.name === field.name;
+      });
+      if (!scaleType || !dataSetField) {
+        // if new dataset doesn't contain previously set field
+        return defaultDomain;
+      }
+      return dataset.getColumnLayerDomain(dataSetField, scaleType) || defaultDomain;
+    }
+  }, {
+    key: "updateHexColorDomain",
+    value: function updateHexColorDomain(dataset) {
+      var _this8 = this;
+      if (!dataset) {
+        return this;
+      }
+      Object.values(this.visualChannels).forEach(function (channel) {
+        var channelConfig = _this8.config.visConfig[channel.range];
+        var field = _this8.config[channel.field];
+        if ((channelConfig === null || channelConfig === void 0 ? void 0 : channelConfig.type) === _colorRanges.hexColor && field !== null && field !== void 0 && field.colorColumn) {
+          var dataSetField = dataset.fields.find(function (f) {
+            return f.name === field.colorColumn;
+          });
+          var colors = dataset.getColumnLayerDomain(dataSetField, _defaultSettings.SCALE_TYPES.ordinal).map(function (c) {
+            return (0, _colorUtils.checkColorOrFallback)(c);
+          });
+          _this8.updateLayerVisConfig((0, _defineProperty2["default"])({}, channel.range, _objectSpread(_objectSpread({}, channelConfig), {}, {
+            colors: colors
+          })));
+        }
+      });
       return this;
     }
-    Object.values(this.visualChannels).forEach(channel => {
-      const channelConfig = this.config.visConfig[channel.range];
-      const field = this.config[channel.field];
-      if ((channelConfig === null || channelConfig === void 0 ? void 0 : channelConfig.type) === _colorRanges.hexColor && field !== null && field !== void 0 && field.colorColumn) {
-        const dataSetField = dataset.fields.find(f => f.name === field.colorColumn);
-        const colors = dataset.getColumnLayerDomain(dataSetField, _defaultSettings.SCALE_TYPES.ordinal).map(c => (0, _colorUtils.checkColorOrFallback)(c));
-        this.updateLayerVisConfig({
-          [channel.range]: {
-            ...channelConfig,
-            colors
-          }
-        });
+  }, {
+    key: "calculateHexColumnLegend",
+    value: function calculateHexColumnLegend(datasets) {
+      var _this9 = this;
+      var dataset = this.getDataset(datasets);
+      if (!datasets) {
+        return;
       }
-    });
-    return this;
-  }
-  calculateHexColumnLegend(datasets) {
-    const dataset = this.getDataset(datasets);
-    if (!datasets) {
-      return;
-    }
-    const legendSettings = Object.keys(this.visualChannels).reduce((legends, channel) => {
-      const {
-        range,
-        field: channelField
-      } = this.visualChannels[channel];
-      const channelConfig = this.config.visConfig[range];
-      const field = this.config[channelField];
-      if ((channelConfig === null || channelConfig === void 0 ? void 0 : channelConfig.type) === _colorRanges.hexColor && field !== null && field !== void 0 && field.colorColumn) {
-        const dataSetField = dataset.fields.find(f => f.name === field.colorColumn);
-        const legend = dataset.calculateLegend(field, dataSetField);
-        legends[channel] = legend;
+      var legendSettings = Object.keys(this.visualChannels).reduce(function (legends, channel) {
+        var _this9$visualChannels = _this9.visualChannels[channel],
+          range = _this9$visualChannels.range,
+          channelField = _this9$visualChannels.field;
+        var channelConfig = _this9.config.visConfig[range];
+        var field = _this9.config[channelField];
+        if ((channelConfig === null || channelConfig === void 0 ? void 0 : channelConfig.type) === _colorRanges.hexColor && field !== null && field !== void 0 && field.colorColumn) {
+          var dataSetField = dataset.fields.find(function (f) {
+            return f.name === field.colorColumn;
+          });
+          var legend = dataset.calculateLegend(field, dataSetField);
+          legends[channel] = legend;
+        }
+        return legends;
+      }, {});
+      this.updateLayerLegend(legendSettings);
+    }
+  }, {
+    key: "hasHoveredObject",
+    value: function hasHoveredObject(objectInfo) {
+      return this.isLayerHovered(objectInfo) && objectInfo.object ? objectInfo.object : null;
+    }
+  }, {
+    key: "isLayerHovered",
+    value: function isLayerHovered(objectInfo) {
+      var _objectInfo$layer, _objectInfo$layer$pro;
+      return (objectInfo === null || objectInfo === void 0 ? void 0 : objectInfo.picked) && (objectInfo === null || objectInfo === void 0 ? void 0 : (_objectInfo$layer = objectInfo.layer) === null || _objectInfo$layer === void 0 ? void 0 : (_objectInfo$layer$pro = _objectInfo$layer.props) === null || _objectInfo$layer$pro === void 0 ? void 0 : _objectInfo$layer$pro.id) === this.id;
+    }
+  }, {
+    key: "getRadiusScaleByZoom",
+    value: function getRadiusScaleByZoom(mapState, fixedRadius) {
+      var radiusChannel = Object.values(this.visualChannels).find(function (vc) {
+        return vc.property === 'radius';
+      });
+      if (!radiusChannel) {
+        return 1;
       }
-      return legends;
-    }, {});
-    this.updateLayerLegend(legendSettings);
-  }
-  hasHoveredObject(objectInfo) {
-    return this.isLayerHovered(objectInfo) && objectInfo.object ? objectInfo.object : null;
-  }
-  isLayerHovered(objectInfo) {
-    var _objectInfo$layer, _objectInfo$layer$pro;
-    return (objectInfo === null || objectInfo === void 0 ? void 0 : objectInfo.picked) && (objectInfo === null || objectInfo === void 0 ? void 0 : (_objectInfo$layer = objectInfo.layer) === null || _objectInfo$layer === void 0 ? void 0 : (_objectInfo$layer$pro = _objectInfo$layer.props) === null || _objectInfo$layer$pro === void 0 ? void 0 : _objectInfo$layer$pro.id) === this.id;
-  }
-  getRadiusScaleByZoom(mapState, fixedRadius) {
-    const radiusChannel = Object.values(this.visualChannels).find(vc => vc.property === 'radius');
-    if (!radiusChannel) {
-      return 1;
-    }
-    const field = radiusChannel.field;
-    const {
-      radius
-    } = this.config.visConfig;
+      var field = radiusChannel.field;
+      var radius = this.config.visConfig.radius;
 
-    // @ts-ignore
-    return (this.config[field] ? 1 : radius) * this.getZoomFactor(mapState);
-  }
-  getRadiusScale() {
-    const radiusChannel = Object.values(this.visualChannels).find(vc => vc.property === 'radius');
-    if (!radiusChannel || this.config[radiusChannel.field]) {
-      return 1;
+      // @ts-ignore
+      return (this.config[field] ? 1 : radius) * this.getZoomFactor(mapState);
     }
-    return this.config.visConfig.radius;
-  }
-  getMaxMarkerSize() {
-    const {
-      radiusField,
-      sizeField,
-      visConfig
-    } = this.config;
-    const {
-      radiusRange,
-      radius
-    } = visConfig;
-    const field = radiusField || sizeField;
-    return Math.ceil(field && radiusRange ? radiusRange[1] : radius);
-  }
-  shouldCalculateLayerData(props) {
-    return props.some(p => !this.noneLayerDataAffectingProps.includes(p));
-  }
-  getBrushingExtensionProps(interactionConfig, brushingTarget) {
-    const {
-      brush
-    } = interactionConfig;
-    return {
-      // brushing
-      autoHighlight: !brush.enabled,
-      brushingRadius: brush.config.size * 1000,
-      brushingTarget: brushingTarget || 'source',
-      brushingEnabled: brush.enabled
-    };
-  }
-  getDefaultDeckLayerProps(_ref8) {
-    let {
-      idx,
-      gpuFilter,
-      mapState,
-      visible,
-      maskPolygon
-    } = _ref8;
-    const maskExtensionProps = (0, _layerUtils.getMaskExtensionProps)(maskPolygon);
-    return {
-      ...maskExtensionProps,
-      id: this.id,
-      idx,
-      coordinateSystem: _core.COORDINATE_SYSTEM.LNGLAT,
-      pickable: this.hasInteractivity,
-      wrapLongitude: true,
-      parameters: {
-        depthTest: Boolean(mapState.dragRotate || this.config.visConfig.enable3d)
-      },
-      hidden: this.config.hidden,
-      visibilityByZoom: this.config.visibilityByZoom,
-      // visconfig
-      opacity: this.config.visConfig.opacity,
-      highlightColor: this.config.highlightColor,
-      // data filtering
-      extensions: [dataFilterExtension, ...maskExtensionProps.extensions],
-      filterRange: gpuFilter ? gpuFilter.filterRange : undefined,
-      // layer should be visible and if splitMap, shown in to one of panel
-      visible: this.config.isVisible && visible
-    };
-  }
-  getDefaultHoverLayerProps() {
-    return {
-      id: `${this.id}-hovered`,
-      pickable: false,
-      wrapLongitude: true,
-      coordinateSystem: _core.COORDINATE_SYSTEM.LNGLAT
-    };
-  }
-  renderTextLabelLayer(_ref9, renderOpts) {
-    let {
-      getPosition,
-      getRadius,
-      radiusScale,
-      updateTriggers,
-      sharedProps
-    } = _ref9;
-    const {
-      data
-    } = renderOpts;
-    const {
-      textLabel,
-      visibilityByZoom
-    } = this.config;
-    const extensions = [...sharedProps.extensions, collisionFilterExtension];
-    if (!data || !data.textLabels || !data.textLabels[0] || !data.textLabels[0].getText) {
-      return [];
+  }, {
+    key: "getRadiusScale",
+    value: function getRadiusScale() {
+      var radiusChannel = Object.values(this.visualChannels).find(function (vc) {
+        return vc.property === 'radius';
+      });
+      if (!radiusChannel || this.config[radiusChannel.field]) {
+        return 1;
+      }
+      return this.config.visConfig.radius;
     }
-    const [mainLabel, secondaryLabel] = textLabel;
-    const {
-      alignment,
-      anchor,
-      color: getColor,
-      field: mainField,
-      outlineColor,
-      size: sizeScale
-    } = mainLabel;
-    const {
-      color: getSecondaryColor,
-      field: secondaryField,
-      outlineColor: secondaryOutlineColor,
-      size: secondarySizeScale
-    } = secondaryLabel || {};
-    return [new _carto.PointLabelLayer({
-      ...sharedProps,
-      // Recreate layer when labels change otherwise rendering breaks
-      // TODO could be more efficient with updateTriggers?
-      id: `${this.id}-${mainField === null || mainField === void 0 ? void 0 : mainField.name}-${secondaryField === null || secondaryField === void 0 ? void 0 : secondaryField.name}-label`,
-      data: data.data,
-      visibilityByZoom,
-      extensions,
-      characterSet: 'auto',
-      collisionEnabled: true,
-      collisionGroup: `${this.id}-labels`,
-      getText: data.textLabels[0].getText,
-      getColor,
-      sizeScale,
-      outlineColor,
-      ...(secondaryField && {
-        getSecondaryText: data.textLabels[1].getText,
-        getSecondaryColor,
-        secondarySizeScale,
-        secondaryOutlineColor
-      }),
-      // Position
-      getPosition,
-      getRadius,
-      radiusScale,
-      getTextAnchor: anchor,
-      getAlignmentBaseline: alignment,
-      // Style
-      fontFamily: 'Inter, sans',
-      fontSettings: {
-        sdf: true
-      },
-      fontWeight: 500,
-      outlineWidth: 4,
-      parameters: {
-        // text will always show on top of all layers
-        depthTest: false
-      },
-      getFilterValue: data.getFilterValue,
-      updateTriggers: {
-        ...updateTriggers,
-        getText: mainField === null || mainField === void 0 ? void 0 : mainField.name,
-        getColor: mainField === null || mainField === void 0 ? void 0 : mainField.color,
-        getTextAnchor: mainLabel.anchor,
-        getAlignmentBaseline: mainLabel.alignment,
-        getSecondaryText: secondaryField === null || secondaryField === void 0 ? void 0 : secondaryField.name
+  }, {
+    key: "getMaxMarkerSize",
+    value: function getMaxMarkerSize() {
+      var _ref12 = this.config,
+        radiusField = _ref12.radiusField,
+        sizeField = _ref12.sizeField,
+        visConfig = _ref12.visConfig;
+      var radiusRange = visConfig.radiusRange,
+        radius = visConfig.radius;
+      var field = radiusField || sizeField;
+      return Math.ceil(field && radiusRange ? radiusRange[1] : radius);
+    }
+  }, {
+    key: "shouldCalculateLayerData",
+    value: function shouldCalculateLayerData(props) {
+      var _this10 = this;
+      return props.some(function (p) {
+        return !_this10.noneLayerDataAffectingProps.includes(p);
+      });
+    }
+  }, {
+    key: "getBrushingExtensionProps",
+    value: function getBrushingExtensionProps(interactionConfig, brushingTarget) {
+      var brush = interactionConfig.brush;
+      return {
+        // brushing
+        autoHighlight: !brush.enabled,
+        brushingRadius: brush.config.size * 1000,
+        brushingTarget: brushingTarget || 'source',
+        brushingEnabled: brush.enabled
+      };
+    }
+  }, {
+    key: "getDefaultDeckLayerProps",
+    value: function getDefaultDeckLayerProps(_ref13) {
+      var idx = _ref13.idx,
+        gpuFilter = _ref13.gpuFilter,
+        mapState = _ref13.mapState,
+        visible = _ref13.visible,
+        maskPolygon = _ref13.maskPolygon;
+      var maskExtensionProps = (0, _layerUtils.getMaskExtensionProps)(maskPolygon);
+      return _objectSpread(_objectSpread({}, maskExtensionProps), {}, {
+        id: this.id,
+        idx: idx,
+        coordinateSystem: _core.COORDINATE_SYSTEM.LNGLAT,
+        pickable: this.hasInteractivity,
+        wrapLongitude: true,
+        parameters: {
+          depthTest: Boolean(mapState.dragRotate || this.config.visConfig.enable3d)
+        },
+        hidden: this.config.hidden,
+        visibilityByZoom: this.config.visibilityByZoom,
+        // visconfig
+        opacity: this.config.visConfig.opacity,
+        highlightColor: this.config.highlightColor,
+        // data filtering
+        extensions: [dataFilterExtension].concat((0, _toConsumableArray2["default"])(maskExtensionProps.extensions)),
+        filterRange: gpuFilter ? gpuFilter.filterRange : undefined,
+        // layer should be visible and if splitMap, shown in to one of panel
+        visible: this.config.isVisible && visible
+      });
+    }
+  }, {
+    key: "getDefaultHoverLayerProps",
+    value: function getDefaultHoverLayerProps() {
+      return {
+        id: "".concat(this.id, "-hovered"),
+        pickable: false,
+        wrapLongitude: true,
+        coordinateSystem: _core.COORDINATE_SYSTEM.LNGLAT
+      };
+    }
+  }, {
+    key: "renderTextLabelLayer",
+    value: function renderTextLabelLayer(_ref14, renderOpts) {
+      var getPosition = _ref14.getPosition,
+        getRadius = _ref14.getRadius,
+        radiusScale = _ref14.radiusScale,
+        updateTriggers = _ref14.updateTriggers,
+        sharedProps = _ref14.sharedProps;
+      var data = renderOpts.data;
+      var _ref15 = this.config,
+        textLabel = _ref15.textLabel,
+        visibilityByZoom = _ref15.visibilityByZoom;
+      var extensions = [].concat((0, _toConsumableArray2["default"])(sharedProps.extensions), [collisionFilterExtension]);
+      if (!data || !data.textLabels || !data.textLabels[0] || !data.textLabels[0].getText) {
+        return [];
       }
-    })];
-  }
+      var _textLabel = (0, _slicedToArray2["default"])(textLabel, 2),
+        mainLabel = _textLabel[0],
+        secondaryLabel = _textLabel[1];
+      var alignment = mainLabel.alignment,
+        anchor = mainLabel.anchor,
+        getColor = mainLabel.color,
+        mainField = mainLabel.field,
+        outlineColor = mainLabel.outlineColor,
+        sizeScale = mainLabel.size;
+      var _ref16 = secondaryLabel || {},
+        getSecondaryColor = _ref16.color,
+        secondaryField = _ref16.field,
+        secondaryOutlineColor = _ref16.outlineColor,
+        secondarySizeScale = _ref16.size;
+      return [new _carto.PointLabelLayer(_objectSpread(_objectSpread(_objectSpread({}, sharedProps), {}, {
+        // Recreate layer when labels change otherwise rendering breaks
+        // TODO could be more efficient with updateTriggers?
+        id: "".concat(this.id, "-").concat(mainField === null || mainField === void 0 ? void 0 : mainField.name, "-").concat(secondaryField === null || secondaryField === void 0 ? void 0 : secondaryField.name, "-label"),
+        data: data.data,
+        visibilityByZoom: visibilityByZoom,
+        extensions: extensions,
+        characterSet: 'auto',
+        collisionEnabled: true,
+        collisionGroup: "".concat(this.id, "-labels"),
+        getText: data.textLabels[0].getText,
+        getColor: getColor,
+        sizeScale: sizeScale,
+        outlineColor: outlineColor
+      }, secondaryField && {
+        getSecondaryText: data.textLabels[1].getText,
+        getSecondaryColor: getSecondaryColor,
+        secondarySizeScale: secondarySizeScale,
+        secondaryOutlineColor: secondaryOutlineColor
+      }), {}, {
+        // Position
+        getPosition: getPosition,
+        getRadius: getRadius,
+        radiusScale: radiusScale,
+        getTextAnchor: anchor,
+        getAlignmentBaseline: alignment,
+        // Style
+        fontFamily: 'Inter, sans',
+        fontSettings: {
+          sdf: true
+        },
+        fontWeight: 500,
+        outlineWidth: 4,
+        parameters: {
+          // text will always show on top of all layers
+          depthTest: false
+        },
+        getFilterValue: data.getFilterValue,
+        updateTriggers: _objectSpread(_objectSpread({}, updateTriggers), {}, {
+          getText: mainField === null || mainField === void 0 ? void 0 : mainField.name,
+          getColor: mainField === null || mainField === void 0 ? void 0 : mainField.color,
+          getTextAnchor: mainLabel.anchor,
+          getAlignmentBaseline: mainLabel.alignment,
+          getSecondaryText: secondaryField === null || secondaryField === void 0 ? void 0 : secondaryField.name
+        })
+      }))];
+    }
 
-  /**
-   * Create deck.gl `IconLayer` "autoPack" mode accessor for custom markers.
-   *
-   * @param {*} iconUrlAccessor deck.gl accessor (or value) that resolves to URL of icon for given row
-   * @returns deck.gl accessor that returns UnpackedIcon ready to consume by IconLayer
-   */
-  getCustomMarkerIconAccessor(iconUrlAccessor) {
-    let mask = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
-    const maxIconSize = this.getMaxMarkerSize();
-    return d => {
-      const wantedUrl = typeof iconUrlAccessor === 'function' ? iconUrlAccessor(d) : iconUrlAccessor;
-      const iconOk = Boolean(wantedUrl);
-      mask = iconOk ? mask : true;
-      const url = iconOk ? wantedUrl : FALLBACK_ICON;
+    /**
+     * Create deck.gl `IconLayer` "autoPack" mode accessor for custom markers.
+     *
+     * @param {*} iconUrlAccessor deck.gl accessor (or value) that resolves to URL of icon for given row
+     * @returns deck.gl accessor that returns UnpackedIcon ready to consume by IconLayer
+     */
+  }, {
+    key: "getCustomMarkerIconAccessor",
+    value: function getCustomMarkerIconAccessor(iconUrlAccessor) {
+      var mask = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+      var maxIconSize = this.getMaxMarkerSize();
+      return function (d) {
+        var wantedUrl = typeof iconUrlAccessor === 'function' ? iconUrlAccessor(d) : iconUrlAccessor;
+        var iconOk = Boolean(wantedUrl);
+        mask = iconOk ? mask : true;
+        var url = iconOk ? wantedUrl : FALLBACK_ICON;
+        return {
+          id: "".concat(url, "@@").concat(maxIconSize, "@").concat(mask ? 'm' : 'c'),
+          url: url,
+          width: maxIconSize,
+          height: maxIconSize,
+          mask: mask
+        };
+      };
+    }
+  }, {
+    key: "calculateDataAttribute",
+    value: function calculateDataAttribute(keplerTable, getPosition) {
+      // implemented in subclasses
+      return [];
+    }
+  }, {
+    key: "updateLayerMeta",
+    value: function updateLayerMeta(dataContainer, getPosition) {
+      // implemented in subclasses
+    }
+  }, {
+    key: "getPositionAccessor",
+    value: function getPositionAccessor(dataContainer) {
+      // implemented in subclasses
+      return function () {
+        return null;
+      };
+    }
+  }, {
+    key: "getHexColumn",
+    value: function getHexColumn(range) {
+      var _Object$values2, _Object$values2$find;
+      var field = (_Object$values2 = Object.values(this.visualChannels)) === null || _Object$values2 === void 0 ? void 0 : (_Object$values2$find = _Object$values2.find(function (value) {
+        return value.range === range;
+      })) === null || _Object$values2$find === void 0 ? void 0 : _Object$values2$find.field;
+      if (field) {
+        var _this$config$field2;
+        return (_this$config$field2 = this.config[field]) === null || _this$config$field2 === void 0 ? void 0 : _this$config$field2.colorColumn;
+      }
+    }
+  }, {
+    key: "isColoredByColorColumn",
+    value: function isColoredByColorColumn(range) {
+      var _this$config$visConfi;
+      return (_this$config$visConfi = this.config.visConfig[range]) === null || _this$config$visConfi === void 0 ? void 0 : _this$config$visConfi.hexColor;
+    }
+  }], [{
+    key: "findDefaultLayerProps",
+    value: function findDefaultLayerProps(dataset, foundLayers) {
       return {
-        id: `${url}@@${maxIconSize}@${mask ? 'm' : 'c'}`,
-        url,
-        width: maxIconSize,
-        height: maxIconSize,
-        mask
+        props: [],
+        foundLayers: foundLayers
       };
-    };
-  }
-  calculateDataAttribute(keplerTable, getPosition) {
-    // implemented in subclasses
-    return [];
-  }
-  updateLayerMeta(dataContainer, getPosition) {
-    // implemented in subclasses
-  }
-  getPositionAccessor(dataContainer) {
-    // implemented in subclasses
-    return () => null;
-  }
-  getHexColumn(range) {
-    var _Object$values, _Object$values$find;
-    const field = (_Object$values = Object.values(this.visualChannels)) === null || _Object$values === void 0 ? void 0 : (_Object$values$find = _Object$values.find(value => value.range === range)) === null || _Object$values$find === void 0 ? void 0 : _Object$values$find.field;
-    if (field) {
-      var _this$config$field2;
-      return (_this$config$field2 = this.config[field]) === null || _this$config$field2 === void 0 ? void 0 : _this$config$field2.colorColumn;
     }
-  }
-  isColoredByColorColumn(range) {
-    var _this$config$visConfi2;
-    return (_this$config$visConfi2 = this.config.visConfig[range]) === null || _this$config$visConfi2 === void 0 ? void 0 : _this$config$visConfi2.hexColor;
-  }
-}
-var _default = exports.default = Layer;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_window","require","_keymirror","_interopRequireDefault","_extensions","_core","_carto","_defaultLayerIcon","_layerUpdate","_d3Color","_defaultSettings","_colorRanges","_customColorRanges","_layerFactory","_utils","_dataUtils","_dataContainerUtils","_colorUtils","_layerUtils","_d3Scale","LAYER_ID_LENGTH","exports","FALLBACK_ICON","MAX_SAMPLE_SIZE","defaultDomain","dataFilterExtension","DataFilterExtension","filterSize","MAX_GPU_FILTERS","collisionFilterExtension","CollisionFilterExtension","defaultDataAccessor","dc","d","defaultGetFieldValue","field","valueAccessor","scaleIdentity","v","OVERLAY_TYPE","keymirror","deckgl","mapboxgl","layerColors","Object","values","DataVizColors","map","hexToRgb","generateColor","index","length","colorMaker","Layer","constructor","props","arguments","undefined","_defineProperty2","default","id","generateHashId","meta","legendSettings","visConfigSettings","_interactivitySettings","config","getDefaultLayerConfig","columns","getLayerColumns","layerIcon","DefaultLayerIcon","overlayType","type","name","isAggregated","requiredLayerColumns","optionalColumns","noneLayerDataAffectingProps","visualChannels","color","property","scale","domain","range","key","channelScaleType","CHANNEL_SCALES","nullValue","NO_VALUE_COLOR","defaultValue","size","columnValidators","columnPairs","defaultPointColumnPairs","lat","pair","fieldPairKey","lng","defaultLinkColumnPairs","lat0","lng0","lat1","lng1","layerInfoModal","interactivitySettings","hasTooltip","_this$interactivitySe","_this$interactivitySe2","_this$interactivitySe3","_this$interactivitySe4","Boolean","hover","fields","click","hasInteractivity","_this$interactivitySe5","enabled","findDefaultLayerProps","dataset","foundLayers","findDefaultColumnField","defaultFields","allFields","requiredColumns","keys","reduce","prev","requiredFields","filter","f","includes","value","fieldIdx","every","getAllPossibleColumnParis","allKeys","pointers","k","i","countPerKey","pairs","incrementPointers","newPair","cuur","push","pts","counts","c","_visibilityByZoom","_visibilityByZoom2","dataId","visibilityByZoom","min","ZOOM_LEVEL_LIMITS","max","label","DEFAULT_LAYER_LABEL","next","isVisible","isConfigActive","highlightColor","DEFAULT_HIGHLIGHT_COLOR","hidden","colorField","colorDomain","colorScale","SCALE_TYPES","quantile","sizeDomain","sizeScale","linear","sizeField","radiusField","visConfig","textLabel","DEFAULT_TEXT_LABEL","colorUI","DEFAULT_COLOR_UI","colorRange","animation","getVisualChannelDescription","channel","measure","rangeSettings","fieldSettings","displayName","defaultMeasure","assignColumn","update","assignColumnPairs","_this$columnPairs","_this$columnPairs2","_this$columnPairs3","partnerKey","partnerFieldPairKey","getZoomFactor","_ref","zoom","zoomOffset","Math","pow","getElevationZoomFactor","_ref2","enableElevationZoomFactor","formatLayerData","datasets","oldLayerData","renderLayer","getHoverData","object","dataContainer","row","assignConfigToLayer","configToCopy","shallowCopy","concat","notToCopy","forEach","group","currentConfig","copied","copyLayerConfig","updateLayerConfig","validateVisualChannel","isPlainObject","notNullorUndefined","registerVisConfig","layerVisConfigs","item","configItem","LAYER_VIS_CONFIGS","p","hasOwnProperty","required","accu","validator","optional","newConfig","updateLayerVisConfig","newVisConfig","updateLayerColorUI","prop","previous","colorUIProp","entries","_ref3","isColorRange","colors","hexColor","updateColorUIByColorRange","updateColorRangeByColorUI","updateCustomPalette","colorRangeConfig","custom","customPalette","_visConfig$prop$color","showDropdown","steps","reversed","hexColumn","getHexColumn","isHexColumn","isColoredByColorColumn","shouldUpdate","some","getColorGroupByName","sameGroup","COLOR_RANGES","cr","find","reverseColorRange","colorMap","updateColorMap","_this$config$field","updateCategoryColorMap","updateNumericColorMap","assignedCategories","newColorMap","slice","cMap","unassignedColors","category","colorMapValues","maxValue","prevValue","step","hasAllColumns","hasLayerData","layerData","data","isValidToSave","shouldRenderLayer","getColorScale","_","r","g","b","rgb","isNaN","UNKNOWN_COLOR","Array","isArray","Map","_ref4","set","SCALE_FUNC","unknown","getVisChannelScale","getCustomMarkersScale","fallbackIcon","unknownValue","mapping","othersMarker","markerUrl","markerMap","scaleOrdinal","from","getAttributeAccessors","_ref5","dataAccessor","attributeAccessors","fixed","accessor","getAttributeValue","aggregation","shouldGetScale","identity","isFixed","fieldConfig","aggregationValue","scaleFunction","customMarker","customMarkersUrl","getEncodedChannelValue","Console","warn","ordinal","domainIsInfinite","Infinity","scaleFactory","result","getPointsBounds","getPosition","sampleData","numRows","getSampleData","points","mapIndex","latBounds","getLatLngBounds","lngBounds","getChangedTriggers","dataUpdateTriggers","triggerChanged","diffUpdateTriggers","_oldDataUpdateTriggers","_ref6","getValue","channelConfig","channelField","colorColumnValue","columnField","colorColumn","colorColumnIdx","valueAt","attributeValue","ALL_FIELD_TYPES","timestamp","Date","updateMeta","updateLayerLegend","settings","getDataUpdateTriggers","_ref7","filteredIndex","allData","getData","datasetId","getMeta","tl","updateData","getDataset","updateVisualChannelFields","updateHexColorDomain","getPositionAccessor","updateLayerMeta","calculateDataAttribute","_this$config$visConfi","oldField","isUsingHexColorCode","newDataSetField","fd","updateLayerDomain","newFilter","table","scaleType","updatedDomain","calculateLayerDomain","validateFieldType","validateScale","visualChannel","supportedFieldTypes","channelSupportedFieldTypes","CHANNEL_SCALE_SUPPORTED_FIELDS","scaleOptions","getScaleOptions","FIELD_OPTS","updateLayerVisualChannel","getVisualChannelUpdateTriggers","updateTriggers","dataSetField","getColumnLayerDomain","checkColorOrFallback","calculateHexColumnLegend","legends","legend","calculateLegend","hasHoveredObject","objectInfo","isLayerHovered","_objectInfo$layer","_objectInfo$layer$pro","picked","layer","getRadiusScaleByZoom","mapState","fixedRadius","radiusChannel","vc","radius","getRadiusScale","getMaxMarkerSize","radiusRange","ceil","shouldCalculateLayerData","getBrushingExtensionProps","interactionConfig","brushingTarget","brush","autoHighlight","brushingRadius","brushingEnabled","getDefaultDeckLayerProps","_ref8","idx","gpuFilter","visible","maskPolygon","maskExtensionProps","getMaskExtensionProps","coordinateSystem","COORDINATE_SYSTEM","LNGLAT","pickable","wrapLongitude","parameters","depthTest","dragRotate","enable3d","opacity","extensions","filterRange","getDefaultHoverLayerProps","renderTextLabelLayer","_ref9","renderOpts","getRadius","radiusScale","sharedProps","textLabels","getText","mainLabel","secondaryLabel","alignment","anchor","getColor","mainField","outlineColor","getSecondaryColor","secondaryField","secondaryOutlineColor","secondarySizeScale","PointLabelLayer","characterSet","collisionEnabled","collisionGroup","getSecondaryText","getTextAnchor","getAlignmentBaseline","fontFamily","fontSettings","sdf","fontWeight","outlineWidth","getFilterValue","getCustomMarkerIconAccessor","iconUrlAccessor","mask","maxIconSize","wantedUrl","iconOk","url","width","height","keplerTable","_Object$values","_Object$values$find","_this$config$field2","_this$config$visConfi2","_default"],"sources":["../../src/layers/base-layer.ts"],"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 {console as Console} from 'global/window';\nimport keymirror from 'keymirror';\nimport {CollisionFilterExtension, DataFilterExtension} from '@deck.gl/extensions';\nimport {COORDINATE_SYSTEM, Layer as DeckLayer} from '@deck.gl/core';\nimport {PointLabelLayer} from '@deck.gl/carto';\nimport DefaultLayerIcon from './default-layer-icon';\nimport {diffUpdateTriggers} from './layer-update';\nimport {rgb} from 'd3-color';\n\nimport {\n  ALL_FIELD_TYPES,\n  NO_VALUE_COLOR,\n  SCALE_TYPES,\n  CHANNEL_SCALES,\n  FIELD_OPTS,\n  SCALE_FUNC,\n  CHANNEL_SCALE_SUPPORTED_FIELDS,\n  MAX_GPU_FILTERS,\n  UNKNOWN_COLOR,\n  ZOOM_LEVEL_LIMITS\n} from 'constants/default-settings';\nimport {ColorRange, COLOR_RANGES, hexColor} from 'constants/color-ranges';\nimport {DataVizColors} from 'constants/custom-color-ranges';\nimport {\n  LAYER_VIS_CONFIGS,\n  DEFAULT_TEXT_LABEL,\n  DEFAULT_COLOR_UI,\n  DEFAULT_HIGHLIGHT_COLOR,\n  DEFAULT_LAYER_LABEL,\n  LayerVisConfig,\n  LayerVisConfigSettings\n} from './layer-factory';\n\nimport {generateHashId, isPlainObject} from 'utils/utils';\n\nimport {getLatLngBounds, notNullorUndefined} from 'utils/data-utils';\nimport {getSampleData} from 'utils/table-utils/data-container-utils';\n\nimport {\n  hexToRgb,\n  getColorGroupByName,\n  reverseColorRange,\n  checkColorOrFallback\n} from 'utils/color-utils';\nimport {getMaskExtensionProps} from 'utils/layer-utils';\nimport {scaleOrdinal} from 'd3-scale';\n\nimport {RGBColor, RGBAColor, MapState, Filter, Datasets, ValueOf, NestedPartial} from 'reducers';\nimport {LayerTextLabel, ColorUI} from './layer-factory';\nimport {KeplerTable} from '../utils';\nimport {DataContainerInterface} from 'utils/table-utils/data-container-interface';\nimport {Field, GpuFilter} from 'utils/table-utils/kepler-table';\nimport React from 'react';\n\nexport type LayerColumn = {value: string | null; fieldIdx: number; optional?: boolean};\n\nexport type LayerColumns = {\n  [key: string]: LayerColumn;\n};\nexport type VisualChannelDomain = number[] | string[];\nexport type VisualChannelField = Field | null;\nexport type VisualChannelScale = keyof typeof SCALE_TYPES;\n\nexport type LayerBaseConfig = {\n  dataId: string | null;\n  label: string;\n  color: RGBColor;\n\n  columns: LayerColumns;\n  isVisible: boolean;\n  isConfigActive: boolean;\n  highlightColor: RGBColor | RGBAColor;\n  hidden: boolean;\n\n  visConfig: LayerVisConfig;\n  textLabel: LayerTextLabel[];\n\n  colorUI: {\n    color: ColorUI;\n    colorRange: ColorUI;\n  };\n  animation: {\n    enabled: boolean;\n    domain?: null;\n  };\n};\n\nexport type LayerColorConfig = {\n  colorField: VisualChannelField;\n  colorDomain: VisualChannelDomain;\n  colorScale: VisualChannelScale;\n};\nexport type LayerSizeConfig = {\n  // color by size, domain is set by filters, field, scale type\n  sizeDomain: VisualChannelDomain;\n  sizeScale: VisualChannelScale;\n  sizeField: VisualChannelField;\n};\nexport type LayerHeightConfig = {\n  heightField: VisualChannelField;\n  heightDomain: VisualChannelDomain;\n  heightScale: VisualChannelScale;\n};\nexport type LayerStrokeColorConfig = {\n  strokeColorField: VisualChannelField;\n  strokeColorDomain: VisualChannelDomain;\n  strokeColorScale: VisualChannelScale;\n};\nexport type LayerCoverageConfig = {\n  coverageField: VisualChannelField;\n  coverageDomain: VisualChannelDomain;\n  coverageScale: VisualChannelScale;\n};\nexport type LayerRadiusConfig = {\n  radiusField: VisualChannelField;\n  radiusDomain: VisualChannelDomain;\n  radiusScale: VisualChannelScale;\n};\nexport type LayerWeightConfig = {\n  weightField: VisualChannelField;\n};\n\nexport type VisualChannels = {[key: string]: VisualChannel};\n\nexport type VisualChannelAggregation = 'colorAggregation' | 'sizeAggregation';\n\nexport type VisualChannel = {\n  property: string;\n  field: string;\n  scale: string;\n  domain: string;\n  range: string;\n  key: string;\n  channelScaleType: string;\n  nullValue?: any;\n  defaultMeasure?: any;\n  accessor?: string;\n  condition?: (config: any) => boolean;\n  getAttributeValue?: (config: any) => (d: any) => any;\n\n  // TODO: define defaultValue\n  defaultValue?: any;\n  // TODO: define fixed\n  fixed?: any;\n\n  supportedFieldTypes?: Array<keyof typeof ALL_FIELD_TYPES>;\n\n  aggregation?: VisualChannelAggregation;\n};\n\nexport type VisualChannelDescription = {\n  label: string;\n  measure: string;\n};\n\nexport type ColumnPairs = {[key: string]: {pair: string; fieldPairKey: string}};\n\ntype ColumnValidator = (column: LayerColumn, columns: LayerColumns, allFields: Field[]) => boolean;\n\nexport type UpdateTriggers = {\n  [key: string]: UpdateTrigger;\n};\nexport type UpdateTrigger = {\n  [key: string]: {};\n};\nexport type LayerBounds = [number, number, number, number];\nexport type FindDefaultLayerPropsReturnValue = {props: any[]; foundLayers?: any[]};\n/**\n * Approx. number of points to sample in a large data set\n */\nexport const LAYER_ID_LENGTH = 6;\n\n// Note, this is is SVG of solid circle encoded as data-uri\nconst FALLBACK_ICON =\n  'data:image/svg+xml;charset=utf-8;base64,PHN2ZyB2aWV3Qm94PSIwIDAgMTAwIDEwMCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4NCiAgPGNpcmNsZSBjeD0iNTAiIGN5PSI1MCIgcj0iNTAiLz4NCjwvc3ZnPg==';\n\nconst MAX_SAMPLE_SIZE = 5000;\nconst defaultDomain: [number, number] = [0, 1];\nconst dataFilterExtension = new DataFilterExtension({filterSize: MAX_GPU_FILTERS});\nconst collisionFilterExtension = new CollisionFilterExtension();\n\nconst defaultDataAccessor = dc => d => d;\nconst defaultGetFieldValue = (field, d) => field.valueAccessor(d);\nconst scaleIdentity = v => v;\n\nexport const OVERLAY_TYPE = keymirror({\n  deckgl: null,\n  mapboxgl: null\n});\n\nexport const layerColors = Object.values(DataVizColors).map(hexToRgb);\nfunction* generateColor(): Generator<RGBColor> {\n  let index = 0;\n  while (index < layerColors.length + 1) {\n    if (index === layerColors.length) {\n      index = 0;\n    }\n    yield layerColors[index++];\n  }\n}\n\nexport const colorMaker = generateColor();\n\nclass Layer {\n  id: string;\n  meta: {};\n  visConfigSettings: {\n    [key: string]: ValueOf<LayerVisConfigSettings>;\n  };\n  config: LayerBaseConfig;\n  // TODO: define _oldDataUpdateTriggers\n  _oldDataUpdateTriggers: any;\n\n  legendSettings: Record<string, unknown>;\n  _interactivitySettings: Record<string, unknown>;\n\n  constructor(\n    props: {\n      id?: string;\n    } & Partial<LayerBaseConfig> = {}\n  ) {\n    this.id = props.id || generateHashId(LAYER_ID_LENGTH);\n    // meta\n    this.meta = {};\n\n    // legendSettings\n    this.legendSettings = {};\n\n    // visConfigSettings\n    this.visConfigSettings = {};\n\n    // interactivitySettings\n    this._interactivitySettings = {};\n\n    this.config = this.getDefaultLayerConfig({\n      columns: this.getLayerColumns(),\n      ...props\n    });\n  }\n\n  get layerIcon(): React.ElementType {\n    return DefaultLayerIcon;\n  }\n\n  get overlayType(): keyof typeof OVERLAY_TYPE {\n    return OVERLAY_TYPE.deckgl;\n  }\n\n  get type(): string | null {\n    return null;\n  }\n\n  get name() {\n    return this.type;\n  }\n\n  get isAggregated() {\n    return false;\n  }\n\n  get requiredLayerColumns(): string[] {\n    return [];\n  }\n\n  get optionalColumns(): string[] {\n    return [];\n  }\n\n  get noneLayerDataAffectingProps() {\n    return ['label', 'opacity', 'thickness', 'isVisible', 'hidden'];\n  }\n\n  get visualChannels(): VisualChannels {\n    return {\n      color: {\n        property: 'color',\n        field: 'colorField',\n        scale: 'colorScale',\n        domain: 'colorDomain',\n        range: 'colorRange',\n        key: 'color',\n        channelScaleType: CHANNEL_SCALES.color,\n        nullValue: NO_VALUE_COLOR,\n        defaultValue: config => config.color\n      },\n      size: {\n        property: 'size',\n        field: 'sizeField',\n        scale: 'sizeScale',\n        domain: 'sizeDomain',\n        range: 'sizeRange',\n        key: 'size',\n        channelScaleType: CHANNEL_SCALES.size,\n        nullValue: 0,\n        defaultValue: 1\n      }\n    };\n  }\n\n  get columnValidators(): {[key: string]: ColumnValidator} {\n    return {};\n  }\n  /*\n   * Column pairs maps layer column to a specific field pairs,\n   * By default, it is set to null\n   */\n  get columnPairs(): ColumnPairs | null {\n    return null;\n  }\n\n  /*\n   * Default point column pairs, can be used for point based layers: point, icon etc.\n   */\n  get defaultPointColumnPairs(): ColumnPairs {\n    return {\n      lat: {pair: 'lng', fieldPairKey: 'lat'},\n      lng: {pair: 'lat', fieldPairKey: 'lng'}\n    };\n  }\n\n  /*\n   * Default link column pairs, can be used for link based layers: arc, line etc\n   */\n  get defaultLinkColumnPairs(): ColumnPairs {\n    return {\n      lat0: {pair: 'lng0', fieldPairKey: 'lat'},\n      lng0: {pair: 'lat0', fieldPairKey: 'lng'},\n      lat1: {pair: 'lng1', fieldPairKey: 'lat'},\n      lng1: {pair: 'lat1', fieldPairKey: 'lng'}\n    };\n  }\n\n  /**\n   * Return a React component for to render layer instructions in a modal\n   * @returns {object} - an object\n   * @example\n   *  return {\n   *    id: 'iconInfo',\n   *    template: IconInfoModal,\n   *    modalProps: {\n   *      title: 'How to draw icons'\n   *   };\n   * }\n   */\n  get layerInfoModal(): any {\n    return null;\n  }\n\n  get interactivitySettings() {\n    return (this as any)._interactivitySettings;\n  }\n\n  set interactivitySettings(interactivitySettings) {\n    (this as any)._interactivitySettings = interactivitySettings;\n  }\n\n  get hasTooltip() {\n    return Boolean(\n      this.interactivitySettings?.hover?.fields.length ||\n        this.interactivitySettings?.click?.fields.length\n    );\n  }\n\n  get hasInteractivity() {\n    return Boolean(this.hasTooltip && this.interactivitySettings?.enabled);\n  }\n\n  /*\n   * Given a dataset, automatically find props to create layer based on it\n   * and return the props and previous found layers.\n   * By default, no layers will be found\n   */\n  static findDefaultLayerProps(\n    dataset: KeplerTable,\n    foundLayers?: any[]\n  ): FindDefaultLayerPropsReturnValue {\n    return {props: [], foundLayers};\n  }\n\n  /**\n   * Given a array of preset required column names\n   * found field that has the same name to set as layer column\n   *\n   * @param {object} defaultFields\n   * @param {object[]} allFields\n   * @returns {object[] | null} all possible required layer column pairs\n   */\n  static findDefaultColumnField(defaultFields, allFields) {\n    // find all matched fields for each required col\n    const requiredColumns = Object.keys(defaultFields).reduce((prev, key) => {\n      const requiredFields = allFields.filter(\n        f => f.name === defaultFields[key] || defaultFields[key].includes(f.name)\n      );\n\n      prev[key] = requiredFields.length\n        ? requiredFields.map(f => ({\n            value: f.name,\n            fieldIdx: f.fieldIdx\n          }))\n        : null;\n      return prev;\n    }, {});\n\n    if (!Object.values(requiredColumns).every(Boolean)) {\n      // if any field missing, return null\n      return null;\n    }\n\n    return this.getAllPossibleColumnParis(requiredColumns);\n  }\n\n  static getAllPossibleColumnParis(requiredColumns) {\n    // for multiple matched field for one required column, return multiple\n    // combinations, e. g. if column a has 2 matched, column b has 3 matched\n    // 6 possible column pairs will be returned\n    const allKeys = Object.keys(requiredColumns);\n    const pointers = allKeys.map((k, i) => (i === allKeys.length - 1 ? -1 : 0));\n    const countPerKey = allKeys.map(k => requiredColumns[k].length);\n    // TODO: Better typings\n    const pairs: any[] = [];\n\n    /* eslint-disable no-loop-func */\n    while (incrementPointers(pointers, countPerKey, pointers.length - 1)) {\n      const newPair = pointers.reduce((prev, cuur, i) => {\n        prev[allKeys[i]] = requiredColumns[allKeys[i]][cuur];\n        return prev;\n      }, {});\n\n      pairs.push(newPair);\n    }\n    /* eslint-enable no-loop-func */\n\n    // recursively increment pointers\n    function incrementPointers(pts, counts, index) {\n      if (index === 0 && pts[0] === counts[0] - 1) {\n        // nothing to increment\n        return false;\n      }\n\n      if (pts[index] + 1 < counts[index]) {\n        pts[index] = pts[index] + 1;\n        return true;\n      }\n\n      pts[index] = 0;\n      return incrementPointers(pts, counts, index - 1);\n    }\n\n    return pairs;\n  }\n\n  static hexToRgb(c) {\n    return hexToRgb(c);\n  }\n\n  getDefaultLayerConfig(\n    props: Partial<LayerBaseConfig> = {}\n  ): LayerBaseConfig & Partial<LayerColorConfig & LayerSizeConfig> {\n    return {\n      dataId: props.dataId || null,\n      ...{\n        visibilityByZoom: {\n          min: (props as any).visibilityByZoom?.min || ZOOM_LEVEL_LIMITS.min,\n          max: (props as any).visibilityByZoom?.max || ZOOM_LEVEL_LIMITS.max\n        }\n      }, // TODO: Clean up\n      label: props.label || DEFAULT_LAYER_LABEL,\n      color: props.color || colorMaker.next().value,\n      columns: props.columns || {},\n      isVisible: props.isVisible || false,\n      isConfigActive: props.isConfigActive || false,\n      highlightColor: props.highlightColor || DEFAULT_HIGHLIGHT_COLOR,\n      hidden: props.hidden || false,\n\n      // TODO: refactor this into separate visual Channel config\n      // color by field, domain is set by filters, field, scale type\n      colorField: null,\n      colorDomain: [0, 1],\n      colorScale: SCALE_TYPES.quantile,\n\n      // color by size, domain is set by filters, field, scale type\n      sizeDomain: [0, 1],\n      sizeScale: SCALE_TYPES.linear,\n      sizeField: null,\n      ...{radiusField: null}, // TODO: Clean up\n\n      visConfig: {},\n\n      textLabel: [DEFAULT_TEXT_LABEL],\n\n      colorUI: {\n        color: DEFAULT_COLOR_UI,\n        colorRange: DEFAULT_COLOR_UI\n      },\n      animation: {enabled: false}\n    };\n  }\n\n  /**\n   * Get the description of a visualChannel config\n   * @param key\n   * @returns\n   */\n  getVisualChannelDescription(key: string): VisualChannelDescription {\n    // e.g. label: Color, measure: Vehicle Type\n    const channel = this.visualChannels[key];\n    if (!channel) return {label: '', measure: ''};\n    const rangeSettings = this.visConfigSettings[channel.range];\n    const fieldSettings = this.config[channel.field];\n    const label = rangeSettings?.label;\n    return {\n      label: typeof label === 'function' ? label(this.config) : label,\n      measure: fieldSettings\n        ? fieldSettings.displayName || fieldSettings.name\n        : channel.defaultMeasure\n    };\n  }\n\n  /**\n   * Assign a field to layer column, return column config\n   * @param key - Column Key\n   * @param field - Selected field\n   * @returns {{}} - Column config\n   */\n  assignColumn(key: string, field: Field): LayerColumns {\n    // field value could be null for optional columns\n    const update = field\n      ? {\n          value: field.name,\n          fieldIdx: field.fieldIdx\n        }\n      : {value: null, fieldIdx: -1};\n\n    return {\n      ...this.config.columns,\n      [key]: {\n        ...this.config.columns[key],\n        ...update\n      }\n    };\n  }\n\n  /**\n   * Assign a field pair to column config, return column config\n   * @param key - Column Key\n   * @param pair - field Pair\n   * @returns {object} - Column config\n   */\n  assignColumnPairs(key, pair) {\n    if (!this.columnPairs || !this.columnPairs?.[key]) {\n      // should not end in this state\n      return this.config.columns;\n    }\n\n    const {pair: partnerKey, fieldPairKey} = this.columnPairs?.[key];\n    const {fieldPairKey: partnerFieldPairKey} = this.columnPairs?.[partnerKey];\n\n    return {\n      ...this.config.columns,\n      [key]: pair[fieldPairKey],\n      [partnerKey]: pair[partnerFieldPairKey]\n    };\n  }\n\n  /**\n   * Calculate a radius zoom multiplier to render points, so they are visible in all zoom level\n   * @param {object} mapState\n   * @param {number} mapState.zoom - actual zoom\n   * @param {number | void} mapState.zoomOffset - zoomOffset when render in the plot container for export image\n   * @returns {number}\n   */\n  getZoomFactor({zoom, zoomOffset = 0}) {\n    return Math.pow(2, Math.max(14 - zoom + zoomOffset, 0));\n  }\n\n  /**\n   * Calculate a elevation zoom multiplier to render points, so they are visible in all zoom level\n   * @param {object} mapState\n   * @param {number} mapState.zoom - actual zoom\n   * @param {number | void} mapState.zoomOffset - zoomOffset when render in the plot container for export image\n   * @returns {number}\n   */\n  getElevationZoomFactor({zoom, zoomOffset = 0}: {zoom: number; zoomOffset?: number}) {\n    return this.config.visConfig.enableElevationZoomFactor\n      ? Math.pow(2, Math.max(8 - zoom + zoomOffset, 0))\n      : 1;\n  }\n\n  formatLayerData(datasets: Datasets, oldLayerData?: any) {\n    return {};\n  }\n\n  renderLayer(...args: any[]): any[] {\n    return [];\n  }\n\n  getHoverData(object, dataContainer: DataContainerInterface, fields: Field[]) {\n    if (!object) {\n      return null;\n    }\n\n    // By default, each entry of layerData should have an index of a row in the original data container.\n    // Each layer can implement its own getHoverData method\n    return dataContainer.row(object.index);\n  }\n\n  /**\n   * When change layer type, try to copy over layer configs as much as possible\n   * @param configToCopy - config to copy over\n   * @param visConfigSettings - visConfig settings of config to copy\n   */\n  assignConfigToLayer(configToCopy, visConfigSettings) {\n    // don't deep merge visualChannel field\n    // don't deep merge color range, reversed: is not a key by default\n    const shallowCopy = ['colorRange', 'strokeColorRange'].concat(\n      Object.values(this.visualChannels).map(v => v.field)\n    );\n\n    // don't copy over domain and animation\n    const notToCopy = ['animation'].concat(Object.values(this.visualChannels).map(v => v.domain));\n    // if range is for the same property group copy it, otherwise, not to copy\n    Object.values(this.visualChannels).forEach(v => {\n      if (\n        configToCopy.visConfig[v.range] &&\n        this.visConfigSettings[v.range] &&\n        visConfigSettings[v.range].group !== this.visConfigSettings[v.range].group\n      ) {\n        notToCopy.push(v.range);\n      }\n    });\n\n    // don't copy over visualChannel range\n    const currentConfig = this.config;\n    const copied = this.copyLayerConfig(currentConfig, configToCopy, {\n      shallowCopy,\n      notToCopy\n    });\n    this.updateLayerConfig(copied);\n    // validate visualChannel field type and scale types\n    Object.keys(this.visualChannels).forEach(channel => {\n      this.validateVisualChannel(channel);\n    });\n  }\n\n  /*\n   * Recursively copy config over to an empty layer\n   * when received saved config, or copy config over from a different layer type\n   * make sure to only copy over value to existing keys\n   * @param {object} currentConfig - existing config to be override\n   * @param {object} configToCopy - new Config to copy over\n   * @param {string[]} shallowCopy - array of properties to not to be deep copied\n   * @param {string[]} notToCopy - array of properties not to copy\n   * @returns {object} - copied config\n   */\n  copyLayerConfig(\n    currentConfig,\n    configToCopy,\n    {shallowCopy = [], notToCopy = []}: {shallowCopy?: string[]; notToCopy?: string[]} = {}\n  ) {\n    const copied = {};\n    Object.keys(currentConfig).forEach(key => {\n      if (\n        isPlainObject(currentConfig[key]) &&\n        isPlainObject(configToCopy[key]) &&\n        !shallowCopy.includes(key) &&\n        !notToCopy.includes(key)\n      ) {\n        // recursively assign object value\n        copied[key] = this.copyLayerConfig(currentConfig[key], configToCopy[key], {\n          shallowCopy,\n          notToCopy\n        });\n      } else if (notNullorUndefined(configToCopy[key]) && !notToCopy.includes(key)) {\n        // copy\n        copied[key] = configToCopy[key];\n      } else {\n        // keep existing\n        copied[key] = currentConfig[key];\n      }\n    });\n\n    return copied;\n  }\n\n  registerVisConfig(layerVisConfigs: {\n    [key: string]: keyof LayerVisConfigSettings | ValueOf<LayerVisConfigSettings>;\n  }) {\n    Object.keys(layerVisConfigs).forEach(item => {\n      const configItem = layerVisConfigs[item];\n      if (typeof configItem === 'string' && LAYER_VIS_CONFIGS[configItem]) {\n        // if assigned one of default LAYER_CONFIGS\n        this.config.visConfig[item] = LAYER_VIS_CONFIGS[configItem].defaultValue;\n        this.visConfigSettings[item] = LAYER_VIS_CONFIGS[configItem];\n      } else if (\n        typeof configItem === 'object' &&\n        ['type', 'defaultValue'].every(p => configItem.hasOwnProperty(p))\n      ) {\n        // if provided customized visConfig, and has type && defaultValue\n        // TODO: further check if customized visConfig is valid\n        this.config.visConfig[item] = configItem.defaultValue;\n        this.visConfigSettings[item] = configItem;\n      }\n    });\n  }\n\n  getLayerColumns() {\n    const columnValidators = this.columnValidators;\n    const required = this.requiredLayerColumns.reduce(\n      (accu, key) => ({\n        ...accu,\n        [key]: columnValidators[key]\n          ? {value: null, fieldIdx: -1, validator: columnValidators[key]}\n          : {value: null, fieldIdx: -1}\n      }),\n      {}\n    );\n    const optional = this.optionalColumns.reduce(\n      (accu, key) => ({\n        ...accu,\n        [key]: {value: null, fieldIdx: -1, optional: true}\n      }),\n      {}\n    );\n\n    return {...required, ...optional};\n  }\n\n  updateLayerConfig<LayerConfig extends LayerBaseConfig = LayerBaseConfig>(\n    newConfig: Partial<LayerConfig>\n  ): Layer {\n    this.config = {...this.config, ...newConfig};\n    return this;\n  }\n\n  updateLayerVisConfig(newVisConfig) {\n    this.config.visConfig = {...this.config.visConfig, ...newVisConfig};\n    return this;\n  }\n\n  updateLayerColorUI(prop: string, newConfig: NestedPartial<ColorUI>): Layer {\n    const {colorUI: previous, visConfig} = this.config;\n\n    if (!isPlainObject(newConfig) || typeof prop !== 'string') {\n      return this;\n    }\n\n    const colorUIProp = Object.entries(newConfig).reduce((accu, [key, value]) => {\n      return {\n        ...accu,\n        [key]: isPlainObject(accu[key]) && isPlainObject(value) ? {...accu[key], ...value} : value\n      };\n    }, previous[prop] || DEFAULT_COLOR_UI);\n\n    const colorUI = {\n      ...previous,\n      [prop]: colorUIProp\n    };\n\n    this.updateLayerConfig({colorUI});\n    // if colorUI[prop] is colorRange. If type is hexColor then it's also a range\n    const isColorRange =\n      visConfig[prop] && (visConfig[prop].colors || visConfig[prop].type === hexColor);\n\n    if (isColorRange) {\n      this.updateColorUIByColorRange(newConfig, prop);\n      this.updateColorRangeByColorUI(newConfig, previous, prop);\n      this.updateCustomPalette(newConfig, previous, prop);\n    }\n\n    return this;\n  }\n\n  updateCustomPalette(newConfig, previous, prop) {\n    if (!newConfig.colorRangeConfig || !newConfig.colorRangeConfig.custom) {\n      return;\n    }\n\n    const {colorUI, visConfig} = this.config;\n\n    if (!visConfig[prop]) return;\n    const {colors} = visConfig[prop];\n    const customPalette = {\n      ...colorUI[prop].customPalette,\n      name: 'Custom Palette',\n      colors: [...colors]\n    };\n    this.updateLayerConfig({\n      colorUI: {\n        ...colorUI,\n        [prop]: {\n          ...colorUI[prop],\n          customPalette\n        }\n      }\n    });\n  }\n  /**\n   * if open dropdown and prop is color range\n   * Automatically set colorRangeConfig's step, reversed and type\n   * @param {*} newConfig\n   * @param {*} prop\n   */\n  updateColorUIByColorRange(newConfig, prop) {\n    if (typeof newConfig.showDropdown !== 'number') return;\n\n    const {colorUI, visConfig} = this.config;\n    this.updateLayerConfig({\n      colorUI: {\n        ...colorUI,\n        [prop]: {\n          ...colorUI[prop],\n          colorRangeConfig: {\n            ...colorUI[prop].colorRangeConfig,\n            type: visConfig[prop].type,\n            steps: visConfig[prop].colors?.length,\n            reversed: Boolean(visConfig[prop].reversed),\n            hexColumn: this.getHexColumn(prop),\n            isHexColumn: this.isColoredByColorColumn(prop)\n          }\n        }\n      }\n    });\n  }\n\n  // eslint-disable-next-line complexity\n  updateColorRangeByColorUI(newConfig, previous, prop) {\n    // only update colorRange if changes in UI is made to 'reversed', 'steps' or steps\n    const shouldUpdate =\n      newConfig.colorRangeConfig &&\n      ['reversed', 'steps'].some(\n        key =>\n          newConfig.colorRangeConfig.hasOwnProperty(key) &&\n          newConfig.colorRangeConfig[key] !==\n            (previous[prop] || DEFAULT_COLOR_UI).colorRangeConfig[key]\n      );\n    if (!shouldUpdate) return;\n\n    const {colorUI, visConfig} = this.config;\n    const {steps, reversed} = colorUI[prop].colorRangeConfig;\n    const colorRange = visConfig[prop];\n    // find based on step or reversed\n    let update;\n    if (newConfig.colorRangeConfig.hasOwnProperty('steps')) {\n      const group = getColorGroupByName(colorRange);\n\n      if (group) {\n        const sameGroup = COLOR_RANGES.filter(cr => getColorGroupByName(cr) === group);\n\n        update = sameGroup.find(cr => cr.colors.length === steps);\n\n        if (update && colorRange.reversed) {\n          update = reverseColorRange(true, update);\n        }\n\n        if (update && colorRange.colorMap) {\n          update = this.updateColorMap(prop, colorRange.colorMap, update);\n        }\n      }\n    }\n\n    if (newConfig.colorRangeConfig.hasOwnProperty('reversed')) {\n      update = reverseColorRange(reversed, update || colorRange);\n    }\n\n    if (update) {\n      this.updateLayerVisConfig({[prop]: update});\n    }\n  }\n\n  updateColorMap(prop, colorMap, colorRange) {\n    // @ts-ignore\n    const {field, domain} = Object.values(this.visualChannels).find(value => value.range === prop);\n    const type = this.config[field]?.type;\n\n    if (type === 'string' || type === 'boolean' || type === 'date') {\n      return this.updateCategoryColorMap(colorMap, this.config[domain], colorRange);\n    }\n\n    // If no type or type is not string, boolean or date\n    return this.updateNumericColorMap(colorMap, this.config[domain], colorRange);\n  }\n\n  updateCategoryColorMap(colorMap, domain, colorRange) {\n    const colors = colorRange.colors;\n    const assignedCategories = [];\n    if (colorRange.type === hexColor) {\n      return {\n        ...colorRange,\n        colorMap: []\n      };\n    }\n    const newColorMap = colorMap.slice(0, colors.length).map((cMap, index) => {\n      assignedCategories.push(cMap[0]);\n      return [cMap[0], colors[index]];\n    });\n    const unassignedColors = colors.slice(newColorMap.length, colors.length);\n\n    for (const color of unassignedColors) {\n      const category = domain.find(d => !assignedCategories.includes(d));\n      if (!category) {\n        break;\n      }\n      assignedCategories.push(category);\n      newColorMap.push([category, color]);\n    }\n    return {\n      ...colorRange,\n      colorMap: newColorMap\n    };\n  }\n\n  updateNumericColorMap(colorMap, domain, update) {\n    const colors = update.colors;\n    let newColorMap = colorMap.slice(0, colors.length);\n\n    newColorMap = newColorMap.map((cMap, index) => {\n      const value = index === newColorMap.length - 1 ? null : cMap[0];\n      return [value, colors[index]];\n    });\n    const unassignedColors = colors.slice(newColorMap.length, colors.length);\n\n    if (unassignedColors.length > 0) {\n      const colorMapValues = colorMap.map(c => c[0]).filter(c => typeof c === 'number');\n      const maxValue = Math.max(...colorMapValues, domain[domain.length - 1]);\n      const prevValue = newColorMap[newColorMap.length - 2][0];\n      const step = (maxValue - prevValue) / (unassignedColors.length + 1);\n      newColorMap[newColorMap.length - 1][0] = prevValue + step;\n\n      for (const [i, color] of unassignedColors.entries()) {\n        const value = i === unassignedColors.length - 1 ? null : prevValue + step * (i + 2);\n        newColorMap.push([value, color]);\n      }\n    }\n    return {\n      ...update,\n      colorMap: newColorMap\n    };\n  }\n\n  /**\n   * Check whether layer has all columns\n   * @returns yes or no\n   */\n  hasAllColumns(): boolean {\n    const {columns} = this.config;\n    return (\n      columns &&\n      Object.values(columns).every(v => {\n        return Boolean(v.optional || (v.value && v.fieldIdx > -1));\n      })\n    );\n  }\n\n  /**\n   * Check whether layer has data\n   *\n   * @param {Array | Object} layerData\n   * @returns {boolean} yes or no\n   */\n  hasLayerData(layerData) {\n    if (!layerData) {\n      return false;\n    }\n    return Boolean(layerData.data && layerData.data.length);\n  }\n\n  isValidToSave(): boolean {\n    return Boolean(this.type && this.hasAllColumns());\n  }\n\n  shouldRenderLayer(data): boolean {\n    return (\n      Boolean(this.type) &&\n      this.hasAllColumns() &&\n      this.hasLayerData(data) &&\n      typeof this.renderLayer === 'function'\n    );\n  }\n\n  getColorScale(colorScale: string, colorDomain: VisualChannelDomain, colorRange: ColorRange) {\n    if (colorRange.type === hexColor) {\n      return (_, color) => {\n        const {r, g, b} = rgb(color);\n        return [r, g, b].some(isNaN) ? UNKNOWN_COLOR : [r, g, b];\n      };\n    } else if (Array.isArray(colorRange.colorMap)) {\n      const cMap = new Map();\n      colorRange.colorMap.forEach(([k, v]) => {\n        cMap.set(k, typeof v === 'string' ? hexToRgb(v) : v);\n      });\n\n      const scale = SCALE_FUNC[colorScale]()\n        .domain(cMap.keys())\n        .range(cMap.values())\n        .unknown(UNKNOWN_COLOR);\n      return scale;\n    }\n    return this.getVisChannelScale(colorScale, colorDomain, colorRange.colors.map(hexToRgb));\n  }\n\n  getCustomMarkersScale(range, fallbackIcon) {\n    let unknownValue = fallbackIcon || FALLBACK_ICON;\n    if (!range) {\n      return () => unknownValue;\n    }\n\n    const mapping = new Map();\n\n    if (range.othersMarker) {\n      unknownValue = range.othersMarker;\n    }\n    for (const {value, markerUrl} of range.markerMap) {\n      if (markerUrl) {\n        mapping.set(value, markerUrl);\n      }\n    }\n\n    // @ts-ignore d3 scale\n    const scale = scaleOrdinal()\n      .domain(Array.from(mapping.keys()))\n      .range(Array.from(mapping.values()))\n      .unknown(unknownValue);\n    return scale;\n  }\n\n  /**\n   * Mapping from visual channels to deck.gl accesors\n   * @param {Object} param Parameters\n   * @param {Function} param.dataAccessor Access kepler.gl layer data from deck.gl layer\n   * @param {import('utils/table-utils/data-container-interface').DataContainerInterface} param.dataContainer DataContainer to use use with dataAccessor\n   * @return {Object} attributeAccessors - deck.gl layer attribute accessors\n   */\n  getAttributeAccessors({\n    dataAccessor = defaultDataAccessor,\n    dataContainer\n  }: {\n    dataAccessor?: typeof defaultDataAccessor;\n    dataContainer: DataContainerInterface;\n  }) {\n    const attributeAccessors: {[key: string]: any} = {};\n\n    // eslint-disable-next-line complexity\n    Object.keys(this.visualChannels).forEach(channel => {\n      const {\n        field,\n        fixed,\n        scale,\n        domain,\n        range,\n        accessor,\n        defaultValue,\n        getAttributeValue,\n        nullValue,\n        channelScaleType,\n        aggregation\n      } = this.visualChannels[channel];\n\n      const shouldGetScale = Boolean(\n        (scale || channelScaleType === CHANNEL_SCALES.identity) && this.config[field]\n      );\n\n      if (shouldGetScale) {\n        const isFixed = fixed && this.config.visConfig[fixed];\n        // It's important to declare as const all the parameters that we are going to be use in the getEncodedChannelValue call\n        // otherwise, the oldLayerData parameter in formatLayerData method will be wrong (you can check the formatLayerData TileLayer method in Builder as example)\n        const fieldConfig = this.config[field];\n        const aggregationValue = this.config.visConfig[aggregation];\n\n        const scaleFunction =\n          channelScaleType === CHANNEL_SCALES.identity\n            ? scaleIdentity\n            : channelScaleType === CHANNEL_SCALES.color\n            ? this.getColorScale(\n                this.config[scale],\n                this.config[domain],\n                this.config.visConfig[range]\n              )\n            : channelScaleType === CHANNEL_SCALES.customMarker\n            ? this.getCustomMarkersScale(\n                this.config.visConfig[range],\n                this.config.visConfig.customMarkersUrl\n              )\n            : this.getVisChannelScale(\n                this.config[scale],\n                this.config[domain],\n                this.config.visConfig[range],\n                isFixed\n              );\n\n        attributeAccessors[accessor] = d =>\n          this.getEncodedChannelValue({\n            channel,\n            dataContainer,\n            scale: scaleFunction,\n            data: dataAccessor(dataContainer)(d),\n            field: fieldConfig,\n            aggregation: aggregationValue,\n            nullValue\n          });\n      } else if (typeof getAttributeValue === 'function') {\n        attributeAccessors[accessor] = getAttributeValue(this.config);\n      } else {\n        attributeAccessors[accessor] =\n          typeof defaultValue === 'function' ? defaultValue(this.config) : defaultValue;\n      }\n\n      if (!(accessor in attributeAccessors)) {\n        Console.warn(`Failed to provide accessor function for ${accessor || channel}`);\n      }\n    });\n\n    return attributeAccessors;\n  }\n\n  getVisChannelScale(\n    scale: string,\n    domain: VisualChannelDomain,\n    range: any,\n    fixed?: boolean\n  ): () => any | null {\n    if (scale === SCALE_TYPES.ordinal) {\n      return SCALE_FUNC[scale]()\n        .domain(domain.slice(0, range.length) as any)\n        .range(range)\n        .unknown(UNKNOWN_COLOR) as any;\n    }\n\n    // for `count` aggregation, we domain is actually `[0, Infinity]` so it doesn't make sense\n    // to use it, so skip specyfying this domains\n    const domainIsInfinite = domain && domain[0] === 0 && domain[1] === Infinity;\n    const scaleFactory = SCALE_FUNC[fixed ? 'linear' : scale];\n    // @ts-ignore d3-scale type\n    let result = scaleFactory();\n    if (domain && !domainIsInfinite) {\n      result = result.domain(domain);\n    }\n    return result.range(fixed ? domain : range);\n  }\n\n  /**\n   * Get longitude and latitude bounds of the data.\n   * @param {import('utils/table-utils/data-container-interface').DataContainerInterface} dataContainer DataContainer to calculate bounds for.\n   * @param {(d: {index: number}, dc: import('utils/table-utils/data-container-interface').DataContainerInterface) => number[]} getPosition Access kepler.gl layer data from deck.gl layer\n   * @return {number[]|null} bounds of the data.\n   */\n  getPointsBounds(dataContainer, getPosition) {\n    // no need to loop through the entire dataset\n    // get a sample of data to calculate bounds\n    const sampleData =\n      dataContainer.numRows() > MAX_SAMPLE_SIZE\n        ? getSampleData(dataContainer, MAX_SAMPLE_SIZE)\n        : dataContainer;\n\n    const points = sampleData.mapIndex(getPosition);\n\n    const latBounds = getLatLngBounds(points, 1, [-90, 90]);\n    const lngBounds = getLatLngBounds(points, 0, [-180, 180]);\n\n    if (!latBounds || !lngBounds) {\n      return null;\n    }\n\n    return [lngBounds[0], latBounds[0], lngBounds[1], latBounds[1]];\n  }\n\n  getChangedTriggers(dataUpdateTriggers) {\n    const triggerChanged = diffUpdateTriggers(dataUpdateTriggers, this._oldDataUpdateTriggers);\n    this._oldDataUpdateTriggers = dataUpdateTriggers;\n\n    return triggerChanged;\n  }\n\n  getEncodedChannelValue({\n    channel,\n    scale,\n    data,\n    field,\n    dataContainer,\n    // In builder we overwrite the getValue function and we use the _aggregation parameter in spatial index layers as the QuadkeyLayer.\n    aggregation,\n    nullValue = NO_VALUE_COLOR as RGBAColor,\n    getValue = defaultGetFieldValue\n  }: {\n    channel: string;\n    scale: (...value) => any;\n    data: any[];\n    field: VisualChannelField;\n    dataContainer: any;\n    aggregation: any;\n    nullValue?: RGBAColor;\n    getValue?: typeof defaultGetFieldValue;\n  }) {\n    const {type} = field;\n    const value = getValue(field, data);\n    const channelConfig = this.config.visConfig[this.visualChannels[channel].range];\n    const channelField = this.config[this.visualChannels[channel].field];\n    let colorColumnValue: any;\n\n    if (channelConfig?.type === hexColor) {\n      const columnField = {\n        id: channelField.colorColumn,\n        name: channelField.colorColumn,\n        fieldIdx: channelField.colorColumnIdx,\n        valueAccessor: d => {\n          return dataContainer.valueAt(d.index, channelField.colorColumnIdx);\n        }\n      };\n\n      colorColumnValue = getValue(columnField, data);\n    } else if (!notNullorUndefined(value)) {\n      return nullValue;\n    }\n\n    let attributeValue;\n    if (type === ALL_FIELD_TYPES.timestamp) {\n      // shouldn't need to convert here\n      // scale Function should take care of it\n      attributeValue = scale(new Date(value), colorColumnValue);\n    } else {\n      attributeValue = scale(value, colorColumnValue);\n    }\n\n    if (!notNullorUndefined(attributeValue)) {\n      attributeValue = nullValue;\n    }\n\n    return attributeValue;\n  }\n\n  updateMeta(meta) {\n    this.meta = {...this.meta, ...meta};\n  }\n\n  updateLayerLegend(settings) {\n    (this as any).legendSettings = settings;\n  }\n\n  // @ts-expect-error\n  getDataUpdateTriggers({filteredIndex, id, allData}: KeplerTable): any {\n    const {columns} = this.config;\n\n    return {\n      getData: {datasetId: id, allData, columns, filteredIndex},\n      getMeta: {datasetId: id, allData, columns},\n      ...(this.config.textLabel || []).reduce(\n        (accu, tl, i) => ({\n          ...accu,\n          [`getLabelCharacterSet-${i}`]: tl.field ? tl.field.name : null\n        }),\n        {}\n      )\n    };\n  }\n\n  updateData(datasets, oldLayerData) {\n    if (!this.config.dataId) {\n      return {};\n    }\n    const dataset = this.getDataset(datasets);\n    const {dataContainer} = dataset;\n\n    this.updateVisualChannelFields(dataset);\n    this.updateHexColorDomain(dataset);\n\n    const getPosition = this.getPositionAccessor(dataContainer);\n    const dataUpdateTriggers = this.getDataUpdateTriggers(dataset);\n    const triggerChanged = this.getChangedTriggers(dataUpdateTriggers);\n\n    if (triggerChanged && triggerChanged.getMeta) {\n      this.updateLayerMeta(dataContainer, getPosition);\n    }\n\n    let data = [];\n\n    if (!(triggerChanged && triggerChanged.getData) && oldLayerData && oldLayerData.data) {\n      // same data\n      data = oldLayerData.data;\n    } else {\n      data = this.calculateDataAttribute(dataset, getPosition);\n    }\n\n    return {data, triggerChanged};\n  }\n\n  /**\n   * Update styled fields to match ones from new dataset.\n   *\n   * @param {Object} dataset\n   */\n  updateVisualChannelFields(dataset) {\n    for (const {field, range} of Object.values(this.visualChannels)) {\n      const oldField = this.config[field];\n      const isUsingHexColorCode = this.config.visConfig[range]?.hexColor;\n      if (!oldField) {\n        return;\n      }\n      let newDataSetField = dataset.fields.find(fd => fd.name === oldField.name) || null;\n      if (isUsingHexColorCode) {\n        newDataSetField = {\n          ...newDataSetField,\n          colorColumn: newDataSetField.colorColumn || oldField.colorColumn,\n          colorColumnIdx: newDataSetField.colorColumnIdx || oldField.colorColumnIdx\n        };\n      }\n      this.updateLayerConfig({[field]: newDataSetField});\n    }\n  }\n\n  /**\n   * helper function to update one layer domain when state.data changed\n   * if state.data change is due ot update filter, newFiler will be passed\n   * called by updateAllLayerDomainData\n   * @param datasets\n   * @param newFilter\n   * @returns layer\n   */\n  updateLayerDomain(datasets: Datasets, newFilter?: Filter): Layer {\n    const table = this.getDataset(datasets);\n    if (!table) {\n      return this;\n    }\n    Object.values(this.visualChannels).forEach(channel => {\n      const {scale} = channel;\n      const scaleType = this.config[scale];\n\n      // ordinal domain is based on dataContainer, if only filter changed\n      // no need to update ordinal domain\n      if (!newFilter || scaleType !== SCALE_TYPES.ordinal) {\n        const {domain} = channel;\n        const updatedDomain = this.calculateLayerDomain(table, channel);\n        this.updateLayerConfig({[domain]: updatedDomain});\n      }\n    });\n\n    return this;\n  }\n\n  getDataset(datasets) {\n    return this.config.dataId ? datasets[this.config.dataId] : null;\n  }\n\n  /**\n   * Validate visual channel field and scales based on supported field & scale type\n   * @param channel\n   */\n  validateVisualChannel(channel: string) {\n    this.validateFieldType(channel);\n    this.validateScale(channel);\n  }\n\n  /**\n   * Validate field type based on channelScaleType\n   */\n  validateFieldType(channel: string) {\n    const visualChannel = this.visualChannels[channel];\n    const {field, channelScaleType, supportedFieldTypes} = visualChannel;\n\n    if (this.config[field]) {\n      // if field is selected, check if field type is supported\n      const channelSupportedFieldTypes =\n        supportedFieldTypes || CHANNEL_SCALE_SUPPORTED_FIELDS[channelScaleType];\n\n      if (!channelSupportedFieldTypes.includes(this.config[field].type)) {\n        // field type is not supported, set it back to null\n        // set scale back to default\n        this.updateLayerConfig({[field]: null});\n      }\n    }\n  }\n\n  /**\n   * Validate scale type based on aggregation\n   */\n  validateScale(channel) {\n    const visualChannel = this.visualChannels[channel];\n    const {scale, range} = visualChannel;\n    if (\n      !scale ||\n      (this.isColoredByColorColumn(range) && this.config[scale] === SCALE_TYPES.identity)\n    ) {\n      // visualChannel doesn't have scale\n      return;\n    }\n    const scaleOptions = this.getScaleOptions(channel);\n    // check if current selected scale is\n    // supported, if not, change to default\n    if (!scaleOptions.includes(this.config[scale])) {\n      this.updateLayerConfig({[scale]: scaleOptions[0]});\n    }\n  }\n\n  /**\n   * Get scale options based on current field\n   * @param {string} channel\n   * @returns {string[]}\n   */\n  getScaleOptions(channel) {\n    const visualChannel = this.visualChannels[channel];\n    const {field, scale, channelScaleType} = visualChannel;\n\n    return this.config[field]\n      ? FIELD_OPTS[this.config[field].type].scale[channelScaleType]\n      : [this.getDefaultLayerConfig()[scale]];\n  }\n\n  updateLayerVisualChannel(dataset: KeplerTable, channel: string) {\n    const visualChannel = this.visualChannels[channel];\n    this.validateVisualChannel(channel);\n    // calculate layer channel domain\n    const updatedDomain = this.calculateLayerDomain(dataset, visualChannel);\n    this.updateLayerConfig({[visualChannel.domain]: updatedDomain});\n  }\n\n  getVisualChannelUpdateTriggers(): UpdateTriggers {\n    const updateTriggers: UpdateTriggers = {};\n    Object.values(this.visualChannels).forEach(visualChannel => {\n      // field range scale domain\n      const {accessor, field, scale, domain, range, defaultValue, fixed} = visualChannel;\n\n      if (accessor) {\n        updateTriggers[accessor] = {\n          [field]: this.config[field],\n          [scale]: this.config[scale],\n          [domain]: this.config[domain],\n          [range]: this.config.visConfig[range],\n          defaultValue:\n            typeof defaultValue === 'function' ? defaultValue(this.config) : defaultValue,\n          ...(fixed ? {[fixed]: this.config.visConfig[fixed]} : {})\n        };\n      }\n    });\n    return updateTriggers;\n  }\n\n  calculateLayerDomain(dataset, visualChannel) {\n    const {scale} = visualChannel;\n    const field = this.config[visualChannel.field];\n    if (!field || !scale) {\n      // if colorField or sizeField were set back to null\n      return defaultDomain;\n    }\n\n    const scaleType = this.config[scale];\n    const dataSetField = dataset.fields.find(f => f.name === field.name);\n    if (!scaleType || !dataSetField) {\n      // if new dataset doesn't contain previously set field\n      return defaultDomain;\n    }\n\n    return dataset.getColumnLayerDomain(dataSetField, scaleType) || defaultDomain;\n  }\n\n  updateHexColorDomain(dataset) {\n    if (!dataset) {\n      return this;\n    }\n    Object.values(this.visualChannels).forEach(channel => {\n      const channelConfig = this.config.visConfig[channel.range];\n      const field = this.config[channel.field];\n\n      if (channelConfig?.type === hexColor && field?.colorColumn) {\n        const dataSetField = dataset.fields.find(f => f.name === field.colorColumn);\n        const colors = dataset\n          .getColumnLayerDomain(dataSetField, SCALE_TYPES.ordinal)\n          .map(c => checkColorOrFallback(c));\n        this.updateLayerVisConfig({\n          [channel.range]: {...channelConfig, colors}\n        });\n      }\n    });\n\n    return this;\n  }\n\n  calculateHexColumnLegend(datasets) {\n    const dataset = this.getDataset(datasets);\n    if (!datasets) {\n      return;\n    }\n\n    const legendSettings = Object.keys(this.visualChannels).reduce((legends, channel) => {\n      const {range, field: channelField} = this.visualChannels[channel];\n      const channelConfig = this.config.visConfig[range];\n      const field = this.config[channelField];\n\n      if (channelConfig?.type === hexColor && field?.colorColumn) {\n        const dataSetField = dataset.fields.find(f => f.name === field.colorColumn);\n        const legend = dataset.calculateLegend(field, dataSetField);\n        legends[channel] = legend;\n      }\n      return legends;\n    }, {});\n    this.updateLayerLegend(legendSettings);\n  }\n\n  hasHoveredObject(objectInfo) {\n    return this.isLayerHovered(objectInfo) && objectInfo.object ? objectInfo.object : null;\n  }\n\n  isLayerHovered(objectInfo): boolean {\n    return objectInfo?.picked && objectInfo?.layer?.props?.id === this.id;\n  }\n\n  getRadiusScaleByZoom(mapState: MapState, fixedRadius?: boolean) {\n    const radiusChannel = Object.values(this.visualChannels).find(vc => vc.property === 'radius');\n\n    if (!radiusChannel) {\n      return 1;\n    }\n\n    const field = radiusChannel.field;\n    const {radius} = this.config.visConfig;\n\n    // @ts-ignore\n    return (this.config[field] ? 1 : radius) * this.getZoomFactor(mapState);\n  }\n\n  getRadiusScale() {\n    const radiusChannel = Object.values(this.visualChannels).find(vc => vc.property === 'radius');\n\n    if (!radiusChannel || this.config[radiusChannel.field]) {\n      return 1;\n    }\n\n    return this.config.visConfig.radius;\n  }\n\n  getMaxMarkerSize() {\n    const {radiusField, sizeField, visConfig} = this.config as any;\n    const {radiusRange, radius} = visConfig;\n    const field = radiusField || sizeField;\n    return Math.ceil(field && radiusRange ? radiusRange[1] : radius);\n  }\n\n  shouldCalculateLayerData(props: string[]) {\n    return props.some(p => !this.noneLayerDataAffectingProps.includes(p));\n  }\n\n  getBrushingExtensionProps(interactionConfig, brushingTarget?) {\n    const {brush} = interactionConfig;\n\n    return {\n      // brushing\n      autoHighlight: !brush.enabled,\n      brushingRadius: brush.config.size * 1000,\n      brushingTarget: brushingTarget || 'source',\n      brushingEnabled: brush.enabled\n    };\n  }\n\n  getDefaultDeckLayerProps({\n    idx,\n    gpuFilter,\n    mapState,\n    visible,\n    maskPolygon\n  }: {\n    idx: number;\n    gpuFilter: GpuFilter;\n    mapState: MapState;\n    visible: boolean;\n    maskPolygon: any;\n  }) {\n    const maskExtensionProps = getMaskExtensionProps(maskPolygon);\n    return {\n      ...maskExtensionProps,\n      id: this.id,\n      idx,\n      coordinateSystem: COORDINATE_SYSTEM.LNGLAT,\n      pickable: this.hasInteractivity,\n      wrapLongitude: true,\n      parameters: {depthTest: Boolean(mapState.dragRotate || this.config.visConfig.enable3d)},\n      hidden: this.config.hidden,\n      visibilityByZoom: (this.config as any).visibilityByZoom,\n      // visconfig\n      opacity: this.config.visConfig.opacity,\n      highlightColor: this.config.highlightColor,\n      // data filtering\n      extensions: [dataFilterExtension, ...maskExtensionProps.extensions],\n      filterRange: gpuFilter ? gpuFilter.filterRange : undefined,\n      // layer should be visible and if splitMap, shown in to one of panel\n      visible: this.config.isVisible && visible\n    };\n  }\n\n  getDefaultHoverLayerProps() {\n    return {\n      id: `${this.id}-hovered`,\n      pickable: false,\n      wrapLongitude: true,\n      coordinateSystem: COORDINATE_SYSTEM.LNGLAT\n    };\n  }\n\n  renderTextLabelLayer(\n    {getPosition, getRadius, radiusScale, updateTriggers, sharedProps},\n    renderOpts\n  ) {\n    const {data} = renderOpts;\n    const {textLabel, visibilityByZoom} = this.config as any;\n    const extensions = [...sharedProps.extensions, collisionFilterExtension];\n\n    if (!data || !data.textLabels || !data.textLabels[0] || !data.textLabels[0].getText) {\n      return [];\n    }\n\n    const [mainLabel, secondaryLabel] = textLabel;\n    const {\n      alignment,\n      anchor,\n      color: getColor,\n      field: mainField,\n      outlineColor,\n      size: sizeScale\n    } = mainLabel;\n    const {\n      color: getSecondaryColor,\n      field: secondaryField,\n      outlineColor: secondaryOutlineColor,\n      size: secondarySizeScale\n    } = secondaryLabel || {};\n\n    return [\n      new PointLabelLayer({\n        ...sharedProps,\n\n        // Recreate layer when labels change otherwise rendering breaks\n        // TODO could be more efficient with updateTriggers?\n        id: `${this.id}-${mainField?.name}-${secondaryField?.name}-label`,\n        data: data.data,\n        visibilityByZoom,\n        extensions,\n\n        characterSet: 'auto',\n        collisionEnabled: true,\n        collisionGroup: `${this.id}-labels`,\n\n        getText: data.textLabels[0].getText,\n        getColor,\n        sizeScale,\n        outlineColor,\n\n        ...(secondaryField && {\n          getSecondaryText: data.textLabels[1].getText,\n          getSecondaryColor,\n          secondarySizeScale,\n          secondaryOutlineColor\n        }),\n\n        // Position\n        getPosition,\n        getRadius,\n        radiusScale,\n        getTextAnchor: anchor,\n        getAlignmentBaseline: alignment,\n\n        // Style\n        fontFamily: 'Inter, sans',\n        fontSettings: {sdf: true},\n        fontWeight: 500,\n        outlineWidth: 4,\n        parameters: {\n          // text will always show on top of all layers\n          depthTest: false\n        },\n\n        getFilterValue: data.getFilterValue,\n        updateTriggers: {\n          ...updateTriggers,\n          getText: mainField?.name,\n          getColor: (mainField as any)?.color,\n          getTextAnchor: mainLabel.anchor,\n          getAlignmentBaseline: mainLabel.alignment,\n          getSecondaryText: secondaryField?.name\n        }\n      })\n    ];\n  }\n\n  /**\n   * Create deck.gl `IconLayer` \"autoPack\" mode accessor for custom markers.\n   *\n   * @param {*} iconUrlAccessor deck.gl accessor (or value) that resolves to URL of icon for given row\n   * @returns deck.gl accessor that returns UnpackedIcon ready to consume by IconLayer\n   */\n  getCustomMarkerIconAccessor(iconUrlAccessor, mask = true) {\n    const maxIconSize = this.getMaxMarkerSize();\n\n    return d => {\n      const wantedUrl =\n        typeof iconUrlAccessor === 'function' ? iconUrlAccessor(d) : iconUrlAccessor;\n      const iconOk = Boolean(wantedUrl);\n      mask = iconOk ? mask : true;\n      const url = iconOk ? wantedUrl : FALLBACK_ICON;\n      return {\n        id: `${url}@@${maxIconSize}@${mask ? 'm' : 'c'}`,\n        url,\n        width: maxIconSize,\n        height: maxIconSize,\n        mask\n      };\n    };\n  }\n\n  calculateDataAttribute(keplerTable: KeplerTable, getPosition): any {\n    // implemented in subclasses\n    return [];\n  }\n\n  updateLayerMeta(dataContainer: DataContainerInterface, getPosition) {\n    // implemented in subclasses\n  }\n\n  getPositionAccessor(dataContainer?: DataContainerInterface): (...args: any[]) => any {\n    // implemented in subclasses\n    return () => null;\n  }\n\n  getHexColumn(range) {\n    const field = Object.values(this.visualChannels)?.find(value => value.range === range)?.field;\n    if (field) {\n      return this.config[field]?.colorColumn;\n    }\n  }\n\n  isColoredByColorColumn(range) {\n    return this.config.visConfig[range]?.hexColor;\n  }\n}\n\nexport default Layer;\n"],"mappings":"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","ignoreList":[]}
+
+    /**
+     * Given a array of preset required column names
+     * found field that has the same name to set as layer column
+     *
+     * @param {object} defaultFields
+     * @param {object[]} allFields
+     * @returns {object[] | null} all possible required layer column pairs
+     */
+  }, {
+    key: "findDefaultColumnField",
+    value: function findDefaultColumnField(defaultFields, allFields) {
+      // find all matched fields for each required col
+      var requiredColumns = Object.keys(defaultFields).reduce(function (prev, key) {
+        var requiredFields = allFields.filter(function (f) {
+          return f.name === defaultFields[key] || defaultFields[key].includes(f.name);
+        });
+        prev[key] = requiredFields.length ? requiredFields.map(function (f) {
+          return {
+            value: f.name,
+            fieldIdx: f.fieldIdx
+          };
+        }) : null;
+        return prev;
+      }, {});
+      if (!Object.values(requiredColumns).every(Boolean)) {
+        // if any field missing, return null
+        return null;
+      }
+      return this.getAllPossibleColumnParis(requiredColumns);
+    }
+  }, {
+    key: "getAllPossibleColumnParis",
+    value: function getAllPossibleColumnParis(requiredColumns) {
+      // for multiple matched field for one required column, return multiple
+      // combinations, e. g. if column a has 2 matched, column b has 3 matched
+      // 6 possible column pairs will be returned
+      var allKeys = Object.keys(requiredColumns);
+      var pointers = allKeys.map(function (k, i) {
+        return i === allKeys.length - 1 ? -1 : 0;
+      });
+      var countPerKey = allKeys.map(function (k) {
+        return requiredColumns[k].length;
+      });
+      // TODO: Better typings
+      var pairs = [];
+
+      /* eslint-disable no-loop-func */
+      while (incrementPointers(pointers, countPerKey, pointers.length - 1)) {
+        var newPair = pointers.reduce(function (prev, cuur, i) {
+          prev[allKeys[i]] = requiredColumns[allKeys[i]][cuur];
+          return prev;
+        }, {});
+        pairs.push(newPair);
+      }
+      /* eslint-enable no-loop-func */
+
+      // recursively increment pointers
+      function incrementPointers(pts, counts, index) {
+        if (index === 0 && pts[0] === counts[0] - 1) {
+          // nothing to increment
+          return false;
+        }
+        if (pts[index] + 1 < counts[index]) {
+          pts[index] = pts[index] + 1;
+          return true;
+        }
+        pts[index] = 0;
+        return incrementPointers(pts, counts, index - 1);
+      }
+      return pairs;
+    }
+  }, {
+    key: "hexToRgb",
+    value: function hexToRgb(c) {
+      return (0, _colorUtils.hexToRgb)(c);
+    }
+  }]);
+}();
+var _default = exports["default"] = Layer;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_window","require","_keymirror","_interopRequireDefault","_extensions","_core","_carto","_defaultLayerIcon","_layerUpdate","_d3Color","_defaultSettings","_colorRanges","_customColorRanges","_layerFactory","_utils","_dataUtils","_dataContainerUtils","_colorUtils","_layerUtils","_d3Scale","_createForOfIteratorHelper","r","e","t","Symbol","iterator","Array","isArray","_unsupportedIterableToArray","length","_n","F","s","n","done","value","f","TypeError","o","a","u","call","next","_arrayLikeToArray","toString","slice","constructor","name","from","test","ownKeys","Object","keys","getOwnPropertySymbols","filter","getOwnPropertyDescriptor","enumerable","push","apply","_objectSpread","arguments","forEach","_defineProperty2","getOwnPropertyDescriptors","defineProperties","defineProperty","_marked","_regenerator","mark","generateColor","LAYER_ID_LENGTH","exports","FALLBACK_ICON","MAX_SAMPLE_SIZE","defaultDomain","dataFilterExtension","DataFilterExtension","filterSize","MAX_GPU_FILTERS","collisionFilterExtension","CollisionFilterExtension","defaultDataAccessor","dc","d","defaultGetFieldValue","field","valueAccessor","scaleIdentity","v","OVERLAY_TYPE","keymirror","deckgl","mapboxgl","layerColors","values","DataVizColors","map","hexToRgb","index","wrap","generateColor$","_context","prev","stop","colorMaker","Layer","props","undefined","_classCallCheck2","id","generateHashId","meta","legendSettings","visConfigSettings","_interactivitySettings","config","getDefaultLayerConfig","columns","getLayerColumns","_createClass2","key","get","DefaultLayerIcon","type","color","property","scale","domain","range","channelScaleType","CHANNEL_SCALES","nullValue","NO_VALUE_COLOR","defaultValue","size","lat","pair","fieldPairKey","lng","lat0","lng0","lat1","lng1","set","interactivitySettings","_this$interactivitySe","_this$interactivitySe2","_this$interactivitySe3","_this$interactivitySe4","Boolean","hover","fields","click","_this$interactivitySe5","hasTooltip","enabled","_visibilityByZoom","_visibilityByZoom2","dataId","visibilityByZoom","min","ZOOM_LEVEL_LIMITS","max","label","DEFAULT_LAYER_LABEL","isVisible","isConfigActive","highlightColor","DEFAULT_HIGHLIGHT_COLOR","hidden","colorField","colorDomain","colorScale","SCALE_TYPES","quantile","sizeDomain","sizeScale","linear","sizeField","radiusField","visConfig","textLabel","DEFAULT_TEXT_LABEL","colorUI","DEFAULT_COLOR_UI","colorRange","animation","getVisualChannelDescription","channel","visualChannels","measure","rangeSettings","fieldSettings","displayName","defaultMeasure","assignColumn","update","fieldIdx","assignColumnPairs","_this$columnPairs","_this$columnPairs2","_this$columnPairs3","columnPairs","_this$columnPairs$key","partnerKey","_this$columnPairs$par","partnerFieldPairKey","getZoomFactor","_ref","zoom","_ref$zoomOffset","zoomOffset","Math","pow","getElevationZoomFactor","_ref2","_ref2$zoomOffset","enableElevationZoomFactor","formatLayerData","datasets","oldLayerData","renderLayer","getHoverData","object","dataContainer","row","assignConfigToLayer","configToCopy","_this","shallowCopy","concat","notToCopy","group","currentConfig","copied","copyLayerConfig","updateLayerConfig","validateVisualChannel","_this2","_ref3","_ref3$shallowCopy","_ref3$notToCopy","isPlainObject","includes","notNullorUndefined","registerVisConfig","layerVisConfigs","_this3","item","configItem","LAYER_VIS_CONFIGS","_typeof2","every","p","hasOwnProperty","columnValidators","required","requiredLayerColumns","reduce","accu","validator","optional","optionalColumns","newConfig","updateLayerVisConfig","newVisConfig","updateLayerColorUI","prop","_this$config","previous","colorUIProp","entries","_ref4","_ref5","_slicedToArray2","isColorRange","colors","hexColor","updateColorUIByColorRange","updateColorRangeByColorUI","updateCustomPalette","colorRangeConfig","custom","_this$config2","customPalette","_toConsumableArray2","_visConfig$prop$color","showDropdown","_this$config3","steps","reversed","hexColumn","getHexColumn","isHexColumn","isColoredByColorColumn","shouldUpdate","some","_this$config4","_colorUI$prop$colorRa","getColorGroupByName","sameGroup","COLOR_RANGES","cr","find","reverseColorRange","colorMap","updateColorMap","_this$config$field","_Object$values$find","updateCategoryColorMap","updateNumericColorMap","assignedCategories","newColorMap","cMap","unassignedColors","_iterator","_step","category","err","colorMapValues","c","maxValue","prevValue","step","_iterator2","_step2","_step2$value","i","hasAllColumns","hasLayerData","layerData","data","isValidToSave","shouldRenderLayer","getColorScale","_","_rgb","rgb","g","b","isNaN","UNKNOWN_COLOR","Map","_ref6","_ref7","k","SCALE_FUNC","unknown","getVisChannelScale","getCustomMarkersScale","fallbackIcon","unknownValue","mapping","othersMarker","_iterator3","markerMap","_step3","_step3$value","markerUrl","scaleOrdinal","getAttributeAccessors","_ref8","_this4","_ref8$dataAccessor","dataAccessor","attributeAccessors","_this4$visualChannels","fixed","accessor","getAttributeValue","aggregation","shouldGetScale","identity","isFixed","fieldConfig","aggregationValue","scaleFunction","customMarker","customMarkersUrl","getEncodedChannelValue","Console","warn","ordinal","domainIsInfinite","Infinity","scaleFactory","result","getPointsBounds","getPosition","sampleData","numRows","getSampleData","points","mapIndex","latBounds","getLatLngBounds","lngBounds","getChangedTriggers","dataUpdateTriggers","triggerChanged","diffUpdateTriggers","_oldDataUpdateTriggers","_ref9","_ref9$nullValue","_ref9$getValue","getValue","channelConfig","channelField","colorColumnValue","columnField","colorColumn","colorColumnIdx","valueAt","attributeValue","ALL_FIELD_TYPES","timestamp","Date","updateMeta","updateLayerLegend","settings","getDataUpdateTriggers","_ref10","filteredIndex","allData","getData","datasetId","getMeta","tl","updateData","dataset","getDataset","updateVisualChannelFields","updateHexColorDomain","getPositionAccessor","updateLayerMeta","calculateDataAttribute","_this5","_loop","_this5$config$visConf","_Object$values$_i","_Object$values","_i","oldField","isUsingHexColorCode","newDataSetField","fd","_ret","updateLayerDomain","newFilter","_this6","table","scaleType","updatedDomain","calculateLayerDomain","validateFieldType","validateScale","visualChannel","supportedFieldTypes","channelSupportedFieldTypes","CHANNEL_SCALE_SUPPORTED_FIELDS","scaleOptions","getScaleOptions","FIELD_OPTS","updateLayerVisualChannel","getVisualChannelUpdateTriggers","_this7","updateTriggers","dataSetField","getColumnLayerDomain","_this8","checkColorOrFallback","calculateHexColumnLegend","_this9","legends","_this9$visualChannels","legend","calculateLegend","hasHoveredObject","objectInfo","isLayerHovered","_objectInfo$layer","_objectInfo$layer$pro","picked","layer","getRadiusScaleByZoom","mapState","fixedRadius","radiusChannel","vc","radius","getRadiusScale","getMaxMarkerSize","_ref12","radiusRange","ceil","shouldCalculateLayerData","_this10","noneLayerDataAffectingProps","getBrushingExtensionProps","interactionConfig","brushingTarget","brush","autoHighlight","brushingRadius","brushingEnabled","getDefaultDeckLayerProps","_ref13","idx","gpuFilter","visible","maskPolygon","maskExtensionProps","getMaskExtensionProps","coordinateSystem","COORDINATE_SYSTEM","LNGLAT","pickable","hasInteractivity","wrapLongitude","parameters","depthTest","dragRotate","enable3d","opacity","extensions","filterRange","getDefaultHoverLayerProps","renderTextLabelLayer","_ref14","renderOpts","getRadius","radiusScale","sharedProps","_ref15","textLabels","getText","_textLabel","mainLabel","secondaryLabel","alignment","anchor","getColor","mainField","outlineColor","_ref16","getSecondaryColor","secondaryField","secondaryOutlineColor","secondarySizeScale","PointLabelLayer","characterSet","collisionEnabled","collisionGroup","getSecondaryText","getTextAnchor","getAlignmentBaseline","fontFamily","fontSettings","sdf","fontWeight","outlineWidth","getFilterValue","getCustomMarkerIconAccessor","iconUrlAccessor","mask","maxIconSize","wantedUrl","iconOk","url","width","height","keplerTable","_Object$values2","_Object$values2$find","_this$config$field2","_this$config$visConfi","findDefaultLayerProps","foundLayers","findDefaultColumnField","defaultFields","allFields","requiredColumns","requiredFields","getAllPossibleColumnParis","allKeys","pointers","countPerKey","pairs","incrementPointers","newPair","cuur","pts","counts","_default"],"sources":["../../src/layers/base-layer.ts"],"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 {console as Console} from 'global/window';\nimport keymirror from 'keymirror';\nimport {CollisionFilterExtension, DataFilterExtension} from '@deck.gl/extensions';\nimport {COORDINATE_SYSTEM, Layer as DeckLayer} from '@deck.gl/core';\nimport {PointLabelLayer} from '@deck.gl/carto';\nimport DefaultLayerIcon from './default-layer-icon';\nimport {diffUpdateTriggers} from './layer-update';\nimport {rgb} from 'd3-color';\n\nimport {\n  ALL_FIELD_TYPES,\n  NO_VALUE_COLOR,\n  SCALE_TYPES,\n  CHANNEL_SCALES,\n  FIELD_OPTS,\n  SCALE_FUNC,\n  CHANNEL_SCALE_SUPPORTED_FIELDS,\n  MAX_GPU_FILTERS,\n  UNKNOWN_COLOR,\n  ZOOM_LEVEL_LIMITS\n} from 'constants/default-settings';\nimport {ColorRange, COLOR_RANGES, hexColor} from 'constants/color-ranges';\nimport {DataVizColors} from 'constants/custom-color-ranges';\nimport {\n  LAYER_VIS_CONFIGS,\n  DEFAULT_TEXT_LABEL,\n  DEFAULT_COLOR_UI,\n  DEFAULT_HIGHLIGHT_COLOR,\n  DEFAULT_LAYER_LABEL,\n  LayerVisConfig,\n  LayerVisConfigSettings\n} from './layer-factory';\n\nimport {generateHashId, isPlainObject} from 'utils/utils';\n\nimport {getLatLngBounds, notNullorUndefined} from 'utils/data-utils';\nimport {getSampleData} from 'utils/table-utils/data-container-utils';\n\nimport {\n  hexToRgb,\n  getColorGroupByName,\n  reverseColorRange,\n  checkColorOrFallback\n} from 'utils/color-utils';\nimport {getMaskExtensionProps} from 'utils/layer-utils';\nimport {scaleOrdinal} from 'd3-scale';\n\nimport {RGBColor, RGBAColor, MapState, Filter, Datasets, ValueOf, NestedPartial} from 'reducers';\nimport {LayerTextLabel, ColorUI} from './layer-factory';\nimport {KeplerTable} from '../utils';\nimport {DataContainerInterface} from 'utils/table-utils/data-container-interface';\nimport {Field, GpuFilter} from 'utils/table-utils/kepler-table';\nimport React from 'react';\n\nexport type LayerColumn = {value: string | null; fieldIdx: number; optional?: boolean};\n\nexport type LayerColumns = {\n  [key: string]: LayerColumn;\n};\nexport type VisualChannelDomain = number[] | string[];\nexport type VisualChannelField = Field | null;\nexport type VisualChannelScale = keyof typeof SCALE_TYPES;\n\nexport type LayerBaseConfig = {\n  dataId: string | null;\n  label: string;\n  color: RGBColor;\n\n  columns: LayerColumns;\n  isVisible: boolean;\n  isConfigActive: boolean;\n  highlightColor: RGBColor | RGBAColor;\n  hidden: boolean;\n\n  visConfig: LayerVisConfig;\n  textLabel: LayerTextLabel[];\n\n  colorUI: {\n    color: ColorUI;\n    colorRange: ColorUI;\n  };\n  animation: {\n    enabled: boolean;\n    domain?: null;\n  };\n};\n\nexport type LayerColorConfig = {\n  colorField: VisualChannelField;\n  colorDomain: VisualChannelDomain;\n  colorScale: VisualChannelScale;\n};\nexport type LayerSizeConfig = {\n  // color by size, domain is set by filters, field, scale type\n  sizeDomain: VisualChannelDomain;\n  sizeScale: VisualChannelScale;\n  sizeField: VisualChannelField;\n};\nexport type LayerHeightConfig = {\n  heightField: VisualChannelField;\n  heightDomain: VisualChannelDomain;\n  heightScale: VisualChannelScale;\n};\nexport type LayerStrokeColorConfig = {\n  strokeColorField: VisualChannelField;\n  strokeColorDomain: VisualChannelDomain;\n  strokeColorScale: VisualChannelScale;\n};\nexport type LayerCoverageConfig = {\n  coverageField: VisualChannelField;\n  coverageDomain: VisualChannelDomain;\n  coverageScale: VisualChannelScale;\n};\nexport type LayerRadiusConfig = {\n  radiusField: VisualChannelField;\n  radiusDomain: VisualChannelDomain;\n  radiusScale: VisualChannelScale;\n};\nexport type LayerWeightConfig = {\n  weightField: VisualChannelField;\n};\n\nexport type VisualChannels = {[key: string]: VisualChannel};\n\nexport type VisualChannelAggregation = 'colorAggregation' | 'sizeAggregation';\n\nexport type VisualChannel = {\n  property: string;\n  field: string;\n  scale: string;\n  domain: string;\n  range: string;\n  key: string;\n  channelScaleType: string;\n  nullValue?: any;\n  defaultMeasure?: any;\n  accessor?: string;\n  condition?: (config: any) => boolean;\n  getAttributeValue?: (config: any) => (d: any) => any;\n\n  // TODO: define defaultValue\n  defaultValue?: any;\n  // TODO: define fixed\n  fixed?: any;\n\n  supportedFieldTypes?: Array<keyof typeof ALL_FIELD_TYPES>;\n\n  aggregation?: VisualChannelAggregation;\n};\n\nexport type VisualChannelDescription = {\n  label: string;\n  measure: string;\n};\n\nexport type ColumnPairs = {[key: string]: {pair: string; fieldPairKey: string}};\n\ntype ColumnValidator = (column: LayerColumn, columns: LayerColumns, allFields: Field[]) => boolean;\n\nexport type UpdateTriggers = {\n  [key: string]: UpdateTrigger;\n};\nexport type UpdateTrigger = {\n  [key: string]: {};\n};\nexport type LayerBounds = [number, number, number, number];\nexport type FindDefaultLayerPropsReturnValue = {props: any[]; foundLayers?: any[]};\n/**\n * Approx. number of points to sample in a large data set\n */\nexport const LAYER_ID_LENGTH = 6;\n\n// Note, this is is SVG of solid circle encoded as data-uri\nconst FALLBACK_ICON =\n  'data:image/svg+xml;charset=utf-8;base64,PHN2ZyB2aWV3Qm94PSIwIDAgMTAwIDEwMCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4NCiAgPGNpcmNsZSBjeD0iNTAiIGN5PSI1MCIgcj0iNTAiLz4NCjwvc3ZnPg==';\n\nconst MAX_SAMPLE_SIZE = 5000;\nconst defaultDomain: [number, number] = [0, 1];\nconst dataFilterExtension = new DataFilterExtension({filterSize: MAX_GPU_FILTERS});\nconst collisionFilterExtension = new CollisionFilterExtension();\n\nconst defaultDataAccessor = dc => d => d;\nconst defaultGetFieldValue = (field, d) => field.valueAccessor(d);\nconst scaleIdentity = v => v;\n\nexport const OVERLAY_TYPE = keymirror({\n  deckgl: null,\n  mapboxgl: null\n});\n\nexport const layerColors = Object.values(DataVizColors).map(hexToRgb);\nfunction* generateColor(): Generator<RGBColor> {\n  let index = 0;\n  while (index < layerColors.length + 1) {\n    if (index === layerColors.length) {\n      index = 0;\n    }\n    yield layerColors[index++];\n  }\n}\n\nexport const colorMaker = generateColor();\n\nclass Layer {\n  id: string;\n  meta: {};\n  visConfigSettings: {\n    [key: string]: ValueOf<LayerVisConfigSettings>;\n  };\n  config: LayerBaseConfig;\n  // TODO: define _oldDataUpdateTriggers\n  _oldDataUpdateTriggers: any;\n\n  legendSettings: Record<string, unknown>;\n  _interactivitySettings: Record<string, unknown>;\n\n  constructor(\n    props: {\n      id?: string;\n    } & Partial<LayerBaseConfig> = {}\n  ) {\n    this.id = props.id || generateHashId(LAYER_ID_LENGTH);\n    // meta\n    this.meta = {};\n\n    // legendSettings\n    this.legendSettings = {};\n\n    // visConfigSettings\n    this.visConfigSettings = {};\n\n    // interactivitySettings\n    this._interactivitySettings = {};\n\n    this.config = this.getDefaultLayerConfig({\n      columns: this.getLayerColumns(),\n      ...props\n    });\n  }\n\n  get layerIcon(): React.ElementType {\n    return DefaultLayerIcon;\n  }\n\n  get overlayType(): keyof typeof OVERLAY_TYPE {\n    return OVERLAY_TYPE.deckgl;\n  }\n\n  get type(): string | null {\n    return null;\n  }\n\n  get name() {\n    return this.type;\n  }\n\n  get isAggregated() {\n    return false;\n  }\n\n  get requiredLayerColumns(): string[] {\n    return [];\n  }\n\n  get optionalColumns(): string[] {\n    return [];\n  }\n\n  get noneLayerDataAffectingProps() {\n    return ['label', 'opacity', 'thickness', 'isVisible', 'hidden'];\n  }\n\n  get visualChannels(): VisualChannels {\n    return {\n      color: {\n        property: 'color',\n        field: 'colorField',\n        scale: 'colorScale',\n        domain: 'colorDomain',\n        range: 'colorRange',\n        key: 'color',\n        channelScaleType: CHANNEL_SCALES.color,\n        nullValue: NO_VALUE_COLOR,\n        defaultValue: config => config.color\n      },\n      size: {\n        property: 'size',\n        field: 'sizeField',\n        scale: 'sizeScale',\n        domain: 'sizeDomain',\n        range: 'sizeRange',\n        key: 'size',\n        channelScaleType: CHANNEL_SCALES.size,\n        nullValue: 0,\n        defaultValue: 1\n      }\n    };\n  }\n\n  get columnValidators(): {[key: string]: ColumnValidator} {\n    return {};\n  }\n  /*\n   * Column pairs maps layer column to a specific field pairs,\n   * By default, it is set to null\n   */\n  get columnPairs(): ColumnPairs | null {\n    return null;\n  }\n\n  /*\n   * Default point column pairs, can be used for point based layers: point, icon etc.\n   */\n  get defaultPointColumnPairs(): ColumnPairs {\n    return {\n      lat: {pair: 'lng', fieldPairKey: 'lat'},\n      lng: {pair: 'lat', fieldPairKey: 'lng'}\n    };\n  }\n\n  /*\n   * Default link column pairs, can be used for link based layers: arc, line etc\n   */\n  get defaultLinkColumnPairs(): ColumnPairs {\n    return {\n      lat0: {pair: 'lng0', fieldPairKey: 'lat'},\n      lng0: {pair: 'lat0', fieldPairKey: 'lng'},\n      lat1: {pair: 'lng1', fieldPairKey: 'lat'},\n      lng1: {pair: 'lat1', fieldPairKey: 'lng'}\n    };\n  }\n\n  /**\n   * Return a React component for to render layer instructions in a modal\n   * @returns {object} - an object\n   * @example\n   *  return {\n   *    id: 'iconInfo',\n   *    template: IconInfoModal,\n   *    modalProps: {\n   *      title: 'How to draw icons'\n   *   };\n   * }\n   */\n  get layerInfoModal(): any {\n    return null;\n  }\n\n  get interactivitySettings() {\n    return (this as any)._interactivitySettings;\n  }\n\n  set interactivitySettings(interactivitySettings) {\n    (this as any)._interactivitySettings = interactivitySettings;\n  }\n\n  get hasTooltip() {\n    return Boolean(\n      this.interactivitySettings?.hover?.fields.length ||\n        this.interactivitySettings?.click?.fields.length\n    );\n  }\n\n  get hasInteractivity() {\n    return Boolean(this.hasTooltip && this.interactivitySettings?.enabled);\n  }\n\n  /*\n   * Given a dataset, automatically find props to create layer based on it\n   * and return the props and previous found layers.\n   * By default, no layers will be found\n   */\n  static findDefaultLayerProps(\n    dataset: KeplerTable,\n    foundLayers?: any[]\n  ): FindDefaultLayerPropsReturnValue {\n    return {props: [], foundLayers};\n  }\n\n  /**\n   * Given a array of preset required column names\n   * found field that has the same name to set as layer column\n   *\n   * @param {object} defaultFields\n   * @param {object[]} allFields\n   * @returns {object[] | null} all possible required layer column pairs\n   */\n  static findDefaultColumnField(defaultFields, allFields) {\n    // find all matched fields for each required col\n    const requiredColumns = Object.keys(defaultFields).reduce((prev, key) => {\n      const requiredFields = allFields.filter(\n        f => f.name === defaultFields[key] || defaultFields[key].includes(f.name)\n      );\n\n      prev[key] = requiredFields.length\n        ? requiredFields.map(f => ({\n            value: f.name,\n            fieldIdx: f.fieldIdx\n          }))\n        : null;\n      return prev;\n    }, {});\n\n    if (!Object.values(requiredColumns).every(Boolean)) {\n      // if any field missing, return null\n      return null;\n    }\n\n    return this.getAllPossibleColumnParis(requiredColumns);\n  }\n\n  static getAllPossibleColumnParis(requiredColumns) {\n    // for multiple matched field for one required column, return multiple\n    // combinations, e. g. if column a has 2 matched, column b has 3 matched\n    // 6 possible column pairs will be returned\n    const allKeys = Object.keys(requiredColumns);\n    const pointers = allKeys.map((k, i) => (i === allKeys.length - 1 ? -1 : 0));\n    const countPerKey = allKeys.map(k => requiredColumns[k].length);\n    // TODO: Better typings\n    const pairs: any[] = [];\n\n    /* eslint-disable no-loop-func */\n    while (incrementPointers(pointers, countPerKey, pointers.length - 1)) {\n      const newPair = pointers.reduce((prev, cuur, i) => {\n        prev[allKeys[i]] = requiredColumns[allKeys[i]][cuur];\n        return prev;\n      }, {});\n\n      pairs.push(newPair);\n    }\n    /* eslint-enable no-loop-func */\n\n    // recursively increment pointers\n    function incrementPointers(pts, counts, index) {\n      if (index === 0 && pts[0] === counts[0] - 1) {\n        // nothing to increment\n        return false;\n      }\n\n      if (pts[index] + 1 < counts[index]) {\n        pts[index] = pts[index] + 1;\n        return true;\n      }\n\n      pts[index] = 0;\n      return incrementPointers(pts, counts, index - 1);\n    }\n\n    return pairs;\n  }\n\n  static hexToRgb(c) {\n    return hexToRgb(c);\n  }\n\n  getDefaultLayerConfig(\n    props: Partial<LayerBaseConfig> = {}\n  ): LayerBaseConfig & Partial<LayerColorConfig & LayerSizeConfig> {\n    return {\n      dataId: props.dataId || null,\n      ...{\n        visibilityByZoom: {\n          min: (props as any).visibilityByZoom?.min || ZOOM_LEVEL_LIMITS.min,\n          max: (props as any).visibilityByZoom?.max || ZOOM_LEVEL_LIMITS.max\n        }\n      }, // TODO: Clean up\n      label: props.label || DEFAULT_LAYER_LABEL,\n      color: props.color || colorMaker.next().value,\n      columns: props.columns || {},\n      isVisible: props.isVisible || false,\n      isConfigActive: props.isConfigActive || false,\n      highlightColor: props.highlightColor || DEFAULT_HIGHLIGHT_COLOR,\n      hidden: props.hidden || false,\n\n      // TODO: refactor this into separate visual Channel config\n      // color by field, domain is set by filters, field, scale type\n      colorField: null,\n      colorDomain: [0, 1],\n      colorScale: SCALE_TYPES.quantile,\n\n      // color by size, domain is set by filters, field, scale type\n      sizeDomain: [0, 1],\n      sizeScale: SCALE_TYPES.linear,\n      sizeField: null,\n      ...{radiusField: null}, // TODO: Clean up\n\n      visConfig: {},\n\n      textLabel: [DEFAULT_TEXT_LABEL],\n\n      colorUI: {\n        color: DEFAULT_COLOR_UI,\n        colorRange: DEFAULT_COLOR_UI\n      },\n      animation: {enabled: false}\n    };\n  }\n\n  /**\n   * Get the description of a visualChannel config\n   * @param key\n   * @returns\n   */\n  getVisualChannelDescription(key: string): VisualChannelDescription {\n    // e.g. label: Color, measure: Vehicle Type\n    const channel = this.visualChannels[key];\n    if (!channel) return {label: '', measure: ''};\n    const rangeSettings = this.visConfigSettings[channel.range];\n    const fieldSettings = this.config[channel.field];\n    const label = rangeSettings?.label;\n    return {\n      label: typeof label === 'function' ? label(this.config) : label,\n      measure: fieldSettings\n        ? fieldSettings.displayName || fieldSettings.name\n        : channel.defaultMeasure\n    };\n  }\n\n  /**\n   * Assign a field to layer column, return column config\n   * @param key - Column Key\n   * @param field - Selected field\n   * @returns {{}} - Column config\n   */\n  assignColumn(key: string, field: Field): LayerColumns {\n    // field value could be null for optional columns\n    const update = field\n      ? {\n          value: field.name,\n          fieldIdx: field.fieldIdx\n        }\n      : {value: null, fieldIdx: -1};\n\n    return {\n      ...this.config.columns,\n      [key]: {\n        ...this.config.columns[key],\n        ...update\n      }\n    };\n  }\n\n  /**\n   * Assign a field pair to column config, return column config\n   * @param key - Column Key\n   * @param pair - field Pair\n   * @returns {object} - Column config\n   */\n  assignColumnPairs(key, pair) {\n    if (!this.columnPairs || !this.columnPairs?.[key]) {\n      // should not end in this state\n      return this.config.columns;\n    }\n\n    const {pair: partnerKey, fieldPairKey} = this.columnPairs?.[key];\n    const {fieldPairKey: partnerFieldPairKey} = this.columnPairs?.[partnerKey];\n\n    return {\n      ...this.config.columns,\n      [key]: pair[fieldPairKey],\n      [partnerKey]: pair[partnerFieldPairKey]\n    };\n  }\n\n  /**\n   * Calculate a radius zoom multiplier to render points, so they are visible in all zoom level\n   * @param {object} mapState\n   * @param {number} mapState.zoom - actual zoom\n   * @param {number | void} mapState.zoomOffset - zoomOffset when render in the plot container for export image\n   * @returns {number}\n   */\n  getZoomFactor({zoom, zoomOffset = 0}) {\n    return Math.pow(2, Math.max(14 - zoom + zoomOffset, 0));\n  }\n\n  /**\n   * Calculate a elevation zoom multiplier to render points, so they are visible in all zoom level\n   * @param {object} mapState\n   * @param {number} mapState.zoom - actual zoom\n   * @param {number | void} mapState.zoomOffset - zoomOffset when render in the plot container for export image\n   * @returns {number}\n   */\n  getElevationZoomFactor({zoom, zoomOffset = 0}: {zoom: number; zoomOffset?: number}) {\n    return this.config.visConfig.enableElevationZoomFactor\n      ? Math.pow(2, Math.max(8 - zoom + zoomOffset, 0))\n      : 1;\n  }\n\n  formatLayerData(datasets: Datasets, oldLayerData?: any) {\n    return {};\n  }\n\n  renderLayer(...args: any[]): any[] {\n    return [];\n  }\n\n  getHoverData(object, dataContainer: DataContainerInterface, fields: Field[]) {\n    if (!object) {\n      return null;\n    }\n\n    // By default, each entry of layerData should have an index of a row in the original data container.\n    // Each layer can implement its own getHoverData method\n    return dataContainer.row(object.index);\n  }\n\n  /**\n   * When change layer type, try to copy over layer configs as much as possible\n   * @param configToCopy - config to copy over\n   * @param visConfigSettings - visConfig settings of config to copy\n   */\n  assignConfigToLayer(configToCopy, visConfigSettings) {\n    // don't deep merge visualChannel field\n    // don't deep merge color range, reversed: is not a key by default\n    const shallowCopy = ['colorRange', 'strokeColorRange'].concat(\n      Object.values(this.visualChannels).map(v => v.field)\n    );\n\n    // don't copy over domain and animation\n    const notToCopy = ['animation'].concat(Object.values(this.visualChannels).map(v => v.domain));\n    // if range is for the same property group copy it, otherwise, not to copy\n    Object.values(this.visualChannels).forEach(v => {\n      if (\n        configToCopy.visConfig[v.range] &&\n        this.visConfigSettings[v.range] &&\n        visConfigSettings[v.range].group !== this.visConfigSettings[v.range].group\n      ) {\n        notToCopy.push(v.range);\n      }\n    });\n\n    // don't copy over visualChannel range\n    const currentConfig = this.config;\n    const copied = this.copyLayerConfig(currentConfig, configToCopy, {\n      shallowCopy,\n      notToCopy\n    });\n    this.updateLayerConfig(copied);\n    // validate visualChannel field type and scale types\n    Object.keys(this.visualChannels).forEach(channel => {\n      this.validateVisualChannel(channel);\n    });\n  }\n\n  /*\n   * Recursively copy config over to an empty layer\n   * when received saved config, or copy config over from a different layer type\n   * make sure to only copy over value to existing keys\n   * @param {object} currentConfig - existing config to be override\n   * @param {object} configToCopy - new Config to copy over\n   * @param {string[]} shallowCopy - array of properties to not to be deep copied\n   * @param {string[]} notToCopy - array of properties not to copy\n   * @returns {object} - copied config\n   */\n  copyLayerConfig(\n    currentConfig,\n    configToCopy,\n    {shallowCopy = [], notToCopy = []}: {shallowCopy?: string[]; notToCopy?: string[]} = {}\n  ) {\n    const copied = {};\n    Object.keys(currentConfig).forEach(key => {\n      if (\n        isPlainObject(currentConfig[key]) &&\n        isPlainObject(configToCopy[key]) &&\n        !shallowCopy.includes(key) &&\n        !notToCopy.includes(key)\n      ) {\n        // recursively assign object value\n        copied[key] = this.copyLayerConfig(currentConfig[key], configToCopy[key], {\n          shallowCopy,\n          notToCopy\n        });\n      } else if (notNullorUndefined(configToCopy[key]) && !notToCopy.includes(key)) {\n        // copy\n        copied[key] = configToCopy[key];\n      } else {\n        // keep existing\n        copied[key] = currentConfig[key];\n      }\n    });\n\n    return copied;\n  }\n\n  registerVisConfig(layerVisConfigs: {\n    [key: string]: keyof LayerVisConfigSettings | ValueOf<LayerVisConfigSettings>;\n  }) {\n    Object.keys(layerVisConfigs).forEach(item => {\n      const configItem = layerVisConfigs[item];\n      if (typeof configItem === 'string' && LAYER_VIS_CONFIGS[configItem]) {\n        // if assigned one of default LAYER_CONFIGS\n        this.config.visConfig[item] = LAYER_VIS_CONFIGS[configItem].defaultValue;\n        this.visConfigSettings[item] = LAYER_VIS_CONFIGS[configItem];\n      } else if (\n        typeof configItem === 'object' &&\n        ['type', 'defaultValue'].every(p => configItem.hasOwnProperty(p))\n      ) {\n        // if provided customized visConfig, and has type && defaultValue\n        // TODO: further check if customized visConfig is valid\n        this.config.visConfig[item] = configItem.defaultValue;\n        this.visConfigSettings[item] = configItem;\n      }\n    });\n  }\n\n  getLayerColumns() {\n    const columnValidators = this.columnValidators;\n    const required = this.requiredLayerColumns.reduce(\n      (accu, key) => ({\n        ...accu,\n        [key]: columnValidators[key]\n          ? {value: null, fieldIdx: -1, validator: columnValidators[key]}\n          : {value: null, fieldIdx: -1}\n      }),\n      {}\n    );\n    const optional = this.optionalColumns.reduce(\n      (accu, key) => ({\n        ...accu,\n        [key]: {value: null, fieldIdx: -1, optional: true}\n      }),\n      {}\n    );\n\n    return {...required, ...optional};\n  }\n\n  updateLayerConfig<LayerConfig extends LayerBaseConfig = LayerBaseConfig>(\n    newConfig: Partial<LayerConfig>\n  ): Layer {\n    this.config = {...this.config, ...newConfig};\n    return this;\n  }\n\n  updateLayerVisConfig(newVisConfig) {\n    this.config.visConfig = {...this.config.visConfig, ...newVisConfig};\n    return this;\n  }\n\n  updateLayerColorUI(prop: string, newConfig: NestedPartial<ColorUI>): Layer {\n    const {colorUI: previous, visConfig} = this.config;\n\n    if (!isPlainObject(newConfig) || typeof prop !== 'string') {\n      return this;\n    }\n\n    const colorUIProp = Object.entries(newConfig).reduce((accu, [key, value]) => {\n      return {\n        ...accu,\n        [key]: isPlainObject(accu[key]) && isPlainObject(value) ? {...accu[key], ...value} : value\n      };\n    }, previous[prop] || DEFAULT_COLOR_UI);\n\n    const colorUI = {\n      ...previous,\n      [prop]: colorUIProp\n    };\n\n    this.updateLayerConfig({colorUI});\n    // if colorUI[prop] is colorRange. If type is hexColor then it's also a range\n    const isColorRange =\n      visConfig[prop] && (visConfig[prop].colors || visConfig[prop].type === hexColor);\n\n    if (isColorRange) {\n      this.updateColorUIByColorRange(newConfig, prop);\n      this.updateColorRangeByColorUI(newConfig, previous, prop);\n      this.updateCustomPalette(newConfig, previous, prop);\n    }\n\n    return this;\n  }\n\n  updateCustomPalette(newConfig, previous, prop) {\n    if (!newConfig.colorRangeConfig || !newConfig.colorRangeConfig.custom) {\n      return;\n    }\n\n    const {colorUI, visConfig} = this.config;\n\n    if (!visConfig[prop]) return;\n    const {colors} = visConfig[prop];\n    const customPalette = {\n      ...colorUI[prop].customPalette,\n      name: 'Custom Palette',\n      colors: [...colors]\n    };\n    this.updateLayerConfig({\n      colorUI: {\n        ...colorUI,\n        [prop]: {\n          ...colorUI[prop],\n          customPalette\n        }\n      }\n    });\n  }\n  /**\n   * if open dropdown and prop is color range\n   * Automatically set colorRangeConfig's step, reversed and type\n   * @param {*} newConfig\n   * @param {*} prop\n   */\n  updateColorUIByColorRange(newConfig, prop) {\n    if (typeof newConfig.showDropdown !== 'number') return;\n\n    const {colorUI, visConfig} = this.config;\n    this.updateLayerConfig({\n      colorUI: {\n        ...colorUI,\n        [prop]: {\n          ...colorUI[prop],\n          colorRangeConfig: {\n            ...colorUI[prop].colorRangeConfig,\n            type: visConfig[prop].type,\n            steps: visConfig[prop].colors?.length,\n            reversed: Boolean(visConfig[prop].reversed),\n            hexColumn: this.getHexColumn(prop),\n            isHexColumn: this.isColoredByColorColumn(prop)\n          }\n        }\n      }\n    });\n  }\n\n  // eslint-disable-next-line complexity\n  updateColorRangeByColorUI(newConfig, previous, prop) {\n    // only update colorRange if changes in UI is made to 'reversed', 'steps' or steps\n    const shouldUpdate =\n      newConfig.colorRangeConfig &&\n      ['reversed', 'steps'].some(\n        key =>\n          newConfig.colorRangeConfig.hasOwnProperty(key) &&\n          newConfig.colorRangeConfig[key] !==\n            (previous[prop] || DEFAULT_COLOR_UI).colorRangeConfig[key]\n      );\n    if (!shouldUpdate) return;\n\n    const {colorUI, visConfig} = this.config;\n    const {steps, reversed} = colorUI[prop].colorRangeConfig;\n    const colorRange = visConfig[prop];\n    // find based on step or reversed\n    let update;\n    if (newConfig.colorRangeConfig.hasOwnProperty('steps')) {\n      const group = getColorGroupByName(colorRange);\n\n      if (group) {\n        const sameGroup = COLOR_RANGES.filter(cr => getColorGroupByName(cr) === group);\n\n        update = sameGroup.find(cr => cr.colors.length === steps);\n\n        if (update && colorRange.reversed) {\n          update = reverseColorRange(true, update);\n        }\n\n        if (update && colorRange.colorMap) {\n          update = this.updateColorMap(prop, colorRange.colorMap, update);\n        }\n      }\n    }\n\n    if (newConfig.colorRangeConfig.hasOwnProperty('reversed')) {\n      update = reverseColorRange(reversed, update || colorRange);\n    }\n\n    if (update) {\n      this.updateLayerVisConfig({[prop]: update});\n    }\n  }\n\n  updateColorMap(prop, colorMap, colorRange) {\n    // @ts-ignore\n    const {field, domain} = Object.values(this.visualChannels).find(value => value.range === prop);\n    const type = this.config[field]?.type;\n\n    if (type === 'string' || type === 'boolean' || type === 'date') {\n      return this.updateCategoryColorMap(colorMap, this.config[domain], colorRange);\n    }\n\n    // If no type or type is not string, boolean or date\n    return this.updateNumericColorMap(colorMap, this.config[domain], colorRange);\n  }\n\n  updateCategoryColorMap(colorMap, domain, colorRange) {\n    const colors = colorRange.colors;\n    const assignedCategories = [];\n    if (colorRange.type === hexColor) {\n      return {\n        ...colorRange,\n        colorMap: []\n      };\n    }\n    const newColorMap = colorMap.slice(0, colors.length).map((cMap, index) => {\n      assignedCategories.push(cMap[0]);\n      return [cMap[0], colors[index]];\n    });\n    const unassignedColors = colors.slice(newColorMap.length, colors.length);\n\n    for (const color of unassignedColors) {\n      const category = domain.find(d => !assignedCategories.includes(d));\n      if (!category) {\n        break;\n      }\n      assignedCategories.push(category);\n      newColorMap.push([category, color]);\n    }\n    return {\n      ...colorRange,\n      colorMap: newColorMap\n    };\n  }\n\n  updateNumericColorMap(colorMap, domain, update) {\n    const colors = update.colors;\n    let newColorMap = colorMap.slice(0, colors.length);\n\n    newColorMap = newColorMap.map((cMap, index) => {\n      const value = index === newColorMap.length - 1 ? null : cMap[0];\n      return [value, colors[index]];\n    });\n    const unassignedColors = colors.slice(newColorMap.length, colors.length);\n\n    if (unassignedColors.length > 0) {\n      const colorMapValues = colorMap.map(c => c[0]).filter(c => typeof c === 'number');\n      const maxValue = Math.max(...colorMapValues, domain[domain.length - 1]);\n      const prevValue = newColorMap[newColorMap.length - 2][0];\n      const step = (maxValue - prevValue) / (unassignedColors.length + 1);\n      newColorMap[newColorMap.length - 1][0] = prevValue + step;\n\n      for (const [i, color] of unassignedColors.entries()) {\n        const value = i === unassignedColors.length - 1 ? null : prevValue + step * (i + 2);\n        newColorMap.push([value, color]);\n      }\n    }\n    return {\n      ...update,\n      colorMap: newColorMap\n    };\n  }\n\n  /**\n   * Check whether layer has all columns\n   * @returns yes or no\n   */\n  hasAllColumns(): boolean {\n    const {columns} = this.config;\n    return (\n      columns &&\n      Object.values(columns).every(v => {\n        return Boolean(v.optional || (v.value && v.fieldIdx > -1));\n      })\n    );\n  }\n\n  /**\n   * Check whether layer has data\n   *\n   * @param {Array | Object} layerData\n   * @returns {boolean} yes or no\n   */\n  hasLayerData(layerData) {\n    if (!layerData) {\n      return false;\n    }\n    return Boolean(layerData.data && layerData.data.length);\n  }\n\n  isValidToSave(): boolean {\n    return Boolean(this.type && this.hasAllColumns());\n  }\n\n  shouldRenderLayer(data): boolean {\n    return (\n      Boolean(this.type) &&\n      this.hasAllColumns() &&\n      this.hasLayerData(data) &&\n      typeof this.renderLayer === 'function'\n    );\n  }\n\n  getColorScale(colorScale: string, colorDomain: VisualChannelDomain, colorRange: ColorRange) {\n    if (colorRange.type === hexColor) {\n      return (_, color) => {\n        const {r, g, b} = rgb(color);\n        return [r, g, b].some(isNaN) ? UNKNOWN_COLOR : [r, g, b];\n      };\n    } else if (Array.isArray(colorRange.colorMap)) {\n      const cMap = new Map();\n      colorRange.colorMap.forEach(([k, v]) => {\n        cMap.set(k, typeof v === 'string' ? hexToRgb(v) : v);\n      });\n\n      const scale = SCALE_FUNC[colorScale]()\n        .domain(cMap.keys())\n        .range(cMap.values())\n        .unknown(UNKNOWN_COLOR);\n      return scale;\n    }\n    return this.getVisChannelScale(colorScale, colorDomain, colorRange.colors.map(hexToRgb));\n  }\n\n  getCustomMarkersScale(range, fallbackIcon) {\n    let unknownValue = fallbackIcon || FALLBACK_ICON;\n    if (!range) {\n      return () => unknownValue;\n    }\n\n    const mapping = new Map();\n\n    if (range.othersMarker) {\n      unknownValue = range.othersMarker;\n    }\n    for (const {value, markerUrl} of range.markerMap) {\n      if (markerUrl) {\n        mapping.set(value, markerUrl);\n      }\n    }\n\n    // @ts-ignore d3 scale\n    const scale = scaleOrdinal()\n      .domain(Array.from(mapping.keys()))\n      .range(Array.from(mapping.values()))\n      .unknown(unknownValue);\n    return scale;\n  }\n\n  /**\n   * Mapping from visual channels to deck.gl accesors\n   * @param {Object} param Parameters\n   * @param {Function} param.dataAccessor Access kepler.gl layer data from deck.gl layer\n   * @param {import('utils/table-utils/data-container-interface').DataContainerInterface} param.dataContainer DataContainer to use use with dataAccessor\n   * @return {Object} attributeAccessors - deck.gl layer attribute accessors\n   */\n  getAttributeAccessors({\n    dataAccessor = defaultDataAccessor,\n    dataContainer\n  }: {\n    dataAccessor?: typeof defaultDataAccessor;\n    dataContainer: DataContainerInterface;\n  }) {\n    const attributeAccessors: {[key: string]: any} = {};\n\n    // eslint-disable-next-line complexity\n    Object.keys(this.visualChannels).forEach(channel => {\n      const {\n        field,\n        fixed,\n        scale,\n        domain,\n        range,\n        accessor,\n        defaultValue,\n        getAttributeValue,\n        nullValue,\n        channelScaleType,\n        aggregation\n      } = this.visualChannels[channel];\n\n      const shouldGetScale = Boolean(\n        (scale || channelScaleType === CHANNEL_SCALES.identity) && this.config[field]\n      );\n\n      if (shouldGetScale) {\n        const isFixed = fixed && this.config.visConfig[fixed];\n        // It's important to declare as const all the parameters that we are going to be use in the getEncodedChannelValue call\n        // otherwise, the oldLayerData parameter in formatLayerData method will be wrong (you can check the formatLayerData TileLayer method in Builder as example)\n        const fieldConfig = this.config[field];\n        const aggregationValue = this.config.visConfig[aggregation];\n\n        const scaleFunction =\n          channelScaleType === CHANNEL_SCALES.identity\n            ? scaleIdentity\n            : channelScaleType === CHANNEL_SCALES.color\n            ? this.getColorScale(\n                this.config[scale],\n                this.config[domain],\n                this.config.visConfig[range]\n              )\n            : channelScaleType === CHANNEL_SCALES.customMarker\n            ? this.getCustomMarkersScale(\n                this.config.visConfig[range],\n                this.config.visConfig.customMarkersUrl\n              )\n            : this.getVisChannelScale(\n                this.config[scale],\n                this.config[domain],\n                this.config.visConfig[range],\n                isFixed\n              );\n\n        attributeAccessors[accessor] = d =>\n          this.getEncodedChannelValue({\n            channel,\n            dataContainer,\n            scale: scaleFunction,\n            data: dataAccessor(dataContainer)(d),\n            field: fieldConfig,\n            aggregation: aggregationValue,\n            nullValue\n          });\n      } else if (typeof getAttributeValue === 'function') {\n        attributeAccessors[accessor] = getAttributeValue(this.config);\n      } else {\n        attributeAccessors[accessor] =\n          typeof defaultValue === 'function' ? defaultValue(this.config) : defaultValue;\n      }\n\n      if (!(accessor in attributeAccessors)) {\n        Console.warn(`Failed to provide accessor function for ${accessor || channel}`);\n      }\n    });\n\n    return attributeAccessors;\n  }\n\n  getVisChannelScale(\n    scale: string,\n    domain: VisualChannelDomain,\n    range: any,\n    fixed?: boolean\n  ): () => any | null {\n    if (scale === SCALE_TYPES.ordinal) {\n      return SCALE_FUNC[scale]()\n        .domain(domain.slice(0, range.length) as any)\n        .range(range)\n        .unknown(UNKNOWN_COLOR) as any;\n    }\n\n    // for `count` aggregation, we domain is actually `[0, Infinity]` so it doesn't make sense\n    // to use it, so skip specyfying this domains\n    const domainIsInfinite = domain && domain[0] === 0 && domain[1] === Infinity;\n    const scaleFactory = SCALE_FUNC[fixed ? 'linear' : scale];\n    // @ts-ignore d3-scale type\n    let result = scaleFactory();\n    if (domain && !domainIsInfinite) {\n      result = result.domain(domain);\n    }\n    return result.range(fixed ? domain : range);\n  }\n\n  /**\n   * Get longitude and latitude bounds of the data.\n   * @param {import('utils/table-utils/data-container-interface').DataContainerInterface} dataContainer DataContainer to calculate bounds for.\n   * @param {(d: {index: number}, dc: import('utils/table-utils/data-container-interface').DataContainerInterface) => number[]} getPosition Access kepler.gl layer data from deck.gl layer\n   * @return {number[]|null} bounds of the data.\n   */\n  getPointsBounds(dataContainer, getPosition) {\n    // no need to loop through the entire dataset\n    // get a sample of data to calculate bounds\n    const sampleData =\n      dataContainer.numRows() > MAX_SAMPLE_SIZE\n        ? getSampleData(dataContainer, MAX_SAMPLE_SIZE)\n        : dataContainer;\n\n    const points = sampleData.mapIndex(getPosition);\n\n    const latBounds = getLatLngBounds(points, 1, [-90, 90]);\n    const lngBounds = getLatLngBounds(points, 0, [-180, 180]);\n\n    if (!latBounds || !lngBounds) {\n      return null;\n    }\n\n    return [lngBounds[0], latBounds[0], lngBounds[1], latBounds[1]];\n  }\n\n  getChangedTriggers(dataUpdateTriggers) {\n    const triggerChanged = diffUpdateTriggers(dataUpdateTriggers, this._oldDataUpdateTriggers);\n    this._oldDataUpdateTriggers = dataUpdateTriggers;\n\n    return triggerChanged;\n  }\n\n  getEncodedChannelValue({\n    channel,\n    scale,\n    data,\n    field,\n    dataContainer,\n    // In builder we overwrite the getValue function and we use the _aggregation parameter in spatial index layers as the QuadkeyLayer.\n    aggregation,\n    nullValue = NO_VALUE_COLOR as RGBAColor,\n    getValue = defaultGetFieldValue\n  }: {\n    channel: string;\n    scale: (...value) => any;\n    data: any[];\n    field: VisualChannelField;\n    dataContainer: any;\n    aggregation: any;\n    nullValue?: RGBAColor;\n    getValue?: typeof defaultGetFieldValue;\n  }) {\n    const {type} = field;\n    const value = getValue(field, data);\n    const channelConfig = this.config.visConfig[this.visualChannels[channel].range];\n    const channelField = this.config[this.visualChannels[channel].field];\n    let colorColumnValue: any;\n\n    if (channelConfig?.type === hexColor) {\n      const columnField = {\n        id: channelField.colorColumn,\n        name: channelField.colorColumn,\n        fieldIdx: channelField.colorColumnIdx,\n        valueAccessor: d => {\n          return dataContainer.valueAt(d.index, channelField.colorColumnIdx);\n        }\n      };\n\n      colorColumnValue = getValue(columnField, data);\n    } else if (!notNullorUndefined(value)) {\n      return nullValue;\n    }\n\n    let attributeValue;\n    if (type === ALL_FIELD_TYPES.timestamp) {\n      // shouldn't need to convert here\n      // scale Function should take care of it\n      attributeValue = scale(new Date(value), colorColumnValue);\n    } else {\n      attributeValue = scale(value, colorColumnValue);\n    }\n\n    if (!notNullorUndefined(attributeValue)) {\n      attributeValue = nullValue;\n    }\n\n    return attributeValue;\n  }\n\n  updateMeta(meta) {\n    this.meta = {...this.meta, ...meta};\n  }\n\n  updateLayerLegend(settings) {\n    (this as any).legendSettings = settings;\n  }\n\n  // @ts-expect-error\n  getDataUpdateTriggers({filteredIndex, id, allData}: KeplerTable): any {\n    const {columns} = this.config;\n\n    return {\n      getData: {datasetId: id, allData, columns, filteredIndex},\n      getMeta: {datasetId: id, allData, columns},\n      ...(this.config.textLabel || []).reduce(\n        (accu, tl, i) => ({\n          ...accu,\n          [`getLabelCharacterSet-${i}`]: tl.field ? tl.field.name : null\n        }),\n        {}\n      )\n    };\n  }\n\n  updateData(datasets, oldLayerData) {\n    if (!this.config.dataId) {\n      return {};\n    }\n    const dataset = this.getDataset(datasets);\n    const {dataContainer} = dataset;\n\n    this.updateVisualChannelFields(dataset);\n    this.updateHexColorDomain(dataset);\n\n    const getPosition = this.getPositionAccessor(dataContainer);\n    const dataUpdateTriggers = this.getDataUpdateTriggers(dataset);\n    const triggerChanged = this.getChangedTriggers(dataUpdateTriggers);\n\n    if (triggerChanged && triggerChanged.getMeta) {\n      this.updateLayerMeta(dataContainer, getPosition);\n    }\n\n    let data = [];\n\n    if (!(triggerChanged && triggerChanged.getData) && oldLayerData && oldLayerData.data) {\n      // same data\n      data = oldLayerData.data;\n    } else {\n      data = this.calculateDataAttribute(dataset, getPosition);\n    }\n\n    return {data, triggerChanged};\n  }\n\n  /**\n   * Update styled fields to match ones from new dataset.\n   *\n   * @param {Object} dataset\n   */\n  updateVisualChannelFields(dataset) {\n    for (const {field, range} of Object.values(this.visualChannels)) {\n      const oldField = this.config[field];\n      const isUsingHexColorCode = this.config.visConfig[range]?.hexColor;\n      if (!oldField) {\n        return;\n      }\n      let newDataSetField = dataset.fields.find(fd => fd.name === oldField.name) || null;\n      if (isUsingHexColorCode) {\n        newDataSetField = {\n          ...newDataSetField,\n          colorColumn: newDataSetField.colorColumn || oldField.colorColumn,\n          colorColumnIdx: newDataSetField.colorColumnIdx || oldField.colorColumnIdx\n        };\n      }\n      this.updateLayerConfig({[field]: newDataSetField});\n    }\n  }\n\n  /**\n   * helper function to update one layer domain when state.data changed\n   * if state.data change is due ot update filter, newFiler will be passed\n   * called by updateAllLayerDomainData\n   * @param datasets\n   * @param newFilter\n   * @returns layer\n   */\n  updateLayerDomain(datasets: Datasets, newFilter?: Filter): Layer {\n    const table = this.getDataset(datasets);\n    if (!table) {\n      return this;\n    }\n    Object.values(this.visualChannels).forEach(channel => {\n      const {scale} = channel;\n      const scaleType = this.config[scale];\n\n      // ordinal domain is based on dataContainer, if only filter changed\n      // no need to update ordinal domain\n      if (!newFilter || scaleType !== SCALE_TYPES.ordinal) {\n        const {domain} = channel;\n        const updatedDomain = this.calculateLayerDomain(table, channel);\n        this.updateLayerConfig({[domain]: updatedDomain});\n      }\n    });\n\n    return this;\n  }\n\n  getDataset(datasets) {\n    return this.config.dataId ? datasets[this.config.dataId] : null;\n  }\n\n  /**\n   * Validate visual channel field and scales based on supported field & scale type\n   * @param channel\n   */\n  validateVisualChannel(channel: string) {\n    this.validateFieldType(channel);\n    this.validateScale(channel);\n  }\n\n  /**\n   * Validate field type based on channelScaleType\n   */\n  validateFieldType(channel: string) {\n    const visualChannel = this.visualChannels[channel];\n    const {field, channelScaleType, supportedFieldTypes} = visualChannel;\n\n    if (this.config[field]) {\n      // if field is selected, check if field type is supported\n      const channelSupportedFieldTypes =\n        supportedFieldTypes || CHANNEL_SCALE_SUPPORTED_FIELDS[channelScaleType];\n\n      if (!channelSupportedFieldTypes.includes(this.config[field].type)) {\n        // field type is not supported, set it back to null\n        // set scale back to default\n        this.updateLayerConfig({[field]: null});\n      }\n    }\n  }\n\n  /**\n   * Validate scale type based on aggregation\n   */\n  validateScale(channel) {\n    const visualChannel = this.visualChannels[channel];\n    const {scale, range} = visualChannel;\n    if (\n      !scale ||\n      (this.isColoredByColorColumn(range) && this.config[scale] === SCALE_TYPES.identity)\n    ) {\n      // visualChannel doesn't have scale\n      return;\n    }\n    const scaleOptions = this.getScaleOptions(channel);\n    // check if current selected scale is\n    // supported, if not, change to default\n    if (!scaleOptions.includes(this.config[scale])) {\n      this.updateLayerConfig({[scale]: scaleOptions[0]});\n    }\n  }\n\n  /**\n   * Get scale options based on current field\n   * @param {string} channel\n   * @returns {string[]}\n   */\n  getScaleOptions(channel) {\n    const visualChannel = this.visualChannels[channel];\n    const {field, scale, channelScaleType} = visualChannel;\n\n    return this.config[field]\n      ? FIELD_OPTS[this.config[field].type].scale[channelScaleType]\n      : [this.getDefaultLayerConfig()[scale]];\n  }\n\n  updateLayerVisualChannel(dataset: KeplerTable, channel: string) {\n    const visualChannel = this.visualChannels[channel];\n    this.validateVisualChannel(channel);\n    // calculate layer channel domain\n    const updatedDomain = this.calculateLayerDomain(dataset, visualChannel);\n    this.updateLayerConfig({[visualChannel.domain]: updatedDomain});\n  }\n\n  getVisualChannelUpdateTriggers(): UpdateTriggers {\n    const updateTriggers: UpdateTriggers = {};\n    Object.values(this.visualChannels).forEach(visualChannel => {\n      // field range scale domain\n      const {accessor, field, scale, domain, range, defaultValue, fixed} = visualChannel;\n\n      if (accessor) {\n        updateTriggers[accessor] = {\n          [field]: this.config[field],\n          [scale]: this.config[scale],\n          [domain]: this.config[domain],\n          [range]: this.config.visConfig[range],\n          defaultValue:\n            typeof defaultValue === 'function' ? defaultValue(this.config) : defaultValue,\n          ...(fixed ? {[fixed]: this.config.visConfig[fixed]} : {})\n        };\n      }\n    });\n    return updateTriggers;\n  }\n\n  calculateLayerDomain(dataset, visualChannel) {\n    const {scale} = visualChannel;\n    const field = this.config[visualChannel.field];\n    if (!field || !scale) {\n      // if colorField or sizeField were set back to null\n      return defaultDomain;\n    }\n\n    const scaleType = this.config[scale];\n    const dataSetField = dataset.fields.find(f => f.name === field.name);\n    if (!scaleType || !dataSetField) {\n      // if new dataset doesn't contain previously set field\n      return defaultDomain;\n    }\n\n    return dataset.getColumnLayerDomain(dataSetField, scaleType) || defaultDomain;\n  }\n\n  updateHexColorDomain(dataset) {\n    if (!dataset) {\n      return this;\n    }\n    Object.values(this.visualChannels).forEach(channel => {\n      const channelConfig = this.config.visConfig[channel.range];\n      const field = this.config[channel.field];\n\n      if (channelConfig?.type === hexColor && field?.colorColumn) {\n        const dataSetField = dataset.fields.find(f => f.name === field.colorColumn);\n        const colors = dataset\n          .getColumnLayerDomain(dataSetField, SCALE_TYPES.ordinal)\n          .map(c => checkColorOrFallback(c));\n        this.updateLayerVisConfig({\n          [channel.range]: {...channelConfig, colors}\n        });\n      }\n    });\n\n    return this;\n  }\n\n  calculateHexColumnLegend(datasets) {\n    const dataset = this.getDataset(datasets);\n    if (!datasets) {\n      return;\n    }\n\n    const legendSettings = Object.keys(this.visualChannels).reduce((legends, channel) => {\n      const {range, field: channelField} = this.visualChannels[channel];\n      const channelConfig = this.config.visConfig[range];\n      const field = this.config[channelField];\n\n      if (channelConfig?.type === hexColor && field?.colorColumn) {\n        const dataSetField = dataset.fields.find(f => f.name === field.colorColumn);\n        const legend = dataset.calculateLegend(field, dataSetField);\n        legends[channel] = legend;\n      }\n      return legends;\n    }, {});\n    this.updateLayerLegend(legendSettings);\n  }\n\n  hasHoveredObject(objectInfo) {\n    return this.isLayerHovered(objectInfo) && objectInfo.object ? objectInfo.object : null;\n  }\n\n  isLayerHovered(objectInfo): boolean {\n    return objectInfo?.picked && objectInfo?.layer?.props?.id === this.id;\n  }\n\n  getRadiusScaleByZoom(mapState: MapState, fixedRadius?: boolean) {\n    const radiusChannel = Object.values(this.visualChannels).find(vc => vc.property === 'radius');\n\n    if (!radiusChannel) {\n      return 1;\n    }\n\n    const field = radiusChannel.field;\n    const {radius} = this.config.visConfig;\n\n    // @ts-ignore\n    return (this.config[field] ? 1 : radius) * this.getZoomFactor(mapState);\n  }\n\n  getRadiusScale() {\n    const radiusChannel = Object.values(this.visualChannels).find(vc => vc.property === 'radius');\n\n    if (!radiusChannel || this.config[radiusChannel.field]) {\n      return 1;\n    }\n\n    return this.config.visConfig.radius;\n  }\n\n  getMaxMarkerSize() {\n    const {radiusField, sizeField, visConfig} = this.config as any;\n    const {radiusRange, radius} = visConfig;\n    const field = radiusField || sizeField;\n    return Math.ceil(field && radiusRange ? radiusRange[1] : radius);\n  }\n\n  shouldCalculateLayerData(props: string[]) {\n    return props.some(p => !this.noneLayerDataAffectingProps.includes(p));\n  }\n\n  getBrushingExtensionProps(interactionConfig, brushingTarget?) {\n    const {brush} = interactionConfig;\n\n    return {\n      // brushing\n      autoHighlight: !brush.enabled,\n      brushingRadius: brush.config.size * 1000,\n      brushingTarget: brushingTarget || 'source',\n      brushingEnabled: brush.enabled\n    };\n  }\n\n  getDefaultDeckLayerProps({\n    idx,\n    gpuFilter,\n    mapState,\n    visible,\n    maskPolygon\n  }: {\n    idx: number;\n    gpuFilter: GpuFilter;\n    mapState: MapState;\n    visible: boolean;\n    maskPolygon: any;\n  }) {\n    const maskExtensionProps = getMaskExtensionProps(maskPolygon);\n    return {\n      ...maskExtensionProps,\n      id: this.id,\n      idx,\n      coordinateSystem: COORDINATE_SYSTEM.LNGLAT,\n      pickable: this.hasInteractivity,\n      wrapLongitude: true,\n      parameters: {depthTest: Boolean(mapState.dragRotate || this.config.visConfig.enable3d)},\n      hidden: this.config.hidden,\n      visibilityByZoom: (this.config as any).visibilityByZoom,\n      // visconfig\n      opacity: this.config.visConfig.opacity,\n      highlightColor: this.config.highlightColor,\n      // data filtering\n      extensions: [dataFilterExtension, ...maskExtensionProps.extensions],\n      filterRange: gpuFilter ? gpuFilter.filterRange : undefined,\n      // layer should be visible and if splitMap, shown in to one of panel\n      visible: this.config.isVisible && visible\n    };\n  }\n\n  getDefaultHoverLayerProps() {\n    return {\n      id: `${this.id}-hovered`,\n      pickable: false,\n      wrapLongitude: true,\n      coordinateSystem: COORDINATE_SYSTEM.LNGLAT\n    };\n  }\n\n  renderTextLabelLayer(\n    {getPosition, getRadius, radiusScale, updateTriggers, sharedProps},\n    renderOpts\n  ) {\n    const {data} = renderOpts;\n    const {textLabel, visibilityByZoom} = this.config as any;\n    const extensions = [...sharedProps.extensions, collisionFilterExtension];\n\n    if (!data || !data.textLabels || !data.textLabels[0] || !data.textLabels[0].getText) {\n      return [];\n    }\n\n    const [mainLabel, secondaryLabel] = textLabel;\n    const {\n      alignment,\n      anchor,\n      color: getColor,\n      field: mainField,\n      outlineColor,\n      size: sizeScale\n    } = mainLabel;\n    const {\n      color: getSecondaryColor,\n      field: secondaryField,\n      outlineColor: secondaryOutlineColor,\n      size: secondarySizeScale\n    } = secondaryLabel || {};\n\n    return [\n      new PointLabelLayer({\n        ...sharedProps,\n\n        // Recreate layer when labels change otherwise rendering breaks\n        // TODO could be more efficient with updateTriggers?\n        id: `${this.id}-${mainField?.name}-${secondaryField?.name}-label`,\n        data: data.data,\n        visibilityByZoom,\n        extensions,\n\n        characterSet: 'auto',\n        collisionEnabled: true,\n        collisionGroup: `${this.id}-labels`,\n\n        getText: data.textLabels[0].getText,\n        getColor,\n        sizeScale,\n        outlineColor,\n\n        ...(secondaryField && {\n          getSecondaryText: data.textLabels[1].getText,\n          getSecondaryColor,\n          secondarySizeScale,\n          secondaryOutlineColor\n        }),\n\n        // Position\n        getPosition,\n        getRadius,\n        radiusScale,\n        getTextAnchor: anchor,\n        getAlignmentBaseline: alignment,\n\n        // Style\n        fontFamily: 'Inter, sans',\n        fontSettings: {sdf: true},\n        fontWeight: 500,\n        outlineWidth: 4,\n        parameters: {\n          // text will always show on top of all layers\n          depthTest: false\n        },\n\n        getFilterValue: data.getFilterValue,\n        updateTriggers: {\n          ...updateTriggers,\n          getText: mainField?.name,\n          getColor: (mainField as any)?.color,\n          getTextAnchor: mainLabel.anchor,\n          getAlignmentBaseline: mainLabel.alignment,\n          getSecondaryText: secondaryField?.name\n        }\n      })\n    ];\n  }\n\n  /**\n   * Create deck.gl `IconLayer` \"autoPack\" mode accessor for custom markers.\n   *\n   * @param {*} iconUrlAccessor deck.gl accessor (or value) that resolves to URL of icon for given row\n   * @returns deck.gl accessor that returns UnpackedIcon ready to consume by IconLayer\n   */\n  getCustomMarkerIconAccessor(iconUrlAccessor, mask = true) {\n    const maxIconSize = this.getMaxMarkerSize();\n\n    return d => {\n      const wantedUrl =\n        typeof iconUrlAccessor === 'function' ? iconUrlAccessor(d) : iconUrlAccessor;\n      const iconOk = Boolean(wantedUrl);\n      mask = iconOk ? mask : true;\n      const url = iconOk ? wantedUrl : FALLBACK_ICON;\n      return {\n        id: `${url}@@${maxIconSize}@${mask ? 'm' : 'c'}`,\n        url,\n        width: maxIconSize,\n        height: maxIconSize,\n        mask\n      };\n    };\n  }\n\n  calculateDataAttribute(keplerTable: KeplerTable, getPosition): any {\n    // implemented in subclasses\n    return [];\n  }\n\n  updateLayerMeta(dataContainer: DataContainerInterface, getPosition) {\n    // implemented in subclasses\n  }\n\n  getPositionAccessor(dataContainer?: DataContainerInterface): (...args: any[]) => any {\n    // implemented in subclasses\n    return () => null;\n  }\n\n  getHexColumn(range) {\n    const field = Object.values(this.visualChannels)?.find(value => value.range === range)?.field;\n    if (field) {\n      return this.config[field]?.colorColumn;\n    }\n  }\n\n  isColoredByColorColumn(range) {\n    return this.config.visConfig[range]?.hexColor;\n  }\n}\n\nexport default Layer;\n"],"mappings":"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","ignoreList":[]}