@deephaven/chart 0.5.0 → 0.5.2-lessredux.14

package/dist/FigureChartModel.js

@@ -1,49 +1,3 @@
-function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
-
-function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
-
-function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
-
-function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); }
-
-function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
-
-function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
-
-function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
-
-function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
-
-function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
-
-function _iterableToArrayLimit(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
-
-function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
-
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
-
-function _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get(target, property, receiver || target); }
-
-function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
-
-function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
-
-function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
-
-function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
-
-function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
-
-function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
-
-function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
-
 function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 
 /* eslint class-methods-use-this: "off" */
@@ -51,32 +5,23 @@ import memoize from 'memoizee';
 import debounce from 'lodash.debounce';
 import dh from '@deephaven/jsapi-shim';
 import Log from '@deephaven/log';
-import ChartModel from './ChartModel';
-import ChartUtils from './ChartUtils';
+import ChartModel from "./ChartModel.js";
+import ChartUtils from "./ChartUtils.js";
 var log = Log.module('FigureChartModel');
 /**
  * Takes a Figure object from a widget to make a model for a chart
  */
 
-var FigureChartModel = /*#__PURE__*/function (_ChartModel) {
-  _inherits(FigureChartModel, _ChartModel);
-
-  var _super = _createSuper(FigureChartModel);
-
+class FigureChartModel extends ChartModel {
   /**
    * @param {dh.plot.Figure} figure The figure object created by the API
    * @param {Object} settings Chart settings
    */
-  function FigureChartModel(figure) {
-    var _this;
-
+  constructor(figure) {
     var settings = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    super();
 
-    _classCallCheck(this, FigureChartModel);
-
-    _this = _super.call(this);
-
-    _defineProperty(_assertThisInitialized(_this), "getTimeZone", memoize(function (columnType, formatter) {
+    _defineProperty(this, "getTimeZone", memoize((columnType, formatter) => {
       if (formatter != null) {
         var dataFormatter = formatter.getColumnTypeFormatter(columnType);
 
@@ -88,606 +33,542 @@ var FigureChartModel = /*#__PURE__*/function (_ChartModel) {
       return null;
     }));
 
-    _defineProperty(_assertThisInitialized(_this), "getValueTranslator", memoize(function (columnType, formatter) {
-      var timeZone = _this.getTimeZone(columnType, formatter);
-
-      return function (value) {
-        return ChartUtils.unwrapValue(value, timeZone);
-      };
+    _defineProperty(this, "getValueTranslator", memoize((columnType, formatter) => {
+      var timeZone = this.getTimeZone(columnType, formatter);
+      return value => ChartUtils.unwrapValue(value, timeZone);
     }));
 
-    _defineProperty(_assertThisInitialized(_this), "getValueParser", memoize(function (columnType, formatter) {
-      var timeZone = _this.getTimeZone(columnType, formatter);
+    _defineProperty(this, "getValueParser", memoize((columnType, formatter) => {
+      var timeZone = this.getTimeZone(columnType, formatter);
+      return value => ChartUtils.wrapValue(value, columnType, timeZone);
+    }));
 
-      return function (value) {
-        return ChartUtils.wrapValue(value, columnType, timeZone);
-      };
+    _defineProperty(this, "getRangeParser", memoize((columnType, formatter) => range => {
+      var [rangeStart, rangeEnd] = range;
+      var valueParser = this.getValueParser(columnType, formatter);
+      rangeStart = valueParser(rangeStart);
+      rangeEnd = valueParser(rangeEnd);
+      return [rangeStart, rangeEnd];
     }));
 
-    _defineProperty(_assertThisInitialized(_this), "getRangeParser", memoize(function (columnType, formatter) {
-      return function (range) {
-        var _range = _slicedToArray(range, 2),
-            rangeStart = _range[0],
-            rangeEnd = _range[1];
+    _defineProperty(this, "getAxisRangeParser", memoize((chart, formatter) => axis => {
+      var source = ChartUtils.getSourceForAxis(chart, axis);
 
-        var valueParser = _this.getValueParser(columnType, formatter);
+      if (source) {
+        return this.getRangeParser(source.columnType, formatter);
+      }
 
-        rangeStart = valueParser(rangeStart);
-        rangeEnd = valueParser(rangeEnd);
-        return [rangeStart, rangeEnd];
-      };
+      return range => range;
     }));
 
-    _defineProperty(_assertThisInitialized(_this), "getAxisRangeParser", memoize(function (chart, formatter) {
-      return function (axis) {
-        var source = ChartUtils.getSourceForAxis(chart, axis);
+    this.handleFigureUpdated = this.handleFigureUpdated.bind(this);
+    this.handleFigureDisconnected = this.handleFigureDisconnected.bind(this);
+    this.handleFigureReconnected = this.handleFigureReconnected.bind(this);
+    this.handleFigureSeriesAdded = this.handleFigureSeriesAdded.bind(this);
+    this.handleDownsampleStart = this.handleDownsampleStart.bind(this);
+    this.handleDownsampleFinish = this.handleDownsampleFinish.bind(this);
+    this.handleDownsampleFail = this.handleDownsampleFail.bind(this);
+    this.handleDownsampleNeeded = this.handleDownsampleNeeded.bind(this);
+    this.handleRequestFailed = this.handleRequestFailed.bind(this); // We need to debounce adding series so we subscribe to them all in the same tick
+    // This should no longer be necessary after IDS-5049 lands
 
-        if (source) {
-          return _this.getRangeParser(source.columnType, formatter);
-        }
+    this.addPendingSeries = debounce(this.addPendingSeries.bind(this), FigureChartModel.ADD_SERIES_DEBOUNCE);
+    this.figure = figure;
+    this.settings = settings;
+    this.data = [];
+    this.layout = ChartUtils.makeDefaultLayout();
+    this.seriesDataMap = new Map();
+    this.pendingSeries = [];
+    this.oneClicks = [];
+    this.filterColumnMap = new Map();
+    this.lastFilter = new Map();
+    this.isConnected = true; // Assume figure is connected to start
+
+    this.seriesToProcess = new Set();
+    this.setTitle(this.getDefaultTitle());
+    this.initAllSeries();
+    this.updateAxisPositions();
+    this.startListeningFigure();
+  }
 
-        return function (range) {
-          return range;
-        };
-      };
-    }));
+  close() {
+    this.figure.close();
+    this.addPendingSeries.cancel();
+    this.stopListeningFigure();
+  }
 
-    _this.handleFigureUpdated = _this.handleFigureUpdated.bind(_assertThisInitialized(_this));
-    _this.handleFigureDisconnected = _this.handleFigureDisconnected.bind(_assertThisInitialized(_this));
-    _this.handleFigureReconnected = _this.handleFigureReconnected.bind(_assertThisInitialized(_this));
-    _this.handleFigureSeriesAdded = _this.handleFigureSeriesAdded.bind(_assertThisInitialized(_this));
-    _this.handleDownsampleStart = _this.handleDownsampleStart.bind(_assertThisInitialized(_this));
-    _this.handleDownsampleFinish = _this.handleDownsampleFinish.bind(_assertThisInitialized(_this));
-    _this.handleDownsampleFail = _this.handleDownsampleFail.bind(_assertThisInitialized(_this));
-    _this.handleDownsampleNeeded = _this.handleDownsampleNeeded.bind(_assertThisInitialized(_this));
-    _this.handleRequestFailed = _this.handleRequestFailed.bind(_assertThisInitialized(_this)); // We need to debounce adding series so we subscribe to them all in the same tick
-    // This should no longer be necessary after IDS-5049 lands
+  getDefaultTitle() {
+    if (this.figure.charts.length > 0) {
+      var chart = this.figure.charts[0];
+      return chart.title;
+    }
 
-    _this.addPendingSeries = debounce(_this.addPendingSeries.bind(_assertThisInitialized(_this)), FigureChartModel.ADD_SERIES_DEBOUNCE);
-    _this.figure = figure;
-    _this.settings = settings;
-    _this.data = [];
-    _this.layout = ChartUtils.makeDefaultLayout();
-    _this.seriesDataMap = new Map();
-    _this.pendingSeries = [];
-    _this.oneClicks = [];
-    _this.filterColumnMap = new Map();
-    _this.lastFilter = new Map();
-    _this.isConnected = true; // Assume figure is connected to start
+    return '';
+  }
 
-    _this.seriesToProcess = new Set();
+  initAllSeries() {
+    this.oneClicks = [];
+    this.filterColumnMap.clear();
+    var {
+      charts
+    } = this.figure;
+    var activeSeriesNames = [];
 
-    _this.setTitle(_this.getDefaultTitle());
+    for (var i = 0; i < charts.length; i += 1) {
+      var chart = charts[i];
+
+      for (var j = 0; j < chart.series.length; j += 1) {
+        var series = chart.series[j];
+        activeSeriesNames.push(series.name);
+        this.addSeries(series);
+      }
+    } // Remove any series that no longer exist
 
-    _this.initAllSeries();
 
-    _this.updateAxisPositions();
+    var allSeriesNames = [...this.seriesDataMap.keys()];
+    var inactiveSeriesNames = allSeriesNames.filter(seriesName => activeSeriesNames.indexOf(seriesName) < 0);
 
-    _this.startListeningFigure();
+    for (var _i = 0; _i < inactiveSeriesNames; _i += 1) {
+      var seriesName = inactiveSeriesNames[_i];
+      this.seriesDataMap.delete(seriesName);
+    }
 
-    return _this;
+    this.seriesToProcess = new Set([...this.seriesDataMap.keys()]);
   }
 
-  _createClass(FigureChartModel, [{
-    key: "close",
-    value: function close() {
-      this.figure.close();
-      this.addPendingSeries.cancel();
-      this.stopListeningFigure();
-    }
-  }, {
-    key: "getDefaultTitle",
-    value: function getDefaultTitle() {
-      if (this.figure.charts.length > 0) {
-        var chart = this.figure.charts[0];
-        return chart.title;
-      }
+  addSeries(series) {
+    var chart = ChartUtils.getChartForSeries(this.figure, series);
 
-      return '';
+    if (chart == null) {
+      log.error('Unable to find matching chart for series', series);
+      return;
     }
-  }, {
-    key: "initAllSeries",
-    value: function initAllSeries() {
-      this.oneClicks = [];
-      this.filterColumnMap.clear();
-      var charts = this.figure.charts;
-      var activeSeriesNames = [];
-
-      for (var i = 0; i < charts.length; i += 1) {
-        var chart = charts[i];
-
-        for (var j = 0; j < chart.series.length; j += 1) {
-          var series = chart.series[j];
-          activeSeriesNames.push(series.name);
-          this.addSeries(series);
-        }
-      } // Remove any series that no longer exist
 
+    var axisTypeMap = ChartUtils.groupArray(chart.axes, 'type');
+    var seriesData = ChartUtils.makeSeriesDataFromSeries(series, axisTypeMap, ChartUtils.getSeriesVisibility(series.name, this.settings));
+    this.seriesDataMap.set(series.name, seriesData);
+    this.data = [...this.seriesDataMap.values()];
 
-      var allSeriesNames = _toConsumableArray(this.seriesDataMap.keys());
+    if (series.plotStyle === dh.plot.SeriesPlotStyle.STACKED_BAR) {
+      this.layout.barmode = 'stack';
+    } else if (series.plotStyle === dh.plot.SeriesPlotStyle.PIE) {
+      this.layout.hiddenlabels = ChartUtils.getHiddenLabels(this.settings);
+    }
 
-      var inactiveSeriesNames = allSeriesNames.filter(function (seriesName) {
-        return activeSeriesNames.indexOf(seriesName) < 0;
-      });
+    this.layout.showlegend = this.data.length > 1 || series.plotStyle === dh.plot.SeriesPlotStyle.PIE;
 
-      for (var _i2 = 0; _i2 < inactiveSeriesNames; _i2 += 1) {
-        var seriesName = inactiveSeriesNames[_i2];
-        this.seriesDataMap["delete"](seriesName);
-      }
+    if (series.oneClick) {
+      var {
+        oneClick
+      } = series;
+      var {
+        columns
+      } = oneClick;
 
-      this.seriesToProcess = new Set(_toConsumableArray(this.seriesDataMap.keys()));
-    }
-  }, {
-    key: "addSeries",
-    value: function addSeries(series) {
-      var chart = ChartUtils.getChartForSeries(this.figure, series);
-
-      if (chart == null) {
-        log.error('Unable to find matching chart for series', series);
-        return;
+      for (var i = 0; i < columns.length; i += 1) {
+        this.filterColumnMap.set(columns[i].name, columns[i]);
       }
 
-      var axisTypeMap = ChartUtils.groupArray(chart.axes, 'type');
-      var seriesData = ChartUtils.makeSeriesDataFromSeries(series, axisTypeMap, ChartUtils.getSeriesVisibility(series.name, this.settings));
-      this.seriesDataMap.set(series.name, seriesData);
-      this.data = _toConsumableArray(this.seriesDataMap.values());
+      this.oneClicks.push(oneClick);
+    }
 
-      if (series.plotStyle === dh.plot.SeriesPlotStyle.STACKED_BAR) {
-        this.layout.barmode = 'stack';
-      } else if (series.plotStyle === dh.plot.SeriesPlotStyle.PIE) {
-        this.layout.hiddenlabels = ChartUtils.getHiddenLabels(this.settings);
-      }
+    this.updateLayoutFormats();
+  }
 
-      this.layout.showlegend = this.data.length > 1 || series.plotStyle === dh.plot.SeriesPlotStyle.PIE;
+  addPendingSeries() {
+    var {
+      pendingSeries
+    } = this;
 
-      if (series.oneClick) {
-        var oneClick = series.oneClick;
-        var columns = oneClick.columns;
+    for (var i = 0; i < pendingSeries.length; i += 1) {
+      var series = pendingSeries[i];
+      this.addSeries(series);
+      series.subscribe(); // We'll get an update with the data after subscribing
+    }
 
-        for (var i = 0; i < columns.length; i += 1) {
-          this.filterColumnMap.set(columns[i].name, columns[i]);
-        }
+    this.pendingSeries = [];
+  }
 
-        this.oneClicks.push(oneClick);
-      }
+  subscribe() {
+    super.subscribe(...arguments);
 
-      this.updateLayoutFormats();
+    if (this.listeners.length === 1) {
+      // Need to initialize the series here as we may have missed some series when not subscribed
+      this.initAllSeries();
+      this.subscribeFigure();
     }
-  }, {
-    key: "addPendingSeries",
-    value: function addPendingSeries() {
-      var pendingSeries = this.pendingSeries;
+  }
 
-      for (var i = 0; i < pendingSeries.length; i += 1) {
-        var series = pendingSeries[i];
-        this.addSeries(series);
-        series.subscribe(); // We'll get an update with the data after subscribing
-      }
+  unsubscribe() {
+    super.unsubscribe(...arguments);
 
-      this.pendingSeries = [];
+    if (this.listeners.length === 0) {
+      this.unsubscribeFigure();
     }
-  }, {
-    key: "subscribe",
-    value: function subscribe() {
-      var _get2;
+  }
 
-      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-        args[_key] = arguments[_key];
-      }
+  subscribeFigure() {
+    if (!this.isConnected) {
+      log.debug('Ignoring subscribe when figure in disconnected state');
+      return;
+    }
 
-      (_get2 = _get(_getPrototypeOf(FigureChartModel.prototype), "subscribe", this)).call.apply(_get2, [this].concat(args));
+    this.figure.subscribe(this.isDownsamplingDisabled ? dh.plot.DownsampleOptions.DISABLE : dh.plot.DownsampleOptions.DEFAULT);
+  }
 
-      if (this.listeners.length === 1) {
-        // Need to initialize the series here as we may have missed some series when not subscribed
-        this.initAllSeries();
-        this.subscribeFigure();
-      }
-    }
-  }, {
-    key: "unsubscribe",
-    value: function unsubscribe() {
-      var _get3;
+  unsubscribeFigure() {
+    this.figure.unsubscribe();
+  }
 
-      for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
-        args[_key2] = arguments[_key2];
-      }
+  startListeningFigure() {
+    this.figure.addEventListener(dh.plot.Figure.EVENT_UPDATED, this.handleFigureUpdated);
+    this.figure.addEventListener(dh.plot.Figure.EVENT_SERIES_ADDED, this.handleFigureSeriesAdded);
+    this.figure.addEventListener(dh.plot.Figure.EVENT_DISCONNECT, this.handleFigureDisconnected);
+    this.figure.addEventListener(dh.plot.Figure.EVENT_RECONNECT, this.handleFigureReconnected);
+    this.figure.addEventListener(dh.plot.Figure.EVENT_DOWNSAMPLESTARTED, this.handleDownsampleStart);
+    this.figure.addEventListener(dh.plot.Figure.EVENT_DOWNSAMPLEFINISHED, this.handleDownsampleFinish);
+    this.figure.addEventListener(dh.plot.Figure.EVENT_DOWNSAMPLEFAILED, this.handleDownsampleFail);
+    this.figure.addEventListener(dh.plot.Figure.EVENT_DOWNSAMPLENEEDED, this.handleDownsampleNeeded);
+    this.figure.addEventListener(dh.Client.EVENT_REQUEST_FAILED, this.handleRequestFailed);
+  }
 
-      (_get3 = _get(_getPrototypeOf(FigureChartModel.prototype), "unsubscribe", this)).call.apply(_get3, [this].concat(args));
+  stopListeningFigure() {
+    this.figure.removeEventListener(dh.plot.Figure.EVENT_UPDATED, this.handleFigureUpdated);
+    this.figure.removeEventListener(dh.plot.Figure.EVENT_SERIES_ADDED, this.handleFigureSeriesAdded);
+    this.figure.removeEventListener(dh.plot.Figure.EVENT_DISCONNECT, this.handleFigureDisconnected);
+    this.figure.removeEventListener(dh.plot.Figure.EVENT_RECONNECT, this.handleFigureReconnected);
+    this.figure.removeEventListener(dh.plot.Figure.EVENT_DOWNSAMPLESTARTED, this.handleDownsampleStart);
+    this.figure.removeEventListener(dh.plot.Figure.EVENT_DOWNSAMPLEFINISHED, this.handleDownsampleFinish);
+    this.figure.removeEventListener(dh.plot.Figure.EVENT_DOWNSAMPLEFAILED, this.handleDownsampleFail);
+    this.figure.removeEventListener(dh.plot.Figure.EVENT_DOWNSAMPLENEEDED, this.handleDownsampleNeeded);
+    this.figure.removeEventListener(dh.Client.EVENT_REQUEST_FAILED, this.handleRequestFailed);
+  }
 
-      if (this.listeners.length === 0) {
-        this.unsubscribeFigure();
-      }
-    }
-  }, {
-    key: "subscribeFigure",
-    value: function subscribeFigure() {
-      if (!this.isConnected) {
-        log.debug('Ignoring subscribe when figure in disconnected state');
-        return;
-      }
+  handleDownsampleStart(event) {
+    log.debug('Downsample started', event);
+    this.fireDownsampleStart(event.detail);
+  }
 
-      this.figure.subscribe(this.isDownsamplingDisabled ? dh.plot.DownsampleOptions.DISABLE : dh.plot.DownsampleOptions.DEFAULT);
-    }
-  }, {
-    key: "unsubscribeFigure",
-    value: function unsubscribeFigure() {
-      this.figure.unsubscribe();
-    }
-  }, {
-    key: "startListeningFigure",
-    value: function startListeningFigure() {
-      this.figure.addEventListener(dh.plot.Figure.EVENT_UPDATED, this.handleFigureUpdated);
-      this.figure.addEventListener(dh.plot.Figure.EVENT_SERIES_ADDED, this.handleFigureSeriesAdded);
-      this.figure.addEventListener(dh.plot.Figure.EVENT_DISCONNECT, this.handleFigureDisconnected);
-      this.figure.addEventListener(dh.plot.Figure.EVENT_RECONNECT, this.handleFigureReconnected);
-      this.figure.addEventListener(dh.plot.Figure.EVENT_DOWNSAMPLESTARTED, this.handleDownsampleStart);
-      this.figure.addEventListener(dh.plot.Figure.EVENT_DOWNSAMPLEFINISHED, this.handleDownsampleFinish);
-      this.figure.addEventListener(dh.plot.Figure.EVENT_DOWNSAMPLEFAILED, this.handleDownsampleFail);
-      this.figure.addEventListener(dh.plot.Figure.EVENT_DOWNSAMPLENEEDED, this.handleDownsampleNeeded);
-      this.figure.addEventListener(dh.Client.EVENT_REQUEST_FAILED, this.handleRequestFailed);
-    }
-  }, {
-    key: "stopListeningFigure",
-    value: function stopListeningFigure() {
-      this.figure.removeEventListener(dh.plot.Figure.EVENT_UPDATED, this.handleFigureUpdated);
-      this.figure.removeEventListener(dh.plot.Figure.EVENT_SERIES_ADDED, this.handleFigureSeriesAdded);
-      this.figure.removeEventListener(dh.plot.Figure.EVENT_DISCONNECT, this.handleFigureDisconnected);
-      this.figure.removeEventListener(dh.plot.Figure.EVENT_RECONNECT, this.handleFigureReconnected);
-      this.figure.removeEventListener(dh.plot.Figure.EVENT_DOWNSAMPLESTARTED, this.handleDownsampleStart);
-      this.figure.removeEventListener(dh.plot.Figure.EVENT_DOWNSAMPLEFINISHED, this.handleDownsampleFinish);
-      this.figure.removeEventListener(dh.plot.Figure.EVENT_DOWNSAMPLEFAILED, this.handleDownsampleFail);
-      this.figure.removeEventListener(dh.plot.Figure.EVENT_DOWNSAMPLENEEDED, this.handleDownsampleNeeded);
-      this.figure.removeEventListener(dh.Client.EVENT_REQUEST_FAILED, this.handleRequestFailed);
-    }
-  }, {
-    key: "handleDownsampleStart",
-    value: function handleDownsampleStart(event) {
-      log.debug('Downsample started', event);
-      this.fireDownsampleStart(event.detail);
-    }
-  }, {
-    key: "handleDownsampleFinish",
-    value: function handleDownsampleFinish(event) {
-      log.debug('Downsample finished', event);
-      this.fireDownsampleFinish(event.detail);
-    }
-  }, {
-    key: "handleDownsampleFail",
-    value: function handleDownsampleFail(event) {
-      log.error('Downsample failed', event);
-      this.fireDownsampleFail(event.detail);
-    }
-  }, {
-    key: "handleDownsampleNeeded",
-    value: function handleDownsampleNeeded(event) {
-      log.info('Downsample needed', event);
-      this.fireDownsampleNeeded(event.detail);
-    }
-  }, {
-    key: "handleFigureUpdated",
-    value: function handleFigureUpdated(event) {
-      var figureUpdateEvent = event.detail;
-      var seriesArray = figureUpdateEvent.series;
-      log.debug2('handleFigureUpdated', seriesArray);
-
-      for (var i = 0; i < seriesArray.length; i += 1) {
-        var series = seriesArray[i];
-        log.debug2('handleFigureUpdated updating series', series.name);
-        var sources = series.sources;
-
-        for (var j = 0; j < sources.length; j += 1) {
-          var source = sources[j];
-          var columnType = source.columnType,
-              type = source.type;
-          var valueTranslator = this.getValueTranslator(columnType, this.formatter);
-          var dataArray = figureUpdateEvent.getArray(series, type, valueTranslator);
-          this.setDataArrayForSeries(series, type, dataArray);
-        }
+  handleDownsampleFinish(event) {
+    log.debug('Downsample finished', event);
+    this.fireDownsampleFinish(event.detail);
+  }
 
-        this.seriesToProcess["delete"](series.name);
+  handleDownsampleFail(event) {
+    log.error('Downsample failed', event);
+    this.fireDownsampleFail(event.detail);
+  }
 
-        if (this.seriesToProcess.size === 0) {
-          this.fireLoadFinished();
-        }
+  handleDownsampleNeeded(event) {
+    log.info('Downsample needed', event);
+    this.fireDownsampleNeeded(event.detail);
+  }
 
-        this.cleanSeries(series);
+  handleFigureUpdated(event) {
+    var {
+      detail: figureUpdateEvent
+    } = event;
+    var {
+      series: seriesArray
+    } = figureUpdateEvent;
+    log.debug2('handleFigureUpdated', seriesArray);
+
+    for (var i = 0; i < seriesArray.length; i += 1) {
+      var series = seriesArray[i];
+      log.debug2('handleFigureUpdated updating series', series.name);
+      var {
+        sources
+      } = series;
+
+      for (var j = 0; j < sources.length; j += 1) {
+        var source = sources[j];
+        var {
+          columnType,
+          type
+        } = source;
+        var valueTranslator = this.getValueTranslator(columnType, this.formatter);
+        var dataArray = figureUpdateEvent.getArray(series, type, valueTranslator);
+        this.setDataArrayForSeries(series, type, dataArray);
       }
 
-      var data = this.data;
-      this.fireUpdate(data);
-    }
-  }, {
-    key: "handleRequestFailed",
-    value: function handleRequestFailed(event) {
-      log.error('Request failed', event);
-    }
-    /**
-     * Resubscribe to the figure, should be done if settings change
-     */
-
-  }, {
-    key: "resubscribe",
-    value: function resubscribe() {
-      if (this.listeners.length > 0) {
-        this.unsubscribeFigure();
-        this.subscribeFigure();
+      this.seriesToProcess.delete(series.name);
+
+      if (this.seriesToProcess.size === 0) {
+        this.fireLoadFinished();
       }
+
+      this.cleanSeries(series);
     }
-  }, {
-    key: "setFormatter",
-    value: function setFormatter(formatter) {
-      _get(_getPrototypeOf(FigureChartModel.prototype), "setFormatter", this).call(this, formatter);
 
-      this.updateLayoutFormats(); // Unsubscribe and resubscribe to trigger a data update
-      // Data may need to be translated again because of the new formatter
+    var {
+      data
+    } = this;
+    this.fireUpdate(data);
+  }
+
+  handleRequestFailed(event) {
+    log.error('Request failed', event);
+  }
+  /**
+   * Resubscribe to the figure, should be done if settings change
+   */
+
 
-      this.resubscribe();
+  resubscribe() {
+    if (this.listeners.length > 0) {
+      this.unsubscribeFigure();
+      this.subscribeFigure();
     }
-  }, {
-    key: "setDownsamplingDisabled",
-    value: function setDownsamplingDisabled() {
-      var _get4;
+  }
 
-      for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
-        args[_key3] = arguments[_key3];
-      }
+  setFormatter(formatter) {
+    super.setFormatter(formatter);
+    this.updateLayoutFormats(); // Unsubscribe and resubscribe to trigger a data update
+    // Data may need to be translated again because of the new formatter
 
-      (_get4 = _get(_getPrototypeOf(FigureChartModel.prototype), "setDownsamplingDisabled", this)).call.apply(_get4, [this].concat(args));
+    this.resubscribe();
+  }
 
-      this.resubscribe();
-    }
-  }, {
-    key: "handleFigureDisconnected",
-    value: function handleFigureDisconnected(event) {
-      log.debug('Figure disconnected', event);
-      this.isConnected = false;
-
-      if (this.listeners.length > 0) {
-        this.unsubscribeFigure();
-      }
+  setDownsamplingDisabled() {
+    super.setDownsamplingDisabled(...arguments);
+    this.resubscribe();
+  }
+
+  handleFigureDisconnected(event) {
+    log.debug('Figure disconnected', event);
+    this.isConnected = false;
 
-      this.fireDisconnect();
+    if (this.listeners.length > 0) {
+      this.unsubscribeFigure();
     }
-  }, {
-    key: "handleFigureReconnected",
-    value: function handleFigureReconnected(event) {
-      log.debug('Figure reconnected', event);
-      this.isConnected = true; // It's possible the series have changed completely, as the query could have been changed
 
-      this.initAllSeries();
-      this.fireReconnect();
+    this.fireDisconnect();
+  }
 
-      if (this.listeners.length > 0) {
-        this.subscribeFigure();
-      }
-    }
-  }, {
-    key: "handleFigureSeriesAdded",
-    value: function handleFigureSeriesAdded(event) {
-      var series = event.detail;
-      log.debug('handleFigureSeriesAdded', series);
-      this.pendingSeries.push(series);
-      this.addPendingSeries();
-    }
-  }, {
-    key: "setDimensions",
-    value: function setDimensions(rect) {
-      _get(_getPrototypeOf(FigureChartModel.prototype), "setDimensions", this).call(this, rect);
+  handleFigureReconnected(event) {
+    log.debug('Figure reconnected', event);
+    this.isConnected = true; // It's possible the series have changed completely, as the query could have been changed
+
+    this.initAllSeries();
+    this.fireReconnect();
 
-      this.updateAxisPositions();
+    if (this.listeners.length > 0) {
+      this.subscribeFigure();
     }
-  }, {
-    key: "setTitle",
-    value: function setTitle(title) {
-      var _match$length, _match;
+  }
 
-      _get(_getPrototypeOf(FigureChartModel.prototype), "setTitle", this).call(this, title); // Need to recalculate the padding based on how many lines of text the title is
-      // Plotly doesn't handle positioning it correctly, and it's an undocumented feature
+  handleFigureSeriesAdded(event) {
+    var {
+      detail: series
+    } = event;
+    log.debug('handleFigureSeriesAdded', series);
+    this.pendingSeries.push(series);
+    this.addPendingSeries();
+  }
 
+  setDimensions(rect) {
+    super.setDimensions(rect);
+    this.updateAxisPositions();
+  }
+
+  setTitle(title) {
+    var _match$length, _match;
+
+    super.setTitle(title); // Need to recalculate the padding based on how many lines of text the title is
+    // Plotly doesn't handle positioning it correctly, and it's an undocumented feature
 
-      var subtitleCount = (_match$length = (_match = (title !== null && title !== void 0 ? title : '').match(/<br>/g)) === null || _match === void 0 ? void 0 : _match.length) !== null && _match$length !== void 0 ? _match$length : 0;
-      this.layout.margin.t = ChartUtils.DEFAULT_MARGIN.t + subtitleCount * ChartUtils.SUBTITLE_LINE_HEIGHT;
-      this.layout.title.text = title;
-      this.layout.title.pad.t = ChartUtils.DEFAULT_TITLE_PADDING.t + subtitleCount * ChartUtils.SUBTITLE_LINE_HEIGHT * 0.5;
+    var subtitleCount = (_match$length = (_match = (title !== null && title !== void 0 ? title : '').match(/<br>/g)) === null || _match === void 0 ? void 0 : _match.length) !== null && _match$length !== void 0 ? _match$length : 0;
+    this.layout.margin.t = ChartUtils.DEFAULT_MARGIN.t + subtitleCount * ChartUtils.SUBTITLE_LINE_HEIGHT;
+    this.layout.title.text = title;
+    this.layout.title.pad.t = ChartUtils.DEFAULT_TITLE_PADDING.t + subtitleCount * ChartUtils.SUBTITLE_LINE_HEIGHT * 0.5;
+  }
+
+  getPlotWidth() {
+    if (!this.rect || !this.rect.width) {
+      return 0;
     }
-  }, {
-    key: "getPlotWidth",
-    value: function getPlotWidth() {
-      if (!this.rect || !this.rect.width) {
-        return 0;
-      }
 
-      return Math.max(this.rect.width - this.layout.margin.l - this.layout.margin.r, 0);
+    return Math.max(this.rect.width - this.layout.margin.l - this.layout.margin.r, 0);
+  }
+
+  getPlotHeight() {
+    if (!this.rect || !this.rect.height) {
+      return 0;
     }
-  }, {
-    key: "getPlotHeight",
-    value: function getPlotHeight() {
-      if (!this.rect || !this.rect.height) {
-        return 0;
-      }
 
-      return Math.max(this.rect.height - this.layout.margin.t - this.layout.margin.b, 0);
+    return Math.max(this.rect.height - this.layout.margin.t - this.layout.margin.b, 0);
+  }
+
+  updateAxisPositions() {
+    var plotWidth = this.getPlotWidth();
+    var plotHeight = this.getPlotHeight();
+
+    for (var i = 0; i < this.figure.charts.length; i += 1) {
+      var chart = this.figure.charts[i];
+      var axisRangeParser = this.getAxisRangeParser(chart, this.formatter);
+      ChartUtils.updateLayoutAxes(this.layout, chart.axes, plotWidth, plotHeight, axisRangeParser);
     }
-  }, {
-    key: "updateAxisPositions",
-    value: function updateAxisPositions() {
-      var plotWidth = this.getPlotWidth();
-      var plotHeight = this.getPlotHeight();
-
-      for (var i = 0; i < this.figure.charts.length; i += 1) {
-        var chart = this.figure.charts[i];
-        var axisRangeParser = this.getAxisRangeParser(chart, this.formatter);
-        ChartUtils.updateLayoutAxes(this.layout, chart.axes, plotWidth, plotHeight, axisRangeParser);
-      }
+  }
+  /**
+   * Updates the format patterns used
+   */
+
+
+  updateLayoutFormats() {
+    if (!this.formatter) {
+      return;
     }
-    /**
-     * Updates the format patterns used
-     */
 
-  }, {
-    key: "updateLayoutFormats",
-    value: function updateLayoutFormats() {
-      var _this2 = this;
+    var axisFormats = ChartUtils.getAxisFormats(this.figure, this.formatter);
+    axisFormats.forEach((axisFormat, axisLayoutProperty) => {
+      log.debug("Assigning ".concat(axisLayoutProperty), this.layout[axisLayoutProperty], axisFormat);
 
-      if (!this.formatter) {
-        return;
+      if (this.layout[axisLayoutProperty] != null) {
+        Object.assign(this.layout[axisLayoutProperty], axisFormat);
+      } else {
+        log.debug("Ignoring null layout.".concat(axisLayoutProperty));
       }
+    });
+  }
+  /**
+   * Set a specific array for the array of series properties specified.
+   * @param {dh.Series} series The series to set the data array for.
+   * @param {dh.plot.SourceType} sourceType The source type within that series to set the data for.
+   * @param {Any[]} dataArray The array to use for the data for this series source.
+   */
 
-      var axisFormats = ChartUtils.getAxisFormats(this.figure, this.formatter);
-      axisFormats.forEach(function (axisFormat, axisLayoutProperty) {
-        log.debug("Assigning ".concat(axisLayoutProperty), _this2.layout[axisLayoutProperty], axisFormat);
 
-        if (_this2.layout[axisLayoutProperty] != null) {
-          Object.assign(_this2.layout[axisLayoutProperty], axisFormat);
-        } else {
-          log.debug("Ignoring null layout.".concat(axisLayoutProperty));
-        }
-      });
-    }
-    /**
-     * Set a specific array for the array of series properties specified.
-     * @param {dh.Series} series The series to set the data array for.
-     * @param {dh.plot.SourceType} sourceType The source type within that series to set the data for.
-     * @param {Any[]} dataArray The array to use for the data for this series source.
-     */
-
-  }, {
-    key: "setDataArrayForSeries",
-    value: function setDataArrayForSeries(series, sourceType, dataArray) {
-      var name = series.name,
-          plotStyle = series.plotStyle;
-      var property = ChartUtils.getPlotlyProperty(plotStyle, sourceType);
-      var seriesData = this.seriesDataMap.get(name);
-      seriesData[property] = dataArray;
-    }
-    /**
-     * After setting all the data in the series data, we may need to adjust some other properties
-     * Eg. Calculating the width from the xLow/xHigh values; Plot.ly uses `width` instead of a low/high
-     * value for x.
-     * @param {dh.Series} series The series to clean the data for
-     */
-
-  }, {
-    key: "cleanSeries",
-    value: function cleanSeries(series) {
-      var name = series.name,
-          plotStyle = series.plotStyle;
-      var seriesData = this.seriesDataMap.get(name);
-
-      if (plotStyle === dh.plot.SeriesPlotStyle.HISTOGRAM) {
-        var xLow = seriesData.xLow,
-            xHigh = seriesData.xHigh;
-
-        if (xLow && xHigh && xLow.length === xHigh.length) {
-          var width = [];
-
-          for (var i = 0; i < xLow.length; i += 1) {
-            width.push(xHigh[i] - xLow[i]);
-          }
-
-          seriesData.width = width;
-        }
-      } else if (plotStyle === dh.plot.SeriesPlotStyle.LINE) {
-        var x = seriesData.x,
-            _xLow = seriesData.xLow,
-            _xHigh = seriesData.xHigh,
-            y = seriesData.y,
-            yLow = seriesData.yLow,
-            yHigh = seriesData.yHigh;
-
-        if (_xLow && _xHigh && _xLow !== x) {
-          seriesData.error_x = ChartUtils.getPlotlyErrorBars(x, _xLow, _xHigh);
-        }
+  setDataArrayForSeries(series, sourceType, dataArray) {
+    var {
+      name,
+      plotStyle
+    } = series;
+    var property = ChartUtils.getPlotlyProperty(plotStyle, sourceType);
+    var seriesData = this.seriesDataMap.get(name);
+    seriesData[property] = dataArray;
+  }
+  /**
+   * After setting all the data in the series data, we may need to adjust some other properties
+   * Eg. Calculating the width from the xLow/xHigh values; Plot.ly uses `width` instead of a low/high
+   * value for x.
+   * @param {dh.Series} series The series to clean the data for
+   */
+
+
+  cleanSeries(series) {
+    var {
+      name,
+      plotStyle
+    } = series;
+    var seriesData = this.seriesDataMap.get(name);
+
+    if (plotStyle === dh.plot.SeriesPlotStyle.HISTOGRAM) {
+      var {
+        xLow,
+        xHigh
+      } = seriesData;
+
+      if (xLow && xHigh && xLow.length === xHigh.length) {
+        var width = [];
 
-        if (yLow && yHigh && yLow !== y) {
-          seriesData.error_y = ChartUtils.getPlotlyErrorBars(y, yLow, yHigh);
+        for (var i = 0; i < xLow.length; i += 1) {
+          width.push(xHigh[i] - xLow[i]);
         }
+
+        seriesData.width = width;
       }
-    }
-  }, {
-    key: "getData",
-    value: function getData() {
-      return this.data;
-    }
-  }, {
-    key: "getLayout",
-    value: function getLayout() {
-      return this.layout;
-    }
-  }, {
-    key: "getFilterColumnMap",
-    value: function getFilterColumnMap() {
-      return new Map(this.filterColumnMap);
-    }
-  }, {
-    key: "isFilterRequired",
-    value: function isFilterRequired() {
-      return this.oneClicks.find(function (oneClick) {
-        return oneClick.requireAllFiltersToDisplay;
-      }) != null;
-    }
-    /**
-     * Sets the filter on the model. Will only set the values that have changed.
-     * @param {Map<String, String>} filterMap Map of filter column names to values
-     */
-
-  }, {
-    key: "setFilter",
-    value: function setFilter(filterMap) {
-      var _this3 = this;
-
-      if (this.oneClicks.length === 0) {
-        log.warn('Trying to set a filter, but no one click!');
-        return;
+    } else if (plotStyle === dh.plot.SeriesPlotStyle.LINE) {
+      var {
+        x,
+        xLow: _xLow,
+        xHigh: _xHigh,
+        y,
+        yLow,
+        yHigh
+      } = seriesData;
+
+      if (_xLow && _xHigh && _xLow !== x) {
+        seriesData.error_x = ChartUtils.getPlotlyErrorBars(x, _xLow, _xHigh);
       }
 
-      log.debug('setFilter', filterMap);
+      if (yLow && yHigh && yLow !== y) {
+        seriesData.error_y = ChartUtils.getPlotlyErrorBars(y, yLow, yHigh);
+      }
+    }
+  }
 
-      var _loop = function _loop(i) {
-        var oneClick = _this3.oneClicks[i];
-        var columns = oneClick.columns; // Need to get all the keys in case a filter was removed
+  getData() {
+    return this.data;
+  }
 
-        var keys = new Set([].concat(_toConsumableArray(filterMap.keys()), _toConsumableArray(_this3.lastFilter.keys())));
-        keys.forEach(function (key) {
-          var value = filterMap.get(key);
+  getLayout() {
+    return this.layout;
+  }
 
-          if (_this3.lastFilter.get(key) !== value && columns.find(function (column) {
-            return column.name === key;
-          }) != null) {
-            oneClick.setValueForColumn(key, value);
-          }
-        });
-      };
+  getFilterColumnMap() {
+    return new Map(this.filterColumnMap);
+  }
+
+  isFilterRequired() {
+    return this.oneClicks.find(oneClick => oneClick.requireAllFiltersToDisplay) != null;
+  }
+  /**
+   * Sets the filter on the model. Will only set the values that have changed.
+   * @param {Map<String, String>} filterMap Map of filter column names to values
+   */
 
-      for (var i = 0; i < this.oneClicks.length; i += 1) {
-        _loop(i);
-      }
 
-      this.lastFilter = new Map(filterMap);
+  setFilter(filterMap) {
+    var _this = this;
+
+    if (this.oneClicks.length === 0) {
+      log.warn('Trying to set a filter, but no one click!');
+      return;
     }
-  }, {
-    key: "setFigure",
-    value: function setFigure(figure) {
-      this.close();
-      this.figure = figure;
-      this.setTitle(this.getDefaultTitle());
-      this.initAllSeries();
-      this.updateAxisPositions();
-      this.startListeningFigure();
 
-      if (this.listeners.length > 0) {
-        this.subscribeFigure();
-      }
+    log.debug('setFilter', filterMap);
+
+    var _loop = function _loop(i) {
+      var oneClick = _this.oneClicks[i];
+      var {
+        columns
+      } = oneClick; // Need to get all the keys in case a filter was removed
+
+      var keys = new Set([...filterMap.keys(), ..._this.lastFilter.keys()]);
+      keys.forEach(key => {
+        var value = filterMap.get(key);
+
+        if (_this.lastFilter.get(key) !== value && columns.find(column => column.name === key) != null) {
+          oneClick.setValueForColumn(key, value);
+        }
+      });
+    };
+
+    for (var i = 0; i < this.oneClicks.length; i += 1) {
+      _loop(i);
     }
-  }, {
-    key: "updateSettings",
-    value: function updateSettings(settings) {
-      this.settings = settings;
+
+    this.lastFilter = new Map(filterMap);
+  }
+
+  setFigure(figure) {
+    this.close();
+    this.figure = figure;
+    this.setTitle(this.getDefaultTitle());
+    this.initAllSeries();
+    this.updateAxisPositions();
+    this.startListeningFigure();
+
+    if (this.listeners.length > 0) {
+      this.subscribeFigure();
     }
-  }]);
+  }
+
+  updateSettings(settings) {
+    this.settings = settings;
+  }
 
-  return FigureChartModel;
-}(ChartModel);
+}
 
 _defineProperty(FigureChartModel, "ADD_SERIES_DEBOUNCE", 50);